place and connect two diagrams in split composition More...

#include <splitSchema.h>

Inheritance diagram for splitSchema:

Collaboration diagram for splitSchema:

Public Member Functions
virtual void	place (double ox, double oy, int orientation)
	Places the two subschema horizontaly, centered, with enough gap for the connections. More...

virtual void	draw (device &dev)
	Draw the two sub schema and the connections between them. More...

virtual point	inputPoint (unsigned int i) const
	The inputs of s1 <: s2 are the inputs of s1. More...

virtual point	outputPoint (unsigned int i) const
	The outputs of s1 <: s2 are the outputs of s2. More...

virtual void	collectTraits (collector &c)
	Draw the two sub schema and the connections between them. More...

Public Member Functions inherited from schema
	schema (unsigned int inputs, unsigned int outputs, double width, double height)

virtual	~schema ()

double	width () const

double	height () const

unsigned int	inputs () const

unsigned int	outputs () const

void	beginPlace (double x, double y, int orientation)

void	endPlace ()

bool	placed () const

double	x () const

double	y () const

int	orientation () const

Private Member Functions
	splitSchema (schema s1, schema s2, double hgap)
	Constructor for a split schema s1 <: s2 where the outputs of s1 are distributed to the inputs of s2. More...

Private Attributes
schema *	fSchema1

schema *	fSchema2

double	fHorzGap

Friends
schema *	makeSplitSchema (schema s1, schema s2)
	Creates a new split schema. More...

Detailed Description

place and connect two diagrams in split composition

Definition at line 33 of file splitSchema.h.

Constructor & Destructor Documentation

splitSchema::splitSchema	(	schema *	s1,
		schema *	s2,
		double	hgap
	)

private

Constructor for a split schema s1 <: s2 where the outputs of s1 are distributed to the inputs of s2.

The constructor is private in order to enforce the usage of makeSplitSchema

Definition at line 52 of file splitSchema.cpp.

     :   schema( s1->inputs(),
                 s2->outputs(),
                 s1->width() + s2->width() + hgap,
                 max(s1->height(), s2->height()) ),
         fSchema1(s1),
         fSchema2(s2),
         fHorzGap(hgap)
 {
 }

Member Function Documentation

void splitSchema::collectTraits ( collector & c )

virtual

Draw the two sub schema and the connections between them.

Implements schema.

Definition at line 133 of file splitSchema.cpp.

References collector::addTrait(), schema::collectTraits(), fSchema1, fSchema2, schema::inputPoint(), schema::inputs(), schema::outputPoint(), schema::outputs(), schema::placed(), point::x, and point::y.

 {
     assert(placed());
 
     // draw the two subdiagrams
     fSchema1->collectTraits(c);
     fSchema2->collectTraits(c);
 
     unsigned int r = fSchema1->outputs();
     assert(r>0);
 
     // draw the connections between them
     for (unsigned int i=0; i<fSchema2->inputs(); i++) {
         point p = fSchema1->outputPoint(i%r);
         point q = fSchema2->inputPoint(i);
         c.addTrait(trait(point(p.x, p.y), point(q.x, q.y)));
     }
 }

Here is the call graph for this function:

void splitSchema::draw ( device & dev )

virtual

Draw the two sub schema and the connections between them.

Implements schema.

Definition at line 107 of file splitSchema.cpp.

References schema::draw(), fSchema1, fSchema2, schema::inputPoint(), schema::inputs(), schema::outputPoint(), schema::outputs(), schema::placed(), device::trait(), point::x, and point::y.

 {
     assert(placed());
 
     // draw the two subdiagrams
     fSchema1->draw(dev);
     fSchema2->draw(dev);
 
     unsigned int r = fSchema1->outputs();
     assert(r>0);
 #if 0
     // draw the connections between them
     for (unsigned int i=0; i<fSchema2->inputs(); i++) {
         point p = fSchema1->outputPoint(i%r);
         point q = fSchema2->inputPoint(i);
         if(p.z>0) {
             dev.trait(p.x, p.y, q.x, q.y);
         }
     }
 #endif
 }

Here is the call graph for this function:

point splitSchema::inputPoint ( unsigned int i ) const

virtual

The inputs of s1 <: s2 are the inputs of s1.

Implements schema.

Definition at line 89 of file splitSchema.cpp.

References fSchema1, and schema::inputPoint().

 {
     return fSchema1->inputPoint(i);
 }

Here is the call graph for this function:

point splitSchema::outputPoint ( unsigned int i ) const

virtual

The outputs of s1 <: s2 are the outputs of s2.

Implements schema.

Definition at line 98 of file splitSchema.cpp.

References fSchema2, and schema::outputPoint().

 {
     return fSchema2->outputPoint(i);
 }

Here is the call graph for this function:

void splitSchema::place	(	double	ox,
		double	oy,
		int	orientation
	)

virtual

Places the two subschema horizontaly, centered, with enough gap for the connections.

Implements schema.

Definition at line 68 of file splitSchema.cpp.

References schema::beginPlace(), schema::endPlace(), fHorzGap, fSchema1, fSchema2, schema::height(), kLeftRight, max(), schema::orientation(), schema::place(), and schema::width().

 {
     beginPlace(ox, oy, orientation);
 
     double dy1 = max(0.0, fSchema2->height()-fSchema1->height()) / 2.0;
     double dy2 = max(0.0, fSchema1->height()-fSchema2->height()) / 2.0;
 
     if (orientation == kLeftRight) {
         fSchema1->place(ox, oy+dy1, orientation);
         fSchema2->place(ox+fSchema1->width()+fHorzGap, oy+dy2, orientation);
     } else {
         fSchema2->place(ox, oy+dy2, orientation);
         fSchema1->place(ox+fSchema2->width()+fHorzGap, oy+dy1, orientation);
     }
     endPlace();
 }

Here is the call graph for this function:

Friends And Related Function Documentation

schema* makeSplitSchema	(	schema *	s1,
		schema *	s2
	)

friend

Creates a new split schema.

Cables are enlarged to dWire. The horizontal gap between the two subschema is such that the connections are not too slopy.

Definition at line 34 of file splitSchema.cpp.

 {
     // make sure a and b are at least dWire large
     schema * a = makeEnlargedSchema(s1, dWire);
     schema * b = makeEnlargedSchema(s2, dWire);
 
     // horizontal gap to avaoid too slopy connections
     double  hgap = (a->height()+b->height())/4;
 
     return new splitSchema(a,b,hgap);
 }

Member Data Documentation

double splitSchema::fHorzGap

private

Definition at line 37 of file splitSchema.h.

Referenced by place().

schema* splitSchema::fSchema1

private

Definition at line 35 of file splitSchema.h.

Referenced by collectTraits(), draw(), inputPoint(), and place().

schema* splitSchema::fSchema2

private

Definition at line 36 of file splitSchema.h.

Referenced by collectTraits(), draw(), outputPoint(), and place().

The documentation for this class was generated from the following files:

Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation