void URL_DataStorage::StartLoadingTvDocument() { loading = OP_NEW(URL_Tv_LoadHandler, (url, g_main_message_handler)); // We need this to be able to continue in the next stage (url_ds.cpp) if (!loading) //OOM { SetAttribute(URL::KLoadStatus,URL_LOADING_FAILURE); SetAttribute(URL::KHeaderLoaded,TRUE); SetAttribute(URL::KReloading,FALSE); SetAttribute(URL::KResumeSupported,FALSE); SetAttribute(URL::KReloadSameTarget,FALSE); BroadcastMessage(MSG_URL_LOADING_FAILED, url->GetID(), URL_ERRSTR(SI, ERR_COMM_INTERNAL_ERROR), MH_LIST_ALL); //g_memory_manager->RaiseCondition(OpStatus::ERR_NO_MEMORY); return; } SetAttribute(URL::KMIME_ForceContentType, "image/atvef"); SetAttributeL(URL::KMIME_Type, "image/atvef"); SetAttributeL(URL::KContentType, URL_TV_CONTENT); // Broadcast that header has loaded... BroadcastMessage(MSG_HEADER_LOADED, url->GetID(), url->GetIsFollowed() ? 0 : 1, MH_LIST_ALL); // Broadcast that data has been loaded. BroadcastMessage(MSG_URL_DATA_LOADED, url->GetID(), 0,MH_LIST_ALL); UnsetListCallbacks(); mh_list->Clean(); url->SetIsFollowed(TRUE); SetAttribute(URL::KHeaderLoaded, TRUE); SetAttribute(URL::KLoadStatus,URL_LOADED); }
void MythPianoService::WriteAudio(char* samples, size_t bytes) { if (!m_AudioOutput) { BroadcastMessage("Setting up audio rate(%d), channels(%d)\n", m_Player.samplerate, m_Player.channels); QString passthru = gCoreContext->GetNumSetting("PassThruDeviceOverride", false) ? gCoreContext->GetSetting("PassThruOutputDevice") : QString::null; QString main = gCoreContext->GetSetting("AudioOutputDevice"); QString errMsg; m_AudioOutput = AudioOutput::OpenAudio(main, passthru, FORMAT_S16, m_Player.channels, 0, m_Player.samplerate, AUDIOOUTPUT_MUSIC, true, false); } if (!m_AudioOutput) { BroadcastMessage("Error in WriteAudio. m_AudioOutput is null"); return; } if (bytes == 0) return; m_AudioOutput->AddFrames(samples, bytes / 4, -1); m_AudioOutput->Drain(); }
int MythPianoService::GetPlaylist() { BroadcastMessage("Getting playlist...\n"); rlen = sprintf(request, "queue\n"); SendPianodRequest(204); /* parse play list from queue command */ if(response->back().code == 204) { playlist.clear(); for(int x = 0; x < response->size() - 1; x++) { MythPianoResponse r = response->at(x); if(response->at(x).code == 203) { map<string, string> song = PullOutSong(x + 1); if(song.size() != 0) { cout<<"Storing new song: " << song["Title"] << endl; playlist.push_back(song); } } } } else { BroadcastMessage("Failed to get playlist(2)!\n"); return -1; } if(service_heartbeat() < 0) { BroadcastMessage("service heartbeat failed\n"); return -1; } return 0; }
void __fastcall TfrmMain::tcpServerExecute(TIdPeerThread *AThread) { TSimpleClient *Client; AnsiString Com; // System command AnsiString Msg; //Get the text sent from the client try { Msg = AThread->Connection->ReadLn("",5000); } catch (...) { } // Get the clients package info if (Msg.Length()==0)return; Client = (TSimpleClient *)(AThread->Data); // Check to see if the clients name has been assigned yet if (Client->Name == "Logging In") { // if not, assign the name and announce the client Client->Name = Msg; UpdateClientList(); BroadcastMessage("System", Msg + " has just logged in."); AThread->Connection->WriteLn(memEntry->Lines->Text); } else // If name is set, then send the message if (Msg[1] != '@') { // Not a system command BroadcastMessage(Client->Name, Msg); } else { // System command Com = UpperCase(Trim(Msg.SubString(2, Msg.Pos(":") -2))); Msg = UpperCase(Trim(Msg.SubString(Msg.Pos(":") +1, Msg.Length()))); if (Com == "CLIENTS") AThread->Connection->WriteLn( AnsiString("@") + AnsiString("clients:") + lbClients->Items->CommaText); if (Com == "KILL") KillClient(Msg); } }
void MythPianoService::StartPlayback() { BroadcastMessage("Starting playback"); if (m_Playlist == NULL) { BroadcastMessage("Empty playlist"); return; } if (m_Player.mode != audioPlayer::PLAYER_FREED && m_Player.mode != audioPlayer::PLAYER_FINISHED_PLAYBACK) { BroadcastMessage("So sorry, we think we are already playing. Try again (%d).", m_Player.mode); return; } memset (&m_Player, 0, sizeof (m_Player)); WaitressInit (&m_Player.waith); WaitressSetUrl (&m_Player.waith, m_CurrentSong->audioUrl); m_Player.gain = m_CurrentSong->fileGain; m_Player.audioFormat = m_CurrentSong->audioFormat; m_Player.mode = audioPlayer::PLAYER_STARTING; m_Player.writer = &WriteAudioCallback; m_Player.writerCtx = (void*) this; pthread_create (&m_PlayerThread, NULL, BarPlayerThread, &m_Player); BroadcastMessage("New Song"); if (class LCD *lcd = LCD::Get()) { lcd->switchToMusic(m_CurrentSong->artist, m_CurrentSong->album, m_CurrentSong->title); } if (m_Timer) { m_Timer->stop(); m_Timer->disconnect(); delete m_Timer; } m_Timer = new QTimer(this); connect(m_Timer, SIGNAL(timeout()), this, SLOT(heartbeat())); m_Timer->start(1000); }
void Proposer :: Accept() { PLGHead("START ProposalID %lu ValueSize %zu ValueLen %zu", m_oProposerState.GetProposalID(), m_oProposerState.GetValue().size(), m_oProposerState.GetValue().size()); BP->GetProposerBP()->Accept(); m_oTimeStat.Point(); ExitPrepare(); m_bIsAccepting = true; PaxosMsg oPaxosMsg; oPaxosMsg.set_msgtype(MsgType_PaxosAccept); oPaxosMsg.set_instanceid(GetInstanceID()); oPaxosMsg.set_nodeid(m_poConfig->GetMyNodeID()); oPaxosMsg.set_proposalid(m_oProposerState.GetProposalID()); oPaxosMsg.set_value(m_oProposerState.GetValue()); oPaxosMsg.set_lastchecksum(GetLastChecksum()); m_oMsgCounter.StartNewRound(); AddAcceptTimer(); PLGHead("END"); BroadcastMessage(oPaxosMsg, BroadcastMessage_Type_RunSelf_Final); }
void PaxosProposer::OnProposeResponse(PaxosMessage& imsg) { PaxosMessage omsg; Log_Trace("msg.nodeID = %u", imsg.nodeID); if (!state.proposing || imsg.proposalID != state.proposalID) return; if (imsg.type == PAXOS_PROPOSE_REJECTED) { Log_Debug("Propose rejected, quorumID: %U", context->GetQuorumID()); vote->RegisterRejected(imsg.nodeID); } else vote->RegisterAccepted(imsg.nodeID); if (vote->IsRejected()) { StopProposing(); EventLoop::Add(&restartTimeout); } else if (vote->IsAccepted()) { // a majority have accepted our proposal, we have consensus StopProposing(); omsg.LearnProposal(context->GetPaxosID(), MY_NODEID, state.proposalID); BroadcastMessage(omsg); state.learnSent = true; } }
void WED_PackageMgr::Rescan(void) { custom_package_names.clear(); global_package_names.clear(); default_package_names.clear(); system_exists=false; if (MF_GetFileType(system_path.c_str(),mf_CheckType) == mf_Directory) { string cus_dir = system_path + DIR_STR CUSTOM_PACKAGE_PATH; if (MF_GetFileType(cus_dir.c_str(),mf_CheckType) == mf_Directory) { system_exists=true; MF_IterateDirectory(cus_dir.c_str(), package_scan_func, &custom_package_names); sort(custom_package_names.begin(),custom_package_names.end(),CompareNoCase); } string glb_dir = system_path + DIR_STR GLOBAL_PACKAGE_PATH; if (MF_GetFileType(glb_dir.c_str(),mf_CheckType) == mf_Directory) { system_exists=true; MF_IterateDirectory(glb_dir.c_str(), package_scan_func, &global_package_names); sort(global_package_names.begin(),global_package_names.end(),CompareNoCase); } string def_dir = system_path + DIR_STR DEFAULT_PACKAGE_PATH; if (MF_GetFileType(def_dir.c_str(),mf_CheckType) == mf_Directory) { system_exists=true; MF_IterateDirectory(def_dir.c_str(), package_scan_func, &default_package_names); sort(default_package_names.begin(),default_package_names.end(),CompareNoCase); } } BroadcastMessage(msg_SystemFolderChanged,0); }
void PaxosProposer::OnProposeResponse(PaxosMessage& imsg) { PaxosMessage omsg; Log_Trace("msg.nodeID = %u", imsg.nodeID); if (!state.proposing || imsg.proposalID != state.proposalID) return; if (imsg.type == PAXOS_PROPOSE_REJECTED) { Log_Debug("Propose rejected"); vote->RegisterRejected(imsg.nodeID); } else vote->RegisterAccepted(imsg.nodeID); // see if we have enough positive replies to advance if (vote->IsAccepted()) { // a majority have accepted our proposal, we have consensus StopProposing(); omsg.LearnProposal(context->GetPaxosID(), MY_NODEID, state.proposalID); BroadcastMessage(omsg); } else if (vote->IsComplete()) StartPreparing(); }
void Proposer :: Prepare(const bool bNeedNewBallot) { PLGHead("START Now.InstanceID %lu MyNodeID %lu State.ProposalID %lu State.ValueLen %zu", GetInstanceID(), m_poConfig->GetMyNodeID(), m_oProposerState.GetProposalID(), m_oProposerState.GetValue().size()); BP->GetProposerBP()->Prepare(); m_oTimeStat.Point(); ExitAccept(); m_bIsPreparing = true; m_bCanSkipPrepare = false; m_bWasRejectBySomeone = false; m_oProposerState.ResetHighestOtherPreAcceptBallot(); if (bNeedNewBallot) { m_oProposerState.NewPrepare(); } PaxosMsg oPaxosMsg; oPaxosMsg.set_msgtype(MsgType_PaxosPrepare); oPaxosMsg.set_instanceid(GetInstanceID()); oPaxosMsg.set_nodeid(m_poConfig->GetMyNodeID()); oPaxosMsg.set_proposalid(m_oProposerState.GetProposalID()); m_oMsgCounter.StartNewRound(); AddPrepareTimer(); PLGHead("END OK"); BroadcastMessage(oPaxosMsg); }
void DepositHandler::HandlePostEncodedRequest( uint160 request_hash, uint160 post_encoding_credit_hash) { log_ << "HandlePostEncodedRequest: " << request_hash << "\n"; DepositAddressPartMessage part_msg; std::vector<uint160> part_hashes = depositdata[request_hash]["parts"]; foreach_(uint160 part_msg_hash, part_hashes) { part_msg = msgdata[part_msg_hash]["deposit_part"]; Point relay = part_msg.VerificationKey(); log_ << "part " << part_msg_hash << " was sent by " << relay << "\n"; if (keydata[relay].HasProperty("privkey")) { log_ << "have key for " << relay << "; sending disclosure\n"; DepositAddressPartDisclosure disclosure( post_encoding_credit_hash, part_msg_hash); BroadcastMessage(disclosure); log_ << "sent disclosure\n"; } flexnode.scheduler.Schedule("disclosure_timeout_check", part_msg_hash, GetTimeMicros() + COMPLAINT_WAIT_TIME); }
int GUI_PopupButton::MouseDown(int x, int y, int button) { vector<GUI_MenuItem_t> items; items.resize(mItems.size()+1); for (int n = 0; n < mItems.size(); ++n) { items[n].name = mItems[n].c_str(); items[n].key = 0; items[n].flags = 0; items[n].cmd = 0; items[n].checked = 0; } items.back().name = NULL; items.back().key = 0; items.back().flags = 0; items.back().cmd = 0; items.back().checked = 0; int bounds[4]; GetBounds(bounds); int picked = PopupMenuDynamic(&*items.begin(), bounds[0], bounds[3], button, GetValue()); if (picked >= 0) { SetValue(picked); BroadcastMessage(GUI_CONTROL_VALUE_CHANGED,0); } return 1; }
int MythPianoService::RepopulateStations() { BroadcastMessage("Retrieving station list...\n"); stations.clear(); rlen = sprintf(request, "stations list\n"); SendPianodRequest(204); if(response->back().code == 204) { for(int x = 0; x < response->size(); x++) { MythPianoResponse r = response->at(x); if(r.code != 115) continue; /* remove the "Station: " */ r.value = r.value.substr(9); std::cout<<"Adding station: " << r.value << endl; stations.push_back(r.value); } } else { PianodDisconnect("Failed to retrieve station list. Bailing: " + response->back().value); return -1; } service_heartbeat(); return 0; }
void TradeHandler::HandleTraderComplaint(TraderComplaint complaint) { uint160 message_hash = complaint.message_hash; if (!CheckTraderComplaint(complaint)) { should_forward = false; return; } uint160 complaint_hash = complaint.GetHash160(); TradeSecretMessage msg = msgdata[message_hash]["secret"]; pair<string_t, Point> complaint_key; complaint_key = make_pair("received_complaint_about", msg.VerificationKey()); tradedata[msg.accept_commit_hash][complaint_key] = true; vector<Point> awaited_relays; awaited_relays = tradedata[msg.accept_commit_hash]["awaited_relays"]; awaited_relays.push_back(msg.VerificationKey()); tradedata[msg.accept_commit_hash]["awaited_relays"] = awaited_relays; flexnode.pit.HandleRelayMessage(message_hash); if (tradedata[message_hash]["is_mine"]) { BroadcastMessage(RefutationOfTraderComplaint(complaint_hash)); } }
void GUI_SimpleScroller::ReceiveMessage( GUI_Broadcaster * inSrc, intptr_t inMsg, intptr_t inParam) { if (inMsg == GUI_SCROLL_CONTENT_SIZE_CHANGED) BroadcastMessage(inMsg, inParam); }
void CClientManager::OnRecordingFileChanged(LPCWSTR pszFileName) { CMessage Message(MESSAGE_EVENT_RecordingFileChanged); Message.SetProperty(MESSAGE_PROPERTY_FilePath,pszFileName); BroadcastMessage(Message); }
void CClientManager::OnServiceChanged(WORD ServiceID) { CMessage Message(MESSAGE_EVENT_ServiceChanged); Message.SetPropertyInt(MESSAGE_PROPERTY_ServiceID,ServiceID); BroadcastMessage(Message); }
void CClientManager::OnBonDriverLoaded(LPCWSTR pszFileName) { CMessage Message(MESSAGE_EVENT_BonDriverLoaded); Message.SetProperty(MESSAGE_PROPERTY_FilePath,pszFileName); BroadcastMessage(Message); }
CDCMapWorkspace::~CDCMapWorkspace(void) { BroadcastMessage(DCMM_PRE_DESTROY,0,0,0); _foreach(ObjectsSet,m_Objects,it) { (*it)->SaveConfig(&m_Config); g_dcmapCore.DestroyWorkspaceModule(*it); }
void Server::BroadcastMessageToAll(std::string _message){ for (size_t i = 0; i < clientsVec.size(); i++){ //disable the if check if you want to test on localhost // if(!CompareClients(&clientsVec[i], (struct sockaddr *)&remoteaddr)){ BroadcastMessage(_message, &clientsVec[i]); // } } }
bool SendServerMessage(const std::string &body, PeerBitSet peers) { auto session = Blam::Network::GetActiveSession(); if (!session || !session->IsEstablished() || !session->IsHost()) return false; ChatMessage message(ChatMessageType::Server, body); return BroadcastMessage(session, session->MembershipInfo.LocalPeerIndex, &message, peers); }
foreach_(const BigNumsInPositions::value_type& item, credit_secrets_that_dont_recover_currency_secrets) { uint32_t position = item.first; CBigNum bad_credit_secret = item.second; RelayComplaint complaint(message_hash, ASK, position, bad_credit_secret); BroadcastMessage(complaint); }
void CControlPanel::ListenToMessage(MessageT inMessage, void* ioParam) { LStaticText *theCaption; switch (inMessage) { case msg_BroadcasterDied: // maybe you should just StopListening(); break; case msg_RenderModeChanged: _renderingMode = *((UInt32*)ioParam); BroadcastMessage(msg_RenderModeChanged, ioParam); break; } UpdateValues(true); BroadcastMessage(msg_ControllerChanged ,nil); }
void CClientManager::OnChannelChanged(DWORD Space,DWORD Channel,WORD ServiceID) { CMessage Message(MESSAGE_EVENT_ChannelChanged); Message.SetPropertyInt(MESSAGE_PROPERTY_TuningSpace,Space); Message.SetPropertyInt(MESSAGE_PROPERTY_Channel,Channel); if (ServiceID!=0) Message.SetPropertyInt(MESSAGE_PROPERTY_ServiceID,ServiceID); BroadcastMessage(Message); }
int XPCPushButtonMessageAttachment::HandleWidgetMessage( XPCWidget * inObject, XPWidgetMessage inMessage, XPWidgetID inWidget, long inParam1, long inParam2) { if ((inMessage == xpMsg_PushButtonPressed) && ((XPWidgetID) inParam1 == mWidget)) { BroadcastMessage(mMsg, mParam); return 1; } if ((inMessage == xpMsg_ButtonStateChanged) && ((XPWidgetID) inParam1 == mWidget)) { BroadcastMessage(mMsg, mParam); return 1; } return 0; }
void MythPianoService::StartPlayback() { BroadcastMessage("Starting playback... \n"); rlen = sprintf(request, "stop now\n"); SendPianodRequest(200); rlen = sprintf(request, "select station \"%s\"\n", stations[current_station].c_str()); SendPianodRequest(200); rlen = sprintf(request, "play\n"); SendPianodRequest(200); if(response->back().code != 200) { BroadcastMessage("Failed to start playback!\n"); return; } if(playlist.size() == 0) { BroadcastMessage("Empty playlist"); return; } }
//============================================================================ // NPreferences::SetValue : Set a value. //---------------------------------------------------------------------------- void NPreferences::SetValue(const NString &theKey, const NVariant &theValue) { // Validate our parameters NN_ASSERT(!theKey.IsEmpty()); // Set the value NTargetPreferences::SetValue(theKey, theValue); BroadcastMessage(kMsgNPreferenceValueChanged, &theKey); }
void MythPianoService::GetPlaylist() { PianoReturn_t pRet; WaitressReturn_t wRet; PianoRequestDataGetPlaylist_t reqData; reqData.station = m_CurrentStation; reqData.format = PIANO_AF_AACPLUS; BroadcastMessage("Receiving new playlist... "); if (!PianoCall(PIANO_REQUEST_GET_PLAYLIST, &reqData, &pRet, &wRet)) { m_CurrentStation = NULL; m_CurrentSong = NULL; } else { m_Playlist = reqData.retPlaylist; m_CurrentSong = m_Playlist; if (m_Playlist == NULL) { BroadcastMessage("No tracks left.\n"); m_CurrentStation = NULL; m_CurrentSong = NULL; } } }
void CClientManager::OnRecordingStarted(const RecordingInfo &Info) { CMessage Message(MESSAGE_EVENT_RecordingStarted); String Directory,FileName; PathUtility::Split(Info.FilePaths.front(),&Directory,&FileName); Message.SetProperty(MESSAGE_PROPERTY_FileName,FileName); Message.SetProperty(MESSAGE_PROPERTY_Directory,Directory); Message.SetProperty(MESSAGE_PROPERTY_ServiceSelect,CMessageProperty::IntType(Info.Settings.ServiceSelect)); BroadcastMessage(Message); }
void WED_PackageMgr::RenameCustomPackage(int n, const string& new_name) { string oldn = system_path + DIR_STR CUSTOM_PACKAGE_PATH DIR_STR + custom_package_names[n]; string newn = system_path + DIR_STR CUSTOM_PACKAGE_PATH DIR_STR + new_name; int res = FILE_rename_file(oldn.c_str(), newn.c_str()); if (res != 0) { wed_error_exception e(res, __FILE__ , __LINE__); WED_ReportExceptionUI(e, "Unable to rename package %s to %s",oldn.c_str(), newn.c_str()); } else custom_package_names[n] = new_name; BroadcastMessage(msg_SystemFolderUpdated,0); }