smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-10 08:36:32 +01:00
Code Issues Projects Releases Wiki Activity

Fly my pretties!

Browse source 
git-svn-id: svn://localhost/trunk/ardour2@28 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
Taybin Rutkin 2005-09-25 20:33:00 +00:00
parent f872433e8e
commit e493b2b7c4
142 changed files with 1448 additions and 1448 deletions
Download patch file Download diff file Expand all files Collapse all files

2
gtk2_ardour/SConscript
View file

@ -14,7 +14,7 @@ gtkardour = env.Copy()
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')

34
gtk2_ardour/about.cc
View file

@ -26,10 +26,10 @@
#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>
@ -37,8 +37,8 @@
#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"
@ -48,7 +48,7 @@
using namespace Gtk;
using namespace std;
using namespace SigC;
using namespace sigc;
using namespace ARDOUR;
#ifdef WITH_PAYMENT_OPTIONS
@ -125,7 +125,7 @@ static const gchar * paypal_xpm[] = {
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;
}
@ -218,8 +218,8 @@ Contributors:\n\t");
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);
@ -237,8 +237,8 @@ Contributors:\n\t");
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")));
@ -261,7 +261,7 @@ Contributors:\n\t");
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);
@ -293,7 +293,7 @@ Contributors:\n\t");
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);
@ -430,10 +430,10 @@ About::load_logo (Gtk::Window& window)
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;
@ -451,7 +451,7 @@ About::logo_area_expose (GdkEventExpose* ev)
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),

8
gtk2_ardour/about.h
View file

@ -21,8 +21,8 @@
#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;
@ -58,7 +58,7 @@ class About : public Gtk::Window
bool support;
ARDOUR_UI * _ui;
SigC::Connection timeout_connection;
sigc::connection timeout_connection;
bool load_logo_size ();
bool load_logo (Gtk::Window&);
@ -71,7 +71,7 @@ class About : public 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

16
gtk2_ardour/add_route_dialog.cc
View file

@ -23,15 +23,15 @@
#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;
@ -47,7 +47,7 @@ AddRouteDialog::AddRouteDialog ()
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");
@ -89,8 +89,8 @@ AddRouteDialog::AddRouteDialog ()
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);
@ -115,8 +115,8 @@ AddRouteDialog::AddRouteDialog ()
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 ()

12
gtk2_ardour/add_route_dialog.h
View file

@ -3,13 +3,13 @@
#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"

2
gtk2_ardour/ardour_dialog.cc
View file

@ -19,7 +19,7 @@
#include <iostream>
#include <gtkmmext/doi.h>
#include <gtkmm2ext/doi.h>
#include "ardour_dialog.h"
#include "keyboard.h"

2
gtk2_ardour/ardour_dialog.h
View file

@ -21,7 +21,7 @@
#define __ardour_dialog_h__
#include <ardour/ardour.h>
#include <gtk--/window.h>
#include <gtkmm/window.h>
#include "keyboard_target.h"

4
gtk2_ardour/ardour_message.cc
View file

@ -39,7 +39,7 @@ ArdourMessage::ArdourMessage (Gtk::Window* parent,
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);
@ -47,7 +47,7 @@ ArdourMessage::ArdourMessage (Gtk::Window* parent,
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 ();

6
gtk2_ardour/ardour_message.h
View file

@ -24,9 +24,9 @@
#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"

90
gtk2_ardour/ardour_ui.cc
View file

@ -28,19 +28,19 @@
#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>
@ -75,17 +75,17 @@
#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[] = {
@ -782,7 +782,7 @@ vector<string> channel_combo_strings;
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),
@ -824,7 +824,7 @@ ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[], string rcfile)
{
using namespace Gtk::Menu_Helpers;
Gtkmmext::init();
Gtkmm2ext::init();
/* actually, its already loaded, but ... */
@ -1134,9 +1134,9 @@ ARDOUR_UI::ask_about_saving_session (string what)
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);
@ -1150,7 +1150,7 @@ ARDOUR_UI::ask_about_saving_session (string what)
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 ();
@ -1647,7 +1647,7 @@ ARDOUR_UI::session_menu (GdkEventButton *ev)
void
ARDOUR_UI::redisplay_recent_sessions ()
{
using namespace Gtkmmext;
using namespace Gtkmm2ext;
using namespace Gtk::CTree_Helpers;
vector<string *> *sessions;
@ -1657,7 +1657,7 @@ ARDOUR_UI::redisplay_recent_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);
/* ---------------------------------------- */
@ -1809,14 +1809,14 @@ ARDOUR_UI::build_session_selector ()
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));
}
@ -1842,8 +1842,8 @@ ARDOUR_UI::open_session ()
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));
}
@ -1872,7 +1872,7 @@ ARDOUR_UI::open_ok_clicked ()
/* 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);
@ -2226,7 +2226,7 @@ ARDOUR_UI::toggle_record_enable (guint32 dstream)
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
@ -2554,7 +2554,7 @@ ARDOUR_UI::snapshot_session ()
Gtk::Main::run ();
if (prompter.status == Gtkmmext::Prompter::entered) {
if (prompter.status == Gtkmm2ext::Prompter::entered) {
string snapname;
prompter.get_result (snapname);
@ -2648,8 +2648,8 @@ ARDOUR_UI::rec_enable_button_blink (bool onoff, DiskStream *dstream, Widget *w)
}
} 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);
}
}
}
@ -2666,7 +2666,7 @@ ARDOUR_UI::transport_rec_enable_blink (bool onoff)
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;
@ -2676,7 +2676,7 @@ ARDOUR_UI::transport_rec_enable_blink (bool onoff)
default:
rec_button.set_active (false);
rec_button.set_state (GTK_STATE_NORMAL);
rec_button.set_state (Gtk::STATE_NORMAL);
break;
}
}
@ -2723,7 +2723,7 @@ ARDOUR_UI::save_template ()
Gtk::Main::run();
if (prompter.status == Gtkmmext::Prompter::entered) {
if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result (name);
@ -2987,7 +2987,7 @@ require some unused files to continue to exist."));
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);
@ -3014,17 +3014,17 @@ require some unused files to continue to exist."));
}
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 ();
@ -3063,12 +3063,12 @@ Unused audio files will be moved to a \"dead sounds\" location."));
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 ();
@ -3312,8 +3312,8 @@ what you would like to do.\n"));
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);

44
gtk2_ardour/ardour_ui.h
View file

@ -38,13 +38,13 @@
#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>
@ -66,7 +66,7 @@ class AddRouteDialog;
class NewSessionDialog;
class LocationUI;
namespace Gtkmmext {
namespace Gtkmm2ext {
class TearOff;
};
@ -83,7 +83,7 @@ namespace ALSA {
#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);
@ -152,10 +152,10 @@ class ARDOUR_UI : public Gtkmmext::UI
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.
@ -219,7 +219,7 @@ class ARDOUR_UI : public Gtkmmext::UI
private:
struct GlobalClickBox : public Gtk::VBox {
Gtkmmext::ClickBox *box;
Gtkmm2ext::ClickBox *box;
Gtk::Frame frame;
Gtk::Label label;
vector<string> &strings;
@ -230,11 +230,11 @@ class ARDOUR_UI : public Gtkmmext::UI
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);
@ -323,7 +323,7 @@ class ARDOUR_UI : public Gtkmmext::UI
private:
Gtk::VBox top_packer;
SigC::Connection clock_signal_connection;
sigc::connection clock_signal_connection;
void update_clocks ();
void start_clocking ();
void stop_clocking ();
@ -346,7 +346,7 @@ class ARDOUR_UI : public Gtkmmext::UI
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;
@ -529,9 +529,9 @@ class ARDOUR_UI : public Gtkmmext::UI
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*);
@ -543,7 +543,7 @@ class ARDOUR_UI : public Gtkmmext::UI
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*);

94
gtk2_ardour/ardour_ui2.cc
View file

@ -25,14 +25,14 @@
#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>
@ -47,9 +47,9 @@
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 ()
@ -118,7 +118,7 @@ ARDOUR_UI::setup_adjustables ()
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);
}
@ -194,7 +194,7 @@ ARDOUR_UI::setup_transport ()
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);
@ -204,13 +204,13 @@ ARDOUR_UI::setup_transport ()
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"));
@ -230,9 +230,9 @@ ARDOUR_UI::setup_transport ()
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");
@ -250,20 +250,20 @@ ARDOUR_UI::setup_transport ()
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));
@ -280,8 +280,8 @@ ARDOUR_UI::setup_transport ()
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));
@ -322,11 +322,11 @@ ARDOUR_UI::setup_transport ()
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");
@ -356,24 +356,24 @@ ARDOUR_UI::setup_transport ()
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);
@ -483,7 +483,7 @@ ARDOUR_UI::_auditioning_changed (bool onoff)
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
@ -513,11 +513,11 @@ ARDOUR_UI::solo_blink (bool onoff)
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);
}
}
@ -532,11 +532,11 @@ ARDOUR_UI::audition_blink (bool onoff)
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);
}
}

2
gtk2_ardour/ardour_ui_dependents.cc
View file

@ -32,7 +32,7 @@
#include "route_params_ui.h"
#include "i18n.h"
using namespace SigC;
using namespace sigc;
namespace ARDOUR {

2
gtk2_ardour/ardour_ui_dialogs.cc
View file

@ -39,7 +39,7 @@
using namespace ARDOUR;
using namespace Gtk;
using namespace Gtkmmext;
using namespace Gtkmm2ext;
void
ARDOUR_UI::connect_to_session (Session *s)

2
gtk2_ardour/ardour_ui_ed.cc
View file

@ -37,7 +37,7 @@
using namespace ARDOUR;
using namespace Gtk;
using namespace Gtkmmext;
using namespace Gtkmm2ext;
int
ARDOUR_UI::create_editor ()

182
gtk2_ardour/audio_clock.cc
View file

@ -20,7 +20,7 @@
#include <cstdio> // for sprintf
#include <cmath>
#include <gtkmmext/utils.h>
#include <gtkmm2ext/utils.h>
#include <ardour/ardour.h>
#include <ardour/session.h>
@ -33,7 +33,7 @@
#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] = {
@ -164,7 +164,7 @@ AudioClock::AudioClock (const string& name, bool allow_edit, bool duration, bool
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);
@ -185,7 +185,7 @@ AudioClock::AudioClock (const string& name, bool allow_edit, bool duration, bool
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) {
@ -198,31 +198,31 @@ AudioClock::AudioClock (const string& name, bool allow_edit, bool duration, bool
void
AudioClock::setup_events ()
{
clock_base.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.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.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));
@ -272,40 +272,40 @@ AudioClock::setup_events ()
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.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.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));
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));
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);
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);
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);
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);
Gtkmmext::set_usize_to_display_given_text (audio_frames_label, "4294967296", 0, 2);
Gtkmm2ext::set_size_request_to_display_given_text (audio_frames_label, "4294967296", 0, 2);
}
void
@ -701,49 +701,49 @@ AudioClock::field_focus_in_event (GdkEventFocus *ev, Field field)
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;
}
@ -759,51 +759,51 @@ AudioClock::field_focus_out_event (GdkEventFocus *ev, Field field)
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;
}
@ -906,7 +906,7 @@ AudioClock::field_button_press_event (GdkEventButton *ev, Field field)
/* 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;

4
gtk2_ardour/audio_clock.h
View file

@ -21,7 +21,7 @@
#ifndef __audio_clock_h__
#define __audio_clock_h__
#include <gtk--.h>
#include <gtkmm.h>
#include <ardour/ardour.h>
namespace ARDOUR {
@ -50,7 +50,7 @@ class AudioClock : public Gtk::HBox
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;

66
gtk2_ardour/audio_time_axis.cc
View file

@ -30,11 +30,11 @@
#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>
@ -78,7 +78,7 @@
#include "i18n.h"
using namespace ARDOUR;
using namespace SigC;
using namespace sigc;
using namespace LADSPA;
using namespace Gtk;
using namespace Editing;
@ -162,25 +162,25 @@ AudioTimeAxisView::AudioTimeAxisView (PublicEditor& ed, Session& sess, Route& rt
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"));
@ -194,26 +194,26 @@ AudioTimeAxisView::AudioTimeAxisView (PublicEditor& ed, Session& sess, Route& rt
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 */
@ -847,7 +847,7 @@ AudioTimeAxisView::rename_current_playlist ()
Main::run ();
if (prompter.status == Gtkmmext::Prompter::entered) {
if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result (name);
pl->set_name (name);
@ -884,7 +884,7 @@ AudioTimeAxisView::use_copy_playlist ()
Main::run ();
if (prompter.status == Gtkmmext::Prompter::entered) {
if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result (name);
@ -915,7 +915,7 @@ AudioTimeAxisView::use_new_playlist ()
Main::run ();
if (prompter.status == Gtkmmext::Prompter::entered) {
if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result (name);
@ -976,13 +976,13 @@ AudioTimeAxisView::set_waveform_shape (WaveformShape shape)
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

10
gtk2_ardour/audio_time_axis.h
View file

@ -21,10 +21,10 @@
#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>
@ -183,8 +183,8 @@ class AudioTimeAxisView : public RouteUI, public TimeAxisView
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 *);

2
gtk2_ardour/automation_gain_line.cc
View file

@ -18,7 +18,7 @@
$Id$
*/
#include <sigc++/signal_system.h>
#include <sigc++/signal.h>
#include <ardour/curve.h>
#include <pbd/fastlog.h>

2
gtk2_ardour/automation_gain_line.h
View file

@ -3,7 +3,7 @@
#include <ardour/ardour.h>
#include <gtk-canvas.h>
#include <gtk--.h>
#include <gtkmm.h>
#include "automation_line.h"

2
gtk2_ardour/automation_line.cc
View file

@ -273,7 +273,7 @@ AutomationLine::queue_reset ()
{
if (!update_pending) {
update_pending = true;
Gtkmmext::UI::instance()->call_slot (slot (*this, &AutomationLine::reset));
Gtkmm2ext::UI::instance()->call_slot (slot (*this, &AutomationLine::reset));
}
}

6
gtk2_ardour/automation_line.h
View file

@ -26,9 +26,9 @@
#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>
@ -84,7 +84,7 @@ class ControlPoint
ShapeType _shape;
};
class AutomationLine : public SigC::Object
class AutomationLine : public sigc::trackable
{
public:
AutomationLine (string name, TimeAxisView&, GtkCanvasItem *, ARDOUR::AutomationList&,

2
gtk2_ardour/automation_pan_line.cc
View file

@ -18,7 +18,7 @@
$Id$
*/
#include <sigc++/signal_system.h>
#include <sigc++/signal.h>
#include <ardour/curve.h>

2
gtk2_ardour/automation_pan_line.h
View file

@ -3,7 +3,7 @@
#include <ardour/ardour.h>
#include <gtk-canvas.h>
#include <gtk--.h>
#include <gtkmm.h>
#include "automation_line.h"

44
gtk2_ardour/automation_time_axis.cc
View file

@ -122,9 +122,9 @@ AutomationTimeAxisView::AutomationTimeAxisView (Session& s, Route& r, PublicEdit
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;
@ -140,18 +140,18 @@ AutomationTimeAxisView::AutomationTimeAxisView (Session& s, Route& r, PublicEdit
}
/* 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");
@ -310,11 +310,11 @@ AutomationTimeAxisView::set_height (TrackHeight h)
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 ();
@ -328,10 +328,10 @@ AutomationTimeAxisView::set_height (TrackHeight h)
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 ();
@ -345,10 +345,10 @@ AutomationTimeAxisView::set_height (TrackHeight h)
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 ();
@ -362,11 +362,11 @@ AutomationTimeAxisView::set_height (TrackHeight h)
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 ();
@ -381,7 +381,7 @@ AutomationTimeAxisView::set_height (TrackHeight h)
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 ();
@ -396,7 +396,7 @@ AutomationTimeAxisView::set_height (TrackHeight h)
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 ();

2
gtk2_ardour/automation_time_axis.h
View file

@ -112,7 +112,7 @@ class AutomationTimeAxisView : public TimeAxisView {
bool ignore_state_request;
void automation_state_changed ();
SigC::Connection automation_connection;
sigc::connection automation_connection;
void entered ();
void exited ();

8
gtk2_ardour/axis_view.cc
View file

@ -28,9 +28,9 @@
#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>
@ -40,7 +40,7 @@
#include "i18n.h"
using namespace Gtk;
using namespace Gtkmmext;
using namespace Gtkmm2ext;
list<GdkColor> AxisView::used_colors;

8
gtk2_ardour/axis_view.h
View file

@ -22,7 +22,7 @@
#define __ardour_gtk_axis_view_h__
#include <list>
#include <gtk--.h>
#include <gtkmm.h>
#include <pbd/xml++.h>
#include "prompter.h"
@ -34,7 +34,7 @@ namespace ARDOUR {
* AxisView defines the abstract base class for time-axis trackviews and routes.
*
*/
class AxisView : public SigC::Object
class AxisView : public sigc::trackable
{
public:
/**
@ -63,8 +63,8 @@ class AxisView : public SigC::Object
}
virtual bool selected() const { return _selected; }
SigC::Signal0<void> Hiding;
SigC::Signal0<void> GoingAway;
sigc::signal<void> Hiding;
sigc::signal<void> GoingAway;
protected:

58
gtk2_ardour/connection_editor.cc
View file

@ -19,8 +19,8 @@
*/
#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"
@ -41,7 +41,7 @@
using namespace std;
using namespace ARDOUR;
using namespace Gtk;
using namespace SigC;
using namespace sigc;
ConnectionEditor::ConnectionEditor ()
: ArdourDialog ("connection editor"),
@ -59,7 +59,7 @@ ConnectionEditor::ConnectionEditor ()
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;
@ -81,22 +81,22 @@ ConnectionEditor::ConnectionEditor ()
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");
@ -105,7 +105,7 @@ ConnectionEditor::ConnectionEditor ()
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);
@ -136,20 +136,20 @@ ConnectionEditor::ConnectionEditor ()
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);
@ -188,11 +188,11 @@ ConnectionEditor::ConnectionEditor ()
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()
@ -297,13 +297,13 @@ ConnectionEditor::remove_connection (ARDOUR::Connection *connection)
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
@ -438,7 +438,7 @@ ConnectionEditor::display_ports ()
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);
@ -520,7 +520,7 @@ ConnectionEditor::display_connection_state (bool for_input)
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);
@ -530,9 +530,9 @@ ConnectionEditor::display_connection_state (bool for_input)
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 */
@ -638,7 +638,7 @@ ConnectionEditor::new_connection (bool for_input)
Gtk::Main::run();
if (prompter.status == Gtkmmext::Prompter::entered) {
if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result (name);

18
gtk2_ardour/connection_editor.h
View file

@ -28,13 +28,13 @@ using __gnu_cxx::slist;
#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"
@ -138,8 +138,8 @@ class ConnectionEditor : public ArdourDialog {
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);
};

36
gtk2_ardour/crossfade_edit.cc
View file

@ -22,9 +22,9 @@
#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>
@ -34,7 +34,7 @@
#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"
@ -48,7 +48,7 @@
using namespace std;
using namespace ARDOUR;
using namespace Gtk;
using namespace SigC;
using namespace sigc;
using namespace Editing;
#include "i18n.h"
@ -96,10 +96,10 @@ CrossfadeEditor::CrossfadeEditor (Session& s, Crossfade& xf, double my, double m
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);
@ -116,7 +116,7 @@ CrossfadeEditor::CrossfadeEditor (Session& s, Crossfade& xf, double my, double m
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(),
@ -181,8 +181,8 @@ CrossfadeEditor::CrossfadeEditor (Session& s, Crossfade& xf, double my, double m
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);
@ -204,10 +204,10 @@ CrossfadeEditor::CrossfadeEditor (Session& s, Crossfade& xf, double my, double m
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;
@ -223,7 +223,7 @@ CrossfadeEditor::CrossfadeEditor (Session& s, Crossfade& xf, double my, double m
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);
@ -244,7 +244,7 @@ CrossfadeEditor::CrossfadeEditor (Session& s, Crossfade& xf, double my, double m
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);
@ -268,8 +268,8 @@ CrossfadeEditor::CrossfadeEditor (Session& s, Crossfade& xf, double my, double m
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));
@ -318,7 +318,7 @@ CrossfadeEditor::CrossfadeEditor (Session& s, Crossfade& xf, double my, double m
/* 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;

6
gtk2_ardour/crossfade_edit.h
View file

@ -3,9 +3,9 @@
#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>

6
gtk2_ardour/crossfade_view.cc
View file

@ -21,7 +21,7 @@
#include <algorithm>
#include <ardour/region.h>
#include <gtkmmext/doi.h>
#include <gtkmm2ext/doi.h>
#include "canvas-simplerect.h"
#include "canvas-curve.h"
@ -32,11 +32,11 @@
#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,

6
gtk2_ardour/crossfade_view.h
View file

@ -22,9 +22,9 @@
#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"
@ -54,7 +54,7 @@ struct CrossfadeView : public TimeAxisViewItem
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;

6
gtk2_ardour/default_keys.cc
View file

@ -18,7 +18,7 @@
$Id$
*/
#include <gtk--.h>
#include <gtkmm.h>
#include <sigc++/bind.h>
#include <pbd/error.h>
@ -26,9 +26,9 @@
#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 ()

214
gtk2_ardour/editor.cc
View file

@ -29,9 +29,9 @@
#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>
@ -77,10 +77,10 @@
/* </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 */
@ -209,8 +209,8 @@ Editor::Editor (AudioEngine& eng)
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)),
@ -266,10 +266,10 @@ Editor::Editor (AudioEngine& eng)
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;
@ -373,7 +373,7 @@ Editor::Editor (AudioEngine& eng)
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));
@ -392,7 +392,7 @@ Editor::Editor (AudioEngine& eng)
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");
@ -400,13 +400,13 @@ Editor::Editor (AudioEngine& eng)
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 ();
@ -422,42 +422,42 @@ Editor::Editor (AudioEngine& eng)
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);
@ -471,7 +471,7 @@ Editor::Editor (AudioEngine& eng)
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));
@ -482,7 +482,7 @@ Editor::Editor (AudioEngine& eng)
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);
@ -490,20 +490,20 @@ Editor::Editor (AudioEngine& eng)
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");
@ -516,16 +516,16 @@ Editor::Editor (AudioEngine& eng)
// 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);
@ -547,16 +547,16 @@ Editor::Editor (AudioEngine& eng)
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));
@ -570,17 +570,17 @@ Editor::Editor (AudioEngine& eng)
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));
@ -598,11 +598,11 @@ Editor::Editor (AudioEngine& eng)
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);
@ -612,18 +612,18 @@ Editor::Editor (AudioEngine& eng)
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);
@ -632,7 +632,7 @@ Editor::Editor (AudioEngine& eng)
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));
@ -646,10 +646,10 @@ Editor::Editor (AudioEngine& eng)
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);
@ -712,8 +712,8 @@ Editor::Editor (AudioEngine& eng)
/* 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"));
@ -729,7 +729,7 @@ Editor::Editor (AudioEngine& eng)
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));
@ -830,7 +830,7 @@ Editor::initialize_canvas ()
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));
@ -838,7 +838,7 @@ Editor::initialize_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 */
@ -871,7 +871,7 @@ Editor::initialize_canvas ()
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(),
@ -1568,7 +1568,7 @@ Editor::reset_scrolling_region (GtkAllocation *alloc)
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
@ -1593,25 +1593,25 @@ Editor::session_control_changed (Session::ControlType t)
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
@ -1738,7 +1738,7 @@ Editor::connect_to_session (Session *t)
/* 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)));
@ -2774,13 +2774,13 @@ Editor::get_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*>(&region_selection_vpane)->gtkobj()));
snprintf(buf,sizeof(buf), "%d", gtk_paned_get_position (static_cast<Paned*>(&region_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);
@ -3088,12 +3088,12 @@ Editor::setup_toolbar ()
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));
@ -3129,7 +3129,7 @@ Editor::setup_toolbar ()
/* 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);
@ -3152,7 +3152,7 @@ Editor::setup_toolbar ()
/* 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);
@ -3172,7 +3172,7 @@ Editor::setup_toolbar ()
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);
@ -3194,7 +3194,7 @@ Editor::setup_toolbar ()
/* 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);
@ -3251,8 +3251,8 @@ Editor::setup_toolbar ()
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);
@ -3284,7 +3284,7 @@ Editor::setup_toolbar ()
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);
}
@ -3979,8 +3979,8 @@ Editor::duplicate_dialog (bool dup_region)
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);
@ -3994,21 +3994,21 @@ Editor::duplicate_dialog (bool dup_region)
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));
@ -4385,7 +4385,7 @@ Editor::pane_allocation_handler (GtkAllocation *alloc, Gtk::Paned* which)
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);
}
@ -4402,7 +4402,7 @@ Editor::pane_allocation_handler (GtkAllocation *alloc, Gtk::Paned* which)
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);
}
@ -4419,7 +4419,7 @@ Editor::pane_allocation_handler (GtkAllocation *alloc, Gtk::Paned* which)
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);
}
@ -4436,7 +4436,7 @@ Editor::pane_allocation_handler (GtkAllocation *alloc, Gtk::Paned* which)
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);
}
}
@ -4507,8 +4507,8 @@ Editor::edit_xfade (Crossfade* xfade)
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 ();
@ -4572,9 +4572,9 @@ Editor::playlist_deletion_dialog (Playlist* pl)
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));

30
gtk2_ardour/editor.h
View file

@ -31,12 +31,12 @@
#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>
@ -53,7 +53,7 @@
#include "enums.h"
#include "region_selection.h"
namespace Gtkmmext {
namespace Gtkmm2ext {
class TearOff;
}
@ -786,13 +786,13 @@ class Editor : public PublicEditor
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 *);
@ -946,7 +946,7 @@ class Editor : public PublicEditor
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;
@ -1214,7 +1214,7 @@ class Editor : public PublicEditor
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 ();
@ -1343,7 +1343,7 @@ class Editor : public PublicEditor
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;
@ -1395,7 +1395,7 @@ class Editor : public PublicEditor
void setup_toolbar ();
Gtkmmext::TearOff* tools_tearoff;
Gtkmm2ext::TearOff* tools_tearoff;
Gtk::HBox toolbar_hbox;
Gtk::EventBox toolbar_base;
Gtk::Frame toolbar_frame;
@ -1689,8 +1689,8 @@ class Editor : public PublicEditor
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*);
};
@ -1794,14 +1794,14 @@ class Editor : public PublicEditor
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;

2
gtk2_ardour/editor_canvas_events.cc
View file

@ -40,7 +40,7 @@
#include "i18n.h"
using namespace SigC;
using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;

2
gtk2_ardour/editor_cursors.cc
View file

@ -26,7 +26,7 @@
#include "utils.h"
#include "editor.h"
using namespace SigC;
using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;

6
gtk2_ardour/editor_edit_groups.cc
View file

@ -21,7 +21,7 @@
#include <cstdlib>
#include <cmath>
#include <gtkmmext/stop_signal.h>
#include <gtkmm2ext/stop_signal.h>
#include <ardour/route_group.h>
#include "editor.h"
@ -34,7 +34,7 @@
#include "i18n.h"
using namespace SigC;
using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;
@ -102,7 +102,7 @@ Editor::new_edit_group ()
Gtk::Main::run ();
if (prompter.status != Gtkmmext::Prompter::entered) {
if (prompter.status != Gtkmm2ext::Prompter::entered) {
return;
}

4
gtk2_ardour/editor_export_audio.cc
View file

@ -104,8 +104,8 @@ Editor::write_a_region ()
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();

14
gtk2_ardour/editor_hscroller.cc
View file

@ -68,21 +68,21 @@ Editor::hscroll_slider_expose (GdkEventExpose *ev)
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);

6
gtk2_ardour/editor_imageframe.cc
View file

@ -7,7 +7,7 @@
#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>
@ -32,7 +32,7 @@ Editor::add_imageframe_time_axis(std::string track_name, void* src)
}
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)) ;
}
}
@ -90,7 +90,7 @@ Editor::add_imageframe_marker_time_axis(std::string track_name, TimeAxisView* ma
// 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

4
gtk2_ardour/editor_keys.cc
View file

@ -25,7 +25,7 @@
#include <pbd/error.h>
#include <gtkmmext/popup_selector.h>
#include <gtkmm2ext/popup_selector.h>
#include <ardour/session.h>
#include <ardour/region.h>
@ -39,7 +39,7 @@
#include "i18n.h"
using namespace ARDOUR;
using namespace SigC;
using namespace sigc;
void
Editor::install_keybindings ()

12
gtk2_ardour/editor_markers.cc
View file

@ -23,7 +23,7 @@
#include <cmath>
#include <gtk-canvas.h>
#include <gtkmmext/gtk_ui.h>
#include <gtkmm2ext/gtk_ui.h>
#include <ardour/location.h>
@ -36,7 +36,7 @@
#include "i18n.h"
using namespace std;
using namespace SigC;
using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;
@ -739,8 +739,8 @@ Editor::marker_menu_rename ()
}
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);
@ -754,8 +754,8 @@ Editor::marker_menu_rename ()
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 ();

4
gtk2_ardour/editor_mixer.cc
View file

@ -18,7 +18,7 @@
$Id$
*/
#include <gtkmmext/utils.h>
#include <gtkmm2ext/utils.h>
#include <ardour/audioengine.h>
#include "editor.h"
@ -238,7 +238,7 @@ Editor::current_mixer_strip_hidden ()
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 ();
}

16
gtk2_ardour/editor_mouse.cc
View file

@ -26,7 +26,7 @@
#include <algorithm>
#include <pbd/error.h>
#include <gtkmmext/utils.h>
#include <gtkmm2ext/utils.h>
#include "ardour_ui.h"
#include "editor.h"
@ -62,7 +62,7 @@
using namespace std;
using namespace ARDOUR;
using namespace SigC;
using namespace sigc;
using namespace Gtk;
using namespace Editing;
@ -1443,7 +1443,7 @@ Editor::motion_handler (GtkCanvasItem* item, GdkEvent* event, ItemType item_type
/* 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
@ -1584,7 +1584,7 @@ Editor::start_grab (GdkEvent* event, GdkCursor *cursor)
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);
@ -2523,7 +2523,7 @@ Editor::start_region_copy_grab (GtkCanvasItem* item, GdkEvent* event)
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.
*/
@ -3179,7 +3179,7 @@ Editor::region_drag_finished_callback (GtkCanvasItem* item, GdkEvent* event)
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 ();
@ -3416,7 +3416,7 @@ Editor::start_selection_grab (GtkCanvasItem* item, GdkEvent* event)
*/
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.
@ -4444,7 +4444,7 @@ Editor::end_rubberband_select (GtkCanvasItem* item, GdkEvent* event)
gint
Editor::mouse_rename_region (GtkCanvasItem* item, GdkEvent* event)
{
using namespace Gtkmmext;
using namespace Gtkmm2ext;
ArdourPrompter prompter (false);

2
gtk2_ardour/editor_nudge.cc
View file

@ -25,6 +25,6 @@
#include "i18n.h"
using namespace SigC;
using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;

34
gtk2_ardour/editor_ops.cc
View file

@ -31,8 +31,8 @@
#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>
@ -68,7 +68,7 @@
using namespace std;
using namespace ARDOUR;
using namespace SigC;
using namespace sigc;
using namespace Gtk;
using namespace Editing;
@ -183,7 +183,7 @@ Do you really want to destroy %1 ?"),
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 ();
@ -1743,8 +1743,8 @@ Editor::rename_region ()
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);
@ -1759,8 +1759,8 @@ Editor::rename_region ()
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 */
@ -1832,7 +1832,7 @@ Editor::build_interthread_progress_window ()
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);
@ -1893,7 +1893,7 @@ Editor::import_audio (bool as_tracks)
}
SoundFileSelector& sfdb (ARDOUR_UI::instance()->get_sfdb_window());
SigC::Connection c;
sigc::connection c;
string str;
if (as_tracks) {
@ -1917,7 +1917,7 @@ Editor::catch_new_audio_region (AudioRegion* ar)
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
@ -1931,7 +1931,7 @@ Editor::do_import (vector<string> paths, bool split, bool as_tracks)
}
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"));
@ -2000,7 +2000,7 @@ Editor::reject_because_rate_differs (string path, SF_INFO& finfo, string action,
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);
@ -2034,7 +2034,7 @@ Editor::embed_audio ()
}
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);
@ -2162,7 +2162,7 @@ void
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) {
@ -2907,7 +2907,7 @@ Editor::freeze_route ()
}
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 ("");
@ -3434,7 +3434,7 @@ Editor::remove_last_capture ()
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 ();

6
gtk2_ardour/editor_region_list.cc
View file

@ -28,7 +28,7 @@
#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"
@ -37,7 +37,7 @@
#include "i18n.h"
using namespace SigC;
using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;
using namespace Editing;
@ -356,7 +356,7 @@ Editor::region_list_clear ()
/* ---------------------------------------- */
/* 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);
/* ---------------------------------------- */
}

2
gtk2_ardour/editor_route_list.cc
View file

@ -32,7 +32,7 @@
#include "i18n.h"
using namespace SigC;
using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;

38
gtk2_ardour/editor_rulers.cc
View file

@ -24,7 +24,7 @@
#include <string>
#include <ardour/tempo.h>
#include <gtkmmext/gtk_ui.h>
#include <gtkmm2ext/gtk_ui.h>
#include "editor.h"
#include "editing.h"
@ -33,7 +33,7 @@
#include "i18n.h"
using namespace SigC;
using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;
using namespace Editing;
@ -58,27 +58,27 @@ Editor::initialize_rulers ()
_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;
@ -89,10 +89,10 @@ Editor::initialize_rulers ()
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));
@ -530,32 +530,32 @@ Editor::update_ruler_visibility ()
_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));
@ -684,7 +684,7 @@ Editor::update_ruler_visibility ()
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();

8
gtk2_ardour/editor_selection_list.cc
View file

@ -22,13 +22,13 @@
#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"
@ -38,10 +38,10 @@
#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 ()

32
gtk2_ardour/editor_tempodisplay.cc
View file

@ -28,12 +28,12 @@
#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"
@ -45,7 +45,7 @@
#include "i18n.h"
using namespace std;
using namespace SigC;
using namespace sigc;
using namespace ARDOUR;
using namespace Gtk;
using namespace Editing;
@ -252,10 +252,10 @@ Editor::mouse_add_new_tempo_event (jack_nframes_t frame)
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));
@ -294,10 +294,10 @@ Editor::mouse_add_new_meter_event (jack_nframes_t frame)
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));
@ -351,10 +351,10 @@ Editor::edit_meter_section (MeterSection* section)
{
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));
@ -383,10 +383,10 @@ Editor::edit_tempo_section (TempoSection* section)
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));

12
gtk2_ardour/editor_timefx.cc
View file

@ -41,7 +41,7 @@
#include "i18n.h"
using namespace ARDOUR;
using namespace SigC;
using namespace sigc;
using namespace Gtk;
Editor::TimeStretchDialog::TimeStretchDialog (Editor& e)
@ -53,7 +53,7 @@ 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"));
@ -85,7 +85,7 @@ Editor::TimeStretchDialog::TimeStretchDialog (Editor& e)
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
@ -120,7 +120,7 @@ Editor::run_timestretch (AudioRegionSelection& regions, float fraction)
}
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 ();
@ -143,7 +143,7 @@ Editor::run_timestretch (AudioRegionSelection& regions, float fraction)
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)) {
@ -154,7 +154,7 @@ Editor::run_timestretch (AudioRegionSelection& regions, float fraction)
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 ();

84
gtk2_ardour/export_dialog.cc
View file

@ -27,8 +27,8 @@
#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>
@ -45,7 +45,7 @@
#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;
@ -56,7 +56,7 @@ GdkPixmap* ExportDialog::empty_mask = 0;
using namespace std;
using namespace ARDOUR;
using namespace SigC;
using namespace sigc;
using namespace Gtk;
static const gchar *sample_rates[] = {
@ -131,7 +131,7 @@ ExportDialog::ExportDialog(PublicEditor& e, AudioRegion* r)
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);
@ -141,13 +141,13 @@ ExportDialog::ExportDialog(PublicEditor& e, AudioRegion* r)
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);
@ -159,7 +159,7 @@ ExportDialog::ExportDialog(PublicEditor& e, AudioRegion* r)
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);
@ -171,10 +171,10 @@ ExportDialog::ExportDialog(PublicEditor& e, AudioRegion* r)
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);
@ -184,8 +184,8 @@ ExportDialog::ExportDialog(PublicEditor& e, AudioRegion* r)
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);
@ -198,8 +198,8 @@ ExportDialog::ExportDialog(PublicEditor& e, AudioRegion* r)
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);
@ -214,12 +214,12 @@ ExportDialog::ExportDialog(PublicEditor& e, AudioRegion* r)
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);
@ -281,10 +281,10 @@ ExportDialog::ExportDialog(PublicEditor& e, AudioRegion* r)
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);
@ -379,11 +379,11 @@ ExportDialog::ExportDialog(PublicEditor& e, AudioRegion* r)
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));
@ -575,11 +575,11 @@ ExportDialog::save_state()
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);
}
@ -998,17 +998,17 @@ ExportDialog::do_export ()
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));
}
@ -1026,17 +1026,17 @@ ExportDialog::do_export ()
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));
}
@ -1298,12 +1298,12 @@ ExportDialog::track_selector_button_press_event (GdkEventButton* ev)
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);
@ -1322,12 +1322,12 @@ ExportDialog::master_selector_button_press_event (GdkEventButton* ev)
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);
@ -1350,8 +1350,8 @@ ExportDialog::initiate_browse ()
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));
}

4
gtk2_ardour/export_dialog.h
View file

@ -20,7 +20,7 @@
#ifndef __ardour_export_dialog_h__
#define __ardour_export_dialog_h__
#include <gtk--.h>
#include <gtkmm.h>
#include <ardour/export.h>
#include "ardour_dialog.h"
@ -98,7 +98,7 @@ class ExportDialog : public ArdourDialog
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);

6
gtk2_ardour/ghostregion.h
View file

@ -22,12 +22,12 @@
#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;
@ -41,7 +41,7 @@ struct GhostRegion : public SigC::Object
void set_duration (double units);
void set_height ();
SigC::Signal1<void,GhostRegion*> GoingAway;
sigc::signal<void,GhostRegion*> GoingAway;
};
#endif /* __ardour_gtk_ghost_region_h__ */

4
gtk2_ardour/gui_thread.h
View file

@ -2,8 +2,8 @@
#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;\
}

6
gtk2_ardour/imageframe_socket_handler.cc
View file

@ -29,7 +29,7 @@
#include <sigc++/bind.h>
#include <gtkmmext/gtk_ui.h>
#include <gtkmm2ext/gtk_ui.h>
#include "imageframe_socket_handler.h"
#include "imageframe_time_axis.h"
@ -47,12 +47,12 @@
#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 ;

8
gtk2_ardour/imageframe_socket_handler.h
View file

@ -22,7 +22,7 @@
#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"
@ -38,7 +38,7 @@ class ImageFrameTimeAxisGroup ;
* message passing through a socket.
*
*/
class ImageFrameSocketHandler : public SigC::Object
class ImageFrameSocketHandler : public sigc::trackable
{
public:
/**
@ -270,10 +270,10 @@ class ImageFrameSocketHandler : public SigC::Object
// 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:

6
gtk2_ardour/imageframe_time_axis.cc
View file

@ -23,8 +23,8 @@
#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>
@ -44,7 +44,7 @@
#include "i18n.h"
using namespace ARDOUR ;
using namespace SigC ;
using namespace sigc ;
using namespace Gtk ;
/**

6
gtk2_ardour/imageframe_time_axis.h
View file

@ -21,7 +21,7 @@
#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"
@ -158,10 +158,10 @@ class ImageFrameTimeAxis : public VisualTimeAxis
// 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:

4
gtk2_ardour/imageframe_time_axis_group.cc
View file

@ -20,8 +20,8 @@
#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"

14
gtk2_ardour/imageframe_time_axis_group.h
View file

@ -24,7 +24,7 @@
#include <list>
#include <cmath>
#include <gtk--.h>
#include <gtkmm.h>
#include <gtk-canvas.h>
#include <jack/jack.h>
#include "imageframe_time_axis_view.h"
@ -40,7 +40,7 @@ class ImageFrameView ;
* A viewable object may also be useful...
*
*/
class ImageFrameTimeAxisGroup : public SigC::Object
class ImageFrameTimeAxisGroup : public sigc::trackable
{
public:
//---------------------------------------------------------------------------------------//
@ -234,7 +234,7 @@ class ImageFrameTimeAxisGroup : public SigC::Object
//---------------------------------------------------------------------------------//
// Emitted Signals
SigC::Signal0<void> GoingAway ;
sigc::signal<void> GoingAway ;
/**
* Emitted when this Group has been removed
@ -243,16 +243,16 @@ class ImageFrameTimeAxisGroup : public SigC::Object
* 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:

4
gtk2_ardour/imageframe_time_axis_view.cc
View file

@ -20,9 +20,9 @@
#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"

8
gtk2_ardour/imageframe_time_axis_view.h
View file

@ -24,7 +24,7 @@
#include <list>
#include <cmath>
#include <gtk--.h>
#include <gtkmm.h>
#include <gtk-canvas.h>
#include <jack/jack.h>
@ -39,7 +39,7 @@ class ImageFrameTimeAxisGroup ;
* maintains the list of items that have been added to it
*
*/
class ImageFrameTimeAxisView : public SigC::Object
class ImageFrameTimeAxisView : public sigc::trackable
{
public:
//---------------------------------------------------------------------------------------//
@ -222,10 +222,10 @@ class ImageFrameTimeAxisView : public SigC::Object
// 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:

8
gtk2_ardour/imageframe_view.cc
View file

@ -21,8 +21,8 @@
#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"
@ -35,10 +35,10 @@
#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

10
gtk2_ardour/imageframe_view.h
View file

@ -22,9 +22,9 @@
#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"
@ -78,7 +78,7 @@ class ImageFrameView : public TimeAxisViewItem
*/
~ImageFrameView() ;
static SigC::Signal1<void,ImageFrameView*> GoingAway;
static sigc::signal<void,ImageFrameView*> GoingAway;
//---------------------------------------------------------------------------------------//
// Position and duration Accessors/Mutators
@ -173,10 +173,10 @@ class ImageFrameView : public TimeAxisViewItem
// 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 */

44
gtk2_ardour/io_selector.cc
View file

@ -31,8 +31,8 @@
#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"
@ -45,7 +45,7 @@
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)
@ -56,7 +56,7 @@ IOSelectorWindow::IOSelectorWindow (Session& sess, IO& ior, bool input, bool can
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;
@ -87,12 +87,12 @@ IOSelectorWindow::IOSelectorWindow (Session& sess, IO& ior, bool input, bool can
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)));
@ -146,7 +146,7 @@ IOSelector::IOSelector (Session& sess, IO& ior, bool input)
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");
@ -172,10 +172,10 @@ IOSelector::IOSelector (Session& sess, IO& ior, bool input)
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);
@ -234,10 +234,10 @@ IOSelector::IOSelector (Session& sess, IO& ior, bool input)
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));
@ -334,7 +334,7 @@ IOSelector::rescan ()
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);
@ -429,7 +429,7 @@ IOSelector::display_ports ()
*/
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 ();
@ -466,8 +466,8 @@ IOSelector::display_ports ()
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 */
@ -812,9 +812,9 @@ PortInsertWindow::PortInsertWindow (Session& sess, PortInsert& pi, bool can_canc
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));

4
gtk2_ardour/io_selector.h
View file

@ -29,7 +29,7 @@ using __gnu_cxx::slist;
#endif
#include <string>
#include <gtk--.h>
#include <gtkmm.h>
#include <ardour_dialog.h>
@ -53,7 +53,7 @@ class IOSelector : public Gtk::VBox {
Accepted
};
SigC::Signal1<void,Result> Finished;
sigc::signal<void,Result> Finished;
protected:
ARDOUR::Session& session;

4
gtk2_ardour/keyboard.h
View file

@ -24,7 +24,7 @@
#include <vector>
#include <string>
#include <sigc++/signal_system.h>
#include <sigc++/signal.h>
#include <gtk/gtk.h>
#include <ardour/types.h>
@ -36,7 +36,7 @@ using std::string;
class KeyboardTarget;
class ArdourDialog;
class Keyboard : public SigC::Object, Stateful
class Keyboard : public sigc::trackable, Stateful
{
public:
Keyboard ();

10
gtk2_ardour/keyboard_target.h
View file

@ -23,9 +23,9 @@
#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"
@ -39,10 +39,10 @@ class KeyboardTarget
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; }

78
gtk2_ardour/library_ui.cc
View file

@ -30,9 +30,9 @@
#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>
@ -41,7 +41,7 @@
#include <ardour/sndfilesource.h>
#include <ardour/utils.h>
#include <gtkmmext/doi.h>
#include <gtkmm2ext/doi.h>
#include "ardour_ui.h"
#include "public_editor.h"
@ -54,7 +54,7 @@
using namespace std;
using namespace ARDOUR;
using namespace Gtk;
using namespace SigC;
using namespace sigc;
SoundFileSelector::SoundFileSelector ()
: ArdourDialog ("sound file selector"),
@ -91,7 +91,7 @@ SoundFileSelector::SoundFileSelector ()
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));
@ -158,7 +158,7 @@ SoundFileSelector::run (string action, bool multi, bool hide_after)
multiable = multi;
hide_after_action = hide_after;
set_position (GTK_WIN_POS_MOUSE);
set_position (Gtk::WIN_POS_MOUSE);
ArdourDialog::run ();
}
@ -307,7 +307,7 @@ SoundFileBrowser::SoundFileBrowser()
// 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);
@ -322,8 +322,8 @@ SoundFileBrowser::SoundFileBrowser()
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);
@ -440,8 +440,8 @@ LibraryTree::LibraryTree ()
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);
@ -453,16 +453,16 @@ LibraryTree::LibraryTree ()
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));
@ -721,7 +721,7 @@ LibraryTree::file_ok_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);
@ -771,7 +771,7 @@ LibraryTree::folder_btn_clicked ()
Gtk::Main::run();
if (prompter.status == Gtkmmext::Prompter::entered) {
if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result(name);
@ -1002,7 +1002,7 @@ SoundFileBox::SoundFileBox (string uri, bool meta)
}
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);
@ -1014,8 +1014,8 @@ SoundFileBox::SoundFileBox (string uri, bool meta)
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();
@ -1025,9 +1025,9 @@ SoundFileBox::SoundFileBox (string uri, bool meta)
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));
@ -1117,8 +1117,8 @@ SoundFileBox::setup_labels (string uri)
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)));
@ -1211,7 +1211,7 @@ void
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));
}
}
@ -1226,7 +1226,7 @@ SoundFileBox::add_field_clicked ()
Gtk::Main::run();
if (prompter.status == Gtkmmext::Prompter::entered) {
if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result(name);
@ -1254,7 +1254,7 @@ SoundFileBox::setup_fields ()
}
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);
@ -1263,7 +1263,7 @@ SoundFileBox::field_chosen (Gtkmmext::Selector *selector, Gtkmmext::SelectionRes
}
void
SoundFileBox::field_selected (Gtkmmext::Selector *selector, Gtkmmext::SelectionResult *res)
SoundFileBox::field_selected (Gtkmm2ext::Selector *selector, Gtkmm2ext::SelectionResult *res)
{
if (!res){
return;
@ -1280,7 +1280,7 @@ SoundFileBox::field_selected (Gtkmmext::Selector *selector, Gtkmmext::SelectionR
Gtk::Main::run();
if (prompter.status == Gtkmmext::Prompter::entered) {
if (prompter.status == Gtkmm2ext::Prompter::entered) {
string data;
prompter.get_result(data);
@ -1311,7 +1311,7 @@ SearchSounds::SearchSounds ()
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);
@ -1319,7 +1319,7 @@ SearchSounds::SearchSounds ()
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));
@ -1357,7 +1357,7 @@ SearchSounds::fields_refiller (Gtk::CList &clist)
}
void
SearchSounds::field_selected (Gtkmmext::Selector *selector, Gtkmmext::SelectionResult *res)
SearchSounds::field_selected (Gtkmm2ext::Selector *selector, Gtkmm2ext::SelectionResult *res)
{
if (!res){
return;
@ -1371,7 +1371,7 @@ SearchSounds::field_selected (Gtkmmext::Selector *selector, Gtkmmext::SelectionR
Gtk::Main::run();
if (prompter.status == Gtkmmext::Prompter::entered) {
if (prompter.status == Gtkmm2ext::Prompter::entered) {
string data;
prompter.get_result(data);
@ -1450,7 +1450,7 @@ SearchResults::SearchResults (map<string,string> field_values, bool and_search)
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);
@ -1462,7 +1462,7 @@ SearchResults::SearchResults (map<string,string> field_values, bool and_search)
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));
@ -1519,7 +1519,7 @@ SearchResults::import_clicked ()
}
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();

54
gtk2_ardour/library_ui.h
View file

@ -26,9 +26,9 @@
#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>
@ -55,7 +55,7 @@ class SoundFileBox : public Gtk::VBox
SoundFileBox (string uri, bool metadata);
~SoundFileBox ();
SigC::Signal2<void, string, bool> file_chosen;
sigc::signal<void, string, bool> file_chosen;
private:
string uri;
@ -73,7 +73,7 @@ class SoundFileBox : public Gtk::VBox
Gtk::Label channels;
Gtk::Label samplerate;
Gtkmmext::Selector fields;
Gtkmm2ext::Selector fields;
string selected_field;
Gtk::Frame border_frame;
@ -97,10 +97,10 @@ class SoundFileBox : public Gtk::VBox
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);
};
@ -110,7 +110,7 @@ class SearchSounds : public ArdourDialog
SearchSounds ();
~SearchSounds ();
SigC::Signal2<void, string, bool> file_chosen;
sigc::signal<void, string, bool> file_chosen;
private:
Gtk::Button find_btn;
@ -118,7 +118,7 @@ class SearchSounds : public ArdourDialog
Gtk::RadioButton and_rbtn;
Gtk::RadioButton or_rbtn;
Gtkmmext::Selector fields;
Gtkmm2ext::Selector fields;
string selected_field;
Gtk::VBox main_box;
@ -129,8 +129,8 @@ class SearchSounds : public ArdourDialog
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 ();
@ -143,7 +143,7 @@ class SearchResults : public ArdourDialog
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;
@ -159,14 +159,14 @@ class SearchResults : public ArdourDialog
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
@ -175,11 +175,11 @@ 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 ();
@ -236,10 +236,10 @@ class SoundFileBrowser : public Gtk::VBox {
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 ();
@ -272,7 +272,7 @@ class SoundFileSelector : public ArdourDialog {
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;

70
gtk2_ardour/location_ui.cc
View file

@ -21,8 +21,8 @@
#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>
@ -39,7 +39,7 @@
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),
@ -82,20 +82,20 @@ LocationEditRow::LocationEditRow(Session * sess, Location * loc, int32_t num)
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);
@ -108,16 +108,16 @@ LocationEditRow::LocationEditRow(Session * sess, Location * loc, int32_t num)
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));
@ -153,9 +153,9 @@ LocationEditRow::LocationEditRow(Session * sess, Location * loc, int32_t num)
// 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));
@ -218,7 +218,7 @@ LocationEditRow::set_location (Location *loc)
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());
@ -226,10 +226,10 @@ LocationEditRow::set_location (Location *loc)
// 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();
@ -237,22 +237,22 @@ LocationEditRow::set_location (Location *loc)
} 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
@ -449,7 +449,7 @@ LocationEditRow::cd_toggled ()
}
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();
@ -613,8 +613,8 @@ LocationUI::LocationUI ()
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);
@ -634,8 +634,8 @@ LocationUI::LocationUI ()
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");
@ -653,10 +653,10 @@ LocationUI::LocationUI ()
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);
}

16
gtk2_ardour/location_ui.h
View file

@ -21,7 +21,7 @@
#ifndef __ardour_location_ui_h__
#define __ardour_location_ui_h__
#include <gtk--.h>
#include <gtkmm.h>
#include <ardour/location.h>
#include <ardour/session.h>
@ -47,8 +47,8 @@ class LocationEditRow : public Gtk::HBox
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:
@ -126,11 +126,11 @@ class LocationEditRow : public Gtk::HBox
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;
};

14
gtk2_ardour/main.cc
View file

@ -41,9 +41,9 @@
#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"
@ -54,7 +54,7 @@
using namespace Gtk;
using namespace GTK_ARDOUR;
using namespace ARDOUR;
using namespace SigC;
using namespace sigc;
Transmitter error (Transmitter::Error);
Transmitter info (Transmitter::Info);
@ -306,13 +306,13 @@ Please consider the possibilities, and perhaps (re)start JACK."));
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 ();

4
gtk2_ardour/marker.h
View file

@ -25,7 +25,7 @@
#include <glib.h>
#include <ardour/ardour.h>
#include <gtk-canvas.h>
#include <sigc++/signal_system.h>
#include <sigc++/signal.h>
namespace ARDOUR {
class TempoSection;
@ -34,7 +34,7 @@ namespace ARDOUR {
class PublicEditor;
class Marker : public SigC::Object
class Marker : public sigc::trackable
{
public:
enum Type {

6
gtk2_ardour/marker_time_axis.cc
View file

@ -22,7 +22,7 @@
#include <pbd/error.h>
#include <gtkmmext/utils.h>
#include <gtkmm2ext/utils.h>
#include <ardour/session.h>
#include <ardour/utils.h>
@ -40,7 +40,7 @@
#include "i18n.h"
using namespace ARDOUR;
using namespace SigC;
using namespace sigc;
using namespace Gtk;
//---------------------------------------------------------------------------------------//
@ -312,7 +312,7 @@ MarkerTimeAxis::finish_route_rename()
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;
}

2
gtk2_ardour/marker_time_axis.h
View file

@ -21,7 +21,7 @@
#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"

4
gtk2_ardour/marker_time_axis_view.cc
View file

@ -20,8 +20,8 @@
#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"

8
gtk2_ardour/marker_time_axis_view.h
View file

@ -23,7 +23,7 @@
#include <list>
#include <gtk--.h>
#include <gtkmm.h>
#include <gtk-canvas.h>
#include <ardour/location.h>
@ -40,7 +40,7 @@ class TimeAxisViewItem ;
* 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:
//---------------------------------------------------------------------------------------//
@ -202,10 +202,10 @@ class MarkerTimeAxisView : public SigC::Object
// 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:
/**

6
gtk2_ardour/marker_view.cc
View file

@ -18,7 +18,7 @@
$Id$
*/
#include <gtk--.h>
#include <gtkmm.h>
#include "imageframe_time_axis.h"
#include "imageframe_view.h"
@ -27,9 +27,9 @@
#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

8
gtk2_ardour/marker_view.h
View file

@ -22,7 +22,7 @@
#define __gtk_ardour_marker_view_h__
#include <string>
#include <gtk--.h>
#include <gtkmm.h>
#include <gtk-canvas.h>
#include "time_axis_view_item.h"
@ -70,7 +70,7 @@ class MarkerView : public TimeAxisViewItem
*/
~MarkerView() ;
static SigC::Signal1<void,MarkerView*> GoingAway;
static sigc::signal<void,MarkerView*> GoingAway;
//---------------------------------------------------------------------------------------//
// Marker Type Methods
@ -112,10 +112,10 @@ class MarkerView : public TimeAxisViewItem
// 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:

8
gtk2_ardour/meter_bridge.cc
View file

@ -33,9 +33,9 @@
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 ()
@ -65,11 +65,11 @@ 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");

14
gtk2_ardour/meter_bridge.h
View file

@ -23,12 +23,12 @@
#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"
@ -78,7 +78,7 @@ class MeterBridge : public ArdourDialog
list<MeterBridgeStrip*> meters;
bool metering;
SigC::Connection metering_connection;
sigc::connection metering_connection;
void update ();

18
gtk2_ardour/meter_bridge_strip.cc
View file

@ -24,8 +24,8 @@
#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>
@ -41,7 +41,7 @@
using namespace ARDOUR;
using namespace Gtk;
using namespace Gtkmmext;
using namespace Gtkmm2ext;
MeterBridgeStrip::MeterBridgeStrip (AudioEngine &eng,
Session& s,
@ -61,7 +61,7 @@ MeterBridgeStrip::MeterBridgeStrip (AudioEngine &eng,
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));
@ -72,28 +72,28 @@ MeterBridgeStrip::MeterBridgeStrip (AudioEngine &eng,
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);
@ -223,7 +223,7 @@ MeterBridgeStrip::label_button_press_release (GdkEventButton *ev)
Gtk::Main::run();
if (prompter.status == Gtkmmext::Prompter::entered) {
if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result (name);

12
gtk2_ardour/meter_bridge_strip.h
View file

@ -21,9 +21,9 @@
#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;
@ -31,12 +31,12 @@ namespace ARDOUR {
class Route;
}
namespace Gtkmmext {
namespace Gtkmm2ext {
class Selector;
struct SelectionResult;
}
class MeterBridgeStrip : public SigC::Object
class MeterBridgeStrip : public sigc::trackable
{
public:
@ -74,7 +74,7 @@ class MeterBridgeStrip : public SigC::Object
bool meter_clear_pending;
bool over_clear_pending;
Gtkmmext::FastMeter meter;
Gtkmm2ext::FastMeter meter;
bool meter_on;
Gtk::VBox above_meter_vbox;

86
gtk2_ardour/mixer_strip.cc
View file

@ -23,13 +23,13 @@
#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>
@ -61,10 +61,10 @@
#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[] = {
@ -145,8 +145,8 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, Route& rt, bool in_mixer)
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"));
@ -160,7 +160,7 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, Route& rt, bool in_mixer)
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");
@ -178,17 +178,17 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, Route& rt, bool in_mixer)
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);
@ -251,7 +251,7 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, Route& rt, bool in_mixer)
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);
@ -267,7 +267,7 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, Route& rt, bool in_mixer)
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());
@ -280,7 +280,7 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, Route& rt, bool in_mixer)
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);
@ -290,8 +290,8 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, Route& rt, bool in_mixer)
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);
@ -308,7 +308,7 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, Route& rt, bool in_mixer)
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);
@ -430,7 +430,7 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, Route& rt, bool in_mixer)
update_input_display ();
update_output_display ();
add_events (GDK_BUTTON_RELEASE_MASK);
add_events (Gdk::BUTTON_RELEASE_MASK);
}
MixerStrip::~MixerStrip ()
@ -500,7 +500,7 @@ MixerStrip::set_width (Width w)
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"));
@ -512,11 +512,11 @@ MixerStrip::set_width (Width w)
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"));
@ -528,7 +528,7 @@ MixerStrip::set_width (Width w)
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;
}
@ -987,7 +987,7 @@ MixerStrip::_astyle_string (AutoStyle style, bool shrt)
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
@ -1100,13 +1100,13 @@ MixerStrip::pan_automation_state_changed ()
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
@ -1119,7 +1119,7 @@ MixerStrip::comment_button_clicked ()
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 ();
}
}
@ -1136,8 +1136,8 @@ MixerStrip::setup_comment_editor ()
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 ();
@ -1260,7 +1260,7 @@ MixerStrip::show_route_color ()
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();
@ -1325,7 +1325,7 @@ MixerStrip::speed_adjustment_changed ()
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
@ -1357,7 +1357,7 @@ MixerStrip::set_selected (bool yn)
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 ();

22
gtk2_ardour/mixer_strip.h
View file

@ -24,10 +24,10 @@
#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>
@ -48,7 +48,7 @@
class MotionController;
namespace Gtkmmext {
namespace Gtkmm2ext {
class SliderController;
}
@ -130,7 +130,7 @@ class MixerStrip : public RouteUI, public Gtk::EventBox
Gtk::ToggleButton polarity_button;
SigC::Connection newplug_connection;
sigc::connection newplug_connection;
gint mark_update_safe ();
guint32 mode_switch_in_progress;
@ -186,8 +186,8 @@ class MixerStrip : public RouteUI, public Gtk::EventBox
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);
@ -235,7 +235,7 @@ class MixerStrip : public RouteUI, public Gtk::EventBox
/* 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;
@ -246,8 +246,8 @@ class MixerStrip : public RouteUI, public Gtk::EventBox
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"; }

60
gtk2_ardour/mixer_ui.cc
View file

@ -22,9 +22,9 @@
#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>
@ -45,8 +45,8 @@
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"),
@ -82,41 +82,41 @@ Mixer_UI::Mixer_UI (AudioEngine& eng)
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");
@ -125,13 +125,13 @@ Mixer_UI::Mixer_UI (AudioEngine& eng)
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);
@ -147,11 +147,11 @@ Mixer_UI::Mixer_UI (AudioEngine& eng)
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);
@ -193,7 +193,7 @@ Mixer_UI::Mixer_UI (AudioEngine& eng)
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));
@ -202,7 +202,7 @@ Mixer_UI::Mixer_UI (AudioEngine& eng)
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));
@ -276,7 +276,7 @@ Mixer_UI::add_strip (Route* route)
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());
// }
}
@ -704,7 +704,7 @@ Mixer_UI::new_mix_group ()
Main::run ();
if (prompter.status != Gtkmmext::Prompter::entered) {
if (prompter.status != Gtkmm2ext::Prompter::entered) {
return;
}
@ -973,11 +973,11 @@ Mixer_UI::get_state (void)
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);
@ -1021,7 +1021,7 @@ Mixer_UI::pane_allocation_handler (GtkAllocation *alloc, Gtk::Paned* which)
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);
}
@ -1038,7 +1038,7 @@ Mixer_UI::pane_allocation_handler (GtkAllocation *alloc, Gtk::Paned* which)
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);
}
@ -1055,7 +1055,7 @@ Mixer_UI::pane_allocation_handler (GtkAllocation *alloc, Gtk::Paned* which)
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);
}
}

6
gtk2_ardour/mixer_ui.h
View file

@ -23,7 +23,7 @@
#include <list>
#include <gtk--.h>
#include <gtkmm.h>
#include <ardour/ardour.h>
#include <ardour/stateful.h>
@ -122,9 +122,9 @@ class Mixer_UI : public Gtk::Window, public KeyboardTarget
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);

14
gtk2_ardour/new_session_dialog.cc
View file

@ -26,7 +26,7 @@
#include "prompter.h"
#include "new_session_dialog.h"
using namespace Gtkmmext;
using namespace Gtkmm2ext;
using namespace Gtk;
using namespace ARDOUR;
@ -61,7 +61,7 @@ NewSessionDialog::NewSessionDialog (ARDOUR::AudioEngine& engine, bool startup, s
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);
@ -197,8 +197,8 @@ NewSessionDialog::NewSessionDialog (ARDOUR::AudioEngine& engine, bool startup, s
// 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));
@ -277,7 +277,7 @@ NewSessionDialog::mix_template_refiller (CList &clist)
}
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);
@ -286,7 +286,7 @@ NewSessionDialog::mix_template_shift (Gtkmmext::Selector* selector, Gtkmmext::Se
}
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) {
@ -300,7 +300,7 @@ NewSessionDialog::mix_template_control (Gtkmmext::Selector* selector, Gtkmmext::
Gtk::Main::run();
if (prompter.status == Gtkmmext::Prompter::entered) {
if (prompter.status == Gtkmm2ext::Prompter::entered) {
string name;
prompter.get_result (name);

22
gtk2_ardour/new_session_dialog.h
View file

@ -1,11 +1,11 @@
#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;
@ -15,9 +15,9 @@ namespace ARDOUR {
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
@ -25,7 +25,7 @@ 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;
@ -84,8 +84,8 @@ class NewSessionDialog : public ArdourDialog
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 ();

138
gtk2_ardour/option_editor.cc
View file

@ -24,8 +24,8 @@
#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"
@ -42,7 +42,7 @@
using namespace ARDOUR;
using namespace Gtk;
using namespace Editing;
using namespace Gtkmmext;
using namespace Gtkmm2ext;
static const gchar *psync_strings[] = {
N_("Internal"),
@ -153,7 +153,7 @@ OptionEditor::OptionEditor (ARDOUR_UI& uip, PublicEditor& ed, Mixer_UI& mixui)
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");
@ -411,18 +411,18 @@ OptionEditor::setup_path_options()
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);
@ -531,8 +531,8 @@ OptionEditor::setup_fade_options ()
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");
@ -629,9 +629,9 @@ OptionEditor::setup_solo_options ()
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 ();
@ -751,11 +751,11 @@ OptionEditor::setup_display_options ()
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));
@ -877,9 +877,9 @@ OptionEditor::setup_sync_options ()
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);
@ -924,8 +924,8 @@ OptionEditor::setup_sync_options ()
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
@ -1011,9 +1011,9 @@ OptionEditor::setup_midi_options ()
*/
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());
@ -1024,13 +1024,13 @@ OptionEditor::setup_midi_options ()
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 ());
@ -1314,7 +1314,7 @@ void
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 ();
@ -1339,7 +1339,7 @@ void
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 ();
@ -1574,15 +1574,15 @@ OptionEditor::setup_click_editor ()
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);
@ -1595,13 +1595,13 @@ OptionEditor::setup_click_editor ()
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);
@ -1674,16 +1674,16 @@ OptionEditor::setup_misc_options()
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);
@ -1723,19 +1723,19 @@ OptionEditor::setup_misc_options()
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
@ -1888,14 +1888,14 @@ OptionEditor::setup_keyboard_options ()
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());
@ -1918,14 +1918,14 @@ OptionEditor::setup_keyboard_options ()
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());
@ -1948,8 +1948,8 @@ OptionEditor::setup_keyboard_options ()
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
@ -2038,7 +2038,7 @@ OptionEditor::fixup_combo_size (Gtk::Combo& combo, vector<string>& strings)
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

2
gtk2_ardour/option_editor.h
View file

@ -21,7 +21,7 @@
#ifndef __gtk_ardour_option_editor_h__
#define __gtk_ardour_option_editor_h__
#include <gtk--.h>
#include <gtkmm.h>
#include <ardour/session.h>

4
gtk2_ardour/pan_automation_time_axis.cc
View file

@ -22,7 +22,7 @@
#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"
@ -53,7 +53,7 @@ PanAutomationTimeAxisView::add_automation_event (GtkCanvasItem* item, GdkEvent*
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 ();

10
gtk2_ardour/panner2d.cc
View file

@ -24,7 +24,7 @@
#include <pbd/error.h>
#include <ardour/panner.h>
#include <gtkmmext/gtk_ui.h>
#include <gtkmm2ext/gtk_ui.h>
#include "panner2d.h"
#include "keyboard.h"
@ -34,7 +34,7 @@
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)
@ -67,7 +67,7 @@ Panner2d::Panner2d (Panner& p, int32_t w, int32_t h)
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);
}
@ -450,13 +450,13 @@ Panner2d::expose_event_impl (GdkEventExpose *event)
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);

Some files were not shown because too many files have changed in this diff Show more