src/apps/diskprobe/DataView.cpp

   1 /*
   2  * Copyright 2004-2015, Axel Dörfler, axeld@pinc-software.de.
   3  * Distributed under the terms of the MIT License.
   4  */
   5
   6
   7 #include "DataView.h"
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11
  12 #include <Autolock.h>
  13 #include <Beep.h>
  14 #include <Clipboard.h>
  15 #include <Mime.h>
  16 #include <ScrollBar.h>
  17 #include <Window.h>
  18
  19 #include "DataEditor.h"
  20
  21
  22 static const uint32 kBlockSize = 16;
  23 // TODO: use variable spacing
  24 static const uint32 kHorizontalSpace = 8;
  25 static const uint32 kVerticalSpace = 4;
  26 static const uint32 kPositionLength = 4;
  27
  28 static const uint32 kBlockSpace = 3;
  29 static const uint32 kHexByteWidth = 3;
  30         // these are determined by the implementation of DataView::ConvertLine()
  31
  32
  33 /*!     This function checks if the buffer contains a valid UTF-8
  34         string, following the convention from the DataView::ConvertLine()
  35         method: everything that's not replaced by a '.' will be accepted.
  36 */
  37 bool
  38 is_valid_utf8(uint8 *data, size_t size)
  39 {
  40         for (size_t i = 0; i < size; i++) {
  41                 // accept a terminating null byte
  42                 if (i == size - 1 && data[i] == '\0')
  43                         return true;
  44
  45                 if ((data[i] & 0x80) == 0) {
  46                         // a single byte character
  47                         if ((data[i] < ' '
  48                                         && data[i] != 0x0d && data[i] != 0x09 && data[i] != 0x0a)
  49                                 || data[i] == 0x7f)
  50                                 return false;
  51
  52                         continue;
  53                 }
  54
  55                 if ((data[i] & 0xc0) == 0x80) {
  56                         // not a proper multibyte start
  57                         return false;
  58                 }
  59
  60                 // start of a multibyte character
  61                 uint8 mask = 0x80;
  62                 uint32 result = (uint32)(data[i++] & 0xff);
  63
  64                 while (result & mask) {
  65                         if (mask == 0x02) {
  66                                 // seven byte char - invalid
  67                                 return false;
  68                         }
  69
  70                         result &= ~mask;
  71                         mask >>= 1;
  72                 }
  73
  74                 while (i < size && (data[i] & 0xc0) == 0x80) {
  75                         result <<= 6;
  76                         result += data[i++] & 0x3f;
  77
  78                         mask <<= 1;
  79                         if (mask == 0x40)
  80                                 break;
  81                 }
  82
  83                 if (mask != 0x40) {
  84                         // not enough bytes in multibyte char
  85                         return false;
  86                 }
  87         }
  88
  89         return true;
  90 }
  91
  92
  93 //      #pragma mark -
  94
  95
  96 DataView::DataView(DataEditor &editor)
  97         : BView("dataView", B_WILL_DRAW | B_NAVIGABLE | B_FRAME_EVENTS),
  98         fEditor(editor),
  99         fFocus(kHexFocus),
 100         fBase(kHexBase),
 101         fIsActive(true),
 102         fMouseSelectionStart(-1),
 103         fKeySelectionStart(-1),
 104         fBitPosition(0),
 105         fFitFontSize(false),
 106         fDragMessageSize(-1)
 107 {
 108         fStart = fEnd = 0;
 109
 110         if (fEditor.Lock()) {
 111                 fDataSize = fEditor.ViewSize();
 112                 fOffset = fEditor.ViewOffset();
 113                 fEditor.Unlock();
 114         } else
 115                 fDataSize = 512;
 116         fData = (uint8 *)malloc(fDataSize);
 117
 118         SetFontSize(12.0);
 119                 // also sets the fixed font
 120
 121         UpdateFromEditor();
 122 }
 123
 124
 125 DataView::~DataView()
 126 {
 127 }
 128
 129
 130 void
 131 DataView::DetachedFromWindow()
 132 {
 133         fEditor.StopWatching(this);
 134 }
 135
 136
 137 void
 138 DataView::AttachedToWindow()
 139 {
 140         fEditor.StartWatching(this);
 141         MakeFocus(true);
 142                 // this seems to be necessary - if we don't do this here,
 143                 // the view is sometimes focus, but IsFocus() returns false...
 144
 145         SetViewUIColor(B_DOCUMENT_BACKGROUND_COLOR);
 146         SetLowUIColor(ViewUIColor());
 147         SetHighUIColor(B_DOCUMENT_TEXT_COLOR);
 148 }
 149
 150
 151 void
 152 DataView::UpdateFromEditor(BMessage *message)
 153 {
 154         if (fData == NULL)
 155                 return;
 156
 157         BAutolock locker(fEditor);
 158
 159         fFileSize = fEditor.FileSize();
 160
 161         // get the range of the changes
 162
 163         int32 start = 0, end = fDataSize - 1;
 164         off_t offset, size;
 165         if (message != NULL
 166                 && message->FindInt64("offset", &offset) == B_OK
 167                 && message->FindInt64("size", &size) == B_OK) {
 168                 if (offset > fOffset + (off_t)fDataSize
 169                         || offset + (off_t)size < fOffset) {
 170                         // the changes are not within our scope, so we can ignore them
 171                         return;
 172                 }
 173
 174                 if (offset > fOffset)
 175                         start = offset - fOffset;
 176                 if (offset + (off_t)size < fOffset + (off_t)fDataSize)
 177                         end = offset + size - fOffset;
 178         }
 179
 180         if (fOffset + (off_t)fDataSize > fFileSize)
 181                 fSizeInView = fFileSize - fOffset;
 182         else
 183                 fSizeInView = fDataSize;
 184
 185         const uint8 *data;
 186         if (fEditor.GetViewBuffer(&data) == B_OK)
 187                 // ToDo: copy only the relevant part
 188                 memcpy(fData, data, fDataSize);
 189
 190         InvalidateRange(start, end);
 191
 192         // we notify our selection listeners also if the
 193         // data in the selection has changed
 194         if (start <= fEnd && end >= fStart) {
 195                 BMessage update;
 196                 update.AddInt64("start", fStart);
 197                 update.AddInt64("end", fEnd);
 198                 SendNotices(kDataViewSelection, &update);
 199         }
 200 }
 201
 202
 203 bool
 204 DataView::AcceptsDrop(const BMessage *message)
 205 {
 206         return !fEditor.IsReadOnly()
 207                 && (message->HasData("text/plain", B_MIME_TYPE)
 208                         || message->HasData(B_FILE_MIME_TYPE, B_MIME_TYPE));
 209 }
 210
 211
 212 void
 213 DataView::MessageReceived(BMessage *message)
 214 {
 215         switch (message->what) {
 216                 case kMsgUpdateData:
 217                 case kMsgDataEditorUpdate:
 218                         UpdateFromEditor(message);
 219                         break;
 220
 221                 case kMsgDataEditorParameterChange:
 222                 {
 223                         int32 viewSize;
 224                         off_t offset;
 225                         if (message->FindInt64("offset", &offset) == B_OK) {
 226                                 fOffset = offset;
 227                                 SetSelection(0, 0);
 228                                 MakeVisible(0);
 229                         }
 230                         if (message->FindInt32("view_size", &viewSize) == B_OK) {
 231                                 fDataSize = viewSize;
 232                                 fData = (uint8 *)realloc(fData, fDataSize);
 233                                 UpdateScroller();
 234                                 SendNotices(kDataViewPreferredSize);
 235                         }
 236                         if (message->FindInt64("file_size", &offset) == B_OK)
 237                                 UpdateFromEditor();
 238                         break;
 239                 }
 240
 241                 case kMsgBaseType:
 242                 {
 243                         int32 type;
 244                         if (message->FindInt32("base", &type) != B_OK)
 245                                 break;
 246
 247                         SetBase((base_type)type);
 248                         break;
 249                 }
 250
 251                 case kMsgSetSelection:
 252                 {
 253                         int64 start, end;
 254                         if (message->FindInt64("start", &start) != B_OK
 255                                 || message->FindInt64("end", &end) != B_OK)
 256                                 break;
 257
 258                         SetSelection(start, end);
 259                         break;
 260                 }
 261
 262                 case B_SELECT_ALL:
 263                         SetSelection(0, fDataSize - 1);
 264                         break;
 265
 266                 case B_COPY:
 267                         Copy();
 268                         break;
 269
 270                 case B_PASTE:
 271                         Paste();
 272                         break;
 273
 274                 case B_UNDO:
 275                         fEditor.Undo();
 276                         break;
 277
 278                 case B_REDO:
 279                         fEditor.Redo();
 280                         break;
 281
 282                 case B_MIME_DATA:
 283                         if (AcceptsDrop(message)) {
 284                                 const void *data;
 285                                 ssize_t size;
 286                                 if (message->FindData("text/plain", B_MIME_TYPE, &data, &size) == B_OK
 287                                         || message->FindData(B_FILE_MIME_TYPE, B_MIME_TYPE, &data, &size) == B_OK) {
 288                                         if (fEditor.Replace(fOffset + fStart, (const uint8 *)data, size) != B_OK)
 289                                                 SetSelection(fStoredStart, fStoredEnd);
 290
 291                                         fDragMessageSize = -1;
 292                                 }
 293                         }
 294                         break;
 295
 296                 default:
 297                         BView::MessageReceived(message);
 298         }
 299 }
 300
 301
 302 void
 303 DataView::Copy()
 304 {
 305         if (!be_clipboard->Lock())
 306                 return;
 307
 308         be_clipboard->Clear();
 309
 310         BMessage *clip;
 311         if ((clip = be_clipboard->Data()) != NULL) {
 312                 uint8 *data = fData + fStart;
 313                 size_t length = fEnd + 1 - fStart;
 314
 315                 clip->AddData(B_FILE_MIME_TYPE, B_MIME_TYPE, data, length);
 316
 317                 if (is_valid_utf8(data, length))
 318                         clip->AddData("text/plain", B_MIME_TYPE, data, length);
 319
 320                 be_clipboard->Commit();
 321         }
 322
 323         be_clipboard->Unlock();
 324 }
 325
 326
 327 void
 328 DataView::Paste()
 329 {
 330         if (!be_clipboard->Lock())
 331                 return;
 332
 333         const void *data;
 334         ssize_t length;
 335         BMessage *clip;
 336         if ((clip = be_clipboard->Data()) != NULL
 337                 && (clip->FindData(B_FILE_MIME_TYPE, B_MIME_TYPE, &data, &length) == B_OK
 338                         || clip->FindData("text/plain", B_MIME_TYPE, &data, &length) == B_OK)) {
 339                 // we have valid data, but it could still be too
 340                 // large to to fit in the file
 341                 if (fOffset + fStart + length > fFileSize)
 342                         length = fFileSize - fOffset;
 343
 344                 if (fEditor.Replace(fOffset + fStart, (const uint8 *)data, length) == B_OK)
 345                         SetSelection(fStart + length, fStart + length);
 346         } else
 347                 beep();
 348
 349         be_clipboard->Unlock();
 350 }
 351
 352
 353 void
 354 DataView::ConvertLine(char *line, off_t offset, const uint8 *buffer, size_t size)
 355 {
 356         if (size == 0) {
 357                 line[0] = '\0';
 358                 return;
 359         }
 360
 361         line += sprintf(line, fBase == kHexBase ? "%0*" B_PRIxOFF":  " : "%0*"
 362                 B_PRIdOFF":  ", (int)kPositionLength, offset);
 363
 364         for (uint32 i = 0; i < kBlockSize; i++) {
 365                 if (i >= size) {
 366                         strcpy(line, "   ");
 367                         line += kHexByteWidth;
 368                 } else
 369                         line += sprintf(line, "%02x ", *(unsigned char *)(buffer + i));
 370         }
 371
 372         strcpy(line, "   ");
 373         line += 3;
 374
 375         for (uint32 i = 0; i < kBlockSize; i++) {
 376                 if (i < size) {
 377                         char c = buffer[i];
 378
 379                         if (c < ' ' || c == 0x7f)
 380                                 *line++ = '.';
 381                         else
 382                                 *line++ = c;
 383                 } else
 384                         break;
 385         }
 386
 387         *line = '\0';
 388 }
 389
 390
 391 void
 392 DataView::Draw(BRect updateRect)
 393 {
 394         if (fData == NULL || fFileSize == 0)
 395                 return;
 396
 397         // ToDo: take "updateRect" into account!
 398
 399         char line[255];
 400         BPoint location(kHorizontalSpace, kVerticalSpace + fAscent);
 401
 402         for (uint32 i = 0; i < fSizeInView; i += kBlockSize) {
 403                 ConvertLine(line, i, fData + i, fSizeInView - i);
 404                 DrawString(line, location);
 405
 406                 location.y += fFontHeight;
 407         }
 408
 409         DrawSelection();
 410 }
 411
 412
 413 BRect
 414 DataView::DataBounds(bool inView) const
 415 {
 416         return BRect(0, 0,
 417                 fCharWidth * (kBlockSize * 4 + kPositionLength + 6) + 2 * kHorizontalSpace,
 418                 fFontHeight * (((inView ? fSizeInView : fDataSize) + kBlockSize - 1) / kBlockSize)
 419                         + 2 * kVerticalSpace);
 420 }
 421
 422
 423 int32
 424 DataView::PositionAt(view_focus focus, BPoint point, view_focus *_newFocus)
 425 {
 426         // clip the point into our data bounds
 427
 428         BRect bounds = DataBounds(true);
 429         if (point.x < bounds.left)
 430                 point.x = bounds.left;
 431         else if (point.x > bounds.right)
 432                 point.x = bounds.right;
 433
 434         if (point.y < bounds.top)
 435                 point.y = bounds.top;
 436         else if (point.y >= bounds.bottom - kVerticalSpace)
 437                 point.y = bounds.bottom - kVerticalSpace - 1;
 438
 439         float left = fCharWidth * (kPositionLength + kBlockSpace) + kHorizontalSpace;
 440         float hexWidth = fCharWidth * kBlockSize * kHexByteWidth;
 441         float width = fCharWidth;
 442
 443         if (focus == kNoFocus) {
 444                 // find in which part the point is in
 445                 if (point.x < left - width / 2)
 446                         return -1;
 447
 448                 if (point.x > left + hexWidth)
 449                         focus = kAsciiFocus;
 450                 else
 451                         focus = kHexFocus;
 452
 453                 if (_newFocus)
 454                         *_newFocus = focus;
 455         }
 456         if (focus == kHexFocus) {
 457                 left -= width / 2;
 458                 width *= kHexByteWidth;
 459         } else
 460                 left += hexWidth + (kBlockSpace * width);
 461
 462         int32 row = int32((point.y - kVerticalSpace) / fFontHeight);
 463         int32 column = int32((point.x - left) / width);
 464         if (column >= (int32)kBlockSize)
 465                 column = (int32)kBlockSize - 1;
 466         else if (column < 0)
 467                 column = 0;
 468
 469         return row * kBlockSize + column;
 470 }
 471
 472
 473 BRect
 474 DataView::SelectionFrame(view_focus which, int32 start, int32 end)
 475 {
 476         float spacing = 0;
 477         float width = fCharWidth;
 478         float byteWidth = fCharWidth;
 479         float left;
 480
 481         if (which == kHexFocus) {
 482                 spacing = fCharWidth / 2;
 483                 left = width * (kPositionLength + kBlockSpace);
 484                 width *= kHexByteWidth;
 485                 byteWidth *= 2;
 486         } else
 487                 left = width * (kPositionLength + 2 * kBlockSpace + kHexByteWidth * kBlockSize);
 488
 489         left += kHorizontalSpace;
 490         float startInLine = (start % kBlockSize) * width;
 491         float endInLine = (end % kBlockSize) * width + byteWidth - 1;
 492
 493         return BRect(left + startInLine - spacing,
 494                 kVerticalSpace + (start / kBlockSize) * fFontHeight,
 495                 left + endInLine + spacing,
 496                 kVerticalSpace + (end / kBlockSize + 1) * fFontHeight - 1);
 497 }
 498
 499
 500 void
 501 DataView::DrawSelectionFrame(view_focus which)
 502 {
 503         if (fFileSize == 0)
 504                 return;
 505
 506         bool drawBlock = false;
 507         bool drawLastLine = false;
 508         BRect block, lastLine;
 509         int32 spacing = 0;
 510         if (which == kAsciiFocus)
 511                 spacing++;
 512
 513         // draw first line
 514
 515         int32 start = fStart % kBlockSize;
 516         int32 first = (fStart / kBlockSize) * kBlockSize;
 517
 518         int32 end = fEnd;
 519         if (end > first + (int32)kBlockSize - 1)
 520                 end = first + kBlockSize - 1;
 521
 522         BRect firstLine = SelectionFrame(which, first + start, end);
 523         firstLine.right += spacing;
 524         first += kBlockSize;
 525
 526         // draw block (and last line) if necessary
 527
 528         end = fEnd % kBlockSize;
 529         int32 last = (fEnd / kBlockSize) * kBlockSize;
 530
 531         if (last >= first) {
 532                 if (end == kBlockSize - 1)
 533                         last += kBlockSize;
 534                 if (last > first) {
 535                         block = SelectionFrame(which, first, last - 1);
 536                         block.right += spacing;
 537                         drawBlock = true;
 538                 }
 539                 if (end != kBlockSize - 1) {
 540                         lastLine = SelectionFrame(which, last, last + end);
 541                         lastLine.right += spacing;
 542                         drawLastLine = true;
 543                 }
 544         }
 545
 546         SetDrawingMode(B_OP_INVERT);
 547         BeginLineArray(8);
 548
 549         // +*******
 550         // |      *
 551         // +------+
 552
 553         const rgb_color color = {0, 0, 0};
 554         float bottom;
 555         if (drawBlock)
 556                 bottom = block.bottom;
 557         else
 558                 bottom = firstLine.bottom;
 559
 560         AddLine(BPoint(firstLine.left + 1, firstLine.top), firstLine.RightTop(), color);
 561         AddLine(BPoint(firstLine.right, firstLine.top + 1), BPoint(firstLine.right, bottom), color);
 562
 563         // *-------+
 564         // *       |
 565         // *********
 566
 567         BRect rect;
 568         if (start == 0 || (!drawBlock && !drawLastLine))
 569                 rect = firstLine;
 570         else if (drawBlock)
 571                 rect = block;
 572         else
 573                 rect = lastLine;
 574
 575         if (drawBlock)
 576                 rect.bottom = block.bottom;
 577         if (drawLastLine) {
 578                 rect.bottom = lastLine.bottom;
 579                 rect.right = lastLine.right;
 580         }
 581         rect.bottom++;
 582
 583         AddLine(rect.LeftTop(), rect.LeftBottom(), color);
 584         AddLine(BPoint(rect.left + 1, rect.bottom), rect.RightBottom(), color);
 585
 586         //     *--------+
 587         //     *        |
 588         // +****        |
 589         // |            |
 590
 591         if (start && (drawLastLine || drawBlock)) {
 592                 AddLine(firstLine.LeftTop(), firstLine.LeftBottom(), color);
 593
 594                 float right = firstLine.left;
 595                 if (!drawBlock && right > lastLine.right)
 596                         right = lastLine.right;
 597                 AddLine(BPoint(rect.left + 1, rect.top), BPoint(right, rect.top), color);
 598         }
 599
 600         // |            |
 601         // |        *****
 602         // |        *
 603         // +--------+
 604
 605         if (drawLastLine) {
 606                 AddLine(lastLine.RightBottom(), BPoint(lastLine.right, lastLine.top + 1), color);
 607                 if (!drawBlock && lastLine.right <= firstLine.left)
 608                         lastLine.right = firstLine.left + (lastLine.right < firstLine.left ? 0 : 1);
 609                 AddLine(BPoint(lastLine.right, lastLine.top), BPoint(firstLine.right, lastLine.top), color);
 610         }
 611
 612         EndLineArray();
 613         SetDrawingMode(B_OP_COPY);
 614 }
 615
 616
 617 void
 618 DataView::DrawSelectionBlock(view_focus which, int32 blockStart, int32 blockEnd)
 619 {
 620         if (fFileSize == 0)
 621                 return;
 622
 623         // draw first line
 624
 625         SetDrawingMode(B_OP_INVERT);
 626
 627         int32 start = blockStart % kBlockSize;
 628         int32 first = (blockStart / kBlockSize) * kBlockSize;
 629
 630         int32 end = blockEnd;
 631         if (end > first + (int32)kBlockSize - 1)
 632                 end = first + kBlockSize - 1;
 633
 634         FillRect(SelectionFrame(which, first + start, end));
 635         first += kBlockSize;
 636
 637         // draw block (and last line) if necessary
 638
 639         end = blockEnd % kBlockSize;
 640         int32 last = (blockEnd / kBlockSize) * kBlockSize;
 641
 642         if (last >= first) {
 643                 if (end == kBlockSize - 1)
 644                         last += kBlockSize;
 645
 646                 if (last > first)
 647                         FillRect(SelectionFrame(which, first, last - 1));
 648                 if (end != kBlockSize - 1)
 649                         FillRect(SelectionFrame(which, last, last + end));
 650         }
 651
 652         SetDrawingMode(B_OP_COPY);
 653 }
 654
 655
 656 void
 657 DataView::DrawSelectionBlock(view_focus which)
 658 {
 659         DrawSelectionBlock(which, fStart, fEnd);
 660 }
 661
 662
 663 void
 664 DataView::DrawSelection(bool frameOnly)
 665 {
 666         if (IsFocus() && fIsActive) {
 667                 if (!frameOnly)
 668                         DrawSelectionBlock(fFocus);
 669                 DrawSelectionFrame(fFocus == kHexFocus ? kAsciiFocus : kHexFocus);
 670         } else {
 671                 DrawSelectionFrame(kHexFocus);
 672                 DrawSelectionFrame(kAsciiFocus);
 673         }
 674 }
 675
 676
 677 void
 678 DataView::SetSelection(int32 start, int32 end, view_focus focus)
 679 {
 680         // correct the values if necessary
 681
 682         if (start > end) {
 683                 int32 temp = start;
 684                 start = end;
 685                 end = temp;
 686         }
 687
 688         if (start > (int32)fSizeInView - 1)
 689                 start = (int32)fSizeInView - 1;
 690         if (start < 0)
 691                 start = 0;
 692
 693         if (end > (int32)fSizeInView - 1)
 694                 end = (int32)fSizeInView - 1;
 695         if (end < 0)
 696                 end = 0;
 697
 698         if (fStart == start && fEnd == end) {
 699                 // nothing has changed, no need to update
 700                 return;
 701         }
 702
 703         // notify our listeners
 704         if (fStart != start) {
 705                 BMessage update;
 706                 update.AddInt64("position", start);
 707                 SendNotices(kDataViewCursorPosition, &update);
 708         }
 709
 710         BMessage update;
 711         update.AddInt64("start", start);
 712         update.AddInt64("end", end);
 713         SendNotices(kDataViewSelection, &update);
 714
 715         // Update selection - first, we need to remove the old selection, then
 716         // we redraw the selection with the current values.
 717
 718         DrawSelection(focus == kNoFocus);
 719                 // From the block selection, only the parts that need updating are
 720                 // actually updated, if there is no focus change.
 721
 722         if (IsFocus() && fIsActive && focus == kNoFocus) {
 723                 // Update the selection block incrementally
 724
 725                 if (start > fStart) {
 726                         // remove from the top
 727                         DrawSelectionBlock(fFocus, fStart, start - 1);
 728                 } else if (start < fStart) {
 729                         // add to the top
 730                         DrawSelectionBlock(fFocus, start, fStart - 1);
 731                 }
 732
 733                 if (end < fEnd) {
 734                         // remove from bottom
 735                         DrawSelectionBlock(fFocus, end + 1, fEnd);
 736                 } else if (end > fEnd) {
 737                         // add to the bottom
 738                         DrawSelectionBlock(fFocus, fEnd + 1, end);
 739                 }
 740         }
 741
 742         if (focus != kNoFocus)
 743                 fFocus = focus;
 744         fStart = start;
 745         fEnd = end;
 746
 747         DrawSelection(focus == kNoFocus);
 748
 749         fBitPosition = 0;
 750 }
 751
 752
 753 void
 754 DataView::GetSelection(int32 &start, int32 &end)
 755 {
 756         start = fStart;
 757         end = fEnd;
 758 }
 759
 760
 761 void
 762 DataView::InvalidateRange(int32 start, int32 end)
 763 {
 764         if (start <= 0 && end >= int32(fDataSize) - 1) {
 765                 Invalidate();
 766                 return;
 767         }
 768
 769         int32 startLine = start / kBlockSize;
 770         int32 endLine = end / kBlockSize;
 771
 772         if (endLine > startLine) {
 773                 start = startLine * kBlockSize;
 774                 end = (endLine + 1) * kBlockSize - 1;
 775         }
 776
 777         // the part with focus
 778         BRect rect = SelectionFrame(fFocus, start, end);
 779         rect.bottom++;
 780         rect.right++;
 781         Invalidate(rect);
 782
 783         // the part without focus
 784         rect = SelectionFrame(fFocus == kHexFocus ? kAsciiFocus : kHexFocus, start, end);
 785         rect.bottom++;
 786         rect.right++;
 787         Invalidate(rect);
 788 }
 789
 790
 791 void
 792 DataView::MakeVisible(int32 position)
 793 {
 794         if (position < 0 || position > int32(fDataSize) - 1)
 795                 return;
 796
 797         BRect frame = SelectionFrame(fFocus, position, position);
 798         BRect bounds = Bounds();
 799         if (bounds.Contains(frame))
 800                 return;
 801
 802         // special case the first and the last line and column, so that
 803         // we can take kHorizontalSpace & kVerticalSpace into account
 804
 805         if ((position % kBlockSize) == 0)
 806                 frame.left -= kHorizontalSpace;
 807         else if ((position % kBlockSize) == kBlockSize - 1)
 808                 frame.right += kHorizontalSpace;
 809
 810         if (position < int32(kBlockSize))
 811                 frame.top -= kVerticalSpace;
 812         else if (position > int32(fDataSize - kBlockSize))
 813                 frame.bottom += kVerticalSpace;
 814
 815         // compute the scroll point
 816
 817         BPoint point = bounds.LeftTop();
 818         if (bounds.left > frame.left)
 819                 point.x = frame.left;
 820         else if (bounds.right < frame.right)
 821                 point.x = frame.right - bounds.Width();
 822
 823         if (bounds.top > frame.top)
 824                 point.y = frame.top;
 825         else if (bounds.bottom < frame.bottom)
 826                 point.y = frame.bottom - bounds.Height();
 827
 828         ScrollTo(point);
 829 }
 830
 831
 832 const uint8 *
 833 DataView::DataAt(int32 start)
 834 {
 835         if (start < 0 || start >= int32(fSizeInView) || fData == NULL)
 836                 return NULL;
 837
 838         return fData + start;
 839 }
 840
 841
 842 /*static*/ int32
 843 DataView::WidthForFontSize(float size)
 844 {
 845         BFont font = be_fixed_font;
 846         font.SetSize(size);
 847
 848         float charWidth = font.StringWidth("w");
 849         return (int32)ceilf(charWidth * (kBlockSize * 4 + kPositionLength + 6)
 850                 + 2 * kHorizontalSpace);
 851 }
 852
 853
 854 void
 855 DataView::SetBase(base_type type)
 856 {
 857         if (fBase == type)
 858                 return;
 859
 860         fBase = type;
 861         Invalidate();
 862 }
 863
 864
 865 void
 866 DataView::SetFocus(view_focus which)
 867 {
 868         if (which == fFocus)
 869                 return;
 870
 871         DrawSelection();
 872         fFocus = which;
 873         DrawSelection();
 874 }
 875
 876
 877 void
 878 DataView::SetActive(bool active)
 879 {
 880         if (active == fIsActive)
 881                 return;
 882
 883         fIsActive = active;
 884
 885         // only redraw the focussed part
 886
 887         if (IsFocus() && active) {
 888                 DrawSelectionFrame(fFocus);
 889                 DrawSelectionBlock(fFocus);
 890         } else {
 891                 DrawSelectionBlock(fFocus);
 892                 DrawSelectionFrame(fFocus);
 893         }
 894 }
 895
 896
 897 void
 898 DataView::WindowActivated(bool active)
 899 {
 900         BView::WindowActivated(active);
 901         SetActive(active);
 902 }
 903
 904
 905 void
 906 DataView::MakeFocus(bool focus)
 907 {
 908         bool previous = IsFocus();
 909         BView::MakeFocus(focus);
 910
 911         if (focus == previous)
 912                 return;
 913
 914         if (Window()->IsActive() && focus)
 915                 SetActive(true);
 916         else if (!Window()->IsActive() || !focus)
 917                 SetActive(false);
 918 }
 919
 920
 921 void
 922 DataView::UpdateScroller()
 923 {
 924         float width, height;
 925         GetPreferredSize(&width, &height);
 926
 927         SetExplicitMinSize(BSize(250, 200));
 928         SetExplicitMaxSize(BSize(B_SIZE_UNSET, height));
 929         SetExplicitPreferredSize(BSize(width, height));
 930
 931         BScrollBar *bar;
 932         if ((bar = ScrollBar(B_HORIZONTAL)) != NULL) {
 933                 float delta = width - Bounds().Width();
 934                 if (delta < 0)
 935                         delta = 0;
 936
 937                 bar->SetRange(0, delta);
 938                 bar->SetSteps(fCharWidth, Bounds().Width());
 939                 bar->SetProportion(Bounds().Width() / width);
 940         }
 941         if ((bar = ScrollBar(B_VERTICAL)) != NULL) {
 942                 float delta = height - Bounds().Height();
 943                 if (delta < 0)
 944                         delta = 0;
 945
 946                 bar->SetRange(0, delta);
 947                 bar->SetSteps(fFontHeight, Bounds().Height());
 948                 bar->SetProportion(Bounds().Height() / height);
 949         }
 950 }
 951
 952
 953 void
 954 DataView::FrameResized(float width, float height)
 955 {
 956         if (fFitFontSize) {
 957                 // adapt the font size to fit in the view's bounds
 958                 float oldSize = FontSize();
 959                 float steps = 0.5f;
 960
 961                 float size;
 962                 for (size = 1.f; size < 100; size += steps) {
 963                         int32 preferredWidth = WidthForFontSize(size);
 964                         if (preferredWidth > width)
 965                                 break;
 966
 967                         if (size > 6)
 968                                 steps = 1.0f;
 969                 }
 970                 size -= steps;
 971
 972                 if (oldSize != size) {
 973                         BFont font = be_fixed_font;
 974                         font.SetSize(size);
 975                         SetFont(&font);
 976
 977                         Invalidate();
 978                 }
 979         }
 980
 981         UpdateScroller();
 982 }
 983
 984
 985 void
 986 DataView::InitiateDrag(view_focus focus)
 987 {
 988         BMessage *drag = new BMessage(B_MIME_DATA);
 989
 990         // Add originator and action
 991         drag->AddPointer("be:originator", this);
 992         //drag->AddString("be:clip_name", "Byte Clipping");
 993         //drag->AddInt32("be_actions", B_TRASH_TARGET);
 994
 995         // Add data (just like in Copy())
 996         uint8 *data = fData + fStart;
 997         size_t length = fEnd + 1 - fStart;
 998
 999         drag->AddData(B_FILE_MIME_TYPE, B_MIME_TYPE, data, length);
1000         if (is_valid_utf8(data, length))
1001                 drag->AddData("text/plain", B_MIME_TYPE, data, length);
1002
1003         // get a frame that contains the whole selection - SelectionFrame()
1004         // only spans a rectangle between the start and the end point, so
1005         // we have to pass it the correct input values
1006
1007         BRect frame;
1008         const int32 width = kBlockSize - 1;
1009         int32 first = fStart & ~width;
1010         int32 last = ((fEnd + width) & ~width) - 1;
1011         if (first == (last & ~width))
1012                 frame = SelectionFrame(focus, fStart, fEnd);
1013         else
1014                 frame = SelectionFrame(focus, first, last);
1015
1016         BRect bounds = Bounds();
1017         if (!bounds.Contains(frame))
1018                 frame = bounds & frame;
1019
1020         DragMessage(drag, frame, NULL);
1021
1022         fStoredStart = fStart;
1023         fStoredEnd = fEnd;
1024         fDragMessageSize = length;
1025 }
1026
1027
1028 void
1029 DataView::MouseDown(BPoint where)
1030 {
1031         MakeFocus(true);
1032
1033         BMessage *message = Looper()->CurrentMessage();
1034         int32 buttons;
1035         if (message == NULL || message->FindInt32("buttons", &buttons) != B_OK)
1036                 return;
1037
1038         view_focus newFocus;
1039         int32 position = PositionAt(kNoFocus, where, &newFocus);
1040
1041         if ((buttons & B_SECONDARY_MOUSE_BUTTON) != 0
1042                 && position >= fStart && position <= fEnd) {
1043                 InitiateDrag(newFocus);
1044                 return;
1045         }
1046
1047         if ((buttons & B_PRIMARY_MOUSE_BUTTON) == 0)
1048                 return;
1049
1050         int32 modifiers = message->FindInt32("modifiers");
1051
1052         fMouseSelectionStart = position;
1053         if (fMouseSelectionStart == -1) {
1054                 // "where" is outside the valid frame
1055                 return;
1056         }
1057
1058         int32 selectionEnd = fMouseSelectionStart;
1059         if (modifiers & B_SHIFT_KEY) {
1060                 // enlarge the current selection
1061                 if (fStart < selectionEnd)
1062                         fMouseSelectionStart = fStart;
1063                 else if (fEnd > selectionEnd)
1064                         fMouseSelectionStart = fEnd;
1065         }
1066         SetSelection(fMouseSelectionStart, selectionEnd, newFocus);
1067
1068         SetMouseEventMask(B_POINTER_EVENTS,
1069                 B_NO_POINTER_HISTORY | B_SUSPEND_VIEW_FOCUS | B_LOCK_WINDOW_FOCUS);
1070 }
1071
1072
1073 void
1074 DataView::MouseMoved(BPoint where, uint32 transit, const BMessage *dragMessage)
1075 {
1076         if (transit == B_EXITED_VIEW && fDragMessageSize > 0) {
1077                 SetSelection(fStoredStart, fStoredEnd);
1078                 fDragMessageSize = -1;
1079         }
1080
1081         if (dragMessage && AcceptsDrop(dragMessage)) {
1082                 // handle drag message and tracking
1083
1084                 if (transit == B_ENTERED_VIEW) {
1085                         fStoredStart = fStart;
1086                         fStoredEnd = fEnd;
1087
1088                         const void *data;
1089                         ssize_t size;
1090                         if (dragMessage->FindData("text/plain", B_MIME_TYPE, &data, &size) == B_OK
1091                                 || dragMessage->FindData("text/plain", B_MIME_TYPE, &data, &size) == B_OK)
1092                                 fDragMessageSize = size;
1093                 } else if (fDragMessageSize > 0) {
1094                         view_focus newFocus;
1095                         int32 start = PositionAt(kNoFocus, where, &newFocus);
1096                         int32 end = start + fDragMessageSize - 1;
1097
1098                         SetSelection(start, end);
1099                         MakeVisible(start);
1100                 }
1101                 return;
1102         }
1103
1104         if (fMouseSelectionStart == -1)
1105                 return;
1106
1107         int32 end = PositionAt(fFocus, where);
1108         if (end == -1)
1109                 return;
1110
1111         SetSelection(fMouseSelectionStart, end);
1112         MakeVisible(end);
1113 }
1114
1115
1116 void
1117 DataView::MouseUp(BPoint where)
1118 {
1119         fMouseSelectionStart = fKeySelectionStart = -1;
1120 }
1121
1122
1123 void
1124 DataView::KeyDown(const char *bytes, int32 numBytes)
1125 {
1126         int32 modifiers;
1127         if (Looper()->CurrentMessage() == NULL
1128                 || Looper()->CurrentMessage()->FindInt32("modifiers", &modifiers) != B_OK)
1129                 modifiers = ::modifiers();
1130
1131         // check if the selection is going to be changed
1132         switch (bytes[0]) {
1133                 case B_LEFT_ARROW:
1134                 case B_RIGHT_ARROW:
1135                 case B_UP_ARROW:
1136                 case B_DOWN_ARROW:
1137                         if (modifiers & B_SHIFT_KEY) {
1138                                 if (fKeySelectionStart == -1)
1139                                         fKeySelectionStart = fStart;
1140                         } else
1141                                 fKeySelectionStart = -1;
1142                         break;
1143         }
1144
1145         switch (bytes[0]) {
1146                 case B_LEFT_ARROW:
1147                 {
1148                         int32 position = fStart - 1;
1149
1150                         if (modifiers & B_SHIFT_KEY) {
1151                                 if (fKeySelectionStart == fEnd)
1152                                         SetSelection(fStart - 1, fEnd);
1153                                 else {
1154                                         SetSelection(fStart, fEnd - 1);
1155                                         position = fEnd;
1156                                 }
1157                         } else
1158                                 SetSelection(fStart - 1, fStart - 1);
1159
1160                         MakeVisible(position);
1161                         break;
1162                 }
1163                 case B_RIGHT_ARROW:
1164                 {
1165                         int32 position = fEnd + 1;
1166
1167                         if (modifiers & B_SHIFT_KEY) {
1168                                 if (fKeySelectionStart == fStart)
1169                                         SetSelection(fStart, fEnd + 1);
1170                                 else
1171                                         SetSelection(fStart + 1, fEnd);
1172                         } else
1173                                 SetSelection(fEnd + 1, fEnd + 1);
1174
1175                         MakeVisible(position);
1176                         break;
1177                 }
1178                 case B_UP_ARROW:
1179                 {
1180                         int32 start, end;
1181                         if (modifiers & B_SHIFT_KEY) {
1182                                 if (fKeySelectionStart == fStart) {
1183                                         start = fEnd - int32(kBlockSize);
1184                                         end = fStart;
1185                                 } else {
1186                                         start = fStart - int32(kBlockSize);
1187                                         end = fEnd;
1188                                 }
1189                                 if (start < 0)
1190                                         start = 0;
1191                         } else {
1192                                 start = fStart - int32(kBlockSize);
1193                                 if (start < 0)
1194                                         start = fStart;
1195
1196                                 end = start;
1197                         }
1198
1199                         SetSelection(start, end);
1200                         MakeVisible(start);
1201                         break;
1202                 }
1203                 case B_DOWN_ARROW:
1204                 {
1205                         int32 start, end;
1206                         if (modifiers & B_SHIFT_KEY) {
1207                                 if (fKeySelectionStart == fEnd) {
1208                                         start = fEnd;
1209                                         end = fStart + int32(kBlockSize);
1210                                 } else {
1211                                         start = fStart;
1212                                         end = fEnd + int32(kBlockSize);
1213                                 }
1214                                 if (end >= int32(fSizeInView))
1215                                         end = int32(fSizeInView) - 1;
1216                         } else {
1217                                 end = fEnd + int32(kBlockSize);
1218                                 if (end >= int32(fSizeInView))
1219                                         start = fEnd;
1220
1221                                 start = end;
1222                         }
1223
1224                         SetSelection(start, end);
1225                         MakeVisible(end);
1226                         break;
1227                 }
1228
1229                 case B_PAGE_UP:
1230                 {
1231                         // scroll one page up, but keep the same cursor column
1232
1233                         BRect frame = SelectionFrame(fFocus, fStart, fStart);
1234                         frame.OffsetBy(0, -Bounds().Height());
1235                         if (frame.top <= kVerticalSpace)
1236                                 frame.top = kVerticalSpace + 1;
1237                         ScrollBy(0, -Bounds().Height());
1238
1239                         int32 position = PositionAt(fFocus, frame.LeftTop());
1240                         SetSelection(position, position);
1241                         break;
1242                 }
1243                 case B_PAGE_DOWN:
1244                 {
1245                         // scroll one page down, but keep the same cursor column
1246
1247                         BRect frame = SelectionFrame(fFocus, fStart, fStart);
1248                         frame.OffsetBy(0, Bounds().Height());
1249
1250                         float lastLine = DataBounds().Height() - 1 - kVerticalSpace;
1251                         if (frame.top > lastLine)
1252                                 frame.top = lastLine;
1253                         ScrollBy(0, Bounds().Height());
1254
1255                         int32 position = PositionAt(fFocus, frame.LeftTop());
1256                         SetSelection(position, position);
1257                         break;
1258                 }
1259                 case B_HOME:
1260                         SetSelection(0, 0);
1261                         MakeVisible(fStart);
1262                         break;
1263                 case B_END:
1264                         SetSelection(fDataSize - 1, fDataSize - 1);
1265                         MakeVisible(fStart);
1266                         break;
1267                 case B_TAB:
1268                         SetFocus(fFocus == kHexFocus ? kAsciiFocus : kHexFocus);
1269                         MakeVisible(fStart);
1270                         break;
1271
1272                 case B_FUNCTION_KEY:
1273                         // this is ignored
1274                         break;
1275
1276                 case B_BACKSPACE:
1277                         if (fBitPosition == 0)
1278                                 SetSelection(fStart - 1, fStart - 1);
1279
1280                         if (fFocus == kHexFocus)
1281                                 fBitPosition = (fBitPosition + 4) % 8;
1282
1283                         // supposed to fall through
1284                 case B_DELETE:
1285                         SetSelection(fStart, fStart);
1286                                 // to make sure only the cursor is selected
1287
1288                         if (fFocus == kHexFocus) {
1289                                 const uint8 *data = DataAt(fStart);
1290                                 if (data == NULL)
1291                                         break;
1292
1293                                 uint8 c = data[0] & (fBitPosition == 0 ? 0x0f : 0xf0);
1294                                         // mask out region to be cleared
1295
1296                                 fEditor.Replace(fOffset + fStart, &c, 1);
1297                         } else
1298                                 fEditor.Replace(fOffset + fStart, (const uint8 *)"", 1);
1299                         break;
1300
1301                 default:
1302                         if (fFocus == kHexFocus) {
1303                                 // only hexadecimal characters are allowed to be entered
1304                                 const uint8 *data = DataAt(fStart);
1305                                 uint8 c = bytes[0];
1306                                 if (c >= 'A' && c <= 'F')
1307                                         c += 'A' - 'a';
1308                                 const char *hexNumbers = "0123456789abcdef";
1309                                 addr_t number;
1310                                 if (data == NULL || (number = (addr_t)strchr(hexNumbers, c)) == 0)
1311                                         break;
1312
1313                                 SetSelection(fStart, fStart);
1314                                         // to make sure only the cursor is selected
1315
1316                                 number -= (addr_t)hexNumbers;
1317                                 fBitPosition = (fBitPosition + 4) % 8;
1318
1319                                 c = (data[0] & (fBitPosition ? 0x0f : 0xf0)) | (number << fBitPosition);
1320                                         // mask out overwritten region and bit-wise or the number to be inserted
1321
1322                                 if (fEditor.Replace(fOffset + fStart, &c, 1) == B_OK && fBitPosition == 0)
1323                                         SetSelection(fStart + 1, fStart + 1);
1324                         } else {
1325                                 if (fEditor.Replace(fOffset + fStart, (const uint8 *)bytes, numBytes) == B_OK)
1326                                         SetSelection(fStart + 1, fStart + 1);
1327                         }
1328                         break;
1329         }
1330 }
1331
1332
1333 void
1334 DataView::SetFont(const BFont *font, uint32 properties)
1335 {
1336         if (!font->IsFixed())
1337                 return;
1338
1339         BView::SetFont(font, properties);
1340
1341         font_height fontHeight;
1342         font->GetHeight(&fontHeight);
1343
1344         fFontHeight = int32(fontHeight.ascent + fontHeight.descent + fontHeight.leading);
1345         fAscent = fontHeight.ascent;
1346         fCharWidth = font->StringWidth("w");
1347 }
1348
1349
1350 float
1351 DataView::FontSize() const
1352 {
1353         BFont font;
1354         GetFont(&font);
1355
1356         return font.Size();
1357 }
1358
1359
1360 void
1361 DataView::SetFontSize(float point)
1362 {
1363         bool fit = (point == 0.0f);
1364         if (fit) {
1365                 if (!fFitFontSize)
1366                         SendNotices(kDataViewPreferredSize);
1367                 fFitFontSize = fit;
1368
1369                 FrameResized(Bounds().Width(), Bounds().Height());
1370                 return;
1371         }
1372
1373         fFitFontSize = false;
1374
1375         BFont font = be_fixed_font;
1376         font.SetSize(point);
1377
1378         SetFont(&font);
1379         UpdateScroller();
1380         Invalidate();
1381
1382         SendNotices(kDataViewPreferredSize);
1383 }
1384
1385
1386 void
1387 DataView::GetPreferredSize(float *_width, float *_height)
1388 {
1389         BRect bounds = DataBounds();
1390
1391         if (_width)
1392                 *_width = bounds.Width();
1393
1394         if (_height)
1395                 *_height = bounds.Height();
1396 }
1397