fpicker/source/win32/filepicker/WinFileOpenImpl.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: WinFileOpenImpl.cxx,v $
  10  * $Revision: 1.30 $
  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 "shared.hxx"
  39 #include "WinFileOpenImpl.hxx"
  40 #include <osl/diagnose.h>
  41 #include <osl/file.hxx>
  42 #include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
  43 #include <com/sun/star/ui/dialogs/FilePickerEvent.hpp>
  44 #include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp>
  45 #include <com/sun/star/ui/dialogs/CommonFilePickerElementIds.hpp>
  46 #include <com/sun/star/ui/dialogs/FilePreviewImageFormats.hpp>
  47 #include <com/sun/star/ui/dialogs/ListBoxControlActions.hpp>
  48 #include "..\misc\WinImplHelper.hxx"
  49
  50 #ifndef _FILEPICKER_HXX_
  51 #include "filepicker.hxx"
  52 #endif
  53 #include "controlaccess.hxx"
  54 #include <rtl/ustrbuf.hxx>
  55 #include <rtl/string.hxx>
  56 #include <osl/thread.hxx>
  57 #include "filepickerstate.hxx"
  58
  59 //------------------------------------------------------------------------
  60 // namespace directives
  61 //------------------------------------------------------------------------
  62
  63 using namespace com::sun::star;
  64
  65 using com::sun::star::ui::dialogs::FilePickerEvent;
  66 using com::sun::star::lang::IllegalArgumentException;
  67 using com::sun::star::ui::dialogs::XFilePicker2;
  68
  69 using namespace ::com::sun::star::ui::dialogs::ExtendedFilePickerElementIds;
  70 using namespace ::com::sun::star::ui::dialogs::CommonFilePickerElementIds;
  71 using namespace ::com::sun::star::ui::dialogs::ListboxControlActions;
  72
  73 //-------------------------------------------------------------------------
  74 // to distinguish what to do in the enum child window callback function
  75 //-------------------------------------------------------------------------
  76
  77 enum ECW_ACTION_T
  78 {
  79     INIT_CUSTOM_CONTROLS,
  80     CACHE_CONTROL_VALUES
  81 };
  82
  83 struct EnumParam
  84 {
  85     ECW_ACTION_T        m_action;
  86     CWinFileOpenImpl*   m_instance;
  87
  88     EnumParam( ECW_ACTION_T action, CWinFileOpenImpl* instance ):
  89         m_action( action ),
  90         m_instance( instance )
  91     {}
  92 };
  93
  94 //-------------------------------------------------------------------------
  95 // ctor
  96 //-------------------------------------------------------------------------
  97
  98 CWinFileOpenImpl::CWinFileOpenImpl(
  99     CFilePicker* aFilePicker,
 100     sal_Bool bFileOpenDialog,
 101     sal_uInt32 dwFlags,
 102     sal_uInt32 dwTemplateId,
 103     HINSTANCE hInstance) :
 104     CFileOpenDialog(bFileOpenDialog, dwFlags, dwTemplateId, hInstance),
 105     m_filterContainer(new CFilterContainer()),
 106     m_Preview(new CPreviewAdapter(hInstance)),
 107     m_CustomControlFactory(new CCustomControlFactory()),
 108     m_CustomControls(m_CustomControlFactory->CreateCustomControlContainer()),
 109     m_FilePicker(aFilePicker),
 110     m_bInitialSelChanged(sal_True),
 111     m_HelpPopupWindow(hInstance, m_hwndFileOpenDlg),
 112     m_ExecuteFilePickerState(new CExecuteFilePickerState()),
 113     m_NonExecuteFilePickerState(new CNonExecuteFilePickerState())
 114 {
 115     m_FilePickerState = m_NonExecuteFilePickerState;
 116 }
 117
 118 //------------------------------------------------------------------------
 119 // dtor
 120 //------------------------------------------------------------------------
 121
 122 CWinFileOpenImpl::~CWinFileOpenImpl()
 123 {
 124     delete m_ExecuteFilePickerState;
 125     delete m_NonExecuteFilePickerState;
 126 }
 127
 128 //------------------------------------------------------------------------
 129 // we expect the directory in URL format
 130 //------------------------------------------------------------------------
 131
 132 void CWinFileOpenImpl::setDisplayDirectory(const rtl::OUString& aDirectory)
 133     throw( IllegalArgumentException, uno::RuntimeException )
 134 {
 135     rtl::OUString aSysDirectory;
 136     if( aDirectory.getLength() > 0)
 137     {
 138         if ( ::osl::FileBase::E_None !=
 139              ::osl::FileBase::getSystemPathFromFileURL(aDirectory,aSysDirectory))
 140             throw IllegalArgumentException(
 141                 rtl::OUString::createFromAscii("Invalid directory"),
 142                 static_cast<XFilePicker2*>(m_FilePicker), 1);
 143
 144         // we ensure that there is a trailing '/' at the end of
 145         // he given file url, because the windows functions only
 146         // works correctly when providing "c:\" or an environment
 147         // variable like "=c:=c:\.." etc. is set, else the
 148         // FolderPicker would stand in the root of the shell
 149         // hierarchie which is the desktop folder
 150         if ( aSysDirectory.lastIndexOf(BACKSLASH) != (aSysDirectory.getLength() - 1))
 151             aSysDirectory += BACKSLASH;
 152     }
 153
 154     // call base class method
 155     CFileOpenDialog::setDisplayDirectory(aSysDirectory);
 156 }
 157
 158 //------------------------------------------------------------------------
 159 // we return the directory in URL format
 160 //------------------------------------------------------------------------
 161
 162 rtl::OUString CWinFileOpenImpl::getDisplayDirectory() throw(uno::RuntimeException)
 163 {
 164     return m_FilePickerState->getDisplayDirectory(this);
 165 }
 166
 167 //-----------------------------------------------------------------------------------------
 168 //
 169 //-----------------------------------------------------------------------------------------
 170
 171 void SAL_CALL CWinFileOpenImpl::setDefaultName(const rtl::OUString& aName)
 172     throw( IllegalArgumentException, uno::RuntimeException )
 173 {
 174     // we don't set the default name directly
 175     // because this influences how the file open
 176     // dialog sets the initial path when it is about
 177     // to open (see MSDN: OPENFILENAME)
 178     // so we save the default name which should
 179     // appear in the file-name-box and set
 180     // this name when processing onInitDone
 181     m_defaultName = aName;
 182 }
 183
 184 //-----------------------------------------------------------------------------------------
 185 // return format: URL
 186 // if multiselection is allowed there are two different cases
 187 // 1. one file selected: the sequence contains one entry path\filename.ext
 188 // 2. multiple files selected: the sequence contains multiple entries
 189 //    the first entry is the path url, all other entries are file names
 190 //-----------------------------------------------------------------------------------------
 191
 192 uno::Sequence<rtl::OUString> SAL_CALL CWinFileOpenImpl::getFiles()
 193     throw(uno::RuntimeException)
 194 {
 195     return m_FilePickerState->getFiles(this);
 196 }
 197
 198 //-----------------------------------------------------------------------------------------
 199 // shows the FileOpen/FileSave dialog
 200 //-----------------------------------------------------------------------------------------
 201
 202 sal_Int16 SAL_CALL CWinFileOpenImpl::execute(  ) throw(uno::RuntimeException)
 203 {
 204     sal_Int16 rc = CFileOpenDialog::doModal();
 205
 206     if (1 == rc)
 207         rc = ::com::sun::star::ui::dialogs::ExecutableDialogResults::OK;
 208     else if (0 == rc)
 209         rc = ::com::sun::star::ui::dialogs::ExecutableDialogResults::CANCEL;
 210     else
 211         throw uno::RuntimeException(
 212             rtl::OUString::createFromAscii("Error executing dialog"),
 213             static_cast<XFilePicker2*>(m_FilePicker));
 214
 215     return rc;
 216 }
 217
 218 //-----------------------------------------------------------------------------------------
 219 // appends a new filter
 220 // returns false if the title (aTitle) was already added or the title or the filter are
 221 // empty
 222 //-----------------------------------------------------------------------------------------
 223
 224 void SAL_CALL CWinFileOpenImpl::appendFilter(const rtl::OUString& aTitle, const rtl::OUString& aFilter)
 225     throw(IllegalArgumentException, uno::RuntimeException)
 226 {
 227     sal_Bool bRet = m_filterContainer->addFilter(aTitle, aFilter);
 228
 229     if (!bRet)
 230         throw IllegalArgumentException(
 231             rtl::OUString::createFromAscii("filter already exists"),
 232             static_cast<XFilePicker2*>(m_FilePicker), 1);
 233
 234     // #95345# see MSDN OPENFILENAME
 235     // If nFilterIndex is zero and lpstrCustomFilter is NULL,
 236     // the system uses the first filter in the lpstrFilter buffer.
 237     // to reflect this we must set the filter index so that calls
 238     // to getSelectedFilterIndex without explicitly calling
 239     // setFilterIndex before does not return 0 which leads to a
 240     // false state
 241     if (0 == getSelectedFilterIndex())
 242         CFileOpenDialog::setFilterIndex(1);
 243 }
 244
 245 //-----------------------------------------------------------------------------------------
 246 // sets a current filter
 247 //-----------------------------------------------------------------------------------------
 248
 249 void SAL_CALL CWinFileOpenImpl::setCurrentFilter(const rtl::OUString& aTitle)
 250     throw( IllegalArgumentException, uno::RuntimeException)
 251 {
 252     sal_Int32 filterPos = m_filterContainer->getFilterPos(aTitle);
 253
 254     if (filterPos < 0)
 255         throw IllegalArgumentException(
 256             rtl::OUString::createFromAscii("filter doesn't exist"),
 257             static_cast<XFilePicker2*>(m_FilePicker), 1);
 258
 259     // filter index of the base class starts with 1
 260     CFileOpenDialog::setFilterIndex(filterPos + 1);
 261 }
 262
 263 //-----------------------------------------------------------------------------------------
 264 // returns the currently selected filter
 265 //-----------------------------------------------------------------------------------------
 266
 267 rtl::OUString SAL_CALL CWinFileOpenImpl::getCurrentFilter() throw(uno::RuntimeException)
 268 {
 269     sal_uInt32 nIndex = getSelectedFilterIndex();
 270
 271     rtl::OUString currentFilter;
 272     if (nIndex > 0)
 273     {
 274         // filter index of the base class starts with 1
 275         if (!m_filterContainer->getFilter(nIndex - 1, currentFilter)) {
 276             OSL_ASSERT(false);
 277         }
 278     }
 279
 280     return currentFilter;
 281 }
 282
 283 //-----------------------------------------------------------------------------------------
 284 //
 285 //-----------------------------------------------------------------------------------------
 286
 287 inline void SAL_CALL CWinFileOpenImpl::appendFilterGroupSeparator()
 288 {
 289     m_filterContainer->addFilter(FILTER_SEPARATOR, ALL_FILES_WILDCARD, ALLOW_DUPLICATES);
 290 }
 291
 292 //-----------------------------------------------------------------------------------------
 293 // XFilterGroupManager
 294 //-----------------------------------------------------------------------------------------
 295
 296 void SAL_CALL CWinFileOpenImpl::appendFilterGroup(const rtl::OUString& sGroupTitle, const uno::Sequence<beans::StringPair>& aFilters)
 297     throw (IllegalArgumentException, uno::RuntimeException)
 298 {
 299     (void) sGroupTitle; // avoid warning
 300     OSL_ENSURE(0 == sGroupTitle.getLength(), "appendFilterGroup: Parameter 'GroupTitle' currently ignored");
 301
 302     sal_Int32 nFilters = aFilters.getLength();
 303
 304     OSL_PRECOND(nFilters > 0, "Empty filter list");
 305
 306     if (nFilters > 0)
 307     {
 308         // append a separator before the next group if
 309         // there is already a group of filters
 310         if (m_filterContainer->numFilter() > 0)
 311             appendFilterGroupSeparator();
 312
 313         for (int i = 0; i < nFilters; i++)
 314             appendFilter(aFilters[i].First, aFilters[i].Second);
 315     }
 316 }
 317
 318 //=================================================================================================================
 319 // XExtendedFilePicker
 320 //=================================================================================================================
 321
 322 void SAL_CALL CWinFileOpenImpl::setValue(sal_Int16 aControlId, sal_Int16 aControlAction, const uno::Any& aValue)
 323     throw(uno::RuntimeException)
 324 {
 325     OSL_ASSERT(m_FilePickerState);
 326     m_FilePickerState->setValue(aControlId, aControlAction, aValue);
 327 }
 328
 329 //-----------------------------------------------------------------------------------------
 330 // returns the value of an custom template element
 331 // we assume that there are only checkboxes or comboboxes
 332 //-----------------------------------------------------------------------------------------
 333
 334 uno::Any SAL_CALL CWinFileOpenImpl::getValue(sal_Int16 aControlId, sal_Int16 aControlAction)
 335     throw(uno::RuntimeException)
 336 {
 337     OSL_ASSERT(m_FilePickerState);
 338     return m_FilePickerState->getValue(aControlId, aControlAction);
 339 }
 340
 341 //-----------------------------------------------------------------------------------------
 342 // enables a custom template element
 343 //-----------------------------------------------------------------------------------------
 344
 345 void SAL_CALL CWinFileOpenImpl::enableControl(sal_Int16 ControlID, sal_Bool bEnable)
 346     throw(uno::RuntimeException)
 347 {
 348     OSL_ASSERT(m_FilePickerState);
 349     m_FilePickerState->enableControl(ControlID, bEnable);
 350 }
 351
 352 //-----------------------------------------------------------------------------------------
 353 //
 354 //-----------------------------------------------------------------------------------------
 355
 356 void SAL_CALL CWinFileOpenImpl::setLabel( sal_Int16 aControlId, const rtl::OUString& aLabel )
 357     throw (uno::RuntimeException)
 358 {
 359     m_FilePickerState->setLabel(aControlId, aLabel);
 360 }
 361
 362 //-----------------------------------------------------------------------------------------
 363 //
 364 //-----------------------------------------------------------------------------------------
 365
 366 rtl::OUString SAL_CALL CWinFileOpenImpl::getLabel( sal_Int16 aControlId )
 367         throw (uno::RuntimeException)
 368 {
 369     return m_FilePickerState->getLabel(aControlId);
 370 }
 371
 372 //-----------------------------------------------------------------------------------------
 373 //
 374 //-----------------------------------------------------------------------------------------
 375
 376 uno::Sequence<sal_Int16> SAL_CALL CWinFileOpenImpl::getSupportedImageFormats()
 377     throw (uno::RuntimeException)
 378 {
 379     return m_Preview->getSupportedImageFormats();
 380 }
 381
 382 //-----------------------------------------------------------------------------------------
 383 //
 384 //-----------------------------------------------------------------------------------------
 385
 386 sal_Int32 SAL_CALL CWinFileOpenImpl::getTargetColorDepth()
 387     throw (uno::RuntimeException)
 388 {
 389     return m_Preview->getTargetColorDepth();
 390 }
 391
 392 //-----------------------------------------------------------------------------------------
 393 //
 394 //-----------------------------------------------------------------------------------------
 395
 396 sal_Int32 SAL_CALL CWinFileOpenImpl::getAvailableWidth()
 397         throw (uno::RuntimeException)
 398 {
 399     return m_Preview->getAvailableWidth();
 400 }
 401
 402 //-----------------------------------------------------------------------------------------
 403 //
 404 //-----------------------------------------------------------------------------------------
 405
 406 sal_Int32 SAL_CALL CWinFileOpenImpl::getAvailableHeight()
 407     throw (uno::RuntimeException)
 408 {
 409     return m_Preview->getAvailableHeight();
 410 }
 411
 412 //-----------------------------------------------------------------------------------------
 413 //
 414 //-----------------------------------------------------------------------------------------
 415
 416 void SAL_CALL CWinFileOpenImpl::setImage(sal_Int16 aImageFormat, const uno::Any& aImage)
 417     throw (IllegalArgumentException, uno::RuntimeException)
 418 {
 419     m_Preview->setImage(aImageFormat,aImage);
 420 }
 421
 422 //-----------------------------------------------------------------------------------------
 423 //
 424 //-----------------------------------------------------------------------------------------
 425
 426 sal_Bool SAL_CALL CWinFileOpenImpl::setShowState(sal_Bool bShowState)
 427         throw (uno::RuntimeException)
 428 {
 429     return m_Preview->setShowState(bShowState);
 430 }
 431
 432 //-----------------------------------------------------------------------------------------
 433 //
 434 //-----------------------------------------------------------------------------------------
 435
 436 sal_Bool SAL_CALL CWinFileOpenImpl::getShowState()
 437     throw (uno::RuntimeException)
 438 {
 439     return m_Preview->getShowState();
 440 }
 441
 442 //-----------------------------------------------------------------------------------------
 443 //
 444 //-----------------------------------------------------------------------------------------
 445
 446 void SAL_CALL CWinFileOpenImpl::cancel()
 447 {
 448     if (IsWindow(m_hwndFileOpenDlg))
 449     {
 450         // simulate a mouse click to the
 451         // cancel button
 452         PostMessage(
 453             m_hwndFileOpenDlg,
 454             WM_COMMAND,
 455             MAKEWPARAM(IDCANCEL,BN_CLICKED),
 456             (LPARAM)GetDlgItem(m_hwndFileOpenDlg, IDCANCEL));
 457     }
 458 }
 459
 460 //-----------------------------------------------------------------------------------------
 461 // returns the id of a custom template element
 462 //-----------------------------------------------------------------------------------------
 463
 464 sal_Int16 SAL_CALL CWinFileOpenImpl::getFocused()
 465 {
 466     int nID = GetDlgCtrlID(GetFocus());
 467
 468     // we don't forward id's of standard file open
 469     // dialog elements (ctlFirst is defined in dlgs.h
 470     // in MS Platform SDK)
 471     if (nID >= ctlFirst)
 472         nID = 0;
 473
 474     return sal::static_int_cast< sal_Int16 >(nID);
 475 }
 476
 477 //-----------------------------------------------------------------------------------------
 478 //
 479 //-----------------------------------------------------------------------------------------
 480
 481 inline sal_Bool SAL_CALL CWinFileOpenImpl::IsCustomControlHelpRequested(LPHELPINFO lphi) const
 482 {
 483     return ((lphi->iCtrlId != IDOK) && (lphi->iCtrlId != IDCANCEL) && (lphi->iCtrlId < ctlFirst));
 484 }
 485
 486 //-----------------------------------------------------------------------------------------
 487 // our own DlgProc because we do subclass the dialog
 488 // we catch the WM_NCDESTROY message in order to erase an entry in our static map
 489 // if one instance dies
 490 //-----------------------------------------------------------------------------------------
 491
 492 LRESULT CALLBACK CWinFileOpenImpl::SubClassFunc(
 493     HWND hWnd, UINT wMessage, WPARAM wParam, LPARAM lParam)
 494 {
 495     unsigned int lResult = 0;
 496
 497     CWinFileOpenImpl* pImpl = dynamic_cast<CWinFileOpenImpl*>(getCurrentInstance(hWnd));
 498
 499     switch(wMessage)
 500     {
 501     case WM_HELP:
 502     {
 503         LPHELPINFO lphi = reinterpret_cast<LPHELPINFO>(lParam);
 504
 505         if (pImpl->IsCustomControlHelpRequested(lphi))
 506             pImpl->onCustomControlHelpRequest(lphi);
 507         else
 508             lResult = CallWindowProc(
 509                 reinterpret_cast<WNDPROC>(pImpl->m_pfnOldDlgProc),
 510                 hWnd,wMessage,wParam,lParam);
 511     }
 512     break;
 513
 514     case WM_SIZE:
 515         lResult = CallWindowProc(
 516             reinterpret_cast<WNDPROC>(pImpl->m_pfnOldDlgProc),
 517             hWnd,wMessage,wParam,lParam);
 518
 519         pImpl->onWMSize();
 520         break;
 521
 522     case WM_WINDOWPOSCHANGED:
 523         lResult = CallWindowProc(
 524             reinterpret_cast<WNDPROC>(pImpl->m_pfnOldDlgProc),
 525             hWnd,wMessage,wParam,lParam);
 526
 527         pImpl->onWMWindowPosChanged();
 528         break;
 529
 530     case WM_SHOWWINDOW:
 531         lResult = CallWindowProc(
 532             reinterpret_cast<WNDPROC>(pImpl->m_pfnOldDlgProc),
 533             hWnd,wMessage,wParam,lParam);
 534
 535         pImpl->onWMShow((BOOL)wParam);
 536         break;
 537
 538     case WM_NCDESTROY:
 539         // restore the old window proc
 540         SetWindowLong(hWnd, GWL_WNDPROC,
 541             reinterpret_cast<LONG>(pImpl->m_pfnOldDlgProc));
 542
 543         lResult = CallWindowProc(
 544             reinterpret_cast<WNDPROC>(pImpl->m_pfnOldDlgProc),
 545             hWnd,wMessage,wParam,lParam);
 546         break;
 547
 548     default:
 549         lResult = CallWindowProc(
 550             reinterpret_cast<WNDPROC>(pImpl->m_pfnOldDlgProc),
 551             hWnd,wMessage,wParam,lParam);
 552     break;
 553
 554     } // switch
 555
 556     return lResult;
 557 }
 558
 559 //-----------------------------------------------------------------
 560 //
 561 //-----------------------------------------------------------------
 562
 563 void SAL_CALL CWinFileOpenImpl::InitControlLabel(HWND hWnd)
 564 {
 565     //-----------------------------------------
 566     // set the labels for all extendet controls
 567     //-----------------------------------------
 568
 569     sal_Int16 aCtrlId = sal::static_int_cast< sal_Int16 >(GetDlgCtrlID(hWnd));
 570     rtl::OUString aLabel = m_ResProvider.getResString(aCtrlId);
 571     if (aLabel.getLength())
 572         setLabel(aCtrlId, aLabel);
 573 }
 574
 575 //-----------------------------------------------------------------
 576 // There may be problems with the layout of our custom controls,
 577 // so that they are not aligned with the standard controls of the
 578 // FileOpen dialog.
 579 // We use a simple algorithm to move the custom controls to their
 580 // proper position and resize them.
 581 // Our approach is to align all static text controls with the
 582 // static text control "File name" of the FileOpen dialog,
 583 // all checkboxes and all list/comboboxes will be left aligned with
 584 // the standard combobox edt1 (defined in MS platform sdk dlgs.h)
 585 // and all push buttons will be left aligned with the standard
 586 // "OK" button
 587 //-----------------------------------------------------------------
 588
 589 void SAL_CALL CWinFileOpenImpl::InitCustomControlContainer(HWND hCustomControl)
 590 {
 591     m_CustomControls->AddControl(
 592         m_CustomControlFactory->CreateCustomControl(hCustomControl,m_hwndFileOpenDlg));
 593 }
 594
 595 //-----------------------------------------------------------------
 596 //
 597 //-----------------------------------------------------------------
 598
 599 void SAL_CALL CWinFileOpenImpl::CacheControlState(HWND hWnd)
 600 {
 601     OSL_ASSERT(m_FilePickerState && m_NonExecuteFilePickerState);
 602     m_ExecuteFilePickerState->cacheControlState(hWnd, m_NonExecuteFilePickerState);
 603 }
 604
 605 //-----------------------------------------------------------------
 606 //
 607 //-----------------------------------------------------------------
 608
 609 BOOL CALLBACK CWinFileOpenImpl::EnumChildWndProc(HWND hWnd, LPARAM lParam)
 610 {
 611     EnumParam* enumParam    = (EnumParam*)lParam;
 612     CWinFileOpenImpl* pImpl = enumParam->m_instance;
 613
 614     OSL_ASSERT(pImpl);
 615
 616     BOOL bRet = TRUE;
 617
 618     switch(enumParam->m_action)
 619     {
 620     case INIT_CUSTOM_CONTROLS:
 621         pImpl->InitControlLabel(hWnd);
 622         pImpl->InitCustomControlContainer(hWnd);
 623         break;
 624
 625     case CACHE_CONTROL_VALUES:
 626         pImpl->CacheControlState(hWnd);
 627     break;
 628
 629     default:
 630         // should not end here
 631         OSL_ASSERT(sal_False);
 632     }
 633
 634     return bRet;
 635 }
 636
 637 //-----------------------------------------------------------------
 638 //
 639 //-----------------------------------------------------------------
 640
 641 sal_uInt32 SAL_CALL CWinFileOpenImpl::onFileOk()
 642 {
 643     m_NonExecuteFilePickerState->reset();
 644
 645     EnumParam enumParam(CACHE_CONTROL_VALUES,this);
 646
 647     EnumChildWindows(
 648         m_hwndFileOpenDlgChild,
 649         CWinFileOpenImpl::EnumChildWndProc,
 650         (LPARAM)&enumParam);
 651
 652     return 0;
 653 }
 654
 655 //-----------------------------------------------------------------
 656 //
 657 //-----------------------------------------------------------------
 658
 659 void SAL_CALL CWinFileOpenImpl::onSelChanged(HWND)
 660 {
 661     // the windows file open dialog sends an initial
 662     // SelChanged message after the InitDone message
 663     // when the dialog is about to be opened
 664     // if the lpstrFile buffer of the OPENFILENAME is
 665     // empty (zero length string) the windows file open
 666     // dialog sends a WM_SETTEXT message with an empty
 667     // string to the file name edit line
 668     // this would overwritte our text when we would set
 669     // the default name in onInitDone, so we have to
 670     // remeber that this is the first SelChanged message
 671     // and set the default name here to overwrite the
 672     // windows setting
 673     InitialSetDefaultName();
 674
 675     FilePickerEvent evt;
 676     m_FilePicker->fileSelectionChanged(evt);
 677 }
 678
 679 // #i40865# The size of the standard labels 'File name'
 680 // and 'File type' is to short in some cases when the
 681 // label will be changed (e.g. in the Brazil version).
 682 // We just make sure that the labels are using the maximum
 683 // available space.
 684 void CWinFileOpenImpl::EnlargeStdControlLabels() const
 685 {
 686     HWND hFilterBoxLabel = GetDlgItem(m_hwndFileOpenDlg, stc2);
 687     HWND hFileNameBoxLabel = GetDlgItem(m_hwndFileOpenDlg, stc3);
 688     HWND hFileNameBox = GetDlgItem(m_hwndFileOpenDlg, cmb13);
 689     if (!hFileNameBox)
 690         hFileNameBox = GetDlgItem(m_hwndFileOpenDlg, edt1); // under Win98 it is edt1 instead of cmb13
 691
 692     HWND hFilterBox = GetDlgItem(m_hwndFileOpenDlg, cmb1);
 693     HWND hOkButton = GetDlgItem(m_hwndFileOpenDlg, IDOK);
 694
 695     // Move filter and file name box nearer to OK and Cancel button
 696     RECT rcOkButton;
 697     GetWindowRect(hOkButton, &rcOkButton);
 698
 699     const int MAX_GAP = IsWindows98() ? 5 : 10;
 700     const int OFFSET = IsWindows98() ? 10 : 0;
 701
 702     RECT rcFileNameBox;
 703     GetWindowRect(hFileNameBox, &rcFileNameBox);
 704     int w = rcFileNameBox.right - rcFileNameBox.left;
 705     int h = rcFileNameBox.bottom - rcFileNameBox.top;
 706
 707     int gap = rcOkButton.left - rcFileNameBox.right;
 708     gap = (gap > MAX_GAP) ? gap - MAX_GAP : gap;
 709
 710     ScreenToClient(m_hwndFileOpenDlg, (LPPOINT)&rcFileNameBox);
 711     MoveWindow(hFileNameBox, rcFileNameBox.left + gap + OFFSET, rcFileNameBox.top, w - OFFSET, h, true);
 712
 713     RECT rcFilterBox;
 714     GetWindowRect(hFilterBox, &rcFilterBox);
 715     w = rcFilterBox.right - rcFilterBox.left;
 716     h = rcFilterBox.bottom - rcFilterBox.top;
 717     ScreenToClient(m_hwndFileOpenDlg, (LPPOINT)&rcFilterBox);
 718     MoveWindow(hFilterBox, rcFilterBox.left + gap + OFFSET, rcFilterBox.top, w - OFFSET, h, true);
 719
 720     // get the new window rect
 721     GetWindowRect(hFileNameBox, &rcFileNameBox);
 722
 723     RECT rcFilterBoxLabel;
 724     GetWindowRect(hFilterBoxLabel, &rcFilterBoxLabel);
 725     int offset = rcFileNameBox.left - rcFilterBoxLabel.right - 1;
 726
 727     w = rcFilterBoxLabel.right - rcFilterBoxLabel.left + offset;
 728     h = rcFilterBoxLabel.bottom - rcFilterBoxLabel.top;
 729     ScreenToClient(m_hwndFileOpenDlg, (LPPOINT)&rcFilterBoxLabel);
 730     MoveWindow(hFilterBoxLabel, rcFilterBoxLabel.left, rcFilterBoxLabel.top, w, h, true);
 731
 732     RECT rcFileNameBoxLabel;
 733     GetWindowRect(hFileNameBoxLabel, &rcFileNameBoxLabel);
 734     w = rcFileNameBoxLabel.right - rcFileNameBoxLabel.left + offset;
 735     h = rcFileNameBoxLabel.bottom - rcFileNameBoxLabel.top;
 736     ScreenToClient(m_hwndFileOpenDlg, (LPPOINT)&rcFileNameBoxLabel);
 737     MoveWindow(hFileNameBoxLabel, rcFileNameBoxLabel.left, rcFileNameBoxLabel.top, w, h, true);
 738 }
 739
 740 void SAL_CALL CWinFileOpenImpl::onInitDone()
 741 {
 742     m_Preview->setParent(m_hwndFileOpenDlg);
 743
 744     // but now we have a valid parent handle
 745     m_HelpPopupWindow.setParent(m_hwndFileOpenDlg);
 746
 747     EnlargeStdControlLabels();
 748
 749     // #99826
 750     // Set the online filepicker state before initializing
 751     // the control labels from the resource else we are
 752     // overriding the offline settings
 753     m_ExecuteFilePickerState->setHwnd(m_hwndFileOpenDlgChild);
 754
 755     m_FilePickerState = m_ExecuteFilePickerState;
 756
 757     // initialize controls from cache
 758
 759     EnumParam enumParam(INIT_CUSTOM_CONTROLS,this);
 760
 761     EnumChildWindows(
 762         m_hwndFileOpenDlgChild,
 763         CWinFileOpenImpl::EnumChildWndProc,
 764         (LPARAM)&enumParam);
 765
 766     m_ExecuteFilePickerState->initFilePickerControls(
 767         m_NonExecuteFilePickerState->getControlCommand());
 768
 769     SetDefaultExtension();
 770
 771     m_CustomControls->Align();
 772
 773     m_CustomControls->SetFont(
 774         reinterpret_cast<HFONT>(SendMessage(m_hwndFileOpenDlg, WM_GETFONT, 0, 0)));
 775
 776     // resume event notification that was
 777     // defered in onInitDialog
 778     m_FilePicker->resumeEventNotification();
 779
 780     //#105996 let vcl know that now a system window is active
 781     PostMessage(
 782         HWND_BROADCAST,
 783         RegisterWindowMessage(TEXT("SYSTEM_WINDOW_ACTIVATED")),
 784         0,
 785         0);
 786
 787     // call the parent function to center the
 788     // dialog to it's parent
 789     CFileOpenDialog::onInitDone();
 790 }
 791
 792 //-----------------------------------------------------------------
 793 //
 794 //-----------------------------------------------------------------
 795
 796 void SAL_CALL CWinFileOpenImpl::onFolderChanged()
 797 {
 798     FilePickerEvent evt;
 799     m_FilePicker->directoryChanged(evt);
 800 }
 801
 802 //-----------------------------------------------------------------
 803 //
 804 //-----------------------------------------------------------------
 805
 806 void SAL_CALL CWinFileOpenImpl::onTypeChanged(sal_uInt32)
 807 {
 808     SetDefaultExtension();
 809
 810     FilePickerEvent evt;
 811     evt.ElementId = LISTBOX_FILTER;
 812     m_FilePicker->controlStateChanged(evt);
 813 }
 814
 815 //-----------------------------------------------------------------------------------------
 816 // onMessageCommand handler
 817 //-----------------------------------------------------------------------------------------
 818
 819 sal_uInt32 SAL_CALL CWinFileOpenImpl::onCtrlCommand(
 820     HWND, sal_uInt16 ctrlId, sal_uInt16)
 821 {
 822     SetDefaultExtension();
 823
 824     if (ctrlId < ctlFirst)
 825     {
 826         FilePickerEvent evt;
 827         evt.ElementId = ctrlId;
 828         m_FilePicker->controlStateChanged(evt);
 829     }
 830
 831     return 0;
 832 }
 833
 834 //-----------------------------------------------------------------------------------------
 835 //
 836 //-----------------------------------------------------------------------------------------
 837
 838 void CWinFileOpenImpl::onWMSize()
 839 {
 840     m_Preview->notifyParentSizeChanged();
 841     m_CustomControls->Align();
 842     m_FilePicker->dialogSizeChanged();
 843 }
 844
 845 //-----------------------------------------------------------------------------------------
 846 //
 847 //-----------------------------------------------------------------------------------------
 848
 849 void CWinFileOpenImpl::onWMShow(BOOL bShow)
 850 {
 851     m_Preview->notifyParentShow(bShow);
 852 }
 853
 854 //-----------------------------------------------------------------------------------------
 855 //
 856 //-----------------------------------------------------------------------------------------
 857
 858 void CWinFileOpenImpl::onWMWindowPosChanged()
 859 {
 860     m_Preview->notifyParentWindowPosChanged();
 861 }
 862
 863 //-----------------------------------------------------------------------------------------
 864 //
 865 //-----------------------------------------------------------------------------------------
 866
 867 void CWinFileOpenImpl::onCustomControlHelpRequest(LPHELPINFO lphi)
 868 {
 869     FilePickerEvent evt;
 870     evt.ElementId = sal::static_int_cast< sal_Int16 >(lphi->iCtrlId);
 871
 872     rtl::OUString aPopupHelpText = m_FilePicker->helpRequested(evt);
 873
 874     if (aPopupHelpText.getLength())
 875     {
 876         m_HelpPopupWindow.setText(aPopupHelpText);
 877
 878         DWORD dwMsgPos = GetMessagePos();
 879         m_HelpPopupWindow.show(LOWORD(dwMsgPos),HIWORD(dwMsgPos));
 880     }
 881 }
 882
 883 //-----------------------------------------------------------------------------------------
 884 //
 885 //-----------------------------------------------------------------------------------------
 886
 887 void SAL_CALL CWinFileOpenImpl::onInitDialog(HWND hwndDlg)
 888 {
 889     // subclass the dialog window
 890     m_pfnOldDlgProc =
 891         reinterpret_cast<WNDPROC>(
 892             SetWindowLong( hwndDlg, GWL_WNDPROC,
 893             reinterpret_cast<LONG>(SubClassFunc)));
 894 }
 895
 896 //-----------------------------------------------------------------------------------------
 897 // processing before showing the dialog
 898 //-----------------------------------------------------------------------------------------
 899
 900 bool SAL_CALL CWinFileOpenImpl::preModal()
 901 {
 902     CFileOpenDialog::setFilter(
 903         makeWinFilterBuffer(*m_filterContainer.get()));
 904
 905     return true;
 906 }
 907
 908 //-----------------------------------------------------------------------------------------
 909 // processing after showing the dialog
 910 //-----------------------------------------------------------------------------------------
 911
 912 void CWinFileOpenImpl::postModal(sal_Int16 nDialogResult)
 913 {
 914     CFileOpenDialog::postModal(nDialogResult);
 915
 916     // empty the container in order to get rid off
 917     // invalid controls in case someone calls execute
 918     // twice in sequence with the same instance
 919     m_CustomControls->RemoveAllControls();
 920
 921     m_FilePickerState = m_NonExecuteFilePickerState;
 922 }
 923
 924 //-----------------------------------------------------------------------------------------
 925 //
 926 //-----------------------------------------------------------------------------------------
 927
 928 void SAL_CALL CWinFileOpenImpl::SetDefaultExtension()
 929 {
 930     HWND hwndChkSaveWithExt = GetDlgItem(m_hwndFileOpenDlgChild, 100);
 931
 932     if (hwndChkSaveWithExt)
 933     {
 934         uno::Any aAny = CheckboxGetState(hwndChkSaveWithExt);
 935         sal_Bool bChecked = *reinterpret_cast<const sal_Bool*>(aAny.getValue());
 936
 937         if (bChecked)
 938         {
 939             sal_uInt32 nIndex = getSelectedFilterIndex();
 940
 941             rtl::OUString currentFilter;
 942             if (nIndex > 0)
 943             {
 944                 // filter index of the base class starts with 1
 945                 m_filterContainer->getFilter(nIndex - 1, currentFilter);
 946
 947                 if (currentFilter.getLength())
 948                 {
 949                     rtl::OUString FilterExt;
 950                     m_filterContainer->getFilter(currentFilter, FilterExt);
 951
 952                     sal_Int32 posOfPoint = FilterExt.indexOf(L'.');
 953                     const sal_Unicode* pFirstExtStart = FilterExt.getStr() + posOfPoint + 1;
 954
 955                     sal_Int32 posOfSemiColon = FilterExt.indexOf(L';') - 1;
 956                     if (posOfSemiColon < 0)
 957                         posOfSemiColon = FilterExt.getLength() - 1;
 958
 959                     FilterExt = rtl::OUString(pFirstExtStart, posOfSemiColon - posOfPoint);
 960
 961                     SendMessage(m_hwndFileOpenDlg, CDM_SETDEFEXT, 0, reinterpret_cast<LPARAM>(FilterExt.getStr()));
 962                  }
 963             }
 964         }
 965         else
 966         {
 967             SendMessage(m_hwndFileOpenDlg, CDM_SETDEFEXT, 0, reinterpret_cast<LPARAM>(TEXT("")));
 968         }
 969     }
 970
 971     // !!! HACK !!!
 972 }
 973
 974 //-----------------------------------------------------------------------------------------
 975 //
 976 //-----------------------------------------------------------------------------------------
 977
 978 void SAL_CALL CWinFileOpenImpl::InitialSetDefaultName()
 979 {
 980     // manually setting the file name that appears
 981     // initially in the file-name-box of the file
 982     // open dialog (reason: see above setDefaultName)
 983     if (m_bInitialSelChanged && m_defaultName.getLength())
 984     {
 985         sal_Int32 edt1Id = edt1;
 986
 987         // under W2k the there is a combobox instead
 988         // of an edit field for the file name edit field
 989         // the control id of this box is cmb13 and not
 990         // edt1 as before so we must use this id
 991         if (IsWindows2000Platform())
 992             edt1Id = cmb13;
 993
 994         HWND hwndEdt1 = GetDlgItem(m_hwndFileOpenDlg, edt1Id);
 995         SetWindowText(hwndEdt1, reinterpret_cast<LPCTSTR>(m_defaultName.getStr()));
 996     }
 997
 998     m_bInitialSelChanged = sal_False;
 999 }