void mforms::gtk::MenuItemImpl::insert_item(mforms::MenuBase *menub, int index, mforms::MenuItem *item) {
Gtk::MenuShell *menu_shell = cast<Gtk::MenuShell *>(menub->get_data_ptr());
Gtk::MenuItem *item_to_insert = cast<Gtk::MenuItem *>(item->get_data_ptr());
if (!menu_shell) // menub is not a menubar
{
Gtk::MenuItem *mi = cast<Gtk::MenuItem *>(menub->get_data_ptr());
if (mi) {
Gtk::Menu *menu = 0;
if (mi->has_submenu()) // item already has submenu, add to it
menu = mi->get_submenu();
else { // no submenu yet in item, create one
menu = Gtk::manage(new Gtk::Menu());
mi->signal_activate().connect(sigc::bind(sigc::ptr_fun(menu_will_show), menub));
mi->set_submenu(*menu);
menu->show();
}
menu_shell = menu;
} else
logError("Passed MenuBase %p does not contain neither Gtk::MenuBar nor Gtk::MenuItem\n", menub);
} else {
if (menub->get_parent() && get_accel_group(menub))
propagate_accel_group(menub, get_accel_group(menub));
}
if (menu_shell && item_to_insert)
menu_shell->insert(*item_to_insert, index);
else
logError("Internal error in MenuBase::insert_item()\n");
}
Glib::RefPtr<Gtk::UIManager> SmartChessWindow::createUIManager(
Glib::RefPtr<Gtk::ActionGroup> &action_group) {
auto ui_manager = Gtk::UIManager::create();
ui_manager->insert_action_group(action_group);
add_accel_group(ui_manager->get_accel_group());
Glib::ustring ui_info =
"<ui>"
" <menubar name='MenuBar'>"
" <menu action='MenuFile'>"
" <separator/>"
" <menuitem action='Quit'/>"
" </menu>"
" <menu action='MenuView'>"
" <menuitem action='ShowOptionsArea' />"
" <menuitem action='ShowLogArea' />"
" </menu>"
" <menu action='MenuHelp'>"
" <menuitem action='About' />"
" </menu>"
" </menubar>"
" <toolbar name='ToolBar'>"
" <toolitem action='Quit'/>"
" </toolbar>"
"</ui>";
ui_manager->add_ui_from_string(ui_info);
return ui_manager;
}
void
libbalsa_window_set_accels(GtkApplicationWindow * window,
GMenuModel * menu_model)
{
GSList *accel_groups;
GtkAccelGroup *accel_group;
/* Remove current accelerators: */
accel_groups = gtk_accel_groups_from_object(G_OBJECT(window));
if (accel_groups)
/* Last is first... */
gtk_window_remove_accel_group(GTK_WINDOW(window),
accel_groups->data);
accel_group = get_accel_group(menu_model, G_ACTION_MAP(window));
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
g_object_unref(accel_group);
}
//------------------------------------------------------------------------------
void mforms::gtk::MenuItemImpl::set_shortcut(mforms::MenuItem *item, const std::string &item_shortcut) {
if (item_shortcut.empty()) {
logWarning("Shortcut is empty\n");
return;
}
Gtk::MenuItem *menu_item = cast<Gtk::MenuItem *>(item->get_data_ptr());
if (menu_item == NULL) {
logError("Menu item was not defined (%s)\n", item_shortcut.c_str());
return;
}
// convert the accelerator format from Control+X to <control>x which is recognized by gtk
std::vector<std::string> parts(base::split(item_shortcut, "+"));
std::vector<std::string> keys;
std::string key = parts.back();
parts.pop_back();
if (key == "Space")
keys.push_back("space");
else if (key == "PageUp") {
keys.push_back("Page_Up");
keys.push_back("KP_Page_Up");
} else if (key == "PageDown") {
keys.push_back("Page_Down");
keys.push_back("KP_Page_Down");
} else if (key == "Slash") {
keys.push_back("slash");
keys.push_back("KP_Divide");
} else if (key == "Minus") {
keys.push_back("minus");
keys.push_back("KP_Subtract");
} else if (key == "Plus") {
keys.push_back("plus");
keys.push_back("KP_Add");
} else if (key == "Asterisk") {
keys.push_back("multiply");
keys.push_back("KP_Multiply");
} else if (key == "Period") {
keys.push_back("period");
keys.push_back("KP_Decimal");
} else if (key == "Return") {
keys.push_back("Return");
keys.push_back("KP_Enter");
} else if (key == "Home") {
keys.push_back("Home");
keys.push_back("KP_Home");
} else if (key == "End") {
keys.push_back("End");
keys.push_back("KP_End");
} else if (key == "Insert") {
keys.push_back("Insert");
keys.push_back("KP_Insert");
} else if (key == "Delete") {
keys.push_back("Delete");
keys.push_back("KP_Delete");
} else if (key == "Up") {
keys.push_back("Up");
keys.push_back("KP_Up");
} else if (key == "Down") {
keys.push_back("Down");
keys.push_back("KP_Down");
} else if (key == "Left") {
keys.push_back("Left");
keys.push_back("KP_Left");
} else if (key == "Right") {
keys.push_back("Right");
keys.push_back("KP_Right");
} else if (key == "0") {
keys.push_back("0");
keys.push_back("KP_0");
} else if (key == "1") {
keys.push_back("1");
keys.push_back("KP_1");
} else if (key == "2") {
keys.push_back("2");
keys.push_back("KP_2");
} else if (key == "3") {
keys.push_back("3");
keys.push_back("KP_3");
} else if (key == "4") {
keys.push_back("4");
keys.push_back("KP_4");
} else if (key == "5") {
keys.push_back("5");
keys.push_back("KP_5");
} else if (key == "6") {
keys.push_back("6");
keys.push_back("KP_6");
} else if (key == "7") {
keys.push_back("7");
keys.push_back("KP_7");
} else if (key == "8") {
keys.push_back("8");
keys.push_back("KP_8");
} else if (key == "9") {
keys.push_back("9");
keys.push_back("KP_9");
} else
keys.push_back(key);
// if the item is not in a menu yet, the shortcut adding will be deferred
if (item->get_parent() && get_accel_group(item->get_parent()))
add_shortcuts(get_accel_group(item->get_parent()), menu_item, parts, keys);
}
mixer_window::mixer_window(mixer & mixer)
: mixer_(mixer),
file_menu_item_(gettext("_File"), true),
quit_menu_item_(Gtk::StockID("gtk-quit")),
settings_menu_item_(gettext("_Settings"), true),
format_menu_item_(gettext("_Format"), true),
sources_menu_item_(gettext("_Sources"), true),
safe_area_menu_item_(gettext("_Highlight safe area"), true),
fullscreen_menu_item_(gettext("Fu_ll screen"), true),
status_bar_menu_item_(gettext("Status _Bar"), true),
status_bar_radio_grp(),
status_bar_on_menu_item_(status_bar_radio_grp, gettext("On"), false),
status_bar_off_menu_item_(status_bar_radio_grp, gettext("Off"), false),
status_bar_blink_menu_item_(status_bar_radio_grp, gettext("Blink"), false),
record_button_(),
record_icon_(Gtk::Stock::MEDIA_RECORD, Gtk::ICON_SIZE_BUTTON),
cut_button_(),
cut_icon_(Gtk::Stock::CUT, Gtk::ICON_SIZE_BUTTON),
effects_frame_(gettext("Effects")),
none_button_(effect_group_, gettext("No effect/transition")),
pip_button_(effect_group_, gettext("_Pic-in-pic"), true),
mfade_button_(effect_group_, gettext("_Manual fade"), true),
tfade_button_(effect_group_, gettext("Timed fa_de"), true),
tfade_label_(gettext("Transition speed [ms]:")),
tfade_value_(40, 15040, 40),
mfade_label_(gettext("Manual fade A/B:")),
mfade_ab_(0, 256, 1),
apply_button_(),
apply_icon_(Gtk::Stock::APPLY, Gtk::ICON_SIZE_BUTTON),
trans_frame_(gettext("Transitions")),
vu_meter_(-56, 0),
pri_video_source_id_(0),
sec_video_source_id_(0),
pip_active_(false),
pip_pending_(false),
mfade_active_(false),
progress_active_(false),
fullscreen_state_(false),
wakeup_pipe_(O_NONBLOCK, O_NONBLOCK),
next_source_id_(0),
osc_(NULL),
source_count_(0)
{
// In some locales (e.g., Dutch), the shortcuts of the stock button
// labels conflict (e.g., _record -> op_nemen, cu_t -> k_nippen).
// So, rather than using stock buttons, use buttons with our own
// gettexted strings, and the same stock labels; the look will be
// the same, but now the shortcut can be overridden for localized
// variants.
record_button_.set_label(gettext("_Record"));
record_button_.set_use_underline();
record_button_.set_image(record_icon_);
cut_button_.set_label(gettext("Cu_t"));
cut_button_.set_use_underline();
cut_button_.set_image(cut_icon_);
apply_button_.set_label(gettext("_Apply"));
apply_button_.set_use_underline();
apply_button_.set_image(apply_icon_);
Glib::RefPtr<Glib::IOSource> pipe_io_source(
Glib::IOSource::create(wakeup_pipe_.reader.get(), Glib::IO_IN));
pipe_io_source->set_priority(Glib::PRIORITY_DEFAULT_IDLE);
pipe_io_source->connect(sigc::mem_fun(this, &mixer_window::update));
pipe_io_source->attach();
set_mnemonic_modifier(Gdk::ModifierType(0));
quit_menu_item_.signal_activate().connect(sigc::mem_fun(this, &mixer_window::open_quit_dialog));
quit_menu_item_.show();
file_menu_.add(quit_menu_item_);
file_menu_item_.set_submenu(file_menu_);
file_menu_item_.show();
menu_bar_.add(file_menu_item_);
format_menu_item_.signal_activate().connect(
sigc::mem_fun(this, &mixer_window::open_format_dialog));
format_menu_item_.show();
sources_menu_item_.signal_activate().connect(
sigc::mem_fun(this, &mixer_window::open_sources_dialog));
sources_menu_item_.show();
safe_area_menu_item_.signal_toggled().connect(
sigc::mem_fun(this, &mixer_window::toggle_safe_area_display));
safe_area_menu_item_.show();
safe_area_menu_item_.set_active(true);
fullscreen_menu_item_.signal_toggled().connect(
sigc::mem_fun(this, &mixer_window::toggle_fullscreen));
fullscreen_menu_item_.show();
fullscreen_menu_item_.set_active(false);
settings_menu_.add(sources_menu_item_);
settings_menu_.add(format_menu_item_);
settings_menu_.add(safe_area_menu_item_);
settings_menu_.add(fullscreen_menu_item_);
status_bar_on_menu_item_.signal_toggled().connect(
sigc::bind<0>(sigc::mem_fun(osd_, &status_overlay::set_bar_mode), status_overlay::BAR_ON));
status_bar_off_menu_item_.signal_toggled().connect(
sigc::bind<0>(sigc::mem_fun(osd_, &status_overlay::set_bar_mode), status_overlay::BAR_OFF));
status_bar_blink_menu_item_.signal_toggled().connect(
sigc::bind<0>(sigc::mem_fun(osd_, &status_overlay::set_bar_mode), status_overlay::BAR_BLINK));
status_bar_blink_menu_item_.set_active(true);
status_bar_on_menu_item_.show();
status_bar_off_menu_item_.show();
status_bar_blink_menu_item_.show();
status_bar_menu_.add(status_bar_on_menu_item_);
status_bar_menu_.add(status_bar_off_menu_item_);
status_bar_menu_.add(status_bar_blink_menu_item_);
status_bar_menu_item_.show();
status_bar_menu_item_.set_submenu(status_bar_menu_);
settings_menu_.add(status_bar_menu_item_);
settings_menu_item_.set_submenu(settings_menu_);
settings_menu_item_.show();
menu_bar_.add(settings_menu_item_);
menu_bar_.show();
record_button_.set_mode(/*draw_indicator=*/false);
record_button_.signal_toggled().connect(
sigc::mem_fun(*this, &mixer_window::toggle_record));
record_button_.set_sensitive(false);
record_button_.show();
cut_button_.set_sensitive(false);
cut_button_.signal_clicked().connect(sigc::mem_fun(mixer_, &mixer::cut));
cut_button_.show();
command_sep_.show();
none_button_.set_mode(/*draw_indicator=*/false);
none_button_.set_sensitive(false);
none_button_.signal_clicked().connect(
sigc::mem_fun(this, &mixer_window::cancel_effect));
none_button_.add_accelerator("activate",
get_accel_group(),
GDK_Escape,
Gdk::ModifierType(0),
Gtk::AccelFlags(0));
none_button_.show();
pip_button_.set_mode(/*draw_indicator=*/false);
pip_button_.set_sensitive(false);
pip_button_.signal_clicked().connect(
sigc::mem_fun(this, &mixer_window::begin_pic_in_pic));
pip_button_.show();
mfade_button_.set_mode(/*draw_indicator=*/false);
mfade_button_.set_sensitive(false);
mfade_button_.signal_clicked().connect(
sigc::mem_fun(this, &mixer_window::begin_mfade));
mfade_button_.show();
tfade_button_.set_mode(/*draw_indicator=*/false);
tfade_button_.set_sensitive(false);
tfade_button_.signal_clicked().connect(
sigc::mem_fun(this, &mixer_window::begin_tfade));
tfade_button_.show();
// there are no stacked effects: manual and timed fading is exclusive:
// starting a timed fade will cancel the manual one.
// a short fade (2-3 frames) can still trick the viewer.
// once effect stacking is possible this should likley be set to
// a sane default - i.e 500 ms - 2 seconds is rather long.
tfade_value_.set_value(100);
tfade_value_.set_sensitive(false);
tfade_value_.set_value_pos(Gtk::POS_BOTTOM);
tfade_value_.show();
tfade_label_.show();
mfade_ab_.set_value(0);
mfade_ab_.set_draw_value(false);
mfade_ab_.set_sensitive(false);
mfade_ab_.show();
mfade_label_.show();
mfade_ab_.signal_value_changed().connect(
sigc::mem_fun(this, &mixer_window::mfade_update));
apply_button_.set_sensitive(false);
apply_button_.signal_clicked().connect(
sigc::mem_fun(this, &mixer_window::apply_effect));
apply_button_.add_accelerator("activate",
get_accel_group(),
GDK_Return,
Gdk::ModifierType(0),
Gtk::AccelFlags(0));
apply_button_.add_accelerator("activate",
get_accel_group(),
GDK_KP_Enter,
Gdk::ModifierType(0),
Gtk::AccelFlags(0));
apply_button_.show();
progress_.set_text(gettext("Transition Progress"));
progress_.show();
vu_meter_.show();
display_.show();
osd_.add(display_);
osd_.set_status(gettext("STOP"), "gtk-media-stop");
osd_.show();
selector_.set_border_width(gui_standard_spacing);
selector_.set_accel_group(get_accel_group());
selector_.signal_pri_video_selected().connect(
sigc::mem_fun(*this, &mixer_window::set_pri_video_source));
selector_.signal_sec_video_selected().connect(
sigc::mem_fun(*this, &mixer_window::set_sec_video_source));
selector_.signal_audio_selected().connect(
sigc::mem_fun(mixer_, &mixer::set_audio_source));
selector_.show();
effects_box_.set_border_width(gui_standard_spacing);
effects_box_.set_spacing(gui_standard_spacing);
effects_box_.pack_start(apply_button_, Gtk::PACK_SHRINK);
effects_box_.pack_start(pip_button_, Gtk::PACK_SHRINK);
effects_box_.pack_start(mfade_button_, Gtk::PACK_SHRINK);
effects_box_.pack_start(mfade_label_, Gtk::PACK_SHRINK);
effects_box_.pack_start(mfade_ab_, Gtk::PACK_SHRINK);
effects_box_.show();
effects_frame_.add(effects_box_);
effects_frame_.show();
trans_box_.set_border_width(gui_standard_spacing);
trans_box_.set_spacing(gui_standard_spacing);
trans_box_.pack_start(tfade_button_, Gtk::PACK_SHRINK);
trans_box_.pack_start(tfade_label_, Gtk::PACK_SHRINK);
trans_box_.pack_start(tfade_value_, Gtk::PACK_SHRINK);
trans_box_.pack_start(progress_, Gtk::PACK_SHRINK);
trans_box_.show();
trans_frame_.add(trans_box_);
trans_frame_.show();
command_box_.set_spacing(gui_standard_spacing);
command_box_.pack_start(record_button_, Gtk::PACK_SHRINK);
command_box_.pack_start(cut_button_, Gtk::PACK_SHRINK);
command_box_.pack_start(command_sep_, Gtk::PACK_SHRINK);
command_box_.pack_start(none_button_, Gtk::PACK_SHRINK);
command_box_.pack_start(effects_frame_,Gtk::PACK_SHRINK);
command_box_.pack_start(trans_frame_,Gtk::PACK_SHRINK);
command_box_.pack_start(vu_meter_, Gtk::PACK_EXPAND_WIDGET);
command_box_.show();
upper_box_.set_border_width(gui_standard_spacing);
upper_box_.set_spacing(gui_standard_spacing);
upper_box_.pack_start(command_box_, Gtk::PACK_SHRINK);
upper_box_.pack_start(osd_, Gtk::PACK_EXPAND_PADDING);
upper_box_.show();
main_box_.pack_start(menu_bar_, Gtk::PACK_SHRINK);
main_box_.pack_start(upper_box_, Gtk::PACK_SHRINK);
main_box_.pack_start(selector_, Gtk::PACK_EXPAND_PADDING);
main_box_.show();
add(main_box_);
}
void AppWindow::add_accelerator(Gtk::MenuItem *it, char accelerator) {
it->add_accelerator("activate", get_accel_group(), accelerator, (Gdk::ModifierType) 0, Gtk::ACCEL_VISIBLE);
it->add_accelerator("activate", get_accel_group(), accelerator, Gdk::SHIFT_MASK, Gtk::ACCEL_VISIBLE);
}
