自学教程：C++ CheckInput函数代码示例

extern "C" DLL_EXPORT DLL_EXPORT void _cdecl DoCCallBack_LPSTR_OutByRef(CCallBackOutByRef callback){	int len = 10;	LPSTR pStr = (LPSTR)CoTaskMemAlloc(len);	if(!CheckInput(callback(&pStr)))	{		ReportFailure("DoCCallBack_LPSTR_OutByRef:NativeSide,the first Check");	}	if(!CheckInput(pStr))	{		ReportFailure("DoCCallBack_LPSTR_OutByRef:NativeSide,the Second Check");	}	CoTaskMemFree(pStr);}

extern "C" DLL_EXPORT void __cdecl DoSCallBack_LPSTR_OutByRef(SCallBackOutByRef callback){    size_t len = 10;    LPSTR pStr = (LPSTR)CoreClrAlloc(len);    if (!CheckInput(callback(&pStr)))    {        ReportFailure("DoSCallBack_LPSTR_OutByRef:NativeSide,the first check");    }    if (!CheckInput(pStr))    {        ReportFailure("DoSCallBack_LPSTR_OutByRef:NativeSide,the second Check");    }    CoreClrFree(pStr);}

intmain(void){    int h;    // initialize a flag    bool flag = false;    // keep asking for input until it's vaild    do    {        // ask for the height        printf("height: ");        // record users' input        h = GetInt();        // check the input        flag = CheckInput(h);    }    while (flag == false);    // draw the chart    DrawChart(h);    return 0;}

int IdConverter::Convert(std::string & id_in, std::string & id_out){    // sanity check    if(int rc = CheckInput(id_in))    {        return rc;    }    // convert    id_out = "";    for(size_t ipos = 0; ipos < id_in.size(); )    {        if(id_in[ipos + 2] != delimr)        {            // one-token group            if(id_in.compare(ipos, 2, "Z9") == 0)            {                id_out += "A1-A1";            }            else            {                // increment token                char token[8];                IncrementToken(id_in, ipos, token);                id_out += token;            }            ipos += 2;        }        else        {            // two-token group            if(id_in.compare(ipos, 5, "Z9-Z9") == 0)            {                // can not be incremented more                return 3;            }            if(id_in.compare(ipos + 3, 2, "Z9") == 0)            {                // first token should be incremented                char token[8];                IncrementToken(id_in, ipos, token);                id_out += token;                // second token will be "A1"                id_out += "-A1";            }            else            {                // increment second token only                char token[8];                IncrementToken(id_in, ipos + 3, token);                id_out += id_in.substr(ipos, 3);                id_out += token;            }            ipos += 5;        }    }    return 0;}

void CMainMenu::Update(const SUIInput& a_rInput){    if (m_GoingIntoGame)    {        float half = CPostEffects::GameStartTime / 2.0f;        m_CurrentTime += twTime->GetDeltaTime();        float value = m_CurrentTime / half;        ((triebWerk::CUIDrawable*)(m_pBackground->GetDrawable()))->m_Material.m_ConstantBuffer.SetValueInBuffer(4, &value);        if (m_CurrentTime >= half)        {            twSceneManager->SetActiveScene("Game");            m_GoingIntoGame = false;            m_CurrentTime = 0.0f;        }        return;    }    else if (m_LerpToExtras) LerpToExtras();    else if (m_LerpFromExtras) LerpFromExtras();    if (CGameInfo::Instance().m_Menu == EMenus::Main)    {        ((triebWerk::CFontDrawable*)m_pTextExtras->GetDrawable())->m_pText->SetText("Extras");        CheckInput(a_rInput);    }    UpdateGraphics();}

void Example::prepare(float dt){	CheckInput();	DeltaTime = dt;	ModelSky->m_RotateY+=(SPEED*DeltaTime);	const float ROTSPEED = 50.0f;	if(rotate)		m_rotationAngle += ROTSPEED * dt;	if (m_rotationAngle > 360.0f)		m_rotationAngle -= 360.0f;	m_angle += 2.0f * dt;	if (m_angle > 360.0f) 		m_angle -= 360.0f;	const float LIGHT_SPEED = 0.0005f;		m_lightPosZ += LIGHT_SPEED;		m_GLSLProgram->sendUniform("time", timer);}

void auto_smzdm::onStart(){  if (!CheckInput())  {    return;  }  UpdateData();  control_status = true;  ui.lineEdit_msg->setText(QStringLiteral("运行中"));  QString msg = QStringLiteral("运行中");  int count = 0;  while( control_status )  {    QString temp = msg;    smzdm_run();    count ++;     QString temp2;    temp2.setNum(count);    ui.lineEdit_msg->setText(temp + temp2);    QElapsedTimer t;    t.start();    while(t.elapsed()<1000)        QCoreApplication::processEvents();  }}

// Open the ShopNamedScript KeyBind void OpenShop(bool OpenLocker){    // If you're dead, return    if (GetActorProperty(0, APROP_Health) <= 0) return;    // If you're in an Outpost menu, return    if (Player.OutpostMenu > 0) return;    // If you're in any minigames, return    if (Player.InMinigame) return;    // If you're looking inside a crate, return    if (Player.CrateOpen) return;    // Close the main menu if it's open    Player.InMenu = false;    // Sanity check for pressing use while the shop is open in front of the counter in the Outpost    if (Player.InShop && CheckInput(BT_USE, KEY_HELD, false, PlayerNumber())) return;    if (Player.InShop)    {        ActivatorSound("menu/leave", 127);        SetPlayerProperty(0, 0, PROP_TOTALLYFROZEN);        Player.InShop = false;    }    else    {        ActivatorSound("menu/shop", 127);        Player.InShop = true;        if (OpenLocker)            Player.LockerMode = true;    }}

void mexFunction(int nlhs, mxArray *plhs[], int nrhs,const mxArray *prhs[]){  double tau, rownorm;  double *W, *W_thresh, *nz;  long p, K, ik, ip, pK;          CheckInput(nlhs, plhs, nrhs, prhs);    p=mxGetM(prhs[0]); /* # row */  K=mxGetN(prhs[0]); /* # col */  W=mxGetPr(prhs[0]); /* pointer to the input array */  tau=mxGetScalar(prhs[1]);    plhs[0]=mxCreateDoubleMatrix(p,K,mxREAL); /* output p x K array */  W_thresh=mxGetPr(plhs[0]); /* pointer to the data W_thresh*/  pK=p*K;     for (ip=0; ip<p; ip++) {      /* compute the 2-norm of the ip-th row */      for (ik=0, rownorm=0.0; ik<K; ik++)         rownorm+=W[ip+p*ik]*W[ip+p*ik]; /* W(ip+1,ik+1)=W[ip + p*ik], ip=0,...,p, ik=0,...,K */      rownorm=sqrt(rownorm);            /* perform row-wise group-thresholding */     if (rownorm > tau){         for (ik=0; ik<K; ik++)            W_thresh[ip+p*ik]=W[ip+p*ik]*(1-tau/rownorm); /* W(ip+1,ik+1)=W[ip + p*ik], ip=0,...,p, ik=0,...,K */     }     else {         for (ik=0; ik<K; ik++)            W_thresh[ip+p*ik]=0; /* W(ip+1,ik+1)=W[ip + p*ik], ip=0,...,p, ik=0,...,K */     }  }}

// This is called every 4096 nodes to check if we have run out of time// or if we have been interrupted by the GUIstatic void CheckUp(searchinfo_t *sinfo){	if(sinfo->infinite == false && GetTime() >= sinfo->stopTime){		sinfo->stop = true;	}	CheckInput(sinfo);}

void BiasAdderNet::Execute() {  CheckInput();  const Blob* const input = this->input_blobs(0);  const Blob* const bias = this->params(0);  Blob* const output = this->output_blobs(0);  int channels = bias->channels();  CHECK_EQ(channels, input->channels());  int height = input->height();  int width = input->width();  int num = input->num();    LOG(DEBUG) << "input blob: (" << num << "," << input->channels() << ","     << height << "," << width << ")";  LOG(DEBUG) << "bias blob: (" << bias->num() << "," << bias->channels()     << "," << bias->height() << "," << bias->width() << ")";    float* const dst_head = new float[num*channels*height*width];  int size = height * width;  for (int n = 0, offset = 0; n < num; ++n) {    for (int ichannel = 0; ichannel < channels; ++ichannel) {      for(int i = 0; i < size; ++i, ++offset) {        dst_head[offset] = (*input)[offset] + (*bias)[ichannel];      }    }  }  output->CopyData(num, channels, height, width, dst_head);  delete []dst_head;  CheckOutput();}

extern "C" DLL_EXPORT void __cdecl DoCCallBack_LPSTR_Out(CCallBackOut callback){    size_t len = 10;    LPSTR pStr = (LPSTR)CoreClrAlloc(len);    //Check the return value    if (!CheckInput(callback(pStr)))    {        ReportFailure("DoCCallBack_LPSTR_Out:NativeSide,the first check");    }    if (!CheckInput(pStr))    {        ReportFailure("DoCCallBack_LPSTR_Out:NativeSide,the Second Check");    }    CoreClrFree(pStr);}

/**** Main function of this program.**/int main(){    float input;    float input_cents;    do    {        // Get the user input        printf("O hai! How much change is owed?/n");        input = GetFloat();                // Validate the user input        if(CheckInput(input) == FALSE)        {            continue;        }            }while(input < 0.0);    // Convert to cents    input_cents = (float)round(input * 100);        // Lets Start        int number_of_coins = 0;        while(input_cents > 0.0)    {        //printf("input_cents=%f/n",input_cents);        if(input_cents >= QUATAR)        {            // This means the input is can be subtracted by a QUATAR            input_cents = input_cents - QUATAR;            number_of_coins++;          }        else if(input_cents < QUATAR && input_cents >= DIME)        {            // This means the input is can be subtracted by a DIME            input_cents = input_cents - DIME;            number_of_coins++;         }        else if(input_cents < DIME && input_cents >= NICKEL)        {            // This means the input is can be subtracted by a NICKEL            input_cents = input_cents - NICKEL;            number_of_coins++;         }        else        {            // This means remaining are PENNIES. So just add as many number of pennies.            number_of_coins = number_of_coins + input_cents;            input_cents = 0;        }    }    printf("%d/n", number_of_coins);        // Good Bye    return 0;}

void InputDialog::on_btnOK_clicked(){    if(CheckInput())    {        strResult = ui->lnInput->text();        done(QDialog::Accepted);    }}

extern "C" DLL_EXPORT DLL_EXPORT void _cdecl DoSCallBack_LPSTR_InOut(SCallBackInOut callback){	const char* pTemp = "AAAA";	int len = strlen(pTemp)+1;	LPSTR pStr = (LPSTR)CoTaskMemAlloc(len);	strncpy(pStr,pTemp,len);	if(!CheckInput(callback(pStr)))	{		ReportFailure("DoSCallBack_LPSTR_InOut:NativeSide,the first check");	}	if(!CheckInput(pStr))	{		ReportFailure("DoSCallBack_LPSTR_InOut:NativeSide,the second Check");	}	CoTaskMemFree(pStr);}

extern "C" DLL_EXPORT void __cdecl DoSCallBack_LPSTR_InOutByRef(SCallBackInOutByRef callback){    const char* pTemp = "AAAA";    size_t len = strlen(pTemp) + 1;    LPSTR pStr = (LPSTR)CoreClrAlloc(len);    strncpy(pStr, pTemp, len);    if (!CheckInput(callback(&pStr)))    {        ReportFailure("DoSCallBack_LPSTR_InOutByRef:NativeSide,the first check");    }    if (!CheckInput(pStr))    {        ReportFailure("DoSCallBack_LPSTR_InOutByRef:NativeSide,the second Check");    }    CoreClrFree(pStr);}

void MaxPoolingNet::Execute() {  // *** Argument *** //  const float MIN_THRESHOLD = 0.0f;  // *** //    CheckInput();  const Blob* const input = this->input_blobs(0);  Blob* const output = this->output_blobs(0);    int src_h = input->height();  int src_w = input->width();  int num = input->num();  int channels = input->channels();  int dst_h = static_cast<int>(ceil(static_cast<float>(    src_h - kernel_h_) / stride_h_)) + 1;  int dst_w = static_cast<int>(ceil(static_cast<float>(    src_w - kernel_w_) / stride_w_)) + 1;  int dst_count = num * channels * dst_h * dst_w;  float* const dst_head = new float[dst_count];  const float* src_data = input->data().get();  float* dst_data = dst_head;  int src_channel_off = src_h * src_w;  int dst_channel_off = dst_h * dst_w;  for (int n = 0; n < num; ++n) {    for (int c = 0; c < channels; ++c) {      for (int dh = 0, hstart = 0; dh < dst_h;            ++dh, hstart += stride_h_) {        int hend = std::min(hstart + kernel_h_, src_h);        for (int dw = 0, wstart = 0; dw < dst_w;            ++dw, wstart += stride_w_) {          int wend = std::min(wstart + kernel_w_, src_w);          int didx = dh * dst_w + dw;          float max_val = MIN_THRESHOLD;          for (int sh = hstart; sh < hend; ++sh) {            for (int sw = wstart; sw < wend; ++sw) {              int sidx = sh * src_w + sw;              if (src_data[sidx] > max_val) {                max_val = src_data[sidx];              }            } // for sw          } // for sh          dst_data[didx] = max_val;        } // for dw      } // for dh      src_data += src_channel_off;      dst_data += dst_channel_off;    } // for c  } // for n  output->CopyData(num, channels, dst_h, dst_w, dst_head);  delete[] dst_head;  CheckOutput();}

inline voidLocalTrrkKernel( UpperOrLower uplo,  Orientation orientationOfA,  Orientation orientationOfB,  T alpha, const DistMatrix<T,STAR,MC  >& A,           const DistMatrix<T,MR,  STAR>& B,  T beta,        DistMatrix<T,MC,  MR  >& C ){#ifndef RELEASE    PushCallStack("LocalTrrkKernel");    CheckInput( orientationOfA, orientationOfB, A, B, C );#endif    const Grid& g = C.Grid();    DistMatrix<T,STAR,MC> AL(g), AR(g);    DistMatrix<T,MR,STAR> BT(g),                           BB(g);    DistMatrix<T,MC,MR> CTL(g), CTR(g),                        CBL(g), CBR(g);    DistMatrix<T,MC,MR> DTL(g), DBR(g);    const int half = C.Height()/2;    ScaleTrapezoid( beta, LEFT, uplo, 0, C );    LockedPartitionRight( A, AL, AR, half );    LockedPartitionDown    ( B, BT,          BB, half );    PartitionDownDiagonal    ( C, CTL, CTR,         CBL, CBR, half );    DTL.AlignWith( CTL );    DBR.AlignWith( CBR );    DTL.ResizeTo( CTL.Height(), CTL.Width() );    DBR.ResizeTo( CBR.Height(), CBR.Width() );    //------------------------------------------------------------------------//    if( uplo == LOWER )        internal::LocalGemm        ( orientationOfA, orientationOfB, alpha, AR, BT, T(1), CBL );    else        internal::LocalGemm        ( orientationOfA, orientationOfB, alpha, AL, BB, T(1), CTR );    internal::LocalGemm    ( orientationOfA, orientationOfB, alpha, AL, BT, T(0), DTL );    AxpyTriangle( uplo, T(1), DTL, CTL );    internal::LocalGemm    ( orientationOfA, orientationOfB, alpha, AR, BB, T(0), DBR );    AxpyTriangle( uplo, T(1), DBR, CBR );    //------------------------------------------------------------------------//#ifndef RELEASE    PopCallStack();#endif}

void CHSNumEdit::OnChar (UINT nChar, UINT nRepCnt, UINT nFlags){	if( !isdigit(nChar) && nChar != 8 && nChar != '.' && nChar != '-' && nChar != '+' )		return;	CString strWin;	GetWindowText(strWin);	CEdit::OnChar(nChar,nRepCnt,nFlags);	CString strCurText;	GetWindowText(strCurText);	if( !CheckInput(strCurText) )	{		SetWindowText(strWin);	}		/*	if( isdigit(nChar) && CheckInput(nChar) )		CEdit::OnChar(nChar,nRepCnt,nFlags);	else	{		CString txt;		GetWindowText(txt);		switch (nChar) 		{		case '+' : // set to absolute value			{				double x = (double) atof(txt);				if (x > 0)					break; // only break if we already >0, else do "case -"			}		case '-' : // change sign.			{				double x = (double) atof(txt);//				if(x == 0)//				{//					::MessageBeep(MB_ICONQUESTION);//					break;//				}				x = -x;				SetValue(x);				break;			}		case '.' :	 				if ( txt.Find('.') == -1 && CheckInput(nChar))					CEdit::OnChar(nChar, nRepCnt, nFlags);				break; 		case VK_BACK:			CEdit::OnChar(nChar, nRepCnt, nFlags);			break;		}	}	*/}

void DialogInputFileNameForm::ApplyButtonPressed(){    //Check the input    bool inputOk = CheckInput();    //If the input is ok cloase the dialog with accedpted    if(inputOk)    {        QDialog::accept();    }}

CHARLS_IMEXPORT(JLS_ERROR) JpegLsEncodeStream(ByteStreamInfo compressedStreamInfo, size_t* pcbyteWritten, ByteStreamInfo rawStreamInfo, struct JlsParameters* pparams){	if (pcbyteWritten == NULL)		return InvalidJlsParameters;	JLS_ERROR parameterError = CheckInput(rawStreamInfo, pparams);	if (parameterError != OK)		return parameterError;	try	{		JlsParameters info = *pparams;		if (info.bytesperline == 0)		{			info.bytesperline = info.width * ((info.bitspersample + 7)/8);			if (info.ilv != ILV_NONE)			{				info.bytesperline *= info.components;			}		}		Size size = Size(info.width, info.height);		JpegMarkerWriter writer(info.jfif, size, info.bitspersample, info.components);		if (info.colorTransform != 0)		{			writer.AddColorTransform(info.colorTransform);		}		if (info.ilv == ILV_NONE)		{			LONG cbyteComp = size.cx*size.cy*((info.bitspersample +7)/8);			for (LONG component = 0; component < info.components; ++component)			{				writer.AddScan(rawStreamInfo, &info);				SkipBytes(&rawStreamInfo, cbyteComp);			}		}		else		{			writer.AddScan(rawStreamInfo, &info);		}			writer.Write(compressedStreamInfo);		*pcbyteWritten = writer.GetBytesWritten();		return OK;	}	catch (const JlsException& e)	{		return e._error;	}}

bool PlayerObject::Update() {		if (m_moving)		Move();	else		CheckInput();	m_animManager->Update(m_position);	UpdateViewPosition();		return false;}

extern "C" DLL_EXPORT DLL_EXPORT void _cdecl DoCCallBack_LPSTR_InByRef(CallBackInByRef callback){	const char* pTemp = "AAAA";	int len = strlen(pTemp)+1;	LPSTR pStr = (LPSTR)CoTaskMemAlloc(len);	strncpy(pStr,pTemp,len);	if(!CheckInput(callback(&pStr)))	{		ReportFailure("DoCCallBack_LPSTR_InByRef:NativeSide");	}	CoTaskMemFree(pStr);}

extern "C" DLL_EXPORT void __cdecl DoCCallBack_LPSTR_In(CCallBackIn callback){  const char* pTemp = "AAAA";  size_t len = strlen(pTemp)+1;  LPSTR pStr = (LPSTR)CoreClrAlloc(len);  strncpy(pStr,pTemp,len);  if(!CheckInput(callback(pStr)))  {  	ReportFailure("DoCCallBack_LPSTR_In:NativeSide");  }  CoreClrFree(pStr);}

extern "C" DLL_EXPORT LPSTR STDMETHODCALLTYPE SLPStr_InByRef(LPSTR* ppStr){    //Check the Input    if (!CheckInput(*ppStr))    {        ReportFailure("SLPStr_InByRef:NativeSide");    }    //alloc,copy, since we cannot depend the Marshaler's activity.    size_t len = strlen(*ppStr) + 1; //+1, Include the NULL Character.    LPSTR pBack = (LPSTR)CoreClrAlloc(len);    strncpy(pBack, *ppStr, len);    return pBack;}

// ----------------------------------------------------------------int main(int argc, char* argv[]){	Start();	while(CheckInput())	{		MoveStuff();		Draw();	}	Finish();	return(EXIT_SUCCESS);}

CHARLS_IMEXPORT JLS_ERROR JpegLsEncode(void* pdataCompressed, size_t cbyteBuffer, size_t* pcbyteWritten, const void* pdataUncompressed, size_t cbyteUncompressed, const JlsParamaters* pparams){	JlsParamaters info = *pparams;	if(info.bytesperline == 0)	{		info.bytesperline = info.width * ((info.bitspersample + 7)/8);		if (info.ilv != ILV_NONE)		{			info.bytesperline *= info.components;		}	}		JLS_ERROR parameterError = CheckInput(pdataCompressed, cbyteBuffer, pdataUncompressed, cbyteUncompressed, &info);	if (parameterError != OK)		return parameterError;	if (pcbyteWritten == NULL)		return InvalidJlsParameters;	Size size = Size(info.width, info.height);	LONG cbit = info.bitspersample;	JLSOutputStream stream;		stream.Init(size, info.bitspersample, info.components);		if (info.colorTransform != 0)	{		stream.AddColorTransform(info.colorTransform);	}	if (info.ilv == ILV_NONE)	{		LONG cbyteComp = size.cx*size.cy*((cbit +7)/8);		for (LONG icomp = 0; icomp < info.components; ++icomp)		{			const BYTE* pbyteComp = static_cast<const BYTE*>(pdataUncompressed) + icomp*cbyteComp;			stream.AddScan(pbyteComp, &info);		}	}	else 	{		stream.AddScan(pdataUncompressed, &info);	}		stream.Write((BYTE*)pdataCompressed, cbyteBuffer);		*pcbyteWritten = stream.GetBytesWritten();		return OK;}

extern "C" DLL_EXPORT LPSTR __stdcall SLPStr_InOutByRef(LPSTR* ppStr){	//Check the Input	if(!CheckInput(*ppStr))	{		ReportFailure("SLPStr_InOutByRef:NativeSide");	}	//alloc,copy, since we cannot depend the Marshaler's activity.	int len = strlen(*ppStr)+ 1 ; //+1, Include the NULL Character.	LPSTR pBack = (LPSTR)CoTaskMemAlloc(len);	strncpy(pBack,*ppStr,len);	return pBack;}

CHARLS_IMEXPORT(JLS_ERROR) JpegLsEncode(void* compressedData, size_t compressedLength, size_t* pcbyteWritten, const void* uncompressedData, size_t uncompressedLength, struct JlsParameters* pparams){	JlsParameters info = *pparams;	if(info.bytesperline == 0)	{		info.bytesperline = info.width * ((info.bitspersample + 7)/8);		if (info.ilv != ILV_NONE)		{			info.bytesperline *= info.components;		}	}		JLS_ERROR parameterError = CheckInput(compressedData, compressedLength, uncompressedData, uncompressedLength, &info);	if (parameterError != OK)		return parameterError;	if (pcbyteWritten == NULL)		return InvalidJlsParameters;	Size size = Size(info.width, info.height);	JLSOutputStream stream;		stream.Init(size, info.bitspersample, info.components);		if (info.colorTransform != 0)	{		stream.AddColorTransform(info.colorTransform);	}	if (info.ilv == ILV_NONE)	{		LONG cbyteComp = size.cx*size.cy*((info.bitspersample +7)/8);		for (LONG component = 0; component < info.components; ++component)		{			const BYTE* compareData = static_cast<const BYTE*>(uncompressedData) + component*cbyteComp;			stream.AddScan(compareData, &info);		}	}	else 	{		stream.AddScan(uncompressedData, &info);	}		stream.Write((BYTE*)compressedData, compressedLength);		*pcbyteWritten = stream.GetBytesWritten();		return OK;}

void QmitkAICPRegistrationView::OnStartRegistration(){  d->m_Threshold = m_Controls.m_ThresholdSpinbox->value();  d->m_MaxIterations = m_Controls.m_MaxIterationsSpinbox->value();  d->m_SearchRadius = m_Controls.m_SearchRadius->value();  d->m_TrimmFactor = 0.0;  if ( m_Controls.m_EnableTrimming->isChecked() )  {    d->m_TrimmFactor = m_Controls.m_TrimmFactorSpinbox->value();  }  if (! CheckInput() )    return;  d->m_MovingSurface = dynamic_cast<mitk::Surface*>(            m_Controls.m_MovingSurfaceComboBox->GetSelectedNode()->GetData() );  d->m_FixedSurface = dynamic_cast<mitk::Surface*>(            m_Controls.m_FixedSurfaceComboBox->GetSelectedNode()->GetData() );  // sanity check  if ( d->m_FixedSurface.IsNull() || d->m_MovingSurface.IsNull() )  {    const char* message = "Input surfaces are NULL.";    QMessageBox msg;    msg.setIcon(QMessageBox::Critical);    msg.setText(message);    MITK_ERROR << message;    return;  }  // enable trimming  if ( m_Controls.m_EnableTrimming->isChecked() )  {    d->m_TrimmFactor = m_Controls.m_TrimmFactorSpinbox->value();  }  // set data into the UI thread  d->m_Worker->SetRegistrationData(d);  // start thread  d->m_RegistrationThread->start();  // disable registration button  m_Controls.m_RegisterSurfaceButton->setEnabled(false);  mitk::RenderingManager::GetInstance()->RequestUpdateAll();}