Shamusworld >> Repos - architektonas/blob - src/utils.cpp

   1 // utils.cpp: Stuff that's useful to have kicking around, in one spot
   2 //
   3 // Part of the Architektonas Project
   4 // (C) 2015 Underground Software
   5 // See the README and GPLv3 files for licensing and warranty information
   6 //
   7 // JLH = James Hammons <jlhamm@acm.org>
   8 //
   9 // Who  When        What
  10 // ---  ----------  ------------------------------------------------------------
  11 // JLH  05/01/2015  Created this file
  12 //
  13
  14 #include "utils.h"
  15 #include <string.h>             // For memcpy()
  16
  17
  18 //
  19 // Copy objects in one vector to another, creating copies and placing them in
  20 // the other vector. Clearing & etc. of vectors is responsibility of the caller!
  21 //
  22 void CopyObjects(std::vector<void *> & from, std::vector<void *> & to)
  23 {
  24         std::vector<void *>::iterator i;
  25
  26         for(i=from.begin(); i!=from.end(); i++)
  27         {
  28                 Object * obj = (Object *)(*i);
  29                 Object * newObject = CopyObject(obj);
  30                 to.push_back(newObject);
  31         }
  32 }
  33
  34
  35 //
  36 // Create a copy of the passed in object.
  37 //
  38 Object * CopyObject(Object * obj)
  39 {
  40         Object * newObject = NULL;
  41
  42         switch (obj->type)
  43         {
  44         case OTLine:
  45                 newObject = (Object *)new Line();
  46                 memcpy(newObject, obj, sizeof(Line));
  47                 break;
  48         case OTCircle:
  49                 newObject = (Object *)new Circle();
  50                 memcpy(newObject, obj, sizeof(Circle));
  51                 break;
  52         case OTEllipse:
  53                 newObject = (Object *)new Ellipse();
  54                 memcpy(newObject, obj, sizeof(Ellipse));
  55                 break;
  56         case OTArc:
  57                 newObject = (Object *)new Arc();
  58                 memcpy(newObject, obj, sizeof(Arc));
  59                 break;
  60         case OTDimension:
  61                 newObject = (Object *)new Dimension();
  62                 memcpy(newObject, obj, sizeof(Dimension));
  63                 break;
  64 #if 0
  65         case OTSpline:
  66                 newObject = (Object *)new Spline();
  67                 memcpy(newObject, obj, sizeof(Spline));
  68                 break;
  69 #endif
  70         case OTText:
  71                 newObject = (Object *)new Text();
  72                 memcpy(newObject, obj, sizeof(Text));
  73                 ((Text *)newObject)->s = ((Text *)obj)->s;
  74                 break;
  75         case OTContainer:
  76                 newObject = (Object *)new Container();
  77 //this won't work...
  78 //              memcpy(newObject, obj, sizeof(Line));
  79                 CopyObjects(((Container *)obj)->objects, ((Container *)newObject)->objects);
  80                 break;
  81         default:
  82                 break;
  83         }
  84
  85         // Fix objectID
  86         if (newObject && (newObject->type != OTContainer))
  87                 newObject->id = Global::objectID;
  88
  89         return newObject;
  90 }
  91
  92
  93 void MoveSelectedObjectsTo(std::vector<void *> & dest, std::vector<void *> & from)
  94 {
  95         std::vector<void *>::iterator i = from.begin();
  96
  97         while (i != from.end())
  98         {
  99                 Object * obj = (Object *)(*i);
 100
 101                 if (obj->selected)
 102                 {
 103                         dest.push_back(*i);
 104                         from.erase(i);
 105                 }
 106                 else
 107                         i++;
 108         }
 109 }
 110
 111
 112 void AddObjectsTo(std::vector<void *> & dest, std::vector<void *> & from)
 113 {
 114         for(std::vector<void *>::iterator i=from.begin(); i!=from.end(); i++)
 115                 dest.push_back(*i);
 116 }
 117
 118
 119 void ClearSelected(std::vector<void *> & v)
 120 {
 121         std::vector<void *>::iterator i;
 122
 123         for(i=v.begin(); i!=v.end(); i++)
 124                 ((Object *)(*i))->selected = false;
 125 }
 126
 127
 128 void SelectAll(std::vector<void *> & v)
 129 {
 130         std::vector<void *>::iterator i;
 131
 132         for(i=v.begin(); i!=v.end(); i++)
 133                 ((Object *)(*i))->selected = true;
 134 }
 135
 136
 137 //
 138 // Recursively go down thru the Container's vectors, deleting all the objects
 139 // contained therein. Once that is done, the main Container can be deleted. We
 140 // don't have to worry about the underlying std::vectors, as they have their
 141 // own destructors--plus they don't take ownership of objects, which is why we
 142 // have to keep track of that stuff ourselves. :-P Believe it or not, this is a
 143 // Good Thing(TM). ;-)
 144 //
 145 void DeleteContents(std::vector<void *> & v)
 146 {
 147         std::vector<void *>::iterator i;
 148
 149         for(i=v.begin(); i!=v.end(); i++)
 150         {
 151                 Object * obj = (Object *)(*i);
 152
 153                 if (obj->type == OTContainer)
 154                         DeleteContents(((Container *)obj)->objects);
 155
 156                 delete obj;
 157         }
 158 }
 159
 160 void DeleteSelectedObjects(std::vector<void *> & v)
 161 {
 162         std::vector<void *>::iterator i = v.begin();
 163
 164         while (i != v.end())
 165         {
 166                 Object * obj = (Object *)(*i);
 167
 168                 if (obj->selected)
 169                 {
 170                         delete obj;
 171                         v.erase(i);
 172                 }
 173                 else
 174                         i++;
 175         }
 176 }
 177
 178
 179 //
 180 // This is used to remove selected objects from one container in order to move
 181 // them to a different container.
 182 //
 183 void RemoveSelectedObjects(std::vector<void *> & v)
 184 {
 185         std::vector<void *>::iterator i = v.begin();
 186
 187         while (i != v.end())
 188         {
 189                 Object * obj = (Object *)(*i);
 190
 191                 if (obj->selected)
 192                         v.erase(i);
 193                 else
 194                         i++;
 195         }
 196 }
 197
 198
 199 void SavePointsFrom(std::vector<void *> & v, std::vector<Object> & save)
 200 {
 201         save.clear();
 202         Object o;
 203
 204         for(std::vector<void *>::iterator i=v.begin(); i!=v.end(); i++)
 205         {
 206                 memcpy(&o, (*i), sizeof(Object));
 207                 save.push_back(o);
 208         }
 209 }
 210
 211
 212 void RestorePointsTo(std::vector<void *> & v, std::vector<Object> & s)
 213 {
 214         std::vector<Object>::iterator i = s.begin();
 215         std::vector<void *>::iterator j = v.begin();
 216
 217         for(; i!=s.end(); i++, j++)
 218         {
 219                 Object * obj2 = (Object *)(*j);
 220                 obj2->p[0] = (*i).p[0];
 221                 obj2->p[1] = (*i).p[1];
 222                 obj2->angle[0] = (*i).angle[0];
 223                 obj2->angle[1] = (*i).angle[1];
 224 //we don't do this because we want to keep selected & friends from changing
 225 //              memcpy(obj2, *j, sizeof(Object));
 226         }
 227 }
 228
 229
 230 void TranslateObject(Object * obj, Point delta)
 231 {
 232         if (obj->type == OTContainer)
 233         {
 234                 Container * c = (Container *)obj;
 235                 std::vector<void *>::iterator i;
 236
 237                 for(i=c->objects.begin(); i!=c->objects.end(); i++)
 238                         TranslateObject((Object *)*i, delta);
 239         }
 240         else
 241         {
 242                 obj->p[0] += delta;
 243                 obj->p[1] += delta;
 244         }
 245 }
 246
 247