medit.c

miniucgui1.30版本的源码

    {
        int off=0;
        off1 = MIN (strlen(caption),LEN_MLEDIT_BUFFER);
        if (off1 && (char)caption[off1-1] == '\r')
            off = off1-1;
        else
            off = off1;
        if (pMLEditData->curtotalLen + MIN (off,LEN_MLEDIT_BUFFER) >= pMLEditData->totalLimit)
        {
            pLineData->dataEnd = pMLEditData->totalLimit-pMLEditData->curtotalLen;
            if (pLineData->dataEnd-2 > 0 && (char)caption[pLineData->dataEnd-2] == '\r')
                pLineData->dataEnd -= 2;
            else if (pLineData->dataEnd-1 > 0 && (char)caption[pLineData->dataEnd-1] == '\n')
                pLineData->dataEnd --;

            memcpy(pLineData->buffer,caption, pLineData->dataEnd);
            pLineData->buffer[pLineData->dataEnd] = '\0';

        }else {
            memcpy(pLineData->buffer,caption,off1);
            if (off1 && pLineData->buffer[off1-1] == '\r')
                pLineData->buffer[off1-1] = '\0';
            else
                pLineData->buffer[off1] = '\0';
            pLineData->dataEnd         = strlen(pLineData->buffer); 
            pLineData->next            = NULL; 

        }
        pMLEditData->curtotalLen += pLineData->dataEnd;
        if (pMLEditData->curtotalLen == pMLEditData->totalLimit-1)
            pMLEditData->curtotalLen = pMLEditData->totalLimit;
        if (!pLineData->dataEnd)
        {
            pLineData->nwrapline = 1;
            pLineData->wrapStartPos[0] = 0;
            pLineData->wrapStartPos[1] = 0;
        } else
              calcLineInfo (hWnd, pMLEditData, pLineData);

        pMLEditData->wraplines += pLineData->nwrapline;
        pLineData->lineNO = lineNO++;
    }

    pMLEditData->lines      = lineNO; 

    if (dwStyle & ES_AUTOWRAP)
        pMLEditData->linesDisp     =  MIN (pMLEditData->wraplines, pMLEditData->MaxlinesDisp);
    else
        pMLEditData->linesDisp     =  MIN (lineNO , pMLEditData->MaxlinesDisp);
    pMLEditData->EndlineDisp = pMLEditData->StartlineDisp + pMLEditData->linesDisp -1;
}

PLINEDATA GetLineData(PMLEDITDATA pMLEditData,int lineNO)
{
    PLINEDATA pLineData=pMLEditData->head;
    for (; pLineData; pLineData=pLineData->next)
    {
        if(pLineData->lineNO==lineNO)
            return pLineData;
    }
    return NULL;
}

int GetMaxLen (HWND hWnd, PMLEDITDATA pMLEditData)
{
    int i;
    PLINEDATA pLineData = pMLEditData->head;
    
    i = 0;
    while (pLineData)
    {
        edtGetLineInfo (hWnd, pLineData);
        if (pMLEditData->sz.cx > i) 
            i = pMLEditData->sz.cx;
        pLineData = pLineData->next;
    }
    return i;
}

// get the valid unit position in the array 
// according to the pos 
// which is relative to the original point of current line (0)  
static int  edtGetNewvPos (HWND hWnd, PLINEDATA pLineData , int pos)
{
    int i = 0;
    int dist = MAX_IMPOSSIBLE;
    int newdist = 0;
    
    PMLEDITDATA pMLEditData = (PMLEDITDATA) GetWindowAdditionalData2(hWnd);
    edtGetLineInfo (hWnd, pLineData);

    if (pos < 0) return -1;
    if (pos > pMLEditData->sz.cx) return -2;
    for (i=0; i<pMLEditData->fit_chars + 1; i++) {
        newdist = pos - pMLEditData->dx_chars[i];
        if (newdist > 0 && newdist < dist)
            dist = newdist;
        else 
             return i;
    }
    return 0;
}

static void edtSetScrollInfo (HWND hWnd, PMLEDITDATA pMLEditData, BOOL fRedraw)
{
    SCROLLINFO     si;
    PLINEDATA     pLineData;
    RECT         rc;
    int         viLn;

    // Vscroll
    GetClientRect (hWnd, &rc);
    viLn = (rc.bottom - rc.top - pMLEditData->topMargin - pMLEditData->bottomMargin) / pMLEditData->lineHeight;
    
    si.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
    
    if ((GetWindowStyle(hWnd)) & ES_AUTOWRAP) 
        si.nMax = pMLEditData->wraplines - 1;
    else
        si.nMax = pMLEditData->lines - 1;

    si.nMin = 0;
    si.nPage = MIN (pMLEditData->EndlineDisp - pMLEditData->StartlineDisp + 1, viLn);
    
    si.nPos = pMLEditData->StartlineDisp;
    
    if ((si.nMax < viLn) && (!si.nPos)) {
        si.nMax = 100;
        si.nMin = 0;
        si.nPage = 10;
        si.nPos = 0;
        SetScrollInfo (hWnd, SB_VERT, &si, fRedraw);
//        EnableScrollBar (hWnd, SB_VERT, FALSE);
    } else {
        SetScrollInfo (hWnd, SB_VERT, &si, fRedraw);
//        EnableScrollBar (hWnd, SB_VERT, TRUE);
    }
    
    if ((GetWindowStyle(hWnd)) & ES_AUTOWRAP) 
    {
        EnableScrollBar (hWnd, SB_HORZ, FALSE);
        return;
    }
    // Hscroll
    pLineData = GetLineData(pMLEditData, pMLEditData->editLine);
    si.nMax = GetMaxLen(hWnd, pMLEditData) - 1;
    si.nMin = 0;
    si.nPage = edtGetOutWidth (hWnd);
    edtGetLineInfo (hWnd, pLineData);
    si.nPos = pMLEditData->dispPos;
            
    if (si.nMax < si.nPage && (!si.nPos)) {
        si.nMax = 100;
        si.nMin = 0;
        si.nPage = 10;
        si.nPos = 0;
        SetScrollInfo (hWnd, SB_HORZ, &si, fRedraw);
//        EnableScrollBar (hWnd, SB_HORZ, FALSE);
    } else {
        SetScrollInfo (hWnd, SB_HORZ, &si, fRedraw);
//        EnableScrollBar (hWnd, SB_HORZ, TRUE);
    }
}

int edtGetLineNums (PMLEDITDATA pMLEditData, int curline, int* line, int* wrapLine)
{
       PLINEDATA      pLineData = pMLEditData->head;
    int startline = 0;

    if (!curline)
    {
        *line = 0;
        *wrapLine = 0;
        return 0;
    }

    for (; pLineData; pLineData=pLineData->next)
    {
        if (startline+pLineData->nwrapline-1 >= curline)
        {
            *line = pLineData->lineNO;
            *wrapLine = curline - startline;
            return 0;
        }
        startline +=pLineData->nwrapline;
    }
    return -1;
}

// to set the Caret to a valid pos
BOOL edtGetCaretValid (HWND hWnd, int lineNO, int olddispPos, int newOff/*of caret*/)
{
    int line, wrapline;
    int dist = MAX_IMPOSSIBLE;
    int i, newdist = 0;
    PLINEDATA temp;
    PMLEDITDATA pMLEditData =(PMLEDITDATA) GetWindowAdditionalData2(hWnd);
        
    if (GetWindowStyle(hWnd) & ES_AUTOWRAP)
    {
        edtGetLineNums (pMLEditData, lineNO, &line, &wrapline);
        temp = GetLineData (pMLEditData, line);
        edtGetLineInfo (hWnd, temp);

        if( newOff >= pMLEditData->dx_chars[temp->wrapStartPos[wrapline+1]]
                            - pMLEditData->dx_chars[temp->wrapStartPos[wrapline]])
        {
            if (wrapline < temp->nwrapline-1)
                pMLEditData->veditPos = temp->wrapStartPos[wrapline+1]-1;
            else
                pMLEditData->veditPos = temp->wrapStartPos[wrapline+1];
        }else {
            newOff += pMLEditData->dx_chars[temp->wrapStartPos[wrapline]];
            for (i=temp->wrapStartPos[wrapline]; i<temp->wrapStartPos[wrapline+1]+1; i++) {
                newdist = newOff - pMLEditData->dx_chars[i];
                if (newdist > 0 && newdist < dist)
                    dist = newdist;
                else { 
                      pMLEditData->veditPos =i;
                    return FALSE;
                }
            }
        }
    }else {        
        temp = GetLineData (pMLEditData, lineNO);
        edtGetLineInfo (hWnd, temp);

        if( olddispPos > pMLEditData->sz.cx ) 
        {
            pMLEditData->veditPos = pMLEditData->fit_chars;
               pMLEditData->vdispPos = edtGetStartDispPosAtEnd (hWnd, temp);
            return TRUE;
        }else {
            pMLEditData->veditPos = edtGetNewvPos (hWnd, temp, newOff);
            if (pMLEditData->veditPos == -2)
                pMLEditData->veditPos = pMLEditData->fit_chars;
            pMLEditData->vdispPos = edtGetNewvPos (hWnd, temp, olddispPos);
            if (olddispPos != pMLEditData->dx_chars[pMLEditData->vdispPos])
                return TRUE;
        }
    }
    return FALSE;
}

void edtSetCaretPos (HWND hWnd)
{
    int line = 0, wrapline = 0;
    PMLEDITDATA pMLEditData =(PMLEDITDATA) GetWindowAdditionalData2(hWnd);
    PLINEDATA temp;

    if (GetWindowStyle(hWnd) & ES_AUTOWRAP)
    {
        edtGetLineNums (pMLEditData, pMLEditData->editLine, &line, &wrapline);
        temp = GetLineData (pMLEditData, line);
        edtGetLineInfo (hWnd, temp);
        SetCaretPos (hWnd, 
                pMLEditData->dx_chars[pMLEditData->veditPos] 
                    - pMLEditData->dx_chars[temp->wrapStartPos[wrapline]]
                    + pMLEditData->leftMargin, 
                (pMLEditData->editLine-pMLEditData->StartlineDisp) * pMLEditData->lineHeight
                    + pMLEditData->topMargin);
        
    }else {
        temp = GetLineData (pMLEditData, pMLEditData->editLine);
        edtGetLineInfo (hWnd, temp);
        SetCaretPos (hWnd, 
                pMLEditData->dx_chars[pMLEditData->veditPos] 
                    - pMLEditData->dx_chars[pMLEditData->vdispPos]
                    + pMLEditData->leftMargin, 
                (pMLEditData->editLine-pMLEditData->StartlineDisp) * pMLEditData->lineHeight
                    + pMLEditData->topMargin);
    }
}

void edtPosProc (HWND hWnd)
{
    int line, wrapline;
    PMLEDITDATA pMLEditData =(PMLEDITDATA) GetWindowAdditionalData2(hWnd);
    PLINEDATA pLineData;

    if (pMLEditData->diff) {
        pMLEditData->editLine = pMLEditData->realeditLine;
        pMLEditData->vdispPos = pMLEditData->realdispPos;
        pMLEditData->dispPos = pMLEditData->dx_chars[pMLEditData->vdispPos];
        pMLEditData->StartlineDisp = pMLEditData->realStartLine;
        pMLEditData->EndlineDisp   = pMLEditData->realEndLine;
        pMLEditData->diff = FALSE;
        if (GetWindowStyle(hWnd) & ES_AUTOWRAP)
        {
            edtGetLineNums (pMLEditData, pMLEditData->editLine, &line, &wrapline);
            pLineData = GetLineData(pMLEditData, line);
        }else
            pLineData= GetLineData(pMLEditData, pMLEditData->editLine);
           edtGetLineInfo (hWnd, pLineData);
        ActiveCaret (hWnd);
        pMLEditData->bSCROLL = TRUE;
    }else
        pMLEditData->bSCROLL = FALSE;
}

/* add end*/

static void edtOnEraseBackground (HWND hWnd, DWORD dwStyle, HDC hdc, const RECT* pClipRect)
{
    int i;
    RECT rcTemp;
    BOOL fGetDC = FALSE;
    PMLEDITDATA pMLEditData = (PMLEDITDATA) GetWindowAdditionalData2(hWnd);

    if (hdc == 0) {
        hdc = GetClientDC (hWnd);
        fGetDC = TRUE;
    }

    GetClientRect (hWnd, &rcTemp);

    if (pClipRect)
        ClipRectIntersect (hdc, pClipRect);

    if (dwStyle & WS_DISABLED) {
        SetBrushColor (hdc, PIXEL_lightgray);
    }
    else {
        SetBrushColor (hdc, PIXEL_lightwhite);
    }
    FillBox (hdc, rcTemp.left, rcTemp.top, 
                 RECTW (rcTemp), RECTH (rcTemp));

    if (dwStyle & ES_BASELINE) {
        SetPenColor (hdc, PIXEL_black);