picture.cpp

Go to the documentation of this file.

#ifndef PICTURE_IMPLEMENTATION_FILE
#define PICTURE_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : picture                                                           *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1991-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "picture.h"
#include "wp_implementation.h"

#include <basis/guards.h>
#include <data_struct/amorph.cpp>

picture::picture(const c_point &origin)
: drawable(origin), amorph<picture_part>(0), _origin(origin) {}

picture::~picture() {}

const drawable *picture::get(int index) const
  { return amorph<picture_part>::get(index)->stored; }

drawable *picture::acquire(int index)
{
  drawable *to_return = amorph<picture_part>::acquire(index)->stored;
  remove(index);
  return to_return;
}

void picture::add(drawable *to_add)
{
  if (!to_add) return;
  picture_part *wrapper = new picture_part(to_add->origin());
  wrapper->stored = to_add;
  int i;
  for (i = 0; i < elements(); i++)
    if (get(i)->layer() > to_add->layer()) break;
  i--;
  if (i < 0) i = 0;
  if ( (i == elements() - 2) && (get(i+1)->layer() <= to_add->layer()) ) i++;
    // the index is checked for being at the top of the list (less than zero)
    // and for being at the penultimate end of the list when it should be at
    // the actual end.
  insert(i, 1);
  put(i, wrapper);
  to_add->set_origin(to_add->origin() + drawable::origin());
}

c_rectangle picture::dimensions() const
{
  c_rectangle to_return(c_point(0, 0), c_point(0, 0));
  if (elements())
    to_return = get(0)->dimensions();
  for (int i = 1; i < elements(); i++)
    to_return.encompass(get(i)->dimensions());
  return to_return;
}

bool picture::remove(drawable *to_remove)
{
  int num_elements = elements();
  for (int i = 0; i < num_elements; i++)
    if (get(i) == to_remove) { return remove(i); }
  return false;
}

void picture::draw()
{
  for (int i = 0; i < elements(); i++) {
    picture_part *found = amorph<picture_part>::borrow(i);
    found->stored->draw();
  }
}

void picture::erase()
{
  for (int i = 0; i < elements(); i++) {
    picture_part *found = amorph<picture_part>::borrow(i);
    found->stored->erase();
  }
}

void picture::draw_intersecting(const c_rectangle &region)
{
  for (int i = 0; i < elements(); i++)
    if (region.intersect(get(i)->dimensions())) {
      picture_part *found = amorph<picture_part>::borrow(i);
      found->stored->draw();
    }
}

void picture::erase_intersecting(const c_rectangle &region)
{
  for (int i = 0; i < elements(); i++)
    if (region.intersect(get(i)->dimensions())) {
      picture_part *found = amorph<picture_part>::borrow(i);
      found->stored->erase();
    }
}

bool picture::remove(int index)
{
  bounds_return(index, 0, elements() - 1, false);
  zap(index, index);
  return true;
}

void picture::set_origin(const c_point &new_origin)
{
  bool was_visible(visible());
  if (was_visible) erase();

  for (int i = 0; i < elements(); i++) {
    picture_part *found = amorph<picture_part>::borrow(i);
    found->stored->set_origin(new_origin + c_point(*found));
  }
  drawable::set_origin(new_origin);

  if (was_visible) draw();
}

void picture::update()
{
//  erase();
  amorph<picture_part> hold(elements());
  for (int i = 0; i < elements(); i++)
    hold.put(i, amorph<picture_part>::acquire(i));
// i know, it's a fricking bubble sort.  oh well...
  for (int a = 0; a < hold.elements() - 1; a++)
    for (int b = a + 1; b < hold.elements(); b++)
      if (hold.get(a)->stored->layer() > hold.get(b)->stored->layer()) {
        picture_part *first = hold.acquire(a);
        hold.put(a, hold.acquire(b));
        hold.put(b, first);
      }
  for (int q = 0; q < elements(); q++) put(q, hold.acquire(q));
//  draw();
}

#endif //PICTURE_IMPLEMENTATION_FILE

---