2811 lines
88 KiB
C++
2811 lines
88 KiB
C++
|
|
/*
|
|
This file is part of Telegram Desktop,
|
|
an unofficial desktop messaging app, see https://telegram.org
|
|
|
|
Telegram Desktop is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
It 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.
|
|
|
|
Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
|
|
Copyright (c) 2014 John Preston, https://tdesktop.com
|
|
*/
|
|
#include "stdafx.h"
|
|
#include "pspecific.h"
|
|
|
|
#include "lang.h"
|
|
#include "application.h"
|
|
#include "mainwidget.h"
|
|
|
|
#include <Shobjidl.h>
|
|
#include <dbghelp.h>
|
|
#include <shellapi.h>
|
|
#include <Strsafe.h>
|
|
#include <shlobj.h>
|
|
#include <Windowsx.h>
|
|
|
|
#include <qpa/qplatformnativeinterface.h>
|
|
|
|
#include <dwmapi.h>
|
|
|
|
#define min(a, b) ((a) < (b) ? (a) : (b))
|
|
#define max(a, b) ((a) < (b) ? (b) : (a))
|
|
|
|
#ifndef DCX_USESTYLE
|
|
#define DCX_USESTYLE 0x00010000
|
|
#endif
|
|
|
|
#ifndef WM_NCPOINTERUPDATE
|
|
#define WM_NCPOINTERUPDATE 0x0241
|
|
#define WM_NCPOINTERDOWN 0x0242
|
|
#define WM_NCPOINTERUP 0x0243
|
|
#endif
|
|
|
|
#include <gdiplus.h>
|
|
#pragma comment (lib,"Gdiplus.lib")
|
|
#pragma comment (lib,"Msimg32.lib")
|
|
|
|
namespace {
|
|
bool frameless = true;
|
|
bool useDWM = false;
|
|
bool useTheme = false;
|
|
bool useOpenAs = false;
|
|
bool themeInited = false;
|
|
bool finished = true;
|
|
int menuShown = 0, menuHidden = 0;
|
|
int dleft = 0, dtop = 0;
|
|
QMargins simpleMargins, margins;
|
|
HICON bigIcon = 0, smallIcon = 0, overlayIcon = 0;
|
|
|
|
UINT tbCreatedMsgId = 0;
|
|
ITaskbarList3 *tbListInterface = 0;
|
|
|
|
HWND createTaskbarHider() {
|
|
HINSTANCE appinst = (HINSTANCE)GetModuleHandle(0);
|
|
HWND hWnd = 0;
|
|
|
|
QString cn = QString("TelegramTaskbarHider");
|
|
LPCWSTR _cn = (LPCWSTR)cn.utf16();
|
|
WNDCLASSEX wc;
|
|
|
|
wc.cbSize = sizeof(wc);
|
|
wc.style = 0;
|
|
wc.lpfnWndProc = DefWindowProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = 0;
|
|
wc.hInstance = appinst;
|
|
wc.hIcon = 0;
|
|
wc.hCursor = 0;
|
|
wc.hbrBackground = 0;
|
|
wc.lpszMenuName = NULL;
|
|
wc.lpszClassName = _cn;
|
|
wc.hIconSm = 0;
|
|
if (!RegisterClassEx(&wc)) {
|
|
DEBUG_LOG(("Application Error: could not register taskbar hider window class, error: %1").arg(GetLastError()));
|
|
return hWnd;
|
|
}
|
|
|
|
hWnd = CreateWindowEx(WS_EX_TOOLWINDOW, _cn, 0, WS_POPUP, 0, 0, 0, 0, 0, 0, appinst, 0);
|
|
if (!hWnd) {
|
|
DEBUG_LOG(("Application Error: could not create taskbar hider window class, error: %1").arg(GetLastError()));
|
|
return hWnd;
|
|
}
|
|
return hWnd;
|
|
}
|
|
|
|
enum {
|
|
_PsShadowMoved = 0x01,
|
|
_PsShadowResized = 0x02,
|
|
_PsShadowShown = 0x04,
|
|
_PsShadowHidden = 0x08,
|
|
_PsShadowActivate = 0x10,
|
|
};
|
|
|
|
enum {
|
|
_PsInitHor = 0x01,
|
|
_PsInitVer = 0x02,
|
|
};
|
|
|
|
int32 _psSize = 0;
|
|
class _PsShadowWindows {
|
|
public:
|
|
|
|
_PsShadowWindows() : screenDC(0), max_w(0), max_h(0), _x(0), _y(0), _w(0), _h(0), hidden(true), r(0), g(0), b(0), noKeyColor(RGB(255, 255, 255)) {
|
|
for (int i = 0; i < 4; ++i) {
|
|
dcs[i] = 0;
|
|
bitmaps[i] = 0;
|
|
hwnds[i] = 0;
|
|
}
|
|
}
|
|
|
|
void setColor(QColor c) {
|
|
r = c.red();
|
|
g = c.green();
|
|
b = c.blue();
|
|
|
|
if (!hwnds[0]) return;
|
|
Gdiplus::SolidBrush brush(Gdiplus::Color(_alphas[0], r, g, b));
|
|
for (int i = 0; i < 4; ++i) {
|
|
Gdiplus::Graphics graphics(dcs[i]);
|
|
graphics.SetCompositingMode(Gdiplus::CompositingModeSourceCopy);
|
|
if ((i % 2) && _h || !(i % 2) && _w) {
|
|
graphics.FillRectangle(&brush, 0, 0, (i % 2) ? _size : _w, (i % 2) ? _h : _size);
|
|
}
|
|
}
|
|
initCorners();
|
|
|
|
_x = _y = _w = _h = 0;
|
|
update(_PsShadowMoved | _PsShadowResized);
|
|
}
|
|
|
|
bool init(QColor c) {
|
|
style::rect topLeft = st::wndShadow;
|
|
_fullsize = topLeft.width();
|
|
_shift = st::wndShadowShift;
|
|
QImage cornersImage(_fullsize, _fullsize, QImage::Format_ARGB32_Premultiplied);
|
|
{
|
|
QPainter p(&cornersImage);
|
|
p.drawPixmap(QPoint(0, 0), App::sprite(), topLeft);
|
|
}
|
|
uchar *bits = cornersImage.bits();
|
|
if (bits) {
|
|
for (
|
|
quint32 *p = (quint32*)bits, *end = (quint32*)(bits + cornersImage.byteCount());
|
|
p < end;
|
|
++p
|
|
) {
|
|
*p = (*p ^ 0x00ffffff) << 24;
|
|
}
|
|
}
|
|
|
|
_metaSize = _fullsize + 2 * _shift;
|
|
_alphas.reserve(_metaSize);
|
|
_colors.reserve(_metaSize * _metaSize);
|
|
for (int32 j = 0; j < _metaSize; ++j) {
|
|
for (int32 i = 0; i < _metaSize; ++i) {
|
|
_colors.push_back((i < 2 * _shift || j < 2 * _shift) ? 1 : qMax(BYTE(1), BYTE(cornersImage.pixel(QPoint(i - 2 * _shift, j - 2 * _shift)) >> 24)));
|
|
}
|
|
}
|
|
uchar prev = 0;
|
|
for (int32 i = 0; i < _metaSize; ++i) {
|
|
uchar a = _colors[(_metaSize - 1) * _metaSize + i];
|
|
if (a < prev) break;
|
|
|
|
_alphas.push_back(a);
|
|
prev = a;
|
|
}
|
|
_psSize = _size = _alphas.size() - 2 * _shift;
|
|
|
|
setColor(c);
|
|
|
|
Gdiplus::GdiplusStartupInput gdiplusStartupInput;
|
|
ULONG_PTR gdiplusToken;
|
|
Gdiplus::Status gdiRes = Gdiplus::GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
|
|
|
|
if (gdiRes != Gdiplus::Ok) {
|
|
DEBUG_LOG(("Application Error: could not init GDI+, error: %1").arg((int)gdiRes));
|
|
return false;
|
|
}
|
|
blend.AlphaFormat = AC_SRC_ALPHA;
|
|
blend.SourceConstantAlpha = 255;
|
|
blend.BlendFlags = 0;
|
|
blend.BlendOp = AC_SRC_OVER;
|
|
|
|
screenDC = GetDC(0);
|
|
if (!screenDC) return false;
|
|
|
|
QRect avail(QDesktopWidget().availableGeometry());
|
|
max_w = avail.width();
|
|
if (max_w < st::wndMinWidth) max_w = st::wndMinWidth;
|
|
max_h = avail.height();
|
|
if (max_h < st::wndMinHeight) max_h = st::wndMinHeight;
|
|
|
|
HINSTANCE appinst = (HINSTANCE)GetModuleHandle(0);
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
QString cn = QString("TelegramShadow%1").arg(i);
|
|
LPCWSTR _cn = (LPCWSTR)cn.utf16();
|
|
WNDCLASSEX wc;
|
|
|
|
wc.cbSize = sizeof(wc);
|
|
wc.style = 0;
|
|
wc.lpfnWndProc = wndProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = 0;
|
|
wc.hInstance = appinst;
|
|
wc.hIcon = 0;
|
|
wc.hCursor = 0;
|
|
wc.hbrBackground = 0;
|
|
wc.lpszMenuName = NULL;
|
|
wc.lpszClassName = _cn;
|
|
wc.hIconSm = 0;
|
|
if (!RegisterClassEx(&wc)) {
|
|
DEBUG_LOG(("Application Error: could not register shadow window class %1, error: %2").arg(i).arg(GetLastError()));
|
|
destroy();
|
|
return false;
|
|
}
|
|
|
|
hwnds[i] = CreateWindowEx(WS_EX_LAYERED | WS_EX_TOOLWINDOW, _cn, 0, WS_POPUP, 0, 0, 0, 0, 0, 0, appinst, 0);
|
|
if (!hwnds[i]) {
|
|
DEBUG_LOG(("Application Error: could not create shadow window class %1, error: %2").arg(i).arg(GetLastError()));
|
|
destroy();
|
|
return false;
|
|
}
|
|
|
|
dcs[i] = CreateCompatibleDC(screenDC);
|
|
if (!dcs[i]) {
|
|
DEBUG_LOG(("Application Error: could not create dc for shadow window class %1, error: %2").arg(i).arg(GetLastError()));
|
|
destroy();
|
|
return false;
|
|
}
|
|
|
|
bitmaps[i] = CreateCompatibleBitmap(screenDC, (i % 2) ? _size : max_w, (i % 2) ? max_h : _size);
|
|
if (!bitmaps[i]) {
|
|
DEBUG_LOG(("Application Error: could not create bitmap for shadow window class %1, error: %2").arg(i).arg(GetLastError()));
|
|
destroy();
|
|
return false;
|
|
}
|
|
|
|
SelectObject(dcs[i], bitmaps[i]);
|
|
}
|
|
|
|
initCorners();
|
|
return true;
|
|
}
|
|
|
|
void initCorners(int directions = (_PsInitHor | _PsInitVer)) {
|
|
bool hor = (directions & _PsInitHor), ver = (directions & _PsInitVer);
|
|
Gdiplus::Graphics graphics0(dcs[0]), graphics1(dcs[1]), graphics2(dcs[2]), graphics3(dcs[3]);
|
|
graphics0.SetCompositingMode(Gdiplus::CompositingModeSourceCopy);
|
|
graphics1.SetCompositingMode(Gdiplus::CompositingModeSourceCopy);
|
|
graphics2.SetCompositingMode(Gdiplus::CompositingModeSourceCopy);
|
|
graphics3.SetCompositingMode(Gdiplus::CompositingModeSourceCopy);
|
|
|
|
Gdiplus::SolidBrush brush(Gdiplus::Color(_alphas[0], r, g, b));
|
|
if (hor) graphics0.FillRectangle(&brush, 0, 0, _fullsize - (_size - _shift), 2 * _shift);
|
|
|
|
if (ver) {
|
|
graphics1.FillRectangle(&brush, 0, 0, _size, 2 * _shift);
|
|
graphics3.FillRectangle(&brush, 0, 0, _size, 2 * _shift);
|
|
graphics1.FillRectangle(&brush, _size - _shift, 2 * _shift, _shift, _fullsize);
|
|
graphics3.FillRectangle(&brush, 0, 2 * _shift, _shift, _fullsize);
|
|
}
|
|
|
|
if (hor) {
|
|
for (int j = 2 * _shift; j < _size; ++j) {
|
|
for (int k = 0; k < _fullsize - (_size - _shift); ++k) {
|
|
brush.SetColor(Gdiplus::Color(_colors[j * _metaSize + k + (_size + _shift)], r, g, b));
|
|
graphics0.FillRectangle(&brush, k, j, 1, 1);
|
|
graphics2.FillRectangle(&brush, k, _size - (j - 2 * _shift) - 1, 1, 1);
|
|
}
|
|
}
|
|
for (int j = _size; j < _size + 2 * _shift; ++j) {
|
|
for (int k = 0; k < _fullsize - (_size - _shift); ++k) {
|
|
brush.SetColor(Gdiplus::Color(_colors[j * _metaSize + k + (_size + _shift)], r, g, b));
|
|
graphics2.FillRectangle(&brush, k, _size - (j - 2 * _shift) - 1, 1, 1);
|
|
}
|
|
}
|
|
}
|
|
if (ver) {
|
|
for (int j = 2 * _shift; j < _fullsize + 2 * _shift; ++j) {
|
|
for (int k = _shift; k < _size; ++k) {
|
|
brush.SetColor(Gdiplus::Color(_colors[j * _metaSize + (k + _shift)], r, g, b));
|
|
graphics1.FillRectangle(&brush, _size - k - 1, j, 1, 1);
|
|
graphics3.FillRectangle(&brush, k, j, 1, 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
void verCorners(int h, Gdiplus::Graphics *pgraphics1, Gdiplus::Graphics *pgraphics3) {
|
|
Gdiplus::SolidBrush brush(Gdiplus::Color(_alphas[0], r, g, b));
|
|
pgraphics1->FillRectangle(&brush, _size - _shift, h - _fullsize, _shift, _fullsize);
|
|
pgraphics3->FillRectangle(&brush, 0, h - _fullsize, _shift, _fullsize);
|
|
for (int j = 0; j < _fullsize; ++j) {
|
|
for (int k = _shift; k < _size; ++k) {
|
|
brush.SetColor(Gdiplus::Color(_colors[(j + 2 * _shift) * _metaSize + k + _shift], r, g, b));
|
|
pgraphics1->FillRectangle(&brush, _size - k - 1, h - j - 1, 1, 1);
|
|
pgraphics3->FillRectangle(&brush, k, h - j - 1, 1, 1);
|
|
}
|
|
}
|
|
}
|
|
void horCorners(int w, Gdiplus::Graphics *pgraphics0, Gdiplus::Graphics *pgraphics2) {
|
|
Gdiplus::SolidBrush brush(Gdiplus::Color(_alphas[0], r, g, b));
|
|
pgraphics0->FillRectangle(&brush, w - 2 * _size - (_fullsize - (_size - _shift)), 0, _fullsize - (_size - _shift), 2 * _shift);
|
|
for (int j = 2 * _shift; j < _size; ++j) {
|
|
for (int k = 0; k < _fullsize - (_size - _shift); ++k) {
|
|
brush.SetColor(Gdiplus::Color(_colors[j * _metaSize + k + (_size + _shift)], r, g, b));
|
|
pgraphics0->FillRectangle(&brush, w - 2 * _size - k - 1, j, 1, 1);
|
|
pgraphics2->FillRectangle(&brush, w - 2 * _size - k - 1, _size - (j - 2 * _shift) - 1, 1, 1);
|
|
}
|
|
}
|
|
for (int j = _size; j < _size + 2 * _shift; ++j) {
|
|
for (int k = 0; k < _fullsize - (_size - _shift); ++k) {
|
|
brush.SetColor(Gdiplus::Color(_colors[j * _metaSize + k + (_size + _shift)], r, g, b));
|
|
pgraphics2->FillRectangle(&brush, w - 2 * _size - k - 1, _size - (j - 2 * _shift) - 1, 1, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
void update(int changes, WINDOWPOS *pos = 0) {
|
|
HWND hwnd = Application::wnd() ? Application::wnd()->psHwnd() : 0;
|
|
if (!hwnd || !hwnds[0]) return;
|
|
|
|
if (changes == _PsShadowActivate) {
|
|
for (int i = 0; i < 4; ++i) {
|
|
SetWindowPos(hwnds[i], hwnd, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (changes & _PsShadowHidden) {
|
|
if (!hidden) {
|
|
for (int i = 0; i < 4; ++i) {
|
|
hidden = true;
|
|
ShowWindow(hwnds[i], SW_HIDE);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (!Application::wnd()->psPosInited()) return;
|
|
|
|
int x = _x, y = _y, w = _w, h = _h;
|
|
if (pos && (!(pos->flags & SWP_NOMOVE) || !(pos->flags & SWP_NOSIZE) || !(pos->flags & SWP_NOREPOSITION))) {
|
|
if (!(pos->flags & SWP_NOMOVE)) {
|
|
x = pos->x - _size;
|
|
y = pos->y - _size;
|
|
} else if (pos->flags & SWP_NOSIZE) {
|
|
for (int i = 0; i < 4; ++i) {
|
|
SetWindowPos(hwnds[i], hwnd, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
|
|
}
|
|
return;
|
|
}
|
|
if (!(pos->flags & SWP_NOSIZE)) {
|
|
w = pos->cx + 2 * _size;
|
|
h = pos->cy + 2 * _size;
|
|
}
|
|
} else {
|
|
RECT r;
|
|
GetWindowRect(hwnd, &r);
|
|
x = r.left - _size;
|
|
y = r.top - _size;
|
|
w = r.right + _size - x;
|
|
h = r.bottom + _size - y;
|
|
}
|
|
if (h < 2 * _fullsize + 2 * _shift) {
|
|
h = 2 * _fullsize + 2 * _shift;
|
|
}
|
|
if (w < 2 * (_fullsize + _shift)) {
|
|
w = 2 * (_fullsize + _shift);
|
|
}
|
|
|
|
if (w != _w) {
|
|
int from = (_w > 2 * (_fullsize + _shift)) ? (_w - _size - _fullsize - _shift) : (_fullsize - (_size - _shift));
|
|
int to = w - _size - _fullsize - _shift;
|
|
if (w > max_w) {
|
|
from = _fullsize - (_size - _shift);
|
|
max_w *= 2;
|
|
for (int i = 0; i < 4; i += 2) {
|
|
DeleteObject(bitmaps[i]);
|
|
bitmaps[i] = CreateCompatibleBitmap(screenDC, max_w, _size);
|
|
SelectObject(dcs[i], bitmaps[i]);
|
|
}
|
|
initCorners(_PsInitHor);
|
|
}
|
|
Gdiplus::Graphics graphics0(dcs[0]), graphics2(dcs[2]);
|
|
graphics0.SetCompositingMode(Gdiplus::CompositingModeSourceCopy);
|
|
graphics2.SetCompositingMode(Gdiplus::CompositingModeSourceCopy);
|
|
Gdiplus::SolidBrush brush(Gdiplus::Color(_alphas[0], r, g, b));
|
|
if (to > from) {
|
|
graphics0.FillRectangle(&brush, from, 0, to - from, 2 * _shift);
|
|
for (int i = 2 * _shift; i < _size; ++i) {
|
|
Gdiplus::Pen pen(Gdiplus::Color(_alphas[i], r, g, b));
|
|
graphics0.DrawLine(&pen, from, i, to, i);
|
|
graphics2.DrawLine(&pen, from, _size - (i - 2 * _shift) - 1, to, _size - (i - 2 * _shift) - 1);
|
|
}
|
|
for (int i = _size; i < _size + 2 * _shift; ++i) {
|
|
Gdiplus::Pen pen(Gdiplus::Color(_alphas[i], r, g, b));
|
|
graphics2.DrawLine(&pen, from, _size - (i - 2 * _shift) - 1, to, _size - (i - 2 * _shift) - 1);
|
|
}
|
|
}
|
|
if (_w > w) {
|
|
graphics0.FillRectangle(&brush, w - _size - _fullsize - _shift, 0, _fullsize - (_size - _shift), _size);
|
|
graphics2.FillRectangle(&brush, w - _size - _fullsize - _shift, 0, _fullsize - (_size - _shift), _size);
|
|
}
|
|
horCorners(w, &graphics0, &graphics2);
|
|
POINT p0 = { x + _size, y }, p2 = { x + _size, y + h - _size }, f = { 0, 0 };
|
|
SIZE s = { w - 2 * _size, _size };
|
|
updateWindow(0, &p0, &s);
|
|
updateWindow(2, &p2, &s);
|
|
} else if (x != _x || y != _y) {
|
|
POINT p0 = { x + _size, y }, p2 = { x + _size, y + h - _size };
|
|
updateWindow(0, &p0);
|
|
updateWindow(2, &p2);
|
|
} else if (h != _h) {
|
|
POINT p2 = { x + _size, y + h - _size };
|
|
updateWindow(2, &p2);
|
|
}
|
|
|
|
if (h != _h) {
|
|
int from = (_h > 2 * _fullsize + 2 * _shift) ? (_h - _fullsize) : (_fullsize + 2 * _shift);
|
|
int to = h - _fullsize;
|
|
if (h > max_h) {
|
|
from = (_fullsize + 2 * _shift);
|
|
max_h *= 2;
|
|
for (int i = 1; i < 4; i += 2) {
|
|
DeleteObject(bitmaps[i]);
|
|
bitmaps[i] = CreateCompatibleBitmap(dcs[i], _size, max_h);
|
|
SelectObject(dcs[i], bitmaps[i]);
|
|
}
|
|
initCorners(_PsInitVer);
|
|
}
|
|
Gdiplus::Graphics graphics1(dcs[1]), graphics3(dcs[3]);
|
|
graphics1.SetCompositingMode(Gdiplus::CompositingModeSourceCopy);
|
|
graphics3.SetCompositingMode(Gdiplus::CompositingModeSourceCopy);
|
|
|
|
Gdiplus::SolidBrush brush(Gdiplus::Color(_alphas[0], r, g, b));
|
|
if (to > from) {
|
|
graphics1.FillRectangle(&brush, _size - _shift, from, _shift, to - from);
|
|
graphics3.FillRectangle(&brush, 0, from, _shift, to - from);
|
|
for (int i = 2 * _shift; i < _size + _shift; ++i) {
|
|
Gdiplus::Pen pen(Gdiplus::Color(_alphas[i], r, g, b));
|
|
graphics1.DrawLine(&pen, _size + _shift - i - 1, from, _size + _shift - i - 1, to);
|
|
graphics3.DrawLine(&pen, i - _shift, from, i - _shift, to);
|
|
}
|
|
}
|
|
if (_h > h) {
|
|
graphics1.FillRectangle(&brush, 0, h - _fullsize, _size, _fullsize);
|
|
graphics3.FillRectangle(&brush, 0, h - _fullsize, _size, _fullsize);
|
|
}
|
|
verCorners(h, &graphics1, &graphics3);
|
|
|
|
POINT p1 = {x + w - _size, y}, p3 = {x, y}, f = {0, 0};
|
|
SIZE s = { _size, h };
|
|
updateWindow(1, &p1, &s);
|
|
updateWindow(3, &p3, &s);
|
|
} else if (x != _x || y != _y) {
|
|
POINT p1 = { x + w - _size, y }, p3 = { x, y };
|
|
updateWindow(1, &p1);
|
|
updateWindow(3, &p3);
|
|
} else if (w != _w) {
|
|
POINT p1 = { x + w - _size, y };
|
|
updateWindow(1, &p1);
|
|
}
|
|
_x = x;
|
|
_y = y;
|
|
_w = w;
|
|
_h = h;
|
|
|
|
if (hidden && (changes & _PsShadowShown)) {
|
|
for (int i = 0; i < 4; ++i) {
|
|
SetWindowPos(hwnds[i], hwnd, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOACTIVATE);
|
|
}
|
|
hidden = false;
|
|
}
|
|
}
|
|
|
|
void updateWindow(int i, POINT *p, SIZE *s = 0) {
|
|
static POINT f = {0, 0};
|
|
if (s) {
|
|
UpdateLayeredWindow(hwnds[i], (s ? screenDC : 0), p, s, (s ? dcs[i] : 0), (s ? (&f) : 0), noKeyColor, &blend, ULW_ALPHA);
|
|
} else {
|
|
SetWindowPos(hwnds[i], 0, p->x, p->y, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
|
|
}
|
|
}
|
|
|
|
void destroy() {
|
|
for (int i = 0; i < 4; ++i) {
|
|
if (dcs[i]) DeleteDC(dcs[i]);
|
|
if (bitmaps[i]) DeleteObject(bitmaps[i]);
|
|
if (hwnds[i]) DestroyWindow(hwnds[i]);
|
|
dcs[i] = 0;
|
|
bitmaps[i] = 0;
|
|
hwnds[i] = 0;
|
|
}
|
|
if (screenDC) ReleaseDC(0, screenDC);
|
|
}
|
|
|
|
private:
|
|
|
|
int _x, _y, _w, _h;
|
|
int _metaSize, _fullsize, _size, _shift;
|
|
QVector<BYTE> _alphas, _colors;
|
|
|
|
bool hidden;
|
|
|
|
HWND hwnds[4];
|
|
HDC dcs[4], screenDC;
|
|
HBITMAP bitmaps[4];
|
|
int max_w, max_h;
|
|
BLENDFUNCTION blend;
|
|
|
|
BYTE r, g, b;
|
|
COLORREF noKeyColor;
|
|
|
|
static LRESULT CALLBACK _PsShadowWindows::wndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
|
|
|
|
};
|
|
_PsShadowWindows _psShadowWindows;
|
|
|
|
LRESULT CALLBACK _PsShadowWindows::wndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
|
|
if (finished) return DefWindowProc(hwnd, msg, wParam, lParam);
|
|
|
|
int i;
|
|
for (i = 0; i < 4; ++i) {
|
|
if (_psShadowWindows.hwnds[i] && hwnd == _psShadowWindows.hwnds[i]) {
|
|
break;
|
|
}
|
|
}
|
|
if (i == 4) return DefWindowProc(hwnd, msg, wParam, lParam);
|
|
|
|
switch (msg) {
|
|
case WM_CLOSE:
|
|
Application::wnd()->close();
|
|
break;
|
|
case WM_NCHITTEST: {
|
|
int32 xPos = GET_X_LPARAM(lParam), yPos = GET_Y_LPARAM(lParam);
|
|
switch (i) {
|
|
case 0: return HTTOP;
|
|
case 1: return (yPos < _psShadowWindows._y + _psSize) ? HTTOPRIGHT : ((yPos >= _psShadowWindows._y + _psShadowWindows._h - _psSize) ? HTBOTTOMRIGHT : HTRIGHT);
|
|
case 2: return HTBOTTOM;
|
|
case 3: return (yPos < _psShadowWindows._y + _psSize) ? HTTOPLEFT : ((yPos >= _psShadowWindows._y + _psShadowWindows._h - _psSize) ? HTBOTTOMLEFT : HTLEFT);
|
|
}
|
|
return HTTRANSPARENT;
|
|
} break;
|
|
|
|
case WM_NCACTIVATE: return DefWindowProc(hwnd, msg, wParam, lParam);
|
|
case WM_NCLBUTTONDOWN:
|
|
case WM_NCLBUTTONUP:
|
|
case WM_NCLBUTTONDBLCLK:
|
|
case WM_NCMBUTTONDOWN:
|
|
case WM_NCMBUTTONUP:
|
|
case WM_NCMBUTTONDBLCLK:
|
|
case WM_NCRBUTTONDOWN:
|
|
case WM_NCRBUTTONUP:
|
|
case WM_NCRBUTTONDBLCLK:
|
|
case WM_NCXBUTTONDOWN:
|
|
case WM_NCXBUTTONUP:
|
|
case WM_NCXBUTTONDBLCLK:
|
|
case WM_NCMOUSEHOVER:
|
|
case WM_NCMOUSELEAVE:
|
|
case WM_NCMOUSEMOVE:
|
|
case WM_NCPOINTERUPDATE:
|
|
case WM_NCPOINTERDOWN:
|
|
case WM_NCPOINTERUP:
|
|
if (App::wnd() && App::wnd()->psHwnd()) {
|
|
if (msg == WM_NCLBUTTONDOWN) {
|
|
::SetForegroundWindow(App::wnd()->psHwnd());
|
|
}
|
|
LRESULT res = SendMessage(App::wnd()->psHwnd(), msg, wParam, lParam);
|
|
return res;
|
|
}
|
|
return 0;
|
|
break;
|
|
case WM_ACTIVATE:
|
|
if (App::wnd() && App::wnd()->psHwnd() && wParam == WA_ACTIVE) {
|
|
if ((HWND)lParam != App::wnd()->psHwnd()) {
|
|
::SetForegroundWindow(hwnd);
|
|
::SetWindowPos(App::wnd()->psHwnd(), hwnd, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
|
|
}
|
|
}
|
|
return DefWindowProc(hwnd, msg, wParam, lParam);
|
|
break;
|
|
default:
|
|
return DefWindowProc(hwnd, msg, wParam, lParam);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
QColor _shActive(0, 0, 0), _shInactive(0, 0, 0);
|
|
|
|
typedef BOOL (FAR STDAPICALLTYPE *f_dwmDefWindowProc)(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, _Out_ LRESULT *plResult);
|
|
f_dwmDefWindowProc dwmDefWindowProc;
|
|
|
|
typedef HRESULT (FAR STDAPICALLTYPE *f_dwmSetWindowAttribute)(HWND hWnd, DWORD dwAttribute, _In_ LPCVOID pvAttribute, DWORD cbAttribute);
|
|
f_dwmSetWindowAttribute dwmSetWindowAttribute;
|
|
|
|
typedef HRESULT (FAR STDAPICALLTYPE *f_dwmExtendFrameIntoClientArea)(HWND hWnd, const MARGINS *pMarInset);
|
|
f_dwmExtendFrameIntoClientArea dwmExtendFrameIntoClientArea;
|
|
|
|
typedef HRESULT (FAR STDAPICALLTYPE *f_setWindowTheme)(HWND hWnd, LPCWSTR pszSubAppName, LPCWSTR pszSubIdList);
|
|
f_setWindowTheme setWindowTheme;
|
|
|
|
typedef HRESULT (FAR STDAPICALLTYPE *f_openAs_RunDLL)(HWND hWnd, HINSTANCE hInstance, LPCWSTR lpszCmdLine, int nCmdShow);
|
|
f_openAs_RunDLL openAs_RunDLL;
|
|
|
|
typedef HRESULT (FAR STDAPICALLTYPE *f_shOpenWithDialog)(HWND hwndParent, const OPENASINFO *poainfo);
|
|
f_shOpenWithDialog shOpenWithDialog;
|
|
|
|
template <typename TFunction>
|
|
bool loadFunction(HINSTANCE dll, LPCSTR name, TFunction &func) {
|
|
if (!dll) return false;
|
|
|
|
func = (TFunction)GetProcAddress(dll, name);
|
|
return !!func;
|
|
}
|
|
|
|
class _PsInitializer {
|
|
public:
|
|
_PsInitializer() {
|
|
setupDWM();
|
|
useDWM = true;
|
|
frameless = !useDWM;
|
|
|
|
setupUx();
|
|
setupOpenAs();
|
|
}
|
|
void setupDWM() {
|
|
HINSTANCE procId = LoadLibrary(L"DWMAPI.DLL");
|
|
|
|
if (!loadFunction(procId, "DwmDefWindowProc", dwmDefWindowProc)) return;
|
|
if (!loadFunction(procId, "DwmSetWindowAttribute", dwmSetWindowAttribute)) return;
|
|
if (!loadFunction(procId, "DwmExtendFrameIntoClientArea", dwmExtendFrameIntoClientArea)) return;
|
|
useDWM = true;
|
|
}
|
|
void setupUx() {
|
|
HINSTANCE procId = LoadLibrary(L"UXTHEME.DLL");
|
|
|
|
if (!loadFunction(procId, "SetWindowTheme", setWindowTheme)) return;
|
|
useTheme = true;
|
|
}
|
|
void setupOpenAs() {
|
|
HINSTANCE procId = LoadLibrary(L"SHELL32.DLL");
|
|
|
|
if (!loadFunction(procId, "SHOpenWithDialog", shOpenWithDialog) && !loadFunction(procId, "OpenAs_RunDLLW", openAs_RunDLL)) return;
|
|
useOpenAs = true;
|
|
}
|
|
};
|
|
_PsInitializer _psInitializer;
|
|
|
|
class _PsEventFilter : public QAbstractNativeEventFilter {
|
|
public:
|
|
_PsEventFilter() {
|
|
}
|
|
|
|
bool nativeEventFilter(const QByteArray &eventType, void *message, long *result) {
|
|
Window *wnd = Application::wnd();
|
|
if (!wnd) return false;
|
|
|
|
MSG *msg = (MSG*)message;
|
|
if (msg->message == WM_ENDSESSION) {
|
|
App::quit();
|
|
return false;
|
|
}
|
|
if (msg->hwnd == wnd->psHwnd() || msg->hwnd && !wnd->psHwnd()) {
|
|
return mainWindowEvent(msg->hwnd, msg->message, msg->wParam, msg->lParam, (LRESULT*)result);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool mainWindowEvent(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *result) {
|
|
if (tbCreatedMsgId && msg == tbCreatedMsgId) {
|
|
if (CoCreateInstance(CLSID_TaskbarList, NULL, CLSCTX_ALL, IID_ITaskbarList3, (void**)&tbListInterface) != S_OK) {
|
|
tbListInterface = 0;
|
|
}
|
|
}
|
|
switch (msg) {
|
|
|
|
case WM_DESTROY: {
|
|
App::quit();
|
|
} return false;
|
|
|
|
case WM_ACTIVATE: {
|
|
if (LOWORD(wParam) == WA_CLICKACTIVE) {
|
|
App::wnd()->inactivePress(true);
|
|
}
|
|
Application::wnd()->psUpdateMargins();
|
|
if (LOWORD(wParam) != WA_INACTIVE) {
|
|
_psShadowWindows.setColor(_shActive);
|
|
_psShadowWindows.update(_PsShadowActivate);
|
|
} else {
|
|
_psShadowWindows.setColor(_shInactive);
|
|
}
|
|
QTimer::singleShot(0, Application::wnd(), SLOT(psUpdateCounter()));
|
|
Application::wnd()->update();
|
|
} return false;
|
|
|
|
case WM_NCPAINT: if (QSysInfo::WindowsVersion >= QSysInfo::WV_WINDOWS8) return false; *result = 0; return true;
|
|
|
|
case WM_NCCALCSIZE: if (!useDWM) return false; {
|
|
if (wParam == TRUE) {
|
|
LPNCCALCSIZE_PARAMS params = (LPNCCALCSIZE_PARAMS)lParam;
|
|
params->rgrc[0].left += margins.left() - simpleMargins.left();
|
|
params->rgrc[0].top += margins.top() - simpleMargins.top();
|
|
params->rgrc[0].right -= margins.right() - simpleMargins.right();
|
|
params->rgrc[0].bottom -= margins.bottom() - simpleMargins.bottom();
|
|
} else if (wParam == FALSE) {
|
|
LPRECT rect = (LPRECT)lParam;
|
|
|
|
rect->left += margins.left() - simpleMargins.left();
|
|
rect->top += margins.top() - simpleMargins.top();
|
|
rect->right += margins.right() - simpleMargins.right();
|
|
rect->bottom += margins.bottom() - simpleMargins.bottom();
|
|
}
|
|
*result = 0;
|
|
} return true;
|
|
|
|
case WM_NCACTIVATE: {
|
|
Application::wnd()->psUpdateMargins();
|
|
*result = LRESULT(TRUE);
|
|
Application::wnd()->repaint();
|
|
} return true;
|
|
|
|
case WM_WINDOWPOSCHANGING:
|
|
case WM_WINDOWPOSCHANGED: {
|
|
_psShadowWindows.update(_PsShadowMoved | _PsShadowResized, (WINDOWPOS*)lParam);
|
|
} return false;
|
|
|
|
case WM_SIZE: {
|
|
if (App::wnd()) {
|
|
if (wParam == SIZE_MAXIMIZED || wParam == SIZE_RESTORED || wParam == SIZE_MINIMIZED) {
|
|
if (wParam != SIZE_RESTORED || App::wnd()->windowState() != Qt::WindowNoState) {
|
|
Qt::WindowState state = Qt::WindowNoState;
|
|
if (wParam == SIZE_MAXIMIZED) {
|
|
state = Qt::WindowMaximized;
|
|
} else if (wParam == SIZE_MINIMIZED) {
|
|
state = Qt::WindowMinimized;
|
|
}
|
|
emit App::wnd()->windowHandle()->windowStateChanged(state);
|
|
} else {
|
|
App::wnd()->psUpdatedPosition();
|
|
}
|
|
int changes = (wParam == SIZE_MINIMIZED || wParam == SIZE_MAXIMIZED) ? _PsShadowHidden : (_PsShadowResized | _PsShadowShown);
|
|
_psShadowWindows.update(changes);
|
|
}
|
|
}
|
|
} return false;
|
|
|
|
case WM_SHOWWINDOW: {
|
|
LONG style = GetWindowLong(hWnd, GWL_STYLE);
|
|
int changes = _PsShadowResized | ((wParam && !(style & (WS_MAXIMIZE | WS_MINIMIZE))) ? _PsShadowShown : _PsShadowHidden);
|
|
_psShadowWindows.update(changes);
|
|
} return false;
|
|
|
|
case WM_MOVE: {
|
|
_psShadowWindows.update(_PsShadowMoved);
|
|
App::wnd()->psUpdatedPosition();
|
|
} return false;
|
|
|
|
case WM_NCHITTEST: {
|
|
POINTS p = MAKEPOINTS(lParam);
|
|
RECT r;
|
|
GetWindowRect(hWnd, &r);
|
|
HitTestType res = Application::wnd()->hitTest(QPoint(p.x - r.left + dleft, p.y - r.top + dtop));
|
|
switch (res) {
|
|
case HitTestClient:
|
|
case HitTestSysButton: *result = HTCLIENT; break;
|
|
case HitTestIcon: *result = HTCAPTION; break;
|
|
case HitTestCaption: *result = HTCAPTION; break;
|
|
case HitTestTop: *result = HTTOP; break;
|
|
case HitTestTopRight: *result = HTTOPRIGHT; break;
|
|
case HitTestRight: *result = HTRIGHT; break;
|
|
case HitTestBottomRight: *result = HTBOTTOMRIGHT; break;
|
|
case HitTestBottom: *result = HTBOTTOM; break;
|
|
case HitTestBottomLeft: *result = HTBOTTOMLEFT; break;
|
|
case HitTestLeft: *result = HTLEFT; break;
|
|
case HitTestTopLeft: *result = HTTOPLEFT; break;
|
|
case HitTestNone:
|
|
default: *result = HTTRANSPARENT; break;
|
|
};
|
|
} return true;
|
|
|
|
case WM_NCRBUTTONUP: {
|
|
SendMessage(hWnd, WM_SYSCOMMAND, SC_MOUSEMENU, lParam);
|
|
} return true;
|
|
|
|
case WM_NCLBUTTONDOWN: {
|
|
POINTS p = MAKEPOINTS(lParam);
|
|
RECT r;
|
|
GetWindowRect(hWnd, &r);
|
|
HitTestType res = Application::wnd()->hitTest(QPoint(p.x - r.left + dleft, p.y - r.top + dtop));
|
|
switch (res) {
|
|
case HitTestIcon:
|
|
if (menuHidden && getms() < menuHidden + 10) {
|
|
menuHidden = 0;
|
|
if (getms() < menuShown + GetDoubleClickTime()) {
|
|
Application::wnd()->close();
|
|
}
|
|
} else {
|
|
QRect icon = Application::wnd()->iconRect();
|
|
p.x = r.left - dleft + icon.left();
|
|
p.y = r.top - dtop + icon.top() + icon.height();
|
|
Application::wnd()->psUpdateSysMenu(Application::wnd()->windowHandle()->windowState());
|
|
menuShown = getms();
|
|
menuHidden = 0;
|
|
TrackPopupMenu(Application::wnd()->psMenu(), TPM_LEFTALIGN | TPM_TOPALIGN | TPM_LEFTBUTTON, p.x, p.y, 0, hWnd, 0);
|
|
menuHidden = getms();
|
|
}
|
|
return true;
|
|
};
|
|
} return false;
|
|
|
|
case WM_NCLBUTTONDBLCLK: {
|
|
POINTS p = MAKEPOINTS(lParam);
|
|
RECT r;
|
|
GetWindowRect(hWnd, &r);
|
|
HitTestType res = Application::wnd()->hitTest(QPoint(p.x - r.left + dleft, p.y - r.top + dtop));
|
|
switch (res) {
|
|
case HitTestIcon: Application::wnd()->close(); return true;
|
|
};
|
|
} return false;
|
|
|
|
case WM_SYSCOMMAND: {
|
|
if (wParam == SC_MOUSEMENU) {
|
|
POINTS p = MAKEPOINTS(lParam);
|
|
Application::wnd()->psUpdateSysMenu(Application::wnd()->windowHandle()->windowState());
|
|
TrackPopupMenu(Application::wnd()->psMenu(), TPM_LEFTALIGN | TPM_TOPALIGN | TPM_LEFTBUTTON, p.x, p.y, 0, hWnd, 0);
|
|
}
|
|
} return false;
|
|
|
|
case WM_COMMAND: {
|
|
if (HIWORD(wParam)) return false;
|
|
int cmd = LOWORD(wParam);
|
|
switch (cmd) {
|
|
case SC_CLOSE: Application::wnd()->close(); return true;
|
|
case SC_MINIMIZE: Application::wnd()->setWindowState(Qt::WindowMinimized); return true;
|
|
case SC_MAXIMIZE: Application::wnd()->setWindowState(Qt::WindowMaximized); return true;
|
|
case SC_RESTORE: Application::wnd()->setWindowState(Qt::WindowNoState); return true;
|
|
}
|
|
} return true;
|
|
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
_PsEventFilter *_psEventFilter = 0;
|
|
|
|
};
|
|
|
|
PsMainWindow::PsMainWindow(QWidget *parent) : QMainWindow(parent), ps_hWnd(0), ps_menu(0), icon256(qsl(":/gui/art/iconround256.png")),
|
|
ps_iconBig(0), ps_iconSmall(0), ps_iconOverlay(0), trayIcon(0), trayIconMenu(0), posInited(false), ps_tbHider_hWnd(createTaskbarHider()), psIdle(false) {
|
|
tbCreatedMsgId = RegisterWindowMessage(L"TaskbarButtonCreated");
|
|
icon16 = icon256.scaledToWidth(16, Qt::SmoothTransformation);
|
|
icon32 = icon256.scaledToWidth(32, Qt::SmoothTransformation);
|
|
connect(&psIdleTimer, SIGNAL(timeout()), this, SLOT(psIdleTimeout()));
|
|
psIdleTimer.setSingleShot(false);
|
|
connect(¬ifyWaitTimer, SIGNAL(timeout()), this, SLOT(psNotifyFire()));
|
|
notifyWaitTimer.setSingleShot(true);
|
|
}
|
|
|
|
void PsMainWindow::psIdleTimeout() {
|
|
LASTINPUTINFO lii;
|
|
lii.cbSize = sizeof(LASTINPUTINFO);
|
|
BOOL res = GetLastInputInfo(&lii);
|
|
if (res) {
|
|
uint64 ticks = GetTickCount();
|
|
if (lii.dwTime >= ticks - IdleMsecs) {
|
|
psIdle = false;
|
|
psIdleTimer.stop();
|
|
if (App::main()) App::main()->setOnline();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool PsMainWindow::psIsActive() const {
|
|
return isActiveWindow() && isVisible() && !(windowState() & Qt::WindowMinimized);
|
|
}
|
|
|
|
bool PsMainWindow::psIsOnline(int windowState) const {
|
|
if (windowState < 0) windowState = this->windowState();
|
|
if (windowState & Qt::WindowMinimized) {
|
|
return false;
|
|
} else if (!isVisible()) {
|
|
return false;
|
|
}
|
|
LASTINPUTINFO lii;
|
|
lii.cbSize = sizeof(LASTINPUTINFO);
|
|
BOOL res = GetLastInputInfo(&lii);
|
|
if (res) {
|
|
uint64 ticks = GetTickCount();
|
|
if (lii.dwTime < ticks - IdleMsecs) {
|
|
if (!psIdle) {
|
|
psIdle = true;
|
|
psIdleTimer.start(900);
|
|
}
|
|
return false;
|
|
} else {
|
|
psIdle = false;
|
|
psIdleTimer.stop();
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void PsMainWindow::psRefreshTaskbarIcon() {
|
|
QWidget *w = new QWidget(this);
|
|
w->setWindowFlags(Qt::Tool | Qt::FramelessWindowHint);
|
|
w->setGeometry(x() + 1, y() + 1, 1, 1);
|
|
QPalette p(w->palette());
|
|
p.setColor(QPalette::Background, st::titleBG->c);
|
|
QWindow *wnd = w->windowHandle();
|
|
w->setPalette(p);
|
|
w->show();
|
|
w->activateWindow();
|
|
delete w;
|
|
}
|
|
|
|
void PsMainWindow::psUpdateWorkmode() {
|
|
switch (cWorkMode()) {
|
|
case dbiwmWindowAndTray: {
|
|
setupTrayIcon();
|
|
HWND psOwner = (HWND)GetWindowLong(ps_hWnd, GWL_HWNDPARENT);
|
|
if (psOwner) {
|
|
SetWindowLong(ps_hWnd, GWL_HWNDPARENT, 0);
|
|
psRefreshTaskbarIcon();
|
|
}
|
|
} break;
|
|
|
|
case dbiwmTrayOnly: {
|
|
setupTrayIcon();
|
|
HWND psOwner = (HWND)GetWindowLong(ps_hWnd, GWL_HWNDPARENT);
|
|
if (!psOwner) {
|
|
SetWindowLong(ps_hWnd, GWL_HWNDPARENT, (LONG)ps_tbHider_hWnd);
|
|
}
|
|
} break;
|
|
|
|
case dbiwmWindowOnly: {
|
|
if (trayIconMenu) trayIconMenu->deleteLater();
|
|
trayIconMenu = 0;
|
|
if (trayIcon) trayIcon->deleteLater();
|
|
trayIcon = 0;
|
|
|
|
HWND psOwner = (HWND)GetWindowLong(ps_hWnd, GWL_HWNDPARENT);
|
|
if (psOwner) {
|
|
SetWindowLong(ps_hWnd, GWL_HWNDPARENT, 0);
|
|
psRefreshTaskbarIcon();
|
|
}
|
|
} break;
|
|
}
|
|
}
|
|
|
|
HICON qt_pixmapToWinHICON(const QPixmap &);
|
|
static HICON _qt_createHIcon(const QIcon &icon, int xSize, int ySize) {
|
|
if (!icon.isNull()) {
|
|
const QPixmap pm = icon.pixmap(icon.actualSize(QSize(xSize, ySize)));
|
|
if (!pm.isNull())
|
|
return qt_pixmapToWinHICON(pm);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void PsMainWindow::psUpdateCounter() {
|
|
int32 counter = App::histories().unreadFull;
|
|
style::color bg = (App::histories().unreadMuted < counter) ? st::counterBG : st::counterMuteBG;
|
|
QIcon icon;
|
|
QImage cicon16(icon16), cicon32(icon32);
|
|
if (counter > 0) {
|
|
{
|
|
QString cnt = (counter < 1000) ? QString("%1").arg(counter) : QString("..%1").arg(counter % 100, 2, 10, QChar('0'));
|
|
QPainter p16(&cicon16);
|
|
p16.setBrush(bg->b);
|
|
p16.setPen(Qt::NoPen);
|
|
p16.setRenderHint(QPainter::Antialiasing);
|
|
int32 fontSize = 8;
|
|
style::font f(fontSize);
|
|
int32 w = f->m.width(cnt), d = 2, r = 3;
|
|
p16.drawRoundedRect(QRect(16 - w - d * 2, 16 - f->height, w + d * 2, f->height), r, r);
|
|
p16.setFont(f->f);
|
|
|
|
p16.setPen(st::counterColor->p);
|
|
|
|
p16.drawText(16 - w - d, 16 - f->height + f->ascent, cnt);
|
|
}
|
|
if (!tbListInterface) {
|
|
QString cnt = (counter < 10000) ? QString("%1").arg(counter) : ((counter < 1000000) ? QString("%1K").arg(counter / 1000) : QString("%1M").arg(counter / 1000000));
|
|
QPainter p32(&cicon32);
|
|
style::font f(10);
|
|
int32 w = f->m.width(cnt), d = 3, r = 6;
|
|
p32.setBrush(bg->b);
|
|
p32.setPen(Qt::NoPen);
|
|
p32.setRenderHint(QPainter::Antialiasing);
|
|
p32.drawRoundedRect(QRect(32 - w - d * 2, 0, w + d * 2, f->height - 1), r, r);
|
|
p32.setPen(st::counterColor->p);
|
|
p32.setFont(f->f);
|
|
p32.drawText(32 - w - d, f->ascent - 1, cnt);
|
|
}
|
|
}
|
|
icon.addPixmap(QPixmap::fromImage(cicon16));
|
|
icon.addPixmap(QPixmap::fromImage(cicon32));
|
|
if (trayIcon) {
|
|
QIcon ticon;
|
|
QImage ticon16(icon16);
|
|
if (counter > 0) {
|
|
QString cnt = (counter < 1000) ? QString("%1").arg(counter) : QString("..%1").arg(counter % 100, 2, 10, QChar('0'));
|
|
{
|
|
QPainter p16(&ticon16);
|
|
p16.setBrush(bg->b);
|
|
p16.setPen(Qt::NoPen);
|
|
p16.setRenderHint(QPainter::Antialiasing);
|
|
int32 fontSize = 8;
|
|
style::font f(fontSize);
|
|
int32 w = f->m.width(cnt), d = 2, r = 3;
|
|
p16.drawRoundedRect(QRect(16 - w - d * 2, 16 - f->height, w + d * 2, f->height), r, r);
|
|
p16.setFont(f->f);
|
|
|
|
p16.setPen(st::counterColor->p);
|
|
|
|
p16.drawText(16 - w - d, 16 - f->height + f->ascent, cnt);
|
|
}
|
|
}
|
|
ticon.addPixmap(QPixmap::fromImage(ticon16));
|
|
ticon.addPixmap(QPixmap::fromImage(cicon32));
|
|
trayIcon->setIcon(ticon);
|
|
}
|
|
|
|
setWindowTitle((counter > 0) ? qsl("Telegram (%1)").arg(counter) : qsl("Telegram"));
|
|
psDestroyIcons();
|
|
ps_iconSmall = _qt_createHIcon(icon, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON));
|
|
ps_iconBig = _qt_createHIcon(icon, GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON));
|
|
SendMessage(ps_hWnd, WM_SETICON, 0, (LPARAM)ps_iconSmall);
|
|
SendMessage(ps_hWnd, WM_SETICON, 1, (LPARAM)(ps_iconBig ? ps_iconBig : ps_iconSmall));
|
|
if (tbListInterface) {
|
|
if (counter > 0) {
|
|
QString cnt = (counter < 1000) ? QString("%1").arg(counter) : QString("..%1").arg(counter % 100, 2, 10, QChar('0'));
|
|
QImage oicon16(16, 16, QImage::Format_ARGB32);
|
|
int32 cntSize = cnt.size();
|
|
oicon16.fill(st::transparent->c);
|
|
{
|
|
QPainter p16(&oicon16);
|
|
p16.setBrush(bg->b);
|
|
p16.setPen(Qt::NoPen);
|
|
p16.setRenderHint(QPainter::Antialiasing);
|
|
int32 fontSize = (cntSize < 2) ? 12 : ((cntSize < 3) ? 12 : 8);
|
|
style::font f(fontSize);
|
|
int32 w = f->m.width(cnt), d = (cntSize < 2) ? 5 : ((cntSize < 3) ? 2 : 2), r = (cntSize < 2) ? 8 : ((cntSize < 3) ? 7 : 3);
|
|
p16.drawRoundedRect(QRect(16 - w - d * 2, 16 - f->height, w + d * 2, f->height), r, r);
|
|
p16.setFont(f->f);
|
|
|
|
p16.setPen(st::counterColor->p);
|
|
|
|
p16.drawText(16 - w - d, 16 - f->height + f->ascent, cnt);
|
|
}
|
|
QIcon oicon(QPixmap::fromImage(oicon16));
|
|
ps_iconOverlay = _qt_createHIcon(oicon, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON));
|
|
}
|
|
QString description = counter > 0 ? QString("%1 unread messages").arg(counter) : qsl("No unread messages");
|
|
static WCHAR descriptionArr[1024];
|
|
description.toWCharArray(descriptionArr);
|
|
tbListInterface->SetOverlayIcon(ps_hWnd, ps_iconOverlay, descriptionArr);
|
|
}
|
|
}
|
|
|
|
namespace {
|
|
HMONITOR enumMonitor = 0;
|
|
RECT enumMonitorWork;
|
|
|
|
BOOL CALLBACK _monitorEnumProc(
|
|
_In_ HMONITOR hMonitor,
|
|
_In_ HDC hdcMonitor,
|
|
_In_ LPRECT lprcMonitor,
|
|
_In_ LPARAM dwData
|
|
) {
|
|
MONITORINFOEX info;
|
|
info.cbSize = sizeof(info);
|
|
GetMonitorInfo(hMonitor, &info);
|
|
if (dwData == hashCrc32(info.szDevice, sizeof(info.szDevice))) {
|
|
enumMonitor = hMonitor;
|
|
enumMonitorWork = info.rcWork;
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
void PsMainWindow::psInitSize() {
|
|
setMinimumWidth(st::wndMinWidth);
|
|
setMinimumHeight(st::wndMinHeight);
|
|
|
|
TWindowPos pos(cWindowPos());
|
|
if (cDebug()) { // temp while design
|
|
pos.w = 800;
|
|
pos.h = 600;
|
|
}
|
|
QRect avail(QDesktopWidget().availableGeometry());
|
|
bool maximized = false;
|
|
QRect geom(avail.x() + (avail.width() - st::wndDefWidth) / 2, avail.y() + (avail.height() - st::wndDefHeight) / 2, st::wndDefWidth, st::wndDefHeight);
|
|
if (pos.w && pos.h) {
|
|
if (pos.y < 0) pos.y = 0;
|
|
enumMonitor = 0;
|
|
EnumDisplayMonitors(0, 0, &_monitorEnumProc, pos.moncrc);
|
|
if (enumMonitor) {
|
|
int32 w = enumMonitorWork.right - enumMonitorWork.left, h = enumMonitorWork.bottom - enumMonitorWork.top;
|
|
if (w >= st::wndMinWidth && h >= st::wndMinHeight) {
|
|
if (pos.w > w) pos.w = w;
|
|
if (pos.h > h) pos.h = h;
|
|
pos.x += enumMonitorWork.left;
|
|
pos.y += enumMonitorWork.top;
|
|
if (pos.x < enumMonitorWork.right - 10 && pos.y < enumMonitorWork.bottom - 10) {
|
|
geom = QRect(pos.x, pos.y, pos.w, pos.h);
|
|
}
|
|
}
|
|
}
|
|
maximized = pos.maximized;
|
|
}
|
|
setGeometry(geom);
|
|
}
|
|
|
|
void PsMainWindow::psInitFrameless() {
|
|
psUpdatedPositionTimer.setSingleShot(true);
|
|
connect(&psUpdatedPositionTimer, SIGNAL(timeout()), this, SLOT(psSavePosition()));
|
|
|
|
QPlatformNativeInterface *i = QGuiApplication::platformNativeInterface();
|
|
ps_hWnd = static_cast<HWND>(i->nativeResourceForWindow(QByteArrayLiteral("handle"), windowHandle()));
|
|
|
|
if (!ps_hWnd) return;
|
|
|
|
if (frameless) {
|
|
setWindowFlags(Qt::FramelessWindowHint);
|
|
}
|
|
|
|
// RegisterApplicationRestart(NULL, 0);
|
|
|
|
psInitSysMenu();
|
|
connect(windowHandle(), SIGNAL(windowStateChanged(Qt::WindowState)), this, SLOT(psStateChanged(Qt::WindowState)));
|
|
}
|
|
|
|
void PsMainWindow::psSavePosition(Qt::WindowState state) {
|
|
if (state == Qt::WindowActive) state = windowHandle()->windowState();
|
|
if (state == Qt::WindowMinimized || !posInited) return;
|
|
|
|
TWindowPos pos(cWindowPos()), curPos = pos;
|
|
|
|
if (state == Qt::WindowMaximized) {
|
|
curPos.maximized = 1;
|
|
} else {
|
|
RECT w;
|
|
GetWindowRect(ps_hWnd, &w);
|
|
curPos.x = w.left;
|
|
curPos.y = w.top;
|
|
curPos.w = w.right - w.left;
|
|
curPos.h = w.bottom - w.top;
|
|
curPos.maximized = 0;
|
|
}
|
|
|
|
HMONITOR hMonitor = MonitorFromWindow(ps_hWnd, MONITOR_DEFAULTTONEAREST);
|
|
if (hMonitor) {
|
|
MONITORINFOEX info;
|
|
info.cbSize = sizeof(info);
|
|
GetMonitorInfo(hMonitor, &info);
|
|
if (!curPos.maximized) {
|
|
curPos.x -= info.rcWork.left;
|
|
curPos.y -= info.rcWork.top;
|
|
}
|
|
curPos.moncrc = hashCrc32(info.szDevice, sizeof(info.szDevice));
|
|
}
|
|
|
|
if (curPos.w >= st::wndMinWidth && curPos.h >= st::wndMinHeight) {
|
|
if (curPos.x != pos.x || curPos.y != pos.y || curPos.w != pos.w || curPos.h != pos.h || curPos.moncrc != pos.moncrc || curPos.maximized != pos.maximized) {
|
|
cSetWindowPos(curPos);
|
|
App::writeConfig();
|
|
}
|
|
}
|
|
}
|
|
|
|
void PsMainWindow::psUpdatedPosition() {
|
|
psUpdatedPositionTimer.start(4000);
|
|
}
|
|
|
|
void PsMainWindow::psStateChanged(Qt::WindowState state) {
|
|
psUpdateSysMenu(state);
|
|
psUpdateMargins();
|
|
if (state == Qt::WindowMinimized && GetWindowLong(ps_hWnd, GWL_HWNDPARENT)) {
|
|
minimizeToTray();
|
|
}
|
|
psSavePosition(state);
|
|
}
|
|
|
|
Q_DECLARE_METATYPE(QMargins);
|
|
void PsMainWindow::psFirstShow() {
|
|
_psShadowWindows.init(_shActive);
|
|
finished = false;
|
|
|
|
psUpdateMargins();
|
|
|
|
_psShadowWindows.update(_PsShadowHidden);
|
|
bool showShadows = true;
|
|
|
|
show();
|
|
if (cWindowPos().maximized) {
|
|
setWindowState(Qt::WindowMaximized);
|
|
}
|
|
|
|
if (cFromAutoStart()) {
|
|
if (cStartMinimized()) {
|
|
setWindowState(Qt::WindowMinimized);
|
|
if (cWorkMode() == dbiwmTrayOnly || cWorkMode() == dbiwmWindowAndTray) {
|
|
hide();
|
|
} else {
|
|
show();
|
|
}
|
|
showShadows = false;
|
|
} else {
|
|
show();
|
|
}
|
|
} else {
|
|
show();
|
|
}
|
|
posInited = true;
|
|
if (showShadows) {
|
|
_psShadowWindows.update(_PsShadowMoved | _PsShadowResized | _PsShadowShown);
|
|
}
|
|
}
|
|
|
|
bool PsMainWindow::psHandleTitle() {
|
|
return useDWM;
|
|
}
|
|
|
|
void PsMainWindow::psInitSysMenu() {
|
|
Qt::WindowStates states = windowState();
|
|
ps_menu = GetSystemMenu(ps_hWnd, FALSE);
|
|
psUpdateSysMenu(windowHandle()->windowState());
|
|
}
|
|
|
|
void PsMainWindow::psUpdateSysMenu(Qt::WindowState state) {
|
|
if (!ps_menu) return;
|
|
|
|
int menuToDisable = SC_RESTORE;
|
|
if (state == Qt::WindowMaximized) {
|
|
menuToDisable = SC_MAXIMIZE;
|
|
} else if (state == Qt::WindowMinimized) {
|
|
menuToDisable = SC_MINIMIZE;
|
|
}
|
|
int itemCount = GetMenuItemCount(ps_menu);
|
|
for (int i = 0; i < itemCount; ++i) {
|
|
MENUITEMINFO itemInfo = {0};
|
|
itemInfo.cbSize = sizeof(itemInfo);
|
|
itemInfo.fMask = MIIM_TYPE | MIIM_STATE | MIIM_ID;
|
|
if (GetMenuItemInfo(ps_menu, i, TRUE, &itemInfo)) {
|
|
if (itemInfo.fType & MFT_SEPARATOR) {
|
|
continue;
|
|
}
|
|
if (itemInfo.wID && !(itemInfo.fState & MFS_DEFAULT)) {
|
|
UINT fOldState = itemInfo.fState, fState = itemInfo.fState & ~MFS_DISABLED;
|
|
if (itemInfo.wID == SC_CLOSE) {
|
|
fState |= MFS_DEFAULT;
|
|
} else if (itemInfo.wID == menuToDisable || (itemInfo.wID != SC_MINIMIZE && itemInfo.wID != SC_MAXIMIZE && itemInfo.wID != SC_RESTORE)) {
|
|
fState |= MFS_DISABLED;
|
|
}
|
|
itemInfo.fMask = MIIM_STATE;
|
|
itemInfo.fState = fState;
|
|
if (!SetMenuItemInfo(ps_menu, i, TRUE, &itemInfo)) {
|
|
DEBUG_LOG(("PS Error: could not set state %1 to menu item %2, old state %3, error %4").arg(fState).arg(itemInfo.wID).arg(fOldState).arg(GetLastError()));
|
|
DestroyMenu(ps_menu);
|
|
ps_menu = 0;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
DEBUG_LOG(("PS Error: could not get state, menu item %1 of %2, error %3").arg(i).arg(itemCount).arg(GetLastError()));
|
|
DestroyMenu(ps_menu);
|
|
ps_menu = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void PsMainWindow::psUpdateMargins() {
|
|
if (!useDWM) return;
|
|
|
|
RECT r, a;
|
|
|
|
GetClientRect(ps_hWnd, &r);
|
|
a = r;
|
|
|
|
LONG style = GetWindowLong(ps_hWnd, GWL_STYLE), styleEx = GetWindowLong(ps_hWnd, GWL_EXSTYLE);
|
|
AdjustWindowRectEx(&a, style, false, styleEx);
|
|
simpleMargins = QMargins(a.left - r.left, a.top - r.top, r.right - a.right, r.bottom - a.bottom);
|
|
if (style & WS_MAXIMIZE) {
|
|
RECT w, m;
|
|
GetWindowRect(ps_hWnd, &w);
|
|
m = w;
|
|
|
|
HMONITOR hMonitor = MonitorFromRect(&w, MONITOR_DEFAULTTONEAREST);
|
|
if (hMonitor) {
|
|
MONITORINFO mi;
|
|
mi.cbSize = sizeof(mi);
|
|
GetMonitorInfo(hMonitor, &mi);
|
|
m = mi.rcWork;
|
|
}
|
|
|
|
dleft = w.left - m.left;
|
|
dtop = w.top - m.top;
|
|
|
|
margins.setLeft(simpleMargins.left() - w.left + m.left);
|
|
margins.setRight(simpleMargins.right() - m.right + w.right);
|
|
margins.setBottom(simpleMargins.bottom() - m.bottom + w.bottom);
|
|
margins.setTop(simpleMargins.top() - w.top + m.top);
|
|
} else {
|
|
margins = simpleMargins;
|
|
dleft = dtop = 0;
|
|
}
|
|
|
|
QPlatformNativeInterface *i = QGuiApplication::platformNativeInterface();
|
|
i->setWindowProperty(windowHandle()->handle(), "WindowsCustomMargins", QVariant::fromValue<QMargins>(margins));
|
|
if (!themeInited) {
|
|
themeInited = true;
|
|
if (useTheme) {
|
|
if (QSysInfo::WindowsVersion < QSysInfo::WV_WINDOWS8) {
|
|
setWindowTheme(ps_hWnd, L" ", L" ");
|
|
QApplication::setStyle(QStyleFactory::create("Windows"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void PsMainWindow::psFlash() {
|
|
if (GetForegroundWindow() == ps_hWnd) return;
|
|
|
|
FLASHWINFO info;
|
|
info.cbSize = sizeof(info);
|
|
info.hwnd = ps_hWnd;
|
|
info.dwFlags = FLASHW_ALL;
|
|
info.dwTimeout = 0;
|
|
info.uCount = 1;
|
|
FlashWindowEx(&info);
|
|
}
|
|
|
|
HWND PsMainWindow::psHwnd() const {
|
|
return ps_hWnd;
|
|
}
|
|
|
|
HMENU PsMainWindow::psMenu() const {
|
|
return ps_menu;
|
|
}
|
|
|
|
void PsMainWindow::psDestroyIcons() {
|
|
if (ps_iconBig) {
|
|
DestroyIcon(ps_iconBig);
|
|
ps_iconBig = 0;
|
|
}
|
|
if (ps_iconSmall) {
|
|
DestroyIcon(ps_iconSmall);
|
|
ps_iconSmall = 0;
|
|
}
|
|
if (ps_iconOverlay) {
|
|
DestroyIcon(ps_iconOverlay);
|
|
ps_iconOverlay = 0;
|
|
}
|
|
}
|
|
|
|
PsMainWindow::~PsMainWindow() {
|
|
finished = true;
|
|
if (ps_menu) DestroyMenu(ps_menu);
|
|
psDestroyIcons();
|
|
_psShadowWindows.destroy();
|
|
psClearNotifyFast();
|
|
if (ps_tbHider_hWnd) DestroyWindow(ps_tbHider_hWnd);
|
|
}
|
|
|
|
void PsMainWindow::psNotify(History *history, MsgId msgId) {
|
|
if (App::quiting() || !history->notifyFrom) return;
|
|
|
|
bool haveSetting = (history->peer->notify != UnknownNotifySettings);
|
|
if (haveSetting) {
|
|
if (history->peer->notify != EmptyNotifySettings && history->peer->notify->mute > unixtime()) {
|
|
history->clearNotifyFrom();
|
|
return;
|
|
}
|
|
} else {
|
|
App::wnd()->getNotifySetting(MTP_inputNotifyPeer(history->peer->input));
|
|
}
|
|
|
|
uint64 ms = getms() + NotifyWaitTimeout;
|
|
notifyWhenAlerts[history].insert(ms);
|
|
if (cDesktopNotify()) {
|
|
NotifyWhenMaps::iterator i = notifyWhenMaps.find(history);
|
|
if (i == notifyWhenMaps.end()) {
|
|
i = notifyWhenMaps.insert(history, NotifyWhenMap());
|
|
}
|
|
if (i.value().constFind(msgId) == i.value().cend()) {
|
|
i.value().insert(msgId, ms);
|
|
}
|
|
NotifyWaiters *addTo = haveSetting ? ¬ifyWaiters : ¬ifySettingWaiters;
|
|
if (addTo->constFind(history) == addTo->cend()) {
|
|
addTo->insert(history, NotifyWaiter(msgId, ms));
|
|
}
|
|
}
|
|
if (haveSetting) {
|
|
if (!notifyWaitTimer.isActive()) {
|
|
notifyWaitTimer.start(NotifyWaitTimeout);
|
|
}
|
|
}
|
|
}
|
|
|
|
void PsMainWindow::psNotifyFire() {
|
|
psShowNextNotify();
|
|
}
|
|
|
|
void PsMainWindow::psNotifySettingGot() {
|
|
int32 t = unixtime();
|
|
for (NotifyWaiters::iterator i = notifySettingWaiters.begin(); i != notifySettingWaiters.end();) {
|
|
History *history = i.key();
|
|
if (history->peer->notify == UnknownNotifySettings) {
|
|
++i;
|
|
} else {
|
|
if (history->peer->notify == EmptyNotifySettings || history->peer->notify->mute <= t) {
|
|
notifyWaiters.insert(i.key(), i.value());
|
|
}
|
|
i = notifySettingWaiters.erase(i);
|
|
}
|
|
}
|
|
notifyWaitTimer.stop();
|
|
psShowNextNotify();
|
|
}
|
|
|
|
void PsMainWindow::psClearNotify(History *history) {
|
|
if (!history) {
|
|
for (PsNotifyWindows::const_iterator i = notifyWindows.cbegin(), e = notifyWindows.cend(); i != e; ++i) {
|
|
(*i)->unlinkHistory();
|
|
}
|
|
for (NotifyWhenMaps::const_iterator i = notifyWhenMaps.cbegin(), e = notifyWhenMaps.cend(); i != e; ++i) {
|
|
i.key()->clearNotifyFrom();
|
|
}
|
|
notifyWaiters.clear();
|
|
notifySettingWaiters.clear();
|
|
notifyWhenMaps.clear();
|
|
return;
|
|
}
|
|
notifyWaiters.remove(history);
|
|
notifySettingWaiters.remove(history);
|
|
for (PsNotifyWindows::const_iterator i = notifyWindows.cbegin(), e = notifyWindows.cend(); i != e; ++i) {
|
|
(*i)->unlinkHistory(history);
|
|
}
|
|
notifyWhenMaps.remove(history);
|
|
notifyWhenAlerts.remove(history);
|
|
}
|
|
|
|
void PsMainWindow::psClearNotifyFast() {
|
|
notifyWaiters.clear();
|
|
notifySettingWaiters.clear();
|
|
for (PsNotifyWindows::const_iterator i = notifyWindows.cbegin(), e = notifyWindows.cend(); i != e; ++i) {
|
|
(*i)->deleteLater();
|
|
}
|
|
notifyWindows.clear();
|
|
notifyWhenMaps.clear();
|
|
notifyWhenAlerts.clear();
|
|
}
|
|
|
|
// QApplication::desktop()->availableGeometry(App::wnd()) works not very fine, returns not nearest
|
|
namespace {
|
|
//RECT _monitorRECT;
|
|
QRect _monitorRect;
|
|
//uint32 _monitorDelta;
|
|
//int32 _wndX, _wndY;
|
|
uint64 _monitorLastGot = 0;
|
|
|
|
//BOOL CALLBACK _monitorRectProc(
|
|
//_In_ HMONITOR hMonitor,
|
|
//_In_ HDC hdcMonitor,
|
|
//_In_ LPRECT lprcMonitor,
|
|
//_In_ LPARAM dwData
|
|
//) {
|
|
// MONITORINFOEX info;
|
|
// info.cbSize = sizeof(info);
|
|
// GetMonitorInfo(hMonitor, &info);
|
|
// int32 centerx = (info.rcWork.right + info.rcWork.left) / 2, centery = (info.rcWork.bottom + info.rcWork.top) / 2;
|
|
// uint32 delta = (info.rcWork.right > _wndX && info.rcWork.left <= _wndX && info.rcWork.bottom > _wndY && info.rcWork.top <= _wndY) ? 0 : ((centerx - _wndX) * (centerx - _wndX) + (centery - _wndY) * (centery - _wndY));
|
|
// if (delta < _monitorDelta) {
|
|
// _monitorDelta = delta;
|
|
// _monitorRECT = info.rcWork;
|
|
// }
|
|
// return !!delta;
|
|
//}
|
|
QRect _desktopRect() {
|
|
uint64 tnow = getms();
|
|
if (tnow > _monitorLastGot + 1000 || tnow < _monitorLastGot) {
|
|
_monitorLastGot = tnow;
|
|
//RECT r;
|
|
//GetWindowRect(App::wnd()->psHwnd(), &r);
|
|
//_wndX = (r.right + r.left) / 2;
|
|
//_wndY = (r.bottom + r.top) / 2;
|
|
//_monitorDelta = INT_MAX;
|
|
//EnumDisplayMonitors(0, 0, &_monitorRectProc, 0);
|
|
//_monitorRect = (_monitorDelta < INT_MAX) ? QRect(_monitorRECT.left, _monitorRECT.top, _monitorRECT.right - _monitorRECT.left, _monitorRECT.bottom - _monitorRECT.top) : QApplication::desktop()->availableGeometry(App::wnd());
|
|
HMONITOR hMonitor = MonitorFromWindow(App::wnd()->psHwnd(), MONITOR_DEFAULTTONEAREST);
|
|
if (hMonitor) {
|
|
MONITORINFOEX info;
|
|
info.cbSize = sizeof(info);
|
|
GetMonitorInfo(hMonitor, &info);
|
|
_monitorRect = QRect(info.rcWork.left, info.rcWork.top, info.rcWork.right - info.rcWork.left, info.rcWork.bottom - info.rcWork.top);
|
|
} else {
|
|
_monitorRect = QApplication::desktop()->availableGeometry(App::wnd());
|
|
}
|
|
}
|
|
return _monitorRect;
|
|
}
|
|
}
|
|
|
|
void PsMainWindow::psShowNextNotify(PsNotifyWindow *remove) {
|
|
if (App::quiting()) return;
|
|
|
|
int32 count = NotifyWindows;
|
|
if (remove) {
|
|
for (PsNotifyWindows::iterator i = notifyWindows.begin(), e = notifyWindows.end(); i != e; ++i) {
|
|
if ((*i) == remove) {
|
|
notifyWindows.erase(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
uint64 ms = getms(), nextAlert = 0;
|
|
bool alert = false;
|
|
for (NotifyWhenAlerts::iterator i = notifyWhenAlerts.begin(); i != notifyWhenAlerts.end();) {
|
|
while (!i.value().isEmpty() && *i.value().begin() <= ms) {
|
|
i.value().erase(i.value().begin());
|
|
NotifySettingsPtr n = i.key()->peer->notify;
|
|
if (n == EmptyNotifySettings || n != UnknownNotifySettings && n->mute <= unixtime()) {
|
|
alert = true;
|
|
}
|
|
}
|
|
if (i.value().isEmpty()) {
|
|
i = notifyWhenAlerts.erase(i);
|
|
} else {
|
|
if (!nextAlert || nextAlert > *i.value().begin()) {
|
|
nextAlert = *i.value().begin();
|
|
}
|
|
++i;
|
|
}
|
|
}
|
|
if (alert) {
|
|
psFlash();
|
|
App::playSound();
|
|
}
|
|
|
|
for (PsNotifyWindows::const_iterator i = notifyWindows.cbegin(), e = notifyWindows.cend(); i != e; ++i) {
|
|
int32 ind = (*i)->index();
|
|
if (ind < 0) continue;
|
|
--count;
|
|
}
|
|
if (count <= 0 || !cDesktopNotify()) {
|
|
if (nextAlert) {
|
|
notifyWaitTimer.start(nextAlert - ms);
|
|
}
|
|
return;
|
|
}
|
|
|
|
QRect r = _desktopRect();
|
|
int32 x = r.x() + r.width() - st::notifyWidth - st::notifyDeltaX, y = r.y() + r.height() - st::notifyHeight - st::notifyDeltaY;
|
|
while (count > 0) {
|
|
uint64 next = 0;
|
|
HistoryItem *notifyItem = 0;
|
|
NotifyWaiters::iterator notifyWaiter;
|
|
for (NotifyWaiters::iterator i = notifyWaiters.begin(); i != notifyWaiters.end(); ++i) {
|
|
History *history = i.key();
|
|
if (history->notifyFrom && history->notifyFrom->id != i.value().msg) {
|
|
NotifyWhenMaps::iterator j = notifyWhenMaps.find(history);
|
|
if (j == notifyWhenMaps.end()) {
|
|
history->clearNotifyFrom();
|
|
i = notifyWaiters.erase(i);
|
|
continue;
|
|
}
|
|
do {
|
|
NotifyWhenMap::const_iterator k = j.value().constFind(history->notifyFrom->id);
|
|
if (k != j.value().cend()) {
|
|
i.value().msg = k.key();
|
|
i.value().when = k.value();
|
|
break;
|
|
}
|
|
history->getNextNotifyFrom();
|
|
} while (history->notifyFrom);
|
|
}
|
|
if (!history->notifyFrom) {
|
|
notifyWhenMaps.remove(history);
|
|
i = notifyWaiters.erase(i);
|
|
continue;
|
|
}
|
|
uint64 when = i.value().when;
|
|
if (!notifyItem || next > when) {
|
|
next = when;
|
|
notifyItem = history->notifyFrom;
|
|
notifyWaiter = i;
|
|
}
|
|
}
|
|
if (notifyItem) {
|
|
if (next > ms) {
|
|
if (nextAlert && nextAlert < next) {
|
|
next = nextAlert;
|
|
nextAlert = 0;
|
|
}
|
|
notifyWaitTimer.start(next - ms);
|
|
break;
|
|
} else {
|
|
notifyWindows.push_back(new PsNotifyWindow(notifyItem, x, y));
|
|
--count;
|
|
|
|
uint64 ms = getms();
|
|
History *history = notifyItem->history();
|
|
history->getNextNotifyFrom();
|
|
NotifyWhenMaps::iterator j = notifyWhenMaps.find(history);
|
|
if (j == notifyWhenMaps.end() || !history->notifyFrom) {
|
|
history->clearNotifyFrom();
|
|
notifyWaiters.erase(notifyWaiter);
|
|
if (j != notifyWhenMaps.end()) notifyWhenMaps.erase(j);
|
|
continue;
|
|
}
|
|
j.value().remove(notifyItem->id);
|
|
do {
|
|
NotifyWhenMap::const_iterator k = j.value().constFind(history->notifyFrom->id);
|
|
if (k != j.value().cend()) {
|
|
notifyWaiter.value().msg = k.key();
|
|
notifyWaiter.value().when = k.value();
|
|
break;
|
|
}
|
|
history->getNextNotifyFrom();
|
|
} while (history->notifyFrom);
|
|
if (!history->notifyFrom) {
|
|
notifyWaiters.erase(notifyWaiter);
|
|
notifyWhenMaps.erase(j);
|
|
continue;
|
|
}
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if (nextAlert) {
|
|
notifyWaitTimer.start(nextAlert - ms);
|
|
}
|
|
|
|
count = NotifyWindows - count;
|
|
for (PsNotifyWindows::const_iterator i = notifyWindows.cbegin(), e = notifyWindows.cend(); i != e; ++i) {
|
|
int32 ind = (*i)->index();
|
|
if (ind < 0) continue;
|
|
--count;
|
|
(*i)->moveTo(x, y - count * (st::notifyHeight + st::notifyDeltaY));
|
|
}
|
|
}
|
|
|
|
void PsMainWindow::psStopHiding() {
|
|
for (PsNotifyWindows::const_iterator i = notifyWindows.cbegin(), e = notifyWindows.cend(); i != e; ++i) {
|
|
(*i)->stopHiding();
|
|
}
|
|
}
|
|
|
|
void PsMainWindow::psStartHiding() {
|
|
for (PsNotifyWindows::const_iterator i = notifyWindows.cbegin(), e = notifyWindows.cend(); i != e; ++i) {
|
|
(*i)->startHiding();
|
|
}
|
|
}
|
|
|
|
void PsMainWindow::psUpdateNotifies() {
|
|
for (PsNotifyWindows::const_iterator i = notifyWindows.cbegin(), e = notifyWindows.cend(); i != e; ++i) {
|
|
(*i)->updatePeerPhoto();
|
|
}
|
|
}
|
|
|
|
PsNotifyWindow::PsNotifyWindow(HistoryItem *item, int32 x, int32 y) : history(item->history()), aOpacity(0), _index(0), hiding(false), started(GetTickCount()),
|
|
alphaDuration(st::notifyFastAnim), posDuration(st::notifyFastAnim), aY(y + st::notifyHeight + st::notifyDeltaY), close(this, st::notifyClose), aOpacityFunc(st::notifyFastAnimFunc) {
|
|
|
|
int32 w = st::notifyWidth, h = st::notifyHeight;
|
|
QImage img(w, h, QImage::Format_ARGB32_Premultiplied);
|
|
img.fill(st::notifyBG->c);
|
|
|
|
{
|
|
QPainter p(&img);
|
|
p.setPen(st::notifyBorder->p);
|
|
p.setBrush(Qt::NoBrush);
|
|
p.drawRect(0, 0, w - 1, h - 1);
|
|
|
|
if (history->peer->photo->loaded()) {
|
|
p.drawPixmap(st::notifyPhotoPos.x(), st::notifyPhotoPos.y(), history->peer->photo->pix(st::notifyPhotoSize));
|
|
} else {
|
|
MTP::clearLoaderPriorities();
|
|
peerPhoto = history->peer->photo;
|
|
peerPhoto->load(true, true);
|
|
}
|
|
|
|
int32 itemWidth = w - st::notifyPhotoPos.x() - st::notifyPhotoSize - st::notifyTextLeft - st::notifyClosePos.x() - st::notifyClose.width;
|
|
|
|
QRect rectForName(st::notifyPhotoPos.x() + st::notifyPhotoSize + st::notifyTextLeft, st::notifyTextTop, itemWidth, st::msgNameFont->height);
|
|
if (history->peer->chat) {
|
|
p.drawPixmap(QPoint(rectForName.left() + st::dlgChatImgLeft, rectForName.top() + st::dlgChatImgTop), App::sprite(), st::dlgChatImg);
|
|
rectForName.setLeft(rectForName.left() + st::dlgChatImgSkip);
|
|
}
|
|
|
|
QDateTime now(QDateTime::currentDateTime()), lastTime(item->date);
|
|
QDate nowDate(now.date()), lastDate(lastTime.date());
|
|
QString dt = lastTime.toString(qsl("hh:mm"));
|
|
int32 dtWidth = st::dlgHistFont->m.width(dt);
|
|
rectForName.setWidth(rectForName.width() - dtWidth - st::dlgDateSkip);
|
|
p.setFont(st::dlgDateFont->f);
|
|
p.setPen(st::dlgDateColor->p);
|
|
p.drawText(rectForName.left() + rectForName.width() + st::dlgDateSkip, rectForName.top() + st::dlgHistFont->ascent, dt);
|
|
|
|
const HistoryItem *textCachedFor = 0;
|
|
Text itemTextCache(itemWidth);
|
|
bool active = false;
|
|
item->drawInDialog(p, QRect(st::notifyPhotoPos.x() + st::notifyPhotoSize + st::notifyTextLeft, st::notifyItemTop + st::msgNameFont->height, itemWidth, 2 * st::dlgFont->height), active, textCachedFor, itemTextCache);
|
|
|
|
p.setPen(st::dlgNameColor->p);
|
|
history->nameText.drawElided(p, rectForName.left(), rectForName.top(), rectForName.width());
|
|
}
|
|
pm = QPixmap::fromImage(img);
|
|
|
|
hideTimer.setSingleShot(true);
|
|
connect(&hideTimer, SIGNAL(timeout()), this, SLOT(hideByTimer()));
|
|
|
|
inputTimer.setSingleShot(true);
|
|
connect(&inputTimer, SIGNAL(timeout()), this, SLOT(checkLastInput()));
|
|
|
|
connect(&close, SIGNAL(clicked()), this, SLOT(unlinkHistory()));
|
|
close.setAcceptBoth(true);
|
|
close.move(w - st::notifyClose.width - st::notifyClosePos.x(), st::notifyClosePos.y());
|
|
close.show();
|
|
|
|
aY.start(y);
|
|
setGeometry(x, aY.current(), st::notifyWidth, st::notifyHeight);
|
|
|
|
aOpacity.start(1);
|
|
setWindowFlags(Qt::Tool | Qt::WindowStaysOnTopHint | Qt::FramelessWindowHint);
|
|
|
|
show();
|
|
|
|
setWindowOpacity(aOpacity.current());
|
|
|
|
alphaDuration = posDuration = st::notifyFastAnim;
|
|
anim::start(this);
|
|
|
|
checkLastInput();
|
|
}
|
|
|
|
void PsNotifyWindow::checkLastInput() {
|
|
LASTINPUTINFO lii;
|
|
lii.cbSize = sizeof(LASTINPUTINFO);
|
|
BOOL res = GetLastInputInfo(&lii);
|
|
if (!res || lii.dwTime >= started) {
|
|
hideTimer.start(st::notifyWaitLongHide);
|
|
} else {
|
|
inputTimer.start(300);
|
|
}
|
|
}
|
|
|
|
void PsNotifyWindow::moveTo(int32 x, int32 y, int32 index) {
|
|
if (index >= 0) {
|
|
_index = index;
|
|
}
|
|
move(x, aY.current());
|
|
aY.start(y);
|
|
aOpacity.restart();
|
|
posDuration = st::notifyFastAnim;
|
|
anim::start(this);
|
|
}
|
|
|
|
void PsNotifyWindow::updatePeerPhoto() {
|
|
if (!peerPhoto->isNull() && peerPhoto->loaded()) {
|
|
QImage img(pm.toImage());
|
|
{
|
|
QPainter p(&img);
|
|
p.drawPixmap(st::notifyPhotoPos.x(), st::notifyPhotoPos.y(), peerPhoto->pix(st::notifyPhotoSize));
|
|
}
|
|
peerPhoto = ImagePtr();
|
|
pm = QPixmap::fromImage(img);
|
|
update();
|
|
}
|
|
}
|
|
|
|
void PsNotifyWindow::unlinkHistory(History *hist) {
|
|
if (!hist || hist == history) {
|
|
animHide(st::notifyFastAnim, st::notifyFastAnimFunc);
|
|
history = 0;
|
|
App::wnd()->psShowNextNotify();
|
|
}
|
|
}
|
|
|
|
void PsNotifyWindow::enterEvent(QEvent *e) {
|
|
if (!history) return;
|
|
if (App::wnd()) App::wnd()->psStopHiding();
|
|
}
|
|
|
|
void PsNotifyWindow::leaveEvent(QEvent *e) {
|
|
if (!history) return;
|
|
App::wnd()->psStartHiding();
|
|
}
|
|
|
|
void PsNotifyWindow::startHiding() {
|
|
hideTimer.start(st::notifyWaitShortHide);
|
|
}
|
|
|
|
void PsNotifyWindow::mousePressEvent(QMouseEvent *e) {
|
|
if (!history) return;
|
|
if (e->button() == Qt::RightButton) {
|
|
unlinkHistory();
|
|
} else if (history) {
|
|
App::wnd()->showFromTray();
|
|
App::wnd()->hideSettings();
|
|
App::main()->showPeer(history->peer->id, false, true);
|
|
e->ignore();
|
|
}
|
|
}
|
|
|
|
void PsNotifyWindow::paintEvent(QPaintEvent *e) {
|
|
QPainter p(this);
|
|
p.drawPixmap(0, 0, pm);
|
|
}
|
|
|
|
void PsNotifyWindow::animHide(float64 duration, anim::transition func) {
|
|
if (!history) return;
|
|
alphaDuration = duration;
|
|
aOpacityFunc = func;
|
|
aOpacity.start(0);
|
|
aY.restart();
|
|
hiding = true;
|
|
anim::start(this);
|
|
}
|
|
|
|
void PsNotifyWindow::stopHiding() {
|
|
if (!history) return;
|
|
alphaDuration = st::notifyFastAnim;
|
|
aOpacityFunc = st::notifyFastAnimFunc;
|
|
aOpacity.start(1);
|
|
aY.restart();
|
|
hiding = false;
|
|
hideTimer.stop();
|
|
anim::start(this);
|
|
}
|
|
|
|
void PsNotifyWindow::hideByTimer() {
|
|
if (!history) return;
|
|
animHide(st::notifySlowHide, st::notifySlowHideFunc);
|
|
}
|
|
|
|
bool PsNotifyWindow::animStep(float64 ms) {
|
|
float64 dtAlpha = ms / alphaDuration, dtPos = ms / posDuration;
|
|
if (dtAlpha >= 1) {
|
|
aOpacity.finish();
|
|
if (hiding) {
|
|
deleteLater();
|
|
}
|
|
} else {
|
|
aOpacity.update(dtAlpha, aOpacityFunc);
|
|
}
|
|
setWindowOpacity(aOpacity.current());
|
|
if (dtPos >= 1) {
|
|
aY.finish();
|
|
} else {
|
|
aY.update(dtPos, anim::linear);
|
|
}
|
|
move(x(), aY.current());
|
|
update();
|
|
return (dtAlpha < 1 || !hiding && dtPos < 1);
|
|
}
|
|
|
|
PsNotifyWindow::~PsNotifyWindow() {
|
|
if (App::wnd()) App::wnd()->psShowNextNotify(this);
|
|
}
|
|
|
|
PsApplication::PsApplication(int &argc, char **argv) : QApplication(argc, argv) {
|
|
}
|
|
|
|
void PsApplication::psInstallEventFilter() {
|
|
delete _psEventFilter;
|
|
_psEventFilter = new _PsEventFilter();
|
|
installNativeEventFilter(_psEventFilter);
|
|
}
|
|
|
|
PsApplication::~PsApplication() {
|
|
delete _psEventFilter;
|
|
_psEventFilter = 0;
|
|
}
|
|
|
|
PsUpdateDownloader::PsUpdateDownloader(QThread *thread, const MTPDhelp_appUpdate &update) : already(0), reply(0), full(0) {
|
|
updateUrl = qs(update.vurl);
|
|
moveToThread(thread);
|
|
manager.moveToThread(thread);
|
|
App::setProxySettings(manager);
|
|
|
|
connect(thread, SIGNAL(started()), this, SLOT(start()));
|
|
initOutput();
|
|
}
|
|
|
|
PsUpdateDownloader::PsUpdateDownloader(QThread *thread, const QString &url) : already(0), reply(0), full(0) {
|
|
updateUrl = url;
|
|
moveToThread(thread);
|
|
manager.moveToThread(thread);
|
|
App::setProxySettings(manager);
|
|
|
|
connect(thread, SIGNAL(started()), this, SLOT(start()));
|
|
initOutput();
|
|
}
|
|
|
|
void PsUpdateDownloader::initOutput() {
|
|
QString fileName;
|
|
QRegularExpressionMatch m = QRegularExpression(qsl("/([^/\\?]+)(\\?|$)")).match(updateUrl);
|
|
if (m.hasMatch()) {
|
|
fileName = m.captured(1).replace(QRegularExpression(qsl("[^a-zA-Z0-9_\\-]")), QString());
|
|
}
|
|
if (fileName.isEmpty()) {
|
|
fileName = qsl("tupdate-%1").arg(rand());
|
|
}
|
|
QString dirStr = cWorkingDir() + qsl("tupdates/");
|
|
fileName = dirStr + fileName;
|
|
QFileInfo file(fileName);
|
|
|
|
QDir dir(dirStr);
|
|
if (dir.exists()) {
|
|
QFileInfoList all = dir.entryInfoList(QDir::Files);
|
|
for (QFileInfoList::iterator i = all.begin(), e = all.end(); i != e; ++i) {
|
|
if (i->absoluteFilePath() != file.absoluteFilePath()) {
|
|
QFile::remove(i->absoluteFilePath());
|
|
}
|
|
}
|
|
} else {
|
|
dir.mkdir(dir.absolutePath());
|
|
}
|
|
outputFile.setFileName(fileName);
|
|
if (file.exists()) {
|
|
uint64 fullSize = file.size();
|
|
if (fullSize < INT_MAX) {
|
|
int32 goodSize = (int32)fullSize;
|
|
if (goodSize % UpdateChunk) {
|
|
goodSize = goodSize - (goodSize % UpdateChunk);
|
|
if (goodSize) {
|
|
if (outputFile.open(QIODevice::ReadOnly)) {
|
|
QByteArray goodData = outputFile.readAll().mid(0, goodSize);
|
|
outputFile.close();
|
|
if (outputFile.open(QIODevice::WriteOnly)) {
|
|
outputFile.write(goodData);
|
|
outputFile.close();
|
|
|
|
QMutexLocker lock(&mutex);
|
|
already = goodSize;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
QMutexLocker lock(&mutex);
|
|
already = goodSize;
|
|
}
|
|
}
|
|
if (!already) {
|
|
QFile::remove(fileName);
|
|
}
|
|
}
|
|
}
|
|
|
|
void PsUpdateDownloader::start() {
|
|
sendRequest();
|
|
}
|
|
|
|
void PsUpdateDownloader::sendRequest() {
|
|
QNetworkRequest req(updateUrl);
|
|
QByteArray rangeHeaderValue = "bytes=" + QByteArray::number(already) + "-";// + QByteArray::number(already + cUpdateChunk() - 1);
|
|
req.setRawHeader("Range", rangeHeaderValue);
|
|
req.setAttribute(QNetworkRequest::HttpPipeliningAllowedAttribute, true);
|
|
if (reply) reply->deleteLater();
|
|
reply = manager.get(req);
|
|
connect(reply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(partFinished(qint64,qint64)));
|
|
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(partFailed(QNetworkReply::NetworkError)));
|
|
connect(reply, SIGNAL(metaDataChanged()), this, SLOT(partMetaGot()));
|
|
}
|
|
|
|
void PsUpdateDownloader::partMetaGot() {
|
|
typedef QList<QNetworkReply::RawHeaderPair> Pairs;
|
|
Pairs pairs = reply->rawHeaderPairs();
|
|
for (Pairs::iterator i = pairs.begin(), e = pairs.end(); i != e; ++i) {
|
|
if (QString::fromUtf8(i->first).toLower() == "content-range") {
|
|
QRegularExpressionMatch m = QRegularExpression(qsl("/(\\d+)([^\\d]|$)")).match(QString::fromUtf8(i->second));
|
|
if (m.hasMatch()) {
|
|
{
|
|
QMutexLocker lock(&mutex);
|
|
full = m.captured(1).toInt();
|
|
}
|
|
emit App::app()->updateDownloading(already, full);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int32 PsUpdateDownloader::ready() {
|
|
QMutexLocker lock(&mutex);
|
|
return already;
|
|
}
|
|
|
|
int32 PsUpdateDownloader::size() {
|
|
QMutexLocker lock(&mutex);
|
|
return full;
|
|
}
|
|
|
|
void PsUpdateDownloader::partFinished(qint64 got, qint64 total) {
|
|
if (!reply) return;
|
|
|
|
QVariant statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
|
|
if (statusCode.isValid()) {
|
|
int status = statusCode.toInt();
|
|
if (status != 200 && status != 206 && status != 416) {
|
|
LOG(("Update Error: Bad HTTP status received in partFinished(): %1").arg(status));
|
|
return fatalFail();
|
|
}
|
|
}
|
|
|
|
if (!already && !full) {
|
|
QMutexLocker lock(&mutex);
|
|
full = total;
|
|
}
|
|
DEBUG_LOG(("Update Info: part %1 of %2").arg(got).arg(total));
|
|
|
|
if (!outputFile.isOpen()) {
|
|
if (!outputFile.open(QIODevice::Append)) {
|
|
LOG(("Update Error: Could not open output file '%1' for appending").arg(outputFile.fileName()));
|
|
return fatalFail();
|
|
}
|
|
}
|
|
QByteArray r = reply->readAll();
|
|
if (!r.isEmpty()) {
|
|
outputFile.write(r);
|
|
|
|
QMutexLocker lock(&mutex);
|
|
already += r.size();
|
|
}
|
|
if (got >= total) {
|
|
reply->deleteLater();
|
|
reply = 0;
|
|
outputFile.close();
|
|
unpackUpdate();
|
|
} else {
|
|
emit App::app()->updateDownloading(already, full);
|
|
}
|
|
}
|
|
|
|
void PsUpdateDownloader::partFailed(QNetworkReply::NetworkError e) {
|
|
if (!reply) return;
|
|
|
|
QVariant statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
|
|
reply->deleteLater();
|
|
reply = 0;
|
|
if (statusCode.isValid()) {
|
|
int status = statusCode.toInt();
|
|
if (status == 416) { // Requested range not satisfiable
|
|
outputFile.close();
|
|
unpackUpdate();
|
|
return;
|
|
}
|
|
}
|
|
LOG(("Update Error: failed to download part starting from %1, error %2").arg(already).arg(e));
|
|
emit App::app()->updateFailed();
|
|
}
|
|
|
|
void PsUpdateDownloader::deleteDir(const QString &dir) {
|
|
std::wstring wDir = QDir::toNativeSeparators(dir).toStdWString();
|
|
WCHAR path[4096];
|
|
memcpy(path, wDir.c_str(), (wDir.size() + 1) * sizeof(WCHAR));
|
|
path[wDir.size() + 1] = 0;
|
|
SHFILEOPSTRUCT file_op = {
|
|
NULL,
|
|
FO_DELETE,
|
|
path,
|
|
L"",
|
|
FOF_NOCONFIRMATION |
|
|
FOF_NOERRORUI |
|
|
FOF_SILENT,
|
|
false,
|
|
0,
|
|
L""
|
|
};
|
|
int res = SHFileOperation(&file_op);
|
|
}
|
|
|
|
void PsUpdateDownloader::fatalFail() {
|
|
clearAll();
|
|
emit App::app()->updateFailed();
|
|
}
|
|
|
|
void PsUpdateDownloader::clearAll() {
|
|
deleteDir(cWorkingDir() + qsl("tupdates"));
|
|
}
|
|
|
|
void PsUpdateDownloader::unpackUpdate() {
|
|
QByteArray packed;
|
|
if (!outputFile.open(QIODevice::ReadOnly)) {
|
|
LOG(("Update Error: cant read updates file!"));
|
|
return fatalFail();
|
|
}
|
|
|
|
const int32 hSigLen = 128, hShaLen = 20, hPropsLen = LZMA_PROPS_SIZE, hOriginalSizeLen = sizeof(int32), hSize = hSigLen + hShaLen + hPropsLen + hOriginalSizeLen; // header
|
|
|
|
QByteArray compressed = outputFile.readAll();
|
|
int32 compressedLen = compressed.size() - hSize;
|
|
if (compressedLen <= 0) {
|
|
LOG(("Update Error: bad compressed size: %1").arg(compressed.size()));
|
|
return fatalFail();
|
|
}
|
|
outputFile.close();
|
|
|
|
QString tempDirPath = cWorkingDir() + qsl("tupdates/temp"), readyDirPath = cWorkingDir() + qsl("tupdates/ready");
|
|
deleteDir(tempDirPath);
|
|
deleteDir(readyDirPath);
|
|
|
|
QDir tempDir(tempDirPath), readyDir(readyDirPath);
|
|
if (tempDir.exists() || readyDir.exists()) {
|
|
LOG(("Update Error: cant clear tupdates/temp or tupdates/ready dir!"));
|
|
return fatalFail();
|
|
}
|
|
|
|
uchar sha1Buffer[20];
|
|
bool goodSha1 = !memcmp(compressed.constData() + hSigLen, hashSha1(compressed.constData() + hSigLen + hShaLen, compressedLen + hPropsLen + hOriginalSizeLen, sha1Buffer), hShaLen);
|
|
if (!goodSha1) {
|
|
LOG(("Update Error: bad SHA1 hash of update file!"));
|
|
return fatalFail();
|
|
}
|
|
|
|
RSA *pbKey = PEM_read_bio_RSAPublicKey(BIO_new_mem_buf(const_cast<char*>(UpdatesPublicKey), -1), 0, 0, 0);
|
|
if (!pbKey) {
|
|
LOG(("Update Error: cant read public rsa key!"));
|
|
return fatalFail();
|
|
}
|
|
if (RSA_verify(NID_sha1, (const uchar*)(compressed.constData() + hSigLen), hShaLen, (const uchar*)(compressed.constData()), hSigLen, pbKey) != 1) { // verify signature
|
|
RSA_free(pbKey);
|
|
LOG(("Update Error: bad RSA signature of update file!"));
|
|
return fatalFail();
|
|
}
|
|
RSA_free(pbKey);
|
|
|
|
QByteArray uncompressed;
|
|
|
|
int32 uncompressedLen;
|
|
memcpy(&uncompressedLen, compressed.constData() + hSigLen + hShaLen + hPropsLen, hOriginalSizeLen);
|
|
uncompressed.resize(uncompressedLen);
|
|
|
|
size_t resultLen = uncompressed.size();
|
|
SizeT srcLen = compressedLen;
|
|
int uncompressRes = LzmaUncompress((uchar*)uncompressed.data(), &resultLen, (const uchar*)(compressed.constData() + hSize), &srcLen, (const uchar*)(compressed.constData() + hSigLen + hShaLen), LZMA_PROPS_SIZE);
|
|
if (uncompressRes != SZ_OK) {
|
|
LOG(("Update Error: could not uncompress lzma, code: %1").arg(uncompressRes));
|
|
return fatalFail();
|
|
}
|
|
|
|
tempDir.mkdir(tempDir.absolutePath());
|
|
|
|
quint32 version;
|
|
{
|
|
QBuffer buffer(&uncompressed);
|
|
buffer.open(QIODevice::ReadOnly);
|
|
QDataStream stream(&buffer);
|
|
stream.setVersion(QDataStream::Qt_5_1);
|
|
|
|
stream >> version;
|
|
if (stream.status() != QDataStream::Ok) {
|
|
LOG(("Update Error: cant read version from downloaded stream, status: %1").arg(stream.status()));
|
|
return fatalFail();
|
|
}
|
|
if (version <= AppVersion) {
|
|
LOG(("Update Error: downloaded version %1 is not greater, than mine %2").arg(version).arg(AppVersion));
|
|
return fatalFail();
|
|
}
|
|
|
|
quint32 filesCount;
|
|
stream >> filesCount;
|
|
if (stream.status() != QDataStream::Ok) {
|
|
LOG(("Update Error: cant read files count from downloaded stream, status: %1").arg(stream.status()));
|
|
return fatalFail();
|
|
}
|
|
if (!filesCount) {
|
|
LOG(("Update Error: update is empty!"));
|
|
return fatalFail();
|
|
}
|
|
for (int32 i = 0; i < filesCount; ++i) {
|
|
QString relativeName;
|
|
quint32 fileSize;
|
|
QByteArray fileInnerData;
|
|
|
|
stream >> relativeName >> fileSize >> fileInnerData;
|
|
if (stream.status() != QDataStream::Ok) {
|
|
LOG(("Update Error: cant read file from downloaded stream, status: %1").arg(stream.status()));
|
|
return fatalFail();
|
|
}
|
|
if (fileSize != fileInnerData.size()) {
|
|
LOG(("Update Error: bad file size %1 not matching data size %2").arg(fileSize).arg(fileInnerData.size()));
|
|
return fatalFail();
|
|
}
|
|
|
|
QFile f(tempDirPath + '/' + relativeName);
|
|
if (!f.open(QIODevice::WriteOnly)) {
|
|
LOG(("Update Error: cant open file '%1' for writing").arg(tempDirPath + '/' + relativeName));
|
|
return fatalFail();
|
|
}
|
|
if (f.write(fileInnerData) != fileSize) {
|
|
f.close();
|
|
LOG(("Update Error: cant write file '%1'").arg(tempDirPath + '/' + relativeName));
|
|
return fatalFail();
|
|
}
|
|
f.close();
|
|
}
|
|
|
|
// create tdata/version file
|
|
tempDir.mkdir(QDir(tempDirPath + qsl("/tdata")).absolutePath());
|
|
std::wstring versionString = ((version % 1000) ? QString("%1.%2.%3").arg(int(version / 1000000)).arg(int((version % 1000000) / 1000)).arg(int(version % 1000)) : QString("%1.%2").arg(int(version / 1000000)).arg(int((version % 1000000) / 1000))).toStdWString();
|
|
DWORD versionNum = DWORD(version), versionLen = DWORD(versionString.size() * sizeof(WCHAR));
|
|
WCHAR versionStr[32];
|
|
memcpy(versionStr, versionString.c_str(), versionLen);
|
|
|
|
QFile fVersion(tempDirPath + qsl("/tdata/version"));
|
|
if (!fVersion.open(QIODevice::WriteOnly)) {
|
|
LOG(("Update Error: cant write version file '%1'").arg(tempDirPath + qsl("/version")));
|
|
return fatalFail();
|
|
}
|
|
fVersion.write((const char*)&versionNum, sizeof(DWORD));
|
|
fVersion.write((const char*)&versionLen, sizeof(DWORD));
|
|
fVersion.write((const char*)&versionStr[0], versionLen);
|
|
fVersion.close();
|
|
}
|
|
|
|
if (!tempDir.rename(tempDir.absolutePath(), readyDir.absolutePath())) {
|
|
LOG(("Update Error: cant rename temp dir '%1' to ready dir '%2'").arg(tempDir.absolutePath()).arg(readyDir.absolutePath()));
|
|
return fatalFail();
|
|
}
|
|
deleteDir(tempDirPath);
|
|
outputFile.remove();
|
|
|
|
emit App::app()->updateReady();
|
|
}
|
|
|
|
PsUpdateDownloader::~PsUpdateDownloader() {
|
|
delete reply;
|
|
reply = 0;
|
|
}
|
|
|
|
namespace {
|
|
BOOL CALLBACK _ActivateProcess(HWND hWnd, LPARAM lParam) {
|
|
uint64 &processId(*(uint64*)lParam);
|
|
|
|
DWORD dwProcessId;
|
|
::GetWindowThreadProcessId(hWnd, &dwProcessId);
|
|
|
|
if ((uint64)dwProcessId == processId) { // found top-level window
|
|
static const int32 nameBufSize = 1024;
|
|
WCHAR nameBuf[nameBufSize];
|
|
int32 len = GetWindowText(hWnd, nameBuf, nameBufSize);
|
|
if (len && len < nameBufSize) {
|
|
if (QRegularExpression(qsl("^Telegram(\\s*\\(\\d+\\))?$")).match(QString::fromStdWString(nameBuf)).hasMatch()) {
|
|
BOOL res = ::SetForegroundWindow(hWnd);
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
void psActivateProcess(uint64 pid) {
|
|
::EnumWindows((WNDENUMPROC)_ActivateProcess, (LPARAM)&pid);
|
|
}
|
|
|
|
QString psCurrentCountry() {
|
|
int chCount = GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SISO3166CTRYNAME, 0, 0);
|
|
if (chCount && chCount < 128) {
|
|
WCHAR wstrCountry[128];
|
|
int len = GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SISO3166CTRYNAME, wstrCountry, chCount);
|
|
return len ? QString::fromStdWString(std::wstring(wstrCountry)) : QString::fromLatin1(DefaultCountry);
|
|
}
|
|
return QString::fromLatin1(DefaultCountry);
|
|
}
|
|
|
|
namespace {
|
|
QString langById(int lngId) {
|
|
int primary = lngId & 0xFF;
|
|
switch (primary) {
|
|
case 0x36: return qsl("af");
|
|
case 0x1C: return qsl("sq");
|
|
case 0x5E: return qsl("am");
|
|
case 0x01: return qsl("ar");
|
|
case 0x2B: return qsl("hy");
|
|
case 0x4D: return qsl("as");
|
|
case 0x2C: return qsl("az");
|
|
case 0x45: return qsl("bn");
|
|
case 0x6D: return qsl("ba");
|
|
case 0x2D: return qsl("eu");
|
|
case 0x23: return qsl("be");
|
|
case 0x1A:
|
|
if (lngId == LANG_CROATIAN) {
|
|
return qsl("hr");
|
|
} else if (lngId == LANG_BOSNIAN_NEUTRAL || lngId == LANG_BOSNIAN) {
|
|
return qsl("bs");
|
|
}
|
|
return qsl("sr");
|
|
break;
|
|
case 0x7E: return qsl("br");
|
|
case 0x02: return qsl("bg");
|
|
case 0x92: return qsl("ku");
|
|
case 0x03: return qsl("ca");
|
|
case 0x04: return qsl("zh");
|
|
case 0x83: return qsl("co");
|
|
case 0x05: return qsl("cs");
|
|
case 0x06: return qsl("da");
|
|
case 0x65: return qsl("dv");
|
|
case 0x13: return qsl("nl");
|
|
case 0x09: return qsl("en");
|
|
case 0x25: return qsl("et");
|
|
case 0x38: return qsl("fo");
|
|
case 0x0B: return qsl("fi");
|
|
case 0x0c: return qsl("fr");
|
|
case 0x62: return qsl("fy");
|
|
case 0x56: return qsl("gl");
|
|
case 0x37: return qsl("ka");
|
|
case 0x07: return qsl("de");
|
|
case 0x08: return qsl("el");
|
|
case 0x6F: return qsl("kl");
|
|
case 0x47: return qsl("gu");
|
|
case 0x68: return qsl("ha");
|
|
case 0x0D: return qsl("he");
|
|
case 0x39: return qsl("hi");
|
|
case 0x0E: return qsl("hu");
|
|
case 0x0F: return qsl("is");
|
|
case 0x70: return qsl("ig");
|
|
case 0x21: return qsl("id");
|
|
case 0x5D: return qsl("iu");
|
|
case 0x3C: return qsl("ga");
|
|
case 0x34: return qsl("xh");
|
|
case 0x35: return qsl("zu");
|
|
case 0x10: return qsl("it");
|
|
case 0x11: return qsl("ja");
|
|
case 0x4B: return qsl("kn");
|
|
case 0x3F: return qsl("kk");
|
|
case 0x53: return qsl("kh");
|
|
case 0x87: return qsl("rw");
|
|
case 0x12: return qsl("ko");
|
|
case 0x40: return qsl("ky");
|
|
case 0x54: return qsl("lo");
|
|
case 0x26: return qsl("lv");
|
|
case 0x27: return qsl("lt");
|
|
case 0x6E: return qsl("lb");
|
|
case 0x2F: return qsl("mk");
|
|
case 0x3E: return qsl("ms");
|
|
case 0x4C: return qsl("ml");
|
|
case 0x3A: return qsl("mt");
|
|
case 0x81: return qsl("mi");
|
|
case 0x4E: return qsl("mr");
|
|
case 0x50: return qsl("mn");
|
|
case 0x61: return qsl("ne");
|
|
case 0x14: return qsl("no");
|
|
case 0x82: return qsl("oc");
|
|
case 0x48: return qsl("or");
|
|
case 0x63: return qsl("ps");
|
|
case 0x29: return qsl("fa");
|
|
case 0x15: return qsl("pl");
|
|
case 0x16: return qsl("pt");
|
|
case 0x67: return qsl("ff");
|
|
case 0x46: return qsl("pa");
|
|
case 0x18: return qsl("ro");
|
|
case 0x17: return qsl("rm");
|
|
case 0x19: return qsl("ru");
|
|
case 0x3B: return qsl("se");
|
|
case 0x4F: return qsl("sa");
|
|
case 0x32: return qsl("tn");
|
|
case 0x59: return qsl("sd");
|
|
case 0x5B: return qsl("si");
|
|
case 0x1B: return qsl("sk");
|
|
case 0x24: return qsl("sl");
|
|
case 0x0A: return qsl("es");
|
|
case 0x41: return qsl("sw");
|
|
case 0x1D: return qsl("sv");
|
|
case 0x28: return qsl("tg");
|
|
case 0x49: return qsl("ta");
|
|
case 0x44: return qsl("tt");
|
|
case 0x4A: return qsl("te");
|
|
case 0x1E: return qsl("th");
|
|
case 0x51: return qsl("bo");
|
|
case 0x73: return qsl("ti");
|
|
case 0x1F: return qsl("tr");
|
|
case 0x42: return qsl("tk");
|
|
case 0x22: return qsl("uk");
|
|
case 0x20: return qsl("ur");
|
|
case 0x80: return qsl("ug");
|
|
case 0x43: return qsl("uz");
|
|
case 0x2A: return qsl("vi");
|
|
case 0x52: return qsl("cy");
|
|
case 0x88: return qsl("wo");
|
|
case 0x78: return qsl("ii");
|
|
case 0x6A: return qsl("yo");
|
|
}
|
|
return QString::fromLatin1(DefaultLanguage);
|
|
}
|
|
}
|
|
|
|
QString psCurrentLanguage() {
|
|
int chCount = GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SNAME, 0, 0);
|
|
if (chCount && chCount < 128) {
|
|
WCHAR wstrLocale[128];
|
|
int len = GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SNAME, wstrLocale, chCount);
|
|
if (!len) return QString::fromLatin1(DefaultLanguage);
|
|
QString locale = QString::fromStdWString(std::wstring(wstrLocale));
|
|
QRegularExpressionMatch m = QRegularExpression("(^|[^a-z])([a-z]{2})-").match(locale);
|
|
if (m.hasMatch()) {
|
|
return m.captured(2);
|
|
}
|
|
}
|
|
chCount = GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ILANGUAGE, 0, 0);
|
|
if (chCount && chCount < 128) {
|
|
WCHAR wstrLocale[128];
|
|
int len = GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ILANGUAGE, wstrLocale, chCount), lngId = 0;
|
|
if (len < 5) return QString::fromLatin1(DefaultLanguage);
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
WCHAR ch = wstrLocale[i];
|
|
lngId *= 16;
|
|
if (ch >= WCHAR('0') && ch <= WCHAR('9')) {
|
|
lngId += (ch - WCHAR('0'));
|
|
} else if (ch >= WCHAR('A') && ch <= WCHAR('F')) {
|
|
lngId += (10 + ch - WCHAR('A'));
|
|
} else {
|
|
return QString::fromLatin1(DefaultLanguage);
|
|
}
|
|
}
|
|
return langById(lngId);
|
|
}
|
|
return QString::fromLatin1(DefaultLanguage);
|
|
}
|
|
|
|
QString psAppDataPath() {
|
|
static const int maxFileLen = MAX_PATH * 10;
|
|
WCHAR wstrPath[maxFileLen];
|
|
if (GetEnvironmentVariable(L"APPDATA", wstrPath, maxFileLen)) {
|
|
QDir appData(QString::fromStdWString(std::wstring(wstrPath)));
|
|
return appData.absolutePath() + '/' + QString::fromWCharArray(AppName) + '/';
|
|
}
|
|
return QString();
|
|
}
|
|
|
|
QString psCurrentExeDirectory(int argc, char *argv[]) {
|
|
LPWSTR *args;
|
|
int argsCount;
|
|
args = CommandLineToArgvW(GetCommandLine(), &argsCount);
|
|
if (args) {
|
|
QFileInfo info(QDir::fromNativeSeparators(QString::fromWCharArray(args[0])));
|
|
if (info.isFile()) {
|
|
return info.absoluteDir().absolutePath() + '/';
|
|
}
|
|
LocalFree(args);
|
|
}
|
|
return QString();
|
|
}
|
|
|
|
void psDoCleanup() {
|
|
try {
|
|
psAutoStart(false, true);
|
|
} catch (...) {
|
|
}
|
|
}
|
|
|
|
int psCleanup() {
|
|
__try
|
|
{
|
|
psDoCleanup();
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void psDoFixPrevious() {
|
|
try {
|
|
static const int bufSize = 4096;
|
|
DWORD checkType, checkSize = bufSize * 2;
|
|
WCHAR checkStr[bufSize];
|
|
|
|
QString appId = QString::fromStdWString(AppId);
|
|
QString newKeyStr1 = QString("Software\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\%1_is1").arg(appId);
|
|
QString newKeyStr2 = QString("Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\%1_is1").arg(appId);
|
|
QString oldKeyStr1 = QString("SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\%1_is1").arg(appId);
|
|
QString oldKeyStr2 = QString("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\%1_is1").arg(appId);
|
|
HKEY newKey1, newKey2, oldKey1, oldKey2;
|
|
LSTATUS newKeyRes1 = RegOpenKeyEx(HKEY_CURRENT_USER, newKeyStr1.toStdWString().c_str(), 0, KEY_READ, &newKey1);
|
|
LSTATUS newKeyRes2 = RegOpenKeyEx(HKEY_CURRENT_USER, newKeyStr2.toStdWString().c_str(), 0, KEY_READ, &newKey2);
|
|
LSTATUS oldKeyRes1 = RegOpenKeyEx(HKEY_LOCAL_MACHINE, oldKeyStr1.toStdWString().c_str(), 0, KEY_READ, &oldKey1);
|
|
LSTATUS oldKeyRes2 = RegOpenKeyEx(HKEY_LOCAL_MACHINE, oldKeyStr2.toStdWString().c_str(), 0, KEY_READ, &oldKey2);
|
|
|
|
bool existNew1 = (newKeyRes1 == ERROR_SUCCESS) && (RegQueryValueEx(newKey1, L"InstallDate", 0, &checkType, (BYTE*)checkStr, &checkSize) == ERROR_SUCCESS); checkSize = bufSize * 2;
|
|
bool existNew2 = (newKeyRes2 == ERROR_SUCCESS) && (RegQueryValueEx(newKey2, L"InstallDate", 0, &checkType, (BYTE*)checkStr, &checkSize) == ERROR_SUCCESS); checkSize = bufSize * 2;
|
|
bool existOld1 = (oldKeyRes1 == ERROR_SUCCESS) && (RegQueryValueEx(oldKey1, L"InstallDate", 0, &checkType, (BYTE*)checkStr, &checkSize) == ERROR_SUCCESS); checkSize = bufSize * 2;
|
|
bool existOld2 = (oldKeyRes2 == ERROR_SUCCESS) && (RegQueryValueEx(oldKey2, L"InstallDate", 0, &checkType, (BYTE*)checkStr, &checkSize) == ERROR_SUCCESS); checkSize = bufSize * 2;
|
|
|
|
if (newKeyRes1 == ERROR_SUCCESS) RegCloseKey(newKey1);
|
|
if (newKeyRes2 == ERROR_SUCCESS) RegCloseKey(newKey2);
|
|
if (oldKeyRes1 == ERROR_SUCCESS) RegCloseKey(oldKey1);
|
|
if (oldKeyRes2 == ERROR_SUCCESS) RegCloseKey(oldKey2);
|
|
|
|
if (existNew1 || existNew2) {
|
|
oldKeyRes1 = existOld1 ? RegDeleteKey(HKEY_LOCAL_MACHINE, oldKeyStr1.toStdWString().c_str()) : ERROR_SUCCESS;
|
|
oldKeyRes2 = existOld2 ? RegDeleteKey(HKEY_LOCAL_MACHINE, oldKeyStr2.toStdWString().c_str()) : ERROR_SUCCESS;
|
|
}
|
|
|
|
QString userDesktopLnk, commonDesktopLnk;
|
|
WCHAR userDesktopFolder[MAX_PATH], commonDesktopFolder[MAX_PATH];
|
|
HRESULT userDesktopRes = SHGetFolderPath(0, CSIDL_DESKTOPDIRECTORY, 0, SHGFP_TYPE_CURRENT, userDesktopFolder);
|
|
HRESULT commonDesktopRes = SHGetFolderPath(0, CSIDL_COMMON_DESKTOPDIRECTORY, 0, SHGFP_TYPE_CURRENT, commonDesktopFolder);
|
|
if (SUCCEEDED(userDesktopRes)) {
|
|
userDesktopLnk = QString::fromWCharArray(userDesktopFolder) + "\\Telegram.lnk";
|
|
}
|
|
if (SUCCEEDED(commonDesktopRes)) {
|
|
commonDesktopLnk = QString::fromWCharArray(commonDesktopFolder) + "\\Telegram.lnk";
|
|
}
|
|
QFile userDesktopFile(userDesktopLnk), commonDesktopFile(commonDesktopLnk);
|
|
if (QFile::exists(userDesktopLnk) && QFile::exists(commonDesktopLnk) && userDesktopLnk != commonDesktopLnk) {
|
|
bool removed = QFile::remove(commonDesktopLnk);
|
|
}
|
|
} catch (...) {
|
|
}
|
|
}
|
|
|
|
int psFixPrevious() {
|
|
__try
|
|
{
|
|
psDoFixPrevious();
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool psCheckReadyUpdate() {
|
|
QString readyPath = cWorkingDir() + qsl("tupdates/ready");
|
|
if (!QDir(readyPath).exists()) {
|
|
return false;
|
|
}
|
|
|
|
// check ready version
|
|
QString versionPath = readyPath + qsl("/tdata/version");
|
|
{
|
|
QFile fVersion(versionPath);
|
|
if (!fVersion.open(QIODevice::ReadOnly)) {
|
|
LOG(("Update Error: cant read version file '%1'").arg(versionPath));
|
|
PsUpdateDownloader::clearAll();
|
|
return false;
|
|
}
|
|
DWORD versionNum;
|
|
if (fVersion.read((char*)&versionNum, sizeof(DWORD)) != sizeof(DWORD)) {
|
|
LOG(("Update Error: cant read version from file '%1'").arg(versionPath));
|
|
PsUpdateDownloader::clearAll();
|
|
return false;
|
|
}
|
|
fVersion.close();
|
|
if (versionNum <= AppVersion) {
|
|
LOG(("Update Error: cant install version %1 having version %2").arg(versionNum).arg(AppVersion));
|
|
PsUpdateDownloader::clearAll();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
QString curUpdater = (cExeDir() + "Updater.exe");
|
|
QFileInfo updater(cWorkingDir() + "tupdates/ready/Updater.exe");
|
|
if (!updater.exists()) {
|
|
QFileInfo current(curUpdater);
|
|
if (!current.exists()) {
|
|
PsUpdateDownloader::clearAll();
|
|
return false;
|
|
}
|
|
if (CopyFile(current.absoluteFilePath().toStdWString().c_str(), updater.absoluteFilePath().toStdWString().c_str(), TRUE) == FALSE) {
|
|
PsUpdateDownloader::clearAll();
|
|
return false;
|
|
}
|
|
}
|
|
if (CopyFile(updater.absoluteFilePath().toStdWString().c_str(), curUpdater.toStdWString().c_str(), FALSE) == FALSE) {
|
|
PsUpdateDownloader::clearAll();
|
|
return false;
|
|
}
|
|
if (DeleteFile(updater.absoluteFilePath().toStdWString().c_str()) == FALSE) {
|
|
PsUpdateDownloader::clearAll();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void psPostprocessFile(const QString &name) {
|
|
std::wstring zoneFile = QDir::toNativeSeparators(name).toStdWString() + L":Zone.Identifier";
|
|
HANDLE f = CreateFile(zoneFile.c_str(), GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
|
|
if (f == INVALID_HANDLE_VALUE) { // :(
|
|
return;
|
|
}
|
|
|
|
const char data[] = "[ZoneTransfer]\r\nZoneId=3\r\n";
|
|
|
|
DWORD written = 0;
|
|
BOOL result = WriteFile(f, data, sizeof(data), &written, NULL);
|
|
CloseHandle(f);
|
|
|
|
if (!result || written != sizeof(data)) { // :(
|
|
return;
|
|
}
|
|
}
|
|
|
|
void psOpenFile(const QString &name, bool openWith) {
|
|
std::wstring wname = QDir::toNativeSeparators(name).toStdWString();
|
|
|
|
if (openWith && useOpenAs) {
|
|
if (shOpenWithDialog) {
|
|
OPENASINFO info;
|
|
info.oaifInFlags = OAIF_ALLOW_REGISTRATION | OAIF_REGISTER_EXT | OAIF_EXEC;
|
|
info.pcszClass = NULL;
|
|
info.pcszFile = wname.c_str();
|
|
shOpenWithDialog(0, &info);
|
|
} else {
|
|
openAs_RunDLL(0, 0, wname.c_str(), SW_SHOWNORMAL);
|
|
}
|
|
} else {
|
|
ShellExecute(0, L"open", wname.c_str(), 0, 0, SW_SHOWNORMAL);
|
|
}
|
|
}
|
|
|
|
void psShowInFolder(const QString &name) {
|
|
QString nameEscaped = QDir::toNativeSeparators(name).replace('"', qsl("\"\""));
|
|
ShellExecute(0, 0, qsl("explorer").toStdWString().c_str(), (qsl("/select,") + nameEscaped).toStdWString().c_str(), 0, SW_SHOWNORMAL);
|
|
}
|
|
|
|
void psFinish() {
|
|
}
|
|
|
|
void psExecUpdater() {
|
|
QString targs = qsl("-update");
|
|
if (cFromAutoStart()) targs += qsl(" -autostart");
|
|
if (cDebug()) targs += qsl(" -debug");
|
|
|
|
QString updater(QDir::toNativeSeparators(cExeDir() + "Updater.exe")), wdir(QDir::toNativeSeparators(cWorkingDir()));
|
|
|
|
DEBUG_LOG(("Application Info: executing %1 %2").arg(cExeDir() + "Updater.exe").arg(targs));
|
|
HINSTANCE r = ShellExecute(0, 0, updater.toStdWString().c_str(), targs.toStdWString().c_str(), wdir.isEmpty() ? 0 : wdir.toStdWString().c_str(), SW_SHOWNORMAL);
|
|
if (long(r) < 32) {
|
|
DEBUG_LOG(("Application Error: failed to execute %1, working directory: '%2', result: %3").arg(updater).arg(wdir).arg(long(r)));
|
|
QString readyPath = cWorkingDir() + qsl("tupdates/ready");
|
|
PsUpdateDownloader::deleteDir(readyPath);
|
|
}
|
|
}
|
|
|
|
void psExecTelegram() {
|
|
QString targs = qsl("-noupdate -tosettings");
|
|
if (cFromAutoStart()) targs += qsl(" -autostart");
|
|
if (cDebug()) targs += qsl(" -debug");
|
|
if (cDataFile() != (cTestMode() ? qsl("data_test") : qsl("data"))) targs += qsl(" -key \"") + cDataFile() + '"';
|
|
|
|
QString telegram(QDir::toNativeSeparators(cExeDir() + "Telegram.exe")), wdir(QDir::toNativeSeparators(cWorkingDir()));
|
|
|
|
DEBUG_LOG(("Application Info: executing %1 %2").arg(cExeDir() + "Telegram.exe").arg(targs));
|
|
HINSTANCE r = ShellExecute(0, 0, telegram.toStdWString().c_str(), targs.toStdWString().c_str(), wdir.isEmpty() ? 0 : wdir.toStdWString().c_str(), SW_SHOWNORMAL);
|
|
if (long(r) < 32) {
|
|
DEBUG_LOG(("Application Error: failed to execute %1, working directory: '%2', result: %3").arg(telegram).arg(wdir).arg(long(r)));
|
|
}
|
|
}
|
|
|
|
void psAutoStart(bool start, bool silent) {
|
|
WCHAR startupFolder[MAX_PATH];
|
|
HRESULT hres = SHGetFolderPath(0, CSIDL_STARTUP, 0, SHGFP_TYPE_CURRENT, startupFolder);
|
|
if (SUCCEEDED(hres)) {
|
|
QString lnk = QString::fromWCharArray(startupFolder) + "\\Telegram.lnk";
|
|
if (start) {
|
|
IShellLink* psl;
|
|
hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (LPVOID*)&psl);
|
|
if (SUCCEEDED(hres)) {
|
|
IPersistFile* ppf;
|
|
|
|
QString exe = QDir::toNativeSeparators(QDir(cExeDir()).absolutePath() + "//Telegram.exe"), dir = QDir::toNativeSeparators(QDir(cWorkingDir()).absolutePath());
|
|
psl->SetArguments(L"-autostart");
|
|
psl->SetPath(exe.toStdWString().c_str());
|
|
psl->SetWorkingDirectory(dir.toStdWString().c_str());
|
|
psl->SetDescription(L"Telegram autorun link.\nYou can disable autorun in Telegram settings.");
|
|
|
|
hres = psl->QueryInterface(IID_IPersistFile, (LPVOID*)&ppf);
|
|
|
|
if (SUCCEEDED(hres)) {
|
|
hres = ppf->Save(lnk.toStdWString().c_str(), TRUE);
|
|
ppf->Release();
|
|
} else {
|
|
if (!silent) LOG(("App Error: could not create interface IID_IPersistFile %1").arg(hres));
|
|
}
|
|
psl->Release();
|
|
} else {
|
|
if (!silent) LOG(("App Error: could not create instance of IID_IShellLink %1").arg(hres));
|
|
}
|
|
} else {
|
|
QFile::remove(lnk);
|
|
}
|
|
} else {
|
|
if (!silent) LOG(("App Error: could not get CSIDL_STARTUP folder %1").arg(hres));
|
|
}
|
|
}
|
|
|
|
#ifdef _NEED_WIN_GENERATE_DUMP
|
|
static const WCHAR *_programName = L"Telegram Win (Unofficial)"; // folder in APPDATA, if current path is unavailable for writing
|
|
static const WCHAR *_exeName = L"Telegram.exe";
|
|
|
|
LPTOP_LEVEL_EXCEPTION_FILTER _oldWndExceptionFilter = 0;
|
|
|
|
typedef BOOL (FAR STDAPICALLTYPE *t_miniDumpWriteDump)(
|
|
_In_ HANDLE hProcess,
|
|
_In_ DWORD ProcessId,
|
|
_In_ HANDLE hFile,
|
|
_In_ MINIDUMP_TYPE DumpType,
|
|
_In_opt_ PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
|
|
_In_opt_ PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
|
|
_In_opt_ PMINIDUMP_CALLBACK_INFORMATION CallbackParam
|
|
);
|
|
t_miniDumpWriteDump miniDumpWriteDump = 0;
|
|
|
|
HANDLE _generateDumpFileAtPath(const WCHAR *path) {
|
|
static const int maxFileLen = MAX_PATH * 10;
|
|
|
|
WCHAR szPath[maxFileLen];
|
|
wsprintf(szPath, L"%stdumps\\", path);
|
|
|
|
if (!CreateDirectory(szPath, NULL)) {
|
|
DWORD errCode = GetLastError();
|
|
if (errCode && errCode != ERROR_ALREADY_EXISTS) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
WCHAR szFileName[maxFileLen];
|
|
WCHAR szExeName[maxFileLen];
|
|
|
|
wcscpy_s(szExeName, _exeName);
|
|
WCHAR *dotFrom = wcschr(szExeName, WCHAR(L'.'));
|
|
if (dotFrom) {
|
|
wsprintf(dotFrom, L"");
|
|
}
|
|
|
|
SYSTEMTIME stLocalTime;
|
|
|
|
GetLocalTime(&stLocalTime);
|
|
|
|
wsprintf(szFileName, L"%s%s-%s-%04d%02d%02d-%02d%02d%02d-%ld-%ld.dmp",
|
|
szPath, szExeName, AppVersionStr,
|
|
stLocalTime.wYear, stLocalTime.wMonth, stLocalTime.wDay,
|
|
stLocalTime.wHour, stLocalTime.wMinute, stLocalTime.wSecond,
|
|
GetCurrentProcessId(), GetCurrentThreadId());
|
|
return CreateFile(szFileName, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_WRITE|FILE_SHARE_READ, 0, CREATE_ALWAYS, 0, 0);
|
|
}
|
|
|
|
void _generateDump(EXCEPTION_POINTERS* pExceptionPointers) {
|
|
static const int maxFileLen = MAX_PATH * 10;
|
|
|
|
HMODULE hDll = LoadLibrary(L"DBGHELP.DLL");
|
|
if (!hDll) return;
|
|
|
|
miniDumpWriteDump = (t_miniDumpWriteDump)GetProcAddress(hDll, "MiniDumpWriteDump");
|
|
if (!miniDumpWriteDump) return;
|
|
|
|
HANDLE hDumpFile = 0;
|
|
|
|
WCHAR szPath[maxFileLen];
|
|
DWORD len = GetModuleFileName(GetModuleHandle(0), szPath, maxFileLen);
|
|
if (!len) return;
|
|
|
|
WCHAR *pathEnd = szPath + len;
|
|
|
|
if (!_wcsicmp(pathEnd - wcslen(_exeName), _exeName)) {
|
|
wsprintf(pathEnd - wcslen(_exeName), L"");
|
|
hDumpFile = _generateDumpFileAtPath(szPath);
|
|
}
|
|
if (!hDumpFile || hDumpFile == INVALID_HANDLE_VALUE) {
|
|
WCHAR wstrPath[maxFileLen];
|
|
DWORD wstrPathLen;
|
|
if (wstrPathLen = GetEnvironmentVariable(L"APPDATA", wstrPath, maxFileLen)) {
|
|
wsprintf(wstrPath + wstrPathLen, L"\\%s\\", _programName);
|
|
hDumpFile = _generateDumpFileAtPath(wstrPath);
|
|
}
|
|
}
|
|
|
|
if (!hDumpFile || hDumpFile == INVALID_HANDLE_VALUE) {
|
|
return;
|
|
}
|
|
|
|
MINIDUMP_EXCEPTION_INFORMATION ExpParam = {0};
|
|
ExpParam.ThreadId = GetCurrentThreadId();
|
|
ExpParam.ExceptionPointers = pExceptionPointers;
|
|
ExpParam.ClientPointers = TRUE;
|
|
|
|
miniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hDumpFile, MiniDumpWithDataSegs, &ExpParam, NULL, NULL);
|
|
}
|
|
|
|
LONG CALLBACK _exceptionFilter(EXCEPTION_POINTERS* pExceptionPointers) {
|
|
_generateDump(pExceptionPointers);
|
|
return _oldWndExceptionFilter ? (*_oldWndExceptionFilter)(pExceptionPointers) : EXCEPTION_CONTINUE_SEARCH;
|
|
}
|
|
#endif
|