/* * CDE - Common Desktop Environment * * Copyright (c) 1993-2012, The Open Group. All rights reserved. * * These libraries and programs are free software; you can * redistribute them and/or modify them under the terms of the GNU * Lesser General Public License as published by the Free Software * Foundation; either version 2 of the License, or (at your option) * any later version. * * These libraries and programs are distributed in the hope that * they will be useful, but WITHOUT ANY WARRANTY; without even the * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU Lesser General Public License for more * details. * * You should have received a copy of the GNU Lesser General Public * License along with these libraries and programs; if not, write * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth * Floor, Boston, MA 02110-1301 USA */ /* * * (c) Copyright 1993, 1994, 1996 Hewlett-Packard Company * * (c) Copyright 1993, 1994, 1996 International Business Machines Corp. * * (c) Copyright 1993, 1994, 1996 Sun Microsystems, Inc. * * (c) Copyright 1993, 1994, 1996 Novell, Inc. * * (c) Copyright 1996 Digital Equipment Corporation. * * (c) Copyright 1996 FUJITSU LIMITED. * * (c) Copyright 1996 Hitachi. * */ #include "TermHeader.h" #include "TermPrimDebug.h" #include "TermPrimP.h" #include "TermPrimI.h" #include "TermPrimData.h" #include "TermPrimLineDraw.h" #include "TermPrimBufferP.h" #include "TermPrimRender.h" #include "TermPrimRenderP.h" #include "TermPrimSelect.h" #include "TermPrimSelectP.h" #include "TermPrimMessageCatI.h" #include #ifdef DKS void _termSetRenderFont(Widget w, TermFont *termFont) { DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w; struct termData *tpd = tw->term.tpd; int i; /* DKS: ** alert ** alert ** alert ** alert ** alert ** * * The following opens up a memory leak that needs to be closed. * we need to free up both the list and any created entries... */ /* do initialization... */ if (!tpd->renderTermFontsNum) { tpd->renderTermFontsNum = 4; tpd->renderTermFonts = (TermFont **) malloc((unsigned) tpd->renderTermFontsNum * sizeof(TermFont *)); (void) memset(tpd->renderTermFonts, '\0', tpd->renderTermFontsNum * sizeof(TermFont *)); } /* replace the font if we already have one defined, else add it... */ for (i = 0; i < tpd->renderTermFontsNum; i++) { if (tpd->renderTermFonts[i] && (tpd->renderTermFonts[i]->id == termFont->id)) /* found an existing font with this id... */ break; } if (i >= tpd->renderTermFontsNum) { /* we didn't find one, so let's add this one to the list... */ for (i = 0; i < tpd->renderTermFontsNum; i++) { if (!tpd->renderTermFonts[i]) break; } /* check for list full... */ if (i >= tpd->renderTermFontsNum) { (void) fprintf(stderr, "setRenderFont: list full can't add font to widget 0x%lx\n", w); } /* we found an empty spot and need to malloc storage... */ tpd->renderTermFonts[i] = (TermFont *) malloc(sizeof(TermFont)); /* we don't need to initialize it as we will do a copy below... */ } (void) memcpy(tpd->renderTermFonts[i], termFont, sizeof(TermFont)); if ((0 == tpd->cellWidth) || ('@' == termFont->id)) { tpd->cellWidth = termFont->width; tpd->cellHeight = termFont->height; tw->term.widthInc = termFont->width; tw->term.heightInc = termFont->height; tw->term.ascent = termFont->ascent; } } #endif /* DKS */ void _DtTermPrimBell(Widget w) { DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w; struct termData *tpd = tw->term.tpd; int i; if (tw->term.visualBell) { /* the speed of this operation is not critical, so we will just * use the standard text rendering GC and restore it after we * are done... */ if (tpd->renderGC.foreground != (tw->primitive.foreground ^ tw->core.background_pixel)) { tpd->renderGC.foreground = tw->primitive.foreground ^ tw->core.background_pixel; (void) XSetForeground(XtDisplay(w), tpd->renderGC.gc, tpd->renderGC.foreground); } (void) XSetFunction(XtDisplay(w), tpd->renderGC.gc, GXxor); for (i = 0; i < 2; i++) { (void) XFillRectangle(XtDisplay(w), /* Display */ XtWindow(w), /* Drawable */ tpd->renderGC.gc, /* GC */ tpd->offsetX, /* x */ tpd->offsetY, /* y */ tw->term.columns * tpd->cellWidth, /* width */ tw->term.rows * tpd->cellHeight); /* height */ (void) XSync(XtDisplay(w), 0); } /* restore the GC... */ (void) XSetFunction(XtDisplay(w), tpd->renderGC.gc, GXcopy); } else { (void) XBell(XtDisplay(w), 0); } } void _DtTermPrimRefreshText(Widget w, short startColumn, short startRow, short endColumn, short endRow) { DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w; struct termData *tpd = tw->term.tpd; TermBuffer tBuffer = tpd->termBuffer; int lineWidth; unsigned char *linePtr; TermFont termFont; int currentColorPair = 0; int currentVideo = 0; short chunkStartColumn; short chunkWidth; enhValues enhancements; int i; int lineNum; unsigned long valueMask; GC gc; XGCValues values; TermEnhInfoRec enhInfo; Boolean checkSelection = False; int selectionEnd; Pixel tmpPixel; XmTextPosition begin, end; DebugF('t', 0, fprintf(stderr, ">>_DtTermPrimRefreshText() starting\n")); DebugF('t', 0, fprintf(stderr, ">>_DtTermPrimRefreshText() startCol=%hd startRow=%hd endCol=%hd endRow=%hd\n", startColumn, startRow, endColumn, endRow)); if (tpd->mbCurMax > 1) { _DtTermPrimRefreshTextWc(w, startColumn, startRow, endColumn, endRow); return; } /* clip start/end x/y... */ if (startColumn <= 0) startColumn = 0; if (startRow <= 0) startRow = 0; if (endColumn >= tw->term.columns) endColumn = tw->term.columns - 1; if (endRow >= tw->term.rows) endRow = tw->term.rows - 1; /* ** don't display if we are in jump scroll and in the process ** of scrolling and inside the scroll region... */ if (tw->term.jumpScroll && tpd->scroll.jump.scrolled) { /* set all the scrollRefreshRows flags... */ for (; startRow <= endRow; startRow++) { tpd->scrollRefreshRows[startRow] = True; } DebugF('t', 0, fprintf(stderr, ">>_DtTermPrimRefreshText() jump scroll in progress, no render\n")); return; } if (!tpd->renderGC.gc) { /* get a drawImageString GC... */ int i; XGCValues values; /*********************************************************** * renderGC... */ /* set the GC fg and bg... */ values.foreground = tw->term.reverseVideo ? tw->core.background_pixel : tw->primitive.foreground; values.background = tw->term.reverseVideo ? tw->primitive.foreground : tw->core.background_pixel; tpd->renderGC.gc = XCreateGC(XtDisplay(w), XtWindow(w), GCForeground | GCBackground, &values); /* set the GC cache values... */ tpd->renderGC.foreground = values.foreground; tpd->renderGC.background = values.background; tpd->renderGC.fid = (Font) 0; /*********************************************************** * renderReverseGC... */ values.foreground = tw->term.reverseVideo ? tw->primitive.foreground : tw->core.background_pixel; values.background = tw->term.reverseVideo ? tw->core.background_pixel : tw->primitive.foreground; tpd->renderReverseGC.gc = XCreateGC(XtDisplay(w), XtWindow(w), GCForeground | GCBackground, &values); /* set the GC cache values... */ tpd->renderReverseGC.foreground = values.foreground; tpd->renderReverseGC.background = values.background; tpd->renderReverseGC.fid = (Font) 0; /*********************************************************** * clearGC... */ values.foreground = tw->term.reverseVideo ? tw->primitive.foreground : tw->core.background_pixel; values.background = tw->term.reverseVideo ? tw->core.background_pixel : tw->primitive.foreground; tpd->clearGC.gc = XCreateGC(XtDisplay(w), XtWindow(w), GCForeground | GCBackground, &values); /* set the GC cache values... */ tpd->clearGC.foreground = values.foreground; tpd->clearGC.background = values.background; tpd->clearGC.fid = (Font) 0; } #ifdef SUN_MOTIF_PERF /* use the clear GC... */ gc = tpd->clearGC.gc; valueMask = (unsigned long) 0; if (tpd->clearGC.foreground != tw->term.reverseVideo ? tw->core.background_pixel : tw->primitive.foreground) { values.foreground = tw->term.reverseVideo ? tw->primitive.foreground : tw->core.background_pixel; tpd->clearGC.foreground = values.foreground; valueMask |= GCForeground; } if (tpd->clearGC.background != tw->term.reverseVideo ? tw->primitive.foreground : tw->core.background_pixel) { values.background = tw->term.reverseVideo ? tw->core.background_pixel : tw->primitive.foreground; tpd->clearGC.background = values.background; valueMask |= GCBackground; } if (valueMask) { (void) XChangeGC(XtDisplay(w), tpd->clearGC.gc, valueMask, &values); } (void) XFillRectangle(XtDisplay(w), /* Display */ XtWindow(w), /* Drawable */ gc, /* GC */ startColumn * tpd->cellWidth + tpd->offsetX, /* x */ startRow * tpd->cellHeight + tpd->offsetY, /* y */ (endColumn - startColumn + 1) * tpd->cellWidth, /* width */ (endRow - startRow + 1) * tpd->cellHeight); /* height */ #endif /* SUN_MOTIF_PERF */ for (; startRow <= endRow; startRow++) { /* if we are refreshing a full line, then we can clear the * scrollRefreshRows flag for this line... */ if ((startColumn == 0) && (endColumn >= tw->term.columns - 1)) { tpd->scrollRefreshRows[startRow] = False; } lineNum = startRow + tpd->topRow; if (!tw->term.jumpScroll && tpd->scroll.nojump.pendingScroll) { if (lineNum != tpd->scrollLockBottomRow) { lineNum -= tpd->scroll.nojump.pendingScrollLines; } } /* are we in the selected area?... */ if (tpd->useHistoryBuffer) { if (_DtTermPrimSelectGetSelection(w, &begin, &end) && (begin < end) && (lineNum >= (begin / (tpd->selectInfo->columns + 1)) - tpd->lastUsedHistoryRow) && (lineNum <= (end / (tpd->selectInfo->columns + 1)) - tpd->lastUsedHistoryRow)) { checkSelection = True; } else { checkSelection = False; } } else { if (_DtTermPrimSelectGetSelection(w, &begin, &end) && (begin < end) && (lineNum >= (begin / (tpd->selectInfo->columns + 1))) && (lineNum <= (end / (tpd->selectInfo->columns + 1)))) { checkSelection = True; } else { checkSelection = False; } } chunkStartColumn = startColumn; if (startColumn > endColumn) { /* nothing to render on this line... */ continue; } if (lineNum >= tpd->lastUsedRow) { /* we are pointing to empty screen space below the last used * line of the display... */ lineWidth = 0; linePtr = NULL; } else if (lineNum < 0) { if ((tpd->useHistoryBuffer) && (-lineNum <= tpd->lastUsedHistoryRow)) { /* get a line out of the history buffer... */ lineWidth = MAX(0, MIN(endColumn - startColumn + 1, _DtTermPrimBufferGetLineWidth(tpd->historyBuffer, tpd->lastUsedHistoryRow + lineNum) - startColumn)); linePtr = _DtTermPrimBufferGetCharacterPointer(tpd->historyBuffer, tpd->lastUsedHistoryRow + lineNum, startColumn); } else { /* we are above the history buffer. Should not happen, but... */ lineWidth = 0; linePtr = NULL; } } else { /* get the line width and a pointer to the data... */ lineWidth = MAX(0, MIN(endColumn - startColumn + 1, _DtTermPrimBufferGetLineWidth(tBuffer, lineNum) - startColumn)); linePtr = _DtTermPrimBufferGetCharacterPointer(tBuffer, lineNum, startColumn); } while (lineWidth > 0) { /* get the enhancement values for the first chunk of the * string... */ if (lineNum >= 0) { (void) _DtTermPrimBufferGetEnhancement(tBuffer, /* TermBuffer */ lineNum, /* row */ chunkStartColumn, /* col */ &enhancements, /* enhancements */ &chunkWidth, /* width */ countAll); /* countWhich */ } else { /* get it from the history buffer... */ (void) _DtTermPrimBufferGetEnhancement(tpd->historyBuffer, /* TermBuffer */ tpd->lastUsedHistoryRow + lineNum, /* row */ chunkStartColumn, /* col */ &enhancements, /* enhancements */ &chunkWidth, /* width */ countAll); /* countWhich */ } /* clip chunkWidth... */ if (chunkWidth > lineWidth) chunkWidth = lineWidth; /* set reasonable defaults for our render info... */ enhInfo.fg = tw->primitive.foreground; enhInfo.bg = tw->core.background_pixel; enhInfo.font = tpd->defaultTermFont; enhInfo.flags = (unsigned long) 0; /* set our font and color from the enhancements... */ if (ENH_PROC(tBuffer)) { (void) (*(ENH_PROC(tBuffer)))(w, enhancements, &enhInfo); } /* if we are in reverse video mode... */ if (tw->term.reverseVideo) { /* flip fg and bg... */ tmpPixel = enhInfo.fg; enhInfo.fg = enhInfo.bg; enhInfo.bg = tmpPixel; } /* are we in the selection area?... */ if (checkSelection && _DtTermPrimSelectIsInSelection(w, lineNum, chunkStartColumn, chunkWidth, &chunkWidth)) { /* flip fg and bg... */ tmpPixel = enhInfo.fg; enhInfo.fg = enhInfo.bg; enhInfo.bg = tmpPixel; } /* if secure, we will use a XFillRectangle, and we need * foreground set to the background... */ if (TermIS_SECURE(enhInfo.flags)) { /* render secure video locally... */ /* set the renderReverseGC... */ valueMask = (unsigned long) 0; if (tpd->renderReverseGC.foreground != enhInfo.bg) { tpd->renderReverseGC.foreground = enhInfo.bg; values.foreground = enhInfo.bg; valueMask |= GCForeground; } if (valueMask) { (void) XChangeGC(XtDisplay(w), tpd->renderReverseGC.gc, valueMask, &values); } (void) XFillRectangle(XtDisplay(w), XtWindow(w), tpd->renderReverseGC.gc, chunkStartColumn * tpd->cellWidth + tpd->offsetX, startRow * tpd->cellHeight + tpd->offsetY, tpd->cellWidth * chunkWidth, tpd->cellHeight); /* underline as well... */ if (TermIS_UNDERLINE(enhInfo.flags)) { valueMask = (unsigned long) 0; if (tpd->renderGC.foreground != enhInfo.fg) { tpd->renderGC.foreground = enhInfo.fg; values.foreground = enhInfo.fg; valueMask |= GCForeground; } if (valueMask) { (void) XChangeGC(XtDisplay(w), tpd->renderGC.gc, valueMask, &values); } (void) XDrawLine(XtDisplay(w), /* Display */ XtWindow(w), /* Drawable */ tpd->renderGC.gc, /* GC */ chunkStartColumn * tpd->cellWidth + tpd->offsetX, /* X1 */ startRow * tpd->cellHeight + tpd->offsetY + tpd->cellHeight - 1, /* Y1 */ (chunkStartColumn + chunkWidth) * tpd->cellWidth + tpd->offsetX, /* X2 */ startRow * tpd->cellHeight + tpd->offsetY + tpd->cellHeight - 1); /* Y2 */ } } else { (void) _DtTermPrimRenderText( w, /* Widget */ enhInfo.font, /* TermFont */ enhInfo.fg, /* fg Pixel */ enhInfo.bg, /* bg Pixel */ enhInfo.flags, /* flags */ chunkStartColumn * tpd->cellWidth + tpd->offsetX, /* x */ startRow * tpd->cellHeight + tpd->offsetY, /* y */ linePtr, /* string */ chunkWidth); /* width */ } chunkStartColumn += chunkWidth; lineWidth -= chunkWidth; linePtr += chunkWidth; } /* clear any extra space in the line. chunkStartColumn now points to * the end of the line, and lineWidth == 0... */ while (endColumn - chunkStartColumn >= 0) { chunkWidth = endColumn - chunkStartColumn + 1; if (checkSelection && _DtTermPrimSelectIsInSelection(w, lineNum, chunkStartColumn, chunkWidth, &chunkWidth)) { /* use the render gc set to the fg color... */ gc = tpd->renderReverseGC.gc; valueMask = (unsigned long) 0; if (tpd->renderReverseGC.foreground != tw->term.reverseVideo ? tw->core.background_pixel : tw->primitive.foreground) { values.foreground = tw->term.reverseVideo ? tw->core.background_pixel : tw->primitive.foreground; tpd->renderReverseGC.foreground = values.foreground; valueMask |= GCForeground; } if (valueMask) { (void) XChangeGC(XtDisplay(w), tpd->renderReverseGC.gc, valueMask, &values); } #ifndef SUN_MOTIF_PERF } else { /* use the clear GC... */ gc = tpd->clearGC.gc; valueMask = (unsigned long) 0; if (tpd->clearGC.foreground != tw->term.reverseVideo ? tw->core.background_pixel : tw->primitive.foreground) { values.foreground = tw->term.reverseVideo ? tw->primitive.foreground : tw->core.background_pixel; tpd->clearGC.foreground = values.foreground; valueMask |= GCForeground; } if (tpd->clearGC.background != tw->term.reverseVideo ? tw->primitive.foreground : tw->core.background_pixel) { values.background = tw->term.reverseVideo ? tw->core.background_pixel : tw->primitive.foreground; tpd->clearGC.background = values.background; valueMask |= GCBackground; } if (valueMask) { (void) XChangeGC(XtDisplay(w), tpd->clearGC.gc, valueMask, &values); } } #endif /* not SUN_MOTIF_PERF */ if (isDebugFSet('t', 1)) { #ifdef BBA #pragma BBA_IGNORE #endif /*BBA*/ /* Fill in the clear area so we can see what is going to * be displayed... */ (void) XFillRectangle(XtDisplay(w), XtWindow(w), tpd->renderGC.gc, chunkStartColumn * tpd->cellWidth + tpd->offsetX, startRow * tpd->cellHeight + tpd->offsetY, chunkWidth * tpd->cellWidth, tpd->cellHeight); (void) XSync(XtDisplay(w), False); (void) shortSleep(100000); } (void) XFillRectangle(XtDisplay(w), /* Display */ XtWindow(w), /* Drawable */ gc, /* GC */ chunkStartColumn * tpd->cellWidth + tpd->offsetX, /* x */ startRow * tpd->cellHeight + tpd->offsetY, /* y */ chunkWidth * tpd->cellWidth, /* width */ tpd->cellHeight); /* height */ #ifdef SUN_MOTIF_PERF } #endif /* SUN_MOTIF_PERF */ chunkStartColumn += chunkWidth; } } DebugF('t', 0, fprintf(stderr, ">>_DtTermPrimRefreshText() finished\n")); } /************************************************************************** * Function: * _DtTermPrimExposeText(): expose (refresh) the text in rectangular area * * Parameters: * Widget w: widget to expose * int x: starting x pixel in window * int y: starting y pixel in window * int width: width in pixels * int height: height in pixels * Boolean isExposeEvent: true, deal with copyarea / expose overlap * * Returns: * * * Notes: * This function will redisplay the text in a rectangular exposure * area. The x, y, width, and height are in absolute pixels. The * internal x and y offsets will be accounted for, and the minimum * number of characters will be displayed. The algorithm has been * tuned (somewhat) and no longer exposes an extra character at the * end of the refresh lines and an extra line at the bottom of the * refresh area. This can be verified by using the 't' and 'e' * debug flags. */ void _DtTermPrimExposeText(Widget w, int x, int y, int width, int height, Boolean isExposeEvent) { struct termData *tpd = ((DtTermPrimitiveWidget) w)->term.tpd; DebugF('e', 0, fprintf(stderr, ">>exposeText() starting\n")); DebugF('e', 0, fprintf(stderr, ">>exposeText() startX=%d startY=%d width=%d height=%d\n", x, y, width, height)); DebugF('e', 0, fprintf(stderr, ">> offsetX=%d offsetY=%d cellHeight=%d cellWidth=%d\n", tpd->offsetX, tpd->offsetY, tpd->cellHeight, tpd->cellWidth)); /* The following "hack" takes care of the problem of an exposure event * from the server and a copy area from the client crossing. The * combination of these two events can cause a race condition which * manifests itself by leaving a hole in the terminal window. What * happens is this: * * A window is partially obscured. The terminal emulator does a copy * area (scroll) which includes part of obscured area. Before the * server processes the copy area, the window is unobscured, and the * server sends an exposure event back to the client. * * - The window is partially obscured. * * - The terminal emulator does a copy area (scroll) which includes a * portion of the obscured area. Normally, the server will generate * a graphics exposure event for the obscured portion that it can't * copy which will allow the terminal emulator to update the area. * * - Before the server receives the copy area request, the server * unobscures the window and sends an exposure event for the exposed * area. (This is where the hack comes into play and refreshes the * scrolled portion of this area (and possibly some extra space as * well)). * * - The server processes the copy area. Since the area in question is * no longer obscured, the server will copy blank space and not * generate a graphics exposure event. * * - The terminal emulator processes the exposure event and refreshes * the exposed area. (This is the hack extends the exposure to cover * the gap). * * - You now have a blank chunk of the terminal window where the * obscured area was scrolled (without the hack). * * Our fix is similar to the one used in xterm. The Motif text widget * uses a more brute force method and simply extends the exposure event * to the full height (or width) of the screen in the direction of the * copy area. */ if (isExposeEvent && tpd->scrollInProgress) { int bothX1; int bothX2; int bothY1; int bothY2; bothX1 = MAX(tpd->scrollSrcX, x); bothY1 = MAX(tpd->scrollSrcY, y); bothX2 = MIN(tpd->scrollSrcX + tpd->scrollWidth, x + width - 1); bothY2 = MIN(tpd->scrollSrcY + tpd->scrollHeight, y + height - 1); if ((bothX2 > bothX1) && (bothY2 > bothY1)) { (void) _DtTermPrimRefreshText(w, (x - tpd->offsetX + tpd->scrollDestX - tpd->scrollSrcX) / tpd->cellWidth, (y - tpd->offsetY + tpd->scrollDestY - tpd->scrollSrcY) / tpd->cellHeight, (x + width - 1 - tpd->offsetX + tpd->scrollDestX - tpd->scrollSrcX) / tpd->cellWidth, (y + height - 1 - tpd->offsetY + tpd->scrollDestY - tpd->scrollSrcY) / tpd->cellHeight); } } /* render the text... */ DebugF('t', 0, fprintf(stderr, ">>exposeText() calling _DtTermPrimRefreshText()\n")); (void) _DtTermPrimRefreshText(w, (x - tpd->offsetX) / tpd->cellWidth, (y - tpd->offsetY) / tpd->cellHeight, (x + width - 1 - tpd->offsetX) / tpd->cellWidth, (y + height - 1 - tpd->offsetY) / tpd->cellHeight); DebugF('e', 0, fprintf(stderr, ">>exposeText() finished\n")); } void _DtTermPrimFillScreenGap(Widget w) { DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w; struct termData *tpd = tw->term.tpd; TermBuffer tBuffer = tpd->termBuffer; int linesNeeded; int linesCopied; int historyLinesNeeded; int i1; TermLineSelection selectionFlag; /* before we insert any text, we need to insure that the cursor is * on a valid buffer row. If not, we will need to fill in any gap * between the lastUsedRow and the current cursor postion with 0 * width lines, and get a buffer row for the current cursor row... */ if (tpd->topRow + tpd->cursorRow >= tpd->lastUsedRow) { /* if there are lines left in the buffer, just use them... */ /* this does not effect the position of the selection... */ for (; (tpd->lastUsedRow < tpd->bufferRows) && (tpd->topRow + tpd->cursorRow >= tpd->lastUsedRow); ) { /* all we need to do is clear the line... */ _DtTermPrimBufferClearLine(tBuffer, tpd->lastUsedRow++, 0); } /* if we still need more lines, then we will need to steal from * the top of the buffer... */ if (tpd->topRow + tpd->cursorRow >= tpd->lastUsedRow) { if (tpd->memoryLockMode == SCROLL_LOCKprotect) { if (!tpd->warningDialogMapped) { (void) _DtTermPrimWarningDialog(w, GETMESSAGE(NL_SETN_PrimRend, 1,"MEMORY FULL\nPress OK to clear")); } } else { /* figure out how many lines are needed... */ linesNeeded = tpd->topRow + tpd->cursorRow - (tpd->lastUsedRow - 1); linesCopied = 0; /* before we drop them off of the top, if we are * using a history buffer, we need to transfer them * into the history buffer... */ if (tpd->useHistoryBuffer && (tpd->scrollLockTopRow == 0) && (tpd->scrollLockBottomRow >= (tw->term.rows - 1))) { /* do we have enough lines in the history buffer, or * do we need to steal some from the top?... */ historyLinesNeeded = linesNeeded - (tpd->historyBufferRows - tpd->lastUsedHistoryRow); if ((historyLinesNeeded > 0) && (tpd->historyBufferRows > 0)) { /* take them from the top... */ /* we are effectively deleting the lines from the * top of the combined buffers... */ (void) _DtTermPrimSelectDeleteLines(w, 0, historyLinesNeeded); /* move the lines from the top to the bottom... */ (void) _DtTermPrimBufferInsertLineFromTB( tpd->historyBuffer, tpd->historyBufferRows - 1, historyLinesNeeded, insertFromTop); /* the lines are now freed, adjust the used count... */ tpd->lastUsedHistoryRow -= historyLinesNeeded; if (tpd->lastUsedHistoryRow < 0) { tpd->lastUsedHistoryRow = 0; } } /* copy the lines over... */ for (i1 = 0; (i1 < linesNeeded) && (tpd->lastUsedHistoryRow < tpd->historyBufferRows); i1++) { termChar *c1; short length; termChar *overflowChars; short overflowCount; /* get the line from the active buffer... */ length = _DtTermPrimBufferGetLineLength(tBuffer, i1); /* ** stuff it into the history buffer... ** (but only if there is something to copy) */ if (length > 0) { unsigned char eIndex; short eCol; short eCount; enhValue *eValues = (enhValue *)NULL; overflowChars = (termChar *) XtMalloc(BUFSIZ * sizeof (termChar)); /* Perpetuate the enhancements. */ for (eCol = 0; eCol < length; eCol += eCount) { if (_DtTermPrimBufferGetEnhancement(tBuffer, i1, eCol, &eValues, &eCount, countAll)) { if ((eValues == (enhValue *)NULL) || (eCount <= 0)) break; for (eIndex = 0; eIndex < NUM_ENH_FIELDS(tBuffer); eIndex++) { _DtTermPrimBufferSetEnhancement( tpd->historyBuffer, tpd->lastUsedHistoryRow, eCol, eIndex, eValues[eIndex]); } c1 = _DtTermPrimBufferGetCharacterPointer( tBuffer, i1, eCol); (void) _DtTermPrimBufferInsert( tpd->historyBuffer, tpd->lastUsedHistoryRow, eCol, c1, eCount, False, &overflowChars, &overflowCount); } else break; } if (eCol < length) { /* Clear out enhancement values if necessary */ if (eValues != (enhValue *)NULL) { for (eIndex = 0; eIndex < NUM_ENH_FIELDS(tBuffer); eIndex++) { _DtTermPrimBufferSetEnhancement( tpd->historyBuffer, tpd->lastUsedHistoryRow, eCol, eIndex, 0); } } c1 = _DtTermPrimBufferGetCharacterPointer( tBuffer, i1, eCol); (void) _DtTermPrimBufferInsert( tpd->historyBuffer, tpd->lastUsedHistoryRow, eCol, c1, length - eCol, False, &overflowChars, &overflowCount); } (void) XtFree((char *) overflowChars); } else { (void) _DtTermPrimBufferClearLine( tpd->historyBuffer, tpd->lastUsedHistoryRow, 0); } /* perpetuate the state of the wrap flag... */ (void) _DtTermPrimBufferSetLineWrapFlag( tpd->historyBuffer, tpd->lastUsedHistoryRow, _DtTermPrimBufferTestLineWrapFlag(tBuffer, i1)); /* perpetuate the state of the inSelection flag... */ selectionFlag = _DtTermPrimBufferGetInSelectionFlag( tBuffer, i1); (void) _DtTermPrimBufferSetInSelectionFlag( tpd->historyBuffer, tpd->lastUsedHistoryRow, selectionFlag); /* clear the inselection flag before we scroll * the lines off or we will end up releasing the * selection... */ (void) _DtTermPrimBufferSetInSelectionFlag( tBuffer, i1, (TermLineSelection) 0); (void) tpd->lastUsedHistoryRow++; (void) linesCopied++; } } /* take them from the top. If we are about to take lines * from the top without first copying them into the * history buffer, we need to adjust the selection * position... */ if (linesNeeded > linesCopied) { (void) _DtTermPrimSelectDeleteLines(w, tpd->lastUsedHistoryRow + linesCopied, linesNeeded - linesCopied); } (void) _DtTermPrimBufferInsertLineFromTB(tBuffer, tpd->bufferRows - 1, linesNeeded, insertFromTop); /* adjust everything... */ tpd->topRow -= linesNeeded; } } } } static short DoInsert(Widget w, unsigned char *buffer, int length, Boolean *wrapped) { DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w; struct termData *tpd = tw->term.tpd; TermBuffer tBuffer = tpd->termBuffer; short newWidth; termChar *returnChars; short returnCount; /* before we insert any text, we need to insure that the cursor is on * a valid buffer row... */ if (tpd->topRow + tpd->cursorRow >= tpd->lastUsedRow) { (void) _DtTermPrimFillScreenGap(w); } /* insert the text... */ returnChars = (termChar *) XtMalloc(BUFSIZ * sizeof (termChar)); newWidth = _DtTermPrimBufferInsert(tBuffer, /* TermBuffer */ tpd->topRow + tpd->cursorRow, /* row */ tpd->cursorColumn, /* column */ (termChar *) buffer, /* newChars */ length, /* numChars */ tpd->insertCharMode != DtTERM_INSERT_CHAR_OFF, /* insert flag */ &returnChars, /* return char ptr */ &returnCount); /* return count ptr */ if ((tpd->insertCharMode != DtTERM_INSERT_CHAR_ON_WRAP) || (returnCount <= 0)) { (void) XtFree((char *) returnChars); return(newWidth); } /* we are in insert char mode with wrap and we wrapped text off of * the line... */ *wrapped = True; /* wrap the inserted characters into the following line... */ if (tpd->topRow + tpd->cursorRow + 1 >= tpd->lastUsedRow) { /* fake cursorRow... */ (void) tpd->cursorRow++; (void) _DtTermPrimFillScreenGap(w); (void) tpd->cursorRow--; } /* we will allocate a temporary buffer so we don't have to worry * about _DtTermPrimBufferInsert tromping over its overflow buffer... */ length = returnCount; buffer = (unsigned char *) XtMalloc(length); (void) memcpy(buffer, returnChars, length); /* insert the text into the next line... */ newWidth = _DtTermPrimBufferInsert(tBuffer, /* TermBuffer */ tpd->topRow + tpd->cursorRow + 1, /* row */ 0, /* column */ (termChar *) buffer, /* newChars */ length, /* numChars */ tpd->insertCharMode != DtTERM_INSERT_CHAR_OFF, /* insert flag */ &returnChars, /* return char ptr */ &returnCount); /* return count ptr */ (void) XtFree((char *) buffer); (void) XtFree((char *) returnChars); return(newWidth); } int _DtTermPrimInsertText(Widget w, unsigned char *buffer, int length) { DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w; struct termData *tpd = tw->term.tpd; TermBuffer tBuffer = tpd->termBuffer; int i; short renderStartX; short renderEndX; short insertStartX; short insertCharCount; short newWidth; Boolean needToRender = False; Boolean wrapped = False; if (tpd->mbCurMax > 1) { short wcBufferLen; wchar_t *wcBuffer; wchar_t *pwc; int i; int mbLen; char *pmb; #ifdef NOCODE /* ** It would be nice if the calling function supplied us with a count ** of the number of mb characters in the buffer, then we wouldn't ** have to count them again. */ /* ** we could use this if the multi-byte buffer was null terminated */ wcBufferLen = mbstowcs((wchar_t *)NULL, (char *)buffer, length); #else /* NOCODE */ i = 0; pmb = (char *)buffer; /* ** we should never need more than length * sizeof(wchar_t) ** bytes to store the wide char equivalent of the incoming mb string */ wcBuffer = (wchar_t *)XtMalloc(length * sizeof(wchar_t)); pwc = wcBuffer; wcBufferLen = 0; while (i < length) { switch (mbLen = mbtowc(pwc, pmb, MIN(((int)MB_CUR_MAX), length - i))) { case -1: if ((int)MB_CUR_MAX <= length - i) { /* we have a bogus multi-byte character. Throw away * the first byte and rescan (TM 12/14/93)... */ /* ** in this case, we move the remaining length - i - 1 ** bytes one byte to the left (to overwrite the bogus ** byte) */ memmove(pmb, pmb + 1, length - i - 1); length--; continue; } break; case 0: /* ** treat null character same as any other character... */ mbLen = 1; default: i += mbLen; pmb += mbLen; pwc++; wcBufferLen++; } } #endif /* NOCODE */ i = _DtTermPrimInsertTextWc(w, wcBuffer, wcBufferLen); /* convert back from a wide character count to a multibyte * character count... */ pmb = (char *)buffer; wcBufferLen = i; i = 0; while (i < wcBufferLen) { switch (mbLen = mblen(pmb, MIN(((int)MB_CUR_MAX), length - i))) { case -1: case 0: /* ** treat null character same as any other character... */ mbLen = 1; default: i ++; pmb += mbLen; } } XtFree((char *)wcBuffer); return(pmb - (char *) buffer); } /* turn off the cursor... */ if (CURSORoff != tpd->cursorState) { (void) _DtTermPrimCursorOff(w); } /* we support two different types of autowrap. The HP style one is where * you display the character and then wrap if you are at the end of the * line. The ANSI style one is where you insert the character at the end * of the line and don't autowrap until you try to insert another * character... */ renderStartX = tpd->cursorColumn; renderEndX = tpd->cursorColumn; insertStartX = tpd->cursorColumn; insertCharCount = 0; for (i = 0; (i < length) && tpd->ptyInputId; i++) { /* the following code performs two functions. If we are in * autowrap, it performs a sanity check on the insert position. * if we are not in autowrap, it will insure that characters * inserted after the last position will replace the last * character... */ if ((tpd->cursorColumn >= tw->term.columns) && !(tpd->autoWrapRight && !tpd->wrapRightAfterInsert)) { /* blow away the previous character... */ tpd->cursorColumn = tw->term.columns - 1; renderStartX = MIN(renderStartX, tpd->cursorColumn); tpd->wrapState = WRAPpastRightMargin; } /* for emulations that wrap after inserting the character, we * will insert the character and then check for wrap... */ if (tpd->wrapRightAfterInsert) { if (insertCharCount == 0) { insertStartX = i; } (void) insertCharCount++; } if (((tpd->cursorColumn + insertCharCount) >= tw->term.columns) || ((tpd->cursorColumn + insertCharCount) == tpd->rightMargin + 1)) { if (tpd->autoWrapRight) { /* perform an auto wrap... */ /* we need to insert any pending characters, and * render them... */ if (insertCharCount) { newWidth = DoInsert(w, &buffer[insertStartX], insertCharCount, &wrapped); tpd->cursorColumn += insertCharCount; insertCharCount = 0; if (tpd->insertCharMode != DtTERM_INSERT_CHAR_OFF) { renderEndX = newWidth; } else { renderEndX = MAX(renderEndX, tpd->cursorColumn); } needToRender = True; } if (needToRender) { DebugF('t', 0, fprintf(stderr, ">>termInsertText() calling[2] _DtTermPrimRefreshText()\n")); (void) _DtTermPrimRefreshText(w, renderStartX, tpd->cursorRow, wrapped ? tw->term.columns : MAX(renderEndX, 0), tpd->cursorRow); if (wrapped && (tpd->cursorRow + 1 < tw->term.rows)) { (void) _DtTermPrimRefreshText(w, 0, tpd->cursorRow + 1, renderEndX, tpd->cursorRow + 1); } wrapped = False; needToRender = False; } tpd->cursorColumn = tpd->leftMargin; tpd->wrapState = WRAPbetweenMargins; renderEndX = 0; _DtTermPrimBufferSetLineWrapFlag(tBuffer, tpd->topRow + tpd->cursorRow, True); if (tpd->cursorRow == tpd->scrollLockBottomRow) { /* scroll at the bottom of the lock area... */ (void) _DtTermPrimScrollText(w, 1); (void) _DtTermPrimFillScreenGap(w); } else if (++tpd->cursorRow >= tw->term.rows) { /* we are at the bottom row of the locked region. * Wrap to the beginning of this line... */ tpd->cursorRow = tw->term.rows - 1; } else { /* we are not at the bottom row. We already have * wrapped down one line... */ } renderStartX = tpd->cursorColumn; if (tpd->scroll.nojump.pendingScroll) { /* If we wrapped the screen, bail out now and we * will take care of this character when we * finish the scroll. If we are in wrap after, * then we need to skip past this character so * that it doesn't get processed twice... */ if (tpd->wrapRightAfterInsert) (void) i++; break; } } else { /* overwrite the last character(s) on the line... */ if (insertCharCount > 0) { newWidth = DoInsert(w, &buffer[insertStartX], insertCharCount, &wrapped); tpd->cursorColumn += insertCharCount; insertCharCount = 0; if (tpd->insertCharMode != DtTERM_INSERT_CHAR_OFF) { renderEndX = newWidth; } else { renderEndX = MAX(renderEndX, tpd->cursorColumn); } needToRender = True; } if (tpd->cursorColumn == tpd->rightMargin + 1) tpd->cursorColumn = tpd->rightMargin; else tpd->cursorColumn = tw->term.columns - 1; } } /* for emulations that wrap before inserting the character, we * will insert the character and then check for wrap... */ if (!tpd->wrapRightAfterInsert) { /* before we insert any text, we need to insure that the * cursor is on a valid buffer row... */ if (insertCharCount == 0) { insertStartX = i; } (void) insertCharCount++; } } /* insert and render any remaining text... */ if (insertCharCount > 0) { newWidth = DoInsert(w, &buffer[insertStartX], insertCharCount, &wrapped); tpd->cursorColumn += insertCharCount; if (tpd->insertCharMode != DtTERM_INSERT_CHAR_OFF) { renderEndX = newWidth; } else { renderEndX = MAX(renderEndX, tpd->cursorColumn); } needToRender = True; } if (needToRender) { renderEndX = MAX(renderEndX, tpd->cursorColumn); DebugF('t', 0, fprintf(stderr, ">>termInsertText() calling _DtTermPrimRefreshText()\n")); (void) _DtTermPrimRefreshText(w, renderStartX, tpd->cursorRow, wrapped ? tw->term.columns : MAX(renderEndX, 0), tpd->cursorRow); if (wrapped && (tpd->cursorRow + 1 < tw->term.rows)) { (void) _DtTermPrimRefreshText(w, 0, tpd->cursorRow + 1, renderEndX, tpd->cursorRow + 1); } } return(i); } static void buildDangleBuffer ( unsigned char *buffer, int bufferLen, unsigned char *mbPartialChar, int *mbPartialCharLen, int writeLen, unsigned char **dangleBuffer, int *dangleBufferLen ) { /* malloc our dangle buffer... */ *dangleBufferLen = bufferLen + *mbPartialCharLen - writeLen; *dangleBuffer = (unsigned char *) XtMalloc(*dangleBufferLen); /* copy over the unwritten part of the original buffer... */ (void) memmove(*dangleBuffer, buffer + writeLen, bufferLen - writeLen); if (*mbPartialCharLen) { (void) memmove(*dangleBuffer + bufferLen - writeLen, mbPartialChar, *mbPartialCharLen); *mbPartialCharLen = 0; } return; } Boolean _DtTermPrimParseInput ( Widget w, unsigned char *buffer, int len, unsigned char **dangleBuffer, int *dangleBufferLen ) { DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w; struct termData *tpd = tw->term.tpd; DtTermPrimitiveClassPart *termClassPart = &(((DtTermPrimitiveClassRec *) (tw->core.widget_class))->term_primitive_class); int i; short insertStart; short insertByteCount; short returnLen; Boolean turnCursorOn = False; unsigned char *tmpBuffer = (unsigned char *) 0; unsigned char mbChar[MB_LEN_MAX]; int mbCharLen = 1; static Boolean *preParseTable = (Boolean *) 0; *dangleBuffer = (unsigned char *) 0; insertStart = 0; insertByteCount = 0; /* initialize the preParseTable if necessary... */ _DtTermProcessLock(); if (!preParseTable) { preParseTable = (Boolean *) XtMalloc(256 * sizeof(Boolean)); (void) memset(preParseTable, '\0', 256 * sizeof(Boolean)); for (i = 0x00; i <= 0x1f; i++) { preParseTable[i] = True; } for (i = 0x80; i <= 0x9f; i++) { preParseTable[i] = True; } } _DtTermProcessUnlock(); /* check for partial multibyte character... */ if (tpd->mbPartialCharLen > 0) { tmpBuffer = (unsigned char *) XtMalloc(len + tpd->mbPartialCharLen); (void) memcpy(tmpBuffer, tpd->mbPartialChar, tpd->mbPartialCharLen); (void) memcpy(tmpBuffer + tpd->mbPartialCharLen, buffer, len); buffer = tmpBuffer; len += tpd->mbPartialCharLen; tpd->mbPartialCharLen = 0; } /* turn off the cursor... */ if (CURSORoff != tpd->cursorState) { (void) _DtTermPrimCursorOff(w); turnCursorOn = True; } for (i = 0; (i < len) && tpd->ptyInputId; ) { if (tpd->mbCurMax > 1) { switch (mbCharLen = mblen((char *) &buffer[i], MIN(((int)MB_CUR_MAX), len - i))) { case -1: if ((int)MB_CUR_MAX <= len - i) { /* we have a bogus multi-byte character. Throw away * the first byte and rescan (TM 12/14/93)... */ /* dump what we know we want to insert... */ if (insertByteCount > 0) { returnLen = (*(termClassPart->term_insert_proc))(w, &buffer[insertStart], insertByteCount); if (returnLen != insertByteCount) { (void) buildDangleBuffer(buffer, len, tpd->mbPartialChar, &tpd->mbPartialCharLen, insertStart + returnLen, dangleBuffer, dangleBufferLen); insertByteCount = 0; break; } insertByteCount = 0; } /* skip over the bogus char's first byte... */ (void) i++; insertStart = i; continue; } else { /* we have a dangling partial multi-byte character... */ (void) memmove(tpd->mbPartialChar, &buffer[i], len - i); tpd->mbPartialCharLen = len - i; /* remove the partial char from the buffer and adjust * the buffer len... */ len = i; continue; } break; case 0: mbCharLen = 1; /* fall through */ default: break; } } if (((mbCharLen == 1) && preParseTable[buffer[i]]) || tpd->parserNotInStartState) { /* ** It's either a control code or we are not in the start state. ** If we have any text to insert, insert ** the text, display any added text, then send it down through ** the parser. */ if (insertByteCount > 0) { returnLen = (*(termClassPart->term_insert_proc))(w, &buffer[insertStart], insertByteCount); if (returnLen != insertByteCount) { (void) buildDangleBuffer(buffer, len, tpd->mbPartialChar, &tpd->mbPartialCharLen, insertStart + returnLen, dangleBuffer, dangleBufferLen); insertByteCount = 0; break; } insertByteCount = 0; } tpd->parserNotInStartState = _DtTermPrimParse(w, &buffer[i], mbCharLen); i += mbCharLen; insertStart = i; } else { /* queue up text to insert into the buffer... */ insertByteCount += mbCharLen; i += mbCharLen; } } if (insertByteCount > 0) { returnLen = (*(termClassPart->term_insert_proc))(w, &buffer[insertStart], insertByteCount); if (returnLen != insertByteCount) { (void) buildDangleBuffer(buffer, len, tpd->mbPartialChar, &tpd->mbPartialCharLen, insertStart + returnLen, dangleBuffer, dangleBufferLen); } } else { /* ** insertByteCount <= 0, check to make sure we haven't ** already saved any remaining text in the dangleBuffer... */ if (i < len && !*dangleBuffer) { (void) buildDangleBuffer(buffer, len, tpd->mbPartialChar, &tpd->mbPartialCharLen, i, dangleBuffer, dangleBufferLen); } } /* if we turned the cursor off, turn the cursor back on... */ if (turnCursorOn) { (void) _DtTermPrimCursorOn(w); } if (tmpBuffer) { (void) XtFree((char *) tmpBuffer); } if (*dangleBuffer) { return(False); } return(True); } /* ** Pad the current line from the current end of line up to (and ** including) the current cursor column. */ void _DtTermPrimRenderPadLine ( Widget w ) { DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w; struct termData *tpd = tw->term.tpd; TermBuffer tBuffer = tpd->termBuffer; short currentWidth; /* before we pad this line, we need to insure that cursor is on a * valid buffer row... */ (void) _DtTermPrimFillScreenGap(w); currentWidth = _DtTermPrimBufferGetLineWidth(tBuffer, tpd->topRow + tpd->cursorRow); if (tpd->cursorColumn >= currentWidth) { /* ** Pad the line and refresh it. */ if (tpd->mbCurMax > 1) { _DtTermPrimBufferPadLineWc(tBuffer, tpd->topRow + tpd->cursorRow, tpd->cursorColumn + 1); } else { _DtTermPrimBufferPadLine(tBuffer, tpd->topRow + tpd->cursorRow, tpd->cursorColumn + 1); } _DtTermPrimRefreshText(w, currentWidth, tpd->cursorRow, tpd->cursorColumn, tpd->cursorRow); } } void _DtTermPrimDestroyFont( Widget w, TermFont font ) { if (font) (void) (*(font->destroyFunction))(w, font); return; } void _DtTermPrimRenderText( Widget w, TermFont font, Pixel fg, Pixel bg, unsigned long flags, int x, int y, unsigned char *string, int len ) { (void) (*(font->renderFunction))(w, font, fg, bg, flags, x, y, string, len); return; }