reactos/subsys/system/regedit/hexedit.c

   1 /*
   2  * Hex editor control
   3  *
   4  * Copyright (C) 2004 Thomas Weidenmueller <w3seek@reactos.com>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #define WIN32_LEAN_AND_MEAN     /* Exclude rarely-used stuff from Windows headers */
  22 #include <windows.h>
  23 #include <commctrl.h>
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <tchar.h>
  27 #include <zmouse.h>
  28
  29 #include "hexedit.h"
  30
  31 typedef struct
  32 {
  33   HWND hWndSelf;
  34   HWND hWndParent;
  35   HLOCAL hBuffer;
  36   DWORD style;
  37   DWORD MaxBuffer;
  38   INT ColumnsPerLine;
  39   INT nLines;
  40   INT nVisibleLinesComplete;
  41   INT nVisibleLines;
  42   INT Position;
  43   INT LineHeight;
  44   INT CharWidth;
  45   HFONT hFont;
  46   BOOL SbVisible;
  47
  48   INT LeftMargin;
  49   INT AddressSpacing;
  50   INT SplitSpacing;
  51
  52   BOOL EditingField;
  53   INT CaretCol;
  54   INT CaretLine;
  55 } HEXEDIT_DATA, *PHEXEDIT_DATA;
  56
  57 /* hit test codes */
  58 #define HEHT_LEFTMARGIN (0x1)
  59 #define HEHT_ADDRESS    (0x2)
  60 #define HEHT_ADDRESSSPACING     (0x3)
  61 #define HEHT_HEXDUMP    (0x4)
  62 #define HEHT_HEXDUMPSPACING     (0x5)
  63 #define HEHT_ASCIIDUMP  (0x6)
  64 #define HEHT_RIGHTMARGIN        (0x7)
  65
  66 INT_PTR CALLBACK HexEditWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  67
  68 ATOM
  69 STDCALL
  70 RegisterHexEditorClass(HINSTANCE hInstance)
  71 {
  72   WNDCLASSEX WndClass;
  73
  74   ZeroMemory(&WndClass, sizeof(WNDCLASSEX));
  75   WndClass.cbSize = sizeof(WNDCLASSEX);
  76   WndClass.style = CS_DBLCLKS;
  77   WndClass.lpfnWndProc = (WNDPROC)HexEditWndProc;
  78   WndClass.cbWndExtra = sizeof(PHEXEDIT_DATA);
  79   WndClass.hInstance = hInstance;
  80   WndClass.hCursor = LoadCursor(0, IDC_IBEAM);
  81   WndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
  82   WndClass.lpszClassName = HEX_EDIT_CLASS_NAME;
  83
  84   return RegisterClassEx(&WndClass);
  85 }
  86
  87 BOOL
  88 STDCALL
  89 UnregisterHexEditorClass(HINSTANCE hInstance)
  90 {
  91   return UnregisterClass(HEX_EDIT_CLASS_NAME, hInstance);
  92 }
  93
  94 /*** Helper functions *********************************************************/
  95
  96 static VOID
  97 HEXEDIT_MoveCaret(PHEXEDIT_DATA hed, BOOL Scroll)
  98 {
  99   SCROLLINFO si;
 100
 101   si.cbSize = sizeof(SCROLLINFO);
 102   si.fMask = SIF_POS;
 103   GetScrollInfo(hed->hWndSelf, SB_VERT, &si);
 104
 105   if(Scroll)
 106   {
 107     if(si.nPos > hed->CaretLine)
 108     {
 109       si.nPos = hed->CaretLine;
 110       SetScrollInfo(hed->hWndSelf, SB_VERT, &si, TRUE);
 111       GetScrollInfo(hed->hWndSelf, SB_VERT, &si);
 112       InvalidateRect(hed->hWndSelf, NULL, TRUE);
 113     }
 114     else if(hed->CaretLine >= (hed->nVisibleLinesComplete + si.nPos))
 115     {
 116       si.nPos = hed->CaretLine - hed->nVisibleLinesComplete + 1;
 117       SetScrollInfo(hed->hWndSelf, SB_VERT, &si, TRUE);
 118       GetScrollInfo(hed->hWndSelf, SB_VERT, &si);
 119       InvalidateRect(hed->hWndSelf, NULL, TRUE);
 120     }
 121   }
 122
 123   if(hed->EditingField)
 124     SetCaretPos(hed->LeftMargin + ((4 + hed->AddressSpacing + (3 * hed->CaretCol)) * hed->CharWidth) - 1, (hed->CaretLine - si.nPos) * hed->LineHeight);
 125   else
 126     SetCaretPos(hed->LeftMargin + ((4 + hed->AddressSpacing + hed->SplitSpacing + (3 * hed->ColumnsPerLine) + hed->CaretCol) * hed->CharWidth) - 2, (hed->CaretLine - si.nPos) * hed->LineHeight);
 127 }
 128
 129 static VOID
 130 HEXEDIT_Update(PHEXEDIT_DATA hed)
 131 {
 132   SCROLLINFO si;
 133   RECT rcClient;
 134   BOOL SbVisible;
 135   INT bufsize, cvislines;
 136
 137   GetClientRect(hed->hWndSelf, &rcClient);
 138   hed->style = GetWindowLong(hed->hWndSelf, GWL_STYLE);
 139
 140   bufsize = (hed->hBuffer ? LocalSize(hed->hBuffer) : 0);
 141   hed->nLines = max(bufsize / hed->ColumnsPerLine, 1);
 142   if(bufsize > hed->ColumnsPerLine && (bufsize % hed->ColumnsPerLine) > 0)
 143   {
 144     hed->nLines++;
 145   }
 146
 147   if(hed->LineHeight > 0)
 148   {
 149     hed->nVisibleLinesComplete = cvislines = rcClient.bottom / hed->LineHeight;
 150     hed->nVisibleLines = hed->nVisibleLinesComplete;
 151     if(rcClient.bottom % hed->LineHeight)
 152     {
 153       hed->nVisibleLines++;
 154     }
 155   }
 156   else
 157   {
 158     hed->nVisibleLines = cvislines = 0;
 159   }
 160
 161   SbVisible = bufsize > 0 && cvislines < hed->nLines;
 162   ShowScrollBar(hed->hWndSelf, SB_VERT, SbVisible);
 163
 164   /* update scrollbar */
 165   si.cbSize = sizeof(SCROLLINFO);
 166   si.fMask = SIF_RANGE | SIF_PAGE;
 167   si.nMin = 0;
 168   si.nMax = ((bufsize > 0) ? hed->nLines - 1 : 0);
 169   si.nPage = ((hed->LineHeight > 0) ? rcClient.bottom / hed->LineHeight : 0);
 170   SetScrollInfo(hed->hWndSelf, SB_VERT, &si, TRUE);
 171
 172   if(IsWindowVisible(hed->hWndSelf) && SbVisible != hed->SbVisible)
 173   {
 174     InvalidateRect(hed->hWndSelf, NULL, TRUE);
 175   }
 176
 177   hed->SbVisible = SbVisible;
 178 }
 179
 180 static HFONT
 181 HEXEDIT_GetFixedFont(VOID)
 182 {
 183   LOGFONT lf;
 184   GetObject(GetStockObject(ANSI_FIXED_FONT), sizeof(LOGFONT), &lf);
 185   return CreateFontIndirect(&lf);
 186 }
 187
 188 static VOID
 189 HEXEDIT_PaintLines(PHEXEDIT_DATA hed, HDC hDC, DWORD ScrollPos, DWORD First, DWORD Last, RECT *rc)
 190 {
 191   DWORD dx, dy, linestart;
 192   INT x;
 193   PBYTE buf, current, end, line;
 194   UINT bufsize;
 195   TCHAR hex[3], addr[17];
 196   RECT rct;
 197
 198   FillRect(hDC, rc, (HBRUSH)(COLOR_WINDOW + 1));
 199
 200   if(hed->hBuffer)
 201   {
 202     bufsize = LocalSize(hed->hBuffer);
 203     buf = LocalLock(hed->hBuffer);
 204   }
 205   else
 206   {
 207     buf = NULL;
 208     bufsize = 0;
 209
 210     if(ScrollPos + First == 0)
 211     {
 212       /* draw address */
 213       _stprintf(addr, _T("%04X"), 0);
 214       TextOut(hDC, hed->LeftMargin, First * hed->LineHeight, addr, 4);
 215     }
 216   }
 217
 218   if(buf)
 219   {
 220     end = buf + bufsize;
 221     dy = First * hed->LineHeight;
 222     linestart = (ScrollPos + First) * hed->ColumnsPerLine;
 223     current = buf + linestart;
 224     Last = min(hed->nLines - ScrollPos, Last);
 225
 226     while(First <= Last && current < end)
 227     {
 228       DWORD dh;
 229
 230       dx = hed->LeftMargin;
 231
 232       /* draw address */
 233       _stprintf(addr, _T("%04lX"), linestart);
 234       TextOut(hDC, dx, dy, addr, 4);
 235
 236       dx += ((4 + hed->AddressSpacing) * hed->CharWidth);
 237       dh = (3 * hed->CharWidth);
 238
 239       rct.left = dx;
 240       rct.top = dy;
 241       rct.right = rct.left + dh;
 242       rct.bottom = dy + hed->LineHeight;
 243
 244       /* draw hex map */
 245       dx += (hed->CharWidth / 2);
 246       line = current;
 247       for(x = 0; x < hed->ColumnsPerLine && current < end; x++)
 248       {
 249         rct.left += dh;
 250         rct.right += dh;
 251
 252         _stprintf(hex, _T("%02X"), *(current++));
 253         ExtTextOut(hDC, dx, dy, ETO_OPAQUE, &rct, hex, 2, NULL);
 254         dx += dh;
 255       }
 256
 257       /* draw ascii map */
 258       dx = ((4 + hed->AddressSpacing + hed->SplitSpacing + (hed->ColumnsPerLine * 3)) * hed->CharWidth);
 259       current = line;
 260       for(x = 0; x < hed->ColumnsPerLine && current < end; x++)
 261       {
 262         _stprintf(hex, _T("%C"), *(current++));
 263         hex[0] = ((hex[0] & _T('\x007f')) >= _T(' ') ? hex[0] : _T('.'));
 264         TextOut(hDC, dx, dy, hex, 1);
 265         dx += hed->CharWidth;
 266       }
 267
 268       dy += hed->LineHeight;
 269       linestart += hed->ColumnsPerLine;
 270       First++;
 271     }
 272   }
 273
 274   LocalUnlock(hed->hBuffer);
 275 }
 276
 277 static DWORD
 278 HEXEDIT_HitRegionTest(PHEXEDIT_DATA hed, POINTS pt)
 279 {
 280   int d;
 281
 282   if(pt.x <= hed->LeftMargin)
 283   {
 284     return HEHT_LEFTMARGIN;
 285   }
 286
 287   pt.x -= hed->LeftMargin;
 288   d = (4 * hed->CharWidth);
 289   if(pt.x <= d)
 290   {
 291     return HEHT_ADDRESS;
 292   }
 293
 294   pt.x -= d;
 295   d = (hed->AddressSpacing * hed->CharWidth);
 296   if(pt.x <= d)
 297   {
 298     return HEHT_ADDRESSSPACING;
 299   }
 300
 301   pt.x -= d;
 302   d = (3 * hed->ColumnsPerLine * hed->CharWidth);
 303   if(pt.x <= d)
 304   {
 305     return HEHT_HEXDUMP;
 306   }
 307
 308   pt.x -= d;
 309   d = (hed->SplitSpacing * hed->CharWidth);
 310   if(pt.x <= d)
 311   {
 312     return HEHT_HEXDUMPSPACING;
 313   }
 314
 315   pt.x -= d;
 316   d = (hed->ColumnsPerLine * hed->CharWidth);
 317   if(pt.x <= d)
 318   {
 319     return HEHT_ASCIIDUMP;
 320   }
 321
 322   return HEHT_RIGHTMARGIN;
 323 }
 324
 325 static DWORD
 326 HEXEDIT_PositionFromPoint(PHEXEDIT_DATA hed, POINTS pt, DWORD Hit, POINT *EditPos, BOOL *EditField)
 327 {
 328   SCROLLINFO si;
 329   DWORD Pos, bufsize;
 330
 331   si.cbSize = sizeof(SCROLLINFO);
 332   si.fMask = SIF_POS;
 333   GetScrollInfo(hed->hWndSelf, SB_VERT, &si);
 334
 335   EditPos->x = 0;
 336
 337   if(hed->LineHeight > 0)
 338   {
 339     EditPos->y = min(si.nPos + (pt.y / hed->LineHeight), hed->nLines - 1);
 340   }
 341   else
 342   {
 343     EditPos->y = si.nPos;
 344   }
 345
 346   switch(Hit)
 347   {
 348     case HEHT_LEFTMARGIN:
 349     case HEHT_ADDRESS:
 350     case HEHT_ADDRESSSPACING:
 351     case HEHT_HEXDUMP:
 352       pt.x -= hed->LeftMargin + ((4 + hed->AddressSpacing) * hed->CharWidth);
 353       *EditField = TRUE;
 354       break;
 355
 356     default:
 357       pt.x -= hed->LeftMargin + ((4 + hed->AddressSpacing + hed->SplitSpacing + (3 * hed->ColumnsPerLine)) * hed->CharWidth);
 358       *EditField = FALSE;
 359       break;
 360   }
 361
 362   if(pt.x > 0)
 363   {
 364     INT BlockWidth = (*EditField ? hed->CharWidth * 3 : hed->CharWidth);
 365     EditPos->x = min(hed->ColumnsPerLine, pt.x / BlockWidth);
 366   }
 367
 368   bufsize = (hed->hBuffer ? LocalSize(hed->hBuffer) : 0);
 369   Pos = (EditPos->y * hed->ColumnsPerLine) + EditPos->x;
 370   if(Pos > bufsize)
 371   {
 372     INT tmp = bufsize % hed->ColumnsPerLine;
 373     Pos = bufsize;
 374     EditPos->x = (tmp == 0 ? hed->ColumnsPerLine : tmp);
 375   }
 376   return Pos;
 377 }
 378
 379 /*** Control specific messages ************************************************/
 380
 381 static LRESULT
 382 HEXEDIT_HEM_LOADBUFFER(PHEXEDIT_DATA hed, PVOID Buffer, DWORD Size)
 383 {
 384   if(Buffer != NULL && Size > 0)
 385   {
 386     LPVOID buf;
 387
 388     if(hed->MaxBuffer > 0 && Size > hed->MaxBuffer)
 389     {
 390       Size = hed->MaxBuffer;
 391     }
 392
 393     if(hed->hBuffer)
 394     {
 395       if(Size > 0)
 396       {
 397         if(LocalSize(hed->hBuffer) != Size)
 398         {
 399           hed->hBuffer = LocalReAlloc(hed->hBuffer, Size, LMEM_MOVEABLE | LMEM_ZEROINIT);
 400         }
 401       }
 402       else
 403       {
 404         hed->hBuffer = LocalFree(hed->hBuffer);
 405         hed->Position = 0;
 406         HEXEDIT_Update(hed);
 407
 408         return 0;
 409       }
 410     }
 411     else if(Size > 0)
 412     {
 413       hed->hBuffer = LocalAlloc(LHND, Size);
 414     }
 415
 416     if(Size > 0)
 417     {
 418       buf = LocalLock(hed->hBuffer);
 419       if(buf)
 420       {
 421         memcpy(buf, Buffer, Size);
 422       }
 423       else
 424         Size = 0;
 425       LocalUnlock(hed->hBuffer);
 426     }
 427
 428     hed->Position = 0;
 429     HEXEDIT_Update(hed);
 430     return Size;
 431   }
 432   else if(hed->hBuffer)
 433   {
 434     hed->Position = 0;
 435     hed->hBuffer = LocalFree(hed->hBuffer);
 436     HEXEDIT_Update(hed);
 437   }
 438
 439   return 0;
 440 }
 441
 442 static LRESULT
 443 HEXEDIT_HEM_COPYBUFFER(PHEXEDIT_DATA hed, PVOID Buffer, DWORD Size)
 444 {
 445   DWORD nCpy;
 446
 447   if(!hed->hBuffer)
 448   {
 449     return 0;
 450   }
 451
 452   if(Buffer != NULL && Size > 0)
 453   {
 454     nCpy = min(Size, LocalSize(hed->hBuffer));
 455     if(nCpy > 0)
 456     {
 457       PVOID buf;
 458
 459       buf = LocalLock(hed->hBuffer);
 460       if(buf)
 461       {
 462         memcpy(Buffer, buf, nCpy);
 463       }
 464       else
 465         nCpy = 0;
 466       LocalUnlock(hed->hBuffer);
 467     }
 468     return nCpy;
 469   }
 470
 471   return (LRESULT)LocalSize(hed->hBuffer);
 472 }
 473
 474 static LRESULT
 475 HEXEDIT_HEM_SETMAXBUFFERSIZE(PHEXEDIT_DATA hed, DWORD nMaxSize)
 476 {
 477   hed->MaxBuffer = nMaxSize;
 478   if(hed->MaxBuffer > 0 && hed->hBuffer && LocalSize(hed->hBuffer) > hed->MaxBuffer)
 479   {
 480     /* truncate the buffer */
 481     hed->hBuffer = LocalReAlloc(hed->hBuffer, hed->MaxBuffer, LMEM_MOVEABLE);
 482     HEXEDIT_Update(hed);
 483   }
 484   return 0;
 485 }
 486
 487 /*** Message Proc *************************************************************/
 488
 489 static LRESULT
 490 HEXEDIT_WM_NCCREATE(HWND hWnd, CREATESTRUCT *cs)
 491 {
 492   PHEXEDIT_DATA hed;
 493
 494   if(!(hed = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HEXEDIT_DATA))))
 495   {
 496     return FALSE;
 497   }
 498
 499   hed->hWndSelf = hWnd;
 500   hed->hWndParent = cs->hwndParent;
 501   hed->style = cs->style;
 502
 503   hed->ColumnsPerLine = 8;
 504   hed->LeftMargin = 2;
 505   hed->AddressSpacing = 2;
 506   hed->SplitSpacing = 2;
 507   hed->EditingField = TRUE; /* in hexdump field */
 508
 509   SetWindowLongPtr(hWnd, 0, (DWORD_PTR)hed);
 510   HEXEDIT_Update(hed);
 511
 512   return TRUE;
 513 }
 514
 515 static LRESULT
 516 HEXEDIT_WM_NCDESTROY(PHEXEDIT_DATA hed)
 517 {
 518   if(hed->hBuffer)
 519   {
 520     //while(LocalUnlock(hed->hBuffer));
 521     LocalFree(hed->hBuffer);
 522   }
 523
 524   if(hed->hFont)
 525   {
 526     DeleteObject(hed->hFont);
 527   }
 528
 529   SetWindowLongPtr(hed->hWndSelf, 0, (DWORD_PTR)0);
 530   HeapFree(GetProcessHeap(), 0, hed);
 531
 532   return 0;
 533 }
 534
 535 static LRESULT
 536 HEXEDIT_WM_CREATE(PHEXEDIT_DATA hed)
 537 {
 538   return 1;
 539 }
 540
 541 static LRESULT
 542 HEXEDIT_WM_SETFOCUS(PHEXEDIT_DATA hed)
 543 {
 544   CreateCaret(hed->hWndSelf, 0, 1, hed->LineHeight);
 545   HEXEDIT_MoveCaret(hed, FALSE);
 546   ShowCaret(hed->hWndSelf);
 547   return 0;
 548 }
 549
 550 static LRESULT
 551 HEXEDIT_WM_KILLFOCUS(PHEXEDIT_DATA hed)
 552 {
 553   DestroyCaret();
 554   return 0;
 555 }
 556
 557 static LRESULT
 558 HEXEDIT_WM_VSCROLL(PHEXEDIT_DATA hed, WORD ThumbPosition, WORD SbCmd)
 559 {
 560   int ScrollY;
 561   SCROLLINFO si;
 562
 563   ZeroMemory(&si, sizeof(SCROLLINFO));
 564   si.cbSize = sizeof(SCROLLINFO);
 565   si.fMask = SIF_ALL;
 566   GetScrollInfo(hed->hWndSelf, SB_VERT, &si);
 567
 568   ScrollY = si.nPos;
 569   switch(SbCmd)
 570   {
 571     case SB_TOP:
 572       si.nPos = si.nMin;
 573       break;
 574
 575     case SB_BOTTOM:
 576       si.nPos = si.nMax;
 577       break;
 578
 579     case SB_LINEUP:
 580       si.nPos--;
 581       break;
 582
 583     case SB_LINEDOWN:
 584       si.nPos++;
 585       break;
 586
 587     case SB_PAGEUP:
 588       si.nPos -= si.nPage;
 589       break;
 590
 591     case SB_PAGEDOWN:
 592       si.nPos += si.nPage;
 593       break;
 594
 595     case SB_THUMBTRACK:
 596       si.nPos = si.nTrackPos;
 597       break;
 598   }
 599
 600   si.fMask = SIF_POS;
 601   SetScrollInfo(hed->hWndSelf, SB_VERT, &si, TRUE);
 602   GetScrollInfo(hed->hWndSelf, SB_VERT, &si);
 603
 604   if(si.nPos != ScrollY)
 605   {
 606     ScrollWindow(hed->hWndSelf, 0, (ScrollY - si.nPos) * hed->LineHeight, NULL, NULL);
 607     UpdateWindow(hed->hWndSelf);
 608   }
 609
 610   return 0;
 611 }
 612
 613 static LRESULT
 614 HEXEDIT_WM_SETFONT(PHEXEDIT_DATA hed, HFONT hFont, BOOL bRedraw)
 615 {
 616   HDC hDC;
 617   TEXTMETRIC tm;
 618   HFONT hOldFont = 0;
 619
 620   if(hFont == 0)
 621   {
 622     hFont = HEXEDIT_GetFixedFont();
 623   }
 624
 625   hed->hFont = hFont;
 626   hDC = GetDC(hed->hWndSelf);
 627   if(hFont)
 628   {
 629     hOldFont = SelectObject(hDC, hFont);
 630   }
 631   GetTextMetrics(hDC, &tm);
 632   hed->LineHeight = tm.tmHeight;
 633   hed->CharWidth = tm.tmAveCharWidth;
 634   if(hOldFont)
 635   {
 636     SelectObject(hDC, hOldFont);
 637   }
 638   ReleaseDC(hed->hWndSelf, hDC);
 639
 640   if(bRedraw)
 641   {
 642     InvalidateRect(hed->hWndSelf, NULL, TRUE);
 643   }
 644
 645   return 0;
 646 }
 647
 648 static LRESULT
 649 HEXEDIT_WM_GETFONT(PHEXEDIT_DATA hed)
 650 {
 651   return (LRESULT)hed->hFont;
 652 }
 653
 654 static LRESULT
 655 HEXEDIT_WM_PAINT(PHEXEDIT_DATA hed)
 656 {
 657   PAINTSTRUCT ps;
 658   SCROLLINFO si;
 659   RECT rc;
 660   HBITMAP hbmp, hbmpold;
 661   INT nLines, nFirst;
 662   HFONT hOldFont;
 663   HDC hTempDC;
 664   DWORD height;
 665
 666   if(GetUpdateRect(hed->hWndSelf, &rc, FALSE) && (hed->LineHeight > 0))
 667   {
 668     ZeroMemory(&si, sizeof(SCROLLINFO));
 669     si.cbSize = sizeof(SCROLLINFO);
 670     si.fMask = SIF_POS;
 671     GetScrollInfo(hed->hWndSelf, SB_VERT, &si);
 672
 673     height = (rc.bottom - rc.top);
 674     nLines = height / hed->LineHeight;
 675     if((height % hed->LineHeight) > 0)
 676     {
 677       nLines++;
 678     }
 679     if(nLines > hed->nLines - si.nPos)
 680     {
 681       nLines = hed->nLines - si.nPos;
 682     }
 683     nFirst = rc.top / hed->LineHeight;
 684
 685     BeginPaint(hed->hWndSelf, &ps);
 686     if(!(hTempDC = CreateCompatibleDC(ps.hdc)))
 687     {
 688       FillRect(ps.hdc, &rc, (HBRUSH)(COLOR_WINDOW + 1));
 689       goto epaint;
 690     }
 691     if(!(hbmp = CreateCompatibleBitmap(hTempDC, ps.rcPaint.right, ps.rcPaint.bottom)))
 692     {
 693       FillRect(ps.hdc, &rc, (HBRUSH)(COLOR_WINDOW + 1));
 694       DeleteDC(hTempDC);
 695       goto epaint;
 696     }
 697     hbmpold = SelectObject(hTempDC, hbmp);
 698     hOldFont = SelectObject(hTempDC, hed->hFont);
 699     HEXEDIT_PaintLines(hed, hTempDC, si.nPos, nFirst, nFirst + nLines, &ps.rcPaint);
 700     BitBlt(ps.hdc, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, hTempDC, rc.left, rc.top, SRCCOPY);
 701     SelectObject(hTempDC, hOldFont);
 702     SelectObject(hTempDC, hbmpold);
 703
 704     DeleteObject(hbmp);
 705     DeleteDC(hTempDC);
 706
 707     epaint:
 708     EndPaint(hed->hWndSelf, &ps);
 709   }
 710
 711   return 0;
 712 }
 713
 714 static LRESULT
 715 HEXEDIT_WM_MOUSEWHEEL(PHEXEDIT_DATA hed, int cyMoveLines, WORD ButtonsDown, LPPOINTS MousePos)
 716 {
 717   SCROLLINFO si;
 718   int ScrollY;
 719
 720   SetFocus(hed->hWndSelf);
 721
 722   si.cbSize = sizeof(SCROLLINFO);
 723   si.fMask = SIF_ALL;
 724   GetScrollInfo(hed->hWndSelf, SB_VERT, &si);
 725
 726   ScrollY = si.nPos;
 727
 728   si.fMask = SIF_POS;
 729   si.nPos += cyMoveLines;
 730   SetScrollInfo(hed->hWndSelf, SB_VERT, &si, TRUE);
 731
 732   GetScrollInfo(hed->hWndSelf, SB_VERT, &si);
 733   if(si.nPos != ScrollY)
 734   {
 735     ScrollWindow(hed->hWndSelf, 0, (ScrollY - si.nPos) * hed->LineHeight, NULL, NULL);
 736     UpdateWindow(hed->hWndSelf);
 737   }
 738
 739   return 0;
 740 }
 741
 742 static LRESULT
 743 HEXEDIT_WM_GETDLGCODE(LPMSG Msg)
 744 {
 745   return DLGC_WANTARROWS | DLGC_WANTCHARS;
 746 }
 747
 748 static LRESULT
 749 HEXEDIT_WM_LBUTTONDOWN(PHEXEDIT_DATA hed, INT Buttons, POINTS Pt)
 750 {
 751   BOOL NewField;
 752   POINT EditPos;
 753   DWORD Hit = HEXEDIT_HitRegionTest(hed, Pt);
 754
 755   SetFocus(hed->hWndSelf);
 756
 757   hed->Position = HEXEDIT_PositionFromPoint(hed, Pt, Hit, &EditPos, &NewField);
 758   hed->EditingField = NewField;
 759   hed->CaretCol = EditPos.x;
 760   hed->CaretLine = EditPos.y;
 761
 762   HEXEDIT_MoveCaret(hed, TRUE);
 763
 764   return 0;
 765 }
 766
 767 static BOOL
 768 HEXEDIT_WM_KEYDOWN(PHEXEDIT_DATA hed, INT VkCode)
 769 {
 770   DWORD bufsize;
 771   BOOL shift, control;
 772
 773   if(GetKeyState(VK_MENU) & 0x8000)
 774   {
 775     return FALSE;
 776   }
 777
 778   shift = GetKeyState(VK_SHIFT) & 0x8000;
 779   control = GetKeyState(VK_CONTROL) & 0x8000;
 780
 781   bufsize = (hed->hBuffer ? LocalSize(hed->hBuffer) : 0);
 782
 783   switch(VkCode)
 784   {
 785     case VK_LEFT:
 786       if(hed->Position > 0)
 787       {
 788         if(--hed->CaretCol < 0)
 789         {
 790           hed->CaretLine--;
 791           hed->CaretCol = hed->ColumnsPerLine;
 792         }
 793         else
 794           hed->Position--;
 795       }
 796       HEXEDIT_MoveCaret(hed, TRUE);
 797       break;
 798
 799     case VK_RIGHT:
 800       if(hed->Position < (INT)bufsize)
 801       {
 802         if(++hed->CaretCol > hed->ColumnsPerLine)
 803         {
 804           hed->CaretCol = 0;
 805           hed->CaretLine++;
 806         }
 807         else
 808           hed->Position++;
 809       }
 810       HEXEDIT_MoveCaret(hed, TRUE);
 811       break;
 812
 813     case VK_UP:
 814       if(hed->Position > 0)
 815       {
 816         if(hed->CaretLine <= 0)
 817         {
 818           hed->CaretCol = 0;
 819           hed->Position = 0;
 820         }
 821         else
 822         {
 823           hed->CaretLine--;
 824           hed->Position -= hed->ColumnsPerLine;
 825         }
 826       }
 827       HEXEDIT_MoveCaret(hed, TRUE);
 828       break;
 829
 830     case VK_DOWN:
 831       if(hed->Position <= (INT)bufsize)
 832       {
 833         if(hed->CaretLine < hed->nLines - 1)
 834         {
 835           hed->Position += hed->ColumnsPerLine;
 836           hed->CaretLine++;
 837           if(hed->Position > (INT)bufsize)
 838           {
 839             hed->Position = bufsize;
 840             hed->CaretLine = (hed->nLines > 0 ? hed->nLines - 1 : 0);
 841             hed->CaretCol = bufsize % hed->ColumnsPerLine;
 842           }
 843         }
 844         else
 845         {
 846           INT tmp = bufsize % hed->ColumnsPerLine;
 847           hed->Position = bufsize;
 848           hed->CaretCol = (tmp == 0 ? hed->ColumnsPerLine : tmp);
 849         }
 850       }
 851       HEXEDIT_MoveCaret(hed, TRUE);
 852       break;
 853   }
 854
 855   return FALSE;
 856 }
 857
 858 static LRESULT
 859 HEXEDIT_WM_SIZE(PHEXEDIT_DATA hed, DWORD sType, WORD NewWidth, WORD NewHeight)
 860 {
 861   HEXEDIT_Update(hed);
 862   return 0;
 863 }
 864
 865 INT_PTR CALLBACK
 866 HexEditWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 867 {
 868   PHEXEDIT_DATA hed;
 869
 870   hed = (PHEXEDIT_DATA)GetWindowLongPtr(hWnd, (DWORD_PTR)0);
 871   switch(uMsg)
 872   {
 873     case WM_ERASEBKGND:
 874       return TRUE;
 875
 876     case WM_PAINT:
 877       return HEXEDIT_WM_PAINT(hed);
 878
 879     case WM_KEYDOWN:
 880       return HEXEDIT_WM_KEYDOWN(hed, (INT)wParam);
 881
 882     case WM_VSCROLL:
 883       return HEXEDIT_WM_VSCROLL(hed, HIWORD(wParam), LOWORD(wParam));
 884
 885     case WM_SIZE:
 886       return HEXEDIT_WM_SIZE(hed, (DWORD)wParam, LOWORD(lParam), HIWORD(lParam));
 887
 888     case WM_LBUTTONDOWN:
 889       return HEXEDIT_WM_LBUTTONDOWN(hed, (INT)wParam, MAKEPOINTS(lParam));
 890
 891     case WM_MOUSEWHEEL:
 892     {
 893       UINT nScrollLines = 3;
 894       int delta = 0;
 895
 896       SystemParametersInfoW(SPI_GETWHEELSCROLLLINES, 0, &nScrollLines, 0);
 897       delta -= (SHORT)HIWORD(wParam);
 898       if(abs(delta) >= WHEEL_DELTA && nScrollLines != 0)
 899       {
 900         return HEXEDIT_WM_MOUSEWHEEL(hed, nScrollLines * (delta / WHEEL_DELTA), LOWORD(wParam), &MAKEPOINTS(lParam));
 901       }
 902       break;
 903     }
 904
 905     case HEM_LOADBUFFER:
 906       return HEXEDIT_HEM_LOADBUFFER(hed, (PVOID)wParam, (DWORD)lParam);
 907
 908     case HEM_COPYBUFFER:
 909       return HEXEDIT_HEM_COPYBUFFER(hed, (PVOID)wParam, (DWORD)lParam);
 910
 911     case HEM_SETMAXBUFFERSIZE:
 912       return HEXEDIT_HEM_SETMAXBUFFERSIZE(hed, (DWORD)lParam);
 913
 914     case WM_SETFOCUS:
 915       return HEXEDIT_WM_SETFOCUS(hed);
 916
 917     case WM_KILLFOCUS:
 918       return HEXEDIT_WM_KILLFOCUS(hed);
 919
 920     case WM_GETDLGCODE:
 921       return HEXEDIT_WM_GETDLGCODE((LPMSG)lParam);
 922
 923     case WM_SETFONT:
 924       return HEXEDIT_WM_SETFONT(hed, (HFONT)wParam, (BOOL)LOWORD(lParam));
 925
 926     case WM_GETFONT:
 927       return HEXEDIT_WM_GETFONT(hed);
 928
 929     case WM_CREATE:
 930       return HEXEDIT_WM_CREATE(hed);
 931
 932     case WM_NCCREATE:
 933       if(!hed)
 934       {
 935         return HEXEDIT_WM_NCCREATE(hWnd, (CREATESTRUCT*)lParam);
 936       }
 937       break;
 938
 939     case WM_NCDESTROY:
 940       if(hed)
 941       {
 942         return HEXEDIT_WM_NCDESTROY(hed);
 943       }
 944       break;
 945   }
 946
 947   return CallWindowProc(DefWindowProc, hWnd, uMsg, wParam, lParam);
 948 }
 949