void RADIO_DataIndicationPacket(tRxPacket *sRxPacket) { if (sRxPacket->u8Status==SMAC1_TIMEOUT) { /* Put timeout condition code here */ LED1_Neg(); LED2_Neg(); /* indicator for bad or no communication */ EVNT_SetEvent(EVNT_RADIO_TIMEOUT); } else if (sRxPacket->u8Status == SMAC1_SUCCESS) { /* good packet received: handle it. */ if (RADIO_isSniffing) { QueueMessage(RADIO_QUEUE_MSG_SNIFF, (const char*)sRxPacket->pu8Data, sRxPacket->u8DataLength); } /* check if it is the packet we expect...*/ if ( RADIO_AppStatus==RADIO_WAITING_FOR_ACK && UTIL1_strncmp((char*)sRxPacket->pu8Data, RADIO_PREFIX_STR RADIO_ACK_STR, sizeof(RADIO_PREFIX_STR RADIO_ACK_STR)-1)==0 ) /* is it our acknowledge packet? */ { EVNT_SetEvent(EVNT_RADIO_ACK); } else if (UTIL1_strncmp((char*)sRxPacket->pu8Data, RADIO_PREFIX_STR, sizeof(RADIO_PREFIX_STR)-1)==0) { #if PL_HAS_REMOTE && PL_HAS_MOTOR /*! \todo Implement your own message handling */ if (UTIL1_strncmp((char*)sRxPacket->pu8Data, RADIO_PREFIX_STR REMOTE_ACCEL_PREFIX, sizeof(RADIO_PREFIX_STR REMOTE_ACCEL_PREFIX)-1)==0) { QueueMessage(RADIO_QUEUE_MSG_ACCEL, (const char*)sRxPacket->pu8Data, sRxPacket->u8DataLength); } #endif EVNT_SetEvent(EVNT_RADIO_DATA); } else { /* unknown packet? */ EVNT_SetEvent(EVNT_RADIO_UNKNOWN); } } else if (sRxPacket->u8Status==SMAC1_OVERFLOW) { /* received packet, but it was longer than what we expect. */ EVNT_SetEvent(EVNT_RADIO_OVERFLOW); LED1_Neg(); LED2_Neg(); /* indicator for bad or no communication */ } }
BOOL display::SetDisplayMode(WORD _width, WORD _height, BYTE _bpp) { int error = 0; set_color_depth(_bpp); error = set_gfx_mode(this->mode, _width, _height, 0, 0); if(error != 0) { LogError("Error setting graphics resolution."); LogError("Allegro returned this error message: %s", allegro_error); return false; } this->back = Surface(new surface(_width, _height, _bpp)); this->_screen = Surface(new surface(::screen)); this->_screen->Acquire(); this->_screen->ShowMouse(); this->_screen->Release(); this->width = _width; this->height = _height; this->bpp = _bpp; /*LogMessage("Screen resolution succesfully changed."); LogMessage("Display Width: %d", this->width); LogMessage("Display Height: %d", this->height); LogMessage("Display bits per pixel: %d", this->bpp); LogMessage("Display mode: %d", this->mode);*/ //queue a message stating that the gfx has been changed. QueueMessage(Message(new message(0, MSG_GFX_SCREEN_RES_CHANGED, MAKEDWORD(_width, _height), MAKEDWORD((WORD)_bpp, (WORD)this->mode), NULL))); return true; }
void CsoundPerformanceThread::Record(std::string filename, int samplebits, int numbufs) { QueueMessage(new CsPerfThreadMsg_Record(this, filename, samplebits, numbufs)); }
int GUIAPI PostMessage (HWND hWnd, int iMsg, WPARAM wParam, LPARAM lParam) { PMSGQUEUE pMsgQueue; MSG msg; if (!(pMsgQueue = GetMsgQueue(hWnd))) return ERR_INV_HWND; if (iMsg == MSG_PAINT) { LOCK_MSGQ (pMsgQueue); pMsgQueue->dwState |= QS_PAINT; UNLOCK_MSGQ (pMsgQueue); #ifndef _LITE_VERSION if ( !BE_THIS_THREAD(hWnd) ) POST_MSGQ(pMsgQueue); #endif return ERR_OK; } msg.hwnd = hWnd; msg.message = iMsg; msg.wParam = wParam; msg.lParam = lParam; if (!QueueMessage(pMsgQueue, &msg)) return ERR_QUEUE_FULL; return ERR_OK; }
/*---------------------------------------------------------------------------------------------------------------------- Function: SspWriteData Description: Queues a data array for transfer on the target SSP peripheral. Requires: - psSspPeripheral_ has been requested and holds a valid pointer to a transmit buffer; even if a transmission is in progress, the node in the buffer that is currently being sent will not be destroyed during this function. - The chip select line of the SSP device should be asserted - u32Size_ is the number of bytes in the data array - u8Data_ points to the first byte of the data array Promises: - adds the data message at psSspPeripheral_->pTransmitBuffer that will be sent by the SSP application when it is available. - Returns the message token assigned to the message; 0 is returned if the message cannot be queued in which case G_u32MessagingFlags can be checked for the reason */ u32 SspWriteData(SspPeripheralType* psSspPeripheral_, u32 u32Size_, u8* pu8Data_) { u8 u8FullCycles; u8 u8Remainder; u32 u32Index = 0; u32 u32Token; u8FullCycles = u32Size_ / MAX_TX_MESSAGE_LENGTH; u8Remainder = u32Size_ % MAX_TX_MESSAGE_LENGTH; /* Slice up the data to the allowable message size */ for(u8 i = 0; i < u8FullCycles; i++) { u32Token = QueueMessage(MAX_TX_MESSAGE_LENGTH, pu8Data_ + u32Index, &psSspPeripheral_->pTransmitBuffer); if(!u32Token) { return(0); } /* Only update the index if pu8Data_ isn't pointed at the dummy array since that data should be repeated */ if(pu8Data_ != &SSP_au8Dummies[0]) { u32Index += MAX_TX_MESSAGE_LENGTH; } /* If the system is initializing, manually cycle the SSP task through one iteration to send the message */ if(G_u32SystemFlags & _SYSTEM_INITIALIZING) { SspManualMode(); } } /* Complete the remaining bytes and assign the token to this message */ u32Token = QueueMessage(u8Remainder, pu8Data_ + u32Index, &psSspPeripheral_->pTransmitBuffer); if(u32Token) { if(G_u32SystemFlags & _SYSTEM_INITIALIZING) { SspManualMode(); } } return(u32Token); } /* end SspWriteData() */
void sig::MessageNetwork::QueueMessage(Node *from, Node *to, string body, float wait, void *udata) { Message *msg = new Message(); msg->SetBody(body); msg->SetFrom(from); msg->SetTo(to); msg->m_timeout = wait; msg->userData = udata; QueueMessage(msg); }
/*---------------------------------------------------------------------------------------------------------------------- Function: SspReadData Description: Gets multiple bytes from the slave on the target SSP peripheral. Requires: - psSspPeripheral_ has been requested and holds a valid pointer to a transmit buffer; even if a transmission is in progress, the node in the buffer that is currently being sent will not be destroyed during this function. - The chip select line of the SSP device should be asserted - u32Size_ is the number of bytes in the data array Promises: - Adds a dummy byte message at psSspPeripheral_->psTransmitBuffer that will be sent by the SSP application when it is available and thus clock in the received bytes to the designated Rx buffer. - Returns the message token of the dummy message used to read data - If the peripheral is busy reading data already, then returns 0. */ u32 SspReadData(SspPeripheralType* psSspPeripheral_, u32 u32Size_) { u8 au8MsgTooBig[] = "\r\nSSP message to large\n\r"; /* Disallow if requested size is too large */ if(u32Size_ > MAX_TX_MESSAGE_LENGTH) { DebugPrintf(au8MsgTooBig); return 0; } return( QueueMessage(&psSspPeripheral_->psTransmitBuffer, u32Size_, &SSP_au8Dummies[0]) ); } /* end SspReadData() */
GLuint RendererThread::GetCurrentWallpaperTexture() { bool currentFlip = m_flipWallpaperTextures.load(); GLuint back = GetBackWallpaperTexture(currentFlip); FlipWallpaperTextures(currentFlip); if(!m_firstChange) { QueueMessage(Message::MessageType::FadeWallpaper); } else { m_firstChange = false; } return back; }
/*---------------------------------------------------------------------------------------------------------------------- Function: SspWriteByte Description: Queues a single byte for transfer on the target SSP peripheral. Requires: - psSspPeripheral_ has been requested. - The chip select line of the SSP device should be asserted Promises: - Creates a 1-byte message at psSspPeripheral_->psTransmitBuffer that will be sent by the SSP application when it is available. - Returns the message token assigned to the message */ u32 SspWriteByte(SspPeripheralType* psSspPeripheral_, u8 u8Byte_) { u32 u32Token; u8 u8Data = u8Byte_; u32Token = QueueMessage(&psSspPeripheral_->psTransmitBuffer, 1, &u8Data); if( u32Token != 0 ) { /* If the system is initializing, we want to manually cycle the SSP task through one iteration to send the message */ if(G_u32SystemFlags & _SYSTEM_INITIALIZING) { SspManualMode(); } } return(u32Token); } /* end SspWriteByte() */
/*---------------------------------------------------------------------------------------------------------------------- Function: SspWriteData Description: Queues a data array for transfer on the target SSP peripheral. Requires: - psSspPeripheral_ has been requested and holds a valid pointer to a transmit buffer; even if a transmission is in progress, the node in the buffer that is currently being sent will not be destroyed during this function. - The chip select line of the SSP device should be asserted - u32Size_ is the number of bytes in the data array - u8Data_ points to the first byte of the data array Promises: - adds the data message at psSspPeripheral_->psTransmitBuffer that will be sent by the SSP application when it is available. - Returns the message token assigned to the message; 0 is returned if the message cannot be queued in which case G_u32MessagingFlags can be checked for the reason */ u32 SspWriteData(SspPeripheralType* psSspPeripheral_, u32 u32Size_, u8* pu8Data_) { u32 u32Token; u32Token = QueueMessage(&psSspPeripheral_->psTransmitBuffer, u32Size_, pu8Data_); if( u32Token == 0 ) { return(0); } /* If the system is initializing, manually cycle the SSP task through one iteration to send the message */ if(G_u32SystemFlags & _SYSTEM_INITIALIZING) { SspManualMode(); } return(u32Token); } /* end SspWriteData() */
void CsoundPerformanceThread::SetScoreOffsetSeconds(double timeVal) { QueueMessage(new CsPerfThreadMsg_SetScoreOffsetSeconds(this, timeVal)); }
void CsoundPerformanceThread::InputMessage(const char *s) { QueueMessage(new CsPerfThreadMsg_InputMessage(this, s)); }
void CsoundPerformanceThread::ScoreEvent(int absp2mode, char opcod, int pcnt, const MYFLT *p) { QueueMessage(new CsPerfThreadMsg_ScoreEvent(this, absp2mode, opcod, pcnt, p)); }
void MessageManager::ProcessMessage(Message * message) { // Check for UI-messages first. String msg = message->msg; // UserInterface * globalUI = GlobalUI(); // Do note that not all messages uses the string-argument... // if (!msg.Length()) // return; if (message->recipientEntity) { message->recipientEntity->ProcessMessage(message); } // Let active lighting process messages if wanted. Lighting * activeLighting = Graphics.ActiveLighting(); if (activeLighting) { if (activeLighting->ProcessMessage(message)) return; } WindowMan.ProcessMessage(message); UI::ProcessMessage(message); switch(message->type) { case MessageType::BOOL_MESSAGE: { BoolMessage * bm = (BoolMessage*) message; if (msg == "BGMEnabled") { QueueAudio(new AMSetb(AT_BGM_ENABLED, bm->value)); } break; } case MessageType::INTEGER_MESSAGE: { IntegerMessage * im = (IntegerMessage*) message; if (msg == "SetMasterVolume") { QueueAudio(new AMSet(AT_MASTER_VOLUME, im->value * 0.01f)); } else if (msg == "SetBGMVolume") { QueueAudio(new AMSet(AT_BGM_VOLUME, im->value * 0.01f)); } else if (msg == "SetSFXVolume") { QueueAudio(new AMSet(AT_SFX_VOLUME, im->value * 0.01f)); } break; } case MessageType::COLLISSION_CALLBACK: { CollisionCallback * cc = (CollisionCallback*) message; /// o.o Entity * one = cc->one; Entity * two = cc->two; one->ProcessMessage(cc); two->ProcessMessage(cc); break; } case MessageType::RAYCAST: { Raycast * raycast = (Raycast*) message; if (raycast->relevantEntity) { raycast->relevantEntity->ProcessMessage(message); } break; } case MessageType::DRAG_AND_DROP: { DragAndDropMessage * dadm = (DragAndDropMessage*) message; // Hover to where the drop is to take place. InputMan.MouseMove(HoverWindow(), dadm->position); /// Check cursor location, can we drop stuff? UIElement * e = InputMan.HoverElement(); if (e) e->ProcessMessage(message); break; } case MessageType::PASTE: { if (msg.Contains("Paste:")) { // Check for active ui element. UserInterface * ui = ActiveUI(); if (ui){ UIElement * element = ui->GetActiveElement(); if (element) { element->ProcessMessage(message); } } } } case MessageType::STRING: { msg.SetComparisonMode(String::NOT_CASE_SENSITIVE); if (msg.StartsWith("SetLight")) { Light::ProcessMessageStatic(message); } else if (msg == "ToggleMute") { // Mute? QueueAudio(new AMGlobal(AM_TOGGLE_MUTE)); } else if (msg.StartsWith("SetGravity")) { String gravStr = msg.Tokenize("()")[1]; Vector3f grav; grav.ReadFrom(gravStr); PhysicsQueue.Add(new PMSet(PT_GRAVITY, grav)); } else if (msg.StartsWith("AdjustMasterVolume(")) { float diff = msg.Tokenize("()")[1].ParseFloat(); QueueAudio(new AMSet(AT_MASTER_VOLUME, AudioMan.MasterVolume() + diff)); } else if (msg == "CreateEditorCamera") { CreateEditorCamera(); } else if (msg.Contains("CreateNormalMapTestEntities")) { // Create some entities. Entity * entity = MapMan.CreateEntity("NormalMapSprite", ModelMan.GetModel("sprite.obj"), TexMan.GetTexture("0x77"), Vector3f(0,0,0)); GraphicsQueue.Add(new GMSetEntityTexture(entity, NORMAL_MAP, "normalMapTest2")); } if (msg == "AcceptInput:false") inputState->acceptInput = false; else if (msg.Contains("InputMan.printHoverElement")) InputMan.printHoverElement = !InputMan.printHoverElement; else if (msg == "SetGlobalState:NULL") StateMan.SetGlobalState(NULL); else if (msg == "SetActiveState:NULL") StateMan.SetActiveState(NULL); else if (msg == "StateMan.DeleteStates") StateMan.DeleteStates(); else if (msg == "NetworkMan.Shutdown") NetworkMan.Shutdown(); else if (msg == "StateMan.Shutdown") StateMan.shouldLive = false; else if (msg == "MultimediaMan.Shutdown") MultimediaMan.Shutdown(); else if (msg == "AudioMan.Shutdown") AudioMan.QueueMessage(new AMGlobal(AM_SHUTDOWN)); else if (msg == "GraphicsMan.Shutdown") Graphics.QueueMessage(new GraphicsMessage(GM_SHUTDOWN)); else if (msg == "PrintScreenshot") { Graphics.QueueMessage(new GraphicsMessage(GM_PRINT_SCREENSHOT)); } else if (msg.Contains("SetOutOfFocusSleepThread(")) { int sleepTime = msg.Tokenize("()")[1].ParseInt(); GraphicsMan.QueueMessage(new GMSeti(GM_SET_OUT_OF_FOCUS_SLEEP_TIME, sleepTime)); } else if (msg.StartsWith("RenderGrid")) { // Disable it, everywhere? for (int i = 0; i < WindowMan.GetWindows().Size(); ++i) { AppWindow * w = WindowMan.GetWindows()[i]; w->RenderGrid(false); } } else if (msg.Contains("PrintHttpOutput(")) { bool value = msg.Tokenize("()")[1].ParseBool(); printHttpOutput = value; } else if (msg.Contains("SetHttpTool:")) { httpTool = msg.Tokenize(":")[1].ParseInt(); } else if (msg.Contains("HttpGet:")) { String url = msg - "HttpGet:"; HttpGet(url); } else if (msg == "ResumePhysics") { PhysicsMan.Resume(); } else if (msg.Contains("PlayBGM:")) { String source = msg - "PlayBGM:"; source.RemoveSurroundingWhitespaces(); AudioMan.QueueMessage(new AMPlayBGM(source, 1.f)); } else if (msg.Contains("NavigateUI(")){ bool toggle = msg.Tokenize("()")[1].ParseBool(); InputMan.NavigateUI(toggle); return; } else if (msg == "IgnoreMouseInput") { bool & ignore = InputMan.ignoreMouse; ignore = !ignore; } else if (msg == "DisableLogging") { extern bool loggingEnabled; loggingEnabled = false; } else if (msg == "EnableLogging") { extern bool loggingEnabled; loggingEnabled = true; } else if (msg == "PrintExpressionSymbols") { Expression::printExpressionSymbols = true; } else if (msg == "List cameras") { CameraMan.ListCameras(); } else if (msg == "mute") { AudioMan.QueueMessage(new AMGlobal(AM_DISABLE_AUDIO)); // AudioMan.DisableAudio(); } else if (msg == "muteSFX") { AudioMan.QueueMessage(new AMGlobal(AM_MUTE_SFX)); } else if (msg == "CreateMainWindow") { // Creates the main application AppWindow. A message is sent upon startup from the initializer thread for this. if (!WindowMan.MainWindow()) { AppWindow * mainWindow = WindowMan.CreateMainWindow(); // Optionally set more user-related stuff to the options before creating it. // Then create it! mainWindow->Create(); /// Create default UI and globalUI that may later on be replaced as needed. mainWindow->CreateUI(); mainWindow->CreateGlobalUI(); mainWindow->backgroundColor = Vector4f(1,0,0,1); } // Reveal the main AppWindow to the user now that all managers are allocated. WindowMan.MainWindow()->Show(); } else if (msg == "HideWindows") { if (MainWindow()) { MainWindow()->Hide(); } } else if (msg == "DestroyMainWindow" || msg == "DeleteWindows" || msg == "DeleteMainWindow") { if (WindowMan.MainWindow()) { AppWindow * mainWindow = WindowMan.MainWindow(); mainWindow->Hide(); mainWindow->Destroy(); } } else if (msg.Contains("MaximizeWindow(")) { String windowName = msg.Tokenize("()")[1]; AppWindow * window = WindowMan.GetWindowByName(windowName); if (window) { if (!window->IsFullScreen()) window->ToggleFullScreen(); } } else if (msg.Contains("INTERPRET_CONSOLE_COMMAND(this)")) { String command = message->element->text; Message * newMes = new Message(MessageType::CONSOLE_COMMAND); newMes->msg = command; MesMan.QueueMessage(newMes); return; } else if (msg == "TogglePause(this)"){ UIElement * e = message->element; if (e->type != UIType::VIDEO) return; UIVideo * video = (UIVideo*) e; video->TogglePause(); } else if (msg.Contains("UIProceed(")) { String name = msg.Tokenize("()")[1]; UserInterface * ui = RelevantUI(); UIElement * e = ui->GetElementByName(name); if (!e) return; e->Proceed(); return; } else if (msg.Contains("UITextureInput(")) { String name = msg.Tokenize("()")[1]; UserInterface * ui = RelevantUI(); UIElement * e = ui->GetElementByName(name); if (e->type != UIType::TEXTURE_INPUT) return; UITextureInput * ti = (UITextureInput*) e; TextureMessage * m = new TextureMessage(ti->action, ti->GetTextureSource()); MesMan.QueueMessage(m); return; } else if (msg.Contains("UIStringInput(")) { /// Obsolete? /* String name = msg.Tokenize("()")[1]; UserInterface * ui = RelevantUI(); if (!ui) return; UIElement * e = ui->GetElementByName(name); if (e->type != UIType::STRING_INPUT) return; UIStringInput * si = (UIStringInput*)e; SetStringMessage * m = new SetStringMessage(si->action, si->GetValue()); MesMan.QueueMessage(m); */ return; } else if (msg.Contains("UIFloatInput(")) { String name = msg.Tokenize("()")[1]; UserInterface * ui = RelevantUI(); UIElement * e = ui->GetElementByName(name); if (e->type != UIType::FLOAT_INPUT) return; UIFloatInput * fi = (UIFloatInput*)e; FloatMessage * m = new FloatMessage(fi->action, fi->GetValue()); MesMan.QueueMessage(m); return; } else if (msg.Contains("UIIntegerInput(")) { String name = msg.Tokenize("()")[1]; UserInterface * ui = RelevantUI(); UIElement * e = ui->GetElementByName(name); if (e->type != UIType::INTEGER_INPUT) return; UIIntegerInput * ii = (UIIntegerInput*)e; IntegerMessage * m = new IntegerMessage(ii->action, ii->GetValue()); MesMan.QueueMessage(m); return; } else if (msg.Contains("UIVectorInput(")) { String name = msg.Tokenize("()")[1]; UserInterface * ui = RelevantUI(); UIElement * e = ui->GetElementByName(name); if (e->type != UIType::VECTOR_INPUT) return; UIVectorInput * vi = (UIVectorInput*)e; /// Fetch vector data from the input first. VectorMessage * m = NULL; switch(vi->numInputs) { case 2: m = new VectorMessage(vi->action, vi->GetValue2i()); break; case 3: m = new VectorMessage(vi->action, vi->GetValue3f()); break; case 4: m = new VectorMessage(vi->action, vi->GetValue4f()); break; default: assert(false && "implement"); break; } if (m) MesMan.QueueMessage(m); return; } else if (msg.Contains("setVisibility")) { List<String> params = msg.Tokenize("(),"); assert(params.Size() >= 2 && "Invalid amount of arguments to SetVisibility UI command!"); String uiName = params[1]; /// Check if the name-parameter is 'this' if (uiName == "this"){ // std::cout<<"\nElement with 'this' lacking name.. fix yo."; uiName = message->element->name; } bool visibility = params[2].ParseBool(); Graphics.QueueMessage(new GMSetUIb(uiName, GMUI::VISIBILITY, visibility)); return; } else if (msg.Contains("SetText(")){ List<String> params = msg.Tokenize("(),"); assert(params.Size() >= 2 && "Invalid amount of arguments to SetVisibility UI command!"); String uiName = params[1]; /// Check if the name-parameter is 'this' if (uiName == "this"){ // std::cout<<"\nElement with 'this' lacking name.. fix yo."; uiName = message->element->name; } String text = params[2]; text.Remove("\"", true); Graphics.QueueMessage(new GMSetUIs(uiName, GMUI::TEXT, text)); return; } else if (msg.Contains("CyclicUIY(")){ InputMan.cyclicY = msg.Tokenize("()")[1].ParseBool(); return; } else if (msg.Contains("Query(")){ // Create a new UI to place on top of it all! String uiName = msg; List<String> params = msg.Tokenize("(),"); assert(params.Size() >= 2); String action = params[1]; /// Create the dialogue UIQueryDialogue * dialog = new UIQueryDialogue(action, action); dialog->navigateUIOnPush = true; dialog->exitable = true; if (params.Size() >= 4){ dialog->headerText = params[2]; dialog->textToPresent = params[3]; } dialog->CreateChildren(); /// Add the dialogue to the global UI Graphics.QueueMessage(new GMAddGlobalUI(dialog, "root")); /// Push it to the top... should not be needed with the global ui. Graphics.QueueMessage(GMPushUI::ToUI(dialog, GlobalUI())); return; } else if (msg.Contains("SetFileBrowserDirectory(")) { List<String> params = msg.Tokenize(",()"); String uiName = params[1]; UIElement * ui = RelevantUI()->GetElementByName(uiName); if (!ui) return; assert(ui->type == UIType::FILE_BROWSER); UIFileBrowser * fb = (UIFileBrowser*)ui; String path = params[2]; if (path == "this") path = message->element->text; fb->SetPath(path, false); return; } else if (msg.Contains("UpdateFileBrowserDirectory(")) { List<String> params = msg.Tokenize(",()"); String uiName = params[1]; UIElement * ui = RelevantUI()->GetElementByName(uiName); if (!ui) return; assert(ui->type == UIType::FILE_BROWSER); UIFileBrowser * fb = (UIFileBrowser*)ui; String path = params[2]; if (path == "this") path = message->element->text; fb->UpdatePath(path, false); return; } else if (msg.Contains("EvaluateFileBrowserSelection(")) { List<String> params = msg.Tokenize("()"); String uiName = params[1]; UIElement * ui = RelevantUI()->GetElementByName(uiName); if (!ui) return; FileEvent * message = new FileEvent(); UIFileBrowser * fb = (UIFileBrowser*)ui; message->msg = fb->action; message->files = fb->GetFileSelection(); // Queue the new message. QueueMessage(message); return; } else if (msg.Contains("SetFileBrowserFile(")) { List<String> params = msg.Tokenize(",()"); String uiName = params[1]; UIElement * ui = RelevantUI()->GetElementByName(uiName); if (!ui) return; assert(ui->type == UIType::FILE_BROWSER); UIFileBrowser * fb = (UIFileBrowser*)ui; String file = params[2]; if (file == "this"){ file = message->element->text; } fb->SetActiveFile(file); return; } else if (msg.Contains("OpenFileBrowser(")){ /// Parse stuff List<String> params = msg.Tokenize("(),"); assert(params.Size() >= 3); String title = params[1]; title.Remove("\"", true); String action = params[2]; String filter; if (params.Size() >= 4){ filter = params[3]; filter.Remove("\"", true); } /// Create the browser. UIFileBrowser * fileBrowser = new UIFileBrowser(title, action, filter); fileBrowser->CreateChildren(); fileBrowser->LoadDirectory(false); /// Push it to the UI. UserInterface * ui = RelevantUI(); assert(ui); Graphics.QueueMessage(new GMAddUI(fileBrowser, "root", ui)); Graphics.QueueMessage(GMPushUI::ToUI(fileBrowser, ui)); return; } else if (msg.Contains("QuitApplication")) { StateMan.QueueState(StateMan.GetStateByID(GameStateID::GAME_STATE_EXIT)); return; } else if (msg.Contains("PushToStack(") || msg.Contains("PushUI(")){ // Fetch target. List<String> params = msg.Tokenize("(),"); assert(params.Size() >= 2 && "Invalid amount of arguments to PushToStack UI command!"); if (params.Size() < 2) { LogMain("Bad arguments in message: "+msg, ERROR); return; } PushUI(params[1]); return; } else if (msg.Contains("PopFromStack(") || msg.Contains("PopUI(")) { // std::cout<<"\nPopFromStack/PopUI received."; // Fetch target. List<String> params = msg.Tokenize("(),"); assert(params.Size() >= 2 && "Invalid amount of arguments to PopFromStack UI command!"); if (params.Size() < 2){ std::cout<<"\nToo few parameters."; return; } String uiName = params[1]; if (uiName == "this") uiName = message->element->name; PopUI(uiName); return; } else if (msg == "Back") { UserInterface * ui = RelevantUI(); UIElement * stackTop = ui->GetStackTop(); Graphics.QueueMessage(new GMPopUI(stackTop->name, ui)); return; } else if (msg.Contains("begin_input(") || msg.Contains("BeginInput(")) { String elementName = msg.Tokenize("()")[1]; UIElement * element; if (elementName == "this") element = message->element; else element = StateMan.ActiveState()->GetUI()->GetElementByName(elementName); if (!element) return; assert(element->demandInputFocus); ((UIInput*)element)->BeginInput(); return; /* UserInterface * ui = StateMan.ActiveState()->GetUI(); UIElement * element = message->element; if (!element){ std::cout<<"\nNo active element, fetching hover element."; element = ui->GetHoverElement(); } if (element != NULL){ // assert(element->onTrigger); if (!element->onTrigger) std::cout<<"\nBegnning input for element without onTrigger specified!"; InputMan.SetActiveUIInputElement(element); InputMan.EnterTextInputMode(element->onTrigger); } else assert(false && "NULL-element :<"); return; */ } else if (msg.Contains("Remove(") || msg.Contains("DeleteUI(")) { UserInterface * ui = StateMan.ActiveState()->GetUI(); UIElement * element; String uiName = msg.Tokenize("()")[1]; /// this-deletion if (uiName == "this"){ if (message->element) element = message->element; else element = ui->GetActiveElement(); } /// Named deletion else { element = ui->GetElementByName(uiName); } /// For all usual AI, the state is not active after activation, so just grab the one with the hover-state! if (element == NULL) element = ui->GetHoverElement(); assert(element); if (element == NULL){ std::cout<<"\nERRORRRR: Invalid hellelemend? No active hover element, yo.."; return; } Graphics.QueueMessage(new GMRemoveUI(element)); return; } else if (msg.Contains("ContinueEvent(")){ List<Script*> events, mapEvents; Map * map = MapMan.ActiveMap(); if (map) mapEvents = map->GetEvents(); List<Script*> moreEvents = ScriptMan.GetActiveEvents(); events += mapEvents + moreEvents; String targetEvent = msg.Tokenize("()")[1]; for (int i = 0; i < events.Size(); ++i){ Script * event = events[i]; if (event->name == targetEvent) event->lineFinished = true; } return; } else if (msg.Contains("ActivateDialogueAlternative(")){ List<Script*> events = MapMan.ActiveMap()->GetEvents(); List<Script*> moreEvents = ScriptMan.GetActiveEvents(); events += moreEvents; String argsString = msg.Tokenize("()")[1]; List<String> args = argsString.Tokenize(" ,"); String targetEvent = args[0]; String alternative = args[1]; assert(alternative); for (int i = 0; i < events.Size(); ++i){ Script * e = events[i]; if (e->name == targetEvent){ e->ContinueToAlternative(alternative); } } return; } break; } } // First send it to global state StateManager * stateMan = StateManager::Instance(); if (stateMan) { AppState * global = StateMan.GlobalState(); if (global) global->ProcessMessage(message); // Send it to the state for processing if (StateMan.ActiveState()) StateMan.ActiveState()->ProcessMessage(message); } }
void RendererThread::EmptyEventQueue() { QueueMessage(Message::MessageType::EmptyEventQueue); }
void RendererThread::QueueUpdate() { QueueMessage(Message::MessageType::Update); }
void RendererThread::Stop() { QueueMessage(Message::MessageType::Close); m_thread->wait(); }
// Queue a message void MenuSystem::QueueMessage(std::string title, std::string message) { QueueMessage(title, message, [](){}); }
void CsoundPerformanceThread::TogglePause() { QueueMessage(new CsPerfThreadMsg_TogglePause(this)); }
/*---------------------------------------------------------------------------------------------------------------------- Function: SspReadByte Description: Master mode only. Gets a single byte from the slave on the target SSP peripheral. Requires: - psSspPeripheral_ has been requested. - The chip select line of the SSP device should be asserted - Promises: - Creates a message with one SSP_DUMMY_BYTE at psSspPeripheral_->psTransmitBuffer that will be sent by the SSP application when it is available and thus clock in a received byte to the target receive buffer. - Returns the Token of the transmitted dummy message used to read data. */ u32 SspReadByte(SspPeripheralType* psSspPeripheral_) { return( QueueMessage(&psSspPeripheral_->psTransmitBuffer, 1, &SSP_au8Dummies[0]) ); } /* end SspReadByte() */
void CsoundPerformanceThread::Stop() { QueueMessage(new CsPerfThreadMsg_Stop(this)); }
void CsoundPerformanceThread::Play() { QueueMessage(new CsPerfThreadMsg_Play(this)); }
bool MessageManager::QueueMessage(int msg){ Message * m = new Message(msg); return QueueMessage(m); }