自学教程：C++ wxGetLocalTimeMillis函数代码示例

wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds){    wxMutexLocker locker(m_mutex);    wxLongLong startTime = wxGetLocalTimeMillis();    while ( m_count == 0 )    {        wxLongLong elapsed = wxGetLocalTimeMillis() - startTime;        long remainingTime = (long)milliseconds - (long)elapsed.GetLo();        if ( remainingTime <= 0 )        {            // timeout            return wxSEMA_TIMEOUT;        }        switch ( m_cond.WaitTimeout(remainingTime) )        {            case wxCOND_TIMEOUT:                return wxSEMA_TIMEOUT;            default:                return wxSEMA_MISC_ERROR;            case wxCOND_NO_ERROR:                ;        }    }    m_count--;    return wxSEMA_NO_ERROR;}

	/*****************************************************	**	**   AtlasLogicCountWorker   ---   Entry	**	******************************************************/	ExitCode Entry()	{		while ( sharedSection->doExit == false )		{			Sleep( COUNT_THREAD_SLEEP_MILLISEC );			if ( sharedSection->countHasOrder )			{#ifdef DEB_ATLAS_LOGIC				printf( "AtlasLogicCountWorker: location count started, filter /"%s/", country /"%s/", mode %d/n",					str2char( logic->filter ), str2char( logic->country ), logic->mode );				wxLongLong starttime = wxGetLocalTimeMillis();#endif				sharedSection->countHasOrder = false;				int c = dao->getMatchCount( logic->filter, logic->country, logic->mode );				if ( sharedSection->countHasOrder )				{					// new order arrived, filter conditions have changed meanwhile: do not write results					printf( "WARN: AtlasLogicCountWorker has new order before finishing request/n" );				}				else				{					mutex.Lock();					sharedSection->countHasNews = true;					sharedSection->count = c;					mutex.Unlock();#ifdef DEB_ATLAS_LOGIC					wxLongLong duration = wxGetLocalTimeMillis() - starttime;					printf( "AtlasLogicCountWorker: Location count finished, %d results in %ld millisec/n", c, duration.ToLong() );#endif				}			}		}		return 0;	}

intwxEpollDispatcher::DoPoll(epoll_event *events, int numEvents, int timeout) const{    // the code below relies on TIMEOUT_INFINITE being -1 so that we can pass    // timeout value directly to epoll_wait() which interprets -1 as meaning to    // wait forever and would need to be changed if the value of    // TIMEOUT_INFINITE ever changes    wxCOMPILE_TIME_ASSERT( TIMEOUT_INFINITE == -1, UpdateThisCode );    wxMilliClock_t timeEnd;    if ( timeout > 0 )        timeEnd = wxGetLocalTimeMillis();    int rc;    for ( ;; )    {        rc = epoll_wait(m_epollDescriptor, events, numEvents, timeout);        if ( rc != -1 || errno != EINTR )            break;        // we got interrupted, update the timeout and restart        if ( timeout > 0 )        {            timeout = wxMilliClockToLong(timeEnd - wxGetLocalTimeMillis());            if ( timeout < 0 )                return 0;        }    }    return rc;}

void ProfileFindInFilesCodeMode() {    printf("*******/n");    wxLongLong time = wxGetLocalTimeMillis();    t4p::DirectorySearchClass directorySearch;    t4p::SourceClass src;    src.RootDirectory.AssignDir(DirName);    src.SetIncludeWildcards(wxT("*.php"));    std::vector<t4p::SourceClass> sources;    sources.push_back(src);    if (directorySearch.Init(sources)) {        t4p::FindInFilesClass findInFiles;        findInFiles.Expression = UNICODE_STRING_SIMPLE("class Db");        findInFiles.Mode = t4p::FinderClass::EXACT;        if (findInFiles.Prepare()) {            while (directorySearch.More()) {                directorySearch.Walk(findInFiles);            }            std::vector<wxString> matchedFiles = directorySearch.GetMatchedFiles();            for (size_t i = 0; i < matchedFiles.size(); ++i) {                printf("Found at least one match in file %s./n", (const char*)matchedFiles[i].ToUTF8());            }            time = wxGetLocalTimeMillis() - time;            printf("time for findInFiles Code Mode:%ld ms/n", time.ToLong());        } else {            puts("Invalid expression: class Db/n");        }    } else {        printf("Could not open Directory: %s/n", (const char*)DirName.ToAscii());    }}

void ProfileFindInFilesExactMode() {    printf("*******/n");    wxLongLong time = wxGetLocalTimeMillis();    t4p::DirectorySearchClass directorySearch;    if (directorySearch.Init(DirName)) {        t4p::FindInFilesClass findInFiles;        findInFiles.Expression = UNICODE_STRING_SIMPLE("class Db");        findInFiles.Mode = t4p::FinderClass::EXACT;        if (findInFiles.Prepare()) {            while (directorySearch.More()) {                directorySearch.Walk(findInFiles);            }            std::vector<wxString> matchedFiles = directorySearch.GetMatchedFiles();            for (size_t i = 0; i < matchedFiles.size(); ++i) {                printf("Found at least one match in file %s./n", (const char*)matchedFiles[i].ToUTF8());            }            time = wxGetLocalTimeMillis() - time;            printf("time for findInFiles Exact Mode:%ld ms /n", time.ToLong());        } else {            puts("Invalid expression: class Db/n");        }    } else {        printf("Could not open Directory: %s/n", (const char*)DirName.ToAscii());    }}

/*********************************************************   Painter   ---   drawMString********************************************************/void Painter::drawMString( const MRect &r, MString &f, const int& align ){#ifdef SHOW_STOP_WATCH	static wxLongLong totaltime = 0;	const wxLongLong starttime = wxGetLocalTimeMillis();#endif	static int count = 0;	SheetFormatter sfmt;	wxString s;	if ( f.formattedLines.size() == 0 )	{		if ( ! f.isEmpty() && f.size.real() == 0 )		{			s = sfmt.fragment2PlainText( f );			//printf( "Painter::drawMString - old size %f %f/n", f.size.real(), f.size.imag());			f.size = getTextExtent( f );			printf( "Painter::drawMString - size not set #%d contents was %s, size now %f %f/n", count++, str2char( s ), f.size.real(), f.size.imag());		}		drawSingleMStringLine( r, f, align );		//return;	}	else	{		double y0 = r.y;		if ( align & Align::Top )		{			// nothing		}		else if ( align & Align::Bottom )		{			y0 = y0 + r.height - f.size.imag();		}		else // default: align & align::VCenter		{			y0 += .5 * ( r.height - f.size.imag());		}		MRect rect( r.x, y0, r.width, r.height );		int line = 0;		for( list<MString>::iterator iter = f.formattedLines.begin(); iter != f.formattedLines.end(); iter++ )		{			line++;			rect.height = iter->size.imag();			//printf( "  --->>> Line %d width %f h %f/n", line, iter->size.real(), iter->size.imag() );			drawSingleMStringLine( rect, *iter, align );			rect.y += rect.height;		}	}#ifdef SHOW_STOP_WATCH	const wxLongLong duration = wxGetLocalTimeMillis() - starttime;	totaltime += duration;	wxLogMessage( wxString::Format( wxT( "Painter::drawTextFormatted in %ld msec, total %ld" ), duration.ToLong(), totaltime.ToLong() ));#endif}

void GOrgueMidiRecorder::PreconfigureMapping(const wxString& element, bool isNRPN, const wxString& reference){	unsigned id = m_Map.GetElementByString(element);	unsigned ref = m_Map.GetElementByString(reference);	for(unsigned i = 0; i < m_Preconfig.size(); i++)		if (m_Preconfig[i].elementID == ref)		{			GOrgueMidiEvent e1;			e1.SetTime(wxGetLocalTimeMillis());			e1.SetMidiType(MIDI_SYSEX_GO_SETUP);			e1.SetKey(id);			e1.SetChannel(m_Preconfig[i].channel);			e1.SetValue(m_Preconfig[i].key);			SendEvent(e1);			midi_map m = m_Preconfig[i];			m.elementID = ref;			if (ref >= m_Mappings.size())				m_Mappings.resize(ref + 1);			m_Mappings[ref] = m;			return;		}	midi_map m;	if (isNRPN)	{		if (m_NextNRPN >= 1 << 18)			return;		m.elementID = ref;		m.channel = 1 + m_NextNRPN / (1 << 14);		m.key = m_NextNRPN % (1 << 14);		m_NextNRPN++;	}	else	{		if (m_NextChannel > 16)			return;		m.elementID = ref;		m.channel = m_NextChannel;		m.key = 0;		m_NextChannel++;	}	m_Preconfig.push_back(m);	GOrgueMidiEvent e1;	e1.SetTime(wxGetLocalTimeMillis());	e1.SetMidiType(MIDI_SYSEX_GO_SETUP);	e1.SetKey(id);	e1.SetChannel(m.channel);	e1.SetValue(m.key);	SendEvent(e1);	if (ref >= m_Mappings.size())		m_Mappings.resize(ref + 1);	m_Mappings[ref] = m;}

void Export_DLG::Step(const wxString& fname){	++pos;	if (next_update_tick < wxGetLocalTimeMillis().GetLo())	{		m_gauge1->SetValue(pos);		m_textCtrl1->SetLabel(fname);		next_update_tick = wxGetLocalTimeMillis().GetLo()+100;		wxGetApp().Yield();	}}

/*********************************************************   AtlasImporter   ---   Destructor********************************************************/AtlasImporter::~AtlasImporter(){	sharedSection->threadOrder = THREADORDER_EXIT;	if ( importWorker->IsRunning())	{		printf( "AtlasImportDialog destructor waiting for import worker to join .../n" );		wxLongLong starttime = wxGetLocalTimeMillis();		importWorker->Wait();		wxLongLong duration = wxGetLocalTimeMillis() - starttime;		printf( "Import worker stopped in %ld milllisec/n", duration.ToLong());	}	delete importWorker;	delete sharedSection;}

 FlyTool::FlyTool(View::DocumentViewHolder& documentViewHolder, InputController& inputController) : Tool(documentViewHolder, inputController, false) {     for (MoveKey::Type i = 0; i < 4; i++)         m_moveKeys[i] = 0;     m_lastUpdateTime = wxGetLocalTimeMillis();     Start(1000 / 60); }

void ThreadList::updateThreads(const ProcessInfo* processInfo, SymbolInfo *symInfo){	this->selected_threads.clear();	DeleteAllItems();	this->threads.clear();	ok_button->Enable(false);	all_button->Enable(false);	if(processInfo != NULL)	{		this->process_handle = processInfo->getProcessHandle();		this->syminfo = symInfo;		this->threads = processInfo->threads;		int numDisplayedThreads = getNumDisplayedThreads();		for(int i=0; i<numDisplayedThreads; ++i)		{			long tmp = this->InsertItem(i, "", -1);			SetItemData(tmp, i);		}		all_button->Enable(this->threads.size() != 0);		lastTime = wxGetLocalTimeMillis();		updateTimes();		updateSorting();		fillList();	}}

void EDA_DRAW_PANEL_GAL::onPaint( wxPaintEvent& WXUNUSED( aEvent ) ){    m_pendingRefresh = false;    m_lastRefresh = wxGetLocalTimeMillis();    if( !m_drawing )    {        m_drawing = true;        m_view->UpdateItems();        m_gal->BeginDrawing();        m_gal->ClearScreen( m_painter->GetSettings()->GetBackgroundColor() );        if( m_view->IsDirty() )        {            m_view->ClearTargets();            // Grid has to be redrawn only when the NONCACHED target is redrawn            if( m_view->IsTargetDirty( KIGFX::TARGET_NONCACHED ) )                m_gal->DrawGrid();            m_view->Redraw();        }        m_gal->DrawCursor( m_viewControls->GetCursorPosition() );        m_gal->EndDrawing();        m_drawing = false;    }}

ThreadList::ThreadList(wxWindow *parent, const wxPoint& pos,						 const wxSize& size, wxButton *_ok_button, wxButton *_all_button)						 :	wxSortedListCtrl(parent, THREADS_LIST, pos, size, wxLC_REPORT),						 timer(this, THREADS_LIST_TIMER),						 ok_button(_ok_button), all_button(_all_button){	InitSort();	wxListItem itemCol;	itemCol.m_mask = wxLIST_MASK_TEXT/* | wxLIST_MASK_IMAGE*/;	itemCol.m_text = _T("Thread");	itemCol.m_image = -1;	InsertColumn(COL_ID, itemCol);	itemCol.m_text = _T("Location");	InsertColumn(COL_LOCATION, itemCol);	itemCol.m_text = _T("Thread Usage");	InsertColumn(COL_CPUUSAGE, itemCol);	SetColumnWidth(COL_ID, 50);	SetColumnWidth(COL_LOCATION, 200);	SetColumnWidth(COL_CPUUSAGE, 120);	sort_column = COL_CPUUSAGE;	sort_dir = SORT_DOWN;	SetSortImage(sort_column, sort_dir); 	process_handle = NULL;	syminfo = NULL;	lastTime = wxGetLocalTimeMillis();	updateThreads(NULL, NULL);	timer.Start(UPDATE_DELAY);}

wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds){    wxLongLong curtime = wxGetLocalTimeMillis();    curtime += milliseconds;    wxLongLong temp = curtime / 1000;    int sec = temp.GetLo();    temp *= 1000;    temp = curtime - temp;    int millis = temp.GetLo();    timespec tspec;    tspec.tv_sec = sec;    tspec.tv_nsec = millis * 1000L * 1000L;    int err = pthread_cond_timedwait( &m_cond, GetPMutex(), &tspec );    switch ( err )    {        case ETIMEDOUT:            return wxCOND_TIMEOUT;        case 0:            return wxCOND_NO_ERROR;        default:            wxLogApiError(_T("pthread_cond_timedwait()"), err);    }    return wxCOND_MISC_ERROR;}

	void VolumeCreationProgressWizardPage::SetProgressState (bool volumeCreatorRunning)	{		if (volumeCreatorRunning)			StartTime = wxGetLocalTimeMillis();		VolumeCreatorRunning = volumeCreatorRunning;	}

	void VolumeCreationProgressWizardPage::SetProgressValue (uint64 value)	{		int gaugeValue = static_cast <int> (value * RealProgressBarRange / ProgressBarRange);		if (value == ProgressBarRange)			gaugeValue = RealProgressBarRange; // Prevent round-off error		if (gaugeValue != PreviousGaugeValue)		{			ProgressGauge->SetValue (gaugeValue);			PreviousGaugeValue = gaugeValue;		}		if (value != 0)		{			SizeDoneStaticText->SetLabel (wxString::Format (L"%7.3f%%", 100.0 - double (ProgressBarRange - value) / (double (ProgressBarRange) / 100.0)));			wxLongLong timeDiff = wxGetLocalTimeMillis() - StartTime;			if (timeDiff.GetValue() > 0)			{				uint64 speed = value * 1000 / timeDiff.GetValue();				if (ProgressBarRange != value)					SpeedStaticText->SetLabel (Gui->SpeedToString (speed));				TimeLeftStaticText->SetLabel (speed > 0 ? Gui->TimeSpanToString ((ProgressBarRange - value) / speed) : L"");			}		}		else		{			SizeDoneStaticText->SetLabel (L"");			SpeedStaticText->SetLabel (L"");			TimeLeftStaticText->SetLabel (L"");		}	}

wxCondError BOINC_Condition::WaitTimeout(unsigned long milliseconds) {    int err;    wxLongLong curtime = wxGetLocalTimeMillis();    curtime += milliseconds;    wxLongLong temp = curtime / 1000;    int sec = temp.GetLo();    temp *= 1000;    temp = curtime - temp;    int millis = temp.GetLo();    timespec tspec;    tspec.tv_sec = sec;    tspec.tv_nsec = millis * 1000L * 1000L;        err = pthread_cond_timedwait(&m_cond, &m_BOINC_Mutex.m_mutex, &tspec);    switch (err) {    case 0:        return wxCOND_NO_ERROR;    case EINVAL:        return wxCOND_INVALID;    case ETIMEDOUT:        return wxCOND_TIMEOUT;    default:        return wxCOND_MISC_ERROR;    }    return wxCOND_NO_ERROR;}

bool GOrgueMidiRecorder::SetupMapping(unsigned element, bool isNRPN){	if (element >= m_Mappings.size())		m_Mappings.resize(element + 1);	if (element != m_Mappings[element].elementID)	{		if (isNRPN)		{			if (m_NextNRPN >= 1 << 18)				return false;			m_Mappings[element].elementID = element;			m_Mappings[element].channel = 1 + m_NextNRPN / (1 << 14);			m_Mappings[element].key = m_NextNRPN % (1 << 14);			m_NextNRPN++;		}		else		{			if (m_NextChannel > 16)				return false;			m_Mappings[element].elementID = element;			m_Mappings[element].channel = m_NextChannel;			m_Mappings[element].key = 0;			m_NextChannel++;		}		GOrgueMidiEvent e1;		e1.SetTime(wxGetLocalTimeMillis());		e1.SetMidiType(MIDI_SYSEX_GO_SETUP);		e1.SetKey(m_Mappings[element].elementID);		e1.SetChannel(m_Mappings[element].channel);		e1.SetValue(m_Mappings[element].key);		SendEvent(e1);	}	return true;}

void EDA_DRAW_PANEL_GAL::Refresh( bool aEraseBackground, const wxRect* aRect ){    if( m_pendingRefresh )        return;    m_pendingRefresh = true;#ifdef __WXMAC__    // Timers on OS X may have a high latency (seen up to 500ms and more) which    // makes repaints jerky. No negative impact seen without throttling, so just    // do an unconditional refresh for OS X.    ForceRefresh();#else    wxLongLong t = wxGetLocalTimeMillis();    wxLongLong delta = t - m_lastRefresh;    if( delta >= MinRefreshPeriod )    {        ForceRefresh();    }    else    {        // One shot timer        m_refreshTimer.Start( ( MinRefreshPeriod - delta ).ToLong(), true );    }#endif}

void DisassemblyTextCtrl::OnGetFocus(wxFocusEvent& event){    // store timestamp for use in cbEditor::GetControl()    // don't use event.GetTimeStamp(), because the focus event has no timestamp !    m_lastFocusTime = wxGetLocalTimeMillis();    event.Skip();} // end of OnGetFocus

VSTEffect::VSTEffect(const wxString & path):  mPath(path){   mModule = NULL;   mAEffect = NULL;   mInBuffer = NULL;   mOutBuffer = NULL;   mInputs = 0;   mOutputs = 0;   mChannels = 0;   mBlockSize = 0;   memset(&mTimeInfo, 0, sizeof(mTimeInfo));   mTimeInfo.samplePos = 0.0;   mTimeInfo.sampleRate = 44100.0;   mTimeInfo.nanoSeconds = wxGetLocalTimeMillis().ToDouble();   mTimeInfo.tempo = 120.0;   mTimeInfo.timeSigNumerator = 4;   mTimeInfo.timeSigDenominator = 4;   mTimeInfo.flags = kVstTempoValid | kVstNanosValid;   PluginManager & pm = PluginManager::Get();   if (pm.IsRegistered(VSTPLUGINTYPE, mPath)) {      mName = pm.Read(wxT("Name"), wxEmptyString);      mVendor = pm.Read(wxT("Vendor"), wxEmptyString);      mInputs = pm.Read(wxT("Inputs"), 0L);      mOutputs = pm.Read(wxT("Outputs"), 0L);   }   else if (Load()) {      pm.RegisterPlugin(VSTPLUGINTYPE, mPath);      pm.Write(wxT("Name"), mName);      pm.Write(wxT("Vendor"), mVendor);      pm.Write(wxT("Inputs"), mInputs);      pm.Write(wxT("Outputs"), mOutputs);   }   if (mVendor.IsEmpty()) {      mVendor = VSTPLUGINTYPE;   }   if (mName.IsEmpty()) {      wxFileName fn(mPath);      mName = fn.GetName();   }   int flags = PLUGIN_EFFECT;   if (mInputs == 0) {      flags |= INSERT_EFFECT;   }   else if (mOutputs == 0) {      flags |= ANALYZE_EFFECT;   }   else {      flags |= PROCESS_EFFECT;   }   SetEffectFlags(flags);}

void VNCCanvas::onUpdateTimer(wxTimerEvent& event){#ifdef __WXDEBUG__  wxLongLong t0 = wxGetLocalTimeMillis();  size_t nr_rects = 0;  size_t nr_bytes = 0;#endif    wxClientDC dc(this);    // get the update rect list  wxRegionIterator upd(updated_area);   while(upd)    {      wxRect update_rect(upd.GetRect());           wxLogDebug(wxT("VNCCanvas %p: drawing updated rect: (%i,%i,%i,%i)"),		 this,		 update_rect.x,		 update_rect.y,		 update_rect.width,		 update_rect.height);#ifdef __WXDEBUG__            ++nr_rects;      nr_bytes += update_rect.width * update_rect.height;#endif      const wxBitmap& region = conn->getFrameBufferRegion(update_rect);      if(region.IsOk())	dc.DrawBitmap(region, update_rect.x, update_rect.y);	      ++upd;    }  updated_area.Clear();#ifdef __WXDEBUG__  wxLongLong t1 = wxGetLocalTimeMillis();  wxLogDebug(wxT("VNCCanvas %p: updating %zu rects (%zu bytes) took %lld ms"),	     this,	     nr_rects,	     nr_bytes,	     (t1-t0).GetValue());#endif}

void StopWatch::Resume() {    if (!m_paused) {        return;    }    m_sliceStart = wxGetLocalTimeMillis().GetValue();    m_paused = false;}

// Returns elapsed time in millisecondslong wxGetElapsedTime(bool resetTimer){    wxLongLong oldTime = wxStartTime;    wxLongLong newTime = wxGetLocalTimeMillis();    if ( resetTimer )        wxStartTime = newTime;    return (newTime - oldTime).GetLo();}

void GOrgueMidiRecorder::SetSamplesetId(unsigned id1, unsigned id2){	GOrgueMidiEvent e1;	e1.SetTime(wxGetLocalTimeMillis());	e1.SetMidiType(MIDI_SYSEX_GO_SAMPLESET);	e1.SetKey(id1);	e1.SetValue(id2);	SendEvent(e1);	m_Mappings.clear();}

void CShape::Init(){	m_creation_time = wxGetLocalTimeMillis();	m_faces = new CFaceList;	m_edges = new CEdgeList;	m_vertices = new CVertexList;	Add(m_faces, NULL);	Add(m_edges, NULL);	Add(m_vertices, NULL);	create_faces_and_edges();}

long wxStopWatch::GetElapsedTime() const{#if 0//__WXMSW__    if (m_frequency == 0)    {        return (wxGetLocalTimeMillis() - m_t0).GetLo();    }    else    {        LARGE_INTEGER counter_li;        ::QueryPerformanceCounter( &counter_li );        wxLongLong counter = counter_li.QuadPart;        wxLongLong res = (counter * 10000 / m_frequency) - m_t0;        return res.GetLo() / 10;    }#else    return (wxGetLocalTimeMillis() - m_t0).GetLo();#endif}

/*********************************************************   SheetWidget   ---   doPaint********************************************************/void SheetWidget::doPaint( const wxRect &rect, const bool eraseBackground ){#ifdef SCROLLABLE_PAGE_WIDGET_SHOW_STOP_WATCH	const wxLongLong starttime = wxGetLocalTimeMillis();#endif	// may have changed	writer->setSheetConfig( getSheetConfig() );		assert( painter );	painter->writercfg = sheet->writercfg;	painter->colorcfg = colorcfg;	//printf( "RECT x %d y %d w %d h %d/n", rect.x, rect.y, rect.width, rect.height );	MRect therect( rect );	//printf( "SheetWidget::doPaint xviewport %d yviewport %d erase = %d DIRTY %d/n", xviewport, yviewport, eraseBackground, dirty );	// dirty ist okay. kommt bei echten Updates und Resize. nicht bei Scroll, mouse over usw.	if ( dirty )	{		init();		calculateContentSize();		initViewPort();		dirty = false;	}	painter->setBrush( config->colors->bgColor );	painter->setTransparentPen();	painter->drawRectangle( rect );	painter->setTransparentPen();	writer->drawSheet( painter, therect, eraseBackground );#ifdef SCROLLABLE_PAGE_WIDGET_SHOW_STOP_WATCH	const wxLongLong totaltime = wxGetLocalTimeMillis() - starttime;	wxLogMessage( wxString::Format( wxT( "SheetWidget::doPaint in %ld millisec eraseBackground %d" ),		totaltime.ToLong(), eraseBackground ));#endif}

void GOrgueMidiRecorder::Clear(){	m_Mappings.clear();	m_Preconfig.clear();	m_NextChannel = 1;	m_NextNRPN = 0;	GOrgueMidiEvent e;	e.SetMidiType(MIDI_SYSEX_GO_CLEAR);	e.SetTime(wxGetLocalTimeMillis());	SendEvent(e);}