Issue 1109 - Support notifications

src/engine/NotificationWindow.cpp

+/*
+ * This file is part of Adblock Plus <https://adblockplus.org/>,
+ * Copyright (C) 2006-2015 Eyeo GmbH
+ *
+ * Adblock Plus is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * Adblock Plus is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #include <cassert>
 #include "NotificationWindow.h"
 #include "../shared/Utils.h"
 #include <algorithm>
 #include <fstream>
 #include "../shared/MsHTMLUtils.h"
 
 // it is taken from src/plugin/Resource.h
 #define IDI_ICON_ENABLED 301
 
 namespace {
   // DIP = device independant pixels, as DPI is 96
   const uint32_t kWindowWidth = 400 /*DIP*/;
   const uint32_t kWindowHeight = 120 /*DIP*/;
   const uint32_t kIconSize = 64 /*DIP*/;
+  const uint32_t kIconPadding = 10 /*DIP*/;
 
   // offsets from boundaries of working area of screen
   const uint32_t kWindowMarginRight = 50 /*DIP*/;
   const uint32_t kWindowMarginBottom = 20 /*DIP*/;
 
   std::vector<uint16_t> iconSizes = []()->std::vector<uint16_t>
   {
     std::vector<uint16_t> iconSizes;
     iconSizes.emplace_back(16);
     iconSizes.emplace_back(19);
@@ skipping 34 matching lines @@
     {
       return static_cast<HBITMAP>(::SelectObject(m_hDC, value));
     }
   private:
     DCHandle(const DCHandle&);
     DCHandle& operator=(const DCHandle&);
   private:
     HDC m_hDC;
   };
 
-  std::wstring ReplaceMulti(std::wstring workingString, const std::wstring& placeholder, const std::function<std::wstring()>& replacementGenerator)
-  {
-    std::wstring::size_type i = 0;
-    while ((i = workingString.find(placeholder, i)) != std::wstring::npos)

[Oleksandr, 2015/06/26 23:05:18]

How about putting everything in lowercase before this case? To handle stuff like
<A>, <!--body--> placeholders etc.

[sergei, 2015/06/29 11:10:50]

Done.

-    {
-      const std::wstring dst = replacementGenerator();
-      workingString.replace(i, placeholder.length(), dst);
-      // tiny optimisation to skip already processed part of the string
-      i += dst.length();
-    }
-    return workingString;
-  }
-  std::wstring ReplaceMulti(std::wstring workingString, const std::wstring& templ, const std::wstring& replacement)
+  /// Case insensitive pattern replacing function.
+  /// ReplaceMulti("Some TeXt <PlaceHolder>Some link</A> and text", "<placeholder>", ->"<a>")->
+  ///              "Some TeXt <a>Some link</A> and text".
+  std::wstring ReplaceMulti(const std::wstring& src, std::wstring placeholder, const std::function<std::wstring()>& replacementGenerator)
+  {
+    std::transform(placeholder.begin(), placeholder.end(), placeholder.begin(), ::towlower);
+    std::wstring srcLowerCase = src;
+    std::transform(srcLowerCase.begin(), srcLowerCase.end(), srcLowerCase.begin(), ::towlower);
+    std::wstring retValue;
+    std::wstring::size_type placeHolderOffset = 0;
+    std::wstring::size_type nextStringChunkOffset = 0;
+    while ((placeHolderOffset = srcLowerCase.find(placeholder, nextStringChunkOffset)) != std::wstring::npos)
+    {
+      retValue.append(src.substr(nextStringChunkOffset, placeHolderOffset - nextStringChunkOffset));
+      retValue.append(replacementGenerator());
+      nextStringChunkOffset = placeHolderOffset + placeholder.length();
+    }
+    retValue.append(src.substr(nextStringChunkOffset));
+    return retValue;
+  }
+  std::wstring ReplaceMulti(const std::wstring& workingString, const std::wstring& templ, const std::wstring& replacement)
   {
     return ReplaceMulti(workingString, templ, [&replacement]()->std::wstring
     {
       return replacement;
     });
   }
 }
 
 NotificationWindow::NotificationWindow(const AdblockPlus::Notification& notification, const std::wstring& htmlFileDir)
-  : m_dpi(96)
-{
-  m_htmlPage = [](const std::wstring& filePath)->std::wstring

[Oleksandr, 2015/06/26 23:05:18]

Do we really need a lambda function here? Seems to me something like this would
be better:

const std::wstring& filePath = htmlFileDir + L"NotificationWindow.html";
....
m_htmlPage.assign((std::istreambuf_iterator<wchar_t>(ifs)),
std::istreambuf_iterator<wchar_t>());

[sergei, 2015/06/29 11:10:50]

Sorry, forgot to clean it. During the developing I returned a simple template
instead of throwing of exception.
Done.

-  {
-    std::wifstream ifs(filePath);
-    assert(ifs.good() && "Cannot open NotificationWindow.html file");
-    if (!ifs.good())
-    {
-      throw std::runtime_error("Cannot read NotificationWindow.html");
-    }
-    std::wstring fileContent;
-    fileContent.assign((std::istreambuf_iterator<wchar_t>(ifs)), std::istreambuf_iterator<wchar_t>());
-    return fileContent;
-  }(htmlFileDir + L"NotificationWindow.html");
+{
+  const std::wstring filePath = htmlFileDir + L"NotificationWindow.html";
+  std::wifstream ifs(filePath);
+  assert(ifs.good() && "Cannot open NotificationWindow.html file");
+  if (!ifs.good())
+  {
+    throw std::runtime_error("Cannot read NotificationWindow.html");
+  }
+  m_htmlPage.assign((std::istreambuf_iterator<wchar_t>(ifs)), std::istreambuf_iterator<wchar_t>());
 
   m_links = ToUtf16Strings(notification.GetLinks());
   auto body = ToUtf16String(notification.GetMessageString());
   uint32_t linkIDCounter = 0;
   body = ReplaceMulti(body, L"<a>", [this, &linkIDCounter]()->std::wstring
   {
     return L"<a href=\"#\" data-linkID=\"" + std::to_wstring(linkIDCounter++) + L"\">";
   });
   assert(linkIDCounter == m_links.size() && "The amount of links in the text is different from the amount of provided links");
   m_htmlPage = ReplaceMulti(m_htmlPage, L"<!--Title-->", ToUtf16String(notification.GetTitle()));
   m_htmlPage = ReplaceMulti(m_htmlPage, L"<!--Body-->", body);
 }
 
 NotificationWindow::~NotificationWindow()
 {
 }
 
 LRESULT NotificationWindow::OnCreate(const CREATESTRUCT* /*createStruct*/) {
+  {
+    DCHandle hdc(GetDC());
+    m_dpi = hdc.GetDeviceCaps(LOGPIXELSX);
+  }
   m_bgColor.CreateSolidBrush(RGB(255, 255, 255));
-  auto windowCoords = GetWindowCoordinates();
-  MoveWindow(windowCoords.x, windowCoords.y, DPIAware(kWindowWidth), DPIAware(kWindowHeight));
-
-  m_icon.Create(m_hWnd,
-    DPIAware(CRect(CPoint(0, 0), CSize(kIconSize, kIconSize))),
-    nullptr, WS_CHILD | WS_VISIBLE | SS_BITMAP | SS_CENTERIMAGE);
+
+  CRect iconRect(CPoint(0, 0), CSize(kIconSize + 2 * kIconPadding, kIconSize + 2 * kIconPadding));
+  m_icon.Create(m_hWnd, DPIAware(iconRect), nullptr, WS_CHILD | WS_VISIBLE | SS_BITMAP | SS_CENTERIMAGE);
   LoadABPIcon();
 
-  m_axIE.Create(m_hWnd, DPIAware(CRect(CPoint(kIconSize, 0), CSize(kWindowWidth - kIconSize, kWindowHeight))),

[Oleksandr, 2015/06/26 23:05:18]

I think it would make sense to make the title to go outside of the browser.
Right now the title and the close button scroll with the message, if it's too
long. We know the title is just text, and also close button has only one default
purpose anyway.

[sergei, 2015/06/29 11:10:50]

I don't mind but before doing it I would like to see mockups, see
https://codereview.adblockplus.org/6505394822184960/diff/29321093/src/engine/....
BTW, I think it's possible to make the title not scrollable via proper HTML and
CSS.

+  m_axIE.Create(m_hWnd, DPIAware(CRect(CPoint(iconRect.right, 0), CSize(kWindowWidth - iconRect.right, kWindowHeight))),
     L"", WS_CHILD | WS_VISIBLE, 0, kHTMLDocumentCtrlID);
   m_axIE.CreateControl((L"mshtml:" + m_htmlPage).c_str());
   ATL::CComPtr<IAxWinAmbientDispatch> axWinAmbient;
   if (SUCCEEDED(m_axIE.QueryHost(&axWinAmbient))) {
     // disable web browser context menu
     axWinAmbient->put_AllowContextMenu(VARIANT_FALSE);
     // make web browser DPI aware, so the browser itself sets zoom level and
     // cares about rendering (not zooming) in the proper size.
     DWORD docFlags;
     axWinAmbient->get_DocHostFlags(&docFlags);
@@ skipping 13 matching lines @@
 {
   if (reinterpret_cast<HWND>(lParam) != m_icon)
   {
     handled = FALSE;
   }
   return reinterpret_cast<LRESULT>(static_cast<HBRUSH>(m_bgColor));
 }
 
 LRESULT NotificationWindow::OnClick(UINT /*msg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*handled*/)
 {
-  DestroyWindow();
+  if(m_onClickCallback)
+    m_onClickCallback();
   return 0;
 }
 
 void NotificationWindow::OnSize(uint32_t wParam, CSize size)
 {
+  if (m_icon)
+  {
+    CRect rect(CPoint(0, 0), DPIAware(CSize(kIconSize + 2 * kIconPadding, kIconSize + 2 * kIconPadding)));
+    m_icon.SetWindowPos(0, &rect, SWP_NOMOVE);
+  }
   if (m_axIE)
   {
-    size.cx -= kIconSize;
+    size.cx -= DPIAware(kIconSize + 2 * kIconPadding);
     CRect rect(CPoint(0, 0), size);
     m_axIE.SetWindowPos(0, &rect, SWP_NOMOVE);
   }
   SetMsgHandled(false);
 }
 
 void NotificationWindow::OnDestroy()
 {
   AtlAdviseSinkMap(this, false);
   // and proceed as usual
@@ skipping 13 matching lines @@
   }
   ATL::CComBSTR tag;
   htmlElement->get_tagName(&tag);
   const wchar_t expectedTag[] = { L"a" };
   if (_wcsnicmp(tag, expectedTag, min(sizeof(expectedTag), tag.Length())) != 0) {
     return;
   }
   auto classAttr = GetHtmlElementAttribute(*htmlElement, ATL::CComBSTR(L"class"));
   if (classAttr.attributeValue == L"closeButton")
   {
-    PostMessage(WM_CLOSE);
-    return;
-  }
-  if (!linkClicked)
+    if (m_onCloseCallback)
+      m_onCloseCallback();
+    return;
+  }
+  if (!m_onLinkClickedCallback)
   {
     return;
   }
   auto linkIDAttr = GetHtmlElementAttribute(*htmlElement, ATL::CComBSTR(L"data-linkID"));
   uint32_t linkID = 0;
   if (!linkIDAttr.attributeValue.empty() && (linkID = std::stoi(linkIDAttr.attributeValue)) < m_links.size())
   {
-    linkClicked(m_links[linkID]);
-    PostMessage(WM_CLOSE);
+    m_onLinkClickedCallback(m_links[linkID]);
+    if (m_onCloseCallback)
+      m_onCloseCallback();
   }
 }
 
 void __stdcall NotificationWindow::OnHTMLDocumentSelectStart(IHTMLEventObj* eventObject)
 {
   if (!eventObject)
     return;
   // disable selecting
   eventObject->put_cancelBubble(VARIANT_TRUE);
   eventObject->put_returnValue(ATL::CComVariant(false));
-}
-
-void NotificationWindow::OnFinalMessage(HWND) {
-  if (!!destroyed) {
-    destroyed();
-  }
 }
 
 void NotificationWindow::LoadABPIcon()
 {
   ScopedModule m_adblockPlusDLL;
   if (!(m_adblockPlusDLL.Open(L"AdblockPlus32.dll", LOAD_LIBRARY_AS_DATAFILE) ||
     m_adblockPlusDLL.Open(L"AdblockPlus64.dll", LOAD_LIBRARY_AS_DATAFILE) ||
     // for debug
     m_adblockPlusDLL.Open(L"AdblockPlus.dll", LOAD_LIBRARY_AS_DATAFILE)))
   {
@@ skipping 10 matching lines @@
   if (hIcon == nullptr)
   {
     return;
   }
 
   HDC screenDC = m_icon.GetDC();
   DCHandle tmpDC(::CreateCompatibleDC(screenDC));
   ScopedObjectHandle<HBITMAP> bitmap;
   bitmap = CreateCompatibleBitmap(screenDC, DPIAware(kIconSize), DPIAware(kIconSize));
   HBITMAP prevBitmap = tmpDC.SelectBitmap(bitmap);
-  RECT tmpRect = {0, 0, DPIAware(kIconSize), DPIAware(kIconSize)};
+  CRect tmpRect(CPoint(0, 0), DPIAware(CSize(kIconSize, kIconSize)));
   FillRect(tmpDC, &tmpRect, m_bgColor);
-  ::DrawIconEx(tmpDC, 0, 0, hIcon, DPIAware(kIconSize), DPIAware(kIconSize), 0, nullptr, DI_NORMAL);
+  ::DrawIconEx(tmpDC, 0, 0, hIcon, tmpRect.Width(), tmpRect.Height(), 0, nullptr, DI_NORMAL);
   m_iconImg.Attach(bitmap.Detach());
   tmpDC.SelectBitmap(prevBitmap);
   m_icon.SetBitmap(m_iconImg);
 }
 
-POINT NotificationWindow::GetWindowCoordinates() {
+POINT NotificationBorderWindow::GetWindowCoordinates() {
   HMONITOR primaryMonitor = MonitorFromWindow(m_hWnd, MONITOR_DEFAULTTOPRIMARY);
   {
     DCHandle hdc(GetDC());
     m_dpi = hdc.GetDeviceCaps(LOGPIXELSX);

[Oleksandr, 2015/08/18 11:47:40]

Is this still needed, seeing that we now get dpi in OnCreate?

[sergei, 2015/08/18 11:58:40]

It's a little bit odd. `GetWindowCoordinates` is a member of
`NotificationBorderWindow` and is being called from
`NotificationBorderWindow::OnCreate`. In the latest patch we are obtaining DPI
for `NotificationWindow`.

   }
   MONITORINFO monitorInfo = {};
   monitorInfo.cbSize = sizeof(monitorInfo);
   GetMonitorInfo(primaryMonitor, &monitorInfo);
   int windowX = monitorInfo.rcWork.right - DPIAware(kWindowWidth + kWindowMarginRight);
   int windowY = monitorInfo.rcWork.bottom - DPIAware(kWindowHeight + kWindowMarginBottom);
   POINT coords = {windowX, windowY};
   return coords;
+}
+
+NotificationBorderWindow::NotificationBorderWindow(const AdblockPlus::Notification& notification, const std::wstring& htmlFileDir)
+  : m_content(notification, htmlFileDir)
+{
+  m_content.SetOnClick([this]
+  {
+    PostMessage(WM_CLOSE);
+  });
+  m_content.SetOnClose([this]
+  {
+    PostMessage(WM_CLOSE);
+  });
+}
+
+LRESULT NotificationBorderWindow::OnCreate(const CREATESTRUCT* createStruct)
+{
+  auto windowCoords = GetWindowCoordinates();
+  MoveWindow(windowCoords.x, windowCoords.y, DPIAware(kWindowWidth), DPIAware(kWindowHeight));
+
+  RECT clientRect;
+  GetClientRect(&clientRect);
+  // make one pixel border
+  clientRect.top += 1;
+  clientRect.left += 1;
+  clientRect.bottom -= 1;
+  clientRect.right -= 1;
+  m_content.Create(m_hWnd, clientRect, nullptr, WS_CHILD | WS_VISIBLE);
+  auto err = GetLastError();
+  SetMsgHandled(false);
+  return 0;
+}
+
+void NotificationBorderWindow::OnSize(uint32_t wParam, CSize size)
+{
+  if (m_content.IsWindow())
+  {
+    RECT clientRect;
+    GetClientRect(&clientRect);
+    clientRect.top += 1;
+    clientRect.left += 1;
+    clientRect.bottom -= 1;
+    clientRect.right -= 1;
+    m_content.MoveWindow(&clientRect);
+  }
+  SetMsgHandled(false);
+}
+
+LRESULT NotificationBorderWindow::OnClick(UINT /*msg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*handled*/)
+{
+  DestroyWindow();
+  return 0;
+}
+
+void NotificationBorderWindow::OnFinalMessage(HWND) {
+  if (!!m_onDestroyedCallback) {
+    m_onDestroyedCallback();
+  }
 }