Build fixed for QtCreator. Linux libs loading order changed.

2026-08-01 09:55:24 +00:00 · 2016-06-16 20:20:58 +03:00
parent 8e78cfed85
commit 7a9dfb50e1
9 changed files with 672 additions and 514 deletions
@@ -21,6 +21,7 @@ Copyright (c) 2014-2016 John Preston, https://desktop.telegram.org
 #include "stdafx.h"
 #include "platform/linux/main_window_linux.h"

+#include "platform/linux/linux_libs.h"
 #include "mainwindow.h"
 #include "application.h"
 #include "lang.h"
@@ -29,10 +30,165 @@ Copyright (c) 2014-2016 John Preston, https://desktop.telegram.org
 namespace Platform {
 namespace {

+bool noQtTrayIcon = false, tryAppIndicator = false;
+bool useGtkBase = false, useAppIndicator = false, useStatusIcon = false, trayIconChecked = false, useUnityCount = false;
+
+AppIndicator *_trayIndicator = 0;
+GtkStatusIcon *_trayIcon = 0;
+GtkWidget *_trayMenu = 0;
+GdkPixbuf *_trayPixbuf = 0;
+QByteArray _trayPixbufData;
+QList<QPair<GtkWidget*, QObject*> > _trayItems;
+
+int32 _trayIconSize = 22;
+bool _trayIconMuted = true;
+int32 _trayIconCount = 0;
+QImage _trayIconImageBack, _trayIconImage;
+
+void _trayIconPopup(GtkStatusIcon *status_icon, guint button, guint32 activate_time, gpointer popup_menu) {
+    Libs::gtk_menu_popup(Libs::gtk_menu_cast(popup_menu), NULL, NULL, Libs::gtk_status_icon_position_menu, status_icon, button, activate_time);
+}
+
+void _trayIconActivate(GtkStatusIcon *status_icon, gpointer popup_menu) {
+    if (App::wnd()->isActiveWindow() && App::wnd()->isVisible()) {
+        Libs::gtk_menu_popup(Libs::gtk_menu_cast(popup_menu), NULL, NULL, Libs::gtk_status_icon_position_menu, status_icon, 0, Libs::gtk_get_current_event_time());
+    } else {
+        App::wnd()->showFromTray();
+    }
+}
+
+gboolean _trayIconResized(GtkStatusIcon *status_icon, gint size, gpointer popup_menu) {
+   _trayIconSize = size;
+    if (App::wnd()) App::wnd()->psUpdateCounter();
+    return FALSE;
+}
+
+#if Q_BYTE_ORDER == Q_BIG_ENDIAN
+
+#define QT_RED 3
+#define QT_GREEN 2
+#define QT_BLUE 1
+#define QT_ALPHA 0
+
+#else
+
+#define QT_RED 0
+#define QT_GREEN 1
+#define QT_BLUE 2
+#define QT_ALPHA 3
+
+#endif
+
+#define GTK_RED 2
+#define GTK_GREEN 1
+#define GTK_BLUE 0
+#define GTK_ALPHA 3
+
+QImage _trayIconImageGen() {
+	int32 counter = App::histories().unreadBadge(), counterSlice = (counter >= 1000) ? (1000 + (counter % 100)) : counter;
+	bool muted = App::histories().unreadOnlyMuted();
+    if (_trayIconImage.isNull() || _trayIconImage.width() != _trayIconSize || muted != _trayIconMuted || counterSlice != _trayIconCount) {
+        if (_trayIconImageBack.isNull() || _trayIconImageBack.width() != _trayIconSize) {
+            _trayIconImageBack = App::wnd()->iconLarge().scaled(_trayIconSize, _trayIconSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+            _trayIconImageBack = _trayIconImageBack.convertToFormat(QImage::Format_ARGB32);
+            int w = _trayIconImageBack.width(), h = _trayIconImageBack.height(), perline = _trayIconImageBack.bytesPerLine();
+            uchar *bytes = _trayIconImageBack.bits();
+            for (int32 y = 0; y < h; ++y) {
+                for (int32 x = 0; x < w; ++x) {
+                    int32 srcoff = y * perline + x * 4;
+                    bytes[srcoff + QT_RED  ] = qMax(bytes[srcoff + QT_RED  ], uchar(224));
+                    bytes[srcoff + QT_GREEN] = qMax(bytes[srcoff + QT_GREEN], uchar(165));
+                    bytes[srcoff + QT_BLUE ] = qMax(bytes[srcoff + QT_BLUE ], uchar(44));
+                }
+            }
+        }
+        _trayIconImage = _trayIconImageBack;
+        if (counter > 0) {
+            QPainter p(&_trayIconImage);
+            int32 layerSize = -16;
+            if (_trayIconSize >= 48) {
+                layerSize = -32;
+            } else if (_trayIconSize >= 36) {
+                layerSize = -24;
+            } else if (_trayIconSize >= 32) {
+                layerSize = -20;
+            }
+            QImage layer = App::wnd()->iconWithCounter(layerSize, counter, (muted ? st::counterMuteBG : st::counterBG), false);
+            p.drawImage(_trayIconImage.width() - layer.width() - 1, _trayIconImage.height() - layer.height() - 1, layer);
+        }
+    }
+    return _trayIconImage;
+}
+
+QString _trayIconImageFile() {
+	int32 counter = App::histories().unreadBadge(), counterSlice = (counter >= 1000) ? (1000 + (counter % 100)) : counter;
+	bool muted = App::histories().unreadOnlyMuted();
+
+    QString name = cWorkingDir() + qsl("tdata/ticons/ico%1_%2_%3.png").arg(muted ? "mute" : "").arg(_trayIconSize).arg(counterSlice);
+    QFileInfo info(name);
+    if (info.exists()) return name;
+
+    QImage img = _trayIconImageGen();
+    if (img.save(name, "PNG")) return name;
+
+    QDir dir(info.absoluteDir());
+    if (!dir.exists()) {
+        dir.mkpath(dir.absolutePath());
+        if (img.save(name, "PNG")) return name;
+    }
+
+    return QString();
+}
+
+void loadPixbuf(QImage image) {
+    int w = image.width(), h = image.height(), perline = image.bytesPerLine(), s = image.byteCount();
+    _trayPixbufData.resize(w * h * 4);
+    uchar *result = (uchar*)_trayPixbufData.data(), *bytes = image.bits();
+    for (int32 y = 0; y < h; ++y) {
+        for (int32 x = 0; x < w; ++x) {
+            int32 offset = (y * w + x) * 4, srcoff = y * perline + x * 4;
+            result[offset + GTK_RED  ] = bytes[srcoff + QT_RED  ];
+            result[offset + GTK_GREEN] = bytes[srcoff + QT_GREEN];
+            result[offset + GTK_BLUE ] = bytes[srcoff + QT_BLUE ];
+            result[offset + GTK_ALPHA] = bytes[srcoff + QT_ALPHA];
+        }
+    }
+
+    if (_trayPixbuf) Libs::g_object_unref(_trayPixbuf);
+    _trayPixbuf = Libs::gdk_pixbuf_new_from_data(result, GDK_COLORSPACE_RGB, true, 8, w, h, w * 4, 0, 0);
+}
+
+void _trayMenuCallback(GtkMenu *menu, gpointer data) {
+    for (int32 i = 0, l = _trayItems.size(); i < l; ++i) {
+        if ((void*)_trayItems.at(i).first == (void*)menu) {
+            QMetaObject::invokeMethod(_trayItems.at(i).second, "triggered");
+        }
+    }
+}
+
+static gboolean _trayIconCheck(gpointer/* pIn*/) {
+    if (useStatusIcon && !trayIconChecked) {
+        if (Libs::gtk_status_icon_is_embedded(_trayIcon)) {
+            trayIconChecked = true;
+            cSetSupportTray(true);
+            if (App::wnd()) {
+                App::wnd()->psUpdateWorkmode();
+                App::wnd()->psUpdateCounter();
+                App::wnd()->updateTrayMenu();
+            }
+        }
+    }
+    return FALSE;
+}
+
+UnityLauncherEntry *_psUnityLauncherEntry = nullptr;
+
 } // namespace

-MainWindow::MainWindow() : QMainWindow(),
-posInited(false), trayIcon(0), trayIconMenu(0), icon256(qsl(":/gui/art/icon256.png")), iconbig256(icon256), wndIcon(QIcon::fromTheme("telegram", QIcon(QPixmap::fromImage(icon256, Qt::ColorOnly)))), _psCheckStatusIconLeft(100), _psLastIndicatorUpdate(0) {
+MainWindow::MainWindow()
+: icon256(qsl(":/gui/art/icon256.png"))
+, iconbig256(icon256)
+, wndIcon(QIcon::fromTheme("telegram", QIcon(QPixmap::fromImage(icon256, Qt::ColorOnly)))) {
 	connect(&_psCheckStatusIconTimer, SIGNAL(timeout()), this, SLOT(psStatusIconCheck()));
 	_psCheckStatusIconTimer.setSingleShot(false);

@@ -64,11 +220,11 @@ void MainWindow::psTrayMenuUpdated() {
 		if (_trayItems.isEmpty()) {
 			DEBUG_LOG(("Creating tray menu!"));
 			for (int32 i = 0, l = actions.size(); i != l; ++i) {
-				GtkWidget *item = ps_gtk_menu_item_new_with_label(actions.at(i)->text().toUtf8());
-				ps_gtk_menu_shell_append(PS_GTK_MENU_SHELL(_trayMenu), item);
-				ps_g_signal_connect(item, "activate", G_CALLBACK(_trayMenuCallback), this);
-				ps_gtk_widget_show(item);
-				ps_gtk_widget_set_sensitive(item, actions.at(i)->isEnabled());
+				GtkWidget *item = Libs::gtk_menu_item_new_with_label(actions.at(i)->text().toUtf8());
+				Libs::gtk_menu_shell_append(Libs::gtk_menu_shell_cast(_trayMenu), item);
+				Libs::g_signal_connect_helper(item, "activate", G_CALLBACK(_trayMenuCallback), this);
+				Libs::gtk_widget_show(item);
+				Libs::gtk_widget_set_sensitive(item, actions.at(i)->isEnabled());

 				_trayItems.push_back(qMakePair(item, actions.at(i)));
 			}
@@ -76,8 +232,8 @@ void MainWindow::psTrayMenuUpdated() {
 			DEBUG_LOG(("Updating tray menu!"));
 			for (int32 i = 0, l = actions.size(); i != l; ++i) {
 				if (i < _trayItems.size()) {
-					ps_gtk_menu_item_set_label(reinterpret_cast<GtkMenuItem*>(_trayItems.at(i).first), actions.at(i)->text().toUtf8());
-					ps_gtk_widget_set_sensitive(_trayItems.at(i).first, actions.at(i)->isEnabled());
+					Libs::gtk_menu_item_set_label(reinterpret_cast<GtkMenuItem*>(_trayItems.at(i).first), actions.at(i)->text().toUtf8());
+					Libs::gtk_widget_set_sensitive(_trayItems.at(i).first, actions.at(i)->isEnabled());
 				}
 			}
 		}
@@ -113,9 +269,9 @@ void MainWindow::psUpdateWorkmode() {
 	if (cWorkMode() == dbiwmWindowOnly) {
 		if (noQtTrayIcon) {
 			if (useAppIndicator) {
-				ps_app_indicator_set_status(_trayIndicator, APP_INDICATOR_STATUS_PASSIVE);
+				Libs::app_indicator_set_status(_trayIndicator, APP_INDICATOR_STATUS_PASSIVE);
 			} else if (useStatusIcon) {
-				ps_gtk_status_icon_set_visible(_trayIcon, false);
+				Libs::gtk_status_icon_set_visible(_trayIcon, false);
 			}
 		} else {
 			if (trayIcon) {
@@ -127,9 +283,9 @@ void MainWindow::psUpdateWorkmode() {
 	} else {
 		if (noQtTrayIcon) {
 			if (useAppIndicator) {
-				ps_app_indicator_set_status(_trayIndicator, APP_INDICATOR_STATUS_ACTIVE);
+				Libs::app_indicator_set_status(_trayIndicator, APP_INDICATOR_STATUS_ACTIVE);
 			} else if (useStatusIcon) {
-				ps_gtk_status_icon_set_visible(_trayIcon, true);
+				Libs::gtk_status_icon_set_visible(_trayIcon, true);
 			}
 		} else {
 			psSetupTrayIcon();
@@ -144,7 +300,7 @@ void MainWindow::psUpdateIndicator() {
 	if (f.exists()) {
 		QByteArray path = QFile::encodeName(f.absoluteFilePath()), name = QFile::encodeName(f.fileName());
 		name = name.mid(0, name.size() - 4);
-		ps_app_indicator_set_icon_full(_trayIndicator, path.constData(), name);
+		Libs::app_indicator_set_icon_full(_trayIndicator, path.constData(), name);
 	} else {
 		useAppIndicator = false;
 	}
@@ -158,10 +314,10 @@ void MainWindow::psUpdateCounter() {
 	setWindowTitle((counter > 0) ? qsl("Telegram (%1)").arg(counter) : qsl("Telegram"));
 	if (_psUnityLauncherEntry) {
 		if (counter > 0) {
-			ps_unity_launcher_entry_set_count(_psUnityLauncherEntry, (counter > 9999) ? 9999 : counter);
-			ps_unity_launcher_entry_set_count_visible(_psUnityLauncherEntry, TRUE);
+			Libs::unity_launcher_entry_set_count(_psUnityLauncherEntry, (counter > 9999) ? 9999 : counter);
+			Libs::unity_launcher_entry_set_count_visible(_psUnityLauncherEntry, TRUE);
 		} else {
-			ps_unity_launcher_entry_set_count_visible(_psUnityLauncherEntry, FALSE);
+			Libs::unity_launcher_entry_set_count_visible(_psUnityLauncherEntry, FALSE);
 		}
 	}

@@ -174,7 +330,7 @@ void MainWindow::psUpdateCounter() {
 			}
 		} else if (useStatusIcon && trayIconChecked) {
 			loadPixbuf(_trayIconImageGen());
-			ps_gtk_status_icon_set_from_pixbuf(_trayIcon, _trayPixbuf);
+			Libs::gtk_status_icon_set_from_pixbuf(_trayIcon, _trayPixbuf);
 		}
 	} else if (trayIcon) {
 		int32 counter = App::histories().unreadBadge();
@@ -188,6 +344,65 @@ void MainWindow::psUpdateCounter() {
 	}
 }

+void MainWindow::LibsLoaded() {
+	QString cdesktop = QString(getenv("XDG_CURRENT_DESKTOP")).toLower();
+	noQtTrayIcon = (cdesktop == qstr("pantheon")) || (cdesktop == qstr("gnome"));
+	tryAppIndicator = (cdesktop == qstr("xfce"));
+
+	if (noQtTrayIcon) cSetSupportTray(false);
+
+	useGtkBase = (Libs::gtk_init_check != nullptr)
+			&& (Libs::gtk_menu_new != nullptr)
+			&& (Libs::gtk_menu_get_type != nullptr)
+			&& (Libs::gtk_menu_item_new_with_label != nullptr)
+			&& (Libs::gtk_menu_item_set_label != nullptr)
+			&& (Libs::gtk_menu_shell_append != nullptr)
+			&& (Libs::gtk_menu_shell_get_type != nullptr)
+			&& (Libs::gtk_widget_show != nullptr)
+			&& (Libs::gtk_widget_get_toplevel != nullptr)
+			&& (Libs::gtk_widget_get_visible != nullptr)
+			&& (Libs::gtk_widget_set_sensitive != nullptr)
+			&& (Libs::g_type_check_instance_cast != nullptr)
+			&& (Libs::g_signal_connect_data != nullptr)
+			&& (Libs::g_object_ref_sink != nullptr)
+			&& (Libs::g_object_unref != nullptr);
+
+	useAppIndicator = useGtkBase
+			&& (Libs::app_indicator_new != nullptr)
+			&& (Libs::app_indicator_set_status != nullptr)
+			&& (Libs::app_indicator_set_menu != nullptr)
+			&& (Libs::app_indicator_set_icon_full != nullptr);
+
+	if (tryAppIndicator && useGtkBase && useAppIndicator) {
+		noQtTrayIcon = true;
+		cSetSupportTray(false);
+	}
+
+	useStatusIcon = (Libs::gdk_init_check != nullptr)
+			&& (Libs::gdk_pixbuf_new_from_data != nullptr)
+			&& (Libs::gtk_status_icon_new_from_pixbuf != nullptr)
+			&& (Libs::gtk_status_icon_set_from_pixbuf != nullptr)
+			&& (Libs::gtk_status_icon_set_title != nullptr)
+			&& (Libs::gtk_status_icon_set_tooltip_text != nullptr)
+			&& (Libs::gtk_status_icon_set_visible != nullptr)
+			&& (Libs::gtk_status_icon_is_embedded != nullptr)
+			&& (Libs::gtk_status_icon_get_geometry != nullptr)
+			&& (Libs::gtk_status_icon_position_menu != nullptr)
+			&& (Libs::gtk_menu_popup != nullptr)
+			&& (Libs::gtk_get_current_event_time != nullptr)
+			&& (Libs::g_idle_add != nullptr);
+	if (useStatusIcon) {
+		DEBUG_LOG(("Status icon api loaded!"));
+	}
+
+	useUnityCount = (Libs::unity_launcher_entry_get_for_desktop_id != nullptr)
+			&& (Libs::unity_launcher_entry_set_count != nullptr)
+			&& (Libs::unity_launcher_entry_set_count_visible != nullptr);
+	if (useUnityCount) {
+		DEBUG_LOG(("Unity count api loaded!"));
+	}
+}
+
 void MainWindow::psUpdateDelegate() {
 }

@@ -228,10 +443,6 @@ void MainWindow::psInitSize() {
 void MainWindow::psInitFrameless() {
 	psUpdatedPositionTimer.setSingleShot(true);
 	connect(&psUpdatedPositionTimer, SIGNAL(timeout()), this, SLOT(psSavePosition()));
-
-	if (frameless) {
-		//setWindowFlags(Qt::FramelessWindowHint);
-	}
 }

 void MainWindow::psSavePosition(Qt::WindowState state) {
@@ -289,13 +500,13 @@ void MainWindow::psCreateTrayIcon() {

 	if (useAppIndicator) {
 		DEBUG_LOG(("Trying to create AppIndicator"));
-		_trayMenu = ps_gtk_menu_new();
+		_trayMenu = Libs::gtk_menu_new();
 		if (_trayMenu) {
 			DEBUG_LOG(("Created gtk menu for appindicator!"));
 			QFileInfo f(_trayIconImageFile());
 			if (f.exists()) {
 				QByteArray path = QFile::encodeName(f.absoluteFilePath());
-				_trayIndicator = ps_app_indicator_new("Telegram Desktop", path.constData(), APP_INDICATOR_CATEGORY_APPLICATION_STATUS);
+				_trayIndicator = Libs::app_indicator_new("Telegram Desktop", path.constData(), APP_INDICATOR_CATEGORY_APPLICATION_STATUS);
 				if (_trayIndicator) {
 					DEBUG_LOG(("Created appindicator!"));
 				} else {
@@ -309,8 +520,8 @@ void MainWindow::psCreateTrayIcon() {
 			DEBUG_LOG(("Failed to gtk_menu_new()!"));
 		}
 		if (_trayMenu && _trayIndicator) {
-			ps_app_indicator_set_status(_trayIndicator, APP_INDICATOR_STATUS_ACTIVE);
-			ps_app_indicator_set_menu(_trayIndicator, PS_GTK_MENU(_trayMenu));
+			Libs::app_indicator_set_status(_trayIndicator, APP_INDICATOR_STATUS_ACTIVE);
+			Libs::app_indicator_set_menu(_trayIndicator, Libs::gtk_menu_cast(_trayMenu));
 			useStatusIcon = false;
 		} else {
 			DEBUG_LOG(("AppIndicator failed!"));
@@ -318,19 +529,19 @@ void MainWindow::psCreateTrayIcon() {
 		}
 	}
 	if (useStatusIcon) {
-		if (ps_gdk_init_check(0, 0)) {
-			if (!_trayMenu) _trayMenu = ps_gtk_menu_new();
+		if (Libs::gdk_init_check(0, 0)) {
+			if (!_trayMenu) _trayMenu = Libs::gtk_menu_new();
 			if (_trayMenu) {
 				loadPixbuf(_trayIconImageGen());
-				_trayIcon = ps_gtk_status_icon_new_from_pixbuf(_trayPixbuf);
+				_trayIcon = Libs::gtk_status_icon_new_from_pixbuf(_trayPixbuf);
 				if (_trayIcon) {
-					ps_g_signal_connect(_trayIcon, "popup-menu", GCallback(_trayIconPopup), _trayMenu);
-					ps_g_signal_connect(_trayIcon, "activate", GCallback(_trayIconActivate), _trayMenu);
-					ps_g_signal_connect(_trayIcon, "size-changed", GCallback(_trayIconResized), _trayMenu);
+					Libs::g_signal_connect_helper(_trayIcon, "popup-menu", GCallback(_trayIconPopup), _trayMenu);
+					Libs::g_signal_connect_helper(_trayIcon, "activate", GCallback(_trayIconActivate), _trayMenu);
+					Libs::g_signal_connect_helper(_trayIcon, "size-changed", GCallback(_trayIconResized), _trayMenu);

-					ps_gtk_status_icon_set_title(_trayIcon, "Telegram Desktop");
-					ps_gtk_status_icon_set_tooltip_text(_trayIcon, "Telegram Desktop");
-					ps_gtk_status_icon_set_visible(_trayIcon, true);
+					Libs::gtk_status_icon_set_title(_trayIcon, "Telegram Desktop");
+					Libs::gtk_status_icon_set_tooltip_text(_trayIcon, "Telegram Desktop");
+					Libs::gtk_status_icon_set_visible(_trayIcon, true);
 				} else {
 					useStatusIcon = false;
 				}
@@ -343,14 +554,14 @@ void MainWindow::psCreateTrayIcon() {
 	}
 	if (!useStatusIcon && !useAppIndicator) {
 		if (_trayMenu) {
-			ps_g_object_ref_sink(_trayMenu);
-			ps_g_object_unref(_trayMenu);
+			Libs::g_object_ref_sink(_trayMenu);
+			Libs::g_object_unref(_trayMenu);
 			_trayMenu = 0;
 		}
 	}
 	cSetSupportTray(useAppIndicator);
 	if (useStatusIcon) {
-		ps_g_idle_add((GSourceFunc)_trayIconCheck, 0);
+		Libs::g_idle_add((GSourceFunc)_trayIconCheck, 0);
 		_psCheckStatusIconTimer.start(100);
 	} else {
 		psUpdateWorkmode();
@@ -361,11 +572,11 @@ void MainWindow::psFirstShow() {
 	psCreateTrayIcon();

 	if (useUnityCount) {
-		_psUnityLauncherEntry = ps_unity_launcher_entry_get_for_desktop_id("telegramdesktop.desktop");
+		_psUnityLauncherEntry = Libs::unity_launcher_entry_get_for_desktop_id("telegramdesktop.desktop");
 		if (_psUnityLauncherEntry) {
 			LOG(("Found Unity Launcher entry telegramdesktop.desktop!"));
 		} else {
-			_psUnityLauncherEntry = ps_unity_launcher_entry_get_for_desktop_id("Telegram.desktop");
+			_psUnityLauncherEntry = Libs::unity_launcher_entry_get_for_desktop_id("Telegram.desktop");
 			if (_psUnityLauncherEntry) {
 				LOG(("Found Unity Launcher entry Telegram.desktop!"));
 			} else {
@@ -376,8 +587,6 @@ void MainWindow::psFirstShow() {
 		LOG(("Not using Unity Launcher count."));
 	}

-	finished = false;
-
 	psUpdateMargins();

 	bool showShadows = true;
@@ -419,21 +628,32 @@ void MainWindow::psUpdateMargins() {
 void MainWindow::psFlash() {
 }

+void MainWindow::psActivateNotify(NotifyWindow *w) {
+}
+
+void MainWindow::psClearNotifies(PeerId peerId) {
+}
+
+void MainWindow::psNotifyShown(NotifyWindow *w) {
+}
+
+void MainWindow::psPlatformNotify(HistoryItem *item, int32 fwdCount) {
+}
+
 MainWindow::~MainWindow() {
 	if (_trayIcon) {
-		ps_g_object_unref(_trayIcon);
-		_trayIcon = 0;
+		Libs::g_object_unref(_trayIcon);
+		_trayIcon = nullptr;
 	}
 	if (_trayPixbuf) {
-		ps_g_object_unref(_trayPixbuf);
-		_trayPixbuf = 0;
+		Libs::g_object_unref(_trayPixbuf);
+		_trayPixbuf = nullptr;
 	}
 	if (_trayMenu) {
-		ps_g_object_ref_sink(_trayMenu);
-		ps_g_object_unref(_trayMenu);
-		_trayMenu = 0;
+		Libs::g_object_ref_sink(_trayMenu);
+		Libs::g_object_unref(_trayMenu);
+		_trayMenu = nullptr;
 	}
-	finished = true;
 }

 } // namespace Platform