开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
ansiterm.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：32k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

ansiterm.cxx：源码内容
  1. /*
  2.  * ansiterm.cxx
  3.  *
  4.  * ANSI terminal emulation class.
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: ansiterm.cxx,v $
  30.  * Revision 1.40  1998/12/20 09:14:37  robertj
  31.  * Added pragma implementation for GNU compiler.
  32.  *
  33.  * Revision 1.39  1998/12/12 00:44:13  robertj
  34.  * Added capability to get text lines out of scroll back buffer.
  35.  *
  36.  * Revision 1.38  1998/11/30 04:52:12  robertj
  37.  * New directory structure
  38.  *
  39.  * Revision 1.37  1998/10/16 11:08:14  robertj
  40.  * GNU compatibility.
  41.  *
  42.  * Revision 1.36  1998/09/23 06:29:33  robertj
  43.  * Added open source copyright license.
  44.  *
  45.  * Revision 1.35  1998/09/18 13:09:33  robertj
  46.  * Fixed clearing of very bottom of window.
  47.  *
  48.  * Revision 1.34  1998/09/17 04:24:45  robertj
  49.  * Fixed update problems requiring screen refresh to see output text.
  50.  *
  51.  * Revision 1.33  1998/09/04 06:57:02  robertj
  52.  * Fixed crash if window was realy, really wide.
  53.  *
  54.  * Revision 1.32  1997/04/27 05:50:20  robertj
  55.  * DLL support.
  56.  *
  57.  * Revision 1.31  1996/12/21 07:01:35  robertj
  58.  * Fixed flush on close problem in ANSI terminal stream.
  59.  *
  60.  * Revision 1.30  1996/06/03 10:07:31  robertj
  61.  * Fixed bug in auto scroll to cursor position on output.
  62.  * Fixed bug in DEL character processing (no screen update).
  63.  *
  64.  * Revision 1.29  1996/05/15 10:14:40  robertj
  65.  * Rewrite of terminal to make descendant only require single character output function.
  66.  *
  67.  * Revision 1.28  1996/04/30 12:33:45  robertj
  68.  * Changed "inPixels" boolean to enum for three coordinate systems.
  69.  *
  70.  * Revision 1.27  1996/04/29 12:18:24  robertj
  71.  * Added local echo capability to terminal.
  72.  *
  73.  * Revision 1.26  1995/12/10 11:36:16  robertj
  74.  * Fixed bug in display of window bigger than virtual screen.
  75.  * Fixed warning in GNU compiler.
  76.  *
  77.  * Revision 1.25  1995/11/20 11:04:09  robertj
  78.  * Fixed bugs in non-adjustable rows and columns mode.
  79.  * Implemented horizontal scrolling.
  80.  *
  81.  * Revision 1.24  1995/11/09 12:19:50  robertj
  82.  * Removed GNU warning.
  83.  *
  84.  * Revision 1.23  1995/08/24 12:35:51  robertj
  85.  * Implemented copy/paste.
  86.  *
  87.  * Revision 1.22  1995/07/31 12:15:47  robertj
  88.  * Removed PContainer from PChannel ancestor.
  89.  *
  90.  * Revision 1.21  1995/07/02 01:20:58  robertj
  91.  * Removed OnDoubleClick() and added BOOL to OnMouseDown() for double click.
  92.  *
  93.  * Revision 1.20  1995/06/17 11:11:09  robertj
  94.  * Changed OnKeyDown to return BOOL indicating OnKeyInput is to be used.
  95.  *
  96.  * Revision 1.19  1995/06/04 08:41:42  robertj
  97.  * Some minor speedups.
  98.  *
  99.  * Revision 1.18  1995/04/25 11:28:06  robertj
  100.  * Fixed Borland compiler warnings.
  101.  *
  102.  * Revision 1.17  1995/04/01 08:30:08  robertj
  103.  * Changed default end of line wrap option.
  104.  * Fixed loss of focus problem.
  105.  *
  106.  * Revision 1.16  1995/01/07 04:39:44  robertj
  107.  * Redesigned font enumeration code and changed font styles.
  108.  *
  109.  * Revision 1.15  1995/01/06  10:43:53  robertj
  110.  * Changed PRealFont usage from pointer to reference.
  111.  *
  112.  * Revision 1.14  1994/12/05  11:20:22  robertj
  113.  * Removed Normalise() function from PRect as all rectangles should be inherently normal.
  114.  *
  115.  * Revision 1.13  1994/11/28  12:35:42  robertj
  116.  * Fixed closure of channel not clearing the keyboard stream.
  117.  * Moved saved cursor position variables to PAnsiTerminal.
  118.  *
  119.  * Revision 1.12  1994/10/30  11:52:02  robertj
  120.  * Fixed bug in auto scrolling vertical scroll bar position.
  121.  *
  122.  * Revision 1.11  1994/10/23  03:40:23  robertj
  123.  * Fixed scrolling wrong direction.
  124.  * Added ReturnOnLineFeed option.
  125.  * Added capability of setting cursor type.
  126.  * Improved the channel.
  127.  *
  128.  * Revision 1.10  1994/09/25  10:48:32  robertj
  129.  * Added boundary condition tests.
  130.  *
  131.  * Revision 1.9  1994/08/21  23:43:02  robertj
  132.  * Bug fixes.
  133.  *
  134.  * Revision 1.8  1994/08/01  03:41:24  robertj
  135.  * Use of PNEW instead of new for heap debugging. Need undef for Unix end.
  136.  *
  137.  * Revision 1.7  1994/07/27  05:58:07  robertj
  138.  * Synchronisation.
  139.  *
  140.  * Revision 1.6  1994/07/25  03:38:07  robertj
  141.  * Changed variables to int for better portability.
  142.  *
  143.  * Revision 1.5  1994/07/21  12:33:49  robertj
  144.  * Moved cooperative threads to common.
  145.  *
  146.  * Revision 1.4  1994/07/17  10:46:06  robertj
  147.  * Major redesign to get list instead of array for line data.
  148.  *
  149.  * Revision 1.3  1994/06/25  11:55:15  robertj
  150.  * Unix version synchronisation.
  151.  *
  152.  * Revision 1.2  1994/04/20  12:17:44  robertj
  153.  * some implementation
  154.  *
  155.  * Revision 1.1  1994/04/01  14:27:01  robertj
  156.  * Initial revision
  157.  */
  159. #ifdef __GNUC__
  160. #pragma implementation "ansiterm.h"
  161. #endif
  163. #include <pwlib.h>
  164. #include <pwclib/ansiterm.h>
  165. #include <limits.h>
  167. #define new PNEW
  170. PTerminal::PTerminal(PScroller * parent, ostream * kbd)
  171.   : PScrollable(parent)
  172. {
  173.   keyboard = kbd;
  174.   PScrollable::SetFont(PFont("Courier", 10));
  175.   SetCursor(PCursor(PSTD_ID_CURSOR_IBEAM));
  176.   variableRowColumns = TRUE;
  177.   blockCursor = TRUE;
  178.   lineFeedOnReturn = FALSE;
  179.   returnOnLineFeed = FALSE;
  180.   localEcho = FALSE;
  181.   wrapEOL = FALSE;
  182.   columns = 80;
  183.   rows = 25;
  184.   maxSavedRows = 0;
  185.   columnModeSelection = FALSE;
  186.   updateColumn = 0;
  187.   Reset();
  188.   GrabFocus();
  189.   ShowCaret();
  190. }
  193. PTerminal::Row::Row(Attribute attribute)
  194. {
  195.   for (PINDEX i = 0; i < MaxColumns; i++)
  196.     attrib[i] = attribute;
  197.   memset(ascii, ' ', sizeof(ascii));
  198. }
  201. void PTerminal::Reset()
  202. {
  203.   cellWidth = font.GetAvgWidth(TRUE);
  204.   cellHeight = font.GetHeight(TRUE);
  205.   SetScaleFactor(cellWidth, cellHeight);
  207.   cursorRow = cursorColumn = 0;
  208.   caret.SetDimensions(blockCursor ? cellWidth : 1, cellHeight);
  209.   SetCaretPos(0, 0, PixelCoords);
  211.   PDim dim = GetDimensions(PixelCoords);
  212.   columnsVisible = dim.Width()/cellWidth;
  213.   if (columnsVisible > Row::MaxColumns)
  214.     columnsVisible = Row::MaxColumns;
  215.   rowsVisible = dim.Height()/cellHeight;
  217.   if (variableRowColumns) {
  218.     columns = columnsVisible > 1 ? columnsVisible : 2;
  219.     rows = rowsVisible > 1 ? rowsVisible : 2;
  220.   }
  222.   scrollTop = 0;
  223.   scrollBottom = rows;
  225.   attribute.bold = FALSE;
  226.   attribute.underline = FALSE;
  227.   attribute.blink = FALSE;
  228.   attribute.inverse = FALSE;
  229.   attribute.selected = FALSE;
  230.   attribute.fgColor = 8; // Window fg colour
  231.   attribute.bkColor = 9; // Window bk colour
  233.   rowData.RemoveAll();
  234.   for (PINDEX i = 0; i < rows; i++)
  235.     rowData.Append(new Row(attribute));
  237.   SetScrollRange(PRect(0, 0, columns, rows));
  239.   anchor = selection = 0;
  241.   Invalidate();
  242. }
  245. void PTerminal::SetFont(const PFont & newFont, BOOL toChildren)
  246. {
  247.   PScrollable::SetFont(newFont, toChildren);
  249.   cellWidth = font.GetAvgWidth(TRUE);
  250.   cellHeight = font.GetHeight(TRUE);
  251.   SetScaleFactor(cellWidth, cellHeight);
  253.   caret.SetDimensions(blockCursor ? cellWidth : 1, cellHeight);
  255.   SetDimensions(GetDimensions(PixelCoords), PixelCoords);
  256.   Invalidate();
  257. }
  260. void PTerminal::_SetDimensions(PDIMENSION width, PDIMENSION height,
  261.                                CoordinateSystem coords)
  262. {
  263.   PScrollable::_SetDimensions(width, height, coords);
  265.   PDim dim = GetDimensions(PixelCoords);
  266.   columnsVisible = dim.Width()/cellWidth;
  267.   if (columnsVisible > Row::MaxColumns)
  268.     columnsVisible = Row::MaxColumns;
  269.   rowsVisible = dim.Height()/cellHeight;
  271.   if (variableRowColumns) {
  272.     variableRowColumns = FALSE;
  273.     SetColumns(columnsVisible);
  274.     SetRows(rowsVisible);
  275.     variableRowColumns = TRUE;
  276.   }
  277.   else
  278.     SetScrollRange(PRect(0, 0, columns, rowData.GetSize()));
  279. }
  282. void PTerminal::Row::AdjustSelection(PINDEX start, PINDEX finish, BOOL select)
  283. {
  284.   for (PINDEX col = start; col < finish; col++)
  285.     attrib[col].selected = select;
  286. }
  289. void PTerminal::AdjustSelection(PCanvas & canvas,
  290.                                       PINDEX start, PINDEX finish, BOOL select)
  291. {
  292.   if (start == finish)
  293.     return;
  295.   if (start > finish) {
  296.     PINDEX tmp = start;
  297.     start = finish;
  298.     finish = tmp;
  299.   }
  301.   PINDEX firstRow = start/Row::MaxColumns;
  302.   PINDEX lastRow = finish/Row::MaxColumns;
  303.   PINDEX firstCol = start%Row::MaxColumns;
  304.   PINDEX lastCol = finish%Row::MaxColumns;
  306.   if (columnModeSelection) {
  307.     if (firstCol > lastCol) {
  308.       PINDEX tmp = lastCol;
  309.       lastCol = firstCol;
  310.       firstCol = tmp;
  311.     }
  312.     for (PINDEX row = firstRow; row <= lastRow; row++) {
  313.       rowData[row].AdjustSelection(0, Row::MaxColumns, FALSE);
  314.       if (select)
  315.         rowData[row].AdjustSelection(firstCol, lastCol, select);
  316.       rowData[row].Draw(this, canvas, row - origin.Y(), 0);
  317.     }
  318.   }
  319.   else {
  320.     for (PINDEX row = firstRow; row <= lastRow; row++) {
  321.       rowData[row].AdjustSelection(firstCol,
  322.                        row < lastRow ? (int)Row::MaxColumns : lastCol, select);
  323.       rowData[row].Draw(this, canvas, row - origin.Y(), 0);
  324.       firstCol = 0;
  325.     }
  326.   }
  327. }
  330. void PTerminal::OnMouseTrack(PCanvas * canvas,
  331.                                           const PPoint & where, BOOL lastTrack)
  332. {
  333.   PINDEX pos = origin.Y()*Row::MaxColumns + origin.X();
  334.   if (where.Y() > 0)
  335.     pos += (where.Y()/cellHeight)*Row::MaxColumns;
  336.   if (where.X() > 0)
  337.     pos += (where.X() + cellWidth/2)/cellWidth;
  338.   if (pos >= rowData.GetSize()*Row::MaxColumns)
  339.     pos = rowData.GetSize()*Row::MaxColumns - 1;
  341.   if (pos == selection)
  342.     return;
  344.   if ((pos >= anchor && selection < anchor) ||
  345.       (pos <= anchor && selection > anchor)) {
  346.     AdjustSelection(*canvas, anchor, selection, FALSE);
  347.     selection = anchor;
  348.   }
  350.   if (columnModeSelection) {
  351.     if ((pos > anchor && pos < selection) ||
  352.         (pos < anchor && pos > selection))
  353.       AdjustSelection(*canvas, selection, pos, FALSE);
  354.     AdjustSelection(*canvas, anchor, pos, TRUE);
  355.   }
  356.   else
  357.     AdjustSelection(*canvas, pos, selection,
  358.        (pos > anchor && pos > selection) || (pos < anchor && pos < selection));
  360.   selection = pos;
  362.   if (lastTrack)
  363.     UpdateCommandSources();
  364. }
  367. void PTerminal::OnMouseDown(PKeyCode button, const PPoint & where, BOOL)
  368. {
  369.   GrabFocus();
  371.   PCanvas * canvas = StartMouseTrack(TRUE);
  373.   PINDEX pos = (origin.Y() + where.Y()/cellHeight)*Row::MaxColumns +
  374.                                 origin.X() + (where.X()+cellWidth/2)/cellWidth;
  375.   if (pos >= rowData.GetSize()*Row::MaxColumns)
  376.     pos = rowData.GetSize()*Row::MaxColumns - 1;
  378.   if (HasSelection() && button.IsModifier(PKeyCode::Shift)) {
  379.     if ((anchor > selection && pos > anchor) ||
  380.         (anchor < selection && pos < anchor)) {
  381.       PINDEX tmp = anchor;
  382.       anchor = selection;
  383.       selection = tmp;
  384.     }
  385.     OnMouseTrack(canvas, where, FALSE);
  386.   }
  387.   else {
  388.     AdjustSelection(*canvas, anchor, selection, FALSE);
  389.     anchor = selection = pos;
  390.     columnModeSelection = button.IsModifier(PKeyCode::Control);
  391.   }
  392. }
  395. void PTerminal::OnKeyInput(const PString & str)
  396. {
  397.   if (keyboard != NULL) {
  398.     *keyboard << str;
  399.     keyboard->flush();
  400.     if (localEcho)
  401.       Write(str);
  402.   }
  403. }
  406. void PTerminal::Row::Draw(PTerminal * term,
  407.                                  PCanvas & canvas, PINDEX line, PINDEX lastCol)
  408. {
  409.   static PColour colour[10] = {
  410.     PColour::Black,
  411.     PColour::Red,
  412.     PColour::Yellow,
  413.     PColour::Green,
  414.     PColour::Blue,
  415.     PColour::Magenta,
  416.     PColour::Cyan,
  417.     PColour::White,
  418.     PApplication::Current().GetWindowFgColour(),
  419.     PApplication::Current().GetWindowBkColour()
  420.   };
  421.   PDIMENSION origins[MaxColumns];
  423.   for (int i = 0; i < MaxColumns; i++)
  424.     origins[i] = term->cellWidth;
  426.   WORD lastAttr = *(WORD *)&attrib[0];
  427.   PINDEX col = lastCol;
  428.   while (lastCol < term->columnsVisible) {
  429.     col++;
  430.     if (lastAttr != *(WORD *)&attrib[col] || col >= term->columnsVisible) {
  431.       if (col > lastCol) {
  432.         Attribute attr = attrib[lastCol];
  433.         if (attr.inverse ^ attr.selected) {
  434.           canvas.SetTextFgColour(colour[attr.bkColor]);
  435.           canvas.SetTextBkColour(colour[attr.fgColor]);
  436.         }
  437.         else {
  438.           canvas.SetTextFgColour(colour[attr.fgColor]);
  439.           canvas.SetTextBkColour(colour[attr.bkColor]);
  440.         }
  441.         WORD styles = PFont::Regular;
  442.         if (attr.bold)
  443.           styles |= PFont::Bold;
  444.         if (attr.underline)
  445.           styles |= PFont::Underline;
  446.         PFont newFont(term->font.GetFacename(), term->font.GetSize(), styles);
  447.         canvas.SetFont(newFont);
  448.         canvas.DrawTextLine(lastCol*term->cellWidth,
  449.               line*term->cellHeight, &ascii[lastCol], origins, col - lastCol);
  450.       }
  451.       lastAttr = *(WORD *)&attrib[col];
  452.       lastCol = col;
  453.     }
  454.   }
  455. }
  458. void PTerminal::OnRedraw(PCanvas & canvas)
  459. {
  460.   HideCaret();
  462.   canvas.SetMappingRect(canvas.GetViewportRect());
  463.   canvas.SetOrigin(PPoint(origin.X()*scaleFactor.X(), 0));
  465.   PINDEX lastRow = PMIN(rowData.GetSize(), rowsVisible);
  466.   PINDEX bottom = origin.Y() + lastRow;
  468.   canvas.SetPenFgColour(GetBackgroundColour());
  469.   canvas.DrawRect(0, lastRow*cellHeight, 30000, 30000);
  471.   for (PINDEX line = 1; line <= lastRow; line++)
  472.     rowData[bottom - line].Draw(this, canvas, lastRow - line, 0);
  474.   ShowCaret();
  475. }
  478. PString PTerminal::GetRow(PINDEX idx) const
  479. {
  480.   if (idx >= GetTotalRows())
  481.     return PString();
  483.   return rowData[idx].GetText();
  484. }
  487. BOOL PTerminal::HasSelection() const
  488. {
  489.   return anchor != selection;
  490. }
  493. PString PTerminal::Row::GetText() const
  494. {
  495.   PINDEX len = sizeof(ascii)-1;
  496.   while (len > 0 && ascii[len] == ' ')
  497.     len--;
  499.   return PString(ascii, len);
  500. }
  503. PString PTerminal::Row::GetSelection() const
  504. {
  505.   PINDEX firstCol = 0;
  506.   while (firstCol < MaxColumns && !attrib[firstCol].selected)
  507.     firstCol++;
  509.   PINDEX lastCol = MaxColumns - 1;
  510.   while (lastCol > firstCol && (!attrib[lastCol].selected || ascii[lastCol] == ' '))
  511.     lastCol--;
  513.   if (lastCol >= firstCol)
  514.     return PString(&ascii[firstCol], lastCol - firstCol + 1);
  515.   else
  516.     return PString();
  517. }
  520. PString PTerminal::GetSelection() const
  521. {
  522.   PString str;
  524.   if (HasSelection()) {
  525.     PINDEX row = PMIN(anchor, selection)/Row::MaxColumns;
  526.     PINDEX finish = PMAX(anchor, selection)/Row::MaxColumns;
  527.     while (row <= finish)
  528.       str += rowData[row++].GetSelection() + "rn";
  529.   }
  531.   return str;
  532. }
  535. void PTerminal::SetSelection(PINDEX startRow, PINDEX startColumn,
  536.                              PINDEX finishRow, PINDEX finishColumn)
  537. {
  538.   anchor = startRow*Row::MaxColumns + startColumn;
  539.   selection = finishRow*Row::MaxColumns + finishColumn;
  540.   Invalidate();
  541. }
  544. void PTerminal::SetKeyboardStream(ostream * kbd)
  545. {
  546.   keyboard = kbd;
  547. }
  550. void PTerminal::SetMaxSavedRows(PINDEX newRows)
  551. {
  552.   maxSavedRows = newRows;
  553.   if (maxSavedRows != 0 && rowData.GetSize() > maxSavedRows+rows)
  554.     rowData.SetSize(maxSavedRows+rows);
  555. }
  558. void PTerminal::SetVariableRowColumns(BOOL b)
  559. {
  560.   variableRowColumns = b;
  561.   if (variableRowColumns)
  562.     SetDimensions(GetDimensions(PixelCoords), PixelCoords);
  563.   else {
  564.     SetRows(rowsVisible > 0 ? rowsVisible : 25);
  565.     SetColumns(columnsVisible > 1 ? columnsVisible : (int)Row::MaxColumns);
  566.   }
  567. }
  570. void PTerminal::SetRows(PINDEX newRows)
  571. {
  572.   if (variableRowColumns) {
  573.     SetDimensions(GetDimensions(PixelCoords), PixelCoords);
  574.     return;
  575.   }
  577.   if (newRows < 2)
  578.     newRows = 2;
  580.   if (scrollTop >= newRows)
  581.     scrollTop = newRows - 1;
  582.   if (scrollBottom == rows || scrollBottom > newRows)
  583.     scrollBottom = newRows;
  585.   if (newRows <= rows)
  586.     AdjustCaretPosition((int)newRows - (int)rows, 0);
  587.   else {
  588.     for (PINDEX i = rows; i < newRows; i++)
  589.       rowData.Append(new Row(attribute));
  590.     SetScrollRange(PRect(0, 0, columns, rowData.GetSize()));
  591.   }
  593.   rows = newRows;
  594. }
  597. void PTerminal::SetColumns(PINDEX newColumns)
  598. {
  599.   if (variableRowColumns) {
  600.     SetDimensions(GetDimensions(PixelCoords), PixelCoords);
  601.     return;
  602.   }
  604.   if (newColumns < 2)
  605.     newColumns = 2;
  606.   else if (newColumns > Row::MaxColumns)
  607.     newColumns = Row::MaxColumns;
  609.   if (columns != newColumns)
  610.     SetScrollRange(PRect(0, 0, columns, rowData.GetSize()));
  611.   columns = newColumns;
  612. }
  615. void PTerminal::AdjustCaretPosition(int dLine, int dCol)
  616. {
  617.   cursorColumn += dCol;
  618.   if ((int)cursorColumn < 0)
  619.     cursorColumn = 0;
  620.   else if (cursorColumn >= columns)
  621.     cursorColumn = columns-1;
  623.   cursorRow += dLine;
  624.   if ((int)cursorRow < (int)scrollTop)   // Need signed compare here
  625.     cursorRow = scrollTop;
  626.   else if (cursorRow >= scrollBottom)
  627.     cursorRow = scrollBottom-1;
  629.   SetCaretPos(cursorColumn*cellWidth,
  630.               blockCursor ? cursorRow*cellHeight : (cursorRow+1)*cellHeight-1,
  631.               PixelCoords);
  632. }
  635. void PTerminal::MoveCaretPosition(PDrawCanvas & canvas, int dLine, int dCol)
  636. {
  637.   PINDEX absRow = rowData.GetSize() - rows + cursorRow;
  639.   rowData[absRow].Draw(this, canvas, absRow - origin.Y(), updateColumn);
  640.   AdjustCaretPosition(dLine, dCol);
  641.   updateColumn = cursorColumn;
  643.   if (absRow < (PINDEX)origin.Y() ||
  644.       absRow >= (PINDEX)origin.Y()+rowsVisible ||
  645.       cursorColumn < (PINDEX)origin.X() ||
  646.       cursorColumn >= (PINDEX)origin.X()+columnsVisible)
  647.     ScrollTo(cursorColumn-columnsVisible, cursorRow);
  648. }
  651. void PTerminal::SetBlockCursor(BOOL b)
  652. {
  653.   blockCursor = b;
  654.   caret.SetDimensions(blockCursor ? cellWidth : 1, cellHeight);
  655. }
  658. PTerminal::Row & PTerminal::GetCursorRow()
  659. {
  660.   return rowData[rowData.GetSize() - rows + cursorRow];
  661. }
  664. void PTerminal::ScrollLines(PDrawCanvas & canvas,
  665.                                           PINDEX top, PINDEX bottom, int lines)
  666. {
  667.   PAssert(lines != 0 && bottom > top, PInvalidParameter);
  669.   HideCaret();
  670.   Update();           // Make sure interactor is up to date (fully redrawn)
  671.   MoveCaretPosition(canvas, 0, 0);
  673.   PINDEX totalRows = rowData.GetSize();
  674.   int topRow = totalRows - rows + top;
  675.   int bottomRow = totalRows - rows + bottom;
  676.   int absLines = PABS(lines);
  677.   if (absLines > (int)(bottom - top))
  678.     absLines = bottom - top;
  680.   if (lines > 0 && top == 0) {
  681.     while (absLines-- > 0)
  682.       rowData.InsertAt(bottomRow, new Row(attribute));
  683.     if (maxSavedRows != 0 && rowData.GetSize() > maxSavedRows+rows)
  684.       rowData.SetSize(maxSavedRows+rows);
  685.     if (rowData.GetSize() != totalRows) {
  686.       SetScrollRange(PRect(0, 0, columns, rowData.GetSize()));
  687.       ScrollTo(0, rowData.GetSize());
  688.     }
  689.   }
  690.   else {
  691.     PRect scrollRect(0, top*cellHeight, 30000, (bottom - top)*cellHeight);
  692.     PDIMENSION scrollAmount = absLines*cellHeight;
  693.     BOOL doScroll = scrollAmount < scrollRect.Height();
  694.     if (lines > 0) {
  695.       while (absLines-- > 0) {
  696.         rowData.InsertAt(bottomRow, new Row(attribute));
  697.         rowData.RemoveAt(topRow);
  698.       }
  699.       if (doScroll) {
  700.         PDrawCanvas canvas(this, TRUE);
  701.         canvas.Scroll(0, -(PORDINATE)scrollAmount, scrollRect);
  702.         scrollRect.SetTop(scrollRect.Bottom() - scrollAmount);
  703.       }
  704.     }
  705.     else {
  706.       while (absLines-- > 0) {
  707.         rowData.RemoveAt(bottomRow-1);
  708.         rowData.InsertAt(topRow, new Row(attribute));
  709.       }
  710.       if (doScroll) {
  711.         PDrawCanvas canvas(this, TRUE);
  712.         canvas.Scroll(0, scrollAmount, scrollRect);
  713.         scrollRect.SetHeight(scrollAmount);
  714.       }
  715.     }
  716.     Invalidate(scrollRect, PixelCoords);
  717.   }
  719.   ShowCaret();
  720. }
  723. void PTerminal::Row::Scroll(PTerminal * term, PCanvas & canvas,
  724.                            PINDEX line, PINDEX left, PINDEX right, int columns)
  725. {
  726.   PAssert(columns != 0 && right > left, PInvalidParameter);
  728.   if (right >= MaxColumns)
  729.     right = MaxColumns-1;
  731.   PINDEX absCols = PABS(columns);
  732.   if (absCols > right - left)
  733.     absCols = right - left;
  735.   if (columns < 0) {
  736.     memmove(&attrib[left+absCols], &attrib[left], (right-left-absCols)*sizeof(attrib[0]));
  737.     for (PINDEX i = 0; i < absCols; i++)
  738.       attrib[left+i] = term->attribute;
  739.     memmove(&ascii[left+absCols], &ascii[left], (right-left-absCols)*sizeof(ascii[0]));
  740.     memset(&ascii[left], ' ', absCols*sizeof(ascii[0]));
  741.   }
  742.   else {
  743.     memmove(&attrib[left], &attrib[left+absCols], (right-left-absCols)*sizeof(attrib[0]));
  744.     for (PINDEX i = 0; i < absCols; i++)
  745.       attrib[right-absCols+i] = term->attribute;
  746.     memmove(&ascii[left], &ascii[left+absCols], (right-left-absCols)*sizeof(ascii[0]));
  747.     memset(&ascii[right-absCols], ' ', absCols*sizeof(ascii[0]));
  748.   }
  750.   Draw(term, canvas, line, left);
  751. }
  754. void PTerminal::Write(const char * buf, PINDEX len)
  755. {
  756.   if (len <= 0 || (len == 1 && *buf == ''))
  757.     return;
  759.   PDrawCanvas updateCanvas(this, TRUE);
  760.   updateCanvas.SetOrigin(PPoint(origin.X()*scaleFactor.X(), 0));
  762.   HideCaret();
  763.   MoveCaretPosition(updateCanvas, 0, 0);
  765.   for (PINDEX i = 0; i < len; i++)
  766.     ProcessCharacter(updateCanvas, *buf++);
  768.   MoveCaretPosition(updateCanvas, 0, 0);
  769.   ShowCaret();
  770. }
  773. void PTerminal::ProcessCharacter(PDrawCanvas & canvas, char ch)
  774. {
  775.   switch (ch) {
  776.     case 'a' :
  777.       PSound::Beep();
  778.       break;
  780.     case 'b' :
  781.       MoveCaretPosition(canvas, 0, -1);
  782.       break;
  784.     case '13' : // ^K
  785.       MoveCaretPosition(canvas, -1, 0);
  786.       break;
  788.     case '14' : // ^L
  789.       MoveCaretPosition(canvas, 0, 1);
  790.       break;
  792.     case 't' :
  793.       MoveCaretPosition(canvas, 0, 8 - cursorColumn%8);
  794.       break;
  796.     case 'r' :
  797.       MoveCaretPosition(canvas, 0, -(int)cursorColumn);
  798.       if (!lineFeedOnReturn)
  799.         break;
  800.       // Else do line feed case
  802.     case 'n' :
  803.       if (cursorRow < scrollBottom-1)
  804.         MoveCaretPosition(canvas, 1, 0);
  805.       else
  806.         ScrollLines(canvas, scrollTop, scrollBottom, 1);
  807.       if (returnOnLineFeed)
  808.         MoveCaretPosition(canvas, 0, -(int)cursorColumn);
  809.       break;
  811.     case 'x7f' : // DEL
  812.       if (cursorColumn > 0) {
  813.         MoveCaretPosition(canvas, 0, -1);
  814.         GetCursorRow().SetCell(cursorColumn, ' ', attribute);
  815.       }
  816.       break;
  818.     default :
  819.       GetCursorRow().SetCell(cursorColumn, ch, attribute);
  821.       if (cursorColumn < columns-1)
  822.         AdjustCaretPosition(0, 1);
  823.       else if (wrapEOL) {
  824.         ProcessCharacter(canvas, 'r');
  825.         ProcessCharacter(canvas, 'n');
  826.       }
  827.   }
  828. }
  832. ///////////////////////////////////////////////////////////////////////////////
  834. PAnsiTerminal::PAnsiTerminal(PScroller * parent, ostream * kbd)
  835.   : PTerminal(parent, kbd)
  836. {
  837.   Reset();
  838. }
  841. void PAnsiTerminal::Reset()
  842. {
  843.   PTerminal::Reset();
  845.   inEscapeSequence = FALSE;
  846.   savedCursorRow = savedCursorColumn = 0;
  847. }
  850. BOOL PAnsiTerminal::OnKeyDown(PKeyCode key, unsigned repeat)
  851. {
  852.   static const struct {
  853.     PKeyCode::Value value;
  854.     const char * sequence;
  855.   } ansikeys[] = {
  856.     { PKeyCode::F1,       "33OP" },
  857.     { PKeyCode::F2,       "33OQ" },
  858.     { PKeyCode::F3,       "33OR" },
  859.     { PKeyCode::F4,       "33OS" },
  860.     { PKeyCode::Home,     "33[H" },
  861.     { PKeyCode::Separator,"33Ol" },
  862.     { PKeyCode::Subtract, "33Om" },
  863.     { PKeyCode::Decimal,  "33On" },
  864.     { PKeyCode::KP0,      "33Op" },
  865.     { PKeyCode::KP1,      "33Oq" },
  866.     { PKeyCode::KP2,      "33Or" },
  867.     { PKeyCode::KP3,      "33Os" },
  868.     { PKeyCode::KP4,      "33Ot" },
  869.     { PKeyCode::KP5,      "33Ou" },
  870.     { PKeyCode::KP6,      "33Ov" },
  871.     { PKeyCode::KP7,      "33Ow" },
  872.     { PKeyCode::KP8,      "33Ox" },
  873.     { PKeyCode::KP9,      "33Oy" },
  874.     { PKeyCode::Up,       "33[A" },
  875.     { PKeyCode::Down,     "33[B" },
  876.     { PKeyCode::Left,     "33[D" },
  877.     { PKeyCode::Right,    "33[C" },
  878.     { PKeyCode::Delete,   "177" },
  879.   };
  881.   if (keyboard != NULL && key.GetModifiers() == PKeyCode::NoModifier) {
  882.     for (PINDEX i = 0; i < PARRAYSIZE(ansikeys); i++) {
  883.       if (key.GetValue() == ansikeys[i].value) {
  884.         do {
  885.           *keyboard << ansikeys[i].sequence;
  886.         } while (repeat-- > 0);
  887.         keyboard->flush();
  888.         break;
  889.       }
  890.     }
  891.   }
  892.   return PTerminal::OnKeyDown(key, repeat);
  893. }
  896. void PAnsiTerminal::ProcessCharacter(PDrawCanvas & canvas, char ch)
  897. {
  898.   if (!inEscapeSequence) {
  899.     if (ch != '33')
  900.       PTerminal::ProcessCharacter(canvas, ch);
  901.     else {
  902.       inEscapeSequence = TRUE;
  903.       inParameter = FALSE;
  904.       numParameters = 0;
  905.       memset(parameter, 0, sizeof(parameter));
  906.     }
  907.     return;
  908.   }
  910.   if (inParameter && ch >= '0' && ch <= '9') {
  911.     parameter[numParameters] = parameter[numParameters]*10 + ch-'0';
  912.     return;
  913.   }
  915.   switch (ch) {
  916.     case '33' : // <esc>
  917.       inParameter = FALSE;
  918.       numParameters = 0;
  919.       memset(parameter, 0, sizeof(parameter));
  920.       return;
  922.     case '?' : // <esc>?
  923.       return;
  925.     case '[' : // <esc>[
  926.       inParameter = TRUE;
  927.       return;
  929.     case ';' :  // <esc>[0;1;2; etc
  930.       numParameters++;
  931.       return;
  933.     case 'h' : // <esc>[0h  Set Mode
  934.     case 'l' : // <esc>[0l  Reset Mode
  935.       switch (parameter[0]) {
  936.         case 7 :
  937.           wrapEOL = ch == 'h';
  938.           break;
  939.         case 20 :
  940.           lineFeedOnReturn = ch == 'h';
  941.           break;
  942.       }
  943.       break;
  945.     case 'r' : // <esc>[0;24r  Set scroll region
  946.       if (parameter[0] != 0)
  947.         parameter[0]--;
  948.       if (parameter[1] == 0)
  949.         parameter[1] = rows;
  950.       if (parameter[0] < parameter[1]) {
  951.         scrollTop = PMIN(parameter[0], rows-1);
  952.         scrollBottom = PMIN(parameter[1], rows);
  953.       }
  954.       break;
  956.     case 'A' : // <esc>[0A  Cursor Up
  957.       MoveCaretPosition(canvas, -PMAX(parameter[0], 1), 0);
  958.       break;
  960.     case 'B' : // <esc>[0B  Cursor Down
  961.       MoveCaretPosition(canvas, PMAX(parameter[0], 1), 0);
  962.       break;
  964.     case 'C' : // <esc>[0C  Cursor Forward
  965.       MoveCaretPosition(canvas, 0, PMAX(parameter[0], 1));
  966.       break;
  968.     case 'D' :
  969.       if (inParameter) // <esc>[0D  Cursor Backward
  970.         MoveCaretPosition(canvas, 0, -PMAX(parameter[0], 1));
  971.       else // <esc>D  Scroll Forward
  972.         ScrollLines(canvas, scrollTop, scrollBottom, 1);
  973.       break;
  975.     case 'H' : // <esc>[1;1H  Cursor motion
  976.     case 'f' : // <esc>[1;1f  Set active position
  977.       MoveCaretPosition(canvas,
  978.                        parameter[0]-cursorRow-1, parameter[1]-cursorColumn-1);
  979.       break;
  981.     case 'J' : // <esc>[0J  Erase display
  982.       switch (parameter[0]) {
  983.         case 0 : // <esc>[0J  To end
  984.           if (cursorRow != 0 || cursorColumn != 0) {
  985.             GetCursorRow().Scroll(this,
  986.                            canvas, cursorRow, cursorColumn, INT_MAX, INT_MAX);
  987.             if (cursorRow+1 < rows)
  988.               ScrollLines(canvas, cursorRow+1, rows, INT_MAX);
  989.             break;
  990.           }
  991.           // Do whole screen if cursor is homed
  993.         case 2 : // <esc>[2J  Whole screen
  994.           ScrollLines(canvas, 0, rows, INT_MAX);
  995.           break;
  997.         case 1 : // <esc>[1J  To beginning
  998.           GetCursorRow().Scroll(this,
  999.                                 canvas, cursorRow, 0, cursorColumn+1, INT_MAX);
  1000.           if (cursorRow > 0)
  1001.             ScrollLines(canvas, 0, cursorRow, INT_MAX);
  1002.           break;
  1003.       }
  1004.       break;
  1006.     case 'K' : // <esc>[0K  Erase Line
  1007.       switch (parameter[0]) {
  1008.         case 0 : // <esc>[0K  To end
  1009.           GetCursorRow().Scroll(this,
  1010.                             canvas, cursorRow, cursorColumn, INT_MAX, INT_MAX);
  1011.           break;
  1013.         case 1 : // <esc>[1K  To beginning
  1014.           GetCursorRow().Scroll(this,
  1015.                                 canvas, cursorRow, 0, cursorColumn+1, INT_MAX);
  1016.           break;
  1018.         case 2 : // <esc>[2K  Whole
  1019.           GetCursorRow().Scroll(this, canvas, cursorRow, 0, INT_MAX, INT_MAX);
  1020.           break;
  1021.       }
  1022.       break;
  1024.     case 'L' : // <esc>[1L  Insert Lines
  1025.       ScrollLines(canvas, cursorRow, scrollBottom, -PMAX(parameter[0], 1));
  1026.       break;
  1028.     case 'M' :
  1029.       if (inParameter) // <esc>[1M  Delete Lines
  1030.         ScrollLines(canvas, cursorRow, scrollBottom, PMAX(parameter[0], 1));
  1031.       else // <esc>M  Scroll Backward
  1032.         ScrollLines(canvas, scrollTop, scrollBottom, -1);
  1033.       break;
  1035.     case '@' : // <esc>[1@  Insert Character
  1036.       GetCursorRow().Scroll(this,
  1037.              canvas, cursorRow, cursorColumn, INT_MAX, -PMAX(parameter[0], 1));
  1038.       break;
  1040.     case 'P' : // <esc>[1P  Delete Character
  1041.       GetCursorRow().Scroll(this,
  1042.               canvas, cursorRow, cursorColumn, INT_MAX, PMAX(parameter[0], 1));
  1043.       break;
  1045.     case '7' :
  1046.       if (inParameter)
  1047.         break;
  1048.       // Else is <esc>7  Save Cursor Position
  1050.     case 's' : // <esc>[s  Save Cursor Position
  1051.       savedCursorRow = cursorRow;
  1052.       savedCursorColumn = cursorColumn;
  1053.       break;
  1055.     case '8' :
  1056.       if (inParameter)
  1057.         break;
  1058.       // Else is <esc>8  Restore Cursor Position
  1060.     case 'u' : // <esc>[u  Restore Cursor Position
  1061.       cursorRow = savedCursorRow;
  1062.       cursorColumn = savedCursorColumn;
  1063.       MoveCaretPosition(canvas, 0, 0);
  1064.       break;
  1066.     case 'm' : { // <esc>[0m  Set Graphic Rendition
  1067.       for (register PINDEX i = 0; i <= numParameters; i++) {
  1068.         switch (parameter[i]) {
  1069.           case 0 :
  1070.             attribute.bold = FALSE;
  1071.             attribute.underline = FALSE;
  1072.             attribute.blink = FALSE;
  1073.             attribute.inverse = FALSE;
  1074.             attribute.fgColor = 8; // Window fg colour
  1075.             attribute.bkColor = 9; // Window bk colour
  1076.             break;
  1077.           case 1 :
  1078.             attribute.bold = TRUE;
  1079.             break;
  1080.           case 4 :
  1081.             attribute.underline = TRUE;
  1082.             break;
  1083.           case 5 :
  1084.             attribute.blink = TRUE;
  1085.             break;
  1086.           case 7 :
  1087.             attribute.inverse = TRUE;
  1088.             break;
  1090.           default :
  1091.             if (parameter[i] >= 30 && parameter[i] <= 39)
  1092.               attribute.fgColor = parameter[i]-30;
  1093.             else if (parameter[i] >= 40 && parameter[i] <= 49)
  1094.               attribute.bkColor = parameter[i]-40;
  1095.         }
  1096.       }
  1097.       break;
  1098.     }
  1100.     case 'n' : // <esc>[n  Device Status Report
  1101.       if (keyboard != NULL) {
  1102.         *keyboard << "33[" << (cursorRow+1) << ';' << (cursorColumn+1) << 'R';
  1103.         keyboard->flush();
  1104.       }
  1105.       break;
  1106.   }
  1108.   inEscapeSequence = FALSE;
  1109. }
  1113. ///////////////////////////////////////////////////////////////////////////////
  1115. PTerminalChannel::PTerminalChannel()
  1116. {
  1117.   terminal = NULL;
  1118. }
  1121. PTerminalChannel::PTerminalChannel(PTerminal & term)
  1122. {
  1123.   Open(term);
  1124. }
  1127. PTerminalChannel::~PTerminalChannel()
  1128. {
  1129.   Close();
  1130. }
  1133. BOOL PTerminalChannel::IsOpen() const
  1134. {
  1135.   return terminal != NULL;
  1136. }
  1139. PString PTerminalChannel::GetName() const
  1140. {
  1141.   if (IsOpen())
  1142.     return terminal->GetClass();
  1144.   return PString();
  1145. }
  1148. BOOL PTerminalChannel::Read(void * buf, PINDEX len)
  1149. {
  1150.   if (!IsOpen()) {
  1151.     lastReadCount = 0;
  1152.     lastError = NotOpen;
  1153.     return FALSE;
  1154.   }
  1156.   readBuf.read((char *)buf, len);
  1157.   lastReadCount = readBuf.gcount();
  1158.   return lastReadCount > 0;
  1159. }
  1162. BOOL PTerminalChannel::Write(const void * buf, PINDEX len)
  1163. {
  1164.   if (!IsOpen()) {
  1165.     lastWriteCount = 0;
  1166.     lastError = NotOpen;
  1167.     return FALSE;
  1168.   }
  1170.   terminal->Write((const char *)buf, len);
  1171.   lastWriteCount = len;
  1172.   return TRUE;
  1173. }
  1176. BOOL PTerminalChannel::Close()
  1177. {
  1178.   if (!IsOpen()) {
  1179.     lastError = NotOpen;
  1180.     return FALSE;
  1181.   }
  1183.   flush();
  1185.   terminal->SetKeyboardStream(NULL);
  1186.   terminal = NULL;
  1187.   return TRUE;
  1188. }
  1191. BOOL PTerminalChannel::Open(PTerminal & term)
  1192. {
  1193.   terminal = &term;
  1194.   term.SetKeyboardStream(&readBuf);
  1195.   lastError = NoError;
  1196.   return TRUE;
  1197. }
  1199. #undef new
  1202. // End Of File ///////////////////////////////////////////////////////////////