source: trunk/src/testing/app/mframes/machinefile_code/tile_config.h @ 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.h
-       Purpose: Contains all class descriptions for building
-       a description of a tile display system, at run time
---------------------------------------------------------------------------*/
#ifndef SAGE_TILE_CONFIG_H
#define SAGE_TILE_CONFIG_H

#define _DEBUG 1

#include <stdio.h>
#include <stdlib.h>

//__________________________________________
class Physical_Tile;
class Display_Node;
class Virtual_Desktop_Tile;

class DisplayCluster;
class PhysicalDisplay;
class VirtualDesktop;
//__________________________________________

class Physical_Tile
{
private:
        //int horizRes; //horizontal resolution
        //int vertRes;  //vertical resolution
        float screenWidth;      //width of screen in inches
        float screenHeight;     //height of screen in inches
        float leftMullion;      //the width of the left Mullion in inches
        float rightMullion;     // "    "       "  right "      "
        float topMullion;               // "    "       "  top   "      "
        float bottomMullion;    // "    "       "  bottom "     "
        float lowerleftX;       //the x position of the bottom left corner of the tile (including the mullions from left)
                                                //with respect to some arbritrary origin
        float lowerleftY;       //the y position of the bottom left corner of the tile (including the mullions from bottom)
                                                //with respect to some arbritrary origin
        int id;
        Virtual_Desktop_Tile* virtDeskTile;     //the virtual desktop tile that the physical tile will display
        Physical_Tile* next;
        Display_Node*    source;        //the display node that is the source to the physical tile
public:
        Physical_Tile();
        ~Physical_Tile();

        float ScreenWidthDimension();
        float ScreenHeightDimension();
        float LeftMullionThickness();
        float RightMullionThickness();
        float TopMullionThickness();
        float BottomMullionThickness();
        float LowerLeftX();
        float LowerLeftY();
        int ID();
        Physical_Tile* Next();
        Display_Node* Source();
        Virtual_Desktop_Tile* VirtualDesktopTile();


        void ScreenWidthDimension(float);
        void ScreenHeightDimension(float);
        void RightMullionThickness(float);
        void LeftMullionThickness(float);
        void TopMullionThickness(float);
        void BottomMullionThickness(float);
        void LowerLeftX(float);
        void LowerLeftY(float);
        void ID(int);
        void Next(Physical_Tile*);
        void Source(Display_Node*);
        void VirtualDesktopTile(Virtual_Desktop_Tile*);
};

class Virtual_Desktop_Tile
{
private:
        float   lowerLeftX;     //the ratio of the lower left x position to the entire virtual desktop width
        float   lowerLeftY;     //the ratio of the lower left y position to the entire virtual desktop height

        float   widthRatio;   //the ratio of the width of the virtual desktop tile
                                //to the entire virtual desktop width

        float   heightRatio;    //the ratio of the height of the virtual desktop tile
                                //to the entire virtual desktop height

        int     id;             //the id of the virtual desktop tile


        int             lowerLeftPixelX;
        int             lowerLeftPixelY;
        int             widthInPixels;
        int             heightInPixels;

        int     nonMullionLLX;  //lower left X on a zero mullion display
        int             nonMullionLLY;  //lower left Y on a zero mullion display

        Display_Node* dispNode; //the node that will display the virtual desktop tile to the associated physical tile
        Virtual_Desktop_Tile *next;


public:
        Virtual_Desktop_Tile();
        ~Virtual_Desktop_Tile();
        float LowerLeftX();
        float LowerLeftY();
        int     LowerLeftPixelX();
        int LowerLeftPixelY();
        int WidthInPixels();
        int HeightInPixels();
        int NonMullionLLX();
        int NonMullionLLY();

        float WidthRatio();     //The ratio of the width of the tile to that of the whole virtual desktop
        float HeightRatio();    //The ratio of the height of the tile to that of the whole virtual desktop
        int ID();               //The unique ID of the tile
        Display_Node* DisplayNode();    //The physical tile that this virtual desktop tile resides
        Virtual_Desktop_Tile* Next();

        void LowerLeftX(float);
        void LowerLeftY(float);
        void NonMullionLLX(int);
        void NonMullionLLY(int);
        void LowerLeftPixelX(int);
        void LowerLeftPixelY(int);
        void WidthInPixels(int);
        void HeightInPixels(int);
        void WidthRatio(float);
        void HeightRatio(float);
        void ID(int);
        void DisplayNode(Display_Node*);
        void Next(Virtual_Desktop_Tile*);

};

class VDTtoPTmapper
{
        Physical_Tile* pt;
        Virtual_Desktop_Tile *vdt;

public:
        VDTtoPTmapper(Physical_Tile*, Virtual_Desktop_Tile*);
        ~VDTtoPTmapper();
        Physical_Tile* PhysicalTile();
        Virtual_Desktop_Tile* VirtualDesktopTile();

};

class Display_Node
{
private:
        char* nodeName;         //the name of the computer that holds pixels to display
        char* ip;               //ip address of the computer the holds pixels to display
        VDTtoPTmapper** maps;   //pointer to the array of VDTtoPTmapper objects
        Display_Node* next;     //next display node in list
        int numberOfMaps;       //The number of mappings from virtual desktop tile to physical tile
                                //that this display node can make (i.e. how many outputs the display node has)
public:
        Display_Node();
        ~Display_Node();
        void Name(char* );
        void IP(char* );
        char* Name(void);
        char* IP(void);
        int  NumberOfMaps();
        void NumberOfMaps(int);
        VDTtoPTmapper** Maps();
        bool AddMap(VDTtoPTmapper*);
        Display_Node* Next();
        void Next(Display_Node*);
        void RemoveMap(VDTtoPTmapper*);
        void RemoveMap(int);            //delete a specific mapping given an index
};


//__________________________________________

class DisplayCluster
{
protected:
        Display_Node*           displayNodeListHead;    //pointer to the display node linked list
        VirtualDesktop*         vd;
        PhysicalDisplay*        pd;

public:
        DisplayCluster();
        ~DisplayCluster();
        void AddDisplayNode(Display_Node* );
        void RemoveDisplayNode(char*);          //remove a display node given the display node name
        void RemoveDisplayNodeByName(char*);
        void RemoveDisplayNodeByIP(char*);      //remove a display node given the display node ip
        Display_Node*   getFirstNode();         //return the first node in the display node list

        VirtualDesktop* VirtualDesktopAssoc();
        void VirtualDesktopAssoc(VirtualDesktop* );
        PhysicalDisplay* PhysicalDisplayAssoc();
        void PhysicalDisplayAssoc(PhysicalDisplay*);

        bool GenerateMapping(Virtual_Desktop_Tile*, Physical_Tile*);
        bool GenerateMapping(Virtual_Desktop_Tile*, Physical_Tile*, Display_Node*);
        void RemoveMapping(Virtual_Desktop_Tile*, Physical_Tile*, Display_Node*);
        void RemoveMapsWith(Virtual_Desktop_Tile*);     //Removes any mappings made witht the given virtual tile
        void RemoveMapsWith(Physical_Tile*);            //Removes any mappings made with the given physical tile
        bool NodeOnCluster(Display_Node*);

};


class PhysicalDisplay
{
protected:
        Physical_Tile*  physicalTileListHead;   //pointer to the physical tile linked list

        VirtualDesktop*         vd;
        DisplayCluster*         dc;
        float                           pixelsPerInch;          //the pixels per inch ratio

public:
        PhysicalDisplay();
        ~PhysicalDisplay();
        VirtualDesktop* VirtualDesktopAssoc();
        void VirtualDesktopAssoc(VirtualDesktop* );
        DisplayCluster* DisplayClusterAssoc();
        void DisplayClusterAssoc(DisplayCluster* );
        int AddPhysicalTile(Physical_Tile*);                            //adds a tile to the display and returns its unique id

        Physical_Tile* RemovePhysicalTileByID(int, bool);               //remove a physical tile from this physical display
                                                                        //the second parameter is used to have the tile deleted
                                                                        //or just removed.  If "true" the tile will be deleted
                                                                        //from memory, otherwise the address of the tile will
                                                                        //be returned

        Physical_Tile* getFirstNode();          //returns the first node in the physical tile list
        bool TileOnPhysicalDisplay(Physical_Tile*);
        float PixelsPerInch();                          //get the pixels per inch that ALL the physical tiles on this display conform to
        void PixelsPerInch(float);                      //set the pixels per inch that ALL the physical tiles on this display conform to
};

class VirtualDesktop
{
protected:
        int horizRes;           //horizontal resolution of virtual desktop
        int vertRes;            //vertical resolution of virtual desktop

        //pointer to Virtual_Desktop_Tile linked list
        Virtual_Desktop_Tile* tileListHead;

        PhysicalDisplay*        pd;
        DisplayCluster*         dc;


public:
        VirtualDesktop();
        ~VirtualDesktop();

        PhysicalDisplay* PhysicalDisplayAssoc();
        void PhysicalDisplayAssoc(PhysicalDisplay*);
        DisplayCluster* DisplayClusterAssoc();
        void DisplayClusterAssoc(DisplayCluster*);

        int HorizRes(void){ return horizRes; }
        int VertRes(void){ return vertRes; }

        void AddTile(Virtual_Desktop_Tile*);
        void RemoveTile(Virtual_Desktop_Tile*);

        Virtual_Desktop_Tile* getFirstNode(void);

        bool Update(void);              //update the virtual desktop with newly added/removed tile mappings

};

#endif