StdDlg.cpp

Go to the documentation of this file.

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Project: uLib - User mode utility library.
// Module: Standard dialog wrapper classes.
// Author: Copyright (c) Love Nystrom
// License: NNOSL (BSD descendant, see NNOSL.txt in the base directory).
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include <uLib/StdDlg.h>
#include <uLib/UtilFunc.h>
#include <uLib/StrFunc.h>
#include <uLib/Debug.h>

UINT WM_CommonHelp = 0;     // HELPMSGSTRING
UINT WM_FileOk = 0;         // FILEOKSTRING
UINT WM_SelChange = 0;      // LBSELCHSTRING
UINT WM_ShareViolation = 0; // SHAREVISTRING
UINT WM_FindReplace = 0;    // FINDMSGSTRING
UINT WM_ColorOk = 0;        // COLOROKSTRING
UINT WM_SetRGB = 0;         // SETRGBSTRING

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

ACSTR CDErrorMsg( DWORD Err )
{
    #define TBLENTRY(x) { x, #x }
    struct _cdErr { DWORD code; ACSTR msg; }
    static const knownErr[] =
    {
        TBLENTRY( CDERR_DIALOGFAILURE ), // 0xFFFF
        TBLENTRY( CDERR_GENERALCODES ),
        TBLENTRY( CDERR_STRUCTSIZE ),
        TBLENTRY( CDERR_INITIALIZATION ),
        TBLENTRY( CDERR_NOTEMPLATE ),
        TBLENTRY( CDERR_NOHINSTANCE ),
        TBLENTRY( CDERR_LOADSTRFAILURE ),
        TBLENTRY( CDERR_FINDRESFAILURE ),
        TBLENTRY( CDERR_LOADRESFAILURE ),
        TBLENTRY( CDERR_LOCKRESFAILURE ),
        TBLENTRY( CDERR_MEMALLOCFAILURE ),
        TBLENTRY( CDERR_MEMLOCKFAILURE ),
        TBLENTRY( CDERR_NOHOOK ),
        TBLENTRY( CDERR_REGISTERMSGFAIL ),
        TBLENTRY( PDERR_PRINTERCODES ),
        TBLENTRY( PDERR_SETUPFAILURE ),
        TBLENTRY( PDERR_PARSEFAILURE ),
        TBLENTRY( PDERR_RETDEFFAILURE ),
        TBLENTRY( PDERR_LOADDRVFAILURE ),
        TBLENTRY( PDERR_GETDEVMODEFAIL ),
        TBLENTRY( PDERR_INITFAILURE ),
        TBLENTRY( PDERR_NODEVICES ),
        TBLENTRY( PDERR_NODEFAULTPRN ),
        TBLENTRY( PDERR_DNDMMISMATCH ),
        TBLENTRY( PDERR_CREATEICFAILURE ),
        TBLENTRY( PDERR_PRINTERNOTFOUND ),
        TBLENTRY( PDERR_DEFAULTDIFFERENT ),
        TBLENTRY( CFERR_CHOOSEFONTCODES ),
        TBLENTRY( CFERR_NOFONTS ),
        TBLENTRY( CFERR_MAXLESSTHANMIN ),
        TBLENTRY( FNERR_FILENAMECODES ),
        TBLENTRY( FNERR_SUBCLASSFAILURE ),
        TBLENTRY( FNERR_INVALIDFILENAME ),
        TBLENTRY( FNERR_BUFFERTOOSMALL ),
        TBLENTRY( FRERR_FINDREPLACECODES ),
        TBLENTRY( FRERR_BUFFERLENGTHZERO ),
        TBLENTRY( CCERR_CHOOSECOLORCODES )
    };
    #undef TBLENTRY

    if (!Err) Err = CommDlgExtendedError();
    for( short i=0; i < short(dimof(knownErr)); ++i )
        if (knownErr[i].code == Err)
        return knownErr[i].msg;

    static CHAR msgBuf[80];
    sprintf_s( msgBuf, "Error %04X(%u)", Err, Err );
    return msgBuf;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// FileDialog
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

const CSTR ALLFILE_FILTER = _T("All Files\0*.*\0");

FileDialog::FileDialog( HWND owner )
{
    memset( &lStructSize, 0, sizeof(OPENFILENAME) );
    memset( FullName, 0, sizeof(FullName) );

    lStructSize = sizeof(OPENFILENAME);
    lpstrFilter = ALLFILE_FILTER; // provide a default
    nFilterIndex = 1;
    nMaxFile = dimof(FullName); //_MAX_PATH;
    lpstrFile = FullName;
  #if FDLG_USEINITDIR
    memset( InitDir, 0, sizeof(InitDir) );
    lpstrInitialDir = InitDir;
  #endif
    Flags = OFN_EXPLORER | OFN_ENABLESIZING
        | OFN_PATHMUSTEXIST | OFN_SHAREAWARE;

    SetOwner( owner, hInstance );
    REGISTER_CommonHelp();
    REGISTER_FileOk();
    REGISTER_SelChange();
    REGISTER_ShareViolation();
}

void FileDialog::SetOwner( HWND owner, HINSTANCE hInst )
{
    hwndOwner = owner;
    if (!hInst) hInst = ::hInstance; // Fallback
    this->hInstance = hInst;
}

FileDialog::~FileDialog()
{}

bool FileDialog::Execute( UINT mode )
{
    static const UINT
        FDF_OPEN = OFN_FILEMUSTEXIST| OFN_ALLOWMULTISELECT,
        FDF_SAVE = OFN_CREATEPROMPT| OFN_OVERWRITEPROMPT;

    switch( mode ) {

    case FDLG_OPEN:
        Flags &= ~FDF_SAVE;
        Flags |= FDF_OPEN;
        return bool_cast( GetOpenFileName( this ));

    case FDLG_SAVE:
        Flags &= ~FDF_OPEN;
        Flags |= FDF_SAVE;
        return bool_cast( GetSaveFileName( this ));

    default: return false;
    }
}

CSTR FileDialog::PickFile( HWND owner, CSTR caption, CSTR filter )
{
    TSTR rtn = NULL;
    OPENFILENAME ofn = *this; // Use temporary ofn struct copy for this

    ofn.nFilterIndex = 1;
    ofn.Flags = OFN_EXPLORER | OFN_ENABLESIZING | OFN_PATHMUSTEXIST | OFN_CREATEPROMPT;
    ofn.lpstrFilter = filter ? filter : ALLFILE_FILTER;
    ofn.hwndOwner = owner;
    ofn.lpstrTitle = caption;

    if (!caption && owner) // If no caption, use owner's title.
    {
        TCHAR szTitle[128] = S_BLANK;
        GetWindowText( owner, szTitle, dimof(szTitle) );
        ofn.lpstrTitle = szTitle;
    }

    if (GetOpenFileName( &ofn ))
    {
        rtn = FullName;
        _updateOffsets();
    }
    return rtn;
}

CSTR FileDialog::Name()
{
    return lpstrFile + nFileOffset;
}

CSTR FileDialog::Ext()
{
    return lpstrFile + nFileExtension;
}

CSTR FileDialog::SetFilename( CSTR src )
{
    _tcscpy_s( FullName, dimof(FullName), src );
    _updateOffsets();

  #if FDLG_USEINITDIR
    TSTR pzSep = (TSTR)_tcsrchr( src, BSLASH );
    if (pzSep)
    {
        _tcscpy_s( InitDir, dimof(InitDir), src );
        pzSep = (TSTR)_tcsrchr( InitDir, BSLASH );
        if (pzSep) *pzSep = 0;
    }
  #endif
    return src; // Note!
}

void FileDialog::_updateOffsets()
{
    // Compute file offset

    TSTR pch = _tcsrchr( FullName, BSLASH );
    nFileOffset = WORD( pch ? pch - FullName + 1 : 0 );

    // Compute extension offset

    pch = _tcsrchr( FullName, DOT );
    // Let nFileExtension point to terminating NUL if no extension.
    if (pch) nFileExtension = WORD( pch - FullName + 1 );
    else nFileExtension = WORD( _tcschr( FullName, 0 ) - FullName );
}

bool FileDialog::ForEach( FDLG_ItemProc Action, PVOID UserData )
{
    TCHAR path[ MAX_PATH ];

    if (FileExist( FullName )) // If single file selected
    {
      #if FDLG_USEINITDIR
        TSTR bslash = _tcsrchr( FullName, BSLASH );         // Get last bkslash
        if (!bslash)
            _tcscpy_s( InitDir, dimof(InitDir), FullName ); // Consider the string a dir name
        else {                                              // If none, keep fname for init
            size_t span = bslash - FullName;                // Length of dir part
            _tcsncpy_s( InitDir, dimof(InitDir), FullName, span ); // Keep dir as initializer
            InitDir[ span ] = 0;                            // Make sure it's NUL terminated
        }
      #endif
        if (!Action( FullName, UserData )) return false;    // Call action proc
    }
    else // Multiple files selected
    {
      #if FDLG_USEINITDIR
        _tcscpy_s( InitDir, dimof(InitDir), FullName ); // Keep dir as next time initializer
      #endif
        TSTR src = _tcschr( FullName, 0 );      // Get end of dir, next ch is first file
        TSTR fn = _tcsecpy( path, FullName );   // Get directory, fn = ptr to nul termin
        *fn++ = BSLASH;                         // Append bkslash to dir, point to fname
      #ifdef HAVE_SAFE_CSTRINGS
        size_t remain = dimof(path) - (fn - path); // Remaining buffer space
      #endif
        while( *++src )                         // Pre-increment, check if chr or NUL
        {
            _tcscpy_s( fn, remain, src );       // Append filename.ext after dir bkslash
            if (!Action( path, UserData )) return false;
            src = _tcschr( src, 0 );            // Get next nul term
        }
    }
    return true;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// FindDialog
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

FindDialog::FindDialog( HWND Owner )
{
    memset( this, 0, sizeof(FINDREPLACE) );
    memset( What, 0, sizeof(What) );
    memset( With, 0, sizeof(With) );

    lStructSize = sizeof(FINDREPLACE);
    lpstrFindWhat = What;
    lpstrReplaceWith = With;
    wFindWhatLen = dimof(What);
    wReplaceWithLen = dimof(With);
    Flags = FR_DOWN;

    hWnd = NULL;
    SetOwner( Owner );

    REGISTER_CommonHelp();
    REGISTER_FindReplace();
}

void FindDialog::SetOwner( HWND Owner, HINSTANCE hInst )
{
    hwndOwner = Owner;
    if (!hInst) hInst = ::hInstance; // Fallback
    this->hInstance = hInst;
}

FindDialog::~FindDialog()
{
    if (hWnd) DestroyWindow( hWnd );
}

bool FindDialog::Execute( UINT Mode )
{
    Flags &= ~FR_ACTIONMASK; // Clear any previous action flags

    switch( Mode )
    {
    case FD_FIND:
        hWnd = FindText( this );
        TRACE_IF( !hWnd, DP_ERROR, _F("FindText(): %s\n"), CDErrorMsg() );
        break;

    case FD_REPLACE:
        hWnd = ReplaceText( this );
        TRACE_IF( !hWnd, DP_ERROR, _F("ReplaceText(): %s\n"), CDErrorMsg() );
        break;

    case FD_CLOSE:
        if (hWnd) DestroyWindow( hWnd );
        hWnd = NULL;
        break;
    }
    hCurrDlg = hWnd; // (uLib) Find/Replace dialog is modeless
    return (hWnd != NULL);
}

void FindDialog::SendFindNext()
{
    Flags &= ~(FR_REPLACE| FR_REPLACEALL);
    Flags |= FR_FINDNEXT;
    SendMessage( hwndOwner, WM_FindReplace, 0, (LPARAM)this );
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Font dialog
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

FontDialog::FontDialog()
{
    memset( this, 0, sizeof(CHOOSEFONT) );
    lStructSize = sizeof(CHOOSEFONT);

    Flags = CF_SCREENFONTS | CF_INITTOLOGFONTSTRUCT
        | CF_EFFECTS | CF_NOSIMULATIONS | CF_FORCEFONTEXIST;

    lpLogFont = &LogFont;
    SetTypeface( _T("Arial"), 10, FW_NORMAL, ANSI_CHARSET );

    LogFont.lfOutPrecision  = OUT_OUTLINE_PRECIS; // OUT_DEFAULT_PRECIS
    LogFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
    LogFont.lfQuality       = ANTIALIASED_QUALITY; //PROOF_QUALITY; //CLEARTYPE_QUALITY; //DEFAULT_QUALITY;
    LogFont.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
}

void FontDialog::SetOwner( HWND Owner, HINSTANCE hInst )
{
    hwndOwner = Owner;
    if (!hInst) hInst = ::hInstance; // Fallback
    this->hInstance = hInst;
}

void FontDialog::SetFaceName( CSTR Face )
{
    _tcscpy_s( LogFont.lfFaceName, dimof(LogFont.lfFaceName), Face );
}

void FontDialog::SetTypeface( CSTR Face, WORD Points, WORD Weight, BYTE ChrSet )
{
    SetFaceName( Face );
    LogFont.lfHeight = ScreenFontHeight( Points );
    LogFont.lfWeight = Weight;
    LogFont.lfCharSet = ChrSet;
}

bool FontDialog::GetLogFontFromDC( HDC hDC )
{
    HFONT font = (HFONT) GetCurrentObject( hDC, OBJ_FONT );
    LOGFONT tmpLf;
    bool ok = (GetObject( font, sizeof(tmpLf), &tmpLf ) == sizeof(LOGFONT));
    if (ok) LogFont = tmpLf;
    return ok;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Color dialog
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

ColorDialog::ColorDialog()
{
    memset( this, 0, sizeof(CHOOSECOLOR) );
    lStructSize = sizeof(CHOOSECOLOR);
    lpCustColors = Colors;
    Flags = CC_ANYCOLOR | CC_FULLOPEN | CC_RGBINIT;

    BYTE lum = 16, delta = 15; // Grayscale luminocity
    for( BYTE i=0; i < 16; ++i, lum += delta )
        Colors[ i ] = RGB( lum,lum,lum );
}

void ColorDialog::SetOwner( HWND Owner, HINSTANCE hInst )
{
    hwndOwner = Owner;
    if (!hInst) hInst = ::hInstance; // Fallback
    this->hInstance = (HWND) hInst;
    // There's an error in the declaration of CHOOSECOLOR which MS never fixed.
    // Hence the wonky typecast on the instance handle.
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// DirDialog
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

CCSTR DirDialog::DefaultTitle =
    _T("Select a folder in the directory tree\n")
    _T("or click [Cancel] to abort the operation.");

IFolderFilter* DirDialog::FolderFilter = NULL; // Preliminary

#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-function-type"
#endif

DirDialog::DirDialog( HWND Owner, UINT Flags )
{
    memset( &hwndOwner, 0, sizeof(BROWSEINFO) );
    // HWND              hwndOwner;
    // PCIDLIST_ABSOLUTE pidlRoot;
    // LPTSTR            pszDisplayName;
    // LPCTSTR           lpszTitle;
    // UINT              ulFlags;
    // BFFCALLBACK       lpfn;
    // LPARAM            lParam;
    // int               iImage;
    memset( Folder, 0, sizeof(Folder) );
    pszDisplayName = Folder;
    hwndOwner = Owner;
    lpszTitle = DefaultTitle;
    ulFlags = Flags;
    lParam = (LPARAM) this; // NB: Caller must not use lParam, but pData instead.
    lpfn = (BFFCALLBACK)_Hook; // GCC gives misleading warning here..
    //
    pIdl = NULL;
    pData = NULL; // User data.
    pFilterSite = NULL;
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif

DirDialog::~DirDialog()
{
    Done();
}

void DirDialog::Done()
{
    IMalloc* tmpShmall = NULL;
    if ((pIdl || pidlRoot) && !ShMalloc) // Oops.. ShMalloc's gone.
    {
        // This can happen with a global DirDialog, as the user would have
        // already called DoneShellFunc before the global destructor executes.

        CoGetMalloc( MEMCTX_TASK, &tmpShmall );
        ShMalloc = tmpShmall;
    }

    pIdl = (LPITEMIDLIST) ShellFreeEx( pIdl ); // (ShMalloc wrap)
    pidlRoot = (LPCITEMIDLIST) ShellFreeEx( (PVOID)pidlRoot );

    if (tmpShmall)
    {
        tmpShmall->Release();
        ShMalloc = NULL; // NOTE: tmpShmall only exist if ShMalloc was NULL.
    }

    RELEASE_OBJ( FolderFilter );
}

void DirDialog::SetOwner( HWND Owner )
{
    hwndOwner = Owner;
}

bool DirDialog::SetInitialDir( CSTR Dir ) // Initially selected item.
{
    LPITEMIDLIST pidl = GetPathNamePIDL( Dir );
    bool ok = (pidl != NULL);
    if (ok)
    {
        ShellFreeEx( pIdl );
        pIdl = pidl; // This is effectuated later by the _Hook callback.
    }
    return ok;
}

void DirDialog::SetRoot( LPITEMIDLIST pidl ) // Set root by PIDL.
{
    ShellFreeEx( (PVOID)pidlRoot );
    pidlRoot = pidl;
}

bool DirDialog::SetRootCsid( int csId ) // Set root by a CSIDL.
{
    LPITEMIDLIST pidl;
    bool ok = SUCCEEDED(
        SHGetSpecialFolderLocation( hwndOwner, csId, (ITEMIDLIST**)&pidl )
        );
    if (ok) SetRoot( pidl );
    return ok;
}

bool DirDialog::SetRootDir( CSTR Dir )  // Set root by a dir path.
{
    LPITEMIDLIST pidl = GetPathNamePIDL( Dir );
    bool ok = (pidl != NULL);
    if (ok) SetRoot( pidl );
    return ok;
}

bool DirDialog::Execute()
{
    if (!lpfn && pIdl) ShellFreeEx( pIdl ); // If no _Hook, dispose of pIdl here.

    // Quirk: This always raises exception 0x6BA (The RPC server is unavailable)
    // *first time it's called*, regardless if CoInitialize/Ex was called first.
    // The shell handles the exception transparently, so just ignore it.

    pIdl = SHBrowseForFolder( this );
    // Get the full path (SHBrowseForFolder sets Folder to only the last subdir).
    return pIdl ? bool_cast( SHGetPathFromIDList( pIdl, Folder )) : false;
}

#ifndef BFFM_IUNKNOWN // Missing in MinGW's ShlObj.h
#define BFFM_IUNKNOWN  5
#endif

DLGHOOKPROC DirDialog::_Hook( HWND hdlg, UINT msg, LPARAM lp, LPARAM data ) // static
{
    DirDialog*   This = (DirDialog*) data;
    UINT_PTR     rc = 0;

    IUnknown*    punk;
    LPITEMIDLIST pidl;
    CSTR         psz;

    #ifdef NT4_COMP
      #define DDM_SELECT  BFFM_SETSELECTION // Supported on NT4++: Selects the node
    #else
      #define DDM_SELECT  BFFM_SETEXPANDED // Supported on XP++: Selects and expands the node
    #endif

    switch( msg )
    {
    case BFFM_INITIALIZED:
        if (This->pIdl) // Was a directory selected before ?
        {
            // If so, then select it again, as starting point.

            SendMessage( hdlg, DDM_SELECT, FALSE, (LPARAM)This->pIdl );
            This->pIdl = (LPITEMIDLIST) ShellFreeEx( This->pIdl ); // Discard previous selection.
        }
        CenterWindow( hdlg, This->hwndOwner ); //<<-- PONDER: May or may not be a good idea...
        break;

    case BFFM_IUNKNOWN:
        punk = (IUnknown*) lp;
        // This is called just twice in the dialog lifetime. Once at the start,
        // with a valid IUnknown pointer, and once at the end with a NULL pointer
        // to indicate we need to unset any filter we installed.
        
        if (FolderFilter) // NB: static member
        {
            // [MSDN] "To set a custom filter, call QueryInterface on the IUnknown
            // to obtain a pointer to an instance of IFolderFilterSite. Then call
            // IFolderFilterSite::SetFilter with a pointer to your IFolderFilter."

            if (punk)
            {
                static REFIID riid = IID_IFolderFilterSite; //__uuidof( IFolderFilterSite );
                
                // Because we need to call the IFolderFilterSite at the end, we must
                // retain the pointer to it, as we can't QI a NULL pointer later.
                // The pointer is kept in our extended BROWSEINFO record.

                if (SUCCEEDED( punk->QueryInterface( riid, (void**)&This->pFilterSite )))
                {
                    if (FAILED( This->pFilterSite->SetFilter( FolderFilter )))
                        goto __releaseFilterSite;
                }
            }
            else // punk == NULL. The browser has Released it's shell folder interface. 
            {
                if (This->pFilterSite)
                {
                    This->pFilterSite->SetFilter( NULL ); // Release the filter
                  __releaseFilterSite:
                    RELEASE_OBJ( This->pFilterSite );
                }
            }
        }
        break;

    case BFFM_SELCHANGED:
        pidl = (LPITEMIDLIST) lp;
        // FIXME: Kludge to recenter the selected item...
        //if (This->_centerSel)
        //{
        //    static enum { IDC_TREE = 0x3741 };
        //    This->_centerSel = This->_keepCenterSel;
        //
        //    SCROLLINFO  si = { sizeof(SCROLLINFO), SIF_POS| SIF_RANGE| SIF_PAGE, 0,0,0,0,0 };
        //    HWND        htree = GetDlgItem( hdlg, IDC_TREE );
        //    HTREEITEM   htir, htic, htis;
        //    int         count, pos;
        //
        //    if (IsWindow( htree ))
        //    {
        //        htir = TreeView_GetRoot( htree );
        //        htis = TreeView_GetSelection( htree );
        //        htic = TreeView_GetChild( htree, htir );
        //        for( count = pos = 0; htic; htic = TreeView_GetNextVisible( htree, htic ), count++ )
        //            if (htis == htic)
        //            {
        //                pos = count;
        //                break;
        //            }
        //        GetScrollInfo( htree, SB_VERT, &si );
        //        si.nPage /= 2;
        //        if ((pos > int(si.nMin + si.nPage)) && (pos <= int(si.nMax - si.nMin - si.nPage)))
        //        {
        //            si.nMax = si.nPos - si.nMin + si.nPage;
        //            for( ; pos < si.nMax; pos++ ) PostMessage( htree, WM_VSCROLL, MAKEWPARAM( SB_LINEUP,0 ),0 );
        //            for( ; pos > si.nMax; pos-- ) PostMessage( htree, WM_VSCROLL, MAKEWPARAM( SB_LINEDOWN,0 ),0 );
        //        }
        //    }
        //}
        break;

    case BFFM_VALIDATEFAILED:
        psz = (CSTR) lp;
        rc = TRUE;
        break;
    }
    return rc;
    //UNUSED( punk );
    UNUSED( pidl );
    UNUSED( psz );
}

// EOF