SelectionSetToolmenu::SelectionSetToolmenu() :
Gtk::ToolItem(),
_listStore(Gtk::ListStore::create(_columns)),
_clearSetsButton(NULL),
_entry(Gtk::manage(new Gtk::ComboBoxEntry(_listStore, _columns.name)))
{
// Hbox containing all our items
Gtk::HBox* hbox = Gtk::manage(new Gtk::HBox(false, 3));
add(*hbox);
// Pack Label
hbox->pack_start(
*Gtk::manage(new gtkutil::LeftAlignedLabel(_("Selection Set: "))),
false, false, 0);
// Pack Combo Box
hbox->pack_start(*_entry, true, true, 0);
// Add tooltip
_entry->set_tooltip_markup(_(ENTRY_TOOLTIP));
// Add clear button
{
Gtk::Image* image = Gtk::manage(new Gtk::Image(GlobalUIManager().getLocalPixbufWithMask("delete.png")));
image->show();
_clearSetsButton = Gtk::manage(new Gtk::ToolButton(*image, _("Clear Selection Sets")));
// Set tooltip
_clearSetsButton->set_tooltip_text(_("Clear Selection Sets"));
// Connect event
_clearSetsButton->signal_clicked().connect(sigc::mem_fun(*this, &SelectionSetToolmenu::onDeleteAllSetsClicked));
hbox->pack_start(*_clearSetsButton, false, false, 0);
}
// Connect the signals
Gtk::Entry* childEntry = _entry->get_entry();
childEntry->signal_activate().connect(sigc::mem_fun(*this, &SelectionSetToolmenu::onEntryActivated));
_entry->signal_changed().connect(sigc::mem_fun(*this, &SelectionSetToolmenu::onSelectionChanged));
// Populate the list
update();
// Add self as observer
GlobalSelectionSetManager().addObserver(*this);
show_all();
}
ImageEditorFE(grt::Module *m, bec::GRTManager *grtm, const grt::BaseListRef &args)
: PluginEditorBase(m, grtm, args)
, _be(grtm, workbench_model_ImageFigureRef::cast_from(args[0]))
, _xml(0)
, _image(0)
{
set_border_width(8);
_xml= Gtk::Builder::create_from_file(grtm->get_data_file_path("modules/data/editor_image.glade"));
Gtk::Widget *widget;
_xml->get_widget("editor_image_hbox", widget);
Gtk::Button *button(0);
_xml->get_widget("browse_button", button);
button->signal_clicked().connect(sigc::mem_fun(this, &ImageEditorFE::browse_file));
_xml->get_widget("reset_size_button", button);
button->signal_clicked().connect(sigc::mem_fun(this, &ImageEditorFE::reset_aspect));
Gtk::CheckButton *check;
_xml->get_widget("aspect_check", check);
check->signal_toggled().connect(sigc::mem_fun(this, &ImageEditorFE::aspect_toggled));
Gtk::Entry *entry;
_xml->get_widget("width_entry", entry);
entry->signal_activate().connect(sigc::mem_fun(this, &ImageEditorFE::width_changed));
_xml->get_widget("height_entry", entry);
entry->signal_activate().connect(sigc::mem_fun(this, &ImageEditorFE::height_changed));
_xml->get_widget("image", _image);
widget->reparent(*this);
show_all();
refresh_form_data();
}
bool myg_ask_string(Gtk::Window &parent, const Glib::ustring &title,
const Glib::ustring &msg, Glib::ustring &input,
bool password)
{
Gtk::Dialog dlg(title, parent, true, true);
Gtk::Button *okbtn;
dlg.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
okbtn= dlg.add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
Gtk::VBox vbox(false, 20);
Gtk::Entry entry;
Gtk::Label label("", 0.0, 0.5);
label.set_line_wrap(true);
label.set_use_markup(true);
label.set_markup(msg);
dlg.get_vbox()->pack_start(vbox);
if (password)
entry.set_visibility(false);
entry.signal_activate().connect(sigc::mem_fun(*okbtn,&Gtk::Button::clicked));
vbox.set_border_width(20);
vbox.pack_start(label);
vbox.pack_start(entry);
vbox.show();
label.show();
entry.show();
dlg.set_size_request(350, -1);
if (dlg.run() == Gtk::RESPONSE_OK)
{
input= entry.get_text();
return true;
}
return false;
}
Widget_Preview::Widget_Preview():
Gtk::Table(1, 5),
adj_time_scrub(0, 0, 1000, 0, 10, 0),
scr_time_scrub(adj_time_scrub),
b_loop(/*_("Loop")*/),
current_surface(NULL),
currentindex(-100000),//TODO get the value from canvas setting or preview option
audiotime(0),
adj_sound(0, 0, 4),
l_lasttime("0s"),
playing(false),
jackdial(NULL),
jack_enabled(false),
jack_is_playing(false),
jack_time(0),
jack_offset(0)
#ifdef WITH_JACK
,
jack_client(NULL),
jack_synchronizing(false)
#endif
{
//catch key press event for shortcut keys
signal_key_press_event().connect(sigc::mem_fun(*this, &Widget_Preview::on_key_pressed));
//connect to expose events
//signal_expose_event().connect(sigc::mem_fun(*this, &studio::Widget_Preview::redraw));
//manage all the change in values etc...
//1st row: preview content
preview_window.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
//pack preview content into scrolled window
preview_window.add(draw_area);
//preview window background color
Gdk::Color bg_color;
bg_color.set_red(54*256);
bg_color.set_blue(59*256);
bg_color.set_green(59*256);
draw_area.modify_bg(Gtk::STATE_NORMAL, bg_color);
adj_time_scrub.signal_value_changed().connect(sigc::mem_fun(*this,&Widget_Preview::slider_move));
scr_time_scrub.signal_event().connect(sigc::mem_fun(*this,&Widget_Preview::scroll_move_event));
draw_area.signal_expose_event().connect(sigc::mem_fun(*this,&Widget_Preview::redraw));
scr_time_scrub.set_draw_value(0);
disp_sound.set_time_adjustment(&adj_sound);
timedisp = -1;
//Set up signals to modify time value as it should be...
disp_sound.signal_start_scrubbing().connect(sigc::mem_fun(*this,&Widget_Preview::scrub_updated));
disp_sound.signal_scrub().connect(sigc::mem_fun(*this,&Widget_Preview::scrub_updated));
Gtk::Button *button = 0;
Gtk::Image *icon = 0;
#if 1
//2nd row: prevframe play/pause nextframe loop | halt-render re-preview erase-all
toolbar = Gtk::manage(new class Gtk::HBox(false, 0));
//prev rendered frame
Gtk::Button *prev_framebutton;
Gtk::Image *icon0 = manage(new Gtk::Image(Gtk::StockID("synfig-animate_seek_prev_frame"), Gtk::ICON_SIZE_BUTTON));
prev_framebutton = manage(new class Gtk::Button());
prev_framebutton->set_tooltip_text(_("Prev frame"));
icon0->set_padding(0,0);
icon0->show();
prev_framebutton->add(*icon0);
prev_framebutton->set_relief(Gtk::RELIEF_NONE);
prev_framebutton->show();
prev_framebutton->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,&Widget_Preview::seek_frame), -1));
toolbar->pack_start(*prev_framebutton, Gtk::PACK_SHRINK, 0);
{ //play
Gtk::Image *icon = manage(new Gtk::Image(Gtk::StockID("synfig-animate_play"), Gtk::ICON_SIZE_BUTTON));
play_button = manage(new class Gtk::Button());
play_button->set_tooltip_text(_("Play"));
icon->set_padding(0,0);
icon->show();
play_button->add(*icon);
play_button->set_relief(Gtk::RELIEF_NONE);
play_button->show();
play_button->signal_clicked().connect(sigc::mem_fun(*this,&Widget_Preview::on_play_pause_pressed));
toolbar->pack_start(*play_button, Gtk::PACK_SHRINK, 0);
}
{ //pause
Gtk::Image *icon = manage(new Gtk::Image(Gtk::StockID("synfig-animate_pause"), Gtk::ICON_SIZE_BUTTON));
pause_button = manage(new class Gtk::Button());
pause_button->set_tooltip_text(_("Pause"));
icon->set_padding(0,0);
icon->show();
pause_button->add(*icon);
pause_button->set_relief(Gtk::RELIEF_NONE);
pause_button->signal_clicked().connect(sigc::mem_fun(*this,&Widget_Preview::on_play_pause_pressed));
toolbar->pack_start(*pause_button, Gtk::PACK_SHRINK, 0);
}
//next rendered frame
Gtk::Button *next_framebutton;
Gtk::Image *icon2 = manage(new Gtk::Image(Gtk::StockID("synfig-animate_seek_next_frame"), Gtk::ICON_SIZE_BUTTON));
next_framebutton = manage(new class Gtk::Button());
next_framebutton->set_tooltip_text(_("Next frame"));
icon2->set_padding(0,0);
icon2->show();
next_framebutton->add(*icon2);
next_framebutton->set_relief(Gtk::RELIEF_NONE);
next_framebutton->show();
next_framebutton->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,&Widget_Preview::seek_frame), 1));
toolbar->pack_start(*next_framebutton, Gtk::PACK_SHRINK, 0);
//spacing
Gtk::Alignment *space = Gtk::manage(new Gtk::Alignment());
space->set_size_request(8);
toolbar->pack_start(*space, false, true);
//loop
button = &b_loop;
IMAGIFY_BUTTON(button,"synfig-animate_loop", _("Loop"));
toolbar->pack_start(b_loop, Gtk::PACK_SHRINK,0);
//spacing
Gtk::Alignment *space1 = Gtk::manage(new Gtk::Alignment());
space1->set_size_request(24);
toolbar->pack_start(*space1, false, true);
//halt render
button = manage(new Gtk::Button(/*_("Halt Render")*/));
button->signal_clicked().connect(sigc::mem_fun(*this,&Widget_Preview::stoprender));
IMAGIFY_BUTTON(button,Gtk::Stock::STOP, _("Halt render"));
toolbar->pack_start(*button, Gtk::PACK_SHRINK, 0);
//re-preview
button = manage(new Gtk::Button(/*_("Re-Preview")*/));
button->signal_clicked().connect(sigc::mem_fun(*this,&Widget_Preview::repreview));
IMAGIFY_BUTTON(button, Gtk::Stock::EDIT, _("Re-preview"));
toolbar->pack_start(*button, Gtk::PACK_SHRINK, 0);
//erase all
button = manage(new Gtk::Button(/*_("Erase All")*/));
button->signal_clicked().connect(sigc::mem_fun(*this,&Widget_Preview::eraseall));
IMAGIFY_BUTTON(button, Gtk::Stock::CLEAR, _("Erase all rendered frame(s)"));
toolbar->pack_start(*button, Gtk::PACK_SHRINK, 0);
//spacing
Gtk::Alignment *space2 = Gtk::manage(new Gtk::Alignment());
space1->set_size_request(24);
toolbar->pack_start(*space2, false, true);
//jack
jackdial = Gtk::manage(new JackDial());
#ifdef WITH_JACK
jack_dispatcher.connect(sigc::mem_fun(*this, &Widget_Preview::on_jack_sync));
jackdial->signal_enable_jack().connect(sigc::mem_fun(*this, &studio::Widget_Preview::on_toggle_jack_pressed));
jackdial->signal_offset_changed().connect(sigc::mem_fun(*this, &studio::Widget_Preview::on_jack_offset_changed));
jackdial->signal_disable_jack().connect(sigc::mem_fun(*this, &studio::Widget_Preview::on_toggle_jack_pressed));
#endif
//FIXME: Hardcoded FPS!
jackdial->set_fps(24.f);
jackdial->set_offset(jack_offset);
if ( !getenv("SYNFIG_DISABLE_JACK") )
jackdial->show();
toolbar->pack_start(*jackdial, false, true);
//zoom preview
factor_refTreeModel = Gtk::ListStore::create(factors);
zoom_preview.set_model(factor_refTreeModel);
zoom_preview.property_has_frame() = true;
zoom_preview.signal_changed().connect(sigc::mem_fun(*this, &Widget_Preview::preview_draw));
Gtk::TreeModel::Row row = *(factor_refTreeModel->append());
row[factors.factor_id] = "1";
row[factors.factor_value] = "25%";
row = *(factor_refTreeModel->append());
row[factors.factor_id] = "2";
row[factors.factor_value] = "50%";
row = *(factor_refTreeModel->append());
row[factors.factor_id] = "3";
row[factors.factor_value] = "100%";
row = *(factor_refTreeModel->append());
row[factors.factor_id] = "4";
row[factors.factor_value] = "200%";
row = *(factor_refTreeModel->append());
row[factors.factor_id] = "5";
row[factors.factor_value] = _("Fit");
zoom_preview.set_text_column(factors.factor_value);
Gtk::Entry* entry = zoom_preview.get_entry();
entry->set_text("100%"); //default zoom level
entry->set_icon_from_stock(Gtk::StockID("synfig-zoom"));
entry->signal_activate().connect(sigc::mem_fun(*this, &Widget_Preview::on_zoom_entry_activated));
//set the zoom widget width
zoom_preview.set_size_request(100, -1);
zoom_preview.show();
toolbar->pack_end(zoom_preview, Gtk::PACK_SHRINK, 0);
show_toolbar();
//3rd row: previewing frame numbering and rendered frame numbering
Gtk::HBox *status = manage(new Gtk::HBox);
status->pack_start(l_currenttime, Gtk::PACK_SHRINK, 5);
Gtk::Label *separator = manage(new Gtk::Label(" / "));
status->pack_start(*separator, Gtk::PACK_SHRINK, 0);
status->pack_start(l_lasttime, Gtk::PACK_SHRINK, 5);
status->show_all();
//5th row: sound track
disp_sound.set_size_request(-1,32);
// attach all widgets
attach(preview_window, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0);
attach(scr_time_scrub, 0, 1, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK);
attach(*toolbar, 0, 1, 2, 3, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK|Gtk::FILL);
attach(*status, 0, 1, 3, 4, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK);
// attach(disp_sound,0,1,4,5,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
preview_window.show_all();
scr_time_scrub.show_all();
//if(draw_area.get_window()) gc_area = Gdk::GC::create(draw_area.get_window());
#endif
}
PluginDisplay::PluginDisplay(gx_engine::GxMachineBase& machine_, Glib::RefPtr<Gdk::Pixbuf> icon, sigc::slot<void, bool, bool> finished_callback_)
: machine(machine_), pluginlist(), current_plugin(0), old_state(0), bld(), change_count(0),
actiongroup(Gtk::ActionGroup::create("ladspa_window")), uimanager(),
enum_liststore(new EnumListStore), port_liststore(new PortListStore),
plugin_liststore(new PluginListStore), masteridx_liststore(new MasterIdxListStore),
on_reordered_conn(), display_type_list(), display_type_list_sr(), output_type_list(),
finished_callback(finished_callback_)
{
std::vector<std::string> old_not_found;
machine.load_ladspalist(old_not_found, pluginlist);
bld = gx_gui::GxBuilder::create_from_file(machine.get_options().get_builder_filepath("ladspaliste.glade"));
bld->get_toplevel("window1", window);
bld->find_widget("treeview1", treeview1);
bld->find_widget("treeview2", treeview2);
bld->find_widget("treeview3", treeview3);
bld->find_widget("ladspa_category", ladspa_category);
bld->find_widget("ladspa_maker", ladspa_maker);
bld->find_widget("ladspa_uniqueid", ladspa_uniqueid);
bld->find_widget("search_entry", search_entry);
bld->find_widget("combobox_mono_stereo", combobox_mono_stereo);
bld->find_widget("selected_only", selected_only);
bld->find_widget("changed_only", changed_only);
bld->find_widget("ladspa_only", ladspa_only);
bld->find_widget("lv2_only", lv2_only);
bld->find_widget("show_all", show_all);
bld->find_widget("details_box", details_box);
bld->find_widget("plugin_name", plugin_name);
bld->find_widget("plugin_category", plugin_category);
bld->find_widget("plugin_quirks", plugin_quirks);
bld->find_widget("master_slider_idx", master_slider_idx);
bld->find_widget("master_slider_name", master_slider_name);
bld->find_widget("cellrenderer_master", cellrenderer_master);
bld->find_widget("cellrenderer_newrow", cellrenderer_newrow);
bld->find_widget("cellrenderer_caption", cellrenderer_caption);
bld->find_widget("cellrenderer_active", cellrenderer_active);
bld->find_widget("cellrenderer_category", cellrenderer_category);
bld->find_widget("cellrenderer_quirks", cellrenderer_quirks);
set_title();
actiongroup->add(Gtk::Action::create("FileMenuAction",_("_File")));
save_action = Gtk::Action::create("SaveAction", _("_Ok"));
actiongroup->add(save_action, sigc::mem_fun(this, &PluginDisplay::on_save));
apply_action = Gtk::Action::create("ApplyAction", _("_Apply"));
actiongroup->add(apply_action, sigc::mem_fun(this, &PluginDisplay::on_apply));
quit_action = Gtk::Action::create("QuitAction", _("_Quit"));
actiongroup->add(quit_action, sigc::mem_fun(this, &PluginDisplay::on_quit));
select_all_action = Gtk::Action::create("SelectAllAction", _("_Select All"));
actiongroup->add(select_all_action, sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_select_all), true));
select_none_action = Gtk::Action::create("SelectNoneAction", _("Select _None"));
actiongroup->add(select_none_action, sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_select_all), false));
actiongroup->add(Gtk::Action::create("ViewMenuAction", _("_View")));
Glib::RefPtr<Gtk::Action> act = Gtk::Action::create("FindAction", _("_Find"));
actiongroup->add(act, sigc::mem_fun(this, &PluginDisplay::on_find));
uimanager = Gtk::UIManager::create();
uimanager->insert_action_group(actiongroup, 0);
uimanager->add_ui_from_string(menudef);
//uimanager->get_widget("/ladspalist");
//Gtk::HBox *ww; bld->find_widget("menubox", ww); ww->pack_start(*uimanager->get_widget("/ladspalist"));
window->add_accel_group(uimanager->get_accel_group());
window->signal_delete_event().connect(sigc::mem_fun(this, &PluginDisplay::on_delete_event));
bld->find_widget("show_details", show_details);
show_details->signal_clicked().connect(sigc::mem_fun(this, &PluginDisplay::on_show_details));
treeview3->get_selection()->set_mode(Gtk::SELECTION_BROWSE);
treeview3->set_model(enum_liststore);
Gtk::CellRendererText *r;
bld->find_widget("cellrenderer_label", r);
r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_label_edited));
Gtk::TreeViewColumn *c;
bld->find_widget("treeviewcolumn_label", c);
c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_label));
bld->find_widget("dry_wet_button", dry_wet_button);
dry_wet_button->signal_clicked().connect(sigc::mem_fun(this, &PluginDisplay::on_add_dry_wet_controller));
// dry_wet_button->set_active(current_plugin->add_wet_dry);
Glib::RefPtr<Gtk::TreeSelection> sel = treeview2->get_selection();
sel->set_mode(Gtk::SELECTION_BROWSE);
sel->signal_changed().connect(sigc::mem_fun(this, &PluginDisplay::on_parameter_selection_changed));
on_reordered_conn = port_liststore->signal_row_deleted().connect(sigc::mem_fun(this, &PluginDisplay::on_reordered));
treeview2->set_model(port_liststore);
CellRendererComboDerived *rd;
bld->find_widget_derived("cellrenderer_type", rd, sigc::ptr_fun(CellRendererComboDerived::create_from_builder));
rd->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_type_edited));
bld->find_widget("treeviewcolumn_type", c);
c->set_cell_data_func(*rd, sigc::mem_fun(this, &PluginDisplay::display_type));
bld->find_widget_derived("cellrenderer_step", rd, sigc::ptr_fun(CellRendererComboDerived::create_from_builder));
rd->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_step_edited));
bld->find_widget("treeviewcolumn_step", c);
c->set_cell_data_func(*rd, sigc::mem_fun(this, &PluginDisplay::display_step));
cellrenderer_newrow->signal_toggled().connect(sigc::mem_fun(this, &PluginDisplay::on_newrow_toggled));
Gtk::Label *label = new Gtk::Label("N");
label->set_tooltip_text(_("start a new row of controls in the rackbox unit"));
label->show();
bld->find_widget("treeviewcolumn_newrow", c);
c->set_widget(*manage(label));
c->set_cell_data_func(*cellrenderer_newrow, sigc::mem_fun(this, &PluginDisplay::display_newrow));
cellrenderer_caption->signal_toggled().connect(sigc::mem_fun(this, &PluginDisplay::on_caption_toggled));
label = new Gtk::Label("C");
label->set_tooltip_text(_("display the name as caption above the control"));
label->show();
bld->find_widget("treeviewcolumn_caption", c);
c->set_widget(*manage(label));
c->set_cell_data_func(*cellrenderer_caption, sigc::mem_fun(this, &PluginDisplay::display_caption));
bld->find_widget("cellrenderer_name", r);
r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_name_edited));
bld->find_widget("treeviewcolumn_name", c);
c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_name));
bld->find_widget("cellrenderer_dflt", r);
r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_dflt_edited));
bld->find_widget("treeviewcolumn_dflt", c);
c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_default));
bld->find_widget("cellrenderer_low", r);
r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_low_edited));
bld->find_widget("treeviewcolumn_low", c);
c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_lower));
bld->find_widget("cellrenderer_up", r);
r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_up_edited));
bld->find_widget("treeviewcolumn_up", c);
c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_upper));
bld->find_widget("cellrenderer_idx", r);
bld->find_widget("treeviewcolumn_idx", c);
c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_idx));
bld->find_widget("treeviewcolumn_SR", c);
label = new Gtk::Label("SR");
label->set_tooltip_text(_("marked rows: range depends on samplerate; using 44100 as fixed value"));
label->show();
c->set_widget(*manage(label));
Gtk::CellRendererToggle *t;
bld->find_widget("cellrenderer_SR", t);
c->set_cell_data_func(*t, sigc::mem_fun(this, &PluginDisplay::display_SR));
Gtk::TreeModelColumnRecord recdef;
Gtk::TreeModelColumn<Glib::ustring> strcol;
Gtk::TreeModelColumn<DisplayType> intcol;
recdef.add(strcol);
recdef.add(intcol);
display_type_list = Gtk::ListStore::create(recdef);
append_displaytype(display_type_list, tp_scale);
append_displaytype(display_type_list, tp_scale_log);
append_displaytype(display_type_list, tp_toggle);
append_displaytype(display_type_list, tp_int);
append_displaytype(display_type_list, tp_enum);
append_displaytype(display_type_list, tp_none);
display_type_list_sr = Gtk::ListStore::create(recdef);
append_displaytype(display_type_list_sr, tp_scale);
append_displaytype(display_type_list_sr, tp_scale_log);
append_displaytype(display_type_list_sr, tp_none);
output_type_list = Gtk::ListStore::create(recdef);
append_displaytype(output_type_list, tp_display);
append_displaytype(output_type_list, tp_display_toggle);
append_displaytype(output_type_list, tp_none);
treeview1->signal_row_activated().connect(sigc::mem_fun(this, &PluginDisplay::on_row_activated));
treeview1->set_search_equal_func(sigc::mem_fun(this,&PluginDisplay::search_equal));
Gtk::Entry *e;
bld->find_widget("search_entry", e);
e->signal_activate().connect(sigc::mem_fun(this, &PluginDisplay::on_search_entry_activate));
treeview1->set_search_entry(*e);
sel = treeview1->get_selection();
sel->set_mode(Gtk::SELECTION_BROWSE);
sel->signal_changed().connect(sigc::mem_fun(this, &PluginDisplay::selection_changed));
treeview1->set_model(plugin_liststore);
cellrenderer_active->signal_toggled().connect(sigc::mem_fun(this, &PluginDisplay::on_active_toggled));
bld->find_widget("cellrenderer_ladspa", r);
bld->find_widget("treeviewcolumn_ladspa", c);
c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_ladspa));
Gtk::ComboBox *cb;
bld->find_widget("plugin_category", cb);
cb->set_cell_data_func(*cellrenderer_category, sigc::mem_fun(this, &PluginDisplay::display_category));
bld->find_widget("plugin_quirks", cb);
cb->set_cell_data_func(*cellrenderer_quirks, sigc::mem_fun(this, &PluginDisplay::display_quirks));
master_slider_idx->set_cell_data_func(*cellrenderer_master, sigc::mem_fun(this, &PluginDisplay::display_master_idx));
master_slider_idx->signal_changed().connect(sigc::mem_fun(this, &PluginDisplay::set_master_text));
selected_only->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), selected_only));
changed_only->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), changed_only));
ladspa_only->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), ladspa_only));
lv2_only->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), lv2_only));
show_all->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), show_all));
bld->find_widget("combobox_mono_stereo", cb);
cb->signal_changed().connect(sigc::mem_fun(this, &PluginDisplay::on_mono_stereo_changed));
cb->set_active(0);
Gtk::Button *b;
bld->find_widget("reset_changes", b);
b->signal_clicked().connect(sigc::mem_fun(this, &PluginDisplay::on_delete_changes));
bld->find_widget("master_slider_idx", cb);
cb->set_model(masteridx_liststore);
bld->find_widget("button_cancel", b);
gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("QuitAction")->gobj());
bld->find_widget("button_apply", b);
gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("ApplyAction")->gobj());
bld->find_widget("button_save", b);
gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("SaveAction")->gobj());
bld->find_widget("select_all", b);
gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("SelectAllAction")->gobj());
bld->find_widget("select_none", b);
gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("SelectNoneAction")->gobj());
window->set_icon(icon);
window->show();
}
//------------------------------------------------------------------------------
bool mforms::gtk::ToolBarImpl::create_tool_item(mforms::ToolBarItem *item, ToolBarItemType type) {
Gtk::Widget *w = 0;
switch (type) {
case mforms::TextActionItem:
case mforms::ActionItem:
case mforms::SwitcherItem: {
Gtk::Button *btn = Gtk::manage(new Gtk::Button());
btn->set_focus_on_click(false);
btn->set_border_width(0);
btn->set_relief(Gtk::RELIEF_NONE);
btn->signal_clicked().connect(sigc::bind(sigc::ptr_fun(process_ctrl_action), btn, item));
if (type == mforms::SwitcherItem)
btn->set_always_show_image(true);
w = btn;
break;
}
case mforms::SegmentedToggleItem:
case mforms::ToggleItem: {
Gtk::ToggleButton *btn = Gtk::manage(new Gtk::ToggleButton());
btn->set_focus_on_click(false);
btn->set_relief(Gtk::RELIEF_NONE);
btn->signal_toggled().connect(sigc::bind(sigc::ptr_fun(process_ctrl_action), btn, item));
btn->set_inconsistent(false);
w = btn;
break;
}
case mforms::SeparatorItem: {
Gtk::Separator *sep = new Gtk::Separator(Gtk::ORIENTATION_VERTICAL);
w = sep;
break;
}
case mforms::SearchFieldItem: {
#if GTK_VERSION_GE(2, 16)
Gtk::Entry *entry = Gtk::manage(new Gtk::Entry());
w = entry;
entry->set_icon_from_stock(Gtk::Stock::FIND);
#else
Gtk::Box *hbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL, 0));
w = hbox;
Gtk::Image *image = Gtk::manage(new Gtk::Image(Gtk::Stock::FIND, Gtk::ICON_SIZE_MENU));
Gtk::Entry *entry = Gtk::manage(new Gtk::Entry());
hbox->pack_start(*image, false, true);
hbox->pack_start(*entry, true, true);
hbox->set_data("entry", entry);
hbox->show_all();
#endif
entry->signal_activate().connect(sigc::bind(sigc::ptr_fun(process_ctrl_action), entry, item));
break;
}
case mforms::TextEntryItem: {
Gtk::Box *hbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL, 0));
w = hbox;
Gtk::Entry *entry = Gtk::manage(new Gtk::Entry());
hbox->pack_start(*entry, true, true);
hbox->set_data("entry", entry);
hbox->show_all();
entry->signal_activate().connect(sigc::bind(sigc::ptr_fun(process_ctrl_action), entry, item));
break;
}
case mforms::FlatSelectorItem:
case mforms::SelectorItem: {
Gtk::ComboBoxText *ct = Gtk::manage(new Gtk::ComboBoxText());
ct->signal_changed().connect(sigc::bind(sigc::ptr_fun(process_ctrl_action), ct, item));
w = ct;
break;
}
case mforms::ColorSelectorItem: {
if (!color_combo_columns) {
color_combo_columns = new ColorComboColumns();
}
Gtk::ComboBox *ct = Gtk::manage(new Gtk::ComboBox());
ct->pack_start(color_combo_columns->image);
ct->signal_changed().connect(sigc::bind(sigc::ptr_fun(process_ctrl_action), ct, item));
w = ct;
break;
}
case mforms::ExpanderItem:
case mforms::LabelItem: {
Gtk::Label *label = Gtk::manage(new Gtk::Label("", 0.0, 0.5));
w = label;
break;
}
case mforms::ImageBoxItem: {
Gtk::Image *image = Gtk::manage(new Gtk::Image());
w = image;
break;
}
case mforms::TitleItem: {
Gtk::Label *label = Gtk::manage(new Gtk::Label("", 0.0, 0.5));
w = label;
auto provider = Gtk::CssProvider::create();
provider->load_from_data("* { color: #333; font-weight: bold; }");
w->get_style_context()->add_provider(provider, GTK_STYLE_PROVIDER_PRIORITY_USER);
break;
}
}
if (w) {
w->show();
} else
logError("create_tool_item, widget is 0 for passed type %i\n", type);
item->set_data(w);
return w != 0;
}
void Info::show(std::string ClassName, std::set<int> UnitIDs)
{
mp_IDLabel->set_label("");
mp_ProcessOrderLabel->set_label("");
mref_ListStoreFrom->clear();
mref_ListStoreTo->clear();
mref_ListStoreParent->clear();
mref_ListStoreChildren->clear();
mref_ListStoreIDs->clear();
m_InputDataNames.clear();
if (!m_InputDataLineTable.empty())
{
std::map<Gtk::Label*, std::pair<Gtk::Entry*, Gtk::Button*> >::iterator iter;
for (iter = m_InputDataLineTable.begin(); iter
!= m_InputDataLineTable.end(); ++iter)
{
delete((*iter).first);
delete((*iter).second.second);
delete((*iter).second.first);
}
}
m_InputDataLineTable.clear();
mp_NameClassLabel->set_label(ClassName);
mp_TreeViewIDs->set_name("");
std::set<int>::iterator it;
for (it = UnitIDs.begin(); it != UnitIDs.end(); it++)
{
Gtk::TreeRow Row = *mref_ListStoreIDs->append();
Row[m_ModelColumnIDs.m_ID] = *it;
m_InputDataNames
= mp_CoreRepos->getUnit(ClassName, *it)->getInputData()->getInputDataNames();
if(m_InputDataNames.empty())
mp_InputDataTable->set_visible(false);
else
{
mp_InputDataTable->resize((m_InputDataNames.size() * 2) - 1, 3);
mp_InputDataTable->set_homogeneous(false);
mp_InputDataTable->set_spacings(5);
int compt = 0;
for (unsigned int i = 0; i < (m_InputDataNames.size() * 2) - 1; i++)
{
if ((i % 2) == 0)
{
Gtk::Label* InputDataLabel = Gtk::manage(
new Gtk::Label(m_InputDataNames[compt]));
mp_InputDataTable->attach(*InputDataLabel, 0, 1, i, i + 1,
Gtk::FILL | Gtk::EXPAND, Gtk::SHRINK);
Gtk::Entry* InputDataValueEntry = Gtk::manage(new Gtk::Entry());
InputDataValueEntry->set_name(InputDataLabel->get_label());
mp_InputDataTable->attach(*InputDataValueEntry, 1, 2, i, i + 1,
Gtk::FILL | Gtk::EXPAND, Gtk::SHRINK);
InputDataValueEntry->signal_activate().connect(
sigc::bind<std::string>(
sigc::mem_fun(*this, &Info::onEntryInputDataChanged),
InputDataValueEntry->get_name()));
InputDataValueEntry->signal_focus_out_event().connect(
sigc::bind<std::string>(
sigc::mem_fun(*this, &Info::on_focus_out_event),
InputDataValueEntry->get_name()));
InputDataValueEntry->set_activates_default(true);
Gtk::Button* RestoreDefaultButton = Gtk::manage(
new Gtk::Button(_("Restore"), false));
mp_InputDataTable->attach(*RestoreDefaultButton, 2, 3, i, i + 1,
Gtk::FILL | Gtk::EXPAND, Gtk::SHRINK);
std::pair<Gtk::Entry*, Gtk::Button*> TempPairEntryButton =
std::make_pair(InputDataValueEntry, RestoreDefaultButton);
m_InputDataLineTable.insert(
std::pair<Gtk::Label*, std::pair<Gtk::Entry*, Gtk::Button*> >(
InputDataLabel, TempPairEntryButton));
InputDataLabel->set_visible(true);
InputDataValueEntry->set_visible(true);
RestoreDefaultButton->set_visible(true);
RestoreDefaultButton->set_sensitive(false);
compt++;
} else
{
mp_InputDataTable->attach(*ToolBox::setHSeparator(), 0, 3, i, i + 1,
Gtk::FILL | Gtk::EXPAND, Gtk::SHRINK);
}
}
mp_InputDataTable->set_visible(true);
}
}
if(! mref_ListStoreIDs->children().empty())
mp_TreeViewIDs->get_selection()->select(mref_ListStoreIDs->children()[0]);
if (mp_Dialog->run() == Gtk::RESPONSE_OK)
{
}
mp_Dialog->hide();
}
void setEntryCallback(string e, sigc::slot<void> sig) {
Gtk::Entry* en;
VRGuiBuilder()->get_widget(e, en);
en->signal_activate().connect(sig);
}