Annotation of OpenXM_contrib/gnuplot/win/wtext.c, Revision 1.1
1.1 ! maekawa 1: #ifndef lint
! 2: static char *RCSid = "$Id: wtext.c,v 1.11 1998/03/22 22:35:31 drd Exp $";
! 3: #endif
! 4:
! 5: /* GNUPLOT - win/wtext.c */
! 6: /*[
! 7: * Copyright 1992, 1993, 1998 Russell Lang
! 8: *
! 9: * Permission to use, copy, and distribute this software and its
! 10: * documentation for any purpose with or without fee is hereby granted,
! 11: * provided that the above copyright notice appear in all copies and
! 12: * that both that copyright notice and this permission notice appear
! 13: * in supporting documentation.
! 14: *
! 15: * Permission to modify the software is granted, but not the right to
! 16: * distribute the complete modified source code. Modifications are to
! 17: * be distributed as patches to the released version. Permission to
! 18: * distribute binaries produced by compiling modified sources is granted,
! 19: * provided you
! 20: * 1. distribute the corresponding source modifications from the
! 21: * released version in the form of a patch file along with the binaries,
! 22: * 2. add special version identification to distinguish your version
! 23: * in addition to the base release version number,
! 24: * 3. provide your name and address as the primary contact for the
! 25: * support of your modified version, and
! 26: * 4. retain our contact information in regard to use of the base
! 27: * software.
! 28: * Permission to distribute the released version of the source code along
! 29: * with corresponding source modifications in the form of a patch file is
! 30: * granted with same provisions 2 through 4 for binary distributions.
! 31: *
! 32: * This software is provided "as is" without express or implied warranty
! 33: * to the extent permitted by applicable law.
! 34: ]*/
! 35:
! 36: /*
! 37: * AUTHORS
! 38: *
! 39: * Russell Lang
! 40: *
! 41: * Send your comments or suggestions to
! 42: * info-gnuplot@dartmouth.edu.
! 43: * This is a mailing list; to join it send a note to
! 44: * majordomo@dartmouth.edu.
! 45: * Send bug reports to
! 46: * bug-gnuplot@dartmouth.edu.
! 47: */
! 48:
! 49: /* WARNING: Do not write to stdout/stderr with functions not listed
! 50: in win/wtext.h */
! 51:
! 52: #define STRICT
! 53:
! 54: #include <string.h> /* use only far items */
! 55: #include <stdlib.h>
! 56: #include <ctype.h>
! 57: #include <dos.h>
! 58: #ifndef __MSC__
! 59: # include <mem.h>
! 60: #endif
! 61:
! 62: #include <windows.h>
! 63: #include <windowsx.h>
! 64: #if WINVER >= 0x030a
! 65: # include <commdlg.h>
! 66: #endif
! 67:
! 68: #include "wgnuplib.h"
! 69: #include "wresourc.h"
! 70: #include "wcommon.h"
! 71:
! 72: /* font stuff */
! 73: #define TEXTFONTSIZE 9
! 74: #define TEXTFONTNAME "Terminal"
! 75:
! 76: #ifndef EOF /* HBB 980809: for MinGW32 */
! 77: #define EOF -1 /* instead of using <stdio.h> */
! 78: #endif
! 79: /* limits */
! 80: #define MAXSTR 256
! 81: POINT ScreenMinSize = {16,4};
! 82:
! 83: LRESULT CALLBACK WINEXPORT WndParentProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
! 84: LRESULT CALLBACK WINEXPORT WndTextProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
! 85:
! 86: void ReadTextIni(LPTW lptw);
! 87: void LimitMark(LPTW lptw, POINT FAR *lppt);
! 88:
! 89: char szNoMemory[] = "out of memory";
! 90: COLORREF TextColorTable[16] = {
! 91: RGB(0,0,0), /* black */
! 92: RGB(0,0,128), /* dark blue */
! 93: RGB(0,128,0), /* dark green */
! 94: RGB(0,128,128), /* dark cyan */
! 95: RGB(128,0,0), /* dark red */
! 96: RGB(128,0,128), /* dark magenta */
! 97: RGB(128,128,0), /* dark yellow */
! 98: RGB(128,128,128), /* dark grey */
! 99: RGB(192,192,192), /* light grey */
! 100: RGB(0,0,255), /* blue */
! 101: RGB(0,255,0), /* green */
! 102: RGB(0,255,255), /* cyan */
! 103: RGB(255,0,0), /* red */
! 104: RGB(255,0,255), /* magenta */
! 105: RGB(255,255,0), /* yellow */
! 106: RGB(255,255,255), /* white */
! 107: };
! 108: #define NOTEXT 0xF0
! 109: #define MARKFORE RGB(255,255,255)
! 110: #define MARKBACK RGB(0,0,128)
! 111: #define TextFore(attr) TextColorTable[(attr) & 15]
! 112: #define TextBack(attr) TextColorTable[(attr>>4) & 15]
! 113:
! 114:
! 115: void WDPROC
! 116: TextMessage(void)
! 117: {
! 118: MSG msg;
! 119:
! 120: while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
! 121: {
! 122: TranslateMessage(&msg);
! 123: DispatchMessage(&msg);
! 124: }
! 125: return;
! 126: }
! 127:
! 128:
! 129:
! 130: void
! 131: CreateTextClass(LPTW lptw)
! 132: {
! 133: WNDCLASS wndclass;
! 134: #ifdef WIN32
! 135: hdllInstance = lptw->hInstance; /* not using a DLL */
! 136: #endif
! 137: wndclass.style = CS_HREDRAW | CS_VREDRAW;
! 138: wndclass.lpfnWndProc = WndTextProc;
! 139: wndclass.cbClsExtra = 0;
! 140: wndclass.cbWndExtra = 2 * sizeof(void FAR *);
! 141: wndclass.hInstance = lptw->hInstance;
! 142: wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
! 143: wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
! 144: wndclass.hbrBackground = NULL;
! 145: lptw->hbrBackground = CreateSolidBrush(lptw->bSysColors ?
! 146: GetSysColor(COLOR_WINDOW) : RGB(0,0,0));
! 147: wndclass.lpszMenuName = NULL;
! 148: wndclass.lpszClassName = szTextClass;
! 149: RegisterClass(&wndclass);
! 150:
! 151: wndclass.style = CS_HREDRAW | CS_VREDRAW;
! 152: wndclass.lpfnWndProc = WndParentProc;
! 153: wndclass.cbClsExtra = 0;
! 154: wndclass.cbWndExtra = 2 * sizeof(void FAR *);
! 155: wndclass.hInstance = lptw->hInstance;
! 156: if (lptw->hIcon)
! 157: wndclass.hIcon = lptw->hIcon;
! 158: else
! 159: wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
! 160: wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
! 161: wndclass.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
! 162: wndclass.lpszMenuName = NULL;
! 163: wndclass.lpszClassName = szParentClass;
! 164: RegisterClass(&wndclass);
! 165: }
! 166:
! 167:
! 168: /* make text window */
! 169: int WDPROC
! 170: TextInit(LPTW lptw)
! 171: {
! 172: RECT rect;
! 173: HMENU sysmenu;
! 174: HGLOBAL hglobal;
! 175: char buf[80];
! 176:
! 177: ReadTextIni(lptw);
! 178:
! 179: if (!lptw->hPrevInstance)
! 180: CreateTextClass(lptw);
! 181:
! 182: if (lptw->KeyBufSize == 0)
! 183: lptw->KeyBufSize = 256;
! 184:
! 185: if (lptw->ScreenSize.x < ScreenMinSize.x)
! 186: lptw->ScreenSize.x = ScreenMinSize.x;
! 187: if (lptw->ScreenSize.y < ScreenMinSize.y)
! 188: lptw->ScreenSize.y = ScreenMinSize.y;
! 189:
! 190: lptw->CursorPos.x = lptw->CursorPos.y = 0;
! 191: lptw->bFocus = FALSE;
! 192: lptw->bGetCh = FALSE;
! 193: lptw->CaretHeight = 0;
! 194: if (!lptw->nCmdShow)
! 195: lptw->nCmdShow = SW_SHOWNORMAL;
! 196: if (!lptw->Attr)
! 197: lptw->Attr = 0xf0; /* black on white */
! 198:
! 199: hglobal = GlobalAlloc(GHND, lptw->ScreenSize.x * lptw->ScreenSize.y);
! 200: lptw->ScreenBuffer = (BYTE FAR *)GlobalLock(hglobal);
! 201: if (lptw->ScreenBuffer == (BYTE FAR *)NULL) {
! 202: MessageBox((HWND)NULL,szNoMemory,(LPSTR)NULL, MB_ICONHAND | MB_SYSTEMMODAL);
! 203: return(1);
! 204: }
! 205: _fmemset(lptw->ScreenBuffer, ' ', lptw->ScreenSize.x * lptw->ScreenSize.y);
! 206: hglobal = GlobalAlloc(GHND, lptw->ScreenSize.x * lptw->ScreenSize.y);
! 207: lptw->AttrBuffer = (BYTE FAR *)GlobalLock(hglobal);
! 208: if (lptw->AttrBuffer == (BYTE FAR *)NULL) {
! 209: MessageBox((HWND)NULL,szNoMemory,(LPSTR)NULL, MB_ICONHAND | MB_SYSTEMMODAL);
! 210: return(1);
! 211: }
! 212: _fmemset(lptw->AttrBuffer, NOTEXT, lptw->ScreenSize.x * lptw->ScreenSize.y);
! 213: hglobal = GlobalAlloc(LHND, lptw->KeyBufSize);
! 214: lptw->KeyBuf = (BYTE FAR *)GlobalLock(hglobal);
! 215: if (lptw->KeyBuf == (BYTE FAR *)NULL) {
! 216: MessageBox((HWND)NULL,szNoMemory,(LPSTR)NULL, MB_ICONHAND | MB_SYSTEMMODAL);
! 217: return(1);
! 218: }
! 219: lptw->KeyBufIn = lptw->KeyBufOut = lptw->KeyBuf;
! 220:
! 221: lptw->hWndParent = CreateWindow(szParentClass, lptw->Title,
! 222: WS_OVERLAPPEDWINDOW,
! 223: lptw->Origin.x, lptw->Origin.y,
! 224: lptw->Size.x, lptw->Size.y,
! 225: NULL, NULL, lptw->hInstance, lptw);
! 226: if (lptw->hWndParent == (HWND)NULL) {
! 227: MessageBox((HWND)NULL,"Couldn't open parent text window",(LPSTR)NULL, MB_ICONHAND | MB_SYSTEMMODAL);
! 228: return(1);
! 229: }
! 230: GetClientRect(lptw->hWndParent, &rect);
! 231:
! 232: lptw->hWndText = CreateWindow(szTextClass, lptw->Title,
! 233: WS_CHILD | WS_VSCROLL | WS_HSCROLL,
! 234: 0, lptw->ButtonHeight,
! 235: rect.right, rect.bottom-lptw->ButtonHeight,
! 236: lptw->hWndParent, NULL, lptw->hInstance, lptw);
! 237: if (lptw->hWndText == (HWND)NULL) {
! 238: MessageBox((HWND)NULL,"Couldn't open text window",(LPSTR)NULL, MB_ICONHAND | MB_SYSTEMMODAL);
! 239: return(1);
! 240: }
! 241:
! 242: lptw->hPopMenu = CreatePopupMenu();
! 243: AppendMenu(lptw->hPopMenu, MF_STRING, M_COPY_CLIP, "&Copy to Clipboard");
! 244: AppendMenu(lptw->hPopMenu, MF_STRING, M_PASTE, "&Paste");
! 245: #if WINVER >= 0x030a
! 246: AppendMenu(lptw->hPopMenu, MF_STRING, M_CHOOSE_FONT, "Choose &Font...");
! 247: #endif
! 248: AppendMenu(lptw->hPopMenu, MF_STRING | (lptw->bSysColors ? MF_CHECKED : MF_UNCHECKED),
! 249: M_SYSCOLORS, "&System Colors");
! 250: if (lptw->IniFile != (LPSTR)NULL) {
! 251: wsprintf(buf,"&Update %s",lptw->IniFile);
! 252: AppendMenu(lptw->hPopMenu, MF_STRING, M_WRITEINI, (LPSTR)buf);
! 253: }
! 254:
! 255: sysmenu = GetSystemMenu(lptw->hWndParent,0); /* get the sysmenu */
! 256: AppendMenu(sysmenu, MF_SEPARATOR, 0, NULL);
! 257: AppendMenu(sysmenu, MF_POPUP, (UINT)lptw->hPopMenu, "&Options");
! 258: AppendMenu(sysmenu, MF_STRING, M_ABOUT, "&About");
! 259:
! 260: if (lptw->lpmw)
! 261: LoadMacros(lptw);
! 262:
! 263: ShowWindow(lptw->hWndText, SW_SHOWNORMAL);
! 264: BringWindowToTop(lptw->hWndText);
! 265: SetFocus(lptw->hWndText);
! 266: TextMessage();
! 267: return(0);
! 268: }
! 269:
! 270: /* close a text window */
! 271: void WDPROC
! 272: TextClose(LPTW lptw)
! 273: {
! 274: HGLOBAL hglobal;
! 275:
! 276: /* close window */
! 277: if (lptw->hWndParent)
! 278: DestroyWindow(lptw->hWndParent);
! 279: TextMessage();
! 280:
! 281: hglobal = (HGLOBAL)GlobalHandle( SELECTOROF(lptw->ScreenBuffer) );
! 282: if (hglobal) {
! 283: GlobalUnlock(hglobal);
! 284: GlobalFree(hglobal);
! 285: }
! 286: hglobal = (HGLOBAL)GlobalHandle( SELECTOROF(lptw->AttrBuffer) );
! 287: if (hglobal) {
! 288: GlobalUnlock(hglobal);
! 289: GlobalFree(hglobal);
! 290: }
! 291: hglobal = (HGLOBAL)GlobalHandle( SELECTOROF(lptw->KeyBuf) );
! 292: if (hglobal) {
! 293: GlobalUnlock(hglobal);
! 294: GlobalFree(hglobal);
! 295: }
! 296:
! 297: if (lptw->lpmw)
! 298: CloseMacros(lptw);
! 299: lptw->hWndParent = (HWND)NULL;
! 300: }
! 301:
! 302: void
! 303: WriteTextIni(LPTW lptw)
! 304: {
! 305: RECT rect;
! 306: LPSTR file = lptw->IniFile;
! 307: LPSTR section = lptw->IniSection;
! 308: char profile[80];
! 309: int iconic;
! 310:
! 311:
! 312: if ((file == (LPSTR)NULL) || (section == (LPSTR)NULL))
! 313: return;
! 314:
! 315: iconic = IsIconic(lptw->hWndParent);
! 316: if (iconic)
! 317: ShowWindow(lptw->hWndParent, SW_SHOWNORMAL);
! 318: GetWindowRect(lptw->hWndParent,&rect);
! 319: wsprintf(profile, "%d %d", rect.left, rect.top);
! 320: WritePrivateProfileString(section, "TextOrigin", profile, file);
! 321: wsprintf(profile, "%d %d", rect.right-rect.left, rect.bottom-rect.top);
! 322: WritePrivateProfileString(section, "TextSize", profile, file);
! 323: wsprintf(profile, "%d", iconic);
! 324: WritePrivateProfileString(section, "TextMinimized", profile, file);
! 325: wsprintf(profile, "%s,%d", lptw->fontname, lptw->fontsize);
! 326: WritePrivateProfileString(section, "TextFont", profile, file);
! 327: wsprintf(profile, "%d", lptw->bSysColors);
! 328: WritePrivateProfileString(section, "SysColors", profile, file);
! 329: if (iconic)
! 330: ShowWindow(lptw->hWndParent, SW_SHOWMINIMIZED);
! 331: return;
! 332: }
! 333:
! 334: void
! 335: ReadTextIni(LPTW lptw)
! 336: {
! 337: LPSTR file = lptw->IniFile;
! 338: LPSTR section = lptw->IniSection;
! 339: char profile[81];
! 340: LPSTR p;
! 341: BOOL bOKINI;
! 342:
! 343: bOKINI = (file != (LPSTR)NULL) && (section != (LPSTR)NULL);
! 344: profile[0] = '\0';
! 345:
! 346: if (bOKINI)
! 347: GetPrivateProfileString(section, "TextOrigin", "", profile, 80, file);
! 348: if ( (p = GetInt(profile, (LPINT)&lptw->Origin.x)) == NULL)
! 349: lptw->Origin.x = CW_USEDEFAULT;
! 350: if ( (p = GetInt(p, (LPINT)&lptw->Origin.y)) == NULL)
! 351: lptw->Origin.y = CW_USEDEFAULT;
! 352: if ( (file != (LPSTR)NULL) && (section != (LPSTR)NULL) )
! 353: GetPrivateProfileString(section, "TextSize", "", profile, 80, file);
! 354: if ( (p = GetInt(profile, (LPINT)&lptw->Size.x)) == NULL)
! 355: lptw->Size.x = CW_USEDEFAULT;
! 356: if ( (p = GetInt(p, (LPINT)&lptw->Size.y)) == NULL)
! 357: lptw->Size.y = CW_USEDEFAULT;
! 358:
! 359: if (bOKINI)
! 360: GetPrivateProfileString(section, "TextFont", "", profile, 80, file);
! 361: {
! 362: char FAR *size;
! 363: size = _fstrchr(profile,',');
! 364: if (size) {
! 365: *size++ = '\0';
! 366: if ( (p = GetInt(size, &lptw->fontsize)) == NULL)
! 367: lptw->fontsize = TEXTFONTSIZE;
! 368: }
! 369: _fstrcpy(lptw->fontname, profile);
! 370: if (lptw->fontsize == 0)
! 371: lptw->fontsize = TEXTFONTSIZE;
! 372: if (!(*lptw->fontname))
! 373: _fstrcpy(lptw->fontname,TEXTFONTNAME);
! 374: }
! 375:
! 376: if (bOKINI) {
! 377: int iconic;
! 378: GetPrivateProfileString(section, "TextMinimized", "", profile, 80, file);
! 379: if ((p = GetInt(profile, &iconic)) == NULL)
! 380: iconic = 0;
! 381: if (iconic)
! 382: lptw->nCmdShow = SW_SHOWMINIMIZED;
! 383: }
! 384: lptw->bSysColors = FALSE;
! 385: GetPrivateProfileString(section, "SysColors", "", profile, 80, file);
! 386: if ((p = GetInt(profile, &lptw->bSysColors)) == NULL)
! 387: lptw->bSysColors = 0;
! 388: }
! 389:
! 390:
! 391: /* Bring Cursor into text window */
! 392: void WDPROC
! 393: TextToCursor(LPTW lptw)
! 394: {
! 395: int nXinc=0;
! 396: int nYinc=0;
! 397: int cxCursor;
! 398: int cyCursor;
! 399: cyCursor = lptw->CursorPos.y * lptw->CharSize.y;
! 400: if ( (cyCursor + lptw->CharSize.y > lptw->ScrollPos.y + lptw->ClientSize.y)
! 401: || (cyCursor < lptw->ScrollPos.y) ) {
! 402: nYinc = max(0, cyCursor + lptw->CharSize.y - lptw->ClientSize.y) - lptw->ScrollPos.y;
! 403: nYinc = min(nYinc, lptw->ScrollMax.y - lptw->ScrollPos.y);
! 404: }
! 405: cxCursor = lptw->CursorPos.x * lptw->CharSize.x;
! 406: if ( (cxCursor + lptw->CharSize.x > lptw->ScrollPos.x + lptw->ClientSize.x)
! 407: || (cxCursor < lptw->ScrollPos.x) ) {
! 408: nXinc = max(0, cxCursor + lptw->CharSize.x - lptw->ClientSize.x/2) - lptw->ScrollPos.x;
! 409: nXinc = min(nXinc, lptw->ScrollMax.x - lptw->ScrollPos.x);
! 410: }
! 411: if (nYinc || nXinc) {
! 412: lptw->ScrollPos.y += nYinc;
! 413: lptw->ScrollPos.x += nXinc;
! 414: ScrollWindow(lptw->hWndText,-nXinc,-nYinc,NULL,NULL);
! 415: SetScrollPos(lptw->hWndText,SB_VERT,lptw->ScrollPos.y,TRUE);
! 416: SetScrollPos(lptw->hWndText,SB_HORZ,lptw->ScrollPos.x,TRUE);
! 417: UpdateWindow(lptw->hWndText);
! 418: }
! 419: }
! 420:
! 421: void
! 422: NewLine(LPTW lptw)
! 423: {
! 424: lptw->CursorPos.x = 0;
! 425: lptw->CursorPos.y++;
! 426: if (lptw->CursorPos.y >= lptw->ScreenSize.y) {
! 427: int i = lptw->ScreenSize.x * (lptw->ScreenSize.y - 1);
! 428: _fmemmove(lptw->ScreenBuffer, lptw->ScreenBuffer+lptw->ScreenSize.x, i);
! 429: _fmemset(lptw->ScreenBuffer + i, ' ', lptw->ScreenSize.x);
! 430: _fmemmove(lptw->AttrBuffer, lptw->AttrBuffer+lptw->ScreenSize.x, i);
! 431: _fmemset(lptw->AttrBuffer + i, NOTEXT, lptw->ScreenSize.x);
! 432: lptw->CursorPos.y--;
! 433: ScrollWindow(lptw->hWndText,0,-lptw->CharSize.y,NULL,NULL);
! 434: lptw->MarkBegin.y--;
! 435: lptw->MarkEnd.y--;
! 436: LimitMark(lptw, &lptw->MarkBegin);
! 437: LimitMark(lptw, &lptw->MarkEnd);
! 438: UpdateWindow(lptw->hWndText);
! 439: }
! 440: if (lptw->CursorFlag)
! 441: TextToCursor(lptw);
! 442: TextMessage();
! 443: }
! 444:
! 445: /* Update count characters in window at cursor position */
! 446: /* Updates cursor position */
! 447: void
! 448: UpdateText(LPTW lptw, int count)
! 449: {
! 450: HDC hdc;
! 451: int xpos, ypos;
! 452: xpos = lptw->CursorPos.x*lptw->CharSize.x - lptw->ScrollPos.x;
! 453: ypos = lptw->CursorPos.y*lptw->CharSize.y - lptw->ScrollPos.y;
! 454: hdc = GetDC(lptw->hWndText);
! 455: if (lptw->bSysColors) {
! 456: SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT));
! 457: SetBkColor(hdc, GetSysColor(COLOR_WINDOW));
! 458: }
! 459: else {
! 460: SetTextColor(hdc, TextFore(lptw->Attr));
! 461: SetBkColor(hdc, TextBack(lptw->Attr));
! 462: }
! 463: SelectObject(hdc, lptw->hfont);
! 464: TextOut(hdc,xpos,ypos,
! 465: (LPSTR)(lptw->ScreenBuffer + lptw->CursorPos.y*lptw->ScreenSize.x +
! 466: lptw->CursorPos.x), count);
! 467: (void)ReleaseDC(lptw->hWndText,hdc);
! 468: lptw->CursorPos.x += count;
! 469: if (lptw->CursorPos.x >= lptw->ScreenSize.x)
! 470: NewLine(lptw);
! 471: }
! 472:
! 473: int WDPROC
! 474: TextPutCh(LPTW lptw, BYTE ch)
! 475: {
! 476: int pos;
! 477: switch(ch) {
! 478: case '\r':
! 479: lptw->CursorPos.x = 0;
! 480: if (lptw->CursorFlag)
! 481: TextToCursor(lptw);
! 482: break;
! 483: case '\n':
! 484: NewLine(lptw);
! 485: break;
! 486: case 7:
! 487: MessageBeep(0xFFFFFFFF);
! 488: if (lptw->CursorFlag)
! 489: TextToCursor(lptw);
! 490: break;
! 491: case '\t':
! 492: {
! 493: int n;
! 494: for ( n = 8 - (lptw->CursorPos.x % 8); n>0; n-- )
! 495: TextPutCh(lptw, ' ');
! 496: }
! 497: break;
! 498: case 0x08:
! 499: case 0x7f:
! 500: lptw->CursorPos.x--;
! 501: if (lptw->CursorPos.x < 0) {
! 502: lptw->CursorPos.x = lptw->ScreenSize.x - 1;
! 503: lptw->CursorPos.y--;
! 504: }
! 505: if (lptw->CursorPos.y < 0)
! 506: lptw->CursorPos.y = 0;
! 507: break;
! 508: default:
! 509: pos = lptw->CursorPos.y*lptw->ScreenSize.x + lptw->CursorPos.x;
! 510: lptw->ScreenBuffer[pos] = ch;
! 511: lptw->AttrBuffer[pos] = lptw->Attr;
! 512: UpdateText(lptw, 1);
! 513: }
! 514: return ch;
! 515: }
! 516:
! 517: void
! 518: TextPutStr(LPTW lptw, LPSTR str)
! 519: {
! 520: BYTE FAR *p, FAR *pa;
! 521: int count, limit;
! 522: while (*str) {
! 523: p = lptw->ScreenBuffer + lptw->CursorPos.y*lptw->ScreenSize.x + lptw->CursorPos.x;
! 524: pa = lptw->AttrBuffer + lptw->CursorPos.y*lptw->ScreenSize.x + lptw->CursorPos.x;
! 525: limit = lptw->ScreenSize.x - lptw->CursorPos.x;
! 526: for (count=0; (count < limit) && *str && (isprint(*str) || *str=='\t'); count++) {
! 527: if (*str=='\t') {
! 528: int n;
! 529: for ( n = 8 - ((lptw->CursorPos.x+count) % 8); (count < limit) & (n>0); n--, count++ ) {
! 530: *p++ = ' ';
! 531: *pa++ = lptw->Attr;
! 532: }
! 533: str++;
! 534: count--;
! 535: }
! 536: else {
! 537: *p++ = *str++;
! 538: *pa++ = lptw->Attr;
! 539: }
! 540: }
! 541: if (count>0) {
! 542: UpdateText(lptw, count);
! 543: }
! 544: if (*str=='\n') {
! 545: NewLine(lptw);
! 546: str++;
! 547: }
! 548: else if (*str && !isprint(*str) && *str!='\t') {
! 549: TextPutCh(lptw, *str++);
! 550: }
! 551: }
! 552: }
! 553:
! 554:
! 555: void
! 556: LimitMark(LPTW lptw, POINT FAR *lppt)
! 557: {
! 558: if (lppt->x < 0)
! 559: lppt->x = 0;
! 560: if (lppt->y < 0) {
! 561: lppt->x = 0;
! 562: lppt->y = 0;
! 563: }
! 564: if (lppt->x > lptw->ScreenSize.x)
! 565: lppt->x = lptw->ScreenSize.x;
! 566: if (lppt->y >= lptw->ScreenSize.y) {
! 567: lppt->x = 0;
! 568: lppt->y = lptw->ScreenSize.y;
! 569: }
! 570: }
! 571:
! 572: void
! 573: ClearMark(LPTW lptw, POINT pt)
! 574: {
! 575: RECT rect1, rect2, rect3;
! 576: int tmp;
! 577: if ((lptw->MarkBegin.x != lptw->MarkEnd.x) ||
! 578: (lptw->MarkBegin.y != lptw->MarkEnd.y) ) {
! 579: if (lptw->MarkBegin.x > lptw->MarkEnd.x) {
! 580: tmp = lptw->MarkBegin.x;
! 581: lptw->MarkBegin.x = lptw->MarkEnd.x;
! 582: lptw->MarkEnd.x = tmp;
! 583: }
! 584: if (lptw->MarkBegin.y > lptw->MarkEnd.y) {
! 585: tmp = lptw->MarkBegin.y;
! 586: lptw->MarkBegin.y = lptw->MarkEnd.y;
! 587: lptw->MarkEnd.y = tmp;
! 588: }
! 589: /* calculate bounding rectangle in character coordinates */
! 590: if (lptw->MarkBegin.y != lptw->MarkEnd.y) {
! 591: rect1.left = 0;
! 592: rect1.right = lptw->ScreenSize.x;
! 593: }
! 594: else {
! 595: rect1.left = lptw->MarkBegin.x;
! 596: rect1.right = lptw->MarkEnd.x + 1;
! 597: }
! 598: rect1.top = lptw->MarkBegin.y;
! 599: rect1.bottom = lptw->MarkEnd.y + 1;
! 600: /* now convert to client coordinates */
! 601: rect1.left = rect1.left * lptw->CharSize.x - lptw->ScrollPos.x;
! 602: rect1.right = rect1.right * lptw->CharSize.x - lptw->ScrollPos.x;
! 603: rect1.top = rect1.top * lptw->CharSize.y - lptw->ScrollPos.y;
! 604: rect1.bottom = rect1.bottom * lptw->CharSize.y - lptw->ScrollPos.y;
! 605: /* get client rect and calculate intersection */
! 606: GetClientRect(lptw->hWndText, &rect2);
! 607: IntersectRect(&rect3, &rect1, &rect2);
! 608: /* update window if necessary */
! 609: if (!IsRectEmpty(&rect3)) {
! 610: InvalidateRect(lptw->hWndText, &rect3, TRUE);
! 611: }
! 612: }
! 613: LimitMark(lptw, &pt);
! 614: lptw->MarkBegin.x = lptw->MarkEnd.x = pt.x;
! 615: lptw->MarkBegin.y = lptw->MarkEnd.y = pt.y;
! 616: UpdateWindow(lptw->hWndText);
! 617: }
! 618:
! 619:
! 620: /* output a line including attribute changes as needed */
! 621: void
! 622: DoLine(LPTW lptw, HDC hdc, int xpos, int ypos, int offset, int count)
! 623: {
! 624: BYTE FAR *pa, attr;
! 625: int idx, num;
! 626: pa = lptw->AttrBuffer + offset;
! 627: if ((offset < 0) || (offset >= lptw->ScreenSize.x*lptw->ScreenSize.y))
! 628: MessageBox((HWND)NULL, "panic", "panic", MB_OK | MB_ICONEXCLAMATION);
! 629: idx = 0;
! 630: num = count;
! 631: while (num > 0) {
! 632: attr = *pa;
! 633: while ((num > 0) && (attr == *pa)) {
! 634: /* skip over bytes with same attribute */
! 635: num--;
! 636: pa++;
! 637: }
! 638: if (lptw->bSysColors) {
! 639: SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT));
! 640: SetBkColor(hdc, GetSysColor(COLOR_WINDOW));
! 641: }
! 642: else {
! 643: SetTextColor(hdc, TextFore(attr));
! 644: SetBkColor(hdc, TextBack(attr));
! 645: }
! 646: TextOut(hdc,xpos,ypos, (LPSTR)(lptw->ScreenBuffer + offset + idx),
! 647: count-num-idx);
! 648: xpos += lptw->CharSize.x * (count-num-idx);
! 649: idx = count-num;
! 650: }
! 651: }
! 652:
! 653: void
! 654: DoMark(LPTW lptw, POINT pt, POINT end, BOOL mark)
! 655: {
! 656: int xpos, ypos;
! 657: HDC hdc;
! 658: int count;
! 659: int offset;
! 660: offset = lptw->ScreenSize.x * pt.y + pt.x;
! 661: hdc = GetDC(lptw->hWndText);
! 662: SelectObject(hdc, lptw->hfont);
! 663: if (lptw->bSysColors) {
! 664: SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
! 665: SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
! 666: }
! 667: else {
! 668: SetTextColor(hdc, MARKFORE);
! 669: SetBkColor(hdc, MARKBACK);
! 670: }
! 671: while (pt.y < end.y) {
! 672: /* multiple lines */
! 673: xpos = pt.x*lptw->CharSize.x - lptw->ScrollPos.x;
! 674: ypos = pt.y*lptw->CharSize.y - lptw->ScrollPos.y;
! 675: count = lptw->ScreenSize.x - pt.x;
! 676: if (mark)
! 677: TextOut(hdc,xpos,ypos, (LPSTR)(lptw->ScreenBuffer + offset), count);
! 678: else {
! 679: DoLine(lptw, hdc, xpos, ypos, offset, count);
! 680: if (lptw->bSysColors) {
! 681: SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
! 682: SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
! 683: }
! 684: else {
! 685: SetTextColor(hdc, MARKFORE);
! 686: SetBkColor(hdc, MARKBACK);
! 687: }
! 688: }
! 689: offset += count;
! 690: pt.y++;
! 691: pt.x=0;
! 692: }
! 693: /* partial line */
! 694: xpos = pt.x*lptw->CharSize.x - lptw->ScrollPos.x;
! 695: ypos = pt.y*lptw->CharSize.y - lptw->ScrollPos.y;
! 696: count = end.x - pt.x;
! 697: if (end.y != lptw->ScreenSize.y) {
! 698: if (mark)
! 699: TextOut(hdc,xpos,ypos, (LPSTR)(lptw->ScreenBuffer + offset), count);
! 700: else
! 701: DoLine(lptw, hdc, xpos, ypos, offset, count);
! 702: }
! 703: (void)ReleaseDC(lptw->hWndText,hdc);
! 704: }
! 705:
! 706: void
! 707: UpdateMark(LPTW lptw, POINT pt)
! 708: {
! 709: int begin, point, end;
! 710: LimitMark(lptw, &pt);
! 711: begin = lptw->ScreenSize.x*lptw->MarkBegin.y + lptw->MarkBegin.x;
! 712: point = lptw->ScreenSize.x*pt.y + pt.x;
! 713: end = lptw->ScreenSize.x*lptw->MarkEnd.y + lptw->MarkEnd.x;
! 714:
! 715: if (begin <= end) {
! 716: /* forward mark */
! 717: if (point >= end) {
! 718: /* extend marked area */
! 719: DoMark(lptw, lptw->MarkEnd, pt, TRUE);
! 720: }
! 721: else if (point >= begin) {
! 722: /* retract marked area */
! 723: DoMark(lptw, pt, lptw->MarkEnd, FALSE);
! 724: }
! 725: else { /* retract and reverse */
! 726: DoMark(lptw, lptw->MarkBegin, lptw->MarkEnd, FALSE);
! 727: DoMark(lptw, pt, lptw->MarkBegin, TRUE);
! 728: }
! 729: }
! 730: else {
! 731: /* reverse mark */
! 732: if (point <= end) {
! 733: /* extend marked area */
! 734: DoMark(lptw, pt, lptw->MarkEnd, TRUE);
! 735: }
! 736: else if (point <= begin) {
! 737: /* retract marked area */
! 738: DoMark(lptw, lptw->MarkEnd, pt, FALSE);
! 739: }
! 740: else { /* retract and reverse */
! 741: DoMark(lptw, lptw->MarkEnd, lptw->MarkBegin, FALSE);
! 742: DoMark(lptw, lptw->MarkBegin, pt, TRUE);
! 743: }
! 744: }
! 745: lptw->MarkEnd.x = pt.x;
! 746: lptw->MarkEnd.y = pt.y;
! 747: }
! 748:
! 749:
! 750: #if WINVER >= 0x030a
! 751: /* Windows 3.1 drag-drop feature */
! 752: char szFile[80];
! 753: void
! 754: DragFunc(LPTW lptw, HDROP hdrop)
! 755: {
! 756: int i, cFiles;
! 757: LPSTR p;
! 758: if ( (lptw->DragPre==(LPSTR)NULL) || (lptw->DragPost==(LPSTR)NULL) )
! 759: return;
! 760: cFiles = DragQueryFile(hdrop, 0xffff, (LPSTR)NULL, 0);
! 761: for (i=0; i<cFiles; i++) {
! 762: DragQueryFile(hdrop, i, szFile, 80);
! 763: for (p=lptw->DragPre; *p; p++)
! 764: SendMessage(lptw->hWndText,WM_CHAR,*p,1L);
! 765: for (p=szFile; *p; p++)
! 766: SendMessage(lptw->hWndText,WM_CHAR,*p,1L);
! 767: for (p=lptw->DragPost; *p; p++)
! 768: SendMessage(lptw->hWndText,WM_CHAR,*p,1L);
! 769: }
! 770: DragFinish(hdrop);
! 771: }
! 772: #endif
! 773:
! 774:
! 775: void
! 776: TextCopyClip(LPTW lptw)
! 777: {
! 778: int size, count;
! 779: HGLOBAL hGMem;
! 780: LPSTR cbuf, cp;
! 781: POINT pt, end;
! 782: TEXTMETRIC tm;
! 783: UINT type;
! 784: HDC hdc;
! 785:
! 786: if ((lptw->MarkBegin.x == lptw->MarkEnd.x) &&
! 787: (lptw->MarkBegin.y == lptw->MarkEnd.y) ) {
! 788: /* copy user text */
! 789: return;
! 790: }
! 791:
! 792: size = (lptw->MarkEnd.y - lptw->MarkBegin.y + 1)
! 793: * (lptw->ScreenSize.x + 2) + 1;
! 794: hGMem = GlobalAlloc(GMEM_MOVEABLE, (DWORD)size);
! 795: cbuf = cp = (LPSTR)GlobalLock(hGMem);
! 796: if (cp == (LPSTR)NULL)
! 797: return;
! 798:
! 799: pt.x = lptw->MarkBegin.x;
! 800: pt.y = lptw->MarkBegin.y;
! 801: end.x = lptw->MarkEnd.x;
! 802: end.y = lptw->MarkEnd.y;
! 803:
! 804: while (pt.y < end.y) {
! 805: /* copy to global buffer */
! 806: count = lptw->ScreenSize.x - pt.x;
! 807: _fmemcpy(cp, lptw->ScreenBuffer + lptw->ScreenSize.x*pt.y+pt.x, count);
! 808: /* remove trailing spaces */
! 809: for (count=count-1; count>=0; count--) {
! 810: if (cp[count]!=' ')
! 811: break;
! 812: cp[count] = '\0';
! 813: }
! 814: cp[++count] = '\r';
! 815: cp[++count] = '\n';
! 816: cp[++count] = '\0';
! 817: cp += count;
! 818: pt.y++;
! 819: pt.x=0;
! 820: }
! 821: /* partial line */
! 822: count = end.x - pt.x;
! 823: if (end.y != lptw->ScreenSize.y) {
! 824: _fmemcpy(cp, lptw->ScreenBuffer + lptw->ScreenSize.x*pt.y+pt.x, count);
! 825: cp[count] = '\0';
! 826: }
! 827: size = _fstrlen(cbuf) + 1;
! 828: GlobalUnlock(hGMem);
! 829: hGMem = GlobalReAlloc(hGMem, (DWORD)size, GMEM_MOVEABLE);
! 830: /* find out what type to put into clipboard */
! 831: hdc = GetDC(lptw->hWndText);
! 832: SelectObject(hdc, lptw->hfont);
! 833: GetTextMetrics(hdc,(TEXTMETRIC FAR *)&tm);
! 834: if (tm.tmCharSet == OEM_CHARSET)
! 835: type = CF_OEMTEXT;
! 836: else
! 837: type = CF_TEXT;
! 838: ReleaseDC(lptw->hWndText, hdc);
! 839: /* give buffer to clipboard */
! 840: OpenClipboard(lptw->hWndParent);
! 841: EmptyClipboard();
! 842: SetClipboardData(type, hGMem);
! 843: CloseClipboard();
! 844: }
! 845:
! 846: void
! 847: TextMakeFont(LPTW lptw)
! 848: {
! 849: LOGFONT lf;
! 850: TEXTMETRIC tm;
! 851: LPSTR p;
! 852: HDC hdc;
! 853:
! 854: hdc = GetDC(lptw->hWndText);
! 855: _fmemset(&lf, 0, sizeof(LOGFONT));
! 856: _fstrncpy(lf.lfFaceName,lptw->fontname,LF_FACESIZE);
! 857: lf.lfHeight = -MulDiv(lptw->fontsize, GetDeviceCaps(hdc, LOGPIXELSY), 72);
! 858: lf.lfPitchAndFamily = FIXED_PITCH;
! 859: lf.lfCharSet = DEFAULT_CHARSET;
! 860: if ( (p = _fstrstr(lptw->fontname," Italic")) != (LPSTR)NULL ) {
! 861: lf.lfFaceName[ (unsigned int)(p-lptw->fontname) ] = '\0';
! 862: lf.lfItalic = TRUE;
! 863: }
! 864: if ( (p = _fstrstr(lptw->fontname," Bold")) != (LPSTR)NULL ) {
! 865: lf.lfFaceName[ (unsigned int)(p-lptw->fontname) ] = '\0';
! 866: lf.lfWeight = FW_BOLD;
! 867: }
! 868: if (lptw->hfont != 0)
! 869: DeleteObject(lptw->hfont);
! 870: lptw->hfont = CreateFontIndirect((LOGFONT FAR *)&lf);
! 871: /* get text size */
! 872: SelectObject(hdc, lptw->hfont);
! 873: GetTextMetrics(hdc,(TEXTMETRIC FAR *)&tm);
! 874: lptw->CharSize.y = tm.tmHeight;
! 875: lptw->CharSize.x = tm.tmAveCharWidth;
! 876: lptw->CharAscent = tm.tmAscent;
! 877: if (lptw->bFocus)
! 878: CreateCaret(lptw->hWndText, 0, lptw->CharSize.x, 2+lptw->CaretHeight);
! 879: ReleaseDC(lptw->hWndText, hdc);
! 880: return;
! 881: }
! 882:
! 883: void
! 884: TextSelectFont(LPTW lptw) {
! 885: #if WINVER >= 0x030a
! 886: LOGFONT lf;
! 887: CHOOSEFONT cf;
! 888: HDC hdc;
! 889: char lpszStyle[LF_FACESIZE];
! 890: LPSTR p;
! 891:
! 892: /* Set all structure fields to zero. */
! 893: _fmemset(&cf, 0, sizeof(CHOOSEFONT));
! 894: _fmemset(&lf, 0, sizeof(LOGFONT));
! 895: cf.lStructSize = sizeof(CHOOSEFONT);
! 896: cf.hwndOwner = lptw->hWndParent;
! 897: _fstrncpy(lf.lfFaceName,lptw->fontname,LF_FACESIZE);
! 898: if ( (p = _fstrstr(lptw->fontname," Bold")) != (LPSTR)NULL ) {
! 899: _fstrncpy(lpszStyle,p+1,LF_FACESIZE);
! 900: lf.lfFaceName[ (unsigned int)(p-lptw->fontname) ] = '\0';
! 901: }
! 902: else if ( (p = _fstrstr(lptw->fontname," Italic")) != (LPSTR)NULL ) {
! 903: _fstrncpy(lpszStyle,p+1,LF_FACESIZE);
! 904: lf.lfFaceName[ (unsigned int)(p-lptw->fontname) ] = '\0';
! 905: }
! 906: else
! 907: _fstrcpy(lpszStyle,"Regular");
! 908: cf.lpszStyle = lpszStyle;
! 909: hdc = GetDC(lptw->hWndText);
! 910: lf.lfHeight = -MulDiv(lptw->fontsize, GetDeviceCaps(hdc, LOGPIXELSY), 72);
! 911: ReleaseDC(lptw->hWndText, hdc);
! 912: lf.lfPitchAndFamily = FIXED_PITCH;
! 913: cf.lpLogFont = &lf;
! 914: cf.nFontType = SCREEN_FONTTYPE;
! 915: cf.Flags = CF_SCREENFONTS | CF_FIXEDPITCHONLY | CF_INITTOLOGFONTSTRUCT | CF_USESTYLE;
! 916: if (ChooseFont(&cf)) {
! 917: RECT rect;
! 918: _fstrcpy(lptw->fontname,lf.lfFaceName);
! 919: lptw->fontsize = cf.iPointSize / 10;
! 920: if (cf.nFontType & BOLD_FONTTYPE)
! 921: lstrcat(lptw->fontname," Bold");
! 922: if (cf.nFontType & ITALIC_FONTTYPE)
! 923: lstrcat(lptw->fontname," Italic");
! 924: TextMakeFont(lptw);
! 925: /* force a window update */
! 926: GetClientRect(lptw->hWndText, (LPRECT) &rect);
! 927: SendMessage(lptw->hWndText, WM_SIZE, SIZE_RESTORED,
! 928: MAKELPARAM(rect.right-rect.left, rect.bottom-rect.top));
! 929: GetClientRect(lptw->hWndText, (LPRECT) &rect);
! 930: InvalidateRect(lptw->hWndText, (LPRECT) &rect, 1);
! 931: UpdateWindow(lptw->hWndText);
! 932: }
! 933: #endif
! 934: }
! 935:
! 936:
! 937: /* parent overlapped window */
! 938: LRESULT CALLBACK WINEXPORT
! 939: WndParentProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
! 940: {
! 941: HDC hdc;
! 942: PAINTSTRUCT ps;
! 943: RECT rect;
! 944: LPTW lptw;
! 945:
! 946: lptw = (LPTW)GetWindowLong(hwnd, 0);
! 947:
! 948: switch(message) {
! 949: case WM_SYSCOMMAND:
! 950: switch(LOWORD(wParam))
! 951: {
! 952: case M_COPY_CLIP:
! 953: case M_PASTE:
! 954: case M_CHOOSE_FONT:
! 955: case M_SYSCOLORS:
! 956: case M_WRITEINI:
! 957: case M_ABOUT:
! 958: SendMessage(lptw->hWndText, WM_COMMAND, wParam, lParam);
! 959: }
! 960: break;
! 961: case WM_SETFOCUS:
! 962: if (IsWindow(lptw->hWndText)) {
! 963: SetFocus(lptw->hWndText);
! 964: return(0);
! 965: }
! 966: break;
! 967: case WM_GETMINMAXINFO:
! 968: {
! 969: POINT FAR * MMinfo = (POINT FAR *)lParam;
! 970: TEXTMETRIC tm;
! 971: hdc = GetDC(hwnd);
! 972: SelectObject(hdc, GetStockObject(OEM_FIXED_FONT));
! 973: GetTextMetrics(hdc,(LPTEXTMETRIC)&tm);
! 974: ReleaseDC(hwnd,hdc);
! 975: /* minimum size */
! 976: MMinfo[3].x = ScreenMinSize.x*tm.tmAveCharWidth
! 977: + GetSystemMetrics(SM_CXVSCROLL) + 2*GetSystemMetrics(SM_CXFRAME);
! 978: MMinfo[3].y = ScreenMinSize.y*tm.tmHeight
! 979: + GetSystemMetrics(SM_CYHSCROLL) + 2*GetSystemMetrics(SM_CYFRAME)
! 980: + GetSystemMetrics(SM_CYCAPTION);
! 981: }
! 982: return(0);
! 983: case WM_SIZE:
! 984: SetWindowPos(lptw->hWndText, (HWND)NULL, 0, lptw->ButtonHeight,
! 985: LOWORD(lParam), HIWORD(lParam)-lptw->ButtonHeight,
! 986: SWP_NOZORDER | SWP_NOACTIVATE);
! 987: return(0);
! 988: case WM_COMMAND:
! 989: if (IsWindow(lptw->hWndText))
! 990: SetFocus(lptw->hWndText);
! 991: SendMessage(lptw->hWndText, message, wParam, lParam); /* pass on menu commands */
! 992: return(0);
! 993: case WM_PAINT:
! 994: {
! 995: hdc = BeginPaint(hwnd, &ps);
! 996: if (lptw->ButtonHeight) {
! 997: HBRUSH hbrush;
! 998: GetClientRect(hwnd, &rect);
! 999: hbrush = CreateSolidBrush(GetSysColor(COLOR_BTNSHADOW));
! 1000: rect.bottom = lptw->ButtonHeight-1;
! 1001: FillRect(hdc, &rect, hbrush);
! 1002: DeleteObject(hbrush);
! 1003: SelectObject(hdc, GetStockObject(BLACK_PEN));
! 1004: MoveTo(hdc, rect.left, lptw->ButtonHeight-1);
! 1005: LineTo(hdc, rect.right, lptw->ButtonHeight-1);
! 1006: }
! 1007: EndPaint(hwnd, &ps);
! 1008: return 0;
! 1009: }
! 1010: #if WINVER >= 0x030a
! 1011: case WM_DROPFILES:
! 1012: {
! 1013: WORD version = LOWORD(GetVersion());
! 1014: if ((LOBYTE(version)*100 + HIBYTE(version)) >= 310)
! 1015: DragFunc(lptw, (HDROP)wParam);
! 1016: }
! 1017: break;
! 1018: #endif
! 1019: case WM_CREATE:
! 1020: {
! 1021: RECT crect, wrect;
! 1022: TEXTMETRIC tm;
! 1023: lptw = ((CREATESTRUCT FAR *)lParam)->lpCreateParams;
! 1024: SetWindowLong(hwnd, 0, (LONG)lptw);
! 1025: lptw->hWndParent = hwnd;
! 1026: /* get character size */
! 1027: TextMakeFont(lptw);
! 1028: hdc = GetDC(hwnd);
! 1029: SelectObject(hdc, lptw->hfont);
! 1030: GetTextMetrics(hdc,(LPTEXTMETRIC)&tm);
! 1031: lptw->CharSize.y = tm.tmHeight;
! 1032: lptw->CharSize.x = tm.tmAveCharWidth;
! 1033: lptw->CharAscent = tm.tmAscent;
! 1034: ReleaseDC(hwnd,hdc);
! 1035: GetClientRect(hwnd, &crect);
! 1036: if ( lptw->CharSize.x*lptw->ScreenSize.x < crect.right ) {
! 1037: /* shrink x size */
! 1038: GetWindowRect(lptw->hWndParent,&wrect);
! 1039: MoveWindow(lptw->hWndParent, wrect.left, wrect.top,
! 1040: wrect.right-wrect.left + (lptw->CharSize.x*lptw->ScreenSize.x - crect.right),
! 1041: wrect.bottom-wrect.top,
! 1042: TRUE);
! 1043: }
! 1044: if ( lptw->CharSize.y*lptw->ScreenSize.y < crect.bottom ) {
! 1045: /* shrink y size */
! 1046: GetWindowRect(lptw->hWndParent,&wrect);
! 1047: MoveWindow(lptw->hWndParent, wrect.left, wrect.top,
! 1048: wrect.right-wrect.left,
! 1049: wrect.bottom-wrect.top + (lptw->CharSize.y*lptw->ScreenSize.y+lptw->ButtonHeight - crect.bottom),
! 1050: TRUE);
! 1051: }
! 1052: }
! 1053: #if WINVER >= 0x030a
! 1054: {
! 1055: WORD version = LOWORD(GetVersion());
! 1056: if ((LOBYTE(version)*100 + HIBYTE(version)) >= 310)
! 1057: if ( (lptw->DragPre!=(LPSTR)NULL) && (lptw->DragPost!=(LPSTR)NULL) )
! 1058: DragAcceptFiles(hwnd, TRUE);
! 1059: }
! 1060: #endif
! 1061: break;
! 1062: case WM_DESTROY:
! 1063: #if WINVER >= 0x030a
! 1064: {
! 1065: WORD version = LOWORD(GetVersion());
! 1066: if ((LOBYTE(version)*100 + HIBYTE(version)) >= 310)
! 1067: DragAcceptFiles(hwnd, FALSE);
! 1068: }
! 1069: #endif
! 1070: DeleteObject(lptw->hfont);
! 1071: lptw->hfont = 0;
! 1072: break;
! 1073: case WM_CLOSE:
! 1074: if (lptw->shutdown) {
! 1075: FARPROC lpShutDown = lptw->shutdown;
! 1076: (*lpShutDown)();
! 1077: }
! 1078: break;
! 1079: }
! 1080: return DefWindowProc(hwnd, message, wParam, lParam);
! 1081: }
! 1082:
! 1083: /* child text window */
! 1084: LRESULT CALLBACK WINEXPORT
! 1085: WndTextProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
! 1086: {
! 1087: HDC hdc;
! 1088: PAINTSTRUCT ps;
! 1089: RECT rect;
! 1090: int nYinc, nXinc;
! 1091: LPTW lptw;
! 1092:
! 1093: lptw = (LPTW)GetWindowLong(hwnd, 0);
! 1094:
! 1095: switch(message) {
! 1096: case WM_SETFOCUS:
! 1097: lptw->bFocus = TRUE;
! 1098: CreateCaret(hwnd, 0, lptw->CharSize.x, 2+lptw->CaretHeight);
! 1099: SetCaretPos(lptw->CursorPos.x*lptw->CharSize.x - lptw->ScrollPos.x,
! 1100: lptw->CursorPos.y*lptw->CharSize.y + lptw->CharAscent
! 1101: - lptw->CaretHeight - lptw->ScrollPos.y);
! 1102: if (lptw->bGetCh)
! 1103: ShowCaret(hwnd);
! 1104: break;
! 1105: case WM_KILLFOCUS:
! 1106: DestroyCaret();
! 1107: lptw->bFocus = FALSE;
! 1108: break;
! 1109: case WM_SIZE:
! 1110: lptw->ClientSize.y = HIWORD(lParam);
! 1111: lptw->ClientSize.x = LOWORD(lParam);
! 1112:
! 1113: lptw->ScrollMax.y = max(0, lptw->CharSize.y*lptw->ScreenSize.y - lptw->ClientSize.y);
! 1114: lptw->ScrollPos.y = min(lptw->ScrollPos.y, lptw->ScrollMax.y);
! 1115:
! 1116: SetScrollRange(hwnd, SB_VERT, 0, lptw->ScrollMax.y, FALSE);
! 1117: SetScrollPos(hwnd, SB_VERT, lptw->ScrollPos.y, TRUE);
! 1118:
! 1119: lptw->ScrollMax.x = max(0, lptw->CharSize.x*lptw->ScreenSize.x - lptw->ClientSize.x);
! 1120: lptw->ScrollPos.x = min(lptw->ScrollPos.x, lptw->ScrollMax.x);
! 1121:
! 1122: SetScrollRange(hwnd, SB_HORZ, 0, lptw->ScrollMax.x, FALSE);
! 1123: SetScrollPos(hwnd, SB_HORZ, lptw->ScrollPos.x, TRUE);
! 1124:
! 1125: if (lptw->bFocus && lptw->bGetCh) {
! 1126: SetCaretPos(lptw->CursorPos.x*lptw->CharSize.x - lptw->ScrollPos.x,
! 1127: lptw->CursorPos.y*lptw->CharSize.y + lptw->CharAscent
! 1128: - lptw->CaretHeight - lptw->ScrollPos.y);
! 1129: ShowCaret(hwnd);
! 1130: }
! 1131: return(0);
! 1132: case WM_VSCROLL:
! 1133: switch(LOWORD(wParam)) {
! 1134: case SB_TOP:
! 1135: nYinc = -lptw->ScrollPos.y;
! 1136: break;
! 1137: case SB_BOTTOM:
! 1138: nYinc = lptw->ScrollMax.y - lptw->ScrollPos.y;
! 1139: break;
! 1140: case SB_LINEUP:
! 1141: nYinc = -lptw->CharSize.y;
! 1142: break;
! 1143: case SB_LINEDOWN:
! 1144: nYinc = lptw->CharSize.y;
! 1145: break;
! 1146: case SB_PAGEUP:
! 1147: nYinc = min(-1,-lptw->ClientSize.y);
! 1148: break;
! 1149: case SB_PAGEDOWN:
! 1150: nYinc = max(1,lptw->ClientSize.y);
! 1151: break;
! 1152: case SB_THUMBPOSITION:
! 1153: nYinc = LOWORD(lParam) - lptw->ScrollPos.y;
! 1154: break;
! 1155: default:
! 1156: nYinc = 0;
! 1157: }
! 1158: if ( (nYinc = max(-lptw->ScrollPos.y,
! 1159: min(nYinc, lptw->ScrollMax.y - lptw->ScrollPos.y)))
! 1160: != 0 ) {
! 1161: lptw->ScrollPos.y += nYinc;
! 1162: ScrollWindow(hwnd,0,-nYinc,NULL,NULL);
! 1163: SetScrollPos(hwnd,SB_VERT,lptw->ScrollPos.y,TRUE);
! 1164: UpdateWindow(hwnd);
! 1165: }
! 1166: return(0);
! 1167: case WM_HSCROLL:
! 1168: switch(LOWORD(wParam)) {
! 1169: case SB_LINEUP:
! 1170: nXinc = -lptw->CharSize.x;
! 1171: break;
! 1172: case SB_LINEDOWN:
! 1173: nXinc = lptw->CharSize.x;
! 1174: break;
! 1175: case SB_PAGEUP:
! 1176: nXinc = min(-1,-lptw->ClientSize.x);
! 1177: break;
! 1178: case SB_PAGEDOWN:
! 1179: nXinc = max(1,lptw->ClientSize.x);
! 1180: break;
! 1181: case SB_THUMBPOSITION:
! 1182: nXinc = LOWORD(lParam) - lptw->ScrollPos.x;
! 1183: break;
! 1184: default:
! 1185: nXinc = 0;
! 1186: }
! 1187: if ( (nXinc = max(-lptw->ScrollPos.x,
! 1188: min(nXinc, lptw->ScrollMax.x - lptw->ScrollPos.x)))
! 1189: != 0 ) {
! 1190: lptw->ScrollPos.x += nXinc;
! 1191: ScrollWindow(hwnd,-nXinc,0,NULL,NULL);
! 1192: SetScrollPos(hwnd,SB_HORZ,lptw->ScrollPos.x,TRUE);
! 1193: UpdateWindow(hwnd);
! 1194: }
! 1195: return(0);
! 1196: case WM_KEYDOWN:
! 1197: if (GetKeyState(VK_SHIFT) < 0) {
! 1198: switch(wParam) {
! 1199: case VK_HOME:
! 1200: SendMessage(hwnd, WM_VSCROLL, SB_TOP, (LPARAM)0);
! 1201: break;
! 1202: case VK_END:
! 1203: SendMessage(hwnd, WM_VSCROLL, SB_BOTTOM, (LPARAM)0);
! 1204: break;
! 1205: case VK_PRIOR:
! 1206: SendMessage(hwnd, WM_VSCROLL, SB_PAGEUP, (LPARAM)0);
! 1207: break;
! 1208: case VK_NEXT:
! 1209: SendMessage(hwnd, WM_VSCROLL, SB_PAGEDOWN, (LPARAM)0);
! 1210: break;
! 1211: case VK_UP:
! 1212: SendMessage(hwnd, WM_VSCROLL, SB_LINEUP, (LPARAM)0);
! 1213: break;
! 1214: case VK_DOWN:
! 1215: SendMessage(hwnd, WM_VSCROLL, SB_LINEDOWN, (LPARAM)0);
! 1216: break;
! 1217: case VK_LEFT:
! 1218: SendMessage(hwnd, WM_HSCROLL, SB_LINEUP, (LPARAM)0);
! 1219: break;
! 1220: case VK_RIGHT:
! 1221: SendMessage(hwnd, WM_HSCROLL, SB_LINEDOWN, (LPARAM)0);
! 1222: break;
! 1223: }
! 1224: }
! 1225: else {
! 1226: switch(wParam) {
! 1227: case VK_HOME:
! 1228: case VK_END:
! 1229: case VK_PRIOR:
! 1230: case VK_NEXT:
! 1231: case VK_UP:
! 1232: case VK_DOWN:
! 1233: case VK_LEFT:
! 1234: case VK_RIGHT:
! 1235: case VK_DELETE:
! 1236: { /* store key in circular buffer */
! 1237: long count;
! 1238: count = lptw->KeyBufIn - lptw->KeyBufOut;
! 1239: if (count < 0) count += lptw->KeyBufSize;
! 1240: if (count < lptw->KeyBufSize-2) {
! 1241: *lptw->KeyBufIn++ = 0;
! 1242: if (lptw->KeyBufIn - lptw->KeyBuf >= lptw->KeyBufSize)
! 1243: lptw->KeyBufIn = lptw->KeyBuf; /* wrap around */
! 1244: *lptw->KeyBufIn++ = HIWORD(lParam) & 0xff;
! 1245: if (lptw->KeyBufIn - lptw->KeyBuf >= lptw->KeyBufSize)
! 1246: lptw->KeyBufIn = lptw->KeyBuf; /* wrap around */
! 1247: }
! 1248: }
! 1249: }
! 1250: }
! 1251: break;
! 1252: case WM_RBUTTONDOWN:
! 1253: {
! 1254: POINT pt;
! 1255: pt.x = LOWORD(lParam);
! 1256: pt.y = HIWORD(lParam);
! 1257: ClientToScreen(hwnd,&pt);
! 1258: TrackPopupMenu(lptw->hPopMenu, TPM_LEFTALIGN,
! 1259: pt.x, pt.y, 0, hwnd, NULL);
! 1260: }
! 1261: return(0);
! 1262: case WM_LBUTTONDOWN:
! 1263: { /* start marking text */
! 1264: POINT pt;
! 1265: pt.x = LOWORD(lParam);
! 1266: pt.y = HIWORD(lParam);
! 1267: pt.x = (pt.x + lptw->ScrollPos.x)/lptw->CharSize.x;
! 1268: pt.y = (pt.y + lptw->ScrollPos.y)/lptw->CharSize.y;
! 1269: ClearMark(lptw, pt);
! 1270: }
! 1271: SetCapture(hwnd); /* track the mouse */
! 1272: lptw->Marking = TRUE;
! 1273: break;
! 1274: case WM_LBUTTONUP:
! 1275: { /* finish marking text */
! 1276: /* ensure begin mark is before end mark */
! 1277: ReleaseCapture();
! 1278: lptw->Marking = FALSE;
! 1279: if ((lptw->ScreenSize.x*lptw->MarkBegin.y + lptw->MarkBegin.x) >
! 1280: (lptw->ScreenSize.x*lptw->MarkEnd.y + lptw->MarkEnd.x)) {
! 1281: POINT tmp;
! 1282: tmp.x = lptw->MarkBegin.x;
! 1283: tmp.y = lptw->MarkBegin.y;
! 1284: lptw->MarkBegin.x = lptw->MarkEnd.x;
! 1285: lptw->MarkBegin.y = lptw->MarkEnd.y;
! 1286: lptw->MarkEnd.x = tmp.x;
! 1287: lptw->MarkEnd.y = tmp.y;
! 1288: }
! 1289: }
! 1290: break;
! 1291: case WM_MOUSEMOVE:
! 1292: if ( (wParam & MK_LBUTTON) && lptw->Marking ) {
! 1293: RECT rect;
! 1294: POINT pt;
! 1295: pt.x = LOWORD(lParam);
! 1296: pt.y = HIWORD(lParam);
! 1297: GetClientRect(hwnd, &rect);
! 1298: if (PtInRect(&rect, pt)) {
! 1299: pt.x = (pt.x + lptw->ScrollPos.x)/lptw->CharSize.x;
! 1300: pt.y = (pt.y + lptw->ScrollPos.y)/lptw->CharSize.y;
! 1301: UpdateMark(lptw, pt);
! 1302: }
! 1303: else {
! 1304: int nXinc;
! 1305: int nYinc;
! 1306: do {
! 1307: nXinc = 0;
! 1308: nYinc = 0;
! 1309: if (pt.x > rect.right) {
! 1310: nXinc = lptw->CharSize.x * 4;
! 1311: pt.x = (rect.right + lptw->ScrollPos.x)/lptw->CharSize.x + 2;
! 1312: }
! 1313: else if (pt.x < rect.left) {
! 1314: nXinc = -lptw->CharSize.x * 4;
! 1315: pt.x = (rect.left + lptw->ScrollPos.x)/lptw->CharSize.x - 2;
! 1316: }
! 1317: else
! 1318: pt.x = (pt.x + lptw->ScrollPos.x)/lptw->CharSize.x;
! 1319: if (pt.y > rect.bottom) {
! 1320: nYinc = lptw->CharSize.y;
! 1321: pt.y = (rect.bottom + lptw->ScrollPos.y)/lptw->CharSize.y + 1;
! 1322: }
! 1323: else if (pt.y < rect.top) {
! 1324: nYinc = -lptw->CharSize.y;
! 1325: pt.y = (rect.top + lptw->ScrollPos.y)/lptw->CharSize.y - 1;
! 1326: }
! 1327: else
! 1328: pt.y = (pt.y + lptw->ScrollPos.y)/lptw->CharSize.y;
! 1329: LimitMark(lptw, &pt);
! 1330: nXinc = max(nXinc, -lptw->ScrollPos.x);
! 1331: nYinc = max(nYinc, -lptw->ScrollPos.y);
! 1332: nYinc = min(nYinc, lptw->ScrollMax.y - lptw->ScrollPos.y);
! 1333: nXinc = min(nXinc, lptw->ScrollMax.x - lptw->ScrollPos.x);
! 1334: if (nYinc || nXinc) {
! 1335: lptw->ScrollPos.y += nYinc;
! 1336: lptw->ScrollPos.x += nXinc;
! 1337: ScrollWindow(lptw->hWndText,-nXinc,-nYinc,NULL,NULL);
! 1338: SetScrollPos(lptw->hWndText,SB_VERT,lptw->ScrollPos.y,TRUE);
! 1339: SetScrollPos(lptw->hWndText,SB_HORZ,lptw->ScrollPos.x,TRUE);
! 1340: UpdateWindow(lptw->hWndText);
! 1341: }
! 1342: UpdateMark(lptw, pt);
! 1343: GetCursorPos(&pt);
! 1344: ScreenToClient(hwnd, &pt);
! 1345: }
! 1346: while( (nYinc || nXinc) && !PtInRect(&rect, pt) &&
! 1347: (GetAsyncKeyState(VK_LBUTTON) < 0) );
! 1348: }
! 1349: }
! 1350: break;
! 1351: case WM_CHAR:
! 1352: { /* store key in circular buffer */
! 1353: long count;
! 1354: count = lptw->KeyBufIn - lptw->KeyBufOut;
! 1355: if (count < 0) count += lptw->KeyBufSize;
! 1356: if (count < lptw->KeyBufSize-1) {
! 1357: *lptw->KeyBufIn++ = wParam;
! 1358: if (lptw->KeyBufIn - lptw->KeyBuf >= lptw->KeyBufSize)
! 1359: lptw->KeyBufIn = lptw->KeyBuf; /* wrap around */
! 1360: }
! 1361: }
! 1362: return(0);
! 1363: case WM_COMMAND:
! 1364: if (LOWORD(wParam) < NUMMENU)
! 1365: SendMacro(lptw, LOWORD(wParam));
! 1366: else
! 1367: switch(LOWORD(wParam))
! 1368: {
! 1369: case M_COPY_CLIP:
! 1370: TextCopyClip(lptw);
! 1371: return 0;
! 1372: case M_PASTE:
! 1373: {
! 1374: HGLOBAL hGMem;
! 1375: BYTE FAR *cbuf;
! 1376: TEXTMETRIC tm;
! 1377: UINT type;
! 1378: /* find out what type to get from clipboard */
! 1379: hdc = GetDC(hwnd);
! 1380: SelectObject(hdc, lptw->hfont);
! 1381: GetTextMetrics(hdc,(TEXTMETRIC FAR *)&tm);
! 1382: if (tm.tmCharSet == OEM_CHARSET)
! 1383: type = CF_OEMTEXT;
! 1384: else
! 1385: type = CF_TEXT;
! 1386: ReleaseDC(lptw->hWndText, hdc);
! 1387: /* now get it from clipboard */
! 1388: OpenClipboard(hwnd);
! 1389: hGMem = GetClipboardData(type);
! 1390: if (hGMem) {
! 1391: cbuf = (BYTE FAR *) GlobalLock(hGMem);
! 1392: while (*cbuf) {
! 1393: if (*cbuf != '\n')
! 1394: SendMessage(lptw->hWndText,WM_CHAR,*cbuf,1L);
! 1395: cbuf++;
! 1396: }
! 1397: GlobalUnlock(hGMem);
! 1398: }
! 1399: CloseClipboard();
! 1400: return 0;
! 1401: }
! 1402: case M_CHOOSE_FONT:
! 1403: TextSelectFont(lptw);
! 1404: return 0;
! 1405: case M_SYSCOLORS:
! 1406: lptw->bSysColors = !lptw->bSysColors;
! 1407: if (lptw->bSysColors)
! 1408: CheckMenuItem(lptw->hPopMenu, M_SYSCOLORS, MF_BYCOMMAND | MF_CHECKED);
! 1409: else
! 1410: CheckMenuItem(lptw->hPopMenu, M_SYSCOLORS, MF_BYCOMMAND | MF_UNCHECKED);
! 1411: SendMessage(hwnd, WM_SYSCOLORCHANGE, (WPARAM)0, (LPARAM)0);
! 1412: InvalidateRect(hwnd, (LPRECT)NULL, 1);
! 1413: UpdateWindow(hwnd);
! 1414: return 0;
! 1415: case M_WRITEINI:
! 1416: WriteTextIni(lptw);
! 1417: return 0;
! 1418: case M_ABOUT:
! 1419: AboutBox(hwnd,lptw->AboutText);
! 1420: return 0;
! 1421: }
! 1422: return(0);
! 1423: case WM_SYSCOLORCHANGE:
! 1424: DeleteObject(lptw->hbrBackground);
! 1425: lptw->hbrBackground = CreateSolidBrush(lptw->bSysColors ?
! 1426: GetSysColor(COLOR_WINDOW) : RGB(0,0,0));
! 1427: return(0);
! 1428: case WM_ERASEBKGND:
! 1429: return(1); /* we will erase it ourselves */
! 1430: case WM_PAINT:
! 1431: {
! 1432: POINT source, width, dest;
! 1433: POINT MarkBegin, MarkEnd;
! 1434: hdc = BeginPaint(hwnd, &ps);
! 1435: if (ps.fErase)
! 1436: FillRect(hdc, &ps.rcPaint, lptw->hbrBackground);
! 1437: SelectObject(hdc, lptw->hfont);
! 1438: SetMapMode(hdc, MM_TEXT);
! 1439: SetBkMode(hdc,OPAQUE);
! 1440: GetClientRect(hwnd, &rect);
! 1441: source.x = (rect.left + lptw->ScrollPos.x) / lptw->CharSize.x; /* source */
! 1442: source.y = (rect.top + lptw->ScrollPos.y) / lptw->CharSize.y;
! 1443: dest.x = source.x * lptw->CharSize.x - lptw->ScrollPos.x; /* destination */
! 1444: dest.y = source.y * lptw->CharSize.y - lptw->ScrollPos.y;
! 1445: width.x = ((rect.right + lptw->ScrollPos.x + lptw->CharSize.x - 1) / lptw->CharSize.x) - source.x; /* width */
! 1446: width.y = ((rect.bottom + lptw->ScrollPos.y + lptw->CharSize.y - 1) / lptw->CharSize.y) - source.y;
! 1447: if (source.x < 0)
! 1448: source.x = 0;
! 1449: if (source.y < 0)
! 1450: source.y = 0;
! 1451: if (source.x+width.x > lptw->ScreenSize.x)
! 1452: width.x = lptw->ScreenSize.x - source.x;
! 1453: if (source.y+width.y > lptw->ScreenSize.y)
! 1454: width.y = lptw->ScreenSize.y - source.y;
! 1455: /* ensure begin mark is before end mark */
! 1456: if ((lptw->ScreenSize.x*lptw->MarkBegin.y + lptw->MarkBegin.x) >
! 1457: (lptw->ScreenSize.x*lptw->MarkEnd.y + lptw->MarkEnd.x)) {
! 1458: MarkBegin.x = lptw->MarkEnd.x;
! 1459: MarkBegin.y = lptw->MarkEnd.y;
! 1460: MarkEnd.x = lptw->MarkBegin.x;
! 1461: MarkEnd.y = lptw->MarkBegin.y;
! 1462: }
! 1463: else {
! 1464: MarkBegin.x = lptw->MarkBegin.x;
! 1465: MarkBegin.y = lptw->MarkBegin.y;
! 1466: MarkEnd.x = lptw->MarkEnd.x;
! 1467: MarkEnd.y = lptw->MarkEnd.y;
! 1468: }
! 1469: /* for each line */
! 1470: while (width.y>0) {
! 1471: if ( (source.y >= MarkBegin.y) && (source.y <= MarkEnd.y) ) {
! 1472: int start, end;
! 1473: int count, offset;
! 1474: if (source.y == MarkBegin.y)
! 1475: start = MarkBegin.x;
! 1476: else
! 1477: start = 0;
! 1478: if (source.y == MarkEnd.y)
! 1479: end = MarkEnd.x;
! 1480: else
! 1481: end = lptw->ScreenSize.x;
! 1482: /* do stuff before marked text */
! 1483: offset = 0;
! 1484: count = start - source.x;
! 1485: if (count > 0)
! 1486: DoLine(lptw, hdc, dest.x, dest.y,
! 1487: source.y*lptw->ScreenSize.x + source.x, count);
! 1488: /* then the marked text */
! 1489: offset += count;
! 1490: count = end - start;
! 1491: if ((count > 0) && (offset < width.x)){
! 1492: if (lptw->bSysColors) {
! 1493: SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
! 1494: SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
! 1495: }
! 1496: else {
! 1497: SetTextColor(hdc, MARKFORE);
! 1498: SetBkColor(hdc, MARKBACK);
! 1499: }
! 1500: TextOut(hdc, dest.x + lptw->CharSize.x*offset, dest.y,
! 1501: (LPSTR)(lptw->ScreenBuffer + source.y*lptw->ScreenSize.x
! 1502: + source.x + offset), count);
! 1503: }
! 1504: /* then stuff after marked text */
! 1505: offset += count;
! 1506: count = width.x + source.x - end;
! 1507: if ((count > 0) && (offset < width.x))
! 1508: DoLine(lptw, hdc, dest.x + lptw->CharSize.x*offset, dest.y,
! 1509: source.y*lptw->ScreenSize.x + source.x + offset, count);
! 1510: }
! 1511: else {
! 1512: DoLine(lptw, hdc, dest.x, dest.y,
! 1513: source.y*lptw->ScreenSize.x + source.x, width.x);
! 1514: }
! 1515: dest.y += lptw->CharSize.y;
! 1516: source.y++;
! 1517: width.y--;
! 1518: }
! 1519: EndPaint(hwnd, &ps);
! 1520: return 0;
! 1521: }
! 1522: case WM_CREATE:
! 1523: lptw = ((CREATESTRUCT FAR *)lParam)->lpCreateParams;
! 1524: SetWindowLong(hwnd, 0, (LONG)lptw);
! 1525: lptw->hWndText = hwnd;
! 1526: break;
! 1527: case WM_DESTROY:
! 1528: DeleteObject(lptw->hbrBackground);
! 1529: break;
! 1530: }
! 1531: return DefWindowProc(hwnd, message, wParam, lParam);
! 1532: }
! 1533:
! 1534:
! 1535: /* ================================== */
! 1536: /* replacement stdio routines */
! 1537:
! 1538: /* TRUE if key hit, FALSE if no key */
! 1539: int WDPROC
! 1540: TextKBHit(LPTW lptw)
! 1541: {
! 1542: return (lptw->KeyBufIn != lptw->KeyBufOut);
! 1543: }
! 1544:
! 1545: /* get character from keyboard, no echo */
! 1546: /* need to add extended codes */
! 1547: int WDPROC
! 1548: TextGetCh(LPTW lptw)
! 1549: {
! 1550: int ch;
! 1551: TextToCursor(lptw);
! 1552: lptw->bGetCh = TRUE;
! 1553: if (lptw->bFocus) {
! 1554: SetCaretPos(lptw->CursorPos.x*lptw->CharSize.x - lptw->ScrollPos.x,
! 1555: lptw->CursorPos.y*lptw->CharSize.y + lptw->CharAscent
! 1556: - lptw->CaretHeight - lptw->ScrollPos.y);
! 1557: ShowCaret(lptw->hWndText);
! 1558: }
! 1559: while (!TextKBHit(lptw)) { /* CMW: can't use TextMessage here as it does not idle properly */
! 1560: MSG msg;
! 1561: GetMessage(&msg, 0, 0, 0);
! 1562: TranslateMessage(&msg);
! 1563: DispatchMessage(&msg);
! 1564: }
! 1565: ch = *lptw->KeyBufOut++;
! 1566: if (ch=='\r')
! 1567: ch = '\n';
! 1568: if (lptw->KeyBufOut - lptw->KeyBuf >= lptw->KeyBufSize)
! 1569: lptw->KeyBufOut = lptw->KeyBuf; /* wrap around */
! 1570: if (lptw->bFocus)
! 1571: HideCaret(lptw->hWndText);
! 1572: lptw->bGetCh = FALSE;
! 1573: return ch;
! 1574: }
! 1575:
! 1576: /* get character from keyboard, with echo */
! 1577: int WDPROC
! 1578: TextGetChE(LPTW lptw)
! 1579: {
! 1580: int ch;
! 1581: ch = TextGetCh(lptw);
! 1582: TextPutCh(lptw, (BYTE)ch);
! 1583: return ch;
! 1584: }
! 1585:
! 1586: LPSTR WDPROC
! 1587: TextGetS(LPTW lptw, LPSTR str, unsigned int size)
! 1588: {
! 1589: LPSTR next = str;
! 1590: while (--size>0) {
! 1591: switch(*next = TextGetChE(lptw)) {
! 1592: case EOF:
! 1593: *next = 0;
! 1594: if (next == str) return (char *)NULL;
! 1595: return str;
! 1596: case '\n':
! 1597: *(next+1) = 0;
! 1598: return str;
! 1599: case 0x08:
! 1600: case 0x7f:
! 1601: if (next > str)
! 1602: --next;
! 1603: break;
! 1604: default:
! 1605: ++next;
! 1606: }
! 1607: }
! 1608: *next = 0;
! 1609: return str;
! 1610: }
! 1611:
! 1612: int WDPROC
! 1613: TextPutS(LPTW lptw, LPSTR str)
! 1614: {
! 1615: TextPutStr(lptw, str);
! 1616: return str[_fstrlen(str)-1];
! 1617: }
! 1618:
! 1619: /* ================================== */
! 1620: /* routines added for elvis */
! 1621:
! 1622: void WDPROC
! 1623: TextGotoXY(LPTW lptw, int x, int y)
! 1624: {
! 1625: lptw->CursorPos.x = x;
! 1626: lptw->CursorPos.y = y;
! 1627: }
! 1628:
! 1629: int WDPROC
! 1630: TextWhereX(LPTW lptw)
! 1631: {
! 1632: return lptw->CursorPos.x;
! 1633: }
! 1634:
! 1635: int WDPROC
! 1636: TextWhereY(LPTW lptw)
! 1637: {
! 1638: return lptw->CursorPos.y;
! 1639: }
! 1640:
! 1641: void WDPROC
! 1642: TextCursorHeight(LPTW lptw, int height)
! 1643: {
! 1644: lptw->CaretHeight = height;
! 1645: if (lptw->bFocus)
! 1646: CreateCaret(lptw->hWndText, 0, lptw->CharSize.x, 2+lptw->CaretHeight);
! 1647: }
! 1648:
! 1649: void WDPROC
! 1650: TextClearEOL(LPTW lptw)
! 1651: {
! 1652: HDC hdc;
! 1653: int xpos, ypos;
! 1654: int from, len;
! 1655: POINT pt;
! 1656: pt.x = pt.y = 0;
! 1657: ClearMark(lptw, pt);
! 1658: from = lptw->CursorPos.y*lptw->ScreenSize.x + lptw->CursorPos.x;
! 1659: len = lptw->ScreenSize.x-lptw->CursorPos.x;
! 1660: _fmemset(lptw->ScreenBuffer + from, ' ', len);
! 1661: _fmemset(lptw->AttrBuffer + from, NOTEXT, len);
! 1662: xpos = lptw->CursorPos.x*lptw->CharSize.x - lptw->ScrollPos.x;
! 1663: ypos = lptw->CursorPos.y*lptw->CharSize.y - lptw->ScrollPos.y;
! 1664: hdc = GetDC(lptw->hWndText);
! 1665: if (lptw->bSysColors) {
! 1666: SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT));
! 1667: SetBkColor(hdc, GetSysColor(COLOR_WINDOW));
! 1668: }
! 1669: else {
! 1670: SetTextColor(hdc, TextFore(lptw->Attr));
! 1671: SetBkColor(hdc, TextBack(lptw->Attr));
! 1672: }
! 1673: SelectObject(hdc, (lptw->hfont));
! 1674: TextOut(hdc,xpos,ypos,
! 1675: (LPSTR)(lptw->ScreenBuffer + lptw->CursorPos.y*lptw->ScreenSize.x +
! 1676: lptw->CursorPos.x), lptw->ScreenSize.x-lptw->CursorPos.x);
! 1677: (void)ReleaseDC(lptw->hWndText,hdc);
! 1678: }
! 1679:
! 1680: void WDPROC
! 1681: TextClearEOS(LPTW lptw)
! 1682: {
! 1683: RECT rect;
! 1684: int from, len;
! 1685: POINT pt;
! 1686: pt.x = pt.y = 0;
! 1687: ClearMark(lptw, pt);
! 1688: from = lptw->CursorPos.y*lptw->ScreenSize.x + lptw->CursorPos.x;
! 1689: len = lptw->ScreenSize.x-lptw->CursorPos.x +
! 1690: (lptw->ScreenSize.y-lptw->CursorPos.y-1)*lptw->ScreenSize.x;
! 1691: _fmemset(lptw->ScreenBuffer + from, ' ', len);
! 1692: _fmemset(lptw->AttrBuffer + from, NOTEXT, len);
! 1693: GetClientRect(lptw->hWndText, (LPRECT) &rect);
! 1694: InvalidateRect(lptw->hWndText, (LPRECT) &rect, 1);
! 1695: UpdateWindow(lptw->hWndText);
! 1696: }
! 1697:
! 1698: void WDPROC
! 1699: TextInsertLine(LPTW lptw)
! 1700: {
! 1701: RECT rect;
! 1702: int from, to, len;
! 1703: POINT pt;
! 1704: pt.x = pt.y = 0;
! 1705: ClearMark(lptw, pt);
! 1706: from = lptw->CursorPos.y*lptw->ScreenSize.x,
! 1707: to = (lptw->CursorPos.y+1)*lptw->ScreenSize.x;
! 1708: len = (lptw->ScreenSize.y-lptw->CursorPos.y-1)*lptw->ScreenSize.x;
! 1709: _fmemmove(lptw->ScreenBuffer + to, lptw->ScreenBuffer + from, len);
! 1710: _fmemmove(lptw->AttrBuffer + to, lptw->AttrBuffer + from, len);
! 1711: _fmemset(lptw->ScreenBuffer + from, ' ', lptw->ScreenSize.x);
! 1712: _fmemset(lptw->AttrBuffer + from, NOTEXT, lptw->ScreenSize.x);
! 1713: GetClientRect(lptw->hWndText, (LPRECT) &rect);
! 1714: InvalidateRect(lptw->hWndText, (LPRECT) &rect, 1);
! 1715: UpdateWindow(lptw->hWndText);
! 1716: if (lptw->CursorFlag)
! 1717: TextToCursor(lptw);
! 1718: }
! 1719:
! 1720: void WDPROC
! 1721: TextDeleteLine(LPTW lptw)
! 1722: {
! 1723: RECT rect;
! 1724: int from, to, len;
! 1725: POINT pt;
! 1726: pt.x = pt.y = 0;
! 1727: ClearMark(lptw, pt);
! 1728: to = lptw->CursorPos.y*lptw->ScreenSize.x,
! 1729: from = (lptw->CursorPos.y+1)*lptw->ScreenSize.x;
! 1730: len = (lptw->ScreenSize.y-lptw->CursorPos.y-1)*lptw->ScreenSize.x;
! 1731: _fmemmove(lptw->ScreenBuffer + to, lptw->ScreenBuffer + from, len);
! 1732: _fmemmove(lptw->AttrBuffer + to, lptw->AttrBuffer + from, len);
! 1733: from = lptw->ScreenSize.x*(lptw->ScreenSize.y -1);
! 1734: _fmemset(lptw->ScreenBuffer + from, ' ', lptw->ScreenSize.x);
! 1735: _fmemset(lptw->AttrBuffer + from, NOTEXT, lptw->ScreenSize.x);
! 1736: GetClientRect(lptw->hWndText, (LPRECT) &rect);
! 1737: InvalidateRect(lptw->hWndText, (LPRECT) &rect, 1);
! 1738: UpdateWindow(lptw->hWndText);
! 1739: if (lptw->CursorFlag)
! 1740: TextToCursor(lptw);
! 1741: }
! 1742:
! 1743: void WDPROC
! 1744: TextScrollReverse(LPTW lptw)
! 1745: {
! 1746: RECT rect;
! 1747: int len = lptw->ScreenSize.x * (lptw->ScreenSize.y - 1);
! 1748: _fmemmove(lptw->ScreenBuffer+lptw->ScreenSize.x, lptw->ScreenBuffer, len);
! 1749: _fmemset(lptw->ScreenBuffer, ' ', lptw->ScreenSize.x);
! 1750: _fmemmove(lptw->AttrBuffer+lptw->ScreenSize.x, lptw->AttrBuffer, len);
! 1751: _fmemset(lptw->AttrBuffer, NOTEXT, lptw->ScreenSize.x);
! 1752: if (lptw->CursorPos.y)
! 1753: lptw->CursorPos.y--;
! 1754: ScrollWindow(lptw->hWndText,0,+lptw->CharSize.y,NULL,NULL);
! 1755: GetClientRect(lptw->hWndText, (LPRECT) &rect);
! 1756: rect.top = lptw->ScreenSize.y*lptw->CharSize.y;
! 1757: if (rect.top < rect.bottom)
! 1758: InvalidateRect(lptw->hWndText, (LPRECT) &rect, 1);
! 1759: lptw->MarkBegin.y++;
! 1760: lptw->MarkEnd.y++;
! 1761: LimitMark(lptw, &lptw->MarkBegin);
! 1762: LimitMark(lptw, &lptw->MarkEnd);
! 1763: UpdateWindow(lptw->hWndText);
! 1764: }
! 1765:
! 1766: void WDPROC
! 1767: TextAttr(LPTW lptw, BYTE attr)
! 1768: {
! 1769: lptw->Attr = attr;
! 1770: }
! 1771:
! 1772: /* About Box */
! 1773: BOOL CALLBACK WINEXPORT
! 1774: AboutDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
! 1775: {
! 1776: switch (wMsg) {
! 1777: case WM_INITDIALOG:
! 1778: {
! 1779: char buf[80];
! 1780: GetWindowText(GetParent(hDlg),buf,80);
! 1781: SetDlgItemText(hDlg, AB_TEXT1, buf);
! 1782: SetDlgItemText(hDlg, AB_TEXT2, (LPSTR)lParam);
! 1783: #ifdef __DLL__
! 1784: wsprintf(buf,"WGNUPLOT.DLL Version %s",(LPSTR)WGNUPLOTVERSION);
! 1785: SetDlgItemText(hDlg, AB_TEXT3, buf);
! 1786: #endif
! 1787: }
! 1788: return TRUE;
! 1789: case WM_DRAWITEM:
! 1790: {
! 1791: LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT)lParam;
! 1792: #ifdef WIN32
! 1793: DrawIcon(lpdis->hDC, 0, 0, (HICON)GetClassLong(GetParent(hDlg), GCL_HICON));
! 1794: #else
! 1795: DrawIcon(lpdis->hDC, 0, 0, (HICON)GetClassWord(GetParent(hDlg), GCW_HICON));
! 1796: #endif
! 1797: }
! 1798: return FALSE;
! 1799: case WM_COMMAND:
! 1800: switch (LOWORD(wParam)) {
! 1801: case IDCANCEL:
! 1802: case IDOK:
! 1803: EndDialog(hDlg, LOWORD(wParam));
! 1804: return TRUE;
! 1805: }
! 1806: break;
! 1807: }
! 1808: return FALSE;
! 1809: }
! 1810:
! 1811:
! 1812: void WDPROC
! 1813: AboutBox(HWND hwnd, LPSTR str)
! 1814: {
! 1815: #ifdef WIN32
! 1816: DialogBoxParam(hdllInstance,"AboutDlgBox",hwnd,AboutDlgProc,(LPARAM)str);
! 1817: #else
! 1818: DLGPROC lpfnAboutDlgProc;
! 1819: #ifdef __DLL__
! 1820: lpfnAboutDlgProc = (DLGPROC)GetProcAddress(hdllInstance, "AboutDlgProc");
! 1821: #else
! 1822: lpfnAboutDlgProc = (DLGPROC)MakeProcInstance((FARPROC)AboutDlgProc, hdllInstance);
! 1823: #endif
! 1824: DialogBoxParam(hdllInstance,"AboutDlgBox",hwnd,lpfnAboutDlgProc,(LPARAM)str);
! 1825: EnableWindow(hwnd,TRUE);
! 1826: #ifndef __DLL__
! 1827: FreeProcInstance((FARPROC)lpfnAboutDlgProc);
! 1828: #endif
! 1829: #endif
! 1830: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to wtext.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot / win