void TorusObject::SetGenUVW(BOOL sw) {
if (sw==HasUVW()) return;
pblock->SetValue(PB_GENUVS,0, sw);
UpdateUI();
}
// Define my frame constructor
MyFrame::MyFrame(wxFrame *frame, const wxString& title)
: wxFrame(frame, wxID_ANY, title, wxDefaultPosition, wxSize(400, 300))
{
#if wxUSE_STATUSBAR
CreateStatusBar();
#endif // wxUSE_STATUSBAR
SetIcon(wxICON(sample));
m_server = NULL;
wxPanel * const panel = new wxPanel(this);
wxBoxSizer * const sizerMain = new wxBoxSizer( wxVERTICAL );
wxFlexGridSizer * const sizerCmds = new wxFlexGridSizer( 2, 0, 0 );
sizerCmds->AddGrowableCol( 1 );
wxButton *btn;
btn = new wxButton(panel, ID_START, "&Start Server");
sizerCmds->Add(btn, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5);
const wxString choices[] = { IPC_SERVICE, "..." };
wxChoice * const choice = new wxChoice
(
panel,
ID_SERVERNAME,
wxDefaultPosition, wxSize(100, -1),
WXSIZEOF(choices), choices
);
sizerCmds->Add(choice, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5);
btn = new wxButton(panel, ID_DISCONNECT, "&Disconnect Client");
sizerCmds->Add(btn, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5);
sizerCmds->AddSpacer(20);
btn = new wxButton( panel, ID_ADVISE, "&Advise");
sizerCmds->Add(btn, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5);
sizerCmds->AddSpacer(20);
sizerMain->Add(sizerCmds, wxSizerFlags().Expand().Border(wxALL, 5));
wxStaticBoxSizer * const
sizerLog = new wxStaticBoxSizer(wxVERTICAL, panel, "Server &log");
wxTextCtrl * const textLog = new wxTextCtrl
(
panel,
wxID_ANY,
"",
wxDefaultPosition, wxSize(500, 140),
wxTE_MULTILINE
);
sizerLog->Add(textLog, wxSizerFlags(1).Expand().Border(wxALL, 5));
sizerMain->Add(sizerLog, wxSizerFlags(1).Expand().Border(wxALL, 5));
panel->SetSizer(sizerMain);
sizerMain->SetSizeHints(panel);
SetClientSize(panel->GetSize());
GetServername()->SetSelection(0);
wxLogTextCtrl *logWindow = new wxLogTextCtrl(textLog);
delete wxLog::SetActiveTarget(logWindow);
wxLogMessage("Click on Start to start the server");
UpdateUI();
}
void EffectDtmf::OnDuration(wxCommandEvent & WXUNUSED(evt))
{
SetDuration(mDtmfDurationT->GetValue());
Recalculate();
UpdateUI();
}
void CCElection::DoIncVoteComplete( void )
{
UpdateUI();
}
// OnMenu handles all events which don't have their own event handler
void LifeFrame::OnMenu(wxCommandEvent& event)
{
switch (event.GetId())
{
case wxID_NEW:
{
// stop if it was running
OnStop();
m_life->Clear();
m_canvas->Recenter(0, 0);
m_tics = 0;
UpdateInfoText();
break;
}
case wxID_ABOUT:
{
LifeAboutDialog dialog(this);
dialog.ShowModal();
break;
}
case wxID_EXIT:
{
// true is to force the frame to close
Close(true);
break;
}
case ID_SHOWNAV:
{
bool checked = GetMenuBar()->GetMenu(1)->IsChecked(ID_SHOWNAV);
if (m_navigator)
m_navigator->Show(checked);
break;
}
case ID_INFO:
{
wxString desc = m_life->GetDescription();
if ( desc.empty() )
desc = _("Not available");
// should we make the description editable here?
wxMessageBox(desc, _("Description"), wxOK | wxICON_INFORMATION);
break;
}
case ID_START : OnStart(); break;
case ID_STEP : OnStep(); break;
case wxID_STOP : OnStop(); break;
case ID_TOPSPEED:
{
m_running = true;
m_topspeed = true;
UpdateUI();
while (m_running && m_topspeed)
{
OnStep();
wxYield();
}
break;
}
}
}
void CManageTagsDlg::OnLbnSelchangeManageTagsList()
{
UpdateUI();
}
void CCElection::DoAddDepositComplete( u_long idPlayer, __int64 iDeposit, time_t tCreate )
{
if(g_WndMng.m_pWndLordTender) g_WndMng.m_pWndLordTender->RefreshDeposit();
UpdateUI();
}
void CJobControlDlg::UpdateList()
{
m_List.SetItemCountEx(GetJobCount(), 0); // invalidate all items
UpdateUI();
}
void CJobControlDlg::SetStatus(int JobIdx, int Status)
{
m_Job.m_Info[JobIdx].m_Status = Status;
m_List.Update(JobIdx);
UpdateUI();
}
bool CMusikPlayer::Play( size_t nItem, int nStartPos, int nFadeType )
{
if((m_bSuppressAutomaticSongPicking == false)
&& (m_Playlist.GetCount() < (size_t)wxGetApp().Prefs.nAutoDJChooseSongsToPlayInAdvance)
&& ( MUSIK_PLAYMODE_AUTO_DJ == m_Playmode || MUSIK_PLAYMODE_AUTO_DJ_ALBUM == m_Playmode)
)
{
if(m_Playlist.GetCount() == 0)
nItem = 0;
_AddRandomSongs();
if(m_Playlist.GetCount() == 0) // no songs could be chosen
{
m_Playing = false;
return false;
}
}
m_bSuppressAutomaticSongPicking = false;
//--- check for an invalid playlist ---//
if ( ( nItem >= m_Playlist.GetCount() ) || ( m_Playlist.GetCount() == 0 ) )
{
m_Playing = false;
return false;
}
if (IsPlaying() && _CurrentSongIsNetStream())
{
if(m_SongIndex == nItem )
{
return true; // already playing this stream
}
// _PostPlayRestart(); // will restart playing postponed
// return true;
}
else if (_IsNETSTREAMConnecting())
{
return true;
}
CSongPath sFilename;
std::auto_ptr<CMusikSong> pNewSong = m_Playlist.Item( nItem ).Song();
sFilename = pNewSong->MetaData.Filename;
if((pNewSong->MetaData.eFormat != MUSIK_FORMAT_NETSTREAM) && !sFilename.FileExists())
{ // not a network stream
// and
// file does not exist
wxMessageBox( _( "Cannot find file.\n Filename:" ) + sFilename.GetFullPath(), MUSIKAPPNAME_VERSION, wxICON_STOP );
Stop();
return false;
}
bool bNewSongStarted = (m_Playlist[nItem] != m_CurrentSong) && (nStartPos == 0);
if(bNewSongStarted && IsPlaying())
{
// player is currently playing, so we have to record history here, because Stop() is not
// called between the playing of the songs of the playlist.
wxGetApp().Library.RecordSongHistory(m_CurrentSong,GetTime(FMOD_MSEC));
}
//---------------------------------------------//
//--- start with the basics ---//
//---------------------------------------------//
m_Stopping = false;
m_SongIndex = nItem;
m_CurrentSong = m_Playlist.Item( m_SongIndex );
//---------------------------------------------//
//--- if there is already a fade in ---//
//--- progress, then we need to abort it ---//
//---------------------------------------------//
SetCrossfadeType( nFadeType );
//---------------------------------------------//
//--- open a new stream and push it to the ---//
//--- bottom of the m_ActiveStreams array ---//
//---------------------------------------------//
FSOUND_Stream_SetBufferSize( wxGetApp().Prefs.nSndBuffer );
FMODEngine::eOpenMode om = _CurrentSongNeedsMPEGACCURATE() ? FMODEngine::OpenMode_MPEGACCURATE : FMODEngine::OpenMode_Default;
m_SndEngine.SetOpenMode(om);
MUSIKStream* pNewStream = m_SndEngine.OpenMedia( ( const char* )ConvFn2A( sFilename.GetFullPath() ));
if(pNewStream == NULL)
{
wxMessageBox( _( "Playback will be stopped, because loading failed.\n Filename:" ) + sFilename.GetFullPath(), MUSIKAPPNAME_VERSION, wxICON_STOP );
Stop(false);
return false;
}
InitDSP();
if(_CurrentSongIsNetStream()&& _IsNETSTREAMConnecting() == false)
{
ClearOldStreams(true);// clear all streams
m_MetaDataSong = CMusikSong();
m_MetaDataSong.MetaData.eFormat = MUSIK_FORMAT_NETSTREAM;
m_p_NETSTREAM_Connecting = pNewStream;
m_Playing = true;
m_b_NETSTREAM_AbortConnect = false;
bool bExit = false;
do
{
int openstate = FSOUND_Stream_GetOpenState((FSOUND_STREAM*)pNewStream->GetStreamOut()->STREAM());
if ((openstate == -1) || (openstate == -3))
{
wxMessageBox(_("ERROR: failed to open stream:")+ ConvA2W(FSOUND_Stream_Net_GetLastServerStatus()));
m_b_NETSTREAM_AbortConnect = true;
break;
}
switch(_NetStreamStatusUpdate(pNewStream))
{
case FSOUND_STREAM_NET_READY:
if(openstate == 0)
bExit = true;
break;
case FSOUND_STREAM_NET_ERROR:
m_b_NETSTREAM_AbortConnect = true;
break;
}
wxGetApp().Yield();
} while (!bExit && !m_b_NETSTREAM_AbortConnect);
m_p_NETSTREAM_Connecting = NULL;
if( m_b_NETSTREAM_AbortConnect )
{
delete pNewStream;
Stop(false);
m_b_NETSTREAM_AbortConnect = false;
return false;
}
}
//---------------------------------------------//
//--- start playback on the new stream on ---//
//--- the designated channel. ---//
//---------------------------------------------//
int retries = 2;
bool bPlaySucceeded = false;
pNewStream->SetTime( nStartPos * 1000 );
while( retries -- && (!bPlaySucceeded))
{
if(!pNewStream->Play())
{
wxCriticalSectionLocker lock(m_protectingStreamArrays);
if(m_ActiveStreams.GetCount())
{
delete( m_ActiveStreams[0] );
m_ActiveStreams.RemoveAt(0);
}
}
else
bPlaySucceeded = true;
}
if(!bPlaySucceeded)
{
wxMessageBox(_("Play failed, please try again."));
wxLogDebug(wxT("play failed:%s"),(const wxChar *) ConvA2W(m_SndEngine.ErrorString()));
delete pNewStream;
Stop(false);
return false;
}
if(_CurrentSongIsNetStream())
{
FSOUND_Stream_Net_SetMetadataCallback((FSOUND_STREAM*)pNewStream->GetStreamOut()->STREAM(), MetadataCallback, this);
}
pNewStream->SetVolume( 0.0 );
m_Playing = true;
m_Paused = false;
if(g_FaderThread)
g_FaderThread->CrossfaderAbort();
//---------------------------------------------//
//--- update the global arrays containing ---//
//--- active channels and streams ---//
//---------------------------------------------//
{
wxCriticalSectionLocker lock(m_protectingStreamArrays);
m_ActiveStreams.Add( pNewStream );
}
//---------------------------------------------//
//--- playback has been started, update the ---//
//--- user interface to reflect it ---//
//---------------------------------------------//
MusikPlayerEvent ev_start(this,wxEVT_MUSIKPLAYER_PLAY_START);
ProcessEvent(ev_start);
UpdateUI();//TODO: remove this. replace by event handling of playlistctrl etc.
//---------------------------------------------//
//--- record history in database ---//
//---------------------------------------------//
if(bNewSongStarted)
{
MusikPlayerEvent ev_songchange(this,wxEVT_MUSIKPLAYER_SONG_CHANGED);
ProcessEvent(ev_songchange);
wxGetApp().Library.UpdateItemLastPlayed ( m_CurrentSong );//TODO: replace by event handling of wxEVT_MUSIKPLAYER_SONG_CHANGED in library
}
//---------------------------------------------//
//--- if fading is not enabled, shut down ---//
//--- all of the old channels, and set the ---//
//--- active stream to full volume ---//
//---------------------------------------------//
if ( wxGetApp().Prefs.bFadeEnable == 0 || wxGetApp().Prefs.bGlobalFadeEnable == 0 )
{
if(pNewStream)
pNewStream->SetVolume(1.0);
ClearOldStreams();
}
//---------------------------------------------//
//--- tell the listening thread its time to ---//
//--- start fading ---//
//---------------------------------------------//
else if ( wxGetApp().Prefs.bFadeEnable && wxGetApp().Prefs.bGlobalFadeEnable )
SetFadeStart();
return true;
}
void EffectCompressor::OnSlider(wxCommandEvent & WXUNUSED(evt))
{
TransferDataFromWindow();
UpdateUI();
}
void SoundManager::UpdateTriggerReverb
(
TriggerReverb * reverb
)
{
cvar_t *cvar;
int reverbtype;
float reverblevel;
str faceted;
Vector tempvec;
if ( !reverb )
{
return;
}
//
// go to a known state
//
reverb->SetOneShot( false );
// no angle use
reverb->useTriggerDir = false;
// make sure it doesn't trigger
reverb->triggerable = false;
// get origin
cvar = gi.Cvar_Get( "snd_origin", "", 0 );
sscanf( cvar->string, "%f %f %f", &tempvec[ 0 ], &tempvec[ 1 ], &tempvec[ 2 ] );
reverb->setOrigin( tempvec );
// get targetname
cvar = gi.Cvar_Get( "snd_targetname", "", 0 );
reverb->SetTargetName( cvar->string );
// get width
cvar = gi.Cvar_Get( "snd_width", "", 0 );
reverb->mins[ 0 ] = -cvar->value;
reverb->maxs[ 0 ] = cvar->value;
// get length
cvar = gi.Cvar_Get( "snd_length", "", 0 );
reverb->mins[ 1 ] = -cvar->value;
reverb->maxs[ 1 ] = cvar->value;
// get height
cvar = gi.Cvar_Get( "snd_height", "", 0 );
reverb->mins[ 2 ] = 0;
reverb->maxs[ 2 ] = cvar->value;
reverb->setSize( reverb->mins, reverb->maxs );
// get current multi faceted ness
cvar = gi.Cvar_Get( "snd_multifaceted", "", 0 );
faceted = cvar->string;
if ( faceted == "North/South" )
{
reverb->SetMultiFaceted( 1 );
}
else if ( faceted == "East/West" )
{
reverb->SetMultiFaceted( 2 );
}
else
{
reverb->SetMultiFaceted( 0 );
}
// get reverb type
cvar = gi.Cvar_Get( "snd_reverbtype", "", 0 );
reverbtype = cvar->integer;
// get reverb level
cvar = gi.Cvar_Get( "snd_reverblevel", "", 0 );
reverblevel = cvar->value;
if ( reverb->multiFaceted && currentFacet )
{
reverb->SetAltReverb( reverbtype, reverblevel );
}
else
{
reverb->SetReverb( reverbtype, reverblevel );
}
// get onetime
cvar = gi.Cvar_Get( "snd_onetime", "", 0 );
if ( cvar->integer )
{
reverb->SetOneShot( true );
}
// get yaw
cvar = gi.Cvar_Get( "snd_yaw", "", 0 );
reverb->angles[ YAW ] = cvar->value;
reverb->setAngles();
// get useangles
cvar = gi.Cvar_Get( "snd_useangles", "", 0 );
if ( cvar->integer )
{
reverb->SetTriggerDir( reverb->angles[ YAW ] );
}
UpdateUI();
}
void SoundManager::UpdateTriggerMusic
(
TriggerMusic * music
)
{
cvar_t *cvar;
str current;
str fallback;
str faceted;
Vector tempvec;
if ( !music )
{
return;
}
//
// go to a known state
//
music->SetOneShot( false );
// no angle use
music->useTriggerDir = false;
// make sure it doesn't trigger
music->triggerable = false;
// get origin
cvar = gi.Cvar_Get( "snd_origin", "", 0 );
sscanf( cvar->string, "%f %f %f", &tempvec[ 0 ], &tempvec[ 1 ], &tempvec[ 2 ] );
music->setOrigin( tempvec );
// get targetname
cvar = gi.Cvar_Get( "snd_targetname", "", 0 );
music->SetTargetName( cvar->string );
// get width
cvar = gi.Cvar_Get( "snd_width", "", 0 );
music->mins[ 0 ] = -cvar->value;
music->maxs[ 0 ] = cvar->value;
// get length
cvar = gi.Cvar_Get( "snd_length", "", 0 );
music->mins[ 1 ] = -cvar->value;
music->maxs[ 1 ] = cvar->value;
// get height
cvar = gi.Cvar_Get( "snd_height", "", 0 );
music->mins[ 2 ] = 0;
music->maxs[ 2 ] = cvar->value;
music->setSize( music->mins, music->maxs );
// get current multi faceted ness
cvar = gi.Cvar_Get( "snd_multifaceted", "", 0 );
faceted = cvar->string;
if ( faceted == "North/South" )
{
music->SetMultiFaceted( 1 );
}
else if ( faceted == "East/West" )
{
music->SetMultiFaceted( 2 );
}
else
{
music->SetMultiFaceted( 0 );
}
// get current mood
cvar = gi.Cvar_Get( "snd_currentmood", "", 0 );
current = cvar->string;
// get fallback mood
cvar = gi.Cvar_Get( "snd_fallbackmood", "", 0 );
fallback = cvar->string;
if ( music->multiFaceted && currentFacet )
{
music->SetAltMood( current, fallback );
}
else
{
music->SetMood( current, fallback );
}
// get onetime
cvar = gi.Cvar_Get( "snd_onetime", "", 0 );
if ( cvar->integer )
{
music->SetOneShot( true );
}
// get yaw
cvar = gi.Cvar_Get( "snd_yaw", "", 0 );
music->angles[ YAW ] = cvar->value;
music->setAngles();
// get useangles
cvar = gi.Cvar_Get( "snd_useangles", "", 0 );
if ( cvar->integer )
{
music->SetTriggerDir( music->angles[ YAW ] );
}
UpdateUI();
}
void TimeIPDlg::Initialize()
{
UpdateUI();
exec();
}
void EffectTruncSilence::PopulateOrExchange(ShuttleGui & S)
{
wxASSERT(kNumActions == WXSIZEOF(kActionStrings));
wxArrayString actionChoices;
for (int i = 0; i < kNumActions; i++)
{
actionChoices.Add(wxGetTranslation(kActionStrings[i]));
}
S.AddSpace(0, 5);
S.StartStatic(_("Detect Silence"));
{
S.StartMultiColumn(3, wxALIGN_CENTER_HORIZONTAL);
{
// Threshold
mTruncDbChoice = S.AddChoice(_("Level:"), wxT(""), &mDbChoices);
mTruncDbChoice->SetValidator(wxGenericValidator(&mTruncDbChoiceIndex));
S.SetSizeHints(-1, -1);
S.AddSpace(0); // 'choices' already includes units.
// Ignored silence
FloatingPointValidator<double> vldDur(3, &mInitialAllowedSilence, NUM_VAL_NO_TRAILING_ZEROES);
vldDur.SetRange(MIN_Minimum, MAX_Minimum);
mInitialAllowedSilenceT = S.AddTextBox(_("Duration:"), wxT(""), 12);
mInitialAllowedSilenceT->SetValidator(vldDur);
S.AddUnits(wxT("seconds"));
}
S.EndMultiColumn();
}
S.EndStatic();
S.StartStatic(_("Action"));
{
S.StartHorizontalLay();
{
// Action choices
mActionChoice = S.AddChoice(wxT(""), wxT(""), &actionChoices);
mActionChoice->SetValidator(wxGenericValidator(&mActionIndex));
S.SetSizeHints(-1, -1);
}
S.EndHorizontalLay();
S.StartMultiColumn(3, wxALIGN_CENTER_HORIZONTAL);
{
// Truncation / Compression factor
FloatingPointValidator<double> vldTrunc(3, &mTruncLongestAllowedSilence, NUM_VAL_NO_TRAILING_ZEROES);
vldTrunc.SetRange(MIN_Truncate, MAX_Truncate);
mTruncLongestAllowedSilenceT = S.AddTextBox(_("Truncate to:"), wxT(""), 12);
mTruncLongestAllowedSilenceT->SetValidator(vldTrunc);
S.AddUnits(wxT("seconds"));
FloatingPointValidator<double> vldComp(3, &mSilenceCompressPercent, NUM_VAL_NO_TRAILING_ZEROES);
vldComp.SetRange(MIN_Compress, MAX_Compress);
mSilenceCompressPercentT = S.AddTextBox(_("Compress to:"), wxT(""), 12);
mSilenceCompressPercentT->SetValidator(vldComp);
S.AddUnits(wxT("percent"));
}
S.EndMultiColumn();
S.StartMultiColumn(2, wxALIGN_CENTER_HORIZONTAL);
{
mIndependent = S.AddCheckBox(_("Truncate tracks independently"),
mbIndependent ? wxT("true") : wxT("false"));
}
S.EndMultiColumn();
}
S.EndStatic();
UpdateUI();
}
void CJobControlDlg::Abort()
{
SkipJob();
m_Main->SetBatchMode(FALSE); // force RunBatchJobs to abort and exit
UpdateUI(); // update UI to reflect final state
}
void DetectorFlowDlg::Initialize()
{
UpdateUI();
OnReadFlowButtonClicked();
exec();
}
//---------------------------------------------------------------------
int __fastcall TRADIOSetDlg::Execute(void)
{
PortName->Text = RADIO.StrPort;
Baud->Text = RADIO.BaudRate;
BitLen->ItemIndex = RADIO.BitLen;
Parity->ItemIndex = RADIO.Parity;
Stop->ItemIndex = RADIO.Stop;
flwXON->Checked = RADIO.flwXON;
flwCTS->Checked = RADIO.flwCTS;
CBPTT->Checked = RADIO.usePTT;
ByteWait->Text = int(RADIO.ByteWait);
char bf[32];
sprintf( bf, "%02X", RADIO.Cmdxx);
Cmdxx->Text = bf;
CmdInit->Text = RADIO.CmdInit;
CmdRx->Text = RADIO.CmdRx;
CmdTx->Text = RADIO.CmdTx;
CmdGNR->Text = RADIO.cmdGNR;
OpenGNR->Checked = RADIO.openGNR;
m_PollType = RADIO.PollType;
PollInt->Text = (RADIO.PollInterval + 5)/10.0;
AddrScan->Checked = RADIO.PollScan;
SetMaker();
UpdateUI();
if( ShowModal() == IDOK ){
StrCopy(RADIO.StrPort, AnsiString(PortName->Text).c_str(), 31); //ja7ude 0428
int dd;
if( sscanf(AnsiString(Baud->Text).c_str(), "%u", &dd) == 1 ){ //ja7ude 0428
RADIO.BaudRate = dd;
}
RADIO.BitLen = BitLen->ItemIndex;
RADIO.Parity = Parity->ItemIndex;
RADIO.Stop = Stop->ItemIndex;
RADIO.flwXON = flwXON->Checked;
RADIO.flwCTS = flwCTS->Checked;
RADIO.usePTT = CBPTT->Checked;
if( sscanf(AnsiString(ByteWait->Text).c_str(), "%u", &dd) == 1 ){ //ja7ude 0428
if( (dd >= 0) && (dd <= 1000) ){
RADIO.ByteWait = dd;
}
}
if( sscanf(AnsiString(Cmdxx->Text).c_str(), "%X", &dd) == 1 ){ //ja7ude 0428
RADIO.Cmdxx = dd & 0x000000ff;
}
RADIO.CmdInit = CmdInit->Text;
RADIO.CmdRx = CmdRx->Text;
RADIO.CmdTx = CmdTx->Text;
RADIO.cmdGNR = CmdGNR->Text;
RADIO.openGNR = OpenGNR->Checked;
RADIO.PollType = m_PollType;
double d;
if( sscanf(AnsiString(PollInt->Text).c_str(), "%lf", &d) == 1 ){ //ja7ude 0428
if( d >= 0.5 ){
RADIO.PollInterval = int((d * 10.0) - 5);
if( RADIO.PollInterval < 0 ) RADIO.PollInterval = 0;
}
}
RADIO.PollScan = AddrScan->Checked;
RADIO.change = 1;
return TRUE;
}
else {
return FALSE;
}
}
void CManageTagsDlg::OnBnClickedManageTagsAddBtn()
{
CString lTags;
CString lTag;
CAddTagsDlg lAddTagsDlg;
CAddMultipleTagsDlg lAddMultipleTagsDlg;
int lPos;
if (lAddTagsDlg.DoModal() == IDOK)
{
m_ManageTagsList.SelItemRange(FALSE, 0, m_ManageTagsList.GetCount() - 1);
// Add Multiple Tags dialog
if (lAddTagsDlg.NeedShowAddMultipleTagsDlg())
{
if (lAddMultipleTagsDlg.DoModal() == IDOK)
{
mAddedTags = lTags = lAddMultipleTagsDlg.GetText();
while ((lPos = lTags.Find(_T("\r\n"))) != -1)
{
lTag = lTags.Left(lPos);
if (!lTag.IsEmpty())
{
if (m_ManageTagsList.FindStringExact(-1, lTag) == LB_ERR)
{
CString lStr;
lStr = lTag;
lStr.Remove(' ');
if (!lStr.IsEmpty())
{
int lSelTagIdx = m_ManageTagsList.AddString(lTag);
m_ManageTagsList.SetItemData(lSelTagIdx, MANAGETAGS_NEWTAGID);
m_ManageTagsList.SetSel(lSelTagIdx);
}
}
}
lTags = lTags.Right(lTags.GetLength() - lPos - 2);
}
lTag = lTags;
if (!lTag.IsEmpty())
{
if (m_ManageTagsList.FindStringExact(-1, lTag) == LB_ERR)
{
CString lStr;
lStr = lTag;
lStr.Remove(' ');
if (!lStr.IsEmpty())
{
//m_ManageTagsList.SetFocus();
//m_ManageTagsList.SetSel(-1);
int lTagIdx = m_ManageTagsList.AddString(lTag);
m_ManageTagsList.SetItemData(lTagIdx, MANAGETAGS_NEWTAGID);
m_ManageTagsList.SetSel(lTagIdx);
}
}
}
}
}
// Add Tag
else
{
mAddedTags = lTag = lAddTagsDlg.GetText();
if (!lTag.IsEmpty())
{
if (m_ManageTagsList.FindStringExact(-1, lTag) == LB_ERR)
{
CString lStr;
lStr = lTag;
lStr.Remove(' ');
if (!lStr.IsEmpty())
{
//m_ManageTagsList.SetFocus();
// m_ManageTagsList.s SetSel(-1);
int lTagIdx = m_ManageTagsList.AddString(lTag);
m_ManageTagsList.SetItemData(lTagIdx, MANAGETAGS_NEWTAGID);
m_ManageTagsList.SetSel(lTagIdx);
}
}
else
{
// Show error message if it's necessary
}
}
}
}
UpdateUI();
}
//---------------------------------------------------------------------------
void __fastcall TRADIOSetDlg::PortNameChange(TObject *Sender)
{
if( m_DisEvent ) return;
UpdateUI();
}
void CCElection::DoSetPlegeComplete( void )
{
UpdateUI();
}
HRESULT MainWindow::OnCreate()
{
HRESULT hr = S_OK;
// Create the background brush.
brush = CreateHatchBrush(HS_BDIAGONAL, RGB(0, 0x80, 0xFF));
if (brush == NULL)
{
hr = __HRESULT_FROM_WIN32(GetLastError());
}
// Create the rebar control.
if (SUCCEEDED(hr))
{
hr = rebar.Create(m_hInstance, m_hwnd, IDC_REBAR_CONTROL);
}
// Create the toolbar control.
if (SUCCEEDED(hr))
{
hr = toolbar.Create(m_hInstance, m_hwnd, IDC_TOOLBAR, TBSTYLE_FLAT | TBSTYLE_TOOLTIPS);
}
// Set the image list for toolbar buttons (normal state).
if (SUCCEEDED(hr))
{
hr = toolbar.SetImageList(
Toolbar::Normal, // Image list for normal state
IDB_TOOLBAR_IMAGES_NORMAL, // Bitmap resource
Size(48, 48), // Size of each button
5, // Number of buttons
RGB(0xFF, 0x00, 0xFF) // Color mask
);
}
// Set the image list for toolbar buttons (disabled state).
if (SUCCEEDED(hr))
{
hr = toolbar.SetImageList(
Toolbar::Disabled, // Image list for normal state
IDB_TOOLBAR_IMAGES_DISABLED, // Bitmap resource
Size(48, 48), // Size of each button
5, // Number of buttons
RGB(0xFF, 0x00, 0xFF) // Color mask
);
}
// Add buttons to the toolbar.
if (SUCCEEDED(hr))
{
// Play
hr = toolbar.AddButton(Toolbar::Button(ID_IMAGE_PLAY, IDC_BUTTON_PLAY));
}
if (SUCCEEDED(hr))
{
// Stop
hr = toolbar.AddButton(Toolbar::Button(ID_IMAGE_STOP, IDC_BUTTON_STOP));
}
if (SUCCEEDED(hr))
{
// Pause
hr = toolbar.AddButton(Toolbar::Button(ID_IMAGE_PAUSE, IDC_BUTTON_PAUSE));
}
if (SUCCEEDED(hr))
{
// Mute
hr = toolbar.AddButton(Toolbar::Button(ID_IMAGE_MUTE_OFF, IDC_BUTTON_MUTE));
}
// Add the toolbar to the rebar control.
if (SUCCEEDED(hr))
{
hr = rebar.AddBand(toolbar.Window(), 0);
}
//// Create the slider for seeking.
if (SUCCEEDED(hr))
{
hr = Slider_Init(); // Initialize the Slider control.
}
if (SUCCEEDED(hr))
{
hr = seekbar.Create(m_hwnd, Rect(0, 0, 300, 16), IDC_SEEKBAR);
}
if (SUCCEEDED(hr))
{
hr = seekbar.SetThumbBitmap(IDB_SLIDER_THUMB);
seekbar.SetBackground(CreateSolidBrush(RGB(239, 239, 231)));
seekbar.Enable(FALSE);
}
if (SUCCEEDED(hr))
{
hr = rebar.AddBand(seekbar.Window(), 1);
}
//// Create the slider for changing the volume.
if (SUCCEEDED(hr))
{
hr = volumeSlider.Create(m_hwnd, Rect(0, 0, 100, 32), IDC_VOLUME);
}
if (SUCCEEDED(hr))
{
hr = volumeSlider.SetThumbBitmap(IDB_SLIDER_VOLUME);
volumeSlider.SetBackground(CreateSolidBrush(RGB(239, 239, 231)));
volumeSlider.Enable(TRUE);
// Set the range of the volume slider. In my experience, only the top half of the
// range is audible.
volumeSlider.SetRange(MIN_VOLUME / 2, MAX_VOLUME);
volumeSlider.SetPosition(MAX_VOLUME);
}
if (SUCCEEDED(hr))
{
hr = rebar.AddBand(volumeSlider.Window(), 2);
}
// Create the DirectShow player object.
if (SUCCEEDED(hr))
{
m_pPlayer = new DShowPlayer(m_hwnd);
if (m_pPlayer == NULL)
{
hr = E_OUTOFMEMORY;
}
}
// Set the event notification window.
if (SUCCEEDED(hr))
{
hr = m_pPlayer->SetEventWindow(m_hwnd, WM_GRAPH_EVENT);
}
// Set default UI state.
if (SUCCEEDED(hr))
{
UpdateUI();
}
return hr;
}
BOOL CCElection::DoTestBeginCandidacy( void )
{ // 군주 입후보 시작
PrintCaption( prj.GetText( TID_GAME_ELECTION_CAPTION_BEGIN_CANDIDACY_01 ) );
UpdateUI();
return TRUE;
}
void MainWindow::OnPlay()
{
m_pPlayer->Play();
UpdateUI();
}
void MyFrame::Disconnect()
{
m_server->Disconnect();
UpdateUI();
}
void MainWindow::OnPause()
{
m_pPlayer->Pause();
UpdateUI();
}
void EffectDtmf::OnSequence(wxCommandEvent & WXUNUSED(evt))
{
dtmfSequence = mDtmfSequenceT->GetValue();
Recalculate();
UpdateUI();
}
void Dlg_EditPrim::ClickedBoxRadio(void)
{
pVXRegion->CreateBoxRegion(Vec3D<>(0,0,0), Vec3D<>(0.1, 0.1, 0.1));
UpdateUI();
emit RequestUpdateGL();
}
void EffectDtmf::OnDutyCycle(wxCommandEvent & evt)
{
dtmfDutyCycle = (double) evt.GetInt() / SCL_DutyCycle;
Recalculate();
UpdateUI();
}
void __fastcall TTNCSetDlg::TNCTypeClick(TObject *Sender)
{
if( m_DisEvent ) return;
UpdateUI();
}
