home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / fed0217s.zip / source / editbox.cpp < prev    next >
C/C++ Source or Header  |  2001-10-16  |  11KB  |  571 lines
  1. /*
  2. ** Module   :EDITBOX.CPP
  3. ** Abstract :Complete interface for single editor window
  4. **
  5. ** Copyright (C) Sergey I. Yevtushenko
  6. **
  7. ** Log: Sat  03/05/1997       Created
  8. */
  9.  
  10. #include <string.h>
  11.  
  12. #include <fio.h>
  13. #include <stddlg.h>
  14. #include <version.h>
  15.  
  16. #define INCL_DOSFILEMGR
  17. #include <os2.h>
  18.  
  19. short EditBox::used = 0;
  20.  
  21. EditBox::EditBox(int i, int j, int k, int l)
  22. {
  23.     row = i;
  24.     col = j;
  25.     rows = k;
  26.     cols = l;
  27.     name = 0;
  28.     orig_file = 0;
  29.     num = 10;
  30.  
  31.     short bit = 1;
  32.  
  33.     memset(bookmark, 0, sizeof(bookmark));
  34.  
  35.     for(i = 0; i < 10; i++)
  36.     {
  37.         if(!(used & bit))
  38.         {
  39.             num = i;
  40.             used |= bit;
  41.             break;
  42.         }
  43.         bit <<= 1;
  44.     }
  45.  
  46.     new_file();
  47. }
  48.  
  49. EditBox::~EditBox()
  50. {
  51.     if(num < 10)
  52.     {
  53.         short bit = 1;
  54.         bit <<= num;
  55.         used &= ~bit;
  56.     }
  57.     delete name;
  58.     _fr_file(orig_file);
  59. }
  60.  
  61. int EditBox::load(char* new_name)
  62. {
  63.     char *str, *ptr;
  64.     int old_completed = -1;
  65.     int _unx = 1;
  66.  
  67.     close();
  68.  
  69.     if(!new_name)
  70.         new_name = untitled;
  71.  
  72.     name = get_full_name(new_name);
  73.  
  74.     set_hiliting(0);
  75. //-------------------------------------
  76. // Guess hiliting
  77.  
  78.     orig_file = _ld_file(name);
  79.  
  80.     long flen = strlen(orig_file);
  81.  
  82.     if(!flen)
  83.     {
  84.         _unx = iDefType;
  85.         add_line(new Line);
  86.         set_hiliting(Parser::GuessType(name));
  87.         set_custom_syntax(0);
  88.  
  89.         if(!_file_exists(name))
  90.             set_changed(1);
  91.  
  92.         return -1;
  93.     }
  94.  
  95. //-------------------------------------
  96. // scan loaded file and prepare them for displaying
  97. //
  98.     for(ptr = str = orig_file; (str - orig_file) < flen;)
  99.     {
  100.         int i = 1;
  101.  
  102.         long completed = ((long)(str - orig_file) * 40 + 1)/flen;
  103.  
  104.         if(completed != old_completed)
  105.         {
  106.             vio_print2(Rows - 1,
  107.                        0,
  108.                        &ProgressBar[40 - completed],
  109.                        Cols,
  110.                        app_pal[CL_APPLICATION_START+CL_STATUSLINE]);
  111.             old_completed = completed;
  112.         }
  113.  
  114.         while(*str && *str != '\n')
  115.         {
  116.             if(str[0] == '\r' && str[1] != '\n')
  117.             {
  118.                 str++;
  119.                 break;
  120.             }
  121.             str++;
  122.         }
  123.  
  124.         if(*str)
  125.         {
  126.             if((str > orig_file) && str[-1] == '\r')
  127.             {
  128.                 _unx = 0;
  129.                 str[-1] = 0;
  130.             }
  131.  
  132.             if(str[0] == '\n')
  133.                 *str++ = 0;
  134.         }
  135.  
  136.         Add(new Line(ptr));
  137.  
  138.         ptr = str;
  139.     }
  140.  
  141.     if(!Count())
  142.     {
  143.         _unx = iDefType;
  144.         add_line(new Line);
  145.     }
  146.  
  147.     set_hiliting(Parser::GuessType(name));
  148.     set_custom_syntax(0);       //This is our guess, not a user setting
  149.  
  150.     char *ea = 0;
  151.  
  152.     if(!get_ea(get_name(), ".FEDPOS",&ea) && ea)
  153.     {
  154.         int cX = 0;
  155.         int cY = 0;
  156.  
  157.         parse_pos(ea, &cX, &cY);
  158.  
  159.         if(cX > 0)
  160.             goto_line(*this, cX - 1);
  161.  
  162.         if(cY > 0)
  163.             goto_col(*this, cY - 1);
  164.  
  165.         delete ea;
  166.         ea = 0;
  167.     }
  168.  
  169.     int i;
  170.  
  171.     for(i = 0; i < BMK_NUM; i++)
  172.     {
  173.         char eaname[128];
  174.  
  175.         strcpy(eaname, ".FEDMARK");
  176.         strcat(eaname, cvt_num(i,0));
  177.  
  178.         if(!get_ea(get_name(), eaname, &ea) && ea)
  179.         {
  180.             bookmark[i].row = bookmark[i].col = 0;
  181.             parse_pos(ea, &bookmark[i].row, &bookmark[i].col);
  182.             delete ea;
  183.             ea = 0;
  184.         }
  185.     }
  186.  
  187.     if(!get_ea(get_name(), ".FEDSTATE",&ea) && ea)
  188.     {
  189.         int cX = 0;
  190.         int cY = 0;
  191.         char *ptr;
  192.  
  193.         ptr = parse_pos(ea, &cX, &cY);
  194.  
  195.         if(cX > 0)
  196.             goto_line(*this, cX - 1);
  197.  
  198.         if(cY > 0)
  199.             goto_col(*this, cY - 1);
  200.  
  201.         if(ptr && *ptr == ' ')
  202.             ptr++;
  203.  
  204.         for(i = 0; i < BMK_NUM && ptr; i++)
  205.         {
  206.             bookmark[i].row = bookmark[i].col = 0;
  207.             ptr = parse_pos(ptr, &bookmark[i].row, &bookmark[i].col);
  208.  
  209.             if(ptr && *ptr == ' ')
  210.                 ptr++;
  211.         }
  212.  
  213.         if(ptr && *ptr == ' ')
  214.             ptr++;
  215.  
  216.         if(ptr && *ptr == '+')
  217.         {
  218.             ptr++;
  219.             int num = 0;
  220.  
  221.             while(*ptr && *ptr >= '0' && *ptr <= '9')
  222.             {
  223.                 num *= num;
  224.                 num += *ptr - '0';
  225.                 ptr++;
  226.             }
  227.  
  228.             if(num > 0)
  229.                 set_hiliting(num - 1);
  230.  
  231.             if(ptr && *ptr == ' ')
  232.                 ptr++;
  233.         }
  234.  
  235.         if(ptr && *ptr == ' ')
  236.             ptr++;
  237.  
  238.         if(ptr && *ptr == '*')
  239.             set_xlate(ptr + 1);
  240.  
  241.         delete ea;
  242.         ea = 0;
  243.     }
  244.  
  245.     set_unix(_unx);
  246.  
  247. // Finally fill hiliting
  248.  
  249.     if(get_hiliting())
  250.        fill_hiliting(0, ST_INITIAL);
  251.  
  252.     return 0;
  253. }
  254.  
  255. int EditBox::new_file()
  256. {
  257.     close();
  258.     add_line(new Line);
  259.     set_unix(iDefType);
  260.  
  261.     name = get_full_name(untitled);
  262.  
  263.     return 0;
  264. }
  265.  
  266. int EditBox::save_as(char *new_name)
  267. {
  268.     set_changed();
  269.     set_name(new_name);
  270.     return save();
  271. }
  272.  
  273. int EditBox::set_name(char *new_name)
  274. {
  275.     delete name;
  276.     name = get_full_name(new_name);
  277.  
  278.     return 0;
  279. }
  280.  
  281. void EditBox::put_xy()
  282. {
  283.     char ea[256];
  284.  
  285.     if(iNoEA)
  286.         return;
  287.  
  288. #if 0   /* old version */
  289.     char eaname[128];
  290.     mk_pos(ea, get_edit_row(), get_edit_col());
  291.     put_ea(get_name(), ".FEDPOS", ea);
  292.  
  293.     for(int i = 0; i < BMK_NUM; i++)
  294.     {
  295.         mk_pos(ea, bookmark[i].row, bookmark[i].col);
  296.         strcpy(eaname, ".FEDMARK");
  297.         strcat(eaname, cvt_num(i,0));
  298.         put_ea(get_name(), eaname, ea);
  299.     }
  300.  
  301. #else
  302.  
  303.     char *ptr = ea;
  304.  
  305.     ptr = mk_pos(ptr, get_edit_row(), get_edit_col());
  306.     *ptr++ = ' ';
  307.  
  308.     for(int i = 0; i < BMK_NUM; i++)
  309.     {
  310.         ptr = mk_pos(ptr, bookmark[i].row, bookmark[i].col);
  311.         *ptr++ = ' ';
  312.     }
  313.  
  314.     *ptr = 0;
  315.  
  316.     //Save syntax at all?
  317.  
  318.     if(iSaveSyntax && (iSaveSyntax > 1 || get_custom_syntax()))
  319.     {
  320.         strcat(ptr, "+");
  321.         strcat(ptr, cvt_num(get_hiliting() + 1,0));
  322.     }
  323.     strcat(ptr, " ");
  324.     strcat(ptr, "*");
  325.     strcat(ptr, get_cur_cp());
  326.  
  327.     put_ea(get_name(), ".FEDSTATE", ea);
  328.  
  329. #endif
  330. }
  331.  
  332. int EditBox::save()
  333. {
  334.     if(!get_changed())
  335.     {
  336.         //Preserve original time and date
  337.         APIRET rc;
  338.         FILESTATUS3 stFStatus;
  339.  
  340.         memset(&stFStatus, 0, sizeof(FILESTATUS3));
  341.  
  342.         rc = DosQueryPathInfo(get_name(),
  343.                               FIL_STANDARD,
  344.                               &stFStatus,
  345.                               sizeof(FILESTATUS3));
  346.  
  347.         if(!rc)
  348.         {
  349.             put_xy();
  350.  
  351.             DosSetPathInfo(get_name(),
  352.                            FIL_STANDARD,
  353.                            &stFStatus,
  354.                            sizeof(FILESTATUS3),
  355.                            DSPI_WRTTHRU);
  356.         }
  357.         return 0;
  358.     }
  359.  
  360.     int out;
  361.     int old_completed = -1;
  362.  
  363.     out = _lopen(name, OP_WRITE);
  364.  
  365.     if(out <= 0)
  366.         return -1;
  367.  
  368.     BlockWrite blk = 32000;
  369.  
  370.     blk.Open(out);
  371.  
  372.     for(int i = 0; i < Count(); i++)
  373.     {
  374.         char *str = line(i)->str;
  375.         char *non_blank = str;
  376.         int len;
  377.         int completed = (i * 40 + 1)/Count();
  378.  
  379.         if(completed != old_completed)
  380.         {
  381.             vio_print2(Rows - 1,
  382.                        0,
  383.                        &ProgressBar[40 - completed],
  384.                        Cols,
  385.                        app_pal[CL_APPLICATION_START+CL_STATUSLINE]);
  386.             old_completed = completed;
  387.         }
  388.         while(*str)
  389.         {
  390.             if(!__issp(*str))
  391.                 non_blank = str;
  392.             str++;
  393.         }
  394.  
  395.         if(!__issp(*non_blank) && *non_blank != 0)
  396.             non_blank++;
  397.  
  398.         len = non_blank - line(i)->str;
  399.  
  400.         if(len)
  401.             blk.Add(line(i)->str, len);
  402.  
  403.         if(get_unix())
  404.             blk.Add("\n", 1);
  405.         else
  406.             blk.Add("\r\n", 2);
  407.     }
  408.  
  409.     blk.Close();
  410.  
  411.     _lclose(out);
  412.  
  413.     set_changed(0);
  414.  
  415.     put_xy();
  416.  
  417.     return 0;
  418. }
  419.  
  420. int EditBox::close()
  421. {
  422.     _fr_file(orig_file);
  423.     delete name;
  424.  
  425.     name      = 0;
  426.     orig_file = 0;
  427.  
  428.     track_cancel();
  429.     clear_undobuff();
  430.     RemoveAll();
  431.  
  432.     return 0;
  433. }
  434.  
  435. void EditBox::draw()
  436. {
  437.     Buffer::draw(*this);
  438.     vio_cursor_pos(row+get_cur_row(), col+get_cur_col());
  439.     vio_cursor_type((get_ins_mode()) ? Underline:BigCursor);
  440. }
  441.  
  442. int EditBox::search(char* flags, char *patt)
  443. {
  444.     return Buffer::search(*this, flags, patt);
  445. }
  446.  
  447. int EditBox::replace(char *repl)
  448. {
  449.     return Buffer::replace(*this, repl);
  450. }
  451.  
  452. int EditBox::check_save()
  453. {
  454.     if(!get_changed())
  455.         return 0;
  456.  
  457.     int rc = AChoice(5, 5, Yes_No, "Save?");
  458.  
  459.     switch(rc)
  460.     {
  461.         case -1:
  462.         case  2:
  463.             return -1;
  464.         case  0:
  465.  
  466.             if(is_untitled())
  467.             {
  468.                 rc = FileDialog(5, 5, cName, 2);
  469.                 if(!rc)
  470.                     save_as(cName);
  471.                 else
  472.                     return -1;
  473.             }
  474.             save();
  475.     }
  476.     return 0;
  477. }
  478.  
  479. int EditBox::is_untitled()
  480. {
  481.     char buff[FED_MAXPATH];
  482.     char buff2[FED_MAXPATH];
  483.     make_short_name(get_name(), buff);
  484.     make_short_name(untitled, buff2);
  485.     return (!strcmp(buff, buff2)) ? 1:0;
  486. }
  487.  
  488. void EditBox::bmk_go(int i)
  489. {
  490.     if(i < 0 || i >= BMK_NUM)
  491.         return;
  492.  
  493.     if(bookmark[i].row > 0)
  494.         goto_line(*this, bookmark[i].row - 1);
  495.  
  496.     if(bookmark[i].col > 0)
  497.         goto_col(*this, bookmark[i].col - 1);
  498. }
  499.  
  500. void EditBox::bmk_place(int i)
  501. {
  502.     if(i < 0 || i >= BMK_NUM)
  503.         return;
  504.  
  505.     bookmark[i].row = get_edit_row();
  506.     bookmark[i].col = get_edit_col();
  507. }
  508.  
  509. char *EditBox::get_fmt_name(int minlen, int fill)
  510. {
  511.     static char buff[FED_MAXPATH];
  512.     char fname[FED_MAXPATH];
  513.     char *tmp;
  514.     char *src;
  515.  
  516.     if(minlen > FED_MAXPATH)
  517.         minlen = FED_MAXPATH;
  518.  
  519.     memset(buff, 0, FED_MAXPATH);
  520.  
  521.     if(minlen)
  522.         memset(buff, fill, minlen);
  523.  
  524.     tmp = buff;
  525.  
  526.     src = get_name();
  527.  
  528.     if(src)
  529.     {
  530.         strcpy(fname, src);
  531.         fname[minlen] = 0;
  532.  
  533.         if(strlen(src) > minlen && minlen > 7 && iFileName)
  534.         {
  535.             char *dst = fname;
  536.  
  537.             while(*src != '\\')
  538.                 *dst++ = *src++;
  539.  
  540.             while(strlen(src) > (minlen - 6))
  541.             {
  542.                 char *slash = strchr(src + 1, '\\');
  543.  
  544.                 if(slash)
  545.                     src = slash;
  546.                 else
  547.                     break;  //no more slashes, leave
  548.             }
  549.  
  550.             *dst++ = '\\';
  551.             *dst++ = '.' ;
  552.             *dst++ = '.' ;
  553.             *dst++ = '.' ;
  554.  
  555.             strcpy(dst, src);
  556.             fname[minlen] = 0;
  557.         }
  558.  
  559.         src = fname;
  560.  
  561.         while(*src)
  562.         {
  563.             *tmp++ = *src++;
  564.         }
  565.     }
  566.  
  567.     return buff;
  568. }
  569.  
  570.  
  571.