src/libs/icon/shape/PathContainer.cpp

   1 /*
   2  * Copyright 2006, Haiku.
   3  * Distributed under the terms of the MIT License.
   4  *
   5  * Authors:
   6  *              Stephan Aßmus <superstippi@gmx.de>
   7  */
   8
   9 #include "PathContainer.h"
  10
  11 #include <stdio.h>
  12 #include <string.h>
  13
  14 #include <OS.h>
  15
  16 #include "VectorPath.h"
  17
  18 #ifdef ICON_O_MATIC
  19 PathContainerListener::PathContainerListener() {}
  20 PathContainerListener::~PathContainerListener() {}
  21 #endif
  22
  23
  24 // constructor
  25 PathContainer::PathContainer(bool ownsPaths)
  26         : fPaths(16),
  27           fOwnsPaths(ownsPaths)
  28 #ifdef ICON_O_MATIC
  29         , fListeners(2)
  30 #endif
  31 {
  32 }
  33
  34 // destructor
  35 PathContainer::~PathContainer()
  36 {
  37 #ifdef ICON_O_MATIC
  38         int32 count = fListeners.CountItems();
  39         if (count > 0) {
  40                 debugger("~PathContainer() - there are still"
  41                                  "listeners attached\n");
  42         }
  43 #endif // ICON_O_MATIC
  44         _MakeEmpty();
  45 }
  46
  47 // #pragma mark -
  48
  49 // AddPath
  50 bool
  51 PathContainer::AddPath(VectorPath* path)
  52 {
  53         return AddPath(path, CountPaths());
  54 }
  55
  56 // AddPath
  57 bool
  58 PathContainer::AddPath(VectorPath* path, int32 index)
  59 {
  60         if (!path)
  61                 return false;
  62
  63         // prevent adding the same path twice
  64         if (HasPath(path))
  65                 return false;
  66
  67         if (fPaths.AddItem((void*)path, index)) {
  68 #ifdef ICON_O_MATIC
  69                 _NotifyPathAdded(path, index);
  70 #endif
  71                 return true;
  72         }
  73
  74         fprintf(stderr, "PathContainer::AddPath() - out of memory!\n");
  75         return false;
  76 }
  77
  78 // RemovePath
  79 bool
  80 PathContainer::RemovePath(VectorPath* path)
  81 {
  82         if (fPaths.RemoveItem((void*)path)) {
  83 #ifdef ICON_O_MATIC
  84                 _NotifyPathRemoved(path);
  85 #endif
  86                 return true;
  87         }
  88
  89         return false;
  90 }
  91
  92 // RemovePath
  93 VectorPath*
  94 PathContainer::RemovePath(int32 index)
  95 {
  96         VectorPath* path = (VectorPath*)fPaths.RemoveItem(index);
  97 #ifdef ICON_O_MATIC
  98         if (path) {
  99                 _NotifyPathRemoved(path);
 100         }
 101 #endif
 102
 103         return path;
 104 }
 105
 106 // MakeEmpty
 107 void
 108 PathContainer::MakeEmpty()
 109 {
 110         _MakeEmpty();
 111 }
 112
 113 // #pragma mark -
 114
 115 // CountPaths
 116 int32
 117 PathContainer::CountPaths() const
 118 {
 119         return fPaths.CountItems();
 120 }
 121
 122 // HasPath
 123 bool
 124 PathContainer::HasPath(VectorPath* path) const
 125 {
 126         return fPaths.HasItem((void*)path);
 127 }
 128
 129 // IndexOf
 130 int32
 131 PathContainer::IndexOf(VectorPath* path) const
 132 {
 133         return fPaths.IndexOf((void*)path);
 134 }
 135
 136 // PathAt
 137 VectorPath*
 138 PathContainer::PathAt(int32 index) const
 139 {
 140         return (VectorPath*)fPaths.ItemAt(index);
 141 }
 142
 143 // PathAtFast
 144 VectorPath*
 145 PathContainer::PathAtFast(int32 index) const
 146 {
 147         return (VectorPath*)fPaths.ItemAtFast(index);
 148 }
 149
 150 // #pragma mark -
 151
 152 #ifdef ICON_O_MATIC
 153 // AddListener
 154 bool
 155 PathContainer::AddListener(PathContainerListener* listener)
 156 {
 157         if (listener && !fListeners.HasItem((void*)listener))
 158                 return fListeners.AddItem(listener);
 159         return false;
 160 }
 161
 162 // RemoveListener
 163 bool
 164 PathContainer::RemoveListener(PathContainerListener* listener)
 165 {
 166         return fListeners.RemoveItem(listener);
 167 }
 168 #endif // ICON_O_MATIC
 169
 170 // #pragma mark -
 171
 172 // _MakeEmpty
 173 void
 174 PathContainer::_MakeEmpty()
 175 {
 176         int32 count = CountPaths();
 177         for (int32 i = 0; i < count; i++) {
 178                 VectorPath* path = PathAtFast(i);
 179 #ifdef ICON_O_MATIC
 180                 _NotifyPathRemoved(path);
 181                 if (fOwnsPaths)
 182                         path->ReleaseReference();
 183 #else
 184                 if (fOwnsPaths)
 185                         delete path;
 186 #endif
 187         }
 188         fPaths.MakeEmpty();
 189 }
 190
 191 // #pragma mark -
 192
 193 #ifdef ICON_O_MATIC
 194 // _NotifyPathAdded
 195 void
 196 PathContainer::_NotifyPathAdded(VectorPath* path, int32 index) const
 197 {
 198         BList listeners(fListeners);
 199         int32 count = listeners.CountItems();
 200         for (int32 i = 0; i < count; i++) {
 201                 PathContainerListener* listener
 202                         = (PathContainerListener*)listeners.ItemAtFast(i);
 203                 listener->PathAdded(path, index);
 204         }
 205 }
 206
 207 // _NotifyPathRemoved
 208 void
 209 PathContainer::_NotifyPathRemoved(VectorPath* path) const
 210 {
 211         BList listeners(fListeners);
 212         int32 count = listeners.CountItems();
 213         for (int32 i = 0; i < count; i++) {
 214                 PathContainerListener* listener
 215                         = (PathContainerListener*)listeners.ItemAtFast(i);
 216                 listener->PathRemoved(path);
 217         }
 218 }
 219 #endif // ICON_O_MATIC
 220