void
perfedit::set_image (bool isrunning)
{
delete m_image_play;
if (isrunning)
{
m_image_play = manage(new PIXBUF_IMAGE(pause_xpm));
add_tooltip(m_button_play, "Pause playback at the current location.");
}
else
{
m_image_play = manage(new PIXBUF_IMAGE(play2_xpm));
add_tooltip(m_button_play, "Resume playback from the current location.");
}
m_button_play->set_image(*m_image_play);
}
/*Jack Sync page */
void
options::add_jack_sync_page()
{
#ifdef JACK_SUPPORT
VBox *vbox = manage(new VBox());
vbox->set_border_width(4);
m_notebook->append_page(*vbox, "_Jack Sync", true);
/*Frame for transport options*/
Frame* transportframe = manage(new Frame("Transport"));
transportframe->set_border_width(4);
vbox->pack_start(*transportframe, Gtk::PACK_SHRINK);
VBox *transportbox = manage(new VBox());
transportbox->set_border_width(4);
transportframe->add(*transportbox);
CheckButton *check = manage(new CheckButton("Jack _Transport", true));
check->set_active (global_with_jack_transport);
add_tooltip( check, "Enable sync with JACK Transport.");
check->signal_toggled().connect(bind(mem_fun(*this,
&options::transport_callback), e_jack_transport, check));
transportbox->pack_start(*check, false, false);
check = manage(new CheckButton("Trans_port Master", true));
check->set_active (global_with_jack_master);
add_tooltip( check, "Seq24 will attempt to serve as JACK Master.");
check->signal_toggled().connect(bind(mem_fun(*this,
&options::transport_callback), e_jack_master, check));
transportbox->pack_start(*check, false, false);
check = manage (new CheckButton ("Master C_onditional", true));
check->set_active (global_with_jack_master_cond);
add_tooltip( check,
"Seq24 will fail to be master if there is already a master set.");
check->signal_toggled().connect(bind(mem_fun(*this,
&options::transport_callback), e_jack_master_cond, check));
transportbox->pack_start(*check, false, false);
#endif
}
/*------------------- create_mounter -------------------*/
static gboolean create_mounter_control (Control * control)
{
TRACE ("enters create_mounter_control");
t_mounter * mounter ;
mounter = g_new0(t_mounter,1);
/* default on_mount command */
mounter->on_mount_cmd = NULL;
/* default mount commands */
mounter->mount_command = strdup (DEFAULT_MOUNT_COMMAND);
mounter->umount_command = strdup (DEFAULT_UMOUNT_COMMAND);
/*plugin button */
GdkPixbuf * pb ;
pb = gdk_pixbuf_new_from_inline (sizeof(icon_plugin), icon_plugin, FALSE, NULL);
mounter->button = xfce_iconbutton_new_from_pixbuf (pb);
gtk_button_set_relief(GTK_BUTTON(mounter->button),GTK_RELIEF_NONE);
add_tooltip(GTK_WIDGET(mounter->button),_("devices"));
/*-------------------------------------------------------------*/
g_signal_connect(G_OBJECT(mounter->button),"button_press_event",G_CALLBACK(on_button_press),mounter);
gtk_widget_show(mounter->button);
/*get the data*/
mounter_data_new(mounter);
gtk_container_add(GTK_CONTAINER(control->base), mounter->button);
control->data = mounter ;
TRACE ("leaves create_mounter_control");
return TRUE;
}
tempopopup::tempopopup(tempo *a_tempo) :
m_tempo(a_tempo),
m_escape(false),
m_return(false),
m_is_typing(false),
m_current_beats(0),
m_base_time_ms(0),
m_last_time_ms(0)
{
// std::string title = "BPM";
// set_title(title);
set_size_request(150, 50);
#if GTK_MINOR_VERSION < 12
m_tooltips = manage( new Tooltips() );
#endif
/* bpm spin button */
m_adjust_bpm = manage(new Adjustment(m_tempo->m_mainperf->get_bpm(), c_bpm_minimum -1, c_bpm_maximum, 1));
m_spinbutton_bpm = manage( new SpinButton( *m_adjust_bpm ));
m_spinbutton_bpm->set_editable( true );
m_spinbutton_bpm->set_digits(2); // 2 = two decimal precision
m_adjust_bpm->signal_value_changed().connect(
mem_fun(*this, &tempopopup::adj_callback_bpm ));
m_spinbutton_bpm->set_numeric();
add_tooltip
(
m_spinbutton_bpm,
"Adjust beats per minute (BPM) value.\n"
"Values range from 0 to 600.00.\n"
"Escape to leave without setting\n"
"Entry of 0 indicates a STOP marker.\n"
);
m_spinbutton_bpm->set_update_policy(Gtk::UPDATE_IF_VALID); // ignore bad entries
Label* bpmlabel = manage(new Label("BPM"));
/* bpm tap tempo button - sequencer64 */
m_button_tap = manage(new Button("0"));
m_button_tap->signal_clicked().connect(sigc::mem_fun(*this, &tempopopup::tap));
add_tooltip
(
m_button_tap,
"Tap in time to set the beats per minute (BPM) value. "
"After 5 seconds of no taps, the tap-counter will reset to 0. "
"Also see the File / Options / Keyboard / Tap BPM key assignment."
);
m_button_tap->set_can_focus(false); // to force all keys to the spin button
HBox *hbox = manage(new HBox());
hbox->set_border_width(6);
hbox->pack_start(*bpmlabel, Gtk::PACK_SHRINK);
hbox->pack_start(*m_spinbutton_bpm, Gtk::PACK_SHRINK );
hbox->pack_start(*m_button_tap, Gtk::PACK_SHRINK, 5 );
add(*hbox);
set_modal(); // keep focus until done
set_transient_for(*m_tempo->m_perfedit); // always on top
set_decorated(false); // don't show title bar
add_events( Gdk::KEY_PRESS_MASK | Gdk::KEY_RELEASE_MASK );
m_timeout_connect = Glib::signal_timeout().connect(
mem_fun(*this, &tempopopup::timer_callback), 25);
}
/*MIDI Clock page*/
void
options::add_midi_clock_page()
{
// Clock Buses
int buses = m_perf->get_master_midi_bus ()->get_num_out_buses ();
VBox *vbox = manage(new VBox());
vbox->set_border_width(6);
m_notebook->append_page(*vbox, "MIDI _Clock", true);
manage (new Tooltips ());
for (int i = 0; i < buses; i++)
{
HBox *hbox2 = manage (new HBox ());
Label *label = manage( new Label(m_perf->get_master_midi_bus ()->
get_midi_out_bus_name (i), 0));
hbox2->pack_start (*label, false, false);
Gtk::RadioButton * rb_off = manage (new RadioButton ("Off"));
add_tooltip( rb_off, "Midi Clock will be disabled.");
Gtk::RadioButton * rb_on = manage (new RadioButton ("On (Pos)"));
add_tooltip( rb_on,
"Midi Clock will be sent. Midi Song Position and Midi Continue will be sent if starting greater than tick 0 in song mode, otherwise Midi Start is sent.");
Gtk::RadioButton * rb_mod = manage (new RadioButton ("On (Mod)"));
add_tooltip( rb_mod, "Midi Clock will be sent. Midi Start will be sent and clocking will begin once the song position has reached the modulo of the specified Size. (Used for gear that doesn't respond to Song Position)");
Gtk::RadioButton::Group group = rb_off->get_group ();
rb_on->set_group (group);
rb_mod->set_group (group);
rb_off->signal_toggled().connect (sigc::bind(mem_fun (*this,
&options::clock_callback_off), i, rb_off ));
rb_on->signal_toggled ().connect (sigc::bind(mem_fun (*this,
&options::clock_callback_on), i, rb_on ));
rb_mod->signal_toggled().connect (sigc::bind(mem_fun (*this,
&options::clock_callback_mod), i, rb_mod ));
hbox2->pack_end (*rb_mod, false, false );
hbox2->pack_end (*rb_on, false, false);
hbox2->pack_end (*rb_off, false, false);
vbox->pack_start( *hbox2, false, false );
switch ( m_perf->get_master_midi_bus ()->get_clock (i))
{
case e_clock_off:
rb_off->set_active(1);
break;
case e_clock_pos:
rb_on->set_active(1);
break;
case e_clock_mod:
rb_mod->set_active(1);
break;
}
}
Adjustment *clock_mod_adj = new Adjustment(midibus::get_clock_mod(),
1, 16 << 10, 1 );
SpinButton *clock_mod_spin = new SpinButton( *clock_mod_adj );
HBox *hbox2 = manage (new HBox ());
//m_spinbutton_bpm->set_editable( false );
hbox2->pack_start(*(manage(new Label(
"Clock Start Modulo (1/16 Notes)"))), false, false, 4);
hbox2->pack_start(*clock_mod_spin, false, false );
vbox->pack_start( *hbox2, false, false );
clock_mod_adj->signal_value_changed().connect(sigc::bind(mem_fun(*this,
&options::clock_mod_callback), clock_mod_adj));
}
perfedit::perfedit
(
perform & p,
bool second_perfedit,
int ppqn
) :
gui_window_gtk2 (p, 750, 500),
m_peer_perfedit (nullptr),
m_table (manage(new Gtk::Table(6, 3, false))),
m_vadjust (manage(new Gtk::Adjustment(0, 0, 1, 1, 1, 1))),
m_hadjust (manage(new Gtk::Adjustment(0, 0, 1, 1, 1, 1))),
m_vscroll (manage(new Gtk::VScrollbar(*m_vadjust))),
m_hscroll (manage(new Gtk::HScrollbar(*m_hadjust))),
m_perfnames (manage(new perfnames(perf(), *this, *m_vadjust))),
m_perfroll
(
manage(new perfroll(perf(), *this, *m_hadjust, *m_vadjust, ppqn))
),
m_perftime (manage(new perftime(perf(), *this, *m_hadjust))),
m_menu_snap (manage(new Gtk::Menu())),
#ifdef SEQ64_STAZED_TRANSPOSE
m_menu_xpose (manage(new Gtk::Menu())),
m_button_xpose (manage(new Gtk::Button())),
m_entry_xpose (manage(new Gtk::Entry())),
#endif
m_image_play (manage(new PIXBUF_IMAGE(play2_xpm))),
m_button_snap (manage(new Gtk::Button())),
m_entry_snap (manage(new Gtk::Entry())),
m_button_stop (manage(new Gtk::Button())),
m_button_play (manage(new Gtk::Button())),
m_button_loop (manage(new Gtk::ToggleButton())),
m_button_expand (manage(new Gtk::Button())),
m_button_collapse (manage(new Gtk::Button())),
m_button_copy (manage(new Gtk::Button())),
m_button_grow (manage(new Gtk::Button())),
m_button_undo (manage(new Gtk::Button())),
m_button_redo (manage(new Gtk::Button())), // stazed
#ifdef SEQ64_STAZED_JACK_SUPPORT
m_button_jack (manage(new Gtk::ToggleButton())),
m_button_follow (manage(new Gtk::ToggleButton())),
#endif
m_button_bpm (manage(new Gtk::Button())),
m_entry_bpm (manage(new Gtk::Entry())),
m_button_bw (manage(new Gtk::Button())),
m_entry_bw (manage(new Gtk::Entry())),
m_hbox (manage(new Gtk::HBox(false, 2))),
m_hlbox (manage(new Gtk::HBox(false, 2))),
m_tooltips (manage(new Gtk::Tooltips())), // valgrind complains!
m_menu_bpm (manage(new Gtk::Menu())),
m_menu_bw (manage(new Gtk::Menu())),
m_snap (0),
m_bpm (0),
m_bw (0),
m_ppqn (0),
#ifdef SEQ64_PAUSE_SUPPORT
m_is_running (false),
#endif
m_standard_bpm (SEQ64_DEFAULT_LINES_PER_MEASURE) /* 4 */
{
std::string title = "Sequencer64 - Song Editor";
if (second_perfedit)
title += " 2";
m_ppqn = choose_ppqn(ppqn);
set_icon(Gdk::Pixbuf::create_from_xpm_data(perfedit_xpm));
set_title(title); /* caption bar */
m_table->set_border_width(2);
m_hlbox->set_border_width(2);
m_button_grow->add
(
*manage(new Gtk::Arrow(Gtk::ARROW_RIGHT, Gtk::SHADOW_OUT))
);
m_button_grow->signal_clicked().connect(mem_fun(*this, &perfedit::grow));
add_tooltip(m_button_grow, "Increase size of grid.");
/*
* Fill the table
*/
m_table->attach(*m_hlbox, 0, 3, 0, 1, Gtk::FILL, Gtk::SHRINK, 2, 0);
m_table->attach(*m_perfnames, 0, 1, 2, 3, Gtk::SHRINK, Gtk::FILL);
m_table->attach(*m_perftime, 1, 2, 1, 2, Gtk::FILL, Gtk::SHRINK);
m_table->attach
(
*m_perfroll, 1, 2, 2, 3, Gtk::FILL | Gtk::SHRINK, Gtk::FILL | Gtk::SHRINK
);
m_table->attach(*m_vscroll, 2, 3, 2, 3, Gtk::SHRINK, Gtk::FILL | Gtk::EXPAND);
m_table->attach(*m_hbox, 0, 1, 3, 4, Gtk::FILL, Gtk::SHRINK, 0, 2);
m_table->attach(*m_hscroll, 1, 2, 3, 4, Gtk::FILL | Gtk::EXPAND, Gtk::SHRINK);
m_table->attach(*m_button_grow, 2, 3, 3, 4, Gtk::SHRINK, Gtk::SHRINK);
/*
* To reduce the amount of written code, we now use a static array to
* initialize some of the menu entries. We use the same list for the snap
* menu and for the beat-width menu. This adds a beat-width of 32 to the
* beat-width menu. A new feature! :-D
*/
#define SET_SNAP mem_fun(*this, &perfedit::set_snap)
#define SET_BW mem_fun(*this, &perfedit::set_beat_width)
static const int s_width_items [] =
{
1, 2, 4, 8, 16, 32,
0,
3, 6, 12, 24,
#ifdef USE_STAZED_EXTRA_SNAPS
0,
5, 10, 20, 40,
0,
7, 9, 11, 13, 14, 15
#endif
};
static const int s_width_count = sizeof(s_width_items) / sizeof(int);
for (int si = 0; si < s_width_count; ++si)
{
int item = s_width_items[si];
char fmt[8];
bool use_separator = false;
if (item > 1)
snprintf(fmt, sizeof fmt, "1/%d", item);
else if (item == 0)
use_separator = true;
else
snprintf(fmt, sizeof fmt, "%d", item);
if (use_separator)
{
m_menu_snap->items().push_back(SeparatorElem());
}
else
{
m_menu_snap->items().push_back
(
MenuElem(fmt, sigc::bind(SET_SNAP, item))
);
snprintf(fmt, sizeof fmt, "%d", item);
m_menu_bw->items().push_back(MenuElem(fmt, sigc::bind(SET_BW, item)));
}
}
#define SET_POPUP mem_fun(*this, &perfedit::popup_menu)
m_button_snap->add(*manage(new PIXBUF_IMAGE(snap_xpm)));
m_button_snap->signal_clicked().connect
(
sigc::bind<Gtk::Menu *>(SET_POPUP, m_menu_snap)
);
add_tooltip(m_button_snap, "Grid snap (fraction of measure length).");
m_entry_snap->set_size_request(40, -1);
m_entry_snap->set_editable(false);
#ifdef SEQ64_STAZED_TRANSPOSE
char num[12];
for (int i = -SEQ64_OCTAVE_SIZE; i <= SEQ64_OCTAVE_SIZE; ++i)
{
if (i != 0)
snprintf(num, sizeof num, "%+d [%s]", i, c_interval_text[abs(i)]);
else
snprintf(num, sizeof num, "0 [normal]");
m_menu_xpose->items().push_front
(
MenuElem
(
num,
sigc::bind
(
mem_fun(*this, &perfedit::transpose_button_callback), i
)
)
);
}
m_button_xpose->add
(
*manage(new Gtk::Image(Gdk::Pixbuf::create_from_xpm_data(transpose_xpm)))
);
m_button_xpose->signal_clicked().connect
(
sigc::bind<Gtk::Menu *>
(
mem_fun(*this, &perfedit::popup_menu), m_menu_xpose
)
);
add_tooltip(m_button_xpose, "Song-transpose all transposable sequences.");
m_entry_xpose->set_size_request(30, -1);
m_entry_xpose->set_editable(false);
#endif // SEQ64_STAZED_TRANSPOSE
#define SET_BPB mem_fun(*this, &perfedit::set_beats_per_bar)
char b[4];
for (int i = 0; i < 16; ++i)
{
snprintf(b, sizeof b, "%d", i + 1);
m_menu_bpm->items().push_back(MenuElem(b, sigc::bind(SET_BPB, i + 1)));
}
m_button_bpm->add(*manage(new PIXBUF_IMAGE(down_xpm)));
m_button_bpm->signal_clicked().connect
(
sigc::bind<Gtk::Menu *>(SET_POPUP, m_menu_bpm)
);
add_tooltip
(
m_button_bpm, "Time signature: beats per measure or bar."
);
m_entry_bpm->set_width_chars(2);
m_entry_bpm->set_editable(false);
m_button_bw->add(*manage(new PIXBUF_IMAGE(down_xpm))); /* beat width */
m_button_bw->signal_clicked().connect
(
sigc::bind<Gtk::Menu *>(SET_POPUP, m_menu_bw)
);
add_tooltip(m_button_bw, "Time signature: length of measure or bar.");
m_entry_bw->set_width_chars(2);
m_entry_bw->set_editable(false);
m_button_undo->add(*manage(new PIXBUF_IMAGE(undo_xpm)));
m_button_undo->signal_clicked().connect(mem_fun(*this, &perfedit::undo));
add_tooltip(m_button_undo, "Undo the last action (Ctrl-Z).");
m_button_redo->add(*manage(new PIXBUF_IMAGE(redo_xpm)));
m_button_redo->signal_clicked().connect(mem_fun(*this, &perfedit::redo));
add_tooltip(m_button_redo, "Redo the last undone action (Ctrl-R).");
m_button_expand->add(*manage(new PIXBUF_IMAGE(expand_xpm)));
m_button_expand->signal_clicked().connect(mem_fun(*this, &perfedit::expand));
add_tooltip(m_button_expand, "Expand space between L and R markers.");
m_button_collapse->add(*manage(new PIXBUF_IMAGE(collapse_xpm)));
m_button_collapse->signal_clicked().connect
(
mem_fun(*this, &perfedit::collapse)
);
add_tooltip(m_button_collapse, "Collapse pattern between L and R markers.");
m_button_copy->add(*manage(new PIXBUF_IMAGE(copy_xpm))); /* expand+copy */
m_button_copy->signal_clicked().connect(mem_fun(*this, &perfedit::copy));
add_tooltip(m_button_copy, "Expand and copy between the L and R markers.");
m_button_loop->add(*manage(new PIXBUF_IMAGE(loop_xpm)));
m_button_loop->signal_toggled().connect
(
mem_fun(*this, &perfedit::set_looped)
);
add_tooltip(m_button_loop, "Playback looped between the L and R markers.");
m_button_stop->set_focus_on_click(false);
m_button_stop->add(*manage(new PIXBUF_IMAGE(stop_xpm)));
m_button_stop->signal_clicked().connect
(
mem_fun(*this, &perfedit::stop_playing)
);
add_tooltip(m_button_stop, "Stop playback.");
m_button_stop->set_sensitive(true);
m_button_play->set_focus_on_click(false);
m_button_play->set_image(*m_image_play);
m_button_play->signal_clicked().connect
(
mem_fun(*this, &perfedit::start_playing)
);
add_tooltip(m_button_play, "Begin playback at the L marker.");
m_button_play->set_sensitive(true);
#ifdef SEQ64_STAZED_JACK_SUPPORT
m_button_jack->add(*manage(new PIXBUF_IMAGE(jack_black_xpm)));
m_button_jack->signal_clicked().connect
(
mem_fun(*this, &perfedit::set_jack_mode)
);
add_tooltip(m_button_jack, "Toggle JACK sync connection.");
if (rc().with_jack_transport())
m_button_jack->set_active(true);
m_button_follow->add(*manage(new PIXBUF_IMAGE(transport_follow_xpm)));
m_button_follow->signal_clicked().connect
(
mem_fun(*this, &perfedit::set_follow_transport)
);
add_tooltip(m_button_follow, "Toggle the following of JACK transport.");
m_button_follow->set_active(true);
#endif
m_hlbox->pack_end(*m_button_copy , false, false);
m_hlbox->pack_end(*m_button_expand , false, false);
m_hlbox->pack_end(*m_button_collapse , false, false);
m_hlbox->pack_end(*m_button_undo , false, false);
m_hlbox->pack_end(*m_button_redo , false, false); // stazed
m_hlbox->pack_start(*m_button_stop , false, false);
m_hlbox->pack_start(*m_button_play , false, false);
m_hlbox->pack_start(*m_button_loop , false, false);
m_hlbox->pack_start(*m_button_bpm , false, false);
m_hlbox->pack_start(*m_entry_bpm , false, false);
m_hlbox->pack_start(*(manage(new Gtk::Label("/"))), false, false, 4);
m_hlbox->pack_start(*m_button_bw , false, false);
m_hlbox->pack_start(*m_entry_bw , false, false);
m_hlbox->pack_start(*(manage(new Gtk::Label("x"))), false, false, 4);
m_hlbox->pack_start(*m_button_snap , false, false);
m_hlbox->pack_start(*m_entry_snap , false, false);
#ifdef SEQ64_STAZED_TRANSPOSE
m_hlbox->pack_start(*m_button_xpose , false, false);
m_hlbox->pack_start(*m_entry_xpose , false, false);
#endif
#ifdef SEQ64_STAZED_JACK_SUPPORT
m_hlbox->pack_start(*m_button_jack, false, false);
m_hlbox->pack_start(*m_button_follow, false, false);
#endif
add(*m_table);
/*
* Here, the set_snap call depends on the others being done first. These
* calls also depend upon the values being set to bogus (0) values in the
* initializer list, otherwise no change will occur, and the items won't
* be displayed.
*/
set_beats_per_bar(SEQ64_DEFAULT_BEATS_PER_MEASURE); /* time-sig numerator */
set_beat_width(SEQ64_DEFAULT_BEAT_WIDTH); /* time-sig denominator */
set_snap(SEQ64_DEFAULT_PERFEDIT_SNAP);
#ifdef SEQ64_STAZED_TRANSPOSE
set_transpose(0);
#endif
/*
* Log the pointer to the appropriate perfedit object, if not already
* done.
*/
if (second_perfedit)
{
if (is_nullptr(gs_perfedit_pointer_1))
gs_perfedit_pointer_1 = this;
}
else
{
if (is_nullptr(gs_perfedit_pointer_0))
gs_perfedit_pointer_0 = this;
}
}
mainwnd::mainwnd(perform *a_p):
m_mainperf(a_p),
m_modified(false),
m_options(NULL)
{
set_icon(Gdk::Pixbuf::create_from_xpm_data(seq24_32_xpm));
/*sjh stuff...*/
set_wsetlist_mode(m_mainperf->get_setlist_mode());
/*............*/
/* register for notification */
m_mainperf->m_notify.push_back( this );
/* main window */
update_window_title();
#if GTK_MINOR_VERSION < 12
m_tooltips = manage( new Tooltips() );
#endif
m_main_wid = manage( new mainwid( m_mainperf ));
m_main_time = manage( new maintime( ));
m_menubar = manage(new MenuBar());
m_menu_file = manage(new Menu());
m_menubar->items().push_front(MenuElem("_File", *m_menu_file));
m_menu_view = manage( new Menu());
m_menubar->items().push_back(MenuElem("_View", *m_menu_view));
m_menu_help = manage( new Menu());
m_menubar->items().push_back(MenuElem("_Help", *m_menu_help));
/* file menu items */
m_menu_file->items().push_back(MenuElem("_New",
Gtk::AccelKey("<control>N"),
mem_fun(*this, &mainwnd::file_new)));
m_menu_file->items().push_back(MenuElem("_Open...",
Gtk::AccelKey("<control>O"),
mem_fun(*this, &mainwnd::file_open)));
m_menu_file->items().push_back(MenuElem("_Save",
Gtk::AccelKey("<control>S"),
mem_fun(*this, &mainwnd::file_save)));
m_menu_file->items().push_back(MenuElem("Save _as...",
mem_fun(*this, &mainwnd::file_save_as)));
m_menu_file->items().push_back(MenuElem("Open _setlist...",
mem_fun(*this, &mainwnd::file_open_setlist)));
m_menu_file->items().push_back(SeparatorElem());
m_menu_file->items().push_back(MenuElem("_Import...",
mem_fun(*this, &mainwnd::file_import_dialog)));
m_menu_file->items().push_back(MenuElem("O_ptions...",
mem_fun(*this,&mainwnd::options_dialog)));
m_menu_file->items().push_back(SeparatorElem());
m_menu_file->items().push_back(MenuElem("E_xit",
Gtk::AccelKey("<control>Q"),
mem_fun(*this, &mainwnd::file_exit)));
/* view menu items */
m_menu_view->items().push_back(MenuElem("_Song Editor...",
Gtk::AccelKey("<control>E"),
mem_fun(*this, &mainwnd::open_performance_edit)));
/* help menu items */
m_menu_help->items().push_back(MenuElem("_About...",
mem_fun(*this, &mainwnd::about_dialog)));
/* top line items */
HBox *tophbox = manage( new HBox( false, 0 ) );
tophbox->pack_start(
*m_s24_pic,
// *manage(new Image(Gdk::Pixbuf::create_from_xpm_data(seq24_xpm))),
false, false);
// adjust placement...
VBox *vbox_b = manage( new VBox() );
HBox *hbox3 = manage( new HBox( false, 0 ) );
vbox_b->pack_start( *hbox3, false, false );
tophbox->pack_end( *vbox_b, false, false );
hbox3->set_spacing( 10 );
/* timeline */
hbox3->pack_start( *m_main_time, false, false );
/* group learn button */
m_button_learn = manage( new Button( ));
m_button_learn->set_focus_on_click( false );
m_button_learn->set_flags( m_button_learn->get_flags() & ~Gtk::CAN_FOCUS );
m_button_learn->set_image(*manage(new Image(
Gdk::Pixbuf::create_from_xpm_data( learn_xpm ))));
m_button_learn->signal_clicked().connect(
mem_fun(*this, &mainwnd::learn_toggle));
add_tooltip( m_button_learn, "Mute Group Learn\n\n"
"Click 'L' then press a mutegroup key to store the mute state of "
"the sequences in that key.\n\n"
"(see File/Options/Keyboard for available mutegroup keys "
"and the corresponding hotkey for the 'L' button)" );
hbox3->pack_end( *m_button_learn, false, false );
/*this seems to be a dirty hack:*/
Button w;
hbox3->set_focus_child( w ); // clear the focus not to trigger L via keys
/* bottom line items */
HBox *bottomhbox = manage( new HBox(false, 10));
/* container for start+stop buttons */
HBox *startstophbox = manage(new HBox(false, 4));
bottomhbox->pack_start(*startstophbox, Gtk::PACK_SHRINK);
/* stop button */
m_button_stop = manage( new Button());
m_button_stop->add(*manage(new Image(
Gdk::Pixbuf::create_from_xpm_data( stop_xpm ))));
m_button_stop->signal_clicked().connect(
mem_fun(*this, &mainwnd::stop_playing));/*sjh - can't pass anything into the stop_playing function because of this. */
add_tooltip( m_button_stop, "Stop playing MIDI sequence" );
m_button_stop->set_can_focus(false);
startstophbox->pack_start(*m_button_stop, Gtk::PACK_SHRINK);
/* play button */
m_button_play = manage(new Button() );
m_button_play->add(*manage(new Image(
Gdk::Pixbuf::create_from_xpm_data( play2_xpm ))));
m_button_play->signal_clicked().connect(
mem_fun( *this, &mainwnd::start_playing));
add_tooltip( m_button_play, "Play MIDI sequence" );
startstophbox->pack_start(*m_button_play, Gtk::PACK_SHRINK);
/* bpm spin button with label*/
HBox *bpmhbox = manage(new HBox(false, 4));
bottomhbox->pack_start(*bpmhbox, Gtk::PACK_SHRINK);
m_adjust_bpm = manage(new Adjustment(m_mainperf->get_bpm(), 20, 500, 1));
m_spinbutton_bpm = manage( new SpinButton( *m_adjust_bpm ));
m_spinbutton_bpm->set_editable( false );
m_adjust_bpm->signal_value_changed().connect(
mem_fun(*this, &mainwnd::adj_callback_bpm));
add_tooltip( m_spinbutton_bpm, "Adjust beats per minute (BPM) value");
Label* bpmlabel = manage(new Label("_bpm", true));
bpmlabel->set_mnemonic_widget(*m_spinbutton_bpm);
bpmhbox->pack_start(*bpmlabel, Gtk::PACK_SHRINK);
bpmhbox->pack_start(*m_spinbutton_bpm, Gtk::PACK_SHRINK);
/* screen set name edit line */
HBox *notebox = manage(new HBox(false, 4));
bottomhbox->pack_start(*notebox, Gtk::PACK_EXPAND_WIDGET);
m_entry_notes = manage( new Entry());
m_entry_notes->signal_changed().connect(
mem_fun(*this, &mainwnd::edit_callback_notepad));
m_entry_notes->set_text(*m_mainperf->get_screen_set_notepad(
m_mainperf->get_screenset()));
add_tooltip( m_entry_notes, "Enter screen set name" );
Label* notelabel = manage(new Label("_Name", true));
notelabel->set_mnemonic_widget(*m_entry_notes);
notebox->pack_start(*notelabel, Gtk::PACK_SHRINK);
notebox->pack_start(*m_entry_notes, Gtk::PACK_EXPAND_WIDGET);
/* sequence set spin button */
HBox *sethbox = manage(new HBox(false, 4));
bottomhbox->pack_start(*sethbox, Gtk::PACK_SHRINK);
m_adjust_ss = manage( new Adjustment( 0, 0, c_max_sets - 1, 1 ));
m_spinbutton_ss = manage( new SpinButton( *m_adjust_ss ));
m_spinbutton_ss->set_editable( false );
m_spinbutton_ss->set_wrap( true );
m_adjust_ss->signal_value_changed().connect(
mem_fun(*this, &mainwnd::adj_callback_ss ));
add_tooltip( m_spinbutton_ss, "Select screen set" );
Label* setlabel = manage(new Label("_Set", true));
setlabel->set_mnemonic_widget(*m_spinbutton_ss);
sethbox->pack_start(*setlabel, Gtk::PACK_SHRINK);
sethbox->pack_start(*m_spinbutton_ss, Gtk::PACK_SHRINK);
/* song edit button */
m_button_songedit = manage( new Button( ));
m_button_songedit->add( *manage( new Image(
Gdk::Pixbuf::create_from_xpm_data( perfedit_xpm ))));
m_button_songedit->signal_clicked().connect(
mem_fun( *this, &mainwnd::open_performance_edit ));
add_tooltip( m_button_songedit, "Show or hide song editor window" );
bottomhbox->pack_end(*m_button_songedit, Gtk::PACK_SHRINK);
/* vertical layout container for window content*/
VBox *contentvbox = new VBox();
contentvbox->set_spacing(10);
contentvbox->set_border_width(10);
contentvbox->pack_start(*tophbox, Gtk::PACK_SHRINK);
contentvbox->pack_start(*m_main_wid, Gtk::PACK_SHRINK);
contentvbox->pack_start(*bottomhbox, Gtk::PACK_SHRINK);
/*main container for menu and window content */
VBox *mainvbox = new VBox();
mainvbox->pack_start(*m_menubar, false, false );
mainvbox->pack_start( *contentvbox );
/* add main layout box */
this->add (*mainvbox);
/* show everything */
show_all();
add_events( Gdk::KEY_PRESS_MASK | Gdk::KEY_RELEASE_MASK );
m_timeout_connect = Glib::signal_timeout().connect(
mem_fun(*this, &mainwnd::timer_callback), 25);
m_perf_edit = new perfedit( m_mainperf );
// m_playlist_wnd = new playlist_wnd( m_mainperf);
m_playplay = new playlist_player();
m_sigpipe[0] = -1;
m_sigpipe[1] = -1;
install_signal_handlers();
}
options::options (Gtk::Window & parent, perform * a_p):
Gtk::Dialog ("Options", parent, true, true)
{
m_perf = a_p;
VBox *vbox = NULL;
HBox *hbox = manage (new HBox ());
get_vbox ()->pack_start (*hbox, false, false);
get_action_area ()->set_border_width (2);
hbox->set_border_width (6);
m_button_ok = manage (new Button ("Ok"));
get_action_area ()->pack_end (*m_button_ok, false, false);
m_button_ok->signal_clicked ().connect (mem_fun (*this, &options::hide));
m_notebook = manage (new Notebook ());
hbox->pack_start (*m_notebook);
// Clock Buses
int buses = m_perf->get_master_midi_bus ()->get_num_out_buses ();
//Notebook *clock_notebook = manage( new Notebook());
//clock_notebook->set_scrollable(true);
vbox = manage(new VBox());
m_notebook->pages().push_back(Notebook_Helpers::TabElem(*vbox,
"MIDI Clock"));
CheckButton *check;
Label *label;
Gtk::Tooltips * tooltips = manage (new Tooltips ());
for (int i = 0; i < buses; i++)
{
HBox *hbox2 = manage (new HBox ());
label = manage( new Label(m_perf->get_master_midi_bus ()->
get_midi_out_bus_name (i), 0));
hbox2->pack_start (*label, false, false);
Gtk::RadioButton * rb_off = manage (new RadioButton ("Off"));
add_tooltip( rb_off, "Midi Clock will be disabled.");
Gtk::RadioButton * rb_on = manage (new RadioButton ("On (Pos)"));
add_tooltip( rb_on,
"Midi Clock will be sent. Midi Song Position and Midi Continue will be sent if starting greater than tick 0 in song mode, otherwise Midi Start is sent.");
Gtk::RadioButton * rb_mod = manage (new RadioButton ("On (Mod)"));
add_tooltip( rb_mod, "Midi Clock will be sent. Midi Start will be sent and clocking will begin once the song position has reached the modulo of the specified Size. (Used for gear that doesn't respond to Song Position)");
Gtk::RadioButton::Group group = rb_off->get_group ();
rb_on->set_group (group);
rb_mod->set_group (group);
rb_off->signal_toggled().connect (sigc::bind(mem_fun (*this, &options::clock_callback_off), i, rb_off ));
rb_on->signal_toggled ().connect (sigc::bind(mem_fun (*this, &options::clock_callback_on), i, rb_on ));
rb_mod->signal_toggled().connect (sigc::bind(mem_fun (*this, &options::clock_callback_mod), i, rb_mod ));
hbox2->pack_end (*rb_mod, false, false );
hbox2->pack_end (*rb_on, false, false);
hbox2->pack_end (*rb_off, false, false);
vbox->pack_start( *hbox2, false, false );
switch ( m_perf->get_master_midi_bus ()->get_clock (i))
{
case e_clock_off: rb_off->set_active(1); break;
case e_clock_pos: rb_on->set_active(1); break;
case e_clock_mod: rb_mod->set_active(1); break;
}
// SET DEFAULT STATES check->set_active (m_perf->get_master_midi_bus ()->get_clock (i));
}
Adjustment *clock_mod_adj = new Adjustment( midibus::get_clock_mod(), 1, 16 << 10, 1 );
SpinButton *clock_mod_spin = new SpinButton( *clock_mod_adj );
HBox *hbox2 = manage (new HBox ());
//m_spinbutton_bpm->set_editable( false );
hbox2->pack_start(*(manage( new Label( "Clock Start Modulo (1/16 Notes)"))), false, false, 4);
hbox2->pack_start(*clock_mod_spin, false, false );
vbox->pack_start( *hbox2, false, false );
clock_mod_adj->signal_value_changed().connect( sigc::bind(mem_fun(*this,&options::clock_mod_callback),clock_mod_adj));
// add controls for input method
{
Adjustment *adj = new Adjustment( global_interactionmethod, 0, e_number_of_interactions-1, 1 );
SpinButton *spin = new SpinButton( *adj );
HBox *hbox2 = manage (new HBox ());
HBox *hbox3 = manage (new HBox ());
//m_spinbutton_bpm->set_editable( false );
interaction_method_label = new Label("Input Method");
hbox2->pack_start(*(manage( interaction_method_label )), false, false, 4);
hbox2->pack_start(*spin, false, false );
vbox->pack_start( *hbox2, false, false );
interaction_method_desc_label = new Label(" ----- ");
hbox3->pack_start(*(manage( interaction_method_desc_label )), false, false, 4);
vbox->pack_start(*hbox3, false, false );
adj->signal_value_changed().connect( sigc::bind(mem_fun(*this,&options::interaction_method_callback),adj));
// force it to refresh.
interaction_method_callback( adj );
}
// Input Buses
buses = m_perf->get_master_midi_bus ()->get_num_in_buses ();
vbox = manage (new VBox ());
m_notebook->pages ().
push_back (Notebook_Helpers::TabElem (*vbox, "MIDI Input"));
for (int i = 0; i < buses; i++)
{
check =
manage (new
CheckButton (m_perf->get_master_midi_bus ()->
get_midi_in_bus_name (i), 0));
check->signal_toggled ().
connect (bind (mem_fun (*this, &options::input_callback), i, check));
check->set_active (m_perf->get_master_midi_bus ()->get_input (i));
vbox->pack_start (*check, false, false);
}
// KeyBoard keybinding setup (editor for .seq42rc keybindings.
vbox = manage (new VBox ());
m_notebook->pages ().push_back (Notebook_Helpers::TabElem (*vbox, "Keyboard"));
{
Label* label;
KeyBindEntry* entry;
HBox *hbox;
#define AddKey(text, integer) \
label = manage (new Label( text )); \
hbox->pack_start (*label, false, false, 4); \
entry = manage (new KeyBindEntry( &integer )); \
hbox->pack_start (*entry, false, false, 4);
hbox = manage (new HBox ());
AddKey( "start:", m_perf->m_key_start );
AddKey( "stop:", m_perf->m_key_stop );
AddKey( "toggle looping:", m_perf->m_key_loop );
vbox->pack_start (*hbox, false, false);
hbox = manage (new HBox ());
AddKey( "bpm dn:", m_perf->m_key_bpm_dn );
AddKey( "bpm up:", m_perf->m_key_bpm_up );
vbox->pack_start (*hbox, false, false);
#undef AddKey
}
// Jack
#ifdef JACK_SUPPORT
VBox *vbox2 = manage (new VBox ());
vbox2->set_border_width (4);
m_notebook->pages().push_back(Notebook_Helpers::TabElem(*vbox2,
"Jack Sync"));
check = manage (new CheckButton ("Jack Transport"));
check->set_active (global_with_jack_transport);
add_tooltip( check, "Enable sync with JACK Transport.");
check->signal_toggled ().
connect (bind
(mem_fun (*this, &options::transport_callback), e_jack_transport,
check));
vbox2->pack_start (*check, false, false);
check = manage (new CheckButton ("Transport Master"));
check->set_active (global_with_jack_master);
add_tooltip( check, "Seq42 will attempt to serve as JACK Master.");
check->signal_toggled ().
connect (bind
(mem_fun (*this, &options::transport_callback), e_jack_master,
check));
vbox2->pack_start (*check, false, false);
check = manage (new CheckButton ("Master Conditional"));
check->set_active (global_with_jack_master_cond);
add_tooltip( check,
"Seq42 will fail to be master if there is already a master set.");
check->signal_toggled ().
connect (bind
(mem_fun (*this, &options::transport_callback), e_jack_master_cond,
check));
vbox2->pack_start (*check, false, false);
Gtk::Button * button = manage (new Button ("Connect"));
add_tooltip( button, "Connect to Jack.");
button->signal_clicked().connect(bind(mem_fun(*this,
&options::transport_callback), e_jack_connect, button));
vbox2->pack_start (*button, false, false);
button = manage (new Button ("Disconnect"));
add_tooltip( button, "Disconnect Jack.");
button->signal_clicked().connect(bind(mem_fun(*this,
&options::transport_callback), e_jack_disconnect, button));
vbox2->pack_start (*button, false, false);
#endif
/* show everything */
show_all_children ();
}
static gboolean
update_apm_status(t_battmon *battmon)
{
#ifdef __OpenBSD__
struct apm_power_info apm;
#else
struct apm_info apm;
#endif
int charge;
int time_remaining;
gboolean acline;
gchar buffer[128];
if(battmon->method == BM_BROKEN) {
/* See if ACPI or APM support has been enabled yet */
if(!detect_battery_info(battmon)) return TRUE;
if(battmon->timeoutid != 0) g_source_remove(battmon->timeoutid);
/* Poll only once per minute if using ACPI due to a bug */
if(battmon->method == BM_USE_ACPI) {
battmon->timeoutid = g_timeout_add(60 * 1000, (GSourceFunc) update_apm_status, battmon);
}
else {
battmon->timeoutid = g_timeout_add(2 * 1000, (GSourceFunc) update_apm_status, battmon);
}
}
/* Show initial state if using ACPI rather than waiting a minute */
if(battmon->flag) {
battmon->flag = FALSE;
g_source_remove(battmon->timeoutid);
battmon->timeoutid = g_timeout_add(60 * 1000, (GSourceFunc) update_apm_status, battmon);
}
#ifdef __FreeBSD__
/* This is how I read the information from the APM subsystem under
FreeBSD. Each time this functions is called (once every second)
the APM device is opened, read from and then closed.
*/
int fd;
battmon->method = BM_BROKEN;
fd = open(APMDEVICE, O_RDONLY);
if (fd == -1) return TRUE;
if (ioctl(fd, APMIO_GETINFO, &apm) == -1)
return TRUE;
close(fd);
acline = apm.ai_acline ? TRUE : FALSE;
time_remaining = apm.ai_batt_time;
time_remaining = time_remaining / 60; /* convert from seconds to minutes */
charge = apm.ai_batt_life;
#elif __OpenBSD__
/* Code for OpenBSD by Joe Ammond <*****@*****.**>. Using the same
procedure as for FreeBSD.
*/
int fd;
battmon->method = BM_BROKEN;
fd = open(APMDEVICE, O_RDONLY);
if (fd == -1) return TRUE;
if (ioctl(fd, APM_IOC_GETPOWER, &apminfo) == -1)
return TRUE;
close(fd);
charge = apm.battery_life;
time_remaining = apm.minutes_left;
acline = apm.ac_state ? TRUE : FALSE;
#elif __linux__
if(battmon->method == BM_USE_ACPI) acpi_linux_read(&apm);
else apm_read(&apm); /* not broken and not using ACPI, assume APM */
charge = apm.battery_percentage;
if(battmon->method == BM_USE_ACPI) time_remaining = 0; /* no such info for ACPI :( */
else time_remaining = apm.battery_time;
acline = apm.ac_line_status ? TRUE : FALSE;
#endif
if(charge < 0) charge = 0;
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(battmon->battstatus), charge / 100.0);
if(battmon->options.tooltip_display_percentage && battmon->options.tooltip_display_time) {
if(acline)
g_snprintf(buffer, sizeof(buffer), _("%d%% (AC on-line)"), charge);
else if(time_remaining > 0)
g_snprintf(buffer, sizeof(buffer), _("%d%% (%d:%.2d) remaining"), charge, time_remaining / 60, time_remaining % 60);
else
g_snprintf(buffer, sizeof(buffer), _("%d%% (AC off-line)"), charge);
add_tooltip(battmon->ebox, buffer);
}
else if(battmon->options.tooltip_display_percentage) {
g_snprintf(buffer, sizeof(buffer), _("%d%%"), charge);
add_tooltip(battmon->ebox, buffer);
}
else if(battmon->options.tooltip_display_time) {
if(acline)
g_snprintf(buffer, sizeof(buffer), _("AC on-line"));
else if(time_remaining > 0)
g_snprintf(buffer, sizeof(buffer), _("%d:%.2d remaining"), time_remaining / 60, time_remaining % 60);
else
g_snprintf(buffer, sizeof(buffer), _("AC off-line"));
add_tooltip(battmon->ebox, buffer);
}
else add_tooltip(battmon->ebox, NULL);
if(battmon->options.display_percentage) {
g_snprintf(buffer, sizeof(buffer), _("%d%%"), charge);
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(battmon->battstatus), buffer);
}
else gtk_progress_bar_set_text(GTK_PROGRESS_BAR(battmon->battstatus), NULL);
if(!battmon->critical && charge <= battmon->options.critical_percentage) {
battmon->critical = TRUE;
battmon->low = TRUE;
if(battmon->options.action_on_critical == BM_MESSAGE)
xfce_warn(_("WARNING: Your battery has reached critical status. You should plug in or shutdown your computer now to avoid possible data loss."));
if(battmon->options.action_on_critical == BM_COMMAND) {
if(battmon->options.command_on_critical && battmon->options.command_on_critical[0])
exec_cmd(battmon->options.command_on_critical, 0, 0);
}
if(battmon->options.action_on_critical == BM_COMMAND_TERM) {
if(battmon->options.command_on_critical && battmon->options.command_on_critical[0])
exec_cmd(battmon->options.command_on_critical, 1, 0);
}
}
else if(battmon->critical && charge > battmon->options.critical_percentage)
battmon->critical = FALSE;
if(!battmon->low && charge <= battmon->options.low_percentage) {
battmon->low = TRUE;
if(battmon->options.action_on_low == BM_MESSAGE)
xfce_warn(_("WARNING: Your battery is running low. You should consider plugging in or shutting down your computer soon to avoid possible data loss."));
if(battmon->options.action_on_low == BM_COMMAND) {
if(battmon->options.command_on_low && battmon->options.command_on_low[0])
exec_cmd(battmon->options.command_on_low, 0, 0);
}
if(battmon->options.action_on_low == BM_COMMAND_TERM) {
if(battmon->options.command_on_low && battmon->options.command_on_low[0])
exec_cmd(battmon->options.command_on_low, 1, 0);
}
}
else if(battmon->low && charge > battmon->options.low_percentage)
battmon->low = FALSE;
return TRUE;
}
