---

gapeunitgroup.cpp

//GapeUnitGroup.cpp
//Dave Chisholm dkc@ccrma.stanford.edu
//11/20/00

#include "gapeunitgroup.h"

GapeUnitGroup::GapeUnitGroup(GapeController* c, int capacity)
: GapeUnit() {
    units = new GapeUnit* [capacity];
    for (int i = 0; i < capacity; i++) {
        units[i] = NULL;
    }
    currentCapacity = capacity;
    numUnits = 0;
}


GapeUnitGroup::~GapeUnitGroup()    {
    for (int i = 0; i < numUnits; i++) {
        delete units[i];
        units[i] = NULL;
    }
}


void GapeUnitGroup::addUnit(GapeUnit* u) {
    if (u == NULL) return;
    updateMutex.lock();
    if (numUnits == currentCapacity) {
        units = (GapeUnit**) GapeConsts::expandArray((void**)units, &currentCapacity);
    }


    //rewire old connections if necesary
    if (numUnits != 0) {
        disconnect(units[numUnits-1], SIGNAL(emitTick(const GapeFloat*,int)), this, SIGNAL(emitTick(const GapeFloat*,int)));
        connect(units[numUnits-1], SIGNAL(emitTick(const GapeFloat*,int)), u, SLOT(receiveTick(const GapeFloat*,int)));
    }

    //put the new unit at the end of our chain
    units[numUnits] = u;
    connect(u, SIGNAL(emitTick(const GapeFloat*,int)), this, SIGNAL(emitTick(const GapeFloat*,int)));//wire the new units output to ours
    numUnits++;

    for (int i = 0; i < numControllers; i++) {
        u->addController(controllers[i]);
    }
    updateMutex.unlock();
}


void GapeUnitGroup::removeUnit(GapeUnit* u) {
    int i;
    if (u == NULL) return;// false;

    for (i = 0;i < numUnits; i++) {
        if (units[i] == u) break;//find the unit
    }

    if (i == numUnits) {
        GapeConsts::reportError("Tried to remove unit from unit group that wasn't there! GapeUnitGroup.cpp\n");
        return;// false;//we don't actually have the unit!
    }
    updateMutex.lock();
    if (i != 0) {//if this is not our first unit, we disconnect the unit before it
        disconnect(units[i-1], SIGNAL(emitTick(const GapeFloat*,int)), units[i], SLOT(receiveTick(const GapeFloat*,int)));

        if (i < (numUnits - 1)) {//and if its not our last unit, we disconnect the following unit
            disconnect(units[i], SIGNAL(emitTick(const GapeFloat*,int)), units[i+1], SLOT(receiveTick(const GapeFloat*,int)));
            //then connect the unit before to the unit after
            connect(units[i-1], SIGNAL(emitTick(const GapeFloat*,int)), units[i+1], SLOT(receiveTick(const GapeFloat*,int)));

        } else {//ie this is our last unit and not the first, we disconnect from our unitGroup's emit signal
            disconnect(units[i], SIGNAL(emitTick(const GapeFloat*,int)), this, SIGNAL(emitTick(const GapeFloat*,int)));
            //and connect the previous unit to the emitTick signal
            connect(units[i-1], SIGNAL(emitTick(const GapeFloat*,int)), this, SIGNAL(emitTick(const GapeFloat*,int)));
        }


    } else {//ie this is our first unit
        if (i < (numUnits - 1)) {//and if its not also our last unit, we disconnect the following unit
            disconnect(units[i], SIGNAL(emitTick(const GapeFloat*,int)), units[i+1], SLOT(receiveTick(const GapeFloat*,int)));

        } else {//ie this is our first and last unit, we disconnect from our unitGroup's emit signal(ie numUnits ==1)
            disconnect(units[i], SIGNAL(emitTick(const GapeFloat*,int)), this, SIGNAL(emitTick(const GapeFloat*,int)));
        }
    }

    //now we shift everything after the deleted unit back one in the array
    for (int j = i + 1; j < numUnits; j++) {
        units[j-1] = units[j];
    }

    for (i = 0; i < numControllers; i++) {
        u->removeController(controllers[i]);
    }

    units[numUnits-1] = NULL;
    numUnits--;
    updateMutex.unlock();
    return;// true;
}


/*void** expandArray(void** array, int* oldCapacity, int factor) {
    void** temp = new void* [oldSize*factor];
    memcpy(temp, array,(*oldSize) * sizeof(void*));
    (*oldCapacity) *= 2;
    delete array
    return temp;
}

//this function increases the capacity of our group, by allocating an array twice as large and then coping the contents of the old into the new
void GapeUnitGroup::expandUnit() {
    GapeUnit** temp = new GapeUnit* [currentCapacity * 2];
    memcpy(temp, units, numUnits * sizeof(GapeUnit*));
    currentCapacity *= 2;
    delete[] units;
    units = temp;
}
*/


void GapeUnitGroup::addController(GapeController* c) {
    GapeUnit::addController(c);
    for (int i = 0; i < numUnits; i++) {
        units[i]->addController(c);
    }
}


void GapeUnitGroup::removeController(GapeController* c) {
    GapeUnit::removeController(c);
    for (int i = 0; i < numUnits; i++) {
        units[i]->removeController(c);
    }
}


GapeUnit* GapeUnitGroup::getUnit(int index) {
    if (index >= numUnits || index < 0) {
        return NULL;
    } else {
        return units[index];
    }
}


void GapeUnitGroup::requestSolo(GapeUnit* requestingUnit) {
    for (int i = 0; i < numUnits; i++) {
        if (units[i] != requestingUnit) {
            units[i]->setMute(true);
        }
    }
}


void GapeUnitGroup::endSolo(GapeUnit* requestingUnit) {
    for (int i = 0; i < numUnits; i++) {
        if (units[i] != requestingUnit) {
            units[i]->setMute(false);
        }
    }
}

---