home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / magazine / pcmagazi / 1992 / 04 / myscroll.cpp < prev    next >
C/C++ Source or Header  |  1992-02-06  |  12KB  |  410 lines
  1. // myscroll.cpp RHS 11/5/91
  2.  
  3. #include<malloc.h>
  4. #include"msgbox.h"
  5. #include"myscroll.h"
  6.  
  7.  
  8. char *MyScroller::GetBuffer(int bufnum)     {   return bufMgr[bufnum]->buffer;  }
  9. BYTE MyScroller::GetAttribute(int bufnum)   {   return bufMgr[bufnum]->attribute;   }
  10. void MyScroller::SetBuffer(int bufnum, char *buffer)    {   strcpy(bufMgr[bufnum]->buffer,buffer);  }
  11. void MyScroller::SetAttribute(int bufnum, BYTE attribute)   {   bufMgr[bufnum]->attribute = attribute;  }
  12.  
  13. void MyScroller::ReInit(void)
  14.     {
  15.     startRow = endRow = 0;
  16.     numRows = (int)(IndexFile.Size()/sizeof(OUTBUF));
  17.     OpenFiles();
  18.     IndexFile.Offset(0L);   // go to beginning of file
  19.     startBuf = curBuf = 0;
  20.     endBuf = (numRows < clientheight) ? numRows-1 : clientheight-1;
  21.     FillBufs();
  22.     Clear();
  23.     Paint();
  24.     DispPath();
  25.     }
  26.  
  27. MyScroller::MyScroller(Window *pathw,char *title, DWORD position, BYTE colors)
  28.     : Scroller(title,position,colors)
  29.     {
  30. //    numbuffers = bufMgr.Init(num,size);
  31.     startRow = endRow = 0;
  32.     numRows = (int)(IndexFile.Size()/sizeof(OUTBUF));
  33.     OpenFiles();
  34.     IndexFile.Offset(0L);   // go to beginning of file
  35.     pathW = pathw;
  36.     purges_ok = FALSE;
  37.     }
  38.  
  39. MyScroller::~MyScroller(void)
  40.     {
  41.     CloseFiles();
  42.     farfree(DirNames);
  43.     }
  44.  
  45. void MyScroller::OpenFiles(void)
  46.     {
  47.     if(IndexFile.IsOpen())
  48.         IndexFile.Close();
  49.     if(DataFile.IsOpen())
  50.         DataFile.Close();
  51.     IndexFile.Open("rb+");
  52.     DataFile.Open("rb+");
  53.     }
  54.  
  55. void MyScroller::CloseFiles(void)
  56.     {
  57.     IndexFile.Close();
  58.     DataFile.Close();
  59.     }
  60.  
  61. void MyScroller::Init(int numbufs, int sizebufs)
  62.     {
  63.     Scroller::Init(numbufs,sizebufs);
  64.     numbuffers = bufMgr.Init(numbufs,sizebufs);
  65.     endBuf = (numRows < clientheight) ? numRows-1 : clientheight-1;
  66.     DirNames = (char far *)farmalloc(numbufs*DIRNAMELEN);
  67.     FillBufs();
  68.     *file1 = *file2 = '\0';
  69.     }
  70.  
  71. void MyScroller::Change(int item, char *contents, BYTE attribute, long recno)
  72.     {
  73.     SetBuffer(item,contents);
  74.     SetAttribute(item,attribute);
  75.     bufMgr[item]->recno = recno;
  76.     }
  77.  
  78. void MyScroller::Open(void)
  79.     {
  80.     Scroller::Open();
  81.     DispPath();
  82.     }
  83.  
  84. int MyScroller::MaxBufs(void)
  85.     {
  86.     if((endRow-startRow-1) < (numbuffers-1))
  87.         return endRow-startRow-1;     
  88.     return numbuffers-1;
  89.     }
  90.  
  91. void MyScroller::BufMgt(int action)
  92.     {
  93.     switch(action)
  94.         {
  95.         case SCROLL_HOME:
  96.             if(bufMgr[0]->recno > 0L)
  97.                 {
  98.                 IndexFile.Offset(0L);           // go to beginning of file
  99.                 startRow = startBuf = 0;
  100.                 FillBufs();
  101.                 buffer_changed = TRUE;
  102.                 }
  103. //            if(startBuf>0 && startRow == bufMgr[0]->recno)
  104. //                startBuf = 0;
  105.             break;
  106.         case SCROLL_END:
  107.             if((endRow < numRows) && (bufMgr[numbuffers-1]->recno != numRows-1))
  108.                 {
  109.                 long offset;
  110.                 IndexFile.Offset(offset = (IndexFile.Size()-(numbuffers*sizeof(OUTBUF))));
  111.                 startRow = (int)(offset/sizeof(OUTBUF));
  112.                 FillBufs();
  113.                 buffer_changed = TRUE;
  114.                 }
  115.             break;
  116.         case SCROLL_PGUP:
  117.             if(((startBuf - (int)Lines()) < 0) && (startRow > 0))
  118.                 {
  119.                 if((startRow -= (numbuffers/2)) < 0)   
  120.                     startRow = 0;
  121.                 IndexFile.Offset((startRow*1L)*sizeof(OUTBUF));
  122.                 FillBufs();
  123.                 buffer_changed = TRUE;
  124.                 }
  125.             break;
  126.         case SCROLL_PGDN:
  127.             if((endBuf == numbuffers-1) && (endRow < (numRows-1)))
  128.                 {
  129.                 if((endRow += (numbuffers/2)) > (numRows-1))
  130.                     endRow = numRows-1;
  131.                 if((startRow = endRow-numbuffers) < 0)
  132.                     startRow = 0;
  133.                 IndexFile.Offset((startRow*1L)*sizeof(OUTBUF));
  134.                 FillBufs();
  135.                 buffer_changed = TRUE;
  136.                 }
  137.             break;
  138.         case SCROLL_UP:
  139.             if((startBuf == 0) && (startRow != 0))   // if no records prior
  140.                 {
  141.                 int temp = startRow;
  142.                 if((startRow -= (numbuffers/2)) < 0)
  143.                     startRow = 0;
  144.                 else
  145.                     temp = numbuffers/2;
  146.  
  147.                 IndexFile.Offset((startRow*1L)*sizeof(OUTBUF));
  148.                 FillBufs();
  149.                 startBuf += temp;
  150.                 endBuf += temp;
  151.                 curBuf += temp;
  152.                 }
  153.             break;
  154.         case SCROLL_DN:
  155.             if((endBuf == numbuffers-1) && (endRow < (numRows-1)))
  156.                 {
  157.                 if((endRow += (numbuffers/2)) > (numRows-1))
  158.                     endRow = numRows-1;
  159.                 if((startRow = endRow-numbuffers) < 0)
  160.                     startRow = 0;
  161.                 IndexFile.Offset((startRow*1L)*sizeof(OUTBUF));
  162.                 FillBufs();
  163.                 int temp = numbuffers/2;
  164.                 startBuf -= temp;
  165.                 endBuf -= temp;
  166.                 curBuf -= temp;
  167.                 buffer_changed = TRUE;
  168.                 }
  169.             break;
  170.         }
  171.     }
  172.  
  173. void MyScroller::KeyProcess(int key)
  174.     {
  175. //    Screen::AtSay(1,0,
  176. //"startRow=%04d endRow=%04d startBuf=%02d endBuf=%02d curBuf=%02d",
  177. //startRow,endRow,startBuf,endBuf,curBuf);
  178.  
  179.     switch(key)
  180.         {
  181.         case KEY_HOME:          // initialize screen buffers with data
  182.             Home();
  183.             break;
  184.  
  185.         case KEY_END:                   // goto end of file
  186. //        if(endRow < numRows-1)
  187.             End();
  188.             break;
  189.  
  190.         case KEY_PGUP:                  // show previous page of lines
  191.             PgUp();
  192.             break;
  193.  
  194.         case KEY_PGDN:              // show next page of lines
  195. //            if(endRow < numRows-1)
  196.             PgDn();
  197.             break;
  198.  
  199.         case KEY_UP:                // move to prev group or shift screen down and add to start
  200.             Up();
  201.             break;
  202.  
  203.         case KEY_DOWN:              // move to next group or shift screen up and add to end
  204.             Down();
  205.             break;
  206.         }
  207. //    Screen::AtSay(5,0,
  208. //"startRow=%04d endRow=%04d startBuf=%02d endBuf=%02d curBuf=%02d",
  209. //startRow,endRow,startBuf,endBuf,curBuf);
  210.  
  211.     buffer_changed = FALSE;
  212.     DispPath();
  213.     }
  214.  
  215. char *trim(char *str)
  216.     {
  217.     char *p = strchr(str,' ');
  218.  
  219.     if(p)
  220.         *p = '\0';
  221.     return str;
  222.     }
  223.  
  224. void MyScroller::DispPath(void)
  225.     {
  226.     char formatbuffer[80];
  227.  
  228.     SetWords((void far *)formatbuffer,0,WordSize(formatbuffer));
  229.     _fstrcpy(formatbuffer,&DirNames[curBuf*DIRNAMELEN]);
  230.     pathW->Clear();
  231.     pathW->AtSay(0,0,formatbuffer);
  232.     }
  233.  
  234. void MyScroller::FillBufs(void)
  235.     {
  236.     int i;
  237.     char formatbuffer[80];
  238.     
  239.     for(i = 0; i < numbuffers; i++)
  240.         {
  241.         if(!GetRecord())
  242.             break;
  243.         FormatRecord(formatbuffer);
  244.         {
  245.         char buf[15];
  246.         sprintf(buf,"  %04ld",(startRow+i)*1L);
  247.         strcat(formatbuffer,buf);
  248.         }
  249.         Change(i,formatbuffer,OutBuf.status,(startRow+i)*1L);
  250.         _fstrcpy(&DirNames[i*DIRNAMELEN],DirName.dirname);
  251.         }
  252.     endRow = (startRow+i);
  253.     purges_ok = TRUE;
  254.     }
  255.  
  256. void MyScroller::FormatRecord(char *buf)
  257.     {
  258.     sprintf(buf,"%-12s  %02d/%02d/%02d  %02d:%02d:%02d  %10ld",
  259.         OutBuf.buf,
  260.         ((DataBuf.date & 0x01ff) >> 5),
  261.         DataBuf.date & 0x001f,
  262.         ((DataBuf.date >> 9) + 80),
  263.         (DataBuf.time >> 11),
  264.         ((DataBuf.time >> 5) & 0x003f),
  265.         ((DataBuf.time & 0x001f) << 1),
  266.         DataBuf.size);
  267.     }
  268.  
  269. #include<errno.h>
  270.  
  271. void MyScroller::Delete(void)
  272.     {
  273.     char formatbuffer[80];
  274.  
  275.     CurFileName(formatbuffer);
  276.  
  277.     File file(formatbuffer);
  278.     extern int errno;
  279.     if((file.Delete() == 0) || errno == ENOENT)
  280.         {
  281.         long save_position = IndexFile.CurPosition();
  282.         IndexFile.ReadAt(bufMgr[curBuf]->recno*sizeof(OUTBUF)*1L,sizeof(OUTBUF),&OutBuf);
  283.         OutBuf.status = SCROLLER_DELETED;
  284.         SetAttribute(curBuf,SCROLLER_DELETED);
  285.         IndexFile.WriteAt(bufMgr[curBuf]->recno*sizeof(OUTBUF)*1L,sizeof(OUTBUF),&OutBuf);       // write index entry
  286.         IndexFile.Offset(save_position);
  287.         }
  288.     Paint();
  289.     }
  290.  
  291.    
  292. void MyScroller::Purge(void)
  293.     {
  294.     IndexFile.Offset(0L);
  295.  
  296.     int i;
  297.     char formatbuffer[80];
  298.     long cur_position;
  299.     extern int errno;
  300.  
  301.     for( i = 0; i < numRows; i++)
  302.         {
  303.         cur_position = IndexFile.CurPosition();
  304.         IndexFile.Offset(cur_position);     // re-position in case just after a write
  305.         if(!GetRecord())
  306.             break;
  307.         if(OutBuf.status & SCROLLER_SELECTED_NORMAL)
  308.             {
  309.             strcpy(formatbuffer,DirName.dirname);
  310.             strcat(formatbuffer,OutBuf.buf);
  311.             File file(formatbuffer);
  312.  
  313.             if((file.Delete() == 0) || errno == ENOENT)
  314.                 {
  315.                 OutBuf.status = SCROLLER_DELETED;
  316.                 IndexFile.WriteAt(cur_position,sizeof(OUTBUF),&OutBuf);       // write index entry
  317.                 IndexFile.Flush();
  318.                 }
  319.             else
  320.                 MsgBox("Unable to Delete File:",formatbuffer);
  321.             }
  322.         }
  323.     IndexFile.Offset((startRow*1L)*sizeof(OUTBUF));
  324.     FillBufs();
  325.     Paint();
  326.     }
  327.  
  328. char *MyScroller::CurFileName(char *buf)
  329.     {
  330.     _fstrcpy(buf,&DirNames[curBuf*DIRNAMELEN]);
  331.     char temp[13];
  332.     strncpy(temp,bufMgr[curBuf]->buffer,12);
  333.     temp[12] = '\0';
  334.     strcat(buf,temp);
  335.     trim(buf);
  336.     return buf;
  337.     }
  338.  
  339. void MyScroller::Select(void)
  340.     {
  341.     BYTE attrib_old = bufMgr[curBuf]->attribute;
  342.  
  343.     if(attrib_old & SCROLLER_DELETED)
  344.         return;
  345.     BYTE attrib_new = Scroller::Select();
  346.  
  347.     if(attrib_old == attrib_new)
  348.         return;
  349.     long save_position = IndexFile.CurPosition();
  350.  
  351.     IndexFile.ReadAt(bufMgr[curBuf]->recno*sizeof(OUTBUF)*1L,sizeof(OUTBUF),&OutBuf);
  352.         // turn off CURRENT bit
  353.     OutBuf.status = (attrib_new & 0xfe);
  354.     IndexFile.WriteAt(bufMgr[curBuf]->recno*sizeof(OUTBUF)*1L,sizeof(OUTBUF),&OutBuf);       // write index entry
  355.     IndexFile.Offset(save_position);
  356.     }
  357.  
  358. BOOL MyScroller::CompareSetup(void)
  359.     {
  360.     if(*file1 && *file2)
  361.         *file1 = *file2 = '\0';
  362.     char temp[13];
  363.     if(!*file1)
  364.         {
  365.         CurFileName(file1);
  366.         return FALSE;
  367.         }
  368.     if(!*file2)
  369.         {
  370.         CurFileName(file2);
  371.         return TRUE;
  372.         }
  373.     }
  374.  
  375. BOOL MyScroller::FileCompare(void)
  376.     {
  377.     if(!strcmp(file1,file2))
  378.         return TRUE;
  379.  
  380.     File f1(file1), f2(file2);
  381.     long size;
  382.  
  383.     if((size = f1.Size()) != f2.Size())
  384.         return FALSE;
  385.     BYTE byte1, byte2;
  386.     f1.Open("rb");
  387.     f2.Open("rb");
  388.     BYTE buf1[512], buf2[512];
  389.  
  390.     int j,k;
  391.     for(long i = 0L; i < size; i += k)
  392.         {
  393.         k = f1.ReadAt(i,512,buf1);
  394.         f2.ReadAt(i,512,buf2);
  395.         for(j = 0; j < k; j++)
  396.             if(buf1[j] != buf2[j])
  397.                 return FALSE;
  398.         }
  399.     return TRUE;
  400.     }
  401.  
  402. BOOL MyScroller::IsDeleted(void)
  403.     {
  404.     if(GetAttribute(curBuf) & SCROLLER_DELETED)
  405.         return TRUE;
  406.     return FALSE;
  407.     }
  408.  
  409.  
  410.