domain = 'gtk_ardour'
-gtkardour.Append(DOMAIN=domain, MAJOR=1,MINOR=0,MICRO=1)
+gtkardour.Append(DOMAIN=domain, MAJOR=1,MINOR=0,MICRO=2)
gtkardour.Append(CXXFLAGS="-DPACKAGE=\\\"" + domain + "\\\"")
gtkardour.Append(PACKAGE=domain)
gtkardour.Append(POTFILE=domain + '.pot')
#include <ctime>
#include <cstdlib>
-#include <gtk--/label.h>
-#include <gtk--/text.h>
-#include <gtk--/scrolledwindow.h>
-#include <gtk--/notebook.h>
+#include <gtkmm/label.h>
+#include <gtkmm/text.h>
+#include <gtkmm/scrolledwindow.h>
+#include <gtkmm/notebook.h>
#include <ardour/ardour.h>
#include <ardour/version.h>
#include "utils.h"
#include "version.h"
-#include <gtkmmext/gtk_ui.h>
-#include <gtkmmext/doi.h>
+#include <gtkmm2ext/gtk_ui.h>
+#include <gtkmm2ext/doi.h>
#include "about.h"
#include "rgb_macros.h"
using namespace Gtk;
using namespace std;
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
#ifdef WITH_PAYMENT_OPTIONS
static gint
stoppit (GdkEventButton* ev, Gtk::Notebook* notebook)
{
- gtk_signal_emit_stop_by_name (GTK_OBJECT(notebook->gtkobj()),
+ gtk_signal_emit_stop_by_name (GTK_OBJECT(notebook->gobj()),
"button_release_event");
return TRUE;
}
author_text->insert (str);
author_scroller->add (*author_text);
- author_scroller->set_usize (-1, 75);
- author_scroller->set_policy (GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+ author_scroller->set_size_request (-1, 75);
+ author_scroller->set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
ScrolledWindow* translator_scroller = manage (new ScrolledWindow);
Text* translator_text = manage (new Text);
translator_text->insert (str);
translator_scroller->add (*translator_text);
- translator_scroller->set_usize (-1, 75);
- translator_scroller->set_policy (GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+ translator_scroller->set_size_request (-1, 75);
+ translator_scroller->set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
Label* author_tab_label = manage (new Label (_("Authors")));
Label* translator_tab_label = manage (new Label (_("Translators")));
vbox.set_spacing (5);
if (load_logo_size ()) {
- logo_area.set_usize (logo_width, logo_height);
+ logo_area.set_size_request (logo_width, logo_height);
load_logo (*this);
vbox.pack_start (logo_area, false, false);
delete_event.connect (bind (slot (just_hide_it), static_cast<Gtk::Window*> (this)));
add (vbox);
- add_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
+ add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
set_position (GTK_WIN_POS_CENTER);
window.realize ();
- logo_pixmap = gdk_pixmap_new (GTK_WIDGET(window.gtkobj())->window, logo_width, logo_height,
+ logo_pixmap = gdk_pixmap_new (GTK_WIDGET(window.gobj())->window, logo_width, logo_height,
gtk_preview_get_visual()->depth);
gc = gdk_gc_new (logo_pixmap);
- gtk_preview_put (preview.gtkobj(), logo_pixmap, gc, 0, 0, 0, 0, logo_width, logo_height);
+ gtk_preview_put (preview.gobj(), logo_pixmap, gc, 0, 0, 0, 0, logo_width, logo_height);
gdk_gc_destroy (gc);
delete [] pixelrow;
if (logo_pixmap) {
logo_area.get_window().draw_pixmap (logo_area.get_style()->get_black_gc(),
- Gdk_Pixmap (logo_pixmap),
+ Gdk::Pixmap (logo_pixmap),
0, 0,
((logo_area.width() - logo_width) / 2),
((logo_area.height() - logo_height) / 2),
#ifndef __ardour_gtk_about_h__
#define __ardour_gtk_about_h__
-#include <gtk--/window.h>
-#include <gtk--/pixmap.h>
+#include <gtkmm/window.h>
+#include <gtkmm/pixmap.h>
#include <gtk-canvas.h>
class ARDOUR_UI;
bool support;
ARDOUR_UI * _ui;
- SigC::Connection timeout_connection;
+ sigc::connection timeout_connection;
bool load_logo_size ();
bool load_logo (Gtk::Window&);
void gone_hidden ();
#ifdef WITH_PAYMENT_OPTIONS
- Gtk::Pixmap paypal_pixmap;
+ Gtk::Image paypal_pixmap;
Gtk::Button paypal_button;
void goto_paypal ();
#endif
#include <sigc++/bind.h>
-#include <gtkmmext/utils.h>
+#include <gtkmm2ext/utils.h>
#include "utils.h"
#include "add_route_dialog.h"
#include "i18n.h"
using namespace Gtk;
-using namespace Gtkmmext;
-using namespace SigC;
+using namespace Gtkmm2ext;
+using namespace sigc;
extern std::vector<string> channel_combo_strings;
set_name ("AddRouteDialog");
set_title (_("ardour: add track/bus"));
set_wmclass (X_("ardour_add_track_bus"), "Ardour");
- set_position (GTK_WIN_POS_MOUSE);
+ set_position (Gtk::WIN_POS_MOUSE);
set_keyboard_input (true);
name_template_entry.set_name ("AddRouteDialogNameTemplateEntry");
HBox* hbbut = manage (new HBox);
- set_usize_to_display_given_text (ok_button, _("Cancel"), 20, 15); // this is cancel on purpose
- set_usize_to_display_given_text (cancel_button, _("Cancel"), 20, 15);
+ set_size_request_to_display_given_text (ok_button, _("Cancel"), 20, 15); // this is cancel on purpose
+ set_size_request_to_display_given_text (cancel_button, _("Cancel"), 20, 15);
hbbut->set_homogeneous (true);
hbbut->set_spacing (6);
add (*vb2);
delete_event.connect (slot (*this, &ArdourDialog::wm_close_event));
- ok_button.clicked.connect (bind (slot (*this, &ArdourDialog::stop), 0));
- cancel_button.clicked.connect (bind (slot (*this, &ArdourDialog::stop), 1));
+ ok_button.signal_clicked().connect (bind (slot (*this, &ArdourDialog::stop), 0));
+ cancel_button.signal_clicked().connect (bind (slot (*this, &ArdourDialog::stop), 1));
}
AddRouteDialog::~AddRouteDialog ()
#include <string>
-#include <gtk--/entry.h>
-#include <gtk--/radiobutton.h>
-#include <gtk--/adjustment.h>
-#include <gtk--/spinbutton.h>
-#include <gtk--/button.h>
+#include <gtkmm/entry.h>
+#include <gtkmm/radiobutton.h>
+#include <gtkmm/adjustment.h>
+#include <gtkmm/spinbutton.h>
+#include <gtkmm/button.h>
-#include <gtkmmext/click_box.h>
+#include <gtkmm2ext/click_box.h>
#include "ardour_dialog.h"
#include <iostream>
-#include <gtkmmext/doi.h>
+#include <gtkmm2ext/doi.h>
#include "ardour_dialog.h"
#include "keyboard.h"
#define __ardour_dialog_h__
#include <ardour/ardour.h>
-#include <gtk--/window.h>
+#include <gtkmm/window.h>
#include "keyboard_target.h"
label.set_name (X_("PrompterLabel"));
ok_button.set_name ("EditorGTKButton");
- ok_button.clicked.connect (bind (slot (*this, &ArdourDialog::stop), 1));
+ ok_button.signal_clicked().connect (bind (slot (*this, &ArdourDialog::stop), 1));
packer.set_spacing (10);
packer.set_border_width (10);
packer.pack_start (ok_button);
set_name (X_("Prompter"));
- set_position (GTK_WIN_POS_MOUSE);
+ set_position (Gtk::WIN_POS_MOUSE);
set_modal (true);
add (packer);
show_all ();
#include <string>
-#include <gtk--/box.h>
-#include <gtk--/button.h>
-#include <gtk--/label.h>
+#include <gtkmm/box.h>
+#include <gtkmm/button.h>
+#include <gtkmm/label.h>
#include "ardour_dialog.h"
#include <iostream>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <pbd/error.h>
#include <pbd/basename.h>
#include <pbd/pathscanner.h>
#include <pbd/failed_constructor.h>
-#include <gtkmmext/gtk_ui.h>
-#include <gtkmmext/pix.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/click_box.h>
-#include <gtkmmext/selector.h>
-#include <gtkmmext/fastmeter.h>
-#include <gtkmmext/stop_signal.h>
-#include <gtkmmext/popup.h>
+#include <gtkmm2ext/gtk_ui.h>
+#include <gtkmm2ext/pix.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/click_box.h>
+#include <gtkmm2ext/selector.h>
+#include <gtkmm2ext/fastmeter.h>
+#include <gtkmm2ext/stop_signal.h>
+#include <gtkmm2ext/popup.h>
#include <midi++/port.h>
#include <midi++/mmc.h>
#include "i18n.h"
using namespace ARDOUR;
-using namespace Gtkmmext;
+using namespace Gtkmm2ext;
using namespace Gtk;
-using namespace SigC;
+using namespace sigc;
ARDOUR_UI *ARDOUR_UI::theArdourUI = 0;
SoundFileSelector* ARDOUR_UI::sfdb_window = 0;
-SigC::Signal1<void,bool> ARDOUR_UI::Blink;
-SigC::Signal0<void> ARDOUR_UI::RapidScreenUpdate;
-SigC::Signal0<void> ARDOUR_UI::SuperRapidScreenUpdate;
-SigC::Signal1<void,jack_nframes_t> ARDOUR_UI::Clock;
+sigc::signal<void,bool> ARDOUR_UI::Blink;
+sigc::signal<void> ARDOUR_UI::RapidScreenUpdate;
+sigc::signal<void> ARDOUR_UI::SuperRapidScreenUpdate;
+sigc::signal<void,jack_nframes_t> ARDOUR_UI::Clock;
/* XPM */
static const gchar *h_meter_strip_xpm[] = {
ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[], string rcfile)
- : Gtkmmext::UI ("ardour", argcp, argvp, rcfile),
+ : Gtkmm2ext::UI ("ardour", argcp, argvp, rcfile),
primary_clock (X_("TransportClockDisplay"), true, false, true),
secondary_clock (X_("SecondaryClockDisplay"), true, false, true),
{
using namespace Gtk::Menu_Helpers;
- Gtkmmext::init();
+ Gtkmm2ext::init();
/* actually, its already loaded, but ... */
prompt_label.set_alignment (0.5, 0.5);
prompt_label.set_name (X_("PrompterLabel"));
- save_button.clicked.connect (bind(slot(window,&ArdourDialog::stop), 1));
- nosave_button.clicked.connect (bind(slot(window,&ArdourDialog::stop), 0));
- noquit_button.clicked.connect (bind(slot(window,&ArdourDialog::stop), -1));
+ save_button.signal_clicked().connect (bind(slot(window,&ArdourDialog::stop), 1));
+ nosave_button.signal_clicked().connect (bind(slot(window,&ArdourDialog::stop), 0));
+ noquit_button.signal_clicked().connect (bind(slot(window,&ArdourDialog::stop), -1));
button_packer.set_spacing (10);
button_packer.pack_start (save_button);
window.set_name (_("Prompter"));
window.set_title (_("ardour: save session?"));
- window.set_position (GTK_WIN_POS_MOUSE);
+ window.set_position (Gtk::WIN_POS_MOUSE);
window.set_modal (true);
window.add (packer);
window.show_all ();
void
ARDOUR_UI::redisplay_recent_sessions ()
{
- using namespace Gtkmmext;
+ using namespace Gtkmm2ext;
using namespace Gtk::CTree_Helpers;
vector<string *> *sessions;
/* ---------------------------------------- */
/* XXX MAKE ME A FUNCTION (no CTree::clear() in gtkmm 1.2) */
- gtk_ctree_remove_node (session_selector.gtkobj(), NULL);
+ gtk_ctree_remove_node (session_selector.gobj(), NULL);
/* ---------------------------------------- */
vpacker->pack_start (*button_packer, false, false);
scroller->add (session_selector);
- scroller->set_policy(GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+ scroller->set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
session_selector_window->add (*vpacker);
session_selector_window->set_name ("SessionSelectorWindow");
- session_selector_window->set_usize (200, 400);
+ session_selector_window->set_size_request (200, 400);
session_selector_window->delete_event.connect (bind (slot (just_hide_it), static_cast<Gtk::Window*>(session_selector_window)));
- cancel_button->clicked.connect (bind (slot (*this, &ARDOUR_UI::hide_dialog), session_selector_window));
+ cancel_button-.signal_clicked().connect (bind (slot (*this, &ARDOUR_UI::hide_dialog), session_selector_window));
session_selector.tree_select_row.connect (slot (*this, &ARDOUR_UI::session_selection));
}
if (open_session_selector == 0) {
open_session_selector = new Gtk::FileSelection(_("open session"));
- open_session_selector->get_ok_button()->clicked.connect (slot (*this, &ARDOUR_UI::open_ok_clicked));
- open_session_selector->get_cancel_button()->clicked.connect (bind (slot (*this, &ARDOUR_UI::fs_cancel_clicked), open_session_selector));
+ open_session_selector->get_ok_button()-.signal_clicked().connect (slot (*this, &ARDOUR_UI::open_ok_clicked));
+ open_session_selector->get_cancel_button()-.signal_clicked().connect (bind (slot (*this, &ARDOUR_UI::fs_cancel_clicked), open_session_selector));
open_session_selector->delete_event.connect (bind (slot (*this, &ARDOUR_UI::fs_delete_event), open_session_selector));
}
/* XXX hack hack hack */
- GtkCList* clist = (GtkCList*) open_session_selector->gtkobj()->file_list;
+ GtkCList* clist = (GtkCList*) open_session_selector->gobj()->file_list;
gtk_clist_unselect_all (clist);
allow_focus(false);
void
ARDOUR_UI::queue_transport_change ()
{
- Gtkmmext::UI::instance()->call_slot (slot (*this, &ARDOUR_UI::map_transport_state));
+ Gtkmm2ext::UI::instance()->call_slot (slot (*this, &ARDOUR_UI::map_transport_state));
}
void
Gtk::Main::run ();
- if (prompter.status == Gtkmmext::Prompter::entered) {
+ if (prompter.status == Gtkmm2ext::Prompter::entered) {
string snapname;
prompter.get_result (snapname);
}
} else {
- if (w->get_state() != GTK_STATE_NORMAL) {
- w->set_state (GTK_STATE_NORMAL);
+ if (w->get_state() != Gtk::STATE_NORMAL) {
+ w->set_state (Gtk::STATE_NORMAL);
}
}
}
if (onoff) {
rec_button.set_state (GTK_STATE_ACTIVE);
} else {
- rec_button.set_state (GTK_STATE_NORMAL);
+ rec_button.set_state (Gtk::STATE_NORMAL);
}
break;
default:
rec_button.set_active (false);
- rec_button.set_state (GTK_STATE_NORMAL);
+ rec_button.set_state (Gtk::STATE_NORMAL);
break;
}
}
Gtk::Main::run();
- if (prompter.status == Gtkmmext::Prompter::entered) {
+ if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result (name);
Gtk::VBox vpacker;
const char* rowtext[1];
- list_scroller.set_policy (GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+ list_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
vpacker.set_border_width (10);
vpacker.set_spacing (10);
}
list_scroller.add_with_viewport (list);
- list_scroller.set_usize (-1, 250);
+ list_scroller.set_size_request (-1, 250);
vpacker.pack_start (list_scroller, true, true);
vpacker.pack_start (ok_button, false, false);
- ok_button.clicked.connect (Main::quit.slot ());
+ ok_button.signal_clicked().connect (Main::quit.slot ());
results.Hiding.connect (Main::quit.slot ());
results.add (vpacker);
- results.set_position (GTK_WIN_POS_MOUSE);
+ results.set_position (Gtk::WIN_POS_MOUSE);
results.set_title (_("ardour: cleanup"));
results.set_modal (true);
results.run ();
checker.set_name (_("CleanupDialog"));
checker.set_title (_("ardour cleanup"));
checker.set_wmclass (_("ardour_cleanup"), "Ardour");
- checker.set_position (GTK_WIN_POS_MOUSE);
+ checker.set_position (Gtk::WIN_POS_MOUSE);
checker.realize ();
checker.get_window().set_decorations (GdkWMDecoration (GDK_DECOR_BORDER|GDK_DECOR_RESIZEH));
- ok_button.clicked.connect (bind (slot (checker, &ArdourDialog::stop), 1));
- cancel_button.clicked.connect (bind (slot (checker, &ArdourDialog::stop), 0));
+ ok_button.signal_clicked().connect (bind (slot (checker, &ArdourDialog::stop), 1));
+ cancel_button.signal_clicked().connect (bind (slot (checker, &ArdourDialog::stop), 0));
checker.run ();
hpacker.pack_start (use_button);
hpacker.pack_start (cancel_button);
- use_button.clicked.connect (bind (slot (dialog, &ArdourDialog::stop), 0));
- cancel_button.clicked.connect (bind (slot (dialog, &ArdourDialog::stop), 1));
+ use_button.signal_clicked().connect (bind (slot (dialog, &ArdourDialog::stop), 0));
+ cancel_button.signal_clicked().connect (bind (slot (dialog, &ArdourDialog::stop), 1));
dialog.add (vpacker);
dialog.set_position (GTK_WIN_POS_CENTER);
#include <gtk-canvas.h>
#include <pbd/xml++.h>
-#include <gtkmmext/gtk_ui.h>
-#include <gtkmmext/pix.h>
-#include <gtkmmext/spinner.h>
-#include <gtkmmext/pixmap_button.h>
-#include <gtkmmext/popup_selector.h>
-#include <gtkmmext/click_box.h>
-#include <gtkmmext/selector.h>
+#include <gtkmm2ext/gtk_ui.h>
+#include <gtkmm2ext/pix.h>
+#include <gtkmm2ext/spinner.h>
+#include <gtkmm2ext/pixmap_button.h>
+#include <gtkmm2ext/popup_selector.h>
+#include <gtkmm2ext/click_box.h>
+#include <gtkmm2ext/selector.h>
#include <ardour/ardour.h>
#include <ardour/session.h>
class NewSessionDialog;
class LocationUI;
-namespace Gtkmmext {
+namespace Gtkmm2ext {
class TearOff;
};
#define FRAME_NAME "BaseFrame"
-class ARDOUR_UI : public Gtkmmext::UI
+class ARDOUR_UI : public Gtkmm2ext::UI
{
public:
ARDOUR_UI (int *argcp, char **argvp[], string rcfile);
Gtk::Tooltips& tooltips() { return _tooltips; }
- static SigC::Signal1<void,bool> Blink;
- static SigC::Signal0<void> RapidScreenUpdate;
- static SigC::Signal0<void> SuperRapidScreenUpdate;
- static SigC::Signal1<void,jack_nframes_t> Clock;
+ static sigc::signal<void,bool> Blink;
+ static sigc::signal<void> RapidScreenUpdate;
+ static sigc::signal<void> SuperRapidScreenUpdate;
+ static sigc::signal<void,jack_nframes_t> Clock;
/* this is a helper function to centralize the (complex) logic for
blinking rec-enable buttons.
private:
struct GlobalClickBox : public Gtk::VBox {
- Gtkmmext::ClickBox *box;
+ Gtkmm2ext::ClickBox *box;
Gtk::Frame frame;
Gtk::Label label;
vector<string> &strings;
GlobalClickBox (const string &str, vector<string> &vs)
: strings (vs),
adjustment (0, 0, vs.size() - 1, 1, 1, 0) {
- box = new Gtkmmext::ClickBox (&adjustment, "ClickButton");
+ box = new Gtkmm2ext::ClickBox (&adjustment, "ClickButton");
label.set_text (str);
label.set_name ("GlobalButtonLabel");
frame.add (*box);
- frame.set_shadow_type (GTK_SHADOW_IN);
+ frame.set_shadow_type (Gtk::SHADOW_IN);
pack_start (label);
pack_start (frame);
box->set_print_func (printer, this);
private:
Gtk::VBox top_packer;
- SigC::Connection clock_signal_connection;
+ sigc::connection clock_signal_connection;
void update_clocks ();
void start_clocking ();
void stop_clocking ();
void detach_tearoff (Gtk::Box* parent, Gtk::Widget* contents);
void reattach_tearoff (Gtk::Box* parent, Gtk::Widget* contents, int32_t order);
- Gtkmmext::TearOff* transport_tearoff;
+ Gtkmm2ext::TearOff* transport_tearoff;
Gtk::Frame transport_frame;
Gtk::HBox transport_tearoff_hbox;
Gtk::HBox transport_hbox;
gint every_point_one_seconds ();
gint every_point_zero_one_seconds ();
- SigC::Connection second_connection;
- SigC::Connection point_one_second_connection;
- SigC::Connection point_zero_one_second_connection;
+ sigc::connection second_connection;
+ sigc::connection point_one_second_connection;
+ sigc::connection point_zero_one_second_connection;
void diskstream_added (ARDOUR::DiskStream*);
string template_name;
void new_session_ok_clicked ();
- void new_session_template_choice (Gtkmmext::Selector *, Gtkmmext::SelectionResult*);
+ void new_session_template_choice (Gtkmm2ext::Selector *, Gtkmm2ext::SelectionResult*);
void hide_dialog (ArdourDialog *dialog);
void fs_cancel_clicked (Gtk::FileSelection*);
#include <iostream>
#include <cmath>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <pbd/error.h>
#include <pbd/basename.h>
#include <pbd/fastlog.h>
-#include <gtkmmext/pix.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/click_box.h>
-#include <gtkmmext/tearoff.h>
+#include <gtkmm2ext/pix.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/click_box.h>
+#include <gtkmm2ext/tearoff.h>
#include <ardour/audioengine.h>
#include <ardour/ardour.h>
using namespace std;
using namespace ARDOUR;
-using namespace Gtkmmext;
+using namespace Gtkmm2ext;
using namespace Gtk;
-using namespace SigC;
+using namespace sigc;
int
ARDOUR_UI::setup_windows ()
mmc_id_button->adjustment.value_changed.connect (slot (*this,&ARDOUR_UI::mmc_device_id_adjusted));
- adjuster_table.attach (*online_control_button, 0, 2, 1, 2, GTK_FILL|GTK_EXPAND, 0, 5, 5);
+ adjuster_table.attach (*online_control_button, 0, 2, 1, 2, Gtk::FILL|Gtk::EXPAND, 0, 5, 5);
adjuster_table.attach (*mmc_id_button, 2, 3, 1, 2, 0, 0, 5, 5);
}
transport_base.set_name ("TransportBase");
transport_base.add (transport_hbox);
- transport_frame.set_shadow_type (GTK_SHADOW_OUT);
+ transport_frame.set_shadow_type (Gtk::SHADOW_OUT);
transport_frame.set_name ("BaseFrame");
transport_frame.add (transport_base);
static_cast<Gtk::Widget*> (&transport_frame), 1));
- goto_start_button.add (*(manage (new Gtk::Pixmap (start_xpm))));
- goto_end_button.add (*(manage (new Gtk::Pixmap (end_xpm))));
- roll_button.add (*(manage (new Gtk::Pixmap (arrow_xpm))));
- stop_button.add (*(manage (new Gtk::Pixmap (stop_xpm))));
- play_selection_button.add (*(manage (new Gtk::Pixmap (play_selection_xpm))));
- rec_button.add (*(manage (new Gtk::Pixmap (rec_xpm))));
- auto_loop_button.add (*(manage (new Gtk::Pixmap (loop_xpm))));
+ goto_start_button.add (*(manage (new Gtk::Image (start_xpm))));
+ goto_end_button.add (*(manage (new Gtk::Image (end_xpm))));
+ roll_button.add (*(manage (new Gtk::Image (arrow_xpm))));
+ stop_button.add (*(manage (new Gtk::Image (stop_xpm))));
+ play_selection_button.add (*(manage (new Gtk::Image (play_selection_xpm))));
+ rec_button.add (*(manage (new Gtk::Image (rec_xpm))));
+ auto_loop_button.add (*(manage (new Gtk::Image (loop_xpm))));
ARDOUR_UI::instance()->tooltips().set_tip (roll_button, _("Play from playhead"));
ARDOUR_UI::instance()->tooltips().set_tip (stop_button, _("Stop playback"));
ARDOUR_UI::instance()->tooltips().set_tip (shuttle_style_button, _("Select sprung or wheel behaviour"));
ARDOUR_UI::instance()->tooltips().set_tip (speed_display_box, _("Current transport speed"));
- shuttle_box.set_flags (GTK_CAN_FOCUS);
- shuttle_box.set_events (shuttle_box.get_events() | GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK|GDK_BUTTON_RELEASE_MASK|GDK_BUTTON_PRESS_MASK|GDK_POINTER_MOTION_MASK);
- shuttle_box.set_usize (100, 15);
+ shuttle_box.set_flags (Gtk::CAN_FOCUS);
+ shuttle_box.set_events (shuttle_box.get_events() | GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::POINTER_MOTION_MASK);
+ shuttle_box.set_size_request (100, 15);
shuttle_box.set_name ("TransportButton");
goto_start_button.set_name ("TransportButton");
click_button.set_name ("TransportButton");
follow_button.set_name ("TransportButton");
- goto_start_button.unset_flags (GTK_CAN_FOCUS);
- goto_end_button.unset_flags (GTK_CAN_FOCUS);
- roll_button.unset_flags (GTK_CAN_FOCUS);
- stop_button.unset_flags (GTK_CAN_FOCUS);
- play_selection_button.unset_flags (GTK_CAN_FOCUS);
- rec_button.unset_flags (GTK_CAN_FOCUS);
- auto_loop_button.unset_flags (GTK_CAN_FOCUS);
- auto_return_button.unset_flags (GTK_CAN_FOCUS);
- auto_play_button.unset_flags (GTK_CAN_FOCUS);
- auto_input_button.unset_flags (GTK_CAN_FOCUS);
- punch_out_button.unset_flags (GTK_CAN_FOCUS);
- punch_in_button.unset_flags (GTK_CAN_FOCUS);
- click_button.unset_flags (GTK_CAN_FOCUS);
- follow_button.unset_flags (GTK_CAN_FOCUS);
+ goto_start_button.unset_flags (Gtk::CAN_FOCUS);
+ goto_end_button.unset_flags (Gtk::CAN_FOCUS);
+ roll_button.unset_flags (Gtk::CAN_FOCUS);
+ stop_button.unset_flags (Gtk::CAN_FOCUS);
+ play_selection_button.unset_flags (Gtk::CAN_FOCUS);
+ rec_button.unset_flags (Gtk::CAN_FOCUS);
+ auto_loop_button.unset_flags (Gtk::CAN_FOCUS);
+ auto_return_button.unset_flags (Gtk::CAN_FOCUS);
+ auto_play_button.unset_flags (Gtk::CAN_FOCUS);
+ auto_input_button.unset_flags (Gtk::CAN_FOCUS);
+ punch_out_button.unset_flags (Gtk::CAN_FOCUS);
+ punch_in_button.unset_flags (Gtk::CAN_FOCUS);
+ click_button.unset_flags (Gtk::CAN_FOCUS);
+ follow_button.unset_flags (Gtk::CAN_FOCUS);
goto_start_button.set_events (goto_start_button.get_events() & ~(GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK));
goto_end_button.set_events (goto_end_button.get_events() & ~(GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK));
punch_in_button.set_events (punch_in_button.get_events() & ~(GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK));
punch_out_button.set_events (punch_out_button.get_events() & ~(GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK));
- goto_start_button.clicked.connect (slot (*this,&ARDOUR_UI::transport_goto_start));
- goto_end_button.clicked.connect (slot (*this,&ARDOUR_UI::transport_goto_end));
+ goto_start_button.signal_clicked().connect (slot (*this,&ARDOUR_UI::transport_goto_start));
+ goto_end_button.signal_clicked().connect (slot (*this,&ARDOUR_UI::transport_goto_end));
roll_button.button_release_event.connect (slot (*this,&ARDOUR_UI::mouse_transport_roll));
play_selection_button.button_release_event.connect (slot (*this,&ARDOUR_UI::mouse_transport_play_selection));
punch_in_button.toggled.connect (slot (*this,&ARDOUR_UI::toggle_punch_in));
punch_out_button.toggled.connect (slot (*this,&ARDOUR_UI::toggle_punch_out));
- preroll_button.unset_flags (GTK_CAN_FOCUS);
+ preroll_button.unset_flags (Gtk::CAN_FOCUS);
preroll_button.set_events (preroll_button.get_events() & ~(GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK));
preroll_button.set_name ("TransportButton");
- postroll_button.unset_flags (GTK_CAN_FOCUS);
+ postroll_button.unset_flags (Gtk::CAN_FOCUS);
postroll_button.set_events (postroll_button.get_events() & ~(GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK));
postroll_button.set_name ("TransportButton");
Gtk::VBox* svbox = manage (new VBox);
Gtk::HBox* shbox = manage (new HBox);
- sframe->set_shadow_type (GTK_SHADOW_IN);
+ sframe->set_shadow_type (Gtk::SHADOW_IN);
sframe->add (shuttle_box);
shuttle_box.set_name (X_("ShuttleControl"));
speed_display_box.add (speed_display_label);
- set_usize_to_display_given_text (speed_display_box, _("stopped"), 2, 2);
+ set_size_request_to_display_given_text (speed_display_box, _("stopped"), 2, 2);
speed_display_box.set_name (X_("ShuttleDisplay"));
shuttle_units_button.set_name (X_("ShuttleButton"));
- shuttle_units_button.clicked.connect (slot (*this, &ARDOUR_UI::shuttle_unit_clicked));
+ shuttle_units_button.signal_clicked().connect (slot (*this, &ARDOUR_UI::shuttle_unit_clicked));
shuttle_style_button.set_name (X_("ShuttleButton"));
- shuttle_style_button.clicked.connect (slot (*this, &ARDOUR_UI::shuttle_style_clicked));
+ shuttle_style_button.signal_clicked().connect (slot (*this, &ARDOUR_UI::shuttle_style_clicked));
Gtk::Frame* sdframe = manage (new Frame);
- sdframe->set_shadow_type (GTK_SHADOW_IN);
+ sdframe->set_shadow_type (Gtk::SHADOW_IN);
sdframe->add (speed_display_box);
shbox->pack_start (*sdframe, false, false);
void
ARDOUR_UI::auditioning_changed (bool onoff)
{
- Gtkmmext::UI::instance()->call_slot(bind (slot (*this, &ARDOUR_UI::_auditioning_changed), onoff));
+ Gtkmm2ext::UI::instance()->call_slot(bind (slot (*this, &ARDOUR_UI::_auditioning_changed), onoff));
}
void
if (onoff) {
solo_alert_button.set_state (GTK_STATE_ACTIVE);
} else {
- solo_alert_button.set_state (GTK_STATE_NORMAL);
+ solo_alert_button.set_state (Gtk::STATE_NORMAL);
}
} else {
solo_alert_button.set_active (false);
- solo_alert_button.set_state (GTK_STATE_NORMAL);
+ solo_alert_button.set_state (Gtk::STATE_NORMAL);
}
}
if (onoff) {
auditioning_alert_button.set_state (GTK_STATE_ACTIVE);
} else {
- auditioning_alert_button.set_state (GTK_STATE_NORMAL);
+ auditioning_alert_button.set_state (Gtk::STATE_NORMAL);
}
} else {
auditioning_alert_button.set_active (false);
- auditioning_alert_button.set_state (GTK_STATE_NORMAL);
+ auditioning_alert_button.set_state (Gtk::STATE_NORMAL);
}
}
#include "route_params_ui.h"
#include "i18n.h"
-using namespace SigC;
+using namespace sigc;
namespace ARDOUR {
using namespace ARDOUR;
using namespace Gtk;
-using namespace Gtkmmext;
+using namespace Gtkmm2ext;
void
ARDOUR_UI::connect_to_session (Session *s)
using namespace ARDOUR;
using namespace Gtk;
-using namespace Gtkmmext;
+using namespace Gtkmm2ext;
int
ARDOUR_UI::create_editor ()
#include <cstdio> // for sprintf
#include <cmath>
-#include <gtkmmext/utils.h>
+#include <gtkmm2ext/utils.h>
#include <ardour/ardour.h>
#include <ardour/session.h>
#include "i18n.h"
using namespace ARDOUR;
-using namespace SigC;
+using namespace sigc;
using namespace Gtk;
const uint32_t AudioClock::field_length[(int) AudioClock::AudioFrames+1] = {
b1.set_name (name);
b2.set_name (name);
- clock_frame.set_shadow_type (GTK_SHADOW_IN);
+ clock_frame.set_shadow_type (Gtk::SHADOW_IN);
clock_frame.set_name ("BaseFrame");
clock_frame.add (clock_base);
stays disabled.
*/
- clock_base.add_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
+ clock_base.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
clock_base.button_release_event.connect (bind (slot (*this, &AudioClock::field_button_release_event), SMPTE_Hours));
if (editable) {
void
AudioClock::setup_events ()
{
- clock_base.set_flags (GTK_CAN_FOCUS);
-
- hours_ebox.add_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK|GDK_FOCUS_CHANGE_MASK|GDK_POINTER_MOTION_MASK);
- minutes_ebox.add_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK|GDK_FOCUS_CHANGE_MASK|GDK_POINTER_MOTION_MASK);
- seconds_ebox.add_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK|GDK_FOCUS_CHANGE_MASK|GDK_POINTER_MOTION_MASK);
- frames_ebox.add_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK|GDK_FOCUS_CHANGE_MASK|GDK_POINTER_MOTION_MASK);
- bars_ebox.add_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK|GDK_FOCUS_CHANGE_MASK|GDK_POINTER_MOTION_MASK);
- beats_ebox.add_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK|GDK_FOCUS_CHANGE_MASK|GDK_POINTER_MOTION_MASK);
- ticks_ebox.add_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK|GDK_FOCUS_CHANGE_MASK|GDK_POINTER_MOTION_MASK);
- ms_hours_ebox.add_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK|GDK_FOCUS_CHANGE_MASK|GDK_POINTER_MOTION_MASK);
- ms_minutes_ebox.add_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK|GDK_FOCUS_CHANGE_MASK|GDK_POINTER_MOTION_MASK);
- ms_seconds_ebox.add_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK|GDK_FOCUS_CHANGE_MASK|GDK_POINTER_MOTION_MASK);
- audio_frames_ebox.add_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK|GDK_FOCUS_CHANGE_MASK|GDK_POINTER_MOTION_MASK);
-
- hours_ebox.set_flags (GTK_CAN_FOCUS);
- minutes_ebox.set_flags (GTK_CAN_FOCUS);
- seconds_ebox.set_flags (GTK_CAN_FOCUS);
- frames_ebox.set_flags (GTK_CAN_FOCUS);
- audio_frames_ebox.set_flags (GTK_CAN_FOCUS);
- bars_ebox.set_flags (GTK_CAN_FOCUS);
- beats_ebox.set_flags (GTK_CAN_FOCUS);
- ticks_ebox.set_flags (GTK_CAN_FOCUS);
- ms_hours_ebox.set_flags (GTK_CAN_FOCUS);
- ms_minutes_ebox.set_flags (GTK_CAN_FOCUS);
- ms_seconds_ebox.set_flags (GTK_CAN_FOCUS);
+ clock_base.set_flags (Gtk::CAN_FOCUS);
+
+ hours_ebox.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::FOCUS_CHANGE_MASK|Gdk::POINTER_MOTION_MASK);
+ minutes_ebox.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::FOCUS_CHANGE_MASK|Gdk::POINTER_MOTION_MASK);
+ seconds_ebox.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::FOCUS_CHANGE_MASK|Gdk::POINTER_MOTION_MASK);
+ frames_ebox.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::FOCUS_CHANGE_MASK|Gdk::POINTER_MOTION_MASK);
+ bars_ebox.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::FOCUS_CHANGE_MASK|Gdk::POINTER_MOTION_MASK);
+ beats_ebox.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::FOCUS_CHANGE_MASK|Gdk::POINTER_MOTION_MASK);
+ ticks_ebox.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::FOCUS_CHANGE_MASK|Gdk::POINTER_MOTION_MASK);
+ ms_hours_ebox.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::FOCUS_CHANGE_MASK|Gdk::POINTER_MOTION_MASK);
+ ms_minutes_ebox.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::FOCUS_CHANGE_MASK|Gdk::POINTER_MOTION_MASK);
+ ms_seconds_ebox.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::FOCUS_CHANGE_MASK|Gdk::POINTER_MOTION_MASK);
+ audio_frames_ebox.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::FOCUS_CHANGE_MASK|Gdk::POINTER_MOTION_MASK);
+
+ hours_ebox.set_flags (Gtk::CAN_FOCUS);
+ minutes_ebox.set_flags (Gtk::CAN_FOCUS);
+ seconds_ebox.set_flags (Gtk::CAN_FOCUS);
+ frames_ebox.set_flags (Gtk::CAN_FOCUS);
+ audio_frames_ebox.set_flags (Gtk::CAN_FOCUS);
+ bars_ebox.set_flags (Gtk::CAN_FOCUS);
+ beats_ebox.set_flags (Gtk::CAN_FOCUS);
+ ticks_ebox.set_flags (Gtk::CAN_FOCUS);
+ ms_hours_ebox.set_flags (Gtk::CAN_FOCUS);
+ ms_minutes_ebox.set_flags (Gtk::CAN_FOCUS);
+ ms_seconds_ebox.set_flags (Gtk::CAN_FOCUS);
hours_ebox.motion_notify_event.connect (bind (slot (*this, &AudioClock::field_motion_notify_event), SMPTE_Hours));
minutes_ebox.motion_notify_event.connect (bind (slot (*this, &AudioClock::field_motion_notify_event), SMPTE_Minutes));
ms_minutes_ebox.key_release_event.connect (bind (slot (*this, &AudioClock::field_key_release_event), MS_Minutes));
ms_seconds_ebox.key_release_event.connect (bind (slot (*this, &AudioClock::field_key_release_event), MS_Seconds));
- hours_ebox.focus_in_event.connect (bind (slot (*this, &AudioClock::field_focus_in_event), SMPTE_Hours));
- minutes_ebox.focus_in_event.connect (bind (slot (*this, &AudioClock::field_focus_in_event), SMPTE_Minutes));
- seconds_ebox.focus_in_event.connect (bind (slot (*this, &AudioClock::field_focus_in_event), SMPTE_Seconds));
- frames_ebox.focus_in_event.connect (bind (slot (*this, &AudioClock::field_focus_in_event), SMPTE_Frames));
- audio_frames_ebox.focus_in_event.connect (bind (slot (*this, &AudioClock::field_focus_in_event), AudioFrames));
- bars_ebox.focus_in_event.connect (bind (slot (*this, &AudioClock::field_focus_in_event), Bars));
- beats_ebox.focus_in_event.connect (bind (slot (*this, &AudioClock::field_focus_in_event), Beats));
- ticks_ebox.focus_in_event.connect (bind (slot (*this, &AudioClock::field_focus_in_event), Ticks));
- ms_hours_ebox.focus_in_event.connect (bind (slot (*this, &AudioClock::field_focus_in_event), MS_Hours));
- ms_minutes_ebox.focus_in_event.connect (bind (slot (*this, &AudioClock::field_focus_in_event), MS_Minutes));
- ms_seconds_ebox.focus_in_event.connect (bind (slot (*this, &AudioClock::field_focus_in_event), MS_Seconds));
-
- hours_ebox.focus_out_event.connect (bind (slot (*this, &AudioClock::field_focus_out_event), SMPTE_Hours));
- minutes_ebox.focus_out_event.connect (bind (slot (*this, &AudioClock::field_focus_out_event), SMPTE_Minutes));
- seconds_ebox.focus_out_event.connect (bind (slot (*this, &AudioClock::field_focus_out_event), SMPTE_Seconds));
- frames_ebox.focus_out_event.connect (bind (slot (*this, &AudioClock::field_focus_out_event), SMPTE_Frames));
- audio_frames_ebox.focus_out_event.connect (bind (slot (*this, &AudioClock::field_focus_out_event), AudioFrames));
- bars_ebox.focus_out_event.connect (bind (slot (*this, &AudioClock::field_focus_out_event), Bars));
- beats_ebox.focus_out_event.connect (bind (slot (*this, &AudioClock::field_focus_out_event), Beats));
- ticks_ebox.focus_out_event.connect (bind (slot (*this, &AudioClock::field_focus_out_event), Ticks));
- ms_hours_ebox.focus_out_event.connect (bind (slot (*this, &AudioClock::field_focus_out_event), MS_Hours));
- ms_minutes_ebox.focus_out_event.connect (bind (slot (*this, &AudioClock::field_focus_out_event), MS_Minutes));
- ms_seconds_ebox.focus_out_event.connect (bind (slot (*this, &AudioClock::field_focus_out_event), MS_Seconds));
-
- Gtkmmext::set_usize_to_display_given_text (hours_label, "-88", 0, 2);
- Gtkmmext::set_usize_to_display_given_text (minutes_label, "88", 0, 2);
- Gtkmmext::set_usize_to_display_given_text (seconds_label, "88", 0, 2);
- Gtkmmext::set_usize_to_display_given_text (frames_label, "88", 0, 2);
-
- Gtkmmext::set_usize_to_display_given_text (bars_label, "-888", 0, 2);
- Gtkmmext::set_usize_to_display_given_text (beats_label, "88", 0, 2);
- Gtkmmext::set_usize_to_display_given_text (ticks_label, "8888", 0, 2);
-
- Gtkmmext::set_usize_to_display_given_text (audio_frames_label, "4294967296", 0, 2);
+ hours_ebox.signal_focus_in_event().connect (bind (slot (*this, &AudioClock::field_focus_in_event), SMPTE_Hours));
+ minutes_ebox.signal_focus_in_event().connect (bind (slot (*this, &AudioClock::field_focus_in_event), SMPTE_Minutes));
+ seconds_ebox.signal_focus_in_event().connect (bind (slot (*this, &AudioClock::field_focus_in_event), SMPTE_Seconds));
+ frames_ebox.signal_focus_in_event().connect (bind (slot (*this, &AudioClock::field_focus_in_event), SMPTE_Frames));
+ audio_frames_ebox.signal_focus_in_event().connect (bind (slot (*this, &AudioClock::field_focus_in_event), AudioFrames));
+ bars_ebox.signal_focus_in_event().connect (bind (slot (*this, &AudioClock::field_focus_in_event), Bars));
+ beats_ebox.signal_focus_in_event().connect (bind (slot (*this, &AudioClock::field_focus_in_event), Beats));
+ ticks_ebox.signal_focus_in_event().connect (bind (slot (*this, &AudioClock::field_focus_in_event), Ticks));
+ ms_hours_ebox.signal_focus_in_event().connect (bind (slot (*this, &AudioClock::field_focus_in_event), MS_Hours));
+ ms_minutes_ebox.signal_focus_in_event().connect (bind (slot (*this, &AudioClock::field_focus_in_event), MS_Minutes));
+ ms_seconds_ebox.signal_focus_in_event().connect (bind (slot (*this, &AudioClock::field_focus_in_event), MS_Seconds));
+
+ hours_ebox.signal_focus_out_event().connect (bind (slot (*this, &AudioClock::field_focus_out_event), SMPTE_Hours));
+ minutes_ebox.signal_focus_out_event().connect (bind (slot (*this, &AudioClock::field_focus_out_event), SMPTE_Minutes));
+ seconds_ebox.signal_focus_out_event().connect (bind (slot (*this, &AudioClock::field_focus_out_event), SMPTE_Seconds));
+ frames_ebox.signal_focus_out_event().connect (bind (slot (*this, &AudioClock::field_focus_out_event), SMPTE_Frames));
+ audio_frames_ebox.signal_focus_out_event().connect (bind (slot (*this, &AudioClock::field_focus_out_event), AudioFrames));
+ bars_ebox.signal_focus_out_event().connect (bind (slot (*this, &AudioClock::field_focus_out_event), Bars));
+ beats_ebox.signal_focus_out_event().connect (bind (slot (*this, &AudioClock::field_focus_out_event), Beats));
+ ticks_ebox.signal_focus_out_event().connect (bind (slot (*this, &AudioClock::field_focus_out_event), Ticks));
+ ms_hours_ebox.signal_focus_out_event().connect (bind (slot (*this, &AudioClock::field_focus_out_event), MS_Hours));
+ ms_minutes_ebox.signal_focus_out_event().connect (bind (slot (*this, &AudioClock::field_focus_out_event), MS_Minutes));
+ ms_seconds_ebox.signal_focus_out_event().connect (bind (slot (*this, &AudioClock::field_focus_out_event), MS_Seconds));
+
+ Gtkmm2ext::set_size_request_to_display_given_text (hours_label, "-88", 0, 2);
+ Gtkmm2ext::set_size_request_to_display_given_text (minutes_label, "88", 0, 2);
+ Gtkmm2ext::set_size_request_to_display_given_text (seconds_label, "88", 0, 2);
+ Gtkmm2ext::set_size_request_to_display_given_text (frames_label, "88", 0, 2);
+
+ Gtkmm2ext::set_size_request_to_display_given_text (bars_label, "-888", 0, 2);
+ Gtkmm2ext::set_size_request_to_display_given_text (beats_label, "88", 0, 2);
+ Gtkmm2ext::set_size_request_to_display_given_text (ticks_label, "8888", 0, 2);
+
+ Gtkmm2ext::set_size_request_to_display_given_text (audio_frames_label, "4294967296", 0, 2);
}
void
switch (field) {
case SMPTE_Hours:
- hours_ebox.set_flags (GTK_HAS_FOCUS);
+ hours_ebox.set_flags (Gtk::HAS_FOCUS);
hours_ebox.set_state (GTK_STATE_ACTIVE);
break;
case SMPTE_Minutes:
- minutes_ebox.set_flags (GTK_HAS_FOCUS);
+ minutes_ebox.set_flags (Gtk::HAS_FOCUS);
minutes_ebox.set_state (GTK_STATE_ACTIVE);
break;
case SMPTE_Seconds:
- seconds_ebox.set_flags (GTK_HAS_FOCUS);
+ seconds_ebox.set_flags (Gtk::HAS_FOCUS);
seconds_ebox.set_state (GTK_STATE_ACTIVE);
break;
case SMPTE_Frames:
- frames_ebox.set_flags (GTK_HAS_FOCUS);
+ frames_ebox.set_flags (Gtk::HAS_FOCUS);
frames_ebox.set_state (GTK_STATE_ACTIVE);
break;
case AudioFrames:
- audio_frames_ebox.set_flags (GTK_HAS_FOCUS);
+ audio_frames_ebox.set_flags (Gtk::HAS_FOCUS);
audio_frames_ebox.set_state (GTK_STATE_ACTIVE);
break;
case MS_Hours:
- ms_hours_ebox.set_flags (GTK_HAS_FOCUS);
+ ms_hours_ebox.set_flags (Gtk::HAS_FOCUS);
ms_hours_ebox.set_state (GTK_STATE_ACTIVE);
break;
case MS_Minutes:
- ms_minutes_ebox.set_flags (GTK_HAS_FOCUS);
+ ms_minutes_ebox.set_flags (Gtk::HAS_FOCUS);
ms_minutes_ebox.set_state (GTK_STATE_ACTIVE);
break;
case MS_Seconds:
- ms_seconds_ebox.set_flags (GTK_HAS_FOCUS);
+ ms_seconds_ebox.set_flags (Gtk::HAS_FOCUS);
ms_seconds_ebox.set_state (GTK_STATE_ACTIVE);
break;
case Bars:
- bars_ebox.set_flags (GTK_HAS_FOCUS);
+ bars_ebox.set_flags (Gtk::HAS_FOCUS);
bars_ebox.set_state (GTK_STATE_ACTIVE);
break;
case Beats:
- beats_ebox.set_flags (GTK_HAS_FOCUS);
+ beats_ebox.set_flags (Gtk::HAS_FOCUS);
beats_ebox.set_state (GTK_STATE_ACTIVE);
break;
case Ticks:
- ticks_ebox.set_flags (GTK_HAS_FOCUS);
+ ticks_ebox.set_flags (Gtk::HAS_FOCUS);
ticks_ebox.set_state (GTK_STATE_ACTIVE);
break;
}
switch (field) {
case SMPTE_Hours:
- hours_ebox.unset_flags (GTK_HAS_FOCUS);
- hours_ebox.set_state (GTK_STATE_NORMAL);
+ hours_ebox.unset_flags (Gtk::HAS_FOCUS);
+ hours_ebox.set_state (Gtk::STATE_NORMAL);
break;
case SMPTE_Minutes:
- minutes_ebox.unset_flags (GTK_HAS_FOCUS);
- minutes_ebox.set_state (GTK_STATE_NORMAL);
+ minutes_ebox.unset_flags (Gtk::HAS_FOCUS);
+ minutes_ebox.set_state (Gtk::STATE_NORMAL);
break;
case SMPTE_Seconds:
- seconds_ebox.unset_flags (GTK_HAS_FOCUS);
- seconds_ebox.set_state (GTK_STATE_NORMAL);
+ seconds_ebox.unset_flags (Gtk::HAS_FOCUS);
+ seconds_ebox.set_state (Gtk::STATE_NORMAL);
break;
case SMPTE_Frames:
- frames_ebox.unset_flags (GTK_HAS_FOCUS);
- frames_ebox.set_state (GTK_STATE_NORMAL);
+ frames_ebox.unset_flags (Gtk::HAS_FOCUS);
+ frames_ebox.set_state (Gtk::STATE_NORMAL);
break;
case AudioFrames:
- audio_frames_ebox.unset_flags (GTK_HAS_FOCUS);
- audio_frames_ebox.set_state (GTK_STATE_NORMAL);
+ audio_frames_ebox.unset_flags (Gtk::HAS_FOCUS);
+ audio_frames_ebox.set_state (Gtk::STATE_NORMAL);
break;
case MS_Hours:
- ms_hours_ebox.unset_flags (GTK_HAS_FOCUS);
- ms_hours_ebox.set_state (GTK_STATE_NORMAL);
+ ms_hours_ebox.unset_flags (Gtk::HAS_FOCUS);
+ ms_hours_ebox.set_state (Gtk::STATE_NORMAL);
break;
case MS_Minutes:
- ms_minutes_ebox.unset_flags (GTK_HAS_FOCUS);
- ms_minutes_ebox.set_state (GTK_STATE_NORMAL);
+ ms_minutes_ebox.unset_flags (Gtk::HAS_FOCUS);
+ ms_minutes_ebox.set_state (Gtk::STATE_NORMAL);
break;
case MS_Seconds:
- ms_seconds_ebox.unset_flags (GTK_HAS_FOCUS);
- ms_seconds_ebox.set_state (GTK_STATE_NORMAL);
+ ms_seconds_ebox.unset_flags (Gtk::HAS_FOCUS);
+ ms_seconds_ebox.set_state (Gtk::STATE_NORMAL);
break;
case Bars:
- bars_ebox.unset_flags (GTK_HAS_FOCUS);
- bars_ebox.set_state (GTK_STATE_NORMAL);
+ bars_ebox.unset_flags (Gtk::HAS_FOCUS);
+ bars_ebox.set_state (Gtk::STATE_NORMAL);
break;
case Beats:
- beats_ebox.unset_flags (GTK_HAS_FOCUS);
- beats_ebox.set_state (GTK_STATE_NORMAL);
+ beats_ebox.unset_flags (Gtk::HAS_FOCUS);
+ beats_ebox.set_state (Gtk::STATE_NORMAL);
break;
case Ticks:
- ticks_ebox.unset_flags (GTK_HAS_FOCUS);
- ticks_ebox.set_state (GTK_STATE_NORMAL);
+ ticks_ebox.unset_flags (Gtk::HAS_FOCUS);
+ ticks_ebox.set_state (Gtk::STATE_NORMAL);
break;
}
/* make absolutely sure that the pointer is grabbed */
gdk_pointer_grab(ev->window,FALSE ,
- GdkEventMask( GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK |GDK_BUTTON_RELEASE_MASK),
+ GdkEventMask( Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_PRESS_MASK |Gdk::BUTTON_RELEASE_MASK),
NULL,NULL,ev->time);
dragging = true;
drag_accum = 0;
#ifndef __audio_clock_h__
#define __audio_clock_h__
-#include <gtk--.h>
+#include <gtkmm.h>
#include <ardour/ardour.h>
namespace ARDOUR {
jack_nframes_t current_duration (jack_nframes_t position = 0) const;
void set_session (ARDOUR::Session *s);
- SigC::Signal0<void> ValueChanged;
+ sigc::signal<void> ValueChanged;
private:
ARDOUR::Session *session;
#include <pbd/error.h>
#include <pbd/stl_delete.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/selector.h>
-#include <gtkmmext/gtk_ui.h>
-#include <gtkmmext/stop_signal.h>
-#include <gtkmmext/bindable_button.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/selector.h>
+#include <gtkmm2ext/gtk_ui.h>
+#include <gtkmm2ext/stop_signal.h>
+#include <gtkmm2ext/bindable_button.h>
#include <ardour/session.h>
#include <ardour/session_playlist.h>
#include "i18n.h"
using namespace ARDOUR;
-using namespace SigC;
+using namespace sigc;
using namespace LADSPA;
using namespace Gtk;
using namespace Editing;
mute_button->button_release_event.connect (slot (*this, &RouteUI::mute_release));
rec_enable_button->button_press_event.connect (slot (*this, &RouteUI::rec_enable_press));
edit_group_button.button_release_event.connect (slot (*this, &AudioTimeAxisView::edit_click));
- playlist_button.clicked.connect (slot (*this, &AudioTimeAxisView::playlist_click));
- automation_button.clicked.connect (slot (*this, &AudioTimeAxisView::automation_click));
+ playlist_button.signal_clicked().connect (slot (*this, &AudioTimeAxisView::playlist_click));
+ automation_button.signal_clicked().connect (slot (*this, &AudioTimeAxisView::automation_click));
size_button.button_release_event.connect (slot (*this, &AudioTimeAxisView::size_click));
- visual_button.clicked.connect (slot (*this, &AudioTimeAxisView::visual_click));
- hide_button.clicked.connect (slot (*this, &AudioTimeAxisView::hide_click));
+ visual_button.signal_clicked().connect (slot (*this, &AudioTimeAxisView::visual_click));
+ hide_button.signal_clicked().connect (slot (*this, &AudioTimeAxisView::hide_click));
name_entry.activate.connect (slot (*this, &AudioTimeAxisView::name_entry_activated));
- name_entry.focus_out_event.connect (slot (*this, &AudioTimeAxisView::name_entry_focus_out_handler));
+ name_entry.signal_focus_out_event().connect (slot (*this, &AudioTimeAxisView::name_entry_focus_out_handler));
name_entry.button_press_event.connect (slot (*this, &AudioTimeAxisView::name_entry_button_press_handler));
name_entry.button_release_event.connect (slot (*this, &AudioTimeAxisView::name_entry_button_release_handler));
name_entry.key_release_event.connect (slot (*this, &AudioTimeAxisView::name_entry_key_release_handler));
if (is_audio_track()) {
- controls_table.attach (*rec_enable_button, 6, 7, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
+ controls_table.attach (*rec_enable_button, 6, 7, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
}
- controls_table.attach (*mute_button, 7, 8, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
- controls_table.attach (*solo_button, 8, 9, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_FILL|GTK_EXPAND, 0, 0);
+ controls_table.attach (*mute_button, 7, 8, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
+ controls_table.attach (*solo_button, 8, 9, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|GTK_FILL|Gtk::EXPAND, 0, 0);
- controls_table.attach (edit_group_button, 7, 8, 1, 2, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
+ controls_table.attach (edit_group_button, 7, 8, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
ARDOUR_UI::instance()->tooltips().set_tip(*rec_enable_button, _("Record"));
ARDOUR_UI::instance()->tooltips().set_tip(*solo_button,_("Solo"));
label_view ();
- controls_table.attach (hide_button, 0, 1, 1, 2, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
- controls_table.attach (visual_button, 1, 2, 1, 2, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
- controls_table.attach (size_button, 2, 3, 1, 2, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
- controls_table.attach (automation_button, 3, 4, 1, 2, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (hide_button, 0, 1, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
+ controls_table.attach (visual_button, 1, 2, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
+ controls_table.attach (size_button, 2, 3, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
+ controls_table.attach (automation_button, 3, 4, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
if (is_audio_track()) {
- controls_table.attach (playlist_button, 6, 7, 1, 2, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (playlist_button, 6, 7, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
}
/* remove focus from the buttons */
- automation_button.unset_flags (GTK_CAN_FOCUS);
- solo_button->unset_flags (GTK_CAN_FOCUS);
- mute_button->unset_flags (GTK_CAN_FOCUS);
- edit_group_button.unset_flags (GTK_CAN_FOCUS);
- size_button.unset_flags (GTK_CAN_FOCUS);
- playlist_button.unset_flags (GTK_CAN_FOCUS);
- hide_button.unset_flags (GTK_CAN_FOCUS);
- visual_button.unset_flags (GTK_CAN_FOCUS);
+ automation_button.unset_flags (Gtk::CAN_FOCUS);
+ solo_button->unset_flags (Gtk::CAN_FOCUS);
+ mute_button->unset_flags (Gtk::CAN_FOCUS);
+ edit_group_button.unset_flags (Gtk::CAN_FOCUS);
+ size_button.unset_flags (Gtk::CAN_FOCUS);
+ playlist_button.unset_flags (Gtk::CAN_FOCUS);
+ hide_button.unset_flags (Gtk::CAN_FOCUS);
+ visual_button.unset_flags (Gtk::CAN_FOCUS);
/* map current state of the route */
Main::run ();
- if (prompter.status == Gtkmmext::Prompter::entered) {
+ if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result (name);
pl->set_name (name);
Main::run ();
- if (prompter.status == Gtkmmext::Prompter::entered) {
+ if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result (name);
Main::run ();
- if (prompter.status == Gtkmmext::Prompter::entered) {
+ if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result (name);
void
AudioTimeAxisView::speed_changed ()
{
- Gtkmmext::UI::instance()->call_slot (slot (*this, &AudioTimeAxisView::reset_samples_per_unit));
+ Gtkmm2ext::UI::instance()->call_slot (slot (*this, &AudioTimeAxisView::reset_samples_per_unit));
}
void
AudioTimeAxisView::diskstream_changed (void *src)
{
- Gtkmmext::UI::instance()->call_slot (slot (*this, &AudioTimeAxisView::update_diskstream_display));
+ Gtkmm2ext::UI::instance()->call_slot (slot (*this, &AudioTimeAxisView::update_diskstream_display));
}
void
#ifndef __ardour_trackview_h__
#define __ardour_trackview_h__
-#include <gtk--.h>
+#include <gtkmm.h>
#include <gtk-canvas.h>
-#include <gtkmmext/selector.h>
-#include <gtkmmext/popup_selector.h>
+#include <gtkmm2ext/selector.h>
+#include <gtkmm2ext/popup_selector.h>
#include <list>
#include <ardour/types.h>
void add_to_redirect_display (ARDOUR::Redirect *);
void redirects_changed (void *);
- SigC::Connection modified_connection;
- SigC::Connection state_changed_connection;
+ sigc::connection modified_connection;
+ sigc::connection state_changed_connection;
void take_name_changed (void *);
void route_name_changed (void *);
$Id$
*/
-#include <sigc++/signal_system.h>
+#include <sigc++/signal.h>
#include <ardour/curve.h>
#include <pbd/fastlog.h>
#include <ardour/ardour.h>
#include <gtk-canvas.h>
-#include <gtk--.h>
+#include <gtkmm.h>
#include "automation_line.h"
{
if (!update_pending) {
update_pending = true;
- Gtkmmext::UI::instance()->call_slot (slot (*this, &AutomationLine::reset));
+ Gtkmm2ext::UI::instance()->call_slot (slot (*this, &AutomationLine::reset));
}
}
#include <string>
#include <sys/types.h>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <gtk-canvas.h>
-#include <sigc++/signal_system.h>
+#include <sigc++/signal.h>
#include <pbd/undo.h>
ShapeType _shape;
};
-class AutomationLine : public SigC::Object
+class AutomationLine : public sigc::trackable
{
public:
AutomationLine (string name, TimeAxisView&, GtkCanvasItem *, ARDOUR::AutomationList&,
$Id$
*/
-#include <sigc++/signal_system.h>
+#include <sigc++/signal.h>
#include <ardour/curve.h>
#include <ardour/ardour.h>
#include <gtk-canvas.h>
-#include <gtk--.h>
+#include <gtkmm.h>
#include "automation_line.h"
plugname->set_alignment (1.0, 0.5);
name_label.set_name (X_("TrackParameterName"));
controls_table.remove (name_hbox);
- controls_table.attach (*plugname, 1, 6, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (*plugname, 1, 6, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
plugname_packed = true;
- controls_table.attach (name_hbox, 1, 6, 1, 2, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (name_hbox, 1, 6, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
} else {
plugname = 0;
plugname_packed = false;
}
/* add the buttons */
- controls_table.attach (hide_button, 0, 1, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
- controls_table.attach (height_button, 0, 1, 1, 2, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (hide_button, 0, 1, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
+ controls_table.attach (height_button, 0, 1, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
- controls_table.attach (auto_button, 7, 9, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
- controls_table.attach (clear_button, 7, 9, 1, 2, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (auto_button, 7, 9, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
+ controls_table.attach (clear_button, 7, 9, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
controls_table.show_all ();
- height_button.clicked.connect (slot (*this, &AutomationTimeAxisView::height_clicked));
- clear_button.clicked.connect (slot (*this, &AutomationTimeAxisView::clear_clicked));
- hide_button.clicked.connect (slot (*this, &AutomationTimeAxisView::hide_clicked));
- auto_button.clicked.connect (slot (*this, &AutomationTimeAxisView::auto_clicked));
+ height_button.signal_clicked().connect (slot (*this, &AutomationTimeAxisView::height_clicked));
+ clear_button.signal_clicked().connect (slot (*this, &AutomationTimeAxisView::clear_clicked));
+ hide_button.signal_clicked().connect (slot (*this, &AutomationTimeAxisView::hide_clicked));
+ auto_button.signal_clicked().connect (slot (*this, &AutomationTimeAxisView::auto_clicked));
controls_base_selected_name = X_("AutomationTrackControlsBaseSelected");
controls_base_unselected_name = X_("AutomationTrackControlsBase");
controls_table.remove (*plugname);
plugname_packed = false;
}
- controls_table.attach (*plugname, 1, 6, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (*plugname, 1, 6, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
plugname_packed = true;
- controls_table.attach (name_hbox, 1, 6, 1, 2, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (name_hbox, 1, 6, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
} else {
- controls_table.attach (name_hbox, 1, 6, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (name_hbox, 1, 6, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
}
controls_table.show_all ();
name_label.show ();
controls_table.remove (*plugname);
plugname_packed = false;
}
- controls_table.attach (*plugname, 1, 6, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (*plugname, 1, 6, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
plugname_packed = true;
} else {
- controls_table.attach (name_hbox, 1, 6, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (name_hbox, 1, 6, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
}
controls_table.show_all ();
name_label.show ();
controls_table.remove (*plugname);
plugname_packed = false;
}
- controls_table.attach (*plugname, 1, 6, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (*plugname, 1, 6, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
plugname_packed = true;
} else {
- controls_table.attach (name_hbox, 1, 6, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (name_hbox, 1, 6, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
}
controls_table.show_all ();
name_label.show ();
controls_table.remove (*plugname);
plugname_packed = false;
}
- controls_table.attach (*plugname, 1, 6, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (*plugname, 1, 6, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
plugname_packed = true;
- controls_table.attach (name_hbox, 1, 6, 1, 2, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (name_hbox, 1, 6, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
} else {
- controls_table.attach (name_hbox, 1, 6, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (name_hbox, 1, 6, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
}
controls_table.show_all ();
name_label.show ();
plugname_packed = false;
}
}
- controls_table.attach (name_hbox, 1, 6, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (name_hbox, 1, 6, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
controls_table.hide_all ();
name_hbox.show_all ();
controls_table.show ();
plugname_packed = false;
}
}
- controls_table.attach (name_hbox, 1, 6, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (name_hbox, 1, 6, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
controls_table.hide_all ();
name_hbox.show_all ();
controls_table.show ();
bool ignore_state_request;
void automation_state_changed ();
- SigC::Connection automation_connection;
+ sigc::connection automation_connection;
void entered ();
void exited ();
#include <pbd/error.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/selector.h>
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/selector.h>
+#include <gtkmm2ext/gtk_ui.h>
#include <ardour/session.h>
#include <ardour/utils.h>
#include "i18n.h"
using namespace Gtk;
-using namespace Gtkmmext;
+using namespace Gtkmm2ext;
list<GdkColor> AxisView::used_colors;
#define __ardour_gtk_axis_view_h__
#include <list>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <pbd/xml++.h>
#include "prompter.h"
* AxisView defines the abstract base class for time-axis trackviews and routes.
*
*/
-class AxisView : public SigC::Object
+class AxisView : public sigc::trackable
{
public:
/**
}
virtual bool selected() const { return _selected; }
- SigC::Signal0<void> Hiding;
- SigC::Signal0<void> GoingAway;
+ sigc::signal<void> Hiding;
+ sigc::signal<void> GoingAway;
protected:
*/
#include <stdint.h>
-#include <gtkmmext/gtk_ui.h>
-#include <gtkmmext/utils.h>
+#include <gtkmm2ext/gtk_ui.h>
+#include <gtkmm2ext/utils.h>
#include <sigc++/bind.h>
#include "connection_editor.h"
using namespace std;
using namespace ARDOUR;
using namespace Gtk;
-using namespace SigC;
+using namespace sigc;
ConnectionEditor::ConnectionEditor ()
: ArdourDialog ("connection editor"),
rescan_button (_("Rescan"))
{
- add_events (GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK);
+ add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
session = 0;
selected_port = -1;
button_box.set_spacing (15);
button_box.set_border_width (5);
- Gtkmmext::set_usize_to_display_given_text (ok_button, _("OK"), 40, 15);
+ Gtkmm2ext::set_size_request_to_display_given_text (ok_button, _("OK"), 40, 15);
button_box.pack_end (ok_button, false, false);
// button_box.pack_end (cancel_button, false, false);
cancel_button.hide();
button_frame.add (button_box);
- ok_button.clicked.connect (slot (*this, &ConnectionEditor::accept));
- cancel_button.clicked.connect (slot (*this, &ConnectionEditor::cancel));
- cancel_button.clicked.connect (slot (*this, &ConnectionEditor::rescan));
+ ok_button.signal_clicked().connect (slot (*this, &ConnectionEditor::accept));
+ cancel_button.signal_clicked().connect (slot (*this, &ConnectionEditor::cancel));
+ cancel_button.signal_clicked().connect (slot (*this, &ConnectionEditor::rescan));
notebook.set_name ("ConnectionEditorNotebook");
- notebook.set_usize (-1, 125);
+ notebook.set_size_request (-1, 125);
clear_button.set_name ("ConnectionEditorButton");
add_port_button.set_name ("ConnectionEditorButton");
- Gtkmmext::set_usize_to_display_given_text (add_port_button, _("Add Port"), 35, 15);
+ Gtkmm2ext::set_size_request_to_display_given_text (add_port_button, _("Add Port"), 35, 15);
selector_frame.set_name ("ConnectionEditorFrame");
port_frame.set_name ("ConnectionEditorFrame");
selector_button_box.set_spacing (5);
selector_button_box.set_border_width (5);
- Gtkmmext::set_usize_to_display_given_text (rescan_button, _("Rescan"), 35, 15);
+ Gtkmm2ext::set_size_request_to_display_given_text (rescan_button, _("Rescan"), 35, 15);
selector_button_box.pack_start (rescan_button, false, false);
selector_box.set_spacing (5);
right_vbox.set_border_width (5);
right_vbox.pack_start (port_and_selector_box);
- input_connection_display.set_shadow_type (GTK_SHADOW_IN);
+ input_connection_display.set_shadow_type (Gtk::SHADOW_IN);
input_connection_display.set_selection_mode (GTK_SELECTION_SINGLE);
- input_connection_display.set_usize (80, -1);
+ input_connection_display.set_size_request (80, -1);
input_connection_display.set_name ("ConnectionEditorConnectionList");
input_connection_display.select_row.connect (bind (slot (*this, &ConnectionEditor::connection_selected), true));
- output_connection_display.set_shadow_type (GTK_SHADOW_IN);
+ output_connection_display.set_shadow_type (Gtk::SHADOW_IN);
output_connection_display.set_selection_mode (GTK_SELECTION_SINGLE);
- output_connection_display.set_usize (80, -1);
+ output_connection_display.set_size_request (80, -1);
output_connection_display.set_name ("ConnectionEditorConnectionList");
output_connection_display.select_row.connect (bind (slot (*this, &ConnectionEditor::connection_selected), false));
- input_scroller.set_policy (GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
- output_scroller.set_policy (GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+ input_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
+ output_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
input_scroller.add_with_viewport (input_connection_display);
output_scroller.add_with_viewport (output_connection_display);
delete_event.connect (bind (slot (just_hide_it), reinterpret_cast<Window *> (this)));
- clear_button.clicked.connect (slot (*this, &ConnectionEditor::clear));
- add_port_button.clicked.connect (slot (*this, &ConnectionEditor::add_port));
- new_input_connection_button.clicked.connect (bind (slot (*this, &ConnectionEditor::new_connection), true));
- new_output_connection_button.clicked.connect (bind (slot (*this, &ConnectionEditor::new_connection), false));
- delete_connection_button.clicked.connect (slot (*this, &ConnectionEditor::delete_connection));
+ clear_button.signal_clicked().connect (slot (*this, &ConnectionEditor::clear));
+ add_port_button.signal_clicked().connect (slot (*this, &ConnectionEditor::add_port));
+ new_input_connection_button.signal_clicked().connect (bind (slot (*this, &ConnectionEditor::new_connection), true));
+ new_output_connection_button.signal_clicked().connect (bind (slot (*this, &ConnectionEditor::new_connection), false));
+ delete_connection_button.signal_clicked().connect (slot (*this, &ConnectionEditor::delete_connection));
}
ConnectionEditor::~ConnectionEditor()
void
ConnectionEditor::proxy_add_connection_and_select (ARDOUR::Connection *connection)
{
- Gtkmmext::UI::instance()->call_slot (bind (slot (*this, &ConnectionEditor::add_connection_and_select), connection));
+ Gtkmm2ext::UI::instance()->call_slot (bind (slot (*this, &ConnectionEditor::add_connection_and_select), connection));
}
void
ConnectionEditor::proxy_remove_connection (ARDOUR::Connection *connection)
{
- Gtkmmext::UI::instance()->call_slot (bind (slot (*this, &ConnectionEditor::remove_connection), connection));
+ Gtkmm2ext::UI::instance()->call_slot (bind (slot (*this, &ConnectionEditor::remove_connection), connection));
}
void
ScrolledWindow *scroller = manage (new ScrolledWindow);
scroller->add_with_viewport (*client_port_display);
- scroller->set_policy (GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+ scroller->set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
client_box->pack_start (*scroller);
scroller = new ScrolledWindow;
scroller->add_with_viewport (*clist);
- scroller->set_policy (GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+ scroller->set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
port_displays.insert (port_displays.end(), scroller);
port_box.pack_start (*scroller);
clist->set_name ("ConnectionEditorPortList");
clist->click_column.connect (bind (slot (*this, &ConnectionEditor::port_column_click), clist));
clist->set_selection_mode (GTK_SELECTION_SINGLE);
- clist->set_shadow_type (GTK_SHADOW_IN);
+ clist->set_shadow_type (Gtk::SHADOW_IN);
- scroller->set_usize (-1, 75);
+ scroller->set_size_request (-1, 75);
/* now fill the clist with the current connections */
Gtk::Main::run();
- if (prompter.status == Gtkmmext::Prompter::entered) {
+ if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result (name);
#include <slist.h>
#endif
-#include <gtk--/box.h>
-#include <gtk--/window.h>
-#include <gtk--/scrolledwindow.h>
-#include <gtk--/button.h>
-#include <gtk--/frame.h>
-#include <gtk--/notebook.h>
-#include <gtk--/clist.h>
+#include <gtkmm/box.h>
+#include <gtkmm/window.h>
+#include <gtkmm/scrolledwindow.h>
+#include <gtkmm/button.h>
+#include <gtkmm/frame.h>
+#include <gtkmm/notebook.h>
+#include <gtkmm/clist.h>
#include "ardour_dialog.h"
gint connection_click (GdkEventButton *ev, Gtk::CList *clist);
void connection_selected (gint, gint, GdkEvent *, bool);
- SigC::Connection config_connection;
- SigC::Connection connect_connection;
+ sigc::connection config_connection;
+ sigc::connection connect_connection;
void configuration_changed (bool);
void connections_changed (int, bool);
};
#include <sigc++/bind.h>
-#include <gtk--/frame.h>
-#include <gtk--/pixmap.h>
-#include <gtk--/scrolledwindow.h>
+#include <gtkmm/frame.h>
+#include <gtkmm/pixmap.h>
+#include <gtkmm/scrolledwindow.h>
#include <ardour/automation_event.h>
#include <ardour/curve.h>
#include <ardour/audioplaylist.h>
#include <ardour/playlist_templates.h>
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm2ext/gtk_ui.h>
#include "ardour_ui.h"
#include "crossfade_edit.h"
using namespace std;
using namespace ARDOUR;
using namespace Gtk;
-using namespace SigC;
+using namespace sigc;
using namespace Editing;
#include "i18n.h"
set_wmclass ("ardour_automationedit", "Ardour");
set_name ("CrossfadeEditWindow");
set_title (_("ardour: x-fade edit"));
- set_position (GTK_WIN_POS_MOUSE);
+ set_position (Gtk::WIN_POS_MOUSE);
add (vpacker);
- add_events (GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK|GDK_POINTER_MOTION_MASK);
+ add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::POINTER_MOTION_MASK);
select_out_button.set_group (select_in_button.group());
select_out_button.set_mode (false);
canvas = wrap (_canvas);
canvas->size_allocate.connect (slot (*this, &CrossfadeEditor::canvas_allocation));
- canvas->set_usize (425, 200);
+ canvas->set_size_request (425, 200);
toplevel = gtk_canvas_item_new (gtk_canvas_root (GTK_CANVAS(_canvas)),
gtk_canvas_simplerect_get_type(),
select_in_button.set_name (X_("CrossfadeEditCurveButton"));
select_out_button.set_name (X_("CrossfadeEditCurveButton"));
- select_in_button.clicked.connect (bind (slot (this, &CrossfadeEditor::curve_select_clicked), In));
- select_out_button.clicked.connect (bind (slot (this, &CrossfadeEditor::curve_select_clicked), Out));
+ select_in_button.signal_clicked().connect (bind (slot (this, &CrossfadeEditor::curve_select_clicked), In));
+ select_out_button.signal_clicked().connect (bind (slot (this, &CrossfadeEditor::curve_select_clicked), Out));
HBox* acbox = manage (new HBox);
Frame* canvas_frame = manage (new Frame);
canvas_frame->add (*canvas);
- canvas_frame->set_shadow_type (GTK_SHADOW_IN);
+ canvas_frame->set_shadow_type (Gtk::SHADOW_IN);
- fade_in_table.attach (select_in_button, 0, 2, 0, 1, GTK_FILL|GTK_EXPAND);
- fade_out_table.attach (select_out_button, 0, 2, 0, 1, GTK_FILL|GTK_EXPAND);
+ fade_in_table.attach (select_in_button, 0, 2, 0, 1, Gtk::FILL|Gtk::EXPAND);
+ fade_out_table.attach (select_out_button, 0, 2, 0, 1, Gtk::FILL|Gtk::EXPAND);
Pixmap *pxmap;
Button* pbutton;
pbutton = manage (new Button);
pbutton->add (*pxmap);
pbutton->set_name ("CrossfadeEditButton");
- pbutton->clicked.connect (bind (slot (*this, &CrossfadeEditor::apply_preset), *i));
+ pbutton-.signal_clicked().connect (bind (slot (*this, &CrossfadeEditor::apply_preset), *i));
fade_in_table.attach (*pbutton, col, col+1, row, row+1);
fade_in_buttons.push_back (pbutton);
pbutton = manage (new Button);
pbutton->add (*pxmap);
pbutton->set_name ("CrossfadeEditButton");
- pbutton->clicked.connect (bind (slot (*this, &CrossfadeEditor::apply_preset), *i));
+ pbutton-.signal_clicked().connect (bind (slot (*this, &CrossfadeEditor::apply_preset), *i));
fade_out_table.attach (*pbutton, col, col+1, row, row+1);
fade_out_buttons.push_back (pbutton);
audition_right_dry_button.set_name ("CrossfadeEditAuditionButton");
audition_right_button.set_name ("CrossfadeEditAuditionButton");
- clear_button.clicked.connect (slot (*this, &CrossfadeEditor::clear));
- revert_button.clicked.connect (slot (*this, &CrossfadeEditor::reset));
+ clear_button.signal_clicked().connect (slot (*this, &CrossfadeEditor::clear));
+ revert_button.signal_clicked().connect (slot (*this, &CrossfadeEditor::reset));
audition_both_button.toggled.connect (slot (*this, &CrossfadeEditor::audition_toggled));
audition_right_button.toggled.connect (slot (*this, &CrossfadeEditor::audition_right_toggled));
audition_right_dry_button.toggled.connect (slot (*this, &CrossfadeEditor::audition_right_dry_toggled));
/* button to allow hackers to check the actual curve values */
// Button* foobut = manage (new Button ("dump"));
-// foobut->clicked.connect (slot (*this, &CrossfadeEditor::dump));
+// foobut-.signal_clicked().connect (slot (*this, &CrossfadeEditor::dump));
// vpacker.pack_start (*foobut, false, false);
current = In;
#include <list>
-#include <gtk--/box.h>
-#include <gtk--/button.h>
-#include <gtk--/radiobutton.h>
+#include <gtkmm/box.h>
+#include <gtkmm/button.h>
+#include <gtkmm/radiobutton.h>
#include <gtk-canvas.h>
#include <ardour/curve.h>
#include <algorithm>
#include <ardour/region.h>
-#include <gtkmmext/doi.h>
+#include <gtkmm2ext/doi.h>
#include "canvas-simplerect.h"
#include "canvas-curve.h"
#include "regionview.h"
#include "utils.h"
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
using namespace Editing;
-SigC::Signal1<void,CrossfadeView*> CrossfadeView::GoingAway;
+sigc::signal<void,CrossfadeView*> CrossfadeView::GoingAway;
CrossfadeView::CrossfadeView (GtkCanvasGroup *parent,
AudioTimeAxisView &tv,
#define __gtk_ardour_crossfade_view_h__
#include <vector>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <gtk-canvas.h>
-#include <sigc++/signal_system.h>
+#include <sigc++/signal.h>
#include <ardour/crossfade.h>
#include "time_axis_view_item.h"
bool visible() const { return _visible; }
void set_valid (bool yn);
- static SigC::Signal1<void,CrossfadeView*> GoingAway;
+ static sigc::signal<void,CrossfadeView*> GoingAway;
AudioRegionView& upper_regionview () const;
$Id$
*/
-#include <gtk--.h>
+#include <gtkmm.h>
#include <sigc++/bind.h>
#include <pbd/error.h>
#include "keyboard_target.h"
using namespace ARDOUR;
-using namespace Gtkmmext;
+using namespace Gtkmm2ext;
using namespace Gtk;
-using namespace SigC;
+using namespace sigc;
void
ARDOUR_UI::install_keybindings ()
#include <gtk-canvas.h>
#include <pbd/error.h>
-#include <gtkmmext/gtk_ui.h>
-#include <gtkmmext/tearoff.h>
-#include <gtkmmext/utils.h>
+#include <gtkmm2ext/gtk_ui.h>
+#include <gtkmm2ext/tearoff.h>
+#include <gtkmm2ext/utils.h>
#include <ardour/audio_track.h>
#include <ardour/diskstream.h>
/* </CMT Additions> */
using namespace std;
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;
-using namespace Gtkmmext;
+using namespace Gtkmm2ext;
using namespace Editing;
/* XXX this is a hack. it ought to be the maximum value of an jack_nframes_t */
transport_mark_label (_("Loop/Punch Ranges")),
edit_packer (3, 3, false),
- edit_hscroll_left_arrow (GTK_ARROW_LEFT, GTK_SHADOW_OUT),
- edit_hscroll_right_arrow (GTK_ARROW_RIGHT, GTK_SHADOW_OUT),
+ edit_hscroll_left_arrow (Gtk::ARROW_LEFT, Gtk::SHADOW_OUT),
+ edit_hscroll_right_arrow (Gtk::ARROW_RIGHT, Gtk::SHADOW_OUT),
region_list_display (internationalize (region_list_display_titles)),
init_colormap ();
check_pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL,
- gtk_widget_get_colormap (GTK_WIDGET(edit_group_list.gtkobj())),
+ gtk_widget_get_colormap (GTK_WIDGET(edit_group_list.gobj())),
&check_mask, NULL, (gchar **) check_xpm);
empty_pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL,
- gtk_widget_get_colormap (GTK_WIDGET(edit_group_list.gtkobj())),
+ gtk_widget_get_colormap (GTK_WIDGET(edit_group_list.gobj())),
&empty_mask, NULL, (gchar **) empty_xpm);
session = 0;
initialize_canvas ();
track_canvas_scroller.add (*track_canvas);
- track_canvas_scroller.set_policy (GTK_POLICY_NEVER, GTK_POLICY_NEVER);
+ track_canvas_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_NEVER);
track_canvas_scroller.set_name ("TrackCanvasScroller");
track_canvas_scroller.get_vadjustment()->value_changed.connect (slot (*this, &Editor::tie_vertical_scrolling));
edit_hscrollbar.size_allocate.connect (slot (*this, &Editor::hscroll_slider_allocate));
time_canvas_scroller.add (*time_canvas);
- time_canvas_scroller.set_policy (GTK_POLICY_NEVER, GTK_POLICY_NEVER);
+ time_canvas_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_NEVER);
time_canvas_scroller.set_hadjustment (track_canvas_scroller.get_hadjustment());
time_canvas_scroller.set_name ("TimeCanvasScroller");
edit_controls_hbox.pack_start (edit_controls_vbox, true, true);
edit_controls_scroller.add_with_viewport (edit_controls_hbox);
edit_controls_scroller.set_name ("EditControlsBase");
- edit_controls_scroller.set_policy (GTK_POLICY_NEVER, GTK_POLICY_NEVER);
+ edit_controls_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_NEVER);
Viewport* viewport = static_cast<Viewport*> (edit_controls_scroller.get_child());
viewport->set_shadow_type (GTK_SHADOW_NONE);
viewport->set_name ("EditControlsBase");
- viewport->add_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK);
+ viewport->add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK);
viewport->button_release_event.connect (slot (*this, &Editor::edit_controls_button_release));
build_cursors ();
time_canvas_vbox.pack_start (*frames_ruler, false, false);
time_canvas_vbox.pack_start (*bbt_ruler, false, false);
time_canvas_vbox.pack_start (time_canvas_scroller, true, true);
- time_canvas_vbox.set_usize (-1, (int)(timebar_height * visible_timebars));
+ time_canvas_vbox.set_size_request (-1, (int)(timebar_height * visible_timebars));
bbt_label.set_name ("EditorTimeButton");
- bbt_label.set_usize (-1, (int)timebar_height);
+ bbt_label.set_size_request (-1, (int)timebar_height);
bbt_label.set_alignment (1.0, 0.5);
bbt_label.set_padding (5,0);
minsec_label.set_name ("EditorTimeButton");
- minsec_label.set_usize (-1, (int)timebar_height);
+ minsec_label.set_size_request (-1, (int)timebar_height);
minsec_label.set_alignment (1.0, 0.5);
minsec_label.set_padding (5,0);
smpte_label.set_name ("EditorTimeButton");
- smpte_label.set_usize (-1, (int)timebar_height);
+ smpte_label.set_size_request (-1, (int)timebar_height);
smpte_label.set_alignment (1.0, 0.5);
smpte_label.set_padding (5,0);
frame_label.set_name ("EditorTimeButton");
- frame_label.set_usize (-1, (int)timebar_height);
+ frame_label.set_size_request (-1, (int)timebar_height);
frame_label.set_alignment (1.0, 0.5);
frame_label.set_padding (5,0);
tempo_label.set_name ("EditorTimeButton");
- tempo_label.set_usize (-1, (int)timebar_height);
+ tempo_label.set_size_request (-1, (int)timebar_height);
tempo_label.set_alignment (1.0, 0.5);
tempo_label.set_padding (5,0);
meter_label.set_name ("EditorTimeButton");
- meter_label.set_usize (-1, (int)timebar_height);
+ meter_label.set_size_request (-1, (int)timebar_height);
meter_label.set_alignment (1.0, 0.5);
meter_label.set_padding (5,0);
mark_label.set_name ("EditorTimeButton");
- mark_label.set_usize (-1, (int)timebar_height);
+ mark_label.set_size_request (-1, (int)timebar_height);
mark_label.set_alignment (1.0, 0.5);
mark_label.set_padding (5,0);
range_mark_label.set_name ("EditorTimeButton");
- range_mark_label.set_usize (-1, (int)timebar_height);
+ range_mark_label.set_size_request (-1, (int)timebar_height);
range_mark_label.set_alignment (1.0, 0.5);
range_mark_label.set_padding (5,0);
transport_mark_label.set_name ("EditorTimeButton");
- transport_mark_label.set_usize (-1, (int)timebar_height);
+ transport_mark_label.set_size_request (-1, (int)timebar_height);
transport_mark_label.set_alignment (1.0, 0.5);
transport_mark_label.set_padding (5,0);
time_button_event_box.add (time_button_vbox);
- time_button_event_box.set_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
+ time_button_event_box.set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
time_button_event_box.set_name ("TimebarLabelBase");
time_button_event_box.button_release_event.connect (slot (*this, &Editor::ruler_label_button_release));
track_canvas_event_box.add (track_canvas_scroller);
time_canvas_event_box.add (time_canvas_vbox);
- time_canvas_event_box.set_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_POINTER_MOTION_MASK);
+ time_canvas_event_box.set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::POINTER_MOTION_MASK);
edit_packer.set_col_spacings (0);
edit_packer.set_homogeneous (false);
edit_packer.set_name ("EditorWindow");
-// edit_packer.attach (edit_hscroll_left_arrow_event, 0, 1, 0, 1, GTK_FILL, 0, 0, 0);
-// edit_packer.attach (edit_hscroll_slider, 1, 2, 0, 1, GTK_FILL|GTK_EXPAND, 0, 0, 0);
-// edit_packer.attach (edit_hscroll_right_arrow_event, 2, 3, 0, 1, GTK_FILL, 0, 0, 0);
- edit_packer.attach (edit_hscrollbar, 1, 2, 0, 1, GTK_FILL|GTK_EXPAND, 0, 0, 0);
+// edit_packer.attach (edit_hscroll_left_arrow_event, 0, 1, 0, 1, Gtk::FILL, 0, 0, 0);
+// edit_packer.attach (edit_hscroll_slider, 1, 2, 0, 1, Gtk::FILL|Gtk::EXPAND, 0, 0, 0);
+// edit_packer.attach (edit_hscroll_right_arrow_event, 2, 3, 0, 1, Gtk::FILL, 0, 0, 0);
+ edit_packer.attach (edit_hscrollbar, 1, 2, 0, 1, Gtk::FILL|Gtk::EXPAND, 0, 0, 0);
- edit_packer.attach (time_button_event_box, 0, 1, 1, 2, GTK_FILL, 0, 0, 0);
- edit_packer.attach (time_canvas_event_box, 1, 2, 1, 2, GTK_FILL|GTK_EXPAND, 0, 0, 0);
+ edit_packer.attach (time_button_event_box, 0, 1, 1, 2, Gtk::FILL, 0, 0, 0);
+ edit_packer.attach (time_canvas_event_box, 1, 2, 1, 2, Gtk::FILL|Gtk::EXPAND, 0, 0, 0);
- edit_packer.attach (edit_controls_scroller, 0, 1, 2, 3, GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
- edit_packer.attach (track_canvas_event_box, 1, 2, 2, 3, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
- edit_packer.attach (edit_vscrollbar, 2, 3, 2, 3, 0, GTK_FILL|GTK_EXPAND, 0, 0);
+ edit_packer.attach (edit_controls_scroller, 0, 1, 2, 3, Gtk::FILL, Gtk::FILL|Gtk::EXPAND, 0, 0);
+ edit_packer.attach (track_canvas_event_box, 1, 2, 2, 3, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
+ edit_packer.attach (edit_vscrollbar, 2, 3, 2, 3, 0, Gtk::FILL|Gtk::EXPAND, 0, 0);
edit_frame.set_name ("BaseFrame");
- edit_frame.set_shadow_type (GTK_SHADOW_IN);
+ edit_frame.set_shadow_type (Gtk::SHADOW_IN);
edit_frame.add (edit_packer);
zoom_in_button.set_name ("EditorTimeButton");
// ARDOUR_UI::instance()->tooltips().set_tip (zoom_onetoone_button, _("Zoom in 1:1"));
ARDOUR_UI::instance()->tooltips().set_tip (zoom_out_full_button, _("Zoom to session"));
- zoom_in_button.add (*(manage (new Gtk::Pixmap (zoom_in_button_xpm))));
- zoom_out_button.add (*(manage (new Gtk::Pixmap (zoom_out_button_xpm))));
- zoom_out_full_button.add (*(manage (new Gtk::Pixmap (zoom_out_full_button_xpm))));
-// zoom_onetoone_button.add (*(manage (new Gtk::Pixmap (zoom_onetoone_button_xpm))));
+ zoom_in_button.add (*(manage (new Gtk::Image (zoom_in_button_xpm))));
+ zoom_out_button.add (*(manage (new Gtk::Image (zoom_out_button_xpm))));
+ zoom_out_full_button.add (*(manage (new Gtk::Image (zoom_out_full_button_xpm))));
+// zoom_onetoone_button.add (*(manage (new Gtk::Image (zoom_onetoone_button_xpm))));
- zoom_in_button.clicked.connect (bind (slot (*this, &Editor::temporal_zoom_step), false));
- zoom_out_button.clicked.connect (bind (slot (*this, &Editor::temporal_zoom_step), true));
- zoom_out_full_button.clicked.connect (slot (*this, &Editor::temporal_zoom_session));
-// zoom_onetoone_button.clicked.connect (bind (slot (*this, &Editor::temporal_zoom), 1.0));
+ zoom_in_button.signal_clicked().connect (bind (slot (*this, &Editor::temporal_zoom_step), false));
+ zoom_out_button.signal_clicked().connect (bind (slot (*this, &Editor::temporal_zoom_step), true));
+ zoom_out_full_button.signal_clicked().connect (slot (*this, &Editor::temporal_zoom_session));
+// zoom_onetoone_button.signal_clicked().connect (bind (slot (*this, &Editor::temporal_zoom), 1.0));
zoom_indicator_box.pack_start (zoom_out_button, false, false);
zoom_indicator_box.pack_start (zoom_in_button, false, false);
bottom_hbox.set_spacing (3);
route_list.set_name ("TrackListDisplay");
- route_list.set_usize (75,-1);
+ route_list.set_size_request (75,-1);
route_list.column_titles_active();
route_list.set_compare_func (route_list_compare_func);
- route_list.set_shadow_type (GTK_SHADOW_IN);
+ route_list.set_shadow_type (Gtk::SHADOW_IN);
route_list.set_selection_mode (GTK_SELECTION_MULTIPLE);
route_list.set_reorderable (true);
- edit_group_list.set_usize (75, -1);
+ edit_group_list.set_size_request (75, -1);
route_list_scroller.add (route_list);
- route_list_scroller.set_policy (GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+ route_list_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
route_list.select_row.connect (slot (*this, &Editor::route_list_selected));
route_list.unselect_row.connect (slot (*this, &Editor::route_list_unselected));
edit_group_list.column_titles_hide();
edit_group_list.set_name ("MixerGroupList");
- edit_group_list.set_shadow_type (GTK_SHADOW_IN);
+ edit_group_list.set_shadow_type (Gtk::SHADOW_IN);
edit_group_list.set_selection_mode (GTK_SELECTION_MULTIPLE);
edit_group_list.set_reorderable (false);
- edit_group_list.set_usize (75, -1);
+ edit_group_list.set_size_request (75, -1);
edit_group_list.set_column_auto_resize (0, true);
edit_group_list.columns_autosize ();
edit_group_list_scroller.add (edit_group_list);
- edit_group_list_scroller.set_policy (GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+ edit_group_list_scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
- edit_group_list_button.clicked.connect (slot (*this, &Editor::edit_group_list_button_clicked));
+ edit_group_list_button.signal_clicked().connect (slot (*this, &Editor::edit_group_list_button_clicked));
edit_group_list.button_press_event.connect (slot (*this, &Editor::edit_group_list_button_press_event));
edit_group_list.select_row.connect (slot (*this, &Editor::edit_group_selected));
edit_group_list.unselect_row.connect (slot (*this, &Editor::edit_group_unselected));
edit_group_vbox.pack_start (edit_group_list_scroller, true, true);
route_list_frame.set_name ("BaseFrame");
- route_list_frame.set_shadow_type (GTK_SHADOW_IN);
+ route_list_frame.set_shadow_type (Gtk::SHADOW_IN);
route_list_frame.add (route_list_scroller);
edit_group_list_frame.set_name ("BaseFrame");
- edit_group_list_frame.set_shadow_type (GTK_SHADOW_IN);
+ edit_group_list_frame.set_shadow_type (Gtk::SHADOW_IN);
edit_group_list_frame.add (edit_group_vbox);
route_group_vpane.add1 (route_list_frame);
region_list_hidden_node = region_list_display.rows().end();
- region_list_display.add_events (GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK|GDK_POINTER_MOTION_MASK);
+ region_list_display.add_events (GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK|Gdk::POINTER_MOTION_MASK);
region_list_display.drag_dest_set (GTK_DEST_DEFAULT_ALL,
target_table, n_targets - 1,
- GdkDragAction (GDK_ACTION_COPY|GDK_ACTION_MOVE));
+ GdkDragAction (Gdk::ACTION_COPY|Gdk::ACTION_MOVE));
region_list_display.drag_data_received.connect (slot (*this, &Editor::region_list_display_drag_data_received));
region_list_scroller.add (region_list_display);
- region_list_scroller.set_policy (GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+ region_list_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
region_list_display.set_name ("RegionListDisplay");
- region_list_display.set_usize (100, -1);
+ region_list_display.set_size_request (100, -1);
region_list_display.column_titles_active ();
region_list_display.set_selection_mode (GTK_SELECTION_SINGLE);
region_list_sort_type = ByName;
reset_region_list_sort_type (region_list_sort_type);
- region_list_display.set_flags (GTK_CAN_FOCUS);
+ region_list_display.set_flags (Gtk::CAN_FOCUS);
region_list_display.key_press_event.connect (slot (*this, &Editor::region_list_display_key_press));
region_list_display.key_release_event.connect (slot (*this, &Editor::region_list_display_key_release));
region_list_display.click_column.connect (slot (*this, &Editor::region_list_column_click));
named_selection_scroller.add (named_selection_display);
- named_selection_scroller.set_policy (GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+ named_selection_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
named_selection_display.set_name ("RegionListDisplay");
- named_selection_display.set_usize (100, -1);
+ named_selection_display.set_size_request (100, -1);
named_selection_display.column_titles_active ();
named_selection_display.set_selection_mode (GTK_SELECTION_SINGLE);
/* nudge stuff */
- nudge_forward_button.add (*(manage (new Gtk::Pixmap (right_arrow_xpm))));
- nudge_backward_button.add (*(manage (new Gtk::Pixmap (left_arrow_xpm))));
+ nudge_forward_button.add (*(manage (new Gtk::Image (right_arrow_xpm))));
+ nudge_backward_button.add (*(manage (new Gtk::Image (left_arrow_xpm))));
ARDOUR_UI::instance()->tooltips().set_tip (nudge_forward_button, _("Nudge region/selection forwards"));
ARDOUR_UI::instance()->tooltips().set_tip (nudge_backward_button, _("Nudge region/selection backwards"));
set_wmclass (_("ardour_editor"), "Ardour");
add (vpacker);
- add_events (GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK);
+ add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
configure_event.connect (slot (*ARDOUR_UI::instance(), &ARDOUR_UI::configure_handler));
delete_event.connect (slot (*ARDOUR_UI::instance(), &ARDOUR_UI::exit_on_main_window_close));
track_canvas = wrap (track_gtk_canvas);
track_canvas->set_name ("EditorMainCanvas");
- track_canvas->add_events (GDK_POINTER_MOTION_HINT_MASK);
+ track_canvas->add_events (Gdk::POINTER_MOTION_HINT_MASK);
track_canvas->leave_notify_event.connect (slot (*this, &Editor::left_track_canvas));
track_canvas->drag_dest_set (GTK_DEST_DEFAULT_ALL,
target_table, n_targets - 1,
- GdkDragAction (GDK_ACTION_COPY|GDK_ACTION_MOVE));
+ GdkDragAction (Gdk::ACTION_COPY|Gdk::ACTION_MOVE));
track_canvas->drag_data_received.connect (slot (*this, &Editor::track_canvas_drag_data_received));
/* stuff for the verbose canvas cursor */
time_canvas = wrap (time_gtk_canvas);
time_canvas->set_name ("EditorTimeCanvas");
- time_canvas->add_events (GDK_POINTER_MOTION_HINT_MASK);
+ time_canvas->add_events (Gdk::POINTER_MOTION_HINT_MASK);
meter_group = gtk_canvas_item_new (gtk_canvas_root(GTK_CANVAS(time_gtk_canvas)),
gtk_canvas_group_get_type(),
void
Editor::queue_session_control_changed (Session::ControlType t)
{
- Gtkmmext::UI::instance()->call_slot (bind (slot (*this, &Editor::session_control_changed), t));
+ Gtkmm2ext::UI::instance()->call_slot (bind (slot (*this, &Editor::session_control_changed), t));
}
void
void
Editor::fake_add_edit_group (RouteGroup *group)
{
- Gtkmmext::UI::instance()->call_slot (bind (slot (*this, &Editor::add_edit_group), group));
+ Gtkmm2ext::UI::instance()->call_slot (bind (slot (*this, &Editor::add_edit_group), group));
}
void
Editor::fake_handle_new_audio_region (AudioRegion *region)
{
- Gtkmmext::UI::instance()->call_slot (bind (slot (*this, &Editor::handle_new_audio_region), region));
+ Gtkmm2ext::UI::instance()->call_slot (bind (slot (*this, &Editor::handle_new_audio_region), region));
}
void
Editor::fake_handle_audio_region_removed (AudioRegion *region)
{
- Gtkmmext::UI::instance()->call_slot (bind (slot (*this, &Editor::handle_audio_region_removed), region));
+ Gtkmm2ext::UI::instance()->call_slot (bind (slot (*this, &Editor::handle_audio_region_removed), region));
}
void
Editor::fake_handle_new_duration ()
{
- Gtkmmext::UI::instance()->call_slot (slot (*this, &Editor::handle_new_duration));
+ Gtkmm2ext::UI::instance()->call_slot (slot (*this, &Editor::handle_new_duration));
}
void
/* These signals can all be emitted by a non-GUI thread. Therefore the
handlers for them must not attempt to directly interact with the GUI,
- but use Gtkmmext::UI::instance()->call_slot();
+ but use Gtkmm2ext::UI::instance()->call_slot();
*/
session_connections.push_back (session->TransportStateChange.connect (slot (*this, &Editor::map_transport_state)));
geometry->add_property("x_off", string(buf));
snprintf(buf, sizeof(buf), "%d", yoff);
geometry->add_property("y_off", string(buf));
- snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&canvas_region_list_pane)->gtkobj()));
+ snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&canvas_region_list_pane)->gobj()));
geometry->add_property("canvas_region_list_pane_pos", string(buf));
- snprintf(buf,sizeof(buf), "%d", gtk_paned_get_position (static_cast<Paned*>(&track_list_canvas_pane)->gtkobj()));
+ snprintf(buf,sizeof(buf), "%d", gtk_paned_get_position (static_cast<Paned*>(&track_list_canvas_pane)->gobj()));
geometry->add_property("track_list_canvas_pane_pos", string(buf));
- snprintf(buf,sizeof(buf), "%d", gtk_paned_get_position (static_cast<Paned*>(®ion_selection_vpane)->gtkobj()));
+ snprintf(buf,sizeof(buf), "%d", gtk_paned_get_position (static_cast<Paned*>(®ion_selection_vpane)->gobj()));
geometry->add_property("region_selection_pane_pos", string(buf));
- snprintf(buf,sizeof(buf), "%d", gtk_paned_get_position (static_cast<Paned*>(&route_group_vpane)->gtkobj()));
+ snprintf(buf,sizeof(buf), "%d", gtk_paned_get_position (static_cast<Paned*>(&route_group_vpane)->gobj()));
geometry->add_property("route_group_pane_pos", string(buf));
node->add_child_nocopy (*geometry);
ARDOUR_UI::instance()->tooltips().set_tip (mouse_timefx_button, _("stretch/shrink regions"));
ARDOUR_UI::instance()->tooltips().set_tip (mouse_audition_button, _("listen to specific regions"));
- mouse_move_button.unset_flags (GTK_CAN_FOCUS);
- mouse_select_button.unset_flags (GTK_CAN_FOCUS);
- mouse_gain_button.unset_flags (GTK_CAN_FOCUS);
- mouse_zoom_button.unset_flags (GTK_CAN_FOCUS);
- mouse_timefx_button.unset_flags (GTK_CAN_FOCUS);
- mouse_audition_button.unset_flags (GTK_CAN_FOCUS);
+ mouse_move_button.unset_flags (Gtk::CAN_FOCUS);
+ mouse_select_button.unset_flags (Gtk::CAN_FOCUS);
+ mouse_gain_button.unset_flags (Gtk::CAN_FOCUS);
+ mouse_zoom_button.unset_flags (Gtk::CAN_FOCUS);
+ mouse_timefx_button.unset_flags (Gtk::CAN_FOCUS);
+ mouse_audition_button.unset_flags (Gtk::CAN_FOCUS);
mouse_select_button.toggled.connect (bind (slot (*this, &Editor::mouse_mode_toggled), Editing::MouseRange));
mouse_select_button.button_release_event.connect (slot (*this, &Editor::mouse_select_button_release));
/* XXX another disgusting hack because of the way combo boxes size themselves */
- Gtkmmext::set_usize_to_display_given_text (*edit_mode_selector.get_entry(), "EdgtMode", 2, 10);
+ Gtkmm2ext::set_size_request_to_display_given_text (*edit_mode_selector.get_entry(), "EdgtMode", 2, 10);
edit_mode_selector.set_popdown_strings (internationalize (edit_mode_strings));
edit_mode_selector.set_value_in_list (true, false);
/* XXX another disgusting hack because of the way combo boxes size themselves */
const guint32 FUDGE = 10; // Combo's are stupid - they steal space from the entry for the button
- Gtkmmext::set_usize_to_display_given_text (*snap_type_selector.get_entry(), "Region bounds", 2+FUDGE, 10);
+ Gtkmm2ext::set_size_request_to_display_given_text (*snap_type_selector.get_entry(), "Region bounds", 2+FUDGE, 10);
snap_type_selector.set_popdown_strings (internationalize (snap_type_strings));
snap_type_selector.set_value_in_list (true, false);
snap_mode_box.set_spacing (3);
snap_mode_box.set_border_width (3);
- Gtkmmext::set_usize_to_display_given_text (*snap_mode_selector.get_entry(), "SngpMode", 2, 10);
+ Gtkmm2ext::set_size_request_to_display_given_text (*snap_mode_selector.get_entry(), "SngpMode", 2, 10);
snap_mode_selector.set_popdown_strings (internationalize (snap_mode_strings));
snap_mode_selector.set_value_in_list (true, false);
/* XXX another disgusting hack because of the way combo boxes size themselves */
- Gtkmmext::set_usize_to_display_given_text (*zoom_focus_selector.get_entry(), "Edgt Cursor", 2, 10);
+ Gtkmm2ext::set_size_request_to_display_given_text (*zoom_focus_selector.get_entry(), "Edgt Cursor", 2, 10);
zoom_focus_selector.set_popdown_strings (internationalize (zoom_focus_strings));
zoom_focus_selector.set_value_in_list (true, false);
HBox *nbox = manage (new HBox);
- nudge_forward_button.clicked.connect (bind (slot (*this, &Editor::nudge_forward), false));
- nudge_backward_button.clicked.connect (bind (slot (*this, &Editor::nudge_backward), false));
+ nudge_forward_button.signal_clicked().connect (bind (slot (*this, &Editor::nudge_forward), false));
+ nudge_backward_button.signal_clicked().connect (bind (slot (*this, &Editor::nudge_backward), false));
nbox->pack_start (nudge_backward_button, false, false);
nbox->pack_start (nudge_forward_button, false, false);
toolbar_base.set_name ("ToolBarBase");
toolbar_base.add (toolbar_hbox);
- toolbar_frame.set_shadow_type (GTK_SHADOW_OUT);
+ toolbar_frame.set_shadow_type (Gtk::SHADOW_OUT);
toolbar_frame.set_name ("BaseFrame");
toolbar_frame.add (toolbar_base);
}
VBox vbox;
button_box.set_spacing (7);
- set_usize_to_display_given_text (ok_button, _("Cancel"), 20, 15); // this is cancel on purpose
- set_usize_to_display_given_text (cancel_button, _("Cancel"), 20, 15);
+ set_size_request_to_display_given_text (ok_button, _("Cancel"), 20, 15); // this is cancel on purpose
+ set_size_request_to_display_given_text (cancel_button, _("Cancel"), 20, 15);
button_box.pack_end (ok_button, false, false);
button_box.pack_end (cancel_button, false, false);
vbox.pack_start (button_box);
win.add (vbox);
- win.set_position (GTK_WIN_POS_MOUSE);
+ win.set_position (Gtk::WIN_POS_MOUSE);
win.show_all ();
- ok_button.clicked.connect (bind (slot (win, &ArdourDialog::stop), 0));
+ ok_button.signal_clicked().connect (bind (slot (win, &ArdourDialog::stop), 0));
entry.activate.connect (bind (slot (win, &ArdourDialog::stop), 0));
- cancel_button.clicked.connect (bind (slot (win, &ArdourDialog::stop), 1));
+ cancel_button.signal_clicked().connect (bind (slot (win, &ArdourDialog::stop), 1));
- entry.focus_in_event.connect (slot (ARDOUR_UI::generic_focus_in_event));
- entry.focus_out_event.connect (slot (ARDOUR_UI::generic_focus_out_event));
+ entry.signal_focus_in_event().connect (slot (ARDOUR_UI::generic_focus_in_event));
+ entry.signal_focus_out_event().connect (slot (ARDOUR_UI::generic_focus_out_event));
entry.set_text ("1");
- set_usize_to_display_given_text (entry, X_("12345678"), 20, 15);
+ set_size_request_to_display_given_text (entry, X_("12345678"), 20, 15);
entry.select_region (0, entry.get_text_length());
- win.set_position (GTK_WIN_POS_MOUSE);
+ win.set_position (Gtk::WIN_POS_MOUSE);
win.realize ();
win.get_window().set_decorations (GdkWMDecoration (GDK_DECOR_BORDER|GDK_DECOR_RESIZEH));
pos = atoi (prop->value());
}
- if ((done[0] = GTK_WIDGET(track_list_canvas_pane.gtkobj())->allocation.width > pos)) {
+ if ((done[0] = GTK_WIDGET(track_list_canvas_pane.gobj())->allocation.width > pos)) {
track_list_canvas_pane.set_position (pos);
}
pos = atoi (prop->value());
}
- if ((done[1] = GTK_WIDGET(canvas_region_list_pane.gtkobj())->allocation.width > pos)) {
+ if ((done[1] = GTK_WIDGET(canvas_region_list_pane.gobj())->allocation.width > pos)) {
canvas_region_list_pane.set_position (pos);
}
pos = atoi (prop->value());
}
- if ((done[2] = GTK_WIDGET(route_group_vpane.gtkobj())->allocation.height > pos)) {
+ if ((done[2] = GTK_WIDGET(route_group_vpane.gobj())->allocation.height > pos)) {
route_group_vpane.set_position (pos);
}
pos = atoi (prop->value());
}
- if ((done[3] = GTK_WIDGET(region_selection_vpane.gtkobj())->allocation.height > pos)) {
+ if ((done[3] = GTK_WIDGET(region_selection_vpane.gobj())->allocation.height > pos)) {
region_selection_vpane.set_position (pos);
}
}
ensure_float (cew);
- cew.ok_button.clicked.connect (bind (slot (cew, &ArdourDialog::stop), 1));
- cew.cancel_button.clicked.connect (bind (slot (cew, &ArdourDialog::stop), 0));
+ cew.ok_button.signal_clicked().connect (bind (slot (cew, &ArdourDialog::stop), 1));
+ cew.cancel_button.signal_clicked().connect (bind (slot (cew, &ArdourDialog::stop), 0));
cew.delete_event.connect (slot (cew, &ArdourDialog::wm_doi_event_stop));
cew.run ();
dialog.set_position (GTK_WIN_POS_CENTER);
dialog.show_all ();
- del_button.clicked.connect (bind (slot (dialog, &ArdourDialog::stop), 0));
- keep_button.clicked.connect (bind (slot (dialog, &ArdourDialog::stop), 1));
- abort_button.clicked.connect (bind (slot (dialog, &ArdourDialog::stop), 2));
+ del_button.signal_clicked().connect (bind (slot (dialog, &ArdourDialog::stop), 0));
+ keep_button.signal_clicked().connect (bind (slot (dialog, &ArdourDialog::stop), 1));
+ abort_button.signal_clicked().connect (bind (slot (dialog, &ArdourDialog::stop), 2));
dialog.realize ();
dialog.get_window().set_decorations (GdkWMDecoration (GDK_DECOR_BORDER|GDK_DECOR_RESIZEH));
#include <sndfile.h>
-#include <gtk--.h>
-#include <gtk--/layout.h>
+#include <gtkmm.h>
+#include <gtkmm/layout.h>
#include <gtk-canvas.h>
#include <gtk-canvas/gtk-canvas-util.h>
-#include <gtkmmext/selector.h>
-#include <gtkmmext/click_box.h>
+#include <gtkmm2ext/selector.h>
+#include <gtkmm2ext/click_box.h>
#include <ardour/stateful.h>
#include <ardour/session.h>
#include "enums.h"
#include "region_selection.h"
-namespace Gtkmmext {
+namespace Gtkmm2ext {
class TearOff;
}
static void build_cursors ();
- SigC::Connection scroll_connection;
+ sigc::connection scroll_connection;
jack_nframes_t last_update_frame;
void center_screen (jack_nframes_t);
void center_screen_internal (jack_nframes_t, float);
void update_current_screen ();
- SigC::Connection slower_update_connection;
+ sigc::connection slower_update_connection;
void update_slower ();
gint show_track_context_menu (GdkEventButton *);
Gtk::ProgressBar interthread_progress_bar;
Gtk::Button interthread_cancel_button;
Gtk::Label interthread_cancel_label;
- SigC::Connection interthread_progress_connection;
+ sigc::connection interthread_progress_connection;
void interthread_cancel_clicked ();
void build_interthread_progress_window ();
ARDOUR::InterThreadInfo* current_interthread_info;
void set_edit_cursor (GdkEvent* event);
void set_playhead_cursor (GdkEvent* event);
- void kbd_driver (SigC::Slot1<void,GdkEvent*>, bool use_track_canvas = true, bool use_time_canvas = true, bool can_select = true);
+ void kbd_driver (sigc::slot<void,GdkEvent*>, bool use_track_canvas = true, bool use_time_canvas = true, bool can_select = true);
void kbd_set_playhead_cursor ();
void kbd_set_edit_cursor ();
void kbd_split ();
Gtk::Label toolbar_selection_cursor_label;
Gtk::Table mouse_mode_button_table;
- Gtkmmext::TearOff* mouse_mode_tearoff;
+ Gtkmm2ext::TearOff* mouse_mode_tearoff;
Gtk::ToggleButton mouse_select_button;
Gtk::ToggleButton mouse_move_button;
Gtk::ToggleButton mouse_gain_button;
void setup_toolbar ();
- Gtkmmext::TearOff* tools_tearoff;
+ Gtkmm2ext::TearOff* tools_tearoff;
Gtk::HBox toolbar_hbox;
Gtk::EventBox toolbar_base;
Gtk::Frame toolbar_frame;
TimeStretchDialog (Editor& e);
gint update_progress ();
- SigC::Connection first_cancel;
- SigC::Connection first_delete;
+ sigc::connection first_cancel;
+ sigc::connection first_delete;
void cancel_timestretch_in_progress ();
gint delete_timestretch_in_progress (GdkEventAny*);
};
int playlist_deletion_dialog (ARDOUR::Playlist*);
- vector<SigC::Connection> session_connections;
+ vector<sigc::connection> session_connections;
/* tracking step changes of track height */
TimeAxisView* current_stepping_trackview;
struct timeval last_track_height_step_timestamp;
gint track_height_step_timeout();
- SigC::Connection step_timeout;
+ sigc::connection step_timeout;
TimeAxisView* entered_track;
AudioRegionView* entered_regionview;
#include "i18n.h"
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;
#include "utils.h"
#include "editor.h"
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;
#include <cstdlib>
#include <cmath>
-#include <gtkmmext/stop_signal.h>
+#include <gtkmm2ext/stop_signal.h>
#include <ardour/route_group.h>
#include "editor.h"
#include "i18n.h"
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;
Gtk::Main::run ();
- if (prompter.status != Gtkmmext::Prompter::entered) {
+ if (prompter.status != Gtkmm2ext::Prompter::entered) {
return;
}
FileSelection file_selector;
file_selector.get_selection_entry()->activate.connect (bind (slot (*this, &Editor::finish_sub_event_loop), 1));
- file_selector.get_cancel_button()->clicked.connect (bind (slot (*this, &Editor::finish_sub_event_loop), -1));
- file_selector.get_ok_button()->clicked.connect (bind (slot (*this, &Editor::finish_sub_event_loop), 1));
+ file_selector.get_cancel_button()-.signal_clicked().connect (bind (slot (*this, &Editor::finish_sub_event_loop), -1));
+ file_selector.get_ok_button()-.signal_clicked().connect (bind (slot (*this, &Editor::finish_sub_event_loop), 1));
file_selector.delete_event.connect (bind (slot (*this, &Editor::finish_sub_event_loop_on_delete), -1));
file_selector.show_all();
gdk_rectangle_intersect (&ev->area, &bar_rect, &draw_rect);
- gtk_paint_box (edit_hscroll_slider.get_style()->gtkobj(),
+ gtk_paint_box (edit_hscroll_slider.get_style()->gobj(),
edit_hscroll_slider.get_window(),
GTK_STATE_ACTIVE,
- GTK_SHADOW_IN,
+ Gtk::SHADOW_IN,
&ev->area,
- GTK_WIDGET(edit_hscroll_slider.gtkobj()),
+ GTK_WIDGET(edit_hscroll_slider.gobj()),
"trough",
0, 0, -1, -1);
- gtk_paint_box (edit_hscroll_slider.get_style()->gtkobj(),
+ gtk_paint_box (edit_hscroll_slider.get_style()->gobj(),
edit_hscroll_slider.get_window(),
- GTK_STATE_NORMAL,
- GTK_SHADOW_OUT,
+ Gtk::STATE_NORMAL,
+ Gtk::SHADOW_OUT,
&draw_rect,
- GTK_WIDGET(edit_hscroll_slider.gtkobj()),
+ GTK_WIDGET(edit_hscroll_slider.gobj()),
"hscale",
bar_rect.x, bar_rect.y, bar_rect.width, bar_rect.height);
#include "marker_view.h"
#include "editor.h"
#include "i18n.h"
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm2ext/gtk_ui.h>
#include <pbd/error.h>
#include <sys/types.h>
}
else
{
- Gtkmmext::UI::instance()->call_slot(bind(slot(*this, &Editor::handle_new_imageframe_time_axis_view),track_name, src)) ;
+ Gtkmm2ext::UI::instance()->call_slot(bind(slot(*this, &Editor::handle_new_imageframe_time_axis_view),track_name, src)) ;
}
}
// Can we only bind 2 data Items?
// @todo we really want to bind the src attribute too, for the moment tracks can only be added remotely,
// so this is not too much of an issue, however will need to be looked at again
- Gtkmmext::UI::instance()->call_slot(SigC::bind(slot(*this, &Editor::handle_new_imageframe_marker_time_axis_view),track_name, marked_track)) ;
+ Gtkmm2ext::UI::instance()->call_slot(SigC::bind(slot(*this, &Editor::handle_new_imageframe_marker_time_axis_view),track_name, marked_track)) ;
}
void
#include <pbd/error.h>
-#include <gtkmmext/popup_selector.h>
+#include <gtkmm2ext/popup_selector.h>
#include <ardour/session.h>
#include <ardour/region.h>
#include "i18n.h"
using namespace ARDOUR;
-using namespace SigC;
+using namespace sigc;
void
Editor::install_keybindings ()
#include <cmath>
#include <gtk-canvas.h>
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm2ext/gtk_ui.h>
#include <ardour/location.h>
#include "i18n.h"
using namespace std;
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;
}
dialog.set_name ("MarkRenameWindow");
- dialog.set_usize (300, -1);
- dialog.set_position (GTK_WIN_POS_MOUSE);
+ dialog.set_size_request (300, -1);
+ dialog.set_position (Gtk::WIN_POS_MOUSE);
dialog.set_modal (true);
dialog.get_vbox()->set_border_width (10);
cancel_button.set_name ("EditorGTKButton");
entry.activate.connect (bind (slot (*this, &Editor::finish_sub_event_loop), 1));
- cancel_button.clicked.connect (bind (slot (*this, &Editor::finish_sub_event_loop), -1));
- ok_button.clicked.connect (bind (slot (*this, &Editor::finish_sub_event_loop), 1));
+ cancel_button.signal_clicked().connect (bind (slot (*this, &Editor::finish_sub_event_loop), -1));
+ ok_button.signal_clicked().connect (bind (slot (*this, &Editor::finish_sub_event_loop), 1));
dialog.delete_event.connect (bind (slot (*this, &Editor::finish_sub_event_loop_on_delete), -1));
dialog.show_all ();
$Id$
*/
-#include <gtkmmext/utils.h>
+#include <gtkmm2ext/utils.h>
#include <ardour/audioengine.h>
#include "editor.h"
void
Editor::session_going_away ()
{
- for (vector<SigC::Connection>::iterator i = session_connections.begin(); i != session_connections.end(); ++i) {
+ for (vector<sigc::connection>::iterator i = session_connections.begin(); i != session_connections.end(); ++i) {
(*i).disconnect ();
}
#include <algorithm>
#include <pbd/error.h>
-#include <gtkmmext/utils.h>
+#include <gtkmm2ext/utils.h>
#include "ardour_ui.h"
#include "editor.h"
using namespace std;
using namespace ARDOUR;
-using namespace SigC;
+using namespace sigc;
using namespace Gtk;
using namespace Editing;
/* We call this so that MOTION_NOTIFY events continue to be
delivered to the canvas. We need to do this because we set
- GDK_POINTER_MOTION_HINT_MASK on the canvas. This reduces
+ Gdk::POINTER_MOTION_HINT_MASK on the canvas. This reduces
the density of the events, at the expense of a round-trip
to the server. Given that this will mostly occur on cases
where DISPLAY = :0.0, and given the cost of what the motion
drag_info.copied_location = 0;
gtk_canvas_item_grab (drag_info.item,
- GDK_POINTER_MOTION_MASK|GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK,
+ Gdk::POINTER_MOTION_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK,
cursor,
event->button.time);
session->add_undo (to_playlist->get_memento ());
latest_regionview = 0;
- SigC::Connection c = atv->view->AudioRegionViewAdded.connect (slot (*this, &Editor::collect_new_region_view));
+ sigc::connection c = atv->view->AudioRegionViewAdded.connect (slot (*this, &Editor::collect_new_region_view));
/* create a new region with the same name.
*/
from_playlist->remove_region (&((*i)->region));
- SigC::Connection c = atv2->view->AudioRegionViewAdded.connect (slot (*this, &Editor::collect_new_region_view));
+ sigc::connection c = atv2->view->AudioRegionViewAdded.connect (slot (*this, &Editor::collect_new_region_view));
to_playlist->add_region (*new_region, where);
c.disconnect ();
*/
latest_regionview = 0;
- SigC::Connection c = clicked_audio_trackview->view->AudioRegionViewAdded.connect (slot (*this, &Editor::collect_new_region_view));
+ sigc::connection c = clicked_audio_trackview->view->AudioRegionViewAdded.connect (slot (*this, &Editor::collect_new_region_view));
/* A selection grab currently creates two undo/redo operations, one for
creating the new region and another for moving it.
gint
Editor::mouse_rename_region (GtkCanvasItem* item, GdkEvent* event)
{
- using namespace Gtkmmext;
+ using namespace Gtkmm2ext;
ArdourPrompter prompter (false);
#include "i18n.h"
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;
#include <pbd/basename.h>
#include <pbd/pthread_utils.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/choice.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/choice.h>
#include <ardour/audioengine.h>
#include <ardour/session.h>
using namespace std;
using namespace ARDOUR;
-using namespace SigC;
+using namespace sigc;
using namespace Gtk;
using namespace Editing;
choices.push_back (_("No, do nothing."));
- Gtkmmext::Choice prompter (prompt, choices);
+ Gtkmm2ext::Choice prompter (prompt, choices);
prompter.chosen.connect (Gtk::Main::quit.slot());
prompter.show_all ();
dialog.set_title (_("ardour: rename region"));
dialog.set_name ("RegionRenameWindow");
- dialog.set_usize (300, -1);
- dialog.set_position (GTK_WIN_POS_MOUSE);
+ dialog.set_size_request (300, -1);
+ dialog.set_position (Gtk::WIN_POS_MOUSE);
dialog.set_modal (true);
dialog.get_vbox()->set_border_width (10);
region_renamed = false;
entry.activate.connect (bind (slot (*this, &Editor::rename_region_finished), true));
- ok_button.clicked.connect (bind (slot (*this, &Editor::rename_region_finished), true));
- cancel_button.clicked.connect (bind (slot (*this, &Editor::rename_region_finished), false));
+ ok_button.signal_clicked().connect (bind (slot (*this, &Editor::rename_region_finished), true));
+ cancel_button.signal_clicked().connect (bind (slot (*this, &Editor::rename_region_finished), false));
/* recurse */
interthread_cancel_button.add (interthread_cancel_label);
- interthread_cancel_button.clicked.connect (slot (*this, &Editor::interthread_cancel_clicked));
+ interthread_cancel_button.signal_clicked().connect (slot (*this, &Editor::interthread_cancel_clicked));
interthread_progress_window->set_modal (true);
interthread_progress_window->set_default_size (200, 100);
}
SoundFileSelector& sfdb (ARDOUR_UI::instance()->get_sfdb_window());
- SigC::Connection c;
+ sigc::connection c;
string str;
if (as_tracks) {
void
Editor::do_import (vector<string> paths, bool split, bool as_tracks)
{
- SigC::Connection c;
+ sigc::connection c;
/* SFDB sets "multichan" to true to indicate "split channels"
so reverse the setting to match the way libardour
}
interthread_progress_window->set_title (_("ardour: audio import in progress"));
- interthread_progress_window->set_position (GTK_WIN_POS_MOUSE);
+ interthread_progress_window->set_position (Gtk::WIN_POS_MOUSE);
interthread_progress_window->show_all ();
interthread_progress_bar.set_percentage (0.0f);
interthread_cancel_label.set_text (_("Cancel Import"));
choices.push_back (_("Cancel"));
}
- Gtkmmext::Choice rate_choice (
+ Gtkmm2ext::Choice rate_choice (
compose (_("%1\nThis audiofile's sample rate doesn't match the session sample rate!"), path),
choices);
}
SoundFileSelector& sfdb (ARDOUR_UI::instance()->get_sfdb_window());
- SigC::Connection c = sfdb.Action.connect (slot (*this, &Editor::do_embed_sndfiles));
+ sigc::connection c = sfdb.Action.connect (slot (*this, &Editor::do_embed_sndfiles));
sfdb.run (_("Add to External Region list"), true);
Editor::insert_sndfile (bool as_tracks)
{
SoundFileSelector& sfdb (ARDOUR_UI::instance()->get_sfdb_window());
- SigC::Connection c;
+ sigc::connection c;
string str;
if (as_tracks) {
}
interthread_progress_window->set_title (_("ardour: freeze"));
- interthread_progress_window->set_position (GTK_WIN_POS_MOUSE);
+ interthread_progress_window->set_position (Gtk::WIN_POS_MOUSE);
interthread_progress_window->show_all ();
interthread_progress_bar.set_percentage (0.0f);
interthread_progress_label.set_text ("");
choices.push_back (_("Yes, destroy it."));
choices.push_back (_("No, do nothing."));
- Gtkmmext::Choice prompter (prompt, choices);
+ Gtkmm2ext::Choice prompter (prompt, choices);
prompter.chosen.connect (Gtk::Main::quit.slot());
prompter.show_all ();
#include <ardour/audioregion.h>
#include <ardour/session_region.h>
-#include <gtkmmext/stop_signal.h>
+#include <gtkmm2ext/stop_signal.h>
#include "editor.h"
#include "editing.h"
#include "i18n.h"
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;
using namespace Editing;
/* ---------------------------------------- */
/* XXX MAKE ME A FUNCTION (no CTree::clear() in gtkmm 1.2) */
- gtk_ctree_remove_node (region_list_display.gtkobj(), NULL);
+ gtk_ctree_remove_node (region_list_display.gobj(), NULL);
/* ---------------------------------------- */
}
#include "i18n.h"
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;
#include <string>
#include <ardour/tempo.h>
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm2ext/gtk_ui.h>
#include "editor.h"
#include "editing.h"
#include "i18n.h"
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;
using namespace Editing;
_smpte_ruler = gtk_custom_hruler_new ();
smpte_ruler = wrap (_smpte_ruler);
smpte_ruler->set_name ("SMPTERuler");
- smpte_ruler->set_usize (-1, (int)timebar_height);
+ smpte_ruler->set_size_request (-1, (int)timebar_height);
gtk_custom_ruler_set_metric (GTK_CUSTOM_RULER(_smpte_ruler), &ruler_metrics[ruler_metric_smpte]);
ruler_shown[ruler_metric_smpte] = true;
_bbt_ruler = gtk_custom_hruler_new ();
bbt_ruler = wrap (_bbt_ruler);
bbt_ruler->set_name ("BBTRuler");
- bbt_ruler->set_usize (-1, (int)timebar_height);
+ bbt_ruler->set_size_request (-1, (int)timebar_height);
gtk_custom_ruler_set_metric (GTK_CUSTOM_RULER(_bbt_ruler), &ruler_metrics[ruler_metric_bbt]);
ruler_shown[ruler_metric_bbt] = true;
_frames_ruler = gtk_custom_hruler_new ();
frames_ruler = wrap (_frames_ruler);
frames_ruler->set_name ("FramesRuler");
- frames_ruler->set_usize (-1, (int)timebar_height);
+ frames_ruler->set_size_request (-1, (int)timebar_height);
gtk_custom_ruler_set_metric (GTK_CUSTOM_RULER(_frames_ruler), &ruler_metrics[ruler_metric_frames]);
_minsec_ruler = gtk_custom_hruler_new ();
minsec_ruler = wrap (_minsec_ruler);
minsec_ruler->set_name ("MinSecRuler");
- minsec_ruler->set_usize (-1, (int)timebar_height);
+ minsec_ruler->set_size_request (-1, (int)timebar_height);
gtk_custom_ruler_set_metric (GTK_CUSTOM_RULER(_minsec_ruler), &ruler_metrics[ruler_metric_minsec]);
ruler_shown[ruler_time_meter] = true;
ruler_shown[ruler_metric_frames] = false;
ruler_shown[ruler_metric_minsec] = false;
- smpte_ruler->set_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
- bbt_ruler->set_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
- frames_ruler->set_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
- minsec_ruler->set_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
+ smpte_ruler->set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
+ bbt_ruler->set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
+ frames_ruler->set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
+ minsec_ruler->set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
smpte_ruler->button_release_event.connect (slot (*this, &Editor::ruler_button_release));
bbt_ruler->button_release_event.connect (slot (*this, &Editor::ruler_button_release));
_smpte_ruler = gtk_custom_hruler_new ();
smpte_ruler = wrap (_smpte_ruler);
smpte_ruler->set_name ("SMPTERuler");
- smpte_ruler->set_usize (-1, (int)timebar_height);
+ smpte_ruler->set_size_request (-1, (int)timebar_height);
gtk_custom_ruler_set_metric (GTK_CUSTOM_RULER(_smpte_ruler), &ruler_metrics[ruler_metric_smpte]);
_bbt_ruler = gtk_custom_hruler_new ();
bbt_ruler = wrap (_bbt_ruler);
bbt_ruler->set_name ("BBTRuler");
- bbt_ruler->set_usize (-1, (int)timebar_height);
+ bbt_ruler->set_size_request (-1, (int)timebar_height);
gtk_custom_ruler_set_metric (GTK_CUSTOM_RULER(_bbt_ruler), &ruler_metrics[ruler_metric_bbt]);
_frames_ruler = gtk_custom_hruler_new ();
frames_ruler = wrap (_frames_ruler);
frames_ruler->set_name ("FramesRuler");
- frames_ruler->set_usize (-1, (int)timebar_height);
+ frames_ruler->set_size_request (-1, (int)timebar_height);
gtk_custom_ruler_set_metric (GTK_CUSTOM_RULER(_frames_ruler), &ruler_metrics[ruler_metric_frames]);
_minsec_ruler = gtk_custom_hruler_new ();
minsec_ruler = wrap (_minsec_ruler);
minsec_ruler->set_name ("MinSecRuler");
- minsec_ruler->set_usize (-1, (int)timebar_height);
+ minsec_ruler->set_size_request (-1, (int)timebar_height);
gtk_custom_ruler_set_metric (GTK_CUSTOM_RULER(_minsec_ruler), &ruler_metrics[ruler_metric_minsec]);
- smpte_ruler->set_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
- bbt_ruler->set_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
- frames_ruler->set_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
- minsec_ruler->set_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
+ smpte_ruler->set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
+ bbt_ruler->set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
+ frames_ruler->set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
+ minsec_ruler->set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
smpte_ruler->button_release_event.connect (slot (*this, &Editor::ruler_button_release));
bbt_ruler->button_release_event.connect (slot (*this, &Editor::ruler_button_release));
gtk_canvas_item_hide (transport_marker_group);
}
- time_canvas_vbox.set_usize (-1, (int)(timebar_height * visible_timebars));
+ time_canvas_vbox.set_size_request (-1, (int)(timebar_height * visible_timebars));
time_canvas_event_box.queue_resize();
update_fixed_rulers();
#include <cmath>
#include <vector>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <ardour/named_selection.h>
#include <ardour/session_selection.h>
#include <ardour/playlist.h>
-#include <gtkmmext/stop_signal.h>
+#include <gtkmm2ext/stop_signal.h>
#include "editor.h"
#include "selection.h"
#include "i18n.h"
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;
-using namespace Gtkmmext;
+using namespace Gtkmm2ext;
void
Editor::handle_new_named_selection ()
#include <pbd/error.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/gtk_ui.h>
#include <ardour/session.h>
#include <ardour/tempo.h>
-#include <gtkmmext/doi.h>
+#include <gtkmm2ext/doi.h>
#include "editor.h"
#include "marker.h"
#include "i18n.h"
using namespace std;
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;
using namespace Editing;
TempoDialog tempo_dialog (map, frame, _("add"));
tempo_dialog.bpm_entry.activate.connect (bind (slot (tempo_dialog, &ArdourDialog::stop), 0));
- tempo_dialog.ok_button.clicked.connect (bind (slot (tempo_dialog, &ArdourDialog::stop), 0));
- tempo_dialog.cancel_button.clicked.connect (bind (slot (tempo_dialog, &ArdourDialog::stop), -1));
+ tempo_dialog.ok_button.signal_clicked().connect (bind (slot (tempo_dialog, &ArdourDialog::stop), 0));
+ tempo_dialog.cancel_button.signal_clicked().connect (bind (slot (tempo_dialog, &ArdourDialog::stop), -1));
- tempo_dialog.set_position (GTK_WIN_POS_MOUSE);
+ tempo_dialog.set_position (Gtk::WIN_POS_MOUSE);
tempo_dialog.realize ();
tempo_dialog.get_window().set_decorations (GdkWMDecoration (GDK_DECOR_BORDER|GDK_DECOR_RESIZEH));
TempoMap& map(session->tempo_map());
MeterDialog meter_dialog (map, frame, _("add"));
- meter_dialog.ok_button.clicked.connect (bind (slot (meter_dialog, &ArdourDialog::stop), 0));
- meter_dialog.cancel_button.clicked.connect (bind (slot (meter_dialog, &ArdourDialog::stop), -1));
+ meter_dialog.ok_button.signal_clicked().connect (bind (slot (meter_dialog, &ArdourDialog::stop), 0));
+ meter_dialog.cancel_button.signal_clicked().connect (bind (slot (meter_dialog, &ArdourDialog::stop), -1));
- meter_dialog.set_position (GTK_WIN_POS_MOUSE);
+ meter_dialog.set_position (Gtk::WIN_POS_MOUSE);
meter_dialog.realize ();
meter_dialog.get_window().set_decorations (GdkWMDecoration (GDK_DECOR_BORDER|GDK_DECOR_RESIZEH));
{
MeterDialog meter_dialog (*section, _("done"));
- meter_dialog.ok_button.clicked.connect (bind (slot (meter_dialog, &ArdourDialog::stop), 0));
- meter_dialog.cancel_button.clicked.connect (bind (slot (meter_dialog, &ArdourDialog::stop), -1));
+ meter_dialog.ok_button.signal_clicked().connect (bind (slot (meter_dialog, &ArdourDialog::stop), 0));
+ meter_dialog.cancel_button.signal_clicked().connect (bind (slot (meter_dialog, &ArdourDialog::stop), -1));
- meter_dialog.set_position (GTK_WIN_POS_MOUSE);
+ meter_dialog.set_position (Gtk::WIN_POS_MOUSE);
meter_dialog.realize ();
meter_dialog.get_window().set_decorations (GdkWMDecoration (GDK_DECOR_BORDER|GDK_DECOR_RESIZEH));
TempoDialog tempo_dialog (*section, _("done"));
tempo_dialog.bpm_entry.activate.connect (bind (slot (tempo_dialog, &ArdourDialog::stop), 0));
- tempo_dialog.ok_button.clicked.connect (bind (slot (tempo_dialog, &ArdourDialog::stop), 0));
- tempo_dialog.cancel_button.clicked.connect (bind (slot (tempo_dialog, &ArdourDialog::stop), -1));
+ tempo_dialog.ok_button.signal_clicked().connect (bind (slot (tempo_dialog, &ArdourDialog::stop), 0));
+ tempo_dialog.cancel_button.signal_clicked().connect (bind (slot (tempo_dialog, &ArdourDialog::stop), -1));
- tempo_dialog.set_position (GTK_WIN_POS_MOUSE);
+ tempo_dialog.set_position (Gtk::WIN_POS_MOUSE);
tempo_dialog.realize ();
tempo_dialog.get_window().set_decorations (GdkWMDecoration (GDK_DECOR_BORDER|GDK_DECOR_RESIZEH));
#include "i18n.h"
using namespace ARDOUR;
-using namespace SigC;
+using namespace sigc;
using namespace Gtk;
Editor::TimeStretchDialog::TimeStretchDialog (Editor& e)
action_button (_("Stretch/Shrink it"))
{
set_modal (true);
- set_position (GTK_WIN_POS_MOUSE);
+ set_position (Gtk::WIN_POS_MOUSE);
set_title (_("ardour: timestretch"));
set_name (N_("TimeStretchDialog"));
antialias_button.set_name (N_("TimeStretchButton"));
progress_bar.set_name (N_("TimeStretchProgress"));
- action_button.clicked.connect (bind (slot (*this, &ArdourDialog::stop), 1));
+ action_button.signal_clicked().connect (bind (slot (*this, &ArdourDialog::stop), 1));
}
gint
}
current_timestretch->progress_bar.set_percentage (0.0f);
- current_timestretch->first_cancel = current_timestretch->cancel_button.clicked.connect (bind (slot (*current_timestretch, &ArdourDialog::stop), -1));
+ current_timestretch->first_cancel = current_timestretch->cancel_button.signal_clicked().connect (bind (slot (*current_timestretch, &ArdourDialog::stop), -1));
current_timestretch->first_delete = current_timestretch->delete_event.connect (slot (*current_timestretch, &ArdourDialog::wm_close_event));
current_timestretch->run ();
current_timestretch->first_cancel.disconnect();
current_timestretch->first_delete.disconnect();
- current_timestretch->cancel_button.clicked.connect (slot (current_timestretch, &TimeStretchDialog::cancel_timestretch_in_progress));
+ current_timestretch->cancel_button.signal_clicked().connect (slot (current_timestretch, &TimeStretchDialog::cancel_timestretch_in_progress));
current_timestretch->delete_event.connect (slot (current_timestretch, &TimeStretchDialog::delete_timestretch_in_progress));
if (pthread_create_and_store ("timestretch", &thread, 0, timestretch_thread, current_timestretch)) {
pthread_detach (thread);
- SigC::Connection c = Main::timeout.connect (slot (current_timestretch, &TimeStretchDialog::update_progress), 100);
+ sigc::connection c = Main::timeout.connect (slot (current_timestretch, &TimeStretchDialog::update_progress), 100);
while (current_timestretch->request.running) {
gtk_main_iteration ();
#include <pbd/pthread_utils.h>
#include <pbd/xml++.h>
-#include <gtk--.h>
-#include <gtkmmext/utils.h>
+#include <gtkmm.h>
+#include <gtkmm2ext/utils.h>
#include <ardour/export.h>
#include <ardour/sndfile_helpers.h>
#include <ardour/audio_track.h>
#include "i18n.h"
-#define FRAME_SHADOW_STYLE GTK_SHADOW_IN
+#define FRAME_SHADOW_STYLE Gtk::SHADOW_IN
#define FRAME_NAME "BaseFrame"
GdkPixmap* ExportDialog::check_pixmap = 0;
using namespace std;
using namespace ARDOUR;
-using namespace SigC;
+using namespace sigc;
using namespace Gtk;
static const gchar *sample_rates[] = {
set_title (_("ardour: export"));
set_wmclass (_("ardour_export"), "Ardour");
set_name ("ExportWindow");
- add_events (GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK);
+ add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
add (vpacker);
file_selector = 0;
spec.running = false;
- file_entry.focus_in_event.connect (slot (ARDOUR_UI::generic_focus_in_event));
- file_entry.focus_out_event.connect (slot (ARDOUR_UI::generic_focus_out_event));
+ file_entry.signal_focus_in_event().connect (slot (ARDOUR_UI::generic_focus_in_event));
+ file_entry.signal_focus_out_event().connect (slot (ARDOUR_UI::generic_focus_out_event));
file_entry.set_name ("ExportFileNameEntry");
master_selector.set_name ("ExportTrackSelector");
- master_selector.set_usize (-1, 100);
+ master_selector.set_size_request (-1, 100);
master_selector.set_column_min_width (0, 100);
master_selector.set_column_min_width (1, 40);
master_selector.set_column_auto_resize(1, true);
master_selector.button_press_event.connect (slot (*this, &ExportDialog::master_selector_button_press_event));
track_selector.set_name ("ExportTrackSelector");
- track_selector.set_usize (-1, 130);
+ track_selector.set_size_request (-1, 130);
track_selector.set_column_min_width (0, 100);
track_selector.set_column_min_width (1, 40);
track_selector.set_column_auto_resize(1, true);
track_selector.button_press_event.connect (slot (*this, &ExportDialog::track_selector_button_press_event));
check_pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL,
- gtk_widget_get_colormap(GTK_WIDGET(track_selector.gtkobj())),
+ gtk_widget_get_colormap(GTK_WIDGET(track_selector.gobj())),
&check_mask, NULL, (gchar**) check_xpm);
empty_pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL,
- gtk_widget_get_colormap(GTK_WIDGET(track_selector.gtkobj())),
+ gtk_widget_get_colormap(GTK_WIDGET(track_selector.gobj())),
&empty_mask, NULL, (gchar**) empty_xpm);
progress_bar.set_show_text (false);
format_frame.add (format_table);
format_frame.set_name (FRAME_NAME);
- track_scroll.set_policy(GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
- master_scroll.set_policy(GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+ track_scroll.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
+ master_scroll.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
vpacker.pack_start (file_frame, false, false);
master_scroll.add (master_selector);
track_scroll.add (track_selector);
- master_scroll.set_usize (220, 100);
- track_scroll.set_usize (220, 100);
+ master_scroll.set_size_request (220, 100);
+ track_scroll.set_size_request (220, 100);
vpacker.pack_start (hpacker, true, true);
track_selector_button.set_name ("EditorGTKButton");
- track_selector_button.clicked.connect (slot (*this, &ExportDialog::track_selector_button_click));
+ track_selector_button.signal_clicked().connect (slot (*this, &ExportDialog::track_selector_button_click));
vpacker.pack_start (button_box, false, false);
vpacker.pack_start (progress_bar, false, false);
- Gtkmmext::set_usize_to_display_given_text (file_entry, X_("Kg/quite/a/reasonable/size/for/files/i/think"), 5, 8);
+ Gtkmm2ext::set_size_request_to_display_given_text (file_entry, X_("Kg/quite/a/reasonable/size/for/files/i/think"), 5, 8);
file_hbox.set_spacing (5);
file_hbox.set_border_width (5);
longest_str[0] = 'g';
longest_str[1] = 'l';
- Gtkmmext::set_usize_to_display_given_text (*header_format_combo.get_entry(), longest_str.c_str(), 5+FUDGE, 5);
+ Gtkmm2ext::set_size_request_to_display_given_text (*header_format_combo.get_entry(), longest_str.c_str(), 5+FUDGE, 5);
// TRANSLATORS: "slereg" is "stereo" with ascender and descender substituted
- Gtkmmext::set_usize_to_display_given_text (*channel_count_combo.get_entry(), _("slereg"), 5+FUDGE, 5);
+ Gtkmm2ext::set_size_request_to_display_given_text (*channel_count_combo.get_entry(), _("slereg"), 5+FUDGE, 5);
header_format_combo.set_use_arrows_always (true);
bitdepth_format_combo.set_use_arrows_always (true);
file_entry.set_name ("ExportFileDisplay");
delete_event.connect (slot (*this, &ExportDialog::window_closed));
- ok_button.clicked.connect (slot (*this, &ExportDialog::do_export));
- cancel_button.clicked.connect (slot (*this, &ExportDialog::end_dialog));
+ ok_button.signal_clicked().connect (slot (*this, &ExportDialog::do_export));
+ cancel_button.signal_clicked().connect (slot (*this, &ExportDialog::end_dialog));
file_browse_button.set_name ("EditorGTKButton");
- file_browse_button.clicked.connect (slot (*this, &ExportDialog::initiate_browse));
+ file_browse_button.signal_clicked().connect (slot (*this, &ExportDialog::initiate_browse));
channel_count_combo.get_popwin()->unmap_event.connect (slot (*this, &ExportDialog::channels_chosen));
bitdepth_format_combo.get_popwin()->unmap_event.connect (slot (*this, &ExportDialog::bitdepth_chosen));
for (CList_Helpers::RowIterator ri = track_selector.rows().begin(); ri != track_selector.rows().end(); ++ri, ++n) {
XMLNode* track = new XMLNode(X_("Track"));
- Gdk_Pixmap left_pixmap = track_selector.cell (n, 1).get_pixmap ();
- track->add_property(X_("channel1"), left_pixmap.gdkobj() == check_pixmap ? X_("on") : X_("off"));
+ Gdk::Pixmap left_pixmap = track_selector.cell (n, 1).get_pixmap ();
+ track->add_property(X_("channel1"), left_pixmap.gobj() == check_pixmap ? X_("on") : X_("off"));
- Gdk_Pixmap right_pixmap = track_selector.cell (n, 2).get_pixmap ();
- track->add_property(X_("channel2"), right_pixmap.gdkobj() == check_pixmap ? X_("on") : X_("off"));
+ Gdk::Pixmap right_pixmap = track_selector.cell (n, 2).get_pixmap ();
+ track->add_property(X_("channel2"), right_pixmap.gobj() == check_pixmap ? X_("on") : X_("off"));
tracks->add_child_nocopy(*track);
}
chan = 0;
}
- Gdk_Pixmap left_pixmap = master_selector.cell (n, 1).get_pixmap ();
+ Gdk::Pixmap left_pixmap = master_selector.cell (n, 1).get_pixmap ();
- if (left_pixmap.gdkobj() == check_pixmap) {
+ if (left_pixmap.gobj() == check_pixmap) {
spec.port_map[0].push_back (std::pair<Port*,uint32_t>(port, chan));
}
if (spec.channels == 2) {
- Gdk_Pixmap right_pixmap = master_selector.cell (n, 2).get_pixmap ();
+ Gdk::Pixmap right_pixmap = master_selector.cell (n, 2).get_pixmap ();
- if (right_pixmap.gdkobj() == check_pixmap) {
+ if (right_pixmap.gobj() == check_pixmap) {
spec.port_map[1].push_back (std::pair<Port*,uint32_t>(port, chan));
}
chan = 0;
}
- Gdk_Pixmap left_pixmap = track_selector.cell (n, 1).get_pixmap ();
+ Gdk::Pixmap left_pixmap = track_selector.cell (n, 1).get_pixmap ();
- if (left_pixmap.gdkobj() == check_pixmap) {
+ if (left_pixmap.gobj() == check_pixmap) {
spec.port_map[0].push_back (std::pair<Port*,uint32_t>(port, chan));
}
if (spec.channels == 2) {
- Gdk_Pixmap right_pixmap = track_selector.cell (n, 2).get_pixmap ();
+ Gdk::Pixmap right_pixmap = track_selector.cell (n, 2).get_pixmap ();
- if (right_pixmap.gdkobj() == check_pixmap) {
+ if (right_pixmap.gobj() == check_pixmap) {
spec.port_map[1].push_back (std::pair<Port*,uint32_t>(port, chan));
}
return FALSE;
}
- gtk_signal_emit_stop_by_name (GTK_OBJECT(track_selector.gtkobj()), "button_press_event");
+ gtk_signal_emit_stop_by_name (GTK_OBJECT(track_selector.gobj()), "button_press_event");
- Gdk_Pixmap pixmap = track_selector.cell (row,col).get_pixmap ();
+ Gdk::Pixmap pixmap = track_selector.cell (row,col).get_pixmap ();
if (col != 0) {
- if (pixmap.gdkobj() == check_pixmap) {
+ if (pixmap.gobj() == check_pixmap) {
track_selector.cell (row,col).set_pixmap (empty_pixmap, empty_mask);
} else {
track_selector.cell (row,col).set_pixmap (check_pixmap, check_mask);
return FALSE;
}
- gtk_signal_emit_stop_by_name (GTK_OBJECT(master_selector.gtkobj()), "button_press_event");
+ gtk_signal_emit_stop_by_name (GTK_OBJECT(master_selector.gobj()), "button_press_event");
if (col != 0) {
- Gdk_Pixmap pixmap = master_selector.cell (row,col).get_pixmap ();
+ Gdk::Pixmap pixmap = master_selector.cell (row,col).get_pixmap ();
- if (pixmap.gdkobj() == check_pixmap) {
+ if (pixmap.gobj() == check_pixmap) {
master_selector.cell (row,col).set_pixmap (empty_pixmap, empty_mask);
} else {
master_selector.cell (row,col).set_pixmap (check_pixmap, check_mask);
file_selector = new FileSelection;
file_selector->set_modal (true);
- file_selector->get_cancel_button()->clicked.connect (bind (slot (*this, &ExportDialog::finish_browse), -1));
- file_selector->get_ok_button()->clicked.connect (bind (slot (*this, &ExportDialog::finish_browse), 1));
+ file_selector->get_cancel_button()-.signal_clicked().connect (bind (slot (*this, &ExportDialog::finish_browse), -1));
+ file_selector->get_ok_button()-.signal_clicked().connect (bind (slot (*this, &ExportDialog::finish_browse), 1));
file_selector->map_event.connect (bind (slot (*this, &ExportDialog::change_focus_policy), true));
file_selector->unmap_event.connect (bind (slot (*this, &ExportDialog::change_focus_policy), false));
}
#ifndef __ardour_export_dialog_h__
#define __ardour_export_dialog_h__
-#include <gtk--.h>
+#include <gtkmm.h>
#include <ardour/export.h>
#include "ardour_dialog.h"
static void *_thread (void *arg);
gint progress_timeout ();
- SigC::Connection progress_connection;
+ sigc::connection progress_connection;
void build_window ();
void end_dialog();
gint header_chosen (GdkEventAny *ignored);
#define __ardour_gtk_ghost_region_h__
#include <vector>
-#include <sigc++/signal_system.h>
+#include <sigc++/signal.h>
#include <gtk-canvas.h>
class AutomationTimeAxisView;
-struct GhostRegion : public SigC::Object
+struct GhostRegion : public sigc::trackable
{
AutomationTimeAxisView& trackview;
GtkCanvasItem* group;
void set_duration (double units);
void set_height ();
- SigC::Signal1<void,GhostRegion*> GoingAway;
+ sigc::signal<void,GhostRegion*> GoingAway;
};
#endif /* __ardour_gtk_ghost_region_h__ */
#define __ardour_gtk_gui_thread_h__
#define ENSURE_GUI_THREAD(slot) \
- if (!Gtkmmext::UI::instance()->caller_is_gui_thread()) {\
- Gtkmmext::UI::instance()->call_slot ((slot));\
+ if (!Gtkmm2ext::UI::instance()->caller_is_gui_thread()) {\
+ Gtkmm2ext::UI::instance()->call_slot ((slot));\
return;\
}
#include <sigc++/bind.h>
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm2ext/gtk_ui.h>
#include "imageframe_socket_handler.h"
#include "imageframe_time_axis.h"
#include <ardour/session.h>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <unistd.h>
using namespace std;
using namespace ardourvis ;
-using namespace SigC;
+using namespace sigc;
ImageFrameSocketHandler* ImageFrameSocketHandler::_instance = 0 ;
#define __ardour_gtk_imageframe_socket_handler_h__
#include <string>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <list>
#include "editor.h"
#include "ardour_image_compositor_socket.h"
* message passing through a socket.
*
*/
-class ImageFrameSocketHandler : public SigC::Object
+class ImageFrameSocketHandler : public sigc::trackable
{
public:
/**
// Emitted Signals
/** Emitted if the socket connection is shutdown at the other end */
- SigC::Signal0<void> CompositorSocketShutdown ;
+ sigc::signal<void> CompositorSocketShutdown ;
/** Emitted as a generic error is captured from the socket connection to the animatic compositor */
- SigC::Signal0<void> CompositorSocketError ;
+ sigc::signal<void> CompositorSocketError ;
protected:
#include <pbd/error.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/gtk_ui.h>
#include <ardour/session.h>
#include <ardour/utils.h>
#include "i18n.h"
using namespace ARDOUR ;
-using namespace SigC ;
+using namespace sigc ;
using namespace Gtk ;
/**
#ifndef __ardour_imageframe_time_axis_h__
#define __ardour_imageframe_time_axis_h__
-#include <gtk--.h>
+#include <gtkmm.h>
#include <gtk-canvas.h>
#include "ardour_dialog.h"
// Emitted Signals
/** Emitted when a Marker Time Axis is Added, or associated with, this time axis */
- SigC::Signal2<void,MarkerTimeAxis*,void*> MarkerTimeAxisAdded ;
+ sigc::signal<void,MarkerTimeAxis*,void*> MarkerTimeAxisAdded ;
/** Emitted when a Marker Time Axis is removed, from this time axis */
- SigC::Signal2<void,std::string,void*> MarkerTimeAxisRemoved ;
+ sigc::signal<void,std::string,void*> MarkerTimeAxisRemoved ;
protected:
#include <algorithm>
-#include <gtk--.h>
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm.h>
+#include <gtkmm2ext/gtk_ui.h>
#include "imageframe_time_axis_group.h"
#include "imageframe_time_axis_view.h"
#include <list>
#include <cmath>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <gtk-canvas.h>
#include <jack/jack.h>
#include "imageframe_time_axis_view.h"
* A viewable object may also be useful...
*
*/
-class ImageFrameTimeAxisGroup : public SigC::Object
+class ImageFrameTimeAxisGroup : public sigc::trackable
{
public:
//---------------------------------------------------------------------------------------//
//---------------------------------------------------------------------------------//
// Emitted Signals
- SigC::Signal0<void> GoingAway ;
+ sigc::signal<void> GoingAway ;
/**
* Emitted when this Group has been removed
* the destructor, this allows us to capture the source of the deletion
* event
*/
- SigC::Signal2<void,std::string,void*> GroupRemoved ;
+ sigc::signal<void,std::string,void*> GroupRemoved ;
/** Emitted when we have changed the name of this TimeAxis */
- SigC::Signal3<void,std::string,std::string,void*> NameChanged ;
+ sigc::signal<void,std::string,std::string,void*> NameChanged ;
/** Emitted when an ImageFrameView is added to this group */
- SigC::Signal2<void, ImageFrameView*, void*> ImageFrameAdded ;
+ sigc::signal<void, ImageFrameView*, void*> ImageFrameAdded ;
/** Emitted when an ImageFrameView is removed from this group */
- SigC::Signal4<void, std::string&, std::string&, std::string&, void*> ImageFrameRemoved ;
+ sigc::signal<void, std::string&, std::string&, std::string&, void*> ImageFrameRemoved ;
protected:
#include <algorithm>
-#include <gtk--.h>
+#include <gtkmm.h>
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm2ext/gtk_ui.h>
#include "imageframe_time_axis_view.h"
#include "imageframe_time_axis_group.h"
#include <list>
#include <cmath>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <gtk-canvas.h>
#include <jack/jack.h>
* maintains the list of items that have been added to it
*
*/
-class ImageFrameTimeAxisView : public SigC::Object
+class ImageFrameTimeAxisView : public sigc::trackable
{
public:
//---------------------------------------------------------------------------------------//
// Emitted Signals
/** Emitted when and ImageFrameGroup is added to this time axis */
- SigC::Signal2<void,ImageFrameTimeAxisGroup*,void*> ImageFrameGroupAdded ;
+ sigc::signal<void,ImageFrameTimeAxisGroup*,void*> ImageFrameGroupAdded ;
/** Emitted when an ImageFrameGroup is removed from this time axis */
- SigC::Signal2<void,std::string,void*> ImageFrameGroupRemoved ;
+ sigc::signal<void,std::string,void*> ImageFrameGroupRemoved ;
protected:
#include <algorithm>
#include <cmath>
-#include <gtk--.h>
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm.h>
+#include <gtkmm2ext/gtk_ui.h>
#include "imageframe_time_axis.h"
#include "imageframe_time_axis_group.h"
#include "canvas-imageframe.h"
#include "gui_thread.h"
-using namespace SigC ;
+using namespace sigc ;
using namespace ARDOUR ;
-SigC::Signal1<void,ImageFrameView*> ImageFrameView::GoingAway;
+sigc::signal<void,ImageFrameView*> ImageFrameView::GoingAway;
/**
* Constructs a new ImageFrameView upon the canvas
#define __gtk_ardour_imageframe_view_h__
#include <string>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <gtk-canvas.h>
-#include <sigc++/signal_system.h>
+#include <sigc++/signal.h>
#include <list>
#include "enums.h"
*/
~ImageFrameView() ;
- static SigC::Signal1<void,ImageFrameView*> GoingAway;
+ static sigc::signal<void,ImageFrameView*> GoingAway;
//---------------------------------------------------------------------------------------//
// Position and duration Accessors/Mutators
// Emitted Signals
/** Emitted when a marker Item is added to this Item */
- SigC::Signal2<void,MarkerView*,void*> MarkerViewAdded ;
+ sigc::signal<void,MarkerView*,void*> MarkerViewAdded ;
/** Emitted when a Marker Item is added to this Item */
- SigC::Signal2<void,MarkerView*,void*> MarkerViewRemoved ;
+ sigc::signal<void,MarkerView*,void*> MarkerViewRemoved ;
private:
/** the list of MarkerViews associated with this item */
#include <ardour/session.h>
#include <ardour/diskstream.h>
-#include <gtkmmext/doi.h>
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm2ext/doi.h>
+#include <gtkmm2ext/gtk_ui.h>
#include "utils.h"
#include "ardour_message.h"
using namespace std;
using namespace Gtk;
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
IOSelectorWindow::IOSelectorWindow (Session& sess, IO& ior, bool input, bool can_cancel)
rescan_button (_("Rescan"))
{
- add_events (GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK);
+ add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
set_name ("IOSelectorWindow");
string title;
vbox.pack_start (_selector);
vbox.pack_start (button_box, false, false);
- ok_button.clicked.connect (slot (*this, &IOSelectorWindow::accept));
- cancel_button.clicked.connect (slot (*this, &IOSelectorWindow::cancel));
- rescan_button.clicked.connect (slot (*this, &IOSelectorWindow::rescan));
+ ok_button.signal_clicked().connect (slot (*this, &IOSelectorWindow::accept));
+ cancel_button.signal_clicked().connect (slot (*this, &IOSelectorWindow::cancel));
+ rescan_button.signal_clicked().connect (slot (*this, &IOSelectorWindow::rescan));
set_title (title);
- set_position (GTK_WIN_POS_MOUSE);
+ set_position (Gtk::WIN_POS_MOUSE);
add (vbox);
delete_event.connect (bind (slot (just_hide_it), reinterpret_cast<Window *> (this)));
selected_port = 0;
notebook.set_name ("IOSelectorNotebook");
- notebook.set_usize (-1, 125);
+ notebook.set_size_request (-1, 125);
clear_connections_button.set_name ("IOSelectorButton");
add_port_button.set_name ("IOSelectorButton");
port_display_scroller.set_name ("IOSelectorNotebook");
port_display_scroller.set_border_width (0);
- port_display_scroller.set_usize (-1, 170);
+ port_display_scroller.set_size_request (-1, 170);
port_display_scroller.add_with_viewport (port_box);
- port_display_scroller.set_policy (GTK_POLICY_NEVER,
- GTK_POLICY_AUTOMATIC);
+ port_display_scroller.set_policy (Gtk::POLICY_NEVER,
+ Gtk::POLICY_AUTOMATIC);
port_button_box.set_spacing (5);
port_button_box.set_border_width (5);
rescan();
display_ports ();
- clear_connections_button.clicked.connect (slot (*this, &IOSelector::clear_connections));
+ clear_connections_button.signal_clicked().connect (slot (*this, &IOSelector::clear_connections));
- add_port_button.clicked.connect (slot (*this, &IOSelector::add_port));
- remove_port_button.clicked.connect (slot (*this, &IOSelector::remove_port));
+ add_port_button.signal_clicked().connect (slot (*this, &IOSelector::add_port));
+ remove_port_button.signal_clicked().connect (slot (*this, &IOSelector::remove_port));
if (for_input) {
io.input_changed.connect (slot (*this, &IOSelector::ports_changed));
ScrolledWindow *scroller = manage (new ScrolledWindow);
scroller->add_with_viewport (*client_port_display);
- scroller->set_policy (GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+ scroller->set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
client_box->pack_start (*scroller);
*/
clist->column(0).get_widget(); // force the column title button to be created
- GtkButton *b = GTK_BUTTON(clist->gtkobj()->column[0].button); // no API to access this
+ GtkButton *b = GTK_BUTTON(clist->gobj()->column[0].button); // no API to access this
Gtk::Button *B = wrap (b); // make C++ signal handling easier.
clist->column_titles_show ();
clist->set_name ("IOSelectorPortList");
clist->set_selection_mode (GTK_SELECTION_SINGLE);
- clist->set_shadow_type (GTK_SHADOW_IN);
- clist->set_usize (-1, 75);
+ clist->set_shadow_type (Gtk::SHADOW_IN);
+ clist->set_size_request (-1, 75);
/* now fill the clist with the current connections */
add (vbox);
- ok_button.clicked.connect (slot (*this, &PortInsertWindow::accept));
- cancel_button.clicked.connect (slot (*this, &PortInsertWindow::cancel));
- rescan_button.clicked.connect (slot (*this, &PortInsertWindow::rescan));
+ ok_button.signal_clicked().connect (slot (*this, &PortInsertWindow::accept));
+ cancel_button.signal_clicked().connect (slot (*this, &PortInsertWindow::cancel));
+ rescan_button.signal_clicked().connect (slot (*this, &PortInsertWindow::rescan));
delete_event.connect (bind (slot (just_hide_it), reinterpret_cast<Window *> (this)));
pi.GoingAway.connect (slot (*this, &PortInsertWindow::plugin_going_away));
#endif
#include <string>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <ardour_dialog.h>
Accepted
};
- SigC::Signal1<void,Result> Finished;
+ sigc::signal<void,Result> Finished;
protected:
ARDOUR::Session& session;
#include <vector>
#include <string>
-#include <sigc++/signal_system.h>
+#include <sigc++/signal.h>
#include <gtk/gtk.h>
#include <ardour/types.h>
class KeyboardTarget;
class ArdourDialog;
-class Keyboard : public SigC::Object, Stateful
+class Keyboard : public sigc::trackable, Stateful
{
public:
Keyboard ();
#include <map>
#include <string>
-#include <sigc++/signal_system.h>
+#include <sigc++/signal.h>
#include <gdk/gdk.h>
-#include <gtk--/window.h>
+#include <gtkmm/window.h>
#include <pbd/xml++.h>
#include "keyboard.h"
KeyboardTarget(Gtk::Window& w, string name);
virtual ~KeyboardTarget();
- SigC::Signal0<void> Hiding;
- SigC::Signal0<void> GoingAway;
+ sigc::signal<void> Hiding;
+ sigc::signal<void> GoingAway;
- typedef SigC::Slot0<void> KeyAction;
+ typedef sigc::slot<void> KeyAction;
string name() const { return _name; }
#include <pbd/basename.h>
#include <pbd/forkexec.h>
#include <pbd/ftw.h>
-#include <gtk--.h>
-#include <gtk--/fileselection.h>
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm.h>
+#include <gtkmm/fileselection.h>
+#include <gtkmm2ext/gtk_ui.h>
#include <ardour/audio_library.h>
#include <ardour/audioregion.h>
#include <ardour/region.h>
#include <ardour/sndfilesource.h>
#include <ardour/utils.h>
-#include <gtkmmext/doi.h>
+#include <gtkmm2ext/doi.h>
#include "ardour_ui.h"
#include "public_editor.h"
using namespace std;
using namespace ARDOUR;
using namespace Gtk;
-using namespace SigC;
+using namespace sigc;
SoundFileSelector::SoundFileSelector ()
: ArdourDialog ("sound file selector"),
delete_event.connect (slot (*this, &ArdourDialog::wm_close_event));
- import_btn.clicked.connect (slot (*this, &SoundFileSelector::import_btn_clicked));
+ import_btn.signal_clicked().connect (slot (*this, &SoundFileSelector::import_btn_clicked));
sfdb_tree.group_selected.connect (slot(*this, &SoundFileSelector::sfdb_group_selected));
sfdb_tree.member_selected.connect (bind (slot(*this, &SoundFileSelector::member_selected), true));
multiable = multi;
hide_after_action = hide_after;
- set_position (GTK_WIN_POS_MOUSE);
+ set_position (Gtk::WIN_POS_MOUSE);
ArdourDialog::run ();
}
// This is ugly ugly ugly. But gtk1 (and gtk2) don't give us any
// choice.
- GtkFileSelection* fs_gtk = fs_selector.gtkobj();
+ GtkFileSelection* fs_gtk = fs_selector.gobj();
file_list= Gtk::wrap((GtkCList*)(fs_gtk->file_list));
Gtk::VBox* vbox = manage(new Gtk::VBox);
Gtk::HBox* hbox = manage(new Gtk::HBox);
Gtk::ScrolledWindow* dir_scroll = manage(new Gtk::ScrolledWindow);
Gtk::ScrolledWindow* file_scroll = manage(new Gtk::ScrolledWindow);
- dir_scroll->set_policy(GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
- file_scroll->set_policy(GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+ dir_scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
+ file_scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
Gtk::CList* dir_list = Gtk::wrap((GtkCList*)(fs_gtk->dir_list));
dir_list->reparent(*dir_scroll);
pack_start(btn_box_bottom, false, false);
hbox.pack_start(scroll);
- scroll.set_usize (200, 150);
- scroll.set_policy (GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+ scroll.set_size_request (200, 150);
+ scroll.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
scroll.add_with_viewport(tree);
tree.set_selection_mode(GTK_SELECTION_MULTIPLE);
remove_btn.set_sensitive (false);
- add_btn.clicked.connect (slot (*this, &LibraryTree::add_btn_clicked));
- folder_btn.clicked.connect (slot(*this, &LibraryTree::folder_btn_clicked));
- remove_btn.clicked.connect (slot(*this, &LibraryTree::remove_btn_clicked));
- find_btn.clicked.connect (slot (*this, &LibraryTree::find_btn_clicked));
+ add_btn.signal_clicked().connect (slot (*this, &LibraryTree::add_btn_clicked));
+ folder_btn.signal_clicked().connect (slot(*this, &LibraryTree::folder_btn_clicked));
+ remove_btn.signal_clicked().connect (slot(*this, &LibraryTree::remove_btn_clicked));
+ find_btn.signal_clicked().connect (slot (*this, &LibraryTree::find_btn_clicked));
files_select.hide_fileop_buttons();
files_select.set_filename("/");
- files_select.get_ok_button()->clicked.connect (slot ( *this,
+ files_select.get_ok_button()-.signal_clicked().connect (slot ( *this,
&LibraryTree::file_ok_clicked));
- files_select.get_cancel_button()->clicked.connect (slot ( *this,
+ files_select.get_cancel_button()-.signal_clicked().connect (slot ( *this,
&LibraryTree::file_cancel_clicked));
main_box->pack_start(*bar);
Gtk::Button* cancel_btn = manage(new Gtk::Button(_("Cancel")));
main_box->pack_start(*cancel_btn);
- cancel_btn->clicked.connect (slot (*this, &LibraryTree::cancel_import_clicked));
+ cancel_btn-.signal_clicked().connect (slot (*this, &LibraryTree::cancel_import_clicked));
progress_win->show_all();
clone_ftw((void*)file);
Gtk::Main::run();
- if (prompter.status == Gtkmmext::Prompter::entered) {
+ if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result(name);
}
main_box.pack_start(bottom_box, false, false);
- fields.set_usize(200, 150);
+ fields.set_size_request(200, 150);
top_box.set_homogeneous(true);
top_box.pack_start(add_field_btn);
bottom_box.pack_start(play_btn);
bottom_box.pack_start(stop_btn);
- play_btn.clicked.connect (slot (*this, &SoundFileBox::play_btn_clicked));
- stop_btn.clicked.connect (slot (*this, &SoundFileBox::stop_btn_clicked));
+ play_btn.signal_clicked().connect (slot (*this, &SoundFileBox::play_btn_clicked));
+ stop_btn.signal_clicked().connect (slot (*this, &SoundFileBox::stop_btn_clicked));
PublicEditor& edit = ARDOUR_UI::instance()->the_editor();
ARDOUR::Session* sess = edit.current_session();
sess->AuditionActive.connect(slot (*this, &SoundFileBox::audition_status_changed));
}
- add_field_btn.clicked.connect
+ add_field_btn.signal_clicked().connect
(slot (*this, &SoundFileBox::add_field_clicked));
- remove_field_btn.clicked.connect
+ remove_field_btn.signal_clicked().connect
(slot (*this, &SoundFileBox::remove_field_clicked));
fields.selection_made.connect (slot (*this, &SoundFileBox::field_selected));
path_entry.set_text (file);
path_entry.set_position (-1);
- path_entry.focus_in_event.connect (slot (ARDOUR_UI::generic_focus_in_event));
- path_entry.focus_out_event.connect (slot (ARDOUR_UI::generic_focus_out_event));
+ path_entry.signal_focus_in_event().connect (slot (ARDOUR_UI::generic_focus_in_event));
+ path_entry.signal_focus_out_event().connect (slot (ARDOUR_UI::generic_focus_out_event));
length.set_alignment (0.0f, 0.0f);
length.set_text (compose("Length: %1", length2string(sf_info->frames, sf_info->samplerate)));
SoundFileBox::audition_status_changed (bool active)
{
if (!active) {
- Gtkmmext::UI::instance()->call_slot( slot(*this, &SoundFileBox::stop_btn_clicked));
+ Gtkmm2ext::UI::instance()->call_slot( slot(*this, &SoundFileBox::stop_btn_clicked));
}
}
Gtk::Main::run();
- if (prompter.status == Gtkmmext::Prompter::entered) {
+ if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result(name);
}
void
-SoundFileBox::field_chosen (Gtkmmext::Selector *selector, Gtkmmext::SelectionResult *res)
+SoundFileBox::field_chosen (Gtkmm2ext::Selector *selector, Gtkmm2ext::SelectionResult *res)
{
if (res) {
remove_field_btn.set_sensitive(true);
}
void
-SoundFileBox::field_selected (Gtkmmext::Selector *selector, Gtkmmext::SelectionResult *res)
+SoundFileBox::field_selected (Gtkmm2ext::Selector *selector, Gtkmm2ext::SelectionResult *res)
{
if (!res){
return;
Gtk::Main::run();
- if (prompter.status == Gtkmmext::Prompter::entered) {
+ if (prompter.status == Gtkmm2ext::Prompter::entered) {
string data;
prompter.get_result(data);
bottom_box.set_homogeneous(true);
bottom_box.pack_start(find_btn);
- fields.set_usize(200, 150);
+ fields.set_size_request(200, 150);
main_box.pack_start(fields);
main_box.pack_start(rbtn_box, false, false);
delete_event.connect (slot (*this, &ArdourDialog::wm_doi_event));
- find_btn.clicked.connect (slot (*this, &SearchSounds::find_btn_clicked));
+ find_btn.signal_clicked().connect (slot (*this, &SearchSounds::find_btn_clicked));
fields.selection_made.connect (slot
(*this, &SearchSounds::field_selected));
}
void
-SearchSounds::field_selected (Gtkmmext::Selector *selector, Gtkmmext::SelectionResult *res)
+SearchSounds::field_selected (Gtkmm2ext::Selector *selector, Gtkmm2ext::SelectionResult *res)
{
if (!res){
return;
Gtk::Main::run();
- if (prompter.status == Gtkmmext::Prompter::entered) {
+ if (prompter.status == Gtkmm2ext::Prompter::entered) {
string data;
prompter.get_result(data);
main_box.pack_start(import_box, false, false);
- results.set_usize (200, 150);
+ results.set_size_request (200, 150);
import_box.set_homogeneous(true);
import_box.pack_start(import_btn);
delete_event.connect (slot (*this, &ArdourDialog::wm_doi_event));
- import_btn.clicked.connect (slot (*this, &SearchResults::import_clicked));
+ import_btn.signal_clicked().connect (slot (*this, &SearchResults::import_clicked));
results.choice_made.connect (slot (*this, &SearchResults::result_chosen));
}
void
-SearchResults::result_chosen (Gtkmmext::Selector *selector, Gtkmmext::SelectionResult *res)
+SearchResults::result_chosen (Gtkmm2ext::Selector *selector, Gtkmm2ext::SelectionResult *res)
{
if (res) {
selection = selector->clist().row(res->row)[1].get_text();
#include <sys/stat.h>
#include <sys/types.h>
-#include <sigc++/signal_system.h>
-#include <gtk--.h>
-#include <gtkmmext/selector.h>
+#include <sigc++/signal.h>
+#include <gtkmm.h>
+#include <gtkmm2ext/selector.h>
#include <ardour/region.h>
SoundFileBox (string uri, bool metadata);
~SoundFileBox ();
- SigC::Signal2<void, string, bool> file_chosen;
+ sigc::signal<void, string, bool> file_chosen;
private:
string uri;
Gtk::Label channels;
Gtk::Label samplerate;
- Gtkmmext::Selector fields;
+ Gtkmm2ext::Selector fields;
string selected_field;
Gtk::Frame border_frame;
void add_field_clicked ();
void remove_field_clicked ();
- void field_selected (Gtkmmext::Selector *selector,
- Gtkmmext::SelectionResult *re);
- void field_chosen (Gtkmmext::Selector *selector,
- Gtkmmext::SelectionResult *re);
+ void field_selected (Gtkmm2ext::Selector *selector,
+ Gtkmm2ext::SelectionResult *re);
+ void field_chosen (Gtkmm2ext::Selector *selector,
+ Gtkmm2ext::SelectionResult *re);
void audition_status_changed (bool state);
};
SearchSounds ();
~SearchSounds ();
- SigC::Signal2<void, string, bool> file_chosen;
+ sigc::signal<void, string, bool> file_chosen;
private:
Gtk::Button find_btn;
Gtk::RadioButton and_rbtn;
Gtk::RadioButton or_rbtn;
- Gtkmmext::Selector fields;
+ Gtkmm2ext::Selector fields;
string selected_field;
Gtk::VBox main_box;
void fields_refiller (Gtk::CList &clist);
void setup_fields ();
- void field_selected (Gtkmmext::Selector *selector,
- Gtkmmext::SelectionResult *re);
+ void field_selected (Gtkmm2ext::Selector *selector,
+ Gtkmm2ext::SelectionResult *re);
void find_btn_clicked ();
SearchResults (map<string,string> field_values, bool and_search);
~SearchResults ();
- SigC::Signal2<void, string, bool> file_chosen;
+ sigc::signal<void, string, bool> file_chosen;
private:
map<string,string> search_info;
SoundFileBox* info_box;
- Gtkmmext::Selector results;
+ Gtkmm2ext::Selector results;
static void _results_refiller (Gtk::CList &list, void* arg);
void results_refiller (Gtk::CList &clist);
void import_clicked ();
- void result_chosen (Gtkmmext::Selector *selector,
- Gtkmmext::SelectionResult *re);
+ void result_chosen (Gtkmm2ext::Selector *selector,
+ Gtkmm2ext::SelectionResult *re);
};
class LibraryTree : public Gtk::VBox
LibraryTree ();
~LibraryTree ();
- SigC::Signal2<void, string, bool> file_chosen;
- SigC::Signal0<void> group_selected;
- SigC::Signal1<void, string> member_selected;
- SigC::Signal0<void> member_deselected;
- SigC::Signal0<void> deselected;
+ sigc::signal<void, string, bool> file_chosen;
+ sigc::signal<void> group_selected;
+ sigc::signal<void, string> member_selected;
+ sigc::signal<void> member_deselected;
+ sigc::signal<void> deselected;
list<string> selection;
void clear_selection ();
SoundFileBrowser ();
~SoundFileBrowser ();
- SigC::Signal0<void> group_selected;
- SigC::Signal1<void, string> member_selected;
- SigC::Signal0<void> member_deselected;
- SigC::Signal0<void> deselected;
+ sigc::signal<void> group_selected;
+ sigc::signal<void, string> member_selected;
+ sigc::signal<void> member_deselected;
+ sigc::signal<void> deselected;
list<RowTaggedString> selection;
void clear_selection ();
void get_result (vector<string>& paths, bool& split);
void hide_import_stuff();
- SigC::Signal2<void,vector<string>,bool> Action;
+ sigc::signal<void,vector<string>,bool> Action;
private:
bool multiable;
#include <cmath>
#include <cstdlib>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/stop_signal.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/stop_signal.h>
#include <ardour/utils.h>
#include <ardour/configuration.h>
using namespace ARDOUR;
using namespace Gtk;
-using namespace Gtkmmext;
+using namespace Gtkmm2ext;
LocationEditRow::LocationEditRow(Session * sess, Location * loc, int32_t num)
: location(0), session(0),
isrc_label.set_text ("ISRC: ");
- isrc_label.set_usize (30, -1);
+ isrc_label.set_size_request (30, -1);
performer_label.set_text ("Performer: ");
- performer_label.set_usize (60, -1);
+ performer_label.set_size_request (60, -1);
composer_label.set_text ("Composer: ");
- composer_label.set_usize (60, -1);
+ composer_label.set_size_request (60, -1);
- isrc_entry.set_usize (112, -1);
+ isrc_entry.set_size_request (112, -1);
isrc_entry.set_max_length(12);
isrc_entry.set_editable (true);
- performer_entry.set_usize (100, -1);
+ performer_entry.set_size_request (100, -1);
performer_entry.set_editable (true);
- composer_entry.set_usize (100, -1);
+ composer_entry.set_size_request (100, -1);
composer_entry.set_editable (true);
cd_track_details_hbox.pack_start (isrc_label, false, false);
cd_track_details_hbox.pack_start (composer_entry, true, true);
isrc_entry.changed.connect (slot (*this, &LocationEditRow::isrc_entry_changed));
- isrc_entry.focus_in_event.connect (slot (*this, &LocationEditRow::entry_focus_event));
- isrc_entry.focus_out_event.connect (slot (*this, &LocationEditRow::entry_focus_event));
+ isrc_entry.signal_focus_in_event().connect (slot (*this, &LocationEditRow::entry_focus_event));
+ isrc_entry.signal_focus_out_event().connect (slot (*this, &LocationEditRow::entry_focus_event));
performer_entry.changed.connect (slot (*this, &LocationEditRow::performer_entry_changed));
- performer_entry.focus_in_event.connect (slot (*this, &LocationEditRow::entry_focus_event));
- performer_entry.focus_out_event.connect (slot (*this, &LocationEditRow::entry_focus_event));
+ performer_entry.signal_focus_in_event().connect (slot (*this, &LocationEditRow::entry_focus_event));
+ performer_entry.signal_focus_out_event().connect (slot (*this, &LocationEditRow::entry_focus_event));
composer_entry.changed.connect (slot (*this, &LocationEditRow::composer_entry_changed));
- composer_entry.focus_in_event.connect (slot (*this, &LocationEditRow::entry_focus_event));
- composer_entry.focus_out_event.connect (slot (*this, &LocationEditRow::entry_focus_event));
+ composer_entry.signal_focus_in_event().connect (slot (*this, &LocationEditRow::entry_focus_event));
+ composer_entry.signal_focus_out_event().connect (slot (*this, &LocationEditRow::entry_focus_event));
scms_check_button.toggled.connect(slot (*this, &LocationEditRow::scms_toggled));
preemph_check_button.toggled.connect(slot (*this, &LocationEditRow::preemph_toggled));
// item_table.attach (length_clock, 3, 4, 0, 1, 0, 0, 4, 0);
length_clock.ValueChanged.connect (bind ( slot (*this, &LocationEditRow::clock_changed), LocLength));
-// item_table.attach (cd_check_button, 4, 5, 0, 1, 0, GTK_FILL, 4, 0);
-// item_table.attach (hide_check_button, 5, 6, 0, 1, 0, GTK_FILL, 4, 0);
-// item_table.attach (remove_button, 7, 8, 0, 1, 0, GTK_FILL, 4, 0);
+// item_table.attach (cd_check_button, 4, 5, 0, 1, 0, Gtk::FILL, 4, 0);
+// item_table.attach (hide_check_button, 5, 6, 0, 1, 0, Gtk::FILL, 4, 0);
+// item_table.attach (remove_button, 7, 8, 0, 1, 0, Gtk::FILL, 4, 0);
cd_check_button.toggled.connect(slot (*this, &LocationEditRow::cd_toggled));
hide_check_button.toggled.connect(slot (*this, &LocationEditRow::hide_toggled));
if (!location) return;
if (!hide_check_button.get_parent()) {
- item_table.attach (hide_check_button, 6, 7, 0, 1, 0, GTK_FILL, 4, 0);
+ item_table.attach (hide_check_button, 6, 7, 0, 1, 0, Gtk::FILL, 4, 0);
}
hide_check_button.set_active (location->is_hidden());
// use label instead of entry
name_label.set_text (location->name());
- name_label.set_usize (80, -1);
+ name_label.set_size_request (80, -1);
if (!name_label.get_parent()) {
- item_table.attach (name_label, 1, 2, 0, 1, 0, GTK_FILL, 4, 0);
+ item_table.attach (name_label, 1, 2, 0, 1, 0, Gtk::FILL, 4, 0);
}
name_label.show();
} else {
name_entry.set_text (location->name());
- name_entry.set_usize (100, -1);
+ name_entry.set_size_request (100, -1);
name_entry.set_editable (true);
name_entry.changed.connect (slot (*this, &LocationEditRow::name_entry_changed));
- name_entry.focus_in_event.connect (slot (*this, &LocationEditRow::entry_focus_event));
- name_entry.focus_out_event.connect (slot (*this, &LocationEditRow::entry_focus_event));
+ name_entry.signal_focus_in_event().connect (slot (*this, &LocationEditRow::entry_focus_event));
+ name_entry.signal_focus_out_event().connect (slot (*this, &LocationEditRow::entry_focus_event));
if (!name_entry.get_parent()) {
- item_table.attach (name_entry, 1, 2, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL, 4, 0);
+ item_table.attach (name_entry, 1, 2, 0, 1, Gtk::FILL | Gtk::EXPAND, Gtk::FILL, 4, 0);
}
name_entry.show();
if (!cd_check_button.get_parent()) {
- item_table.attach (cd_check_button, 5, 6, 0, 1, 0, GTK_FILL, 4, 0);
+ item_table.attach (cd_check_button, 5, 6, 0, 1, 0, Gtk::FILL, 4, 0);
}
if (!remove_button.get_parent()) {
- item_table.attach (remove_button, 7, 8, 0, 1, 0, GTK_FILL, 4, 0);
+ item_table.attach (remove_button, 7, 8, 0, 1, 0, Gtk::FILL, 4, 0);
}
/* XXX i can't find a way to hide the button without messing up
}
if(!cd_track_details_hbox.get_parent()) {
- item_table.attach (cd_track_details_hbox, 1, 8, 1, 2, GTK_FILL | GTK_EXPAND, 0, 4, 0);
+ item_table.attach (cd_track_details_hbox, 1, 8, 1, 2, Gtk::FILL | Gtk::EXPAND, 0, 4, 0);
}
// item_table.resize(2, 7);
cd_track_details_hbox.show_all();
location_rows.set_name("LocationLocRows");
location_rows_scroller.add_with_viewport (location_rows);
location_rows_scroller.set_name ("LocationLocRowsScroller");
- location_rows_scroller.set_policy (GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
- location_rows_scroller.set_usize (-1, 130);
+ location_rows_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
+ location_rows_scroller.set_size_request (-1, 130);
loc_frame_box.set_spacing (5);
loc_frame_box.set_border_width (5);
range_rows.set_name("LocationRangeRows");
range_rows_scroller.add_with_viewport (range_rows);
range_rows_scroller.set_name ("LocationRangeRowsScroller");
- range_rows_scroller.set_policy (GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
- range_rows_scroller.set_usize (-1, 130);
+ range_rows_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
+ range_rows_scroller.set_size_request (-1, 130);
range_frame_box.set_spacing (5);
range_frame_box.set_name("LocationFrameBox");
location_hpacker.pack_start (location_vpacker, true, true);
- add_location_button.clicked.connect (slot (*this, &LocationUI::add_new_location));
- add_range_button.clicked.connect (slot (*this, &LocationUI::add_new_range));
+ add_location_button.signal_clicked().connect (slot (*this, &LocationUI::add_new_location));
+ add_range_button.signal_clicked().connect (slot (*this, &LocationUI::add_new_range));
- //add_events (GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK|GDK_BUTTON_RELEASE_MASK);
+ //add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::BUTTON_RELEASE_MASK);
}
#ifndef __ardour_location_ui_h__
#define __ardour_location_ui_h__
-#include <gtk--.h>
+#include <gtkmm.h>
#include <ardour/location.h>
#include <ardour/session.h>
void set_number (int);
- SigC::Signal1<void,ARDOUR::Location*> remove_requested;
- SigC::Signal0<void> redraw_ranges;
+ sigc::signal<void,ARDOUR::Location*> remove_requested;
+ sigc::signal<void> redraw_ranges;
protected:
void location_changed (ARDOUR::Location *);
void flags_changed (ARDOUR::Location *, void *src);
- SigC::Connection start_changed_connection;
- SigC::Connection end_changed_connection;
- SigC::Connection name_changed_connection;
- SigC::Connection changed_connection;
- SigC::Connection flags_changed_connection;
+ sigc::connection start_changed_connection;
+ sigc::connection end_changed_connection;
+ sigc::connection name_changed_connection;
+ sigc::connection changed_connection;
+ sigc::connection flags_changed_connection;
};
#include <ardour/ardour.h>
#include <ardour/audioengine.h>
-#include <gtk--/main.h>
-#include <gtkmmext/popup.h>
-#include <gtkmmext/utils.h>
+#include <gtkmm/main.h>
+#include <gtkmm2ext/popup.h>
+#include <gtkmm2ext/utils.h>
#include "version.h"
#include "ardour_ui.h"
using namespace Gtk;
using namespace GTK_ARDOUR;
using namespace ARDOUR;
-using namespace SigC;
+using namespace sigc;
Transmitter error (Transmitter::Error);
Transmitter info (Transmitter::Info);
win.set_border_width (7);
win.add (vpacker);
win.show_all ();
- win.delete_event.connect (SigC::slot (jack_fooey));
- win.add_events (GDK_BUTTON_RELEASE_MASK|GDK_BUTTON_PRESS_MASK);
+ win.delete_event.connect (sigc::ptr_fun (jack_fooey));
+ win.add_events (Gdk::BUTTON_RELEASE_MASK|Gdk::BUTTON_PRESS_MASK);
win.set_position (GTK_WIN_POS_CENTER);
win.realize ();
win.get_window().set_decorations (GdkWMDecoration (GDK_DECOR_BORDER|GDK_DECOR_RESIZEH));
- ok.clicked.connect (SigC::slot (jack_foobar));
+ ok.signal_clicked().connect (sigc::ptr_fun (jack_foobar));
ok.grab_focus ();
#include <glib.h>
#include <ardour/ardour.h>
#include <gtk-canvas.h>
-#include <sigc++/signal_system.h>
+#include <sigc++/signal.h>
namespace ARDOUR {
class TempoSection;
class PublicEditor;
-class Marker : public SigC::Object
+class Marker : public sigc::trackable
{
public:
enum Type {
#include <pbd/error.h>
-#include <gtkmmext/utils.h>
+#include <gtkmm2ext/utils.h>
#include <ardour/session.h>
#include <ardour/utils.h>
#include "i18n.h"
using namespace ARDOUR;
-using namespace SigC;
+using namespace sigc;
using namespace Gtk;
//---------------------------------------------------------------------------------------//
name_prompter->hide_all ();
ARDOUR_UI::instance()->allow_focus (false);
- if (name_prompter->status == Gtkmmext::Prompter::cancelled) {
+ if (name_prompter->status == Gtkmm2ext::Prompter::cancelled) {
return;
}
#ifndef __ardour_marker_time_axis_h__
#define __ardour_marker_time_axis_h__
-#include <gtk--.h>
+#include <gtkmm.h>
#include <gtk-canvas.h>
#include "ardour_dialog.h"
#include <algorithm>
-#include <gtk--.h>
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm.h>
+#include <gtkmm2ext/gtk_ui.h>
#include "marker_time_axis_view.h"
#include "marker_time_axis.h"
#include <list>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <gtk-canvas.h>
#include <ardour/location.h>
* This object is responsible for the time axis canvas view, and
* maintains the list of items that have been added to it
*/
-class MarkerTimeAxisView : public SigC::Object
+class MarkerTimeAxisView : public sigc::trackable
{
public:
//---------------------------------------------------------------------------------------//
// Emitted Signals
/** Emitted when a MarkerView is Added */
- SigC::Signal2<void,MarkerView*,void*> MarkerViewAdded ;
+ sigc::signal<void,MarkerView*,void*> MarkerViewAdded ;
/** Emitted when a MarkerView Item is removed */
- SigC::Signal2<void,std::string,void*> MarkerViewRemoved ;
+ sigc::signal<void,std::string,void*> MarkerViewRemoved ;
private:
/**
$Id$
*/
-#include <gtk--.h>
+#include <gtkmm.h>
#include "imageframe_time_axis.h"
#include "imageframe_view.h"
#include "marker_view.h"
using namespace ARDOUR ;
-using namespace SigC;
+using namespace sigc;
-SigC::Signal1<void,MarkerView*> MarkerView::GoingAway;
+sigc::signal<void,MarkerView*> MarkerView::GoingAway;
//---------------------------------------------------------------------------------------//
// Constructor / Desctructor
#define __gtk_ardour_marker_view_h__
#include <string>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <gtk-canvas.h>
#include "time_axis_view_item.h"
*/
~MarkerView() ;
- static SigC::Signal1<void,MarkerView*> GoingAway;
+ static sigc::signal<void,MarkerView*> GoingAway;
//---------------------------------------------------------------------------------------//
// Marker Type Methods
// Emitted Signals
/** Emitted when the mark type text is changed */
- SigC::Signal2<void,std::string,void*> MarkTypeChanged ;
+ sigc::signal<void,std::string,void*> MarkTypeChanged ;
/** Emitted when the Marked Item is changed */
- SigC::Signal2<void,ImageFrameView*,void*> MarkedItemChanged ;
+ sigc::signal<void,ImageFrameView*,void*> MarkedItemChanged ;
protected:
using namespace ARDOUR;
using namespace Gtk;
-using namespace SigC;
+using namespace sigc;
-#define FRAME_SHADOW_STYLE GTK_SHADOW_IN
+#define FRAME_SHADOW_STYLE Gtk::SHADOW_IN
#define FRAME_NAME "BaseFrame"
MeterBridge::MeterBridge ()
meter_scroller.add (meter_viewport);
meter_scroller.set_name ("MeterBridgeWindow");
- meter_scroller.set_policy (GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+ meter_scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
meter_scroller.set_border_width (5);
add (meter_scroller);
- add_events (GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK);
+ add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
set_name ("MeterBridgeWindow");
set_title (_("ardour: meter bridge"));
set_wmclass (_("ardour_meter_bridge"), "Ardour");
#include <list>
-#include <gtk--/eventbox.h>
-#include <gtk--/viewport.h>
-#include <gtk--/scrolledwindow.h>
-#include <gtk--/box.h>
-#include <gtk--/fixed.h>
-#include <gtk--/frame.h>
+#include <gtkmm/eventbox.h>
+#include <gtkmm/viewport.h>
+#include <gtkmm/scrolledwindow.h>
+#include <gtkmm/box.h>
+#include <gtkmm/fixed.h>
+#include <gtkmm/frame.h>
#include "keyboard_target.h"
#include "ardour_dialog.h"
list<MeterBridgeStrip*> meters;
bool metering;
- SigC::Connection metering_connection;
+ sigc::connection metering_connection;
void update ();
#include <pbd/pathscanner.h>
#include <pbd/fastlog.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/selector.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/selector.h>
#include <ardour/audioengine.h>
#include <ardour/route.h>
using namespace ARDOUR;
using namespace Gtk;
-using namespace Gtkmmext;
+using namespace Gtkmm2ext;
MeterBridgeStrip::MeterBridgeStrip (AudioEngine &eng,
Session& s,
label.set_name ("ChannelMeterLabel");
label_ebox.set_name ("MeterBridgeWindow");
- label_ebox.set_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK);
+ label_ebox.set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK);
label_ebox.add (label);
label_ebox.button_release_event.connect (slot (*this, &MeterBridgeStrip::label_button_press_release));
over_long_button.add (over_long_label);
over_long_button.set_name ("OverMeter");
over_long_frame.add (over_long_button);
- over_long_frame.set_shadow_type (GTK_SHADOW_IN);
+ over_long_frame.set_shadow_type (Gtk::SHADOW_IN);
over_long_frame.set_name ("BaseFrame");
over_long_hbox.pack_start (over_long_frame, false, false);
snprintf(buf, sizeof(buf)-1, _("# of %u-sample overs"), long_over);
ARDOUR_UI::instance()->tooltips().set_tip (over_long_button, buf);
- set_usize_to_display_given_text (over_long_button, "88g", 2, 2);
+ set_size_request_to_display_given_text (over_long_button, "88g", 2, 2);
over_short_label.set_text ("0");
over_short_label.set_name ("OverMeterLabel");
over_short_button.add (over_short_label);
over_short_button.set_name ("OverMeter");
over_short_frame.add (over_short_button);
- over_short_frame.set_shadow_type (GTK_SHADOW_IN);
+ over_short_frame.set_shadow_type (Gtk::SHADOW_IN);
over_short_frame.set_name ("BaseFrame");
over_short_hbox.pack_start (over_short_frame, false, false);
snprintf(buf, sizeof(buf)-1, _("# of %u-sample overs"), short_over);
ARDOUR_UI::instance()->tooltips().set_tip (over_short_button, buf);
- set_usize_to_display_given_text (over_short_button, "88g", 2, 2);
+ set_size_request_to_display_given_text (over_short_button, "88g", 2, 2);
above_meter_vbox.set_spacing (5);
below_meter_vbox.set_spacing (5);
Gtk::Main::run();
- if (prompter.status == Gtkmmext::Prompter::entered) {
+ if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result (name);
#ifndef __ardour_meterbridgestrip_h__
#define __ardour_meterbridgestrip_h__
-#include <sigc++/signal_system.h>
-#include <gtk--.h>
-#include <gtkmmext/fastmeter.h>
+#include <sigc++/signal.h>
+#include <gtkmm.h>
+#include <gtkmm2ext/fastmeter.h>
namespace ARDOUR {
class AudioEngine;
class Route;
}
-namespace Gtkmmext {
+namespace Gtkmm2ext {
class Selector;
struct SelectionResult;
}
-class MeterBridgeStrip : public SigC::Object
+class MeterBridgeStrip : public sigc::trackable
{
public:
bool meter_clear_pending;
bool over_clear_pending;
- Gtkmmext::FastMeter meter;
+ Gtkmm2ext::FastMeter meter;
bool meter_on;
Gtk::VBox above_meter_vbox;
#include <sigc++/bind.h>
-#include <gtkmmext/gtk_ui.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/choice.h>
-#include <gtkmmext/slider_controller.h>
-#include <gtkmmext/stop_signal.h>
-#include <gtkmmext/bindable_button.h>
-#include <gtkmmext/doi.h>
+#include <gtkmm2ext/gtk_ui.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/choice.h>
+#include <gtkmm2ext/slider_controller.h>
+#include <gtkmm2ext/stop_signal.h>
+#include <gtkmm2ext/bindable_button.h>
+#include <gtkmm2ext/doi.h>
#include <ardour/ardour.h>
#include <ardour/session.h>
#include "i18n.h"
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;
-using namespace Gtkmmext;
+using namespace Gtkmm2ext;
/* XPM */
static const gchar * small_x_xpm[] = {
ignore_speed_adjustment = false;
comment_window = 0;
- width_button.add (*(manage (new Gtk::Pixmap (lr_xpm))));
- hide_button.add (*(manage (new Gtk::Pixmap (small_x_xpm))));
+ width_button.add (*(manage (new Gtk::Image (lr_xpm))));
+ hide_button.add (*(manage (new Gtk::Image (small_x_xpm))));
input_label.set_text (_("INPUT"));
output_label.set_name ("MixerIOButtonLabel");
rec_enable_button->set_name ("MixerRecordEnableButton");
- rec_enable_button->unset_flags (GTK_CAN_FOCUS);
+ rec_enable_button->unset_flags (Gtk::CAN_FOCUS);
solo_button->set_name ("MixerSoloButton");
mute_button->set_name ("MixerMuteButton");
hide_button.set_events (hide_button.get_events() & ~(GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK));
- width_button.unset_flags (GTK_CAN_FOCUS);
- hide_button.unset_flags (GTK_CAN_FOCUS);
- input_button.unset_flags (GTK_CAN_FOCUS);
- output_button.unset_flags (GTK_CAN_FOCUS);
- solo_button->unset_flags (GTK_CAN_FOCUS);
- mute_button->unset_flags (GTK_CAN_FOCUS);
- gain_automation_style_button.unset_flags (GTK_CAN_FOCUS);
- gain_automation_state_button.unset_flags (GTK_CAN_FOCUS);
- pan_automation_style_button.unset_flags (GTK_CAN_FOCUS);
- pan_automation_state_button.unset_flags (GTK_CAN_FOCUS);
- polarity_button.unset_flags (GTK_CAN_FOCUS);
+ width_button.unset_flags (Gtk::CAN_FOCUS);
+ hide_button.unset_flags (Gtk::CAN_FOCUS);
+ input_button.unset_flags (Gtk::CAN_FOCUS);
+ output_button.unset_flags (Gtk::CAN_FOCUS);
+ solo_button->unset_flags (Gtk::CAN_FOCUS);
+ mute_button->unset_flags (Gtk::CAN_FOCUS);
+ gain_automation_style_button.unset_flags (Gtk::CAN_FOCUS);
+ gain_automation_state_button.unset_flags (Gtk::CAN_FOCUS);
+ pan_automation_style_button.unset_flags (Gtk::CAN_FOCUS);
+ pan_automation_state_button.unset_flags (Gtk::CAN_FOCUS);
+ polarity_button.unset_flags (Gtk::CAN_FOCUS);
button_table.set_homogeneous (true);
speed_adjustment.value_changed.connect (slot (*this, &MixerStrip::speed_adjustment_changed));
speed_frame.set_name ("BaseFrame");
- speed_frame.set_shadow_type (GTK_SHADOW_IN);
+ speed_frame.set_shadow_type (Gtk::SHADOW_IN);
speed_frame.add (speed_spinner);
speed_spinner.set_print_func (speed_printer, 0);
name_button.add (name_label);
name_button.set_name ("MixerNameButton");
- Gtkmmext::set_usize_to_display_given_text (name_button, "longest label", 2, 2);
+ Gtkmm2ext::set_size_request_to_display_given_text (name_button, "longest label", 2, 2);
name_label.set_name ("MixerNameButtonLabel");
name_label.set_text (_route.name());
ARDOUR_UI::instance()->tooltips().set_tip (comment_button, _route.comment()=="" ?
_("click to add/edit comments"):
_route.comment());
- comment_button.clicked.connect (slot (*this, &MixerStrip::comment_button_clicked));
+ comment_button.signal_clicked().connect (slot (*this, &MixerStrip::comment_button_clicked));
global_vpacker.set_border_width (4);
global_vpacker.set_spacing (4);
width_button.set_name ("MixerWidthButton");
hide_button.set_name ("MixerHideButton");
- width_button.clicked.connect (slot (*this, &MixerStrip::width_clicked));
- hide_button.clicked.connect (slot (*this, &MixerStrip::hide_clicked));
+ width_button.signal_clicked().connect (slot (*this, &MixerStrip::width_clicked));
+ hide_button.signal_clicked().connect (slot (*this, &MixerStrip::hide_clicked));
width_hide_box.pack_start (width_button, false, true);
width_hide_box.pack_end (hide_button, false, true);
global_vpacker.pack_start (comment_button, false, false);
global_frame.add (global_vpacker);
- global_frame.set_shadow_type (GTK_SHADOW_IN);
+ global_frame.set_shadow_type (Gtk::SHADOW_IN);
global_frame.set_name ("BaseFrame");
add (global_frame);
update_input_display ();
update_output_display ();
- add_events (GDK_BUTTON_RELEASE_MASK);
+ add_events (Gdk::BUTTON_RELEASE_MASK);
}
MixerStrip::~MixerStrip ()
switch (w) {
case Wide:
- set_usize (-1, -1);
+ set_size_request (-1, -1);
xml_node->add_property ("strip_width", "wide");
static_cast<Gtk::Label*> (rec_enable_button->get_child())->set_text (_("RECORD"));
static_cast<Gtk::Label*> (pan_automation_style_button.get_child())->set_text (astyle_string(_route.panner().automation_style()));
static_cast<Gtk::Label*> (pan_automation_state_button.get_child())->set_text (astate_string(_route.panner().automation_state()));
static_cast<Gtk::Label*> (polarity_button.get_child())->set_text (_("polarity"));
- Gtkmmext::set_usize_to_display_given_text (name_button, "long", 2, 2);
+ Gtkmm2ext::set_size_request_to_display_given_text (name_button, "long", 2, 2);
break;
case Narrow:
- set_usize (50, -1);
+ set_size_request (50, -1);
xml_node->add_property ("strip_width", "narrow");
static_cast<Gtk::Label*> (rec_enable_button->get_child())->set_text (_("REC"));
static_cast<Gtk::Label*> (pan_automation_style_button.get_child())->set_text (short_astyle_string(_route.panner().automation_style()));
static_cast<Gtk::Label*> (pan_automation_state_button.get_child())->set_text (short_astate_string(_route.panner().automation_state()));
static_cast<Gtk::Label*> (polarity_button.get_child())->set_text (_("pol"));
- Gtkmmext::set_usize_to_display_given_text (name_button, "longest label", 2, 2);
+ Gtkmm2ext::set_size_request_to_display_given_text (name_button, "longest label", 2, 2);
break;
}
void
MixerStrip::diskstream_changed (void *src)
{
- Gtkmmext::UI::instance()->call_slot (slot (*this, &MixerStrip::update_diskstream_display));
+ Gtkmm2ext::UI::instance()->call_slot (slot (*this, &MixerStrip::update_diskstream_display));
}
void
void
MixerStrip::input_changed (IOChange change, void *src)
{
- Gtkmmext::UI::instance()->call_slot (slot (*this, &MixerStrip::update_input_display));
+ Gtkmm2ext::UI::instance()->call_slot (slot (*this, &MixerStrip::update_input_display));
}
void
MixerStrip::output_changed (IOChange change, void *src)
{
- Gtkmmext::UI::instance()->call_slot (slot (*this, &MixerStrip::update_output_display));
+ Gtkmm2ext::UI::instance()->call_slot (slot (*this, &MixerStrip::update_output_display));
}
void
if (comment_window->is_visible()) {
comment_window->hide ();
} else {
- comment_window->set_position (GTK_WIN_POS_MOUSE);
+ comment_window->set_position (Gtk::WIN_POS_MOUSE);
comment_window->show_all ();
}
}
comment_area.set_name ("MixerTrackCommentArea");
comment_area.set_editable (true);
- comment_area.focus_in_event.connect (slot (ARDOUR_UI::generic_focus_in_event));
- comment_area.focus_out_event.connect (slot (ARDOUR_UI::generic_focus_out_event));
+ comment_area.signal_focus_in_event().connect (slot (ARDOUR_UI::generic_focus_in_event));
+ comment_area.signal_focus_out_event().connect (slot (ARDOUR_UI::generic_focus_out_event));
comment_area.changed.connect (slot (*this, &MixerStrip::comment_edited));
comment_area.button_release_event.connect_after (slot (do_not_propagate));
comment_area.show ();
name_button.ensure_style ();
style = name_button.get_style()->copy();
- style->set_bg (GTK_STATE_NORMAL, color());
+ style->set_bg (Gtk::STATE_NORMAL, color());
name_button.set_style (*style);
style->unref();
void
MixerStrip::speed_changed ()
{
- Gtkmmext::UI::instance()->call_slot (slot (*this, &MixerStrip::update_speed_display));
+ Gtkmm2ext::UI::instance()->call_slot (slot (*this, &MixerStrip::update_speed_display));
}
void
global_frame.set_shadow_type (GTK_SHADOW_ETCHED_OUT);
global_frame.set_name ("MixerStripSelectedFrame");
} else {
- global_frame.set_shadow_type (GTK_SHADOW_IN);
+ global_frame.set_shadow_type (Gtk::SHADOW_IN);
global_frame.set_name ("MixerStripFrame");
}
global_frame.queue_draw ();
#include <vector>
#include <cmath>
-#include <gtk--.h>
-#include <gtkmmext/auto_spin.h>
-#include <gtkmmext/slider_controller.h>
-#include <gtkmmext/click_box.h>
+#include <gtkmm.h>
+#include <gtkmm2ext/auto_spin.h>
+#include <gtkmm2ext/slider_controller.h>
+#include <gtkmm2ext/click_box.h>
#include <ardour/types.h>
#include <ardour/ardour.h>
class MotionController;
-namespace Gtkmmext {
+namespace Gtkmm2ext {
class SliderController;
}
Gtk::ToggleButton polarity_button;
- SigC::Connection newplug_connection;
+ sigc::connection newplug_connection;
gint mark_update_safe ();
guint32 mode_switch_in_progress;
void gain_automation_style_changed();
void pan_automation_style_changed();
- SigC::Connection panstate_connection;
- SigC::Connection panstyle_connection;
+ sigc::connection panstate_connection;
+ sigc::connection panstyle_connection;
void connect_to_pan ();
std::string astate_string (ARDOUR::AutoState);
/* speed control (for tracks only) */
Gtk::Adjustment speed_adjustment;
- Gtkmmext::ClickBox speed_spinner;
+ Gtkmm2ext::ClickBox speed_spinner;
Gtk::Label speed_label;
Gtk::Frame speed_frame;
void map_frozen ();
void hide_redirect_editor (ARDOUR::Redirect* redirect);
- SigC::Connection gain_watching;
- SigC::Connection pan_watching;
+ sigc::connection gain_watching;
+ sigc::connection pan_watching;
bool ignore_speed_adjustment;
string solo_button_name () const { return "MixerSoloButton"; }
#include <sigc++/bind.h>
#include <pbd/lockmonitor.h>
-#include <gtkmmext/gtk_ui.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/stop_signal.h>
+#include <gtkmm2ext/gtk_ui.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/stop_signal.h>
#include <ardour/audioengine.h>
#include <ardour/session.h>
using namespace ARDOUR;
using namespace Gtk;
-using namespace Gtkmmext;
-using namespace SigC;
+using namespace Gtkmm2ext;
+using namespace sigc;
static const gchar* track_display_titles[] = {
N_("Strips"),
track_menu = 0;
check_pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL,
- gtk_widget_get_colormap (GTK_WIDGET(group_list.gtkobj())),
+ gtk_widget_get_colormap (GTK_WIDGET(group_list.gobj())),
&check_mask, NULL, (gchar **) check_xpm);
empty_pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL,
- gtk_widget_get_colormap (GTK_WIDGET(group_list.gtkobj())),
+ gtk_widget_get_colormap (GTK_WIDGET(group_list.gobj())),
&empty_mask, NULL, (gchar **) empty_xpm);
XMLNode* node = ARDOUR_UI::instance()->mixer_settings();
set_state (*node);
- scroller_base.add_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
+ scroller_base.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
scroller_base.set_name ("MixerWindow");
scroller_base.button_release_event.connect (slot (*this, &Mixer_UI::strip_scroller_button_release));
// add as last item of strip packer
strip_packer.pack_end (scroller_base, true, true);
scroller.add_with_viewport (strip_packer);
- scroller.set_policy (GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+ scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
track_display_list.column_titles_active();
track_display_list.set_name ("MixerTrackDisplayList");
- track_display_list.set_shadow_type (GTK_SHADOW_IN);
+ track_display_list.set_shadow_type (Gtk::SHADOW_IN);
track_display_list.set_selection_mode (GTK_SELECTION_MULTIPLE);
track_display_list.set_reorderable (true);
- track_display_list.set_usize (75, -1);
+ track_display_list.set_size_request (75, -1);
track_display_scroller.add (track_display_list);
- track_display_scroller.set_policy (GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+ track_display_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
snapshot_display.column_titles_active();
snapshot_display.set_name ("MixerSnapshotDisplayList");
- snapshot_display.set_shadow_type (GTK_SHADOW_IN);
+ snapshot_display.set_shadow_type (Gtk::SHADOW_IN);
snapshot_display.set_selection_mode (GTK_SELECTION_SINGLE);
snapshot_display.set_reorderable (true);
- snapshot_display.set_usize (75, -1);
+ snapshot_display.set_size_request (75, -1);
snapshot_display_scroller.add (snapshot_display);
- snapshot_display_scroller.set_policy (GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+ snapshot_display_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
group_list_button_label.set_text (_("Mix Groups"));
group_list_button_label.set_name ("MixerGroupTitleButton");
group_list.column_titles_hide();
group_list.set_name ("MixerGroupList");
- group_list.set_shadow_type (GTK_SHADOW_IN);
+ group_list.set_shadow_type (Gtk::SHADOW_IN);
group_list.set_selection_mode (GTK_SELECTION_MULTIPLE);
group_list.set_reorderable (false);
- group_list.set_usize (75, -1);
+ group_list.set_size_request (75, -1);
group_list.set_column_auto_resize (0, true);
group_list_scroller.add (group_list);
- group_list_scroller.set_policy (GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+ group_list_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
group_list_vbox.pack_start (group_list_button, false, false);
group_list_vbox.pack_start (group_list_scroller, true, true);
group_list.cell(0,0).set_pixmap (check_pixmap);
track_display_frame.set_name("BaseFrame");
- track_display_frame.set_shadow_type (GTK_SHADOW_IN);
+ track_display_frame.set_shadow_type (Gtk::SHADOW_IN);
track_display_frame.add(track_display_scroller);
group_list_frame.set_name ("BaseFrame");
- group_list_frame.set_shadow_type (GTK_SHADOW_IN);
+ group_list_frame.set_shadow_type (Gtk::SHADOW_IN);
group_list_frame.add (group_list_vbox);
rhs_pane1.add1 (track_display_frame);
delete_event.connect (bind (slot (just_hide_it),
static_cast<Gtk::Window *>(this)));
- add_events (GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK);
+ add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
snapshot_display.select_row.connect (slot (*this, &Mixer_UI::snapshot_display_selected));
track_display_list.row_move.connect (slot (*this, &Mixer_UI::queue_track_display_reordered));
track_display_list.click_column.connect (slot (*this, &Mixer_UI::track_column_click));
- group_list_button.clicked.connect (slot (*this, &Mixer_UI::group_list_button_clicked));
+ group_list_button.signal_clicked().connect (slot (*this, &Mixer_UI::group_list_button_clicked));
group_list.button_press_event.connect (slot (*this, &Mixer_UI::group_list_button_press_event));
group_list.select_row.connect (slot (*this, &Mixer_UI::group_selected));
group_list.unselect_row.connect (slot (*this, &Mixer_UI::group_unselected));
strip->button_release_event.connect (bind (slot (*this, &Mixer_UI::strip_button_release_event), strip));
// if (width() < gdk_screen_width()) {
-// set_usize (width() + (_strip_width == Wide ? 75 : 50), height());
+// set_size_request (width() + (_strip_width == Wide ? 75 : 50), height());
// }
}
Main::run ();
- if (prompter.status != Gtkmmext::Prompter::entered) {
+ if (prompter.status != Gtkmm2ext::Prompter::entered) {
return;
}
snprintf(buf, sizeof(buf), "%d", yoff);
geometry->add_property(X_("y_off"), string(buf));
- snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&rhs_pane1)->gtkobj()));
+ snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&rhs_pane1)->gobj()));
geometry->add_property(X_("mixer_rhs_pane1_pos"), string(buf));
- snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&rhs_pane2)->gtkobj()));
+ snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&rhs_pane2)->gobj()));
geometry->add_property(X_("mixer_rhs_pane2_pos"), string(buf));
- snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&list_hpane)->gtkobj()));
+ snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&list_hpane)->gobj()));
geometry->add_property(X_("mixer_list_hpane_pos"), string(buf));
node->add_child_nocopy (*geometry);
pos = atoi (prop->value());
}
- if ((done[0] = GTK_WIDGET(rhs_pane1.gtkobj())->allocation.height > pos)) {
+ if ((done[0] = GTK_WIDGET(rhs_pane1.gobj())->allocation.height > pos)) {
rhs_pane1.set_position (pos);
}
pos = atoi (prop->value());
}
- if ((done[1] = GTK_WIDGET(rhs_pane2.gtkobj())->allocation.height > pos)) {
+ if ((done[1] = GTK_WIDGET(rhs_pane2.gobj())->allocation.height > pos)) {
rhs_pane2.set_position (pos);
}
pos = atoi (prop->value());
}
- if ((done[2] = GTK_WIDGET(list_hpane.gtkobj())->allocation.width > pos)) {
+ if ((done[2] = GTK_WIDGET(list_hpane.gobj())->allocation.width > pos)) {
list_hpane.set_position (pos);
}
}
#include <list>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <ardour/ardour.h>
#include <ardour/stateful.h>
void disconnect_from_session ();
- SigC::Connection screen_update_connection;
+ sigc::connection screen_update_connection;
void update_strips ();
- SigC::Connection fast_screen_update_connection;
+ sigc::connection fast_screen_update_connection;
void fast_update_strips ();
void snapshot_display_selected (gint row, gint col, GdkEvent* ev);
#include "prompter.h"
#include "new_session_dialog.h"
-using namespace Gtkmmext;
+using namespace Gtkmm2ext;
using namespace Gtk;
using namespace ARDOUR;
set_name ("NewSessionDialog");
set_title (_("new session setup"));
set_wmclass (_("ardour_new_session"), "Ardour");
- set_position (GTK_WIN_POS_MOUSE);
+ set_position (Gtk::WIN_POS_MOUSE);
set_keyboard_input (true);
set_policy (false, true, false);
set_modal (true);
// template_selector.control_made.connect (
// slot (*this, &NewSessionDialog::mix_template_control));
- file_selector.cancel_button.clicked.connect (bind (slot (*this, &ArdourDialog::stop), -1));
- file_selector.op_button.clicked.connect (bind (slot (*this, &ArdourDialog::stop), 0));
+ file_selector.cancel_button.signal_clicked().connect (bind (slot (*this, &ArdourDialog::stop), -1));
+ file_selector.op_button.signal_clicked().connect (bind (slot (*this, &ArdourDialog::stop), 0));
file_selector.Expanded.connect (slot (*this, &NewSessionDialog::file_selector_expansion));
delete_event.connect (slot (*this, &ArdourDialog::wm_close_event));
}
void
-NewSessionDialog::mix_template_shift (Gtkmmext::Selector* selector, Gtkmmext::SelectionResult* res)
+NewSessionDialog::mix_template_shift (Gtkmm2ext::Selector* selector, Gtkmm2ext::SelectionResult* res)
{
if (res && res->text){
Session::delete_template(*res->text);
}
void
-NewSessionDialog::mix_template_control (Gtkmmext::Selector* selector, Gtkmmext::SelectionResult* res)
+NewSessionDialog::mix_template_control (Gtkmm2ext::Selector* selector, Gtkmm2ext::SelectionResult* res)
{
#if 0
if (res && res->text) {
Gtk::Main::run();
- if (prompter.status == Gtkmmext::Prompter::entered) {
+ if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result (name);
#ifndef __gtk_ardour_new_session_dialog_h__
#define __gtk_ardour_new_session_dialog_h__
-#include <gtk--/adjustment.h>
-#include <gtk--/radiobutton.h>
-#include <gtk--/frame.h>
-#include <gtk--/box.h>
-#include <gtk--/checkbutton.h>
+#include <gtkmm/adjustment.h>
+#include <gtkmm/radiobutton.h>
+#include <gtkmm/frame.h>
+#include <gtkmm/box.h>
+#include <gtkmm/checkbutton.h>
namespace Gtk {
class CList;
class AudioEngine;
}
-#include <gtkmmext/click_box.h>
-#include <gtkmmext/selector.h>
-#include <gtkmmext/newsavedialog.h>
+#include <gtkmm2ext/click_box.h>
+#include <gtkmm2ext/selector.h>
+#include <gtkmm2ext/newsavedialog.h>
#include "ardour_dialog.h"
class NewSessionDialog : public ArdourDialog
public:
NewSessionDialog (ARDOUR::AudioEngine&, bool startup, std::string path);
- Gtkmmext::NewSaveDialog file_selector;
+ Gtkmm2ext::NewSaveDialog file_selector;
Gtk::Combo control_out_channel_combo;
Gtk::Combo master_out_channel_combo;
Gtk::CheckButton use_control_button;
static void _mix_template_refiller (Gtk::CList &clist, void *);
void mix_template_refiller (Gtk::CList &clist);
- void mix_template_shift (Gtkmmext::Selector *, Gtkmmext::SelectionResult*);
- void mix_template_control (Gtkmmext::Selector *, Gtkmmext::SelectionResult*);
+ void mix_template_shift (Gtkmm2ext::Selector *, Gtkmm2ext::SelectionResult*);
+ void mix_template_control (Gtkmm2ext::Selector *, Gtkmm2ext::SelectionResult*);
void fixup_at_realize ();
void fixup_at_show ();
#include <ardour/auditioner.h>
#include <ardour/crossfade.h>
#include <midi++/manager.h>
-#include <gtkmmext/stop_signal.h>
-#include <gtkmmext/utils.h>
+#include <gtkmm2ext/stop_signal.h>
+#include <gtkmm2ext/utils.h>
#include "public_editor.h"
#include "mixer_ui.h"
using namespace ARDOUR;
using namespace Gtk;
using namespace Editing;
-using namespace Gtkmmext;
+using namespace Gtkmm2ext;
static const gchar *psync_strings[] = {
N_("Internal"),
set_wmclass (_("ardour_option_editor"), "Ardour");
set_name ("OptionsWindow");
- add_events (GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK);
+ add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
layer_mode_label.set_name ("OptionsLabel");
xfade_model_label.set_name ("OptionsLabel");
session_raid_entry.activate.connect (slot (*this, &OptionEditor::raid_path_changed));
- session_raid_entry.focus_in_event.connect (slot (Keyboard::the_keyboard(), &Keyboard::focus_in_handler));
- session_raid_entry.focus_out_event.connect (bind (slot (*this, &OptionEditor::focus_out_event_handler), &OptionEditor::raid_path_changed));
+ session_raid_entry.signal_focus_in_event().connect (slot (Keyboard::the_keyboard(), &Keyboard::focus_in_handler));
+ session_raid_entry.signal_focus_out_event().connect (bind (slot (*this, &OptionEditor::focus_out_event_handler), &OptionEditor::raid_path_changed));
label = manage(new Label(_("session RAID path")));
label->set_name ("OptionsLabel");
path_table.attach (*label, 0, 1, 0, 1, 0, 0);
- path_table.attach (session_raid_entry, 1, 3, 0, 1, GTK_FILL|GTK_EXPAND, 0);
+ path_table.attach (session_raid_entry, 1, 3, 0, 1, Gtk::FILL|Gtk::EXPAND, 0);
label = manage(new Label(_("Native Format")));
label->set_name ("OptionsLabel");
path_table.attach (*label, 0, 1, 1, 2, 0, 0);
- path_table.attach (native_format_combo, 1, 3, 1, 2, GTK_FILL|GTK_EXPAND, 0);
+ path_table.attach (native_format_combo, 1, 3, 1, 2, Gtk::FILL|Gtk::EXPAND, 0);
vector<string> nfstrings = internationalize (native_format_strings);
auto_xfade_button.set_active (Config->get_auto_xfade());
/* xfade and layer mode active requires session */
- auto_xfade_button.clicked.connect (slot (*this, &OptionEditor::auto_xfade_clicked));
- xfade_active_button.clicked.connect (slot (*this, &OptionEditor::xfade_active_clicked));
+ auto_xfade_button.signal_clicked().connect (slot (*this, &OptionEditor::auto_xfade_clicked));
+ xfade_active_button.signal_clicked().connect (slot (*this, &OptionEditor::xfade_active_clicked));
Label* short_xfade_label = manage (new Label (_("Short crossfade length (msecs)")));
short_xfade_label->set_name ("OptionsLabel");
hbox->pack_start (solo_latched_button, false, false);
solo_packer.pack_start (*hbox, false, false);
- solo_via_bus_button.clicked.connect
+ solo_via_bus_button.signal_clicked().connect
(slot (*this, &OptionEditor::solo_via_bus_clicked));
- solo_latched_button.clicked.connect
+ solo_latched_button.signal_clicked().connect
(slot (*this, &OptionEditor::solo_latched_clicked));
solo_packer.show_all ();
display_packer.pack_start (*hbox, false, false);
- show_waveforms_button.clicked.connect (slot (*this, &OptionEditor::show_waveforms_clicked));
- show_waveforms_recording_button.clicked.connect (slot (*this, &OptionEditor::show_waveforms_recording_clicked));
- show_measures_button.clicked.connect (slot (*this, &OptionEditor::show_measures_clicked));
- mixer_strip_width_button.clicked.connect (slot (*this, &OptionEditor::strip_width_clicked));
- follow_playhead_button.clicked.connect (slot (*this, &OptionEditor::follow_playhead_clicked));
+ show_waveforms_button.signal_clicked().connect (slot (*this, &OptionEditor::show_waveforms_clicked));
+ show_waveforms_recording_button.signal_clicked().connect (slot (*this, &OptionEditor::show_waveforms_recording_clicked));
+ show_measures_button.signal_clicked().connect (slot (*this, &OptionEditor::show_measures_clicked));
+ mixer_strip_width_button.signal_clicked().connect (slot (*this, &OptionEditor::strip_width_clicked));
+ follow_playhead_button.signal_clicked().connect (slot (*this, &OptionEditor::follow_playhead_clicked));
editor.DisplayControlChanged.connect (slot (*this, &OptionEditor::display_control_changed));
jack_time_master_button.set_name ("OptionEditorToggleButton");
smpte_offset_negative_button.set_name ("OptionEditorToggleButton");
- send_mtc_button.unset_flags (GTK_CAN_FOCUS);
- jack_time_master_button.unset_flags (GTK_CAN_FOCUS);
- smpte_offset_negative_button.unset_flags (GTK_CAN_FOCUS);
+ send_mtc_button.unset_flags (Gtk::CAN_FOCUS);
+ jack_time_master_button.unset_flags (Gtk::CAN_FOCUS);
+ smpte_offset_negative_button.unset_flags (Gtk::CAN_FOCUS);
hbox = manage (new HBox);
hbox->set_border_width (5);
jack_time_master_button.set_active (Config->get_jack_time_master());
send_mtc_button.button_press_event.connect (bind (slot (*this, &OptionEditor::send_mtc_toggled), &send_mtc_button));
- jack_time_master_button.clicked.connect (slot (*this, &OptionEditor::jack_time_master_clicked));
- smpte_offset_negative_button.clicked.connect (slot (*this, &OptionEditor::smpte_offset_negative_clicked));
+ jack_time_master_button.signal_clicked().connect (slot (*this, &OptionEditor::jack_time_master_clicked));
+ smpte_offset_negative_button.signal_clicked().connect (slot (*this, &OptionEditor::smpte_offset_negative_clicked));
}
void
*/
if (strlen (_("offline")) > strlen (_("online"))) {
- set_usize_to_display_given_text (*tb, _("offline"), 15, 12);
+ set_size_request_to_display_given_text (*tb, _("offline"), 15, 12);
} else {
- set_usize_to_display_given_text (*tb, _("online"), 15, 12);
+ set_size_request_to_display_given_text (*tb, _("online"), 15, 12);
}
tb->set_active (!(*i).second->input()->offline());
tb = manage (new ToggleButton ());
tb->set_name ("OptionEditorToggleButton");
tb->button_press_event.connect (bind (slot (*this, &OptionEditor::port_trace_in_toggled), (*i).second, tb));
- tb->set_usize (10, 10);
+ tb->set_size_request (10, 10);
table->attach (*tb, 2, 3, n+2, n+3, 0, 0);
tb = manage (new ToggleButton ());
tb->set_name ("OptionEditorToggleButton");
tb->button_press_event.connect (bind (slot (*this, &OptionEditor::port_trace_out_toggled), (*i).second, tb));
- tb->set_usize (10, 10);
+ tb->set_size_request (10, 10);
table->attach (*tb, 3, 4, n+2, n+3, 0, 0);
rb = manage (new RadioButton ());
OptionEditor::click_browse_clicked ()
{
SoundFileSelector& sfdb (ARDOUR_UI::instance()->get_sfdb_window());
- SigC::Connection c = sfdb.Action.connect (slot (*this, &OptionEditor::click_chosen));
+ sigc::connection c = sfdb.Action.connect (slot (*this, &OptionEditor::click_chosen));
sfdb.run (_("Use as click"), false, true);
c.disconnect ();
OptionEditor::click_emphasis_browse_clicked ()
{
SoundFileSelector& sfdb (ARDOUR_UI::instance()->get_sfdb_window());
- SigC::Connection c = sfdb.Action.connect (slot (*this, &OptionEditor::click_emphasis_chosen));
+ sigc::connection c = sfdb.Action.connect (slot (*this, &OptionEditor::click_emphasis_chosen));
sfdb.run (_("Use as click emphasis"), false, true);
c.disconnect ();
click_path_entry.activate.connect (slot (*this, &OptionEditor::click_sound_changed));
click_emphasis_path_entry.activate.connect (slot (*this, &OptionEditor::click_emphasis_sound_changed));
- click_path_entry.focus_in_event.connect (slot (Keyboard::the_keyboard(), &Keyboard::focus_in_handler));
- click_path_entry.focus_out_event.connect (bind (slot (*this, &OptionEditor::focus_out_event_handler), &OptionEditor::click_sound_changed));
- click_emphasis_path_entry.focus_in_event.connect (slot (Keyboard::the_keyboard(), &Keyboard::focus_in_handler));
- click_emphasis_path_entry.focus_out_event.connect (bind (slot (*this, &OptionEditor::focus_out_event_handler), &OptionEditor::click_emphasis_sound_changed));
+ click_path_entry.signal_focus_in_event().connect (slot (Keyboard::the_keyboard(), &Keyboard::focus_in_handler));
+ click_path_entry.signal_focus_out_event().connect (bind (slot (*this, &OptionEditor::focus_out_event_handler), &OptionEditor::click_sound_changed));
+ click_emphasis_path_entry.signal_focus_in_event().connect (slot (Keyboard::the_keyboard(), &Keyboard::focus_in_handler));
+ click_emphasis_path_entry.signal_focus_out_event().connect (bind (slot (*this, &OptionEditor::focus_out_event_handler), &OptionEditor::click_emphasis_sound_changed));
click_browse_button.set_name ("EditorGTKButton");
click_emphasis_browse_button.set_name ("EditorGTKButton");
- click_browse_button.clicked.connect (slot (*this, &OptionEditor::click_browse_clicked));
- click_emphasis_browse_button.clicked.connect (slot (*this, &OptionEditor::click_emphasis_browse_clicked));
+ click_browse_button.signal_clicked().connect (slot (*this, &OptionEditor::click_browse_clicked));
+ click_emphasis_browse_button.signal_clicked().connect (slot (*this, &OptionEditor::click_emphasis_browse_clicked));
click_packer.set_border_width (12);
click_packer.set_spacing (5);
label = manage(new Label(_("Click audio file")));
label->set_name ("OptionsLabel");
click_table.attach (*label, 0, 1, 0, 1, 0, 0);
- click_table.attach (click_path_entry, 1, 2, 0, 1, GTK_FILL|GTK_EXPAND, 0);
+ click_table.attach (click_path_entry, 1, 2, 0, 1, Gtk::FILL|Gtk::EXPAND, 0);
click_table.attach (click_browse_button, 2, 3, 0, 1, 0, 0);
label = manage(new Label(_("Click emphasis audiofile")));
label->set_name ("OptionsLabel");
click_table.attach (*label, 0, 1, 1, 2, 0, 0);
- click_table.attach (click_emphasis_path_entry, 1, 2, 1, 2, GTK_FILL|GTK_EXPAND, 0);
+ click_table.attach (click_emphasis_path_entry, 1, 2, 1, 2, Gtk::FILL|Gtk::EXPAND, 0);
click_table.attach (click_emphasis_browse_button, 2, 3, 1, 2, 0, 0);
hpacker->set_spacing (10);
misc_packer.set_spacing (3);
misc_packer.pack_start (*table, true, true);
- table->attach (hw_monitor_button, 0, 1, 0, 1, GTK_FILL, 0, 8, 0);
- table->attach (sw_monitor_button, 0, 1, 1, 2, GTK_FILL, 0, 8, 0);
- table->attach (plugins_stop_button, 0, 1, 2, 3, GTK_FILL, 0, 8, 0);
- table->attach (plugins_on_rec_button, 0, 1, 3, 4, GTK_FILL, 0, 8, 0);
- table->attach (verify_remove_last_capture_button, 0, 1, 4, 5, GTK_FILL, 0, 8, 0);
+ table->attach (hw_monitor_button, 0, 1, 0, 1, Gtk::FILL, 0, 8, 0);
+ table->attach (sw_monitor_button, 0, 1, 1, 2, Gtk::FILL, 0, 8, 0);
+ table->attach (plugins_stop_button, 0, 1, 2, 3, Gtk::FILL, 0, 8, 0);
+ table->attach (plugins_on_rec_button, 0, 1, 3, 4, Gtk::FILL, 0, 8, 0);
+ table->attach (verify_remove_last_capture_button, 0, 1, 4, 5, Gtk::FILL, 0, 8, 0);
- table->attach (stop_rec_on_xrun_button, 1, 2, 0, 1, GTK_FILL, 0, 8, 0);
- table->attach (stop_at_end_button, 1, 2, 1, 2, GTK_FILL, 0, 8, 0);
- table->attach (debug_keyboard_button, 1, 2, 2, 3, GTK_FILL, 0, 8, 0);
- table->attach (speed_quieten_button, 1, 2, 3, 4, GTK_FILL, 0, 8, 0);
+ table->attach (stop_rec_on_xrun_button, 1, 2, 0, 1, Gtk::FILL, 0, 8, 0);
+ table->attach (stop_at_end_button, 1, 2, 1, 2, Gtk::FILL, 0, 8, 0);
+ table->attach (debug_keyboard_button, 1, 2, 2, 3, Gtk::FILL, 0, 8, 0);
+ table->attach (speed_quieten_button, 1, 2, 3, 4, Gtk::FILL, 0, 8, 0);
Gtk::VBox* connect_box = manage (new VBox);
connect_box->set_spacing (3);
debug_keyboard_button.set_active (false);
speed_quieten_button.set_active (Config->get_quieten_at_speed() != 1.0f);
- hw_monitor_button.clicked.connect (slot (*this, &OptionEditor::hw_monitor_clicked));
- sw_monitor_button.clicked.connect (slot (*this, &OptionEditor::sw_monitor_clicked));
- plugins_stop_button.clicked.connect (slot (*this, &OptionEditor::plugins_stop_with_transport_clicked));
- plugins_on_rec_button.clicked.connect (slot (*this, &OptionEditor::plugins_on_while_recording_clicked));
- verify_remove_last_capture_button.clicked.connect (slot (*this, &OptionEditor::verify_remove_last_capture_clicked));
- auto_connect_inputs_button.clicked.connect (slot (*this, &OptionEditor::auto_connect_inputs_clicked));
- auto_connect_output_physical_button.clicked.connect (slot (*this, &OptionEditor::auto_connect_output_physical_clicked));
- auto_connect_output_master_button.clicked.connect (slot (*this, &OptionEditor::auto_connect_output_master_clicked));
- auto_connect_output_manual_button.clicked.connect (slot (*this, &OptionEditor::auto_connect_output_manual_clicked));
- stop_rec_on_xrun_button.clicked.connect (slot (*this, &OptionEditor::stop_rec_on_xrun_clicked));
- stop_at_end_button.clicked.connect (slot (*this, &OptionEditor::stop_at_end_clicked));
- debug_keyboard_button.clicked.connect (slot (*this, &OptionEditor::debug_keyboard_clicked));
- speed_quieten_button.clicked.connect (slot (*this, &OptionEditor::speed_quieten_clicked));
+ hw_monitor_button.signal_clicked().connect (slot (*this, &OptionEditor::hw_monitor_clicked));
+ sw_monitor_button.signal_clicked().connect (slot (*this, &OptionEditor::sw_monitor_clicked));
+ plugins_stop_button.signal_clicked().connect (slot (*this, &OptionEditor::plugins_stop_with_transport_clicked));
+ plugins_on_rec_button.signal_clicked().connect (slot (*this, &OptionEditor::plugins_on_while_recording_clicked));
+ verify_remove_last_capture_button.signal_clicked().connect (slot (*this, &OptionEditor::verify_remove_last_capture_clicked));
+ auto_connect_inputs_button.signal_clicked().connect (slot (*this, &OptionEditor::auto_connect_inputs_clicked));
+ auto_connect_output_physical_button.signal_clicked().connect (slot (*this, &OptionEditor::auto_connect_output_physical_clicked));
+ auto_connect_output_master_button.signal_clicked().connect (slot (*this, &OptionEditor::auto_connect_output_master_clicked));
+ auto_connect_output_manual_button.signal_clicked().connect (slot (*this, &OptionEditor::auto_connect_output_manual_clicked));
+ stop_rec_on_xrun_button.signal_clicked().connect (slot (*this, &OptionEditor::stop_rec_on_xrun_clicked));
+ stop_at_end_button.signal_clicked().connect (slot (*this, &OptionEditor::stop_at_end_clicked));
+ debug_keyboard_button.signal_clicked().connect (slot (*this, &OptionEditor::debug_keyboard_clicked));
+ speed_quieten_button.signal_clicked().connect (slot (*this, &OptionEditor::speed_quieten_clicked));
}
void
label->set_name ("OptionsLabel");
label->set_alignment (1.0, 0.5);
- keyboard_mouse_table.attach (*label, 0, 1, 0, 1, GTK_FILL|GTK_EXPAND, 0);
- keyboard_mouse_table.attach (edit_modifier_combo, 1, 2, 0, 1, GTK_FILL|GTK_EXPAND, 0);
+ keyboard_mouse_table.attach (*label, 0, 1, 0, 1, Gtk::FILL|Gtk::EXPAND, 0);
+ keyboard_mouse_table.attach (edit_modifier_combo, 1, 2, 0, 1, Gtk::FILL|Gtk::EXPAND, 0);
label = manage (new Label (_("+ button")));
label->set_name ("OptionsLabel");
- keyboard_mouse_table.attach (*label, 3, 4, 0, 1, GTK_FILL|GTK_EXPAND, 0);
- keyboard_mouse_table.attach (edit_button_spin, 4, 5, 0, 1, GTK_FILL|GTK_EXPAND, 0);
+ keyboard_mouse_table.attach (*label, 3, 4, 0, 1, Gtk::FILL|Gtk::EXPAND, 0);
+ keyboard_mouse_table.attach (edit_button_spin, 4, 5, 0, 1, Gtk::FILL|Gtk::EXPAND, 0);
edit_button_spin.set_name ("OptionsEntry");
edit_button_adjustment.set_value (Keyboard::edit_button());
label->set_name ("OptionsLabel");
label->set_alignment (1.0, 0.5);
- keyboard_mouse_table.attach (*label, 0, 1, 1, 2, GTK_FILL|GTK_EXPAND, 0);
- keyboard_mouse_table.attach (delete_modifier_combo, 1, 2, 1, 2, GTK_FILL|GTK_EXPAND, 0);
+ keyboard_mouse_table.attach (*label, 0, 1, 1, 2, Gtk::FILL|Gtk::EXPAND, 0);
+ keyboard_mouse_table.attach (delete_modifier_combo, 1, 2, 1, 2, Gtk::FILL|Gtk::EXPAND, 0);
label = manage (new Label (_("+ button")));
label->set_name ("OptionsLabel");
- keyboard_mouse_table.attach (*label, 3, 4, 1, 2, GTK_FILL|GTK_EXPAND, 0);
- keyboard_mouse_table.attach (delete_button_spin, 4, 5, 1, 2, GTK_FILL|GTK_EXPAND, 0);
+ keyboard_mouse_table.attach (*label, 3, 4, 1, 2, Gtk::FILL|Gtk::EXPAND, 0);
+ keyboard_mouse_table.attach (delete_button_spin, 4, 5, 1, 2, Gtk::FILL|Gtk::EXPAND, 0);
delete_button_spin.set_name ("OptionsEntry");
delete_button_adjustment.set_value (Keyboard::delete_button());
label->set_name ("OptionsLabel");
label->set_alignment (1.0, 0.5);
- keyboard_mouse_table.attach (*label, 0, 1, 2, 3, GTK_FILL|GTK_EXPAND, 0);
- keyboard_mouse_table.attach (snap_modifier_combo, 1, 2, 2, 3, GTK_FILL|GTK_EXPAND, 0);
+ keyboard_mouse_table.attach (*label, 0, 1, 2, 3, Gtk::FILL|Gtk::EXPAND, 0);
+ keyboard_mouse_table.attach (snap_modifier_combo, 1, 2, 2, 3, Gtk::FILL|Gtk::EXPAND, 0);
}
gint
const guint32 FUDGE = 10; // Combo's are stupid - they steal space from the entry for the button
- set_usize_to_display_given_text (*combo.get_entry(), maxstring.c_str(), 10 + FUDGE, 10);
+ set_size_request_to_display_given_text (*combo.get_entry(), maxstring.c_str(), 10 + FUDGE, 10);
}
void
#ifndef __gtk_ardour_option_editor_h__
#define __gtk_ardour_option_editor_h__
-#include <gtk--.h>
+#include <gtkmm.h>
#include <ardour/session.h>
#include <ardour/route.h>
#include <ardour/panner.h>
-#include <gtkmmext/popup.h>
+#include <gtkmm2ext/popup.h>
#include "pan_automation_time_axis.h"
#include "automation_line.h"
if (lines.size() > 1) {
- Gtkmmext::PopUp* msg = new Gtkmmext::PopUp (GTK_WIN_POS_MOUSE, 5000, true);
+ Gtkmm2ext::PopUp* msg = new Gtkmm2ext::PopUp (Gtk::WIN_POS_MOUSE, 5000, true);
msg->set_text (_("You can't graphically edit panning of more than stream"));
msg->touch ();
#include <pbd/error.h>
#include <ardour/panner.h>
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm2ext/gtk_ui.h>
#include "panner2d.h"
#include "keyboard.h"
using namespace std;
using namespace Gtk;
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
Panner2d::Target::Target (float xa, float ya, const char *txt)
panner.StateChanged.connect (slot (*this, &Panner2d::handle_state_change));
drag_target = 0;
- set_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_POINTER_MOTION_MASK);
+ set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::POINTER_MOTION_MASK);
}
fy = max (fy, -1.0f);
y = (gint) floor (height * fy - 4);
- get_window().draw_arc (get_style()->get_fg_gc(GTK_STATE_NORMAL),
+ get_window().draw_arc (get_style()->get_fg_gc(Gtk::STATE_NORMAL),
true,
x, y,
8, 8,
0, 360 * 64);
get_window().draw_text (get_style()->get_font(),
- get_style()->get_fg_gc(GTK_STATE_NORMAL),
+ get_style()->get_fg_gc(Gtk::STATE_NORMAL),
x + 6, y + 6,
puck->text,
puck->textlen);
#include <sys/types.h>
#include <map>
#include <string>
-#include <gtk--.h>
+#include <gtkmm.h>
using std::map;
using std::string;
void move_puck (int, float x, float y);
void reset (uint32_t n_inputs);
- SigC::Signal1<void,int> PuckMoved;
- SigC::Signal1<void,int> TargetMoved;
+ sigc::signal<void,int> PuckMoved;
+ sigc::signal<void,int> TargetMoved;
protected:
gint expose_event_impl (GdkEventExpose *);
#include <ardour/io.h>
#include <ardour/dB.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/stop_signal.h>
-#include <gtkmmext/barcontroller.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/stop_signal.h>
+#include <gtkmm2ext/barcontroller.h>
#include <midi++/manager.h>
#include <pbd/fastlog.h>
#include "i18n.h"
using namespace ARDOUR;
-using namespace Gtkmmext;
+using namespace Gtkmm2ext;
using namespace Gtk;
-using namespace SigC;
+using namespace sigc;
/* XPM */
static const gchar * forwdblarrow_xpm[] = {
PannerUI::PannerUI (IO& io, Session& s)
: _io (io),
_session (s),
- panning_up_arrow (GTK_ARROW_UP, GTK_SHADOW_OUT),
- panning_down_arrow (GTK_ARROW_DOWN, GTK_SHADOW_OUT),
+ panning_up_arrow (GTK_ARROW_UP, Gtk::SHADOW_OUT),
+ panning_down_arrow (GTK_ARROW_DOWN, Gtk::SHADOW_OUT),
panning_link_button (_("link"))
{
pan_menu = 0;
in_pan_update = false;
- pan_bar_packer.set_usize (-1, 61);
- panning_viewport.set_usize (61, 61);
+ pan_bar_packer.set_size_request (-1, 61);
+ panning_viewport.set_size_request (61, 61);
panning_viewport.set_name (X_("BaseFrame"));
{
switch (w) {
case Wide:
- panning_viewport.set_usize (61, 61);
+ panning_viewport.set_size_request (61, 61);
if (panner) {
- panner->set_usize (61, 61);
+ panner->set_size_request (61, 61);
}
for (vector<BarController*>::iterator i = pan_bars.begin(); i != pan_bars.end(); ++i) {
- (*i)->set_usize (61, 15);
+ (*i)->set_size_request (61, 15);
}
static_cast<Gtk::Label*> (panning_link_button.get_child())->set_text (_("link"));
break;
case Narrow:
- panning_viewport.set_usize (31, 61);
+ panning_viewport.set_size_request (31, 61);
if (panner) {
- panner->set_usize (31, 61);
+ panner->set_size_request (31, 61);
}
for (vector<BarController*>::iterator i = pan_bars.begin(); i != pan_bars.end(); ++i) {
- (*i)->set_usize (31, 15);
+ (*i)->set_size_request (31, 15);
}
static_cast<Gtk::Label*> (panning_link_button.get_child())->set_text (_("L"));
break;
bc->set_name ("PanSlider");
bc->set_shadow_type (GTK_SHADOW_NONE);
bc->set_style (BarController::Line);
- bc->get_spin_button().focus_in_event.connect (slot (*this, &PannerUI::entry_focus_event));
- bc->get_spin_button().focus_out_event.connect (slot (*this, &PannerUI::entry_focus_event));
+ bc->get_spin_button().signal_focus_in_event().connect (slot (*this, &PannerUI::entry_focus_event));
+ bc->get_spin_button().signal_focus_out_event().connect (slot (*this, &PannerUI::entry_focus_event));
bc->StartGesture.connect (bind (slot (_io, &IO::start_pan_touch), (uint32_t) asz));
bc->StopGesture.connect (bind (slot (_io, &IO::end_pan_touch), (uint32_t) asz));
pan_bars.push_back (bc);
switch (_width) {
case Wide:
- pan_bars.back()->set_usize (61, 15);
+ pan_bars.back()->set_size_request (61, 15);
break;
case Narrow:
- pan_bars.back()->set_usize (31, 15);
+ pan_bars.back()->set_size_request (31, 15);
break;
}
update_pan_sensitive ();
panner->reset (_io.n_inputs());
- panner->set_usize (w, 61);
+ panner->set_size_request (w, 61);
/* and finally, add it to the panner frame */
#define __ardour_gtk_panner_ui_h__
#include <vector>
-#include <gtk--.h>
-#include <gtkmmext/slider_controller.h>
-#include <gtkmmext/click_box.h>
+#include <gtkmm.h>
+#include <gtkmm2ext/slider_controller.h>
+#include <gtkmm2ext/click_box.h>
#include "enums.h"
class IO;
class Session;
}
-namespace Gtkmmext {
+namespace Gtkmm2ext {
class FastMeter;
class BarController;
}
void panning_link_direction_clicked ();
vector<Gtk::Adjustment*> pan_adjustments;
- vector<Gtkmmext::BarController*> pan_bars;
+ vector<Gtkmm2ext::BarController*> pan_bars;
void pan_adjustment_changed (uint32_t which);
void pan_value_changed (uint32_t which);
*/
-#include <gtk--/button.h>
-#include <gtk--/ctree.h>
+#include <gtkmm/button.h>
+#include <gtkmm/ctree.h>
#include <ardour/session_playlist.h>
#include <ardour/diskstream.h>
#include <ardour/audioplaylist.h>
#include <ardour/configuration.h>
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm2ext/gtk_ui.h>
#include "playlist_selector.h"
#include "route_ui.h"
#include "i18n.h"
using namespace std;
-using namespace SigC;
+using namespace sigc;
using namespace Gtk;
using namespace ARDOUR;
{
rui = 0;
- set_position (GTK_WIN_POS_MOUSE);
+ set_position (Gtk::WIN_POS_MOUSE);
set_name ("PlaylistSelectorWindow");
set_title (_("ardour: playlists"));
set_modal(true);
- add_events (GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK);
- set_usize (300, 200);
+ add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
+ set_size_request (300, 200);
scroller.add_with_viewport (tree);
- scroller.set_policy (GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+ scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
- close_button.clicked.connect (slot (*this, &PlaylistSelector::close_button_click));
+ close_button.signal_clicked().connect (slot (*this, &PlaylistSelector::close_button_click));
vpacker.set_border_width (6);
vpacker.set_spacing (12);
/* ---------------------------------------- */
/* XXX MAKE ME A FUNCTION (no CTree::clear() in gtkmm 1.2) */
- gtk_ctree_remove_node (tree.gtkobj(), NULL);
+ gtk_ctree_remove_node (tree.gobj(), NULL);
/* ---------------------------------------- */
session->foreach_playlist (this, &PlaylistSelector::add_playlist_to_map);
#ifndef __ardour_playlist_selector_h__
#define __ardour_playlist_selector_h__
-#include <gtk--.h>
-#include <gtk--/ctree.h>
-#include <gtkmmext/selector.h>
+#include <gtkmm.h>
+#include <gtkmm/ctree.h>
+#include <gtkmm2ext/selector.h>
#include <ardour_dialog.h>
DSPL_Map dspl_map;
RouteUI* rui;
- SigC::Connection select_connection;
+ sigc::connection select_connection;
void add_playlist_to_map (ARDOUR::Playlist*);
void clear_map ();
#include <cstdio>
#include <lrdf.h>
-#include <gtk--/table.h>
-#include <gtk--/button.h>
-#include <gtk--/notebook.h>
-#include <gtk--/ctree.h>
+#include <gtkmm/table.h>
+#include <gtkmm/button.h>
+#include <gtkmm/notebook.h>
+#include <gtkmm/ctree.h>
#include <ardour/plugin_manager.h>
#include <ardour/plugin.h>
#endif
o_selector (_output_refiller, this, internationalize (o_titles), false, true)
{
- set_position (GTK_WIN_POS_MOUSE);
+ set_position (Gtk::WIN_POS_MOUSE);
set_name ("PluginSelectorWindow");
set_title (_("ardour: plugins"));
set_modal(true);
- add_events (GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK);
+ add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
manager = mgr;
session = 0;
btn_remove->set_name("PluginSelectorButton");
Gtk::Table* table = manage(new Gtk::Table(7, 10));
- table->set_usize(750, 500);
+ table->set_size_request(750, 500);
table->attach(notebook, 0, 7, 0, 5);
- table->attach(*btn_add, 1, 2, 5, 6, GTK_FILL, 0, 5, 5);
- table->attach(*btn_remove, 3, 4, 5, 6, GTK_FILL, 0, 5, 5);
- table->attach(*btn_update, 5, 6, 5, 6, GTK_FILL, 0, 5, 5);
+ table->attach(*btn_add, 1, 2, 5, 6, Gtk::FILL, 0, 5, 5);
+ table->attach(*btn_remove, 3, 4, 5, 6, Gtk::FILL, 0, 5, 5);
+ table->attach(*btn_update, 5, 6, 5, 6, Gtk::FILL, 0, 5, 5);
table->attach(o_selector, 0, 7, 7, 9);
- table->attach(*btn_ok, 1, 3, 9, 10, GTK_FILL, 0, 5, 5);
- table->attach(*btn_cancel, 3, 4, 9, 10, GTK_FILL, 0, 5, 5);
+ table->attach(*btn_ok, 1, 3, 9, 10, Gtk::FILL, 0, 5, 5);
+ table->attach(*btn_cancel, 3, 4, 9, 10, Gtk::FILL, 0, 5, 5);
add (*table);
using namespace Gtk::Notebook_Helpers;
ladspa_display.selection_made.connect (slot(*this, &PluginSelector::i_plugin_selected));
ladspa_display.choice_made.connect(slot(*this, &PluginSelector::i_plugin_chosen));
- ladspa_display.clist().click_column.connect(bind (slot(*this, &PluginSelector::column_clicked), ladspa_display.clist().gtkobj()));
+ ladspa_display.clist().click_column.connect(bind (slot(*this, &PluginSelector::column_clicked), ladspa_display.clist().gobj()));
#ifdef VST_SUPPORT
if (Config->get_use_vst()) {
vst_display.selection_made.connect (slot(*this, &PluginSelector::i_plugin_selected));
vst_display.choice_made.connect(slot(*this, &PluginSelector::i_plugin_chosen));
- vst_display.clist().click_column.connect(bind (slot(*this, &PluginSelector::column_clicked), vst_display.clist().gtkobj()));
+ vst_display.clist().click_column.connect(bind (slot(*this, &PluginSelector::column_clicked), vst_display.clist().gobj()));
}
#endif
o_selector.selection_made.connect(slot(*this, &PluginSelector::o_plugin_selected));
o_selector.choice_made.connect(slot(*this,&PluginSelector::o_plugin_chosen));
- btn_update->clicked.connect (slot(*this, &PluginSelector::btn_update_clicked));
+ btn_update-.signal_clicked().connect (slot(*this, &PluginSelector::btn_update_clicked));
btn_add->clicked.connect(slot(*this, &PluginSelector::btn_add_clicked));
btn_remove->clicked.connect(slot(*this, &PluginSelector::btn_remove_clicked));
btn_ok->clicked.connect(slot(*this, &PluginSelector::btn_ok_clicked));
}
void
-PluginSelector::i_plugin_chosen (Gtkmmext::Selector *selector,
- Gtkmmext::SelectionResult *res)
+PluginSelector::i_plugin_chosen (Gtkmm2ext::Selector *selector,
+ Gtkmm2ext::SelectionResult *res)
{
if (res) {
// get text for name column (0)
}
void
-PluginSelector::i_plugin_selected (Gtkmmext::Selector *selector,
- Gtkmmext::SelectionResult *res)
+PluginSelector::i_plugin_selected (Gtkmm2ext::Selector *selector,
+ Gtkmm2ext::SelectionResult *res)
{
if (res) {
added_plugins.push_back (static_cast<PluginInfo*> (selector->clist().row(res->row).get_data()));
}
void
-PluginSelector::o_plugin_chosen (Gtkmmext::Selector *selector,
- Gtkmmext::SelectionResult *res)
+PluginSelector::o_plugin_chosen (Gtkmm2ext::Selector *selector,
+ Gtkmm2ext::SelectionResult *res)
{
if (res && res->text) {
o_selected_plug = res->row;
}
void
-PluginSelector::o_plugin_selected (Gtkmmext::Selector *selector,
- Gtkmmext::SelectionResult *res)
+PluginSelector::o_plugin_selected (Gtkmm2ext::Selector *selector,
+ Gtkmm2ext::SelectionResult *res)
{
if(res && res->text){
gint row = 0;
#ifndef __ardour_plugin_selector_h__
#define __ardour_plugin_selector_h__
-#include <gtk--.h>
-#include <gtk--/ctree.h>
-#include <gtkmmext/selector.h>
+#include <gtkmm.h>
+#include <gtkmm/ctree.h>
+#include <gtkmm2ext/selector.h>
#include <ardour_dialog.h>
{
public:
PluginSelector (ARDOUR::PluginManager *);
- SigC::Signal1<void,ARDOUR::Plugin *> PluginCreated;
+ sigc::signal<void,ARDOUR::Plugin *> PluginCreated;
void set_session (ARDOUR::Session*);
Gtk::Notebook notebook;
// page 1
- Gtkmmext::Selector ladspa_display;
+ Gtkmm2ext::Selector ladspa_display;
void column_clicked (int column, GtkCList* clist);
#ifdef VST_SUPPORT
// page 2
- Gtkmmext::Selector vst_display;
+ Gtkmm2ext::Selector vst_display;
static void _vst_refiller (Gtk::CList &, void *);
void vst_refiller (Gtk::CList &);
#endif
- Gtkmmext::Selector o_selector;
+ Gtkmm2ext::Selector o_selector;
ARDOUR::PluginInfo* i_selected_plug;
void input_refiller (Gtk::CList &);
void output_refiller (Gtk::CList &);
- void i_plugin_selected (Gtkmmext::Selector *selector,
- Gtkmmext::SelectionResult *res);
- void i_plugin_chosen (Gtkmmext::Selector *selector,
- Gtkmmext::SelectionResult *res);
- void o_plugin_selected (Gtkmmext::Selector *selector,
- Gtkmmext::SelectionResult *res);
- void o_plugin_chosen (Gtkmmext::Selector *selector,
- Gtkmmext::SelectionResult *res);
+ void i_plugin_selected (Gtkmm2ext::Selector *selector,
+ Gtkmm2ext::SelectionResult *res);
+ void i_plugin_chosen (Gtkmm2ext::Selector *selector,
+ Gtkmm2ext::SelectionResult *res);
+ void o_plugin_selected (Gtkmm2ext::Selector *selector,
+ Gtkmm2ext::SelectionResult *res);
+ void o_plugin_chosen (Gtkmm2ext::Selector *selector,
+ Gtkmm2ext::SelectionResult *res);
void btn_add_clicked();
void btn_remove_clicked();
#include <pbd/xml++.h>
#include <pbd/failed_constructor.h>
-#include <gtkmmext/click_box.h>
-#include <gtkmmext/fastmeter.h>
-#include <gtkmmext/slider_controller.h>
-#include <gtkmmext/barcontroller.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/doi.h>
+#include <gtkmm2ext/click_box.h>
+#include <gtkmm2ext/fastmeter.h>
+#include <gtkmm2ext/slider_controller.h>
+#include <gtkmm2ext/barcontroller.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/doi.h>
#include <midi++/manager.h>
using namespace std;
using namespace ARDOUR;
-using namespace Gtkmmext;
+using namespace Gtkmm2ext;
using namespace Gtk;
-using namespace SigC;
+using namespace sigc;
PluginUIWindow::PluginUIWindow (AudioEngine &engine, PluginInsert& insert, bool scrollable)
: ArdourDialog ("plugin ui")
unmap_event.connect (slot (*pu, &PluginUI::stop_updating));
}
- set_position (GTK_WIN_POS_MOUSE);
+ set_position (Gtk::WIN_POS_MOUSE);
set_name ("PluginEditor");
- add_events (GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK);
+ add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
delete_event.connect (bind (slot (just_hide_it), reinterpret_cast<Window*> (this)));
insert.GoingAway.connect (slot (*this, &PluginUIWindow::plugin_going_away));
pack_start (settings_box, false, false);
if ( is_scrollable ) {
- scroller.set_policy (GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+ scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
scroller.set_name ("PluginEditor");
scroller_view.set_name("PluginEditor");
scroller_view.add (hpacker);
}
button_table.attach (*cui, button_col, button_col + 1, button_row, button_row+1,
- GTK_FILL|GTK_EXPAND, 0);
+ Gtk::FILL|Gtk::EXPAND, 0);
button_row++;
} else if (cui->display) {
}
output_table.attach (*cui, output_col, output_col + 1, output_row, output_row+1,
- GTK_FILL|GTK_EXPAND, 0);
+ Gtk::FILL|Gtk::EXPAND, 0);
output_row++;
}
/* don't fix the height, it messes up the bar controllers */
- set_usize_to_display_given_text (automate_button, X_("longenuff"), 2, -1);
+ set_size_request_to_display_given_text (automate_button, X_("longenuff"), 2, -1);
ignore_change = 0;
display = 0;
control_ui->button = manage (new ToggleButton ());
control_ui->button->set_name ("PluginEditorButton");
- control_ui->button->set_usize (20, 20);
+ control_ui->button->set_size_request (20, 20);
control_ui->pack_start (control_ui->label, true, true);
control_ui->pack_start (*control_ui->button, false, true);
control_ui->pack_start (control_ui->automate_button, false, false);
- control_ui->button->clicked.connect (bind (slot (*this, &PluginUI::control_port_toggled), control_ui));
+ control_ui->button-.signal_clicked().connect (bind (slot (*this, &PluginUI::control_port_toggled), control_ui));
if(plugin.get_parameter (port_index) == 1){
control_ui->button->set_active(true);
if (desc.integer_step) {
control_ui->clickbox = new ClickBox (control_ui->adjustment, "PluginUIClickBox");
- Gtkmmext::set_usize_to_display_given_text (*control_ui->clickbox, "g9999999", 2, 2);
+ Gtkmm2ext::set_size_request_to_display_given_text (*control_ui->clickbox, "g9999999", 2, 2);
control_ui->clickbox->set_print_func (integer_printer, 0);
} else {
// control_ui->control = new HSliderController (ARDOUR_UI::instance()->plugin_ui_slider_pix(),
// control_ui->adjustment,
// mcontrol);
- SigC::Slot2<void,char*,uint32_t> pslot = SigC::bind (slot (*this, &PluginUI::print_parameter), (uint32_t) port_index);
+ sigc::slot<void,char*,uint32_t> pslot = sigc::bind (slot (*this, &PluginUI::print_parameter), (uint32_t) port_index);
control_ui->control = new BarController (*control_ui->adjustment, mcontrol, pslot);
- control_ui->control->set_usize (200, 15);
+ control_ui->control->set_size_request (200, 15);
control_ui->control->set_name (X_("PluginSlider"));
control_ui->control->set_style (BarController::LeftToRight);
control_ui->control->set_use_parent (true);
- control_ui->control->get_spin_button().focus_in_event.connect (slot (*this, &PluginUI::entry_focus_event));
- control_ui->control->get_spin_button().focus_out_event.connect (slot (*this, &PluginUI::entry_focus_event));
+ control_ui->control->get_spin_button().signal_focus_in_event().connect (slot (*this, &PluginUI::entry_focus_event));
+ control_ui->control->get_spin_button().signal_focus_out_event().connect (slot (*this, &PluginUI::entry_focus_event));
control_ui->control->StartGesture.connect (bind (slot (*this, &PluginUI::start_touch), control_ui));
control_ui->control->StopGesture.connect (bind (slot (*this, &PluginUI::stop_touch), control_ui));
control_ui->pack_start (control_ui->automate_button, false, false);
control_ui->adjustment->value_changed.connect (bind (slot (*this, &PluginUI::control_adjustment_changed), control_ui));
- control_ui->automate_button.clicked.connect (bind (slot (*this, &PluginUI::astate_clicked), control_ui, (uint32_t) port_index));
+ control_ui->automate_button.signal_clicked().connect (bind (slot (*this, &PluginUI::astate_clicked), control_ui, (uint32_t) port_index));
automation_state_changed (control_ui);
control_ui->display_label->set_name ("ParameterValueDisplay");
control_ui->display->add (*control_ui->display_label);
- Gtkmmext::set_usize_to_display_given_text (*control_ui->display, "g999999", 2, 2);
+ Gtkmm2ext::set_size_request_to_display_given_text (*control_ui->display, "g999999", 2, 2);
control_ui->display->show_all ();
if (cui->port_index == abs_port_id) {
if (!cui->update_pending) {
cui->update_pending = true;
- Gtkmmext::UI::instance()->call_slot (bind (slot (*this, &PluginUI::update_control_display), cui));
+ Gtkmm2ext::UI::instance()->call_slot (bind (slot (*this, &PluginUI::update_control_display), cui));
}
}
}
Main::run();
- if (prompter.status == Gtkmmext::Prompter::entered) {
+ if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result(name);
#include <map>
#include <list>
-#include <sigc++/signal_system.h>
+#include <sigc++/signal.h>
-#include <gtk--.h>
-#include <gtk--/socket.h>
+#include <gtkmm.h>
+#include <gtkmm/socket.h>
#include <ardour_dialog.h>
#include <ardour/types.h>
class Controllable;
}
-namespace Gtkmmext {
+namespace Gtkmm2ext {
class HSliderController;
class BarController;
class ClickBox;
class PixmapButton;
}
-class PlugUIBase : public SigC::Object
+class PlugUIBase : public sigc::trackable
{
public:
PlugUIBase (ARDOUR::PluginInsert&);
bool is_scrollable;
struct MeterInfo {
- Gtkmmext::FastMeter *meter;
+ Gtkmm2ext::FastMeter *meter;
float min;
float max;
Gtk::Combo* combo;
std::map<string, float>* combo_map;
Gtk::ToggleButton* button;
- Gtkmmext::BarController* control;
- Gtkmmext::ClickBox* clickbox;
+ Gtkmm2ext::BarController* control;
+ Gtkmm2ext::ClickBox* clickbox;
Gtk::Label label;
bool logarithmic;
bool update_pending;
};
std::vector<ControlUI*> output_controls;
- SigC::Connection screen_update_connection;
+ sigc::connection screen_update_connection;
void output_update();
void build (ARDOUR::AudioEngine &);
#include "prompter.h"
#include "ardour_ui.h"
-using namespace SigC;
+using namespace sigc;
ArdourPrompter::ArdourPrompter (bool modal)
- : Gtkmmext::Prompter (modal)
+ : Gtkmm2ext::Prompter (modal)
{
- the_entry().focus_in_event.connect (slot (ARDOUR_UI::generic_focus_in_event));
- the_entry().focus_out_event.connect (slot (ARDOUR_UI::generic_focus_out_event));
+ the_entry().signal_focus_in_event().connect (slot (ARDOUR_UI::generic_focus_in_event));
+ the_entry().signal_focus_out_event().connect (slot (ARDOUR_UI::generic_focus_out_event));
}
#ifndef __ardour_gtk_prompter_h__
#define __ardour_gtk_prompter_h__
-#include <gtkmmext/prompter.h>
+#include <gtkmm2ext/prompter.h>
-class ArdourPrompter : public Gtkmmext::Prompter
+class ArdourPrompter : public Gtkmm2ext::Prompter
{
public:
ArdourPrompter (bool modal = false);
#include <glib.h>
#include <gdk/gdktypes.h>
#include <gtk-canvas.h>
-#include <gtk--/window.h>
+#include <gtkmm/window.h>
#include <jack/types.h>
-#include <sigc++/signal_system.h>
+#include <sigc++/signal.h>
#include "editing.h"
#include "keyboard_target.h"
virtual void reposition_x_origin (jack_nframes_t frame) = 0;
virtual void remove_last_capture () = 0;
- SigC::Signal1<void,Editing::DisplayControl> DisplayControlChanged;
- SigC::Signal0<void> ZoomFocusChanged;
- SigC::Signal0<void> ZoomChanged;
- SigC::Signal0<void> XOriginChanged;
- SigC::Signal0<void> Resized;
+ sigc::signal<void,Editing::DisplayControl> DisplayControlChanged;
+ sigc::signal<void> ZoomFocusChanged;
+ sigc::signal<void> ZoomChanged;
+ sigc::signal<void> XOriginChanged;
+ sigc::signal<void> Resized;
static gint canvas_crossfade_view_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
static gint canvas_fade_in_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
#include <ardour/ardour.h>
#include <gtk-canvas.h>
-#include <gtk--.h>
+#include <gtkmm.h>
#include "automation_line.h"
#include <sigc++/bind.h>
-#include <gtkmmext/gtk_ui.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/choice.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/stop_signal.h>
-#include <gtkmmext/doi.h>
+#include <gtkmm2ext/gtk_ui.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/choice.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/stop_signal.h>
+#include <gtkmm2ext/doi.h>
#include <ardour/ardour.h>
#include <ardour/session.h>
#include "i18n.h"
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;
-using namespace Gtkmmext;
+using namespace Gtkmm2ext;
redirect_display.set_button_actions (3, 0);
redirect_display.drag_begin.connect (slot (*this, &RedirectBox::redirect_drag_begin));
redirect_display.drag_end.connect (slot (*this, &RedirectBox::redirect_drag_end));
- redirect_display.set_usize (-1, 48);
+ redirect_display.set_size_request (-1, 48);
redirect_display.set_selection_mode (GTK_SELECTION_MULTIPLE);
- redirect_display.set_shadow_type (GTK_SHADOW_IN);
+ redirect_display.set_shadow_type (Gtk::SHADOW_IN);
redirect_display.row_move.connect (slot (*this, &RedirectBox::redirects_reordered));
- redirect_scroller.set_policy (GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+ redirect_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
redirect_scroller.add (redirect_display);
redirect_eventbox.add (redirect_scroller);
redirects_changed (0);
- //add_events (GDK_BUTTON_RELEASE_MASK);
+ //add_events (Gdk::BUTTON_RELEASE_MASK);
}
RedirectBox::~RedirectBox ()
vpacker.pack_start (label);
vpacker.pack_start (button_box);
- button.clicked.connect (bind (slot (dialog, &ArdourDialog::stop), 0));
+ button.signal_clicked().connect (bind (slot (dialog, &ArdourDialog::stop), 0));
dialog.add (vpacker);
dialog.set_name (X_("PluginIODialog"));
- dialog.set_position (GTK_WIN_POS_MOUSE);
+ dialog.set_position (Gtk::WIN_POS_MOUSE);
dialog.set_modal (true);
dialog.show_all ();
vpacker.pack_start (label);
vpacker.pack_start (button_box);
- button.clicked.connect (bind (slot (dialog, &ArdourDialog::stop), 0));
+ button.signal_clicked().connect (bind (slot (dialog, &ArdourDialog::stop), 0));
dialog.add (vpacker);
dialog.set_name (X_("PluginIODialog"));
- dialog.set_position (GTK_WIN_POS_MOUSE);
+ dialog.set_position (Gtk::WIN_POS_MOUSE);
dialog.set_modal (true);
dialog.show_all ();
dialog.set_title (_("ardour: rename redirect"));
dialog.set_name ("RedirectRenameWindow");
- dialog.set_usize (300, -1);
- dialog.set_position (GTK_WIN_POS_MOUSE);
+ dialog.set_size_request (300, -1);
+ dialog.set_position (Gtk::WIN_POS_MOUSE);
dialog.set_modal (true);
vbox.set_border_width (12);
cancel_button.set_name ("EditorGTKButton");
entry.activate.connect (bind (slot (dialog, &ArdourDialog::stop), 1));
- cancel_button.clicked.connect (bind (slot (dialog, &ArdourDialog::stop), -1));
- ok_button.clicked.connect (bind (slot (dialog, &ArdourDialog::stop), 1));
+ cancel_button.signal_clicked().connect (bind (slot (dialog, &ArdourDialog::stop), -1));
+ ok_button.signal_clicked().connect (bind (slot (dialog, &ArdourDialog::stop), 1));
/* recurse */
choices.push_back (_("Yes, remove them all"));
choices.push_back (_("Cancel"));
- Gtkmmext::Choice prompter (prompt, choices);
+ Gtkmm2ext::Choice prompter (prompt, choices);
prompter.chosen.connect (Gtk::Main::quit.slot());
prompter.show_all ();
#include <vector>
#include <cmath>
-#include <gtk--.h>
-#include <gtkmmext/auto_spin.h>
-#include <gtkmmext/click_box.h>
+#include <gtkmm.h>
+#include <gtkmm2ext/auto_spin.h>
+#include <gtkmm2ext/click_box.h>
#include <ardour/types.h>
#include <ardour/ardour.h>
void select_all_inserts ();
void select_all_sends ();
- SigC::Signal1<void,ARDOUR::Redirect *> RedirectSelected;
- SigC::Signal1<void,ARDOUR::Redirect *> RedirectUnselected;
+ sigc::signal<void,ARDOUR::Redirect *> RedirectSelected;
+ sigc::signal<void,ARDOUR::Redirect *> RedirectUnselected;
protected:
void set_stuff_from_route ();
Width _width;
- SigC::Connection newplug_connection;
+ sigc::connection newplug_connection;
Gtk::Menu *send_action_menu;
void build_send_action_menu ();
void redirects_reordered (gint, gint);
gint compute_redirect_sort_keys ();
- vector<SigC::Connection> redirect_active_connections;
- vector<SigC::Connection> redirect_name_connections;
+ vector<sigc::connection> redirect_active_connections;
+ vector<sigc::connection> redirect_name_connections;
bool redirect_drag_in_progress;
void redirect_drag_begin (GdkDragContext*);
#include <ardour/audioregion.h>
#include <ardour/utils.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/stop_signal.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/stop_signal.h>
#include <cmath>
#include "region_editor.h"
#include "i18n.h"
using namespace ARDOUR;
-using namespace SigC;
+using namespace sigc;
using namespace std;
AudioRegionEditor::AudioRegionEditor (Session&s, AudioRegion& r, AudioRegionView& rv)
lock_button (_("lock")),
mute_button (_("mute")),
opaque_button (_("opaque")),
- raise_arrow (GTK_ARROW_UP, GTK_SHADOW_OUT),
- lower_arrow (GTK_ARROW_DOWN, GTK_SHADOW_OUT),
+ raise_arrow (GTK_ARROW_UP, Gtk::SHADOW_OUT),
+ lower_arrow (GTK_ARROW_DOWN, Gtk::SHADOW_OUT),
layer_label (_("Layer")),
audition_label (_("play")),
time_table (3, 2),
name_entry.set_name ("AudioRegionEditorEntry");
name_label.set_name ("AudioRegionEditorLabel");
- name_entry.focus_in_event.connect (slot (*this, &AudioRegionEditor::focus_change));
- name_entry.focus_out_event.connect (slot (*this, &AudioRegionEditor::focus_change));
+ name_entry.signal_focus_in_event().connect (slot (*this, &AudioRegionEditor::focus_change));
+ name_entry.signal_focus_out_event().connect (slot (*this, &AudioRegionEditor::focus_change));
name_hbox.set_spacing (5);
name_hbox.pack_start (name_label, false, false);
raise_button.add (raise_arrow);
lower_button.add (lower_arrow);
layer_frame.set_name ("BaseFrame");
- layer_frame.set_shadow_type (GTK_SHADOW_IN);
+ layer_frame.set_shadow_type (Gtk::SHADOW_IN);
layer_frame.add (layer_value_label);
layer_label.set_name ("AudioRegionEditorLabel");
layer_value_label.set_name ("AudioRegionEditorLabel");
- Gtkmmext::set_usize_to_display_given_text (layer_value_label, "99", 5, 2);
+ Gtkmm2ext::set_size_request_to_display_given_text (layer_value_label, "99", 5, 2);
layer_hbox.set_spacing (5);
layer_hbox.pack_start (layer_label, false, false);
ARDOUR_UI::instance()->tooltips().set_tip (fade_out_active_button, _("use fade out curve during playback"));
ARDOUR_UI::instance()->tooltips().set_tip (audition_button, _("audition this region"));
- mute_button.unset_flags (GTK_CAN_FOCUS);
- opaque_button.unset_flags (GTK_CAN_FOCUS);
- lock_button.unset_flags (GTK_CAN_FOCUS);
- envelope_active_button.unset_flags (GTK_CAN_FOCUS);
- envelope_view_button.unset_flags (GTK_CAN_FOCUS);
- fade_in_active_button.unset_flags (GTK_CAN_FOCUS);
- fade_out_active_button.unset_flags (GTK_CAN_FOCUS);
- audition_button.unset_flags (GTK_CAN_FOCUS);
+ mute_button.unset_flags (Gtk::CAN_FOCUS);
+ opaque_button.unset_flags (Gtk::CAN_FOCUS);
+ lock_button.unset_flags (Gtk::CAN_FOCUS);
+ envelope_active_button.unset_flags (Gtk::CAN_FOCUS);
+ envelope_view_button.unset_flags (Gtk::CAN_FOCUS);
+ fade_in_active_button.unset_flags (Gtk::CAN_FOCUS);
+ fade_out_active_button.unset_flags (Gtk::CAN_FOCUS);
+ audition_button.unset_flags (Gtk::CAN_FOCUS);
mute_button.set_events (mute_button.get_events() & ~(GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK));
opaque_button.set_events (opaque_button.get_events() & ~(GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK));
envelope_loop_table.set_border_width (5);
envelope_loop_table.set_row_spacings (2);
envelope_loop_table.attach (envelope_label, 0, 1, 0, 1, 0, 0);
- envelope_loop_table.attach (envelope_active_button, 0, 1, 1, 2, GTK_FILL|GTK_EXPAND, 0);
- envelope_loop_table.attach (envelope_view_button, 0, 1, 2, 3, GTK_FILL|GTK_EXPAND, 0);
+ envelope_loop_table.attach (envelope_active_button, 0, 1, 1, 2, Gtk::FILL|Gtk::EXPAND, 0);
+ envelope_loop_table.attach (envelope_view_button, 0, 1, 2, 3, Gtk::FILL|Gtk::EXPAND, 0);
/* fade in */
fade_in_length_spinner.set_digits (3);
- fade_in_length_spinner.focus_in_event.connect (slot (*this, &AudioRegionEditor::focus_change));
- fade_in_length_spinner.focus_out_event.connect (slot (*this, &AudioRegionEditor::focus_change));
+ fade_in_length_spinner.signal_focus_in_event().connect (slot (*this, &AudioRegionEditor::focus_change));
+ fade_in_length_spinner.signal_focus_out_event().connect (slot (*this, &AudioRegionEditor::focus_change));
fade_in_length_spinner.activate.connect (slot (*this, &AudioRegionEditor::activation));
- Gtkmmext::set_usize_to_display_given_text (fade_in_length_spinner, "500g", 20, -1);
+ Gtkmm2ext::set_size_request_to_display_given_text (fade_in_length_spinner, "500g", 20, -1);
fade_in_label_align.add (fade_in_label);
fade_in_label_align.set (0.5);
- fade_in_table.attach (fade_in_label_align, 0, 2, 0, 1, GTK_FILL|GTK_EXPAND, 0, 0, 0);
+ fade_in_table.attach (fade_in_label_align, 0, 2, 0, 1, Gtk::FILL|Gtk::EXPAND, 0, 0, 0);
- fade_in_table.attach (fade_in_length_label, 0, 1, 1, 2, GTK_EXPAND, 0, 0, 0);
- fade_in_table.attach (fade_in_length_spinner, 0, 1, 2, 3, GTK_FILL|GTK_EXPAND, 0, 0, 0);
+ fade_in_table.attach (fade_in_length_label, 0, 1, 1, 2, Gtk::EXPAND, 0, 0, 0);
+ fade_in_table.attach (fade_in_length_spinner, 0, 1, 2, 3, Gtk::FILL|Gtk::EXPAND, 0, 0, 0);
- fade_in_table.attach (fade_in_active_button, 0, 2, 3, 5, GTK_FILL|GTK_EXPAND, 0);
+ fade_in_table.attach (fade_in_active_button, 0, 2, 3, 5, Gtk::FILL|Gtk::EXPAND, 0);
/* fade out */
fade_out_length_spinner.set_digits (3);
- fade_out_length_spinner.focus_in_event.connect (slot (*this, &AudioRegionEditor::focus_change));
- fade_out_length_spinner.focus_out_event.connect (slot (*this, &AudioRegionEditor::focus_change));
+ fade_out_length_spinner.signal_focus_in_event().connect (slot (*this, &AudioRegionEditor::focus_change));
+ fade_out_length_spinner.signal_focus_out_event().connect (slot (*this, &AudioRegionEditor::focus_change));
fade_out_length_spinner.activate.connect (slot (*this, &AudioRegionEditor::activation));
- Gtkmmext::set_usize_to_display_given_text (fade_out_length_spinner, "500g", 20, -1);
+ Gtkmm2ext::set_size_request_to_display_given_text (fade_out_length_spinner, "500g", 20, -1);
fade_out_label_align.add (fade_out_label);
fade_out_label_align.set (0.5);
- fade_out_table.attach (fade_out_label_align, 0, 2, 0, 1, GTK_FILL|GTK_EXPAND, 0, 0, 0);
+ fade_out_table.attach (fade_out_label_align, 0, 2, 0, 1, Gtk::FILL|Gtk::EXPAND, 0, 0, 0);
- fade_out_table.attach (fade_out_length_label, 0, 1, 1, 2, GTK_EXPAND, 0, 0, 0);
- fade_out_table.attach (fade_out_length_spinner, 0, 1, 2, 3, GTK_FILL|GTK_EXPAND, 0, 0, 0);
+ fade_out_table.attach (fade_out_length_label, 0, 1, 1, 2, Gtk::EXPAND, 0, 0, 0);
+ fade_out_table.attach (fade_out_length_spinner, 0, 1, 2, 3, Gtk::FILL|Gtk::EXPAND, 0, 0, 0);
- fade_out_table.attach (fade_out_active_button, 0, 2, 3, 5, GTK_FILL|GTK_EXPAND, 0);
+ fade_out_table.attach (fade_out_active_button, 0, 2, 3, 5, Gtk::FILL|Gtk::EXPAND, 0);
lower_hbox.pack_start (time_table, true, true);
lower_hbox.pack_start (sep1, false, false);
add (upper_vbox);
set_name ("AudioRegionEditorWindow");
- add_events (GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK);
+ add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
delete_event.connect (bind (slot (just_hide_it), static_cast<Window *> (this)));
case 3:
if (ev->type == GDK_BUTTON_PRESS) { /* no double clicks here */
if (!spin_arrow_grab) {
- if ((ev->window == but->gtkobj()->panel)) {
+ if ((ev->window == but->gobj()->panel)) {
spin_arrow_grab = true;
(this->*pmf)();
}
envelope_active_button.button_release_event.connect (slot (*this, &AudioRegionEditor::envelope_active_button_release));
audition_button.toggled.connect (slot (*this, &AudioRegionEditor::audition_button_toggled));
envelope_view_button.toggled.connect (slot (*this, &AudioRegionEditor::envelope_view_button_toggled));
- lock_button.clicked.connect (slot (*this, &AudioRegionEditor::lock_button_clicked));
- mute_button.clicked.connect (slot (*this, &AudioRegionEditor::mute_button_clicked));
- opaque_button.clicked.connect (slot (*this, &AudioRegionEditor::opaque_button_clicked));
- raise_button.clicked.connect (slot (*this, &AudioRegionEditor::raise_button_clicked));
- lower_button.clicked.connect (slot (*this, &AudioRegionEditor::lower_button_clicked));
+ lock_button.signal_clicked().connect (slot (*this, &AudioRegionEditor::lock_button_clicked));
+ mute_button.signal_clicked().connect (slot (*this, &AudioRegionEditor::mute_button_clicked));
+ opaque_button.signal_clicked().connect (slot (*this, &AudioRegionEditor::opaque_button_clicked));
+ raise_button.signal_clicked().connect (slot (*this, &AudioRegionEditor::raise_button_clicked));
+ lower_button.signal_clicked().connect (slot (*this, &AudioRegionEditor::lower_button_clicked));
}
void
#include <map>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <gtk-canvas.h>
-#include <sigc++/signal_system.h>
+#include <sigc++/signal.h>
#include "audio_clock.h"
#include "ardour_dialog.h"
#include <ardour/ardour.h>
#include <gtk-canvas.h>
-#include <gtk--.h>
+#include <gtkmm.h>
#include "automation_line.h"
#include "region_selection.h"
using namespace ARDOUR;
-using namespace SigC;
+using namespace sigc;
bool
#include <set>
#include <list>
-#include <sigc++/signal_system.h>
+#include <sigc++/signal.h>
#include <ardour/types.h>
using std::list;
bool operator() (const AudioRegionView* a, const AudioRegionView* b) const;
};
-class AudioRegionSelection : public set<AudioRegionView*, AudioRegionComparator>, public SigC::Object
+class AudioRegionSelection : public set<AudioRegionView*, AudioRegionComparator>, public sigc::trackable
{
public:
AudioRegionSelection();
#include <cmath>
#include <algorithm>
-#include <gtk--.h>
+#include <gtkmm.h>
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm2ext/gtk_ui.h>
#include <ardour/playlist.h>
#include <ardour/audioregion.h>
#include "i18n.h"
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
using namespace Editing;
static const int32_t sync_mark_width = 9;
-SigC::Signal1<void,AudioRegionView*> AudioRegionView::AudioRegionViewGoingAway;
+sigc::signal<void,AudioRegionView*> AudioRegionView::AudioRegionViewGoingAway;
AudioRegionView::AudioRegionView (GtkCanvasGroup *parent, AudioTimeAxisView &tv,
AudioRegion& r,
void
AudioRegionView::peaks_ready_handler (uint32_t which)
{
- Gtkmmext::UI::instance()->call_slot (bind (slot (*this, &AudioRegionView::create_one_wave), which, false));
+ Gtkmm2ext::UI::instance()->call_slot (bind (slot (*this, &AudioRegionView::create_one_wave), which, false));
}
void
#define __gtk_ardour_region_view_h__
#include <vector>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <gtk-canvas.h>
-#include <sigc++/signal_system.h>
+#include <sigc++/signal.h>
#include <ardour/region.h>
#include "time_axis_view_item.h"
void region_changed (ARDOUR::Change);
void envelope_active_changed ();
- static SigC::Signal1<void,AudioRegionView*> AudioRegionViewGoingAway;
- SigC::Signal0<void> GoingAway;
+ static sigc::signal<void,AudioRegionView*> AudioRegionViewGoingAway;
+ sigc::signal<void> GoingAway;
GhostRegion* add_ghost (AutomationTimeAxisView&);
void remove_ghost (GhostRegion*);
#include <algorithm>
#include <pbd/lockmonitor.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/stop_signal.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/stop_signal.h>
#include <ardour/session.h>
#include <ardour/session_route.h>
using namespace ARDOUR;
using namespace Gtk;
-using namespace SigC;
+using namespace sigc;
static const gchar *route_display_titles[] = { N_("Tracks/Buses"), 0 };
static const gchar *pre_display_titles[] = { N_("Pre Redirects"), 0 };
route_select_list.column_titles_active();
route_select_list.set_name ("RouteParamsListDisplay");
- route_select_list.set_shadow_type (GTK_SHADOW_IN);
+ route_select_list.set_shadow_type (Gtk::SHADOW_IN);
route_select_list.set_selection_mode (GTK_SELECTION_SINGLE);
route_select_list.set_reorderable (false);
- route_select_list.set_usize (75, -1);
+ route_select_list.set_size_request (75, -1);
route_select_scroller.add (route_select_list);
- route_select_scroller.set_policy (GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+ route_select_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
route_select_frame.set_name("RouteSelectBaseFrame");
- route_select_frame.set_shadow_type (GTK_SHADOW_IN);
+ route_select_frame.set_shadow_type (Gtk::SHADOW_IN);
route_select_frame.add(route_select_scroller);
list_vpacker.pack_start (route_select_frame, true, true);
// changeable area
route_param_frame.set_name("RouteParamsBaseFrame");
- route_param_frame.set_shadow_type (GTK_SHADOW_IN);
+ route_param_frame.set_shadow_type (Gtk::SHADOW_IN);
route_hpacker.pack_start (notebook, true, true);
route_select_list.click_column.connect (slot (*this, &RouteParams_UI::show_track_menu));
- add_events (GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK|GDK_BUTTON_RELEASE_MASK);
+ add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::BUTTON_RELEASE_MASK);
_plugin_selector = new PluginSelector (PluginManager::the_manager());
_plugin_selector->delete_event.connect (bind (slot (just_hide_it),
#include <list>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <ardour/ardour.h>
#include <ardour/stateful.h>
RouteRedirectSelection _rr_selection;
ARDOUR::Route *_route;
- SigC::Connection _route_conn;
- SigC::Connection _route_ds_conn;
+ sigc::connection _route_conn;
+ sigc::connection _route_ds_conn;
ARDOUR::Redirect * _pre_redirect;
- SigC::Connection _pre_plugin_conn;
+ sigc::connection _pre_plugin_conn;
ARDOUR::Redirect * _post_redirect;
- SigC::Connection _post_plugin_conn;
+ sigc::connection _post_plugin_conn;
enum ConfigView {
void update_title ();
//void unselect_all_redirects ();
- SigC::Connection update_connection;
+ sigc::connection update_connection;
void update_views ();
void start_updating ();
#include "i18n.h"
using namespace ARDOUR;
-using namespace SigC;
+using namespace sigc;
RouteRedirectSelection&
RouteRedirectSelection::operator= (const RouteRedirectSelection& other)
#define __ardour_gtk_route_redirect_selection_h__
#include <vector>
-#include <sigc++/signal_system.h>
+#include <sigc++/signal.h>
#include "redirect_selection.h"
#include "route_selection.h"
-class RouteRedirectSelection : public SigC::Object
+class RouteRedirectSelection : public sigc::trackable
{
public:
RedirectSelection redirects;
RouteRedirectSelection& operator= (const RouteRedirectSelection& other);
- SigC::Signal0<void> RedirectsChanged;
- SigC::Signal0<void> RoutesChanged;
+ sigc::signal<void> RedirectsChanged;
+ sigc::signal<void> RoutesChanged;
void clear ();
bool empty();
$Id$
*/
-#include <gtkmmext/gtk_ui.h>
-#include <gtkmmext/stop_signal.h>
-#include <gtkmmext/choice.h>
-#include <gtkmmext/bindable_button.h>
-#include <gtkmmext/doi.h>
+#include <gtkmm2ext/gtk_ui.h>
+#include <gtkmm2ext/stop_signal.h>
+#include <gtkmm2ext/choice.h>
+#include <gtkmm2ext/bindable_button.h>
+#include <gtkmm2ext/doi.h>
#include <ardour/route_group.h>
#include "i18n.h"
-using namespace SigC;
+using namespace sigc;
using namespace Gtk;
-using namespace Gtkmmext;
+using namespace Gtkmm2ext;
using namespace ARDOUR;
rec_enable_button = manage (new BindableToggleButton (0, r_name ));
}
- mute_button->unset_flags (GTK_CAN_FOCUS);
- solo_button->unset_flags (GTK_CAN_FOCUS);
- rec_enable_button->unset_flags (GTK_CAN_FOCUS);
+ mute_button->unset_flags (Gtk::CAN_FOCUS);
+ solo_button->unset_flags (Gtk::CAN_FOCUS);
+ rec_enable_button->unset_flags (Gtk::CAN_FOCUS);
/* map the current state */
void
RouteUI::solo_changed(void* src)
{
- Gtkmmext::UI::instance()->call_slot (slot (*this, &RouteUI::update_solo_display));
+ Gtkmm2ext::UI::instance()->call_slot (slot (*this, &RouteUI::update_solo_display));
}
void
void
RouteUI::mute_changed(void* src)
{
- Gtkmmext::UI::instance()->call_slot (slot (*this, &RouteUI::update_mute_display));
+ Gtkmm2ext::UI::instance()->call_slot (slot (*this, &RouteUI::update_mute_display));
}
void
void
RouteUI::route_rec_enable_changed (void *src)
{
- Gtkmmext::UI::instance()->call_slot (slot (*this, &RouteUI::update_rec_display));
+ Gtkmm2ext::UI::instance()->call_slot (slot (*this, &RouteUI::update_rec_display));
}
void
RouteUI::session_rec_enable_changed ()
{
- Gtkmmext::UI::instance()->call_slot (slot (*this, &RouteUI::update_rec_display));
+ Gtkmm2ext::UI::instance()->call_slot (slot (*this, &RouteUI::update_rec_display));
}
void
}
} else {
- if (rec_enable_button->get_state() != GTK_STATE_NORMAL) {
- rec_enable_button->set_state (GTK_STATE_NORMAL);
+ if (rec_enable_button->get_state() != Gtk::STATE_NORMAL) {
+ rec_enable_button->set_state (Gtk::STATE_NORMAL);
}
}
}
current[2] = _color.get_blue() / 65535.0;
current[3] = 1.0;
- color = Gtkmmext::UI::instance()->get_color (_("ardour: color selection"), picked, current);
+ color = Gtkmm2ext::UI::instance()->get_color (_("ardour: color selection"), picked, current);
if (picked) {
set_color (color);
Gtk::Main::run();
- if (name_prompter.status == Gtkmmext::Prompter::cancelled) {
+ if (name_prompter.status == Gtkmm2ext::Prompter::cancelled) {
return;
}
RouteUI::route_active_changed ()
{
if (route_active_menu_item) {
- Gtkmmext::UI::instance()->call_slot (bind (slot (*route_active_menu_item, &CheckMenuItem::set_active), _route.active()));
+ Gtkmm2ext::UI::instance()->call_slot (bind (slot (*route_active_menu_item, &CheckMenuItem::set_active), _route.active()));
}
}
#include <list>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <pbd/xml++.h>
#include <ardour/ardour.h>
#include <ardour/route.h>
#include "axis_view.h"
-namespace Gtkmmext {
+namespace Gtkmm2ext {
class BindableToggleButton;
}
bool ignore_toggle;
bool wait_for_release;
- Gtkmmext::BindableToggleButton * mute_button;
- Gtkmmext::BindableToggleButton * solo_button;
- Gtkmmext::BindableToggleButton * rec_enable_button;
+ Gtkmm2ext::BindableToggleButton * mute_button;
+ Gtkmm2ext::BindableToggleButton * solo_button;
+ Gtkmm2ext::BindableToggleButton * rec_enable_button;
virtual string solo_button_name () const { return "SoloButton"; }
virtual string safe_solo_button_name () const { return "SafeSoloButton"; }
int set_color_from_route ();
- SigC::Connection blink_connection;
+ sigc::connection blink_connection;
void rec_enable_button_blink (bool onoff, ARDOUR::DiskStream *, Gtk::Widget *w);
#include "i18n.h"
using namespace ARDOUR;
-using namespace SigC;
+using namespace sigc;
struct AudioRangeComparator {
bool operator()(AudioRange a, AudioRange b) {
for (list<TimeAxisView*>::const_iterator i = track_list.begin(); i != track_list.end(); ++i) {
if (find (tracks.begin(), tracks.end(), (*i)) == tracks.end()) {
void (Selection::*pmf)(TimeAxisView*) = &Selection::remove;
- (*i)->GoingAway.connect (bind (slot (*this, pmf), (*i)));
+ (*i)->GoingAway.connect (sigc::bind (mem_fun (*this, pmf), (*i)));
tracks.push_back (*i);
changed = true;
}
{
if (find (tracks.begin(), tracks.end(), track) == tracks.end()) {
void (Selection::*pmf)(TimeAxisView*) = &Selection::remove;
- track->GoingAway.connect (bind (slot (*this, pmf), track));
+ track->GoingAway.connect (sigc::bind (mem_fun (*this, pmf), track));
tracks.push_back (track);
TracksChanged();
}
#ifndef __ardour_gtk_selection_h__
#define __ardour_gtk_selection_h__
-#include <sigc++/signal_system.h>
+#include <sigc++/signal.h>
#include "time_selection.h"
#include "region_selection.h"
class AudioRegionView;
class Selectable;
-class Selection : public SigC::Object
+class Selection : public sigc::trackable
{
public:
enum SelectionType {
Selection& operator= (const Selection& other);
- SigC::Signal0<void> RegionsChanged;
- SigC::Signal0<void> TracksChanged;
- SigC::Signal0<void> TimeChanged;
- SigC::Signal0<void> LinesChanged;
- SigC::Signal0<void> PlaylistsChanged;
- SigC::Signal0<void> RedirectsChanged;
- SigC::Signal0<void> PointsChanged;
+ sigc::signal<void> RegionsChanged;
+ sigc::signal<void> TracksChanged;
+ sigc::signal<void> TimeChanged;
+ sigc::signal<void> LinesChanged;
+ sigc::signal<void> PlaylistsChanged;
+ sigc::signal<void> RedirectsChanged;
+ sigc::signal<void> PointsChanged;
void clear ();
bool empty();
*/
#include <ardour/send.h>
-#include <gtkmmext/doi.h>
+#include <gtkmm2ext/doi.h>
#include "utils.h"
#include "send_ui.h"
Gtk::VBox vbox;
Gtk::VBox hbox;
- SigC::Connection screen_update_connection;
- SigC::Connection fast_screen_update_connection;
+ sigc::connection screen_update_connection;
+ sigc::connection fast_screen_update_connection;
void send_going_away (ARDOUR::Redirect*);
void ins_changed (ARDOUR::IOChange, void*);
#include <cmath>
-#include <gtk--.h>
+#include <gtkmm.h>
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm2ext/gtk_ui.h>
#include <ardour/audioplaylist.h>
#include <ardour/audioregion.h>
{
ENSURE_GUI_THREAD(bind (slot (*this, &StreamView::remove_rec_region), r));
- if (!Gtkmmext::UI::instance()->caller_is_gui_thread()) {
+ if (!Gtkmm2ext::UI::instance()->caller_is_gui_thread()) {
fatal << "region deleted from non-GUI thread!" << endmsg;
/*NOTREACHED*/
}
/* disconnect from old playlist */
- for (vector<SigC::Connection>::iterator i = playlist_connections.begin(); i != playlist_connections.end(); ++i) {
+ for (vector<sigc::connection>::iterator i = playlist_connections.begin(); i != playlist_connections.end(); ++i) {
(*i).disconnect();
}
if ((at = _trackview.audio_track()) != 0) {
DiskStream& ds = at->disk_stream();
/* XXX grrr: when will SigC++ allow me to bind references? */
- Gtkmmext::UI::instance()->call_slot (bind (slot (*this, &StreamView::display_diskstream), &ds));
+ Gtkmm2ext::UI::instance()->call_slot (bind (slot (*this, &StreamView::display_diskstream), &ds));
} else {
- Gtkmmext::UI::instance()->call_slot (slot (*this, &StreamView::undisplay_diskstream));
+ Gtkmm2ext::UI::instance()->call_slot (slot (*this, &StreamView::undisplay_diskstream));
}
}
void
StreamView::rec_enable_changed (void *src)
{
- Gtkmmext::UI::instance()->call_slot (slot (*this, &StreamView::setup_rec_box));
+ Gtkmm2ext::UI::instance()->call_slot (slot (*this, &StreamView::setup_rec_box));
}
void
StreamView::sess_rec_enable_changed ()
{
- Gtkmmext::UI::instance()->call_slot (slot (*this, &StreamView::setup_rec_box));
+ Gtkmm2ext::UI::instance()->call_slot (slot (*this, &StreamView::setup_rec_box));
}
void
StreamView::transport_changed()
{
- Gtkmmext::UI::instance()->call_slot (slot (*this, &StreamView::setup_rec_box));
+ Gtkmm2ext::UI::instance()->call_slot (slot (*this, &StreamView::setup_rec_box));
}
void
AudioRegion::SourceList sources;
- for (list<SigC::Connection>::iterator prc = peak_ready_connections.begin(); prc != peak_ready_connections.end(); ++prc) {
+ for (list<sigc::connection>::iterator prc = peak_ready_connections.begin(); prc != peak_ready_connections.end(); ++prc) {
(*prc).disconnect();
}
peak_ready_connections.clear();
/* disconnect rapid update */
screen_update_connection.disconnect();
- for (list<SigC::Connection>::iterator prc = peak_ready_connections.begin(); prc != peak_ready_connections.end(); ++prc) {
+ for (list<sigc::connection>::iterator prc = peak_ready_connections.begin(); prc != peak_ready_connections.end(); ++prc) {
(*prc).disconnect();
}
peak_ready_connections.clear();
}
void
-StreamView::foreach_regionview (SigC::Slot1<void,AudioRegionView*> slot)
+StreamView::foreach_regionview (sigc::slot<void,AudioRegionView*> slot)
{
for (list<AudioRegionView*>::iterator i = region_views.begin(); i != region_views.end(); ++i) {
slot (*i);
#include <map>
#include <cmath>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <gtk-canvas.h>
#include <ardour/location.h>
class CrossfadeView;
class Selection;
-class StreamView : public SigC::Object
+class StreamView : public sigc::trackable
{
public:
StreamView (AudioTimeAxisView&);
GtkCanvasItem* canvas_item() { return canvas_group; }
- SigC::Signal1<void,AudioRegionView*> AudioRegionViewAdded;
+ sigc::signal<void,AudioRegionView*> AudioRegionViewAdded;
enum ColorTarget {
RegionColor,
void get_inverted_selectables (Selection&, list<Selectable* >& results);
GdkColor get_region_color () const { return region_color; }
- void foreach_regionview (SigC::Slot1<void,AudioRegionView*> slot);
+ void foreach_regionview (sigc::slot<void,AudioRegionView*> slot);
void foreach_crossfadeview (void (CrossfadeView::*pmf)(void));
void attach ();
double _samples_per_unit;
double _amplitude_above_axis;
- SigC::Connection screen_update_connection;
+ sigc::connection screen_update_connection;
vector<RecBoxInfo> rec_rects;
list<ARDOUR::AudioRegion* > rec_regions;
bool rec_updating;
bool rec_active;
bool use_rec_regions;
- list<SigC::Connection> peak_ready_connections;
+ list<sigc::connection> peak_ready_connections;
jack_nframes_t last_rec_peak_frame;
map<ARDOUR::Source*, bool> rec_peak_ready_map;
GdkColor region_color;
uint32_t stream_base_color;
- vector<SigC::Connection> playlist_connections;
- SigC::Connection playlist_change_connection;
+ vector<sigc::connection> playlist_connections;
+ sigc::connection playlist_change_connection;
};
#endif /* __ardour_streamview_h__ */
#include <cstdio> // for snprintf, grrr
-#include <gtkmmext/utils.h>
+#include <gtkmm2ext/utils.h>
#include "tempo_dialog.h"
when_bar_label.set_name ("MetricLabel");
when_beat_label.set_name ("MetricLabel");
- Gtkmmext::set_usize_to_display_given_text (when_bar_entry, "999g", 5, 7);
- Gtkmmext::set_usize_to_display_given_text (when_beat_entry, "999g", 5, 7);
+ Gtkmm2ext::set_size_request_to_display_given_text (when_bar_entry, "999g", 5, 7);
+ Gtkmm2ext::set_size_request_to_display_given_text (when_beat_entry, "999g", 5, 7);
when_table.set_homogeneous (true);
when_table.set_row_spacings (2);
when_table.set_col_spacings (2);
when_table.set_border_width (5);
- when_table.attach (when_bar_label, 0, 1, 0, 1, 0, GTK_FILL|GTK_EXPAND);
- when_table.attach (when_bar_entry, 0, 1, 1, 2, 0, GTK_FILL|GTK_EXPAND);
+ when_table.attach (when_bar_label, 0, 1, 0, 1, 0, Gtk::FILL|Gtk::EXPAND);
+ when_table.attach (when_bar_entry, 0, 1, 1, 2, 0, Gtk::FILL|Gtk::EXPAND);
when_table.attach (when_beat_label, 1, 2, 0, 1, 0, 0);
when_table.attach (when_beat_entry, 1, 2, 1, 2, 0, 0);
snprintf (buf, sizeof (buf), "%.2f", bpb);
bpb_entry.set_text (buf);
bpb_entry.select_region (0, -1);
- Gtkmmext::set_usize_to_display_given_text (bpb_entry, "999999g", 5, 5);
+ Gtkmm2ext::set_size_request_to_display_given_text (bpb_entry, "999999g", 5, 5);
strings.push_back (_("whole (1)"));
note_types.get_entry()->set_text(_("quarter (4)"));
/* strings.back() just happens to be the longest one to display */
- Gtkmmext::set_usize_to_display_given_text (*(note_types.get_entry()), strings.back(), 7, 7);
+ Gtkmm2ext::set_size_request_to_display_given_text (*(note_types.get_entry()), strings.back(), 7, 7);
hspacer1.set_border_width (5);
hspacer1.pack_start (note_types, false, false);
when_bar_label.set_name ("MetricLabel");
when_beat_label.set_name ("MetricLabel");
- Gtkmmext::set_usize_to_display_given_text (when_bar_entry, "999g", 5, 7);
- Gtkmmext::set_usize_to_display_given_text (when_beat_entry, "999g", 5, 7);
+ Gtkmm2ext::set_size_request_to_display_given_text (when_bar_entry, "999g", 5, 7);
+ Gtkmm2ext::set_size_request_to_display_given_text (when_beat_entry, "999g", 5, 7);
when_table.set_homogeneous (true);
when_table.set_row_spacings (2);
when_table.set_col_spacings (2);
when_table.set_border_width (5);
- when_table.attach (when_bar_label, 0, 1, 0, 1, 0, GTK_FILL|GTK_EXPAND);
- when_table.attach (when_bar_entry, 0, 1, 1, 2, 0, GTK_FILL|GTK_EXPAND);
+ when_table.attach (when_bar_label, 0, 1, 0, 1, 0, Gtk::FILL|Gtk::EXPAND);
+ when_table.attach (when_bar_entry, 0, 1, 1, 2, 0, Gtk::FILL|Gtk::EXPAND);
when_table.attach (when_beat_label, 1, 2, 0, 1, 0, 0);
when_table.attach (when_beat_entry, 1, 2, 1, 2, 0, 0);
#ifndef __ardour_gtk_tempo_dialog_h__
#define __ardour_gtk_tempo_dialog_h__
-#include <gtk--.h>
+#include <gtkmm.h>
#include <ardour/types.h>
#include <ardour/tempo.h>
#include <pbd/error.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/selector.h>
-#include <gtkmmext/stop_signal.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/selector.h>
+#include <gtkmm2ext/stop_signal.h>
#include <ardour/session.h>
#include <ardour/utils.h>
#include "i18n.h"
using namespace Gtk;
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
using namespace Editing;
editor(ed),
controls_table (2, 9)
{
- canvas_display = gtk_canvas_item_new (gtk_canvas_root(GTK_CANVAS(canvas->gtkobj())),
+ canvas_display = gtk_canvas_item_new (gtk_canvas_root(GTK_CANVAS(canvas->gobj())),
gtk_canvas_group_get_type(),
"x", 0.0,
"y", 0.0,
name_entry.button_release_event.connect (slot (*this, &TimeAxisView::name_entry_button_release));
name_entry.button_press_event.connect (slot (*this, &TimeAxisView::name_entry_button_press));
- name_entry.focus_in_event.connect (slot (ARDOUR_UI::generic_focus_in_event));
- name_entry.focus_out_event.connect (slot (ARDOUR_UI::generic_focus_out_event));
+ name_entry.signal_focus_in_event().connect (slot (ARDOUR_UI::generic_focus_in_event));
+ name_entry.signal_focus_out_event().connect (slot (ARDOUR_UI::generic_focus_out_event));
- Gtkmmext::set_usize_to_display_given_text (name_entry, N_("gTortnam"), 10, 10); // just represents a short name
+ Gtkmm2ext::set_size_request_to_display_given_text (name_entry, N_("gTortnam"), 10, 10); // just represents a short name
name_label.set_name ("TrackLabel");
name_label.set_alignment (0.0, 0.5);
controls_table.set_homogeneous (true);
controls_table.show ();
- controls_table.attach (name_hbox, 0, 5, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (name_hbox, 0, 5, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
controls_table.show ();
controls_ebox.set_name ("TimeAxisViewControlsBaseUnselected");
controls_ebox.add (controls_vbox);
- controls_ebox.add_events (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
- controls_ebox.set_flags (GTK_CAN_FOCUS);
+ controls_ebox.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
+ controls_ebox.set_flags (Gtk::CAN_FOCUS);
controls_ebox.button_release_event.connect (slot (*this, &TimeAxisView::controls_ebox_button_release));
controls_frame.add (controls_hbox);
controls_frame.set_name ("TimeAxisViewControlsBaseUnselected");
- controls_frame.set_shadow_type (GTK_SHADOW_OUT);
+ controls_frame.set_shadow_type (Gtk::SHADOW_OUT);
}
TimeAxisView::~TimeAxisView()
TimeAxisView::set_height (TrackHeight h)
{
height = (guint32) h;
- controls_frame.set_usize (-1, height);
+ controls_frame.set_size_request (-1, height);
if (GTK_OBJECT_FLAGS(GTK_OBJECT(selection_group)) & GTK_CANVAS_ITEM_VISIBLE) {
/* resize the selection rect */
#include <vector>
#include <list>
-#include <gtk--.h>
+#include <gtkmm.h>
#include <gtk-canvas.h>
#include <ardour/types.h>
#ifndef __gtk_ardour_time_axis_view_item_h__
#define __gtk_ardour_time_axis_view_item_h__
-#include <sigc++/signal_system.h>
+#include <sigc++/signal.h>
#include <gtk-canvas.h>
#include <jack/jack.h>
#include <string>
* A base class for 'items' that may appear upon a TimeAxisView
*
*/
-class TimeAxisViewItem : public SigC::Object, public Selectable
+class TimeAxisViewItem : public sigc::trackable, public Selectable
{
public:
virtual ~TimeAxisViewItem() ;
* the destructor, this allows us to capture the source of the deletion
* event
*/
- SigC::Signal2<void,std::string,void*> ItemRemoved ;
+ sigc::signal<void,std::string,void*> ItemRemoved ;
/** Emitted when the name/Id of this item is changed */
- SigC::Signal3<void,std::string,std::string,void*> NameChanged ;
+ sigc::signal<void,std::string,std::string,void*> NameChanged ;
/** Emiited when the position of this item changes */
- SigC::Signal2<void,jack_nframes_t,void*> PositionChanged ;
+ sigc::signal<void,jack_nframes_t,void*> PositionChanged ;
/** Emitted when the position lock of this item is changed */
- SigC::Signal2<void,bool,void*> PositionLockChanged ;
+ sigc::signal<void,bool,void*> PositionLockChanged ;
/** Emitted when the duration of this item changes */
- SigC::Signal2<void,jack_nframes_t,void*> DurationChanged ;
+ sigc::signal<void,jack_nframes_t,void*> DurationChanged ;
/** Emitted when the maximum item duration is changed */
- SigC::Signal2<void,jack_nframes_t,void*> MaxDurationChanged ;
+ sigc::signal<void,jack_nframes_t,void*> MaxDurationChanged ;
/** Emitted when the mionimum item duration is changed */
- SigC::Signal2<void,jack_nframes_t,void*> MinDurationChanged ;
+ sigc::signal<void,jack_nframes_t,void*> MinDurationChanged ;
/** Emitted when the selected status of this item changes */
- SigC::Signal1<void, bool> Selected ;
+ sigc::signal<void, bool> Selected ;
protected:
#include <cstdlib>
#include <cctype>
#include <libart_lgpl/art_misc.h>
-#include <gtk--/window.h>
-#include <gtk--/combo.h>
-#include <gtk--/label.h>
-#include <gtk--/paned.h>
+#include <gtkmm/window.h>
+#include <gtkmm/combo.h>
+#include <gtkmm/label.h>
+#include <gtkmm/paned.h>
#include <gtk/gtkpaned.h>
-#include <gtkmmext/utils.h>
+#include <gtkmm2ext/utils.h>
#include "ardour_ui.h"
#include "utils.h"
foobar.set_name (widgetname);
foobar.ensure_style();
- if (foobar.get_style() == 0 || foobar.get_style()->gtkobj()->rc_style == 0 || foobar.get_style()->gtkobj()->rc_style->font_name == 0) {
+ if (foobar.get_style() == 0 || foobar.get_style()->gobj()->rc_style == 0 || foobar.get_style()->gobj()->rc_style->font_name == 0) {
return "fixed";
}
- string str = foobar.get_style()->gtkobj()->rc_style->font_name;
+ string str = foobar.get_style()->gobj()->rc_style->font_name;
if (str.empty()) {
return "fixed"; // standard X Window fallback font
gint
pane_handler (GdkEventButton* ev, Gtk::Paned* pane)
{
- if (ev->window != Gtkmmext::get_paned_handle (*pane)) {
+ if (ev->window != Gtkmm2ext::get_paned_handle (*pane)) {
return FALSE;
}
gint pos;
gint cmp;
- pos = Gtkmmext::gtk_paned_get_position (pane->gtkobj());
+ pos = Gtkmm2ext::gtk_paned_get_position (pane->gobj());
if (dynamic_cast<VPaned*>(pane)) {
cmp = pane->height();
foo.set_name (style);
foo.ensure_style ();
- GtkRcStyle* waverc = foo.get_style()->gtkobj()->rc_style;
+ GtkRcStyle* waverc = foo.get_style()->gobj()->rc_style;
if (waverc) {
- r = waverc->fg[GTK_STATE_NORMAL].red / 257;
- g = waverc->fg[GTK_STATE_NORMAL].green / 257;
- b = waverc->fg[GTK_STATE_NORMAL].blue / 257;
+ r = waverc->fg[Gtk::STATE_NORMAL].red / 257;
+ g = waverc->fg[Gtk::STATE_NORMAL].green / 257;
+ b = waverc->fg[Gtk::STATE_NORMAL].blue / 257;
/* what a hack ... "a" is for "active" */
#include <pbd/error.h>
#include <pbd/stl_delete.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/selector.h>
-#include <gtkmmext/gtk_ui.h>
-#include <gtkmmext/stop_signal.h>
-#include <gtkmmext/choice.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/selector.h>
+#include <gtkmm2ext/gtk_ui.h>
+#include <gtkmm2ext/stop_signal.h>
+#include <gtkmm2ext/choice.h>
#include <ardour/session.h>
#include <ardour/utils.h>
#include "i18n.h"
using namespace ARDOUR;
-using namespace SigC;
+using namespace sigc;
using namespace Gtk;
//XXX should really have a common home...
size_button.set_name("TrackSizeButton") ;
visual_button.set_name("TrackVisualButton") ;
hide_button.set_name("TrackRemoveButton") ;
- hide_button.add(*(Gtk::manage(new Gtk::Pixmap(small_x_xpm)))) ;
+ hide_button.add(*(Gtk::manage(new Gtk::Image(small_x_xpm)))) ;
size_button.button_release_event.connect (slot (*this, &VisualTimeAxis::size_click)) ;
- visual_button.clicked.connect (slot (*this, &VisualTimeAxis::visual_click)) ;
- hide_button.clicked.connect (slot (*this, &VisualTimeAxis::hide_click)) ;
+ visual_button.signal_clicked().connect (slot (*this, &VisualTimeAxis::visual_click)) ;
+ hide_button.signal_clicked().connect (slot (*this, &VisualTimeAxis::hide_click)) ;
ARDOUR_UI::instance()->tooltips().set_tip(size_button,_("Display Height")) ;
ARDOUR_UI::instance()->tooltips().set_tip(visual_button, _("Visual options")) ;
ARDOUR_UI::instance()->tooltips().set_tip(hide_button, _("Hide this track")) ;
- controls_table.attach (hide_button, 0, 1, 1, 2, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
- controls_table.attach (visual_button, 1, 2, 1, 2, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
- controls_table.attach (size_button, 2, 3, 1, 2, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND);
+ controls_table.attach (hide_button, 0, 1, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
+ controls_table.attach (visual_button, 1, 2, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
+ controls_table.attach (size_button, 2, 3, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
/* remove focus from the buttons */
- size_button.unset_flags(GTK_CAN_FOCUS) ;
- hide_button.unset_flags(GTK_CAN_FOCUS) ;
- visual_button.unset_flags(GTK_CAN_FOCUS) ;
+ size_button.unset_flags(Gtk::CAN_FOCUS) ;
+ hide_button.unset_flags(Gtk::CAN_FOCUS) ;
+ visual_button.unset_flags(Gtk::CAN_FOCUS) ;
set_height(Normal) ;
}
current[2] = _color.get_blue() / 65535.0 ;
current[3] = 1.0 ;
- color = Gtkmmext::UI::instance()->get_color(_("ardour: color selection"),picked, current) ;
+ color = Gtkmm2ext::UI::instance()->get_color(_("ardour: color selection"),picked, current) ;
if (picked)
{
choices.push_back (_("Yes, remove it."));
choices.push_back (_("No, do nothing."));
- Gtkmmext::Choice prompter (prompt, choices);
+ Gtkmm2ext::Choice prompter (prompt, choices);
prompter.chosen.connect (Gtk::Main::quit.slot());
prompter.show_all ();
name_prompter->hide_all () ;
ARDOUR_UI::instance()->allow_focus (false) ;
- if (name_prompter->status == Gtkmmext::Prompter::cancelled)
+ if (name_prompter->status == Gtkmm2ext::Prompter::cancelled)
{
return;
}
#ifndef __ardour_visual_time_axis_h__
#define __ardour_visual_time_axis_h__
-#include <gtk--.h>
+#include <gtkmm.h>
#include <gtk-canvas.h>
-#include <gtkmmext/selector.h>
-#include <gtkmmext/popup_selector.h>
+#include <gtkmm2ext/selector.h>
+#include <gtkmm2ext/popup_selector.h>
#include "ardour_dialog.h"
#include "route_ui.h"
/**
* Emitted when we have changed the gui, and what we have shanged
*/
- SigC::Signal2<void,string,void*> gui_changed ;
+ sigc::signal<void,string,void*> gui_changed ;
/**
* Emitted when this Visual Time Axis has been removed
* the destructor, this allows us to capture the source of the deletion
* event
*/
- SigC::Signal2<void,std::string,void*> VisualTimeAxisRemoved ;
+ sigc::signal<void,std::string,void*> VisualTimeAxisRemoved ;
/**
* Emitted when we have changed the name of this TimeAxis
*/
- SigC::Signal3<void,std::string,std::string,void*> NameChanged ;
+ sigc::signal<void,std::string,std::string,void*> NameChanged ;
/**
* Emitted when this time axis has been selected for removal
*/
- //SigC::Signal2<void,std::string,void*> VisualTimeAxisRemoved ;
+ //sigc::signal<void,std::string,void*> VisualTimeAxisRemoved ;
//---------------------------------------------------------------------------------------//
// Constructor / Desctructor
projects / ardour.git / commitdiff