C++ UpdateValue函数代码示例

void CRoiDlg::OnKillfocusROIHeight()
{
    m_Roi.height = GetInt(&m_HeightEdit);
    m_Roi.y = GetInt(&m_YEdit);
    UpdateValue(m_Roi.height, 1, GetMaxHeight());
    UpdateValue(m_Roi.y, 0, GetMaxY(), &m_SpinY);
    UpdateData(FALSE);
}

TAstNode::ValueReturned TAstNodeForSentence::Execute() const
{
	auto secondChild = m_firstChild->GetSibling();
	auto thirdChild = secondChild->GetSibling();

	auto firstValue = m_firstChild->Execute();
	auto sencondValue = secondChild->Execute();
	//auto thirdValue = thirdChild->Execute();

	auto scope = GetScope();
	auto name = m_firstChild->GetFirstChild()->GetToken()->Name();
	auto type = TVariateManager::GetInstance()->GetVariateSrollUp(scope, name)->GetType();

	UpdateValue(type, scope, name, firstValue.value);
	
	if (GetValue(type, scope, name)<sencondValue.value)
	{
		Context::interpreterContext.SetNextNode(thirdChild->GetSibling().get());
	}
	else
	{
		Context::interpreterContext.SetNextNode(FindNextValidNode());
	}

	return ValueReturned{ 0, SYMBOL_TYPE::TYPE_VOID };
}

void EventDlg::UpdateColumnEntry(int iItem, int hcol, LPTSTR val)
{
	UINT icol =ImpEditCol::m_fileheadermap[hcol];  // see this garbage? a result of poor design
	CString s;

	if (ImpEditCol::eMeasType == icol)   // for string to numeric internal maps, handle the update differently
	{
		MEvent* pm = (MEvent*)m_List.GetItemData(iItem);
		if (pm)
		{
			CString szDisplayableResult;
			pm->UpdateMeasurementInfo(ImpEditCol::m_meacolmap[icol], val, szDisplayableResult);
			m_List.SetItemText(iItem,ImpEditCol::eMeasType,tMeasurementTypeImage((tMeasurementType)pm->m_vr._iMPMeasurementType));
		}	
	}
	else
	{
		if (UpdateValue(iItem , icol, val, s)) // icol is ImpEd enum
		{
			m_List.SetItemText(iItem , icol, s);
		}
	}


}

void XaLibDom::UpdateElementValueByXPath(xmlDocPtr XmlDomDoc, VectorXPathExpr XPathExpr, VectorXPathValue XPathValue) {

	if (XmlDomDoc != NULL) {
    
		if(XPathExpr.size()==XPathValue.size()){

			for(unsigned n=0; n<XPathExpr.size(); ++n) {

				string xpath=XPathExpr.at(n);
				string value=XPathValue.at(n);

				UpdateValue(XmlDomDoc, (const xmlChar *)xpath.c_str(),(const xmlChar *)value.c_str());
			}

			xmlXPathFreeObject(xpathObj);
			xmlXPathFreeContext(xpathCtx);

		} else{

			cout<<"wrong number of value and expression";
		}
	
	} else {
	}
};

void CMyEdit::OnKillFocus(CWnd* pNewWnd)
{
	if (m_nType == EditUnits)
		UpdateValue();

	CEdit::OnKillFocus(pNewWnd);
}

void COpenCVStitch2013Dlg::DoStitch()
{
	Mat stitched;
	vector<Mat> images;

	for (size_t i = 0; i < camera.size(); i++)
	{
		Mat image;
		camera[i] >> image;

		imshow(camera[i].GetName(), image);
		images.push_back(image);
	}
	if (2 <= camera.size())
	{
		int64 t = getTickCount();
		if (MyStitcher::Status::OK == stitcher.composePanorama(images, stitched)) {
			UpdateValue((getTickCount() - t) / getTickFrequency() * 1000);
			imshow(STITCHED, stitched);
			//if (writer.isOpened())
			//{
			//	writer << stitched;
			//}
		}
		else {
			MessageBox(L"内部処理でのエラー");
		}
		images.clear();
	}
	else
	{
		MessageBox(L"カメラが少ないためキャリブレートできません");
	}
}

void SetMine(context_t *ctxt, int x, int y)
{
    ctxt->board[y*ctxt->columns + x].value = MINE;
    int i;
    for(i = 0; i < 8; ++i)
        UpdateValue(ctxt, x+moveX[i], y+moveY[i]);
}

void ModifyXmlNodeValue(const char *NodeElement,char *NewValue)
{

	char *Value = NULL;
	char *Path = NULL;

	Value = malloc(sizeof(char) * (strlen(UDEVNAME) + strlen(NewValue) + 4));
	Path = malloc(sizeof(char) * (strlen(WEB_PATH) + strlen(DOC_NAME) + 2));
	memset(Path,0,sizeof(Path));
	memset(Value,0,sizeof(Value));

	strcpy(Value,UDEVNAME);
	strcat(Value,"(");
	strcat(Value,NewValue);//ip_address
	strcat(Value,")");

	strcpy(Path,WEB_PATH);
	strcat(Path,"/");
	strcat(Path,DOC_NAME);

	//path,  friendlyName
	UpdateValue(Path,NodeElement,Value);

	free(Path);
	Path = NULL;
	free(Value);
	Value = NULL;

	return;
}

void CMeter2DGraphView::valueChanged()
{
   if( model() )
   {
      UpdateValue();
   }
}

/*
============
idInternalCVar::Set
============
*/
void idInternalCVar::Set( const char *newValue, bool force, bool fromServer )
{
    if ( session && session->IsMultiplayer() && !fromServer )
    {
#ifndef ID_TYPEINFO
        if ( ( flags & CVAR_NETWORKSYNC ) && idAsyncNetwork::client.IsActive() )
        {
            common->Printf( "%s is a synced over the network and cannot be changed on a multiplayer client.\n", nameString.c_str() );
#if ID_ALLOW_CHEATS
            common->Printf( "ID_ALLOW_CHEATS override!\n" );
#else
            return;
#endif
        }
#endif
        if ( ( flags & CVAR_CHEAT ) && !cvarSystem->GetCVarBool( "net_allowCheats" ) )
        {
            common->Printf( "%s cannot be changed in multiplayer.\n", nameString.c_str() );
#if ID_ALLOW_CHEATS
            common->Printf( "ID_ALLOW_CHEATS override!\n" );
#else
            return;
#endif
        }
    }

    if ( !newValue )
    {
        newValue = resetString.c_str();
    }

    if ( !force )
    {
        if ( flags & CVAR_ROM )
        {
            common->Printf( "%s is read only.\n", nameString.c_str() );
            return;
        }

        if ( flags & CVAR_INIT )
        {
            common->Printf( "%s is write protected.\n", nameString.c_str() );
            return;
        }
    }

    if ( valueString.Icmp( newValue ) == 0 )
    {
        return;
    }

    valueString = newValue;
    value = valueString.c_str();
    UpdateValue();

    SetModified();
    cvarSystem->SetModifiedFlags( flags );
}

void SpinButton::KeyDown(const char *bytes, int32 numBytes)
{
    if (numBytes == 1) {
        if (bytes[0] == B_UP_ARROW) {
            UpdateValue(Value() + 1);
        }
        else if (bytes[0] == B_DOWN_ARROW) {
            UpdateValue(Value() - 1);
        }
        if (bytes[0] == B_PAGE_UP) {
            UpdateValue(Value() + fStepValue);
        }
        else if (bytes[0] == B_PAGE_DOWN) {
            UpdateValue(Value() - fStepValue);
        }
        else if (bytes[0] == B_HOME) {
            UpdateValue(fMaxValue);
        }
        else if (bytes[0] == B_END) {
            UpdateValue(fMinValue);
        }
        else if (bytes[0] == B_ENTER || bytes[0] == B_SPACE) {
            UpdateValue(fDefaultValue);
        }
        else {
            BControl::KeyDown(bytes, numBytes);
        }
    }
    else {
        BControl::KeyDown(bytes, numBytes);
    }
}

//++ ------------------------------------------------------------------------------------
// Details:	CMICmnLLDBDebugSessionInfoVarObj constructor.
// Type:	Method.
// Args:	vrStrNameReal	- (R) The actual name of the variable, the expression.
//			vrStrName		- (R) The name given for *this var object.
//			vrValue			- (R) The LLDB SBValue object represented by *this object.
// Return:	None.
// Throws:	None.
//--
CMICmnLLDBDebugSessionInfoVarObj::CMICmnLLDBDebugSessionInfoVarObj( const CMIUtilString & vrStrNameReal, const CMIUtilString & vrStrName, const lldb::SBValue & vrValue )
:	m_eVarFormat( eVarFormat_Natural )
,	m_eVarType( eVarType_Internal )
,	m_strName( vrStrName )
,	m_SBValue( vrValue )
,	m_strNameReal( vrStrNameReal )
{
	UpdateValue();
}

void SpinButton::MouseDown(BPoint point)
{
    if (IsEnabled()) {
        fButton = ButtonAt(point);
        if (fButton != kSpinButtonNone) {
            SetMouseEventMask(B_POINTER_EVENTS,
                              B_NO_POINTER_HISTORY | B_SUSPEND_VIEW_FOCUS);

            if (fButton == kSpinButtonUp)
                UpdateValue(Value() + 1);

            if (fButton == kSpinButtonDown)
                UpdateValue(Value() - 1);
        }
        fPoint = point;
    }
    BControl::MouseDown(point);
}

//++ ------------------------------------------------------------------------------------
// Details:	Set the var format type for *this object and upate the formatting.
// Type:	Method.
// Args:	None.
// Return:	MIstatus::success - Functional succeeded.
//			MIstatus::failure - Functional failed.
// Throws:	None.
//--
bool CMICmnLLDBDebugSessionInfoVarObj::SetVarFormat( const varFormat_e veVarFormat )
{
	if( veVarFormat >= eVarFormat_count )
		return MIstatus::failure;

	m_eVarFormat = veVarFormat;
	UpdateValue();
	return MIstatus::success;
}

void KMaterialUniformToolAlphaOperation::OnDeltaposSpinAlphabase(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMUPDOWN pNMUpDown = reinterpret_cast<LPNMUPDOWN>(pNMHDR);
	m_dwAlphaTestValue = static_cast<DWORD>(LOWORD(m_ctlAlphaCmpBase.GetPos()));
	UpdateData(FALSE);

	UpdateValue();
	*pResult = 0;
}