fpicker/source/win32/filepicker/FileOpenDlg.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: FileOpenDlg.cxx,v $
  10  * $Revision: 1.17 $
  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 <osl/diagnose.h>
  40 #include "../misc/WinImplHelper.hxx"
  41 #include "FileOpenDlg.hxx"
  42
  43 //------------------------------------------------------------------------
  44 // constants
  45 //------------------------------------------------------------------------
  46
  47 namespace /* private */
  48 {
  49     // we choose such large buffers because the size of
  50     // an single line edit field can be up to 32k; if
  51     // a user has a multi selection FilePicker and selects
  52     // a lot of files in a large directory we may reach this
  53     // limit and don't want to get out of memory;
  54     // another much more elegant way would be to subclass the
  55     // FileOpen dialog and overload the BM_CLICK event of the
  56     // OK button so that we determine the size of the text
  57     // currently in the edit field and resize our buffer
  58     // appropriately - in the future we will do this
  59     const size_t MAX_FILENAME_BUFF_SIZE  = 32000;
  60     const size_t MAX_FILETITLE_BUFF_SIZE = 32000;
  61     const size_t MAX_FILTER_BUFF_SIZE    = 4096;
  62
  63     const LPTSTR CURRENT_INSTANCE = TEXT("CurrInst");
  64
  65     //------------------------------------------
  66     // find an appropriate parent window
  67     //------------------------------------------
  68
  69     inline bool is_current_process_window(HWND hwnd)
  70     {
  71         DWORD pid;
  72         GetWindowThreadProcessId(hwnd, &pid);
  73         return (pid == GetCurrentProcessId());
  74     }
  75
  76     HWND choose_parent_window()
  77     {
  78         HWND hwnd_parent = GetForegroundWindow();
  79         if (!is_current_process_window(hwnd_parent))
  80             hwnd_parent = GetDesktopWindow();
  81
  82         return hwnd_parent;
  83     }
  84 };
  85
  86 //------------------------------------------------------------------------
  87 //
  88 //------------------------------------------------------------------------
  89
  90 CFileOpenDialog::CFileOpenDialog(
  91     bool bFileOpenDialog,
  92     sal_uInt32 dwFlags,
  93     sal_uInt32 dwTemplateId,
  94     HINSTANCE hInstance) :
  95     m_hwndFileOpenDlg(0),
  96     m_hwndFileOpenDlgChild(0),
  97     m_bFileOpenDialog(bFileOpenDialog),
  98     m_filterBuffer(MAX_FILTER_BUFF_SIZE),
  99     m_fileTitleBuffer(MAX_FILETITLE_BUFF_SIZE),
 100     m_helperBuffer(MAX_FILENAME_BUFF_SIZE),
 101     m_fileNameBuffer(MAX_FILENAME_BUFF_SIZE),
 102     m_pfnBaseDlgProc(0)
 103 {
 104     // initialize the OPENFILENAME struct
 105     if (IsWindows2000Platform() || IsWindowsME())
 106     {
 107         ZeroMemory(&m_ofn, sizeof(m_ofn));
 108         m_ofn.lStructSize = sizeof(m_ofn);
 109     }
 110     else // OSVER < Win2000
 111     {
 112         // the size of the OPENFILENAME structure is different
 113         // under windows < win2000
 114         ZeroMemory(&m_ofn, _OPENFILENAME_SIZE_VERSION_400);
 115         m_ofn.lStructSize = _OPENFILENAME_SIZE_VERSION_400;
 116     }
 117
 118     // 0x02000000 for #97681, sfx will make the entry into
 119     // the recent document list
 120     m_ofn.Flags |= dwFlags |
 121                    OFN_EXPLORER |
 122                    OFN_ENABLEHOOK |
 123                    OFN_HIDEREADONLY |
 124                    OFN_PATHMUSTEXIST |
 125                    OFN_FILEMUSTEXIST |
 126                    OFN_OVERWRITEPROMPT |
 127                    OFN_ENABLESIZING |
 128                    OFN_DONTADDTORECENT; // 0x02000000 -> OFN_DONTADDTORECENT only available with new platform sdk
 129
 130     // it is a little hack but how else could
 131     // we get a parent window (using a vcl window?)
 132     m_ofn.hwndOwner = choose_parent_window();
 133
 134     m_ofn.lpstrFile = reinterpret_cast<LPTSTR>(const_cast<sal_Unicode*>(m_fileNameBuffer.getStr()));
 135     m_ofn.nMaxFile  = m_fileNameBuffer.getCapacity();
 136
 137     m_ofn.lpstrFileTitle = reinterpret_cast<LPTSTR>(const_cast<sal_Unicode*>(m_fileTitleBuffer.getStr()));
 138     m_ofn.nMaxFileTitle  = m_fileTitleBuffer.getCapacity();
 139
 140     m_ofn.lpfnHook = CFileOpenDialog::ofnHookProc;
 141
 142     // set a custom template
 143
 144     if (dwTemplateId)
 145     {
 146         OSL_ASSERT(hInstance);
 147
 148         m_ofn.Flags          |= OFN_ENABLETEMPLATE;
 149         m_ofn.lpTemplateName  = MAKEINTRESOURCE(dwTemplateId);
 150         m_ofn.hInstance       = hInstance;
 151     }
 152
 153     // set a pointer to myself as ofn parameter
 154     m_ofn.lCustData = reinterpret_cast<long>(this);
 155 }
 156
 157 //------------------------------------------------------------------------
 158 //
 159 //------------------------------------------------------------------------
 160
 161 CFileOpenDialog::~CFileOpenDialog()
 162 {
 163 }
 164
 165 //------------------------------------------------------------------------
 166 //
 167 //------------------------------------------------------------------------
 168
 169 void SAL_CALL CFileOpenDialog::setTitle(const rtl::OUString& aTitle)
 170 {
 171     m_dialogTitle = aTitle;
 172     m_ofn.lpstrTitle = reinterpret_cast<LPCTSTR>(m_dialogTitle.getStr());
 173 }
 174
 175 //------------------------------------------------------------------------
 176 //
 177 //------------------------------------------------------------------------
 178
 179 void CFileOpenDialog::setFilter(const rtl::OUString& aFilter)
 180 {
 181     // Format is like
 182     // "*.TXT" or multiple separate by ';' like "*.TXT;*.DOC;*.SXW"
 183     // Do not include spaces in the pattern string
 184     m_filterBuffer.ensureCapacity(aFilter.getLength());
 185     m_filterBuffer.setLength(0);
 186     m_filterBuffer.append(aFilter);
 187     m_ofn.lpstrFilter = reinterpret_cast<LPCTSTR>(m_filterBuffer.getStr());
 188 }
 189
 190 //------------------------------------------------------------------------
 191 //
 192 //------------------------------------------------------------------------
 193
 194 bool CFileOpenDialog::setFilterIndex(sal_uInt32 aIndex)
 195 {
 196     OSL_ASSERT(aIndex > 0);
 197     m_ofn.nFilterIndex = aIndex;
 198     return sal_True;
 199 }
 200
 201 //------------------------------------------------------------------------
 202 //
 203 //------------------------------------------------------------------------
 204
 205 sal_uInt32 CFileOpenDialog::getSelectedFilterIndex() const
 206 {
 207     return m_ofn.nFilterIndex;
 208 }
 209
 210 //------------------------------------------------------------------------
 211 //
 212 //------------------------------------------------------------------------
 213
 214 void SAL_CALL CFileOpenDialog::setDefaultName(const rtl::OUString& aName)
 215 {
 216     m_fileNameBuffer.setLength(0);
 217     m_fileNameBuffer.append(aName);
 218     m_ofn.lpstrFile = reinterpret_cast<LPTSTR>(const_cast<sal_Unicode*>(m_fileNameBuffer.getStr()));
 219 }
 220
 221 //------------------------------------------------------------------------
 222 //
 223 //------------------------------------------------------------------------
 224
 225 void SAL_CALL CFileOpenDialog::setDisplayDirectory(const rtl::OUString& aDirectory)
 226 {
 227     m_displayDirectory = aDirectory;
 228     m_ofn.lpstrInitialDir = reinterpret_cast<LPCTSTR>(m_displayDirectory.getStr());
 229 }
 230
 231 //------------------------------------------------------------------------
 232 //
 233 //------------------------------------------------------------------------
 234
 235 rtl::OUString SAL_CALL CFileOpenDialog::getLastDisplayDirectory() const
 236 {
 237     return m_displayDirectory;
 238 }
 239
 240 //------------------------------------------------------------------------
 241 //
 242 //------------------------------------------------------------------------
 243
 244 rtl::OUString SAL_CALL CFileOpenDialog::getFullFileName() const
 245 {
 246     return rtl::OUString(m_fileNameBuffer.getStr(),
 247         _wcslenex(m_fileNameBuffer.getStr()));
 248 }
 249
 250 //------------------------------------------------------------------------
 251 //
 252 //------------------------------------------------------------------------
 253
 254 rtl::OUString SAL_CALL CFileOpenDialog::getFileName() const
 255 {
 256     return rtl::OUString(m_fileTitleBuffer);
 257 }
 258
 259 //------------------------------------------------------------------------
 260 //
 261 //------------------------------------------------------------------------
 262
 263 rtl::OUString CFileOpenDialog::getFileExtension()
 264 {
 265     if (m_ofn.nFileExtension)
 266         return rtl::OUString(m_fileNameBuffer.getStr() + m_ofn.nFileExtension,
 267             rtl_ustr_getLength(m_fileNameBuffer.getStr() + m_ofn.nFileExtension));
 268
 269     return rtl::OUString();
 270 }
 271
 272 //------------------------------------------------------------------------
 273 //
 274 //------------------------------------------------------------------------
 275
 276 void CFileOpenDialog::setDefaultFileExtension(const rtl::OUString& aExtension)
 277 {
 278     m_defaultExtension = aExtension;
 279     m_ofn.lpstrDefExt  = reinterpret_cast<LPCTSTR>(m_defaultExtension.getStr());
 280 }
 281
 282 //------------------------------------------------------------------------
 283 //
 284 //------------------------------------------------------------------------
 285
 286 void SAL_CALL CFileOpenDialog::setMultiSelectionMode(bool bMode)
 287 {
 288     if (bMode)
 289         m_ofn.Flags |= OFN_ALLOWMULTISELECT;
 290     else
 291         m_ofn.Flags &= ~OFN_ALLOWMULTISELECT;
 292 }
 293
 294 //------------------------------------------------------------------------
 295 //
 296 //------------------------------------------------------------------------
 297
 298 bool SAL_CALL CFileOpenDialog::getMultiSelectionMode() const
 299 {
 300     return ((m_ofn.Flags & OFN_ALLOWMULTISELECT) > 0);
 301 }
 302
 303 //------------------------------------------------------------------------
 304 //
 305 //------------------------------------------------------------------------
 306
 307 sal_Int16 SAL_CALL CFileOpenDialog::doModal()
 308 {
 309     sal_Int16 nRC = -1;
 310
 311     // pre-processing
 312     if (preModal())
 313     {
 314         bool bRet;
 315
 316         if (m_bFileOpenDialog)
 317             bRet = m_GetFileNameWrapper.getOpenFileName(
 318                 reinterpret_cast<LPOPENFILENAME>(&m_ofn));
 319         else
 320             bRet = m_GetFileNameWrapper.getSaveFileName(
 321                 reinterpret_cast<LPOPENFILENAME>(&m_ofn));
 322
 323         nRC = 1;
 324
 325         if (!bRet)
 326             nRC = (0 == m_GetFileNameWrapper.commDlgExtendedError()) ? 0 : -1;
 327
 328         // post-processing
 329         postModal(nRC);
 330     }
 331
 332     return nRC;
 333 }
 334
 335 //------------------------------------------------------------------------
 336 //
 337 //------------------------------------------------------------------------
 338
 339 sal_uInt32 SAL_CALL CFileOpenDialog::getLastDialogError() const
 340 {
 341     return CommDlgExtendedError();
 342 }
 343
 344 //------------------------------------------------------------------------
 345 //
 346 //------------------------------------------------------------------------
 347
 348 bool SAL_CALL CFileOpenDialog::preModal()
 349 {
 350     return sal_True;
 351 }
 352
 353 //------------------------------------------------------------------------
 354 //
 355 //------------------------------------------------------------------------
 356
 357 void SAL_CALL CFileOpenDialog::postModal(sal_Int16 nDialogResult)
 358 {
 359     OSL_ASSERT((-1 <= nDialogResult) && (nDialogResult <= 1));
 360
 361     if (1 == nDialogResult)
 362     {
 363         // Attention: assuming that nFileOffset is always greater 0 because under
 364         // Windows there is always a drive letter or a server in a complete path
 365         // the OPENFILENAME docu never says that nFileOffset can be 0
 366         m_displayDirectory = rtl::OUString(reinterpret_cast<const sal_Unicode*>(m_ofn.lpstrFile),m_ofn.nFileOffset);
 367     }
 368 }
 369
 370 //------------------------------------------------------------------------
 371 //
 372 //------------------------------------------------------------------------
 373
 374 rtl::OUString SAL_CALL CFileOpenDialog::getCurrentFilePath() const
 375 {
 376     OSL_ASSERT(IsWindow(m_hwndFileOpenDlg));
 377
 378     LPARAM nLen = SendMessage(
 379         m_hwndFileOpenDlg,
 380         CDM_GETFILEPATH,
 381         m_helperBuffer.getCapacity(),
 382         reinterpret_cast<LPARAM>(m_helperBuffer.getStr()));
 383
 384     if (nLen > 0)
 385     {
 386         m_helperBuffer.setLength((nLen * sizeof(sal_Unicode)) - 1);
 387         return rtl::OUString(m_helperBuffer);
 388     }
 389     return rtl::OUString();
 390 }
 391
 392 //------------------------------------------------------------------------
 393 //
 394 //------------------------------------------------------------------------
 395
 396 rtl::OUString SAL_CALL CFileOpenDialog::getCurrentFolderPath() const
 397 {
 398     OSL_ASSERT(IsWindow(m_hwndFileOpenDlg));
 399
 400     LPARAM nLen = SendMessage(
 401         m_hwndFileOpenDlg,
 402         CDM_GETFOLDERPATH,
 403         m_helperBuffer.getCapacity(),
 404         reinterpret_cast<LPARAM>(m_helperBuffer.getStr()));
 405
 406     if (nLen > 0)
 407     {
 408         m_helperBuffer.setLength((nLen * sizeof(sal_Unicode)) - 1);
 409         return rtl::OUString(m_helperBuffer);
 410     }
 411     return rtl::OUString();
 412 }
 413
 414 //------------------------------------------------------------------------
 415 //
 416 //------------------------------------------------------------------------
 417
 418 rtl::OUString SAL_CALL CFileOpenDialog::getCurrentFileName() const
 419 {
 420     OSL_ASSERT(IsWindow(m_hwndFileOpenDlg));
 421
 422     LPARAM nLen = SendMessage(
 423         m_hwndFileOpenDlg,
 424         CDM_GETSPEC,
 425         m_helperBuffer.getCapacity(),
 426         reinterpret_cast<LPARAM>(m_helperBuffer.getStr()));
 427
 428     if (nLen > 0)
 429     {
 430         m_helperBuffer.setLength((nLen * sizeof(sal_Unicode)) - 1);
 431         return rtl::OUString(m_helperBuffer);
 432     }
 433     return rtl::OUString();
 434 }
 435
 436 //------------------------------------------------------------------------
 437 //
 438 //------------------------------------------------------------------------
 439
 440 sal_uInt32 SAL_CALL CFileOpenDialog::onShareViolation(const rtl::OUString&)
 441 {
 442     return 0;
 443 }
 444
 445 //------------------------------------------------------------------------
 446 //
 447 //------------------------------------------------------------------------
 448
 449 sal_uInt32 SAL_CALL CFileOpenDialog::onFileOk()
 450 {
 451     return 0;
 452 }
 453
 454 //------------------------------------------------------------------------
 455 //
 456 //------------------------------------------------------------------------
 457
 458 void SAL_CALL CFileOpenDialog::onSelChanged(HWND)
 459 {
 460 }
 461
 462 //------------------------------------------------------------------------
 463 //
 464 //------------------------------------------------------------------------
 465
 466 void SAL_CALL CFileOpenDialog::onHelp()
 467 {
 468 }
 469
 470 //------------------------------------------------------------------------
 471 //
 472 //------------------------------------------------------------------------
 473
 474 void SAL_CALL CFileOpenDialog::onInitDone()
 475 {
 476     centerPositionToParent();
 477 }
 478
 479 //------------------------------------------------------------------------
 480 //
 481 //------------------------------------------------------------------------
 482
 483 void SAL_CALL CFileOpenDialog::onFolderChanged()
 484 {
 485 }
 486
 487 //------------------------------------------------------------------------
 488 //
 489 //------------------------------------------------------------------------
 490
 491 void SAL_CALL CFileOpenDialog::onTypeChanged(sal_uInt32)
 492 {
 493 }
 494
 495 //------------------------------------------------------------------------
 496 //
 497 //------------------------------------------------------------------------
 498
 499 sal_uInt32 SAL_CALL CFileOpenDialog::onCtrlCommand(HWND, sal_uInt16, sal_uInt16)
 500 {
 501     return 0;
 502 }
 503
 504 //------------------------------------------------------------------------
 505 //
 506 //------------------------------------------------------------------------
 507
 508 sal_uInt32 SAL_CALL CFileOpenDialog::onWMNotify( HWND, LPOFNOTIFY lpOfNotify )
 509 {
 510     switch(lpOfNotify->hdr.code)
 511     {
 512     case CDN_SHAREVIOLATION:
 513         return onShareViolation(reinterpret_cast<const sal_Unicode*>(lpOfNotify->pszFile));
 514
 515     case CDN_FILEOK:
 516         return onFileOk();
 517
 518     case CDN_SELCHANGE:
 519         onSelChanged(lpOfNotify->hdr.hwndFrom);
 520         break;
 521
 522     case CDN_HELP:
 523         onHelp();
 524         break;
 525
 526     case CDN_INITDONE:
 527         onInitDone();
 528         break;
 529
 530     case CDN_FOLDERCHANGE:
 531         onFolderChanged();
 532         break;
 533
 534     case CDN_TYPECHANGE:
 535         m_ofn.nFilterIndex = lpOfNotify->lpOFN->nFilterIndex;
 536         onTypeChanged(lpOfNotify->lpOFN->nFilterIndex);
 537         break;
 538     }
 539
 540     return 0;
 541 }
 542
 543 //------------------------------------------------------------------------
 544 //
 545 //------------------------------------------------------------------------
 546
 547 void SAL_CALL CFileOpenDialog::handleInitDialog(HWND hwndDlg, HWND hwndChild)
 548 {
 549     m_hwndFileOpenDlg      = hwndDlg;
 550     m_hwndFileOpenDlgChild = hwndChild;
 551
 552     OSL_ASSERT(GetParent(hwndChild) == hwndDlg);
 553
 554     // calling virtual function which the
 555     // client can overload
 556     onInitDialog(hwndDlg);
 557 }
 558
 559 //------------------------------------------------------------------------
 560 //
 561 //------------------------------------------------------------------------
 562
 563 unsigned int CALLBACK CFileOpenDialog::ofnHookProc(
 564     HWND hChildDlg, unsigned int uiMsg, WPARAM wParam, LPARAM lParam)
 565 {
 566     HWND hwndDlg = GetParent(hChildDlg);
 567     CFileOpenDialog* pImpl = NULL;
 568
 569     switch( uiMsg )
 570     {
 571     case WM_INITDIALOG:
 572         {
 573             _LPOPENFILENAME lpofn = reinterpret_cast<_LPOPENFILENAME>(lParam);
 574             pImpl = reinterpret_cast<CFileOpenDialog*>(lpofn->lCustData);
 575             OSL_ASSERT(pImpl);
 576
 577             // subclass the base dialog for WM_NCDESTROY processing
 578             pImpl->m_pfnBaseDlgProc =
 579                 reinterpret_cast<WNDPROC>(
 580                     SetWindowLong(
 581                         hwndDlg,
 582                         GWL_WNDPROC,
 583                         reinterpret_cast<LONG>(CFileOpenDialog::BaseDlgProc)));
 584             // connect the instance handle to the window
 585             SetProp(hwndDlg, CURRENT_INSTANCE, pImpl);
 586             pImpl->handleInitDialog(hwndDlg, hChildDlg);
 587         }
 588         return 0;
 589
 590     case WM_NOTIFY:
 591         {
 592             pImpl = getCurrentInstance(hwndDlg);
 593             return pImpl->onWMNotify(
 594                 hChildDlg, reinterpret_cast<LPOFNOTIFY>(lParam));
 595         }
 596
 597     case WM_COMMAND:
 598         {
 599             pImpl = getCurrentInstance(hwndDlg);
 600             OSL_ASSERT(pImpl);
 601
 602             return pImpl->onCtrlCommand(
 603                 hChildDlg, LOWORD(wParam), HIWORD(lParam));
 604         }
 605     }
 606
 607     return 0;
 608 }
 609
 610 //------------------------------------------------------------------------
 611 //
 612 //------------------------------------------------------------------------
 613
 614 LRESULT CALLBACK CFileOpenDialog::BaseDlgProc(
 615     HWND hWnd, UINT wMessage, WPARAM wParam, LPARAM lParam)
 616 {
 617     CFileOpenDialog* pImpl = 0;
 618
 619     if (WM_NCDESTROY == wMessage)
 620     {
 621         pImpl = reinterpret_cast<CFileOpenDialog*>(
 622             RemoveProp(hWnd,CURRENT_INSTANCE));
 623
 624         SetWindowLong(hWnd, GWL_WNDPROC,
 625             reinterpret_cast<LONG>(pImpl->m_pfnBaseDlgProc));
 626     }
 627     else
 628     {
 629         pImpl = getCurrentInstance(hWnd);
 630     }
 631
 632     OSL_ASSERT(pImpl);
 633
 634     return CallWindowProc(
 635         reinterpret_cast<WNDPROC>(pImpl->m_pfnBaseDlgProc),
 636         hWnd,wMessage,wParam,lParam);
 637 }
 638
 639 //------------------------------------------------------------------------
 640 //
 641 //------------------------------------------------------------------------
 642
 643 CFileOpenDialog* SAL_CALL CFileOpenDialog::getCurrentInstance(HWND hwnd)
 644 {
 645     OSL_ASSERT(IsWindow( hwnd));
 646     return reinterpret_cast<CFileOpenDialog*>(
 647         GetProp(hwnd, CURRENT_INSTANCE));
 648 }
 649
 650 //------------------------------------------------------------------------
 651 //
 652 //------------------------------------------------------------------------
 653
 654 void SAL_CALL CFileOpenDialog::centerPositionToParent() const
 655 {
 656     OSL_PRECOND(IsWindow(m_hwndFileOpenDlg), "no dialog window, call method only after or in onInitDone");
 657
 658     HWND hwndParent = m_ofn.hwndOwner;
 659
 660     if (!IsWindow(hwndParent))
 661         hwndParent = GetDesktopWindow();
 662
 663     OSL_ASSERT(IsWindow(hwndParent));
 664
 665     RECT rcPar;
 666     GetWindowRect(hwndParent, &rcPar);
 667
 668     RECT rcDlg;
 669     GetWindowRect(m_hwndFileOpenDlg, &rcDlg);
 670
 671     int lDlgW = rcDlg.right  - rcDlg.left;
 672     int lDlgH = rcDlg.bottom - rcDlg.top;
 673
 674     int x = (rcPar.left + rcPar.right  - lDlgW) / 2;
 675     int y = (rcPar.top  + rcPar.bottom - lDlgH) / 2;
 676
 677     HDC hdc = GetDC(m_hwndFileOpenDlg);
 678
 679     int hResol = GetDeviceCaps(hdc, HORZRES);
 680     int vResol = GetDeviceCaps(hdc, VERTRES);
 681
 682     ReleaseDC(m_hwndFileOpenDlg, hdc);
 683
 684     if (x < 0)
 685         x = 0;
 686     else if ((x + lDlgW) > hResol)
 687         x = hResol - lDlgW;
 688
 689     if (y < 0)
 690         y = 0;
 691     else if ((y + lDlgH) > vResol)
 692         y = vResol - lDlgH;
 693
 694     SetWindowPos(
 695         m_hwndFileOpenDlg,
 696         NULL, x, y, 0, 0,
 697         SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSIZE );
 698 }