C++ NotifyObservers函数代码示例

void CDownloadQueue::AddDownload(CPartFile* file, bool paused, uint8 category)
{
	wxCHECK_RET(!IsFileExisting(file->GetFileHash()), wxT("Adding duplicate part-file"));

	if (file->GetStatus(true) == PS_ALLOCATING) {
		file->PauseFile();
	} else if (paused && GetFileCount()) {
		file->StopFile();
	}

	{
		wxMutexLocker lock(m_mutex);
		m_filelist.push_back( file );
		DoSortByPriority();
	}

	NotifyObservers( EventType( EventType::INSERTED, file ) );
	if (category < theApp->glob_prefs->GetCatCount()) {
		file->SetCategory(category);
	} else {
		AddDebugLogLineN( logDownloadQueue, wxT("Tried to add download into invalid category.") );
	}
	Notify_DownloadCtrlAddFile( file );
	theApp->searchlist->UpdateSearchFileByHash(file->GetFileHash());	// Update file in the search dialog if it's still open
	AddLogLineC(CFormat(_("Downloading %s")) % file->GetFileName() );
}

void CLogServBackupManager::RunL()
//
// This method does two things
//
// 1) Keeps trying to create a backup object - which may fail on device
//    bootup until the ui framework starts the backup server.
//
// 2) Handles the case where the server fails to restart correctly after a backup - it keeps trying
//
{
    LOGTEXT2("CLogServBackupManager::RunL(%d)", iStatus.Int());

    if	(!iBackup)
    {
        LOGTEXT("CLogServBackupManager::RunL() - trying to create backup object");

        // Keep trying to create backup object
        iBackup = CreateBackupL(*iDatabaseName);

        LOGTEXT("CLogServBackupManager::RunL() - backup object created okay");
    }
    else
    {
        // This branch is executed if we failed to create the backup object on our first
        // attempt in BISetDatabaseNameL
        LOGTEXT("CLogServBackupManager::RunL() - notifying observers about dummy backup ended event");
        NotifyObservers(MLogServBackupObserver::EBackupEnded);
    }

    LOGTEXT("CLogServBackupManager::RunL() - end");
}

void Actor::SetPosition( const Vector3& pos, const bool notify /*= true*/ )
{
	if(pos.x != pos.x || pos.y != pos.y || pos.z != pos.z)
	{
		throw "Invalid position";
	}

	this->zPreviousPos = this->zPos;
	this->zPos = pos;

	
	
	if (this->zPhysicsObject)
	{
		this->zPhysicsObject->SetPosition(pos);
	}

	if(notify)
	{
		ActorPositionEvent APE;
		APE.zActor = this;
		NotifyObservers(&APE);
	}

}

void LongParameter::UpdatePercRef()
{
    if (m_pSizeData == NULL)
        return;
    switch (m_PercType)
    {
    case AREA:
        m_PercRef = m_pSizeData->GetArea();
        break;
    case HEIGHT:
        m_PercRef = m_pSizeData->GetHeight();
        break;
    case WIDTH:
        m_PercRef = m_pSizeData->GetWidth();
        break;
    case COLOUR_RANGE:
        m_PercRef = 255;
        break;
    default:
        m_PercRef = -1;
    }
    if (IsPercentModification())
        UpdateValueFromPercent();
    else
        UpdatePercentValue();
    NotifyObservers();
}

Parameter::~Parameter(void)
{
    m_Destroyed = true;
    NotifyObservers();
    if (m_pSizeData != NULL)
        m_pSizeData->RemoveObserver(this);
}

/*****************************************************************************
 * Function -
 * DESCRIPTION:
 * Update subscribers when the alarm limit or warning limit datapoint
 * have been changed through the interface obtained by calls to
 * GetAlarmLimit() and GetWarningLimit()
 ****************************************************************************/
void AlarmConfig::Update(Subject* pSubject)
{
  if (!mLimitDatapointsChangedByAlarmConfig)
  {
    NotifyObservers();
    NotifyObserversE();
  }
}

bool
CUDPChannel::DoNotifyObservers( const CORE::CEvent& eventid               ,
                                CORE::CICloneable* eventData /* = NULL */ )
{GUCEF_TRACE;
    
    return NotifyObservers( eventid   ,
                            eventData );
}

void	CItemSlot::ChangeItemStatus( int iInvenIdx )
{
	m_pEvent->SetID( CTEventItem::EID_CHANGE_ITEM );
	m_pEvent->SetIndex( iInvenIdx );
	m_pEvent->SetItem( GetItem( iInvenIdx ) );
	SetChanged();
	NotifyObservers( m_pEvent );
}

bool
CFileSystemDialogImp::OnCancelButtonClick( const CEGUI::EventArgs& e )
{GUCE_TRACE;

    Hide();
    NotifyObservers( CancelPressedEvent );
    return true;
}

// -----------------------------------------------------------------------------
// CSipSnapAvailabilityMonitor::RunL
// -----------------------------------------------------------------------------
//
void CSipSnapAvailabilityMonitor::RunL()
{
    if ( iStatus == KErrNone )
    {
        iSnapAvailable = IsSnapAvailable( iSnapInfoBuf(), iSnapId );
        NotifyObservers();
    }
}

void HourDataPoint::Update(Subject* pSubject)
{
  I32 value = ActTime::GetInstance()->GetTime(HOURS);
  if (mValue != value)
  {
    mValue = value;
    NotifyObservers();
  }
}

void CAddonMgr::RemoveAddon(const CStdString& ID)
{
  if (m_cpluff && m_cp_context)
  {
    m_cpluff->uninstall_plugin(m_cp_context,ID.c_str());
    SetChanged();
    NotifyObservers(ObservableMessageAddons);
  }
}

void
CButtonImp::OnMouseClick( MyGUI::Widget* sender )
{GUCEF_TRACE;

    GUCEF_USER_LOG( GUCEF::CORE::LOGLEVEL_NORMAL, "MyGUIOgre: User clicked button \"" + GetName() + "\"" );
    
    CWidgetImp< GUCEF::GUI::CButton >::OnMouseClick( sender );    
    NotifyObservers( ButtonClickedEvent );
}

void
CTSGNotifier::OnPumpedNotify( CNotifier* notifier                 ,
                              const CEvent& eventid               ,
                              CICloneable* eventdata /* = NULL */ )
{GUCEF_TRACE;

    NotifyObservers( eventid   ,
                     eventdata );
}

Model::Model()
{
	isGameOver = false;
	isGameWin = false;
	secondsPassed = 0;
	minutesPassed = 0;
	mtable = ntable = 0;
	NotifyObservers(Change::TIME);
}