dotdefs.cc

Go to the documentation of this file.

/*--------------------------------------------------------------------
 *
 * (C) Copyright Koninklijke Philips Electronics NV 2006. 
 * All rights reserved. This software is licensed under the terms of
 * version 2.1 of the GNU Lesser General Public License as published 
 * by the Free Software Foundation. For licensing and warranty
 * information, see the file COPYING in the main directory.
 *
 *------------------------------------------------------------------*/

#include <sys/types.h>
#include "dotdefs.h"

using std::endl;
using std::string;

static std::ostream* g_errorStream = &std::cerr;

inline void dotDefsSetErrorStream(std::ostream&e = std::cerr) {
  g_errorStream = &e;
}

//****************************************************************************
// Default Settings YAPI_DOTTY:
//****************************************************************************


// Level of Hierarchy:
int DotDefs::levelInit(10);

// Colors:
string DotDefs::nodeColorProcessNetwork("white");
string DotDefs::nodeColorProcess("white");
string DotDefs::nodeColorPort("white");
string DotDefs::nodeColorFifo("white");
string DotDefs::fontColorClusterTitle("black");
string DotDefs::fontColorProcessNetwork("black");
string DotDefs::fontColorProcess("black");
string DotDefs::fontColorPort("black");
string DotDefs::fontColorFifo("black");

// Nodes:
string DotDefs::nodeFifo("false");
string DotDefs::nodeStyle("filled");
string DotDefs::nodeShapeProcessNetwork("record");
string DotDefs::nodeShapeProcess("ellipse");
string DotDefs::nodeShapePort("box");
string DotDefs::nodeShapeFifo("diamond");
string DotDefs::nodeWidthProcessNetwork("0.05");
string DotDefs::nodeHeightProcessNetwork("0.05");
string DotDefs::nodeWidthProcess("0.05");
string DotDefs::nodeHeightProcess("0.05");
string DotDefs::nodeWidthPort("0.05");
string DotDefs::nodeHeightPort("0.05");
string DotDefs::nodeWidthFifo("0.05");
string DotDefs::nodeHeightFifo("0.05");

// Edges:
string DotDefs::edgeDecorate("false");
int DotDefs::edgeMinLen(2);
int DotDefs::edgeWeight(4);

// Fonts:
string DotDefs::fontNameClusterTitle("Helvetica");
string DotDefs::fontNameProcessNetwork("Helvetica");
string DotDefs::fontNameProcess("Helvetica");
string DotDefs::fontNamePort("Helvetica");
string DotDefs::fontNameFifo("Helvetica");

int DotDefs::fontSizeClusterTitle(20);
int DotDefs::fontSizeProcessNetwork(16);
int DotDefs::fontSizeProcess(16);
int DotDefs::fontSizePort(16);
int DotDefs::fontSizeFifo(16);

// Attributes:
string DotDefs::nodeSep("0.5");
string DotDefs::ratio("fill");
string DotDefs::center("true");

// PageSetup:
string DotDefs::rankDir("TB");
string DotDefs::size("\"7.5,11\"");
string DotDefs::orientation("portrait");
string DotDefs::margin("\"0.5,0.5\"");

// Dummy:
string DotDefs::dummy("");


//****************************************************************************
// Settings that can be changed by configuration-file dotty.cfg:
//****************************************************************************


//****************************************************************************
// Struct:

struct OptionString
{
  const char* s;
  void(*f)(string, string*);
  string* r;
};

struct OptionInteger
{
  const char* s;
  void(*f)(int, int*);
  int* r;
};


//****************************************************************************
// String:


// Colors:

const int nrColors = 18;
static const char* colors[nrColors] =
{
  "white",
  "gray",
  "black",
  "red",
  "brown",
  "orange",
  "yellow",
  "green",
  "cyan",
  "blue",
  "magenta",
  "pink",
  "beige",
  "gold",
  "violet",
  "lavender",
  "purple",
  "navy"
};

void setColor(string s, string* c)
{
  int i;
  for (i=0; i<nrColors; i++) {
    if (s == colors[i]) {
      *c = s;
      return;
    }
  }
  *g_errorStream << "dotty.cfg:  invalid color [" << s 
       << "], default used [" << *c << "]" << endl;
}                 


// FontNames:

const int nrFonts = 3;
static const char* fontNames[nrFonts] =
{
  "Times-Roman",
  "Helvetica",
  "Courier"
};

void setFontName(string s, string* c)
{
  int i;
  for (i=0; i<nrFonts; i++) {
    if (s == fontNames[i]) {
      if (s == "Times-Roman") {
        *c = "\"Times-Roman\"";
        return;
      } else {
              *c = s;
              return;
      }
    }
  }
  *g_errorStream << "dotty.cfg:  invalid font name [" << s 
       << "], default used [" << *c << "]" << endl;
}     


// Ratio:

const int nrRatios = 3;
static const char* ratios[nrRatios] =
{
  "fill",
  "compress",
  "auto"
};

void setRatio(string s, string* c)
{
  int i;
  for (i=0; i<nrRatios; i++) {
    if (s == ratios[i]) {
      *c = s;
      return;
    }
  }
  *g_errorStream << "dotty.cfg:  invalid ratio [" << s 
       << "], default used [" << *c << "]" << endl;
}


void setPageSize(string s, string* c)
{
  if (s == "A4p") {
    DotDefs::rankDir = "TB";
    DotDefs::size = "\"7.5,11\"";
    DotDefs::orientation = "portrait";
    DotDefs::margin = "\"0.5,0.5\"";
  } else
  if (s == "A4l") {
    DotDefs::rankDir = "LR";
    DotDefs::size = "\"11,7.5\"";
    DotDefs::orientation = "landscape";
    DotDefs::margin = "\"0.5,0.5\"";
      } else
  if (s == "A3p") {
    DotDefs::rankDir = "TB";
    DotDefs::size = "\"9,13\"";
    DotDefs::orientation = "portrait";
    DotDefs::margin = "\"2.0,2.0\"";
      } else
  if (s == "A3l") {
    DotDefs::rankDir = "LR";
    DotDefs::size = "\"14,8.5\"";
    DotDefs::orientation = "landscape";
    DotDefs::margin = "\"2.0,2.0\"";
      } else
  if (s == "A2p") {
    DotDefs::rankDir = "TB";
    DotDefs::size = "\"13,20\"";
    DotDefs::orientation = "portrait";
    DotDefs::margin = "\"2.0,2.0\"";
      } else
  if (s == "A2l") {
    DotDefs::rankDir = "LR";
    DotDefs::size = "\"21,13\"";
    DotDefs::orientation = "landscape";
    DotDefs::margin = "\"2.0,2.0\"";
    } else
  if (s == "A1p") {
    DotDefs::rankDir = "TB";
    DotDefs::size = "\"20,30\"";
    DotDefs::orientation = "portrait";
    DotDefs::margin = "\"2.0,2.0\"";
      } else
  if (s == "A1l") {
    DotDefs::rankDir = "LR";
    DotDefs::size = "\"30,20\"";
    DotDefs::orientation = "landscape";
    DotDefs::margin = "\"2.0,2.0\"";
  } else
  if (s == "A0p") {
    DotDefs::rankDir = "TB";
    DotDefs::size = "\"30,42\"";
    DotDefs::orientation = "portrait";
    DotDefs::margin = "\"2.0,2.0\"";
  } else
  if (s == "A0l") {
    DotDefs::rankDir = "LR";
    DotDefs::size = "\"42,30\"";
    DotDefs::orientation = "landscape";
    DotDefs::margin = "\"2.0,2.0\"";
  } else {
    *g_errorStream << "dotty.cfg:  invalid page size [" << s 
        << "], default used" << endl;
  }
}     


// Decorate:

void setBool(string s, string* c)
{
  if (s == "true") {
    *c = "true";
  } else
  if (s == "false") {
    *c = "false";
  } else {
    *g_errorStream << "dotty.cfg:  invalid boolean [" << s 
         << "], default used [" << *c << "]" << endl;
  }
}     


// NodeFifo:

void setNodeFifo(string s, string* c)
{
  if (s == "true") {
    *c = "true";
    return;
  }
  if (s == "false") {
    *c = "false";
    return;
  }
  *g_errorStream << "Dotty.cfg:  no valid boolean Fifo [" << s 
       << "], default used [" << *c << "]" << endl;
} 


// OptionString:

const int nrOptionStrings = 18;

OptionString optionStrings[nrOptionStrings] = 
{
  {"ProcessNetworkColor", setColor, &DotDefs::nodeColorProcessNetwork},
  {"ProcessColor", setColor, &DotDefs::nodeColorProcess},
  {"PortColor", setColor, &DotDefs::nodeColorPort},
  {"FifoColor", setColor, &DotDefs::nodeColorFifo},
  {"ProcessNetworkClusterFontColor", setColor, &DotDefs::fontColorClusterTitle},
  {"ProcessNetworkFontColor", setColor, &DotDefs::fontColorProcessNetwork},
  {"ProcessFontColor", setColor, &DotDefs::fontColorProcess},
  {"PortFontColor", setColor, &DotDefs::fontColorPort},
  {"FifoFontColor", setColor, &DotDefs::fontColorFifo},
  {"ProcessNetworkClusterFontName", setFontName, &DotDefs::fontNameClusterTitle},
  {"ProcessNetworkFontName", setFontName, &DotDefs::fontNameProcessNetwork},
  {"ProcessFontName", setFontName, &DotDefs::fontNameProcess},
  {"PortFontName", setFontName, &DotDefs::fontNamePort},
  {"FifoFontName", setFontName, &DotDefs::fontNameFifo},
  {"Ratio", setRatio, &DotDefs::ratio},
  {"PageSize", setPageSize, &DotDefs::dummy},
  {"Decorate", setBool, &DotDefs::edgeDecorate},
  {"Fifo", setNodeFifo, &DotDefs::nodeFifo}
};    

void addOptionString(string p, string q)
{
  int i;
  for (i=0; i<nrOptionStrings; i++) {
    if (p == optionStrings[i].s) {
      optionStrings[i].f(q, optionStrings[i].r);
      return;
    }
  }
  *g_errorStream << "dotty.cfg:  unknown option: " << p << endl;
}


//****************************************************************************
// Integer:


// LevelInit:

void setInt(int n, int* c)
{
  *c = n;
}    

// OptionInteger:

const int nrIntegers = 6;
OptionInteger optionIntegers[nrIntegers] =
{
  {"InitLevel", setInt, &DotDefs::levelInit},
  {"ProcessNetworkClusterFontSize", setInt, &DotDefs::fontSizeClusterTitle},
  {"ProcessNetworkFontSize", setInt, &DotDefs::fontSizeProcessNetwork},
  {"ProcessFontSize", setInt, &DotDefs::fontSizeProcess},
  {"PortFontSize", setInt, &DotDefs::fontSizePort},
  {"FifoFontSize", setInt, &DotDefs::fontSizeFifo}
};

void addOptionInteger(string p, int n)
{
  int i;
  for (i=0; i<nrIntegers; i++) {
    if (optionIntegers[i].s == p) {
      optionIntegers[i].f(n, optionIntegers[i].r);
      return;
    }
  }
  *g_errorStream << "Dotty.cfg:  unknown option: " << p << endl;
}

---