From 0ef04e409479c2cc28d9a143ec2046fba6252060 Mon Sep 17 00:00:00 2001 From: c4pp4 Date: Mon, 9 Feb 2026 01:33:42 +0100 Subject: [PATCH 1/1] Revert unwanted Ubuntu Unity changes Revert panel padding, dash and hud border, dash preview, dash and launcher icon size, online search tooltip, drag & drop, and icon desaturation on hud activation. Signed-off-by: c4pp4 --- dash/DashView.cpp | 129 ++++++++++- launcher/BFBLauncherIcon.cpp | 4 +- launcher/Launcher.cpp | 312 ++++++++++++++++++++++++++- lockscreen/LockScreenPanel.cpp | 4 +- panel/PanelIndicatorsView.cpp | 1 - panel/PanelView.cpp | 2 +- plugins/unityshell/unityshell.xml.in | 2 +- unity-shared/DashStyle.cpp | 51 +++-- unity-shared/OverlayRenderer.cpp | 8 +- 9 files changed, 479 insertions(+), 34 deletions(-) diff --git a/dash/DashView.cpp b/dash/DashView.cpp index bc8a57f..380840c 100644 --- a/dash/DashView.cpp +++ b/dash/DashView.cpp @@ -232,12 +232,83 @@ void DashView::OnResultActivated(ResultView::ActivateType type, LocalResult cons void DashView::BuildPreview(Preview::Ptr model) { - // Previews have been removed, so this function has been left blank until we eliminate all of the preview-related code. + if (!preview_displaying_) + { + StartPreviewAnimation(); + + content_view_->SetPresentRedirectedView(false); + preview_scope_view_ = active_scope_view_; + if (preview_scope_view_) + { + preview_scope_view_->ForceCategoryExpansion(stored_activated_unique_id_, true); + preview_scope_view_->EnableResultTextures(true); + preview_scope_view_->PushFilterExpansion(false); + } + + if (!preview_container_) + { + preview_container_ = new previews::PreviewContainer(); + preview_container_->SetRedirectRenderingToTexture(true); + AddChild(preview_container_.GetPointer()); + preview_container_->SetParentObject(this); + } + preview_container_->Preview(model, previews::Navigation::NONE); // no swipe left or right + preview_container_->scale = scale(); + preview_container_->SetGeometry(scopes_layout_->GetGeometry()); + preview_displaying_ = true; + + // connect to nav left/right signals to request nav left/right movement. + preview_container_->navigate_left.connect([this] () { + preview_navigation_mode_ = previews::Navigation::LEFT; + + // sends a message to all result views, sending the the uri of the current preview result + // and the unique id of the result view that should be handling the results + ubus_manager_.SendMessage(UBUS_DASH_PREVIEW_NAVIGATION_REQUEST, g_variant_new("(ivs)", -1, g_variant_ref(last_activated_result_.Variant()), stored_activated_unique_id_.c_str())); + }); + + preview_container_->navigate_right.connect([this] () { + preview_navigation_mode_ = previews::Navigation::RIGHT; + + // sends a message to all result views, sending the the uri of the current preview result + // and the unique id of the result view that should be handling the results + ubus_manager_.SendMessage(UBUS_DASH_PREVIEW_NAVIGATION_REQUEST, g_variant_new("(ivs)", 1, g_variant_ref(last_activated_result_.Variant()), stored_activated_unique_id_.c_str())); + }); + + preview_container_->request_close.connect([this] () { ClosePreview(); }); + } + else + { + // got a new preview whilst already displaying, we probably clicked a navigation button. + preview_container_->Preview(model, preview_navigation_mode_); // TODO + preview_container_->scale = scale(); + } + + if (G_LIKELY(preview_state_machine_.left_results() > 0 && preview_state_machine_.right_results() > 0)) + preview_container_->DisableNavButton(previews::Navigation::NONE); + else if (preview_state_machine_.left_results() > 0) + preview_container_->DisableNavButton(previews::Navigation::RIGHT); + else if (preview_state_machine_.right_results() > 0) + preview_container_->DisableNavButton(previews::Navigation::LEFT); + else + preview_container_->DisableNavButton(previews::Navigation::BOTH); + + QueueDraw(); } void DashView::ClosePreview() { - // Previews have been removed, so this function has been left blank until we eliminate all of the preview-related code. + if (preview_displaying_) + { + EndPreviewAnimation(); + + preview_displaying_ = false; + } + + preview_navigation_mode_ = previews::Navigation::NONE; + + // re-focus dash view component. + nux::GetWindowCompositor().SetKeyFocusArea(default_focus()); + QueueDraw(); } void DashView::StartPreviewAnimation() @@ -1026,7 +1097,59 @@ void DashView::DrawPreviewResultTextures(nux::GraphicsEngine& graphics_engine, b } void DashView::DrawPreview(nux::GraphicsEngine& graphics_engine, bool force_draw) -{ } +{ + if (animate_preview_value_ > 0.0f) + { + bool animating = animate_split_value_ != 1.0f || animate_preview_value_ < 1.0f; + bool preview_force_draw = force_draw || animating || IsFullRedraw(); + + if (preview_force_draw) + nux::GetPainter().PushBackgroundStack(); + + if (animate_preview_value_ < 1.0f && preview_container_->RedirectRenderingToTexture()) + { + preview_container_->SetPresentRedirectedView(false); + preview_container_->ProcessDraw(graphics_engine, preview_force_draw); + + unsigned int alpha, src, dest = 0; + graphics_engine.GetRenderStates().GetBlend(alpha, src, dest); + graphics_engine.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA); + + nux::ObjectPtr preview_texture = preview_container_->BackupTexture(); + if (preview_texture) + { + nux::TexCoordXForm texxform; + texxform.FlipVCoord(true); + texxform.uoffset = 0.0f; + texxform.voffset = 0.0f; + texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD); + + nux::Geometry const& geo_preview = preview_container_->GetGeometry(); + graphics_engine.QRP_1Tex + ( + geo_preview.x, + geo_preview.y, + geo_preview.width, + geo_preview.height, + preview_texture, + texxform, + nux::Color(animate_preview_value_, animate_preview_value_, animate_preview_value_, animate_preview_value_) + ); + } + + preview_container_->SetPresentRedirectedView(true); + + graphics_engine.GetRenderStates().SetBlend(alpha, src, dest); + } + else + { + preview_container_->ProcessDraw(graphics_engine, preview_force_draw); + } + + if (preview_force_draw) + nux::GetPainter().PopBackgroundStack(); + } +} void DashView::OnActivateRequest(GVariant* args) { diff --git a/launcher/BFBLauncherIcon.cpp b/launcher/BFBLauncherIcon.cpp index eece73a..68ff72d 100644 --- a/launcher/BFBLauncherIcon.cpp +++ b/launcher/BFBLauncherIcon.cpp @@ -143,7 +143,9 @@ void BFBLauncherIcon::UpdateDefaultSearchText() { auto home_scope = reader_->GetScopeDataById("home.scope"); - tooltip_text = _("Search your computer"); + tooltip_text = ((Settings::Instance().remote_content) ? + _("Search your computer and online sources") : + _("Search your computer")); if (home_scope) { diff --git a/launcher/Launcher.cpp b/launcher/Launcher.cpp index a4f880a..fa7268d 100644 --- a/launcher/Launcher.cpp +++ b/launcher/Launcher.cpp @@ -1111,6 +1111,13 @@ void Launcher::OnOverlayShown(GVariant* data) bg_effect_helper_.enabled = true; + // Don't desaturate icons if the mouse is over the launcher: + if (!hovered_) + { + LOG_DEBUG(logger) << "Desaturate on monitor " << monitor(); + DesaturateIcons(); + } + if (icon_under_mouse_) icon_under_mouse_->HideTooltip(); } @@ -2760,22 +2767,242 @@ bool Launcher::DndIsSpecialRequest(std::string const& uri) const } void Launcher::ProcessDndEnter() -{ } +{ +#ifdef USE_X11 + SetStateMouseOverLauncher(true); + + dnd_data_.Reset(); + drag_action_ = nux::DNDACTION_NONE; + steal_drag_ = false; + data_checked_ = false; + dnd_hovered_icon_ = nullptr; + drag_edge_touching_ = false; + dnd_hide_animation_.Stop(); +#endif +} void Launcher::DndReset() -{ } +{ +#ifdef USE_X11 + dnd_data_.Reset(); + + bool is_overlay_open = IsOverlayOpen(); + + for (auto it : *model_) + { + auto icon_type = it->GetIconType(); + bool desaturate = false; + + if (icon_type != AbstractLauncherIcon::IconType::HOME && + icon_type != AbstractLauncherIcon::IconType::HUD) + { + desaturate = is_overlay_open && !hovered_; + } + + it->SetQuirk(AbstractLauncherIcon::Quirk::DESAT, desaturate, monitor()); + it->SetQuirk(AbstractLauncherIcon::Quirk::UNFOLDED, false, monitor()); + } + + DndHoveredIconReset(); +#endif +} void Launcher::DndHoveredIconReset() -{ } +{ +#ifdef USE_X11 + SetActionState(ACTION_NONE); + + if (steal_drag_ && dnd_hovered_icon_) + { + dnd_hovered_icon_->SetQuirk(AbstractLauncherIcon::Quirk::VISIBLE, false, monitor()); + dnd_hovered_icon_->remove.emit(dnd_hovered_icon_); + } + + if (!steal_drag_ && dnd_hovered_icon_) + { + dnd_hovered_icon_->SendDndLeave(); + dnd_hovered_icon_->SetQuirk(AbstractLauncherIcon::Quirk::GLOW, false, monitor()); + } + + steal_drag_ = false; + drag_edge_touching_ = false; + dnd_hovered_icon_ = nullptr; +#endif +} void Launcher::ProcessDndLeave() -{ } +{ +#ifdef USE_X11 + SetStateMouseOverLauncher(false); + DndHoveredIconReset(); +#endif +} void Launcher::ProcessDndMove(int x, int y, std::list mimes) -{ } +{ +#ifdef USE_X11 + if (!data_checked_) + { + const std::string uri_list = "text/uri-list"; + data_checked_ = true; + dnd_data_.Reset(); + auto& display = nux::GetWindowThread()->GetGraphicsDisplay(); + + // get the data + for (auto const& mime : mimes) + { + if (mime != uri_list) + continue; + + dnd_data_.Fill(display.GetDndData(const_cast(uri_list.c_str()))); + break; + } + + // see if the launcher wants this one + auto const& uris = dnd_data_.Uris(); + if (std::find_if(uris.begin(), uris.end(), [this] (std::string const& uri) + {return DndIsSpecialRequest(uri);}) != uris.end()) + { + steal_drag_ = true; + } + + // only set hover once we know our first x/y + SetActionState(ACTION_DRAG_EXTERNAL); + SetStateMouseOverLauncher(true); + } + + SetMousePosition(x - parent_->GetGeometry().x, y - parent_->GetGeometry().y); + + if (options()->hide_mode != LAUNCHER_HIDE_NEVER) + { + if ((monitor() == 0 && !IsOverlayOpen() && mouse_position_.x == 0 && !drag_edge_touching_) && + ((launcher_position_ == LauncherPosition::LEFT && + mouse_position_.y <= (parent_->GetGeometry().height - icon_size_.CP(cv_) - 2 * SPACE_BETWEEN_ICONS.CP(cv_))) || + (launcher_position_ == LauncherPosition::BOTTOM && + mouse_position_.x <= (parent_->GetGeometry().width - icon_size_.CP(cv_) - 2 * SPACE_BETWEEN_ICONS.CP(cv_))))) + { + if (dnd_hovered_icon_) + { + dnd_hovered_icon_->SendDndLeave(); + dnd_hovered_icon_->SetQuirk(AbstractLauncherIcon::Quirk::GLOW, false, monitor()); + } + + animation::StartOrReverse(dnd_hide_animation_, animation::Direction::FORWARD); + drag_edge_touching_ = true; + } + else if (drag_edge_touching_ && + ((launcher_position_ == LauncherPosition::LEFT && mouse_position_.x != 0) || + (launcher_position_ == LauncherPosition::BOTTOM && mouse_position_.y != 0))) + { + animation::StartOrReverse(dnd_hide_animation_, animation::Direction::BACKWARD); + drag_edge_touching_ = false; + } + } + + EventLogic(); + auto const& hovered_icon = MouseIconIntersection(mouse_position_.x, mouse_position_.y); + + bool hovered_icon_is_appropriate = false; + if (hovered_icon) + { + if (hovered_icon->GetIconType() == AbstractLauncherIcon::IconType::TRASH) + steal_drag_ = false; + + if (hovered_icon->position() == AbstractLauncherIcon::Position::FLOATING) + hovered_icon_is_appropriate = true; + } + + if (steal_drag_) + { + drag_action_ = nux::DNDACTION_COPY; + if (!dnd_hovered_icon_ && hovered_icon_is_appropriate) + { + dnd_hovered_icon_ = new SpacerLauncherIcon(monitor()); + model_->AddIcon(dnd_hovered_icon_); + model_->ReorderBefore(dnd_hovered_icon_, hovered_icon, true); + } + else if (dnd_hovered_icon_) + { + if (hovered_icon) + { + if (hovered_icon_is_appropriate) + { + model_->ReorderSmart(dnd_hovered_icon_, hovered_icon, true); + } + else + { + dnd_hovered_icon_->SetQuirk(AbstractLauncherIcon::Quirk::VISIBLE, false, monitor()); + dnd_hovered_icon_->remove.emit(dnd_hovered_icon_); + dnd_hovered_icon_ = nullptr; + } + } + } + } + else + { + if (!drag_edge_touching_ && hovered_icon != dnd_hovered_icon_) + { + if (hovered_icon) + { + hovered_icon->SendDndEnter(); + drag_action_ = hovered_icon->QueryAcceptDrop(dnd_data_); + + if (drag_action_ != nux::DNDACTION_NONE) + hovered_icon->SetQuirk(AbstractLauncherIcon::Quirk::GLOW, true, monitor()); + } + else + { + drag_action_ = nux::DNDACTION_NONE; + } + + if (dnd_hovered_icon_) + { + dnd_hovered_icon_->SendDndLeave(); + dnd_hovered_icon_->SetQuirk(AbstractLauncherIcon::Quirk::GLOW, false, monitor()); + } + + dnd_hovered_icon_ = hovered_icon; + } + } + + bool accept; + if (drag_action_ != nux::DNDACTION_NONE) + accept = true; + else + accept = false; + + SendDndStatus(accept, drag_action_, nux::Geometry(x, y, 1, 1)); +#endif +} void Launcher::ProcessDndDrop(int x, int y) -{ } +{ +#ifdef USE_X11 + if (steal_drag_) + { + for (auto const& uri : dnd_data_.Uris()) + { + if (DndIsSpecialRequest(uri)) + add_request.emit(uri, dnd_hovered_icon_); + } + } + else if (dnd_hovered_icon_ && drag_action_ != nux::DNDACTION_NONE) + { + if (IsOverlayOpen()) + ubus_.SendMessage(UBUS_OVERLAY_CLOSE_REQUEST); + + dnd_hovered_icon_->AcceptDrop(dnd_data_); + } + + if (drag_action_ != nux::DNDACTION_NONE) + SendDndFinished(true, drag_action_); + else + SendDndFinished(false, drag_action_); + + // reset our shiz + DndReset(); +#endif +} /* * Returns the current selected icon if it is in keynavmode @@ -2806,16 +3033,81 @@ int Launcher::GetDragDelta() const } void Launcher::DndStarted(std::string const& data) -{ } +{ +#ifdef USE_X11 + SetDndQuirk(); + + dnd_data_.Fill(data.c_str()); + + auto const& uris = dnd_data_.Uris(); + if (std::find_if(uris.begin(), uris.end(), [this] (std::string const& uri) + {return DndIsSpecialRequest(uri);}) != uris.end()) + { + steal_drag_ = true; + + if (IsOverlayOpen()) + SaturateIcons(); + } + else + { + for (auto const& it : *model_) + { + if (it->ShouldHighlightOnDrag(dnd_data_)) + { + it->SetQuirk(AbstractLauncherIcon::Quirk::DESAT, false, monitor()); + it->SetQuirk(AbstractLauncherIcon::Quirk::UNFOLDED, true, monitor()); + } + else + { + it->SetQuirk(AbstractLauncherIcon::Quirk::DESAT, true, monitor()); + it->SetQuirk(AbstractLauncherIcon::Quirk::UNFOLDED, false, monitor()); + } + } + } +#endif +} void Launcher::DndFinished() -{ } +{ +#ifdef USE_X11 + UnsetDndQuirk(); + + data_checked_ = false; + + DndReset(); +#endif +} void Launcher::SetDndQuirk() -{ } +{ +#ifdef USE_X11 + hide_machine_.SetQuirk(LauncherHideMachine::EXTERNAL_DND_ACTIVE, true); +#endif +} void Launcher::UnsetDndQuirk() -{ } +{ +#ifdef USE_X11 + + if (IsOverlayOpen() && !hovered_) + { + DesaturateIcons(); + } + else + { + for (auto const& it : *model_) + { + it->SetQuirk(AbstractLauncherIcon::Quirk::DESAT, false, monitor()); + it->SetQuirk(AbstractLauncherIcon::Quirk::UNFOLDED, false, monitor()); + } + } + + + hide_machine_.SetQuirk(LauncherHideMachine::MT_DRAG_OUT, drag_out_delta_x_ >= DRAG_OUT_PIXELS - 90.0f); + hide_machine_.SetQuirk(LauncherHideMachine::EXTERNAL_DND_ACTIVE, false); + animation::SetValue(dnd_hide_animation_, animation::Direction::BACKWARD); +#endif +} } // namespace launcher } // namespace unity diff --git a/lockscreen/LockScreenPanel.cpp b/lockscreen/LockScreenPanel.cpp index b3087a5..e54e2f1 100644 --- a/lockscreen/LockScreenPanel.cpp +++ b/lockscreen/LockScreenPanel.cpp @@ -37,8 +37,8 @@ namespace lockscreen { namespace { -const RawPixel PADDING = 14_em; -nux::Color BG_COLOR(0.1, 0.1, 0.1, 0.9); +const RawPixel PADDING = 5_em; +const nux::Color BG_COLOR(0.1, 0.1, 0.1, 0.4); } using namespace indicator; diff --git a/panel/PanelIndicatorsView.cpp b/panel/PanelIndicatorsView.cpp index 8bf3c80..20f0638 100644 --- a/panel/PanelIndicatorsView.cpp +++ b/panel/PanelIndicatorsView.cpp @@ -46,7 +46,6 @@ PanelIndicatorsView::PanelIndicatorsView() { opacity.DisableNotifications(); layout_->SetContentDistribution(nux::MAJOR_POSITION_END); - layout_->SetLeftAndRightPadding(layout_->GetLeftPadding(), 6); SetLayout(layout_); LOG_DEBUG(logger) << "Indicators View Added: "; diff --git a/panel/PanelView.cpp b/panel/PanelView.cpp index cffa311..02dd6e7 100644 --- a/panel/PanelView.cpp +++ b/panel/PanelView.cpp @@ -537,7 +537,7 @@ PanelView::UpdateBackground() if (overlay_is_open_ || wm.IsScaleActive()) { - // bg_layer_.reset(new nux::ColorLayer(wm.average_color(), true, rop)); + bg_layer_.reset(new nux::ColorLayer(wm.average_color(), true, rop)); } else { diff --git a/plugins/unityshell/unityshell.xml.in b/plugins/unityshell/unityshell.xml.in index 61afdea..3fdd5f3 100644 --- a/plugins/unityshell/unityshell.xml.in +++ b/plugins/unityshell/unityshell.xml.in @@ -419,7 +419,7 @@