shell/source/win32/shlxthandler/thumbviewer/thumbviewer.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef DONT_HAVE_GDIPLUS
  21
  22
  23 #include "internal/global.hxx"
  24
  25 #include "internal/thumbviewer.hxx"
  26 #include "internal/shlxthdl.hxx"
  27 #include "internal/registry.hxx"
  28 #include "internal/fileextensions.hxx"
  29 #include "internal/config.hxx"
  30 #include "internal/zipfile.hxx"
  31 #include "internal/utilities.hxx"
  32
  33 #include "internal/resource.h"
  34
  35 #include <stdio.h>
  36 #include <utility>
  37 #include <stdlib.h>
  38
  39 #if defined _MSC_VER
  40 #pragma warning(push, 1)
  41 #endif
  42 #include <shellapi.h>
  43 #ifdef _WIN32_WINNT_WINBLUE
  44 #include <VersionHelpers.h>
  45 #endif
  46 #if defined _MSC_VER
  47 #pragma warning(pop)
  48 #endif
  49 #include <memory>
  50
  51 extern HINSTANCE g_hModule;
  52
  53 namespace internal
  54 {
  55     /* The signet.png used for thumbnails of signed documents
  56        is contained as resource in this module, the resource
  57        id is 2000 */
  58     void LoadSignetImageFromResource(ZipFile::ZipContentBuffer_t& buffer)
  59     {
  60         HRSRC hrc = FindResource(g_hModule, TEXT("#2000"), RT_RCDATA);
  61         DWORD size = SizeofResource(g_hModule, hrc);
  62         HGLOBAL hglob = LoadResource(g_hModule, hrc);
  63         char* data = reinterpret_cast<char*>(LockResource(hglob));
  64         buffer = ZipFile::ZipContentBuffer_t(data, data + size);
  65     }
  66
  67     bool IsSignedDocument(const ZipFile* zipfile)
  68     {
  69         return zipfile->HasContent("META-INF/documentsignatures.xml");
  70     }
  71
  72     bool IsWindowsXP()
  73     {
  74 // the Win32 SDK 8.1 deprecates GetVersionEx()
  75 #ifdef _WIN32_WINNT_WINBLUE
  76         return IsWindowsXPOrGreater() ? true : false;
  77 #else
  78         OSVERSIONINFO osvi;
  79         ZeroMemory(&osvi, sizeof(osvi));
  80         osvi.dwOSVersionInfoSize = sizeof(osvi);
  81         GetVersionEx(&osvi);
  82
  83         return ((osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) &&
  84                 ((osvi.dwMajorVersion >= 5) && (osvi.dwMinorVersion >= 1)));
  85 #endif
  86     }
  87
  88     /* Calculate where to position the signet image.
  89        On Windows ME we need to shift the signet a
  90        little bit to the left because Windows ME
  91        puts an overlay icon to the lower right
  92        corner of a thumbnail image so that our signet
  93        we be hidden. */
  94     Gdiplus::Point CalcSignetPosition(
  95         const Gdiplus::Rect& canvas, const Gdiplus::Rect& thumbnail_border, const Gdiplus::Rect& signet)
  96     {
  97         int x = 0;
  98         int y = 0;
  99         int hoffset = canvas.GetRight() - thumbnail_border.GetRight();
 100         int voffset = canvas.GetBottom() - thumbnail_border.GetBottom();
 101
 102         if (hoffset > voffset)
 103         {
 104             x = thumbnail_border.GetRight() - signet.GetRight() + min(signet.GetRight() / 2, hoffset);
 105             y = thumbnail_border.GetBottom() - signet.GetBottom();
 106         }
 107         else
 108         {
 109             x = thumbnail_border.GetRight() - signet.GetRight();
 110             y = thumbnail_border.GetBottom() - signet.GetBottom() + min(signet.GetBottom() / 2, voffset);
 111         }
 112
 113         if (!IsWindowsXP())
 114             x -= 15;
 115
 116         return Gdiplus::Point(x,y);
 117     }
 118 }
 119
 120 class StreamOnZipBuffer : public IStream
 121 {
 122 public:
 123     StreamOnZipBuffer(const ZipFile::ZipContentBuffer_t& zip_buffer);
 124
 125     // IUnknown
 126     virtual ULONG STDMETHODCALLTYPE AddRef();
 127     virtual ULONG STDMETHODCALLTYPE Release();
 128     virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void __RPC_FAR *__RPC_FAR *ppvObject);
 129
 130     // IStream
 131     virtual HRESULT STDMETHODCALLTYPE Read(void *pv, ULONG cb, ULONG *pcbRead);
 132     virtual HRESULT STDMETHODCALLTYPE Write(void const *pv, ULONG cb, ULONG *pcbWritten);
 133     virtual HRESULT STDMETHODCALLTYPE Seek(LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition);
 134     virtual HRESULT STDMETHODCALLTYPE SetSize(ULARGE_INTEGER libNewSize);
 135     virtual HRESULT STDMETHODCALLTYPE CopyTo(IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten);
 136     virtual HRESULT STDMETHODCALLTYPE Commit(DWORD grfCommitFlags);
 137     virtual HRESULT STDMETHODCALLTYPE Revert();
 138     virtual HRESULT STDMETHODCALLTYPE LockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType);
 139     virtual HRESULT STDMETHODCALLTYPE UnlockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType);
 140     virtual HRESULT STDMETHODCALLTYPE Stat(STATSTG *pstatstg, DWORD grfStatFlag);
 141     virtual HRESULT STDMETHODCALLTYPE Clone(IStream **ppstm);
 142
 143 private:
 144     LONG ref_count_;
 145     const ZipFile::ZipContentBuffer_t& ref_zip_buffer_;
 146     size_t pos_;
 147 };
 148
 149 StreamOnZipBuffer::StreamOnZipBuffer(const ZipFile::ZipContentBuffer_t& zip_buffer) :
 150     ref_count_(1),
 151     ref_zip_buffer_(zip_buffer),
 152     pos_(0)
 153 {
 154 }
 155
 156 // IUnknown methods
 157
 158 ULONG STDMETHODCALLTYPE StreamOnZipBuffer::AddRef()
 159 {
 160     return InterlockedIncrement(&ref_count_);
 161 }
 162
 163 ULONG STDMETHODCALLTYPE StreamOnZipBuffer::Release()
 164 {
 165     long refcnt = InterlockedDecrement(&ref_count_);
 166
 167     if (0 == ref_count_)
 168         delete this;
 169
 170     return refcnt;
 171 }
 172
 173 HRESULT STDMETHODCALLTYPE StreamOnZipBuffer::QueryInterface(REFIID riid, void __RPC_FAR *__RPC_FAR *ppvObject)
 174 {
 175     *ppvObject = 0;
 176     IUnknown* pUnk = 0;
 177
 178     if ((IID_IUnknown == riid) || (IID_IStream == riid))
 179     {
 180         pUnk = static_cast<IStream*>(this);
 181         pUnk->AddRef();
 182         *ppvObject = pUnk;
 183         return S_OK;
 184     }
 185     return E_NOINTERFACE;
 186 }
 187
 188 HRESULT STDMETHODCALLTYPE StreamOnZipBuffer::Read(void *pv, ULONG cb, ULONG *pcbRead)
 189 {
 190     if (pv == NULL)
 191         return STG_E_INVALIDPOINTER;
 192
 193     size_t size = ref_zip_buffer_.size();
 194
 195     if (pos_ > size)
 196         return S_FALSE;
 197
 198     char* p = reinterpret_cast<char*>(pv);
 199     ULONG read = 0;
 200
 201     for ( ;(pos_ < size) && (cb > 0); pos_++, cb--, read++)
 202         *p++ = ref_zip_buffer_[pos_];
 203
 204     if (pcbRead)
 205         *pcbRead = read;
 206
 207     return S_OK;
 208 }
 209
 210 HRESULT STDMETHODCALLTYPE StreamOnZipBuffer::Seek(LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *)
 211 {
 212     __int64 size = (__int64) ref_zip_buffer_.size();
 213     __int64 p = 0;
 214
 215     switch (dwOrigin)
 216     {
 217         case STREAM_SEEK_SET:
 218             break;
 219         case STREAM_SEEK_CUR:
 220             p = (__int64) pos_;
 221             break;
 222         case STREAM_SEEK_END:
 223             p = size - 1;
 224             break;
 225    }
 226
 227    HRESULT hr = STG_E_INVALIDFUNCTION;
 228
 229    p += dlibMove.QuadPart;
 230
 231    if ( ( p >= 0 ) && (p < size) )
 232    {
 233         pos_ = (size_t) p;
 234         hr = S_OK;
 235    }
 236    return hr;
 237 }
 238
 239 HRESULT STDMETHODCALLTYPE StreamOnZipBuffer::Stat(STATSTG *pstatstg, DWORD grfStatFlag)
 240 {
 241     if (pstatstg == NULL)
 242         return STG_E_INVALIDPOINTER;
 243
 244     ZeroMemory(pstatstg, sizeof(STATSTG));
 245
 246     if (grfStatFlag == STATFLAG_DEFAULT)
 247     {
 248         size_t sz = 4 * sizeof(wchar_t);
 249         wchar_t* name = reinterpret_cast<wchar_t*>(CoTaskMemAlloc(sz));
 250         ZeroMemory(name, sz);
 251         memcpy(name, L"png", 3 * sizeof(wchar_t));
 252         pstatstg->pwcsName = name;
 253     }
 254
 255     pstatstg->type = STGTY_LOCKBYTES;
 256
 257     ULARGE_INTEGER uli;
 258     uli.LowPart = static_cast<DWORD>(ref_zip_buffer_.size());
 259     uli.HighPart = 0;
 260
 261     pstatstg->cbSize = uli;
 262
 263     return S_OK;
 264 }
 265
 266 HRESULT STDMETHODCALLTYPE StreamOnZipBuffer::Write(void const *, ULONG, ULONG *)
 267 { return E_NOTIMPL; }
 268
 269 HRESULT STDMETHODCALLTYPE StreamOnZipBuffer::SetSize(ULARGE_INTEGER)
 270 { return E_NOTIMPL; }
 271
 272 HRESULT STDMETHODCALLTYPE StreamOnZipBuffer::CopyTo(IStream *, ULARGE_INTEGER, ULARGE_INTEGER *, ULARGE_INTEGER *)
 273 { return E_NOTIMPL; }
 274
 275 HRESULT STDMETHODCALLTYPE StreamOnZipBuffer::Commit(DWORD)
 276 { return E_NOTIMPL; }
 277
 278 HRESULT STDMETHODCALLTYPE StreamOnZipBuffer::Revert()
 279 { return E_NOTIMPL; }
 280
 281 HRESULT STDMETHODCALLTYPE StreamOnZipBuffer::LockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD)
 282 { return E_NOTIMPL; }
 283
 284 HRESULT STDMETHODCALLTYPE StreamOnZipBuffer::UnlockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD)
 285 { return E_NOTIMPL; }
 286
 287 HRESULT STDMETHODCALLTYPE StreamOnZipBuffer::Clone(IStream **)
 288 {  return E_NOTIMPL; }
 289
 290
 291
 292
 293 CThumbviewer::CThumbviewer(long RefCnt) :
 294     ref_count_(RefCnt)
 295 {
 296     InterlockedIncrement(&g_DllRefCnt);
 297
 298     thumbnail_size_.cx = 0;
 299     thumbnail_size_.cy = 0;
 300
 301     Gdiplus::GdiplusStartupInput gdiplusStartupInput;
 302     Gdiplus::GdiplusStartup(&gdiplus_token_, &gdiplusStartupInput, NULL);
 303
 304     ZipFile::ZipContentBuffer_t img_data;
 305     internal::LoadSignetImageFromResource(img_data);
 306     IStream* stream = new StreamOnZipBuffer(img_data);
 307     signet_ = new Gdiplus::Bitmap(stream, TRUE);
 308     stream->Release();
 309 }
 310
 311 CThumbviewer::~CThumbviewer()
 312 {
 313     delete signet_;
 314     Gdiplus::GdiplusShutdown(gdiplus_token_);
 315     InterlockedDecrement(&g_DllRefCnt);
 316 }
 317
 318 // IUnknown methods
 319
 320 HRESULT STDMETHODCALLTYPE CThumbviewer::QueryInterface(REFIID riid, void __RPC_FAR *__RPC_FAR *ppvObject)
 321 {
 322     *ppvObject = 0;
 323     IUnknown* pUnk = 0;
 324
 325     if ((IID_IUnknown == riid) || (IID_IPersistFile == riid))
 326     {
 327         pUnk = static_cast<IPersistFile*>(this);
 328         pUnk->AddRef();
 329         *ppvObject = pUnk;
 330         return S_OK;
 331     }
 332     else if (IID_IExtractImage == riid)
 333     {
 334         pUnk = static_cast<IExtractImage*>(this);
 335         pUnk->AddRef();
 336         *ppvObject = pUnk;
 337         return S_OK;
 338     }
 339     return E_NOINTERFACE;
 340 }
 341
 342 ULONG STDMETHODCALLTYPE CThumbviewer::AddRef()
 343 {
 344     return InterlockedIncrement(&ref_count_);
 345 }
 346
 347 ULONG STDMETHODCALLTYPE CThumbviewer::Release()
 348 {
 349     long refcnt = InterlockedDecrement(&ref_count_);
 350
 351     if (0 == ref_count_)
 352         delete this;
 353
 354     return refcnt;
 355 }
 356
 357 // IExtractImage2 methods
 358
 359 const std::string THUMBNAIL_CONTENT = "Thumbnails/thumbnail.png";
 360
 361 HRESULT STDMETHODCALLTYPE CThumbviewer::Extract(HBITMAP *phBmpImage)
 362 {
 363     HRESULT hr = E_FAIL;
 364
 365     try
 366     {
 367         std::wstring fname = getShortPathName( filename_ );
 368         std::unique_ptr<ZipFile> zipfile( new ZipFile( WStringToString( fname ) ) );
 369
 370         if (zipfile->HasContent(THUMBNAIL_CONTENT))
 371         {
 372             ZipFile::ZipContentBuffer_t thumbnail;
 373             zipfile->GetUncompressedContent(THUMBNAIL_CONTENT, thumbnail);
 374             IStream* stream = new StreamOnZipBuffer(thumbnail);
 375
 376             Gdiplus::Bitmap thumbnail_png(stream, TRUE);
 377
 378             if ((thumbnail_png.GetHeight() == 0) || (thumbnail_png.GetWidth() == 0))
 379             {
 380                 stream->Release();
 381                 return E_FAIL;
 382             }
 383
 384             HWND hwnd = GetDesktopWindow();
 385             HDC hdc = GetDC(hwnd);
 386             HDC memDC = CreateCompatibleDC(hdc);
 387
 388             if (memDC)
 389             {
 390                 UINT offset = 3; // reserve a little border space
 391
 392                 Gdiplus::Rect canvas(0, 0, thumbnail_size_.cx, thumbnail_size_.cy);
 393                 Gdiplus::Rect canvas_thumbnail(offset, offset, thumbnail_size_.cx - 2 * offset, thumbnail_size_.cy - 2 * offset);
 394
 395                 Gdiplus::Rect scaledRect = CalcScaledAspectRatio(
 396                     Gdiplus::Rect(0, 0, thumbnail_png.GetWidth(), thumbnail_png.GetHeight()), canvas_thumbnail);
 397
 398                 struct {
 399                     BITMAPINFOHEADER bi;
 400                     DWORD ct[256];
 401                 } dib;
 402
 403                 ZeroMemory(&dib, sizeof(dib));
 404
 405                 dib.bi.biSize = sizeof(BITMAPINFOHEADER);
 406                 dib.bi.biWidth = thumbnail_size_.cx;
 407                 dib.bi.biHeight = thumbnail_size_.cy;
 408                 dib.bi.biPlanes = 1;
 409                 dib.bi.biBitCount = static_cast<WORD>(color_depth_);
 410                 dib.bi.biCompression = BI_RGB;
 411
 412                 LPVOID lpBits;
 413                 HBITMAP hMemBmp = CreateDIBSection(memDC, (LPBITMAPINFO)&dib, DIB_RGB_COLORS, &lpBits, NULL, 0);
 414                 HGDIOBJ hOldObj = SelectObject(memDC, hMemBmp);
 415
 416                 Gdiplus::Graphics graphics(memDC);
 417                 Gdiplus::Pen blackPen(Gdiplus::Color(255, 0, 0, 0), 1);
 418
 419                 Gdiplus::SolidBrush whiteBrush(Gdiplus::Color(255, 255, 255, 255));
 420                 graphics.FillRectangle(&whiteBrush, canvas);
 421
 422                 scaledRect.X = (canvas.Width - scaledRect.Width) / 2;
 423                 scaledRect.Y = (canvas.Height - scaledRect.Height) / 2;
 424
 425                 Gdiplus::Rect border_rect(scaledRect.X, scaledRect.Y, scaledRect.Width, scaledRect.Height);
 426                 graphics.DrawRectangle(&blackPen, border_rect);
 427
 428                 scaledRect.X += 1;
 429                 scaledRect.Y += 1;
 430                 scaledRect.Width -= 1;
 431                 scaledRect.Height -= 1;
 432
 433                 graphics.SetInterpolationMode(Gdiplus::InterpolationModeHighQualityBicubic);
 434                 Gdiplus::Status stat = graphics.DrawImage(
 435                     &thumbnail_png, scaledRect, 0 , 0,
 436                     thumbnail_png.GetWidth(), thumbnail_png.GetHeight(), Gdiplus::UnitPixel);
 437
 438                 /* Add a signet sign to the thumbnail of signed documents */
 439                 if (internal::IsSignedDocument(zipfile.get()))
 440                 {
 441                     double SCALING_FACTOR = 0.6;
 442                     Gdiplus::Rect signet_scaled(
 443                         0, 0, static_cast<INT>(signet_->GetWidth() * SCALING_FACTOR), static_cast<INT>(signet_->GetHeight() * SCALING_FACTOR));
 444                     Gdiplus::Point pos_signet = internal::CalcSignetPosition(canvas_thumbnail, border_rect, signet_scaled);
 445                     Gdiplus::Rect dest(pos_signet.X, pos_signet.Y, signet_scaled.GetRight(), signet_scaled.GetBottom());
 446
 447                     stat = graphics.DrawImage(
 448                         signet_, dest,
 449                         0, 0, signet_->GetWidth(), signet_->GetHeight(),
 450                         Gdiplus::UnitPixel);
 451                 }
 452
 453                 if (stat == Gdiplus::Ok)
 454                 {
 455                     *phBmpImage = hMemBmp;
 456                     hr = NOERROR;
 457                 }
 458
 459                 SelectObject(memDC, hOldObj);
 460                 DeleteDC(memDC);
 461             }
 462
 463             ReleaseDC(hwnd, hdc);
 464             stream->Release();
 465         }
 466     }
 467     catch(std::exception&)
 468     {
 469         OutputDebugStringFormat( "CThumbviewer Extract ERROR!\n" );
 470         hr = E_FAIL;
 471     }
 472     return hr;
 473 }
 474
 475 HRESULT STDMETHODCALLTYPE CThumbviewer::GetLocation(
 476     LPWSTR pszPathBuffer, DWORD cchMax, DWORD *pdwPriority, const SIZE *prgSize, DWORD dwRecClrDepth, DWORD *pdwFlags)
 477 {
 478     if ((prgSize == NULL) || (pdwFlags == NULL) || ((*pdwFlags & IEIFLAG_ASYNC) && (pdwPriority == NULL)))
 479         return E_INVALIDARG;
 480
 481     thumbnail_size_ = *prgSize;
 482     color_depth_ = dwRecClrDepth;
 483
 484     *pdwFlags = IEIFLAG_CACHE; // we don't cache the image
 485
 486     wcsncpy(pszPathBuffer, filename_.c_str(), cchMax);
 487
 488     return NOERROR;
 489 }
 490
 491 // IPersist methods
 492
 493 HRESULT STDMETHODCALLTYPE CThumbviewer::GetClassID(CLSID* pClassID)
 494 {
 495     pClassID = const_cast<CLSID*>(&CLSID_THUMBVIEWER_HANDLER);
 496     return S_OK;
 497 }
 498
 499 // IPersistFile methods
 500
 501 HRESULT STDMETHODCALLTYPE CThumbviewer::Load(LPCOLESTR pszFileName, DWORD)
 502 {
 503     filename_ = pszFileName;
 504     return S_OK;
 505 }
 506
 507 HRESULT STDMETHODCALLTYPE CThumbviewer::IsDirty()
 508 { return E_NOTIMPL; }
 509
 510 HRESULT STDMETHODCALLTYPE CThumbviewer::Save(LPCOLESTR, BOOL)
 511 { return E_NOTIMPL; }
 512
 513 HRESULT STDMETHODCALLTYPE CThumbviewer::SaveCompleted(LPCOLESTR)
 514 { return E_NOTIMPL; }
 515
 516 HRESULT STDMETHODCALLTYPE CThumbviewer::GetCurFile(LPOLESTR __RPC_FAR*)
 517 { return E_NOTIMPL; }
 518
 519
 520 Gdiplus::Rect CThumbviewer::CalcScaledAspectRatio(const Gdiplus::Rect& src, const Gdiplus::Rect& dest)
 521 {
 522     Gdiplus::Rect result;
 523     if (src.Width >= src.Height)
 524         result = Gdiplus::Rect(0, 0, dest.Width, src.Height * dest.Width / src.Width);
 525     else
 526         result = Gdiplus::Rect(0, 0, src.Width * dest.Height / src.Height, dest.Height);
 527
 528     return result;
 529 }
 530
 531 #endif // DONT_HAVE_GDIPLUS
 532
 533 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */