home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / powervww / w.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-05  |  47.0 KB  |  1,420 lines
  1. //  ____________________________________________________
  2. // |                                                    |
  3. // |  Project:     POWER VIEW IDE                       |
  4. // |  File:        W.CPP                                |
  5. // |  Compiler:    WPP386 (10.6)                        |
  6. // |                                                    |
  7. // |  Subject:     Main module and PV interface         |
  8. // |                                                    |
  9. // |  Author:      Emil Dotchevski                      |
  10. // |____________________________________________________|
  11. //
  12. // E-mail: zajo@geocities.com
  13. // URL:    http://www.geocities.com/SiliconValley/Bay/3577
  14.  
  15. #define uses_ctype
  16. #define uses_stdio
  17. #define uses_string
  18.  
  19. #define uses_app
  20. #define uses_calc
  21. #define uses_comlin
  22. #define uses_desk
  23. #define uses_icons
  24. #define uses_init
  25. #define uses_editor
  26. #define uses_help
  27. #define uses_ht
  28. #define uses_stddlg
  29. #define uses_system
  30. #define uses_table
  31. #define uses_tetris
  32. #define uses_txt
  33.  
  34. #include "PVUSES.H"
  35. #include "COMPILE.H"
  36. #include "TLOG.H"
  37. #include "TPROJECT.H"
  38. #include "OPTIONS.H"
  39.  
  40. #define _DECLARE_W_H
  41.   #include "W.H"
  42. #undef  _DECLARE_W_H
  43.  
  44.  
  45. /*
  46. DEFINES
  47. */
  48.   #define MAX_CLOSED_FILES              64
  49.   #define MAX_MENU_CLOSED_FILES         9
  50.   #define MAX_CLOSED_FILE_LENGTH        25
  51.  
  52.   #define cmFILE_OPEN_CURS              0x1010
  53.   #define cmCLIPBOARD                   0x1011
  54.   #define cmCONDENSE                    0x1012
  55.   #define cmCOM_COMPILE                 0x1013
  56.   #define cmCOM_MAKE                    0x1014
  57.   #define cmCOM_BUILD                   0x1015
  58.   #define cmCOM_LINK                    0x1016
  59.   #define cmCOM_TIMECHECK               0x1017
  60.   #define cmCOM_NEXTERR                 0x1018
  61.   #define cmCOM_PREVERR                 0x1019
  62.   #define cmCOM_RUN                     0x101A
  63.   #define cmCOM_PARAMS                  0x101B
  64.   #define cmPRJ_OPEN                    0x1020
  65.   #define cmPRJ_CLOSE                   0x1021
  66.   #define cmPRJ_EXPORT                  0x1022
  67.   #define cmOPT_FAST                    0x1030
  68.   #define cmOPT_COM_CODE                0x1031
  69.   #define cmOPT_COM_ADVCODE             0x1032
  70.   #define cmOPT_COM_TARGET              0x1033
  71.   #define cmOPT_COM_SEGS                0x1034
  72.   #define cmOPT_COM_FP                  0x1035
  73.   #define cmOPT_COM_DEBUG               0x1036
  74.   #define cmOPT_COM_EXC                 0x1037
  75.   #define cmOPT_COM_OPT                 0x1038
  76.   #define cmOPT_COM_MSG                 0x1039
  77.   #define cmOPT_COM_PRE                 0x103A
  78.   #define cmOPT_COM_NAMES               0x103B
  79.   #define cmOPT_LINKER                  0x103C
  80.   #define cmOPT_EDITOR                  0x103D
  81.   #define cmOPT_DIRS                    0x103E
  82.   #define cmOPT_TOOLS                   0x103F
  83.   #define cmOPT_OPEN                    0x1040
  84.   #define cmOPT_SAVE                    0x1041
  85.   #define cmOPT_SAVE_AS                 0x1042
  86.   #define cmWIN_CALCULATOR              0x1050
  87.   #define cmWIN_TETRIS                  0x1051
  88.   #define cmWIN_PROJECT                 0x1052
  89.   #define cmWIN_LOG                     0x1053
  90.   #define cmWIN_DOS_SCREEN              0x1054
  91.   #define cmWINDOW_CLOSED_WINDOWS       0x1060
  92.   #define cmCLOSED_FILES                0x1061
  93.   #define cmTOOLS                       0x1070
  94.  
  95.  
  96. /*
  97. STRUCTS
  98. */
  99.   struct Tcmd_file
  100.   {
  101.     char *filename;
  102.     Tcmd_file *next;
  103.   };
  104.  
  105.  
  106. /*
  107. STATIC DATA
  108. */
  109.   static Tcmd_file *cmd_files=NULL;
  110.   static Tlb_list closed_files;
  111.   static char menu_titles[MAX_MENU_CLOSED_FILES][MAX_CLOSED_FILE_LENGTH+5];
  112.   static Tmenu_item *file_exit_ptr;
  113.   static Tmenu *file_menu_ptr;
  114.   static boolean disable_closed_files = 0;
  115.   static char wst_signature[] = "\r\nPower View IDE status file.\r\n\032";
  116.  
  117.  
  118. /*
  119. CONSTRUCT FILENAMES
  120. */
  121.   char *tmp_fname( char *result, char *fname )
  122.   {
  123.     char drive[_MAX_DRIVE];
  124.     char dir[_MAX_DIR];
  125.  
  126.     _splitpath( fname, drive, dir, NULL, NULL );
  127.     if( *drive || *dir )
  128.       strcpy( result, fname );
  129.     else
  130.     {
  131.       strcpy( result, default_directories.tmp_files );
  132.       strcat( result, fname );
  133.     }
  134.     return result;
  135.   }
  136.  
  137.   char *exe_fname( char *result, char *path )
  138.   {
  139.     char fname[_MAX_FNAME];
  140.     strcpy( result, default_directories.objects );
  141.     _splitpath( path, NULL, NULL, fname, NULL );
  142.     strcat( result, fname );
  143.     return result;
  144.   }
  145.  
  146.   char *exe_file( char *result, char *path )
  147.   {
  148.     return strcat( exe_fname(result,path), ".EXE" );
  149.   }
  150.  
  151.   char *obj_file( char *result, char *path )
  152.   {
  153.     char fname[_MAX_FNAME];
  154.     strcpy( result, default_directories.objects );
  155.     _splitpath( path, NULL, NULL, fname, NULL );
  156.     strcat( result, fname );
  157.     strcat( result, ".OBJ" );
  158.     return result;
  159.   }
  160.  
  161.   char *target_file( char *result, char *path )
  162.   {
  163.     char drive[_MAX_DRIVE];
  164.     char dir[_MAX_DIR];
  165.     _splitpath( path, drive, dir, NULL, NULL );
  166.     *result = 0;
  167.     if( *drive==0 && *dir==0 )
  168.       strcpy( result, default_directories.objects );
  169.     strcat( result, path );
  170.     return result;
  171.   }
  172.  
  173.  
  174. /*
  175. FILE I/O
  176. */
  177.   static void update_closed_files( void )
  178.   {
  179.     char buffer[_MAX_PATH];
  180.     if( disable_closed_files ) return;
  181.     update_menu( file_menu_ptr, file_exit_ptr );
  182.     if( closed_files.vcount ) mitem();
  183.     for( int i=0; i<closed_files.vcount && i<MAX_MENU_CLOSED_FILES; i++ )
  184.     {
  185.       Tedit_window_status *ew = (Tedit_window_status *)closed_files.getptr(i);
  186.       short_path( min_path(strcpy(buffer,ew->file_name)), MAX_CLOSED_FILE_LENGTH-1 );
  187.       sprintf( menu_titles[i], "|~%d %s", i+1, buffer );
  188.       _help( htFILE_CLOSED_FILES );
  189.       mitem( menu_titles[i], cmCLOSED_FILES+i );
  190.     }
  191.     if( closed_files.vcount )
  192.     {
  193.       _help(htWINDOW_CLOSED_WINDOWS);
  194.       mitem( "|~0 Closed windows list", cmWINDOW_CLOSED_WINDOWS );
  195.     }
  196.     update_menu( NULL, NULL );
  197.   }
  198.  
  199.   static void file_opened( Tedit_window *w )
  200.   {
  201.     if( disable_closed_files ) return;
  202.     char *fn = w->editor->text_editor->file_name;
  203.     if( *fn )
  204.       for( int i=0; i<closed_files.vcount; i++ )
  205.       {
  206.         Tedit_window_status *ew = (Tedit_window_status *)closed_files.getptr(i);
  207.         if( !strcmp(fn,ew->file_name) )
  208.         {
  209.           w->restore_status( *ew );
  210.           w->set_state( isICONIZED, 0 );
  211.           closed_files.del(i);
  212.           update_closed_files();
  213.           return;
  214.         }
  215.       }
  216.     w->resize( desktop_xl, desktop_yl - ( desktop_yl / 3 ) );
  217.   }
  218.  
  219.   static void file_closed( Tedit_window *w )
  220.   {
  221.     char *fn = w->editor->text_editor->file_name;
  222.     uint  bl = w->editor->text_editor->buf_len;
  223.     if( disable_closed_files || *fn==0 || bl==0 ) return;
  224.     Tedit_window_status ew;
  225.     w->save_status( ew );
  226.     closed_files.ins( 0, &ew );
  227.     while( closed_files.vcount>MAX_CLOSED_FILES )
  228.       closed_files.del( closed_files.vcount-1 );
  229.     update_closed_files();
  230.   }
  231.  
  232.   static boolean __editor_path = 0;
  233.   static char *search_file( char *buffer )
  234.   {
  235.     if( *buffer )
  236.     {
  237.       char filespec[_MAX_PATH], *b, *s;
  238.       char drive[_MAX_DRIVE];
  239.       char dir[_MAX_DIR];
  240.       char fname[_MAX_FNAME];
  241.       char ext[_MAX_EXT];
  242.       FILE *f = NULL;
  243.       fexpand( buffer );
  244.       add_ext( buffer, editor_options.extension );
  245.       strcpy( filespec, buffer );
  246.       f = fopen( buffer, "rb" );
  247.       if( __editor_path && f==NULL && current_editor!=NULL )
  248.       {
  249.         _splitpath( ((Tfile_editor *)current_editor->editor)->text_editor->file_name, drive, dir, NULL, NULL );
  250.         _splitpath( buffer, NULL, NULL, fname, ext );
  251.         _makepath( buffer, drive, dir, fname, ext );
  252.         f = fopen( buffer, "rb" );
  253.       }
  254.       __editor_path = 0;
  255.       for( s=b=default_directories.include; f==NULL; s++ )
  256.         if( *s==';' || *s==0 )
  257.         {
  258.           char saved = *s;
  259.           *s = 0;
  260.           _splitpath( filespec, NULL, NULL, fname, ext );
  261.           _splitpath( b, drive, dir, NULL, NULL );
  262.           _makepath( buffer, drive, dir, fname, ext );
  263.           f = fopen( buffer, "rb" );
  264.           *s = saved;
  265.           if( saved==0 ) break;
  266.           b = s+1;
  267.         }
  268.       if( f==NULL )
  269.         strcpy( buffer, filespec );
  270.       else
  271.         fclose( f );
  272.     }
  273.     return buffer;
  274.   }
  275.  
  276.   static Tedit_window *w_open_file( char *filespec )
  277.   {
  278.     if( editor_options.flags&efOPEN_INCLUDE ) search_file( filespec );
  279.     _help( htW_EDITOR );
  280.     return open_file( filespec );
  281.   }
  282.  
  283.   static Tedit_window *w_edit_file( char *filespec )
  284.   {
  285.     if( editor_options.flags&efOPEN_INCLUDE ) search_file( filespec );
  286.     _help( htW_EDITOR );
  287.     return edit_file( filespec );
  288.   }
  289.  
  290.  
  291. /*
  292. STATUS SAVE/RESTORE
  293. */
  294.   #define stEDITOR    0
  295.   #define stLOGOUT    1
  296.   #define stPROJECT   2
  297.   boolean save_status( void )
  298.   {
  299.     FILE *f;
  300.     Tedit_window_status st;
  301.     Tfile_editor *e;
  302.     Titem *p;
  303.     Twindow *w;
  304.     int n, old;
  305.     char kind;
  306.     uint sh;
  307.     boolean result;
  308.  
  309.     disable_closed_files = 1;
  310.     close_calculator();
  311.     f = fopen( "STATUS.W", "wb" );
  312.     p = desktop->first();
  313.     n = 0;
  314.     result = ( fwrite( wst_signature, sizeof( wst_signature ), 1, f ) == 1 ) &&
  315.              ( fwrite( &n, sizeof( n ), 1, f ) == 1 ) &&
  316. #ifndef NOMOUSE
  317.              ( fwrite( &toolbar_enabled, sizeof( toolbar_enabled ), 1, f ) == 1 ) &&
  318. #endif
  319.              ( fwrite( &time_check, sizeof(time_check), 1, f ) == 1 ) &&
  320.              ( fwrite( &desktop->iconize_x, sizeof( desktop->iconize_x ), 1, f ) == 1 ) &&
  321.              ( fwrite( &desktop->iconize_y, sizeof( desktop->iconize_y ), 1, f ) == 1 ) &&
  322.              ( fwrite( options_filename, sizeof( options_filename ), 1, f ) == 1 ) &&
  323.              ( fwrite( program_params, sizeof( program_params ), 1, f ) == 1 ) &&
  324.              ( fwrite( &closed_files.vcount, sizeof( closed_files.vcount ), 1, f ) == 1 );
  325.     for( uint i=0; result && i<closed_files.vcount; i++ )
  326.     {
  327.       Tedit_window_status *ew=(Tedit_window_status *)closed_files.getptr(i);
  328.       result = ( fwrite( ew, sizeof(Tedit_window_status), 1, f )==1 );
  329.     }
  330.     while( result && ( p != NULL ) )
  331.     {
  332.       sh = 0;
  333.       old = n;
  334.       e = open_editors;
  335.       while( !ferror( f ) && result && ( e != NULL ) )
  336.       {
  337.         if( ( e->text_editor != clipboard ) && ( e->owner == p ) )
  338.         {
  339.           kind = stEDITOR;
  340.           ( (Tedit_window *) e->owner )->save_status( st );
  341.           sh = ( (Twindow *)e->owner )->shortcut;
  342.           n++;
  343.           break;
  344.         }
  345.         e = e->next_editor;
  346.       }
  347.       if( ( project != NULL ) &&
  348.           ( ( w = (Twindow *) project->owner->owner ) == p ) )
  349.       {
  350.         kind = stPROJECT;
  351.         strcpy( st.file_name, project->filename );
  352.         n++;
  353.       }
  354.       else
  355.         if( ( w = (Twindow *) log->owner->owner ) == p )
  356.         {
  357.           kind = stLOGOUT;
  358.           n++;
  359.         }
  360.       if( w == p )
  361.       {
  362.         if( w->state( isICONIZED ) )
  363.         {
  364.           st.icon_x = w->x;
  365.           st.icon_y = w->y;
  366.         }
  367.         else
  368.         {
  369.           st.icon_x = w->icon_x;
  370.           st.icon_y = w->icon_y;
  371.         }
  372.         if( w->state( isICONIZED|wsMAXIMIZED ) )
  373.         {
  374.           st.x      = w->x_saved;
  375.           st.y      = w->y_saved;
  376.           st.xl     = w->xl_saved;
  377.           st.yl     = w->yl_saved;
  378.         }
  379.         else
  380.         {
  381.           st.x      = w->x;
  382.           st.y      = w->y;
  383.           st.xl     = w->xl;
  384.           st.yl     = w->yl;
  385.         }
  386.         st.state    = w->state_word;
  387.         sh          = w->shortcut;
  388.       }
  389.       if( n != old )
  390.         result = result &&
  391.           ( fwrite( &kind, sizeof( kind ), 1, f ) == 1 ) &&
  392.           ( fwrite( &st,   sizeof( st ),   1, f ) == 1 ) &&
  393.           ( fwrite( &sh,   sizeof( sh ),   1, f ) == 1 );
  394.       p = p->nextl();
  395.     }
  396.     if( result )
  397.     {
  398.       fseek( f, sizeof( wst_signature ), SEEK_SET );
  399.       result = ( fwrite( &n, sizeof( n ), 1, f ) == 1 );
  400.     }
  401.     fclose( f );
  402.     disable_closed_files = 0;
  403.     return result && !ferror( f );
  404.   }
  405.  
  406.   static boolean restore_status( void )
  407.   {
  408.     char tmp_signature[ sizeof( wst_signature ) ];
  409.     FILE *f;
  410.     Titem *focused;
  411.     Twindow *w;
  412.     Tedit_window_status st;
  413.     int i, n;
  414.     char kind;
  415.     uint sh;
  416.     uint _time_check;
  417.     uint closed_files_num;
  418. #ifndef NOMOUSE
  419.     uint _toolbar_enabled;
  420. #endif
  421.     Tset wn;
  422.     char options_fn[_MAX_PATH];
  423.     boolean result;
  424.  
  425.     f = fopen( "STATUS.W", "rb" );
  426.     if( f == NULL ) return 0;
  427.     memset( tmp_signature, 0, sizeof( tmp_signature ) );
  428.     fread( tmp_signature, sizeof( tmp_signature ), 1, f );
  429.     if( memcmp( tmp_signature, wst_signature, sizeof( tmp_signature ) ) )
  430.     {
  431.       _terror();
  432.       ok( "\"STATUS.W\" is not a Power View IDE status file." );
  433.       fclose( f );
  434.       return 0;
  435.     }
  436.     disable_closed_files = 1;
  437.     if( log != NULL ) DELETE( log->owner->owner );
  438.     log = NULL;
  439.     project_close();
  440.     *options_fn = 0;
  441.     result = ( fread( &n, sizeof( n ), 1, f ) == 1 ) &&
  442. #ifndef NOMOUSE
  443.              ( fread( &_toolbar_enabled, sizeof( _toolbar_enabled ), 1, f ) == 1 ) &&
  444. #endif
  445.              ( fread( &_time_check, sizeof(_time_check), 1, f ) == 1 ) &&
  446.              ( fread( &desktop->iconize_x, sizeof( desktop->iconize_x ), 1, f ) == 1 ) &&
  447.              ( fread( &desktop->iconize_y, sizeof( desktop->iconize_y ), 1, f ) == 1 ) &&
  448.              ( fread( options_fn, sizeof( options_fn ), 1, f ) == 1 ) &&
  449.              ( fread( program_params, sizeof( program_params ), 1, f ) == 1 ) &&
  450.              ( fread( &closed_files_num, sizeof( closed_files_num ), 1, f ) == 1 );
  451.     result = (result && closed_files_num<=MAX_CLOSED_FILES);
  452.     closed_files.clear();
  453.     for( i=0; result && i<closed_files_num; i++ )
  454.     {
  455.       Tedit_window_status ew;
  456.       if( result=(fread(&ew,sizeof(ew),1,f)==1) )
  457.         closed_files.add( &ew );
  458.     }
  459.     update_closed_files();
  460. #ifndef NOMOUSE
  461.     if( result && _toolbar_enabled!=toolbar_enabled ) broadcast( cmWINDOW_TOOLBAR );
  462. #endif
  463.     if( result && _time_check!=time_check ) broadcast( cmCOM_TIMECHECK );
  464.     focused = NULL;
  465.     ~wn;
  466.     for( i = 0; result && i < n; i++ )
  467.     {
  468.       result = ( fread( &kind, sizeof( kind ), 1, f ) == 1 ) &&
  469.                ( fread( &st,   sizeof( st ),   1, f ) == 1 ) &&
  470.                ( fread( &sh,   sizeof( sh ),   1, f ) == 1 );
  471.       if( !result ) break;
  472.       w = NULL;
  473.       switch( kind )
  474.       {
  475.         case stEDITOR:
  476.           _help( htW_EDITOR );
  477.           w = open_file( st );
  478.           break;
  479.         case stPROJECT:
  480.           open_project( st.file_name, 1 );
  481.           if( project != NULL )
  482.           {
  483.             w = (Twindow *) project->owner->owner;
  484.           w_setup:
  485.             w->set_state( st.state, 0 );
  486.             w->resize( st.xl, st.yl );
  487.             w->drag( st.x, st.y );
  488.             w->icon_x = st.icon_x;
  489.             w->icon_y = st.icon_y;
  490.             w->set_state( st.state, 1 );
  491.           }
  492.           break;
  493.         case stLOGOUT:
  494.           construct_log();
  495.           w = (Twindow *) log->owner->owner;
  496.           goto w_setup;
  497.         default:
  498.           result = 0;
  499.       }
  500.       if( w != NULL )
  501.       {
  502.         if( st.state & isSELECTED ) focused = w;
  503.         desktop->tab_next( -1 );
  504.         w->shortcut = sh;
  505.         if( sh ) wn<<sh;
  506.       }
  507.     }
  508.     win_nums = wn;
  509.     fclose( f );
  510.     if( result = result && !ferror( f ) )
  511.     {
  512.       if( focused != NULL ) focused->focus();
  513.       load_options( options_fn, 1 );
  514.     }
  515.     else
  516.       closed_files.clear();
  517.     if( log == NULL ) construct_log();
  518.     disable_closed_files = 0;
  519.     update_closed_files();
  520.     return result;
  521.   }
  522.   #undef stEDITOR
  523.   #undef stLOGOUT
  524.   #undef stPROJECT
  525.  
  526.  
  527. /*
  528. MENU FILE
  529. */
  530.   static void file_new( void )
  531.   {
  532.     _help( htW_EDITOR );
  533.     open_file( "" );
  534.   }
  535.  
  536.   static void file_open( void )
  537.   {
  538.     char f[_MAX_PATH];
  539.     static char dir_svd[_MAX_PATH] = "";
  540.     static uint filt_svd=0;
  541.     uint gf;
  542.     _multi_files();
  543.     _get_file_svd( dir_svd, filt_svd );
  544.     _filters( filter_str );
  545.     while( gf=get_file("Open a file",f) )
  546.       if( gf==cmOK )
  547.       {
  548.         w_open_file(f);
  549.         break;
  550.       }
  551.       else
  552.         open_file(f);
  553.   }
  554.  
  555.   static void file_open_at_cursor( void )
  556.   {
  557.     char buffer[_MAX_PATH];
  558.     if( current_editor == NULL ) return;
  559.     current_editor->get_word_str( buffer, _MAX_PATH - 1 );
  560.     if( *buffer )
  561.     {
  562.       __editor_path++;
  563.       w_edit_file( buffer );
  564.     }
  565.   }
  566.  
  567.   static void file_dos_shell( void )
  568.   {
  569.     exec( 0, getenv( "COMSPEC" ), "", "" );
  570.   }
  571.  
  572.  
  573. /*
  574. MENU SEARCH
  575. */
  576.   static boolean main_line( uint line_start, uint level )
  577.   {
  578.     uint n;
  579.     char c;
  580.  
  581.     if( ( current_editor->line_end( line_start ) - line_start ) < editor_options.condense_length ) return 0;
  582.     c = 0;
  583.     n = 0;
  584.     while( n <= level )
  585.     {
  586.       c = current_editor->buf_char( line_start );
  587.       if( c == ' ' )
  588.         n++;
  589.       else
  590.         if( c == '\t' )
  591.           n += tab_size - ( n % tab_size );
  592.         else
  593.           break;
  594.       line_start++;
  595.     }
  596.     c = toupper( c );
  597.     return ( n <= level ) && ( c >= 'A' ) && ( c <= 'Z' );
  598.   }
  599.  
  600.   static Tlist_box *condensed_list;
  601.   struct Tcondensed_list_data
  602.   {
  603.     uint offset; //offset of the text in the current edit buffer
  604.     uint level;  //condense level for that entry
  605.   };
  606.  
  607.   static void ins_condensed_line( uint line_start, uint level, uint index )
  608.   {
  609.     char buf1[51], buf2[51], *s, *d;
  610.     uint l, i;
  611.     Tcondensed_list_data cld;
  612.  
  613.     l = current_editor->line_end( line_start ) - line_start;
  614.     if( l > 50 ) l = 50;
  615.     current_editor->get_text( buf1, line_start, l );
  616.     while( buf1[--l] < ' ' );
  617.     buf1[++l] = 0;
  618.     memset( buf2, ' ', sizeof( buf2 ) ); buf2[50] = 0;
  619.     for( i = 0, s = buf1, d = buf2; *s && ( i < 50 ); s++ )
  620.     {
  621.       l = 1;
  622.       *d = *s;
  623.       if( *s == '\t' )
  624.       {
  625.         *d = ' ';
  626.         l = tab_size - ( i % tab_size );
  627.       }
  628.       i += l;
  629.       d += l;
  630.     }
  631.     cld.offset = line_start; cld.level = level;
  632.     _ldata( &cld );
  633.     condensed_list->ins( index, buf2 );
  634.   }
  635.  
  636.   #define cmCONDENSE_LEFT  cmUSER00
  637.   #define cmCONDENSE_RIGHT cmUSER01
  638.   static boolean condense_validator( uint command )
  639.   {
  640.     uint beg, end, o, i, this_level;
  641.     Tcondensed_list_data cld;
  642.  
  643.     if( command == cmCONDENSE_LEFT )
  644.     {
  645.       beg = end = condensed_list->vcurrent;
  646.       condensed_list->getdata( beg, &cld );
  647.       this_level = cld.level;
  648.       while( beg && ( cld.level >= this_level ) )
  649.         condensed_list->getdata( --beg, &cld );
  650.       if( ( beg == 0 ) && ( cld.level == this_level ) ) return 0;
  651.       condensed_list->getdata( end, &cld );
  652.       while( ( end < condensed_list->vcount ) && ( cld.level >= this_level ) )
  653.         condensed_list->getdata( ++end, &cld );
  654.       for( o = end-1; o > beg; o-- )
  655.         condensed_list->del( o );
  656.       condensed_list->at( beg );
  657.       return 0;
  658.     }
  659.     if( command == cmCONDENSE_RIGHT )
  660.     {
  661.       end = current_editor->buf_len;
  662.       beg = i = condensed_list->vcurrent + 1;
  663.       if( i < condensed_list->vcount )
  664.       {
  665.         condensed_list->getdata( i, &cld );
  666.         end = cld.offset;
  667.       }
  668.       condensed_list->getdata( condensed_list->vcurrent, &cld );
  669.       this_level = cld.level + 2;
  670.       if( this_level > 254 ) return 0;
  671.       o = current_editor->next_line( cld.offset );
  672.       for( ; o < end; o = current_editor->next_line( o ) )
  673.         if( main_line( o, this_level ) ) ins_condensed_line( o, this_level, i++ );
  674.       condensed_list->at( beg );
  675.       return 0;
  676.     }
  677.     return 1;
  678.   }
  679.  
  680.   static void condense( void )
  681.   {
  682.     uint n, o, p;
  683.     Tcondensed_list_data cld;
  684.  
  685.     if( current_editor == NULL ) return;
  686.     _help( htD_CONDENSED );
  687.     dialog( "Condensed display" );
  688.     validator( condense_validator );
  689.     _lsize( sizeof( Tcondensed_list_data ) );
  690.     condensed_list = list_box( "|~Main lines", n, 50, 13 );
  691.     condensed_list->scroll_ahead = 2;
  692.     condensed_list->set_flags( ifSTAY, 1 );
  693.     condensed_list->h_bar->set_flags( sfHANDLE_KEYBOARD, 0 );
  694.     p = current_editor->line_start( current_editor->cur_ptr );
  695.     while( p && !main_line( p, editor_options.condense_column ) )
  696.       p = current_editor->prev_line( p );
  697.     n = 0;
  698.     for( o = 0; o < current_editor->buf_len; o = current_editor->next_line( o ) )
  699.       if( main_line( o, editor_options.condense_column ) )
  700.       {
  701.         ins_condensed_line( o, editor_options.condense_column, condensed_list->vcount );
  702.         if( o == p ) n = condensed_list->vcount - 1;
  703.       }
  704.     condensed_list->at( n );
  705.     hor(); hspacing( 1 ); nl(); vspace(); _acenter();
  706.     kbutton( " Edit " );
  707.     button ( "  <<  ", cmCONDENSE_LEFT  )->shortcut = kLEFT;
  708.     button ( "  >>  ", cmCONDENSE_RIGHT )->shortcut = kRIGHT;
  709.     cbutton( "Cancel" );
  710.     hbutton( " Help " );
  711.     if( ( run() == cmOK ) && condensed_list->vcount )
  712.     {
  713.       current_editor->editor->owner->set_state( isICONIZED, 0 );
  714.       condensed_list->getdata( n, &cld );
  715.       current_editor->set_cur_ptr( cld.offset, 0 );
  716.       for( Tfile_editor *e=open_editors; e!=NULL; e=e->next_editor )
  717.         if( e->state( isFOCUSED ) )
  718.         {
  719.           e->track_cursor( 1 );
  720.           break;
  721.         }
  722.     }
  723.     DELETE( condensed_list );
  724.     condensed_list = NULL;
  725.   }
  726.   #undef cmCONDENSE_LEFT
  727.   #undef cmCONDENSE_RIGHT
  728.  
  729.  
  730. /*
  731. MENU WINDOWS
  732. */
  733.   static Tlist_box *closed_windows_lbox;
  734.   static boolean closed_windows_list_validator( uint command )
  735.   {
  736.     boolean result = 0;
  737.     if( command!=cmDELETE )
  738.       result = 1;
  739.     else
  740.       closed_windows_lbox->del( closed_windows_lbox->vcurrent );
  741.     closed_windows_lbox->cstate( cmDELETE, closed_windows_lbox->vcount );
  742.     closed_windows_lbox->cstate( cmOK, closed_windows_lbox->vcount );
  743.     return result;
  744.   }
  745.  
  746.   static void closed_windows_list( void )
  747.   {
  748.     uint cur_cf;
  749.     _help( htD_CLOSED_WINDOWS ); dialog( "Closed windows list" );
  750.     validator( closed_windows_list_validator );
  751.     closed_windows_lbox = list_box( "|~Closed windows", cur_cf, 35, 11, &closed_files );
  752.     nc();
  753.     kbutton( " Open " );
  754.     cbutton( " Done " );
  755.     button( "|~Delete", cmDELETE )->shortcut = kDEL;
  756.     hbutton( " Help " );
  757.     closed_windows_list_validator(0);
  758.     if( run()==cmOK && closed_files.vcount )
  759.     {
  760.       _help( htW_EDITOR );
  761.       open_file( ((Tedit_window_status *)closed_files.getptr(cur_cf))->file_name );
  762.     }
  763.     update_closed_files();
  764.   }
  765.  
  766.  
  767.   static void win_dos_screen( void )
  768.   {
  769.     Tevent ev;
  770.     char pv_mode, pv_char_size;
  771.  
  772.     pv_mode = scr_mode;
  773.     pv_char_size = scr_char_size;
  774. #ifndef NOMOUSE
  775.     hide_mouse();
  776. #endif
  777.     restore_dos_screen();
  778. #if !defined( NOICONS ) && !defined( HGR )
  779.     restore_graph_chars();
  780. #endif
  781. #if !defined( NOMOUSE ) && !defined( HGR )
  782.     restore_chars_def();
  783. #endif
  784.     clear_events();
  785.     do
  786.     {
  787.       get_event( ev );
  788.     }
  789.     while( ev.code!=evKEY_DOWN
  790. #ifndef NOMOUSE
  791.       && ev.code!=evMOUSE_DOWN
  792. #endif
  793.     );
  794. #if !defined( NOMOUSE ) && !defined( HGR )
  795.     save_chars_def();
  796. #endif
  797. #if !defined( NOICONS ) && !defined( HGR )
  798.     set_graph_chars();
  799. #endif
  800.     save_dos_screen();
  801.     set_video_mode( pv_mode, pv_char_size );
  802. #ifndef HGR
  803.     set_blink( 0 );
  804. #endif
  805. #ifndef NOMOUSE
  806.     show_mouse();
  807. #endif
  808.     idle( 0 );
  809.     application->redraw();
  810.     application->refresh_screen();
  811.  
  812.     if( ev.code == evKEY_DOWN )
  813.       while( ev.code != evKEY_UP   ) get_event( ev );
  814. #ifndef NOMOUSE
  815.     if( ev.code == evMOUSE_DOWN )
  816.       while( ev.code != evMOUSE_UP ) get_event( ev );
  817. #endif
  818.     clear_events();
  819.   }
  820.  
  821.  
  822. /*
  823. MENU HELP
  824. */
  825. #pragma off( unreferenced )
  826.   static void help_about( void )
  827.   {
  828.     static char program_id[] = "Program ID: PVIDE";
  829.     _title( "About" );
  830.     _inothing();
  831.     _tacenter();
  832.     _help( htABOUT );
  833.     ok( "POWER VIEW IDE\n\nVersion 5.00\n\nWritten by Emil Dotchevski\n\nUnregistered Shareware Version " );
  834.   }
  835. #pragma on( unreferenced )
  836.  
  837.  
  838. /*
  839. POWER VIEW INTERFACE
  840. */
  841.   static void cmdhandler( uint cmd_code, void *cmd_info )
  842.   {
  843.     switch( cmd_code )
  844.     {
  845.       case cmeEDITOR_OPEN:
  846.         file_opened( (Tedit_window *)cmd_info );
  847.         break;
  848.       case cmeEDITOR_CLOSE:
  849.         file_closed( (Tedit_window *)cmd_info );
  850.         break;
  851.       case cmFILE_NEW:
  852.         file_new();
  853.         break;
  854.       case cmFILE_OPEN:
  855.         file_open();
  856.         break;
  857.       case cmFILE_OPEN_CURS:
  858.         file_open_at_cursor();
  859.         break;
  860.       case cmFILE_DOS_SHELL:
  861.         file_dos_shell();
  862.         break;
  863.       case cmCLIPBOARD:
  864.         show_clipboard();
  865.         break;
  866.       case cmCONDENSE:
  867.         condense();
  868.         break;
  869.       case cmCOM_COMPILE:
  870.         project_compile();
  871.         break;
  872.       case cmCOM_MAKE:
  873.         project_make();
  874.         break;
  875.       case cmCOM_BUILD:
  876.         project_build();
  877.         break;
  878.       case cmCOM_LINK:
  879.         project_link();
  880.         break;
  881.       case cmCOM_TIMECHECK:
  882.         time_check = cmCOM_TIMECHECK-time_check;
  883.         break;
  884.       case cmCOM_NEXTERR:
  885.         log_nexterr();
  886.         break;
  887.       case cmCOM_PREVERR:
  888.         log_preverr();
  889.         break;
  890.       case cmCOM_RUN:
  891.         project_run();
  892.         break;
  893.       case cmCOM_PARAMS:
  894.         project_params();
  895.         break;
  896.       case cmPRJ_OPEN:
  897.         project_open();
  898.         break;
  899.       case cmPRJ_CLOSE:
  900.         project_close();
  901.         break;
  902.       case cmPRJ_EXPORT:
  903.         project_export();
  904.         break;
  905.       case cmOPT_FAST:
  906.         options_fast();
  907.         break;
  908.       case cmOPT_COM_CODE:
  909.         options_compiler_code_generation();
  910.         break;
  911.       case cmOPT_COM_ADVCODE:
  912.         options_compiler_advanced_code_generation();
  913.         break;
  914.       case cmOPT_COM_TARGET:
  915.         options_compiler_target();
  916.         break;
  917.       case cmOPT_COM_SEGS:
  918.         options_compiler_segment_registers();
  919.         break;
  920.       case cmOPT_COM_FP:
  921.         options_compiler_floating_point();
  922.         break;
  923.       case cmOPT_COM_DEBUG:
  924.         options_compiler_debugging();
  925.         break;
  926.       case cmOPT_COM_EXC:
  927.         options_compiler_exceptions_handling();
  928.         break;
  929.       case cmOPT_COM_OPT:
  930.         options_compiler_optimizations();
  931.         break;
  932.       case cmOPT_COM_MSG:
  933.         options_compiler_messages();
  934.         break;
  935.       case cmOPT_COM_PRE:
  936.         options_compiler_preprocess_files();
  937.         break;
  938.       case cmOPT_COM_NAMES:
  939.         options_compiler_names();
  940.         break;
  941.       case cmOPT_LINKER:
  942.         options_linker();
  943.         break;
  944.       case cmOPT_EDITOR:
  945.         options_editor();
  946.         break;
  947.       case cmOPT_DIRS:
  948.         options_directories();
  949.         break;
  950.       case cmOPT_TOOLS:
  951.         options_tools();
  952.         break;
  953.       case cmOPT_OPEN:
  954.         options_open();
  955.         break;
  956.       case cmOPT_SAVE:
  957.         options_save();
  958.         break;
  959.       case cmOPT_SAVE_AS:
  960.         options_save_as();
  961.         break;
  962.       case cmWINDOW_CLOSED_WINDOWS:
  963.         closed_windows_list();
  964.         break;
  965.       case cmWIN_CALCULATOR:
  966.         _help( htW_CALCULATOR ); calculator();
  967.         break;
  968.       case cmWIN_TETRIS:
  969.         _help( htW_TETRIS ); tetris();
  970.         break;
  971.       case cmWIN_PROJECT:
  972.         win_project();
  973.         break;
  974.       case cmWIN_LOG:
  975.         win_log();
  976.         break;
  977.       case cmWIN_DOS_SCREEN:
  978.         win_dos_screen();
  979.         break;
  980.       case cmHELP_ABOUT:
  981.         help_about();
  982.         break;
  983.       default:
  984.         if( cmd_code>=cmTOOLS && cmd_code<cmTOOLS+ot_tools->vcount )
  985.           exec_tool( cmd_code - cmTOOLS, "" );
  986.         if( cmd_code>=cmCLOSED_FILES && cmd_code<cmCLOSED_FILES+MAX_MENU_CLOSED_FILES )
  987.         {
  988.           int i = cmd_code-cmCLOSED_FILES;
  989.           if( i<closed_files.vcount )
  990.           {
  991.             _help( htW_EDITOR );
  992.             open_file( ((Tedit_window_status *)closed_files.getptr(i))->file_name );
  993.           }
  994.         }
  995.     }
  996.     boolean has_project = project != NULL;
  997.     boolean project_focused = has_project && project->state( isFOCUSED );
  998.     boolean has_editor = current_editor != NULL;
  999.     boolean not_empty = has_project && project->vcount;
  1000.     boolean has_program = has_project || has_editor;
  1001.     cstate( cmSAVE_ALL, open_editors!=NULL && open_editors->text_editor!=clipboard );
  1002.     cstate( cmWIN_PROJECT, has_project );
  1003.     cstate( cmCONDENSE, has_editor );
  1004.     cenable( cmPRJ_OPEN );
  1005.     cstate( cmPRJ_CLOSE, has_project );
  1006.     cstate( cmPRJ_EXPORT, has_project );
  1007.     cstate( cmCOM_COMPILE, has_editor );
  1008.     cstate( cmCOM_MAKE, has_program );
  1009.     cstate( cmCOM_BUILD, has_program );
  1010.     cstate( cmCOM_LINK, has_program );
  1011.     cstate( cmWINDOW_CLOSED_WINDOWS, closed_files.vcount );
  1012.     if( log != NULL )
  1013.     {
  1014.       cstate( cmCOM_NEXTERR, log->vcurrent + 1 < log->vcount );
  1015.       cstate( cmCOM_PREVERR, log->vcurrent > 0 );
  1016.     }
  1017.     cstate( cmCOM_RUN, has_program );
  1018.     cenable( cmCOM_PARAMS );
  1019.   }
  1020.  
  1021.   static void context_handler( int context )
  1022.   {
  1023. #ifndef NOMOUSE
  1024.     construct_toolbar();
  1025.     add_tool( "?", cmHELP, kF1 );
  1026.     add_tool( "Open", cmFILE_OPEN, kF3 );
  1027.     add_tool( "Save", cmFILE_SAVE, kF2 );
  1028.     add_tool( "Run", cmCOM_RUN, kF5 );
  1029.     add_tool( "Make", cmCOM_MAKE, kF9 );
  1030.     add_tool( "Compile", cmCOM_COMPILE, kALT_F9 );
  1031.     add_tool( "<<", cmCOM_PREVERR, kF7 );
  1032.     add_tool( ">>", cmCOM_NEXTERR, kF8 );
  1033.     local_key( toolbar, cmWIN_CALCULATOR, kCTRL_C );
  1034.     for( uint i = 0; i < ot_tools->vcount; i++ )
  1035.     {
  1036.       Ttools_entry *te = (Ttools_entry *) ot_tools->getptr( i );
  1037.       if( te->shortcut ) local_key( toolbar, cmTOOLS + i, te->shortcut );
  1038.     }
  1039. #endif
  1040.     menu();
  1041.     switch( context )
  1042.     {
  1043.       case cxCALCULATOR:
  1044.         _help( htEDIT_CUT );        mitem( "Cu|~t", "Shift+Del", cmCUT );
  1045.         _help( htEDIT_COPY );       mitem( "|~Copy", "Ctrl+Ins", cmCOPY );
  1046.         _help( htEDIT_PASTE );      mitem( "|~Paste", "Shift+Ins", cmPASTE );
  1047.         _help( htEDIT_CLEAR );      mitem( "C|~lear", "Del", cmCLEAR );
  1048.                                     mitem();
  1049. #ifndef NOMOUSE
  1050.                                     add_tool( "Cut", cmCUT, kSHIFT_DEL );
  1051.                                     add_tool( "Copy", cmCOPY, kCTRL_INS  );
  1052.                                     add_tool( "Paste", cmPASTE, kSHIFT_INS );
  1053.                                     add_tool( "Clear", cmCLEAR, kCTRL_DEL );
  1054. #endif
  1055.         break;
  1056.       case cxEDITOR:
  1057.         _help( htEDIT_UNDO );       mitem( "|~Undo", "Alt+BkSp", cmUNDO );
  1058.         _help( htSEARCH_FIND );     mitem( "|~Find...", "Ctrl+Q F", cmeFIND );
  1059.         _help( htSEARCH_REPLACE );  mitem( "R|~eplace...", "Ctrl+Q A", cmeREPLACE );
  1060.         _help( htSEARCH_LINE );     mitem( "|~Go to line...", "Ctrl+J", cmeGOTO_LINE );
  1061.         _help( htSEARCH_CONDENSE ); mitem( "Co|~ndense...", "Esc", cmCONDENSE );
  1062.         _help( htSEARCH_FILE );     mitem( "File at |~cursor", "Ctrl+Enter", cmFILE_OPEN_CURS );
  1063.                                     mitem();
  1064.         _help( htEDIT_CUT );        mitem( "Cu|~t", "Shift+Del", cmCUT );
  1065.         _help( htEDIT_COPY );       mitem( "|~Copy", "Ctrl+Ins", cmCOPY );
  1066.         _help( htEDIT_PASTE );      mitem( "|~Paste", "Shift+Ins", cmPASTE );
  1067.         _help( htEDIT_CLEAR );      mitem( "C|~lear", "Del", cmCLEAR );
  1068.                                     mitem();
  1069. #ifndef NOMOUSE
  1070.                                     add_tool( "Cut", cmCUT, kSHIFT_DEL );
  1071.                                     add_tool( "Copy", cmCOPY, kCTRL_INS  );
  1072.                                     add_tool( "Paste", cmPASTE, kSHIFT_INS );
  1073.                                     add_tool( "Clear", cmCLEAR, kCTRL_DEL );
  1074. #endif
  1075.         break;
  1076.       case cxLOG:
  1077.         _help( htEDIT_COPY );       mitem( "|~Copy", "Ctrl+Ins", cmLOG_CLIP_COPY );
  1078.         _help( htEDIT_CLEAR );      mitem( "C|~lear", "Ctrl+Del", cmLOG_CLEAR );
  1079.                                     mitem();
  1080. #ifndef NOMOUSE
  1081.                                     add_tool( "Copy", cmLOG_CLIP_COPY, kCTRL_INS );
  1082.                                     add_tool( "Clear", cmLOG_CLEAR, kCTRL_DEL );
  1083. #endif
  1084.         break;
  1085.       case cxPROJECT:
  1086.         _help( htPROJECT_ADD );     mitem( "|~Add entry...", "Ctrl+A", cmPRJ_ADD );
  1087.         _help( htPROJECT_INS );     mitem( "|~Insert entry...", "Ins", cmPRJ_INS );
  1088.         _help( htPROJECT_DEL );     mitem( "|~Delete entry...", "Del", cmPRJ_DEL );
  1089.         _help( htPROJECT_EDIT );    mitem( "|~Edit file", "Enter", cmPRJ_EDIT_FILE );
  1090.                                     mitem();
  1091.         _help( htPROJECT_LOCAL );   mitem( "|~Local options...", "Ctrl+O", cmPRJ_OPTIONS );
  1092.         _help( htPROJECT_DEPENDS ); mitem( "De|~pends...", "Ctrl+D", cmPRJ_DEPENDS );
  1093.                                     mitem();
  1094.         _help( htPROJECT_EXPORT );  mitem( "E|~xport make file...", cmPRJ_EXPORT );
  1095.                                     mitem();
  1096. #ifndef NOMOUSE
  1097.                                     add_tool( "Add", cmPRJ_ADD, kCTRL_A );
  1098.                                     add_tool( "Ins", cmPRJ_INS, kINS );
  1099.                                     add_tool( "Del", cmPRJ_DEL, kDEL );
  1100.                                     add_tool( "Options", cmPRJ_OPTIONS, kCTRL_O );
  1101.                                     local_key( toolbar, cmPRJ_DEPENDS, kCTRL_D );
  1102. #endif
  1103.     }
  1104.     if( context!=cxTETRIS )
  1105.     {
  1106.       _help( htWINDOW_LIST );       mitem( "|~Windows list...", "Ctrl+Esc", cmWINDOW_LIST );
  1107.       if( closed_files.vcount )
  1108.       _help(htWINDOW_CLOSED_WINDOWS);mitem( "Clo|~sed windows list", cmWINDOW_CLOSED_WINDOWS );
  1109.     }
  1110. #ifndef NOMOUSE
  1111.                                     add_tool( "Exit", cmFILE_EXIT, kALT_X );
  1112. #endif
  1113.     construct_local_menu( endm() );
  1114.   }
  1115.  
  1116.   static void w_editors_supervisor( char *file_name, uint where, int bytes, int lines )
  1117.   {
  1118.     if( log != NULL )
  1119.       log->editors_supervisor( file_name, where, bytes, lines );
  1120.   }
  1121.  
  1122.  
  1123. /*
  1124. STARTUP
  1125. */
  1126.   static void show_syntax( void )
  1127.   {
  1128.     restore_dos_screen();
  1129. #if !defined( NOICONS ) && !defined( HGR )
  1130.     restore_graph_chars();
  1131. #endif
  1132.     printf("\
  1133. Power View IDE written by Emil Dotchevski\n\
  1134. \n\
  1135. Command line syntax:\n\
  1136.   W [switches] [parameters] [<filename>[%s]] ...\n\
  1137. \n\
  1138. Switches:\n\
  1139.   /?     This help message\n\
  1140.   /BW    Use black-and-white palette in color text modes\n\
  1141.   /COLOR Use color palette in black-and-white text modes\n\
  1142.   /M+    Use arrow mouse pointer\n\
  1143.   /M-    Use bar mouse pointer\n\
  1144.   /G+    Use graphical screen controls\n\
  1145.   /G-    Don't use graphical screen controls\n\
  1146. \n\
  1147. Parameters:\n\
  1148.   /INI:<filename>[.INI] Specify init file to use\n\
  1149.   /OPT:<filename>[.PVO] Specify options file to use\n\
  1150. \n\
  1151. Note: Filename wilcards are allowed\n", editor_options.extension );
  1152.     exit( 1 );
  1153.   }
  1154.  
  1155.   static void proceed_command_line( void )
  1156.   {
  1157.     char s[_MAX_PATH];
  1158.     FILE *f;
  1159.  
  1160.     if( param_spec( "/OPT:", s ) )
  1161.     {
  1162.       add_ext( s, ".PVO" );
  1163.       fexpand( s );
  1164.       f = fopen( s, "rb" );
  1165.       if( f == NULL )
  1166.       {
  1167.         _terror();
  1168.         ok( "Can't read options file %s", s );
  1169.         exit( 1 );
  1170.       }
  1171.       fclose( f );
  1172.       load_options( s, 1 );
  1173.     }
  1174.     if( param_opt("/?") ) show_syntax();
  1175.     while( param_filenames(s,editor_options.extension) )
  1176.     {
  1177.       Tcmd_file *x=NEW(Tcmd_file);
  1178.       x->filename=STRDUP(s);
  1179.       x->next=cmd_files;
  1180.       cmd_files=x;
  1181.     }
  1182.   }
  1183.  
  1184.   static void init_options( void )
  1185.   {
  1186.     char *p;
  1187.  
  1188.     if( *options_filename == 0 )
  1189.     {
  1190.       p = strchr( startup_path, 0 );
  1191.       if( !load_options( "SAVED.PVO", 0 ) )
  1192.       {
  1193.         strcpy( p, "SAVED.PVO" );
  1194.         load_options( startup_path, 0 );
  1195.       }
  1196.       if( *options_filename == 0 )
  1197.       {
  1198.         strcpy( p, "SAVED.PVO" );
  1199.         options_file_changed( startup_path );
  1200.         *options_filename=0;
  1201.       }
  1202.       *p = 0;
  1203.     }
  1204.   }
  1205.  
  1206.   void init_main_menu( void )
  1207.   {
  1208.     uint i;
  1209.     static char buf[15][10];
  1210.     Ttools_entry *te;
  1211.                                menu();
  1212.     _help( htMENU_FILE );        submenu( " |~File " );
  1213.     _help( htFILE_NEW );           mitem( "|~New", cmFILE_NEW );
  1214.     _help( htFILE_OPEN );          mitem( "|~Open...", "F3", cmFILE_OPEN );
  1215.     _help( htFILE_SAVE );          mitem( "|~Save", "F2", cmFILE_SAVE );
  1216.     _help( htFILE_SAVE_AS );       mitem( "Save |~as...", cmFILE_SAVE_AS );
  1217.     _help( htFILE_SAVE_ALL );      mitem( "Save a|~ll", "Ctrl+F2", cmSAVE_ALL );
  1218.                                    mitem();
  1219.     _help( htFILE_DOS_SHELL );     mitem( "|~DOS shell", cmFILE_DOS_SHELL );
  1220.     _help( htFILE_EXIT );
  1221.                  file_exit_ptr =   mitem( "E|~xit", "Alt+X", cmFILE_EXIT );
  1222.                  file_menu_ptr = endm();
  1223.     _help( htMENU_EDIT );        submenu( " |~Edit " );
  1224.     _help( htEDIT_UNDO );          mitem( "|~Undo", "Alt+BkSp", cmUNDO );
  1225.                                    mitem();
  1226.     _help( htEDIT_CUT );           mitem( "Cu|~t", "Shift+Del", cmCUT );
  1227.     _help( htEDIT_COPY );          mitem( "|~Copy", "Ctrl+Ins", cmCOPY );
  1228.     _help( htEDIT_PASTE );         mitem( "|~Paste", "Shift+Ins", cmPASTE );
  1229.     _help( htEDIT_CLEAR );         mitem( "C|~lear", "Del", cmCLEAR );
  1230.                                    mitem();
  1231.     _help( htEDIT_CLIPBOARD );     mitem( "|~Show clipboard", cmCLIPBOARD );
  1232.                                  endm();                           
  1233.     _help( htMENU_SEARCH );      submenu( " |~Search " );
  1234.     _help( htSEARCH_FIND );        mitem( "|~Find...", "Ctrl+Q F", cmeFIND );
  1235.     _help( htSEARCH_REPLACE );     mitem( "|~Replace...", "Ctrl+Q A", cmeREPLACE );
  1236.     _help( htSEARCH_AGAIN );       mitem( "|~Search again", "Ctrl+L", cmeSEARCH_AGAIN );
  1237.     _help( htSEARCH_LINE );        mitem( "|~Go to line...", "Ctrl+J", cmeGOTO_LINE );
  1238.                                    mitem();
  1239.     _help( htSEARCH_CONDENSE );    mitem( "|~Condense...", "Esc", cmCONDENSE );
  1240.                                  endm();                           
  1241.     _help( htMENU_COMPILE );     submenu( " |~Compile " );
  1242.     _help( htCOMPILE_COMPILE );    mitem( "|~Compile", "Alt+F9", cmCOM_COMPILE );
  1243.     _help( htCOMPILE_MAKE );       mitem( "|~Make", "F9", cmCOM_MAKE );
  1244.     _help( htCOMPILE_BUILD );      mitem( "|~Build all", cmCOM_BUILD );
  1245.     _help( htCOMPILE_LINK );       mitem( "|~Link", cmCOM_LINK );
  1246.     _help( htCOMPILE_TIMECHECK );  mitem( "|~Time validity check", time_check, cmCOM_TIMECHECK );
  1247.                                    mitem();
  1248.     _help( htCOMPILE_NEXT );       mitem( "|~Next message", "F8", cmCOM_NEXTERR );
  1249.     _help( htCOMPILE_PREVIOUS );   mitem( "|~Previous message", "F7", cmCOM_PREVERR );
  1250.                                    mitem();
  1251.     _help( htCOMPILE_RUN );        mitem( "|~Run", "F5", cmCOM_RUN );
  1252.     _help( htCOMPILE_PARAMS );     mitem( "P|~arameters...", cmCOM_PARAMS );
  1253.                                  endm();                           
  1254.     _help( htMENU_PROJECT );     submenu( " |~Project " );
  1255.     _help( htPROJECT_OPEN );       mitem( "|~Open...", cmPRJ_OPEN );
  1256.     _help( htPROJECT_CLOSE );      mitem( "|~Close", cmPRJ_CLOSE );
  1257.                                    mitem();
  1258.     _help( htPROJECT_ADD );        mitem( "|~Add entry...", "Ctrl+A", cmPRJ_ADD );
  1259.     _help( htPROJECT_INS );        mitem( "|~Insert entry...", "Ins", cmPRJ_INS );
  1260.     _help( htPROJECT_EDIT );       mitem( "|~Edit file", "Enter", cmPRJ_EDIT_FILE );
  1261.     _help( htPROJECT_DEL );        mitem( "|~Delete entry...", "Del", cmPRJ_DEL );
  1262.                                    mitem();
  1263.     _help( htPROJECT_LOCAL );      mitem( "|~Local options...", "Ctrl+O", cmPRJ_OPTIONS );
  1264.     _help( htPROJECT_DEPENDS );    mitem( "De|~pends...", "Ctrl+D", cmPRJ_DEPENDS );
  1265.                                    mitem();
  1266.     _help( htPROJECT_EXPORT );     mitem( "E|~xport make file...", cmPRJ_EXPORT );
  1267.                                  endm();                           
  1268.     _help( htMENU_OPTIONS );     submenu( " |~Options " );
  1269.     _help( htOPTIONS_FAST );       mitem( "|~Fast...", cmOPT_FAST );
  1270.     _help( htOPTIONS_COMPILER );   submenu( "|~Compiler" );
  1271.     _help( htCOMPILER_CODE );        mitem( "|~Code...", cmOPT_COM_CODE );
  1272.     _help( htCOMPILER_ADV_CODE );    mitem( "|~Advanced code...", cmOPT_COM_ADVCODE );
  1273.     _help( htCOMPILER_TARGET );      mitem( "|~Build target...", cmOPT_COM_TARGET );
  1274.     _help( htCOMPILER_OPTIMIZATIONS);mitem( "|~Optimizations...", cmOPT_COM_OPT );
  1275.     _help( htCOMPILER_DEBUGGING );   mitem( "|~Debugging...", cmOPT_COM_DEBUG );
  1276.     _help( htCOMPILER_FLOATING );    mitem( "|~Floating-point...", cmOPT_COM_FP );
  1277.     _help( htCOMPILER_EXCEPTIONS );  mitem( "C++ e|~xceptions...", cmOPT_COM_EXC );
  1278.     _help( htCOMPILER_SEGMENTS );    mitem( "|~Segment regs...", cmOPT_COM_SEGS );
  1279.     _help( htCOMPILER_PREPROCESSOR); mitem( "|~Preprocessor...", cmOPT_COM_PRE );
  1280.     _help( htCOMPILER_NAMES );       mitem( "|~Names...", cmOPT_COM_NAMES );
  1281.     _help( htCOMPILER_MESSAGES );    mitem( "|~Messages...", cmOPT_COM_MSG );
  1282.                                    endm();
  1283.     _help( htOPTIONS_LINKER );     mitem( "|~Linker...", cmOPT_LINKER );
  1284.     _help( htOPTIONS_EDITOR );     mitem( "|~Editor...", cmOPT_EDITOR );
  1285.     _help( htOPTIONS_DIRS );       mitem( "|~Directories...", cmOPT_DIRS );
  1286.     _help( htOPTIONS_TOOLS );      mitem( "|~Tools...", cmOPT_TOOLS );
  1287.                                    mitem();
  1288.     _help( htOPTIONS_OPEN );       mitem( "|~Open...", cmOPT_OPEN );
  1289.     _help( htOPTIONS_SAVE );       mitem( "|~Save", short_options_filename, cmOPT_SAVE );
  1290.     _help( htOPTIONS_SAVE_AS );    mitem( "Save |~as...", cmOPT_SAVE_AS );
  1291.                                  endm();                           
  1292.     _help( htMENU_TOOLS );       submenu( " |~Tools " );
  1293.                                    if( ot_tools->vcount > 0 )
  1294.                                    {
  1295.                                      for( i = 0; i < ot_tools->vcount; i++ )
  1296.                                      {
  1297.                                        te = (Ttools_entry *) ot_tools->getptr( i );
  1298.                                        if( te->shortcut )
  1299.                                        {
  1300.                                          sprintf( buf[i], "Shift+F%-2d", ( te->shortcut - 0x5300 ) >> 8 );
  1301.     _help( htTOOLS_TOOL );               mitem( te->title, buf[i], cmTOOLS+i );
  1302.                                        }
  1303.                                        else
  1304.                                        {
  1305.     _help( htTOOLS_TOOL );               mitem( te->title, cmTOOLS+i );
  1306.                                        }
  1307.                                      }
  1308. #ifndef NOMOUSE
  1309.                                      mitem();
  1310. #endif
  1311.                                    }
  1312. #ifndef NOMOUSE
  1313.     _help( htTOOLS_TOOLBAR );      mitem( "Tool|~bar", toolbar_enabled, cmWINDOW_TOOLBAR );
  1314. #endif
  1315.                                  endm();                           
  1316.     _help( htMENU_WINDOWS );     submenu( " |~Windows " );
  1317.     _help( htWINDOW_TILE );        mitem( "|~Tile", cmWINDOW_TILE );
  1318.     _help( htWINDOW_CASCADE );     mitem( "C|~ascade", cmWINDOW_CASCADE );
  1319.     _help( htWINDOW_CLOSE_ALL );   mitem( "Cl|~ose all", cmWINDOW_CLOSE_ALL );
  1320.     _help( htWINDOW_ARRANGE );     mitem( "Arrange |~icons", cmWINDOW_ARRANGE_ICONS );
  1321.     _help( htWINDOW_REFRESH );     mitem( "|~Refresh display", cmWINDOW_REFRESH );
  1322.                                    mitem();
  1323.     _help( htWINDOW_NEXT );        mitem( "|~Next", "F6", cmWINDOW_NEXT );
  1324.     _help( htWINDOW_PREVIOUS );    mitem( "Pre|~vious", "Ctrl+F6", cmWINDOW_PREVIOUS );
  1325.     _help( htWINDOW_LIST );        mitem( "|~List...", "Ctrl+Esc", cmWINDOW_LIST );
  1326.     _help(htWINDOW_CLOSED_WINDOWS);mitem( "Clo|~sed windows list", cmWINDOW_CLOSED_WINDOWS );
  1327.                                    mitem();
  1328.     _help( htWINDOW_PROJECT );     mitem( "|~Project", "Ctrl+P", cmWIN_PROJECT );
  1329.     _help( htWINDOW_LOGOUT );      mitem( "Lo|~g", "Ctrl+G", cmWIN_LOG );
  1330.     _help( htWINDOW_CALCULATOR );  mitem( "|~Calculator", "Ctrl+C", cmWIN_CALCULATOR );
  1331.     _help( htWINDOW_TETRIS );      mitem( "T|~etris...", cmWIN_TETRIS );
  1332.     _help( htWINDOW_DOS_SCREEN );  mitem( "|~DOS screen", "F4", cmWIN_DOS_SCREEN );
  1333.                                  endm();                           
  1334.     _help( htMENU_HELP );        submenu( " |~Help " );
  1335.     _help( htMHELP_USING_HELP );   mitem( "|~Help using help...", cmHELP_USING );
  1336.     _help( htMHELP_CONTENTS );     mitem( "|~Contents...", cmHELP_CONTENTS );
  1337.                                    mitem();
  1338.     _help( htMHELP_ABOUT );        mitem( "|~About...", cmHELP_ABOUT );
  1339.                                  endm();                      
  1340.           construct_main_menu( endm() );
  1341.     update_closed_files();
  1342.   }
  1343.  
  1344.   void init_w( void )
  1345.   {
  1346.     char *p;
  1347.     closed_files.data_size = TEDIT_WINDOW_STATUS_SIZE;
  1348.     cpp_hilight_extensions = editor_options.cpp_extensions;
  1349.     asm_hilight_extensions = editor_options.asm_extensions;
  1350.     p = strchr( startup_path, 0 );
  1351.     strcpy( p, "W.HLP" );
  1352.     set_help_filename( startup_path );
  1353.     *p = 0;
  1354.     install_context_handler( context_handler );
  1355.     cmd_handler( cmdhandler );
  1356.     _lsize( TTOOLS_ENTRY_SIZE ); ot_tools = NEW( Tlb_list );
  1357.     construct_log();
  1358.     log->set_state( isHIDDEN, 1 );
  1359. #ifndef NOPARAM
  1360.     proceed_command_line();
  1361. #endif
  1362.     init_main_menu();
  1363.     global_key( cmCONDENSE,        kESC        );
  1364.     global_key( cmFILE_OPEN_CURS,  kCTRL_ENTER );
  1365.     global_key( cmWINDOW_LIST,     kCTRL_ESC   );
  1366.     global_key( cmWINDOW_LIST,     kALT_0      );
  1367.     global_key( cmHELP_PREVIOUS,   kALT_F1     );
  1368.     global_key( cmWIN_DOS_SCREEN,  kF4         );
  1369.     global_key( cmWINDOW_NEXT,     kF6         );
  1370.     global_key( cmWINDOW_PREVIOUS, kCTRL_F6    );
  1371.     global_key( cmWINDOW_NEXT,     kCTRL_TAB   );
  1372.     global_key( cmWIN_PROJECT,     kCTRL_P     );
  1373.     global_key( cmWIN_LOG,         kCTRL_G     );
  1374.     global_key( cmeGOTO_LINE,      kCTRL_J     );
  1375.     global_key( cmSAVE_ALL,        kCTRL_F2    );
  1376.     filter_str = "C++ files (*.cpp)|C files (*.c)|Header files (*.h)|Assembler files (*.asm)";
  1377.   }
  1378.  
  1379.  
  1380. void main( int argc, char *argv[] )
  1381. {
  1382.   char drive[_MAX_DRIVE];
  1383.   char dir[_MAX_DIR];
  1384.   printf( "\n" );
  1385.   _splitpath( argv[0], drive, dir, NULL, NULL );
  1386.   strcpy( startup_path, drive );
  1387.   strcat( startup_path, dir );
  1388.   init_startup( argc, argv ); //prepare command line & read ini file
  1389.   init_system(); //init system & dos interface
  1390.   init_drivers(); //hook keyboard & mouse ISRs
  1391.   init_dc(); //init screen dc support
  1392.   init_application(); //create application object
  1393.   init_editors(); //create clipboard, init editors
  1394.   __init_tetris();
  1395.   init_w(); //init POWER VIEW IDE
  1396.   tini_startup(); //free ini file & command line, show startup errors
  1397.   save_dos_screen(); atexit( restore_dos_screen );
  1398.   init_screen(); //set startup video mode
  1399.   __init_tables(); //init tables manager
  1400. #ifndef NOMOUSE
  1401.   show_mouse(); //show mouse pointer
  1402. #endif
  1403.   editors_supervisor = w_editors_supervisor;
  1404.   if( editor_options.flags&efSAVE_STATUS ) restore_status();
  1405.   init_options();
  1406.   for( Tcmd_file *n,*f=cmd_files; f!=NULL; n=f->next,DELETE(f),f=n )
  1407.   {
  1408.     char buf[_MAX_PATH];
  1409.     if( w_edit_file(strcpy(buf,f->filename))==NULL ) exit(1);
  1410.   }
  1411.   application->exec(); //start POWER VIEW IDE
  1412.   if( options_changed )
  1413.   {
  1414.     _iwarning();
  1415.     if( yn( "Options has been changed but not saved.\n\nDo you wish to save options?" ) )
  1416.       options_save();
  1417.   }
  1418.   if( editor_options.flags&efSAVE_STATUS ) save_status();
  1419. }
  1420.