Tab reordering

roundabout,
created on Saturday, 15 March 2025, 10:16:25 (1742033785), received on Saturday, 15 March 2025, 10:16:28 (1742033788)
Author identity: vlad <vlad.muntoiu@gmail.com>

                                
                                
                                
                            
                                
                                    
                                        
                                            533  
                                                        drag_source->set_actions(Gdk::DragAction::MOVE);
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            534  
                                                        auto const paintable = Gtk::WidgetPaintable::create();
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            535  
                                                        paintable->set_widget(*this);
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        536 -
                                                    drag_source->set_icon(paintable, 0, 0);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        536 +
                                                    drag_source->set_icon(paintable->get_current_image(), 0, 0);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            537  
                                                        return Gdk::ContentProvider::create(value);
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            538  
                                                    }, false);
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            539  
                                                    update_active_style();
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        540 +
                                                drag_source->signal_drag_begin().connect([this](const Glib::RefPtr<Gdk::Drag>&) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        541 +
                                                    this->set_opacity(0);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        542 +
                                                }, false);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        543 +
                                                drop_target = Gtk::DropTarget::create(ContentPage::get_type(), Gdk::DragAction::MOVE);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        544 +
                                                // Process dropped buttons by inserting them after the current button
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        545 +
                                                drop_target->signal_drop().connect([this](const Glib::ValueBase& value, double x, double y) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        546 +
                                                    const auto &widget = static_cast<const Glib::Value<ContentPage*>&>(value).get();
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        547 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        548 +
                                                    if(widget) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        549 +
                                                        if(auto page = dynamic_cast<ContentPage*>(widget)) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        550 +
                                                            if(page->content_manager != this->page->content_manager) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        551 +
                                                                // If the pane is not in the same layout manager, reject
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        552 +
                                                                return false;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        553 +
                                                            }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        554 +
                                                            auto switcher = dynamic_cast<ContentTabBar*>(this->get_parent());
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        555 +
                                                            if(switcher) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        556 +
                                                                auto *stack = switcher->get_stack();
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        557 +
                                                                // Move the button to the new position
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        558 +
                                                                page->redock(stack);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        559 +
                                                                if(switcher->get_orientation() == Gtk::Orientation::HORIZONTAL) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        560 +
                                                                    if(x < static_cast<double>(this->get_allocated_width()) / 2) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        561 +
                                                                        page->insert_before(*stack, *this->page);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        562 +
                                                                    } else {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        563 +
                                                                        page->insert_after(*stack, *this->page);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        564 +
                                                                    }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        565 +
                                                                } else if(switcher->get_orientation() == Gtk::Orientation::VERTICAL) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        566 +
                                                                    if(y < static_cast<double>(this->get_allocated_height()) / 2) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        567 +
                                                                        page->insert_before(*stack, *this->page);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        568 +
                                                                    } else {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        569 +
                                                                        page->insert_after(*stack, *this->page);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        570 +
                                                                    }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        571 +
                                                                }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        572 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        573 +
                                                                switcher->update_buttons();
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        574 +
                                                            }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        575 +
                                                        }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        576 +
                                                    }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        577 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        578 +
                                                    return true;  // Drop OK
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        579 +
                                                }, false);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        580 +
                                                this->add_controller(drop_target);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            581  
                                                    // Pop out if dragged to an external location
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            582  
                                                    // TODO: Implement this, allow defining custom behavior at the content manager level
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            583  
                                                }
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                            
                                

                                
                                
                                
                            
                                
                                    
                                        
                                            136  
                                                class ContentTab : public Gtk::ToggleButton {
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            137  
                                                private:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            138  
                                                    std::shared_ptr<Gtk::DragSource> drag_source;
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        139 +
                                                std::shared_ptr<Gtk::DropTarget> drop_target;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            140  
                                                    Glib::Value<ContentPage*> value;
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            141  
                                                    void update_active_style();
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            142  
                                                    sigc::connection active_style_handler;