int dialog::run_modal(unsigned id,HWND parent)
{
assert(wnd == 0);
if (wnd != 0) return -1;
m_is_modal = true;
return uDialogBox(id,parent,DlgProc,reinterpret_cast<LPARAM>(this));
}
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;
}
bool spectrum_extension::show_config_popup(HWND wnd_parent)
{
spec_param param(cr_fore, cr_back, mode, m_scale, m_vertical_scale, this);
bool rv = !!uDialogBox(IDD_POPUP_SPECTRUM_NEW, wnd_parent, SpectrumPopupProc, (LPARAM)(¶m));
if (rv)
{
cr_fore = param.cr_fore;
cfg_vis2 = param.cr_fore;
cr_back = param.cr_back;
cfg_vis = param.cr_back;
mode = param.mode;
cfg_vis_mode = param.mode;
m_scale = param.m_scale;
cfg_scale = param.m_scale;
m_vertical_scale = param.m_vertical_scale;
cfg_vertical_scale = param.m_vertical_scale;
if (b_active)
{
flush_brushes();
clear();
}
}
return rv;
}
bool item_details_config_t::run_modal(HWND wnd)
{
m_modal = true; return uDialogBox(IDD_ITEMDETAILS_CONFIG, wnd, g_DialogProc, (LPARAM)this) != 0;
}
bool g_rename_dialog(pfc::string8 * text,HWND parent)
{
rename_param param;
param.m_text = text;
return !!uDialogBox(IDD_RENAME_PLAYLIST,parent,RenameProc,(LPARAM)(¶m));
}
void g_export_layout(HWND wnd)
{
pfc::string8 path;
FCLDialog pFCLDialog;
if (/*MessageBox(wnd, _T("Layout setting exporting is available for testing purposes only. FCL files produced will not work with the release version of Columns UI."), _T("Warning"), MB_OK) == IDOK && */uDialogBox (IDD_FCL1, wnd, FCLDialog::g_FCLDialogProc, (LPARAM)&pFCLDialog) && uGetOpenFileName(wnd, "Columns UI Layout (*.fcl)|*.fcl|All Files (*.*)|*.*", 0, "fcl", "Save as", NULL, path, TRUE))
{
t_export_feedback_impl feedback;
pfc::list_t<GUID> groups;
{
t_size i, count = pFCLDialog.m_nodes.get_count();
for (i=0; i<count; i++)
if (pFCLDialog.m_nodes[i].checked)
groups.add_item(pFCLDialog.m_nodes[i].group->get_guid());
}
try
{
service_ptr_t<file> p_file;
abort_callback_impl p_abort;
filesystem::g_open_write_new(p_file, path, p_abort);
p_file->write_lendian_t(g_fcl_header, p_abort);
p_file->write_lendian_t((t_uint32)fcl_stream_version, p_abort);
p_file->write_lendian_t((t_uint32)pFCLDialog.get_mode(), p_abort);
stream_writer_memblock mem;
t_size actualtotal=0;
{
cui::fcl::dataset_list export_items;
t_size i, count = export_items.get_count();
pfc::array_t< t_export_feedback_impl > feeds;
feeds.set_count(count);
for (i=0; i<count; i++)
{
if (groups.have_item(export_items[i]->get_group()))
{
pfc::string8 name;
export_items[i]->get_name(name);
mem.write_lendian_t(export_items[i]->get_guid(), p_abort);
mem.write_string(name, p_abort);
stream_writer_memblock writer;
export_items[i]->get_data(&writer, pFCLDialog.get_mode(), feeds[i], p_abort);
t_size j, pcount = feeds[i].get_count();
mem.write_lendian_t(pcount, p_abort);
for (j=0; j<pcount; j++)
{
t_uint32 temp = feedback.find_or_add_guid(feeds[i][j]);
mem.write_lendian_t(temp, p_abort);
}
mem.write_lendian_t((t_uint32)writer.m_data.get_size(), p_abort);
mem.write(writer.m_data.get_ptr(), writer.m_data.get_size(), p_abort);
actualtotal++;
}
}
}
{
t_size j, pcount = feedback.get_count();
p_file->write_lendian_t(pcount, p_abort);
for (j=0; j<pcount; j++)
{
uie::window_ptr ptr;
pfc::string8 name;
if (uie::window::create_by_guid(feedback[j], ptr))
ptr->get_name(name);
p_file->write_lendian_t(feedback[j], p_abort);
p_file->write_string(name, p_abort);
}
/*pfc::list_t<uie::window_ptr> windows;
uie::window_ptr ptr;
service_enum_t<uie::window> window_enum;
while (window_enum.next(ptr))
{
windows.add_item(ptr);
}
t_size i, count = windows.get_count();
p_file->write_lendian_t(count, p_abort);
for (i=0; i<count; i++)
{
pfc::string8 temp;
p_file->write_lendian_t(windows[i]->get_extension_guid(), p_abort);
windows[i]->get_name(temp);
p_file->write_string(temp, p_abort);
}*/
}
p_file->write_lendian_t(actualtotal, p_abort);
p_file->write(mem.m_data.get_ptr(), mem.m_data.get_size(), p_abort);
}
catch (const pfc::exception & ex)
{
abort_callback_impl p_abort;
try {if (filesystem::g_exists(path, p_abort)) filesystem::g_remove(path, p_abort);} catch (const pfc::exception &) {};
popup_message::g_show(ex.what(), "Error");
};
}
}
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");
};
}
bool selection_properties_config_t::run_modal(HWND wnd)
{
return uDialogBox(IDD_SELECTIONCONFIG, wnd, g_DialogProc, (LPARAM)this) != 0;
}
