source: trunk/Lucide/gui/lcdfdlg.cpp @ 367

Last change on this file since 367 was 367, checked in by dmik, 11 years ago

Merged bramches/kmk (r294:365) to trunk.

File size: 22.1 KB
Line 
1#include "os2all.h"
2
3#include <string.h>
4#include <stdlib.h>
5#include <io.h>
6#include <fcntl.h>
7
8#include "globals.h"
9#include "pluginman.h"
10#include "lucide_res.h"
11#include "luutils.h"
12#include "messages.h"
13
14
15static HWND hWndFrame            = NULLHANDLE;
16static char *szAllSupportedTypes = NULL;
17
18static void previewFile( HWND hwnd, const char *fn );
19
20struct previewData
21{
22    PFNWP    oldPvProc;
23    HDC      hdc;
24    HPS      hps;
25    HBITMAP  image;
26    HBITMAP  mask;
27    char     *text;
28    HPS      hpsBuffer;
29    HDC      hdcBuffer;
30};
31
32#define IMAGE_X 256
33#define IMAGE_Y 256
34
35static MRESULT EXPENTRY PreviewProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
36{
37    previewData *pd = (previewData *)WinQueryWindowULong( hwnd, QWL_USER );
38
39    switch ( msg )
40    {
41        case WM_PAINT:
42            {
43                RECTL rect = {0};
44                RECTL rcl = {0};
45                WinQueryWindowRect( hwnd, &rect );
46                WinCopyRect( hab, &rcl, &rect );
47                HPS hps = WinBeginPaint( hwnd, 0L, 0L );
48
49                GpiSetColor( pd->hpsBuffer, SYSCLR_WINDOWTEXT );
50                GpiSetBackColor( pd->hpsBuffer, SYSCLR_DIALOGBACKGROUND );
51                WinFillRect( pd->hpsBuffer, &rect, SYSCLR_WINDOWFRAME );
52                rect.xLeft++;
53                rect.yBottom++;
54                rect.xRight--;
55                rect.yTop--;
56                WinFillRect( pd->hpsBuffer, &rect, SYSCLR_DIALOGBACKGROUND );
57                if ( pd->image == NULLHANDLE )
58                {
59                    WinDrawText( pd->hpsBuffer, -1, pd->text, &rect, 0, 0,
60                                 DT_TEXTATTRS | DT_CENTER | DT_VCENTER );
61                }
62                else
63                {
64                    WinQueryWindowRect( hwnd, &rect );
65                    BITMAPINFOHEADER bmi = { 0 };
66                    bmi.cbFix = sizeof( BITMAPINFOHEADER );
67                    GpiQueryBitmapParameters( pd->image, &bmi );
68                    LONG xPos = ( rect.xRight - bmi.cx ) / 2;
69                    LONG yPos = ( rect.yTop - bmi.cy ) / 2;
70
71                    if ( pd->mask != NULLHANDLE )
72                    {
73                        GpiQueryBitmapParameters( pd->mask, &bmi );
74                        GpiSetColor( pd->hpsBuffer, SYSCLR_DIALOGBACKGROUND );
75                        GpiSetBackColor( pd->hpsBuffer, CLR_BLACK );
76                        POINTL aptl[ 4 ] = { { xPos, yPos },
77                                             { xPos + bmi.cx, yPos + (bmi.cy / 2) },
78                                             { 0, bmi.cy / 2 }, { bmi.cx + 1, bmi.cy + 1 } };
79                        GpiWCBitBlt( pd->hpsBuffer, pd->mask, 4, aptl, ROP_SRCAND, BBO_IGNORE );
80                    }
81                    if ( pd->image != NULLHANDLE )
82                    {
83                        GpiQueryBitmapParameters( pd->image, &bmi );
84                        POINTL aptl1[ 4 ] = { { xPos, yPos },
85                                              { xPos + bmi.cx, yPos + bmi.cy },
86                                              { 0, 0 }, { bmi.cx + 1, bmi.cy + 1 } };
87                        if ( pd->mask == NULLHANDLE ) {
88                            WinDrawBitmap( pd->hpsBuffer, pd->image, NULL, aptl1, 0, 0, DBM_NORMAL );
89                        }
90                        else {
91                            GpiWCBitBlt( pd->hpsBuffer, pd->image, 4, aptl1, ROP_SRCPAINT, BBO_IGNORE );
92                        }
93                    }
94                }
95                BlitGraphicsBuffer( hps, pd->hpsBuffer, &rcl );
96                WinEndPaint( hps );
97            }
98            return (MRESULT)FALSE;
99
100        case WM_DESTROY:
101            pd->oldPvProc( hwnd, msg, mp1, mp2 );
102            if ( pd->image != NULLHANDLE ) {
103                GpiDeleteBitmap( pd->image );
104            }
105            if ( pd->mask != NULLHANDLE ) {
106                GpiDeleteBitmap( pd->mask );
107            }
108            delete pd->text;
109            DestroyGraphicsBuffer( pd->hpsBuffer, pd->hdcBuffer );
110            delete pd;
111            return (MRESULT)FALSE;
112    }
113    return pd->oldPvProc( hwnd, msg, mp1, mp2 );
114}
115
116static void resizePreview( HWND hwnd )
117{
118    HWND previewWindow = WinWindowFromID( hwnd, IDC_PREVIEW );
119    RECTL rect = {0};
120    WinQueryWindowRect( previewWindow, &rect );
121    WinSetWindowPos( previewWindow, HWND_TOP, 0, 0, IMAGE_X + 2, rect.yTop, SWP_SIZE );
122    WinQueryWindowRect( previewWindow, &rect );
123    WinMapWindowPoints( previewWindow, hwnd, (PPOINTL)&rect, 2 );
124    LONG xRight = rect.xRight;
125    WinQueryWindowRect( hwnd, &rect );
126    WinSetWindowPos( hwnd, HWND_TOP, 0, 0, xRight + 8, rect.yTop, SWP_SIZE );
127}
128
129static void previewImageCreate( HWND hwnd )
130{
131    previewData *pd = new previewData;
132    memset( pd, 0, sizeof( previewData ) );
133    RECTL rcl;
134    WinQueryWindowRect( hwnd, &rcl );
135    HPS hps = WinGetPS( hwnd );
136    CreateGraphicsBuffer( hab, &rcl, hps, &pd->hpsBuffer, &pd->hdcBuffer );
137    WinReleasePS( hps );
138    pd->oldPvProc = WinSubclassWindow( hwnd, PreviewProc );
139    pd->text = newstrdupL( FDLG_NO_PREVIEW_AVAILABLE );
140    WinSetWindowULong( hwnd, QWL_USER, (ULONG)pd );
141    WinInvalidateRect( hwnd, NULL, FALSE );
142}
143
144static bool isAllFiles( HWND hwnd )
145{
146    char ftext[ 200 ];
147    WinQueryDlgItemText( hwnd, DID_FILTER_CB, sizeof( ftext ), ftext );
148    return ( strcmp( ftext, szAllSupportedTypes ) != 0 );
149}
150
151static BOOL checkFile( char *file, std::vector<std::string> *extList )
152{
153    BOOL rVal = FALSE;
154    std::vector<std::string>::const_iterator iter;
155    for ( iter = extList->begin(); iter != extList->end(); iter++ )
156    {
157        char ext[ 100 ];
158        ext[0] = '.';
159        ext[1] = 0;
160        strcat( ext, (*iter).c_str() );
161        int flen = strlen( file );
162        int elen = strlen( ext );
163
164        if ( flen < elen ) {
165            continue;
166        }
167
168        char *compare_pos = file + flen - elen;
169        if ( stricmp( compare_pos, ext ) == 0 ) {
170            rVal = TRUE;
171            break;
172        }
173    }
174
175    return rVal;
176}
177
178
179struct LcdFDlgData
180{
181    bool isAllFiles;
182    std::vector<std::string> *extList;
183
184    LcdFDlgData() {
185        isAllFiles = false;
186        extList = new std::vector<std::string>;
187    }
188
189    ~LcdFDlgData() {
190        delete extList;
191    }
192};
193
194static MRESULT EXPENTRY LcdFileDlgProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
195{
196    FILEDLG *pfild = (FILEDLG *)WinQueryWindowULong( hwnd, QWL_USER );
197
198    switch ( msg )
199    {
200        case WM_INITDLG:
201        {
202            resizePreview( hwnd );
203            localizeDialog( hwnd );
204            centerWindow( hWndFrame, hwnd );
205            previewImageCreate( WinWindowFromID( hwnd, IDC_PREVIEW ) );
206            SHORT sInx = SHORT1FROMMR( WinSendDlgItemMsg( hwnd, DID_FILTER_CB, LM_SEARCHSTRING,
207                    MPFROM2SHORT( LSS_CASESENSITIVE, 0 ), MPFROMP( szAllSupportedTypes ) ) );
208            WinSendDlgItemMsg( hwnd, DID_FILTER_CB, LM_SELECTITEM,
209                               MPFROMSHORT( sInx ), MPFROMSHORT( TRUE ) );
210
211            ((LcdFDlgData *)pfild->ulUser)->isAllFiles = isAllFiles( hwnd );
212        }
213        break;
214
215        case FDM_FILTER:
216            if ( ((LcdFDlgData *)pfild->ulUser)->isAllFiles ) {
217                return (MRESULT)TRUE;
218            }
219            else {
220                return (MRESULT)checkFile( (char *)mp1,
221                                           ((LcdFDlgData *)pfild->ulUser)->extList );
222            }
223
224        case WM_CONTROL:
225        {
226            switch ( SHORT1FROMMP(mp1) )
227            {
228                case DID_FILES_LB:
229                    if (SHORT2FROMMP(mp1) == LN_SELECT)
230                    {
231                        const MRESULT mr = WinDefFileDlgProc( hwnd, msg, mp1, mp2 );
232
233                        const HWND lbHwnd = HWNDFROMMP(mp2);
234                        const LONG index  = WinQueryLboxSelectedItem(lbHwnd);
235
236                        char itemText[ CCHMAXPATH ] = { 0 };
237
238                        if ( index >= 0 )
239                        {
240                            char fn[ CCHMAXPATH ] = { 0 };
241                            WinQueryLboxItemText( lbHwnd, (SHORT)index, itemText, CCHMAXPATH );
242                            strcpy( fn, pfild->szFullFile );
243                            strcat( fn, itemText );
244                            previewFile( WinWindowFromID( hwnd, IDC_PREVIEW ), fn );
245                        }
246
247                        return mr;
248                    }
249                    break;
250
251                case DID_FILTER_CB:
252                    ((LcdFDlgData *)pfild->ulUser)->isAllFiles = isAllFiles( hwnd );
253                    break;
254            }
255        }
256        break;
257
258    }
259
260    return WinDefFileDlgProc( hwnd, msg, mp1, mp2 );
261}
262
263
264HWND LcdFileDlg( HWND hwndP, HWND hwndO, FILEDLG *pfild )
265{
266    hWndFrame = hwndO;
267    if ( szAllSupportedTypes == NULL ) {
268        szAllSupportedTypes = newstrdupL( FDLG_ALL_SUPPORTED_TYPES );
269    }
270
271    pfild->fl |= FDS_CUSTOM;
272
273    if ( pfild->pfnDlgProc == NULL ) {
274        pfild->pfnDlgProc = LcdFileDlgProc;
275    }
276
277    pfild->hMod    = _hmod;
278    pfild->usDlgId = IDD_LCD_FILEDLG;
279
280    char **apsz;
281    apsz = (char **)malloc( sizeof( char* ) * 2 );
282    apsz[ 0 ] = szAllSupportedTypes;
283    apsz[ 1 ] = NULL;
284    pfild->papszITypeList = (PAPSZ)apsz;
285    pfild->ulUser = (ULONG)new LcdFDlgData;
286    pluginMan->getExtsList( ((LcdFDlgData *)pfild->ulUser)->extList );
287    HWND hDlg = WinFileDlg( hwndP, hwndO, pfild );
288    free( apsz );
289    delete ((LcdFDlgData *)pfild->ulUser);
290    return hDlg;
291}
292
293
294#define BUFSIZE      2000
295#define BUFSIZEEAOP2 65000
296
297static PVOID getEA( const char *pszPath, const char *pszEAname, PULONG ealen )
298{
299    CHAR   *pBuffer;
300    PDENA2 pDena;
301    ULONG  count;
302    ULONG  offset;
303    ULONG  length;
304    PEAOP2 pEAOP2;
305    PGEA2  pGea2;
306    PFEA2  pFEA2;
307    CHAR   *pEABase;
308    PVOID  pEAValue = NULL;
309
310    *ealen = 0;
311    count = -1;
312
313    if ( ( pBuffer = (char*)malloc(BUFSIZE) ) != NULL )
314    {
315        memset( pBuffer, 127, BUFSIZE );
316
317        if ( DosEnumAttribute( ENUMEA_REFTYPE_PATH, (PSZ)pszPath, 1, pBuffer, BUFSIZE,
318                               &count, ENUMEA_LEVEL_NO_VALUE ) == 0 )
319        {
320            pDena = (PDENA2)pBuffer;
321            offset = 0;
322            if ( (pEAOP2=(PEAOP2)malloc(BUFSIZEEAOP2)) != NULL )
323            {
324                pEAOP2->fpGEA2List = (PGEA2LIST)((CHAR*)pEAOP2 + sizeof(EAOP2));
325                pGea2 = (&(pEAOP2->fpGEA2List->list[0]));
326                if ( count != 0 )
327                {
328                    do
329                    {
330                        pDena = (PDENA2)((CHAR*)(pDena) + offset);
331                        strcpy( pGea2->szName, pDena->szName );
332                        pGea2->cbName = pDena->cbName;
333                        offset = pDena->oNextEntryOffset;
334                        length = pGea2->cbName+1 + sizeof(pGea2->cbName) +
335                                            sizeof(pGea2->oNextEntryOffset);
336                        if ((length%4) != 0 )
337                            length += 4-(length%4);
338                        if (!strcmp(pDena->szName, pszEAname))
339                            pGea2->oNextEntryOffset = 0;
340                        else
341                            pGea2->oNextEntryOffset = offset ? length : 0;
342                        pGea2 = (PGEA2)((CHAR*)pGea2 + length);
343                    } while ( pDena->oNextEntryOffset != 0 );
344
345                    pEAOP2->fpGEA2List->cbList = ((CHAR*)pGea2 - (CHAR*)(pEAOP2->fpGEA2List));
346                    pEAOP2->fpFEA2List = (PFEA2LIST)((CHAR*)pEAOP2->fpGEA2List + pEAOP2->fpGEA2List->cbList);
347                    pEAOP2->fpFEA2List->cbList = BUFSIZEEAOP2 - ((CHAR*)pEAOP2->fpFEA2List - (CHAR*)pEAOP2);
348
349                    if ( ( DosQueryPathInfo( pszPath, FIL_QUERYEASFROMLIST, pEAOP2,
350                                sizeof(EAOP2) ) == 0 ) && pEAOP2->fpFEA2List->cbList )
351                    {
352                        offset = 0;
353                        pFEA2 = pEAOP2->fpFEA2List->list;
354                        do
355                        {
356                            pFEA2 = (PFEA2)((CHAR*)pFEA2 + offset);
357                            if ( !strcmp( pFEA2->szName, pszEAname ) )
358                            {
359                                USHORT len = 0;
360                                PVOID pValue = NULL;
361                                pEABase = (CHAR*)pFEA2->szName + pFEA2->cbName + 1;
362                                if ( pszEAname[0] == '.' ) {
363                                    len = *(USHORT *)( pEABase + sizeof( USHORT ) );
364                                    pValue = pEABase + ( sizeof( USHORT ) * 2 );
365                                }
366                                else {
367                                    len = pFEA2->cbValue;
368                                    pValue = pEABase;
369                                }
370                                if ( len )
371                                {
372                                    pEAValue = malloc( len );
373                                    memcpy( pEAValue, pValue, len );
374                                    *ealen = len;
375                                }
376                                break;
377                            }
378                            offset = pFEA2->oNextEntryOffset;
379                        } while ( offset );
380                    }
381                }
382                free( pEAOP2 );
383            }
384        }
385        free( pBuffer );
386    }
387    return pEAValue;
388}
389
390
391HBITMAP LoadBitmap( HAB hab, HDC hdc, HPS *hps, PSZ pszFileName );
392
393static void readGif( HWND hwnd, const char *fn )
394{
395    previewData *pd = (previewData *)WinQueryWindowULong( hwnd, QWL_USER );
396    pd->hdc = DevOpenDC( WinQueryAnchorBlock( hwnd ), OD_MEMORY, "*", 0L, NULL, 0 );
397    pd->image = LoadBitmap( WinQueryAnchorBlock(hwnd), pd->hdc, &pd->hps, (PSZ)fn );
398    if ( pd->image == NULLHANDLE )
399    {
400        if ( pd->hps != NULLHANDLE ) {
401            GpiDestroyPS( pd->hps );
402            pd->hps = NULLHANDLE;
403        }
404        if ( pd->hdc != NULLHANDLE ) {
405            DevCloseDC( pd->hdc );
406            pd->hdc = NULLHANDLE;
407        }
408    }
409}
410
411static BOOL GetPointerBitmaps( HWND hwnd, PBYTE pchIcon, PBITMAPARRAYFILEHEADER2 pbafh2,
412                               HBITMAP *phbmPointer, HBITMAP *phbmColor, USHORT usIconSize )
413{
414    HPS   hps;
415    USHORT usBitCount, usRGB;
416    PBITMAPFILEHEADER2 pbfh2;
417    PBITMAPINFOHEADER2 pbmp2;
418    USHORT usExtra, usExp;
419    PBYTE  p;
420
421    *phbmPointer = (HBITMAP)0;
422    *phbmColor   = (HBITMAP)0;
423
424    // Is it the correct icon type ?
425    switch (pbafh2->usType)
426    {
427        case BFT_BITMAPARRAY:
428            pbfh2 = &pbafh2->bfh2;
429            break;
430
431        case BFT_ICON:
432        case BFT_BMAP:
433        case BFT_POINTER:
434        case BFT_COLORICON:
435        case BFT_COLORPOINTER:
436            pbfh2 = (PBITMAPFILEHEADER2)pbafh2;
437            break;
438
439        default :
440            return FALSE;
441    }
442    pbmp2 = &pbfh2->bmp2;
443
444    // Is it a BITMAPINFOHEADER or BITMAPINFOHEADER2 ?
445    if (pbmp2->cbFix == sizeof (BITMAPINFOHEADER2))
446    {
447        usRGB = sizeof (RGB2);
448        usBitCount = pbmp2->cBitCount;
449        if (usIconSize && pbmp2->cx != usIconSize)
450            return FALSE;
451    }
452    else if (pbmp2->cbFix == sizeof (BITMAPINFOHEADER))
453    {
454        PBITMAPINFOHEADER pbmp = (PBITMAPINFOHEADER)pbmp2;
455        usRGB = sizeof (RGB);
456        usBitCount = pbmp->cBitCount;
457        if (usIconSize && pbmp->cx != usIconSize)
458            return FALSE;
459    }
460    else  // Unknown length found
461        return FALSE;
462
463    // Create the first pointer by getting the presentation space first
464    // and than call GpiCreateBitmap
465    hps = WinGetPS(hwnd);
466    *phbmPointer = GpiCreateBitmap( hps, pbmp2, CBM_INIT,
467                                    (PBYTE)pchIcon + pbfh2->offBits, (PBITMAPINFO2)pbmp2 );
468    if (*phbmPointer == GPI_ERROR)
469    {
470        WinReleasePS(hps);
471        return FALSE;
472    }
473    WinReleasePS(hps);
474
475    // If it is a color icon than another BITMAPFILEHEADER follow after
476    // the color information. This color information contains of a number
477    // of RGB or RGB2 structures. The number depends of the number of colors
478    // in the bitmap. The number of colors is calculated by looking at
479    // the Number of bits per pel and using this number as an exponent on 2.
480    if (pbfh2->usType != BFT_COLORICON && pbfh2->usType != BFT_COLORPOINTER)
481        return TRUE;
482
483    // Calculate beginning of BITMAPFILEHEADER structure 2^Bits_per_pel
484    for (usExtra = 1, usExp = 0; usExp < usBitCount; usExp++)
485        usExtra *= 2;
486
487    p = (PBYTE)(pbfh2) + (pbfh2->cbSize + usExtra * usRGB);
488    pbfh2 = (PBITMAPFILEHEADER2)p;
489    // Get adress of BITMAPINFOHEADER
490    pbmp2 = &pbfh2->bmp2;
491
492    if (pbmp2->cbFix == sizeof (BITMAPINFOHEADER2))
493    {
494        if (pbmp2->cBitCount == 1)
495            return TRUE;
496    }
497    else if (pbmp2->cbFix == sizeof (BITMAPINFOHEADER))
498    {
499        PBITMAPINFOHEADER pbmp = (PBITMAPINFOHEADER)pbmp2;
500        if (pbmp->cBitCount == 1)
501            return TRUE;
502    }
503    else  // Unknown length found
504        return TRUE;
505
506    // And create bitmap number 2
507    hps = WinGetPS(hwnd);
508    *phbmColor = GpiCreateBitmap( hps, pbmp2, CBM_INIT,
509                                  (PBYTE)pchIcon + pbfh2->offBits, (PBITMAPINFO2)pbmp2 );
510    if (*phbmColor == GPI_ERROR)
511    {
512        GpiDeleteBitmap(*phbmPointer);
513        return FALSE;
514    }
515    WinReleasePS(hps);
516    return TRUE;
517}
518
519static BOOL IconBufferToBitmaps( HWND hwnd, PBYTE pchIcon, USHORT usIconSize,
520                                 HBITMAP *clr, HBITMAP *ptr )
521{
522    static USHORT usDeviceCX = 0;
523    static USHORT usDeviceCY = 0;
524    BOOL fContinue, fIconFound;
525    POINTERINFO PointerInfo;
526    PBITMAPARRAYFILEHEADER2 pbafh2;
527    PBYTE p;
528    HPOINTER hptrIcon = NULLHANDLE;
529
530    memset( &PointerInfo, 0, sizeof PointerInfo );
531
532    if ( !usDeviceCX ) {
533        usDeviceCX = WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN);
534        usDeviceCY = WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN);
535    }
536
537    fIconFound = FALSE;
538    pbafh2 = (PBITMAPARRAYFILEHEADER2)pchIcon;
539
540    switch (pbafh2->usType)
541    {
542        case BFT_BITMAPARRAY:
543            break;
544        case BFT_ICON:
545        case BFT_BMAP:
546        case BFT_POINTER:
547        case BFT_COLORICON:
548        case BFT_COLORPOINTER:
549            if (GetPointerBitmaps( hwnd, pchIcon, pbafh2, &PointerInfo.hbmPointer,
550                                   &PointerInfo.hbmColor, 0))
551            {
552                fIconFound = TRUE;
553            }
554            else
555                return FALSE;
556            break;
557        default :
558            return FALSE;
559    }
560
561    // First see if the icon contains an icon for the current device size.
562    fContinue = TRUE;
563    while (!fIconFound && fContinue)
564    {
565        if (pbafh2->cxDisplay == usDeviceCX && pbafh2->cyDisplay == usDeviceCY)
566        {
567            if (GetPointerBitmaps( hwnd, pchIcon, pbafh2, &PointerInfo.hbmPointer,
568                                   &PointerInfo.hbmColor, usIconSize ))
569            {
570                fIconFound = TRUE;
571                break;
572            }
573        }
574
575        p = (PBYTE)pchIcon + pbafh2->offNext;
576        if (!pbafh2->offNext)
577            break;
578        pbafh2 = (PBITMAPARRAYFILEHEADER2)p;
579    }
580
581    // Now look for the independed icons
582    if (!fIconFound)
583    {
584        pbafh2 = (PBITMAPARRAYFILEHEADER2)pchIcon;
585        fContinue = TRUE;
586        while (fContinue)
587        {
588            if (pbafh2->cxDisplay == 0 && pbafh2->cyDisplay == 0)
589            {
590                if (GetPointerBitmaps( hwnd, pchIcon, pbafh2, &PointerInfo.hbmPointer,
591                                       &PointerInfo.hbmColor, usIconSize ))
592                {
593                    fIconFound = TRUE;
594                    break;
595                }
596            }
597
598            p = (PBYTE)pchIcon + pbafh2->offNext;
599            if (!pbafh2->offNext)
600                break;
601            pbafh2 = (PBITMAPARRAYFILEHEADER2)p;
602        }
603    }
604
605    // if we still haven't found an icon we take the first icon there is
606    if (!fIconFound)
607    {
608        pbafh2 = (PBITMAPARRAYFILEHEADER2)pchIcon;
609        if (GetPointerBitmaps( hwnd, pchIcon, pbafh2, &PointerInfo.hbmPointer,
610                               &PointerInfo.hbmColor, 0 ))
611        {
612            fIconFound = TRUE;
613        }
614    }
615
616    if (!fIconFound)
617        return FALSE;
618
619    *clr = PointerInfo.hbmColor;
620    *ptr = PointerInfo.hbmPointer;
621
622    return TRUE;
623}
624
625static void previewFile( HWND hwnd, const char *fn )
626{
627    previewData *pd = (previewData *)WinQueryWindowULong( hwnd, QWL_USER );
628
629    if ( pd->image != NULLHANDLE ) {
630        GpiDeleteBitmap( pd->image );
631        pd->image = NULLHANDLE;
632    }
633    if ( pd->mask != NULLHANDLE ) {
634        GpiDeleteBitmap( pd->mask );
635        pd->mask = NULLHANDLE;
636    }
637    if ( pd->hps != NULLHANDLE ) {
638        GpiDestroyPS( pd->hps );
639        pd->hps = NULLHANDLE;
640    }
641    if ( pd->hdc != NULLHANDLE ) {
642        DevCloseDC( pd->hdc );
643        pd->hdc = NULLHANDLE;
644    }
645
646
647    ULONG ealen = 0;
648    PVOID eadata = getEA( fn, "LUCIDE_THUMBNAIL", &ealen );
649
650    if ( eadata != NULL )
651    {
652        char *tmpgif = new char[ CCHMAXPATH ];
653        getTmpDir( tmpgif );
654        strcat( tmpgif, "LUTHUMBR.GIF" );
655
656        int h = open( tmpgif, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
657                              S_IWRITE | S_IREAD );
658        if ( h != -1 )
659        {
660            ULONG wrt = write( h, eadata, ealen );
661            close( h );
662            if ( wrt == ealen ) {
663                readGif( hwnd, tmpgif );
664            }
665            unlink( tmpgif );
666        }
667        delete tmpgif;
668        free( eadata );
669    }
670    else // eadata == NULL
671    {
672        eadata = getEA( fn, ".ICON", &ealen );
673        if ( eadata != NULL )
674        {
675            IconBufferToBitmaps( hwnd, (PBYTE)eadata, ealen, &pd->image, &pd->mask );
676            free( eadata );
677        }
678    }
679
680    WinInvalidateRect( hwnd, NULL, FALSE );
681}
682
683
Note: See TracBrowser for help on using the repository browser.