src/apps/icon-o-matic/gui/StyleListView.cpp

   1 /*
   2  * Copyright 2006-2012, Stephan Aßmus <superstippi@gmx.de>.
   3  * All rights reserved. Distributed under the terms of the MIT License.
   4  */
   5
   6
   7 #include "StyleListView.h"
   8
   9 #include <new>
  10 #include <stdio.h>
  11
  12 #include <Application.h>
  13 #include <Catalog.h>
  14 #include <ListItem.h>
  15 #include <Locale.h>
  16 #include <Menu.h>
  17 #include <MenuItem.h>
  18 #include <Message.h>
  19 #include <Mime.h>
  20 #include <Window.h>
  21
  22 #include "AddStylesCommand.h"
  23 #include "AssignStyleCommand.h"
  24 #include "CurrentColor.h"
  25 #include "CommandStack.h"
  26 #include "GradientTransformable.h"
  27 #include "MoveStylesCommand.h"
  28 #include "RemoveStylesCommand.h"
  29 #include "Style.h"
  30 #include "Observer.h"
  31 #include "ResetTransformationCommand.h"
  32 #include "Shape.h"
  33 #include "ShapeContainer.h"
  34 #include "Selection.h"
  35 #include "Util.h"
  36
  37
  38 #undef B_TRANSLATION_CONTEXT
  39 #define B_TRANSLATION_CONTEXT "Icon-O-Matic-StylesList"
  40
  41
  42 using std::nothrow;
  43
  44 static const float kMarkWidth           = 14.0;
  45 static const float kBorderOffset        = 3.0;
  46 static const float kTextOffset          = 4.0;
  47
  48 enum {
  49         MSG_ADD                                                 = 'adst',
  50         MSG_REMOVE                                              = 'rmst',
  51         MSG_DUPLICATE                                   = 'dpst',
  52         MSG_RESET_TRANSFORMATION                = 'rstr',
  53 };
  54
  55 class StyleListItem : public SimpleItem,
  56                                          public Observer {
  57 public:
  58         StyleListItem(Style* s, StyleListView* listView, bool markEnabled)
  59                 :
  60                 SimpleItem(""),
  61                 style(NULL),
  62                 fListView(listView),
  63                 fMarkEnabled(markEnabled),
  64                 fMarked(false)
  65         {
  66                 SetStyle(s);
  67         }
  68
  69         virtual ~StyleListItem()
  70         {
  71                 SetStyle(NULL);
  72         }
  73
  74         // SimpleItem interface
  75         virtual void Draw(BView* owner, BRect itemFrame, uint32 flags)
  76         {
  77                 SimpleItem::DrawBackground(owner, itemFrame, flags);
  78
  79                 // text
  80                 if (IsSelected())
  81                         owner->SetHighColor(ui_color(B_LIST_SELECTED_ITEM_TEXT_COLOR));
  82                 else
  83                         owner->SetHighColor(ui_color(B_LIST_ITEM_TEXT_COLOR));
  84                 font_height fh;
  85                 owner->GetFontHeight(&fh);
  86                 BString truncatedString(Text());
  87                 owner->TruncateString(&truncatedString, B_TRUNCATE_MIDDLE,
  88                         itemFrame.Width() - kBorderOffset - kMarkWidth - kTextOffset
  89                         - kBorderOffset);
  90                 float height = itemFrame.Height();
  91                 float textHeight = fh.ascent + fh.descent;
  92                 BPoint pos;
  93                 pos.x = itemFrame.left + kBorderOffset + kMarkWidth + kTextOffset;
  94                 pos.y = itemFrame.top + ceilf((height - textHeight) / 2.0 + fh.ascent);
  95                 owner->DrawString(truncatedString.String(), pos);
  96
  97                 if (!fMarkEnabled)
  98                         return;
  99
 100                 // mark
 101                 BRect markRect = itemFrame;
 102                 float markRectBorderTint = B_DARKEN_1_TINT;
 103                 float markRectFillTint = 1.04;
 104                 float markTint = B_DARKEN_4_TINT;
 105                                         // Dark Themes
 106                 rgb_color lowColor = owner->LowColor();
 107                 if (lowColor.red + lowColor.green + lowColor.blue < 128 * 3) {
 108                         markRectBorderTint = B_LIGHTEN_2_TINT;
 109                         markRectFillTint = 0.85;
 110                         markTint = 0.1;
 111                 }
 112                 markRect.left += kBorderOffset;
 113                 markRect.right = markRect.left + kMarkWidth;
 114                 markRect.top = (markRect.top + markRect.bottom - kMarkWidth) / 2.0;
 115                 markRect.bottom = markRect.top + kMarkWidth;
 116                 owner->SetHighColor(tint_color(owner->LowColor(), markRectBorderTint));
 117                 owner->StrokeRect(markRect);
 118                 markRect.InsetBy(1, 1);
 119                 owner->SetHighColor(tint_color(owner->LowColor(), markRectFillTint));
 120                 owner->FillRect(markRect);
 121                 if (fMarked) {
 122                         markRect.InsetBy(2, 2);
 123                         owner->SetHighColor(tint_color(owner->LowColor(),
 124                                 markTint));
 125                         owner->SetPenSize(2);
 126                         owner->StrokeLine(markRect.LeftTop(), markRect.RightBottom());
 127                         owner->StrokeLine(markRect.LeftBottom(), markRect.RightTop());
 128                         owner->SetPenSize(1);
 129                 }
 130         }
 131
 132         // Observer interface
 133         virtual void    ObjectChanged(const Observable* object)
 134         {
 135                 UpdateText();
 136         }
 137
 138         // StyleListItem
 139         void SetStyle(Style* s)
 140         {
 141                 if (s == style)
 142                         return;
 143
 144                 if (style) {
 145                         style->RemoveObserver(this);
 146                         style->ReleaseReference();
 147                 }
 148
 149                 style = s;
 150
 151                 if (style) {
 152                         style->AcquireReference();
 153                         style->AddObserver(this);
 154                         UpdateText();
 155                 }
 156         }
 157
 158         void UpdateText()
 159         {
 160                 SetText(style->Name());
 161                 Invalidate();
 162         }
 163
 164         void SetMarkEnabled(bool enabled)
 165         {
 166                 if (fMarkEnabled == enabled)
 167                         return;
 168                 fMarkEnabled = enabled;
 169                 Invalidate();
 170         }
 171
 172         void SetMarked(bool marked)
 173         {
 174                 if (fMarked == marked)
 175                         return;
 176                 fMarked = marked;
 177                 Invalidate();
 178         }
 179
 180         void Invalidate()
 181         {
 182                 if (fListView->LockLooper()) {
 183                         fListView->InvalidateItem(fListView->IndexOf(this));
 184                         fListView->UnlockLooper();
 185                 }
 186         }
 187
 188 public:
 189         Style*                  style;
 190
 191 private:
 192         StyleListView*  fListView;
 193         bool                    fMarkEnabled;
 194         bool                    fMarked;
 195 };
 196
 197
 198 class ShapeStyleListener : public ShapeListener,
 199         public ShapeContainerListener {
 200 public:
 201         ShapeStyleListener(StyleListView* listView)
 202                 :
 203                 fListView(listView),
 204                 fShape(NULL)
 205         {
 206         }
 207
 208         virtual ~ShapeStyleListener()
 209         {
 210                 SetShape(NULL);
 211         }
 212
 213         // ShapeListener interface
 214         virtual void TransformerAdded(Transformer* t, int32 index)
 215         {
 216         }
 217
 218         virtual void TransformerRemoved(Transformer* t)
 219         {
 220         }
 221
 222         virtual void StyleChanged(Style* oldStyle, Style* newStyle)
 223         {
 224                 fListView->_SetStyleMarked(oldStyle, false);
 225                 fListView->_SetStyleMarked(newStyle, true);
 226         }
 227
 228         // ShapeContainerListener interface
 229         virtual void ShapeAdded(Shape* shape, int32 index)
 230         {
 231         }
 232
 233         virtual void ShapeRemoved(Shape* shape)
 234         {
 235                 fListView->SetCurrentShape(NULL);
 236         }
 237
 238         // ShapeStyleListener
 239         void SetShape(Shape* shape)
 240         {
 241                 if (fShape == shape)
 242                         return;
 243
 244                 if (fShape)
 245                         fShape->RemoveListener(this);
 246
 247                 fShape = shape;
 248
 249                 if (fShape)
 250                         fShape->AddListener(this);
 251         }
 252
 253         Shape* CurrentShape() const
 254         {
 255                 return fShape;
 256         }
 257
 258 private:
 259         StyleListView*  fListView;
 260         Shape*                  fShape;
 261 };
 262
 263
 264 // #pragma mark -
 265
 266
 267 StyleListView::StyleListView(BRect frame, const char* name, BMessage* message,
 268         BHandler* target)
 269         :
 270         SimpleListView(frame, name, NULL, B_SINGLE_SELECTION_LIST),
 271         fMessage(message),
 272         fStyleContainer(NULL),
 273         fShapeContainer(NULL),
 274         fCommandStack(NULL),
 275         fCurrentColor(NULL),
 276
 277         fCurrentShape(NULL),
 278         fShapeListener(new ShapeStyleListener(this)),
 279
 280         fMenu(NULL)
 281 {
 282         SetTarget(target);
 283 }
 284
 285
 286 StyleListView::~StyleListView()
 287 {
 288         _MakeEmpty();
 289         delete fMessage;
 290
 291         if (fStyleContainer != NULL)
 292                 fStyleContainer->RemoveListener(this);
 293
 294         if (fShapeContainer != NULL)
 295                 fShapeContainer->RemoveListener(fShapeListener);
 296
 297         delete fShapeListener;
 298 }
 299
 300
 301 // #pragma mark -
 302
 303
 304 void
 305 StyleListView::MessageReceived(BMessage* message)
 306 {
 307         switch (message->what) {
 308                 case MSG_ADD:
 309                 {
 310                         Style* style;
 311                         AddStylesCommand* command;
 312                         rgb_color color;
 313                         if (fCurrentColor != NULL)
 314                                 color = fCurrentColor->Color();
 315                         else {
 316                                 color.red = 0;
 317                                 color.green = 0;
 318                                 color.blue = 0;
 319                                 color.alpha = 255;
 320                         }
 321                         new_style(color, fStyleContainer, &style, &command);
 322                         fCommandStack->Perform(command);
 323                         break;
 324                 }
 325
 326                 case MSG_REMOVE:
 327                         RemoveSelected();
 328                         break;
 329
 330                 case MSG_DUPLICATE:
 331                 {
 332                         int32 count = CountSelectedItems();
 333                         int32 index = 0;
 334                         BList items;
 335                         for (int32 i = 0; i < count; i++) {
 336                                 index = CurrentSelection(i);
 337                                 BListItem* item = ItemAt(index);
 338                                 if (item)
 339                                         items.AddItem((void*)item);
 340                         }
 341                         CopyItems(items, index + 1);
 342                         break;
 343                 }
 344
 345                 case MSG_RESET_TRANSFORMATION:
 346                 {
 347                         int32 count = CountSelectedItems();
 348                         BList gradients;
 349                         for (int32 i = 0; i < count; i++) {
 350                                 StyleListItem* item = dynamic_cast<StyleListItem*>(
 351                                         ItemAt(CurrentSelection(i)));
 352                                 if (item && item->style && item->style->Gradient()) {
 353                                         if (!gradients.AddItem((void*)item->style->Gradient()))
 354                                                 break;
 355                                 }
 356                         }
 357                         count = gradients.CountItems();
 358                         if (count <= 0)
 359                                 break;
 360
 361                         Transformable* transformables[count];
 362                         for (int32 i = 0; i < count; i++) {
 363                                 Gradient* gradient = (Gradient*)gradients.ItemAtFast(i);
 364                                 transformables[i] = gradient;
 365                         }
 366
 367                         ResetTransformationCommand* command
 368                                 = new ResetTransformationCommand(transformables, count);
 369
 370                         fCommandStack->Perform(command);
 371                         break;
 372                 }
 373
 374                 default:
 375                         SimpleListView::MessageReceived(message);
 376                         break;
 377         }
 378 }
 379
 380
 381 void
 382 StyleListView::SelectionChanged()
 383 {
 384         SimpleListView::SelectionChanged();
 385
 386         if (!fSyncingToSelection) {
 387                 // NOTE: single selection list
 388                 StyleListItem* item
 389                         = dynamic_cast<StyleListItem*>(ItemAt(CurrentSelection(0)));
 390                 if (fMessage) {
 391                         BMessage message(*fMessage);
 392                         message.AddPointer("style", item ? (void*)item->style : NULL);
 393                         Invoke(&message);
 394                 }
 395         }
 396
 397         _UpdateMenu();
 398 }
 399
 400
 401 void
 402 StyleListView::MouseDown(BPoint where)
 403 {
 404         if (fCurrentShape == NULL) {
 405                 SimpleListView::MouseDown(where);
 406                 return;
 407         }
 408
 409         bool handled = false;
 410         int32 index = IndexOf(where);
 411         StyleListItem* item = dynamic_cast<StyleListItem*>(ItemAt(index));
 412         if (item != NULL) {
 413                 BRect itemFrame(ItemFrame(index));
 414                 itemFrame.right = itemFrame.left + kBorderOffset + kMarkWidth
 415                         + kTextOffset / 2.0;
 416                 Style* style = item->style;
 417                 if (itemFrame.Contains(where)) {
 418                         // set the style on the shape
 419                         if (fCommandStack) {
 420                                 ::Command* command = new AssignStyleCommand(
 421                                                                                         fCurrentShape, style);
 422                                 fCommandStack->Perform(command);
 423                         } else {
 424                                 fCurrentShape->SetStyle(style);
 425                         }
 426                         handled = true;
 427                 }
 428         }
 429
 430         if (!handled)
 431                 SimpleListView::MouseDown(where);
 432 }
 433
 434
 435 void
 436 StyleListView::MakeDragMessage(BMessage* message) const
 437 {
 438         SimpleListView::MakeDragMessage(message);
 439         message->AddPointer("container", fStyleContainer);
 440         int32 count = CountSelectedItems();
 441         for (int32 i = 0; i < count; i++) {
 442                 StyleListItem* item = dynamic_cast<StyleListItem*>(
 443                         ItemAt(CurrentSelection(i)));
 444                 if (item != NULL) {
 445                         message->AddPointer("style", (void*)item->style);
 446                         BMessage archive;
 447                         if (item->style->Archive(&archive, true) == B_OK)
 448                                 message->AddMessage("style archive", &archive);
 449                 } else
 450                         break;
 451         }
 452 }
 453
 454
 455 bool
 456 StyleListView::AcceptDragMessage(const BMessage* message) const
 457 {
 458         return SimpleListView::AcceptDragMessage(message);
 459 }
 460
 461
 462 void
 463 StyleListView::SetDropTargetRect(const BMessage* message, BPoint where)
 464 {
 465         SimpleListView::SetDropTargetRect(message, where);
 466 }
 467
 468
 469 bool
 470 StyleListView::HandleDropMessage(const BMessage* message, int32 dropIndex)
 471 {
 472         // Let SimpleListView handle drag-sorting (when drag came from ourself)
 473         if (SimpleListView::HandleDropMessage(message, dropIndex))
 474                 return true;
 475
 476         if (fCommandStack == NULL || fStyleContainer == NULL)
 477                 return false;
 478
 479         // Drag may have come from another instance, like in another window.
 480         // Reconstruct the Styles from the archive and add them at the drop
 481         // index.
 482         int index = 0;
 483         BList styles;
 484         while (true) {
 485                 BMessage archive;
 486                 if (message->FindMessage("style archive", index, &archive) != B_OK)
 487                         break;
 488                 Style* style = new(std::nothrow) Style(&archive);
 489                 if (style == NULL)
 490                         break;
 491
 492                 if (!styles.AddItem(style)) {
 493                         delete style;
 494                         break;
 495                 }
 496
 497                 index++;
 498         }
 499
 500         int32 count = styles.CountItems();
 501         if (count == 0)
 502                 return false;
 503
 504         AddStylesCommand* command = new(std::nothrow) AddStylesCommand(
 505                 fStyleContainer, (Style**)styles.Items(), count, dropIndex);
 506
 507         if (command == NULL) {
 508                 for (int32 i = 0; i < count; i++)
 509                         delete (Style*)styles.ItemAtFast(i);
 510                 return false;
 511         }
 512
 513         fCommandStack->Perform(command);
 514
 515         return true;
 516 }
 517
 518
 519 void
 520 StyleListView::MoveItems(BList& items, int32 toIndex)
 521 {
 522         if (fCommandStack == NULL || fStyleContainer == NULL)
 523                 return;
 524
 525         int32 count = items.CountItems();
 526         Style** styles = new (nothrow) Style*[count];
 527         if (styles == NULL)
 528                 return;
 529
 530         for (int32 i = 0; i < count; i++) {
 531                 StyleListItem* item
 532                         = dynamic_cast<StyleListItem*>((BListItem*)items.ItemAtFast(i));
 533                 styles[i] = item ? item->style : NULL;
 534         }
 535
 536         MoveStylesCommand* command = new (nothrow) MoveStylesCommand(
 537                 fStyleContainer, styles, count, toIndex);
 538         if (command == NULL) {
 539                 delete[] styles;
 540                 return;
 541         }
 542
 543         fCommandStack->Perform(command);
 544 }
 545
 546
 547 void
 548 StyleListView::CopyItems(BList& items, int32 toIndex)
 549 {
 550         if (fCommandStack == NULL || fStyleContainer == NULL)
 551                 return;
 552
 553         int32 count = items.CountItems();
 554         Style* styles[count];
 555
 556         for (int32 i = 0; i < count; i++) {
 557                 StyleListItem* item
 558                         = dynamic_cast<StyleListItem*>((BListItem*)items.ItemAtFast(i));
 559                 styles[i] = item ? new (nothrow) Style(*item->style) : NULL;
 560         }
 561
 562         AddStylesCommand* command
 563                 = new (nothrow) AddStylesCommand(fStyleContainer,
 564                                                                                  styles, count, toIndex);
 565         if (!command) {
 566                 for (int32 i = 0; i < count; i++)
 567                         delete styles[i];
 568                 return;
 569         }
 570
 571         fCommandStack->Perform(command);
 572 }
 573
 574
 575 void
 576 StyleListView::RemoveItemList(BList& items)
 577 {
 578         if (!fCommandStack || !fStyleContainer)
 579                 return;
 580
 581         int32 count = items.CountItems();
 582         Style* styles[count];
 583         for (int32 i = 0; i < count; i++) {
 584                 StyleListItem* item = dynamic_cast<StyleListItem*>(
 585                         (BListItem*)items.ItemAtFast(i));
 586                 if (item)
 587                         styles[i] = item->style;
 588                 else
 589                         styles[i] = NULL;
 590         }
 591
 592         RemoveStylesCommand* command
 593                 = new (nothrow) RemoveStylesCommand(fStyleContainer,
 594                                                                                         styles, count);
 595         fCommandStack->Perform(command);
 596 }
 597
 598
 599 BListItem*
 600 StyleListView::CloneItem(int32 index) const
 601 {
 602         if (StyleListItem* item = dynamic_cast<StyleListItem*>(ItemAt(index))) {
 603                 return new StyleListItem(item->style,
 604                         const_cast<StyleListView*>(this),
 605                         fCurrentShape != NULL);
 606         }
 607         return NULL;
 608 }
 609
 610
 611 int32
 612 StyleListView::IndexOfSelectable(Selectable* selectable) const
 613 {
 614         Style* style = dynamic_cast<Style*>(selectable);
 615         if (style == NULL)
 616                 return -1;
 617
 618         int count = CountItems();
 619         for (int32 i = 0; i < count; i++) {
 620                 if (SelectableFor(ItemAt(i)) == style)
 621                         return i;
 622         }
 623
 624         return -1;
 625 }
 626
 627
 628 Selectable*
 629 StyleListView::SelectableFor(BListItem* item) const
 630 {
 631         StyleListItem* styleItem = dynamic_cast<StyleListItem*>(item);
 632         if (styleItem != NULL)
 633                 return styleItem->style;
 634         return NULL;
 635 }
 636
 637
 638 // #pragma mark -
 639
 640
 641 void
 642 StyleListView::StyleAdded(Style* style, int32 index)
 643 {
 644         // NOTE: we are in the thread that messed with the
 645         // StyleContainer, so no need to lock the
 646         // container, when this is changed to asynchronous
 647         // notifications, then it would need to be read-locked!
 648         if (!LockLooper())
 649                 return;
 650
 651         if (_AddStyle(style, index))
 652                 Select(index);
 653
 654         UnlockLooper();
 655 }
 656
 657
 658 void
 659 StyleListView::StyleRemoved(Style* style)
 660 {
 661         // NOTE: we are in the thread that messed with the
 662         // StyleContainer, so no need to lock the
 663         // container, when this is changed to asynchronous
 664         // notifications, then it would need to be read-locked!
 665         if (!LockLooper())
 666                 return;
 667
 668         // NOTE: we're only interested in Style objects
 669         _RemoveStyle(style);
 670
 671         UnlockLooper();
 672 }
 673
 674
 675 // #pragma mark -
 676
 677
 678 void
 679 StyleListView::SetMenu(BMenu* menu)
 680 {
 681         if (fMenu == menu)
 682                 return;
 683
 684         fMenu = menu;
 685         if (fMenu == NULL)
 686                 return;
 687
 688         fAddMI = new BMenuItem(B_TRANSLATE("Add"), new BMessage(MSG_ADD));
 689         fMenu->AddItem(fAddMI);
 690
 691         fMenu->AddSeparatorItem();
 692
 693         fDuplicateMI = new BMenuItem(B_TRANSLATE("Duplicate"),
 694                 new BMessage(MSG_DUPLICATE));
 695         fMenu->AddItem(fDuplicateMI);
 696
 697         fResetTransformationMI = new BMenuItem(B_TRANSLATE("Reset transformation"),
 698                 new BMessage(MSG_RESET_TRANSFORMATION));
 699         fMenu->AddItem(fResetTransformationMI);
 700
 701         fMenu->AddSeparatorItem();
 702
 703         fRemoveMI = new BMenuItem(B_TRANSLATE("Remove"), new BMessage(MSG_REMOVE));
 704         fMenu->AddItem(fRemoveMI);
 705
 706         fMenu->SetTargetForItems(this);
 707
 708         _UpdateMenu();
 709 }
 710
 711
 712 void
 713 StyleListView::SetStyleContainer(StyleContainer* container)
 714 {
 715         if (fStyleContainer == container)
 716                 return;
 717
 718         // detach from old container
 719         if (fStyleContainer != NULL)
 720                 fStyleContainer->RemoveListener(this);
 721
 722         _MakeEmpty();
 723
 724         fStyleContainer = container;
 725
 726         if (fStyleContainer == NULL)
 727                 return;
 728
 729         fStyleContainer->AddListener(this);
 730
 731         // sync
 732         int32 count = fStyleContainer->CountStyles();
 733         for (int32 i = 0; i < count; i++)
 734                 _AddStyle(fStyleContainer->StyleAtFast(i), i);
 735 }
 736
 737
 738 void
 739 StyleListView::SetShapeContainer(ShapeContainer* container)
 740 {
 741         if (fShapeContainer == container)
 742                 return;
 743
 744         // detach from old container
 745         if (fShapeContainer)
 746                 fShapeContainer->RemoveListener(fShapeListener);
 747
 748         fShapeContainer = container;
 749
 750         if (fShapeContainer)
 751                 fShapeContainer->AddListener(fShapeListener);
 752 }
 753
 754
 755 void
 756 StyleListView::SetCommandStack(CommandStack* stack)
 757 {
 758         fCommandStack = stack;
 759 }
 760
 761
 762 void
 763 StyleListView::SetCurrentColor(CurrentColor* color)
 764 {
 765         fCurrentColor = color;
 766 }
 767
 768
 769 void
 770 StyleListView::SetCurrentShape(Shape* shape)
 771 {
 772         if (fCurrentShape == shape)
 773                 return;
 774
 775         fCurrentShape = shape;
 776         fShapeListener->SetShape(shape);
 777
 778         _UpdateMarks();
 779 }
 780
 781
 782 // #pragma mark -
 783
 784
 785 bool
 786 StyleListView::_AddStyle(Style* style, int32 index)
 787 {
 788         if (style != NULL) {
 789                  return AddItem(new StyleListItem(
 790                         style, this, fCurrentShape != NULL), index);
 791         }
 792         return false;
 793 }
 794
 795
 796 bool
 797 StyleListView::_RemoveStyle(Style* style)
 798 {
 799         StyleListItem* item = _ItemForStyle(style);
 800         if (item != NULL && RemoveItem(item)) {
 801                 delete item;
 802                 return true;
 803         }
 804         return false;
 805 }
 806
 807
 808 StyleListItem*
 809 StyleListView::_ItemForStyle(Style* style) const
 810 {
 811         int count = CountItems();
 812         for (int32 i = 0; i < count; i++) {
 813                 StyleListItem* item = dynamic_cast<StyleListItem*>(ItemAt(i));
 814                 if (item == NULL)
 815                         continue;
 816                 if (item->style == style)
 817                         return item;
 818         }
 819         return NULL;
 820 }
 821
 822
 823 // #pragma mark -
 824
 825
 826 void
 827 StyleListView::_UpdateMarks()
 828 {
 829         int32 count = CountItems();
 830         if (fCurrentShape) {
 831                 // enable display of marks and mark items whoes
 832                 // style is contained in fCurrentShape
 833                 for (int32 i = 0; i < count; i++) {
 834                         StyleListItem* item = dynamic_cast<StyleListItem*>(ItemAt(i));
 835                         if (item == NULL)
 836                                 continue;
 837                         item->SetMarkEnabled(true);
 838                         item->SetMarked(fCurrentShape->Style() == item->style);
 839                 }
 840         } else {
 841                 // disable display of marks
 842                 for (int32 i = 0; i < count; i++) {
 843                         StyleListItem* item = dynamic_cast<StyleListItem*>(ItemAt(i));
 844                         if (item == NULL)
 845                                 continue;
 846                         item->SetMarkEnabled(false);
 847                 }
 848         }
 849
 850         Invalidate();
 851 }
 852
 853
 854 void
 855 StyleListView::_SetStyleMarked(Style* style, bool marked)
 856 {
 857         StyleListItem* item = _ItemForStyle(style);
 858         if (item != NULL)
 859                 item->SetMarked(marked);
 860 }
 861
 862
 863 void
 864 StyleListView::_UpdateMenu()
 865 {
 866         if (fMenu == NULL)
 867                 return;
 868
 869         bool gotSelection = CurrentSelection(0) >= 0;
 870
 871         fDuplicateMI->SetEnabled(gotSelection);
 872         // TODO: only enable fResetTransformationMI if styles
 873         // with gradients are selected!
 874         fResetTransformationMI->SetEnabled(gotSelection);
 875         fRemoveMI->SetEnabled(gotSelection);
 876 }
 877