src/apps/debugger/user_interface/gui/inspector_window/MemoryView.cpp

   1 /*
   2  * Copyright 2011-2015, Rene Gollent, rene@gollent.com. All rights reserved.
   3  * Distributed under the terms of the MIT License.
   4  */
   5
   6
   7 #include "MemoryView.h"
   8
   9 #include <algorithm>
  10
  11 #include <ctype.h>
  12 #include <stdio.h>
  13
  14 #include <ByteOrder.h>
  15 #include <Clipboard.h>
  16 #include <Looper.h>
  17 #include <MenuItem.h>
  18 #include <MessageRunner.h>
  19 #include <Messenger.h>
  20 #include <PopUpMenu.h>
  21 #include <Region.h>
  22 #include <ScrollView.h>
  23 #include <String.h>
  24
  25 #include "Architecture.h"
  26 #include "AutoDeleter.h"
  27 #include "MessageCodes.h"
  28 #include "Team.h"
  29 #include "TeamMemoryBlock.h"
  30
  31
  32 enum {
  33         MSG_TARGET_ADDRESS_CHANGED      = 'mtac',
  34         MSG_VIEW_AUTOSCROLL                     = 'mvas'
  35 };
  36
  37 static const bigtime_t kScrollTimer = 10000LL;
  38
  39
  40 MemoryView::MemoryView(::Team* team, Listener* listener)
  41         :
  42         BView("memoryView", B_WILL_DRAW | B_FRAME_EVENTS | B_NAVIGABLE
  43                 | B_SUBPIXEL_PRECISE),
  44         fTeam(team),
  45         fTargetBlock(NULL),
  46         fEditableData(NULL),
  47         fEditedOffsets(),
  48         fTargetAddress(0LL),
  49         fEditMode(false),
  50         fEditLowNybble(false),
  51         fCharWidth(0.0),
  52         fLineHeight(0.0),
  53         fTextCharsPerLine(0),
  54         fHexBlocksPerLine(0),
  55         fHexMode(HexMode8BitInt),
  56         fTextMode(TextModeASCII),
  57         fSelectionBase(0),
  58         fSelectionStart(0),
  59         fSelectionEnd(0),
  60         fScrollRunner(NULL),
  61         fTrackingMouse(false),
  62         fListener(listener)
  63 {
  64         Architecture* architecture = team->GetArchitecture();
  65         fTargetAddressSize = architecture->AddressSize() * 2;
  66         fCurrentEndianMode = architecture->IsBigEndian()
  67                 ? EndianModeBigEndian : EndianModeLittleEndian;
  68
  69 }
  70
  71
  72 MemoryView::~MemoryView()
  73 {
  74         if (fTargetBlock != NULL)
  75                 fTargetBlock->ReleaseReference();
  76
  77         delete[] fEditableData;
  78 }
  79
  80
  81 /*static */ MemoryView*
  82 MemoryView::Create(::Team* team, Listener* listener)
  83 {
  84         MemoryView* self = new MemoryView(team, listener);
  85
  86         try {
  87                 self->_Init();
  88         } catch(...) {
  89                 delete self;
  90                 throw;
  91         }
  92
  93         return self;
  94 }
  95
  96
  97 void
  98 MemoryView::SetTargetAddress(TeamMemoryBlock* block, target_addr_t address)
  99 {
 100         fTargetAddress = address;
 101         if (block != fTargetBlock) {
 102                 if (fTargetBlock != NULL)
 103                         fTargetBlock->ReleaseReference();
 104
 105                 fTargetBlock = block;
 106                 if (block != NULL)
 107                         fTargetBlock->AcquireReference();
 108         }
 109
 110         MakeFocus(true);
 111         BMessenger(this).SendMessage(MSG_TARGET_ADDRESS_CHANGED);
 112 }
 113
 114
 115 void
 116 MemoryView::UnsetListener()
 117 {
 118         fListener = NULL;
 119 }
 120
 121
 122 status_t
 123 MemoryView::SetEditMode(bool enabled)
 124 {
 125         if (fTargetBlock == NULL)
 126                 return B_BAD_VALUE;
 127         else if (fEditMode == enabled)
 128                 return B_OK;
 129
 130         if (enabled) {
 131                 status_t error = _SetupEditableData();
 132                 if (error != B_OK)
 133                         return error;
 134         } else {
 135                 delete[] fEditableData;
 136                 fEditableData = NULL;
 137                 fEditedOffsets.clear();
 138                 fEditLowNybble = false;
 139         }
 140
 141         fEditMode = enabled;
 142         Invalidate();
 143
 144         return B_OK;
 145 }
 146
 147
 148 void
 149 MemoryView::AttachedToWindow()
 150 {
 151         BView::AttachedToWindow();
 152         SetViewUIColor(B_DOCUMENT_BACKGROUND_COLOR);
 153         SetFont(be_fixed_font);
 154         fCharWidth = be_fixed_font->StringWidth("a");
 155         font_height fontHeight;
 156         be_fixed_font->GetHeight(&fontHeight);
 157         fLineHeight = ceilf(fontHeight.ascent + fontHeight.descent
 158                 + fontHeight.leading);
 159 }
 160
 161
 162 void
 163 MemoryView::Draw(BRect rect)
 164 {
 165         rect = Bounds();
 166
 167         float divider = (fTargetAddressSize + 1) * fCharWidth;
 168         StrokeLine(BPoint(divider, rect.top),
 169                                 BPoint(divider, rect.bottom));
 170
 171         if (fTargetBlock == NULL)
 172                 return;
 173
 174         uint32 hexBlockSize = _GetHexDigitsPerBlock() + 1;
 175         uint32 blockByteSize = hexBlockSize / 2;
 176         if (fHexMode != HexModeNone && fTextMode != TextModeNone) {
 177                 divider += (fHexBlocksPerLine * hexBlockSize + 1) * fCharWidth;
 178                 StrokeLine(BPoint(divider, rect.top),
 179                                         BPoint(divider, rect.bottom));
 180         }
 181
 182         char buffer[32];
 183         char textbuffer[512];
 184
 185         const char* dataSource = (const char*)(fEditMode ? fEditableData
 186                         : fTargetBlock->Data());
 187
 188         int32 startLine = int32(rect.top / fLineHeight);
 189         const char* currentAddress = dataSource + fHexBlocksPerLine
 190                 * blockByteSize * startLine;
 191         const char* maxAddress = dataSource + fTargetBlock->Size();
 192         const char* targetAddress = dataSource + fTargetAddress
 193                 - fTargetBlock->BaseAddress();
 194         BPoint drawPoint(1.0, (startLine + 1) * fLineHeight);
 195         int32 currentBlocksPerLine = fHexBlocksPerLine;
 196         int32 currentCharsPerLine = fTextCharsPerLine;
 197         rgb_color addressColor = tint_color(HighColor(), B_LIGHTEN_1_TINT);
 198         rgb_color dataColor = HighColor();
 199         font_height fh;
 200         GetFontHeight(&fh);
 201         target_addr_t lineAddress = fTargetBlock->BaseAddress() + startLine
 202                 * currentCharsPerLine;
 203         bool highlightBlock = false;
 204         rgb_color highlightColor;
 205         for (; currentAddress < maxAddress && drawPoint.y < rect.bottom
 206                 + fLineHeight; drawPoint.y += fLineHeight) {
 207                 drawPoint.x = 1.0;
 208                 snprintf(buffer, sizeof(buffer), "%0*" B_PRIx64,
 209                         (int)fTargetAddressSize, lineAddress);
 210                 PushState();
 211                 SetHighColor(tint_color(HighColor(), B_LIGHTEN_1_TINT));
 212                 DrawString(buffer, drawPoint);
 213                 drawPoint.x += fCharWidth * (fTargetAddressSize + 2);
 214                 PopState();
 215                 if (fHexMode != HexModeNone) {
 216                         if (currentAddress + (currentBlocksPerLine * blockByteSize)
 217                                 > maxAddress) {
 218                                 currentCharsPerLine = maxAddress - currentAddress;
 219                                 currentBlocksPerLine = currentCharsPerLine
 220                                         / blockByteSize;
 221                         }
 222
 223                         for (int32 j = 0; j < currentBlocksPerLine; j++) {
 224                                 const char* blockAddress = currentAddress + (j
 225                                         * blockByteSize);
 226                                 _GetNextHexBlock(buffer, sizeof(buffer), blockAddress);
 227
 228                                 highlightBlock = false;
 229                                 if (fEditMode)
 230                                 {
 231                                         int32 offset = blockAddress - dataSource;
 232                                         for (uint32 i = 0; i < blockByteSize; i++) {
 233                                                 if (fEditedOffsets.count(offset + i) != 0) {
 234                                                         highlightBlock = true;
 235                                                         highlightColor.set_to(0, 216, 0);
 236                                                         break;
 237                                                 }
 238                                         }
 239
 240                                 } else if (targetAddress >= blockAddress && targetAddress <
 241                                                 blockAddress + blockByteSize) {
 242                                                 highlightBlock = true;
 243                                                 highlightColor.set_to(216, 0, 0);
 244                                 }
 245
 246                                 if (highlightBlock) {
 247                                         PushState();
 248                                         SetHighColor(highlightColor);
 249                                 }
 250
 251                                 DrawString(buffer, drawPoint);
 252
 253                                 if (highlightBlock)
 254                                         PopState();
 255
 256                                 drawPoint.x += fCharWidth * hexBlockSize;
 257                         }
 258
 259                         if (currentBlocksPerLine < fHexBlocksPerLine)
 260                                 drawPoint.x += fCharWidth * hexBlockSize
 261                                         * (fHexBlocksPerLine - currentBlocksPerLine);
 262                 }
 263
 264                 if (fTextMode != TextModeNone) {
 265                         drawPoint.x += fCharWidth;
 266                         for (int32 j = 0; j < currentCharsPerLine; j++) {
 267                                 // filter non-printable characters
 268                                 textbuffer[j] = currentAddress[j] > 32 ? currentAddress[j]
 269                                         : '.';
 270                         }
 271                         textbuffer[fTextCharsPerLine] = '\0';
 272                         DrawString(textbuffer, drawPoint);
 273                         if (targetAddress >= currentAddress && targetAddress
 274                                 < currentAddress + currentCharsPerLine) {
 275                                 PushState();
 276                                 SetHighColor(B_TRANSPARENT_COLOR);
 277                                 SetDrawingMode(B_OP_INVERT);
 278                                 uint32 blockAddress = uint32(targetAddress - currentAddress);
 279                                 if (fHexMode != HexModeNone)
 280                                         blockAddress &= ~(blockByteSize - 1);
 281                                 float startX = drawPoint.x + fCharWidth * blockAddress;
 282                                 float endX = startX;
 283                                 if (fHexMode != HexModeNone)
 284                                         endX += fCharWidth * ((hexBlockSize - 1) / 2);
 285                                 else
 286                                         endX += fCharWidth;
 287                                 FillRect(BRect(startX, drawPoint.y - fh.ascent, endX,
 288                                         drawPoint.y + fh.descent));
 289                                 PopState();
 290                         }
 291                 }
 292                 if (currentBlocksPerLine > 0) {
 293                         currentAddress += currentBlocksPerLine * blockByteSize;
 294                         lineAddress += currentBlocksPerLine * blockByteSize;
 295                 } else {
 296                         currentAddress += fTextCharsPerLine;
 297                         lineAddress += fTextCharsPerLine;
 298                 }
 299         }
 300
 301         if (fSelectionStart != fSelectionEnd) {
 302                 PushState();
 303                 BRegion selectionRegion;
 304                 _GetSelectionRegion(selectionRegion);
 305                 SetDrawingMode(B_OP_INVERT);
 306                 FillRegion(&selectionRegion, B_SOLID_HIGH);
 307                 PopState();
 308         }
 309
 310         if (fEditMode) {
 311                 PushState();
 312                 BRect caretRect;
 313                 _GetEditCaretRect(caretRect);
 314                 SetDrawingMode(B_OP_INVERT);
 315                 FillRect(caretRect, B_SOLID_HIGH);
 316                 PopState();
 317
 318         }
 319 }
 320
 321
 322 void
 323 MemoryView::FrameResized(float width, float height)
 324 {
 325         BView::FrameResized(width, height);
 326         _RecalcScrollBars();
 327         Invalidate();
 328 }
 329
 330
 331 void
 332 MemoryView::KeyDown(const char* bytes, int32 numBytes)
 333 {
 334         bool handled = true;
 335         if (fTargetBlock != NULL) {
 336                 target_addr_t newAddress = fTargetAddress;
 337                 target_addr_t maxAddress = fTargetBlock->BaseAddress()
 338                         + fTargetBlock->Size() - 1;
 339                 int32 blockSize = 1;
 340                 if (fHexMode != HexModeNone)
 341                         blockSize = 1 << (fHexMode - 1);
 342                 int32 lineCount = int32(Bounds().Height() / fLineHeight);
 343
 344                 switch(bytes[0]) {
 345                         case B_UP_ARROW:
 346                         {
 347                                 newAddress -= blockSize * fHexBlocksPerLine;
 348                                 break;
 349                         }
 350                         case B_DOWN_ARROW:
 351                         {
 352                                 newAddress += blockSize * fHexBlocksPerLine;
 353                                 break;
 354                         }
 355                         case B_LEFT_ARROW:
 356                         {
 357                                 if (fEditMode) {
 358                                         if (!fEditLowNybble)
 359                                                 newAddress--;
 360                                         fEditLowNybble = !fEditLowNybble;
 361                                         if (newAddress == fTargetAddress)
 362                                                 Invalidate();
 363                                 } else
 364                                         newAddress -= blockSize;
 365                                 break;
 366                         }
 367                         case B_RIGHT_ARROW:
 368                         {
 369                                 if (fEditMode) {
 370                                         if (fEditLowNybble)
 371                                                 newAddress++;
 372                                         fEditLowNybble = !fEditLowNybble;
 373                                         if (newAddress == fTargetAddress)
 374                                                 Invalidate();
 375                                 } else
 376                                         newAddress += blockSize;
 377                                 break;
 378                         }
 379                         case B_PAGE_UP:
 380                         {
 381                                 newAddress -= (blockSize * fHexBlocksPerLine) * lineCount;
 382                                 break;
 383                         }
 384                         case B_PAGE_DOWN:
 385                         {
 386                                 newAddress += (blockSize * fHexBlocksPerLine) * lineCount;
 387                                 break;
 388                         }
 389                         case B_HOME:
 390                         {
 391                                 newAddress = fTargetBlock->BaseAddress();
 392                                 fEditLowNybble = false;
 393                                 break;
 394                         }
 395                         case B_END:
 396                         {
 397                                 newAddress = maxAddress;
 398                                 fEditLowNybble = true;
 399                                 break;
 400                         }
 401                         default:
 402                         {
 403                                 if (fEditMode && isxdigit(bytes[0]))
 404                                 {
 405                                         int value = 0;
 406                                         if (isdigit(bytes[0]))
 407                                                 value = bytes[0] - '0';
 408                                         else
 409                                                 value = (int)strtol(bytes, NULL, 16);
 410
 411                                         int32 byteOffset = fTargetAddress
 412                                                 - fTargetBlock->BaseAddress();
 413
 414                                         if (fEditLowNybble)
 415                                                 value = (fEditableData[byteOffset] & 0xf0) | value;
 416                                         else {
 417                                                 value = (fEditableData[byteOffset] & 0x0f)
 418                                                         | (value << 4);
 419                                         }
 420
 421                                         fEditableData[byteOffset] = value;
 422
 423                                         if (fEditableData[byteOffset]
 424                                                 != fTargetBlock->Data()[byteOffset]) {
 425                                                 fEditedOffsets.insert(byteOffset);
 426                                         } else
 427                                                 fEditedOffsets.erase(byteOffset);
 428
 429                                         if (fEditLowNybble) {
 430                                                 if (newAddress < maxAddress) {
 431                                                         newAddress++;
 432                                                         fEditLowNybble = false;
 433                                                 }
 434                                         } else
 435                                                 fEditLowNybble = true;
 436
 437                                         Invalidate();
 438                                 } else
 439                                         handled = false;
 440
 441                                 break;
 442                         }
 443                 }
 444
 445                 if (handled) {
 446                         if (newAddress < fTargetBlock->BaseAddress())
 447                                 newAddress = fTargetAddress;
 448                         else if (newAddress > maxAddress)
 449                                 newAddress = maxAddress;
 450
 451                         if (newAddress != fTargetAddress) {
 452                                 fTargetAddress = newAddress;
 453                                 BMessenger(this).SendMessage(MSG_TARGET_ADDRESS_CHANGED);
 454                         }
 455                 }
 456         } else
 457                 handled = false;
 458
 459         if (!handled)
 460                 BView::KeyDown(bytes, numBytes);
 461 }
 462
 463
 464 void
 465 MemoryView::MakeFocus(bool isFocused)
 466 {
 467         BScrollView* parent = dynamic_cast<BScrollView*>(Parent());
 468         if (parent != NULL)
 469                 parent->SetBorderHighlighted(isFocused);
 470
 471         BView::MakeFocus(isFocused);
 472 }
 473
 474
 475 void
 476 MemoryView::MessageReceived(BMessage* message)
 477 {
 478         switch(message->what) {
 479                 case B_COPY:
 480                 {
 481                         _CopySelectionToClipboard();
 482                         break;
 483                 }
 484                 case MSG_TARGET_ADDRESS_CHANGED:
 485                 {
 486                         _RecalcScrollBars();
 487                         ScrollToSelection();
 488                         Invalidate();
 489                         if (fListener != NULL)
 490                                 fListener->TargetAddressChanged(fTargetAddress);
 491                         break;
 492                 }
 493                 case MSG_SET_HEX_MODE:
 494                 {
 495                         // while editing, hex view changes are disallowed.
 496                         if (fEditMode)
 497                                 break;
 498
 499                         int32 mode;
 500                         if (message->FindInt32("mode", &mode) == B_OK) {
 501                                 if (fHexMode == mode)
 502                                         break;
 503
 504                                 fHexMode = mode;
 505                                 _RecalcScrollBars();
 506                                 Invalidate();
 507
 508                                 if (fListener != NULL)
 509                                         fListener->HexModeChanged(mode);
 510                         }
 511                         break;
 512                 }
 513                 case MSG_SET_ENDIAN_MODE:
 514                 {
 515                         int32 mode;
 516                         if (message->FindInt32("mode", &mode) == B_OK) {
 517                                 if (fCurrentEndianMode == mode)
 518                                         break;
 519
 520                                 fCurrentEndianMode = mode;
 521                                 Invalidate();
 522
 523                                 if (fListener != NULL)
 524                                         fListener->EndianModeChanged(mode);
 525                         }
 526                         break;
 527                 }
 528                 case MSG_SET_TEXT_MODE:
 529                 {
 530                         int32 mode;
 531                         if (message->FindInt32("mode", &mode) == B_OK) {
 532                                 if (fTextMode == mode)
 533                                         break;
 534
 535                                 fTextMode = mode;
 536                                 _RecalcScrollBars();
 537                                 Invalidate();
 538
 539                                 if (fListener != NULL)
 540                                         fListener->TextModeChanged(mode);
 541                         }
 542                         break;
 543                 }
 544                 case MSG_VIEW_AUTOSCROLL:
 545                 {
 546                         _HandleAutoScroll();
 547                         break;
 548                 }
 549                 default:
 550                 {
 551                         BView::MessageReceived(message);
 552                         break;
 553                 }
 554         }
 555 }
 556
 557
 558 void
 559 MemoryView::MouseDown(BPoint point)
 560 {
 561         if (!IsFocus())
 562                 MakeFocus(true);
 563
 564         if (fTargetBlock == NULL)
 565                 return;
 566
 567         int32 buttons;
 568         if (Looper()->CurrentMessage()->FindInt32("buttons", &buttons) != B_OK)
 569                 buttons = B_PRIMARY_MOUSE_BUTTON;
 570
 571         if (buttons == B_SECONDARY_MOUSE_BUTTON) {
 572                 _HandleContextMenu(point);
 573                 return;
 574         }
 575
 576         int32 offset = _GetOffsetAt(point);
 577         if (offset < fSelectionStart || offset > fSelectionEnd) {
 578                 BRegion oldSelectionRegion;
 579                 _GetSelectionRegion(oldSelectionRegion);
 580                 fSelectionBase = offset;
 581                 fSelectionStart = fSelectionBase;
 582                 fSelectionEnd = fSelectionBase;
 583                 Invalidate(oldSelectionRegion.Frame());
 584         }
 585
 586         SetMouseEventMask(B_POINTER_EVENTS, B_NO_POINTER_HISTORY);
 587         fTrackingMouse = true;
 588 }
 589
 590
 591 void
 592 MemoryView::MouseMoved(BPoint point, uint32 transit, const BMessage* message)
 593 {
 594         if (!fTrackingMouse)
 595                 return;
 596
 597         BRegion oldSelectionRegion;
 598         _GetSelectionRegion(oldSelectionRegion);
 599         int32 offset = _GetOffsetAt(point);
 600         if (offset < fSelectionBase) {
 601                 fSelectionStart = offset;
 602                 fSelectionEnd = fSelectionBase;
 603         } else {
 604                 fSelectionStart = fSelectionBase;
 605                 fSelectionEnd = offset;
 606         }
 607
 608         BRegion region;
 609         _GetSelectionRegion(region);
 610         region.Include(&oldSelectionRegion);
 611         Invalidate(region.Frame());
 612
 613         switch (transit) {
 614                 case B_EXITED_VIEW:
 615                         fScrollRunner = new BMessageRunner(BMessenger(this),
 616                                 new BMessage(MSG_VIEW_AUTOSCROLL), kScrollTimer);
 617                         break;
 618
 619                 case B_ENTERED_VIEW:
 620                         delete fScrollRunner;
 621                         fScrollRunner = NULL;
 622                         break;
 623
 624                 default:
 625                         break;
 626         }
 627 }
 628
 629
 630 void
 631 MemoryView::MouseUp(BPoint point)
 632 {
 633         fTrackingMouse = false;
 634         delete fScrollRunner;
 635         fScrollRunner = NULL;
 636 }
 637
 638
 639 void
 640 MemoryView::ScrollToSelection()
 641 {
 642         if (fTargetBlock != NULL) {
 643                 target_addr_t offset = fTargetAddress - fTargetBlock->BaseAddress();
 644                 int32 lineNumber = 0;
 645                 if (fHexBlocksPerLine > 0) {
 646                         lineNumber = offset / (fHexBlocksPerLine
 647                                 * (_GetHexDigitsPerBlock() / 2));
 648                 } else if (fTextCharsPerLine > 0)
 649                         lineNumber = offset / fTextCharsPerLine;
 650
 651                 float y = lineNumber * fLineHeight;
 652                 if (y < Bounds().top)
 653                         ScrollTo(0.0, y);
 654                 else if (y + fLineHeight > Bounds().bottom)
 655                         ScrollTo(0.0, y + fLineHeight - Bounds().Height());
 656         }
 657 }
 658
 659
 660 void
 661 MemoryView::TargetedByScrollView(BScrollView* scrollView)
 662 {
 663         BView::TargetedByScrollView(scrollView);
 664         scrollView->ScrollBar(B_VERTICAL)->SetRange(0.0, 0.0);
 665 }
 666
 667
 668 BSize
 669 MemoryView::MinSize()
 670 {
 671         return BSize(0.0, 0.0);
 672 }
 673
 674
 675 BSize
 676 MemoryView::PreferredSize()
 677 {
 678         return MinSize();
 679 }
 680
 681
 682 BSize
 683 MemoryView::MaxSize()
 684 {
 685         return BSize(B_SIZE_UNLIMITED, B_SIZE_UNLIMITED);
 686 }
 687
 688
 689 void
 690 MemoryView::_Init()
 691 {
 692         SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
 693 }
 694
 695
 696 void
 697 MemoryView::_RecalcScrollBars()
 698 {
 699         float max = 0.0;
 700         BScrollBar *scrollBar = ScrollBar(B_VERTICAL);
 701         if (fTargetBlock != NULL) {
 702                 int32 hexDigits = _GetHexDigitsPerBlock();
 703                 int32 sizeFactor = 1 + hexDigits;
 704                 _RecalcBounds();
 705
 706                 float hexWidth = fHexRight - fHexLeft;
 707                 int32 nybblesPerLine = int32(hexWidth / fCharWidth);
 708                 fHexBlocksPerLine = 0;
 709                 fTextCharsPerLine = 0;
 710                 if (fHexMode != HexModeNone) {
 711                         fHexBlocksPerLine = nybblesPerLine / sizeFactor;
 712                         fHexBlocksPerLine &= ~1;
 713                         fHexRight = fHexLeft + (fHexBlocksPerLine * sizeFactor
 714                                 * fCharWidth);
 715                         if (fTextMode != TextModeNone)
 716                                 fTextCharsPerLine = fHexBlocksPerLine * hexDigits / 2;
 717                 } else if (fTextMode != TextModeNone)
 718                         fTextCharsPerLine = int32((fTextRight - fTextLeft) / fCharWidth);
 719                 int32 lineCount = 0;
 720                 float totalHeight = 0.0;
 721                 if (fHexBlocksPerLine > 0) {
 722                         lineCount = fTargetBlock->Size() / (fHexBlocksPerLine
 723                                         * hexDigits / 2);
 724                 } else if (fTextCharsPerLine > 0)
 725                         lineCount = fTargetBlock->Size() / fTextCharsPerLine;
 726
 727                 totalHeight = lineCount * fLineHeight;
 728                 if (totalHeight > 0.0) {
 729                         BRect bounds = Bounds();
 730                         max = totalHeight - bounds.Height();
 731                         scrollBar->SetProportion(bounds.Height() / totalHeight);
 732                         scrollBar->SetSteps(fLineHeight, bounds.Height());
 733                 }
 734         }
 735         scrollBar->SetRange(0.0, max);
 736 }
 737
 738 void
 739 MemoryView::_GetNextHexBlock(char* buffer, int32 bufferSize,
 740         const char* address) const
 741 {
 742         switch(fHexMode) {
 743                 case HexMode8BitInt:
 744                 {
 745                         snprintf(buffer, bufferSize, "%02" B_PRIx8,
 746                                 *((const uint8*)address));
 747                         break;
 748                 }
 749                 case HexMode16BitInt:
 750                 {
 751                         uint16 data = *((const uint16*)address);
 752                         switch(fCurrentEndianMode)
 753                         {
 754                                 case EndianModeBigEndian:
 755                                 {
 756                                         data = B_HOST_TO_BENDIAN_INT16(data);
 757                                 }
 758                                 break;
 759
 760                                 case EndianModeLittleEndian:
 761                                 {
 762                                         data = B_HOST_TO_LENDIAN_INT16(data);
 763                                 }
 764                                 break;
 765                         }
 766                         snprintf(buffer, bufferSize, "%04" B_PRIx16,
 767                                 data);
 768                         break;
 769                 }
 770                 case HexMode32BitInt:
 771                 {
 772                         uint32 data = *((const uint32*)address);
 773                         switch(fCurrentEndianMode)
 774                         {
 775                                 case EndianModeBigEndian:
 776                                 {
 777                                         data = B_HOST_TO_BENDIAN_INT32(data);
 778                                 }
 779                                 break;
 780
 781                                 case EndianModeLittleEndian:
 782                                 {
 783                                         data = B_HOST_TO_LENDIAN_INT32(data);
 784                                 }
 785                                 break;
 786                         }
 787                         snprintf(buffer, bufferSize, "%08" B_PRIx32,
 788                                 data);
 789                         break;
 790                 }
 791                 case HexMode64BitInt:
 792                 {
 793                         uint64 data = *((const uint64*)address);
 794                         switch(fCurrentEndianMode)
 795                         {
 796                                 case EndianModeBigEndian:
 797                                 {
 798                                         data = B_HOST_TO_BENDIAN_INT64(data);
 799                                 }
 800                                 break;
 801
 802                                 case EndianModeLittleEndian:
 803                                 {
 804                                         data = B_HOST_TO_LENDIAN_INT64(data);
 805                                 }
 806                                 break;
 807                         }
 808                         snprintf(buffer, bufferSize, "%0*" B_PRIx64,
 809                                 16, data);
 810                         break;
 811                 }
 812         }
 813 }
 814
 815
 816 int32
 817 MemoryView::_GetOffsetAt(BPoint point) const
 818 {
 819         if (fTargetBlock == NULL)
 820                 return -1;
 821
 822         // TODO: support selection in the text region as well
 823         if (fHexMode == HexModeNone)
 824                 return -1;
 825
 826         int32 lineNumber = int32(point.y / fLineHeight);
 827         int32 charsPerBlock = _GetHexDigitsPerBlock() / 2;
 828         int32 totalHexBlocks = fTargetBlock->Size() / charsPerBlock;
 829         int32 lineCount = totalHexBlocks / fHexBlocksPerLine;
 830
 831         if (lineNumber >= lineCount)
 832                 return -1;
 833
 834         point.x -= fHexLeft;
 835         if (point.x < 0)
 836                 point.x = 0;
 837         else if (point.x > fHexRight)
 838                 point.x = fHexRight;
 839
 840         float blockWidth = (charsPerBlock * 2 + 1) * fCharWidth;
 841         int32 containingBlock = int32(floor(point.x / blockWidth));
 842
 843         return fHexBlocksPerLine * charsPerBlock * lineNumber
 844                 + containingBlock * charsPerBlock;
 845 }
 846
 847
 848 BPoint
 849 MemoryView::_GetPointForOffset(int32 offset) const
 850 {
 851         BPoint point;
 852         if (fHexMode == HexModeNone)
 853                 return point;
 854
 855         int32 bytesPerLine = fHexBlocksPerLine * _GetHexDigitsPerBlock() / 2;
 856         int32 line = offset / bytesPerLine;
 857         int32 lineOffset = offset % bytesPerLine;
 858
 859         point.x = fHexLeft + (lineOffset * 2 * fCharWidth)
 860                         + (lineOffset * 2 * fCharWidth / _GetHexDigitsPerBlock());
 861         point.y = line * fLineHeight;
 862
 863         return point;
 864 }
 865
 866
 867 void
 868 MemoryView::_RecalcBounds()
 869 {
 870         fHexLeft = 0;
 871         fHexRight = 0;
 872         fTextLeft = 0;
 873         fTextRight = 0;
 874
 875         // the left bound is determined by the space taken up by the actual
 876         // displayed addresses.
 877         float left = _GetAddressDisplayWidth();
 878         float width = Bounds().Width() - left;
 879
 880         if (fHexMode != HexModeNone) {
 881                 int32 hexDigits = _GetHexDigitsPerBlock();
 882                 int32 sizeFactor = 1 + hexDigits;
 883                 if (fTextMode != TextModeNone) {
 884                         float hexProportion = sizeFactor / (float)(sizeFactor
 885                                 + hexDigits / 2);
 886                         float hexWidth = width * hexProportion;
 887                         fTextLeft = left + hexWidth;
 888                         fHexLeft = left;
 889                         // when sharing the display between hex and text,
 890                         // we allocate a 2 character space to separate the views
 891                         hexWidth -= 2 * fCharWidth;
 892                         fHexRight = left + hexWidth;
 893                 } else {
 894                         fHexLeft = left;
 895                         fHexRight = left + width;
 896                 }
 897         } else if (fTextMode != TextModeNone) {
 898                 fTextLeft = left;
 899                 fTextRight = left + width;
 900         }
 901 }
 902
 903
 904 float
 905 MemoryView::_GetAddressDisplayWidth() const
 906 {
 907         return (fTargetAddressSize + 2) * fCharWidth;
 908 }
 909
 910
 911 void
 912 MemoryView::_GetEditCaretRect(BRect& rect) const
 913 {
 914         if (!fEditMode)
 915                 return;
 916
 917         int32 byteOffset = fTargetAddress - fTargetBlock->BaseAddress();
 918         BPoint point = _GetPointForOffset(byteOffset);
 919         if (fEditLowNybble)
 920                 point.x += fCharWidth;
 921
 922         rect.left = point.x;
 923         rect.right = point.x + fCharWidth;
 924         rect.top = point.y;
 925         rect.bottom = point.y + fLineHeight;
 926 }
 927
 928
 929 void
 930 MemoryView::_GetSelectionRegion(BRegion& region) const
 931 {
 932         if (fHexMode == HexModeNone || fTargetBlock == NULL)
 933                 return;
 934
 935         region.MakeEmpty();
 936         BPoint startPoint = _GetPointForOffset(fSelectionStart);
 937         BPoint endPoint = _GetPointForOffset(fSelectionEnd);
 938
 939         BRect rect;
 940         if (startPoint.y == endPoint.y) {
 941                 // single line case
 942                 rect.left = startPoint.x;
 943                 rect.top = startPoint.y;
 944                 rect.right = endPoint.x;
 945                 rect.bottom = endPoint.y + fLineHeight;
 946                 region.Include(rect);
 947         } else {
 948                 float currentLine = startPoint.y;
 949
 950                 // first line
 951                 rect.left = startPoint.x;
 952                 rect.top = startPoint.y;
 953                 rect.right = fHexRight;
 954                 rect.bottom = startPoint.y + fLineHeight;
 955                 region.Include(rect);
 956                 currentLine += fLineHeight;
 957
 958                 // middle region
 959                 if (currentLine < endPoint.y) {
 960                         rect.left = fHexLeft;
 961                         rect.top = currentLine;
 962                         rect.right = fHexRight;
 963                         rect.bottom = endPoint.y;
 964                         region.Include(rect);
 965                 }
 966
 967                 rect.left = fHexLeft;
 968                 rect.top = endPoint.y;
 969                 rect.right = endPoint.x;
 970                 rect.bottom = endPoint.y + fLineHeight;
 971                 region.Include(rect);
 972         }
 973 }
 974
 975
 976 void
 977 MemoryView::_GetSelectedText(BString& text) const
 978 {
 979         if (fSelectionStart == fSelectionEnd)
 980                 return;
 981
 982         text.Truncate(0);
 983         const uint8* dataSource = fEditMode ? fEditableData : fTargetBlock->Data();
 984
 985         const char* data = (const char *)dataSource + fSelectionStart;
 986         int16 blockSize = _GetHexDigitsPerBlock() / 2;
 987         int32 count = (fSelectionEnd - fSelectionStart)
 988                 / blockSize;
 989
 990         char buffer[32];
 991         for (int32 i = 0; i < count; i++) {
 992                 _GetNextHexBlock(buffer, sizeof(buffer), data);
 993                 data += blockSize;
 994                 text << buffer;
 995                 if (i < count - 1)
 996                         text << " ";
 997         }
 998 }
 999
1000
1001 void
1002 MemoryView::_CopySelectionToClipboard()
1003 {
1004         BString text;
1005         _GetSelectedText(text);
1006
1007         if (text.Length() > 0) {
1008                 be_clipboard->Lock();
1009                 be_clipboard->Data()->RemoveData("text/plain");
1010                 be_clipboard->Data()->AddData ("text/plain",
1011                         B_MIME_TYPE, text.String(), text.Length());
1012                 be_clipboard->Commit();
1013                 be_clipboard->Unlock();
1014         }
1015 }
1016
1017
1018 void
1019 MemoryView::_HandleAutoScroll()
1020 {
1021         BPoint point;
1022         uint32 buttons;
1023         GetMouse(&point, &buttons);
1024         float difference = 0.0;
1025         int factor = 0;
1026         BRect visibleRect = Bounds();
1027         if (point.y < visibleRect.top)
1028                 difference = point.y - visibleRect.top;
1029         else if (point.y > visibleRect.bottom)
1030                 difference = point.y - visibleRect.bottom;
1031         if (difference != 0.0) {
1032                 factor = (int)(ceilf(difference / fLineHeight));
1033                 _ScrollByLines(factor);
1034         }
1035
1036         MouseMoved(point, B_OUTSIDE_VIEW, NULL);
1037 }
1038
1039
1040 void
1041 MemoryView::_ScrollByLines(int32 lineCount)
1042 {
1043         BScrollBar* vertical = ScrollBar(B_VERTICAL);
1044         if (vertical == NULL)
1045                 return;
1046
1047         float value = vertical->Value();
1048         vertical->SetValue(value + fLineHeight * lineCount);
1049 }
1050
1051
1052 void
1053 MemoryView::_HandleContextMenu(BPoint point)
1054 {
1055         int32 offset = _GetOffsetAt(point);
1056         if (offset < fSelectionStart || offset > fSelectionEnd)
1057                 return;
1058
1059         BPopUpMenu* menu = new(std::nothrow) BPopUpMenu("Options");
1060         if (menu == NULL)
1061                 return;
1062
1063         ObjectDeleter<BPopUpMenu> menuDeleter(menu);
1064         ObjectDeleter<BMenuItem> itemDeleter;
1065         ObjectDeleter<BMessage> messageDeleter;
1066         BMessage* message = NULL;
1067         BMenuItem* item = NULL;
1068         if (fSelectionEnd - fSelectionStart == fTargetAddressSize / 2) {
1069                 BMessage* message = new(std::nothrow) BMessage(MSG_INSPECT_ADDRESS);
1070                 if (message == NULL)
1071                         return;
1072
1073                 target_addr_t address;
1074                 if (fTargetAddressSize == 8)
1075                         address = *((uint32*)(fTargetBlock->Data() + fSelectionStart));
1076                 else
1077                         address = *((uint64*)(fTargetBlock->Data() + fSelectionStart));
1078
1079                 if (fCurrentEndianMode == EndianModeBigEndian)
1080                         address = B_HOST_TO_BENDIAN_INT64(address);
1081                 else
1082                         address = B_HOST_TO_LENDIAN_INT64(address);
1083
1084                 messageDeleter.SetTo(message);
1085                 message->AddUInt64("address", address);
1086                 BMenuItem* item = new(std::nothrow) BMenuItem("Inspect", message);
1087                 if (item == NULL)
1088                         return;
1089
1090                 messageDeleter.Detach();
1091                 itemDeleter.SetTo(item);
1092                 if (!menu->AddItem(item))
1093                         return;
1094
1095                 item->SetTarget(Looper());
1096                 itemDeleter.Detach();
1097         }
1098
1099         message = new(std::nothrow) BMessage(B_COPY);
1100         if (message == NULL)
1101                 return;
1102
1103         messageDeleter.SetTo(message);
1104         item = new(std::nothrow) BMenuItem("Copy", message);
1105         if (item == NULL)
1106                 return;
1107
1108         messageDeleter.Detach();
1109         itemDeleter.SetTo(item);
1110         if (!menu->AddItem(item))
1111                 return;
1112
1113         item->SetTarget(this);
1114         itemDeleter.Detach();
1115         menuDeleter.Detach();
1116
1117         BPoint screenWhere(point);
1118         ConvertToScreen(&screenWhere);
1119         BRect mouseRect(screenWhere, screenWhere);
1120         mouseRect.InsetBy(-4.0, -4.0);
1121         menu->Go(screenWhere, true, false, mouseRect, true);
1122 }
1123
1124
1125 status_t
1126 MemoryView::_SetupEditableData()
1127 {
1128         fEditableData = new(std::nothrow) uint8[fTargetBlock->Size()];
1129         if (fEditableData == NULL)
1130                 return B_NO_MEMORY;
1131
1132         memcpy(fEditableData, fTargetBlock->Data(), fTargetBlock->Size());
1133
1134         if (fHexMode != HexMode8BitInt) {
1135                 fHexMode = HexMode8BitInt;
1136                 if (fListener != NULL)
1137                         fListener->HexModeChanged(fHexMode);
1138
1139                 _RecalcScrollBars();
1140         }
1141
1142         return B_OK;
1143 }
1144
1145
1146 //#pragma mark - Listener
1147
1148
1149 MemoryView::Listener::~Listener()
1150 {
1151 }