Focus handling, taskbar fixes

applications/desktop/src/background.cpp

@@ -22,16 +22,16 @@
 #include <cairo/cairo.h>
 #include <stdlib.h>
 
-background* background::create()
+background_t* background_t::create()
 {
-	auto instance = createCanvasComponent<background>();
+	auto instance = createCanvasComponent<background_t>();
 	instance->init();
 	return instance;
 }
 
-void background::init()
+void background_t::init()
 {
-	organizer = new item_organizer(100, 100, 5, 5);
+	organizer = new item_organizer_t(100, 100, 5, 5);
 
 	this->setBufferListener([this]()
 	{
@@ -67,7 +67,7 @@ void background::init()
 	this->organize();
 }
 
-void background::onMouseMove(const g_point& position)
+void background_t::onMouseMove(const g_point& position)
 {
 	for(auto item: items)
 	{
@@ -80,9 +80,9 @@ void background::onMouseMove(const g_point& position)
 	}
 }
 
-void background::onMouseLeftPress(const g_point& position, int clickCount)
+void background_t::onMouseLeftPress(const g_point& position, int clickCount)
 {
-	item* pressedItem = nullptr;
+	item_t* pressedItem = nullptr;
 	std::vector<g_rectangle> itemsBounds;
 	for(auto& item: items)
 	{
@@ -107,11 +107,16 @@ void background::onMouseLeftPress(const g_point& position, int clickCount)
 		{
 			for(auto& item: items)
 			{
+				auto wasSelected = item->selected;
 				item->selected = false;
-				item->paint();
+				if(wasSelected != item->selected)
+					item->paint();
 			}
+
+			auto wasSelected = pressedItem->selected;
 			pressedItem->selected = true;
-			pressedItem->paint();
+			if(wasSelected != pressedItem->selected)
+				pressedItem->paint();
 		}
 
 		// Store for each selected item the offset in relation to press point
@@ -129,15 +134,17 @@ void background::onMouseLeftPress(const g_point& position, int clickCount)
 	{
 		for(auto item: items)
 		{
+			auto wasSelected = item->selected;
 			item->selected = false;
-			item->paint();
+			if(wasSelected != item->selected)
+				item->paint();
 		}
 
 		selectionStart = position;
 	}
 }
 
-void background::onMouseDrag(const g_point& position)
+void background_t::onMouseDrag(const g_point& position)
 {
 	if(dragItems)
 	{
@@ -163,32 +170,43 @@ void background::onMouseDrag(const g_point& position)
 			g_rectangle rect = item->getBounds();
 			if(boundsNorm.intersects(rect))
 			{
+				auto wasSelected = item->selected;
 				item->selected = true;
-				item->paint();
+				if(wasSelected != item->selected)
+					item->paint();
 			}
 			else
 			{
+				auto wasSelected = item->selected;
 				item->selected = false;
-				item->paint();
+				if(wasSelected != item->selected)
+					item->paint();
 			}
 		}
 	}
 }
 
-void background::onMouseRelease(const g_point& position)
+void background_t::onMouseRelease(const g_point& position)
 {
 	if(dragItems)
 		dragItems = false;
 	selection->setVisible(false);
 	organize();
 }
 
-void background::organize()
+void background_t::organize()
 {
 	this->organizer->organize(items, this->getBounds());
 }
 
-void background::paint()
+void background_t::addTaskbar(taskbar_t* taskbar)
+{
+	this->taskbar = taskbar;
+	this->addChild(taskbar);
+}
+
+
+void background_t::paint()
 {
 	auto cr = this->acquireGraphics();
 	if(!cr)
@@ -199,7 +217,7 @@ void background::paint()
 	auto bounds = this->getBounds();
 
 	srand(g_millis());
-	int r = rand() % 128 + 50;
+	static int r = rand() % 128 + 50;
 
 	cairo_pattern_t* gradient = cairo_pattern_create_linear(bounds.width * 0.4, 0, bounds.width * 0.8,
 	                                                        bounds.height);
@@ -223,7 +241,7 @@ void background::paint()
 	this->releaseGraphics();
 }
 
-void background::addItem(item* item)
+void background_t::addItem(item_t* item)
 {
 	items.push_back(item);
 	this->addChild(item);

applications/desktop/src/background.hpp

@@ -21,43 +21,47 @@
 #ifndef DESKTOP_BACKGROUND
 #define DESKTOP_BACKGROUND
 
+#include <taskbar.hpp>
+
 #include "item.hpp"
 #include "item_organizer.hpp"
 
 #include <libwindow/canvas.hpp>
 #include <libwindow/selection.hpp>
 #include <vector>
 
-class background : virtual public g_canvas
+class background_t : virtual public g_canvas
 {
 protected:
     void init();
 
-    std::vector<item*> items;
+    taskbar_t* taskbar;
+    std::vector<item_t*> items;
     void onMouseMove(const g_point& position);
     bool dragItems;
     g_point selectionStart;
     g_selection* selection = nullptr;
-    item_organizer* organizer = nullptr;
+    item_organizer_t* organizer = nullptr;
 
     void onMouseLeftPress(const g_point& position, int clickCount);
     void onMouseDrag(const g_point& position);
     void onMouseRelease(const g_point& position);
 
 public:
-    explicit background(g_ui_component_id id):
+    explicit background_t(g_ui_component_id id):
         g_component(id),
         g_canvas(id), dragItems(false)
     {
     }
 
-    ~background() override = default;
-    static background* create();
+    ~background_t() override = default;
+    static background_t* create();
 
+    void addTaskbar(taskbar_t* taskbar);
     virtual void paint();
 
     void organize();
-    void addItem(item* item);
+    void addItem(item_t* item);
 };
 
 #endif

applications/desktop/src/desktop.cpp

@@ -27,8 +27,8 @@
 
 #define USER_DESKTOP_DIR "/user/desktop/"
 
-background* background = nullptr;
-taskbar* taskbar = nullptr;
+background_t* background = nullptr;
+taskbar_t* taskbar = nullptr;
 
 int main()
 {
@@ -38,14 +38,14 @@ int main()
 		return -1;
 	}
 
-	background = background::create();
+	background = background_t::create();
 	g_ui::registerDesktopCanvas(background);
 
 	g_dimension screenDimension;
 	g_ui::getScreenDimension(screenDimension);
-	taskbar = taskbar::create();
+	taskbar = taskbar_t::create();
 	taskbar->setBounds(g_rectangle(0, screenDimension.height - 40, screenDimension.width, 40));
-	background->addChild(taskbar);
+	background->addTaskbar(taskbar);
 	background->setDesktopListener([](g_ui_windows_event* event)
 	{
 		taskbar->handleDesktopEvent(event);
@@ -73,7 +73,7 @@ void desktopLoadItems()
 		g_properties_parser parser(cfg);
 		auto properties = parser.getProperties();
 
-		auto item = item::create(properties["name"], properties["icon"], properties["application"]);
+		auto item = item_t::create(properties["name"], properties["icon"], properties["application"]);
 		background->addItem(item);
 		item->setBounds(g_rectangle(0, next++ * 100, 100, 100));
 	}

applications/desktop/src/item.cpp

@@ -25,7 +25,7 @@
 #include <libwindow/color_argb.hpp>
 #include <helper.hpp>
 
-item::item(uint32_t id):
+item_t::item_t(uint32_t id):
 	g_component(id),
 	g_canvas(id)
 {
@@ -35,14 +35,14 @@ item::item(uint32_t id):
 	});
 }
 
-item* item::create(std::string name, std::string icon, std::string application)
+item_t* item_t::create(std::string name, std::string icon, std::string application)
 {
-	auto instance = createCanvasComponent<item>();
+	auto instance = createCanvasComponent<item_t>();
 	instance->init(name, icon, application);
 	return instance;
 }
 
-void item::init(std::string name, std::string icon, std::string application)
+void item_t::init(std::string name, std::string icon, std::string application)
 {
 	this->application = application;
 	iconSurface = cairo_image_surface_create_from_png(icon.c_str());
@@ -60,7 +60,7 @@ void item::init(std::string name, std::string icon, std::string application)
 	this->addChild(label);
 }
 
-void item::paint()
+void item_t::paint()
 {
 	auto cr = this->acquireGraphics();
 	if(!cr)
@@ -99,7 +99,7 @@ void item::paint()
 	this->blit(g_rectangle(0, 0, bounds.width, bounds.height));
 }
 
-void item::onDoubleClick()
+void item_t::onDoubleClick()
 {
 	klog(("Launching: " + this->application).c_str());
 	g_spawn(this->application.c_str(), "", "", G_SECURITY_LEVEL_APPLICATION);

applications/desktop/src/item.hpp

@@ -25,7 +25,7 @@
 #include <libwindow/label.hpp>
 #include <cairo/cairo.h>
 
-class item : virtual public g_canvas
+class item_t : virtual public g_canvas
 {
 protected:
     cairo_surface_t* iconSurface = nullptr;
@@ -35,15 +35,15 @@ class item : virtual public g_canvas
     void init(std::string name, std::string icon, std::string application);
 
 public:
-    explicit item(uint32_t id);
+    explicit item_t(uint32_t id);
 
     bool hover = false;
     bool selected = false;
     g_point dragOffset;
 
-    static item* create(std::string name, std::string icon, std::string application);
+    static item_t* create(std::string name, std::string icon, std::string application);
 
-    ~item() override = default;
+    ~item_t() override = default;
     virtual void paint();
     void onDoubleClick();
 };

applications/desktop/src/item_organizer.cpp

@@ -21,7 +21,7 @@
 
 #include "item_organizer.hpp"
 
-void item_organizer::organize(const std::vector<item*>& items, const g_rectangle& backgroundBounds) const
+void item_organizer_t::organize(const std::vector<item_t*>& items, const g_rectangle& backgroundBounds) const
 {
 	std::vector<g_rectangle> allBounds;
 	for(auto& item: items)

applications/desktop/src/item_organizer.hpp

@@ -26,7 +26,7 @@
 
 #include <vector>
 
-class item_organizer
+class item_organizer_t
 {
     struct
     {
@@ -37,12 +37,12 @@ class item_organizer
     } grid;
 
 public:
-    item_organizer(int cellWidth, int cellHeight, int xPadding, int yPadding) :
+    item_organizer_t(int cellWidth, int cellHeight, int xPadding, int yPadding) :
         grid{cellWidth, cellHeight, xPadding, yPadding}
     {
     }
 
-    void organize(const std::vector<item*>& items, const g_rectangle& backgroundBounds) const;
+    void organize(const std::vector<item_t*>& items, const g_rectangle& backgroundBounds) const;
 };