Fixed server icon in login dialog

Source/Core/AbstractServerIconCache.cpp

@@ -22,9 +22,9 @@ std::string AbstractServerIconCache::getIconNameForServer(const std::string& nam
     CUploadEngineData* ued = engineList_->byName(name);
 
     std::string serverName = IuStringUtils::Replace(name, "\\", "_");
-    serverName = IuStringUtils::Replace(name, "/", "_");
+    serverName = IuStringUtils::Replace(serverName, "/", "_");
 
-    std::string iconFileName = iconsDir_ + StrToLower(name) + ".ico";
+    std::string iconFileName = iconsDir_ + StrToLower(serverName) + ".ico";
 
     if (!IuCoreUtils::FileExists(iconFileName) && ued && !ued->PluginName.empty()) {
         iconFileName = iconsDir_ + StrToLower(ued->PluginName) + ".ico";

Source/Core/Images/Utils.cpp

@@ -1502,4 +1502,102 @@ CString ImageFormatGUIDToString(GUID guid) {
     return "unknown";
 }
 
+/*
+Gdiplus::Bitmap* GetIconPixelData(HICON hIcon)
+{
+    ICONINFO iconInfo;
+    GetIconInfo(hIcon, &iconInfo);
+
+    BITMAP iconBmp;
+    GetObject(iconInfo.hbmColor, sizeof(BITMAP), &iconBmp);
+
+    Gdiplus::Bitmap* bitmap = new Gdiplus::Bitmap(iconBmp.bmWidth, iconBmp.bmHeight, PixelFormat32bppARGB);
+
+    bool hasAlpha = false;
+    {
+        // We have to read the raw pixels of the bitmap to get proper transparency information
+        // (not sure why, all we're doing is copying one bitmap into another)
+
+        Gdiplus::Bitmap colorBitmap(iconInfo.hbmColor, NULL);
+        Gdiplus::BitmapData bmpData;
+        Gdiplus::Rect bmBounds(0, 0, colorBitmap.GetWidth(), colorBitmap.GetHeight());
+
+        colorBitmap.LockBits(&bmBounds, Gdiplus::ImageLockModeRead, colorBitmap.GetPixelFormat(), &bmpData);
+        for (int y = 0; y < colorBitmap.GetHeight(); y++) {
+            byte* pixelBytes = (byte*)bmpData.Scan0 + y * bmpData.Stride;
+
+            for (int x = 0; x < colorBitmap.GetHeight(); x++) {
+                ARGB* pixel = (ARGB*)(pixelBytes + x * 4);
+                bitmap->SetPixel(x, y, Gdiplus::Color(*pixel));
+                hasAlpha = hasAlpha || (pixelBytes[3] > 0 && pixelBytes[3] < 255);
+            }
+        }
+
+        colorBitmap.UnlockBits(&bmpData);
+    }
+
+    if (!hasAlpha) {
+        // If there's no alpha transparency information, we need to use the mask
+        // to turn back on visible pixels
+
+        Gdiplus::Bitmap maskBitmap(iconInfo.hbmMask, NULL);
+        Gdiplus::Color cMask, cBitmap;
+        for (int y = 0; y < maskBitmap.GetHeight(); y++) {
+            for (int x = 0; x < maskBitmap.GetWidth(); x++) {
+                maskBitmap.GetPixel(x, y, &cBitmap);
+                cBitmap.SetValue(cBitmap.GetValue() | 0xFF000000); // turn alpha to opaque (i.e. 0xFF)
+                bitmap->SetPixel(x, y, cBitmap);
+            }
+        }
+    }
+    return bitmap;
+}*/
+
+std::pair<std::unique_ptr<Gdiplus::Bitmap>,std::unique_ptr<BYTE[]>> GetIconPixelData(HICON hIcon) {
+    if (hIcon == NULL){
+        return {};
+    }
+    ICONINFO icInfo = { 0 };
+
+    if (!::GetIconInfo(hIcon, &icInfo)) {
+        return {};
+    }
+
+    BITMAP bitmap;
+    GetObject(icInfo.hbmColor, sizeof(BITMAP), &bitmap);
+    std::unique_ptr<Bitmap> pBitmap;
+    std::unique_ptr<Bitmap> pWrapBitmap;
+    std::unique_ptr<BYTE[]> data;
+    if (bitmap.bmBitsPixel != 32) {
+        pBitmap.reset(Bitmap::FromHICON(hIcon));
+    } else {
+        pWrapBitmap.reset(Bitmap::FromHBITMAP(icInfo.hbmColor, NULL));
+        BitmapData bitmapData;
+        Rect rcImage(0, 0, pWrapBitmap->GetWidth(), pWrapBitmap->GetHeight());
+
+        if (pWrapBitmap->LockBits(&rcImage, ImageLockModeRead, pWrapBitmap->GetPixelFormat(), &bitmapData) == Ok) {
+            BYTE* srcData {};
+            size_t resultOffset = 0;
+            size_t size = std::abs(bitmapData.Stride) * bitmapData.Height;
+            if (bitmapData.Stride < 0) {
+                srcData = (BYTE*)bitmapData.Scan0 + bitmapData.Stride * (bitmapData.Height-1);
+                resultOffset = -bitmapData.Stride * (bitmapData.Height-1);
+            } else {
+                srcData = (BYTE*)bitmapData.Scan0;
+            }
+
+            data = std::make_unique<BYTE[]>(size);
+            memcpy(data.get(), srcData, size);
+            pBitmap = std::make_unique<Bitmap>(bitmapData.Width, bitmapData.Height, bitmapData.Stride,
+                PixelFormat32bppARGB, data.get() + resultOffset);
+            pWrapBitmap->UnlockBits(&bitmapData);
+        }
+    }
+
+    DeleteObject(icInfo.hbmColor);
+    DeleteObject(icInfo.hbmMask);
+
+    return std::make_pair(std::move(pBitmap), std::move(data));
+}
+
 }

Source/Core/Images/Utils.h

@@ -9,8 +9,7 @@
 
 namespace ImageUtils {
 
-enum SaveImageFormat
-{
+enum SaveImageFormat {
     sifJPEG,
     sifPNG,
     sifGIF,
@@ -19,11 +18,11 @@ enum SaveImageFormat
     sifDetectByExtension,
 };
 
-struct ImageInfo
-{
+struct ImageInfo {
     int width, height;
 
-    ImageInfo() {
+    ImageInfo()
+    {
         width = 0;
         height = 0;
     }
@@ -43,32 +42,31 @@ CComPtr<IStream> CreateMemStream(const BYTE* pInit, UINT cbInit);
 bool CopyBitmapToClipboard(HWND hwnd, HDC dc, Gdiplus::Bitmap* bm, bool preserveAlpha = true);
 void Gdip_RemoveAlpha(Gdiplus::Bitmap& source, Gdiplus::Color color);
 
-
 /**
  * @throws IOException, runtime_error
  */
 bool MySaveImage(Gdiplus::Bitmap* img, const CString& szFilename, CString& szBuffer, SaveImageFormat Format,
-                 int Quality,
-                 LPCTSTR Folder = 0);
+    int Quality,
+    LPCTSTR Folder = 0);
 
 /**
  * @throws IOException, runtime_error
  */
 bool SaveImageToFile(Gdiplus::Bitmap* img, const CString& fileName, IStream* stream, SaveImageFormat Format,
-                     int Quality, CString* mimeType = nullptr);
+    int Quality, CString* mimeType = nullptr);
 SaveImageFormat GetFormatByFileName(CString filename);
 void DrawGradient(Gdiplus::Graphics& gr, Gdiplus::Rect rect, Gdiplus::Color& Color1, Gdiplus::Color& Color2);
 void DrawStrokedText(Gdiplus::Graphics& gr, LPCTSTR Text, Gdiplus::RectF Bounds, const Gdiplus::Font& font,
-                     const Gdiplus::Color& ColorText, const Gdiplus::Color& ColorStroke, int HorPos = 0,
-                     int VertPos = 0,
-                     int width = 1);
+    const Gdiplus::Color& ColorText, const Gdiplus::Color& ColorStroke, int HorPos = 0,
+    int VertPos = 0,
+    int width = 1);
 void ChangeAlphaChannel(Gdiplus::Bitmap& source, Gdiplus::Bitmap& dest, int sourceChannel, int destChannel);
 Gdiplus::Rect MeasureDisplayString(Gdiplus::Graphics& graphics, CString text, Gdiplus::RectF boundingRect,
-                                   Gdiplus::Font& font);
+    Gdiplus::Font& font);
 CRect CenterRect(CRect r1, const CRect& intoR2);
 std::unique_ptr<Gdiplus::Bitmap> GetThumbnail(Gdiplus::Image* bm, int width, int height, Gdiplus::Size* realSize = 0);
 std::unique_ptr<Gdiplus::Bitmap> GetThumbnail(const CString& filename, int width, int height,
-                                              Gdiplus::Size* realSize = 0, CString* imageFormat = nullptr);
+    Gdiplus::Size* realSize = 0, CString* imageFormat = nullptr);
 Gdiplus::Size AdaptProportionalSize(const Gdiplus::Size& szMax, const Gdiplus::Size& szReal);
 Gdiplus::Size ProportionalSize(const Gdiplus::Size& originalSize, const Gdiplus::Size& newSize);
 std::unique_ptr<Gdiplus::Bitmap> BitmapFromMemory(BYTE* data, size_t size);
@@ -97,6 +95,7 @@ bool SaveBitmapAsWebp(Gdiplus::Bitmap* img, CString fileName, IStream* stream, b
 
 std::unique_ptr<Gdiplus::Font> StringToGdiplusFont(LPCTSTR szBuffer);
 CString ImageFormatGUIDToString(GUID guid);
-}
 
+std::pair<std::unique_ptr<Gdiplus::Bitmap>, std::unique_ptr<BYTE[]>> GetIconPixelData(HICON hIcon);
+}
 #endif

Source/Core/QtServerIconCache.cpp

@@ -1,7 +1,5 @@
 #include "QtServerIconCache.h"
 
-#include <thread>
-
 #include <QFile>
 
 #include "Core/Upload/UploadEngine.h"
@@ -44,9 +42,6 @@ QtServerIconCache::CacheItem QtServerIconCache::tryIconLoad(const std::string &n
         return iconIt->second;
     }
 
-    CUploadEngineData* ued = engineList_->byName(name);
-
-    HICON icon = nullptr;
     QString iconFileName = QString::fromStdString(getIconNameForServer(name, true));
 
     if (!QFile::exists(iconFileName)) {

Source/Gui/Dialogs/FloatingWindow.cpp

@@ -914,7 +914,9 @@ void CFloatingWindow::ShowImageUploadedMessage(UploadTask* task, const CString&
     obj->fillFromUploadResult(task->uploadResult(), task);
 
     CString code;
+    CString message; 
     if (settings->TrayResult == WtlGuiSettings::trJustURL) {
+        message = TR("(the link has been copied to the clipboard)");
         code = url;
     } else if (settings->TrayResult == WtlGuiSettings::trLastCodeType) {
         GeneratorID generatorId = static_cast<GeneratorID>(settings->CodeLang);
@@ -934,13 +936,15 @@ void CFloatingWindow::ShowImageUploadedMessage(UploadTask* task, const CString&
         }
 
         code = U2W(generator->generate(objects, settings->UseTxtTemplate));
+        message = TR("(the code has been copied to the clipboard)");
     }
     WinUtils::CopyTextToClipboard(code);
-    CString trimmedUrl = WinUtils::TrimString(code, 70);
-    ShowBaloonTip(trimmedUrl + CString("\r\n")
-        + TR("(the link has been copied to the clipboard)")+ CString("\r\n") + TR("Click on this message to view details...") , 
+    CString trimmedCode = WinUtils::TrimString(code, 70);
+
+    ShowBaloonTip(trimmedCode + CString("\r\n")
+            + message + CString("\r\n") + TR("Click on this message to view details..."), 
         TR("Screenshot was uploaded"), 17000, [this] {showLastUploadedCode(); });
-    CString statusText = TR("Screenshot was uploaded") + CString(_T("\r\n")) + trimmedUrl;
+    CString statusText = TR("Screenshot was uploaded") + CString(_T("\r\n")) + trimmedCode;
     setStatusText(statusText, kStatusHideTimeout);
     lastUploadedItem_ = std::move(obj);
 }

Source/Gui/Dialogs/LoginDlg.cpp

@@ -71,9 +71,9 @@ LRESULT CLoginDlg::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& b
             int iconWidth = ::GetSystemMetrics(SM_CXICON);
             int iconHeight = ::GetSystemMetrics(SM_CYICON);
             serverImage_.SetWindowPos(0, 0, 0, iconWidth, iconHeight, SWP_NOMOVE | SWP_NOZORDER);
-            serverBitmap_.reset(Gdiplus::Bitmap::FromHICON(serverIcon_));
-            if (serverBitmap_ && serverBitmap_->GetLastStatus() == Gdiplus::Ok) {
-                serverImage_.loadImage(0, serverBitmap_.get(), 0, false, GetSysColor(COLOR_BTNFACE), false, true, false);
+            auto [serverBitmap, data] = ImageUtils::GetIconPixelData(serverIcon_);
+            if (serverBitmap && serverBitmap->GetLastStatus() == Gdiplus::Ok) {
+                serverImage_.loadImage(0, serverBitmap.get(), 0, false, GetSysColor(COLOR_BTNFACE), false, true, false);
             }
         }
     }

Source/Gui/Dialogs/LoginDlg.h

@@ -80,7 +80,6 @@ class CLoginDlg : public CCustomDialogIndirectImpl<CLoginDlg>, public CWinDataEx
     CButton loginButton_, logoutButton_;
     CMyImage serverImage_;
     CIcon serverIcon_;
-    std::unique_ptr<Gdiplus::Bitmap> serverBitmap_;
     bool createNew_;
     bool ignoreExistingAccount_;
     bool serverSupportsBeforehandAuthorization_, serverSupportsLogout_;

Source/qimageuploader/Gui/controls/ServerSelectorWidget.cpp

@@ -97,7 +97,7 @@ void ServerSelectorWidget::updateServerList() {
             continue;
         }
         if (addedItems) {
-            serverListComboBox->addItem(line);
+            serverListComboBox->insertSeparator(addedItems);
         }
         for (int i = 0; i < myEngineList->count(); i++) {
             CUploadEngineData* ue = myEngineList->byIndex(i);