src/kits/interface/Slider.cpp

   1 /*
   2  * Copyright 2001-2016 Haiku, Inc. All rights reserved.
   3  * Distributed under the terms of the MIT License.
   4  *
   5  * Authors:
   6  *              Stephan Aßmus <superstippi@gmx.de>
   7  *              Axel Dörfler, axeld@pinc-software.de
   8  *              Marc Flerackers (mflerackers@androme.be)
   9  */
  10
  11
  12 #include <Slider.h>
  13
  14 #include <algorithm>
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19
  20 #include <Bitmap.h>
  21 #include <ControlLook.h>
  22 #include <Errors.h>
  23 #include <LayoutUtils.h>
  24 #include <Message.h>
  25 #include <Region.h>
  26 #include <String.h>
  27 #include <Window.h>
  28
  29 #include <binary_compatibility/Interface.h>
  30
  31
  32 #define USE_OFF_SCREEN_VIEW 0
  33
  34
  35 BSlider::BSlider(
  36         BRect frame, const char* name, const char* label, BMessage* message,
  37         int32 minValue, int32 maxValue, thumb_style thumbType, uint32 resizingMode,
  38         uint32 flags)
  39         :
  40         BControl(frame, name, label, message, resizingMode, flags),
  41         fModificationMessage(NULL),
  42         fSnoozeAmount(20000),
  43
  44         fMinLimitLabel(NULL),
  45         fMaxLimitLabel(NULL),
  46
  47         fMinValue(minValue),
  48         fMaxValue(maxValue),
  49         fKeyIncrementValue(1),
  50
  51         fHashMarkCount(0),
  52         fHashMarks(B_HASH_MARKS_NONE),
  53
  54         fStyle(thumbType),
  55
  56         fOrientation(B_HORIZONTAL),
  57         fBarThickness(6.0)
  58 {
  59         _InitBarColor();
  60
  61         _InitObject();
  62         SetValue(0);
  63 }
  64
  65
  66 BSlider::BSlider(BRect frame, const char* name, const char* label,
  67         BMessage* message, int32 minValue, int32 maxValue, orientation posture,
  68         thumb_style thumbType, uint32 resizingMode, uint32 flags)
  69         :
  70         BControl(frame, name, label, message, resizingMode, flags),
  71         fModificationMessage(NULL),
  72         fSnoozeAmount(20000),
  73
  74         fMinLimitLabel(NULL),
  75         fMaxLimitLabel(NULL),
  76
  77         fMinValue(minValue),
  78         fMaxValue(maxValue),
  79         fKeyIncrementValue(1),
  80
  81         fHashMarkCount(0),
  82         fHashMarks(B_HASH_MARKS_NONE),
  83
  84         fStyle(thumbType),
  85
  86         fOrientation(posture),
  87         fBarThickness(6.0)
  88 {
  89         _InitBarColor();
  90
  91         _InitObject();
  92         SetValue(0);
  93 }
  94
  95
  96 BSlider::BSlider(const char* name, const char* label, BMessage* message,
  97         int32 minValue, int32 maxValue, orientation posture, thumb_style thumbType,
  98         uint32 flags)
  99         :
 100         BControl(name, label, message, flags),
 101         fModificationMessage(NULL),
 102         fSnoozeAmount(20000),
 103
 104         fMinLimitLabel(NULL),
 105         fMaxLimitLabel(NULL),
 106
 107         fMinValue(minValue),
 108         fMaxValue(maxValue),
 109         fKeyIncrementValue(1),
 110
 111         fHashMarkCount(0),
 112         fHashMarks(B_HASH_MARKS_NONE),
 113
 114         fStyle(thumbType),
 115
 116         fOrientation(posture),
 117         fBarThickness(6.0)
 118 {
 119         _InitBarColor();
 120
 121         _InitObject();
 122         SetValue(0);
 123 }
 124
 125
 126 BSlider::BSlider(BMessage* archive)
 127         :
 128         BControl(archive)
 129 {
 130         fModificationMessage = NULL;
 131
 132         if (archive->HasMessage("_mod_msg")) {
 133                 BMessage* message = new BMessage;
 134
 135                 archive->FindMessage("_mod_msg", message);
 136
 137                 SetModificationMessage(message);
 138         }
 139
 140         if (archive->FindInt32("_sdelay", &fSnoozeAmount) != B_OK)
 141                 SetSnoozeAmount(20000);
 142
 143         rgb_color color;
 144         if (archive->FindInt32("_fcolor", (int32*)&color) == B_OK)
 145                 UseFillColor(true, &color);
 146         else
 147                 UseFillColor(false);
 148
 149         int32 orient;
 150         if (archive->FindInt32("_orient", &orient) == B_OK)
 151                 fOrientation = (orientation)orient;
 152         else
 153                 fOrientation = B_HORIZONTAL;
 154
 155         fMinLimitLabel = NULL;
 156         fMaxLimitLabel = NULL;
 157
 158         const char* minlbl = NULL;
 159         const char* maxlbl = NULL;
 160
 161         archive->FindString("_minlbl", &minlbl);
 162         archive->FindString("_maxlbl", &maxlbl);
 163
 164         SetLimitLabels(minlbl, maxlbl);
 165
 166         if (archive->FindInt32("_min", &fMinValue) != B_OK)
 167                 fMinValue = 0;
 168
 169         if (archive->FindInt32("_max", &fMaxValue) != B_OK)
 170                 fMaxValue = 100;
 171
 172         if (archive->FindInt32("_incrementvalue", &fKeyIncrementValue) != B_OK)
 173                 fKeyIncrementValue = 1;
 174
 175         if (archive->FindInt32("_hashcount", &fHashMarkCount) != B_OK)
 176                 fHashMarkCount = 11;
 177
 178         int16 hashloc;
 179         if (archive->FindInt16("_hashloc", &hashloc) == B_OK)
 180                 fHashMarks = (hash_mark_location)hashloc;
 181         else
 182                 fHashMarks = B_HASH_MARKS_NONE;
 183
 184         int16 sstyle;
 185         if (archive->FindInt16("_sstyle", &sstyle) == B_OK)
 186                 fStyle = (thumb_style)sstyle;
 187         else
 188                 fStyle = B_BLOCK_THUMB;
 189
 190         if (archive->FindInt32("_bcolor", (int32*)&color) != B_OK)
 191                 color = tint_color(ui_color(B_PANEL_BACKGROUND_COLOR), B_DARKEN_4_TINT);
 192         SetBarColor(color);
 193
 194         float bthickness;
 195         if (archive->FindFloat("_bthickness", &bthickness) == B_OK)
 196                 fBarThickness = bthickness;
 197         else
 198                 fBarThickness = 6.0f;
 199
 200         _InitObject();
 201 }
 202
 203
 204 BSlider::~BSlider()
 205 {
 206 #if USE_OFF_SCREEN_VIEW
 207         delete fOffScreenBits;
 208 #endif
 209
 210         delete fModificationMessage;
 211         free(fMinLimitLabel);
 212         free(fMaxLimitLabel);
 213 }
 214
 215
 216 void
 217 BSlider::_InitBarColor()
 218 {
 219         SetBarColor(be_control_look->SliderBarColor(
 220                 ui_color(B_PANEL_BACKGROUND_COLOR)));
 221         UseFillColor(false, NULL);
 222 }
 223
 224
 225 void
 226 BSlider::_InitObject()
 227 {
 228         fLocation.x = 0;
 229         fLocation.y = 0;
 230         fInitialLocation.x = 0;
 231         fInitialLocation.y = 0;
 232
 233 #if USE_OFF_SCREEN_VIEW
 234         fOffScreenBits = NULL;
 235         fOffScreenView = NULL;
 236 #endif
 237
 238         fUpdateText = NULL;
 239         fMinSize.Set(-1, -1);
 240         fMaxUpdateTextWidth = -1.0;
 241 }
 242
 243
 244 BArchivable*
 245 BSlider::Instantiate(BMessage* archive)
 246 {
 247         if (validate_instantiation(archive, "BSlider"))
 248                 return new BSlider(archive);
 249
 250         return NULL;
 251 }
 252
 253
 254 status_t
 255 BSlider::Archive(BMessage* archive, bool deep) const
 256 {
 257         status_t ret = BControl::Archive(archive, deep);
 258
 259         if (ModificationMessage() && ret == B_OK)
 260                 ret = archive->AddMessage("_mod_msg", ModificationMessage());
 261
 262         if (ret == B_OK)
 263                 ret = archive->AddInt32("_sdelay", fSnoozeAmount);
 264
 265         if (ret == B_OK)
 266                 ret = archive->AddInt32("_bcolor", (const uint32&)fBarColor);
 267
 268         if (FillColor(NULL) && ret == B_OK)
 269                 ret = archive->AddInt32("_fcolor", (const uint32&)fFillColor);
 270
 271         if (ret == B_OK && fMinLimitLabel != NULL)
 272                 ret = archive->AddString("_minlbl", fMinLimitLabel);
 273
 274         if (ret == B_OK && fMaxLimitLabel != NULL)
 275                 ret = archive->AddString("_maxlbl", fMaxLimitLabel);
 276
 277         if (ret == B_OK)
 278                 ret = archive->AddInt32("_min", fMinValue);
 279
 280         if (ret == B_OK)
 281                 ret = archive->AddInt32("_max", fMaxValue);
 282
 283         if (ret == B_OK)
 284                 ret = archive->AddInt32("_incrementvalue", fKeyIncrementValue);
 285
 286         if (ret == B_OK)
 287                 ret = archive->AddInt32("_hashcount", fHashMarkCount);
 288
 289         if (ret == B_OK)
 290                 ret = archive->AddInt16("_hashloc", fHashMarks);
 291
 292         if (ret == B_OK)
 293                 ret = archive->AddInt16("_sstyle", fStyle);
 294
 295         if (ret == B_OK)
 296                 ret = archive->AddInt32("_orient", fOrientation);
 297
 298         if (ret == B_OK)
 299                 ret = archive->AddFloat("_bthickness", fBarThickness);
 300
 301         return ret;
 302 }
 303
 304
 305 status_t
 306 BSlider::Perform(perform_code code, void* _data)
 307 {
 308         switch (code) {
 309                 case PERFORM_CODE_MIN_SIZE:
 310                         ((perform_data_min_size*)_data)->return_value = BSlider::MinSize();
 311                         return B_OK;
 312
 313                 case PERFORM_CODE_MAX_SIZE:
 314                         ((perform_data_max_size*)_data)->return_value = BSlider::MaxSize();
 315                         return B_OK;
 316
 317                 case PERFORM_CODE_PREFERRED_SIZE:
 318                         ((perform_data_preferred_size*)_data)->return_value
 319                                 = BSlider::PreferredSize();
 320                         return B_OK;
 321
 322                 case PERFORM_CODE_LAYOUT_ALIGNMENT:
 323                         ((perform_data_layout_alignment*)_data)->return_value
 324                                 = BSlider::LayoutAlignment();
 325                         return B_OK;
 326
 327                 case PERFORM_CODE_HAS_HEIGHT_FOR_WIDTH:
 328                         ((perform_data_has_height_for_width*)_data)->return_value
 329                                 = BSlider::HasHeightForWidth();
 330                         return B_OK;
 331
 332                 case PERFORM_CODE_GET_HEIGHT_FOR_WIDTH:
 333                 {
 334                         perform_data_get_height_for_width* data
 335                                 = (perform_data_get_height_for_width*)_data;
 336                         BSlider::GetHeightForWidth(data->width, &data->min, &data->max,
 337                                 &data->preferred);
 338                         return B_OK;
 339                 }
 340
 341                 case PERFORM_CODE_SET_LAYOUT:
 342                 {
 343                         perform_data_set_layout* data = (perform_data_set_layout*)_data;
 344                         BSlider::SetLayout(data->layout);
 345                         return B_OK;
 346                 }
 347
 348                 case PERFORM_CODE_LAYOUT_INVALIDATED:
 349                 {
 350                         perform_data_layout_invalidated* data
 351                                 = (perform_data_layout_invalidated*)_data;
 352                         BSlider::LayoutInvalidated(data->descendants);
 353                         return B_OK;
 354                 }
 355
 356                 case PERFORM_CODE_DO_LAYOUT:
 357                 {
 358                         BSlider::DoLayout();
 359                         return B_OK;
 360                 }
 361
 362                 case PERFORM_CODE_SET_ICON:
 363                 {
 364                         perform_data_set_icon* data = (perform_data_set_icon*)_data;
 365                         return BSlider::SetIcon(data->icon, data->flags);
 366                 }
 367         }
 368
 369         return BControl::Perform(code, _data);
 370 }
 371
 372
 373 void
 374 BSlider::WindowActivated(bool state)
 375 {
 376         BControl::WindowActivated(state);
 377 }
 378
 379
 380 void
 381 BSlider::AttachedToWindow()
 382 {
 383         ResizeToPreferred();
 384
 385 #if USE_OFF_SCREEN_VIEW
 386         BRect bounds(Bounds());
 387
 388         if (!fOffScreenView) {
 389                 fOffScreenView = new BView(bounds, "", B_FOLLOW_ALL, B_WILL_DRAW);
 390
 391                 BFont font;
 392                 GetFont(&font);
 393                 fOffScreenView->SetFont(&font);
 394         }
 395
 396         if (!fOffScreenBits) {
 397                 fOffScreenBits = new BBitmap(bounds, B_RGBA32, true, false);
 398
 399                 if (fOffScreenBits && fOffScreenView)
 400                         fOffScreenBits->AddChild(fOffScreenView);
 401
 402         } else if (fOffScreenView)
 403                 fOffScreenBits->AddChild(fOffScreenView);
 404 #endif // USE_OFF_SCREEN_VIEW
 405
 406         BControl::AttachedToWindow();
 407
 408         BView* view = OffscreenView();
 409         if (view != NULL && view->LockLooper()) {
 410                 view->SetViewColor(B_TRANSPARENT_COLOR);
 411                 if (LowUIColor() != B_NO_COLOR)
 412                         view->SetLowUIColor(LowUIColor());
 413                 else
 414                         view->SetLowColor(LowColor());
 415
 416                 view->UnlockLooper();
 417         }
 418
 419         int32 value = Value();
 420         SetValue(value);
 421                 // makes sure the value is within valid bounds
 422         _SetLocationForValue(Value());
 423                 // makes sure the location is correct
 424         UpdateTextChanged();
 425 }
 426
 427
 428 void
 429 BSlider::AllAttached()
 430 {
 431         BControl::AllAttached();
 432
 433         // When using a layout we may not have a parent, so we need to employ the
 434         // standard system colors manually. Due to how layouts work, this must
 435         // happen here, rather than in AttachedToWindow().
 436         if (Parent() == NULL)
 437                 SetLowUIColor(B_PANEL_BACKGROUND_COLOR);
 438 }
 439
 440
 441 void
 442 BSlider::AllDetached()
 443 {
 444         BControl::AllDetached();
 445 }
 446
 447
 448 void
 449 BSlider::DetachedFromWindow()
 450 {
 451         BControl::DetachedFromWindow();
 452
 453 #if USE_OFF_SCREEN_VIEW
 454         if (fOffScreenBits) {
 455                 delete fOffScreenBits;
 456                 fOffScreenBits = NULL;
 457                 fOffScreenView = NULL;
 458         }
 459 #endif
 460 }
 461
 462
 463 void
 464 BSlider::MessageReceived(BMessage* message)
 465 {
 466         BControl::MessageReceived(message);
 467 }
 468
 469
 470 void
 471 BSlider::FrameMoved(BPoint new_position)
 472 {
 473         BControl::FrameMoved(new_position);
 474 }
 475
 476
 477 void
 478 BSlider::FrameResized(float w,float h)
 479 {
 480         BControl::FrameResized(w, h);
 481
 482         BRect bounds(Bounds());
 483
 484         if (bounds.right <= 0.0f || bounds.bottom <= 0.0f)
 485                 return;
 486
 487 #if USE_OFF_SCREEN_VIEW
 488         if (fOffScreenBits) {
 489                 fOffScreenBits->RemoveChild(fOffScreenView);
 490                 delete fOffScreenBits;
 491
 492                 fOffScreenView->ResizeTo(bounds.Width(), bounds.Height());
 493
 494                 fOffScreenBits = new BBitmap(Bounds(), B_RGBA32, true, false);
 495                 fOffScreenBits->AddChild(fOffScreenView);
 496         }
 497 #endif
 498
 499         Invalidate();
 500 }
 501
 502
 503 void
 504 BSlider::KeyDown(const char* bytes, int32 numBytes)
 505 {
 506         if (!IsEnabled() || IsHidden())
 507                 return;
 508
 509         int32 newValue = Value();
 510
 511         switch (bytes[0]) {
 512                 case B_LEFT_ARROW:
 513                 case B_DOWN_ARROW:
 514                         newValue -= KeyIncrementValue();
 515                         break;
 516
 517                 case B_RIGHT_ARROW:
 518                 case B_UP_ARROW:
 519                         newValue += KeyIncrementValue();
 520                         break;
 521
 522                 case B_HOME:
 523                         newValue = fMinValue;
 524                         break;
 525
 526                 case B_END:
 527                         newValue = fMaxValue;
 528                         break;
 529
 530                 default:
 531                         BControl::KeyDown(bytes, numBytes);
 532                         return;
 533         }
 534
 535         if (newValue < fMinValue)
 536                 newValue = fMinValue;
 537
 538         if (newValue > fMaxValue)
 539                 newValue = fMaxValue;
 540
 541         if (newValue != Value()) {
 542                 fInitialLocation = _Location();
 543                 SetValue(newValue);
 544                 InvokeNotify(ModificationMessage(), B_CONTROL_MODIFIED);
 545         }
 546 }
 547
 548 void
 549 BSlider::KeyUp(const char* bytes, int32 numBytes)
 550 {
 551         if (fInitialLocation != _Location()) {
 552                 // The last KeyDown event triggered the modification message or no
 553                 // notification at all, we may also have sent the modification message
 554                 // continually while the user kept pressing the key. In either case,
 555                 // finish with the final message to make the behavior consistent with
 556                 // changing the value by mouse.
 557                 Invoke();
 558         }
 559 }
 560
 561
 562 /*!
 563         Makes sure the \a point is within valid bounds.
 564         Returns \c true if the relevant coordinate (depending on the orientation
 565         of the slider) differs from \a comparePoint.
 566 */
 567 bool
 568 BSlider::_ConstrainPoint(BPoint& point, BPoint comparePoint) const
 569 {
 570         if (fOrientation == B_HORIZONTAL) {
 571                 if (point.x != comparePoint.x) {
 572                         if (point.x < _MinPosition())
 573                                 point.x = _MinPosition();
 574                         else if (point.x > _MaxPosition())
 575                                 point.x = _MaxPosition();
 576
 577                         return true;
 578                 }
 579         } else {
 580                 if (point.y != comparePoint.y) {
 581                         if (point.y > _MinPosition())
 582                                 point.y = _MinPosition();
 583                         else if (point.y < _MaxPosition())
 584                                 point.y = _MaxPosition();
 585
 586                         return true;
 587                 }
 588         }
 589
 590         return false;
 591 }
 592
 593
 594 void
 595 BSlider::MouseDown(BPoint point)
 596 {
 597         if (!IsEnabled())
 598                 return;
 599
 600         if (BarFrame().Contains(point) || ThumbFrame().Contains(point))
 601                 fInitialLocation = _Location();
 602
 603         uint32 buttons;
 604         GetMouse(&point, &buttons, true);
 605
 606         _ConstrainPoint(point, fInitialLocation);
 607         SetValue(ValueForPoint(point));
 608
 609         if (_Location() != fInitialLocation)
 610                 InvokeNotify(ModificationMessage(), B_CONTROL_MODIFIED);
 611
 612         if (Window()->Flags() & B_ASYNCHRONOUS_CONTROLS) {
 613                 SetTracking(true);
 614                 SetMouseEventMask(B_POINTER_EVENTS,
 615                         B_LOCK_WINDOW_FOCUS | B_NO_POINTER_HISTORY);
 616         } else {
 617                 // synchronous mouse tracking
 618                 BPoint prevPoint;
 619
 620                 while (buttons) {
 621                         prevPoint = point;
 622
 623                         snooze(SnoozeAmount());
 624                         GetMouse(&point, &buttons, true);
 625
 626                         if (_ConstrainPoint(point, prevPoint)) {
 627                                 int32 value = ValueForPoint(point);
 628                                 if (value != Value()) {
 629                                         SetValue(value);
 630                                         InvokeNotify(ModificationMessage(), B_CONTROL_MODIFIED);
 631                                 }
 632                         }
 633                 }
 634                 if (_Location() != fInitialLocation)
 635                         Invoke();
 636         }
 637 }
 638
 639
 640 void
 641 BSlider::MouseUp(BPoint point)
 642 {
 643         if (IsTracking()) {
 644                 if (_Location() != fInitialLocation)
 645                         Invoke();
 646
 647                 SetTracking(false);
 648         } else
 649                 BControl::MouseUp(point);
 650 }
 651
 652
 653 void
 654 BSlider::MouseMoved(BPoint point, uint32 transit, const BMessage* message)
 655 {
 656         if (IsTracking()) {
 657                 if (_ConstrainPoint(point, _Location())) {
 658                         int32 value = ValueForPoint(point);
 659                         if (value != Value()) {
 660                                 SetValue(value);
 661                                 InvokeNotify(ModificationMessage(), B_CONTROL_MODIFIED);
 662                         }
 663                 }
 664         } else
 665                 BControl::MouseMoved(point, transit, message);
 666 }
 667
 668
 669 void
 670 BSlider::Pulse()
 671 {
 672         BControl::Pulse();
 673 }
 674
 675
 676 void
 677 BSlider::SetLabel(const char* label)
 678 {
 679         BControl::SetLabel(label);
 680 }
 681
 682
 683 void
 684 BSlider::SetLimitLabels(const char* minLabel, const char* maxLabel)
 685 {
 686         free(fMinLimitLabel);
 687         fMinLimitLabel = minLabel ? strdup(minLabel) : NULL;
 688
 689         free(fMaxLimitLabel);
 690         fMaxLimitLabel = maxLabel ? strdup(maxLabel) : NULL;
 691
 692         InvalidateLayout();
 693
 694         // TODO: This is for backwards compatibility and should
 695         // probably be removed when breaking binary compatiblity.
 696         // Applications like our own Mouse rely on this behavior.
 697         if ((Flags() & B_SUPPORTS_LAYOUT) == 0)
 698                 ResizeToPreferred();
 699
 700         Invalidate();
 701 }
 702
 703
 704 const char*
 705 BSlider::MinLimitLabel() const
 706 {
 707         return fMinLimitLabel;
 708 }
 709
 710
 711 const char*
 712 BSlider::MaxLimitLabel() const
 713 {
 714         return fMaxLimitLabel;
 715 }
 716
 717
 718 void
 719 BSlider::SetValue(int32 value)
 720 {
 721         if (value < fMinValue)
 722                 value = fMinValue;
 723
 724         if (value > fMaxValue)
 725                 value = fMaxValue;
 726
 727         if (value == Value())
 728                 return;
 729
 730         _SetLocationForValue(value);
 731
 732         BRect oldThumbFrame = ThumbFrame();
 733
 734         // While it would be enough to do this dependent on fUseFillColor,
 735         // that doesn't work out if DrawBar() has been overridden by a sub class
 736         if (fOrientation == B_HORIZONTAL)
 737                 oldThumbFrame.top = BarFrame().top;
 738         else
 739                 oldThumbFrame.left = BarFrame().left;
 740
 741         BControl::SetValueNoUpdate(value);
 742         BRect invalid = oldThumbFrame | ThumbFrame();
 743
 744         if (Style() == B_TRIANGLE_THUMB) {
 745                 // 1) We need to take care of pixels touched because of anti-aliasing.
 746                 // 2) We need to update the region with the focus mark as well. (A
 747                 // method BSlider::FocusMarkFrame() would be nice as well.)
 748                 if (fOrientation == B_HORIZONTAL) {
 749                         if (IsFocus())
 750                                 invalid.bottom += 2;
 751                         invalid.InsetBy(-1, 0);
 752                 } else {
 753                         if (IsFocus())
 754                                 invalid.left -= 2;
 755                         invalid.InsetBy(0, -1);
 756                 }
 757         }
 758
 759         Invalidate(invalid);
 760
 761         UpdateTextChanged();
 762 }
 763
 764
 765 int32
 766 BSlider::ValueForPoint(BPoint location) const
 767 {
 768         float min;
 769         float max;
 770         float position;
 771         if (fOrientation == B_HORIZONTAL) {
 772                 min = _MinPosition();
 773                 max = _MaxPosition();
 774                 position = location.x;
 775         } else {
 776                 max = _MinPosition();
 777                 min = _MaxPosition();
 778                 position = min + (max - location.y);
 779         }
 780
 781         if (position < min)
 782                 position = min;
 783
 784         if (position > max)
 785                 position = max;
 786
 787         return (int32)roundf(((position - min) * (fMaxValue - fMinValue)
 788                 / (max - min)) + fMinValue);
 789 }
 790
 791
 792 void
 793 BSlider::SetPosition(float position)
 794 {
 795         if (position <= 0.0f)
 796                 SetValue(fMinValue);
 797         else if (position >= 1.0f)
 798                 SetValue(fMaxValue);
 799         else
 800                 SetValue((int32)(position * (fMaxValue - fMinValue) + fMinValue));
 801 }
 802
 803
 804 float
 805 BSlider::Position() const
 806 {
 807         float range = (float)(fMaxValue - fMinValue);
 808         if (range == 0.0f)
 809                 range = 1.0f;
 810
 811         return (float)(Value() - fMinValue) / range;
 812 }
 813
 814
 815 void
 816 BSlider::SetEnabled(bool on)
 817 {
 818         BControl::SetEnabled(on);
 819 }
 820
 821
 822 void
 823 BSlider::GetLimits(int32* minimum, int32* maximum) const
 824 {
 825         if (minimum != NULL)
 826                 *minimum = fMinValue;
 827
 828         if (maximum != NULL)
 829                 *maximum = fMaxValue;
 830 }
 831
 832
 833 // #pragma mark - drawing
 834
 835
 836 void
 837 BSlider::Draw(BRect updateRect)
 838 {
 839         // clear out background
 840         BRegion background(updateRect);
 841         background.Exclude(BarFrame());
 842         bool drawBackground = true;
 843         if (Parent() != NULL && (Parent()->Flags() & B_DRAW_ON_CHILDREN) != 0) {
 844                 // This view is embedded somewhere, most likely the Tracker Desktop
 845                 // shelf.
 846                 drawBackground = false;
 847         }
 848
 849 #if USE_OFF_SCREEN_VIEW
 850         if (!fOffScreenBits)
 851                 return;
 852
 853         if (fOffScreenBits->Lock()) {
 854                 fOffScreenView->SetViewColor(ViewColor());
 855                 fOffScreenView->SetLowColor(LowColor());
 856 #endif
 857
 858                 if (drawBackground && background.Frame().IsValid())
 859                         OffscreenView()->FillRegion(&background, B_SOLID_LOW);
 860
 861 #if USE_OFF_SCREEN_VIEW
 862                 fOffScreenView->Sync();
 863                 fOffScreenBits->Unlock();
 864         }
 865 #endif
 866
 867         DrawSlider();
 868 }
 869
 870
 871 void
 872 BSlider::DrawSlider()
 873 {
 874         if (LockLooper()) {
 875 #if USE_OFF_SCREEN_VIEW
 876                 if (fOffScreenBits == NULL)
 877                         return;
 878
 879                 if (fOffScreenBits->Lock()) {
 880 #endif
 881                         DrawBar();
 882                         DrawHashMarks();
 883                         DrawThumb();
 884                         DrawFocusMark();
 885                         DrawText();
 886
 887 #if USE_OFF_SCREEN_VIEW
 888                         fOffScreenView->Sync();
 889                         fOffScreenBits->Unlock();
 890
 891                         DrawBitmap(fOffScreenBits, B_ORIGIN);
 892                 }
 893 #endif
 894                 UnlockLooper();
 895         }
 896 }
 897
 898
 899 void
 900 BSlider::DrawBar()
 901 {
 902         BRect frame = BarFrame();
 903         BView* view = OffscreenView();
 904
 905         uint32 flags = be_control_look->Flags(this);
 906         rgb_color base = ui_color(B_PANEL_BACKGROUND_COLOR);
 907         rgb_color rightFillColor = fBarColor;
 908         rgb_color leftFillColor = fUseFillColor ? fFillColor : fBarColor;
 909         be_control_look->DrawSliderBar(view, frame, frame, base, leftFillColor,
 910                 rightFillColor, Position(), flags, fOrientation);
 911 }
 912
 913
 914 void
 915 BSlider::DrawHashMarks()
 916 {
 917         if (fHashMarks == B_HASH_MARKS_NONE)
 918                 return;
 919
 920         BRect frame = HashMarksFrame();
 921         BView* view = OffscreenView();
 922
 923         rgb_color base = ui_color(B_PANEL_BACKGROUND_COLOR);
 924         uint32 flags = be_control_look->Flags(this);
 925         be_control_look->DrawSliderHashMarks(view, frame, frame, base,
 926                 fHashMarkCount, fHashMarks, flags, fOrientation);
 927 }
 928
 929
 930 void
 931 BSlider::DrawThumb()
 932 {
 933         if (Style() == B_BLOCK_THUMB)
 934                 _DrawBlockThumb();
 935         else
 936                 _DrawTriangleThumb();
 937 }
 938
 939
 940 void
 941 BSlider::DrawFocusMark()
 942 {
 943         if (!IsFocus())
 944                 return;
 945
 946         OffscreenView()->SetHighColor(ui_color(B_KEYBOARD_NAVIGATION_COLOR));
 947
 948         BRect frame = ThumbFrame();
 949
 950         if (fStyle == B_BLOCK_THUMB) {
 951                 frame.left += 2.0f;
 952                 frame.top += 2.0f;
 953                 frame.right -= 3.0f;
 954                 frame.bottom -= 3.0f;
 955                 OffscreenView()->StrokeRect(frame);
 956         } else {
 957                 if (fOrientation == B_HORIZONTAL) {
 958                         OffscreenView()->StrokeLine(BPoint(frame.left, frame.bottom + 2.0f),
 959                                 BPoint(frame.right, frame.bottom + 2.0f));
 960                 } else {
 961                         OffscreenView()->StrokeLine(BPoint(frame.left - 2.0f, frame.top),
 962                                 BPoint(frame.left - 2.0f, frame.bottom));
 963                 }
 964         }
 965 }
 966
 967
 968 void
 969 BSlider::DrawText()
 970 {
 971         BRect bounds(Bounds());
 972         BView* view = OffscreenView();
 973
 974         rgb_color base = LowColor();
 975         uint32 flags = be_control_look->Flags(this);
 976
 977         // erase the is control flag before drawing the label so that the label
 978         // will get drawn using B_PANEL_TEXT_COLOR
 979         flags &= ~BControlLook::B_IS_CONTROL;
 980
 981         font_height fontHeight;
 982         GetFontHeight(&fontHeight);
 983         if (Orientation() == B_HORIZONTAL) {
 984                 if (Label() != NULL) {
 985                         be_control_look->DrawLabel(view, Label(), base, flags,
 986                                 BPoint(0.0f, ceilf(fontHeight.ascent)));
 987                 }
 988
 989                 // the update text is updated in SetValue() only
 990                 if (fUpdateText != NULL) {
 991                         be_control_look->DrawLabel(view, fUpdateText, base, flags,
 992                                 BPoint(bounds.right - StringWidth(fUpdateText),
 993                                         ceilf(fontHeight.ascent)));
 994                 }
 995
 996                 if (fMinLimitLabel != NULL) {
 997                         be_control_look->DrawLabel(view, fMinLimitLabel, base, flags,
 998                                 BPoint(0.0f, bounds.bottom - fontHeight.descent));
 999                 }
1000
1001                 if (fMaxLimitLabel != NULL) {
1002                         be_control_look->DrawLabel(view, fMaxLimitLabel, base, flags,
1003                                 BPoint(bounds.right - StringWidth(fMaxLimitLabel),
1004                                         bounds.bottom - fontHeight.descent));
1005                 }
1006         } else {
1007                 float lineHeight = ceilf(fontHeight.ascent) + ceilf(fontHeight.descent)
1008                         + ceilf(fontHeight.leading);
1009                 float baseLine = ceilf(fontHeight.ascent);
1010
1011                 if (Label() != NULL) {
1012                         be_control_look->DrawLabel(view, Label(), base, flags,
1013                                 BPoint((bounds.Width() - StringWidth(Label())) / 2.0,
1014                                         baseLine));
1015                         baseLine += lineHeight;
1016                 }
1017
1018                 if (fMaxLimitLabel != NULL) {
1019                         be_control_look->DrawLabel(view, fMaxLimitLabel, base, flags,
1020                                 BPoint((bounds.Width() - StringWidth(fMaxLimitLabel)) / 2.0,
1021                                         baseLine));
1022                 }
1023
1024                 baseLine = bounds.bottom - ceilf(fontHeight.descent);
1025
1026                 if (fMinLimitLabel != NULL) {
1027                         be_control_look->DrawLabel(view, fMinLimitLabel, base, flags,
1028                                 BPoint((bounds.Width() - StringWidth(fMinLimitLabel)) / 2.0,
1029                                         baseLine));
1030                                 baseLine -= lineHeight;
1031                 }
1032
1033                 if (fUpdateText != NULL) {
1034                         be_control_look->DrawLabel(view, fUpdateText, base, flags,
1035                                 BPoint((bounds.Width() - StringWidth(fUpdateText)) / 2.0,
1036                                         baseLine));
1037                 }
1038         }
1039 }
1040
1041
1042 // #pragma mark -
1043
1044
1045 const char*
1046 BSlider::UpdateText() const
1047 {
1048         return NULL;
1049 }
1050
1051
1052 void
1053 BSlider::UpdateTextChanged()
1054 {
1055         // update text label
1056         float oldWidth = 0.0;
1057         if (fUpdateText != NULL)
1058                 oldWidth = StringWidth(fUpdateText);
1059
1060         const char* oldUpdateText = fUpdateText;
1061         fUpdateText = UpdateText();
1062         bool updateTextOnOff = (fUpdateText == NULL && oldUpdateText != NULL)
1063                 || (fUpdateText != NULL && oldUpdateText == NULL);
1064
1065         float newWidth = 0.0;
1066         if (fUpdateText != NULL)
1067                 newWidth = StringWidth(fUpdateText);
1068
1069         float width = ceilf(std::max(newWidth, oldWidth)) + 2.0f;
1070         if (width != 0) {
1071                 font_height fontHeight;
1072                 GetFontHeight(&fontHeight);
1073
1074                 float height = ceilf(fontHeight.ascent) + ceilf(fontHeight.descent);
1075                 float lineHeight = height + ceilf(fontHeight.leading);
1076                 BRect invalid(Bounds());
1077                 if (fOrientation == B_HORIZONTAL)
1078                         invalid = BRect(invalid.right - width, 0, invalid.right, height);
1079                 else {
1080                         if (!updateTextOnOff) {
1081                                 invalid.left = (invalid.left + invalid.right - width) / 2;
1082                                 invalid.right = invalid.left + width;
1083                                 if (fMinLimitLabel != NULL)
1084                                         invalid.bottom -= lineHeight;
1085
1086                                 invalid.top = invalid.bottom - height;
1087                         }
1088                 }
1089                 Invalidate(invalid);
1090         }
1091
1092         float oldMaxUpdateTextWidth = fMaxUpdateTextWidth;
1093         fMaxUpdateTextWidth = MaxUpdateTextWidth();
1094         if (oldMaxUpdateTextWidth != fMaxUpdateTextWidth)
1095                 InvalidateLayout();
1096 }
1097
1098
1099 BRect
1100 BSlider::BarFrame() const
1101 {
1102         BRect frame(Bounds());
1103
1104         font_height fontHeight;
1105         GetFontHeight(&fontHeight);
1106
1107         float textHeight = ceilf(fontHeight.ascent) + ceilf(fontHeight.descent);
1108         float leading = ceilf(fontHeight.leading);
1109
1110         float thumbInset;
1111         if (fStyle == B_BLOCK_THUMB)
1112                 thumbInset = 8.0;
1113         else
1114                 thumbInset = 7.0;
1115
1116         if (Orientation() == B_HORIZONTAL) {
1117                 frame.left = thumbInset;
1118                 frame.top = 6.0 + (Label() || fUpdateText ? textHeight + 4.0 : 0.0);
1119                 frame.right -= thumbInset;
1120                 frame.bottom = frame.top + fBarThickness;
1121         } else {
1122                 frame.left = floorf((frame.Width() - fBarThickness) / 2.0);
1123                 frame.top = thumbInset;
1124                 if (Label() != NULL)
1125                         frame.top += textHeight;
1126
1127                 if (fMaxLimitLabel != NULL) {
1128                         frame.top += textHeight;
1129                         if (Label())
1130                                 frame.top += leading;
1131                 }
1132
1133                 frame.right = frame.left + fBarThickness;
1134                 frame.bottom = frame.bottom - thumbInset;
1135                 if (fMinLimitLabel != NULL)
1136                         frame.bottom -= textHeight;
1137
1138                 if (fUpdateText != NULL) {
1139                         frame.bottom -= textHeight;
1140                         if (fMinLimitLabel != NULL)
1141                                 frame.bottom -= leading;
1142                 }
1143         }
1144
1145         return frame;
1146 }
1147
1148
1149 BRect
1150 BSlider::HashMarksFrame() const
1151 {
1152         BRect frame(BarFrame());
1153
1154         if (fOrientation == B_HORIZONTAL) {
1155                 frame.top -= 6.0;
1156                 frame.bottom += 6.0;
1157         } else {
1158                 frame.left -= 6.0;
1159                 frame.right += 6.0;
1160         }
1161
1162         return frame;
1163 }
1164
1165
1166 BRect
1167 BSlider::ThumbFrame() const
1168 {
1169         // TODO: The slider looks really ugly and broken when it is too little.
1170         // I would suggest using BarFrame() here to get the top and bottom coords
1171         // and spread them further apart for the thumb
1172
1173         BRect frame = Bounds();
1174
1175         font_height fontHeight;
1176         GetFontHeight(&fontHeight);
1177
1178         float textHeight = ceilf(fontHeight.ascent) + ceilf(fontHeight.descent);
1179
1180         if (fStyle == B_BLOCK_THUMB) {
1181                 if (Orientation() == B_HORIZONTAL) {
1182                         frame.left = floorf(Position() * (_MaxPosition()
1183                                 - _MinPosition()) + _MinPosition()) - 8;
1184                         frame.top = 2 + (Label() || fUpdateText ? textHeight + 4 : 0);
1185                         frame.right = frame.left + 17;
1186                         frame.bottom = frame.top + fBarThickness + 7;
1187                 } else {
1188                         frame.left = floor((frame.Width() - fBarThickness) / 2) - 4;
1189                         frame.top = floorf(Position() * (_MaxPosition()
1190                                 - _MinPosition()) + _MinPosition()) - 8;
1191                         frame.right = frame.left + fBarThickness + 7;
1192                         frame.bottom = frame.top + 17;
1193                 }
1194         } else {
1195                 if (Orientation() == B_HORIZONTAL) {
1196                         frame.left = floorf(Position() * (_MaxPosition()
1197                                 - _MinPosition()) + _MinPosition()) - 6;
1198                         frame.right = frame.left + 12;
1199                         frame.top = 3 + fBarThickness + (Label() ? textHeight + 4 : 0);
1200                         frame.bottom = frame.top + 8;
1201                 } else {
1202                         frame.left = floorf((frame.Width() + fBarThickness) / 2) - 3;
1203                         frame.top = floorf(Position() * (_MaxPosition()
1204                                 - _MinPosition())) + _MinPosition() - 6;
1205                         frame.right = frame.left + 8;
1206                         frame.bottom = frame.top + 12;
1207                 }
1208         }
1209
1210         return frame;
1211 }
1212
1213
1214 void
1215 BSlider::SetFlags(uint32 flags)
1216 {
1217         BControl::SetFlags(flags);
1218 }
1219
1220
1221 void
1222 BSlider::SetResizingMode(uint32 mode)
1223 {
1224         BControl::SetResizingMode(mode);
1225 }
1226
1227
1228 void
1229 BSlider::GetPreferredSize(float* _width, float* _height)
1230 {
1231         BSize preferredSize = PreferredSize();
1232
1233         if (Orientation() == B_HORIZONTAL) {
1234                 if (_width != NULL) {
1235                         // NOTE: For compatibility reasons, a horizontal BSlider
1236                         // never shrinks horizontally. This only affects applications
1237                         // which do not use the new layout system.
1238                         *_width = std::max(Bounds().Width(), preferredSize.width);
1239                 }
1240
1241                 if (_height != NULL)
1242                         *_height = preferredSize.height;
1243         } else {
1244                 if (_width != NULL)
1245                         *_width = preferredSize.width;
1246
1247                 if (_height != NULL) {
1248                         // NOTE: Similarly, a vertical BSlider never shrinks
1249                         // vertically. This only affects applications which do not
1250                         // use the new layout system.
1251                         *_height = std::max(Bounds().Height(), preferredSize.height);
1252                 }
1253         }
1254 }
1255
1256
1257 void
1258 BSlider::ResizeToPreferred()
1259 {
1260         BControl::ResizeToPreferred();
1261 }
1262
1263
1264 status_t
1265 BSlider::Invoke(BMessage* message)
1266 {
1267         return BControl::Invoke(message);
1268 }
1269
1270
1271 BHandler*
1272 BSlider::ResolveSpecifier(BMessage* message, int32 index, BMessage* specifier,
1273         int32 command, const char* property)
1274 {
1275         return BControl::ResolveSpecifier(message, index, specifier, command,
1276                 property);
1277 }
1278
1279
1280 status_t
1281 BSlider::GetSupportedSuites(BMessage* message)
1282 {
1283         return BControl::GetSupportedSuites(message);
1284 }
1285
1286
1287 void
1288 BSlider::SetModificationMessage(BMessage* message)
1289 {
1290         delete fModificationMessage;
1291         fModificationMessage = message;
1292 }
1293
1294
1295 BMessage*
1296 BSlider::ModificationMessage() const
1297 {
1298         return fModificationMessage;
1299 }
1300
1301
1302 void
1303 BSlider::SetSnoozeAmount(int32 snoozeTime)
1304 {
1305         if (snoozeTime < 10000)
1306                 snoozeTime = 10000;
1307         else if (snoozeTime > 1000000)
1308                 snoozeTime = 1000000;
1309
1310         fSnoozeAmount = snoozeTime;
1311 }
1312
1313
1314 int32
1315 BSlider::SnoozeAmount() const
1316 {
1317         return fSnoozeAmount;
1318 }
1319
1320
1321 void
1322 BSlider::SetKeyIncrementValue(int32 incrementValue)
1323 {
1324         fKeyIncrementValue = incrementValue;
1325 }
1326
1327
1328 int32
1329 BSlider::KeyIncrementValue() const
1330 {
1331         return fKeyIncrementValue;
1332 }
1333
1334
1335 void
1336 BSlider::SetHashMarkCount(int32 hashMarkCount)
1337 {
1338         fHashMarkCount = hashMarkCount;
1339         Invalidate();
1340 }
1341
1342
1343 int32
1344 BSlider::HashMarkCount() const
1345 {
1346         return fHashMarkCount;
1347 }
1348
1349
1350 void
1351 BSlider::SetHashMarks(hash_mark_location where)
1352 {
1353         fHashMarks = where;
1354 // TODO: enable if the hashmark look is influencing the control size!
1355 //      InvalidateLayout();
1356         Invalidate();
1357 }
1358
1359
1360 hash_mark_location
1361 BSlider::HashMarks() const
1362 {
1363         return fHashMarks;
1364 }
1365
1366
1367 void
1368 BSlider::SetStyle(thumb_style style)
1369 {
1370         fStyle = style;
1371         InvalidateLayout();
1372         Invalidate();
1373 }
1374
1375
1376 thumb_style
1377 BSlider::Style() const
1378 {
1379         return fStyle;
1380 }
1381
1382
1383 void
1384 BSlider::SetBarColor(rgb_color barColor)
1385 {
1386         fBarColor = barColor;
1387         Invalidate(BarFrame());
1388 }
1389
1390
1391 rgb_color
1392 BSlider::BarColor() const
1393 {
1394         return fBarColor;
1395 }
1396
1397
1398 void
1399 BSlider::UseFillColor(bool useFill, const rgb_color* barColor)
1400 {
1401         fUseFillColor = useFill;
1402
1403         if (useFill && barColor)
1404                 fFillColor = *barColor;
1405
1406         Invalidate(BarFrame());
1407 }
1408
1409
1410 bool
1411 BSlider::FillColor(rgb_color* barColor) const
1412 {
1413         if (barColor && fUseFillColor)
1414                 *barColor = fFillColor;
1415
1416         return fUseFillColor;
1417 }
1418
1419
1420 BView*
1421 BSlider::OffscreenView() const
1422 {
1423 #if USE_OFF_SCREEN_VIEW
1424         return fOffScreenView;
1425 #else
1426         return (BView*)this;
1427 #endif
1428 }
1429
1430
1431 orientation
1432 BSlider::Orientation() const
1433 {
1434         return fOrientation;
1435 }
1436
1437
1438 void
1439 BSlider::SetOrientation(orientation posture)
1440 {
1441         if (fOrientation == posture)
1442                 return;
1443
1444         fOrientation = posture;
1445         InvalidateLayout();
1446         Invalidate();
1447 }
1448
1449
1450 float
1451 BSlider::BarThickness() const
1452 {
1453         return fBarThickness;
1454 }
1455
1456
1457 void
1458 BSlider::SetBarThickness(float thickness)
1459 {
1460         if (thickness < 1.0)
1461                 thickness = 1.0;
1462         else
1463                 thickness = roundf(thickness);
1464
1465         if (thickness != fBarThickness) {
1466                 // calculate invalid barframe and extend by hashmark size
1467                 float hInset = 0.0;
1468                 float vInset = 0.0;
1469                 if (fOrientation == B_HORIZONTAL)
1470                         vInset = -6.0;
1471                 else
1472                         hInset = -6.0;
1473                 BRect invalid = BarFrame().InsetByCopy(hInset, vInset) | ThumbFrame();
1474
1475                 fBarThickness = thickness;
1476
1477                 invalid = invalid | BarFrame().InsetByCopy(hInset, vInset)
1478                         | ThumbFrame();
1479                 Invalidate(invalid);
1480                 InvalidateLayout();
1481         }
1482 }
1483
1484
1485 void
1486 BSlider::SetFont(const BFont* font, uint32 properties)
1487 {
1488         BControl::SetFont(font, properties);
1489
1490 #if USE_OFF_SCREEN_VIEW
1491         if (fOffScreenView && fOffScreenBits) {
1492                 if (fOffScreenBits->Lock()) {
1493                         fOffScreenView->SetFont(font, properties);
1494                         fOffScreenBits->Unlock();
1495                 }
1496         }
1497 #endif
1498
1499         InvalidateLayout();
1500 }
1501
1502
1503 void
1504 BSlider::SetLimits(int32 minimum, int32 maximum)
1505 {
1506         if (minimum <= maximum) {
1507                 fMinValue = minimum;
1508                 fMaxValue = maximum;
1509
1510                 int32 value = Value();
1511                 value = std::max(minimum, value);
1512                 value = std::min(maximum, value);
1513
1514                 if (value != Value())
1515                         SetValue(value);
1516         }
1517 }
1518
1519
1520 float
1521 BSlider::MaxUpdateTextWidth()
1522 {
1523         // very simplistic implementation that assumes the string will be widest
1524         // at the maximum value
1525         int32 value = Value();
1526         SetValueNoUpdate(fMaxValue);
1527         float width = StringWidth(UpdateText());
1528         SetValueNoUpdate(value);
1529         // in case the derived class uses a fixed buffer, the contents
1530         // should be reset for the old value
1531         UpdateText();
1532
1533         return width;
1534 }
1535
1536
1537 // #pragma mark - layout related
1538
1539
1540 BSize
1541 BSlider::MinSize()
1542 {
1543         return BLayoutUtils::ComposeSize(ExplicitMinSize(), _ValidateMinSize());
1544 }
1545
1546
1547 BSize
1548 BSlider::MaxSize()
1549 {
1550         BSize maxSize = _ValidateMinSize();
1551         if (fOrientation == B_HORIZONTAL)
1552                 maxSize.width = B_SIZE_UNLIMITED;
1553         else
1554                 maxSize.height = B_SIZE_UNLIMITED;
1555
1556         return BLayoutUtils::ComposeSize(ExplicitMaxSize(), maxSize);
1557 }
1558
1559
1560 BSize
1561 BSlider::PreferredSize()
1562 {
1563         BSize preferredSize = _ValidateMinSize();
1564         if (fOrientation == B_HORIZONTAL)
1565                 preferredSize.width = std::max(100.0f, preferredSize.width);
1566         else
1567                 preferredSize.height = std::max(100.0f, preferredSize.height);
1568
1569         return BLayoutUtils::ComposeSize(ExplicitPreferredSize(), preferredSize);
1570 }
1571
1572
1573 status_t
1574 BSlider::SetIcon(const BBitmap* icon, uint32 flags)
1575 {
1576         return BControl::SetIcon(icon, flags);
1577 }
1578
1579
1580 void
1581 BSlider::LayoutInvalidated(bool descendants)
1582 {
1583         // invalidate cached preferred size
1584         fMinSize.Set(-1, -1);
1585 }
1586
1587
1588 // #pragma mark - private
1589
1590
1591 void
1592 BSlider::_DrawBlockThumb()
1593 {
1594         BRect frame = ThumbFrame();
1595         BView* view = OffscreenView();
1596
1597         rgb_color base = ui_color(B_PANEL_BACKGROUND_COLOR);
1598         uint32 flags = be_control_look->Flags(this);
1599         be_control_look->DrawSliderThumb(view, frame, frame, base, flags,
1600                 fOrientation);
1601 }
1602
1603
1604 void
1605 BSlider::_DrawTriangleThumb()
1606 {
1607         BRect frame = ThumbFrame();
1608         BView* view = OffscreenView();
1609         rgb_color base = ui_color(B_PANEL_BACKGROUND_COLOR);
1610         uint32 flags = be_control_look->Flags(this);
1611         be_control_look->DrawSliderTriangle(view, frame, frame, base, flags,
1612                 fOrientation);
1613 }
1614
1615
1616 BPoint
1617 BSlider::_Location() const
1618 {
1619         return fLocation;
1620 }
1621
1622
1623 void
1624 BSlider::_SetLocationForValue(int32 value)
1625 {
1626         BPoint loc;
1627         float range = (float)(fMaxValue - fMinValue);
1628         if (range == 0)
1629                 range = 1;
1630
1631         float pos = (float)(value - fMinValue) / range *
1632                 (_MaxPosition() - _MinPosition());
1633
1634         if (fOrientation == B_HORIZONTAL) {
1635                 loc.x = ceil(_MinPosition() + pos);
1636                 loc.y = 0;
1637         } else {
1638                 loc.x = 0;
1639                 loc.y = floor(_MaxPosition() - pos);
1640         }
1641         fLocation = loc;
1642 }
1643
1644
1645 float
1646 BSlider::_MinPosition() const
1647 {
1648         if (fOrientation == B_HORIZONTAL)
1649                 return BarFrame().left + 1.0f;
1650
1651         return BarFrame().bottom - 1.0f;
1652 }
1653
1654
1655 float
1656 BSlider::_MaxPosition() const
1657 {
1658         if (fOrientation == B_HORIZONTAL)
1659                 return BarFrame().right - 1.0f;
1660
1661         return BarFrame().top + 1.0f;
1662 }
1663
1664
1665 BSize
1666 BSlider::_ValidateMinSize()
1667 {
1668         if (fMinSize.width >= 0) {
1669                 // the preferred size is up to date
1670                 return fMinSize;
1671         }
1672
1673         font_height fontHeight;
1674         GetFontHeight(&fontHeight);
1675
1676         float width = 0.0f;
1677         float height = 0.0f;
1678
1679         if (fMaxUpdateTextWidth < 0.0f)
1680                 fMaxUpdateTextWidth = MaxUpdateTextWidth();
1681
1682         if (Orientation() == B_HORIZONTAL) {
1683                 height = 12.0f + fBarThickness;
1684                 int32 rows = 0;
1685
1686                 float labelWidth = 0;
1687                 int32 labelRows = 0;
1688                 float labelSpacing = StringWidth("M") * 2;
1689                 if (Label() != NULL) {
1690                         labelWidth = StringWidth(Label());
1691                         labelRows = 1;
1692                 }
1693                 if (fMaxUpdateTextWidth > 0.0f) {
1694                         if (labelWidth > 0)
1695                                 labelWidth += labelSpacing;
1696
1697                         labelWidth += fMaxUpdateTextWidth;
1698                         labelRows = 1;
1699                 }
1700                 rows += labelRows;
1701
1702                 if (MinLimitLabel() != NULL)
1703                         width = StringWidth(MinLimitLabel());
1704
1705                 if (MaxLimitLabel() != NULL) {
1706                         // some space between the labels
1707                         if (MinLimitLabel() != NULL)
1708                                 width += labelSpacing;
1709
1710                         width += StringWidth(MaxLimitLabel());
1711                 }
1712
1713                 if (labelWidth > width)
1714                         width = labelWidth;
1715
1716                 if (width < 32.0f)
1717                         width = 32.0f;
1718
1719                 if (MinLimitLabel() || MaxLimitLabel())
1720                         rows++;
1721
1722                 height += rows * (ceilf(fontHeight.ascent)
1723                         + ceilf(fontHeight.descent) + 4.0);
1724         } else {
1725                 // B_VERTICAL
1726                 width = 12.0f + fBarThickness;
1727                 height = 32.0f;
1728
1729                 float lineHeightNoLeading = ceilf(fontHeight.ascent)
1730                         + ceilf(fontHeight.descent);
1731                 float lineHeight = lineHeightNoLeading + ceilf(fontHeight.leading);
1732
1733                 // find largest label
1734                 float labelWidth = 0;
1735                 if (Label() != NULL) {
1736                         labelWidth = StringWidth(Label());
1737                         height += lineHeightNoLeading;
1738                 }
1739                 if (MaxLimitLabel() != NULL) {
1740                         labelWidth = std::max(labelWidth, StringWidth(MaxLimitLabel()));
1741                         height += Label() ? lineHeight : lineHeightNoLeading;
1742                 }
1743                 if (MinLimitLabel() != NULL) {
1744                         labelWidth = std::max(labelWidth, StringWidth(MinLimitLabel()));
1745                         height += lineHeightNoLeading;
1746                 }
1747                 if (fMaxUpdateTextWidth > 0.0f) {
1748                         labelWidth = std::max(labelWidth, fMaxUpdateTextWidth);
1749                         height += MinLimitLabel() ? lineHeight : lineHeightNoLeading;
1750                 }
1751
1752                 width = std::max(labelWidth, width);
1753         }
1754
1755         fMinSize.width = width;
1756         fMinSize.height = height;
1757
1758         ResetLayoutInvalidation();
1759
1760         return fMinSize;
1761 }
1762
1763
1764 // #pragma mark - FBC padding
1765
1766 void BSlider::_ReservedSlider6() {}
1767 void BSlider::_ReservedSlider7() {}
1768 void BSlider::_ReservedSlider8() {}
1769 void BSlider::_ReservedSlider9() {}
1770 void BSlider::_ReservedSlider10() {}
1771 void BSlider::_ReservedSlider11() {}
1772 void BSlider::_ReservedSlider12() {}
1773
1774
1775 BSlider&
1776 BSlider::operator=(const BSlider&)
1777 {
1778         return *this;
1779 }
1780
1781
1782 //      #pragma mark - BeOS compatibility
1783
1784
1785 #if __GNUC__ < 3
1786
1787 extern "C" void
1788 GetLimits__7BSliderPlT1(BSlider* slider, int32* minimum, int32* maximum)
1789 {
1790         slider->GetLimits(minimum, maximum);
1791 }
1792
1793
1794 extern "C" void
1795 _ReservedSlider4__7BSlider(BSlider* slider, int32 minimum, int32 maximum)
1796 {
1797         slider->BSlider::SetLimits(minimum, maximum);
1798 }
1799
1800 extern "C" float
1801 _ReservedSlider5__7BSlider(BSlider* slider)
1802 {
1803         return slider->BSlider::MaxUpdateTextWidth();
1804 }
1805
1806
1807 extern "C" void
1808 _ReservedSlider1__7BSlider(BSlider* slider, orientation _orientation)
1809 {
1810         slider->BSlider::SetOrientation(_orientation);
1811 }
1812
1813
1814 extern "C" void
1815 _ReservedSlider2__7BSlider(BSlider* slider, float thickness)
1816 {
1817         slider->BSlider::SetBarThickness(thickness);
1818 }
1819
1820
1821 extern "C" void
1822 _ReservedSlider3__7BSlider(BSlider* slider, const BFont* font,
1823         uint32 properties)
1824 {
1825         slider->BSlider::SetFont(font, properties);
1826 }
1827
1828
1829 #endif  // __GNUC__ < 3
1830
1831
1832 extern "C" void
1833 B_IF_GCC_2(InvalidateLayout__7BSliderb, _ZN7BSlider16InvalidateLayoutEb)(
1834         BView* view, bool descendants)
1835 {
1836         perform_data_layout_invalidated data;
1837         data.descendants = descendants;
1838
1839         view->Perform(PERFORM_CODE_LAYOUT_INVALIDATED, &data);
1840 }