void cfg_layout_t::reset_presets()
{
if (core_api::are_services_available())
{
m_presets.remove_all();
uie::window_ptr wnd, wnd2;
service_ptr_t<uie::splitter_window> splitter, splitter2;
if (uie::window::create_by_guid(columns_ui::panels::guid_horizontal_splitter, wnd) && uie::window::create_by_guid(columns_ui::panels::guid_vertical_splitter, wnd2))
{
if (wnd->service_query_t(splitter) && wnd2->service_query_t(splitter2))
{
uie::splitter_item_simple_t item, item2;
item.set_panel_guid(columns_ui::panels::guid_playlist_switcher);
item2.set_panel_guid(columns_ui::panels::guid_vertical_splitter);
bool val = true;
splitter2->add_panel(&item);
stream_writer_memblock conf1;
splitter2->get_config(&conf1, abort_callback_impl());
item2.set_panel_config(&stream_reader_memblock_ref(conf1.m_data.get_ptr(), conf1.m_data.get_size()), conf1.m_data.get_size());
t_size index = splitter->add_panel(&item2);
splitter->set_config_item(index, uie::splitter_window::bool_locked, &stream_reader_memblock_ref(&val, sizeof(bool)), abort_callback_impl());
val = false;
splitter->set_config_item(index, uie::splitter_window::bool_show_caption, &stream_reader_memblock_ref(&val, sizeof(bool)), abort_callback_impl());
t_uint32 sz = 175;
splitter->set_config_item(index, uie::splitter_window::uint32_size, &stream_reader_memblock_ref(&sz, sizeof(t_uint32)), abort_callback_impl());
item.set_panel_guid(columns_ui::panels::guid_playlist_view_v2);
t_size index_playlist = splitter->add_panel(&item);
splitter->set_config_item(index_playlist, uie::splitter_window::bool_show_caption, &stream_reader_memblock_ref(&val, sizeof(bool)), abort_callback_impl());
preset preset_default;
preset_default.m_name = "Default";
preset_default.m_guid = columns_ui::panels::guid_horizontal_splitter;
stream_writer_memblock_ref conf(preset_default.m_val, true);
splitter->get_config(&conf, abort_callback_impl());
m_active = m_presets.add_item(preset_default);
}
}
if (m_active < m_presets.get_count() && g_layout_window.get_wnd())
{
uie::splitter_item_ptr item;
m_presets[m_active].get(item);
g_layout_window.set_child(item.get_ptr());
}
}
}
bool splitter_window_impl::show_config_popup(HWND wnd, unsigned index)
{
if (is_index_valid(index))
{
uie::window_ptr p_panel = m_panels[index]->m_child;
if (!p_panel.is_valid())
{
uie::window::create_by_guid(m_panels[index]->m_guid, p_panel);
if (p_panel.is_valid())
{
try{
p_panel->set_config(&stream_reader_memblock_ref(&m_panels[index]->m_child_data, m_panels[index]->m_child_data.get_size()), m_panels[index]->m_child_data.get_size(), abort_callback_impl());
}
catch (const exception_io & e)
{
console::formatter() << "Error setting panel config: " << e.what();
}
}
}
if (p_panel.is_valid())
{
if (p_panel->show_config_popup(wnd))
{
m_panels[index]->m_child_data.set_size(0);
p_panel->get_config(&stream_writer_memblock_ref(m_panels[index]->m_child_data), abort_callback_impl());
return true;
}
}
}
return false;
}
void cfg_layout_t::set_data_raw(stream_reader * p_reader, unsigned p_sizehint, abort_callback & p_abort)
{
t_uint32 version;
p_reader->read_lendian_t(version, p_abort);
if (version <= stream_version_current)
{
m_presets.remove_all();
p_reader->read_lendian_t(m_active, p_abort);
unsigned n, count;
p_reader->read_lendian_t(count, p_abort);
for (n = 0; n < count; n++)
{
preset temp;
temp.read(p_reader, p_abort);
m_presets.add_item(temp);
}
if (m_active < m_presets.get_count())
{
uie::splitter_item_simple_t item;
item.set_panel_guid(m_presets[m_active].m_guid);
item.set_panel_config(&stream_reader_memblock_ref(m_presets[m_active].m_val.get_ptr(), m_presets[m_active].m_val.get_size()), m_presets[m_active].m_val.get_size());
g_layout_window.set_child(&item);
}
//m_initialised = m_presets.get_count() > 0;
}
}
virtual bool show_config_popup(HWND wnd_parent)
{
uie::visualisation_ptr p_vis;
service_ptr_t<spectrum_extension> p_this;
get_vis_ptr(p_vis);
if (p_vis.is_valid())
p_this = static_cast<spectrum_extension*>(p_vis.get_ptr());
service_ptr_t<spectrum_extension> p_temp = p_this;
if (!p_temp.is_valid())
uie::visualization::create_by_guid(get_visualisation_guid(), reinterpret_cast<uie::visualisation_ptr &>(p_temp));
pfc::array_t<t_uint8> m_data;
if (!p_temp->b_active)
{
try{
get_vis_data(m_data);
p_temp->set_config(&stream_reader_memblock_ref(m_data.get_ptr(), m_data.get_size()),m_data.get_size(),abort_callback_impl());
}catch (const exception_io &) {};
}
spec_param param(p_temp->cr_fore, p_temp->cr_back, p_temp->mode, p_temp->m_scale, p_temp->m_vertical_scale, p_temp.get_ptr(), true, get_frame_style());
bool rv = !!uDialogBox(IDD_POPUP_SPECTRUM_NEW, wnd_parent, SpectrumPopupProc, (LPARAM)(¶m));
if (rv)
{
p_temp->cr_fore = param.cr_fore;
cfg_vis2 = param.cr_fore;
p_temp->cr_back = param.cr_back;
cfg_vis = param.cr_back;
p_temp->mode = param.mode;
cfg_vis_mode = param.mode;
p_temp->m_scale = param.m_scale;
cfg_scale = param.m_scale;
p_temp->m_vertical_scale = param.m_vertical_scale;
cfg_vertical_scale = param.m_vertical_scale;
set_frame_style(param.frame);
if (p_temp->b_active)
{
p_temp->flush_brushes();
p_temp->clear();
}
else
{
m_data.set_size(0);
try{
p_temp->get_config(&stream_writer_memblock_ref(m_data), abort_callback_impl());
set_vis_data(m_data.get_ptr(), m_data.get_size());
}
catch (pfc::exception &)
{};
}
}
return rv;
}
void uie::splitter_item_t::set(const splitter_item_t & p_source)
{
stream_writer_memblock temp;
{
set_panel_guid(p_source.get_panel_guid());
p_source.get_panel_config(&temp);
set_panel_config(&stream_reader_memblock_ref(temp.m_data.get_ptr(), temp.m_data.get_size()), temp.m_data.get_size());
}
}
void config_object::set_data_raw(const void * p_data,t_size p_bytes, bool p_notify) {
set_data(&stream_reader_memblock_ref(p_data,p_bytes),abort_callback_dummy(),p_notify);
}
LRESULT window_visualisation::on_message(HWND wnd,UINT msg,WPARAM wp,LPARAM lp)
{
if(msg == WM_CREATE)
{
m_wnd = wnd;
long flags = WS_EX_CONTROLPARENT;
if (m_frame == 1) flags |= WS_EX_CLIENTEDGE;
if (m_frame == 2) flags |= WS_EX_STATICEDGE;
uSetWindowLong(wnd, GWL_EXSTYLE, flags);
SetWindowPos(wnd,0,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE|SWP_FRAMECHANGED);
list_vis.add_item(this);
initialised = true;
ui_extension::visualisation::create_by_guid(get_visualisation_guid(), p_vis);
if (p_vis.is_valid())
{
GetClientRect(wnd, &rc_client);
window_visualisation_interface::g_create(m_interface, this);
try{
p_vis->set_config(&stream_reader_memblock_ref(m_data.get_ptr(), m_data.get_size()),m_data.get_size(),abort_callback_impl());
}catch(const exception_io &){};
p_vis->enable(ui_extension::visualisation_host_ptr(m_interface.get_ptr()));
}
}
else if (msg == WM_DESTROY)
{
if (p_vis.is_valid())
p_vis->disable();
flush_bitmap();
m_interface.release();
initialised = false;
list_vis.remove_item(this);
m_wnd=0;
}
else if (msg == WM_PAINT)
{
if (p_vis.is_valid())
{
RECT rc_paint;
if (!GetUpdateRect(wnd, &rc_paint, 0))
{
rc_paint = rc_client;
}
HDC dc = GetDC(wnd);
HDC dc_bmp = CreateCompatibleDC(0);
if (!bm_display) make_bitmap(dc);
HGDIOBJ meh = SelectObject(dc_bmp,bm_display);
BitBlt(dc,0,0,rc_client.right,rc_client.bottom,dc_bmp,0,0,SRCCOPY);
SelectObject(dc_bmp,meh);
DeleteDC(dc_bmp);
ReleaseDC(wnd, dc);
ValidateRect(wnd, &rc_paint);
}
}
else if (msg == WM_WINDOWPOSCHANGED)
{
LPWINDOWPOS lpwp = (LPWINDOWPOS)lp;
if (!(lpwp->flags & SWP_NOSIZE))
{
GetClientRect(wnd, &rc_client);
flush_bitmap();
}
}
else if (msg == WM_ERASEBKGND)
{
return FALSE;
}
return uDefWindowProc(wnd,msg,wp,lp);
}
void g_import_layout(HWND wnd, const char * path, bool quiet)
{
class t_import_feedback_impl : public cui::fcl::t_import_feedback, public pfc::list_t<GUID>
{
public:
virtual void add_required_panel(const char * name, const GUID & guid)
{
add_item(guid);
}
};
//pfc::list_t<t_required_panel> required_panels;
panel_info_list panel_info;
try
{
class t_dataset
{
public:
GUID guid;
pfc::array_t<t_uint8> data;
};
service_ptr_t<file> p_file;
abort_callback_impl p_abort;
filesystem::g_open_read(p_file, path, p_abort);
GUID guid;
t_uint32 version;
p_file->read_lendian_t(guid, p_abort);
if (guid != g_fcl_header)
throw pfc::exception("Unrecognised file header");
p_file->read_lendian_t(version, p_abort);
if (version > fcl_stream_version)
throw pfc::exception("Need a newer version of Columns UI");
t_uint32 mode = cui::fcl::type_public;
if (version >= 1)
p_file->read_lendian_t(mode, p_abort);
{
pfc::list_t<bool> mask;
t_size i, count;
p_file->read_lendian_t(count, p_abort);
for (i=0; i<count; i++)
{
t_panel_info info;
p_file->read_lendian_t(info.guid, p_abort);
p_file->read_string(info.name, p_abort);
panel_info.add_item(info);
uie::window_ptr ptr;
mask.add_item(uie::window::create_by_guid(info.guid, ptr));
}
panel_info.remove_mask(mask.get_ptr());
}
{
t_size count = panel_info.get_count();
if (count)
{
throw exception_fcl_dependentpanelmissing();
/*pfc::string8 msg, name;
msg << "Import aborted: The following required panels are not present.\r\n\r\nGUID, Name\r\n";
t_size i, count = panel_info.get_count();
for (i=0; i<count; i++)
{
msg << pfc::print_guid(panel_info[i].guid);
msg << ", " << panel_info[i].name;
msg << "\r\n";
//required_panels.add_item(t_required_panel(
}
throw pfc::exception(msg);*/
}
}
{
cui::fcl::dataset_list export_items;
t_size i, count;
p_file->read_lendian_t(count, p_abort);
t_import_feedback_impl feed;
pfc::array_t< pfc::array_t<t_uint32> > panel_indices;
panel_indices.set_count(count);
pfc::array_t< t_dataset > datasets;
datasets.set_count(count);
for (i=0; i<count; i++)
{
//GUID guiditem;
pfc::string8 name;
p_file->read_lendian_t(datasets[i].guid, p_abort);
p_file->read_string(name, p_abort);
t_uint32 pcount, j;
p_file->read_lendian_t(pcount, p_abort);
panel_indices[i].set_count(pcount);
for (j=0; j<pcount; j++)
p_file->read_lendian_t(panel_indices[i][j], p_abort);
//pfc::array_t<t_uint8> data;
t_size size;
p_file->read_lendian_t(size, p_abort);
datasets[i].data.set_size(size);
p_file->read(datasets[i].data.get_ptr(), size, p_abort);
}
pfc::list_t<GUID> datasetsguids;
for (i=0; i<count; i++)
datasetsguids.add_item(datasets[i].guid);
FCLDialog pFCLDialog(true, datasetsguids);
if (!quiet) {
if (!uDialogBox(IDD_FCL, wnd, FCLDialog::g_FCLDialogProc, (LPARAM)&pFCLDialog))
throw exception_aborted();
}
ui_helpers::DisableRedrawScope p_NoRedraw(g_main_window);
for (i = 0; i<count; i++)
{
cui::fcl::dataset_ptr ptr;
if (export_items.find_by_guid(datasets[i].guid, ptr) && (quiet || pFCLDialog.have_node_checked(ptr->get_group())))
ptr->set_data(&stream_reader_memblock_ref(datasets[i].data.get_ptr(), datasets[i].data.get_size()), datasets[i].data.get_size(), mode, feed, p_abort);
}
if (feed.get_count())
{
throw pfc::exception("Bug check: panels missing");
}
}
}
catch (const exception_aborted &)
{
}
catch (const exception_fcl_dependentpanelmissing &)
{
t_import_results_data data(panel_info, true);
ShowWindow(uCreateDialog(IDD_RESULTS, wnd, g_ImportResultsProc, (LPARAM)&data), SW_SHOWNORMAL);
}
catch (const pfc::exception & ex)
{
popup_message::g_show(ex.what(), "Error");
};
}
void splitter_window_impl::refresh_children()
{
unsigned n, count = m_panels.get_count(), size_cumulative = 0;
pfc::array_t<bool> new_items;
new_items.set_count(count);
new_items.fill_null();
for (n = 0; n<count; n++)
{
if (!m_panels[n]->m_wnd)
{
uie::window_ptr p_ext;
p_ext = m_panels[n]->m_child;
bool b_new = false;
if (!p_ext.is_valid())
{
ui_extension::window::create_by_guid(m_panels[n]->m_guid, p_ext);
b_new = true;
}
if (!m_panels[n]->m_interface.is_valid())
{
service_ptr_t<service_base> temp;
g_splitter_host_vert.instance_create(temp);
uie::window_host_ptr ptr;
if (temp->service_query_t(ptr))
{
m_panels[n]->m_interface = static_cast<splitter_host_impl*>(ptr.get_ptr());
m_panels[n]->m_interface->set_window_ptr(this);
}
}
if (p_ext.is_valid() && p_ext->is_available(uie::window_host_ptr(static_cast<uie::window_host*>(m_panels[n]->m_interface.get_ptr()))))
{
pfc::string8 name;
if (m_panels[n]->m_use_custom_title)
{
name = m_panels[n]->m_custom_title;
}
else
{
if (!p_ext->get_short_name(name))
p_ext->get_name(name);
}
HWND wnd_host = m_panels[n]->m_container.create(m_wnd);
m_panels[n]->m_container.set_window_ptr(this);
uSetWindowText(wnd_host, name);
if (wnd_host)
{
if (b_new)
{
try {
p_ext->set_config(&stream_reader_memblock_ref(m_panels[n]->m_child_data.get_ptr(), m_panels[n]->m_child_data.get_size()), m_panels[n]->m_child_data.get_size(), abort_callback_impl());
}
catch (const exception_io & e)
{
console::formatter() << "Error setting panel config: " << e.what();
}
}
HWND wnd_panel = p_ext->create_or_transfer_window(wnd_host, uie::window_host_ptr(m_panels[n]->m_interface.get_ptr())); //FIXX
if (wnd_panel)
{
SetWindowLongPtr(wnd_panel, GWL_STYLE, GetWindowLongPtr(wnd_panel, GWL_STYLE) | WS_CLIPSIBLINGS);
MINMAXINFO mmi;
memset(&mmi, 0, sizeof(MINMAXINFO));
mmi.ptMaxTrackSize.x = MAXLONG;
mmi.ptMaxTrackSize.y = MAXLONG;
uSendMessage(wnd_panel, WM_GETMINMAXINFO, 0, (LPARAM)&mmi);
clip_minmaxinfo(mmi);
m_panels[n]->m_wnd = wnd_host;
m_panels[n]->m_wnd_child = wnd_panel;
m_panels[n]->m_child = p_ext;
m_panels[n]->m_size_limits.min_height = mmi.ptMinTrackSize.y;
m_panels[n]->m_size_limits.min_width = mmi.ptMinTrackSize.x;
m_panels[n]->m_size_limits.max_width = mmi.ptMaxTrackSize.x;
m_panels[n]->m_size_limits.max_height = mmi.ptMaxTrackSize.y;
/*console::formatter() << "name: " << name <<
" min width: " << (t_int32)mmi.ptMinTrackSize.x
<< " min height: " << (t_int32)mmi.ptMinTrackSize.y
<< " max width: " << (t_int32)mmi.ptMaxTrackSize.y
<< " max height: " << (t_int32)mmi.ptMaxTrackSize.y;*/
}
else
{
m_panels[n]->m_container.destroy();
}
}
}
new_items[n] = true;//b_new;
}
}
on_size_changed();
if (IsWindowVisible(get_wnd()))
{
for (n = 0; n<count; n++)
{
if (new_items[n])
{
ShowWindow(m_panels[n]->m_wnd_child, SW_SHOWNORMAL);
ShowWindow(m_panels[n]->m_wnd, SW_SHOWNORMAL);
}
}
get_host()->on_size_limit_change(get_wnd(), uie::size_limit_all);
RedrawWindow(get_wnd(), 0, 0, RDW_UPDATENOW | RDW_ALLCHILDREN);
}
}
void cfg_layout_t::preset::get(uie::splitter_item_ptr & p_out)
{
p_out = new uie::splitter_item_simple_t;
p_out->set_panel_guid(m_guid);
p_out->set_panel_config(&stream_reader_memblock_ref(m_val.get_ptr(), m_val.get_size()), m_val.get_size());
}
void layout_window::g_get_default_presets(pfc::list_t<cfg_layout_t::preset> & p_out)
{
{
uie::window_ptr wnd, wnd2, wnd3;
service_ptr_t<uie::splitter_window> splitter, splitter2, splitter3;
if (uie::window::create_by_guid(columns_ui::panels::guid_horizontal_splitter, wnd) && uie::window::create_by_guid(columns_ui::panels::guid_vertical_splitter, wnd2))
{
if (wnd->service_query_t(splitter) && wnd2->service_query_t(splitter2))
{
uie::splitter_item_simple_t item, item2;
item.set_panel_guid(columns_ui::panels::guid_playlist_switcher);
item2.set_panel_guid(columns_ui::panels::guid_vertical_splitter);
bool val = true;
splitter2->add_panel(&item);
stream_writer_memblock conf1;
splitter2->get_config(&conf1, abort_callback_impl());
item2.set_panel_config(&stream_reader_memblock_ref(conf1.m_data.get_ptr(), conf1.m_data.get_size()), conf1.m_data.get_size());
t_size index = splitter->add_panel(&item2);
splitter->set_config_item(index, uie::splitter_window::bool_locked, &stream_reader_memblock_ref(&val, sizeof(bool)), abort_callback_impl());
val = false;
splitter->set_config_item(index, uie::splitter_window::bool_show_caption, &stream_reader_memblock_ref(&val, sizeof(bool)), abort_callback_impl());
t_uint32 sz = 175;
splitter->set_config_item(index, uie::splitter_window::uint32_size, &stream_reader_memblock_ref(&sz, sizeof(t_uint32)), abort_callback_impl());
item.set_panel_guid(columns_ui::panels::guid_playlist_view_v2);
t_size index_playlist = splitter->add_panel(&item);
splitter->set_config_item(index_playlist, uie::splitter_window::bool_show_caption, &stream_reader_memblock_ref(&val, sizeof(bool)), abort_callback_impl());
cfg_layout_t::preset preset_default;
preset_default.m_name = "NG Playlist + Playlist Switcher";
preset_default.m_guid = columns_ui::panels::guid_horizontal_splitter;
stream_writer_memblock_ref conf(preset_default.m_val, true);
splitter->get_config(&conf, abort_callback_impl());
p_out.add_item(preset_default);
}
}
}
{
uie::window_ptr wnd, wnd2, wnd3, wnd_filter_splitter;
service_ptr_t<uie::splitter_window> splitter, splitter2, splitter3, splitter_filter;
if (uie::window::create_by_guid(columns_ui::panels::guid_horizontal_splitter, wnd) && uie::window::create_by_guid(columns_ui::panels::guid_vertical_splitter, wnd2) && uie::window::create_by_guid(columns_ui::panels::guid_vertical_splitter, wnd3)
&& uie::window::create_by_guid(columns_ui::panels::guid_horizontal_splitter, wnd_filter_splitter))
{
if (wnd->service_query_t(splitter) && wnd2->service_query_t(splitter2) && wnd3->service_query_t(splitter3)
&& wnd_filter_splitter->service_query_t(splitter_filter))
{
uie::splitter_item_simple_t item, item2, item3, item_filter, item_filter_splitter, item_artwork;
item.set_panel_guid(columns_ui::panels::guid_playlist_switcher);
item2.set_panel_guid(columns_ui::panels::guid_vertical_splitter);
item3.set_panel_guid(columns_ui::panels::guid_vertical_splitter);
item_filter_splitter.set_panel_guid(columns_ui::panels::guid_horizontal_splitter);
item_filter.set_panel_guid(columns_ui::panels::guid_filter);
item_artwork.set_panel_guid(columns_ui::panels::guid_artwork_view);;
bool val = true;
splitter2->add_panel(&item);
stream_writer_memblock conf1, conf2, conf3;
splitter2->get_config(&conf1, abort_callback_impl());
item2.set_panel_config(&stream_reader_memblock_ref(conf1.m_data.get_ptr(), conf1.m_data.get_size()), conf1.m_data.get_size());
t_size index = splitter->add_panel(&item2);
splitter->set_config_item(index, uie::splitter_window::bool_locked, &stream_reader_memblock_ref(&val, sizeof(bool)), abort_callback_impl());
val = false;
splitter->set_config_item(index, uie::splitter_window::bool_show_caption, &stream_reader_memblock_ref(&val, sizeof(bool)), abort_callback_impl());
t_uint32 sz = 175;
splitter->set_config_item(index, uie::splitter_window::uint32_size, &stream_reader_memblock_ref(&sz, sizeof(t_uint32)), abort_callback_impl());
t_size index_filter = splitter_filter->add_panel(&item_filter);
splitter_filter->set_config_item_t(index_filter, uie::splitter_window::bool_show_caption, val, abort_callback_dummy());
index_filter = splitter_filter->add_panel(&item_filter);
splitter_filter->set_config_item_t(index_filter, uie::splitter_window::bool_show_caption, val, abort_callback_dummy());
index_filter = splitter_filter->add_panel(&item_filter);
splitter_filter->set_config_item_t(index_filter, uie::splitter_window::bool_show_caption, val, abort_callback_dummy());
{
splitter_filter->get_config(&conf3, abort_callback_impl());
item_filter_splitter.set_panel_config(&stream_reader_memblock_ref(conf3.m_data.get_ptr(), conf3.m_data.get_size()), conf3.m_data.get_size());
t_size indexfs = splitter3->add_panel(&item_filter_splitter);
splitter3->set_config_item_t(indexfs, uie::splitter_window::bool_show_caption, val, abort_callback_dummy());
bool temp = true;
splitter3->set_config_item_t(indexfs, uie::splitter_window::bool_locked, temp, abort_callback_dummy());
t_uint32 size = 175;
splitter3->set_config_item_t(indexfs, uie::splitter_window::uint32_size, size, abort_callback_dummy());
}
item.set_panel_guid(columns_ui::panels::guid_playlist_view_v2);
t_size index_playlist = splitter3->add_panel(&item);
splitter3->set_config_item(index_playlist, uie::splitter_window::bool_show_caption, &stream_reader_memblock_ref(&val, sizeof(bool)), abort_callback_impl());
splitter3->get_config(&conf2, abort_callback_impl());
item3.set_panel_config(&stream_reader_memblock_ref(conf2.m_data.get_ptr(), conf2.m_data.get_size()), conf2.m_data.get_size());
t_size index_splitter2 = splitter->add_panel(&item3);
splitter->set_config_item_t(index_splitter2, uie::splitter_window::bool_show_caption, val, abort_callback_dummy());
cfg_layout_t::preset preset_default;
preset_default.m_name = "NG Playlist + Playlist Switcher + Filters";
preset_default.m_guid = columns_ui::panels::guid_horizontal_splitter;
stream_writer_memblock_ref conf(preset_default.m_val, true);
splitter->get_config(&conf, abort_callback_impl());
p_out.add_item(preset_default);
index = splitter2->add_panel(&item_artwork);
bool b_true = true;
splitter2->set_config_item_t(index, uie::splitter_window::bool_show_caption, val, abort_callback_dummy());
splitter2->set_config_item_t(index, uie::splitter_window::bool_locked, b_true, abort_callback_dummy());
splitter2->set_config_item_t(index, uie::splitter_window::uint32_size, sz, abort_callback_dummy());
conf1.m_data.set_size(0);
splitter2->get_config(&conf1, abort_callback_impl());
item2.set_panel_config(&stream_reader_memblock_ref(conf1.m_data.get_ptr(), conf1.m_data.get_size()), conf1.m_data.get_size());
splitter->replace_panel(0, &item2);
splitter->set_config_item(0, uie::splitter_window::bool_locked, &stream_reader_memblock_ref(&b_true, sizeof(bool)), abort_callback_impl());
splitter->set_config_item(0, uie::splitter_window::bool_show_caption, &stream_reader_memblock_ref(&val, sizeof(bool)), abort_callback_impl());
splitter->set_config_item(0, uie::splitter_window::uint32_size, &stream_reader_memblock_ref(&sz, sizeof(t_uint32)), abort_callback_impl());
preset_default.m_name = "NG Playlist + Playlist Switcher + Artwork + Filters";
preset_default.m_val.set_size(0);
splitter->get_config(&conf, abort_callback_impl());
t_size index_preset = p_out.add_item(preset_default);
splitter3->remove_panel(0);
conf2.m_data.set_size(0);
splitter3->get_config(&conf2, abort_callback_impl());
item3.set_panel_config(&stream_reader_memblock_ref(conf2.m_data.get_ptr(), conf2.m_data.get_size()), conf2.m_data.get_size());
splitter->replace_panel(index_splitter2, &item3);
splitter->set_config_item_t(index_splitter2, uie::splitter_window::bool_show_caption, false, abort_callback_dummy());
preset_default.m_name = "NG Playlist + Playlist Switcher + Artwork";
splitter->get_config(&stream_writer_memblock_ref(preset_default.m_val, true), abort_callback_dummy());
p_out.insert_item(preset_default, index_preset);
}
}
}
{
uie::window_ptr wnd, wnd2, wnd3, wnd_filter_splitter, wnd_bottom_splitter;
service_ptr_t<uie::splitter_window> splitter, splitter2, splitter3, splitter_filter, splitter_bottom;
if (uie::window::create_by_guid(columns_ui::panels::guid_horizontal_splitter, wnd) && uie::window::create_by_guid(columns_ui::panels::guid_vertical_splitter, wnd2) && uie::window::create_by_guid(columns_ui::panels::guid_vertical_splitter, wnd3)
&& uie::window::create_by_guid(columns_ui::panels::guid_horizontal_splitter, wnd_filter_splitter)
&& uie::window::create_by_guid(columns_ui::panels::guid_horizontal_splitter, wnd_bottom_splitter))
{
if (wnd->service_query_t(splitter) && wnd2->service_query_t(splitter2) && wnd3->service_query_t(splitter3)
&& wnd_filter_splitter->service_query_t(splitter_filter)
&& wnd_bottom_splitter->service_query_t(splitter_bottom))
{
uie::splitter_item_simple_t item, item2, item3, item_filter, item_filter_splitter, item_artwork, item_bottom_splitter, item_item_details;
item.set_panel_guid(columns_ui::panels::guid_playlist_switcher);
item2.set_panel_guid(columns_ui::panels::guid_vertical_splitter);
item3.set_panel_guid(columns_ui::panels::guid_vertical_splitter);
item_filter_splitter.set_panel_guid(columns_ui::panels::guid_horizontal_splitter);
item_bottom_splitter.set_panel_guid(columns_ui::panels::guid_horizontal_splitter);
item_filter.set_panel_guid(columns_ui::panels::guid_filter);
item_artwork.set_panel_guid(columns_ui::panels::guid_artwork_view);
item_item_details.set_panel_guid(columns_ui::panels::guid_item_details);
bool val = true;
splitter2->add_panel(&item);
stream_writer_memblock conf1, conf2, conf3, conf4;
splitter2->get_config(&conf1, abort_callback_impl());
item2.set_panel_config(&stream_reader_memblock_ref(conf1.m_data.get_ptr(), conf1.m_data.get_size()), conf1.m_data.get_size());
t_size index = splitter->add_panel(&item2);
splitter->set_config_item(index, uie::splitter_window::bool_locked, &stream_reader_memblock_ref(&val, sizeof(bool)), abort_callback_impl());
val = false;
splitter->set_config_item(index, uie::splitter_window::bool_show_caption, &stream_reader_memblock_ref(&val, sizeof(bool)), abort_callback_impl());
t_uint32 sz = 175;
splitter->set_config_item(index, uie::splitter_window::uint32_size, &stream_reader_memblock_ref(&sz, sizeof(t_uint32)), abort_callback_impl());
t_size index_filter = splitter_filter->add_panel(&item_filter);
splitter_filter->set_config_item_t(index_filter, uie::splitter_window::bool_show_caption, val, abort_callback_dummy());
index_filter = splitter_filter->add_panel(&item_filter);
splitter_filter->set_config_item_t(index_filter, uie::splitter_window::bool_show_caption, val, abort_callback_dummy());
index_filter = splitter_filter->add_panel(&item_filter);
splitter_filter->set_config_item_t(index_filter, uie::splitter_window::bool_show_caption, val, abort_callback_dummy());
{
splitter_filter->get_config(&conf3, abort_callback_impl());
item_filter_splitter.set_panel_config(&stream_reader_memblock_ref(conf3.m_data.get_ptr(), conf3.m_data.get_size()), conf3.m_data.get_size());
}
item.set_panel_guid(columns_ui::panels::guid_playlist_view_v2);
t_size index_playlist = splitter3->add_panel(&item);
splitter3->set_config_item(index_playlist, uie::splitter_window::bool_show_caption, &stream_reader_memblock_ref(&val, sizeof(bool)), abort_callback_impl());
{
t_size index = splitter_bottom->add_panel(&item_item_details);
splitter_bottom->set_config_item_t(index, uie::splitter_window::bool_show_caption, bool(false), abort_callback_dummy());
index = splitter_bottom->add_panel(&item_artwork);
splitter_bottom->set_config_item_t(index, uie::splitter_window::bool_show_caption, bool(false), abort_callback_dummy());
splitter_bottom->set_config_item_t(index, uie::splitter_window::uint32_size, t_size(125), abort_callback_dummy());
splitter_bottom->set_config_item_t(index, uie::splitter_window::bool_locked, bool(true), abort_callback_dummy());
splitter_bottom->get_config(&conf4, abort_callback_impl());
item_bottom_splitter.set_panel_config(&stream_reader_memblock_ref(conf4.m_data.get_ptr(), conf4.m_data.get_size()), conf4.m_data.get_size());
index = splitter3->add_panel(&item_bottom_splitter);
splitter3->set_config_item_t(index, uie::splitter_window::bool_show_caption, bool(false), abort_callback_dummy());
splitter3->set_config_item_t(index, uie::splitter_window::bool_locked, bool(true), abort_callback_dummy());
splitter3->set_config_item_t(index, uie::splitter_window::uint32_size, t_size(125), abort_callback_dummy());
}
splitter3->get_config(&conf2, abort_callback_impl());
item3.set_panel_config(&stream_reader_memblock_ref(conf2.m_data.get_ptr(), conf2.m_data.get_size()), conf2.m_data.get_size());
t_size index_splitter2 = splitter->add_panel(&item3);
splitter->set_config_item_t(index_splitter2, uie::splitter_window::bool_show_caption, val, abort_callback_dummy());
cfg_layout_t::preset preset_default;
preset_default.m_name = "NG Playlist + Playlist Switcher + Item Details + Artwork";
preset_default.m_guid = columns_ui::panels::guid_horizontal_splitter;
stream_writer_memblock_ref conf(preset_default.m_val, true);
splitter->get_config(&conf, abort_callback_impl());
p_out.add_item(preset_default);
{
t_size indexfs = 0;
splitter3->insert_panel(0, &item_filter_splitter);
splitter3->set_config_item_t(indexfs, uie::splitter_window::bool_show_caption, false, abort_callback_dummy());
splitter3->set_config_item_t(indexfs, uie::splitter_window::bool_locked, true, abort_callback_dummy());
t_uint32 size = 175;
splitter3->set_config_item_t(indexfs, uie::splitter_window::uint32_size, size, abort_callback_dummy());
}
conf2.m_data.set_size(0);
splitter3->get_config(&conf2, abort_callback_impl());
item3.set_panel_config(&stream_reader_memblock_ref(conf2.m_data.get_ptr(), conf2.m_data.get_size()), conf2.m_data.get_size());
//t_size index_splitter2 =
splitter->replace_panel(1, &item3);
splitter->set_config_item_t(1, uie::splitter_window::bool_show_caption, false, abort_callback_dummy());
cfg_layout_t::preset preset_default2;
preset_default2.m_name = "NG Playlist + Playlist Switcher + Filters + Item Details + Artwork";
preset_default2.m_guid = columns_ui::panels::guid_horizontal_splitter;
stream_writer_memblock_ref conft(preset_default2.m_val, true);
splitter->get_config(&conft, abort_callback_impl());
p_out.add_item(preset_default2);
}
}
}
{
uie::window_ptr wnd;
service_ptr_t<uie::splitter_window> splitter;
if (uie::window::create_by_guid(columns_ui::panels::guid_playlist_tabs, wnd))
{
if (wnd->service_query_t(splitter))
{
uie::splitter_item_simple_t item;
item.set_panel_guid(columns_ui::panels::guid_playlist_view_v2);
splitter->add_panel(&item);
cfg_layout_t::preset preset_default;
preset_default.m_name = "NG Playlist + Playlist Tabs";
preset_default.m_guid = columns_ui::panels::guid_playlist_tabs;
stream_writer_memblock_ref conf(preset_default.m_val, true);
splitter->get_config(&conf, abort_callback_impl());
//m_active = pfc_infinite;
p_out.add_item(preset_default);
}
}
}
{
uie::window_ptr wnd, wnd2, wnd3, wnd_filter_splitter, wnd_bottom_splitter;
service_ptr_t<uie::splitter_window> splitter, splitter_tabs, splitter3, splitter_filter, splitter_bottom;
if (uie::window::create_by_guid(columns_ui::panels::guid_horizontal_splitter, wnd) && uie::window::create_by_guid(columns_ui::panels::guid_playlist_tabs, wnd2) && uie::window::create_by_guid(columns_ui::panels::guid_vertical_splitter, wnd3)
&& uie::window::create_by_guid(columns_ui::panels::guid_horizontal_splitter, wnd_filter_splitter)
&& uie::window::create_by_guid(columns_ui::panels::guid_horizontal_splitter, wnd_bottom_splitter))
{
if (wnd->service_query_t(splitter) && wnd2->service_query_t(splitter_tabs) && wnd3->service_query_t(splitter3)
&& wnd_filter_splitter->service_query_t(splitter_filter)
&& wnd_bottom_splitter->service_query_t(splitter_bottom))
{
uie::splitter_item_simple_t item_tabs, item, item3, item_filter, item_filter_splitter, item_artwork, item_bottom_splitter, item_item_details;
item_tabs.set_panel_guid(columns_ui::panels::guid_playlist_tabs);
item3.set_panel_guid(columns_ui::panels::guid_vertical_splitter);
item_filter_splitter.set_panel_guid(columns_ui::panels::guid_horizontal_splitter);
item_bottom_splitter.set_panel_guid(columns_ui::panels::guid_horizontal_splitter);
item_filter.set_panel_guid(columns_ui::panels::guid_filter);
item_artwork.set_panel_guid(columns_ui::panels::guid_artwork_view);
item_item_details.set_panel_guid(columns_ui::panels::guid_item_details);
bool val = true;
stream_writer_memblock conf1, conf2, conf3, conf4;
val = false;
t_uint32 sz = 175;
t_size index_filter = splitter_filter->add_panel(&item_filter);
splitter_filter->set_config_item_t(index_filter, uie::splitter_window::bool_show_caption, val, abort_callback_dummy());
index_filter = splitter_filter->add_panel(&item_filter);
splitter_filter->set_config_item_t(index_filter, uie::splitter_window::bool_show_caption, val, abort_callback_dummy());
index_filter = splitter_filter->add_panel(&item_filter);
splitter_filter->set_config_item_t(index_filter, uie::splitter_window::bool_show_caption, val, abort_callback_dummy());
{
splitter_filter->get_config(&conf3, abort_callback_impl());
item_filter_splitter.set_panel_config(&stream_reader_memblock_ref(conf3.m_data.get_ptr(), conf3.m_data.get_size()), conf3.m_data.get_size());
t_size indexfs = splitter3->add_panel(&item_filter_splitter);
splitter3->set_config_item_t(indexfs, uie::splitter_window::bool_show_caption, val, abort_callback_dummy());
bool temp = true;
splitter3->set_config_item_t(indexfs, uie::splitter_window::bool_locked, temp, abort_callback_dummy());
t_uint32 size = 175;
splitter3->set_config_item_t(indexfs, uie::splitter_window::uint32_size, size, abort_callback_dummy());
}
item.set_panel_guid(columns_ui::panels::guid_playlist_view_v2);
t_size index_playlist = splitter_tabs->add_panel(&item);
splitter_tabs->get_config(&conf1, abort_callback_impl());
item_tabs.set_panel_config(&stream_reader_memblock_ref(conf1.m_data.get_ptr(), conf1.m_data.get_size()), conf1.m_data.get_size());
t_size index_tabs = splitter3->add_panel(&item_tabs);
splitter3->set_config_item_t(index_tabs, uie::splitter_window::bool_show_caption, false, abort_callback_impl());
splitter3->get_config(&conf2, abort_callback_impl());
item3.set_panel_config(&stream_reader_memblock_ref(conf2.m_data.get_ptr(), conf2.m_data.get_size()), conf2.m_data.get_size());
t_size index_splitter2 = splitter->add_panel(&item3);
splitter->set_config_item_t(index_splitter2, uie::splitter_window::bool_show_caption, val, abort_callback_dummy());
cfg_layout_t::preset preset_default;
preset_default.m_name = "NG Playlist + Playlist Tabs + Filters";
preset_default.m_guid = columns_ui::panels::guid_horizontal_splitter;
stream_writer_memblock_ref conf(preset_default.m_val, true);
splitter->get_config(&conf, abort_callback_impl());
p_out.add_item(preset_default);
{
t_size index = splitter_bottom->add_panel(&item_item_details);
splitter_bottom->set_config_item_t(index, uie::splitter_window::bool_show_caption, bool(false), abort_callback_dummy());
index = splitter_bottom->add_panel(&item_artwork);
splitter_bottom->set_config_item_t(index, uie::splitter_window::bool_show_caption, bool(false), abort_callback_dummy());
splitter_bottom->set_config_item_t(index, uie::splitter_window::uint32_size, t_size(125), abort_callback_dummy());
splitter_bottom->set_config_item_t(index, uie::splitter_window::bool_locked, bool(true), abort_callback_dummy());
splitter_bottom->get_config(&conf4, abort_callback_impl());
item_bottom_splitter.set_panel_config(&stream_reader_memblock_ref(conf4.m_data.get_ptr(), conf4.m_data.get_size()), conf4.m_data.get_size());
index = splitter3->add_panel(&item_bottom_splitter);
splitter3->set_config_item_t(index, uie::splitter_window::bool_show_caption, bool(false), abort_callback_dummy());
splitter3->set_config_item_t(index, uie::splitter_window::bool_locked, bool(true), abort_callback_dummy());
splitter3->set_config_item_t(index, uie::splitter_window::uint32_size, t_size(125), abort_callback_dummy());
}
conf2.m_data.set_size(0);
splitter3->get_config(&conf2, abort_callback_impl());
item3.set_panel_config(&stream_reader_memblock_ref(conf2.m_data.get_ptr(), conf2.m_data.get_size()), conf2.m_data.get_size());
splitter->replace_panel(index_splitter2, &item3);
splitter->set_config_item_t(index_splitter2, uie::splitter_window::bool_show_caption, false, abort_callback_dummy());
preset_default.m_name = "NG Playlist + Playlist Tabs + Filters + Item Details + Artwork";
preset_default.m_guid = columns_ui::panels::guid_horizontal_splitter;
splitter->get_config(&stream_writer_memblock_ref(preset_default.m_val, true), abort_callback_impl());
t_size preset_tabs_all = p_out.add_item(preset_default);
splitter3->remove_panel(0);
conf2.m_data.set_size(0);
splitter3->get_config(&conf2, abort_callback_impl());
item3.set_panel_config(&stream_reader_memblock_ref(conf2.m_data.get_ptr(), conf2.m_data.get_size()), conf2.m_data.get_size());
splitter->replace_panel(index_splitter2, &item3);
splitter->set_config_item_t(index_splitter2, uie::splitter_window::bool_show_caption, false, abort_callback_dummy());
preset_default.m_name = "NG Playlist + Playlist Tabs + Item Details + Artwork";
preset_default.m_guid = columns_ui::panels::guid_horizontal_splitter;
splitter->get_config(&stream_writer_memblock_ref(preset_default.m_val, true), abort_callback_impl());
p_out.insert_item(preset_default, preset_tabs_all);
}
}
}
}
virtual void set_data (stream_reader * p_reader, t_size stream_size, t_uint32 type, cui::fcl::t_import_feedback & feedback, abort_callback & p_abort)
{
fcl::reader reader(p_reader, stream_size, p_abort);
t_uint32 element_id;
t_uint32 element_size;
while (reader.get_remaining())
{
reader.read_item(element_id);
reader.read_item(element_size);
pfc::array_t<t_uint8> data;
data.set_size(element_size);
reader.read(data.get_ptr(), data.get_size());
switch (element_id)
{
case identifier_global_items:
g_fonts_manager_data.m_common_items_entry->import(&stream_reader_memblock_ref(data), data.get_size(), type, p_abort);
break;
case identifier_global_labels:
g_fonts_manager_data.m_common_labels_entry->import(&stream_reader_memblock_ref(data), data.get_size(), type, p_abort);
break;
case identifier_client_entries:
{
stream_reader_memblock_ref stream2(data);
fcl::reader reader2(&stream2, data.get_size(), p_abort);
t_size count, i;
reader2.read_item(count);
g_fonts_manager_data.m_entries.remove_all();
g_fonts_manager_data.m_entries.set_count(count);
for (i=0; i<count; i++)
{
t_uint32 element_id2;
t_uint32 element_size2;
reader2.read_item(element_id2);
reader2.read_item(element_size2);
if (element_id2 == identifier_client_entry)
{
pfc::array_t<t_uint8> data2;
data2.set_size(element_size2);
reader2.read(data2.get_ptr(), data2.get_size());
g_fonts_manager_data.m_entries[i] = new fonts_manager_data::entry_t;
g_fonts_manager_data.m_entries[i]->import(&stream_reader_memblock_ref(data2), data2.get_size(), type, p_abort);
}
else
reader2.skip(element_size2);
}
}
break;
default:
reader.skip(element_size);
break;
};
}
if (g_tab_appearance_fonts.is_active())
{
g_tab_appearance_fonts.update_mode_combobox();
g_tab_appearance_fonts.update_font_desc();
g_tab_appearance_fonts.update_change();
}
g_fonts_manager_data.g_on_common_font_changed(pfc_infinite);
service_enum_t<cui::fonts::client> font_enum;
cui::fonts::client::ptr ptr;
while (font_enum.next(ptr))
ptr->on_font_changed();
}
///don't pass smartptrs by reference as they may be nuked when destroying stuff
void g_run_live_edit_contextmenu(HWND wnd, POINT pt_menu, window_transparent_fill & p_overlay, const RECT & rc_overlay, uie::window_ptr ptr, uie::splitter_window_ptr p_container, t_size index, uie::window_host_ptr & p_host)
{
//console::print("g_run_live_edit_contextmenu");
//if (!m_trans_fill.get_wnd())
{
HWND wnd_over = p_overlay.create(wnd, 0, ui_helpers::window_position_t(rc_overlay));
HWND wnd_root = (GetAncestor(wnd, GA_ROOT));
//HWND wnd_next = GetWindow(wnd_root, GW_HWNDNEXT);
WindowEnum_t WindowEnum(wnd_root);
WindowEnum.run();
//console::formatter() << WindowEnum.m_wnd_list.get_count() << pfc::format_hex((t_size)wnd_root, 8) << " " << pfc::format_hex((t_size)wnd_next, 8);
//SetWindowPos(wnd_over, GetWindow(GetAncestor(wnd, GA_ROOT), GW_HWNDNEXT), 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE);
t_size count_owned = WindowEnum.m_wnd_list.get_count();
if (count_owned)
{
//console::formatter() << count_owned << " " << pfc::format_hex((t_uint32)WindowEnum.m_wnd_list[count_owned-1]) << " " << string_utf8_from_window(WindowEnum.m_wnd_list[count_owned-1]);
SetWindowPos(wnd_over, WindowEnum.m_wnd_list[count_owned-1], 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOOWNERZORDER);
}
ShowWindow(wnd_over, SW_SHOWNOACTIVATE);
HMENU menu = CreatePopupMenu();
HMENU menu_change = CreatePopupMenu();
uie::window_info_list_simple panels;
g_get_panel_list(panels, p_host);
enum {ID_CLOSE= 1, ID_CHANGE_BASE = 2};
uie::splitter_window_ptr p_splitter;
if (ptr.is_valid())
ptr->service_query_t(p_splitter);
g_append_menu_panels(menu_change, panels, ID_CHANGE_BASE);
pfc::string8 temp;
if (ptr.is_valid())
ptr->get_name(temp);
uAppendMenu(menu, MF_STRING|MF_GRAYED, (UINT_PTR)0, temp);
//uAppendMenu(menu, MF_MENUBREAK, (UINT_PTR)0, NULL);
const UINT_PTR ID_ADD_BASE = ID_CHANGE_BASE + panels.get_count();
const UINT_PTR ID_CHANGE_SPLITTER_BASE = ID_ADD_BASE + panels.get_count();
const UINT_PTR ID_PARENT_ADD_BASE = ID_CHANGE_SPLITTER_BASE + panels.get_count();
if (p_splitter.is_valid())
{
if (p_splitter->get_panel_count() < p_splitter->get_maximum_panel_count())
{
HMENU menu_add = CreatePopupMenu();
g_append_menu_panels(menu_add, panels, ID_ADD_BASE);
AppendMenu(menu, MF_STRING|MF_POPUP, (UINT_PTR)menu_add, L"Add panel");
}
HMENU menu_change = CreatePopupMenu();
g_append_menu_splitters(menu_change, panels, ID_CHANGE_SPLITTER_BASE);
AppendMenu(menu, MF_STRING|MF_POPUP, (UINT_PTR)menu_change, L"Change splitter");
}
AppendMenu(menu, MF_STRING|MF_POPUP, (UINT_PTR)menu_change, L"Change panel");
AppendMenu(menu, MF_STRING, ID_CLOSE, L"Close");
if (p_container->get_panel_count() < p_container->get_maximum_panel_count())
{
uAppendMenu(menu, MF_MENUBREAK, (UINT_PTR)0, NULL);
p_container->get_name(temp);
uAppendMenu(menu, MF_STRING|MF_GRAYED, (UINT_PTR)0, temp);
HMENU menu_add = CreatePopupMenu();
g_append_menu_panels(menu_add, panels, ID_PARENT_ADD_BASE);
AppendMenu(menu, MF_STRING|MF_POPUP, (UINT_PTR)menu_add, L"Add panel");
}
unsigned cmd = (unsigned)TrackPopupMenu(menu, TPM_RIGHTBUTTON|TPM_NONOTIFY|TPM_RETURNCMD,pt_menu.x,pt_menu.y,0,wnd,0);
p_overlay.destroy();
{
{
if (cmd)
{
if (cmd == ID_CLOSE)
{
p_container->remove_panel(index);
}
else if (cmd >=ID_CHANGE_BASE && cmd < panels.get_count()+ID_CHANGE_BASE)
{
t_size panel_index = cmd - ID_CHANGE_BASE;
uie::splitter_item_ptr si = new uie::splitter_item_simple_t;
si->set_panel_guid(panels[panel_index].guid);
p_container->replace_panel(index, si.get_ptr());
}
else if (cmd >=ID_ADD_BASE && cmd < panels.get_count()+ID_ADD_BASE)
{
t_size panel_index = cmd - ID_ADD_BASE;
uie::splitter_item_ptr si = new uie::splitter_item_simple_t;
si->set_panel_guid(panels[panel_index].guid);
p_splitter->add_panel(si.get_ptr());
}
else if (cmd >=ID_CHANGE_SPLITTER_BASE && cmd < panels.get_count()+ID_CHANGE_SPLITTER_BASE)
{
t_size panel_index = cmd - ID_CHANGE_SPLITTER_BASE;
uie::window_ptr window;
service_ptr_t<uie::splitter_window> splitter;
if (uie::window::create_by_guid(panels[panel_index].guid, window) && window->service_query_t(splitter))
{
unsigned n, count = min (p_splitter->get_panel_count(), splitter->get_maximum_panel_count());
if (count == p_splitter->get_panel_count() || MessageBox(wnd, _T("The number of child items will not fit in the selected splitter type. Continue?"), _T("Warning"), MB_YESNO|MB_ICONEXCLAMATION) == IDYES)
{
for (n=0; n<count; n++)
{
uie::splitter_item_ptr ptr;
p_splitter->get_panel(n, ptr);
splitter->add_panel(ptr.get_ptr());
}
uie::splitter_item_ptr newsi;
p_container->get_panel(index, newsi);
stream_writer_memblock conf;
try {splitter->get_config(&conf, abort_callback_impl());}
catch (const pfc::exception &) {};
newsi->set_panel_guid(panels[panel_index].guid);
newsi->set_panel_config(&stream_reader_memblock_ref(conf.m_data.get_ptr(), conf.m_data.get_size()), conf.m_data.get_size());
p_container->replace_panel(index, newsi.get_ptr());
}
}
}
else if (cmd >=ID_PARENT_ADD_BASE && cmd < panels.get_count()+ID_PARENT_ADD_BASE)
{
t_size panel_index = cmd - ID_PARENT_ADD_BASE;
uie::splitter_item_ptr si = new uie::splitter_item_simple_t;
si->set_panel_guid(panels[panel_index].guid);
p_container->add_panel(si.get_ptr());
}
}
}
}
DestroyMenu(menu);
}
}
