src/apps/sudoku/SudokuView.cpp

   1 /*
   2  * Copyright 2007-2015, Axel Dörfler, axeld@pinc-software.de.
   3  * Distributed under the terms of the MIT License.
   4  */
   5
   6
   7 #include "SudokuView.h"
   8
   9 #include "Sudoku.h"
  10 #include "SudokuField.h"
  11 #include "SudokuSolver.h"
  12
  13 #include <ctype.h>
  14 #include <errno.h>
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17
  18 #include <Application.h>
  19 #include <Beep.h>
  20 #include <Bitmap.h>
  21 #include <Clipboard.h>
  22 #include <DataIO.h>
  23 #include <Dragger.h>
  24 #include <File.h>
  25 #include <NodeInfo.h>
  26 #include <Path.h>
  27 #include <Picture.h>
  28 #include <String.h>
  29
  30
  31 static const uint32 kMsgCheckSolved = 'chks';
  32
  33 static const uint32 kStrongLineSize = 2;
  34
  35 static const rgb_color kBackgroundColor = {255, 255, 240};
  36 static const rgb_color kHintColor = {255, 115, 0};
  37 static const rgb_color kValueColor = {0, 91, 162};
  38 static const rgb_color kValueCompletedColor = {55, 140, 35};
  39 static const rgb_color kInvalidValueColor = {200, 0, 0};
  40 static const rgb_color kValueHintBackgroundColor = {255, 215, 127};
  41 static const rgb_color kHintValueHintBackgroundColor = {255, 235, 185};
  42
  43 extern const char* kSignature;
  44
  45
  46 SudokuView::SudokuView(BRect frame, const char* name,
  47                 const BMessage& settings, uint32 resizingMode)
  48         :
  49         BView(frame, name, resizingMode,
  50                 B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE | B_FRAME_EVENTS)
  51 {
  52         _InitObject(&settings);
  53
  54 #if 0
  55         BRect rect(Bounds());
  56         rect.top = rect.bottom - 7;
  57         rect.left = rect.right - 7;
  58         BDragger* dragger = new BDragger(rect, this);
  59         AddChild(dragger);
  60 #endif
  61 }
  62
  63
  64 SudokuView::SudokuView(const char* name, const BMessage& settings)
  65         :
  66         BView(name,
  67                 B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE | B_FRAME_EVENTS)
  68 {
  69         _InitObject(&settings);
  70 }
  71
  72
  73 SudokuView::SudokuView(BMessage* archive)
  74         :
  75         BView(archive)
  76 {
  77         _InitObject(archive);
  78 }
  79
  80
  81 SudokuView::~SudokuView()
  82 {
  83         delete fField;
  84 }
  85
  86
  87 status_t
  88 SudokuView::Archive(BMessage* into, bool deep) const
  89 {
  90         status_t status;
  91
  92         status = BView::Archive(into, deep);
  93         if (status < B_OK)
  94                 return status;
  95
  96         status = into->AddString("add_on", kSignature);
  97         if (status < B_OK)
  98                 return status;
  99
 100         status = into->AddRect("bounds", Bounds());
 101         if (status < B_OK)
 102                 return status;
 103
 104         status = SaveState(*into);
 105         if (status < B_OK)
 106                 return status;
 107         return B_OK;
 108 }
 109
 110
 111 BArchivable*
 112 SudokuView::Instantiate(BMessage* archive)
 113 {
 114         if (!validate_instantiation(archive, "SudokuView"))
 115                 return NULL;
 116         return new SudokuView(archive);
 117 }
 118
 119
 120 status_t
 121 SudokuView::SaveState(BMessage& state) const
 122 {
 123         BMessage field;
 124         status_t status = fField->Archive(&field, true);
 125         if (status == B_OK)
 126                 status = state.AddMessage("field", &field);
 127         if (status == B_OK)
 128                 status = state.AddInt32("hint flags", fHintFlags);
 129         if (status == B_OK)
 130                 status = state.AddBool("show cursor", fShowCursor);
 131
 132         return status;
 133 }
 134
 135
 136 status_t
 137 SudokuView::SetTo(entry_ref& ref)
 138 {
 139         BPath path;
 140         status_t status = path.SetTo(&ref);
 141         if (status < B_OK)
 142                 return status;
 143
 144         FILE* file = fopen(path.Path(), "r");
 145         if (file == NULL)
 146                 return errno;
 147
 148         uint32 maxOut = fField->Size() * fField->Size();
 149         char buffer[1024];
 150         char line[1024];
 151         bool ignore = false;
 152         uint32 out = 0;
 153
 154         while (fgets(line, sizeof(line), file) != NULL
 155                 && out < maxOut) {
 156                 status = _FilterString(line, sizeof(line), buffer, out, ignore);
 157                 if (status < B_OK) {
 158                         fclose(file);
 159                         return status;
 160                 }
 161         }
 162
 163         _PushUndo();
 164         status = fField->SetTo(_BaseCharacter(), buffer);
 165         fValueHintValue = UINT32_MAX;
 166         Invalidate();
 167         fclose(file);
 168         return status;
 169 }
 170
 171
 172 status_t
 173 SudokuView::SetTo(const char* data)
 174 {
 175         if (data == NULL)
 176                 return B_BAD_VALUE;
 177
 178         char buffer[1024];
 179         bool ignore = false;
 180         uint32 out = 0;
 181
 182         status_t status = _FilterString(data, 65536, buffer, out, ignore);
 183         if (status < B_OK)
 184                 return B_BAD_VALUE;
 185
 186         _PushUndo();
 187         status = fField->SetTo(_BaseCharacter(), buffer);
 188         fValueHintValue = UINT32_MAX;
 189         Invalidate();
 190         return status;
 191 }
 192
 193
 194 status_t
 195 SudokuView::SetTo(SudokuField* field)
 196 {
 197         if (field == NULL || field == fField)
 198                 return B_BAD_VALUE;
 199
 200         _PushUndo();
 201         delete fField;
 202         fField = field;
 203
 204         fBlockSize = fField->BlockSize();
 205         fValueHintValue = UINT32_MAX;
 206         FrameResized(0, 0);
 207         Invalidate();
 208         return B_OK;
 209 }
 210
 211
 212 status_t
 213 SudokuView::SaveTo(entry_ref& ref, uint32 exportAs)
 214 {
 215         BFile file;
 216         status_t status = file.SetTo(&ref, B_WRITE_ONLY | B_CREATE_FILE
 217                 | B_ERASE_FILE);
 218         if (status < B_OK)
 219                 return status;
 220
 221         return SaveTo(file, exportAs);
 222 }
 223
 224
 225 status_t
 226 SudokuView::SaveTo(BDataIO& stream, uint32 exportAs)
 227 {
 228         BFile* file = dynamic_cast<BFile*>(&stream);
 229         uint32 i = 0;
 230         BNodeInfo nodeInfo;
 231
 232         if (file)
 233                 nodeInfo.SetTo(file);
 234
 235         switch (exportAs) {
 236                 case kExportAsText:
 237                 {
 238                         BString text = "# Written by Sudoku\n\n";
 239                         stream.Write(text.String(), text.Length());
 240
 241                         char* line = text.LockBuffer(1024);
 242                         memset(line, 0, 1024);
 243                         for (uint32 y = 0; y < fField->Size(); y++) {
 244                                 for (uint32 x = 0; x < fField->Size(); x++) {
 245                                         if (x != 0 && x % fBlockSize == 0)
 246                                                 line[i++] = ' ';
 247                                         _SetText(&line[i++], fField->ValueAt(x, y));
 248                                 }
 249                                 line[i++] = '\n';
 250                         }
 251                         text.UnlockBuffer();
 252
 253                         stream.Write(text.String(), text.Length());
 254                         if (file)
 255                                 nodeInfo.SetType("text/plain");
 256                         return B_OK;
 257                 }
 258
 259                 case kExportAsHTML:
 260                 {
 261                         bool netPositiveFriendly = false;
 262                         BString text = "<html>\n<head>\n<!-- Written by Sudoku -->\n"
 263                                 "<style type=\"text/css\">\n"
 264                                 "table.sudoku { background: #000000; border:0; border-collapse: "
 265                                         "collapse; cellpadding: 10px; cellspacing: 10px; width: "
 266                                         "300px; height: 300px; }\n"
 267                                 "td.sudoku { background: #ffffff; border-color: black; "
 268                                         "border-left: none ; border-top: none ; /*border: none;*/ "
 269                                         "text-align: center; }\n"
 270                                 "td.sudoku_initial {  }\n"
 271                                 "td.sudoku_filled { color: blue; }\n"
 272                                 "td.sudoku_empty {  }\n";
 273
 274                         // border styles: right bottom (none, small or large)
 275                         const char* kStyles[] = {"none", "small", "large"};
 276                         const char* kCssStyles[] = {"none", "solid 1px black",
 277                                 "solid 3px black"};
 278                         enum style_type { kNone = 0, kSmall, kLarge };
 279
 280                         for (int32 right = 0; right < 3; right++) {
 281                                 for (int32 bottom = 0; bottom < 3; bottom++) {
 282                                         text << "td.sudoku_";
 283                                         if (right != bottom)
 284                                                 text << kStyles[right] << "_" << kStyles[bottom];
 285                                         else
 286                                                 text << kStyles[right];
 287
 288                                         text << " { border-right: " << kCssStyles[right]
 289                                                 << "; border-bottom: " << kCssStyles[bottom] << "; }\n";
 290                                 }
 291                         }
 292
 293                         text << "</style>\n"
 294                                 "</head>\n<body>\n\n";
 295                         stream.Write(text.String(), text.Length());
 296
 297                         text = "<table";
 298                         if (netPositiveFriendly)
 299                                 text << " border=\"1\"";
 300                         text << " class=\"sudoku\">";
 301                         stream.Write(text.String(), text.Length());
 302
 303                         text = "";
 304                         BString divider;
 305                         divider << (int)(100.0 / fField->Size()) << "%";
 306                         for (uint32 y = 0; y < fField->Size(); y++) {
 307                                 text << "<tr height=\"" << divider << "\">\n";
 308                                 for (uint32 x = 0; x < fField->Size(); x++) {
 309                                         char buff[2];
 310                                         _SetText(buff, fField->ValueAt(x, y));
 311
 312                                         BString style = "sudoku_";
 313                                         style_type right = kSmall;
 314                                         style_type bottom = kSmall;
 315                                         if ((x + 1) % fField->BlockSize() == 0)
 316                                                 right = kLarge;
 317                                         if ((y + 1) % fField->BlockSize() == 0)
 318                                                 bottom = kLarge;
 319                                         if (x == fField->Size() - 1)
 320                                                 right = kNone;
 321                                         if (y == fField->Size() - 1)
 322                                                 bottom = kNone;
 323
 324                                         if (right != bottom)
 325                                                 style << kStyles[right] << "_" << kStyles[bottom];
 326                                         else
 327                                                 style << kStyles[right];
 328
 329                                         if (fField->ValueAt(x, y) == 0) {
 330                                                 text << "<td width=\"" << divider << "\" ";
 331                                                 text << "class=\"sudoku sudoku_empty " << style;
 332                                                 text << "\">\n&nbsp;";
 333                                         } else if (fField->IsInitialValue(x, y)) {
 334                                                 text << "<td width=\"" << divider << "\" ";
 335                                                 text << "class=\"sudoku sudoku_initial " << style
 336                                                         << "\">\n";
 337                                                 if (netPositiveFriendly)
 338                                                         text << "<font color=\"#000000\">";
 339                                                 text << buff;
 340                                                 if (netPositiveFriendly)
 341                                                         text << "</font>";
 342                                         } else {
 343                                                 text << "<td width=\"" << divider << "\" ";
 344                                                 text << "class=\"sudoku sudoku_filled sudoku_" << style
 345                                                         << "\">\n";
 346                                                 if (netPositiveFriendly)
 347                                                         text << "<font color=\"#0000ff\">";
 348                                                 text << buff;
 349                                                 if (netPositiveFriendly)
 350                                                         text << "</font>";
 351                                         }
 352                                         text << "</td>\n";
 353                                 }
 354                                 text << "</tr>\n";
 355                         }
 356                         text << "</table>\n\n";
 357
 358                         stream.Write(text.String(), text.Length());
 359                         text = "</body></html>\n";
 360                         stream.Write(text.String(), text.Length());
 361                         if (file)
 362                                 nodeInfo.SetType("text/html");
 363                         return B_OK;
 364                 }
 365
 366                 case kExportAsBitmap:
 367                 {
 368                         BMallocIO mallocIO;
 369                         status_t status = SaveTo(mallocIO, kExportAsPicture);
 370                         if (status < B_OK)
 371                                 return status;
 372
 373                         mallocIO.Seek(0LL, SEEK_SET);
 374                         BPicture picture;
 375                         status = picture.Unflatten(&mallocIO);
 376                         if (status < B_OK)
 377                                 return status;
 378
 379                         BBitmap* bitmap = new BBitmap(Bounds(), B_BITMAP_ACCEPTS_VIEWS,
 380                                 B_RGB32);
 381                         BView* view = new BView(Bounds(), "bitmap", B_FOLLOW_NONE,
 382                                 B_WILL_DRAW);
 383                         bitmap->AddChild(view);
 384
 385                         if (bitmap->Lock()) {
 386                                 view->DrawPicture(&picture);
 387                                 view->Sync();
 388
 389                                 view->RemoveSelf();
 390                                 delete view;
 391                                         // it should not become part of the archive
 392                                 bitmap->Unlock();
 393                         }
 394
 395                         BMessage archive;
 396                         status = bitmap->Archive(&archive);
 397                         if (status >= B_OK)
 398                                 status = archive.Flatten(&stream);
 399
 400                         delete bitmap;
 401                         return status;
 402                 }
 403
 404                 case kExportAsPicture:
 405                 {
 406                         BPicture picture;
 407                         BeginPicture(&picture);
 408                         Draw(Bounds());
 409
 410                         status_t status = B_ERROR;
 411                         if (EndPicture())
 412                                 status = picture.Flatten(&stream);
 413
 414                         return status;
 415                 }
 416
 417                 default:
 418                         return B_BAD_VALUE;
 419         }
 420 }
 421
 422
 423 status_t
 424 SudokuView::CopyToClipboard()
 425 {
 426         if (!be_clipboard->Lock())
 427                 return B_ERROR;
 428
 429         be_clipboard->Clear();
 430
 431         BMessage* clip = be_clipboard->Data();
 432         if (clip == NULL) {
 433                 be_clipboard->Unlock();
 434                 return B_ERROR;
 435         }
 436
 437         // As BBitmap
 438         BMallocIO mallocIO;
 439         status_t status = SaveTo(mallocIO, kExportAsBitmap);
 440         if (status >= B_OK) {
 441                 mallocIO.Seek(0LL, SEEK_SET);
 442                 // ShowImage, ArtPaint & WonderBrush use that
 443                 status = clip->AddData("image/bitmap", B_MESSAGE_TYPE,
 444                         mallocIO.Buffer(), mallocIO.BufferLength());
 445                 // Becasso uses that ?
 446                 clip->AddData("image/x-be-bitmap", B_MESSAGE_TYPE, mallocIO.Buffer(),
 447                         mallocIO.BufferLength());
 448                 // Gobe Productive uses that...
 449                 // QuickRes as well, with a rect field.
 450                 clip->AddData("image/x-vnd.Be-bitmap", B_MESSAGE_TYPE,
 451                         mallocIO.Buffer(), mallocIO.BufferLength());
 452         }
 453         mallocIO.Seek(0LL, SEEK_SET);
 454         mallocIO.SetSize(0LL);
 455
 456         // As HTML
 457         if (status >= B_OK)
 458                 status = SaveTo(mallocIO, kExportAsHTML);
 459         if (status >= B_OK) {
 460                 status = clip->AddData("text/html", B_MIME_TYPE, mallocIO.Buffer(),
 461                         mallocIO.BufferLength());
 462         }
 463         mallocIO.Seek(0LL, SEEK_SET);
 464         mallocIO.SetSize(0LL);
 465
 466         // As plain text
 467         if (status >= B_OK)
 468                 SaveTo(mallocIO, kExportAsText);
 469         if (status >= B_OK) {
 470                 status = clip->AddData("text/plain", B_MIME_TYPE, mallocIO.Buffer(),
 471                         mallocIO.BufferLength());
 472         }
 473         mallocIO.Seek(0LL, SEEK_SET);
 474         mallocIO.SetSize(0LL);
 475
 476         // As flattened BPicture, anyone handles that?
 477         if (status >= B_OK)
 478                 status = SaveTo(mallocIO, kExportAsPicture);
 479         if (status >= B_OK) {
 480                 status = clip->AddData("image/x-vnd.Be-picture", B_MIME_TYPE,
 481                         mallocIO.Buffer(), mallocIO.BufferLength());
 482         }
 483         mallocIO.SetSize(0LL);
 484
 485         be_clipboard->Commit();
 486         be_clipboard->Unlock();
 487
 488         return status;
 489 }
 490
 491
 492 void
 493 SudokuView::ClearChanged()
 494 {
 495         _PushUndo();
 496
 497         for (uint32 y = 0; y < fField->Size(); y++) {
 498                 for (uint32 x = 0; x < fField->Size(); x++) {
 499                         if (!fField->IsInitialValue(x, y))
 500                                 fField->SetValueAt(x, y, 0);
 501                 }
 502         }
 503
 504         Invalidate();
 505 }
 506
 507
 508 void
 509 SudokuView::ClearAll()
 510 {
 511         _PushUndo();
 512         fField->Reset();
 513         Invalidate();
 514 }
 515
 516
 517 void
 518 SudokuView::SetHintFlags(uint32 flags)
 519 {
 520         if (flags == fHintFlags)
 521                 return;
 522
 523         if ((flags & kMarkInvalid) ^ (fHintFlags & kMarkInvalid))
 524                 Invalidate();
 525
 526         fHintFlags = flags;
 527 }
 528
 529
 530 void
 531 SudokuView::SetEditable(bool editable)
 532 {
 533         fEditable = editable;
 534 }
 535
 536
 537 void
 538 SudokuView::Undo()
 539 {
 540         _UndoRedo(fUndos, fRedos);
 541 }
 542
 543
 544 void
 545 SudokuView::Redo()
 546 {
 547         _UndoRedo(fRedos, fUndos);
 548 }
 549
 550
 551 // #pragma mark - BWindow methods
 552
 553
 554 void
 555 SudokuView::AttachedToWindow()
 556 {
 557         MakeFocus(true);
 558 }
 559
 560
 561 void
 562 SudokuView::FrameResized(float /*width*/, float /*height*/)
 563 {
 564         // font for numbers
 565
 566         uint32 size = fField->Size();
 567         fWidth = (Bounds().Width() + 2 - kStrongLineSize * (fBlockSize - 1)) / size;
 568         fHeight = (Bounds().Height() + 2 - kStrongLineSize * (fBlockSize - 1))
 569                 / size;
 570         _FitFont(fFieldFont, fWidth - 2, fHeight - 2);
 571
 572         font_height fontHeight;
 573         fFieldFont.GetHeight(&fontHeight);
 574         fBaseline = ceilf(fontHeight.ascent) / 2
 575                 + (fHeight - ceilf(fontHeight.descent)) / 2;
 576
 577         // font for hint
 578
 579         fHintWidth = (fWidth - 2) / fBlockSize;
 580         fHintHeight = (fHeight - 2) / fBlockSize;
 581         _FitFont(fHintFont, fHintWidth, fHintHeight);
 582
 583         fHintFont.GetHeight(&fontHeight);
 584         fHintBaseline = ceilf(fontHeight.ascent) / 2
 585                 + (fHintHeight - ceilf(fontHeight.descent)) / 2;
 586
 587         // fix the dragger's position
 588         BView *dragger = FindView("_dragger_");
 589         if (dragger)
 590                 dragger->MoveTo(Bounds().right - 7, Bounds().bottom - 7);
 591 }
 592
 593
 594 void
 595 SudokuView::MouseDown(BPoint where)
 596 {
 597         uint32 x, y;
 598         if (!fEditable || !_GetFieldFor(where, x, y))
 599                 return;
 600
 601         int32 buttons = B_PRIMARY_MOUSE_BUTTON;
 602         int32 clicks = 1;
 603         if (Looper() != NULL && Looper()->CurrentMessage() != NULL) {
 604                 Looper()->CurrentMessage()->FindInt32("buttons", &buttons);
 605                 Looper()->CurrentMessage()->FindInt32("clicks", &clicks);
 606         }
 607
 608         if (buttons == B_PRIMARY_MOUSE_BUTTON && clicks == 1) {
 609                 uint32 value = fField->ValueAt(x, y);
 610                 if (value != 0) {
 611                         _SetValueHintValue(value);
 612                         return;
 613                 }
 614         }
 615
 616         uint32 hintX, hintY;
 617         if (!_GetHintFieldFor(where, x, y, hintX, hintY))
 618                 return;
 619
 620         uint32 value = hintX + hintY * fBlockSize;
 621         uint32 field = x + y * fField->Size();
 622         _PushUndo();
 623         _SetValueHintValue(value + 1);
 624
 625         if ((clicks == 2 && fLastHintValue == value && fLastField == field)
 626                 || (buttons & (B_SECONDARY_MOUSE_BUTTON
 627                                 | B_TERTIARY_MOUSE_BUTTON)) != 0) {
 628                 // Double click or other buttons set or remove a value
 629                 if (!fField->IsInitialValue(x, y))
 630                         _SetValue(x, y, fField->ValueAt(x, y) == 0 ? value + 1 : 0);
 631
 632                 return;
 633         }
 634
 635         _ToggleHintValue(x, y, hintX, hintY, value, field);
 636 }
 637
 638
 639 void
 640 SudokuView::MouseMoved(BPoint where, uint32 transit,
 641         const BMessage* dragMessage)
 642 {
 643         if (transit == B_EXITED_VIEW || dragMessage != NULL) {
 644                 _RemoveHint();
 645                 return;
 646         }
 647
 648         if (fShowKeyboardFocus) {
 649                 fShowKeyboardFocus = false;
 650                 _InvalidateKeyboardFocus(fKeyboardX, fKeyboardY);
 651         }
 652
 653         uint32 x, y;
 654         bool isField = _GetFieldFor(where, x, y);
 655         if (isField) {
 656                 fKeyboardX = x;
 657                 fKeyboardY = y;
 658         }
 659
 660         if (!isField
 661                 || fField->IsInitialValue(x, y)
 662                 || (!fShowCursor && fField->ValueAt(x, y) != 0)) {
 663                 _RemoveHint();
 664                 return;
 665         }
 666
 667         if (fShowHintX == x && fShowHintY == y)
 668                 return;
 669
 670         int32 buttons = 0;
 671         if (Looper() != NULL && Looper()->CurrentMessage() != NULL)
 672                 Looper()->CurrentMessage()->FindInt32("buttons", &buttons);
 673
 674         uint32 field = x + y * fField->Size();
 675
 676         if (buttons != 0 && field != fLastField) {
 677                 // if a button is pressed, we drag the last hint selection
 678                 // (either set or removal) to the field under the mouse
 679                 uint32 hintMask = fField->HintMaskAt(x, y);
 680                 uint32 valueMask = 1UL << fLastHintValue;
 681                 if (fLastHintValueSet)
 682                         hintMask |= valueMask;
 683                 else
 684                         hintMask &= ~valueMask;
 685
 686                 fField->SetHintMaskAt(x, y, hintMask);
 687         }
 688
 689         _RemoveHint();
 690         fShowHintX = x;
 691         fShowHintY = y;
 692         _InvalidateField(x, y);
 693 }
 694
 695
 696 void
 697 SudokuView::KeyDown(const char *bytes, int32 /*numBytes*/)
 698 {
 699         be_app->ObscureCursor();
 700
 701         uint32 x = fKeyboardX, y = fKeyboardY;
 702
 703         switch (bytes[0]) {
 704                 case B_UP_ARROW:
 705                         if (fKeyboardY == 0)
 706                                 fKeyboardY = fField->Size() - 1;
 707                         else
 708                                 fKeyboardY--;
 709                         break;
 710                 case B_DOWN_ARROW:
 711                         if (fKeyboardY == fField->Size() - 1)
 712                                 fKeyboardY = 0;
 713                         else
 714                                 fKeyboardY++;
 715                         break;
 716
 717                 case B_LEFT_ARROW:
 718                         if (fKeyboardX == 0)
 719                                 fKeyboardX = fField->Size() - 1;
 720                         else
 721                                 fKeyboardX--;
 722                         break;
 723                 case B_RIGHT_ARROW:
 724                         if (fKeyboardX == fField->Size() - 1)
 725                                 fKeyboardX = 0;
 726                         else
 727                                 fKeyboardX++;
 728                         break;
 729
 730                 case B_BACKSPACE:
 731                 case B_DELETE:
 732                 case B_SPACE:
 733                         // clear value
 734                         _InsertKey(_BaseCharacter(), 0);
 735                         break;
 736
 737                 default:
 738                         int32 rawKey = bytes[0];
 739                         int32 modifiers = 0;
 740                         if (Looper() != NULL && Looper()->CurrentMessage() != NULL) {
 741                                 Looper()->CurrentMessage()->FindInt32("raw_char", &rawKey);
 742                                 Looper()->CurrentMessage()->FindInt32("modifiers", &modifiers);
 743                         }
 744
 745                         _InsertKey(rawKey, modifiers);
 746                         break;
 747         }
 748
 749         if (!fShowKeyboardFocus && fShowHintX != ~0UL) {
 750                 // always start at last mouse position, if any
 751                 fKeyboardX = fShowHintX;
 752                 fKeyboardY = fShowHintY;
 753         }
 754
 755         _RemoveHint();
 756
 757         // remove old focus, if any
 758         if (fShowKeyboardFocus && (x != fKeyboardX || y != fKeyboardY))
 759                 _InvalidateKeyboardFocus(x, y);
 760
 761         fShowKeyboardFocus = true;
 762         _InvalidateKeyboardFocus(fKeyboardX, fKeyboardY);
 763 }
 764
 765
 766 void
 767 SudokuView::MessageReceived(BMessage* message)
 768 {
 769         switch (message->what) {
 770                 case kMsgCheckSolved:
 771                         if (fField->IsSolved()) {
 772                                 // notify window
 773                                 Looper()->PostMessage(kMsgSudokuSolved);
 774                         }
 775                         break;
 776
 777                 case B_UNDO:
 778                         Undo();
 779                         break;
 780
 781                 case B_REDO:
 782                         Redo();
 783                         break;
 784
 785                 case kMsgSetAllHints:
 786                         _SetAllHints();
 787                         break;
 788
 789                 case kMsgSolveSudoku:
 790                         _Solve();
 791                         break;
 792
 793                 case kMsgSolveSingle:
 794                         _SolveSingle();
 795                         break;
 796
 797                 default:
 798                         BView::MessageReceived(message);
 799                         break;
 800         }
 801 }
 802
 803
 804 void
 805 SudokuView::Draw(BRect /*updateRect*/)
 806 {
 807         // draw lines
 808
 809         uint32 size = fField->Size();
 810
 811         SetLowColor(fBackgroundColor);
 812         SetHighColor(0, 0, 0);
 813
 814         float width = fWidth - 1;
 815         for (uint32 x = 1; x < size; x++) {
 816                 if (x % fBlockSize == 0) {
 817                         FillRect(BRect(width, 0, width + kStrongLineSize,
 818                                 Bounds().Height()));
 819                         width += kStrongLineSize;
 820                 } else {
 821                         StrokeLine(BPoint(width, 0), BPoint(width, Bounds().Height()));
 822                 }
 823                 width += fWidth;
 824         }
 825
 826         float height = fHeight - 1;
 827         for (uint32 y = 1; y < size; y++) {
 828                 if (y % fBlockSize == 0) {
 829                         FillRect(BRect(0, height, Bounds().Width(),
 830                                 height + kStrongLineSize));
 831                         height += kStrongLineSize;
 832                 } else {
 833                         StrokeLine(BPoint(0, height), BPoint(Bounds().Width(), height));
 834                 }
 835                 height += fHeight;
 836         }
 837
 838         // draw text
 839
 840         for (uint32 y = 0; y < size; y++) {
 841                 for (uint32 x = 0; x < size; x++) {
 842                         uint32 value = fField->ValueAt(x, y);
 843
 844                         rgb_color backgroundColor = fBackgroundColor;
 845                         if (value == fValueHintValue)
 846                                 backgroundColor = kValueHintBackgroundColor;
 847                         else if (value == 0 && fField->HasHint(x, y, fValueHintValue))
 848                                 backgroundColor = kHintValueHintBackgroundColor;
 849
 850                         if (((fShowCursor && x == fShowHintX && y == fShowHintY)
 851                                         || (fShowKeyboardFocus && x == fKeyboardX
 852                                                 && y == fKeyboardY))
 853                                 && !fField->IsInitialValue(x, y)) {
 854                                 // TODO: make color more intense
 855                                 SetLowColor(tint_color(backgroundColor, B_DARKEN_2_TINT));
 856                                 FillRect(_Frame(x, y), B_SOLID_LOW);
 857                         } else {
 858                                 SetLowColor(backgroundColor);
 859                                 FillRect(_Frame(x, y), B_SOLID_LOW);
 860                         }
 861
 862                         if (fShowKeyboardFocus && x == fKeyboardX && y == fKeyboardY)
 863                                 _DrawKeyboardFocus();
 864
 865                         if (value == 0) {
 866                                 _DrawHints(x, y);
 867                                 continue;
 868                         }
 869
 870                         SetFont(&fFieldFont);
 871                         if (fField->IsInitialValue(x, y))
 872                                 SetHighColor(0, 0, 0);
 873                         else {
 874                                 if ((fHintFlags & kMarkInvalid) == 0
 875                                         || fField->IsValid(x, y, value)) {
 876                                         if (fField->IsValueCompleted(value))
 877                                                 SetHighColor(kValueCompletedColor);
 878                                         else
 879                                                 SetHighColor(kValueColor);
 880                                 } else
 881                                         SetHighColor(kInvalidValueColor);
 882                         }
 883
 884                         char text[2];
 885                         _SetText(text, value);
 886                         DrawString(text, _LeftTop(x, y)
 887                                 + BPoint((fWidth - StringWidth(text)) / 2, fBaseline));
 888                 }
 889         }
 890 }
 891
 892
 893 // #pragma mark - Private methods
 894
 895
 896 void
 897 SudokuView::_InitObject(const BMessage* archive)
 898 {
 899         fField = NULL;
 900         fShowHintX = UINT32_MAX;
 901         fValueHintValue = UINT32_MAX;
 902         fLastHintValue = UINT32_MAX;
 903         fLastField = UINT32_MAX;
 904         fKeyboardX = 0;
 905         fKeyboardY = 0;
 906         fShowKeyboardFocus = false;
 907         fEditable = true;
 908
 909         BMessage field;
 910         if (archive->FindMessage("field", &field) == B_OK) {
 911                 fField = new SudokuField(&field);
 912                 if (fField->InitCheck() != B_OK) {
 913                         delete fField;
 914                         fField = NULL;
 915                 } else if (fField->IsSolved())
 916                         ClearAll();
 917         }
 918         if (fField == NULL)
 919                 fField = new SudokuField(3);
 920
 921         fBlockSize = fField->BlockSize();
 922
 923         if (archive->FindInt32("hint flags", (int32*)&fHintFlags) != B_OK)
 924                 fHintFlags = kMarkInvalid;
 925         if (archive->FindBool("show cursor", &fShowCursor) != B_OK)
 926                 fShowCursor = false;
 927
 928         SetViewColor(B_TRANSPARENT_COLOR);
 929                 // to avoid flickering
 930         fBackgroundColor = kBackgroundColor;
 931         SetLowColor(fBackgroundColor);
 932         FrameResized(0, 0);
 933 }
 934
 935
 936 status_t
 937 SudokuView::_FilterString(const char* data, size_t dataLength, char* buffer,
 938         uint32& out, bool& ignore)
 939 {
 940         uint32 maxOut = fField->Size() * fField->Size();
 941
 942         for (uint32 i = 0; i < dataLength && data[i]; i++) {
 943                 if (data[i] == '#')
 944                         ignore = true;
 945                 else if (data[i] == '\n')
 946                         ignore = false;
 947
 948                 if (ignore || isspace(data[i]))
 949                         continue;
 950
 951                 if (!_ValidCharacter(data[i])) {
 952                         return B_BAD_VALUE;
 953                 }
 954
 955                 buffer[out++] = data[i];
 956                 if (out == maxOut)
 957                         break;
 958         }
 959
 960         buffer[out] = '\0';
 961         return B_OK;
 962 }
 963
 964
 965 void
 966 SudokuView::_SetText(char* text, uint32 value)
 967 {
 968         text[0] = value + _BaseCharacter();
 969         text[1] = '\0';
 970 }
 971
 972
 973 char
 974 SudokuView::_BaseCharacter()
 975 {
 976         return fField->Size() > 9 ? '@' : '0';
 977 }
 978
 979
 980 bool
 981 SudokuView::_ValidCharacter(char c)
 982 {
 983         char min = _BaseCharacter();
 984         char max = min + fField->Size();
 985         return c >= min && c <= max;
 986 }
 987
 988
 989 BPoint
 990 SudokuView::_LeftTop(uint32 x, uint32 y)
 991 {
 992         return BPoint(x * fWidth - 1 + x / fBlockSize * kStrongLineSize + 1,
 993                 y * fHeight - 1 + y / fBlockSize * kStrongLineSize + 1);
 994 }
 995
 996
 997 BRect
 998 SudokuView::_Frame(uint32 x, uint32 y)
 999 {
1000         BPoint leftTop = _LeftTop(x, y);
1001         BPoint rightBottom = leftTop + BPoint(fWidth - 2, fHeight - 2);
1002
1003         return BRect(leftTop, rightBottom);
1004 }
1005
1006
1007 void
1008 SudokuView::_InvalidateHintField(uint32 x, uint32 y, uint32 hintX,
1009         uint32 hintY)
1010 {
1011         BPoint leftTop = _LeftTop(x, y);
1012         leftTop.x += hintX * fHintWidth;
1013         leftTop.y += hintY * fHintHeight;
1014         BPoint rightBottom = leftTop;
1015         rightBottom.x += fHintWidth;
1016         rightBottom.y += fHintHeight;
1017
1018         Invalidate(BRect(leftTop, rightBottom));
1019 }
1020
1021
1022 void
1023 SudokuView::_InvalidateField(uint32 x, uint32 y)
1024 {
1025         Invalidate(_Frame(x, y));
1026 }
1027
1028
1029 void
1030 SudokuView::_InvalidateValue(uint32 value, bool invalidateHint,
1031         uint32 fieldX, uint32 fieldY)
1032 {
1033         for (uint32 y = 0; y < fField->Size(); y++) {
1034                 for (uint32 x = 0; x < fField->Size(); x++) {
1035                         if (fField->ValueAt(x, y) == value || (x == fieldX && y == fieldY))
1036                                 Invalidate(_Frame(x, y));
1037                         else if (invalidateHint && fField->ValueAt(x, y) == 0
1038                                 && fField->HasHint(x, y, value))
1039                                 Invalidate(_Frame(x, y));
1040                 }
1041         }
1042 }
1043
1044
1045 void
1046 SudokuView::_InvalidateKeyboardFocus(uint32 x, uint32 y)
1047 {
1048         BRect frame = _Frame(x, y);
1049         frame.InsetBy(-1, -1);
1050         Invalidate(frame);
1051 }
1052
1053
1054 void
1055 SudokuView::_InsertKey(char rawKey, int32 modifiers)
1056 {
1057         if (!fEditable || !_ValidCharacter(rawKey)
1058                 || fField->IsInitialValue(fKeyboardX, fKeyboardY))
1059                 return;
1060
1061         uint32 value = rawKey - _BaseCharacter();
1062
1063         if (modifiers & (B_SHIFT_KEY | B_OPTION_KEY)) {
1064                 // set or remove hint
1065                 if (value == 0)
1066                         return;
1067
1068                 _PushUndo();
1069                 uint32 hintMask = fField->HintMaskAt(fKeyboardX, fKeyboardY);
1070                 uint32 valueMask = 1UL << (value - 1);
1071                 if (modifiers & B_OPTION_KEY)
1072                         hintMask &= ~valueMask;
1073                 else
1074                         hintMask |= valueMask;
1075
1076                 fField->SetValueAt(fKeyboardX, fKeyboardY, 0);
1077                 fField->SetHintMaskAt(fKeyboardX, fKeyboardY, hintMask);
1078         } else {
1079                 _PushUndo();
1080                 _SetValue(fKeyboardX, fKeyboardY, value);
1081         }
1082 }
1083
1084
1085 bool
1086 SudokuView::_GetHintFieldFor(BPoint where, uint32 x, uint32 y,
1087         uint32& hintX, uint32& hintY)
1088 {
1089         BPoint leftTop = _LeftTop(x, y);
1090         hintX = (uint32)floor((where.x - leftTop.x) / fHintWidth);
1091         hintY = (uint32)floor((where.y - leftTop.y) / fHintHeight);
1092
1093         if (hintX >= fBlockSize || hintY >= fBlockSize)
1094                 return false;
1095
1096         return true;
1097 }
1098
1099
1100 bool
1101 SudokuView::_GetFieldFor(BPoint where, uint32& x, uint32& y)
1102 {
1103         float block = fWidth * fBlockSize + kStrongLineSize;
1104         x = (uint32)floor(where.x / block);
1105         uint32 offsetX = (uint32)floor((where.x - x * block) / fWidth);
1106         x = x * fBlockSize + offsetX;
1107
1108         block = fHeight * fBlockSize + kStrongLineSize;
1109         y = (uint32)floor(where.y / block);
1110         uint32 offsetY = (uint32)floor((where.y - y * block) / fHeight);
1111         y = y * fBlockSize + offsetY;
1112
1113         if (offsetX >= fBlockSize || offsetY >= fBlockSize
1114                 || x >= fField->Size() || y >= fField->Size())
1115                 return false;
1116
1117         return true;
1118 }
1119
1120
1121 void
1122 SudokuView::_SetValue(uint32 x, uint32 y, uint32 value)
1123 {
1124         bool wasCompleted;
1125         if (value == 0) {
1126                 // Remove value
1127                 value = fField->ValueAt(x, y);
1128                 wasCompleted = fField->IsValueCompleted(value);
1129
1130                 fField->SetValueAt(x, y, 0);
1131                 fShowHintX = x;
1132                 fShowHintY = y;
1133         } else {
1134                 // Set value
1135                 wasCompleted = fField->IsValueCompleted(value);
1136
1137                 fField->SetValueAt(x, y, value);
1138                 BMessenger(this).SendMessage(kMsgCheckSolved);
1139
1140                 _RemoveHintValues(x, y, value);
1141
1142                 // allow dragging to remove the hint from other fields
1143                 fLastHintValueSet = false;
1144                 fLastHintValue = value - 1;
1145                 fLastField = x + y * fField->Size();
1146         }
1147
1148         if (value != fValueHintValue && fValueHintValue != ~0UL)
1149                 _SetValueHintValue(value);
1150
1151         if (wasCompleted != fField->IsValueCompleted(value))
1152                 _InvalidateValue(value, false, x, y);
1153         else
1154                 _InvalidateField(x, y);
1155 }
1156
1157
1158 void
1159 SudokuView::_ToggleHintValue(uint32 x, uint32 y, uint32 hintX, uint32 hintY,
1160         uint32 value, uint32 field)
1161 {
1162         uint32 hintMask = fField->HintMaskAt(x, y);
1163         uint32 valueMask = 1UL << value;
1164         fLastHintValueSet = (hintMask & valueMask) == 0;
1165
1166         if (fLastHintValueSet)
1167                 hintMask |= valueMask;
1168         else
1169                 hintMask &= ~valueMask;
1170
1171         fField->SetHintMaskAt(x, y, hintMask);
1172
1173         if (value + 1 != fValueHintValue) {
1174                 _SetValueHintValue(UINT32_MAX);
1175                 _InvalidateHintField(x, y, hintX, hintY);
1176         } else
1177                 _InvalidateField(x, y);
1178
1179         fLastHintValue = value;
1180         fLastField = field;
1181 }
1182
1183
1184 void
1185 SudokuView::_RemoveHintValues(uint32 atX, uint32 atY, uint32 value)
1186 {
1187         // Remove all hints in the same block
1188         uint32 blockSize = fField->BlockSize();
1189         uint32 blockX = (atX / blockSize) * blockSize;
1190         uint32 blockY = (atY / blockSize) * blockSize;
1191         uint32 valueMask = 1UL << (value - 1);
1192
1193         for (uint32 y = blockY; y < blockY + blockSize; y++) {
1194                 for (uint32 x = blockX; x < blockX + blockSize; x++) {
1195                         if (x != atX && y != atY)
1196                                 _RemoveHintValue(x, y, valueMask);
1197                 }
1198         }
1199
1200         // Remove all hints from the vertical and horizontal lines
1201
1202         for (uint32 i = 0; i < fField->Size(); i++) {
1203                 if (i != atX)
1204                         _RemoveHintValue(i, atY, valueMask);
1205                 if (i != atY)
1206                         _RemoveHintValue(atX, i, valueMask);
1207         }
1208 }
1209
1210
1211 void
1212 SudokuView::_RemoveHintValue(uint32 x, uint32 y, uint32 valueMask)
1213 {
1214         uint32 hintMask = fField->HintMaskAt(x, y);
1215         if ((hintMask & valueMask) != 0) {
1216                 fField->SetHintMaskAt(x, y, hintMask & ~valueMask);
1217                 _InvalidateField(x, y);
1218         }
1219 }
1220
1221
1222 void
1223 SudokuView::_SetAllHints()
1224 {
1225         uint32 size = fField->Size();
1226
1227         for (uint32 y = 0; y < size; y++) {
1228                 for (uint32 x = 0; x < size; x++) {
1229                         uint32 validMask = fField->ValidMaskAt(x, y);
1230                         fField->SetHintMaskAt(x, y, validMask);
1231                 }
1232         }
1233         Invalidate();
1234 }
1235
1236
1237 void
1238 SudokuView::_Solve()
1239 {
1240         SudokuSolver solver;
1241         if (_GetSolutions(solver)) {
1242                 _PushUndo();
1243                 fField->SetTo(solver.SolutionAt(0));
1244                 Invalidate();
1245         } else
1246                 beep();
1247 }
1248
1249
1250 void
1251 SudokuView::_SolveSingle()
1252 {
1253         if (fField->IsSolved()) {
1254                 beep();
1255                 return;
1256         }
1257
1258         SudokuSolver solver;
1259         if (_GetSolutions(solver)) {
1260                 _PushUndo();
1261
1262                 // find free spot
1263                 uint32 x, y;
1264                 do {
1265                         x = rand() % fField->Size();
1266                         y = rand() % fField->Size();
1267                 } while (fField->ValueAt(x, y));
1268
1269                 uint32 value = solver.SolutionAt(0)->ValueAt(x, y);
1270                 _SetValue(x, y, value);
1271         } else
1272                 beep();
1273 }
1274
1275
1276 bool
1277 SudokuView::_GetSolutions(SudokuSolver& solver)
1278 {
1279         solver.SetTo(fField);
1280         bigtime_t start = system_time();
1281         solver.ComputeSolutions();
1282
1283         printf("found %" B_PRIu32 " solutions in %g msecs\n",
1284                 solver.CountSolutions(), (system_time() - start) / 1000.0);
1285
1286         return solver.CountSolutions() > 0;
1287 }
1288
1289
1290 void
1291 SudokuView::_UndoRedo(BObjectList<BMessage>& undos,
1292         BObjectList<BMessage>& redos)
1293 {
1294         if (undos.IsEmpty())
1295                 return;
1296
1297         BMessage* undo = undos.RemoveItemAt(undos.CountItems() - 1);
1298
1299         BMessage* redo = new BMessage;
1300         if (fField->Archive(redo, true) == B_OK)
1301                 redos.AddItem(redo);
1302
1303         SudokuField field(undo);
1304         delete undo;
1305
1306         fField->SetTo(&field);
1307
1308         SendNotices(kUndoRedoChanged);
1309         Invalidate();
1310 }
1311
1312
1313 void
1314 SudokuView::_PushUndo()
1315 {
1316         fRedos.MakeEmpty();
1317
1318         BMessage* undo = new BMessage;
1319         if (fField->Archive(undo, true) == B_OK
1320                 && fUndos.AddItem(undo))
1321                 SendNotices(kUndoRedoChanged);
1322 }
1323
1324
1325 void
1326 SudokuView::_SetValueHintValue(uint32 value)
1327 {
1328         if (value == fValueHintValue)
1329                 return;
1330
1331         if (fValueHintValue != UINT32_MAX)
1332                 _InvalidateValue(fValueHintValue, true);
1333
1334         fValueHintValue = value;
1335
1336         if (fValueHintValue != UINT32_MAX)
1337                 _InvalidateValue(fValueHintValue, true);
1338 }
1339
1340
1341 void
1342 SudokuView::_RemoveHint()
1343 {
1344         if (fShowHintX == UINT32_MAX)
1345                 return;
1346
1347         uint32 x = fShowHintX;
1348         uint32 y = fShowHintY;
1349         fShowHintX = UINT32_MAX;
1350         fShowHintY = UINT32_MAX;
1351
1352         _InvalidateField(x, y);
1353 }
1354
1355
1356 void
1357 SudokuView::_FitFont(BFont& font, float fieldWidth, float fieldHeight)
1358 {
1359         font.SetSize(100);
1360
1361         font_height fontHeight;
1362         font.GetHeight(&fontHeight);
1363
1364         float width = font.StringWidth("W");
1365         float height = ceilf(fontHeight.ascent) + ceilf(fontHeight.descent);
1366
1367         float factor = fieldWidth != fHintWidth ? 4.f / 5.f : 1.f;
1368         float widthFactor = fieldWidth / (width / factor);
1369         float heightFactor = fieldHeight / (height / factor);
1370         font.SetSize(100 * min_c(widthFactor, heightFactor));
1371 }
1372
1373
1374 void
1375 SudokuView::_DrawKeyboardFocus()
1376 {
1377         BRect frame = _Frame(fKeyboardX, fKeyboardY);
1378         SetHighColor(ui_color(B_KEYBOARD_NAVIGATION_COLOR));
1379         StrokeRect(frame);
1380         frame.InsetBy(-1, -1);
1381         StrokeRect(frame);
1382         frame.InsetBy(2, 2);
1383         StrokeRect(frame);
1384 }
1385
1386
1387 void
1388 SudokuView::_DrawHints(uint32 x, uint32 y)
1389 {
1390         bool showAll = fShowHintX == x && fShowHintY == y;
1391         uint32 hintMask = fField->HintMaskAt(x, y);
1392         if (hintMask == 0 && !showAll)
1393                 return;
1394
1395         uint32 validMask = fField->ValidMaskAt(x, y);
1396         BPoint leftTop = _LeftTop(x, y);
1397         SetFont(&fHintFont);
1398
1399         for (uint32 j = 0; j < fBlockSize; j++) {
1400                 for (uint32 i = 0; i < fBlockSize; i++) {
1401                         uint32 value = j * fBlockSize + i;
1402                         if ((hintMask & (1UL << value)) != 0) {
1403                                 SetHighColor(kHintColor);
1404                         } else {
1405                                 if (!showAll)
1406                                         continue;
1407
1408                                 if ((fHintFlags & kMarkValidHints) == 0
1409                                         || (validMask & (1UL << value)) != 0)
1410                                         SetHighColor(110, 110, 80);
1411                                 else
1412                                         SetHighColor(180, 180, 120);
1413                         }
1414
1415                         char text[2];
1416                         _SetText(text, value + 1);
1417                         DrawString(text, leftTop + BPoint((i + 0.5f) * fHintWidth
1418                                 - StringWidth(text) / 2, floorf(j * fHintHeight)
1419                                         + fHintBaseline));
1420                 }
1421         }
1422 }