xref: /trunk/main/fpicker/source/win32/filepicker/FileOpenDlg.cxx (revision b557fc96600fce3029f73c89748b6c08fd00b34d)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_fpicker.hxx"

//------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------

#include <tchar.h>
#include <osl/diagnose.h>
#include "../misc/WinImplHelper.hxx"
#include "FileOpenDlg.hxx"

//------------------------------------------------------------------------
// constants
//------------------------------------------------------------------------

namespace /* private */
{
    // we choose such large buffers because the size of
    // an single line edit field can be up to 32k; if
    // a user has a multi selection FilePicker and selects
    // a lot of files in a large directory we may reach this
    // limit and don't want to get out of memory;
    // another much more elegant way would be to subclass the
    // FileOpen dialog and overload the BM_CLICK event of the
    // OK button so that we determine the size of the text
    // currently in the edit field and resize our buffer
    // appropriately - in the future we will do this
    const size_t MAX_FILENAME_BUFF_SIZE  = 32000;
    const size_t MAX_FILETITLE_BUFF_SIZE = 32000;
    const size_t MAX_FILTER_BUFF_SIZE    = 4096;

    const LPTSTR CURRENT_INSTANCE = TEXT("CurrInst");

    //------------------------------------------
    // find an appropriate parent window
    //------------------------------------------

    inline bool is_current_process_window(HWND hwnd)
    {
        DWORD pid;
        GetWindowThreadProcessId(hwnd, &pid);
        return (pid == GetCurrentProcessId());
    }

    HWND choose_parent_window()
    {
        HWND hwnd_parent = GetForegroundWindow();
        if (!is_current_process_window(hwnd_parent))
            hwnd_parent = GetDesktopWindow();

        return hwnd_parent;
    }
};

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

CFileOpenDialog::CFileOpenDialog(
    bool bFileOpenDialog,
    sal_uInt32 dwFlags,
    sal_uInt32 dwTemplateId,
    HINSTANCE hInstance) :
    m_hwndFileOpenDlg(0),
    m_hwndFileOpenDlgChild(0),
    m_bFileOpenDialog(bFileOpenDialog),
    m_filterBuffer(MAX_FILTER_BUFF_SIZE),
    m_fileTitleBuffer(MAX_FILETITLE_BUFF_SIZE),
    m_helperBuffer(MAX_FILENAME_BUFF_SIZE),
    m_fileNameBuffer(MAX_FILENAME_BUFF_SIZE),
    m_pfnBaseDlgProc(0)
{
    // initialize the OPENFILENAME struct
    if (IsWindows2000Platform() || IsWindowsME())
    {
        ZeroMemory(&m_ofn, sizeof(m_ofn));
        m_ofn.lStructSize = sizeof(m_ofn);
    }
    else // OSVER < Win2000
    {
        // the size of the OPENFILENAME structure is different
        // under windows < win2000
        ZeroMemory(&m_ofn, _OPENFILENAME_SIZE_VERSION_400);
        m_ofn.lStructSize = _OPENFILENAME_SIZE_VERSION_400;
    }

    // 0x02000000 for #97681, sfx will make the entry into
    // the recent document list
    m_ofn.Flags |= dwFlags |
                   OFN_EXPLORER |
                   OFN_ENABLEHOOK |
                   OFN_HIDEREADONLY |
                   OFN_PATHMUSTEXIST |
                   OFN_FILEMUSTEXIST |
                   OFN_OVERWRITEPROMPT |
                   OFN_ENABLESIZING |
                   OFN_DONTADDTORECENT; // 0x02000000 -> OFN_DONTADDTORECENT only available with new platform sdk

    // it is a little hack but how else could
    // we get a parent window (using a vcl window?)
    m_ofn.hwndOwner = choose_parent_window();

    m_ofn.lpstrFile = reinterpret_cast<LPTSTR>(const_cast<sal_Unicode*>(m_fileNameBuffer.getStr()));
    m_ofn.nMaxFile  = m_fileNameBuffer.getCapacity();

    m_ofn.lpstrFileTitle = reinterpret_cast<LPTSTR>(const_cast<sal_Unicode*>(m_fileTitleBuffer.getStr()));
    m_ofn.nMaxFileTitle  = m_fileTitleBuffer.getCapacity();

    m_ofn.lpfnHook = CFileOpenDialog::ofnHookProc;

    // set a custom template

    if (dwTemplateId)
    {
        OSL_ASSERT(hInstance);

        m_ofn.Flags          |= OFN_ENABLETEMPLATE;
        m_ofn.lpTemplateName  = MAKEINTRESOURCE(dwTemplateId);
        m_ofn.hInstance       = hInstance;
    }

    // set a pointer to myself as ofn parameter
    m_ofn.lCustData = reinterpret_cast<long>(this);
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

CFileOpenDialog::~CFileOpenDialog()
{
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

void SAL_CALL CFileOpenDialog::setTitle(const rtl::OUString& aTitle)
{
    m_dialogTitle = aTitle;
    m_ofn.lpstrTitle = reinterpret_cast<LPCTSTR>(m_dialogTitle.getStr());
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

void CFileOpenDialog::setFilter(const rtl::OUString& aFilter)
{
    // Format is like
    // "*.TXT" or multiple separate by ';' like "*.TXT;*.DOC;*.SXW"
    // Do not include spaces in the pattern string
    m_filterBuffer.ensureCapacity(aFilter.getLength());
    m_filterBuffer.setLength(0);
    m_filterBuffer.append(aFilter);
    m_ofn.lpstrFilter = reinterpret_cast<LPCTSTR>(m_filterBuffer.getStr());
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

bool CFileOpenDialog::setFilterIndex(sal_uInt32 aIndex)
{
    OSL_ASSERT(aIndex > 0);
    m_ofn.nFilterIndex = aIndex;
    return sal_True;
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

sal_uInt32 CFileOpenDialog::getSelectedFilterIndex() const
{
    return m_ofn.nFilterIndex;
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

void SAL_CALL CFileOpenDialog::setDefaultName(const rtl::OUString& aName)
{
    m_fileNameBuffer.setLength(0);
    m_fileNameBuffer.append(aName);
    m_ofn.lpstrFile = reinterpret_cast<LPTSTR>(const_cast<sal_Unicode*>(m_fileNameBuffer.getStr()));
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

void SAL_CALL CFileOpenDialog::setDisplayDirectory(const rtl::OUString& aDirectory)
{
    m_displayDirectory = aDirectory;
    m_ofn.lpstrInitialDir = reinterpret_cast<LPCTSTR>(m_displayDirectory.getStr());
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

rtl::OUString SAL_CALL CFileOpenDialog::getLastDisplayDirectory() const
{
    return m_displayDirectory;
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

rtl::OUString SAL_CALL CFileOpenDialog::getFullFileName() const
{
    return rtl::OUString(m_fileNameBuffer.getStr(),
        _wcslenex(m_fileNameBuffer.getStr()));
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

rtl::OUString SAL_CALL CFileOpenDialog::getFileName() const
{
    return rtl::OUString(m_fileTitleBuffer);
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

rtl::OUString CFileOpenDialog::getFileExtension()
{
    if (m_ofn.nFileExtension)
        return rtl::OUString(m_fileNameBuffer.getStr() + m_ofn.nFileExtension,
            rtl_ustr_getLength(m_fileNameBuffer.getStr() + m_ofn.nFileExtension));

    return rtl::OUString();
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

void CFileOpenDialog::setDefaultFileExtension(const rtl::OUString& aExtension)
{
    m_defaultExtension = aExtension;
    m_ofn.lpstrDefExt  = reinterpret_cast<LPCTSTR>(m_defaultExtension.getStr());
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

void SAL_CALL CFileOpenDialog::setMultiSelectionMode(bool bMode)
{
    if (bMode)
        m_ofn.Flags |= OFN_ALLOWMULTISELECT;
    else
        m_ofn.Flags &= ~OFN_ALLOWMULTISELECT;
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

bool SAL_CALL CFileOpenDialog::getMultiSelectionMode() const
{
    return ((m_ofn.Flags & OFN_ALLOWMULTISELECT) > 0);
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

sal_Int16 SAL_CALL CFileOpenDialog::doModal()
{
    sal_Int16 nRC = -1;

    // pre-processing
    if (preModal())
    {
        bool bRet;

        if (m_bFileOpenDialog)
            bRet = m_GetFileNameWrapper.getOpenFileName(
                reinterpret_cast<LPOPENFILENAME>(&m_ofn));
        else
            bRet = m_GetFileNameWrapper.getSaveFileName(
                reinterpret_cast<LPOPENFILENAME>(&m_ofn));

        nRC = 1;

        if (!bRet)
            nRC = (0 == m_GetFileNameWrapper.commDlgExtendedError()) ? 0 : -1;

        // post-processing
        postModal(nRC);
    }

    return nRC;
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

sal_uInt32 SAL_CALL CFileOpenDialog::getLastDialogError() const
{
    return CommDlgExtendedError();
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

bool SAL_CALL CFileOpenDialog::preModal()
{
    return sal_True;
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

void SAL_CALL CFileOpenDialog::postModal(sal_Int16 nDialogResult)
{
    OSL_ASSERT((-1 <= nDialogResult) && (nDialogResult <= 1));

    if (1 == nDialogResult)
    {
        // Attention: assuming that nFileOffset is always greater 0 because under
        // Windows there is always a drive letter or a server in a complete path
        // the OPENFILENAME docu never says that nFileOffset can be 0
        m_displayDirectory = rtl::OUString(reinterpret_cast<const sal_Unicode*>(m_ofn.lpstrFile),m_ofn.nFileOffset);
    }
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

rtl::OUString SAL_CALL CFileOpenDialog::getCurrentFilePath() const
{
    OSL_ASSERT(IsWindow(m_hwndFileOpenDlg));

    LPARAM nLen = SendMessage(
        m_hwndFileOpenDlg,
        CDM_GETFILEPATH,
        m_helperBuffer.getCapacity(),
        reinterpret_cast<LPARAM>(m_helperBuffer.getStr()));

    if (nLen > 0)
    {
        m_helperBuffer.setLength((nLen * sizeof(sal_Unicode)) - 1);
        return rtl::OUString(m_helperBuffer);
    }
    return rtl::OUString();
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

rtl::OUString SAL_CALL CFileOpenDialog::getCurrentFolderPath() const
{
    OSL_ASSERT(IsWindow(m_hwndFileOpenDlg));

    LPARAM nLen = SendMessage(
        m_hwndFileOpenDlg,
        CDM_GETFOLDERPATH,
        m_helperBuffer.getCapacity(),
        reinterpret_cast<LPARAM>(m_helperBuffer.getStr()));

    if (nLen > 0)
    {
        m_helperBuffer.setLength((nLen * sizeof(sal_Unicode)) - 1);
        return rtl::OUString(m_helperBuffer);
    }
    return rtl::OUString();
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

rtl::OUString SAL_CALL CFileOpenDialog::getCurrentFileName() const
{
    OSL_ASSERT(IsWindow(m_hwndFileOpenDlg));

    LPARAM nLen = SendMessage(
        m_hwndFileOpenDlg,
        CDM_GETSPEC,
        m_helperBuffer.getCapacity(),
        reinterpret_cast<LPARAM>(m_helperBuffer.getStr()));

    if (nLen > 0)
    {
        m_helperBuffer.setLength((nLen * sizeof(sal_Unicode)) - 1);
        return rtl::OUString(m_helperBuffer);
    }
    return rtl::OUString();
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

sal_uInt32 SAL_CALL CFileOpenDialog::onShareViolation(const rtl::OUString&)
{
    return 0;
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

sal_uInt32 SAL_CALL CFileOpenDialog::onFileOk()
{
    return 0;
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

void SAL_CALL CFileOpenDialog::onSelChanged(HWND)
{
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

void SAL_CALL CFileOpenDialog::onHelp()
{
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

void SAL_CALL CFileOpenDialog::onInitDone()
{
    centerPositionToParent();
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

void SAL_CALL CFileOpenDialog::onFolderChanged()
{
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

void SAL_CALL CFileOpenDialog::onTypeChanged(sal_uInt32)
{
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

sal_uInt32 SAL_CALL CFileOpenDialog::onCtrlCommand(HWND, sal_uInt16, sal_uInt16)
{
    return 0;
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

sal_uInt32 SAL_CALL CFileOpenDialog::onWMNotify( HWND, LPOFNOTIFY lpOfNotify )
{
    switch(lpOfNotify->hdr.code)
    {
    case CDN_SHAREVIOLATION:
        return onShareViolation(reinterpret_cast<const sal_Unicode*>(lpOfNotify->pszFile));

    case CDN_FILEOK:
        return onFileOk();

    case CDN_SELCHANGE:
        onSelChanged(lpOfNotify->hdr.hwndFrom);
        break;

    case CDN_HELP:
        onHelp();
        break;

    case CDN_INITDONE:
        onInitDone();
        break;

    case CDN_FOLDERCHANGE:
        onFolderChanged();
        break;

    case CDN_TYPECHANGE:
        m_ofn.nFilterIndex = lpOfNotify->lpOFN->nFilterIndex;
        onTypeChanged(lpOfNotify->lpOFN->nFilterIndex);
        break;
    }

    return 0;
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

void SAL_CALL CFileOpenDialog::handleInitDialog(HWND hwndDlg, HWND hwndChild)
{
    m_hwndFileOpenDlg      = hwndDlg;
    m_hwndFileOpenDlgChild = hwndChild;

    OSL_ASSERT(GetParent(hwndChild) == hwndDlg);

    // calling virtual function which the
    // client can overload
    onInitDialog(hwndDlg);
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

unsigned int CALLBACK CFileOpenDialog::ofnHookProc(
    HWND hChildDlg, unsigned int uiMsg, WPARAM wParam, LPARAM lParam)
{
    HWND hwndDlg = GetParent(hChildDlg);
    CFileOpenDialog* pImpl = NULL;

    switch( uiMsg )
    {
    case WM_INITDIALOG:
        {
            _LPOPENFILENAME lpofn = reinterpret_cast<_LPOPENFILENAME>(lParam);
            pImpl = reinterpret_cast<CFileOpenDialog*>(lpofn->lCustData);
            OSL_ASSERT(pImpl);

            // subclass the base dialog for WM_NCDESTROY processing
            pImpl->m_pfnBaseDlgProc =
                reinterpret_cast<WNDPROC>(
                    SetWindowLong(
                        hwndDlg,
                        GWL_WNDPROC,
                        reinterpret_cast<LONG>(CFileOpenDialog::BaseDlgProc)));
            // connect the instance handle to the window
            SetProp(hwndDlg, CURRENT_INSTANCE, pImpl);
            pImpl->handleInitDialog(hwndDlg, hChildDlg);
        }
        return 0;

    case WM_NOTIFY:
        {
            pImpl = getCurrentInstance(hwndDlg);
            return pImpl->onWMNotify(
                hChildDlg, reinterpret_cast<LPOFNOTIFY>(lParam));
        }

    case WM_COMMAND:
        {
            pImpl = getCurrentInstance(hwndDlg);
            OSL_ASSERT(pImpl);

            return pImpl->onCtrlCommand(
                hChildDlg, LOWORD(wParam), HIWORD(lParam));
        }
    }

    return 0;
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

LRESULT CALLBACK CFileOpenDialog::BaseDlgProc(
    HWND hWnd, UINT wMessage, WPARAM wParam, LPARAM lParam)
{
    CFileOpenDialog* pImpl = 0;

    if (WM_NCDESTROY == wMessage)
    {
        pImpl = reinterpret_cast<CFileOpenDialog*>(
            RemoveProp(hWnd,CURRENT_INSTANCE));

        SetWindowLong(hWnd, GWL_WNDPROC,
            reinterpret_cast<LONG>(pImpl->m_pfnBaseDlgProc));
    }
    else
    {
        pImpl = getCurrentInstance(hWnd);
    }

    OSL_ASSERT(pImpl);

    return CallWindowProc(
        reinterpret_cast<WNDPROC>(pImpl->m_pfnBaseDlgProc),
        hWnd,wMessage,wParam,lParam);
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

CFileOpenDialog* SAL_CALL CFileOpenDialog::getCurrentInstance(HWND hwnd)
{
    OSL_ASSERT(IsWindow( hwnd));
    return reinterpret_cast<CFileOpenDialog*>(
        GetProp(hwnd, CURRENT_INSTANCE));
}

//------------------------------------------------------------------------
//
//------------------------------------------------------------------------

void SAL_CALL CFileOpenDialog::centerPositionToParent() const
{
    OSL_PRECOND(IsWindow(m_hwndFileOpenDlg), "no dialog window, call method only after or in onInitDone");

    HWND hwndParent = m_ofn.hwndOwner;

    if (!IsWindow(hwndParent))
        hwndParent = GetDesktopWindow();

    OSL_ASSERT(IsWindow(hwndParent));

    RECT rcPar;
    GetWindowRect(hwndParent, &rcPar);

    RECT rcDlg;
    GetWindowRect(m_hwndFileOpenDlg, &rcDlg);

    int lDlgW = rcDlg.right  - rcDlg.left;
    int lDlgH = rcDlg.bottom - rcDlg.top;

    int x = (rcPar.left + rcPar.right  - lDlgW) / 2;
    int y = (rcPar.top  + rcPar.bottom - lDlgH) / 2;

    HDC hdc = GetDC(m_hwndFileOpenDlg);

    int hResol = GetDeviceCaps(hdc, HORZRES);
    int vResol = GetDeviceCaps(hdc, VERTRES);

    ReleaseDC(m_hwndFileOpenDlg, hdc);

    if (x < 0)
        x = 0;
    else if ((x + lDlgW) > hResol)
        x = hResol - lDlgW;

    if (y < 0)
        y = 0;
    else if ((y + lDlgH) > vResol)
        y = vResol - lDlgH;

    SetWindowPos(
        m_hwndFileOpenDlg,
        NULL, x, y, 0, 0,
        SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSIZE );
}