[feat] 0.2.0 added minimize to top bar for apps

src/WCompositor.cpp

···
 {
 	return new WOutput;
 }
-fn WCompositor::createSurfaceRequest(Handle<LSurface::Params> params) noexcept -> Handle<LSurface>
+fn WCompositor::createSurfaceRequest(Handle<LSurface::Params> params) noexcept
+    -> Handle<LSurface>
 {
 	return new WSurface(params);
 }

src/WCompositor.hpp

···
 
 	// virtual constructors
 	fn createOutputRequest() noexcept -> Handle<LOutput> override;
-	fn createSurfaceRequest(Handle<LSurface::Params> params) noexcept -> Handle<LSurface> override;
+	fn createSurfaceRequest(Handle<LSurface::Params> params) noexcept
+	    -> Handle<LSurface> override;
 
 	// scene and layers
 	LScene scene;

src/WOutput.cpp

···
  * ======================================================================== */
 #include "WOutput.hpp"
 #include "WCompositor.hpp"
+#include "WSurface.hpp"
 #include "WTopBar.hpp"
 #include "global.hpp"
 #include "prelude.hpp"
···
 
 void WOutput::uninitializeGL() noexcept
 {
+	/*
+	 * set minimized output to nullptr to prevent the compositor from
+	 * crashing when a surface is unminimized and
+	 * WSurface::minimizeChanged() is triggered
+	 */
+	for (let surface : G::surfaces())
+		if (surface->minimizedOutput == this)
+			surface->minimizedOutput = nullptr;
+
 	G::scene()->handleUninitializeGL(this);
 
 	if (wallpaperView->texture())

src/WSurface.cpp

···
  *
  * ======================================================================== */
 #include "WSurface.hpp"
-#include "prelude.hpp"
-#include "global.hpp"
 #include "WCompositor.hpp"
+#include "WOutput.hpp"
+#include "WTopBarItem.hpp"
+#include "global.hpp"
+#include "prelude.hpp"
 #include <LCursor.h>
+#include <LSceneView.h>
 
+WSurface::WSurface(Handle<Params> params) noexcept
+    : LSurface(params), view(this, &G::compositor()->surfacesLayer)
+{
+	view.enableParentOffset(false);
+}
 
-WSurface::WSurface(Handle<Params> params) noexcept : LSurface(params),
-	view(this, &G::compositor()->surfacesLayer)
+WSurface::~WSurface() noexcept
 {
-	view.enableParentOffset(false);
+	// destroy thumbnails
+	while (not topBarItems.empty())
+		delete topBarItems.back();
+
+	// destroy thumbnail texture
+	if (thumbnail != nullptr)
+		delete thumbnail;
 }
 
 void WSurface::roleChanged() noexcept
···
 	if (cursorRole()) {
 		view.setVisible(false);
 
-	} else if (dndIcon()) { // move drag & drop icons to the cursor layer so they always appear above other views
+	} else if (dndIcon()) { // move drag & drop icons to the cursor layer so
+				// they always appear above other views
 		// ensure it is positioned behind 'softwareCursor'
 		view.setParent(&G::compositor()->cursorLayer);
 		view.insertAfter(nullptr, false);
···
 	// view after prev's view
 	if (prev != nullptr) {
 		view.insertAfter(&prev->view, false);
-	} else { // if there is no prev surface, insert it at the beginning of the current parent's children list
+	} else { // if there is no prev surface, insert it at the beginning of
+		 // the current parent's children list
 		view.insertAfter(nullptr, false);
 	}
 }
+
+void WSurface::minimizedChanged() noexcept
+{
+	// remove pointer and keyboard focus
+	if (minimized()) {
+		if (hasPointerFocus())
+			seat()->pointer()->setFocus(nullptr);
+
+		if (hasKeyboardFocus())
+			seat()->keyboard()->setFocus(nullptr);
+	}
+
+	/*
+	 * When a surface is minimized, all its children are also minimized.
+	 * We only want to display toplevels in the top bar so we ignore the
+	 * rest.
+	 */
+
+	if (not toplevel()) {
+		view.setVisible(not minimized());
+		return;
+	}
+
+	if (minimized()) {
+		// find the output where the surface is currently most visible
+		minimizedOutput = primaryOutput();
+
+		if (minimizedOutput != nullptr) {
+			/*
+			 * Save the current surface position relative to the
+			 * output position as a percentage so we can restore it
+			 * later even if the outputs arrangement changes or the
+			 * given output is no longer available.
+			 */
+			let localPos = rolePos() - minimizedOutput->pos();
+			prevMinimizedPos =
+			    localPos / LSizeF(minimizedOutput->size());
+		} else {
+			/*
+			 * In case the surface is not visible on any output, we
+			 * select the first available output and position the
+			 * surface 1/4 of the output as a fallback.
+			 */
+			minimizedOutput = G::outputs().front();
+			prevMinimizedPos = LPointF(0.25f, 0.25f);
+		}
+
+		var tmpScene = LSceneView(sizeB(), bufferScale());
+		capture(&tmpScene);
+
+		// scale it to the thumbnail size
+		thumbnail = tmpScene.texture()->copyB(
+		    LSize((THUMBNAIL_HEIGHT * sizeB().w()) / sizeB().h(),
+			  THUMBNAIL_HEIGHT) *
+		    2);
+
+		// create a top bar item for each top bar
+		for (let output : G::outputs())
+			new WTopBarItem(output->topBar.get(), this);
+	} else {
+		// if minimized output is nullptr, it's because it was
+		// uninitialized while the surface was minimized
+		if (minimizedOutput == nullptr) {
+			minimizedOutput = G::outputs().front();
+			prevMinimizedPos = LPointF(0.25f, 0.25f);
+		}
+
+		// destroy thumbnails
+		while (not topBarItems.empty())
+			delete topBarItems.front();
+
+		// restory back the previous unminimized position
+		setPos(minimizedOutput->pos() +
+		       (prevMinimizedPos * minimizedOutput->size()));
+		minimizedOutput = nullptr;
+		view.setVisible(true);
+
+		// stack the surface above the rest
+		raise();
+	}
+}
+
+fn WSurface::primaryOutput() const noexcept -> Handle<WOutput>
+{
+	var bestOutput = Handle<WOutput>(nullptr);
+	var bestArea = 0;
+	var surfaceRect = LRect();
+
+	// ignore the decoration of toplevel and pop-up roles
+	if (toplevel())
+		surfaceRect =
+		    LRect(rolePos() + toplevel()->windowGeometry().pos(),
+			  toplevel()->windowGeometry().size());
+	else if (popup())
+		surfaceRect = LRect(rolePos() + popup()->windowGeometry().pos(),
+				    popup()->windowGeometry().size());
+	else
+		surfaceRect = LRect(rolePos(), size());
+
+	/*
+	 * Calculate the area of the surface intersected with each output and
+	 * return the one with the largest area
+	 */
+	for (let output : G::outputs()) {
+		// we use LRegion to intersect both rects
+		var tmpRegion = LRegion();
+		tmpRegion.addRect(surfaceRect);
+		tmpRegion.clip(output->rect());
+
+		let extents = tmpRegion.extents();
+		let area =
+		    (extents.x2 - extents.x1) * (extents.y2 - extents.y1);
+
+		if (area > bestArea) {
+			bestArea = area;
+			bestOutput = output;
+		}
+	}
+
+	return bestOutput;
+}
+
+void WSurface::capture(Handle<LSceneView> sceneView)
+{
+	/*
+	 * Instead of moving each view to the sceneView, we move the scene to
+	 * the views' position. This is why disabling parent offset is required.
+	 */
+	sceneView->setPos(rolePos());
+
+	/*
+	 * Add the view and any child subsurface view to the scene. Notice that
+	 * we exclude child surfaces with the popup or toplevel roles.
+	 */
+	G::moveSurfaceWithChildren(this, sceneView, subSurfacesOnly::on);
+	sceneView->render();
+
+	// restore views to the surface layer
+	while (not sceneView->children().empty())
+		sceneView->children().front()->setParent(
+		    &G::compositor()->surfacesLayer);
+}

src/WSurface.hpp

···
 
 using namespace Louvre;
 
+class WTopBarItem;
+class WOutput;
+
 class WSurface : public LSurface {
       public:
 	WSurface(Handle<LSurface::Params> params) noexcept;
+	~WSurface() noexcept;
 
 	void roleChanged() noexcept override;
 	void orderChanged() noexcept override;
+	void minimizedChanged() noexcept override;
+
+	// return the output where the surface is currently the most visible
+	fn primaryOutput() const noexcept -> Handle<WOutput>;
+
+	// take a snapshot of the surface, including its subsurfaces
+	void capture(Handle<LSceneView> sceneView);
 
 	LSurfaceView view;
+
+	// a single thumbnail texture shared by all top bar items
+	Handle<LTexture> thumbnail = nullptr;
+
+	// list of thumbnail views, one for each output's topbar
+	std::list<Handle<WTopBarItem>> topBarItems;
+
+	// the output where the surface was most visible before being minimized
+	Handle<WOutput> minimizedOutput = nullptr;
+
+	LPointF prevMinimizedPos;
 };

src/WTopBar.cpp

···
 #include "WTopBar.hpp"
 #include "WCompositor.hpp"
 #include "WOutput.hpp"
+#include "WTopBarItem.hpp"
 #include "global.hpp"
 
 WTopBar::WTopBar(Handle<WOutput> output) noexcept
     : output(output), view(0.f, 0.f, 0.f, 0.8f, &G::compositor()->overlayLayer)
 {
+	// copy thumbnails from an already initialized output
+	for (let o : G::outputs()) {
+		if (o == output)
+			continue;
+
+		for (let item : Ref<std::list<Handle<WTopBarItem>>>(
+			 o->topBar->view.children()))
+			new WTopBarItem(this, item->surface);
+
+		break;
+	}
 	update();
 }
 
···
 {
 	view.setSize(output->size().w(), TOPBAR_HEIGHT);
 	view.setPos(output->pos());
+
+	// update thumbnails
+	for (var x = TOPBAR_PADDING;
+	     let item : Ref<std::list<Handle<WTopBarItem>>>(view.children())) {
+		item->setPos(x, TOPBAR_PADDING);
+		x += item->size().w() + THUMBNAIL_MARGIN;
+	}
+
 	output->repaint();
 }

src/WTopBarItem.cpp

···
+/* ========================================================================
+ *
+ *     Filename:  WTopBarItem.hpp
+ *  Description:  W Compositor WTopBarItem class declaration
+ *  GitHub Repo:  https://github.com/diego-est/womp
+ *       Author:  Diego A. Estrada Rivera
+ *      License:  GPL-3.0
+ *
+ * ======================================================================== */
+#include "WTopBarItem.hpp"
+#include "WSurface.hpp"
+#include "WTopBar.hpp"
+#include "prelude.hpp"
+
+WTopBarItem::WTopBarItem(Handle<WTopBar> topBar,
+			 Handle<WSurface> surface) noexcept
+    : LTextureView(surface->thumbnail, &topBar->view), topBar(topBar),
+      surface(surface)
+{
+	surface->topBarItems.push_back(this);
+	surfaceLink = std::prev(surface->topBarItems.end());
+
+	setBufferScale(2);
+	enableParentOpacity(false);
+	topBar->update();
+}
+
+WTopBarItem::~WTopBarItem()
+{
+	surface->topBarItems.erase(surfaceLink);
+	setParent(nullptr);
+	topBar->update();
+}

src/WTopBarItem.hpp

···
+/* ========================================================================
+ *
+ *     Filename:  WTopBarItem.hpp
+ *  Description:  W Compositor WTopBarItem class declaration
+ *  GitHub Repo:  https://github.com/diego-est/womp
+ *       Author:  Diego A. Estrada Rivera
+ *      License:  GPL-3.0
+ *
+ * ======================================================================== */
+#pragma once
+
+#include "prelude.hpp"
+#include <LTextureView.h>
+
+using namespace Louvre;
+
+class WTopBar;
+class WSurface;
+
+class WTopBarItem : public LTextureView {
+      public:
+	WTopBarItem(Handle<WTopBar> topBar, Handle<WSurface> surface) noexcept;
+	~WTopBarItem();
+
+	std::list<Handle<WTopBarItem>>::iterator surfaceLink;
+
+	Handle<WTopBar> topBar = nullptr;
+	Handle<WSurface> surface = nullptr;
+};

src/global.cpp

···
  * ======================================================================== */
 #include "global.hpp"
 #include "WCompositor.hpp"
+#include "WSurface.hpp"
 #include "prelude.hpp"
 
 fn G::scene() noexcept -> Handle<LScene>
 {
 	return &compositor()->scene;
 }
+
+void G::moveSurfaceWithChildren(Handle<WSurface> surface, Handle<LView> parent,
+				subSurfacesOnly sso) noexcept
+{
+	surface->view.setParent(parent);
+	var next = surface;
+
+	if (sso == subSurfacesOnly::on) {
+		while ((next = Handle<WSurface>(next->nextSurface())))
+			if (next->isSubchildOf(surface) and
+			    next->subsurface() != nullptr)
+				next->view.setParent(parent);
+	} else {
+		while ((next = Handle<WSurface>(next->nextSurface())))
+			if (next->isSubchildOf(surface))
+				next->view.setParent(parent);
+	}
+}

src/global.hpp

···
 #include <LCompositor.h>
 
 #define TOPBAR_HEIGHT 32
+#define TOPBAR_PADDING 4
+#define THUMBNAIL_MARGIN 4
+#define THUMBNAIL_HEIGHT (TOPBAR_HEIGHT - 2 * TOPBAR_PADDING)
+
+// avoid bool in moveSurfaceWithChildren
+enum class subSurfacesOnly { off, on };
 
 using namespace Louvre;
 
 class WCompositor;
 class WOutput;
+class WSurface;
 
 class G {
       public:
···
 	}
 
 	fn static scene() noexcept -> Handle<LScene>;
+
+	// cast the LCompositor::surfaces() from LSurface to WSurface
+	fn static inline surfaces() noexcept -> Ref<std::list<Handle<WSurface>>>
+	{
+		return Ref<std::list<Handle<WSurface>>>(
+		    LCompositor::compositor()->surfaces());
+	}
+
+	// move surface views with children
+	static void moveSurfaceWithChildren(
+	    Handle<WSurface> surface, Handle<LView> parent,
+	    subSurfacesOnly opt = subSurfacesOnly::off) noexcept;
 };

src/main.cpp

···
  *  GitHub Repo:  https://github.com/diego-est/womp
  *       Author:  Diego A. Estrada Rivera
  *      License:  GPL-3.0
- *      Version:  0.1.0
+ *      Version:  0.2.0
  *
  * ======================================================================== */
 #include "WCompositor.hpp"