Changeset 215 for trunk


Ignore:
Timestamp:
Aug 2, 2007, 6:20:51 PM (14 years ago)
Author:
Eugene Romanenko
Message:
  • If the filename does not have an extension or the extension is unknown, it will check file data to determine a suitable plugin (closes #43)
Location:
trunk/Lucide
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/Lucide/SOURCE/gui/lucide.cpp

    r213 r215  
    384384    char *msg = newstrdupL( MSGS_NO_SUIT_PLUG );
    385385
    386     // find extension
    387     char *ext = strrchr( fn, '.' );
    388     if ( ext == NULL )
     386    // test if file supported and then close previous opened document
     387    if ( pluginMan->createDocumentForFile( fn, true ) == NULL )
    389388    {
    390389        WinMessageBox( HWND_DESKTOP, hWndFrame, msg,
     
    393392    else
    394393    {
    395         // test if extension supported and then close previous opened document
    396         if ( pluginMan->createDocumentForExt( ext + 1, true ) == NULL )
     394        closeDocument();
     395
     396        doc = pluginMan->createDocumentForFile( fn, false );
     397        if ( doc == NULL )
    397398        {
    398399            WinMessageBox( HWND_DESKTOP, hWndFrame, msg,
     
    401402        else
    402403        {
    403             closeDocument();
    404 
    405             doc = pluginMan->createDocumentForExt( ext + 1, false );
    406             if ( doc == NULL )
     404            strcpy( docFullName, fn );
     405            if ( password != NULL ) {
     406                delete password;
     407                password = NULL;
     408            }
     409            bool once = true;
     410            while ( once || ( password != NULL ) )
    407411            {
    408                 WinMessageBox( HWND_DESKTOP, hWndFrame, msg,
    409                                NULL, 0, MB_OK | MB_ICONEXCLAMATION | MB_MOVEABLE );
    410             }
    411             else
    412             {
    413                 strcpy( docFullName, fn );
     412                once = false;
     413                docLoaded = false;
     414                loadError = NULL;
     415
     416                // Load document asynchronously
     417                loadProgressDlg = new ProgressDlg( hWndFrame );
     418                char *ldmsg = newstrdupL( MSGS_LOADING_DOCUMENT );
     419                loadProgressDlg->setText( ldmsg );
     420                delete ldmsg;
     421                loadProgressDlg->show( loadthread, NULL ); // doc will be loaded
     422                delete loadProgressDlg;
     423
    414424                if ( password != NULL ) {
    415425                    delete password;
    416426                    password = NULL;
    417427                }
    418                 bool once = true;
    419                 while ( once || ( password != NULL ) )
     428
     429                if ( docLoaded )
    420430                {
    421                     once = false;
    422                     docLoaded = false;
    423                     loadError = NULL;
    424 
    425                     // Load document asynchronously
    426                     loadProgressDlg = new ProgressDlg( hWndFrame );
    427                     char *ldmsg = newstrdupL( MSGS_LOADING_DOCUMENT );
    428                     loadProgressDlg->setText( ldmsg );
    429                     delete ldmsg;
    430                     loadProgressDlg->show( loadthread, NULL ); // doc will be loaded
    431                     delete loadProgressDlg;
    432 
    433                     if ( password != NULL ) {
    434                         delete password;
    435                         password = NULL;
    436                     }
    437 
    438                     if ( docLoaded )
     431                    char *t = new char[ 2048 ];
     432                    char _fn[ _MAX_FNAME ];
     433                    char _ex[ _MAX_EXT ];
     434                    _splitpath( fn, NULL, NULL, _fn, _ex );
     435                    strcpy( docFileName, _fn );
     436                    strcat( docFileName, _ex );
     437                    snprintf( t, 2048, "%s - %s", docFileName, title );
     438                    WinSetWindowText( hWndFrame, t );
     439                    delete t;
     440                    setDocument( doc );
     441                }
     442                else
     443                {
     444                    if ( loadErrorCode == LU_LDERR_NO_ERROR )
    439445                    {
    440                         char *t = new char[ 2048 ];
    441                         char _fn[ _MAX_FNAME ];
    442                         char _ex[ _MAX_EXT ];
    443                         _splitpath( fn, NULL, NULL, _fn, _ex );
    444                         strcpy( docFileName, _fn );
    445                         strcat( docFileName, _ex );
    446                         snprintf( t, 2048, "%s - %s", docFileName, title );
    447                         WinSetWindowText( hWndFrame, t );
    448                         delete t;
    449                         setDocument( doc );
     446                        char *m = newstrdupL( MSGS_FILE_LOAD_ERROR );
     447                        WinMessageBox( HWND_DESKTOP, hWndFrame, m,
     448                                       NULL, 0, MB_OK | MB_ICONEXCLAMATION | MB_MOVEABLE );
     449                        delete m;
    450450                    }
    451451                    else
    452452                    {
    453                         if ( loadErrorCode == LU_LDERR_NO_ERROR )
     453                        std::string msgTempl = getLocalizedString( MSGS_LDERR );
     454
     455                        const int errmsgLen = 1024;
     456                        char *errmsg = new char[ errmsgLen ];
     457                        memset( errmsg, 0, errmsgLen );
     458
     459                        if ( loadErrorCode == LU_LDERR_CUSTOM )
    454460                        {
    455                             char *m = newstrdupL( MSGS_FILE_LOAD_ERROR );
    456                             WinMessageBox( HWND_DESKTOP, hWndFrame, m,
    457                                            NULL, 0, MB_OK | MB_ICONEXCLAMATION | MB_MOVEABLE );
    458                             delete m;
     461                            snprintf( errmsg, errmsgLen, msgTempl.c_str(), loadError );
     462                            SOMFree( loadError );
    459463                        }
    460464                        else
    461465                        {
    462                             std::string msgTempl = getLocalizedString( MSGS_LDERR );
    463 
    464                             const int errmsgLen = 1024;
    465                             char *errmsg = new char[ errmsgLen ];
    466                             memset( errmsg, 0, errmsgLen );
    467 
    468                             if ( loadErrorCode == LU_LDERR_CUSTOM )
     466                            const char *lmsg = NULL;
     467                            switch ( loadErrorCode )
    469468                            {
    470                                 snprintf( errmsg, errmsgLen, msgTempl.c_str(), loadError );
    471                                 SOMFree( loadError );
     469                                case LU_LDERR_OUT_OF_MEMORY:
     470                                    lmsg = MSGS_LDERR_OUT_OF_MEMORY;
     471                                    break;
     472                                case LU_LDERR_OPEN_ERROR:
     473                                    lmsg = MSGS_LDERR_OPEN_ERROR;
     474                                    break;
     475                                case LU_LDERR_READ_ERROR:
     476                                    lmsg = MSGS_LDERR_READ_ERROR;
     477                                    break;
     478                                case LU_LDERR_DAMAGED:
     479                                    lmsg = MSGS_LDERR_DAMAGED;
     480                                    break;
     481                                case LU_LDERR_WRONG_FORMAT:
     482                                    lmsg = MSGS_LDERR_WRONG_FORMAT;
     483                                    break;
     484                                case LU_LDERR_ENCRYPTED:
     485                                    {
     486                                        lmsg = MSGS_LDERR_ENCRYPTED;
     487
     488                                        PasswordDlg *pd = new PasswordDlg( hWndFrame );
     489                                        if ( pd->showDialog() == DID_OK ) {
     490                                            password = newstrdup( pd->getPassword() );
     491                                        }
     492                                        delete pd;
     493                                    }
     494                                    break;
    472495                            }
    473                             else
    474                             {
    475                                 const char *lmsg = NULL;
    476                                 switch ( loadErrorCode )
    477                                 {
    478                                     case LU_LDERR_OUT_OF_MEMORY:
    479                                         lmsg = MSGS_LDERR_OUT_OF_MEMORY;
    480                                         break;
    481                                     case LU_LDERR_OPEN_ERROR:
    482                                         lmsg = MSGS_LDERR_OPEN_ERROR;
    483                                         break;
    484                                     case LU_LDERR_READ_ERROR:
    485                                         lmsg = MSGS_LDERR_READ_ERROR;
    486                                         break;
    487                                     case LU_LDERR_DAMAGED:
    488                                         lmsg = MSGS_LDERR_DAMAGED;
    489                                         break;
    490                                     case LU_LDERR_WRONG_FORMAT:
    491                                         lmsg = MSGS_LDERR_WRONG_FORMAT;
    492                                         break;
    493                                     case LU_LDERR_ENCRYPTED:
    494                                         {
    495                                             lmsg = MSGS_LDERR_ENCRYPTED;
    496 
    497                                             PasswordDlg *pd = new PasswordDlg( hWndFrame );
    498                                             if ( pd->showDialog() == DID_OK ) {
    499                                                 password = newstrdup( pd->getPassword() );
    500                                             }
    501                                             delete pd;
    502                                         }
    503                                         break;
    504                                 }
    505 
    506                                 if ( lmsg != NULL ) {
    507                                     snprintf( errmsg, errmsgLen, msgTempl.c_str(),
    508                                               getLocalizedString( lmsg ).c_str() );
    509                                 }
     496
     497                            if ( lmsg != NULL ) {
     498                                snprintf( errmsg, errmsgLen, msgTempl.c_str(),
     499                                          getLocalizedString( lmsg ).c_str() );
    510500                            }
    511 
    512                             if ( password == NULL )
    513                             {
    514                                 WinMessageBox( HWND_DESKTOP, hWndFrame, errmsg, NULL, 0,
    515                                                MB_OK | MB_ICONEXCLAMATION | MB_MOVEABLE );
    516                             }
    517                             delete errmsg;
    518                         } // ( loadErrorCode == LU_LDERR_NO_ERROR )
    519 
    520                         if ( password == NULL ) {
    521                             delete doc;
    522                             doc = NULL;
    523501                        }
    524                     } // ( docLoaded )
    525                 } // while ( once || ( password != NULL ) )
    526             } // ( doc == NULL )
    527         } // ( pluginMan->createDocumentForExt( ext + 1, true ) == NULL )
    528     } // ( ext == NULL )
     502
     503                        if ( password == NULL )
     504                        {
     505                            WinMessageBox( HWND_DESKTOP, hWndFrame, errmsg, NULL, 0,
     506                                           MB_OK | MB_ICONEXCLAMATION | MB_MOVEABLE );
     507                        }
     508                        delete errmsg;
     509                    } // ( loadErrorCode == LU_LDERR_NO_ERROR )
     510
     511                    if ( password == NULL ) {
     512                        delete doc;
     513                        doc = NULL;
     514                    }
     515                } // ( docLoaded )
     516            } // while ( once || ( password != NULL ) )
     517        } // ( doc == NULL )
     518    } // ( pluginMan->createDocumentForFile( fn, true ) == NULL )
    529519    delete msg;
    530520}
     
    750740{
    751741    char *param = NULL;
    752    
     742
    753743    if ( file != NULL )
    754744    {
  • trunk/Lucide/SOURCE/gui/pluginman.cpp

    r140 r215  
    3939#include "luutils.h"
    4040#include <dos.h>
     41#include <fcntl.h>
     42#include <stdio.h>
    4143#include <ludoc.xh>
    4244
     
    8789{
    8890    // Function pointer variables
    89     LuDocument * APIENTRY (*pCreateObject)();
    90     char * APIENTRY (*pGetSupportedExtensions)();
    91     char * APIENTRY (*pGetDescription)();
     91    LuDocument * APIENTRY (*pCreateObject)()      = NULL;
     92    char * APIENTRY (*pGetSupportedExtensions)()  = NULL;
     93    char * APIENTRY (*pGetDescription)()          = NULL;
     94    LuCheckStruct * APIENTRY (*pGetCheckStruct)() = NULL;
    9295
    9396    std::string fulldllname = path;
     
    111114        if ( DosQueryProcAddr( h, 0, "getDescription", (PFN *)&pGetDescription ) != 0 )
    112115            break;
     116
     117        // optional
     118        if ( DosQueryProcAddr( h, 0, "getCheckStruct", (PFN *)&pGetCheckStruct ) != 0 ) {
     119            pGetCheckStruct = NULL;
     120        }
    113121
    114122        res = true;
     
    122130        pi.extensions = pGetSupportedExtensions();
    123131        pi.description = pGetDescription();
     132        pi.checkStruct = ( pGetCheckStruct == NULL ) ? NULL : pGetCheckStruct();
    124133
    125134        plugins->push_back( pi );
     
    136145    }
    137146
    138     LuDocument * APIENTRY (*pCreateObject)();
     147    LuDocument * APIENTRY (*pCreateObject)() = NULL;
    139148
    140149    for ( int i = 0; i < plugins->size(); i++ )
     
    178187}
    179188
     189static bool checkDataEntry( LuCheckData *data, int h )
     190{
     191    lseek( h, data->offset, SEEK_SET );
     192    unsigned char *buf = new char[ data->length ];
     193    read( h, buf, data->length );
     194    bool result = ( memcmp( data->data, buf, data->length ) == 0 );
     195    delete buf;
     196    return result;
     197}
     198
     199static bool checkData( LuCheckStruct *checkStruct, const char *file )
     200{
     201    int h = open( file, O_RDONLY | O_BINARY );
     202
     203    if ( h != -1 )
     204    {
     205        bool result = true;
     206
     207        for ( unsigned long i = 0; i < checkStruct->count; i++ )
     208        {
     209            if ( !checkDataEntry( &(checkStruct->cdata[ i ]), h ) ) {
     210                result = false;
     211                break;
     212            }
     213        }
     214
     215        close( h );
     216        return result;
     217    }
     218
     219    return false;
     220}
     221
     222// returns NULL if not suitable plugin found
     223// if checkOnly is true - just check if suitable plugin exist
     224LuDocument *PluginManager::createDocumentForFile( const char *file, bool checkOnly )
     225{
     226    LuDocument *ld = NULL;
     227
     228    // Search by extension
     229    char *ext = strrchr( file, '.' );
     230    if ( ext != NULL ) {
     231        ld = createDocumentForExt( ext + 1, checkOnly );
     232    }
     233
     234    if ( ld != NULL ) {
     235        return ld;
     236    }
     237
     238    // Search by checkstruct
     239    LuDocument * APIENTRY (*pCreateObject)() = NULL;
     240
     241    for ( int i = 0; i < plugins->size(); i++ )
     242    {
     243        PluginInfo *pi = &(*plugins)[ i ];
     244
     245        if ( pi->checkStruct != NULL )
     246        {
     247            if ( checkData( pi->checkStruct, file ) )
     248            {
     249                if ( DosQueryProcAddr( pi->handle, 0, "createObject",
     250                                       (PFN *)&pCreateObject ) == 0 )
     251                {
     252                    if ( checkOnly ) {
     253                        return (LuDocument *)TRUE;
     254                    }
     255                    else {
     256                        return pCreateObject();
     257                    }
     258                }
     259            }
     260        }
     261    }
     262
     263    return NULL;
     264}
    180265
    181266std::string PluginManager::getExtsMask()
     
    198283}
    199284
     285
  • trunk/Lucide/SOURCE/gui/pluginman.h

    r54 r215  
    3939#include <string>
    4040
     41#include <lutypes.h>
     42
    4143
    4244class LuDocument;
     
    4850    std::string extensions;
    4951    std::string description;
     52    LuCheckStruct *checkStruct;
    5053};
    5154
     
    6164        ~PluginManager();
    6265        PluginInfoList *getPluginsList() { return plugins; }
     66        LuDocument *createDocumentForFile( const char *file, bool checkOnly );
    6367        LuDocument *createDocumentForExt( const char *ext, bool checkOnly );
    6468        std::string getExtsMask();
  • trunk/Lucide/SOURCE/plugins/ludjvu/ludjvu.cpp

    r210 r215  
    7878}
    7979
     80LuCheckData   lcd = { 0, 8, (void *)"AT&TFORM" };
     81LuCheckStruct lcs = { 1, &lcd };
     82
     83extern "C" LuCheckStruct * _System getCheckStruct()
     84{
     85        return &lcs;
     86}
     87
     88
    8089extern "C" char * _System getDescription()
    8190{
  • trunk/Lucide/SOURCE/plugins/ludjvu/ludjvu.def

    r142 r215  
    1616  getSupportedExtensions
    1717  getDescription
     18  getCheckStruct
  • trunk/Lucide/SOURCE/plugins/ludjvu/makefile

    r88 r215  
    4141export getSupportedExtensions
    4242export getDescription
     43export getCheckStruct
    4344| tmpmake.lnk >NUL
    4445    wlink @tmpmake.lnk
  • trunk/Lucide/SOURCE/plugins/ludoc/ludoc.cpp

    r155 r215  
    7575{
    7676    return "";
     77}
     78
     79extern "C" LuCheckStruct * _System getCheckStruct()
     80{
     81        return NULL;
    7782}
    7883
  • trunk/Lucide/SOURCE/plugins/ludoc/lutypes.h

    r213 r215  
    3838
    3939struct LuRectangle
    40 { 
    41         double x1;
    42         double y1;
    43         double x2;
    44         double y2;
     40{
     41    double x1;
     42    double y1;
     43    double x2;
     44    double y2;
    4545};
    4646
     
    5555struct LuLink
    5656{
    57         char *title;
    58         char *uri;
    59         long type;
    60         long page;
     57    char *title;
     58    char *uri;
     59    long type;
     60    long page;
    6161};
    6262
     
    6464struct LuLinkMapping
    6565{
    66         LuLink link;
    67         LuRectangle area;
     66    LuLink link;
     67    LuRectangle area;
    6868};
    6969
    7070
    71 #define LU_FONTEMBED_NOT_EMBEDDED               0
    72 #define LU_FONTEMBED_EMBEDDED                   1
    73 #define LU_FONTEMBED_EMBEDDED_SUBSET    2
     71#define LU_FONTEMBED_NOT_EMBEDDED       0
     72#define LU_FONTEMBED_EMBEDDED           1
     73#define LU_FONTEMBED_EMBEDDED_SUBSET    2
    7474
    7575struct LuFontInfo
    7676{
    77         char  *name;
    78         char  *type;
    79         short embedded;
     77    char  *name;
     78    char  *type;
     79    short embedded;
    8080};
    8181
    82        
     82   
    8383#define LU_DOCUMENT_LAYOUT_SINGLE_PAGE       0
    8484#define LU_DOCUMENT_LAYOUT_ONE_COLUMN        1
     
    8888#define LU_DOCUMENT_LAYOUT_TWO_PAGE_RIGHT    5
    8989
    90        
     90   
    9191#define LU_DOCUMENT_MODE_NONE             0
    9292#define LU_DOCUMENT_MODE_USE_OC           1
     
    134134struct LuDocumentInfo
    135135{
    136         char *title;
    137         char *format;
    138         char *author;
    139         char *subject;
    140         char *keywords;
    141         char *creator;
    142         char *producer;
    143         long security;
    144         long linearized;
    145         unsigned long creation_date;
    146         unsigned long modified_date;
    147         unsigned long layout;
    148         unsigned long mode;
    149         unsigned long ui_hints;
    150         unsigned long permissions;
    151         long n_pages;
     136    char *title;
     137    char *format;
     138    char *author;
     139    char *subject;
     140    char *keywords;
     141    char *creator;
     142    char *producer;
     143    long security;
     144    long linearized;
     145    unsigned long creation_date;
     146    unsigned long modified_date;
     147    unsigned long layout;
     148    unsigned long mode;
     149    unsigned long ui_hints;
     150    unsigned long permissions;
     151    long n_pages;
    152152
    153         // Mask of all valid fields
    154         unsigned long fields_mask;
     153    // Mask of all valid fields
     154    unsigned long fields_mask;
    155155};
    156156
     
    178178
    179179
     180// structs to detect type of file by it's content
     181
     182struct LuCheckData
     183{
     184    unsigned long  offset;  // from beginning of file
     185    unsigned long  length;  // length of data bytes to check
     186    void          *data;    // pointer to data bytes
     187};
     188
     189struct LuCheckStruct
     190{
     191    unsigned long  count;    // number of LuCheckData structures
     192    LuCheckData   *cdata;    //
     193};
     194
    180195#endif // lutypes_h
  • trunk/Lucide/SOURCE/plugins/ludoc/makefile

    r156 r215  
    5252export getSupportedExtensions
    5353export getDescription
     54export getCheckStruct
    5455export uniConvertSpChars
    5556export uniLigaturesLength
  • trunk/Lucide/SOURCE/plugins/lujpeg/lujpeg.cpp

    r214 r215  
    7878}
    7979
     80
    8081extern "C" LuDocument * _System createObject()
    8182{
     
    8788    return "JPG;JPEG;JPE";
    8889}
     90
     91LuCheckData   lcd = { 0, 2, (void *)"\xff\xd8" };
     92LuCheckStruct lcs = { 1, &lcd };
     93
     94extern "C" LuCheckStruct * _System getCheckStruct()
     95{
     96        return &lcs;
     97}
     98
    8999
    90100extern "C" char * _System getDescription()
  • trunk/Lucide/SOURCE/plugins/lujpeg/makefile

    r214 r215  
    4040export getSupportedExtensions
    4141export getDescription
     42export getCheckStruct
    4243| tmpmake.lnk >NUL
    4344    wlink @tmpmake.lnk
  • trunk/Lucide/SOURCE/plugins/lupoppler/lupoppler.cpp

    r213 r215  
    8585{
    8686    return "PDF";
     87}
     88
     89LuCheckData   lcd = { 0, 5, (void *)"%PDF-" };
     90LuCheckStruct lcs = { 1, &lcd };
     91
     92extern "C" LuCheckStruct * _System getCheckStruct()
     93{
     94        return &lcs;
    8795}
    8896
  • trunk/Lucide/SOURCE/plugins/lupoppler/makefile

    r156 r215  
    4141export getSupportedExtensions
    4242export getDescription
     43export getCheckStruct
    4344| tmpmake.lnk >NUL
    4445    wlink @tmpmake.lnk
  • trunk/Lucide/changelog

    r213 r215  
     11.02:
     2  - JPG plugin: added support for quality image scaling. 
     3  - If the filename does not have an extension or the extension is unknown,
     4    it will check file data to determine a suitable plugin (closed
     5    ticket #43).
     6
    171.01:
    28  - DJVU plugin: plugin may eat great amount of memory, fixed.
  • trunk/Lucide/readme

    r214 r215  
    1717         DJVU                  Scaling, PostScript printing
    1818
    19          JPG                   -
     19         JPG                   Scaling
    2020  --------------------------------------------------------------------------
    2121
     
    5353General: even/odd printing unavailable for postscript printing.
    5454          ( http://svn.netlabs.org/lucide/ticket/87#comment:4 )
    55 
    56 General: currently, Lucide determines the document type by extension, so
    57          files without extensions are not supported yet.
    58           ( http://svn.netlabs.org/lucide/ticket/43 )
    5955
    6056General: files with more than one dot in the filename are not displayed in
Note: See TracChangeset for help on using the changeset viewer.