#define COMBO_TRIANGLE_WIDTH 25 // ArdourButton _diameter (11) + 2 * arrow-padding (2*2) + 2 * text-padding (2*5)
-static void
-pane_size_watcher (Paned* pane)
-{
- /* if the handle of a pane vanishes into (at least) the tabs of a notebook,
- it is:
-
- X: hard to access
- Quartz: impossible to access
-
- so stop that by preventing it from ever getting too narrow. 35
- pixels is basically a rough guess at the tab width.
-
- ugh.
- */
-
- int max_width_of_lhs = GTK_WIDGET(pane->gobj())->allocation.width - 35;
-
- gint pos = pane->get_position ();
-
- if (pos > max_width_of_lhs) {
- pane->set_position (max_width_of_lhs);
- }
-}
-
Editor::Editor ()
: PublicEditor (global_hpacker)
, editor_mixer_strip_width (Wide)
_notebook_shrunk = false;
- editor_summary_pane.pack1(edit_packer);
+
+ /* Pick up some settings we need to cache, early */
+
+ XMLNode* settings = ARDOUR_UI::instance()->editor_settings();
+ XMLProperty* prop;
+
+ if (settings && (prop = settings->property ("notebook-shrunk"))) {
+ _notebook_shrunk = string_is_affirmative (prop->value ());
+ }
+
+ editor_summary_pane.add (edit_packer);
Button* summary_arrows_left_left = manage (new Button);
summary_arrows_left_left->add (*manage (new Arrow (ARROW_LEFT, SHADOW_NONE)));
_summary_hbox.pack_start (*summary_arrows_right, false, false);
if (!ARDOUR::Profile->get_trx()) {
- editor_summary_pane.pack2 (_summary_hbox);
+ editor_summary_pane.add (_summary_hbox);
}
- edit_pane.pack1 (editor_summary_pane, true, true);
+ edit_pane.add (editor_summary_pane);
if (!ARDOUR::Profile->get_trx()) {
- edit_pane.pack2 (_the_notebook, false, true);
+ edit_pane.add (_the_notebook);
}
- editor_summary_pane.signal_size_allocate().connect (sigc::bind (sigc::mem_fun (*this, &Editor::pane_allocation_handler), static_cast<Paned*> (&editor_summary_pane)));
- /* XXX: editor_summary_pane might need similar to the edit_pane */
+ if (!settings || (prop = settings->property ("edit-horizontal-pane-pos")) == 0) {
+ /* initial allocation is 90% to canvas, 10% to notebook */
+ edit_pane.set_divider (0, 0.90);
+ } else {
+ edit_pane.set_divider (0, atof (prop->value()));
+ }
- edit_pane.signal_size_allocate().connect (sigc::bind (sigc::mem_fun(*this, &Editor::pane_allocation_handler), static_cast<Paned*> (&edit_pane)));
+ if (!settings || (prop = settings->property ("edit-vertical-pane-pos")) == 0) {
+ /* initial allocation is 90% to canvas, 10% to summary */
+ editor_summary_pane.set_divider (0, 0.90);
+ } else {
- Glib::PropertyProxy<int> proxy = edit_pane.property_position();
- proxy.signal_changed().connect (bind (sigc::ptr_fun (pane_size_watcher), static_cast<Paned*> (&edit_pane)));
+ editor_summary_pane.set_divider (0, atof (prop->value()));
+ }
top_hbox.pack_start (toolbar_frame);
node->add_child_nocopy (Tabbable::get_state());
- snprintf(buf,sizeof(buf), "%f", paned_position_as_fraction (edit_pane, false));
+ snprintf(buf,sizeof(buf), "%f", edit_pane.get_divider ());
node->add_property("edit-horizontal-pane-pos", string(buf));
node->add_property("notebook-shrunk", _notebook_shrunk ? "1" : "0");
- snprintf(buf,sizeof(buf), "%f", paned_position_as_fraction (editor_summary_pane, true));
+ snprintf(buf,sizeof(buf), "%f", editor_summary_pane.get_divider());
node->add_property("edit-vertical-pane-pos", string(buf));
maybe_add_mixer_strip_width (*node);
}
}
-void
-Editor::pane_allocation_handler (Allocation &alloc, Paned* which)
-{
- /* recover or initialize pane positions. do this here rather than earlier because
- we don't want the positions to change the child allocations, which they seem to do.
-
- See comments in mixer_ui.cc about how this works.
- */
-
- float pos;
- XMLProperty* prop;
- XMLNode* geometry = ARDOUR_UI::instance()->editor_settings();
-
- enum Pane {
- Horizontal = 0x1,
- Vertical = 0x2
- };
-
- static Pane done;
-
- if (which == static_cast<Paned*> (&edit_pane)) {
-
- if (done & Horizontal) {
- return;
- }
-
- if (geometry && (prop = geometry->property ("notebook-shrunk"))) {
- _notebook_shrunk = string_is_affirmative (prop->value ());
- }
-
- if (!geometry || (prop = geometry->property ("edit-horizontal-pane-pos")) == 0) {
- /* initial allocation is 90% to canvas, 10% to notebook */
- pos = (int) floor (alloc.get_width() * 0.90f);
- } else {
- pos = atof (prop->value());
- }
-
- if (pos > 1.0f) {
- /* older versions of Ardour stored absolute position */
- if (alloc.get_width() > pos) {
- edit_pane.set_position (pos);
- done = (Pane) (done | Horizontal);
- }
- } else {
- if (alloc.get_width() > 1.0/pos) {
- paned_set_position_as_fraction (edit_pane, pos, false);
- done = (Pane) (done | Horizontal);
- }
- }
-
- } else if (which == static_cast<Paned*> (&editor_summary_pane)) {
-
- if (done & Vertical) {
- return;
- }
-
- if (!geometry || (prop = geometry->property ("edit-vertical-pane-pos")) == 0) {
- /* initial allocation is 90% to canvas, 10% to summary */
- pos = (int) floor (alloc.get_height() * 0.90f);
- } else {
-
- pos = atof (prop->value());
- }
-
- if (pos > 1.0f) {
- /* older versions of Ardour stored absolute position */
- if (alloc.get_height() > pos) {
- editor_summary_pane.set_position (pos);
- done = (Pane) (done | Vertical);
- }
- } else {
- if (alloc.get_height() > 1.0/pos) {
- paned_set_position_as_fraction (editor_summary_pane, pos, true);
- done = (Pane) (done | Vertical);
- }
- }
- }
-}
-
void
Editor::set_show_measures (bool yn)
{
if (_notebook_shrunk) {
if (pre_notebook_shrink_pane_width) {
- edit_pane.set_position (*pre_notebook_shrink_pane_width);
+ edit_pane.set_divider (0, *pre_notebook_shrink_pane_width);
}
_notebook_shrunk = false;
} else {
- pre_notebook_shrink_pane_width = edit_pane.get_position();
+ pre_notebook_shrink_pane_width = edit_pane.get_divider();
/* this expands the LHS of the edit pane to cover the notebook
PAGE but leaves the tabs visible.
*/
- edit_pane.set_position (edit_pane.get_position() + page->get_width());
+ edit_pane.set_divider (0, edit_pane.get_divider() + page->get_width());
_notebook_shrunk = true;
}
}
#include <gtkmm/comboboxtext.h>
#include <gtkmm/layout.h>
-#include "gtkmm2ext/selector.h"
+#include "gtkmm2ext/bindings.h"
#include "gtkmm2ext/click_box.h"
#include "gtkmm2ext/dndtreeview.h"
+#include "gtkmm2ext/pane.h"
+#include "gtkmm2ext/selector.h"
#include "gtkmm2ext/stateful_button.h"
-#include "gtkmm2ext/bindings.h"
#include "pbd/stateful.h"
#include "pbd/signals.h"
void update_join_object_range_location (double);
- boost::optional<int> pre_notebook_shrink_pane_width;
-
- void pane_allocation_handler (Gtk::Allocation&, Gtk::Paned*);
+ boost::optional<float> pre_notebook_shrink_pane_width;
Gtk::Notebook _the_notebook;
bool _notebook_shrunk;
void add_notebook_page (std::string const &, Gtk::Widget &);
bool notebook_tab_clicked (GdkEventButton *, Gtk::Widget *);
- Gtk::HPaned edit_pane;
- Gtk::VPaned editor_summary_pane;
+ Gtkmm2ext::HPane edit_pane;
+ Gtkmm2ext::VPane editor_summary_pane;
Gtk::EventBox meter_base;
Gtk::HBox meter_box;
table->attach (loc_frame_box, 0, 2, table_row, table_row + 1);
++table_row;
- loc_range_panes.pack1 (*table, true, false);
+ loc_range_panes.add (*table);
table = manage (new Table (3, 2));
table->set_spacings (2);
table->attach (range_frame_box, 0, 2, table_row, table_row + 1);
++table_row;
- loc_range_panes.pack2 (*table, true, false);
+ loc_range_panes.add (*table);
HBox* add_button_box = manage (new HBox);
add_button_box->pack_start (add_location_button, true, true);
#include <gtkmm/table.h>
#include <gtkmm/entry.h>
#include <gtkmm/label.h>
-#include <gtkmm/paned.h>
#include <gtkmm/scrolledwindow.h>
#include "pbd/signals.h"
#include "ardour/location.h"
#include "ardour/session_handle.h"
+#include <gtkmm2ext/pane.h>
+
#include "ardour_button.h"
#include "ardour_window.h"
#include "audio_clock.h"
LocationEditRow punch_edit_row;
Gtk::VBox loop_punch_box;
- Gtk::VPaned loc_range_panes;
+ Gtkmm2ext::VPane loc_range_panes;
Gtk::VBox loc_frame_box;
Gtk::Button add_location_button;
#include "pbd/md5.h"
#include "gtkmm2ext/gtk_ui.h"
+#include "gtkmm2ext/pane.h"
#include "gtkmm2ext/utils.h"
#include "gtkmm2ext/window_title.h"
vbox->pack_start (*scrollin, true, true, 0);
vbox->pack_start (*hbox, false, false, 2);
- Gtk::VPaned *vpane = manage (new Gtk::VPaned ());
- vpane->pack1 (*vbox, true, false);
- vpane->pack2 (scrollout, false, true);
+ Gtkmm2ext::VPane *vpane = manage (new Gtkmm2ext::VPane ());
+ vpane->add (*vbox);
+ vpane->add (scrollout);
vpane->show_all ();
add (*vpane);
favorite_plugins_frame.set_shadow_type (Gtk::SHADOW_IN);
favorite_plugins_frame.add (favorite_plugins_scroller);
- rhs_pane1.pack1 (favorite_plugins_frame, false, true);
- rhs_pane1.pack2 (track_display_frame);
- rhs_pane2.pack1 (rhs_pane1);
- rhs_pane2.pack2 (group_display_frame);
+ rhs_pane1.add (favorite_plugins_frame);
+ rhs_pane1.add (track_display_frame);
+ rhs_pane2.add (rhs_pane1);
+ rhs_pane2.add (group_display_frame);
list_vpacker.pack_start (rhs_pane2, true, true);
vca_scroller.set_policy (Gtk::POLICY_ALWAYS, Gtk::POLICY_AUTOMATIC);
vca_scroller.signal_button_release_event().connect (sigc::mem_fun(*this, &Mixer_UI::strip_scroller_button_release));
- inner_pane.pack1 (scroller);
- inner_pane.pack2 (vca_scroller);
+ inner_pane.add (scroller);
+ inner_pane.add (vca_scroller);
global_hpacker.pack_start (inner_pane, true, true);
global_hpacker.pack_start (out_packer, false, false);
- list_hpane.pack1(list_vpacker, false, true);
- list_hpane.pack2(global_hpacker, true, false);
-
- rhs_pane1.signal_size_allocate().connect (sigc::bind (sigc::mem_fun(*this, &Mixer_UI::pane_allocation_handler),
- static_cast<Gtk::Paned*> (&rhs_pane1)));
- rhs_pane2.signal_size_allocate().connect (sigc::bind (sigc::mem_fun(*this, &Mixer_UI::pane_allocation_handler),
- static_cast<Gtk::Paned*> (&rhs_pane2)));
- list_hpane.signal_size_allocate().connect (sigc::bind (sigc::mem_fun(*this, &Mixer_UI::pane_allocation_handler),
- static_cast<Gtk::Paned*> (&list_hpane)));
- inner_pane.signal_size_allocate().connect (sigc::bind (sigc::mem_fun(*this, &Mixer_UI::pane_allocation_handler),
- static_cast<Gtk::Paned*> (&inner_pane)));
+ list_hpane.add (list_vpacker);
+ list_hpane.add (global_hpacker);
_content.pack_start (list_hpane, true, true);
list_vpacker.show ();
//if user wants to show the pane, we should make sure that it is wide enough to be visible
- int width = list_hpane.get_position();
- if (width < 40) {
- list_hpane.set_position(40);
- }
+ /// XXX PANE
+ // float width = list_hpane.get_position();
+ //if (width < 40) {
+ // list_hpane.set_position(40);
+ //}
} else {
list_vpacker.hide ();
}
node->add_child_nocopy (Tabbable::get_state());
- snprintf(buf,sizeof(buf), "%f", paned_position_as_fraction (rhs_pane1, true));
+ snprintf(buf,sizeof(buf), "%f", rhs_pane1.get_divider());
node->add_property(X_("mixer-rhs-pane1-pos"), string(buf));
- snprintf(buf,sizeof(buf), "%f", paned_position_as_fraction (rhs_pane2, true));
+ snprintf(buf,sizeof(buf), "%f", rhs_pane2.get_divider());
node->add_property(X_("mixer-rhs_pane2-pos"), string(buf));
- snprintf(buf,sizeof(buf), "%f", paned_position_as_fraction (list_hpane, false));
+ snprintf(buf,sizeof(buf), "%f", list_hpane.get_divider());
node->add_property(X_("mixer-list-hpane-pos"), string(buf));
- snprintf(buf,sizeof(buf), "%f", paned_position_as_fraction (inner_pane, false));
+ snprintf(buf,sizeof(buf), "%f", inner_pane.get_divider());
node->add_property(X_("mixer-inner-pane-pos"), string(buf));
node->add_property ("narrow-strips", _strip_width == Narrow ? "yes" : "no");
return *node;
}
-void
-Mixer_UI::pane_allocation_handler (Allocation& allocation, Gtk::Paned* which)
-{
- float pos;
- XMLProperty* prop = 0;
- XMLNode* geometry = ARDOUR_UI::instance()->mixer_settings();
- int height = default_height;
- static bool done[4] = { false, false, false, false };
-
- /* Gtk::Paned behaves very oddly and rather undesirably. Setting the
- * position is a crapshoot if you time it incorrectly with the overall
- * sizing of the Paned. For example, if you might retrieve the size with
- * ::get_position() and then later call ::set_position() on a Paned at
- * a time when its allocation is different than it was when you retrieved
- * the position. The position will be interpreted as the size of the
- * first (top or left) child widget. If packing/size allocation later
- * resizes the Paned to a (final) smaller size, the position will be
- * used in ways that mean that the Paned ends up NOT in the same state
- * that it was in when you originally saved the position.
- *
- * Concrete example: Paned is 800 pixels wide, position is 400
- * (halfway). Save position as 400. During program restart, set
- * position to 400, before Paned has been allocated any space. Paned
- * ends up initially sized to 1200 pixels. Position is now 1/3 of the
- * way across/down. Subsequent resizes will leave the position 1/3 of
- * the way across, rather than leaving it as a fixed pixel
- * position. Eventually, the Paned ends up 800 pixels wide/high again,
- * but the position is now 267, not 400.
- *
- * So ...
- *
- * We deal with this by using two strategies:
- *
- * 1) only set the position if the allocated size of the Paned is at
- * least as big as it needs to be for the position to make sense.
- *
- * 2) in recent versions of Ardour, save the position as a fraction,
- * and restore it using that fraction.
- *
- * So, we will only call ::set_position() AFTER the Paned is of a
- * sensible size, and then in addition, we will set the position in a
- * way that will be maintained as/when/if the Paned is resized.
- *
- * Once we've called ::set_position() on a Paned, we don't do it
- * again.
- */
-
- if (which == static_cast<Gtk::Paned*> (&rhs_pane1)) {
-
- if (done[0]) {
- return;
- }
-
- if (!geometry || (prop = geometry->property("mixer-rhs-pane1-pos")) == 0) {
- pos = height / 3;
- } else {
- pos = atof (prop->value());
- }
-
- if (pos > 1.0f) {
- /* older versions of Ardour stored absolute position */
- if ((done[0] = (allocation.get_height() > pos))) {
- rhs_pane1.set_position (pos);
- }
- } else {
- if ((done[0] = (allocation.get_height() > 1.0/pos))) {
- paned_set_position_as_fraction (rhs_pane1, pos, true);
- }
- }
- }
-
- if (which == static_cast<Gtk::Paned*> (&rhs_pane2)) {
-
- if (done[1]) {
- return;
- }
-
- if (!geometry || (prop = geometry->property("mixer-rhs-pane2-pos")) == 0) {
- pos = 2 * height / 3;
- } else {
- pos = atof (prop->value());
- }
-
- if (pos > 1.0f) {
- /* older versions of Ardour stored absolute position */
- if ((done[1] = (allocation.get_height() > pos))) {
- rhs_pane2.set_position (pos);
- }
- } else {
- if ((done[1] = (allocation.get_height() > 1.0/pos))) {
- paned_set_position_as_fraction (rhs_pane2, pos, true);
- }
- }
- }
-
- if (which == static_cast<Gtk::Paned*> (&list_hpane)) {
-
- if (done[2]) {
- return;
- }
-
- if (!geometry || (prop = geometry->property("mixer-list-hpane-pos")) == 0) {
- pos = std::max ((float)100, rintf ((float) 125 * UIConfiguration::instance().get_ui_scale()));
- } else {
- pos = max (0.1, atof (prop->value ()));
- }
-
- if (pos > 1.0f) {
- if ((done[2] = (allocation.get_width() > pos))) {
- list_hpane.set_position (pos);
- }
- } else {
- if ((done[2] = (allocation.get_width() > 1.0/pos))) {
- paned_set_position_as_fraction (list_hpane, pos, false);
- }
- }
- }
-
- if (which == static_cast<Gtk::Paned*> (&inner_pane)) {
-
- if (done[3]) {
- return;
- }
-
- if (!geometry || (prop = geometry->property("mixer-inner-pane-pos")) == 0) {
- pos = std::max ((float)100, rintf ((float) 125 * UIConfiguration::instance().get_ui_scale()));
- } else {
- pos = max (0.1, atof (prop->value ()));
- }
-
- if (pos > 1.0f) {
- /* older versions of Ardour stored absolute position */
- if ((done[3] = (allocation.get_width() > pos))) {
- inner_pane.set_position (pos);
- }
- } else {
- if ((done[3] = (allocation.get_width() > 1.0/pos))) {
- paned_set_position_as_fraction (inner_pane, pos, false);
- }
- }
- }
-}
-
void
Mixer_UI::scroll_left ()
{
#include <gtkmm/label.h>
#include <gtkmm/button.h>
#include <gtkmm/frame.h>
-#include <gtkmm/paned.h>
#include <gtkmm/menu.h>
#include <gtkmm/treeview.h>
#include <gtkmm/liststore.h>
#include "ardour/plugin.h"
#include "ardour/plugin_manager.h"
-
#include "gtkmm2ext/dndtreeview.h"
+#include <gtkmm2ext/pane.h>
#include "gtkmm2ext/treeutils.h"
#include "gtkmm2ext/tabbable.h"
Gtk::Frame track_display_frame;
Gtk::Frame group_display_frame;
Gtk::Frame favorite_plugins_frame;
- Gtk::VPaned rhs_pane1;
- Gtk::VPaned rhs_pane2;
- Gtk::HPaned inner_pane;
+ Gtkmm2ext::VPane rhs_pane1;
+ Gtkmm2ext::VPane rhs_pane2;
+ Gtkmm2ext::HPane inner_pane;
Gtk::HBox strip_packer;
Gtk::ScrolledWindow vca_scroller;
Gtk::HBox vca_packer;
Gtk::EventBox vca_scroller_base;
Gtk::HBox out_packer;
- Gtk::HPaned list_hpane;
+ Gtkmm2ext::HPane list_hpane;
MixerGroupTabs* _group_tabs;
bool on_scroll_event (GdkEventScroll*);
- void pane_allocation_handler (Gtk::Allocation&, Gtk::Paned*);
-
std::list<MixerStrip *> strips;
void scroller_drag_data_received (const Glib::RefPtr<Gdk::DragContext>&, int, int, const Gtk::SelectionData&, guint, guint);
route_vpacker.pack_start (route_hpacker, true, true);
- list_hpane.pack1 (list_vpacker);
- list_hpane.add2 (route_vpacker);
+ list_hpane.add (list_vpacker);
+ list_hpane.add (route_vpacker);
- list_hpane.set_position(110);
+ /// XXX PANE
+ //list_hpane.set_position(110);
- redir_hpane.set_position(110);
+ /// XXX PANE
+ //redir_hpane.set_position(110);
//global_vpacker.pack_start (list_hpane, true, true);
//get_vbox()->pack_start (global_vpacker);
if (at) {
at->FreezeChange.connect (route_connections, invalidator (*this), boost::bind (&RouteParams_UI::map_frozen, this), gui_context());
}
- redir_hpane.pack1 (*insert_box);
+ redir_hpane.add (*insert_box);
insert_box->ProcessorSelected.connect (sigc::mem_fun(*this, &RouteParams_UI::redirect_selected)); //note: this indicates a double-click activation, not just a "selection"
insert_box->ProcessorUnselected.connect (sigc::mem_fun(*this, &RouteParams_UI::redirect_selected));
send->DropReferences.connect (_processor_going_away_connection, invalidator (*this), boost::bind (&RouteParams_UI::processor_going_away, this, boost::weak_ptr<Processor>(proc)), gui_context());
_active_view = send_ui;
- redir_hpane.add2 (*_active_view);
+ redir_hpane.add (*_active_view);
redir_hpane.show_all();
} else if ((retrn = boost::dynamic_pointer_cast<Return> (proc)) != 0) {
retrn->DropReferences.connect (_processor_going_away_connection, invalidator (*this), boost::bind (&RouteParams_UI::processor_going_away, this, boost::weak_ptr<Processor>(proc)), gui_context());
_active_view = return_ui;
- redir_hpane.add2 (*_active_view);
+ redir_hpane.add (*_active_view);
redir_hpane.show_all();
} else if ((plugin_insert = boost::dynamic_pointer_cast<PluginInsert> (proc)) != 0) {
plugin_ui->start_updating (0);
_active_view = plugin_ui;
- redir_hpane.pack2 (*_active_view);
+ redir_hpane.add (*_active_view);
redir_hpane.show_all();
} else if ((port_insert = boost::dynamic_pointer_cast<PortInsert> (proc)) != 0) {
port_insert->DropReferences.connect (_processor_going_away_connection, invalidator (*this), boost::bind (&RouteParams_UI::processor_going_away, this, boost::weak_ptr<Processor> (proc)), gui_context());
_active_view = portinsert_ui;
- redir_hpane.pack2 (*_active_view);
+ redir_hpane.add (*_active_view);
portinsert_ui->redisplay();
redir_hpane.show_all();
}
#include <gtkmm/eventbox.h>
#include <gtkmm/frame.h>
#include <gtkmm/label.h>
-#include <gtkmm/paned.h>
#include <gtkmm/scrolledwindow.h>
#include <gtkmm/togglebutton.h>
#include <gtkmm/treeview.h>
#include "ardour/ardour.h"
+#include <gtkmm2ext/pane.h>
+
#include "ardour_window.h"
#include "processor_box.h"
#include "route_processor_selection.h"
Gtk::Notebook notebook;
Gtk::Frame input_frame;
Gtk::Frame output_frame;
- Gtk::HPaned redir_hpane;
+ Gtkmm2ext::HPane redir_hpane;
Gtk::Frame route_select_frame;
ProcessorBox* insert_box;
- Gtk::HPaned list_hpane;
+ Gtkmm2ext::HPane list_hpane;
- Gtk::HPaned right_hpane;
+ Gtkmm2ext::HPane right_hpane;
Gtk::Frame route_choice_frame;
namespace Gtk {
class Window;
class ComboBoxText;
- class Paned;
class Adjustment;
}
projects / ardour.git / commitdiff