bool CStereoscopicsManager::OnAction(const CAction &action)
{
RENDER_STEREO_MODE mode = GetStereoMode();
if (action.GetID() == ACTION_STEREOMODE_NEXT)
{
SetStereoMode(GetNextSupportedStereoMode(mode));
return true;
}
else if (action.GetID() == ACTION_STEREOMODE_PREVIOUS)
{
SetStereoMode(GetNextSupportedStereoMode(mode, RENDER_STEREO_MODE_COUNT - 1));
return true;
}
else if (action.GetID() == ACTION_STEREOMODE_TOGGLE)
{
if (mode == RENDER_STEREO_MODE_OFF)
{
RENDER_STEREO_MODE targetMode = m_lastStereoMode;
if (targetMode == RENDER_STEREO_MODE_OFF)
targetMode = GetPreferredPlaybackMode();
SetStereoMode(targetMode);
}
else
{
SetStereoMode(RENDER_STEREO_MODE_OFF);
}
return true;
}
else if (action.GetID() == ACTION_STEREOMODE_SELECT)
{
SetStereoMode(GetStereoModeByUserChoice());
return true;
}
else if (action.GetID() == ACTION_STEREOMODE_TOMONO)
{
if (mode == RENDER_STEREO_MODE_MONO)
{
RENDER_STEREO_MODE targetMode = m_lastStereoMode;
if (targetMode == RENDER_STEREO_MODE_OFF)
targetMode = GetPreferredPlaybackMode();
SetStereoMode(targetMode);
}
else
{
SetStereoMode(RENDER_STEREO_MODE_MONO);
}
return true;
}
else if (action.GetID() == ACTION_STEREOMODE_SET)
{
int stereoMode = ConvertStringToGuiStereoMode(action.GetName());
if (stereoMode > -1)
SetStereoMode( (RENDER_STEREO_MODE) stereoMode);
return true;
}
return false;
}
/*****************************************************************************
* CSynth::Activate()
*****************************************************************************
* Make the synth active.
*/
HRESULT CSynth::Activate(DWORD dwSampleRate, DWORD dwChannels )
{
m_stLastTime = 0;
SetSampleRate(dwSampleRate);
SetStereoMode(dwChannels);
ResetPerformanceStats();
return S_OK;
}
void CStereoscopicsManager::OnPlaybackStopped(void)
{
RENDER_STEREO_MODE mode = GetStereoMode();
if (CSettings::Get().GetBool("videoplayer.quitstereomodeonstop") == true && mode != RENDER_STEREO_MODE_OFF)
{
SetStereoMode(RENDER_STEREO_MODE_OFF);
}
}
void CStereoscopicsManager::SetStereoModeByUser(const RENDER_STEREO_MODE &mode)
{
// only update last user mode if desired mode is different from current
if (mode != m_stereoModeSetByUser)
m_lastStereoModeSetByUser = m_stereoModeSetByUser;
m_stereoModeSetByUser = mode;
SetStereoMode(mode);
}
/*****************************************************************************
* CSynth::Activate()
*****************************************************************************
* Make the synth active.
*/
HRESULT CSynth::Activate(DWORD dwSampleRate, DWORD dwChannels )
{
NTSTATUS status = STATUS_SUCCESS;
m_stLastTime = 0;
SetSampleRate(dwSampleRate);
SetStereoMode(dwChannels);
ResetPerformanceStats();
return status;
}
void CStereoscopicsManager::OnPlaybackStopped(void)
{
RENDER_STEREO_MODE mode = GetStereoMode();
if (CSettings::Get().GetBool("videoplayer.quitstereomodeonstop") && mode != RENDER_STEREO_MODE_OFF)
SetStereoMode(RENDER_STEREO_MODE_OFF);
// reset user modes on playback end to start over new on next playback and not end up in a probably unwanted mode
if (m_stereoModeSetByUser != RENDER_STEREO_MODE_OFF)
m_lastStereoModeSetByUser = m_stereoModeSetByUser;
m_stereoModeSetByUser = RENDER_STEREO_MODE_UNDEFINED;
}
/*****************************************************************************
* CSynth::CSynth()
*****************************************************************************
* Contructor for CSynth object. Initialize the voice list, the stereo mode,
* sample rate, performance statistics, etc.
*/
CSynth::CSynth()
{
FLOATSAFE fs;
DWORD nIndex;
CVoice *pVoice;
m_fCSInitialized = FALSE;
::InitializeCriticalSection(&m_CriticalSection);
m_fCSInitialized = TRUE;
for (nIndex = 0;nIndex < MAX_NUM_VOICES;nIndex++)
{
pVoice = new CVoice;
if (pVoice != NULL)
{
m_VoicesFree.AddHead(pVoice);
}
}
for (nIndex = 0;nIndex < NUM_EXTRA_VOICES;nIndex++)
{
pVoice = new CVoice;
if (pVoice != NULL)
{
m_VoicesExtra.AddHead(pVoice);
}
}
m_ppControl = NULL;
m_dwControlCount = 0;
m_nMaxVoices = MAX_NUM_VOICES;
m_nExtraVoices = NUM_EXTRA_VOICES;
m_stLastStats = 0;
m_fAllowPanWhilePlayingNote = TRUE;
m_fAllowVolumeChangeWhilePlayingNote = TRUE;
ResetPerformanceStats();
m_dwSampleRate = 22050;
m_dwStereo = 1;
m_stLastTime = 0;
SetSampleRate(SAMPLE_RATE_22);
SetStereoMode(2);
SetGainAdjust(600);
}
void CStereoscopicsManager::OnPlaybackStarted(void)
{
STEREOSCOPIC_PLAYBACK_MODE playbackMode = (STEREOSCOPIC_PLAYBACK_MODE) CSettings::Get().GetInt("videoplayer.stereoscopicplaybackmode");
RENDER_STEREO_MODE mode = GetStereoMode();
// early return if playback mode should be ignored and we're in no stereoscopic mode right now
if (playbackMode == STEREOSCOPIC_PLAYBACK_MODE_IGNORE && mode == RENDER_STEREO_MODE_OFF)
return;
if (!g_infoManager.EvaluateBool("videoplayer.isstereoscopic"))
{
// exit stereo mode if started item is not stereoscopic
// and if user prefers to stop 3D playback when movie is finished
if (mode != RENDER_STEREO_MODE_OFF && CSettings::Get().GetBool("videoplayer.quitstereomodeonstop"))
SetStereoMode(RENDER_STEREO_MODE_OFF);
return;
}
// if we're not in stereomode yet, restore previously selected stereo mode in case it was user selected
if (m_stereoModeSetByUser != RENDER_STEREO_MODE_UNDEFINED)
{
SetStereoMode(m_stereoModeSetByUser);
return;
}
RENDER_STEREO_MODE preferred = GetPreferredPlaybackMode();
RENDER_STEREO_MODE playing = GetStereoModeOfPlayingVideo();
if (mode != RENDER_STEREO_MODE_OFF)
{
// don't change mode if user selected to not exit stereomode on playback stop
// users selecting this option usually have to manually switch their TV into 3D mode
// and would be annoyed by having to switch TV modes when next movies comes up
// @todo probably add a new setting for just this behavior
if (CSettings::Get().GetBool("videoplayer.quitstereomodeonstop") == false)
return;
// only change to new stereo mode if not yet in preferred stereo mode
if (mode == preferred || (preferred == RENDER_STEREO_MODE_AUTO && mode == playing))
return;
}
switch (playbackMode)
{
case STEREOSCOPIC_PLAYBACK_MODE_ASK: // Ask
{
CApplicationMessenger::Get().MediaPause();
CGUIDialogSelect* pDlgSelect = (CGUIDialogSelect*)g_windowManager.GetWindow(WINDOW_DIALOG_SELECT);
pDlgSelect->Reset();
pDlgSelect->SetHeading(CVariant{g_localizeStrings.Get(36527)});
int idx_playing = -1;
// add choices
int idx_preferred = pDlgSelect->Add(g_localizeStrings.Get(36524) // preferred
+ " ("
+ GetLabelForStereoMode(preferred)
+ ")");
int idx_mono = pDlgSelect->Add(GetLabelForStereoMode(RENDER_STEREO_MODE_MONO)); // mono / 2d
if (playing != RENDER_STEREO_MODE_OFF && playing != preferred && preferred != RENDER_STEREO_MODE_AUTO && g_Windowing.SupportsStereo(playing)) // same as movie
idx_playing = pDlgSelect->Add(g_localizeStrings.Get(36532)
+ " ("
+ GetLabelForStereoMode(playing)
+ ")");
int idx_select = pDlgSelect->Add( g_localizeStrings.Get(36531) ); // other / select
pDlgSelect->Open();
if(pDlgSelect->IsConfirmed())
{
int iItem = pDlgSelect->GetSelectedLabel();
if (iItem == idx_preferred) mode = preferred;
else if (iItem == idx_mono) mode = RENDER_STEREO_MODE_MONO;
else if (iItem == idx_playing) mode = RENDER_STEREO_MODE_AUTO;
else if (iItem == idx_select) mode = GetStereoModeByUserChoice();
SetStereoModeByUser( mode );
}
CApplicationMessenger::Get().MediaUnPause();
}
break;
case STEREOSCOPIC_PLAYBACK_MODE_PREFERRED: // Stereoscopic
SetStereoMode( preferred );
break;
case 2: // Mono
SetStereoMode( RENDER_STEREO_MODE_MONO );
break;
default:
break;
}
}
void CStereoscopicsManager::Initialize(void)
{
// turn off stereo mode on XBMC startup
SetStereoMode(RENDER_STEREO_MODE_OFF);
}
void CStereoscopicsManager::OnPlaybackStarted(void)
{
if (!g_infoManager.EvaluateBool("videoplayer.isstereoscopic"))
return;
STEREOSCOPIC_PLAYBACK_MODE playbackMode = (STEREOSCOPIC_PLAYBACK_MODE) CSettings::Get().GetInt("videoplayer.stereoscopicplaybackmode");
RENDER_STEREO_MODE mode = GetStereoMode();
// early return if playback mode should be ignored and we're in no stereoscopic mode right now
if (playbackMode == STEREOSCOPIC_PLAYBACK_MODE_IGNORE && mode == RENDER_STEREO_MODE_OFF)
return;
if (mode != RENDER_STEREO_MODE_OFF)
return;
switch (playbackMode)
{
case STEREOSCOPIC_PLAYBACK_MODE_ASK: // Ask
{
CApplicationMessenger::Get().MediaPause();
CGUIDialogSelect* pDlgSelect = (CGUIDialogSelect*)g_windowManager.GetWindow(WINDOW_DIALOG_SELECT);
pDlgSelect->Reset();
pDlgSelect->SetHeading(g_localizeStrings.Get(36527).c_str());
RENDER_STEREO_MODE preferred = GetPreferredPlaybackMode();
RENDER_STEREO_MODE playing = GetStereoModeOfPlayingVideo();
int idx_playing = -1;
// add choices
int idx_preferred = pDlgSelect->Add(g_localizeStrings.Get(36524) // preferred
+ " ("
+ GetLabelForStereoMode(preferred)
+ ")");
int idx_mono = pDlgSelect->Add(GetLabelForStereoMode(RENDER_STEREO_MODE_MONO)); // mono / 2d
if(playing != RENDER_STEREO_MODE_OFF && playing != preferred && g_Windowing.SupportsStereo(playing))
idx_playing = pDlgSelect->Add(g_localizeStrings.Get(36532)
+ " ("
+ GetLabelForStereoMode(playing)
+ ")");
int idx_select = pDlgSelect->Add( g_localizeStrings.Get(36531) ); // other / select
pDlgSelect->DoModal();
if(pDlgSelect->IsConfirmed())
{
int iItem = pDlgSelect->GetSelectedLabel();
if (iItem == idx_preferred) mode = preferred;
else if (iItem == idx_mono) mode = RENDER_STEREO_MODE_MONO;
else if (iItem == idx_playing) mode = playing;
else if (iItem == idx_select) mode = GetStereoModeByUserChoice();
SetStereoMode(mode);
}
CApplicationMessenger::Get().MediaUnPause();
}
break;
case STEREOSCOPIC_PLAYBACK_MODE_PREFERRED: // Stereoscopic
SetStereoMode( GetPreferredPlaybackMode() );
break;
case 2: // Mono
SetStereoMode( RENDER_STEREO_MODE_MONO );
break;
default:
break;
}
}
void CStereoscopicsManager::OnPlaybackStarted(void)
{
if (!g_infoManager.EvaluateBool("videoplayer.isstereoscopic"))
return;
// only change stereo mode if not yet in stereo mode
RENDER_STEREO_MODE mode = GetStereoMode();
if (mode != RENDER_STEREO_MODE_OFF)
return;
int playbackMode = CSettings::Get().GetInt("videoplayer.stereoscopicplaybackmode");
switch (playbackMode)
{
case 0: // Ask
{
CApplicationMessenger::Get().MediaPause();
CGUIDialogSelect* pDlgSelect = (CGUIDialogSelect*)g_windowManager.GetWindow(WINDOW_DIALOG_SELECT);
pDlgSelect->Reset();
pDlgSelect->SetHeading(g_localizeStrings.Get(36527).c_str());
RENDER_STEREO_MODE preferred = GetPreferredPlaybackMode();
RENDER_STEREO_MODE playing = GetStereoModeOfPlayingVideo();
int idx_preferred = -1
, idx_playing = -1
, idx_mono = -1
, idx_select = -1;
// add choices
idx_preferred = pDlgSelect->Add( g_localizeStrings.Get(36530)
+ " ("
+ GetLabelForStereoMode(preferred)
+ ")");
if(preferred != RENDER_STEREO_MODE_MONO)
idx_mono = pDlgSelect->Add( g_localizeStrings.Get(36529) ); // mono / 2d
if(playing != RENDER_STEREO_MODE_OFF && g_Windowing.SupportsStereo(playing))
idx_playing = pDlgSelect->Add( g_localizeStrings.Get(36532)
+ " ("
+ GetLabelForStereoMode(playing)
+ ")");
idx_select = pDlgSelect->Add( g_localizeStrings.Get(36531) ); // other / select
pDlgSelect->DoModal();
if(pDlgSelect->IsConfirmed())
{
int iItem = pDlgSelect->GetSelectedLabel();
if (iItem == idx_preferred) mode = preferred;
else if (iItem == idx_mono) mode = RENDER_STEREO_MODE_MONO;
else if (iItem == idx_playing) mode = playing;
else if (iItem == idx_select) mode = GetStereoModeByUserChoice();
SetStereoMode(mode);
}
CApplicationMessenger::Get().MediaUnPause();
}
break;
case 1: // Stereoscopic
SetStereoMode( GetPreferredPlaybackMode() );
break;
default:
break;
}
}
BonkEnc::ConfigureFLAC::ConfigureFLAC()
{
Point pos;
Size size;
currentConfig = BonkEnc::currentConfig;
preset = currentConfig->flac_preset;
streamable_subset = currentConfig->flac_streamable_subset;
do_mid_side_stereo = currentConfig->flac_do_mid_side_stereo;
loose_mid_side_stereo = currentConfig->flac_loose_mid_side_stereo;
blocksize = currentConfig->flac_blocksize / 8;
max_lpc_order = currentConfig->flac_max_lpc_order;
qlp_coeff_precision = currentConfig->flac_qlp_coeff_precision;
do_qlp_coeff_prec_search = currentConfig->flac_do_qlp_coeff_prec_search;
do_exhaustive_model_search = currentConfig->flac_do_exhaustive_model_search;
min_residual_partition_order = currentConfig->flac_min_residual_partition_order;
max_residual_partition_order = currentConfig->flac_max_residual_partition_order;
mainWnd = new Window(String(BonkEnc::i18n->TranslateString("%1 encoder configuration")).Replace("%1", "FLAC"), currentConfig->wndPos + Point(80, 80), Size(520, 332));
mainWnd->SetRightToLeft(BonkEnc::i18n->IsActiveLanguageRightToLeft());
mainWnd_titlebar = new Titlebar(TB_CLOSEBUTTON);
divbar = new Divider(39, OR_HORZ | OR_BOTTOM);
layer_simple = new Layer(BonkEnc::i18n->TranslateString("Basic"));
layer_format = new Layer(BonkEnc::i18n->TranslateString("Format"));
layer_advanced = new Layer(BonkEnc::i18n->TranslateString("Expert"));
pos.x = 175;
pos.y = 29;
size.cx = 0;
size.cy = 0;
btn_cancel = new Button(BonkEnc::i18n->TranslateString("Cancel"), NIL, pos, size);
btn_cancel->onAction.Connect(&ConfigureFLAC::Cancel, this);
btn_cancel->SetOrientation(OR_LOWERRIGHT);
pos.x -= 88;
btn_ok = new Button(BonkEnc::i18n->TranslateString("OK"), NIL, pos, size);
btn_ok->onAction.Connect(&ConfigureFLAC::OK, this);
btn_ok->SetOrientation(OR_LOWERRIGHT);
pos.x = 7;
pos.y = 7;
size.cx = 498;
size.cy = 245;
tabwidget = new TabWidget(pos, size);
pos.x = 7;
pos.y = 11;
size.cx = 480;
size.cy = 39;
group_preset = new GroupBox(BonkEnc::i18n->TranslateString("Presets"), pos, size);
pos.x += 9;
pos.y += 13;
text_preset = new Text(BonkEnc::i18n->TranslateString("Use preset:"), pos);
pos.x += (text_preset->textSize.cx + 8);
pos.y -= 3;
size.cx = 453 - text_preset->textSize.cx;
size.cy = 0;
combo_preset = new ComboBox(pos, size);
combo_preset->AddEntry(BonkEnc::i18n->TranslateString("Custom settings"));
combo_preset->AddEntry(String("0").Append(", ").Append(BonkEnc::i18n->TranslateString("Fastest encoding")));
combo_preset->AddEntry("1");
combo_preset->AddEntry("2");
combo_preset->AddEntry("3");
combo_preset->AddEntry("4");
combo_preset->AddEntry("5");
combo_preset->AddEntry("6");
combo_preset->AddEntry("7");
combo_preset->AddEntry(String("8").Append(", ").Append(BonkEnc::i18n->TranslateString("Best compression")));
combo_preset->SelectNthEntry(currentConfig->flac_preset + 1);
combo_preset->onSelectEntry.Connect(&ConfigureFLAC::SetPreset, this);
pos.x = 7;
pos.y = 62;
size.cx = 150;
size.cy = 65;
group_stereo = new GroupBox(BonkEnc::i18n->TranslateString("Stereo mode"), pos, size);
pos.x += 10;
pos.y += 13;
size.cx = 130;
size.cy = 0;
check_mid_side_stereo = new CheckBox(BonkEnc::i18n->TranslateString("Joint Stereo"), pos, size, &do_mid_side_stereo);
check_mid_side_stereo->onAction.Connect(&ConfigureFLAC::SetStereoMode, this);
pos.y += 25;
check_loose_mid_side = new CheckBox(BonkEnc::i18n->TranslateString("Adaptive Joint Stereo"), pos, size, &loose_mid_side_stereo);
pos.x = 7;
pos.y = 11;
size.cx = 480;
size.cy = 66;
group_format = new GroupBox(BonkEnc::i18n->TranslateString("Format"), pos, size);
pos.x += 10;
pos.y += 13;
size.cy = 0;
check_streamable_subset = new CheckBox(BonkEnc::i18n->TranslateString("Use streamable subset"), pos, size, &streamable_subset);
check_streamable_subset->onAction.Connect(&ConfigureFLAC::SetStreamableSubset, this);
check_streamable_subset->SetWidth(check_streamable_subset->textSize.cx + 21);
pos.x -= 1;
pos.y += 27;
text_blocksize = new Text(BonkEnc::i18n->TranslateString("Blocksize:"), pos);
pos.x += text_blocksize->textSize.cx + 7;
pos.y -= 2;
size.cx = 319;
slider_blocksize = new Slider(pos, size, OR_HORZ, &blocksize, 24, 4096);
slider_blocksize->onValueChange.Connect(&ConfigureFLAC::SetBlockSize, this);
pos.x += 328;
pos.y -= 1;
size.cx = 37;
edit_blocksize = new EditBox("", pos, size, 5);
edit_blocksize->onInput.Connect(&ConfigureFLAC::EditBlockSize, this);
pos.x += 44;
pos.y += 3;
text_blocksize_bytes = new Text(BonkEnc::i18n->TranslateString("bytes"), pos);
pos.x = 7;
pos.y = 11;
size.cx = 480;
size.cy = 56;
group_apodization = new GroupBox(BonkEnc::i18n->TranslateString("Apodization"), pos, size);
pos.x += 9;
pos.y += 13;
size.cy = 0;
text_apodization = new Text(BonkEnc::i18n->TranslateString("Apodization function(s):"), pos);
pos.x += text_apodization->textSize.cx + 7;
pos.y -= 3;
size.cx = 454 - text_apodization->textSize.cx;
edit_apodization = new EditBox(currentConfig->flac_apodization, pos, size);
list_apodization = new ListBox(pos, size);
list_apodization->AddEntry("bartlett");
list_apodization->AddEntry("bartlett_hann");
list_apodization->AddEntry("blackman");
list_apodization->AddEntry("blackman_harris_4term_92db");
list_apodization->AddEntry("connes");
list_apodization->AddEntry("flattop");
list_apodization->AddEntry("gauss(0.2)");
list_apodization->AddEntry("hamming");
list_apodization->AddEntry("hann");
list_apodization->AddEntry("kaiser_bessel");
list_apodization->AddEntry("nuttall");
list_apodization->AddEntry("rectangle");
list_apodization->AddEntry("triangle");
list_apodization->AddEntry("tukey(0.5)");
list_apodization->AddEntry("welch");
edit_apodization->SetDropDownList(list_apodization);
pos.x += 2;
pos.y += 25;
text_apodization_explain= new Text(String(BonkEnc::i18n->TranslateString("Note:")).Append(" ").Append(BonkEnc::i18n->TranslateString("You can specify multiple functions separated by semicolons.")), pos);
pos.x = 7;
pos.y = 79;
size.cx = 480;
size.cy = 62;
group_lpc = new GroupBox(BonkEnc::i18n->TranslateString("Linear predictor"), pos, size);
pos.x += 9;
pos.y += 13;
text_max_lpc_order = new Text(String(BonkEnc::i18n->TranslateString("Maximum LPC order")).Append(":"), pos);
pos.x += 7;
pos.y -= 2;
size.cx = 250;
slider_max_lpc_order = new Slider(pos, size, OR_HORZ, &max_lpc_order, 0, 32);
slider_max_lpc_order->onValueChange.Connect(&ConfigureFLAC::SetLPCOrder, this);
pos.x += 257;
pos.y += 2;
text_max_lpc_order_value= new Text(BonkEnc::i18n->TranslateString("disabled"), pos);
pos.x += 50;
pos.y -= 2;
size.cx = 150;
size.cy = 0;
check_exhaustive_model = new CheckBox(BonkEnc::i18n->TranslateString("Exhaustive model search"), pos, size, &do_exhaustive_model_search);
pos.x -= 314;
pos.y += 25;
text_qlp_precision = new Text(String(BonkEnc::i18n->TranslateString("Quantized LPC precision")).Append(":"), pos);
pos.x += 7;
pos.y -= 2;
size.cx = 250;
slider_qlp_precision = new Slider(pos, size, OR_HORZ, &qlp_coeff_precision, 0, 32);
slider_qlp_precision->onValueChange.Connect(&ConfigureFLAC::SetQLPPrecision, this);
pos.x += 257;
pos.y += 2;
text_qlp_precision_value= new Text(BonkEnc::i18n->TranslateString("auto"), pos);
pos.x += 50;
pos.y -= 2;
size.cx = 150;
size.cy = 0;
check_qlp_precision_search= new CheckBox(BonkEnc::i18n->TranslateString("Optimize LPC quantization"), pos, size, &do_qlp_coeff_prec_search);
check_qlp_precision_search->onAction.Connect(&ConfigureFLAC::SetQLPSearch, this);
Int maxTextSize = Math::Max(text_max_lpc_order_value->textSize.cx, text_qlp_precision_value->textSize.cx);
check_exhaustive_model->SetX(text_max_lpc_order_value->GetX() + maxTextSize + 8); check_exhaustive_model->SetWidth(189 - maxTextSize);
check_qlp_precision_search->SetX(text_max_lpc_order_value->GetX() + maxTextSize + 8); check_qlp_precision_search->SetWidth(189 - maxTextSize);
pos.x = 7;
pos.y = 153;
size.cx = 296;
size.cy = 62;
group_rice = new GroupBox(BonkEnc::i18n->TranslateString("Residual coding"), pos, size);
pos.x += 9;
pos.y += 13;
text_min_part_order = new Text(String(BonkEnc::i18n->TranslateString("Minimum partition order")).Append(":"), pos);
pos.x += 7;
pos.y -= 2;
size.cx = 250;
slider_min_part_order = new Slider(pos, size, OR_HORZ, &min_residual_partition_order, 0, 16);
slider_min_part_order->onValueChange.Connect(&ConfigureFLAC::SetRiceOrder, this);
pos.x += 257;
pos.y += 2;
text_min_part_order_value= new Text("", pos);
pos.x -= 264;
pos.y += 23;
text_max_part_order = new Text(String(BonkEnc::i18n->TranslateString("Maximum partition order")).Append(":"), pos);
pos.x += 7;
pos.y -= 2;
size.cx = 250;
slider_max_part_order = new Slider(pos, size, OR_HORZ, &max_residual_partition_order, 0, 16);
slider_max_part_order->onValueChange.Connect(&ConfigureFLAC::SetRiceOrder, this);
pos.x += 257;
pos.y += 2;
text_max_part_order_value= new Text("", pos);
maxTextSize = Math::Max(Math::Max(text_min_part_order->textSize.cx, text_max_part_order->textSize.cx), Math::Max(text_max_lpc_order->textSize.cx, text_qlp_precision->textSize.cx));
slider_min_part_order->SetX(group_lpc->GetX() + 16 + maxTextSize); slider_min_part_order->SetWidth(250 - maxTextSize);
slider_max_part_order->SetX(group_lpc->GetX() + 16 + maxTextSize); slider_max_part_order->SetWidth(250 - maxTextSize);
slider_max_lpc_order->SetX(group_lpc->GetX() + 16 + maxTextSize); slider_max_lpc_order->SetWidth(250 - maxTextSize);
slider_qlp_precision->SetX(group_lpc->GetX() + 16 + maxTextSize); slider_qlp_precision->SetWidth(250 - maxTextSize);
SetStereoMode();
SetStreamableSubset();
SetBlockSize();
SetRiceOrder();
SetLPCOrder();
SetQLPSearch();
SetQLPPrecision();
SetPreset();
Add(mainWnd);
mainWnd->Add(btn_ok);
mainWnd->Add(btn_cancel);
mainWnd->Add(tabwidget);
mainWnd->Add(mainWnd_titlebar);
mainWnd->Add(divbar);
tabwidget->Add(layer_simple);
tabwidget->Add(layer_format);
tabwidget->Add(layer_advanced);
layer_simple->Add(group_preset);
layer_simple->Add(text_preset);
layer_simple->Add(combo_preset);
layer_simple->Add(group_stereo);
layer_simple->Add(check_mid_side_stereo);
layer_simple->Add(check_loose_mid_side);
layer_format->Add(group_format);
layer_format->Add(check_streamable_subset);
layer_format->Add(text_blocksize);
layer_format->Add(slider_blocksize);
layer_format->Add(edit_blocksize);
layer_format->Add(text_blocksize_bytes);
layer_advanced->Add(group_apodization);
layer_advanced->Add(text_apodization);
layer_advanced->Add(edit_apodization);
layer_advanced->Add(text_apodization_explain);
layer_advanced->Add(group_lpc);
layer_advanced->Add(text_max_lpc_order);
layer_advanced->Add(slider_max_lpc_order);
layer_advanced->Add(text_max_lpc_order_value);
layer_advanced->Add(check_exhaustive_model);
layer_advanced->Add(check_qlp_precision_search);
layer_advanced->Add(text_qlp_precision);
layer_advanced->Add(slider_qlp_precision);
layer_advanced->Add(text_qlp_precision_value);
layer_advanced->Add(group_rice);
layer_advanced->Add(text_min_part_order);
layer_advanced->Add(text_max_part_order);
layer_advanced->Add(slider_min_part_order);
layer_advanced->Add(text_min_part_order_value);
layer_advanced->Add(slider_max_part_order);
layer_advanced->Add(text_max_part_order_value);
mainWnd->SetFlags(mainWnd->GetFlags() | WF_NOTASKBUTTON);
mainWnd->SetIcon(ImageLoader::Load("freac.pci:0"));
}
