source: trunk/src/testing/app/mframes/machinefile_code/tile_config.cpp @ 4

/******************************************************************************
 * SAGE - Scalable Adaptive Graphics Environment
 *
 * Copyright (C) 2004 Electronic Visualization Laboratory,
 * University of Illinois at Chicago
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following disclaimer
 *    in the documentation and/or other materials provided with the distribution.
 *  * Neither the name of the University of Illinois at Chicago nor
 *    the names of its contributors may be used to endorse or promote
 *    products derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Direct questions, comments etc about SAGE to http://www.evl.uic.edu/cavern/forum/
 *
 *****************************************************************************/

/*------------------------------------------------------------------------
-       Author: Arun Rao
-       Library: Tile Config
-       Revision Date: 4/22/2004
-       Module: tile_config.cpp
-       Purpose: Contains all class details/implementation for building
-       a description of a tile display system, at run time
---------------------------------------------------------------------------*/
#include "tile_config.h"
#include <string.h>


//----------------------------------------------------------
//
//
//
//
//
//-----------------------------------------------------------

Physical_Tile::Physical_Tile():screenWidth(0),screenHeight(0),
                                leftMullion(0),rightMullion(0),topMullion(0),bottomMullion(0),
                                id(-1),next(NULL),source(NULL)
{
        //nothing else to do
}

Physical_Tile::~Physical_Tile()
{

        source = NULL;
        next = NULL;

}

void Physical_Tile::Source(Display_Node* dn)
{
        source = dn;
}

Display_Node* Physical_Tile::Source()
{ return source; }

float Physical_Tile::LowerLeftX(){ return lowerleftX; }
float Physical_Tile::LowerLeftY(){ return lowerleftY; }

void Physical_Tile::LowerLeftX(float lx){ lowerleftX = lx; }
void Physical_Tile::LowerLeftY(float ly){ lowerleftY = ly; }


float Physical_Tile::ScreenWidthDimension()
{ return screenWidth; }

void Physical_Tile::ScreenWidthDimension(float dim)
{ screenWidth = dim; }

float Physical_Tile::ScreenHeightDimension(void)
{ return screenHeight; }

void Physical_Tile::ScreenHeightDimension(float dim)
{ screenHeight = dim; }

float Physical_Tile::TopMullionThickness()
{ return topMullion; }

void Physical_Tile::TopMullionThickness(float t)
{ topMullion = t; }

float Physical_Tile::BottomMullionThickness()
{ return bottomMullion; }

void Physical_Tile::BottomMullionThickness(float t)
{ bottomMullion = t; }

float Physical_Tile::LeftMullionThickness()
{ return leftMullion; }

void Physical_Tile::LeftMullionThickness(float t)
{ leftMullion = t; }

float Physical_Tile::RightMullionThickness()
{ return rightMullion; }

void Physical_Tile::RightMullionThickness(float t)
{ rightMullion = t; }

int Physical_Tile::ID()
{ return id; }

void Physical_Tile::ID(int i)
{ id = i; }

Physical_Tile* Physical_Tile::Next()
{ return next; }

void Physical_Tile::Next(Physical_Tile* n)
{ next = n; }
//----------------------------------------------------------
//
//
//
//
//
//-----------------------------------------------------------

Virtual_Desktop_Tile::Virtual_Desktop_Tile():lowerLeftX(0),lowerLeftY(0),widthRatio(0),
                                                heightRatio(0),id(-1),next(NULL),nonMullionLLX(0),
                                                nonMullionLLY(0)
{
        //do nothing
}

Virtual_Desktop_Tile::~Virtual_Desktop_Tile()
{

        next = NULL;
}

float Virtual_Desktop_Tile::LowerLeftX()
{ return lowerLeftX; }

void Virtual_Desktop_Tile::LowerLeftX(float x)
{ lowerLeftX = x; }

float Virtual_Desktop_Tile::LowerLeftY()
{ return lowerLeftY; }

void Virtual_Desktop_Tile::LowerLeftY(float y)
{ lowerLeftY = y; }

void Virtual_Desktop_Tile::LowerLeftPixelX(int p)
{ lowerLeftPixelX = p; }

void Virtual_Desktop_Tile::LowerLeftPixelY(int p)
{ lowerLeftPixelY = p; }

void Virtual_Desktop_Tile::WidthInPixels(int p)
{ widthInPixels = p; }

void Virtual_Desktop_Tile::HeightInPixels(int p)
{ heightInPixels = p; }

int Virtual_Desktop_Tile::LowerLeftPixelX()
{ return lowerLeftPixelX; }

int Virtual_Desktop_Tile::LowerLeftPixelY()
{ return lowerLeftPixelY; }

int Virtual_Desktop_Tile::WidthInPixels()
{ return widthInPixels; }

int Virtual_Desktop_Tile::HeightInPixels()
{ return heightInPixels; }

float Virtual_Desktop_Tile::WidthRatio()
{ return widthRatio; }

void Virtual_Desktop_Tile::WidthRatio(float r)
{ widthRatio = r; }

float Virtual_Desktop_Tile::HeightRatio()
{ return heightRatio; }

void Virtual_Desktop_Tile::HeightRatio(float r)
{ heightRatio = r; }

int Virtual_Desktop_Tile::ID()
{ return id; }

void Virtual_Desktop_Tile::ID(int i)
{ id = i; }

Virtual_Desktop_Tile* Virtual_Desktop_Tile::Next()
{ return next; }

void Virtual_Desktop_Tile::Next(Virtual_Desktop_Tile* vdt)
{ next = vdt; }

Display_Node* Virtual_Desktop_Tile::DisplayNode()
{ return dispNode; }

void Virtual_Desktop_Tile::DisplayNode(Display_Node* dn)
{ dispNode = dn; }

int Virtual_Desktop_Tile::NonMullionLLX()
{ return nonMullionLLX; }

int Virtual_Desktop_Tile::NonMullionLLY()
{ return nonMullionLLY; }

void Virtual_Desktop_Tile::NonMullionLLX(int x)
{ nonMullionLLX = x; }

void Virtual_Desktop_Tile::NonMullionLLY(int y)
{ nonMullionLLY = y; }

//----------------------------------------------------------
//
//
//
//
//
//-----------------------------------------------------------
VDTtoPTmapper::VDTtoPTmapper(Physical_Tile* tpt, Virtual_Desktop_Tile* tvdt):pt(tpt),vdt(tvdt)
{ }

VDTtoPTmapper::~VDTtoPTmapper()
{ }

Physical_Tile* VDTtoPTmapper::PhysicalTile(){ return pt; }

Virtual_Desktop_Tile* VDTtoPTmapper::VirtualDesktopTile(){ return vdt; }

//----------------------------------------------------------
//
//
//
//
//
//-----------------------------------------------------------

Display_Node::Display_Node():nodeName(NULL),ip(NULL),next(NULL),maps(NULL),numberOfMaps(0)
{

}

Display_Node::~Display_Node()
{

        if( maps && numberOfMaps)
        {


        }

        if( ip )
                delete [] ip;

        if( nodeName )
                delete [] nodeName;

        next = NULL;
}

void Display_Node::Name(char* newName)
{
        if( nodeName )
                delete [] nodeName;

        nodeName = new char[strlen(newName) + 1];
        strcpy(nodeName,newName);
}

void Display_Node::IP(char* newIP)
{
        if( ip )
                delete [] ip;

        ip = new char[strlen(newIP) + 1];
        strcpy(ip,newIP);
}

char* Display_Node::Name(){ return nodeName; }
char* Display_Node::IP(){ return ip; }
Display_Node* Display_Node::Next(){ return next; }
void Display_Node::Next(Display_Node* dn){ next = dn; }

int Display_Node::NumberOfMaps(){ return numberOfMaps; }
void Display_Node::NumberOfMaps(int n)  //need to adjust maps
{
        VDTtoPTmapper** tempMap = maps;
        maps = NULL;
        maps = new VDTtoPTmapper*[n];

        int i = 0;

        //copy over as many nodes as the new maps array can fit
        for(    ; i < n; i++)
        {
                if( i < numberOfMaps && tempMap)
                {
                        maps[i] = tempMap[i];
                        tempMap[i] = NULL;
                }
                else
                        maps[i] = NULL;
        }

        //clean up any nodes left over in the old maps array
        for(    ; i < numberOfMaps && tempMap; i++)
        {
                tempMap[i]->VirtualDesktopTile()->DisplayNode(NULL);
                tempMap[i]->PhysicalTile()->Source(NULL);

        }

        delete [] tempMap;
        numberOfMaps = n;

}


VDTtoPTmapper** Display_Node::Maps(){ return maps; }

bool Display_Node::AddMap(VDTtoPTmapper* pMap)
{

        for(int i = 0; i < numberOfMaps; i++)
        {
                if(maps[i] == NULL)
                {
                        maps[i] = pMap;
                        maps[i]->VirtualDesktopTile()->DisplayNode(this);
                        maps[i]->PhysicalTile()->Source(this);
                        return true;

                }

        }

        return false;
}

void Display_Node::RemoveMap(VDTtoPTmapper* vpMap)
{
        for(int i = 0; i < numberOfMaps; i++)
        {
                if(maps[i] && maps[i] == vpMap)
                {
                        delete maps[i];
                        maps[i] = NULL;
                }
        }
}

void Display_Node::RemoveMap(int index)
{
        if(index < numberOfMaps && maps[index])
        {
                delete maps[index];
                maps[index] = NULL;
        }
}

//----------------------------------------------------------
//
//
//
//
//
//-----------------------------------------------------------

DisplayCluster::DisplayCluster():displayNodeListHead(NULL)
{

}

DisplayCluster::~DisplayCluster()
{

}


void DisplayCluster::AddDisplayNode(Display_Node* dn)
{
        Display_Node* temp = displayNodeListHead;
        if(temp)
        {
                while(temp->Next())
                {
                        temp = temp->Next();
                }

                temp->Next(dn);
                dn->Next(NULL);
        }
        else
        {
                displayNodeListHead = dn;
                dn->Next(NULL);

        }

}


void DisplayCluster::RemoveDisplayNode(char* name)
{

}

void DisplayCluster::RemoveDisplayNodeByName(char* name)
{
        RemoveDisplayNode(name);
}


void DisplayCluster::RemoveDisplayNodeByIP(char* ip)
{

}

Display_Node* DisplayCluster::getFirstNode()
{
        return this->displayNodeListHead;
}


//Generate and insert a mapping between virtual tile and physical tile to a display node
//Assuming the physical tile already knows the display node source
bool DisplayCluster::GenerateMapping(Virtual_Desktop_Tile* vdt, Physical_Tile* pt)
{
        //make sure the physical tile is on the physical display associated with this display cluster
        if(!pd->TileOnPhysicalDisplay(pt))
                return false;


        if(pt->Source() == NULL)
                return false;           //the physical tile must already have a source

        //make sure that the source node is on this display cluster
        if(!NodeOnCluster(pt->Source()))
                return false;

        VDTtoPTmapper* map = new VDTtoPTmapper(pt,vdt);
        if(pt->Source()->AddMap(map))
                return true;

        delete map;
        return false;

}

PhysicalDisplay* DisplayCluster::PhysicalDisplayAssoc(){ return pd; }
void DisplayCluster::PhysicalDisplayAssoc(PhysicalDisplay* tpd)
{
        pd = tpd;
}

//Generate and insert a mapping between virtual and physical tile using the given display node
bool DisplayCluster::GenerateMapping(Virtual_Desktop_Tile* vdt, Physical_Tile *pt, Display_Node *dn)
{
        //make sure the physical tile is on the physical display associated with this display cluster
        if(!pd->TileOnPhysicalDisplay(pt))
                return false;

        Display_Node *itr = displayNodeListHead;
        //make sure the node is on this display cluster
        if(!NodeOnCluster(dn))
                return false;

        VDTtoPTmapper* map = new VDTtoPTmapper(pt,vdt);
        if(dn->AddMap(map))
                return true;

        delete map;
        return false;

}

void DisplayCluster::RemoveMapping(Virtual_Desktop_Tile* vdt, Physical_Tile *pt, Display_Node* dn)
{
        if(!NodeOnCluster(dn))
                return;

        VDTtoPTmapper** maps = dn->Maps();
        int count = dn->NumberOfMaps();

        for(int i = 0; i < count; i++)
        {
                if(maps[i] && maps[i]->PhysicalTile() == pt && maps[i]->VirtualDesktopTile() == vdt)
                        dn->RemoveMap(i);
        }

}

bool DisplayCluster::NodeOnCluster(Display_Node* dn)
{
        Display_Node* itr = displayNodeListHead;
        while(itr)
        {
                if(itr == dn)
                {
                        return true;
                }
                itr = itr->Next();
        }

        return false;
}

void DisplayCluster::RemoveMapsWith(Virtual_Desktop_Tile* tvdt)
{
        Display_Node* itr = displayNodeListHead;
        while(itr)
        {
                VDTtoPTmapper** maps = itr->Maps();
                int count = itr->NumberOfMaps();
                for(    ;count > 0; count--)
                {
                        if(maps[count - 1] && maps[count - 1]->VirtualDesktopTile() == tvdt)
                                itr->RemoveMap(count - 1);
                }

                itr = itr->Next();
        }
}

void DisplayCluster::RemoveMapsWith(Physical_Tile* tpt)
{
        Display_Node* itr = displayNodeListHead;
        while(itr)
        {
                VDTtoPTmapper** maps = itr->Maps();
                int count = itr->NumberOfMaps();
                for(    ;count > 0; count--)
                {
                        if(maps[count - 1] && maps[count - 1]->PhysicalTile() == tpt)
                                itr->RemoveMap(count - 1);
                }

                itr = itr->Next();
        }
}

VirtualDesktop* DisplayCluster::VirtualDesktopAssoc(){ return vd; }
void DisplayCluster::VirtualDesktopAssoc(VirtualDesktop* tvd)
{

}

//----------------------------------------------------------
//
//
//
//
//
//-----------------------------------------------------------


PhysicalDisplay::PhysicalDisplay():physicalTileListHead(NULL),vd(NULL),dc(NULL),
pixelsPerInch(1.0)
{


}

PhysicalDisplay::~PhysicalDisplay()
{

}

void PhysicalDisplay::VirtualDesktopAssoc(VirtualDesktop *tvd)
{
        vd = tvd;
}
VirtualDesktop* PhysicalDisplay::VirtualDesktopAssoc(){ return vd; }

int PhysicalDisplay::AddPhysicalTile(Physical_Tile* pt)
{
        int ID = 1;
        if(physicalTileListHead == NULL)
        {
                physicalTileListHead = pt;
        }
        else
        {
                Physical_Tile *itr = physicalTileListHead;
                while(itr->Next())
                {
                        itr = itr->Next();
                        ID++;
                }

                itr->Next(pt);
                pt->Next(NULL);
        }

        pt->ID(ID);
        return ID;
}

Physical_Tile* PhysicalDisplay::RemovePhysicalTileByID(int ID, bool delquery)
{

        Physical_Tile *itr = physicalTileListHead;

        if(itr->ID() == ID)
        {
                physicalTileListHead = itr->Next();

        }
        else
        {
                while(itr->Next())
                {
                        //in order to take care of accidental redundant data, loop for each entry
                        if(itr->Next()->ID() == ID)
                        {
                                itr->Next(itr->Next()->Next());
                                if(dc)
                                        dc->RemoveMapsWith(itr);

                        }
                }
        }

        if(delquery)
        {
                delete itr;
                return NULL;
        }
        else
                return itr;


}


DisplayCluster* PhysicalDisplay::DisplayClusterAssoc()
{ return dc; }

void PhysicalDisplay::DisplayClusterAssoc(DisplayCluster* tdc)
{
        //go through the current display cluster and remove all the mappings that were made to the
        //physical tiles associated with this display cluster
        Physical_Tile* itr = physicalTileListHead;
        while(itr)
        {
                if(dc)
                        dc->RemoveMapsWith(itr);
                itr->Source(NULL);
                itr = itr->Next();
        }

        dc = tdc;


}

bool PhysicalDisplay::TileOnPhysicalDisplay(Physical_Tile* pt)
{
        Physical_Tile* itr = physicalTileListHead;
        while(itr)
        {
                if(itr == pt)
                        return true;

                itr = itr->Next();
        }

        return false;
}
Physical_Tile* PhysicalDisplay::getFirstNode()
{ return physicalTileListHead; }

float PhysicalDisplay::PixelsPerInch(){ return pixelsPerInch; }
void PhysicalDisplay::PixelsPerInch(float ratio)
{ pixelsPerInch = ratio; }

//----------------------------------------------------------
//
//
//
//
//
//-----------------------------------------------------------

VirtualDesktop::VirtualDesktop():dc(NULL),pd(NULL),tileListHead(NULL),vertRes(1),horizRes(1)    //just 1 pixel by 1 pixel
{
}

VirtualDesktop::~VirtualDesktop()
{
        Virtual_Desktop_Tile* itr = tileListHead;
        while(itr)
        {
                if(dc)
                        dc->RemoveMapsWith(itr);
                tileListHead = itr->Next();
                delete itr;
                itr = tileListHead;
        }
}

DisplayCluster* VirtualDesktop::DisplayClusterAssoc(){ return dc; }
void VirtualDesktop::DisplayClusterAssoc(DisplayCluster *tdc)
{
        dc = tdc;
}

PhysicalDisplay* VirtualDesktop::PhysicalDisplayAssoc(){ return pd; }
void VirtualDesktop::PhysicalDisplayAssoc(PhysicalDisplay* tpd)
{
        pd = tpd;
}

void VirtualDesktop::AddTile(Virtual_Desktop_Tile* tvdt)
{
        //the tile has to be already mapped to a physical tile,
        VDTtoPTmapper* mapping = NULL;
        if(!dc)
                return;

        Display_Node* itr = dc->getFirstNode();

        while(itr)
        {
                int count = itr->NumberOfMaps();
                VDTtoPTmapper** maps = itr->Maps();
                for( ;count > 0; count--)
                {
                        if(maps[count - 1] && maps[count - 1]->VirtualDesktopTile() == tvdt)
                        {
                                mapping = maps[count - 1];
                                itr = NULL;
                                break;
                        }
                }

                if(itr)
                        itr = itr->Next();
        }

        if(!mapping)
                return;

        //there is a mapping...continue


        //put at end of list
        Virtual_Desktop_Tile* vdtItr = tileListHead;
        if(vdtItr == NULL)
        {
                tileListHead = tvdt;
                tvdt->Next(NULL);
                return;
        }

        while(vdtItr->Next())
        {
                vdtItr = vdtItr->Next();
        }

        vdtItr->Next(tvdt);
        tvdt->Next(NULL);

}

void VirtualDesktop::RemoveTile(Virtual_Desktop_Tile* tvdt)
{
        Virtual_Desktop_Tile* itr = tileListHead;
        while(itr)
        {
                if(itr == tvdt)
                {
                        if(dc)
                        {
                                return dc->RemoveMapsWith(tvdt);
                        }
                }
                itr = itr->Next();
        }

}

Virtual_Desktop_Tile* VirtualDesktop::getFirstNode(void)
{
        return tileListHead;
}

bool VirtualDesktop::Update()
{
        if(!pd)
                return false;


        float positiveHoriz, positiveVert, negativeHoriz, negativeVert;
        positiveHoriz = positiveVert = negativeHoriz = negativeVert = 0.0;
        float leftMullion, bottomMullion;
        //need to determine the whole virtual desktop size
        Physical_Tile* ptItr = pd->getFirstNode();
        while(ptItr)
        {
                if(ptItr->LowerLeftX() < negativeHoriz)
                {
                        negativeHoriz = ptItr->LowerLeftX();
                        leftMullion = ptItr->LeftMullionThickness();
                }
                else if(ptItr->LowerLeftX() + ptItr->ScreenWidthDimension() > positiveHoriz)
                {
                        positiveHoriz = ptItr->LowerLeftX() + ptItr->ScreenWidthDimension();
                }

                if(ptItr->LowerLeftY() < negativeVert)
                {
                        negativeVert = ptItr->LowerLeftY();
                        bottomMullion = ptItr->BottomMullionThickness();

                }
                else if(ptItr->LowerLeftY() + ptItr->ScreenHeightDimension() > positiveVert)
                {
                        positiveVert = ptItr->LowerLeftY() + ptItr->ScreenHeightDimension();
                }

                ptItr = ptItr->Next();
        }

        //save off the resolutions.
        horizRes = (int)((positiveHoriz - negativeHoriz) * (pd->PixelsPerInch()));
        vertRes = (int)((positiveVert - negativeVert) * (pd->PixelsPerInch()));


        //go through all the virtual tiles and adjust their properties based on their mapped physical tiles
        Virtual_Desktop_Tile* vdtItr = tileListHead;
        while(vdtItr)
        {
                VDTtoPTmapper* mapping;

                mapping = NULL;
                if(!dc)
                        return false;

                Display_Node* itr = dc->getFirstNode();

                while(itr)
                {
                        int count = itr->NumberOfMaps();
                        VDTtoPTmapper** maps = itr->Maps();
                        for( ;count > 0; count--)
                        {
                                if(maps[count - 1] && maps[count - 1]->VirtualDesktopTile() == vdtItr)
                                {
                                        mapping = maps[count - 1];
                                        itr = NULL;
                                        break;
                                }
                        }

                        if(itr)
                                itr = itr->Next();
                }

                //we have an unmapped virtual tile....doesn't make sense, stop and return false
                if(!mapping)
                        return false;

                //calculate the virtual tile properties
                float posXRatio, posYRatio, widthRatio, heightRatio;
                posXRatio = posYRatio = widthRatio = heightRatio = 0.0;
                Physical_Tile* ptTemp = mapping->PhysicalTile();

                vdtItr->LowerLeftPixelX( (ptTemp->LowerLeftX() + ptTemp->LeftMullionThickness())  * pd->PixelsPerInch() );
                vdtItr->LowerLeftPixelY( (ptTemp->LowerLeftY() + ptTemp->BottomMullionThickness()) * pd->PixelsPerInch() );
                vdtItr->LowerLeftX( (float)vdtItr->LowerLeftPixelX() / horizRes);
                vdtItr->LowerLeftY( (float)vdtItr->LowerLeftPixelY() / vertRes);

                vdtItr->WidthInPixels( ptTemp->ScreenWidthDimension() * pd->PixelsPerInch() );
                vdtItr->HeightInPixels( ptTemp->ScreenHeightDimension() * pd->PixelsPerInch());
                vdtItr->WidthRatio( (float)vdtItr->WidthInPixels() / horizRes);
                vdtItr->HeightRatio( (float)vdtItr->HeightInPixels() / vertRes);

                vdtItr->ID( ptTemp->ID());      //map the id of the virtual tile to the same id of the physical tile

                //move on
                vdtItr = vdtItr->Next();

        }


        return true;

}