static void StartAudioDMAAndRequestBuffers() {
// Configure DMA stream.
DMA1_Stream5 ->CR = /*(0 * DMA_SxCR_CHSEL_0 )*/0x0E000000 | // Channel 7
(1 * DMA_SxCR_PL_0 ) | // Priority 1
(1 * DMA_SxCR_PSIZE_0 ) | // PSIZE = 16 bit
(1 * DMA_SxCR_MSIZE ) | // MSIZE = 16 bit
DMA_SxCR_MINC | // Increase memory address
(1 * DMA_SxCR_DIR_0 ) | // Memory to peripheral
DMA_SxCR_TCIE; // Transfer complete interrupt
DMA1_Stream5 ->NDTR = NextBufferLength >> 1;
DMA1_Stream5 ->PAR = (uint32_t) &DAC->DHR12R1;
DMA1_Stream5 ->M0AR = (uint32_t) NextBufferSamples;
DMA1_Stream5 ->FCR = DMA_SxFCR_DMDIS;
DMA1_Stream5 ->CR |= DMA_SxCR_EN;
//TIM_Cmd(TIM6, DISABLE);
DAC_Cmd(DAC_Channel_1, ENABLE);
DAC_DMACmd(DAC_Channel_1, ENABLE); //DMAEN1
TIM_Cmd(TIM6, ENABLE);
// Update state.
NextBufferSamples = NULL;
BufferNumber ^= 1;
DMARunning = true;
// Invoke callback if it exists to queue up another buffer.
if (CallbackFunction)
CallbackFunction(CallbackContext, BufferNumber);
}
//------------------------------------------------------------------------------
int32 CGUIWidget::OnEventUpdate(CGUIEventNotification* pEvent )
{
//call callback function
CallbackFunction("OnUpdate", pEvent);
return 0;
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnTimer( CGUIEventTimer* pEvent )
{
//call callback function
CallbackFunction("OnTimer", pEvent);
return 0;
}
bool
CallbackInstruction::DoTick ()
{
/* Initialize variable that states: the job is not done yet (further
ticks need to be made) */
bool done = false;
/* Fire event if required */
if (TimeToNextEvent == 0)
{
/* Check, whether it is a recurring event */
if (ResetValue)
/* If so: reload counter variable */
TimeToNextEvent = ResetValue;
else
/* Otherwise: the job is done after this call */
done = true;
/* Fire event */
CallbackFunction ();
}
/* Count down (the value can not be zero right now). Even freshly reset
counters must be decremented, as they shall fire e.g. at the next
DoTick call in case that they had a reload value of 1 */
TimeToNextEvent--;
/* Indicate whether the job is finished (and can be removed) */
return done;
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnMouseMove( CGUIEventMouse* pEvent )
{
// WIDGET_EVENT_TRACE("OnMouseMove");
//call callback function
CallbackFunction("OnMouseMove", pEvent);
return 0;
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnUnchecked( CGUIEventNotification* pEvent )
{
WIDGET_EVENT_TRACE("OnUnchecked");
//call callback function
CallbackFunction("OnUnchecked", pEvent);
return 0;
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnListBoxSelectChanged( CGUIEventListBox* pEvent )
{
WIDGET_EVENT_TRACE("OnListBoxSelecteChanged");
//call callback function
CallbackFunction("OnListBoxSelecteChanged", pEvent);
return 0;
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnScrollbarScroll( CGUIEventScrollbar* pEvent )
{
//WIDGET_EVENT_TRACE("OnScrollbarScroll");
//call callback function
CallbackFunction("OnScrollbarScroll", pEvent);
return 0;
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnListBoxRightClick( CGUIEventListBox* pEvent )
{
WIDGET_EVENT_TRACE("OnListBoxRightClick");
//call callback function
CallbackFunction("OnListBoxRightClick", pEvent);
return 0;
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnComboBoxSelected(CGUIEventComboBox* pEvent)
{
WIDGET_EVENT_TRACE("OnComboBoxSelected");
//call callback function
CallbackFunction("OnComboBoxSelected", pEvent);
return 0;
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnEventOpen( CGUIEventNotification* pEvent )
{
WIDGET_EVENT_TRACE("OnEventOpen");
//call callback function
CallbackFunction("OnOpen", pEvent);
return 0;
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnUIEvent(CGUIEventUI* pEvent)
{
WIDGET_EVENT_TRACE("OnUIEvent");
//call callback function
CallbackFunction("OnUIEvent", pEvent);
return 0;
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnParentChanged( CGUIEventRelativeChange* pEvent )
{
WIDGET_EVENT_TRACE("OnParentChanged");
//call callback function
CallbackFunction("OnParentChanged", pEvent);
return 0;
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnPageGetFocus( CGUIEventNotification* pEvent )
{
WIDGET_EVENT_TRACE("OnPageGetFocus");
//call callback function
CallbackFunction("OnPageGetFocus", pEvent);
return 0;
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnAlphaChange( CGUIEventAlpha* pEvent )
{
//WIDGET_EVENT_TRACE("OnAlphaChange");
//call callback function
CallbackFunction("OnAlphaChange", pEvent);
return 0;
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnKeyClicked( CGUIEventKeyboard* pEvent )
{
WIDGET_EVENT_TRACE("OnKeyClicked");
//call callback function
CallbackFunction("OnKeyClicked", pEvent);
return 0;
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnChildSizeChange( CGUIEventSize* pEvent )
{
//WIDGET_EVENT_TRACE("OnChildSizeChange");
//call callback function
CallbackFunction("OnChildSizeChange", pEvent);
return 0;
}
void PlayAudioWithCallback(AudioCallbackFunction *callback, void *context) {
StopAudioDMA();
CallbackFunction = callback;
CallbackContext = context;
BufferNumber = 0;
if (CallbackFunction)
CallbackFunction(CallbackContext, BufferNumber);
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnEnable( CGUIEventNotification* pEvent )
{
WIDGET_EVENT_TRACE("OnEnable");
m_aParamDisable.SetSelfValue(true);
//call callback function
CallbackFunction("OnEnable", pEvent);
return 0;
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnDragEnd( CGUIEventDrag* pEvent )
{
WIDGET_EVENT_TRACE("OnDragEnd");
//call callback function
CallbackFunction("OnDragEnd", pEvent);
if( IsMouseConsumed())
{
pEvent->Consume( true );
}
return 0;
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnMouseWheel( CGUIEventMouse* pEvent )
{
WIDGET_EVENT_TRACE("OnMouseWheel");
//call callback function
CallbackFunction("OnMouseWheel", pEvent);
if( IsMouseConsumed())
{
pEvent->Consume( true );
}
return 0;
}
Script* ScriptTarget::addScript(const char* path)
{
ScriptController* sc = Game::getInstance()->getScriptController();
// Load the script
Script* script = sc->loadScript(path, Script::PROTECTED);
if (!script)
return NULL;
// Attach the script
ScriptEntry* se = new ScriptEntry(script);
if (_scripts)
{
ScriptEntry* last = _scripts;
while (last->next)
last = last->next;
last->next = se;
se->prev = last;
}
else
{
_scripts = se;
}
// Inspect the loaded script for event functions that are supported by this ScriptTarget.
// TODO: We'll need to re-load eventCallbacks when EventRegistries change for this ScriptObject.
RegistryEntry* re = _scriptRegistries;
while (re)
{
std::vector<Event*>& events = re->registry->_events;
for (size_t i = 0, count = events.size(); i < count; ++i)
{
const Event* event = events[i];
if (sc->functionExists(event->name.c_str(), script))
{
if (!_scriptCallbacks)
_scriptCallbacks = new std::map<const Event*, std::vector<CallbackFunction>>();
(*_scriptCallbacks)[event].push_back(CallbackFunction(script, event->name.c_str()));
}
}
re = re->next;
}
// Automatically call the 'attached' event if it is defined within the script
if (sc->functionExists("attached", script))
{
sc->executeFunction<void>(script, "attached", "<ScriptTarget>", NULL, (void*)this);
}
return script;
}
void IntervalInfo::Execute() {
PyThreadState *oldThreadState = PyThreadState_Get();
PyThreadState_Swap(ThreadState);
try {
CallbackFunction();
}
catch(const py::error_already_set &) {
PyErr_Print();
}
PyThreadState_Swap(oldThreadState);
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnEventClose( CGUIEventNotification* pEvent )
{
WIDGET_EVENT_TRACE("OnEventClose");
//call callback function
CallbackFunction("OnClose", pEvent);
if( IsFocus())
{
GSystem->SetFocusWidget(NULL);
}
return 0;
}
void PlayAudioWithCallback(AudioCallbackFunction *callback, void *context) {
StopAudioDMA();
NVIC_EnableIRQ(DMA1_Stream7_IRQn);
NVIC_SetPriority(DMA1_Stream7_IRQn, 4);
SPI3 ->CR2 |= SPI_CR2_TXDMAEN; // Enable I2S TX DMA request.
CallbackFunction = callback;
CallbackContext = context;
BufferNumber = 0;
if (CallbackFunction)
CallbackFunction(CallbackContext, BufferNumber);
}
void PlayAudioWithCallback(AudioCallbackFunction *callback,void *context)
{
StopAudioDMA();
InstallInterruptHandler(DMA1_Stream7_IRQn,DMACompleteHandler);
EnableInterrupt(DMA1_Stream7_IRQn);
SetInterruptPriority(DMA1_Stream7_IRQn,4);
SPI3->CR2|=SPI_CR2_TXDMAEN; // Enable I2S TX DMA request.
CallbackFunction=callback;
CallbackContext=context;
BufferNumber=0;
if(CallbackFunction) CallbackFunction(CallbackContext,BufferNumber);
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnDragProcess( CGUIEventDrag* pEvent )
{
//call callback function
CallbackFunction("OnDragProcess", pEvent);
if( pEvent->IsExpired() == false)
{
SetPixelPosition(pEvent->GetWidgetLocalPos());
Refresh();
}
if( IsMouseConsumed())
{
pEvent->Consume( true );
}
return 0;
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnActive( CGUIEventNotification* pEvent )
{
WIDGET_EVENT_TRACE("OnActive");
//call callback function
CallbackFunction("OnActive", pEvent);
//set active
CGUIWidget* pThis = this;
CGUIWidget* pParent = pThis->GetParent();
while( pThis && pParent )
{
if( pThis->IsActivable())
{
pThis->MoveToTop();
}
pThis = pParent;
pParent = pThis->GetParent();
}
return 0;
}
//------------------------------------------------------------------------------
uint32 CGUIWidget::OnSizeChanged( CGUIEventSize* pEvent )
{
//WIDGET_EVENT_TRACE("OnSizeChanged");
//call callback function
CallbackFunction("OnSizeChanged", pEvent);
//send parent's change event to child
if( IsGenerateParentSizeChangeEvent() )
{
CGUIWidget* pWidget = GetChild();
while( pWidget )
{
if( pWidget->IsOpen() )
{
CGUIEventSize aEvent;
aEvent.SetEventId(eEVENT_PARENT_SIZE_CHANGE);
aEvent.SetSize(pEvent->GetSize());
aEvent.SetReceiver(pWidget);
GSystem->SendEvent( &aEvent );
}
pWidget = pWidget->GetNextSibling();
}
}
if( IsGenerateChildSizeChangeEvent() )
{
if( GetParent() && GetParent()->IsOpen() )
{
CGUIEventSize aEvent;
aEvent.SetEventId(eEVENT_CHILD_SIZE_CHANGE);
aEvent.SetSize(pEvent->GetSize());
aEvent.SetReceiver(GetParent());
GSystem->SendEvent( &aEvent );
}
}
return 0;
}
static void StartAudioDMAAndRequestBuffers() {
// Configure DMA stream.
DMA1_Stream7 ->CR = (0 * DMA_SxCR_CHSEL_0 ) | // Channel 0
(1 * DMA_SxCR_PL_0 ) | // Priority 1
(1 * DMA_SxCR_PSIZE_0 ) | // PSIZE = 16 bit
(1 * DMA_SxCR_MSIZE_0 ) | // MSIZE = 16 bit
DMA_SxCR_MINC | // Increase memory address
(1 * DMA_SxCR_DIR_0 ) | // Memory to peripheral
DMA_SxCR_TCIE; // Transfer complete interrupt
DMA1_Stream7 ->NDTR = NextBufferLength;
DMA1_Stream7 ->PAR = (uint32_t) &SPI3 ->DR;
DMA1_Stream7 ->M0AR = (uint32_t) NextBufferSamples;
DMA1_Stream7 ->FCR = DMA_SxFCR_DMDIS;
DMA1_Stream7 ->CR |= DMA_SxCR_EN;
// Update state.
NextBufferSamples = NULL;
BufferNumber ^= 1;
DMARunning = true;
// Invoke callback if it exists to queue up another buffer.
if (CallbackFunction)
CallbackFunction(CallbackContext, BufferNumber);
}
