home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format 98 / af098sub.adf / gallery.LZX / Gallery / Gallery.cpp < prev    next >
C/C++ Source or Header  |  1990-06-03  |  16KB  |  560 lines
  1. #define __VERSION__     "39"
  2. #define __REVISION__     "2"
  3. #define __NAME__            "Gallery"
  4. #define __AUTHOR__        "Markus Hillenbrand"
  5.  
  6. char *V = "$VER: " __NAME__ " " __VERSION__ "." __REVISION__ " (" __DATE__ ")";
  7.  
  8.  
  9. #include <string.h>
  10. #include <stdlib.h>
  11. #include <stdio.h>
  12.  
  13. #include <GUIC_Classes/GUIC_System.hpp>
  14. #include <GUIC_Classes/GUIC_Date.hpp>
  15. #include <GUIC_Classes/GUIC_Error.hpp>
  16. #include <GUIC_Classes/GUIC_Frame.hpp>
  17. #include <GUIC_Classes/GUIC_Application.hpp>
  18. #include <GUIC_Classes/GUIC_Screen.hpp>
  19. #include <GUIC_Classes/GUIC_Window.hpp>
  20. #include <GUIC_Classes/GUIC_Error.hpp>
  21. #include <GUIC_Classes/GUIC_Exceptions.hpp>
  22. #include <GUIC_Classes/GUIC_DirectoryExamine.hpp>
  23. #include <GUIC_Classes/GUIC_FileExamine.hpp>
  24. #include <GUIC_Classes/GUIC_File.hpp>
  25. #include <GUIC_Classes/GUIC_Key.hpp>
  26. #include <GUIC_Classes/GUIC_List.hpp>
  27. #include <GUIC_Classes/GUIC_Node.hpp>
  28. #include <GUIC_Classes/GUIC_Exceptions.hpp>
  29. #include <GUIC_Classes/GUIC_Button.hpp>
  30. #include <GUIC_Classes/GUIC_String.hpp>
  31. #include <GUIC_Classes/GUIC_Integer.hpp>
  32. #include <GUIC_Classes/GUIC_Slider.hpp>
  33. #include <GUIC_Classes/GUIC_Label.hpp>
  34. #include <GUIC_Classes/GUIC_SlidingInteger.hpp>
  35. #include <GUIC_Classes/GUIC_FileString.hpp>
  36. #include <GUIC_Classes/GUIC_PathString.hpp>
  37. #include <GUIC_Classes/GUIC_Message.hpp>
  38. #include <GUIC_Classes/GUIC_FileRequester.hpp>
  39. #include <GUIC_Classes/GUIC_ProgramArgs.hpp>
  40.  
  41. #define COPYRIGHT    "<SMALL> index file created with 'Gallery', (c) 1997 by <A HREF=\"http://www.student.uni-kl.de/~hillenbr\">Markus Hillenbrand</A> </SMALL>"
  42. #define FILEFILTER     "#?.(jpeg|jpg|gif|iff|ilbm|iff24|png)"
  43. #define MINLINES        3
  44. #define ROWS            5
  45. #define MAXLINES        200
  46.  
  47. GUIC_ListC errorList;
  48. int lastDay=0,lastMonth=0,lastYear=0;
  49.  
  50.  
  51. class GalleryEntryC : public GUIC_ObjectC
  52.     {
  53.     public:
  54.         GalleryEntryC    (STRPTR f, LONG s, int d, int m, int y)     { fileName=f; size=s; day=d; month=m; year=y; }
  55.         int compare     (GUIC_ObjectC &o);
  56.         String fileName;
  57.         int day,month,year;
  58.         LONG size;
  59.     protected:
  60.         void cleanUp(void) {};
  61.     };
  62.     
  63. int GalleryEntryC::compare(GUIC_ObjectC &o)
  64. { 
  65.     // First we must convert the argument to what it really is:
  66.     GalleryEntryC *g = (GalleryEntryC *)&o; 
  67.     
  68.     int result = strcmp(this->fileName, g->fileName); // Just compare the two file names
  69.     if (result == 0) return 0; // if there are equal, just return zero
  70.     
  71.     if (this->day && g->day) // then both are normal galleries without any subdirectories
  72.         {
  73.         return result;
  74.         }
  75.     else if (! this->day && ! g->day) // then both are galleries which contain subdirectories
  76.         {
  77.         return result;
  78.         }
  79.     else if (this->day) // this this is a normal entry and should be inserted after the gallery with subdirectories
  80.         {
  81.         return 1;
  82.         }
  83.     else return -1; // the other case
  84. }
  85.  
  86. String     makeThumbnail    (GUIC_FileExamineC &file)
  87. {
  88.     String fileName = file.getName();
  89.  
  90.     int i = fileName.length();
  91.     while (--i) if (fileName[i] == '.') break;
  92.  
  93.     String thumbName = fileName.left(i);
  94.     thumbName+="_.jpg";
  95.  
  96.     try
  97.         {
  98.         GUIC_FileExamineC f(thumbName);
  99.         if (f.newer(file)) return thumbName;
  100.         }
  101.     catch (GUIC_SystemX &e) { }
  102.  
  103.     String args = "<>NIL: \"" + fileName + "\" TO \"" + thumbName + "\" FORMAT JPEG QUALITY 90 BOXFIT 100 100";
  104.  
  105.     cout << " - creating thumbnail for file '" << fileName << "' ... " << flush;
  106.     BOOL result = GUIC_SystemC::runProgram("GfxCon_68020", 100000, args);
  107.     if (result) cout << "done." << endl; else cout << "error occured." << endl;
  108.  
  109.     return thumbName;
  110. }
  111. void         createGallery        (GUIC_ListC &fileList, STRPTR pattern, LONG maxLines)
  112. {
  113.     GalleryEntryC *key = (GalleryEntryC *)fileList.objectAt(1);
  114.     GUIC_FileExamineC firstFile(key->fileName);
  115.     String currentDir = firstFile.getPathPart();
  116.     
  117.     ldiv_t d = ldiv ( fileList.length(), ROWS );
  118.     int lines = d.quot;
  119.     if (d.rem) lines++;
  120.     
  121.     d = ldiv (lines, maxLines);
  122.     int galleries = d.quot;
  123.     if (d.rem) galleries++;
  124.  
  125.     cout << "Creating " << galleries << " galleries in directory '" << currentDir << "' " << endl;
  126.     
  127.     fileList.sort();
  128.     
  129.     GUIC_FileExamineC directoryName(currentDir);
  130.  
  131.     // Create the index file with the frames
  132.     GUIC_FileC gallery(currentDir, "index.html", GUIC_Write);
  133.     gallery.write("<TITLE>Gallery '");
  134.     gallery.write(directoryName.getFilePart());
  135.     gallery.writeLn("'</TITLE>");
  136.     gallery.writeLn("<FRAMESET COLS=150,*>");
  137.     gallery.writeLn("<FRAME NAME=F1 SRC=\"galleries.html\" MarginHeight=0 MarginWidth=0 Scrolling=\"auto\" FrameBorder=0>");
  138.     gallery.writeLn("<FRAME NAME=F2 SRC=\"index1.html\" MarginHeight=0 MarginWidth=0 Scrolling=\"auto\" FrameBorder=0>");
  139.     gallery.writeLn("</FRAMESET>");
  140.     
  141.     // now create the overview over the galleries
  142.     GUIC_FileC overview (currentDir, "galleries.html", GUIC_Write);
  143.     overview.writeLn("<HTML>");
  144.     overview.write("<H2>"); 
  145.     overview.write(directoryName.getFilePart());
  146.     overview.writeLn("</H2><BR>");
  147.     for (int i=1; i<=galleries; i++)
  148.         {
  149.         overview.write("<A HREF=\"index");
  150.         overview.write(i);
  151.         overview.write(".html\" TARGET=F2>Gallery ");
  152.         overview.write(i);
  153.         overview.writeLn("</A> <BR>");
  154.         }
  155.     overview.writeLn("</HTML>");
  156.  
  157.     // create each gallery
  158.     int count = 0;
  159.     for (i=1; i<=galleries; i++)
  160.         {
  161.         char filename[256];
  162.         sprintf(filename, "index%ld.html", i);
  163.         
  164.         GUIC_FileC indexFile(currentDir, filename, GUIC_Write);
  165.  
  166.         // write head and title    
  167.         indexFile.writeLn("<HTML>");
  168.         indexFile.writeLn("<HEAD>");
  169.     
  170.         indexFile.write("<TITLE> "); indexFile.write(directoryName.getFilePart());    indexFile.writeLn(" </TITLE>");
  171.         indexFile.writeLn("</HEAD>");
  172.         indexFile.write("<BODY");
  173.         if (pattern)
  174.             {
  175.             indexFile.write(" Background=\"");
  176.             indexFile.write(pattern);
  177.             indexFile.write("\"");
  178.             }
  179.         indexFile.writeLn(">");
  180.         
  181.         indexFile.write("<CENTER><H2>"); 
  182.         indexFile.write(directoryName.getFilePart()); 
  183.         indexFile.write("</H2> (Part ");
  184.         indexFile.write(i);
  185.         indexFile.write(" of ");
  186.         indexFile.write(galleries);
  187.         indexFile.writeLn(")<BR>");
  188.  
  189.         indexFile.writeLn("<HR>");
  190.         indexFile.writeLn("<TABLE Border=1 CellSpacing=4 CellPadding=4>");
  191.         
  192.         int boundary = count + ROWS*maxLines;
  193.         if (boundary>fileList.length()) boundary = fileList.length();
  194.         
  195.         for (int j=count; j<boundary; j++)
  196.             {
  197.             key = (GalleryEntryC *)fileList.objectAt(j+1);
  198.             GUIC_FileExamineC file(key->fileName);
  199.             String thumbName = "";
  200.  
  201.             // Create the thumbnail now            
  202.             try
  203.                 {
  204.                 thumbName = makeThumbnail(file);
  205.                 GUIC_FileExamineC thumb (thumbName);
  206.                 thumbName = thumb.getFilePart();
  207.                 }
  208.             catch (GUIC_SystemX &e) { GalleryEntryC *s = new GalleryEntryC(key->fileName,0,0,0,0); errorList.addTail(*s); }
  209.  
  210.             // Check the date
  211.             GUIC_DateC oldDate(lastDay,lastMonth,lastYear),*fileDate = file.getDate();;
  212.             if (fileDate->greater(oldDate) )
  213.                 {
  214.                 lastDay   = fileDate->getDay();
  215.                 lastMonth = fileDate->getMonth();
  216.                 lastYear  = fileDate->getYear();
  217.                 }
  218.  
  219.             // Check if there are 5 entries per line in the table
  220.             if (count++ % ROWS == 0) indexFile.write("<TR> ");
  221.  
  222.             // write the picture data                
  223.             indexFile.write("<TD> <CENTER> <IMG SRC=\"");
  224.             indexFile.write(thumbName);
  225.             indexFile.write("\"> <BR> <A HREF=\"");
  226.             indexFile.write(file.getFilePart());
  227.             indexFile.write("\"> ");
  228.             indexFile.write(file.getFilePart());
  229.             indexFile.write(" </A> <BR> Size: ");
  230.             indexFile.write(key->size);
  231.             indexFile.write(" <BR> Date: ");
  232.             indexFile.write(key->day);
  233.             indexFile.write(".");
  234.             indexFile.write(key->month);
  235.             indexFile.write(".");
  236.             indexFile.write(key->year);
  237.             indexFile.writeLn("</TD>");
  238.             }
  239.  
  240.         indexFile.writeLn("</TABLE>");
  241.  
  242.         indexFile.writeLn("<HR>");
  243.         indexFile.writeLn(COPYRIGHT);
  244.         indexFile.writeLn("</BODY>");
  245.         indexFile.writeLn("</HTML>");
  246.         }
  247. }
  248. void         createHTML        (GUIC_ListC &fileList, STRPTR pattern, BOOL hasParent)
  249. {
  250.     GalleryEntryC *key = (GalleryEntryC *)fileList.objectAt(1);
  251.     GUIC_FileExamineC firstFile(key->fileName);
  252.  
  253.     STRPTR currentDir = firstFile.getPathPart();
  254.     GUIC_FileC indexFile(currentDir, "index.html", GUIC_Write);
  255.     GUIC_FileExamineC directoryName(currentDir);
  256.  
  257.     String titleString = directoryName.getFilePart();
  258.     if (titleString == String("") ) titleString = directoryName.getName();
  259.  
  260.     cout << "Creating file '" << indexFile.getName() << "'" << endl;
  261.  
  262.     indexFile.writeLn("<HTML>");
  263.     indexFile.writeLn("<HEAD>");
  264.     indexFile.write("<TITLE> "); indexFile.write(titleString); indexFile.writeLn(" </TITLE>");
  265.     indexFile.writeLn("</HEAD>");
  266.     indexFile.write("<BODY");
  267.     if (pattern)
  268.         {
  269.         indexFile.write(" Background=\"");
  270.         indexFile.write(pattern);
  271.         indexFile.write("\"");
  272.         }
  273.     indexFile.writeLn(">");
  274.     indexFile.write("<CENTER><H1>"); indexFile.write(titleString); indexFile.writeLn("</H1>");
  275.     indexFile.writeLn("<HR><BR><BR>");
  276.     indexFile.writeLn("<TABLE Border=1 CellSpacing=4 CellPadding=4>");
  277.     indexFile.writeLn("<TR> <TH> <CENTER> <H3> Gallery Name </H3> </TH> <TH> <CENTER> <H3> Entries </H3> </TH> <TH> <CENTER> <H3> Last Update </H3> </TH>");
  278.     
  279.     fileList.sort();
  280.  
  281.     for (int i=1; i<=fileList.length(); i++)
  282.         {
  283.         key = (GalleryEntryC *)fileList.objectAt(i);
  284.         GUIC_FileExamineC file (key->fileName);
  285.  
  286.         indexFile.write("<TR> <TD> <CENTER> <A HREF=\"");
  287.         indexFile.write(file.getFilePart());
  288.         indexFile.write("/index.html\"");
  289.         indexFile.write("> ");
  290.         indexFile.write(file.getFilePart());
  291.         indexFile.write(" </A> </TD> <TD> <CENTER> ");
  292.         indexFile.write(key->size);
  293.         indexFile.write(" </TD> <TD> <CENTER> ");
  294.  
  295.         if (key->day)
  296.             {
  297.             indexFile.write(key->day);
  298.             indexFile.write(".");
  299.             indexFile.write(key->month);
  300.             indexFile.write(".");
  301.             indexFile.write(key->year);
  302.             }
  303.         else indexFile.write("(Directory)");
  304.         indexFile.writeLn(" </TD>");
  305.         }
  306.  
  307.     indexFile.writeLn("</TABLE>");
  308.  
  309.     indexFile.writeLn("<HR>");
  310.     indexFile.writeLn(COPYRIGHT);
  311.     indexFile.writeLn("</BODY>");
  312.     indexFile.writeLn("</HTML>");
  313. }
  314. int             scanDir                (STRPTR startDir, STRPTR pattern, LONG maxEntries)
  315. {
  316.     GUIC_ListC fileList,dirList;
  317.     GalleryEntryC *key = 0;
  318.     GUIC_FileExamineC *filex = 0;
  319.     int entries = 0;
  320.  
  321.     GUIC_FileExamineC *examine = new GUIC_FileExamineC(startDir);
  322.     if (!examine->isDirectory()) throw GUIC_SystemX("Error in function ScanDir (directory name expected).");
  323.     String dirName = examine->getName();
  324.     delete examine; examine=0;
  325.  
  326.     GUIC_DirectoryExamineC *direx= new GUIC_DirectoryExamineC(dirName);
  327.     BOOL hasSubDirs = direx->hasSubdirectory();
  328.     if (!hasSubDirs) direx->setFilter(FILEFILTER);
  329.  
  330.     try
  331.         {
  332.         while ( (filex = direx->examineNext()) )
  333.             {
  334.             String fileName  = filex->getName();
  335.             GUIC_DateC *date = filex->getDate();
  336.  
  337.             if (filex->isDirectory())
  338.                 {
  339.                 String newPattern = String("../") + String(pattern);
  340.                 int entriesInDir  = scanDir(fileName, newPattern, maxEntries);
  341.                 if (entriesInDir)
  342.                     {
  343.                     key = new GalleryEntryC(fileName, entriesInDir, lastDay, lastMonth, lastYear);
  344.                     if (!key) throw GUIC_MemoryX("Can't allocate memory for key.");
  345.                     dirList.addTail(*key);
  346.                     entries+=entriesInDir;
  347.                     }
  348.                 lastDay=0; lastMonth=0; lastYear=0;
  349.                 }
  350.             else if (! hasSubDirs && (fileName.right(5) != String("_.jpg") ) )
  351.                 {
  352.                 key = new GalleryEntryC(fileName, filex->getSize(), date->getDay(), date->getMonth(), date->getYear() );
  353.                 if (!key) throw GUIC_MemoryX("Can't allocate memory for key.");
  354.                 fileList.addTail(*key);
  355.                 entries++;
  356.                 }
  357.             }
  358.         }
  359.     catch (GUIC_SystemX &e) { cerr << "Exception caught while processing directory '" << direx->getName() << "': " << e.getMessage() << endl; }
  360.     delete direx;direx=0; /* Damit der lock auf das Verzeichnis freigegeben wird ! */
  361.  
  362.     if (dirList.length())     createHTML        (dirList,pattern, TRUE);
  363.     if (fileList.length())    createGallery        (fileList,pattern, maxEntries);
  364.  
  365.     while (fileList.length()) delete (GalleryEntryC *)fileList.remove(1);
  366.     while ( dirList.length()) delete (GalleryEntryC *) dirList.remove(1);
  367.  
  368.     return entries;
  369. }
  370.  
  371.  
  372. class GalleryWindowC : public GUIC_WindowC
  373.     {
  374.     public:
  375.         GalleryWindowC    (GUIC_ApplicationC *app, GUIC_ScreenC *screen);
  376.         ~GalleryWindowC (void);
  377.         BOOL action        (GUIC_EventC &);
  378.     private:
  379.         GUIC_ButtonC                *start, *quit;
  380.         GUIC_FileStringC            *pattern;
  381.         GUIC_PathStringC        *directory;
  382.         GUIC_SlidingIntegerC     *entries;
  383.         GUIC_FrameC                *frame;
  384.         GUIC_LabelC                *dirLabel, *pattLabel, *entrLabel;
  385.     };
  386.     
  387. GalleryWindowC::GalleryWindowC    (GUIC_ApplicationC *app, GUIC_ScreenC *screen) : GUIC_WindowC (-1,-1,50,19)
  388. {
  389.     frame            = new GUIC_FrameC                (1,1,48,14,"Gallery");
  390.  
  391.     dirLabel        = new GUIC_LabelC                (3,2,44,2,"Start _directory:");
  392.     directory        = new GUIC_PathStringC        (3,4,44,2,"");
  393.     
  394.     pattLabel    = new GUIC_LabelC                (3,6,44,2,"Background _pattern:");
  395.     pattern        = new GUIC_FileStringC            (3,8,44,2,"");
  396.  
  397.     entrLabel    = new GUIC_LabelC                (3,10,44,2,"_Number of entries in each gallery:");
  398.     entries        = new GUIC_SlidingIntegerC    (3,12,44,2,MINLINES,MAXLINES,10);
  399.     
  400.     start            = new GUIC_ButtonC                (1,16,15,2,"_Start");
  401.     quit                = new GUIC_ButtonC                (34,16,15,2,"_Quit");
  402.     
  403.     directory    ->setHelp("Directory path for the first index file.");
  404.     pattern    ->setHelp("Default background pattern in HTML pages.");
  405.     entries    ->setHelp("The maximum number of entries per page.");
  406.     start        ->setHelp("Start the creation of the gallery.");
  407.     quit            ->setHelp("Quit the program.");
  408.     
  409.     directory    ->setShortcut('d');
  410.     pattern    ->setShortcut('p');
  411.     entries    ->setShortcut('n');
  412.     start        ->setShortcut('s');
  413.     quit            ->setShortcut('q');
  414.     
  415.     add(frame);
  416.     add(dirLabel);
  417.     add(directory);
  418.     add(pattLabel);
  419.     add(pattern);
  420.     add(entrLabel);
  421.     add(entries);
  422.     add(start);
  423.     add(quit);
  424.     
  425.     app->addPrefs("GalleryWindow", this);
  426.     app->addPrefs("StartDirectory", directory);
  427.     app->addPrefs("BackgroundPattern", pattern);
  428.     app->addPrefs("NumberOfEntries", entries);
  429.  
  430.     setTitle("Gallery - (c) by Markus Hillenbrand");
  431.     setHelp(TRUE);
  432.     activate();
  433. }
  434. GalleryWindowC::~GalleryWindowC    (void)
  435. {
  436.     delete frame;
  437.     delete dirLabel;
  438.     delete directory;
  439.     delete pattLabel;
  440.     delete pattern;
  441.     delete entrLabel;
  442.     delete entries;
  443.     delete start;
  444.     delete quit;
  445. }
  446.  
  447. BOOL GalleryWindowC::action(GUIC_EventC &e)
  448. {
  449.     switch (e.id)
  450.         {
  451.         case GUIC_GadgetEvent:
  452.             if (e.gadget == (GUIC_GadgetC *)start)
  453.                 {
  454.                 if (! strcmp(directory->get(), "") )
  455.                     {
  456.                     GUIC_ErrorC e("You must at least enter a directory name!");
  457.                     e.request(this);
  458.                     }
  459.                 else 
  460.                     {
  461.                     sleep();
  462.                     GUIC_SystemC::openConsole();
  463.                     try 
  464.                         {
  465.                         scanDir (directory->get(), pattern->get(), entries->get() );
  466.                         }
  467.                     catch (GUIC_Exception &x) { GUIC_ErrorC e("Exception caught:", x.getMessage() ); e.request(this); }
  468.                     waken();
  469.                     }
  470.                 }
  471.             else if (e.gadget == (GUIC_GadgetC *)quit) 
  472.                 {
  473.                 dispose();
  474.                 }
  475.             return TRUE;
  476.             break;
  477.         case GUIC_CloseWindow: 
  478.             return TRUE;
  479.             break;
  480.         default:
  481.             cerr << "Got an event: " << e.id << endl;
  482.         }
  483.     
  484.     return FALSE;
  485. }
  486.  
  487.  
  488.  
  489. void         shell                    (void)
  490. {
  491.     LONG result[3] = { 0,0,0 };
  492.     GUIC_ProgramArgsC args;
  493.     if (! args.fit("STARTDIR/A,MAXENTRIES/N,BGPATTERN",result))
  494.         {
  495.         cerr << "Usage: Gallery <directory> [pattern]" << endl;
  496.         GUIC_SystemC::exit(GUIC_ExitError);
  497.         }
  498.     
  499.     LONG maxEntries = result[1] ? *(LONG *)result[1] : 0;
  500.     if (maxEntries < MINLINES)     maxEntries=MINLINES;
  501.     if (maxEntries > MAXLINES)    maxEntries=MAXLINES;
  502.     
  503.     scanDir((STRPTR)result[0], (STRPTR)result[2], maxEntries); 
  504.  
  505.     if (errorList.length())
  506.         {
  507.         cerr << "The following files could not be converted to a thumbnail:" << endl;
  508.         while (errorList.length())
  509.             {
  510.             GalleryEntryC *s = (GalleryEntryC *)errorList.remove(1);
  511.             cerr << "- " << s->fileName << endl;
  512.             delete s;
  513.             }
  514.         cerr << "Please check them and run 'Gallery' again." << endl;
  515.         }
  516. }
  517. void        workbench            (void)
  518. {
  519.     GUIC_ApplicationC    app("Gallery");
  520.  
  521.     app.setAuthor        (__AUTHOR__);
  522.     app.setVersion    (__VERSION__);
  523.     app.setRevision    (__REVISION__);
  524.     app.setDate        (__DATE__);
  525.     app.setTime        (__TIME__);
  526.     app.setInitializer    (TRUE);
  527.  
  528.     GUIC_ScreenC            screen;
  529.     GalleryWindowC     window(&app, &screen);
  530.     
  531.     screen.add(window);
  532.     app.add(screen);
  533.  
  534.     app.start();
  535.  
  536.     BOOL running = TRUE;
  537.     GUIC_EventC *event = 0;
  538.  
  539.     int count = 0;
  540.     
  541.     while (running && (event = app.wait()) )
  542.         {
  543.         // As we have only one window, it is not neccessary to check for the window id
  544.         if (event->id == GUIC_CloseWindow) 
  545.             {
  546.             GUIC_MessageC    message    ("Do you really want to quit ?", "Yes|No");
  547.             if (1 == message.request(*event->window)) running = FALSE;
  548.             }
  549.         }
  550.  
  551.     app.stop();
  552. }
  553.  
  554. void         main                    (int argc, char **argv)
  555. {
  556.     GUIC_SystemC::checkStackSize(20000);
  557.     if (GUIC_SystemC::runFromShell() ) shell(); else workbench();
  558. }
  559.  
  560.