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);
}

///////////////////////////////////////////////////////////////////////////////
// Function: int CResourceGroup::PrimOnMediaCommandResponse(const CSipCallInfoSptr &a_sipCallInfo)
//
// Description: Handle a MSML server response for a command
//
// Return: int - 0 on success, otherwise failure
//
// Parameters: const CSipCallInfoSptr &a_sipCallInfo
//
///////////////////////////////////////////////////////////////////////////////
int CResourceGroup::PrimOnMediaCommandResponse( const CSipCallInfoSptr& a_sipCallInfo)
{
   LogDebug("PrimOnMediaCommandResponse");

 // TODO:   There may be an HMP bug on Linux because the 200 OK message 
 //         in Ethereal has the correct data but the GC event doesnt.  
 //         Works OK on Windows.
 //         There is an INFO message for setting video attribs that
 //         arrives immediately after the 200 OK.


   CMsmlResponseSptr l_responseData( new CMsmlResponse( a_sipCallInfo->MimeData()));

 #ifdef _WIN32

//   std::string l_response = a_sipCallInfo->MimeData();
//   std::string l_responseCode;
//   const std::string l_responseCodeLabel = "result response=\"";
//   unsigned int l_seperatorPos = l_response.find(l_responseCodeLabel);
//   if ( l_seperatorPos != l_response.npos)
//   {
//      l_responseCode = l_response.substr( l_seperatorPos + l_responseCodeLabel.size(), 3);
//   }

   if ( l_responseData->ResponseCode() == "200")

#else

   if ( a_sipCallInfo->ResponseCode() == 200)

#endif
   {
      LogDebug("PrimOnMediaCommandResponse", "started");
      NotifyObservers( RESOURCEGROUP_MEDIA_COMMAND_COMPLETE, l_responseData);
   }
   else
   {
      LogDebug("PrimOnMediaCommandResponse", "failed");
      NotifyObservers( RESOURCEGROUP_MEDIA_COMMAND_FAILED, l_responseData);
      return -1;
   }

   return 0;
}

void
URLSearchParams::ParseInput(const nsACString& aInput,
                            URLSearchParamsObserver* aObserver)
{
  // Remove all the existing data before parsing a new input.
  DeleteAll();

  nsACString::const_iterator start, end;
  aInput.BeginReading(start);
  aInput.EndReading(end);
  nsACString::const_iterator iter(start);

  while (start != end) {
    nsAutoCString string;

    if (FindCharInReadable('&', iter, end)) {
      string.Assign(Substring(start, iter));
      start = ++iter;
    } else {
      string.Assign(Substring(start, end));
      start = end;
    }

    if (string.IsEmpty()) {
      continue;
    }

    nsACString::const_iterator eqStart, eqEnd;
    string.BeginReading(eqStart);
    string.EndReading(eqEnd);
    nsACString::const_iterator eqIter(eqStart);

    nsAutoCString name;
    nsAutoCString value;

    if (FindCharInReadable('=', eqIter, eqEnd)) {
      name.Assign(Substring(eqStart, eqIter));

      ++eqIter;
      value.Assign(Substring(eqIter, eqEnd));
    } else {
      name.Assign(string);
    }

    nsAutoCString decodedName;
    DecodeString(name, decodedName);

    nsAutoCString decodedValue;
    DecodeString(value, decodedValue);

    AppendInternal(NS_ConvertUTF8toUTF16(decodedName),
                   NS_ConvertUTF8toUTF16(decodedValue));
  }

  NotifyObservers(aObserver);
}

nsresult nsMsgRDFDataSource::NotifyPropertyChanged(nsIRDFResource *resource,
                                                   nsIRDFResource *propertyResource,
                                                   nsIRDFNode *newNode,
                                                   nsIRDFNode *oldNode /* = nullptr */)
{

  NotifyObservers(resource, propertyResource, newNode, oldNode, false, true);
  return NS_OK;

}

//**************************
//Description : Function managing all input events
//Parameters : None
//Return Value : None
//Note : None
//**************************
void CEventManager::ManageEvents()
{
    while ( m_RenderWindow->GetEvent(m_CurrentEvent) )
    {
        if ( m_CurrentEvent.Type == sf::Event::Closed )
            m_RenderWindow->Close();

        NotifyObservers(m_CurrentEvent);
    }
}

nsresult
nsMsgAccountManagerDataSource::OnItemBoolPropertyChanged(nsIRDFResource *aItem,
                                                         nsIAtom *aProperty,
                                                         PRBool aOldValue,
                                                         PRBool aNewValue)
{
  if (aProperty == kDefaultServerAtom)
    NotifyObservers(aItem, kNC_IsDefaultServer, kTrueLiteral, nsnull, aNewValue, PR_FALSE);
  return NS_OK;
}