fpicker/source/win32/filepicker/dibpreview.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: dibpreview.cxx,v $
  10  * $Revision: 1.12 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_fpicker.hxx"
  33
  34 //------------------------------------------------------------------------
  35 // includes
  36 //------------------------------------------------------------------------
  37
  38 #include <tchar.h>
  39 #include "dibpreview.hxx"
  40 #include <osl/diagnose.h>
  41
  42 #ifndef _COM_SUN_STAR_UI_DIALOG_FILEPREVIEWIMAGEFORMATS_HPP_
  43 #include <com/sun/star/ui/dialogs/FilePreviewImageFormats.hpp>
  44 #endif
  45
  46 #ifndef _USTRING_HXX_
  47 #include <rtl/ustring.hxx>
  48 #endif
  49
  50 #include <stdexcept>
  51 #include <string>
  52
  53 //------------------------------------------------------------------------
  54 //
  55 //------------------------------------------------------------------------
  56
  57 using ::com::sun::star::uno::Sequence;
  58 using ::com::sun::star::uno::RuntimeException;
  59 using ::com::sun::star::uno::Any;
  60 using ::com::sun::star::lang::IllegalArgumentException;
  61 using rtl::OUString;
  62
  63 //------------------------------------------------------------------------
  64 //
  65 //------------------------------------------------------------------------
  66
  67 namespace /* private */
  68 {
  69     const LPTSTR CURRENT_INSTANCE = TEXT("CurrInst");
  70 };
  71
  72 //------------------------------------------------------------------------
  73 // defines
  74 //------------------------------------------------------------------------
  75
  76 #define PREVIEWWND_CLASS_NAME TEXT("DIBPreviewWnd###")
  77
  78 // means 3 pixel left and 3 pixel right
  79 #define HORZ_BODER_SPACE    6
  80
  81 // means 3 pixel top and 3 pixel bottom
  82 #define VERT_BORDER_SPACE   6
  83
  84 //---------------------------------------------------
  85 // static member initialization
  86 //---------------------------------------------------
  87
  88 osl::Mutex CDIBPreview::s_Mutex;
  89 ATOM CDIBPreview::s_ClassAtom = 0;
  90 sal_Int32 CDIBPreview::s_RegisterDibPreviewWndCount = 0;
  91
  92 //---------------------------------------------------
  93 //
  94 //---------------------------------------------------
  95
  96 CDIBPreview::CDIBPreview(HINSTANCE instance,HWND parent,sal_Bool bShowWindow) :
  97     m_Instance(instance)
  98 {
  99     RegisterDibPreviewWindowClass();
 100
 101     DWORD dwStyle = WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
 102
 103     if (bShowWindow)
 104         dwStyle |= WS_VISIBLE;
 105
 106     m_Hwnd = CreateWindowEx(
 107         WS_EX_CLIENTEDGE,
 108         PREVIEWWND_CLASS_NAME,
 109         TEXT(""),
 110         dwStyle,
 111         0, 0, 0, 0,
 112         parent,
 113         (HMENU)0x0, // for child windows this will
 114                     // be used as child window identifier
 115         m_Instance,
 116         (LPVOID)this // pass a pointer to the current
 117                      // instance of this class
 118     );
 119
 120     bool bSuccess = IsWindow(m_Hwnd);
 121
 122     OSL_POSTCOND(bSuccess,"Coud not create preview window");
 123
 124     if (!bSuccess)
 125     {
 126         UnregisterDibPreviewWindowClass();
 127         throw std::runtime_error("Could not create preview window");
 128     }
 129 }
 130
 131 //---------------------------------------------------
 132 //
 133 //---------------------------------------------------
 134
 135 CDIBPreview::~CDIBPreview( )
 136 {
 137     // remember: we don't have to destroy the
 138     // preview window because it will be destroyed
 139     // by it's parent window (the FileOpen dialog)
 140     // but we have to unregister the window class
 141     //if ( m_bWndClassRegistered )
 142     UnregisterDibPreviewWindowClass();
 143 }
 144
 145 //-------------------------------
 146 //
 147 //-------------------------------
 148
 149 sal_Int32 SAL_CALL CDIBPreview::getTargetColorDepth() throw (RuntimeException)
 150 {
 151     HDC hdc = GetDC(m_Hwnd);
 152     int clrRes = 0;
 153
 154     if (hdc)
 155         clrRes = GetDeviceCaps(hdc, COLORRES);
 156
 157     return clrRes;
 158 }
 159
 160 //-------------------------------
 161 //
 162 //-------------------------------
 163
 164 sal_Int32 SAL_CALL CDIBPreview::getAvailableWidth() throw (RuntimeException)
 165 {
 166     RECT rect;
 167     bool bRet = GetClientRect(m_Hwnd,&rect);
 168
 169     sal_Int32 cx = 0;
 170
 171     if ( bRet )
 172         cx = rect.right;
 173
 174     return cx;
 175 }
 176
 177 //-------------------------------
 178 //
 179 //-------------------------------
 180
 181 sal_Int32 SAL_CALL CDIBPreview::getAvailableHeight() throw (RuntimeException)
 182 {
 183     RECT rect;
 184     bool bRet = GetClientRect(m_Hwnd,&rect);
 185
 186     sal_Int32 cy = 0;
 187
 188     if ( bRet )
 189         cy = rect.bottom;
 190
 191     return cy;
 192 }
 193
 194 //-------------------------------
 195 //
 196 //-------------------------------
 197
 198 void SAL_CALL CDIBPreview::setImage(sal_Int16 aImageFormat, const Any& aImage)
 199     throw (IllegalArgumentException, RuntimeException)
 200 {
 201     PreviewBase::setImage(aImageFormat,aImage);
 202
 203     // if the any has no value we have an
 204     // empty Sequence which clears the
 205     // preview window
 206     osl::ClearableMutexGuard aGuard(m_PaintLock);
 207
 208     m_Image.realloc(0);
 209     m_ImageData >>= m_Image;
 210
 211     aGuard.clear();
 212
 213     InvalidateRect(m_Hwnd,NULL,FALSE);
 214     UpdateWindow(m_Hwnd);
 215 }
 216
 217 //-------------------------------
 218 //
 219 //-------------------------------
 220
 221 sal_Bool SAL_CALL CDIBPreview::setShowState(sal_Bool bShowState) throw (RuntimeException)
 222 {
 223     PreviewBase::setShowState(bShowState);
 224     ShowWindow(m_Hwnd, m_bShowState ? SW_SHOW : SW_HIDE);
 225     return sal_True;
 226 }
 227
 228 //-------------------------------
 229 //
 230 //-------------------------------
 231
 232 sal_Bool SAL_CALL CDIBPreview::getShowState() throw (RuntimeException)
 233 {
 234     return (sal_Bool)IsWindowVisible(m_Hwnd);
 235 }
 236
 237 //-------------------------------
 238 //
 239 //-------------------------------
 240
 241 HWND SAL_CALL CDIBPreview::getWindowHandle() const
 242 {
 243     return m_Hwnd;
 244 }
 245
 246 //---------------------------------------------------
 247 //
 248 //---------------------------------------------------
 249
 250 void SAL_CALL CDIBPreview::onPaint(HWND hWnd, HDC hDC)
 251 {
 252     BITMAPFILEHEADER*  pbmfh;
 253     BITMAPINFO      *  pbmi;
 254     BYTE            *  pBits;
 255     int                cxDib;
 256     int                cyDib;
 257
 258     osl::MutexGuard aGuard(m_PaintLock);
 259
 260     try
 261     {
 262         pbmfh = reinterpret_cast<BITMAPFILEHEADER*>(m_Image.getArray());
 263
 264         if ( !IsBadReadPtr( pbmfh, sizeof(BITMAPFILEHEADER)) &&
 265              (pbmfh->bfType == ('B' | ('M' << 8))) )
 266         {
 267             pbmi  = reinterpret_cast<BITMAPINFO*>((pbmfh + 1));
 268             pBits = reinterpret_cast<BYTE*>(((DWORD)pbmfh) + pbmfh->bfOffBits);
 269
 270             cxDib =      pbmi->bmiHeader.biWidth;
 271             cyDib = abs (pbmi->bmiHeader.biHeight);
 272
 273             SetStretchBltMode(hDC, COLORONCOLOR);
 274
 275             int nWidth  = getAvailableWidth();
 276             int nHeight = getAvailableHeight();
 277
 278             int nX = abs(nWidth - cxDib) / 2;
 279             int nY = abs(nHeight - cyDib) / 2;
 280
 281             int GDIError = GDI_ERROR;
 282             GDIError = StretchDIBits(
 283                 hDC, nX, nY, cxDib, cyDib,
 284                 0, 0, cxDib, cyDib, pBits, pbmi,
 285                 DIB_RGB_COLORS, SRCCOPY);
 286
 287             OSL_ASSERT(GDI_ERROR != GDIError);
 288
 289             // paint the border
 290             RECT rc;
 291
 292             if (nY > 0)
 293             {
 294                 // top
 295                 rc.left   = 0;
 296                 rc.top    = 0;
 297                 rc.right  = nWidth;
 298                 rc.bottom = nY;
 299                 FillRect(hDC,&rc,(HBRUSH)(COLOR_INACTIVEBORDER + 1));
 300
 301                 // bottom
 302                 rc.left   = 0;
 303                 rc.top    = nHeight - nY - 1;
 304                 rc.right  = nWidth;
 305                 rc.bottom = nHeight;
 306                 FillRect(hDC,&rc,(HBRUSH)(COLOR_INACTIVEBORDER + 1));
 307             }
 308
 309             if (nX > 0)
 310             {
 311                 // left
 312                 rc.left   = 0;
 313                 rc.top    = nY;
 314                 rc.right  = nX;
 315                 rc.bottom = nHeight - nY;
 316                 FillRect(hDC,&rc,(HBRUSH)(COLOR_INACTIVEBORDER + 1));
 317
 318                 // right
 319                 rc.left   = nWidth - nX - 1;
 320                 rc.top    = nY;
 321                 rc.right  = nWidth;
 322                 rc.bottom = nHeight - nY;
 323                 FillRect(hDC,&rc,(HBRUSH)(COLOR_INACTIVEBORDER + 1));
 324             }
 325         }
 326         else // clear background
 327         {
 328             RECT rc;
 329             GetClientRect(hWnd,&rc);
 330             FillRect(hDC,&rc,(HBRUSH)(COLOR_INACTIVEBORDER + 1));
 331         }
 332     }
 333     catch(...)
 334     {
 335         OSL_ASSERT(sal_False);
 336     }
 337 }
 338
 339 //---------------------------------------------------
 340 //
 341 //---------------------------------------------------
 342
 343 LRESULT CALLBACK CDIBPreview::WndProc(
 344     HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 345 {
 346     LRESULT lResult = 0;
 347
 348     switch(uMsg)
 349     {
 350
 351     // we connect a pointer to the current instance
 352     // with a window instance via SetProp
 353     case WM_CREATE:
 354         {
 355             LPCREATESTRUCT lpcs =
 356                 reinterpret_cast< LPCREATESTRUCT >(lParam);
 357
 358             OSL_ASSERT(lpcs->lpCreateParams);
 359
 360             // connect the instance handle to the window
 361             SetProp(hWnd, CURRENT_INSTANCE, lpcs->lpCreateParams);
 362         }
 363         break;
 364
 365     // we remove the window property which connects
 366     // a class instance with a window class
 367     case WM_NCDESTROY:
 368         {
 369             // RemoveProp returns the saved value on success
 370             if (reinterpret_cast<CDIBPreview*>(
 371                     RemoveProp(hWnd, CURRENT_INSTANCE)) == NULL)
 372             {
 373                 OSL_ASSERT(false);
 374             }
 375         }
 376         break;
 377
 378     case WM_PAINT:
 379     {
 380         CDIBPreview* pImpl = reinterpret_cast<CDIBPreview*>(
 381             GetProp(hWnd, CURRENT_INSTANCE));
 382
 383         OSL_ASSERT(pImpl);
 384
 385         HDC         hDC;
 386         PAINTSTRUCT ps;
 387
 388         hDC = BeginPaint(hWnd,&ps);
 389         pImpl->onPaint(hWnd,hDC);
 390         EndPaint(hWnd,&ps);
 391     }
 392     break;
 393
 394     // ignore this message in order to
 395     // avoid flickering during paint
 396     case WM_ERASEBKGND:
 397         lResult = 1;
 398         break;
 399
 400     default:
 401         return DefWindowProc(hWnd, uMsg, wParam, lParam);
 402     }
 403
 404     return lResult;
 405 }
 406
 407 //---------------------------------------------------
 408 //
 409 //---------------------------------------------------
 410
 411 ATOM SAL_CALL CDIBPreview::RegisterDibPreviewWindowClass()
 412 {
 413     osl::MutexGuard aGuard( s_Mutex );
 414
 415     if (0 == s_ClassAtom)
 416     {
 417         // register the preview window class
 418         WNDCLASSEX wndClsEx;
 419         ZeroMemory(&wndClsEx, sizeof(wndClsEx));
 420
 421         wndClsEx.cbSize        = sizeof(wndClsEx);
 422         wndClsEx.style             = CS_HREDRAW | CS_VREDRAW;
 423         wndClsEx.lpfnWndProc   = CDIBPreview::WndProc;
 424         wndClsEx.hInstance     = m_Instance;
 425         wndClsEx.hbrBackground = (HBRUSH)(COLOR_INACTIVEBORDER + 1);
 426         wndClsEx.lpszClassName = PREVIEWWND_CLASS_NAME;
 427
 428         // register the preview window class
 429         // !!! Win95 -   the window class will be unregistered automaticly
 430         //                           if the dll is unloaded
 431         //     Win2000 - the window class must be unregistered manually
 432         //                               if the dll is unloaded
 433         s_ClassAtom = RegisterClassEx(&wndClsEx);
 434
 435         OSL_POSTCOND(s_ClassAtom,"Could  not register preview window class");
 436
 437         if (0 == s_ClassAtom)
 438             throw std::runtime_error("Preview window class could not be registered");
 439     }
 440
 441     // increment the register class counter
 442     // so that we keep track of the number
 443     // of class registrations
 444     //if ( 0 != s_ClassAtom )
 445     s_RegisterDibPreviewWndCount++;
 446
 447     return s_ClassAtom;
 448 }
 449
 450 //---------------------------------------------------
 451 //
 452 //---------------------------------------------------
 453
 454 void SAL_CALL CDIBPreview::UnregisterDibPreviewWindowClass()
 455 {
 456     osl::MutexGuard aGuard( s_Mutex );
 457
 458     OSL_ASSERT( ( (0 != s_ClassAtom) && (s_RegisterDibPreviewWndCount > 0)) ||
 459                 ( (0 == s_ClassAtom) && (0 == s_RegisterDibPreviewWndCount) ) );
 460
 461     // update the register class counter
 462     // and unregister the window class if
 463     // counter drops to zero
 464     if (0 != s_ClassAtom)
 465     {
 466         s_RegisterDibPreviewWndCount--;
 467         OSL_ASSERT(s_RegisterDibPreviewWndCount >= 0);
 468     }
 469
 470     if (0 == s_RegisterDibPreviewWndCount)
 471     {
 472         UnregisterClass((LPCTSTR)MAKELONG(s_ClassAtom,0),m_Instance);
 473         s_ClassAtom = 0;
 474     }
 475 }