home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / ftes46b5.zip / ftes46b5 / src / e_redraw.cpp < prev    next >
C/C++ Source or Header  |  1997-05-30  |  19KB  |  583 lines
  1. /*    e_redraw.cpp
  2.  *
  3.  *    Copyright (c) 1994-1996, Marko Macek
  4.  *
  5.  *    You may distribute under the terms of either the GNU General Public
  6.  *    License or the Artistic License, as specified in the README file.
  7.  *
  8.  */
  9.  
  10. #include "fte.h"
  11.  
  12. int EBuffer::GetMap(int Row, int *StateLen, hsState **StateMap) {
  13.     hlState State = 0;
  14.     
  15.     Rehilit(Row);
  16.     
  17.     *StateLen = LineChars(Row);
  18.     if (Row > 0) State = RLine(Row - 1)->StateE;
  19.     if (*StateLen > 0) {
  20.         PELine L = RLine(Row);
  21.         int ECol;
  22.         
  23.         *StateMap = (hsState *) malloc(*StateLen);
  24.         if (*StateMap == 0) return 0;
  25.         
  26. #ifdef CONFIG_SYNTAX_HILIT
  27.         if (BFI(this, BFI_HilitOn) == 1 && HilitProc != 0)
  28.             HilitProc(this, Row, 0, 0, *StateLen, L, State, *StateMap, &ECol);
  29.         else
  30. #endif
  31.             Hilit_Plain(this, Row, 0, 0, *StateLen, L, State, *StateMap, &ECol);
  32.         //        if (L->StateE != State) {
  33.         //            L->StateE = State;
  34.         //        }
  35.     } else {
  36.         *StateLen = 1;
  37.         *StateMap = (hsState *) malloc(1);
  38.         if (*StateMap == 0) return 0;
  39.         (*StateMap)[0] = (hsState) (State & 0xFF);
  40.     }
  41.     return 1;
  42. }
  43.  
  44. void EBuffer::FullRedraw() { // redraw all views
  45.     EView *V = View;
  46.     EEditPort *W;
  47.     
  48.     while (V) {
  49.         W = GetViewVPort(V);
  50.         Draw(W->TP.Row, W->TP.Row + W->Rows);
  51.         V = V->Next;
  52.         if (V == View)
  53.             break;
  54.     }
  55. }
  56.  
  57. void EBuffer::Hilit(int FromRow) {
  58.     if (FromRow != -1) {
  59.         if (StartHilit == -1)
  60.             StartHilit = FromRow;
  61.         else if (FromRow < StartHilit)
  62.             StartHilit = FromRow;
  63.     }
  64. }
  65.  
  66. void EBuffer::Rehilit(int ToRow) {
  67.     hlState State;
  68.     int HilitX;
  69.     PELine L;
  70.     int ECol;
  71.     
  72.     if (StartHilit == -1)   // all ok
  73.         return ;
  74.     
  75.     if (BFI(this, BFI_MultiLineHilit) == 0) // everything handled in redisplay
  76.         return;
  77.     
  78.     if (ToRow <= StartHilit) // will be handled in redisplay
  79.         return;
  80.     
  81.     if (ToRow >= RCount)
  82.         ToRow = RCount;
  83.     
  84.     HilitX = 1;
  85.     while ((StartHilit < RCount) && ((StartHilit < ToRow) || HilitX)) {
  86.         L = RLine(StartHilit);
  87.         
  88.         HilitX = 0;
  89.         if (StartHilit > 0)
  90.             State = RLine(StartHilit - 1)->StateE;
  91.         else
  92.             State = 0;
  93.         
  94.         if (BFI(this, BFI_HilitOn) == 1 && HilitProc != 0) {
  95.             HilitProc(this, StartHilit, 0, 0, 0, L, State, 0, &ECol);
  96.         } else {
  97.             Hilit_Plain(this, StartHilit, 0, 0, 0, L, State, 0, &ECol);
  98.         }
  99.         if (L->StateE != State) {
  100.             HilitX = 1;
  101.             L->StateE = State;
  102.         }
  103.         Draw(StartHilit, StartHilit);  // ?
  104.         if (StartHilit > EndHilit)
  105.             EndHilit = StartHilit;
  106.         if (HilitX == 0) // jump over (can we always do this ?)
  107.             if (StartHilit < EndHilit) {
  108.                 StartHilit = EndHilit;
  109.             }
  110.         StartHilit++;
  111.     }
  112. }
  113.  
  114. void EBuffer::Draw(int Row0, int RowE) {
  115.     //    printf("r0 = %d, re = %d\n", Row0, RowE);
  116.     //    printf("m = %d, max = %d, rts = %d\n", MinRedraw, MaxRedraw, RedrawToEos);
  117.     if (Row0 == -1) Row0 = 0;
  118.     if ((Row0 < MinRedraw) || (MinRedraw == -1)) {
  119.         MinRedraw = Row0;
  120.         if (MaxRedraw == -1) MaxRedraw = MinRedraw;
  121.     }
  122.     if (RowE == -1) {
  123.         RedrawToEos = 1;
  124.         MaxRedraw = MinRedraw;
  125.     } else if ((RowE > MaxRedraw) || (MaxRedraw == -1)) if (RowE != -1) MaxRedraw = RowE;
  126.     //    printf("m = %d, max = %d, rts = %d\n", MinRedraw, MaxRedraw, RedrawToEos);
  127. }
  128.  
  129. void EBuffer::DrawLine(TDrawBuffer B, int VRow, int C, int W, int &HilitX) {
  130.     hlState State;
  131.     int StartPos, EndPos;
  132.     
  133.     HilitX = 0;
  134.     MoveChar(B, 0, W, ' ', hcPlain_Background, W);
  135.     //    if ((VRow == VCount - 1) && !BFI(this, BFI_ForceNewLine)) {
  136.     // if (BFI(this, BFI_ShowMarkers))
  137.     //     MoveChar(B, 0, W, EOF_MARKER, hcPlain_Markers, W);
  138.     //    }
  139.     if (VRow < VCount) {
  140.         int Row = VToR(VRow);
  141.         PELine L = RLine(Row);
  142.         int ECol = 0;
  143.         
  144.         if (Row > 0) State = RLine(Row - 1)->StateE;
  145.         else State = 0;
  146. #ifdef CONFIG_SYNTAX_HILIT
  147.         if (BFI(this, BFI_HilitOn) == 1 && HilitProc != 0)
  148.             HilitProc(this, Row, B, C, W, L, State, 0, &ECol);
  149.         else
  150. #endif
  151.             Hilit_Plain(this, Row, B, C, W, L, State, 0, &ECol);
  152.         if (L->StateE != State) {
  153.             HilitX = 1;
  154.             L->StateE = State;
  155.         }
  156.         if (BFI(this, BFI_ShowMarkers)) {
  157.             MoveChar(B, ECol - C, W, ConGetDrawChar((Row == RCount - 1) ? DCH_EOF : DCH_EOL), hcPlain_Markers, 1);
  158.             ECol += 1;
  159.         }
  160.         if (Row < RCount) {
  161.             int f;
  162.             int Folded = 0;
  163.             static char fold[20];
  164.             int l;
  165.             
  166.             f = FindFold(Row);
  167.             if (f != -1) {
  168.                 if (FF[f].open == 1) {
  169.                     l = sprintf(fold, "[%d]", FF[f].level);
  170.                     MoveStr(B, ECol - C + 1, W, fold, hcPlain_Folds, 10);
  171.                     ECol += l;
  172.                 } else {
  173.                     if (VRow < VCount - 1) {
  174.                         Folded = Vis(VRow + 1) - Vis(VRow) + 1;
  175.                     } else if (VRow < VCount) {
  176.                         Folded = RCount - (VRow + Vis(VRow));
  177.                     }
  178.                     l = sprintf(fold, "(%d:%d)", FF[f].level, Folded);
  179.                     MoveStr(B, ECol - C + 1, W, fold, hcPlain_Folds, 10);
  180.                     ECol += l;
  181.                     MoveAttr(B, 0, W, hcPlain_Folds, W);
  182.                 }
  183.             }
  184.         }
  185.         if (BB.Row != -1 && BE.Row != -1 && Row >= BB.Row && Row <= BE.Row) {
  186.             switch(BlockMode) {
  187.             case bmLine:
  188.                 StartPos = 0;
  189.                 if (Row == BE.Row) EndPos = 0;
  190.                 else EndPos = W;
  191.                 break;
  192.             case bmColumn:
  193.                 StartPos = BB.Col - C;
  194.                 if (Row == BE.Row) EndPos = BB.Col - C;
  195.                 else EndPos = BE.Col - C;
  196.                 break;
  197.             case bmStream:
  198.                 if (Row == BB.Row && Row == BE.Row) {
  199.                     StartPos = BB.Col - C;
  200.                     EndPos = BE.Col - C;
  201.                 } else if (Row == BB.Row) {
  202.                     StartPos = BB.Col - C;
  203.                     EndPos = W;
  204.                 } else if (Row == BE.Row) {
  205.                     StartPos = 0;
  206.                     EndPos = BE.Col - C;
  207.                 } else {
  208.                     StartPos = 0;
  209.                     EndPos = W;
  210.                 }
  211.                 break;
  212.             default:
  213.         StartPos = EndPos = 0;
  214.         break;
  215.             }
  216.             if (BFI(this, BFI_SeeThruSel))
  217.                 MoveBgAttr(B, StartPos, W, hcPlain_Selected, EndPos - StartPos);
  218.             else
  219.                 MoveAttr(B, StartPos, W, hcPlain_Selected, EndPos - StartPos);
  220.         }
  221.         if (Match.Row != -1 && Match.Col != -1) {
  222.             if (Row == Match.Row) {
  223.                 if (BFI(this, BFI_SeeThruSel))
  224.                     MoveBgAttr(B, Match.Col - C, W, hcPlain_Found, MatchLen);
  225.                 else
  226.                     MoveAttr(B, Match.Col - C, W, hcPlain_Found, MatchLen);
  227.             }
  228.         }
  229.     } else if (VRow == VCount) {
  230.         if (BFI(this, BFI_ShowMarkers))
  231.             MoveChar(B, 0, W, ConGetDrawChar(DCH_END), hcPlain_Markers, W);
  232.     }
  233. }
  234.  
  235. void EBuffer::Redraw() {
  236.     int HilitX;
  237.     EView *V;
  238.     EEditPort *W;
  239.     int Row;
  240.     TDrawBuffer B;
  241.     char s[256];
  242.     ChColor SColor;
  243.     int RowA, RowZ;
  244.     
  245.     {
  246.         int W1, H1;
  247.         if (!(View && View->MView))
  248.             return;
  249.         View->MView->ConQuerySize(&W1, &H1);
  250.         
  251.         if (H1 < 1 || W1 < 1) return;
  252.     }
  253.     //    printf("Redraw\n");
  254.     if (CP.Row >= VCount) CP.Row = VCount - 1;
  255.     if (CP.Row < 0) CP.Row = 0;
  256.     
  257.     CheckBlock();
  258.     V = View; /* check some window data */
  259.     if (!V) {
  260.         MinRedraw = MaxRedraw = -1;
  261.         RedrawToEos = 0;
  262.         return;
  263.     }
  264.     if (View == 0 || View->MView == 0 || View->MView->Win == 0)
  265.         return ;
  266.     
  267.     for ( ; V; V = V->NextView) {
  268.         //        printf("Checking\x7\n");
  269.         if (V->Model != this)
  270.             assert(1 == 0);
  271.         
  272.         W = GetViewVPort(V);
  273.         
  274.         if (W->Rows < 1 || W->Cols < 1)
  275.             continue;
  276.         
  277.         if (V == View) {
  278.             int scrollJumpX = Min(ScrollJumpX, W->Cols / 2);
  279.             int scrollJumpY = Min(ScrollJumpY, W->Rows / 2);
  280.             int scrollBorderX = Min(ScrollBorderX, W->Cols / 2);
  281.             int scrollBorderY = Min(ScrollBorderY, W->Rows / 2);
  282.             
  283.             W->CP = CP;
  284.             TP = W->TP;
  285.             
  286.             if (W->ReCenter) {
  287.                 W->TP.Row = CP.Row - W->Rows / 2;
  288.                 W->TP.Col = CP.Col - W->Cols + 8;
  289.                 W->ReCenter = 0;
  290.             }
  291.             
  292.             if (W->TP.Row + scrollBorderY > CP.Row) W->TP.Row = CP.Row - scrollJumpY + 1 - scrollBorderY;
  293.             if (W->TP.Row + W->Rows - scrollBorderY <= CP.Row) W->TP.Row = CP.Row - W->Rows + 1 + scrollJumpY - 1 + scrollBorderY;
  294.             if (!WeirdScroll)
  295.                 if (W->TP.Row + W->Rows >= VCount) W->TP.Row = VCount - W->Rows;
  296.             if (W->TP.Row < 0) W->TP.Row = 0;
  297.             
  298.             if (W->TP.Col + scrollBorderX > CP.Col) W->TP.Col = CP.Col - scrollJumpX - scrollBorderX;
  299.             if (W->TP.Col + W->Cols - scrollBorderX <= CP.Col) W->TP.Col = CP.Col - W->Cols + scrollJumpX + scrollBorderX;
  300.             if (W->TP.Col < 0) W->TP.Col = 0;
  301.             
  302.             if (W->OldTP.Row != -1 && W->OldTP.Col != -1 && RedrawToEos == 0) {
  303.                 
  304.                 if ((W->OldTP.Row != W->TP.Row) || (W->OldTP.Col != W->TP.Col)) {
  305.                     int A, B;
  306.                     int DeltaX, DeltaY;
  307.                     int Rows = W->Rows;
  308.                     int Delta1 = 0, Delta2 = 0;
  309.                     
  310.                     DeltaY = W->TP.Row - W->OldTP.Row ;
  311.                     DeltaX = W->TP.Col - W->OldTP.Col;
  312.                     
  313.                     if ((DeltaX == 0) && (-Rows < DeltaY) && (DeltaY < Rows)) {
  314.                         if (DeltaY < 0) {
  315.                             W->ScrollY(DeltaY);
  316.                             A = W->TP.Row;
  317.                             B = W->TP.Row - DeltaY;
  318.                         } else {
  319.                             W->ScrollY(DeltaY);
  320.                             A = W->TP.Row + Rows - DeltaY;
  321.                             B = W->TP.Row + Rows;
  322.                         }
  323.                     } else {
  324.                         A = W->TP.Row; 
  325.                         B = W->TP.Row + W->Rows;
  326.                     }
  327.                     if (A >= VCount) {
  328.                         Delta1 = A - VCount + 1;
  329.                         A = VCount - 1;
  330.                     }
  331.                     if (B >= VCount) {
  332.                         Delta2 = B - VCount + 1;
  333.                         B = VCount - 1;
  334.                     }
  335.                     if (A < 0) A = 0;
  336.                     if (B < 0) B = 0;
  337.                     Draw(VToR(A) + Delta1, VToR(B) + Delta2);
  338.                 }
  339.             } else {
  340.                 int A = W->TP.Row;
  341.                 int B = A + W->Rows;
  342.                 int Delta = 0;
  343.                 
  344.                 if (B > VCount) {
  345.                     Delta += B - VCount;
  346.                     B = VCount;
  347.                 }
  348.                 int LastV = VToR(VCount - 1);
  349.                 int B1 = (B == VCount) ? RCount : VToR(B);
  350.                 
  351.                 if (B1 >= LastV) {
  352.                     Delta += B1 - LastV;
  353.                     B1 = LastV;
  354.                 }
  355.                 if (B1 < 0) B1 = 0;
  356.                 Draw(VToR(A), B1 + Delta);
  357.             }
  358.             
  359.             W->OldTP = W->TP;
  360.             TP = W->TP;
  361.         }
  362.         if (W->CP.Row >= VCount) W->CP.Row = VCount - 1;
  363.         if (W->CP.Row < 0) W->CP.Row = 0;
  364.         if (W->TP.Row > W->CP.Row) W->TP.Row = W->CP.Row;
  365.         if (W->TP.Row < 0) W->TP.Row = 0;
  366.         
  367.         if (V->MView->IsActive()) // hack
  368.             SColor = hcStatus_Active;
  369.         else
  370.             SColor = hcStatus_Normal;
  371.         MoveChar(B, 0, W->Cols, ' ', SColor, W->Cols);
  372.         
  373.         if (V->MView->Win->GetViewContext() == V->MView) {
  374.             V->MView->Win->SetSbVPos(W->TP.Row, W->Rows, VCount + (WeirdScroll ? W->Rows - 1 : 0));
  375.             V->MView->Win->SetSbHPos(W->TP.Col, W->Cols, 1024 + (WeirdScroll ? W->Cols - 1 : 0));
  376.         }
  377.         
  378.         if (V->CurMsg == 0) {
  379.             {
  380.                 int CurLine = W->CP.Row;
  381.                 int ActLine = VToR(W->CP.Row);
  382.                 int CurColumn = W->CP.Col;
  383.                 int CurPos = CharOffset(RLine(ActLine), CurColumn);
  384.                 int NumLines = RCount;
  385.                 int NumChars = RLine(ActLine)->Count;
  386.                 //            int NumColumns = ScreenPos(Line(CurLine), NumChars);
  387.                 char *fName = FileName;
  388.                 unsigned char CurCh = 0xFF;
  389.                 int lf = strlen(fName);
  390.                 char CCharStr[20] = "";
  391.                 
  392.                 if (lf > 34) fName += lf - 34;
  393.                 
  394.                 if (CurPos < NumChars) {
  395.                     CurCh = VLine(CurLine)->Chars[CurPos];
  396.                     sprintf(CCharStr, "%3u,%02X", CurCh, CurCh);
  397.                 } else {
  398.                     if (CurPos > NumChars) strcpy(CCharStr, "      ");
  399.                     else if (CurLine < NumLines - 1) strcpy(CCharStr, "   EOL");
  400.                     else strcpy(CCharStr, "   EOF");
  401.                 }
  402.                 
  403.                 sprintf(s, "%04d:%02d %c%c%c%c%c %.6s %c"
  404. #ifdef DOS
  405.                         " %lu "
  406. #endif
  407.                         ,
  408.                         //                    CurLine + 1,
  409.                         ActLine + 1,
  410.                         CurColumn + 1,
  411.                         //                    CurPos + 1,
  412.                         (BFI(this, BFI_Insert)) ? 'I' : ' ',
  413.                         (BFI(this, BFI_AutoIndent)) ? 'A' : ' ',
  414.                         //                    (BFI(this, BFI_ExpandTabs))?'T':' ',
  415.                         (BFI(this, BFI_MatchCase)) ? 'C' : ' ',
  416.                         AutoExtend ?
  417.                         (
  418.                          (BlockMode == bmStream) ? 's' :
  419.                          (BlockMode == bmLine) ? 'l' : 'c'
  420.                         ) :
  421.                         ((BlockMode == bmStream) ? 'S' :
  422.                          (BlockMode == bmLine) ? 'L': 'C'
  423.                         ),
  424. #ifdef CONFIG_WORDWRAP
  425.                         (BFI(this, BFI_WordWrap) == 2) ? 'W' :
  426.                         (BFI(this, BFI_WordWrap) == 1) ? 'w' :
  427.                         ' ',
  428. #endif
  429.                         //                    (BFI(this, BFI_Undo))?'U':' ',
  430.                         //                    (BFI(this, BFI_Trim))?'E':' ',
  431.                         //                    (Flags.KeepBackups)?'B':' ',
  432.                         Mode->fName,
  433.                         (Modified != 0)?'*':(BFI(this, BFI_ReadOnly))?'%':' '
  434. #ifdef DOS
  435.                         ,coreleft()
  436. #endif
  437.                        );
  438.                 
  439.                 int l = strlen(s);
  440.                 int fw = W->Cols - l;
  441.                 int fl = strlen(FileName);
  442.                 char num[10];
  443.                 
  444.                 MoveStr(B, 0, W->Cols, s, SColor, W->Cols);
  445.                 sprintf(num, " %s %d", CCharStr, ModelNo);
  446.                 MoveStr(B, W->Cols - strlen(num), W->Cols, num, SColor, W->Cols);
  447.                 
  448.                 fw -= strlen(num);
  449.                 
  450.                 if (fl > fw) {
  451.                     MoveStr(B, l, W->Cols, FileName + fl - fw, SColor, W->Cols);
  452.                 } else {
  453.                     MoveStr(B, l, W->Cols, FileName, SColor, W->Cols);
  454.                 }
  455.             }
  456.         } else {
  457.             MoveStr(B, 0, W->Cols, V->CurMsg, SColor, W->Cols);
  458.         }
  459.         if (V->MView->Win->GetStatusContext() == V->MView) {
  460.             V->MView->ConPutBox(0, W->Rows, W->Cols, 1, B);
  461.             if (V->MView->IsActive()) {
  462.                 V->MView->ConShowCursor();
  463.                 V->MView->ConSetCursorPos(W->CP.Col - W->TP.Col, W->CP.Row - W->TP.Row);
  464.                 if (BFI(this, BFI_Insert)) {
  465.                     V->MView->ConSetCursorSize(CursorInsSize[0], CursorInsSize[1]);
  466.                 } else {
  467.                     V->MView->ConSetCursorSize(CursorOverSize[0], CursorOverSize[1]);
  468.                 }
  469.             }
  470.         }
  471.     }
  472.     
  473.     Rehilit(VToR(CP.Row));
  474.     
  475.     if (BFI(this, BFI_AutoHilitParen) == 1) {
  476.         if (Match.Row == -1 && Match.Col == -1)
  477.             HilitMatchBracket();
  478.     }
  479.     
  480.     //    if ((Window == WW) && (MinRedraw == -1))
  481.     //        MaxRedraw = MinRedraw = VToR(CP.Row);
  482.     
  483.     //printf("\n\nMinRedraw = %d, MaxRedraw = %d", MinRedraw, MaxRedraw);
  484.     if (MinRedraw == -1)
  485.         return;
  486.     
  487.     //    printf("Will redraw: %d to %d, to eos = %d\n", MinRedraw, MaxRedraw, RedrawToEos);
  488.     if (MinRedraw >= VCount) MinRedraw = VCount - 1;
  489.     if (MinRedraw < 0) MinRedraw = 0;
  490.     //    puts("xxx\x7");
  491.     //    printf("%d\n", MinRedraw);
  492.     Row = RowA = RToVN(MinRedraw);
  493.     //    puts("xxx\x7");
  494.     RowZ = MaxRedraw;
  495.     if (MaxRedraw != -1) {
  496.         int Delta = 0;
  497.         
  498.         if (MaxRedraw >= RCount) {
  499.             Delta = MaxRedraw - RCount + 1;
  500.             MaxRedraw = RCount - 1;
  501.         }
  502.         if (MaxRedraw < 0) MaxRedraw = 0;
  503.         //        printf("%d\n", MaxRedraw);
  504.         RowZ = RToVN(MaxRedraw) + Delta;
  505.     }
  506.     //    puts("xxx\x7");
  507.     //printf("\nRowA = %d, RowZ = %d", RowA, RowZ);
  508.     
  509.     V = View;
  510.     while (V) {
  511.         if (V->Model != this)
  512.             assert(1 == 0);
  513.         
  514.         W = GetViewVPort(V);
  515.         
  516.         for (int R = W->TP.Row; R < W->TP.Row + W->Rows; R++) {
  517.             Row = R;
  518.             if ((Row >= RowA) &&
  519.                 (RedrawToEos || Row <= RowZ))
  520.             {
  521.                 DrawLine(B, Row, W->TP.Col, W->Cols, HilitX);
  522.                 W->DrawLine(Row, B);
  523.                 if (HilitX && Row == RowZ)
  524.                     RowZ++;
  525.             }
  526.         }
  527.         V = V->NextView;
  528.     }
  529.     MinRedraw = MaxRedraw = -1;
  530.     RedrawToEos = 0;
  531. } 
  532.  
  533. int EBuffer::GetHilitWord(int len, char *str, ChColor &clr, int IgnCase) {
  534.     char *p;
  535.     
  536.     if (Mode == 0 || Mode->fColorize == 0)
  537.         return 0;
  538.     
  539.     if (len >= CK_MAXLEN)
  540.         return 0;
  541.     
  542. #ifdef CONFIG_WORD_HILIT
  543.     {
  544.         char s[CK_MAXLEN + 1];
  545.         s[CK_MAXLEN] = 0;
  546.         memcpy(s, str, len);
  547.         s[len] = 0;
  548.         if (HilitFindWord(s)) {
  549.             clr = hcPlain_HilitWord;
  550.             return 1;
  551.         }
  552.     }
  553. #endif
  554.     if (len < 1) return 0;
  555.     p = Mode->fColorize->Keywords.key[len];
  556.     if (IgnCase) {
  557.         while (p && *p) {
  558.             if (strnicmp(p, str, len) == 0) {
  559.                 clr = p[len];
  560.                 return 1;
  561.             }
  562.             p += len + 1;
  563.         }
  564.     } else {
  565.         while (p && *p) {
  566.             if (memcmp(p, str, len) == 0) {
  567.                 clr = p[len];
  568.                 return 1;
  569.             }
  570.             p += len + 1;
  571.         }
  572.     }
  573.     return 0;
  574. }
  575.  
  576. EEditPort *EBuffer::GetViewVPort(EView *V) {
  577.     return (EEditPort *)V->Port;
  578. }
  579.  
  580. EEditPort *EBuffer::GetVPort() {
  581.     return (EEditPort *)View->Port;
  582. }
  583.