riscv
/
coriolis
mirror of https://gitlab.lip6.fr/vlsi-eda/coriolis.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

* ./hurricane : 

- Bug : In Timer.h, forgot to declare the specialized getString()
        template, thus preventing the timer to be correctly display in
        output streams.
    - Bug : In CellWidget::_redraw(), uses "paintersBegin()" instead of
        "painterBegin()" (whithout the "s"). The former open painters for
        both normal & selection planes which are subsequently accessed by
        "setPen()". The laters opens only the normal plane painter resulting
        in warnings for the selection plane painter (shows only from Qt 4.5).
    - New : In CellWidget, ability to support the physical grid (not only the
        symbolic grid). Added selection symbolic/real in the DisplayFilter.
    - Change : add to Technology and all the Layers sub-classes a
        "_onDbuChange(float)" method.
          This is due to the fact that the symbolic technology is loaded first
        into the DataBase (needed for defining the BasicLayer ordering) along with
        all the symbolic dimensions for the symbolic Layers. Only afterward, we
        load the real technology (hcmos9 for instance) which will sets the
        "grids per lambda" factor to it's true value, changing the meaning of
        the already loaded symbolic values. Then, it is necessary to scale those
        values so they are coherent with the new "GPL" factor, hence the
        "_onDbuChange()" function.
          NEVER USE THIS FUNCTION AFTER THE TECHNOLOGY HAS BEEN LOADED, it would
        render all symbolic coordinates false...
This commit is contained in:
Jean-Paul Chaput 2009-04-12 21:05:51 +00:00
parent 617e5db177
commit a404498be5
31 changed files with 621 additions and 1088 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
hurricane/src/hurricane/BasicLayer.cpp
View File

@ -1,5 +1,4 @@
// -*- C++ -*- // -*- C++ -*-
// //
// This file is part of the Hurricane Software. // This file is part of the Hurricane Software.

312
hurricane/src/hurricane/CompositeLayer.cpp
View File

@ -1,312 +0,0 @@
// ****************************************************************************************************
// File: CompositeLayer.cpp
// Authors: R. Escassut
// Copyright (c) BULL S.A. 2000-2004, All Rights Reserved
// ****************************************************************************************************
#include "hurricane/CompositeLayer.h"
#include "hurricane/Technology.h"
#include "hurricane/BasicLayer.h"
#include "hurricane/Error.h"
namespace Hurricane {
// ****************************************************************************************************
// CompositeLayer implementation
// ****************************************************************************************************
CompositeLayer::CompositeLayer(Technology* technology, const Name& name, const Type& type, const Unit& minimalSize, const Unit& minimalSpacing)
// ****************************************************************************************************
: Inherit(technology, name, minimalSize, minimalSpacing),
_type(type),
_basicLayerList(),
_contactSizeMap(),
_segmentSizeMap(),
_segmentExtentionMap(),
_padSizeMap(),
_maximalContactSize(0),
_maximalSegmentSize(0),
_maximalSegmentExtention(0),
_maximalPadSize(0),
_symbolicBasicLayer(NULL)
{
}
CompositeLayer* CompositeLayer::create(Technology* technology, const Name& name, const Type& type, const Unit& minimalSize, const Unit& minimalSpacing)
// ****************************************************************************************************
{
CompositeLayer* compositeLayer =
new CompositeLayer(technology, name, type, minimalSize, minimalSpacing);
compositeLayer->_postCreate();
return compositeLayer;
}
BasicLayers CompositeLayer::getBasicLayers() const
// ***********************************************
{
return getCollection(_basicLayerList);
}
Unit CompositeLayer::getContactSize(const BasicLayer* basicLayer) const
// **************************************************************
{
SizeMap::const_iterator it = _contactSizeMap.find(basicLayer);
return ((it == _contactSizeMap.end()) ? 0 : (*it).second);
}
Unit CompositeLayer::getSegmentSize(const BasicLayer* basicLayer) const
// **************************************************************
{
SizeMap::const_iterator it = _segmentSizeMap.find(basicLayer);
return ((it == _segmentSizeMap.end()) ? 0 : (*it).second);
}
Unit CompositeLayer::getSegmentExtention(const BasicLayer* basicLayer) const
// *******************************************************************
{
SizeMap::const_iterator it = _segmentExtentionMap.find(basicLayer);
return ((it == _segmentExtentionMap.end()) ? 0 : (*it).second);
}
Unit CompositeLayer::getPadSize(const BasicLayer* basicLayer) const
// **********************************************************
{
SizeMap::const_iterator it = _padSizeMap.find(basicLayer);
return ((it == _padSizeMap.end()) ? 0 : (*it).second);
}
void CompositeLayer::add(BasicLayer* basicLayer, const Unit& contactSize, const Unit& segmentSize, const Unit& segmentExtention, const Unit& padSize)
// ****************************************************************************************************
{
if (!basicLayer)
throw Error("Can't add basic layer : null basic layer");
if (contains(basicLayer))
throw Error("Can't add basic layer : already done");
_basicLayerList.push_back(basicLayer);
_setMask(getMask() | basicLayer->getMask());
_setExtractMask(getExtractMask() | basicLayer->getExtractMask());
if (contactSize != 0) _contactSizeMap[basicLayer] = contactSize;
if (segmentSize != 0) _segmentSizeMap[basicLayer] = segmentSize;
if (segmentExtention != 0) _segmentExtentionMap[basicLayer] = segmentExtention;
if (padSize != 0) _padSizeMap[basicLayer] = padSize;
_maximalContactSize = max(contactSize, _maximalContactSize);
_maximalSegmentSize = max(segmentSize, _maximalSegmentSize);
_maximalSegmentExtention = max(segmentExtention, _maximalSegmentExtention);
_maximalPadSize = max(padSize, _maximalPadSize);
}
void CompositeLayer::setContactSize(BasicLayer* basicLayer, const Unit& contactSize)
// *********************************************************************************
{
if (!basicLayer)
throw Error("Can't add basic layer : null basic layer");
if (!contains(basicLayer))
throw Error("Basic layer not part of composite layer");
if (contactSize != 0) _contactSizeMap[basicLayer] = contactSize;
_maximalContactSize = max(contactSize, _maximalContactSize);
}
void CompositeLayer::setSegmentSize(BasicLayer* basicLayer, const Unit& segmentSize)
// *********************************************************************************
{
if (!basicLayer)
throw Error("Can't add basic layer : null basic layer");
if (!contains(basicLayer))
throw Error("Basic layer not part of composite layer");
if (segmentSize != 0) _segmentSizeMap[basicLayer] = segmentSize;
_maximalSegmentSize = max(segmentSize, _maximalSegmentSize);
}
void CompositeLayer::setSegmentExtention(BasicLayer* basicLayer, const Unit& segmentExtention)
// *********************************************************************************
{
if (!basicLayer)
throw Error("Can't add basic layer : null basic layer");
if (!contains(basicLayer))
throw Error("Basic layer not part of composite layer");
if (segmentExtention != 0) _segmentExtentionMap[basicLayer] = segmentExtention;
_maximalSegmentExtention = max(segmentExtention, _maximalSegmentExtention);
}
void CompositeLayer::remove(BasicLayer* basicLayer)
// ************************************************
{
if (!basicLayer)
throw Error("Can't remove basic layer : null basic layer");
if (!contains(basicLayer))
throw Error("Can't remove basic layer : not contained");
_basicLayerList.remove(basicLayer);
_contactSizeMap.erase(basicLayer);
_segmentSizeMap.erase(basicLayer);
_segmentExtentionMap.erase(basicLayer);
_padSizeMap.erase(basicLayer);
_maximalContactSize = 0;
_maximalSegmentSize = 0;
_maximalSegmentExtention = 0;
_maximalPadSize = 0;
Mask mask = 0;
Mask extractMask = 0;
for_each_basic_layer(basicLayer, getBasicLayers()) {
mask |= basicLayer->getMask();
extractMask |= basicLayer->getExtractMask();
_maximalContactSize = max(getContactSize(basicLayer), _maximalContactSize);
_maximalSegmentSize = max(getSegmentSize(basicLayer), _maximalSegmentSize);
_maximalSegmentExtention = max(getSegmentExtention(basicLayer), _maximalSegmentExtention);
_maximalPadSize = max(getPadSize(basicLayer), _maximalPadSize);
end_for;
}
_setMask(mask);
_setExtractMask(extractMask);
}
string CompositeLayer::_getString() const
// **************************************
{
string s = Inherit::_getString();
/*
s.insert(s.length() - 1, " " + getString(_type));
s.insert(s.length() - 1, " {");
string separator = "";
for_each_basic_layer(basicLayer, getBasicLayers()) {
s.insert(s.length() - 1, separator + getString(basicLayer->getName()));
separator = "|";
end_for;
}
s.insert(s.length() - 1, "}");
*/
return s;
}
Record* CompositeLayer::_getRecord() const
// ***************************************
{
Record* record = Inherit::_getRecord();
if (record) {
record->add(getSlot("Type", &_type));
record->add(getSlot("BasicLayers", &_basicLayerList));
record->add(getSlot("ContactSizes", &_contactSizeMap));
record->add(getSlot("SegmentSizes", &_segmentSizeMap));
record->add(getSlot("SegmentExtentions", &_segmentExtentionMap));
record->add(getSlot("PadSizes", &_padSizeMap));
record->add(getSlot("MaximalContactSize", &_maximalContactSize));
record->add(getSlot("MaximalSegmentSize", &_maximalSegmentSize));
record->add(getSlot("MaximalSegmentExtention", &_maximalSegmentExtention));
record->add(getSlot("MaximalPadSize", &_maximalPadSize));
}
return record;
}
void CompositeLayer::_updateSymbolicBasicLayer(const Layer::Mask& visibleBasicLayersMask)
// **************************************************************************************
{
_symbolicBasicLayer = NULL;
BasicLayer* symbolicBasicLayer = NULL;
for_each_basic_layer(basicLayer, getBasicLayers()) {
if (basicLayer->getMask() & visibleBasicLayersMask) {
symbolicBasicLayer = basicLayer;
if (basicLayer->getMaterial() == BasicLayer::Material::cut)
_symbolicBasicLayer = basicLayer;
}
end_for;
}
if (!_symbolicBasicLayer) _symbolicBasicLayer = symbolicBasicLayer;
}
// ****************************************************************************************************
// CompositeLayer::Type implementation
// ****************************************************************************************************
CompositeLayer::Type::Type(const Code& code)
// *****************************************
: _code(code)
{
}
CompositeLayer::Type::Type(const Type& type)
// *****************************************
: _code(type._code)
{
}
CompositeLayer::Type& CompositeLayer::Type::operator=(const Type& type)
// ********************************************************************
{
_code = type._code;
return *this;
}
string CompositeLayer::Type::_getString() const
// ********************************************
{
switch (_code) {
case UNDEFINED : return "UNDEFINED";
case METAL : return "METAL";
case VIA : return "VIA";
}
return "ABNORMAL";
}
Record* CompositeLayer::Type::_getRecord() const
// *********************************************
{
Record* record = new Record(getString(this));
record->add(getSlot("Code", (int)_code));
return record;
}
} // End of Hurricane namespace.
// ****************************************************************************************************
// Generic functions
// ****************************************************************************************************
bool Scan(const string& s, Hurricane::CompositeLayer::Type& type)
// ***************************************************
{
if (s == "UNDEFINED") {
type = Hurricane::CompositeLayer::Type::UNDEFINED;
return true;
}
if (s == "METAL") {
type = Hurricane::CompositeLayer::Type::METAL;
return true;
}
if (s == "VIA") {
type = Hurricane::CompositeLayer::Type::VIA;
return true;
}
return false;
}
// ****************************************************************************************************
// Copyright (c) BULL S.A. 2000-2004, All Rights Reserved
// ****************************************************************************************************

43
hurricane/src/hurricane/ContactLayer.cpp
View File

@ -1,42 +1,14 @@
// -*- C++ -*- // -*- C++ -*-
// //
// This file is part of the Coriolis Project. // This file is part of the Coriolis Software.
// Copyright (C) Laboratoire LIP6 - Departement ASIM // Copyright (c) UPMC/LIP6 2008-2008, All Rights Reserved
// Universite Pierre et Marie Curie
//
// Main contributors :
// Christophe Alexandre <Christophe.Alexandre@lip6.fr>
// Sophie Belloeil <Sophie.Belloeil@lip6.fr>
// Hugo Clément <Hugo.Clement@lip6.fr>
// Jean-Paul Chaput <Jean-Paul.Chaput@lip6.fr>
// Damien Dupuis <Damien.Dupuis@lip6.fr>
// Christian Masson <Christian.Masson@lip6.fr>
// Marek Sroka <Marek.Sroka@lip6.fr>
//
// The Coriolis Project is free software; you can redistribute it
// and/or modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// The Coriolis Project is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with the Coriolis Project; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
//
// License-Tag
// Authors-Tag
// //
// =================================================================== // ===================================================================
// //
// $Id$ // $Id$
// //
//
// x-----------------------------------------------------------------x // x-----------------------------------------------------------------x
// | | // | |
// | H U R R I C A N E | // | H U R R I C A N E |
@ -182,6 +154,15 @@ namespace Hurricane {
} }
void ContactLayer::_onDbuChange ( float scale )
{
Layer::_onDbuChange ( scale );
for ( size_t i=0 ; i<_enclosures.size() ; i++ )
_enclosures[i] = (DbU::Unit)( (float)_enclosures[i] * scale );
_maximalEnclosure = (DbU::Unit)( (float)_maximalEnclosure * scale );
}
string ContactLayer::_getTypeName () const string ContactLayer::_getTypeName () const
{ return _TName("ContactLayer"); } { return _TName("ContactLayer"); }

106
hurricane/src/hurricane/DbU.cpp
View File

@ -1,9 +1,8 @@
// -*- C++ -*- // -*- C++ -*-
// //
// This file is part of the Hurricane Software. // This file is part of the Coriolis Software.
// Copyright (c) BULL S.A. 2000-2004, All Rights Reserved // Copyright (c) UPMC/LIP6 2008-2009, All Rights Reserved
// //
// =================================================================== // ===================================================================
// //
@ -29,6 +28,8 @@
#include "hurricane/DbU.h" #include "hurricane/DbU.h"
#include "hurricane/Error.h" #include "hurricane/Error.h"
#include "hurricane/DataBase.h"
#include "hurricane/Technology.h"
namespace Hurricane { namespace Hurricane {
@ -40,7 +41,8 @@ namespace Hurricane {
double DbU::_gridsPerLambda = 10.0; double DbU::_gridsPerLambda = 10.0;
double DbU::_physicalsPerGrid = 1.0; double DbU::_physicalsPerGrid = 1.0;
unsigned int DbU::_stringMode = DbU::Symbolic; unsigned int DbU::_stringMode = DbU::Symbolic;
DbU::Unit DbU::_snapGridStep = DbU::lambda(1.0); DbU::Unit DbU::_symbolicSnapGridStep = DbU::lambda(1.0);
DbU::Unit DbU::_realSnapGridStep = DbU::grid (10.0);
const DbU::Unit DbU::Min = LONG_MIN; const DbU::Unit DbU::Min = LONG_MIN;
const DbU::Unit DbU::Max = LONG_MAX; const DbU::Unit DbU::Max = LONG_MAX;
@ -103,12 +105,17 @@ namespace Hurricane {
, _maximalPrecision , _maximalPrecision
); );
float scale = (float)precision / (float)_precision;
_precision = precision; _precision = precision;
_resolution = 1; _resolution = 1;
while ( precision-- ) _resolution /= 10; while ( precision-- ) _resolution /= 10;
setSnapGridStep ( DbU::lambda(1) ); DataBase::getDB()->getTechnology()->_onDbuChange ( scale );
setSymbolicSnapGridStep ( DbU::lambda( 1.0) );
setRealSnapGridStep ( DbU::grid (10.0) );
} }
@ -127,9 +134,7 @@ namespace Hurricane {
void DbU::setPhysicalsPerGrid ( double physicalsPerGrid, UnitPower p ) void DbU::setPhysicalsPerGrid ( double physicalsPerGrid, UnitPower p )
{ { _physicalsPerGrid = physicalsPerGrid * getUnitPower(p); }
_physicalsPerGrid = physicalsPerGrid * getUnitPower(p);
}
double DbU::getPhysicalsPerGrid () double DbU::getPhysicalsPerGrid ()
@ -137,9 +142,7 @@ namespace Hurricane {
double DbU::physicalToGrid ( double physical, UnitPower p ) double DbU::physicalToGrid ( double physical, UnitPower p )
{ { return ( physical * getUnitPower(p) ) / _physicalsPerGrid; }
return ( physical * getUnitPower(p) ) / _physicalsPerGrid;
}
void DbU::setGridsPerLambda ( double gridsPerLambda ) void DbU::setGridsPerLambda ( double gridsPerLambda )
@ -150,9 +153,13 @@ namespace Hurricane {
, gridsPerLambda , gridsPerLambda
); );
float scale = gridsPerLambda / (float)_gridsPerLambda;
_gridsPerLambda = gridsPerLambda; _gridsPerLambda = gridsPerLambda;
setSnapGridStep ( DbU::lambda(1) ); DataBase::getDB()->getTechnology()->_onDbuChange ( scale );
setSymbolicSnapGridStep ( DbU::lambda(1) );
} }
@ -160,79 +167,40 @@ namespace Hurricane {
{ return _gridsPerLambda; } { return _gridsPerLambda; }
DbU::Unit DbU::getSnapGridStep () DbU::Unit DbU::getSymbolicSnapGridStep ()
{ { return _symbolicSnapGridStep; }
return _snapGridStep;
}
DbU::Unit DbU::getOnSnapGrid ( DbU::Unit u, SnapMode mode ) DbU::Unit DbU::getOnSymbolicSnapGrid ( DbU::Unit u, SnapMode mode )
{ {
DbU::Unit inferior = ( u / _snapGridStep ) * _snapGridStep; DbU::Unit inferior = ( u / _symbolicSnapGridStep ) * _symbolicSnapGridStep;
DbU::Unit modulo = u % _snapGridStep; DbU::Unit modulo = u % _symbolicSnapGridStep;
if ( !modulo ) return u; if ( !modulo ) return u;
if ( mode == Inferior ) { return inferior; } if ( mode == Inferior ) { return inferior; }
else if ( mode == Superior ) { return inferior + _snapGridStep; } else if ( mode == Superior ) { return inferior + _symbolicSnapGridStep; }
return inferior + ( (modulo > (_snapGridStep/2)) ? _snapGridStep : 0 ); return inferior + ( (modulo > (_symbolicSnapGridStep/2)) ? _symbolicSnapGridStep : 0 );
} }
DbU::Unit DbU::getRealSnapGridStep ()
{ return _realSnapGridStep; }
// **************************************************************************************************** DbU::Unit DbU::getOnRealSnapGrid ( DbU::Unit u, SnapMode mode )
// Grid managers {
// **************************************************************************************************** DbU::Unit inferior = ( u / _realSnapGridStep ) * _realSnapGridStep;
DbU::Unit modulo = u % _realSnapGridStep;
// const DbU::Unit& getGridStep() if ( !modulo ) return u;
// // **********************
// {
// return GRID_STEP;
// }
// void setGridStep(const DbU::Unit& gridStep) if ( mode == Inferior ) { return inferior; }
// // *********************************** else if ( mode == Superior ) { return inferior + _realSnapGridStep; }
// {
// if (!gridStep) throw Error("Can't set grid step : invalid value");
// GRID_STEP = gridStep; return inferior + ( (modulo > (_realSnapGridStep/2)) ? _realSnapGridStep : 0 );
// } }
// bool isOnGrid(const DbU::Unit& unit, int n)
// // ***********************************
// {
// if (n <= 0) throw Error("Can't compute : invalid value");
// n *= GRID_STEP;
// return (((abs(unit) / n) * n) == abs(unit));
// }
// DbU::Unit getOnGridUnit(const DbU::Unit& unit, int s)
// // ****************************************
// {
// switch (s) {
// case -1 : {
// if (0 < unit) return (unit / GRID_STEP) * GRID_STEP;
// else if (unit < 0) return ((unit / GRID_STEP) - 1) * GRID_STEP;
// return unit;
// }
// case 0 : {
// int g1 = (unit / GRID_STEP) * GRID_STEP;
// int g2 = ((g1 < unit) ? (g1 + GRID_STEP) : (g1 - GRID_STEP));
// return (abs(g1 - unit) <= abs(g2 - unit)) ? g1 : g2;
// }
// case +1 : {
// if (0 < unit) return ((unit / GRID_STEP) + 1) * GRID_STEP;
// else if (unit < 0) return (unit / GRID_STEP) * GRID_STEP;
// return unit;
// }
// }
// throw Error("Can't get on grid unit : invalid parameter s (should be -1, 0 or +1)");
// return 0;
// }
string DbU::getValueString ( DbU::Unit u, int mode ) string DbU::getValueString ( DbU::Unit u, int mode )

48
hurricane/src/hurricane/DiffusionLayer.cpp
View File

@ -1,37 +1,8 @@
// -*- C++ -*- // -*- C++ -*-
// //
// This file is part of the Coriolis Project. // This file is part of the Coriolis Software.
// Copyright (C) Laboratoire LIP6 - Departement ASIM // Copyright (c) UPMC/LIP6 2008-2009, All Rights Reserved
// Universite Pierre et Marie Curie
//
// Main contributors :
// Christophe Alexandre <Christophe.Alexandre@lip6.fr>
// Sophie Belloeil <Sophie.Belloeil@lip6.fr>
// Hugo Clément <Hugo.Clement@lip6.fr>
// Jean-Paul Chaput <Jean-Paul.Chaput@lip6.fr>
// Damien Dupuis <Damien.Dupuis@lip6.fr>
// Christian Masson <Christian.Masson@lip6.fr>
// Marek Sroka <Marek.Sroka@lip6.fr>
//
// The Coriolis Project is free software; you can redistribute it
// and/or modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// The Coriolis Project is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with the Coriolis Project; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
//
// License-Tag
// Authors-Tag
// //
// =================================================================== // ===================================================================
// //
@ -203,6 +174,21 @@ namespace Hurricane {
} }
void DiffusionLayer::_onDbuChange ( float scale )
{
Layer::_onDbuChange ( scale );
for ( size_t i=0 ; i<_extentionCaps.size() ; i++ )
_extentionCaps[i] = (DbU::Unit)( (float)_extentionCaps[i] * scale );
for ( size_t i=0 ; i<_extentionWidths.size() ; i++ )
_extentionWidths[i] = (DbU::Unit)( (float)_extentionWidths[i] * scale );
_maximalExtentionCap = (DbU::Unit)( (float)_maximalExtentionCap * scale );
_maximalExtentionWidth = (DbU::Unit)( (float)_maximalExtentionWidth * scale );
}
string DiffusionLayer::_getTypeName () const string DiffusionLayer::_getTypeName () const
{ return _TName("DiffusionLayer"); } { return _TName("DiffusionLayer"); }

8
hurricane/src/hurricane/Layer.cpp
View File

@ -209,6 +209,14 @@ namespace Hurricane {
} }
void Layer::_onDbuChange ( float scale )
{
_minimalSize = (DbU::Unit)( (float)_minimalSize * scale );
_minimalSpacing = (DbU::Unit)( (float)_minimalSpacing * scale );
_pitch = (DbU::Unit)( (float)_pitch * scale );
}
string Layer::_getString() const string Layer::_getString() const
{ {
string s = DBo::_getString(); string s = DBo::_getString();

43
hurricane/src/hurricane/RegularLayer.cpp
View File

@ -1,37 +1,8 @@
// -*- C++ -*- // -*- C++ -*-
// //
// This file is part of the Coriolis Project. // This file is part of the Coriolis Software.
// Copyright (C) Laboratoire LIP6 - Departement ASIM // Copyright (c) UPMC/LIP6 2008-2009, All Rights Reserved
// Universite Pierre et Marie Curie
//
// Main contributors :
// Christophe Alexandre <Christophe.Alexandre@lip6.fr>
// Sophie Belloeil <Sophie.Belloeil@lip6.fr>
// Hugo Clément <Hugo.Clement@lip6.fr>
// Jean-Paul Chaput <Jean-Paul.Chaput@lip6.fr>
// Damien Dupuis <Damien.Dupuis@lip6.fr>
// Christian Masson <Christian.Masson@lip6.fr>
// Marek Sroka <Marek.Sroka@lip6.fr>
//
// The Coriolis Project is free software; you can redistribute it
// and/or modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// The Coriolis Project is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with the Coriolis Project; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
//
// License-Tag
// Authors-Tag
// //
// =================================================================== // ===================================================================
// //
@ -145,6 +116,16 @@ namespace Hurricane {
{ return new Locator(_regularLayer->getBasicLayer()); } { return new Locator(_regularLayer->getBasicLayer()); }
void RegularLayer::_onDbuChange ( float scale )
{
Layer::_onDbuChange ( scale );
_enclosure = (DbU::Unit)( (float)_enclosure * scale );
_extentionCap = (DbU::Unit)( (float)_extentionCap * scale );
_extentionWidth = (DbU::Unit)( (float)_extentionWidth * scale );
}
string RegularLayer_RegularLayers::_getString () const string RegularLayer_RegularLayers::_getString () const
{ {
string s = "<" + _TName("RegularLayer::RegularLayers"); string s = "<" + _TName("RegularLayer::RegularLayers");

7
hurricane/src/hurricane/Technology.cpp
View File

@ -263,6 +263,13 @@ Layer* Technology::getNthMetal ( int nth ) const
} }
void Technology::_onDbuChange ( float scale )
{
forEach ( Layer*, layer, getLayers() )
layer->_onDbuChange ( scale );
}
void Technology::setName(const Name& name) void Technology::setName(const Name& name)
// *************************************** // ***************************************
{ {

49
hurricane/src/hurricane/TransistorLayer.cpp
View File

@ -1,42 +1,14 @@
// -*- C++ -*- // -*- C++ -*-
// //
// This file is part of the Coriolis Project. // This file is part of the Coriolis Software.
// Copyright (C) Laboratoire LIP6 - Departement ASIM // Copyright (c) UPMC/LIP6 2008-2008, All Rights Reserved
// Universite Pierre et Marie Curie
//
// Main contributors :
// Christophe Alexandre <Christophe.Alexandre@lip6.fr>
// Sophie Belloeil <Sophie.Belloeil@lip6.fr>
// Hugo Clément <Hugo.Clement@lip6.fr>
// Jean-Paul Chaput <Jean-Paul.Chaput@lip6.fr>
// Damien Dupuis <Damien.Dupuis@lip6.fr>
// Christian Masson <Christian.Masson@lip6.fr>
// Marek Sroka <Marek.Sroka@lip6.fr>
//
// The Coriolis Project is free software; you can redistribute it
// and/or modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// The Coriolis Project is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with the Coriolis Project; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
//
// License-Tag
// Authors-Tag
// //
// =================================================================== // ===================================================================
// //
// $Id$ // $Id$
// //
//
// x-----------------------------------------------------------------x // x-----------------------------------------------------------------x
// | | // | |
// | H U R R I C A N E | // | H U R R I C A N E |
@ -205,6 +177,21 @@ namespace Hurricane {
} }
void TransistorLayer::_onDbuChange ( float scale )
{
Layer::_onDbuChange ( scale );
for ( size_t i=0 ; i<_extentionCaps.size() ; i++ )
_extentionCaps[i] = (DbU::Unit)( (float)_extentionCaps[i] * scale );
for ( size_t i=0 ; i<_extentionWidths.size() ; i++ )
_extentionWidths[i] = (DbU::Unit)( (float)_extentionWidths[i] * scale );
_maximalExtentionCap = (DbU::Unit)( (float)_maximalExtentionCap * scale );
_maximalExtentionWidth = (DbU::Unit)( (float)_maximalExtentionWidth * scale );
}
string TransistorLayer::_getTypeName () const string TransistorLayer::_getTypeName () const
{ return _TName("TransistorLayer"); } { return _TName("TransistorLayer"); }

11
hurricane/src/hurricane/ViaLayer.cpp
View File

@ -191,6 +191,17 @@ namespace Hurricane {
} }
void ViaLayer::_onDbuChange ( float scale )
{
Layer::_onDbuChange ( scale );
for ( size_t i=0 ; i<_enclosures.size() ; i++ )
_enclosures[i] = (DbU::Unit)( (float)_enclosures[i] * scale );
_maximalEnclosure = (DbU::Unit)( (float)_maximalEnclosure * scale );
}
string ViaLayer::_getTypeName () const string ViaLayer::_getTypeName () const
{ return _TName("ViaLayer"); } { return _TName("ViaLayer"); }

2
hurricane/src/hurricane/hurricane/Commons.h
View File

@ -547,7 +547,7 @@ inline Hurricane::Record* getRecord ( const std::multiset<Element,Compare>* s )
template<> inline std::string getString<Data*>( Data* data ) \ template<> inline std::string getString<Data*>( Data* data ) \
{ \ { \
if (!data) return "NULL [" #Data "]"; \ if (!data) return "NULL [" #Data "]"; \
return const_cast<const Data*>(data)->_getString(); \ return data->_getString(); \
} \ } \
\ \
template<> inline std::string getString<const Data*>( const Data* data ) \ template<> inline std::string getString<const Data*>( const Data* data ) \

129
hurricane/src/hurricane/hurricane/CompositeLayer.h
View File

@ -1,129 +0,0 @@
// ****************************************************************************************************
// File: CompositeLayer.h
// Authors: R. Escassut
// Copyright (c) BULL S.A. 2000-2004, All Rights Reserved
// ****************************************************************************************************
#ifndef HURRICANE_COMPOSITE_LAYER
#define HURRICANE_COMPOSITE_LAYER
#include "hurricane/Layer.h"
#include "hurricane/CompositeLayers.h"
namespace Hurricane {
// ****************************************************************************************************
// CompositeLayer declaration
// ****************************************************************************************************
class CompositeLayer : public Layer {
// ********************************
// Types
// *****
public: typedef Layer Inherit;
public: class Type {
// ***************
public: enum Code {UNDEFINED=0, METAL=1, VIA=2};
private: Code _code;
public: Type(const Code& code = UNDEFINED);
public: Type(const Type& type);
public: Type& operator=(const Type& type);
public: operator const Code&() const {return _code;};
public: const Code& getCode() const {return _code;};
public: string _getTypeName() const { return _TName("CompositeLayer::Type"); };
public: string _getString() const;
public: Record* _getRecord() const;
};
public: typedef list<BasicLayer*> BasicLayerList;
public: typedef map<const BasicLayer*, Unit> SizeMap;
// Attributes
// **********
private: Type _type;
private: BasicLayerList _basicLayerList;
private: SizeMap _contactSizeMap;
private: SizeMap _segmentSizeMap;
private: SizeMap _segmentExtentionMap;
private: SizeMap _padSizeMap;
private: Unit _maximalContactSize;
private: Unit _maximalSegmentSize;
private: Unit _maximalSegmentExtention;
private: Unit _maximalPadSize;
private: BasicLayer* _symbolicBasicLayer;
// Constructors
// ************
protected: CompositeLayer(Technology* technology, const Name& name, const Type& type, const Unit& minimalSize = 0, const Unit& minimalSpacing = 0);
public: static CompositeLayer* create(Technology* technology, const Name& name, const Type& type, const Unit& minimalSize = 0, const Unit& minimalSpacing = 0);
// Accessors
// *********
public: const Type& getType() const {return _type;};
public: virtual BasicLayers getBasicLayers() const;
public: Unit getContactSize(const BasicLayer* basicLayer) const;
public: Unit getSegmentSize(const BasicLayer* basicLayer) const;
public: Unit getSegmentExtention(const BasicLayer* basicLayer) const;
public: Unit getPadSize(const BasicLayer* basicLayer) const;
public: const Unit& getMaximalContactSize() const {return _maximalContactSize;};
public: const Unit& getMaximalSegmentSize() const {return _maximalSegmentSize;};
public: const Unit& getMaximalSegmentExtention() const {return _maximalSegmentExtention;};
public: const Unit& getMaximalPadSize() const {return _maximalPadSize;};
// Updators
// ********
public: void add(BasicLayer* basicLayer, const Unit& contactSize, const Unit& segmentSize, const Unit& segmentExtention, const Unit& padSize);
public: void setContactSize(BasicLayer* basicLayer, const Unit& contactSize);
public: void setSegmentSize(BasicLayer* basicLayer, const Unit& segmentSize);
public: void setSegmentExtention(BasicLayer* basicLayer, const Unit& segmentExtention);
public: void remove(BasicLayer* basicLayer);
// Others
// ******
public: virtual string _getTypeName() const {return _TName("CompositeLayer");};
public: virtual string _getString() const;
public: virtual Record* _getRecord() const;
public: virtual BasicLayer* _getSymbolicBasicLayer() {return _symbolicBasicLayer;};
public: BasicLayerList& _getBasicLayerList() {return _basicLayerList;};
public: void _updateSymbolicBasicLayer(const Layer::Mask& visibleBasicLayersMask);
};
} // End of Hurricane namespace.
// ****************************************************************************************************
// Generic functions
// ****************************************************************************************************
bool Scan(const string& s, Hurricane::CompositeLayer::Type& type);
#endif // HURRICANE_COMPOSITE_LAYER
// ****************************************************************************************************
// Copyright (c) BULL S.A. 2000-2004, All Rights Reserved
// ****************************************************************************************************

35
hurricane/src/hurricane/hurricane/ContactLayer.h
View File

@ -1,37 +1,8 @@
// -*- C++ -*- // -*- C++ -*-
// //
// This file is part of the Coriolis Project. // This file is part of the Coriolis Software.
// Copyright (C) Laboratoire LIP6 - Departement ASIM // Copyright (c) UPMC/LIP6 2008-2009, All Rights Reserved
// Universite Pierre et Marie Curie
//
// Main contributors :
// Christophe Alexandre <Christophe.Alexandre@lip6.fr>
// Sophie Belloeil <Sophie.Belloeil@lip6.fr>
// Hugo Clément <Hugo.Clement@lip6.fr>
// Jean-Paul Chaput <Jean-Paul.Chaput@lip6.fr>
// Damien Dupuis <Damien.Dupuis@lip6.fr>
// Christian Masson <Christian.Masson@lip6.fr>
// Marek Sroka <Marek.Sroka@lip6.fr>
//
// The Coriolis Project is free software; you can redistribute it
// and/or modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// The Coriolis Project is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with the Coriolis Project; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
//
// License-Tag
// Authors-Tag
// //
// =================================================================== // ===================================================================
// //
@ -82,6 +53,7 @@ namespace Hurricane {
// Updators. // Updators.
virtual void setEnclosure ( const BasicLayer* layer, DbU::Unit enclosure ); virtual void setEnclosure ( const BasicLayer* layer, DbU::Unit enclosure );
// Hurricane Managment. // Hurricane Managment.
virtual void _onDbuChange ( float scale );
virtual string _getTypeName () const; virtual string _getTypeName () const;
virtual string _getString () const; virtual string _getString () const;
virtual Record* _getRecord () const; virtual Record* _getRecord () const;
@ -93,7 +65,6 @@ namespace Hurricane {
DbU::Unit _maximalEnclosure; DbU::Unit _maximalEnclosure;
protected: protected:
// Internal: Constructors & Destructors.
ContactLayer ( Technology* technology ContactLayer ( Technology* technology
, const Name& name , const Name& name
, BasicLayer* metalLayer , BasicLayer* metalLayer

19
hurricane/src/hurricane/hurricane/DbU.h
View File

@ -77,13 +77,12 @@ namespace Hurricane {
static void setGridsPerLambda ( double gridsPerLambda ); static void setGridsPerLambda ( double gridsPerLambda );
static double getGridsPerLambda (); static double getGridsPerLambda ();
// Snap Grid Managment. // Snap Grid Managment.
static DbU::Unit getSnapGridStep (); static DbU::Unit getRealSnapGridStep ();
static DbU::Unit getOnSnapGrid ( DbU::Unit u, SnapMode mode=Nearest ); static DbU::Unit getOnRealSnapGrid ( DbU::Unit u, SnapMode mode=Nearest );
static inline void setSnapGridStep ( DbU::Unit step ); static inline void setRealSnapGridStep ( DbU::Unit step );
//static void setGridStep ( const Unit& gridStep ); static DbU::Unit getSymbolicSnapGridStep ();
//static const Unit getGridStep (); static DbU::Unit getOnSymbolicSnapGrid ( DbU::Unit u, SnapMode mode=Nearest );
//static Unit getOnGridUnit ( const DbU::Unit& unit, int s=0 ); static inline void setSymbolicSnapGridStep ( DbU::Unit step );
//static bool isOnGrid ( const Unit& unit, int n=1 );
// Conversions. // Conversions.
static inline long getDb ( Unit u ); static inline long getDb ( Unit u );
static inline double getGrid ( Unit u ); static inline double getGrid ( Unit u );
@ -105,7 +104,8 @@ namespace Hurricane {
static double _gridsPerLambda; static double _gridsPerLambda;
static double _physicalsPerGrid; static double _physicalsPerGrid;
static unsigned int _stringMode; static unsigned int _stringMode;
static DbU::Unit _snapGridStep; static DbU::Unit _realSnapGridStep;
static DbU::Unit _symbolicSnapGridStep;
}; };
@ -117,7 +117,8 @@ namespace Hurricane {
inline double DbU::getGrid ( DbU::Unit u ) { return _resolution*(double)u; } inline double DbU::getGrid ( DbU::Unit u ) { return _resolution*(double)u; }
inline double DbU::getLambda ( DbU::Unit u ) { return getGrid(u)/_gridsPerLambda; } inline double DbU::getLambda ( DbU::Unit u ) { return getGrid(u)/_gridsPerLambda; }
inline void DbU::setStringMode ( unsigned int mode ) { _stringMode = mode; } inline void DbU::setStringMode ( unsigned int mode ) { _stringMode = mode; }
inline void DbU::setSnapGridStep ( DbU::Unit step ) { _snapGridStep = step; } inline void DbU::setRealSnapGridStep ( DbU::Unit step ) { _realSnapGridStep = step; }
inline void DbU::setSymbolicSnapGridStep ( DbU::Unit step ) { _symbolicSnapGridStep = step; }
} // End of Hurricane namespace. } // End of Hurricane namespace.

34
hurricane/src/hurricane/hurricane/DiffusionLayer.h
View File

@ -1,37 +1,8 @@
// -*- C++ -*- // -*- C++ -*-
// //
// This file is part of the Coriolis Project. // This file is part of the Coriolis Software.
// Copyright (C) Laboratoire LIP6 - Departement ASIM // Copyright (c) UPMC/LIP6 2008-2009, All Rights Reserved
// Universite Pierre et Marie Curie
//
// Main contributors :
// Christophe Alexandre <Christophe.Alexandre@lip6.fr>
// Sophie Belloeil <Sophie.Belloeil@lip6.fr>
// Hugo Clément <Hugo.Clement@lip6.fr>
// Jean-Paul Chaput <Jean-Paul.Chaput@lip6.fr>
// Damien Dupuis <Damien.Dupuis@lip6.fr>
// Christian Masson <Christian.Masson@lip6.fr>
// Marek Sroka <Marek.Sroka@lip6.fr>
//
// The Coriolis Project is free software; you can redistribute it
// and/or modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// The Coriolis Project is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with the Coriolis Project; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
//
// License-Tag
// Authors-Tag
// //
// =================================================================== // ===================================================================
// //
@ -83,6 +54,7 @@ namespace Hurricane {
virtual void setExtentionCap ( const BasicLayer* layer, DbU::Unit cap ); virtual void setExtentionCap ( const BasicLayer* layer, DbU::Unit cap );
virtual void setExtentionWidth ( const BasicLayer* layer, DbU::Unit width ); virtual void setExtentionWidth ( const BasicLayer* layer, DbU::Unit width );
// Hurricane Managment. // Hurricane Managment.
virtual void _onDbuChange ( float scale );
virtual string _getTypeName () const; virtual string _getTypeName () const;
virtual string _getString () const; virtual string _getString () const;
virtual Record* _getRecord () const; virtual Record* _getRecord () const;

1
hurricane/src/hurricane/hurricane/Layer.h
View File

@ -90,6 +90,7 @@ namespace Hurricane {
inline void _setMask ( const Mask& mask ); inline void _setMask ( const Mask& mask );
inline void _setExtractMask ( const Mask& extractMask ); inline void _setExtractMask ( const Mask& extractMask );
inline void _setNextOfTechnologyLayerMap ( Layer* layer ); inline void _setNextOfTechnologyLayerMap ( Layer* layer );
virtual void _onDbuChange ( float scale );
public: public:
struct MaskCompare { struct MaskCompare {
inline bool operator () ( const Layer*, const Layer* ) const; inline bool operator () ( const Layer*, const Layer* ) const;

4
hurricane/src/hurricane/hurricane/RegularLayer.h
View File

@ -1,9 +1,8 @@
// -*- C++ -*- // -*- C++ -*-
// //
// This file is part of the Coriolis Software. // This file is part of the Coriolis Software.
// Copyright (c) UPMC/LIP6 2008-2008, All Rights Reserved // Copyright (c) UPMC/LIP6 2008-2009, All Rights Reserved
// //
// =================================================================== // ===================================================================
// //
@ -59,6 +58,7 @@ namespace Hurricane {
virtual void setExtentionCap ( const BasicLayer* layer, DbU::Unit cap ); virtual void setExtentionCap ( const BasicLayer* layer, DbU::Unit cap );
virtual void setExtentionWidth ( const BasicLayer* layer, DbU::Unit width ); virtual void setExtentionWidth ( const BasicLayer* layer, DbU::Unit width );
// Hurricane Managment. // Hurricane Managment.
virtual void _onDbuChange ( float scale );
virtual string _getTypeName () const; virtual string _getTypeName () const;
virtual string _getString () const; virtual string _getString () const;
virtual Record* _getRecord () const; virtual Record* _getRecord () const;

1
hurricane/src/hurricane/hurricane/Technology.h
View File

@ -103,6 +103,7 @@ namespace Hurricane {
void _removeFromLayerMaskMap ( Layer* ); void _removeFromLayerMaskMap ( Layer* );
inline Layer::Mask& _getCutMask (); inline Layer::Mask& _getCutMask ();
inline Layer::Mask& _getMetalMask (); inline Layer::Mask& _getMetalMask ();
void _onDbuChange ( float scale );
// Hurricane Managment. // Hurricane Managment.
virtual string _getTypeName () const; virtual string _getTypeName () const;
virtual string _getString () const; virtual string _getString () const;

3
hurricane/src/hurricane/hurricane/Timer.h
View File

@ -182,7 +182,10 @@ namespace Hurricane {
} // End of Hurricane namespace. } // End of Hurricane namespace.
GETSTRING_VALUE_SUPPORT(Hurricane::Timer);
IOSTREAM_VALUE_SUPPORT(Hurricane::Timer); IOSTREAM_VALUE_SUPPORT(Hurricane::Timer);
//inline std::ostream& operator<< ( std::ostream& o, Hurricane::Timer d )
//{ return o << "<" << "Hurricane::Timer" << ">" << getString<Hurricane::Timer>(d); }
#endif // __HURRICANE_TIMER__ #endif // __HURRICANE_TIMER__

34
hurricane/src/hurricane/hurricane/TransistorLayer.h
View File

@ -1,37 +1,8 @@
// -*- C++ -*- // -*- C++ -*-
// //
// This file is part of the Coriolis Project. // This file is part of the Coriolis Software.
// Copyright (C) Laboratoire LIP6 - Departement ASIM // Copyright (c) UPMC/LIP6 2008-2009, All Rights Reserved
// Universite Pierre et Marie Curie
//
// Main contributors :
// Christophe Alexandre <Christophe.Alexandre@lip6.fr>
// Sophie Belloeil <Sophie.Belloeil@lip6.fr>
// Hugo Clément <Hugo.Clement@lip6.fr>
// Jean-Paul Chaput <Jean-Paul.Chaput@lip6.fr>
// Damien Dupuis <Damien.Dupuis@lip6.fr>
// Christian Masson <Christian.Masson@lip6.fr>
// Marek Sroka <Marek.Sroka@lip6.fr>
//
// The Coriolis Project is free software; you can redistribute it
// and/or modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// The Coriolis Project is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with the Coriolis Project; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
//
// License-Tag
// Authors-Tag
// //
// =================================================================== // ===================================================================
// //
@ -85,6 +56,7 @@ namespace Hurricane {
virtual void setExtentionCap ( const BasicLayer* layer, DbU::Unit cap ); virtual void setExtentionCap ( const BasicLayer* layer, DbU::Unit cap );
virtual void setExtentionWidth ( const BasicLayer* layer, DbU::Unit width ); virtual void setExtentionWidth ( const BasicLayer* layer, DbU::Unit width );
// Hurricane Managment. // Hurricane Managment.
virtual void _onDbuChange ( float scale );
virtual string _getTypeName () const; virtual string _getTypeName () const;
virtual string _getString () const; virtual string _getString () const;
virtual Record* _getRecord () const; virtual Record* _getRecord () const;

34
hurricane/src/hurricane/hurricane/ViaLayer.h
View File

@ -1,37 +1,8 @@
// -*- C++ -*- // -*- C++ -*-
// //
// This file is part of the Coriolis Project. // This file is part of the Coriolis Software.
// Copyright (C) Laboratoire LIP6 - Departement ASIM // Copyright (c) UPMC/LIP6 2008-2009, All Rights Reserved
// Universite Pierre et Marie Curie
//
// Main contributors :
// Christophe Alexandre <Christophe.Alexandre@lip6.fr>
// Sophie Belloeil <Sophie.Belloeil@lip6.fr>
// Hugo Clément <Hugo.Clement@lip6.fr>
// Jean-Paul Chaput <Jean-Paul.Chaput@lip6.fr>
// Damien Dupuis <Damien.Dupuis@lip6.fr>
// Christian Masson <Christian.Masson@lip6.fr>
// Marek Sroka <Marek.Sroka@lip6.fr>
//
// The Coriolis Project is free software; you can redistribute it
// and/or modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// The Coriolis Project is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with the Coriolis Project; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
//
// License-Tag
// Authors-Tag
// //
// =================================================================== // ===================================================================
// //
@ -84,6 +55,7 @@ namespace Hurricane {
// Updators. // Updators.
virtual void setEnclosure ( const BasicLayer* layer, DbU::Unit enclosure ); virtual void setEnclosure ( const BasicLayer* layer, DbU::Unit enclosure );
// Hurricane Managment. // Hurricane Managment.
virtual void _onDbuChange ( float scale );
virtual string _getTypeName () const; virtual string _getTypeName () const;
virtual string _getString () const; virtual string _getString () const;
virtual Record* _getRecord () const; virtual Record* _getRecord () const;

83
hurricane/src/hviewer/CellWidget.cpp
View File

@ -158,8 +158,8 @@ namespace Hurricane {
QPoint CellWidget::Spot::computeSpotPoint ( const QPoint& screenPoint ) QPoint CellWidget::Spot::computeSpotPoint ( const QPoint& screenPoint )
{ {
Point mousePoint = _cellWidget->screenToDbuPoint ( screenPoint ); Point mousePoint = _cellWidget->screenToDbuPoint ( screenPoint );
Point spotPoint = Point ( DbU::getOnSnapGrid(mousePoint.getX()) Point spotPoint = Point ( _cellWidget->_onSnapGrid(mousePoint.getX())
, DbU::getOnSnapGrid(mousePoint.getY()) , _cellWidget->_onSnapGrid(mousePoint.getY())
); );
return _cellWidget->dbuToScreenPoint(spotPoint); return _cellWidget->dbuToScreenPoint(spotPoint);
} }
@ -1101,6 +1101,43 @@ namespace Hurricane {
} }
void CellWidget::changeLayoutMode ()
{
if ( symbolicMode() )
setSymbolicMode ();
else
setRealMode ();
}
void CellWidget::setRealMode ()
{
if ( !realMode() ) {
_state->setRealMode ();
DbU::setStringMode ( DbU::Grid );
updateMousePosition ();
refresh ();
emit layoutModeChanged ();
}
}
void CellWidget::setSymbolicMode ()
{
if ( !symbolicMode() ) {
_state->setSymbolicMode ();
DbU::setStringMode ( DbU::Symbolic );
updateMousePosition ();
refresh ();
emit layoutModeChanged ();
}
}
void CellWidget::setShowSelection ( bool state ) void CellWidget::setShowSelection ( bool state )
{ {
if ( state != _state->showSelection() ) { if ( state != _state->showSelection() ) {
@ -1162,7 +1199,7 @@ namespace Hurricane {
_spot.setRestore ( false ); _spot.setRestore ( false );
//_drawingPlanes.copyToSelect ( redrawArea ); //_drawingPlanes.copyToSelect ( redrawArea );
_drawingPlanes.select ( PlaneId::Normal ); _drawingPlanes.select ( PlaneId::Normal );
_drawingPlanes.painterBegin (); _drawingPlanes.paintersBegin ();
_drawingPlanes.painter().setPen ( Qt::NoPen ); _drawingPlanes.painter().setPen ( Qt::NoPen );
_drawingPlanes.painter().setBackground ( Graphics::getBrush("background") ); _drawingPlanes.painter().setBackground ( Graphics::getBrush("background") );
@ -1248,7 +1285,7 @@ namespace Hurricane {
repaint (); repaint ();
} }
_drawingPlanes.painterEnd (); _drawingPlanes.paintersEnd ();
_cellModificated = false; _cellModificated = false;
} }
@ -1292,7 +1329,7 @@ namespace Hurricane {
); );
_drawingPlanes.select ( PlaneId::Selection ); _drawingPlanes.select ( PlaneId::Selection );
_drawingPlanes.painterBegin (); _drawingPlanes.paintersBegin ();
_drawingPlanes.painter().setPen ( Qt::NoPen ); _drawingPlanes.painter().setPen ( Qt::NoPen );
_drawingPlanes.painter().setBackground ( Graphics::getBrush("background") ); _drawingPlanes.painter().setBackground ( Graphics::getBrush("background") );
_drawingPlanes.painter().setClipRect ( redrawArea ); _drawingPlanes.painter().setClipRect ( redrawArea );
@ -1365,7 +1402,7 @@ namespace Hurricane {
repaint (); repaint ();
} }
_drawingPlanes.painterEnd (); _drawingPlanes.paintersEnd ();
_selectionHasChanged = false; _selectionHasChanged = false;
} }
@ -1380,9 +1417,11 @@ namespace Hurricane {
bool CellWidget::isDrawable ( const Name& name ) bool CellWidget::isDrawable ( const Name& name )
{ {
PaletteItem* item = (_palette) ? _palette->find(name) : NULL; PaletteItem* item = (_palette) ? _palette->find(name) : NULL;
//DbU::Unit unity = symbolicMode() ? DbU::lambda(1.0) : DbU::grid(10.0);
DbU::Unit unity = DbU::lambda(1.0);
return (!item || item->isItemVisible()) return (!item || item->isItemVisible())
&& ( Graphics::getThreshold(name)/DbU::lambda(1.0) < getScale() ); && ( Graphics::getThreshold(name) < getScale()*unity );
} }
@ -1501,6 +1540,14 @@ namespace Hurricane {
} }
bool CellWidget::_underDetailedGridThreshold () const
{
if ( symbolicMode() )
return Graphics::getThreshold("grid")/DbU::lambda(1.0) < getScale()/5;
return Graphics::getThreshold("grid")/DbU::grid(10.0) < getScale()/5;
}
void CellWidget::drawGrid ( QRect redrawArea ) void CellWidget::drawGrid ( QRect redrawArea )
{ {
_drawingPlanes.select ( PlaneId::Normal ); _drawingPlanes.select ( PlaneId::Normal );
@ -1510,31 +1557,29 @@ namespace Hurricane {
Box redrawBox = displayToDbuBox ( redrawArea ).inflate ( DbU::lambda(1.0) ); Box redrawBox = displayToDbuBox ( redrawArea ).inflate ( DbU::lambda(1.0) );
bool lambdaGrid = false; bool detailedGrid = _underDetailedGridThreshold();
if ( Graphics::getThreshold("grid")/DbU::lambda(1.0) < getScale()/5 )
lambdaGrid = true;
DbU::Unit gridStep = DbU::getSnapGridStep(); DbU::Unit gridStep = _snapGridStep();
DbU::Unit superGridStep = gridStep*5; DbU::Unit superGridStep = gridStep*5;
DbU::Unit xGrid; DbU::Unit xGrid;
DbU::Unit yGrid; DbU::Unit yGrid;
QPoint center; QPoint center;
for ( yGrid = DbU::getOnSnapGrid(redrawBox.getYMin()) for ( yGrid = _onSnapGrid(redrawBox.getYMin())
; yGrid < redrawBox.getYMax() ; yGrid < redrawBox.getYMax()
; yGrid += gridStep ; yGrid += gridStep
) { ) {
for ( xGrid = DbU::getOnSnapGrid(redrawBox.getXMin()) for ( xGrid = _onSnapGrid(redrawBox.getXMin())
; xGrid < redrawBox.getXMax() ; xGrid < redrawBox.getXMax()
; xGrid += gridStep ; xGrid += gridStep
) { ) {
center = dbuToDisplayPoint(xGrid,yGrid); center = dbuToDisplayPoint(xGrid,yGrid);
if ( (xGrid % superGridStep) || (yGrid % superGridStep) ) { if ( (xGrid % superGridStep) || (yGrid % superGridStep) ) {
if ( lambdaGrid ) { if ( detailedGrid ) {
_drawingPlanes.painter(PlaneId::Normal).drawPoint ( center ); _drawingPlanes.painter(PlaneId::Normal).drawPoint ( center );
} }
} else { } else {
if ( lambdaGrid ) { if ( detailedGrid ) {
_drawingPlanes.painter(PlaneId::Normal).drawLine ( center.x()-3, center.y() , center.x()+3, center.y() ); _drawingPlanes.painter(PlaneId::Normal).drawLine ( center.x()-3, center.y() , center.x()+3, center.y() );
_drawingPlanes.painter(PlaneId::Normal).drawLine ( center.x() , center.y()-3, center.x() , center.y()+3 ); _drawingPlanes.painter(PlaneId::Normal).drawLine ( center.x() , center.y()-3, center.x() , center.y()+3 );
} else { } else {
@ -1961,11 +2006,8 @@ namespace Hurricane {
commandActive = _commands[i]->mouseMoveEvent ( this, event ); commandActive = _commands[i]->mouseMoveEvent ( this, event );
if ( !commandActive ) { if ( !commandActive ) {
Point mousePoint = screenToDbuPoint ( _mousePosition = event->pos() ); _mousePosition = event->pos();
emit mousePositionChanged ( Point ( DbU::getOnSnapGrid(mousePoint.getX()) updateMousePosition ();
, DbU::getOnSnapGrid(mousePoint.getY())
) );
repaint (); repaint ();
} }
} }
@ -2050,6 +2092,7 @@ namespace Hurricane {
shared_ptr<State> state ( new State(cell) ); shared_ptr<State> state ( new State(cell) );
setState ( state ); setState ( state );
//setRealMode ();
fitToContents ( false ); fitToContents ( false );

78
hurricane/src/hviewer/DisplayFilterWidget.cpp
View File

@ -55,6 +55,8 @@ namespace Hurricane {
, _steiner (new QRadioButton()) , _steiner (new QRadioButton())
, _centric (new QRadioButton()) , _centric (new QRadioButton())
, _barycentric (new QRadioButton()) , _barycentric (new QRadioButton())
, _symbolicMode (new QRadioButton())
, _realMode (new QRadioButton())
, _updateState (ExternalEmit) , _updateState (ExternalEmit)
{ {
setAttribute ( Qt::WA_QuitOnClose, false ); setAttribute ( Qt::WA_QuitOnClose, false );
@ -137,6 +139,27 @@ namespace Hurricane {
group->addButton ( _steiner ); group->addButton ( _steiner );
hLayout->addWidget ( _steiner ); hLayout->addWidget ( _steiner );
groupBox->setLayout ( hLayout );
wLayout->addWidget ( groupBox );
groupBox = new QGroupBox ( tr("Layout Mode") );
hLayout = new QHBoxLayout ();
group = new QButtonGroup ();
hLayout->setContentsMargins ( 5, 0, 5, 0 );
_symbolicMode->setText ( tr("Symbolic (lambda)") );
_symbolicMode->setFont ( Graphics::getNormalFont() );
group->setId ( _symbolicMode, 0 );
group->addButton ( _symbolicMode );
hLayout->addWidget ( _symbolicMode );
_realMode->setText ( tr("Real (foundry grid)") );
_realMode->setFont ( Graphics::getNormalFont() );
group->setId ( _realMode, 0 );
group->addButton ( _realMode );
hLayout->addWidget ( _realMode );
groupBox->setLayout ( hLayout ); groupBox->setLayout ( hLayout );
wLayout->addWidget ( groupBox ); wLayout->addWidget ( groupBox );
wLayout->addStretch (); wLayout->addStretch ();
@ -148,6 +171,8 @@ namespace Hurricane {
connect ( _steiner , SIGNAL(clicked()) , this, SLOT(setRubberSteiner()) ); connect ( _steiner , SIGNAL(clicked()) , this, SLOT(setRubberSteiner()) );
connect ( _centric , SIGNAL(clicked()) , this, SLOT(setRubberCentric()) ); connect ( _centric , SIGNAL(clicked()) , this, SLOT(setRubberCentric()) );
connect ( _barycentric , SIGNAL(clicked()) , this, SLOT(setRubberBarycentric()) ); connect ( _barycentric , SIGNAL(clicked()) , this, SLOT(setRubberBarycentric()) );
connect ( _symbolicMode, SIGNAL(clicked()) , this, SLOT(setSymbolicMode()) );
connect ( _realMode , SIGNAL(clicked()) , this, SLOT(setRealMode()) );
} }
@ -156,6 +181,8 @@ namespace Hurricane {
if ( _cellWidget ) { if ( _cellWidget ) {
disconnect ( this , SIGNAL(queryFilterChanged()), _cellWidget, SLOT(changeQueryFilter()) ); disconnect ( this , SIGNAL(queryFilterChanged()), _cellWidget, SLOT(changeQueryFilter()) );
disconnect ( _cellWidget , SIGNAL(queryFilterChanged()), this , SLOT(changeQueryFilter()) ); disconnect ( _cellWidget , SIGNAL(queryFilterChanged()), this , SLOT(changeQueryFilter()) );
disconnect ( this , SIGNAL(layoutModeChanged ()), _cellWidget, SLOT(changeLayoutMode ()) );
disconnect ( _cellWidget , SIGNAL(layoutModeChanged ()), this , SLOT(changeLayoutMode ()) );
} }
_cellWidget = cw; _cellWidget = cw;
@ -163,9 +190,35 @@ namespace Hurricane {
connect ( this , SIGNAL(queryFilterChanged()), _cellWidget, SLOT(changeQueryFilter()) ); connect ( this , SIGNAL(queryFilterChanged()), _cellWidget, SLOT(changeQueryFilter()) );
connect ( _cellWidget , SIGNAL(queryFilterChanged()), this , SLOT(changeQueryFilter()) ); connect ( _cellWidget , SIGNAL(queryFilterChanged()), this , SLOT(changeQueryFilter()) );
connect ( this , SIGNAL(layoutModeChanged ()), _cellWidget, SLOT(changeLayoutMode ()) );
connect ( _cellWidget , SIGNAL(layoutModeChanged ()), this , SLOT(changeLayoutMode ()) );
_updateState = ExternalEmit; _updateState = ExternalEmit;
changeQueryFilter (); changeQueryFilter ();
changeLayoutMode ();
}
void DisplayFilterWidget::changeLayoutMode ()
{
if ( !_cellWidget ) return;
if ( _updateState == InternalEmit ) {
_updateState = InternalReceive;
emit layoutModeChanged ();
} else {
if ( _updateState == ExternalEmit ) {
blockAllSignals ( true );
if ( _cellWidget->symbolicMode() )
_symbolicMode->setChecked(true);
else
_realMode->setChecked(true);
blockAllSignals ( false );
}
_updateState = ExternalEmit;
}
} }
@ -192,6 +245,7 @@ namespace Hurricane {
case CellWidget::Centric: _centric->setChecked(true); break; case CellWidget::Centric: _centric->setChecked(true); break;
case CellWidget::Barycentric: _barycentric->setChecked(true); break; case CellWidget::Barycentric: _barycentric->setChecked(true); break;
} }
blockAllSignals ( false ); blockAllSignals ( false );
} }
_updateState = ExternalEmit; _updateState = ExternalEmit;
@ -209,6 +263,8 @@ namespace Hurricane {
_steiner ->blockSignals ( state ); _steiner ->blockSignals ( state );
_centric ->blockSignals ( state ); _centric ->blockSignals ( state );
_barycentric ->blockSignals ( state ); _barycentric ->blockSignals ( state );
_symbolicMode ->blockSignals ( state );
_realMode ->blockSignals ( state );
} }
@ -315,4 +371,26 @@ namespace Hurricane {
} }
void DisplayFilterWidget::setSymbolicMode ()
{
if ( _cellWidget ) {
if ( !_cellWidget->symbolicMode() ) {
_updateState = InternalEmit;
_cellWidget->setSymbolicMode ();
}
}
}
void DisplayFilterWidget::setRealMode ()
{
if ( _cellWidget ) {
if ( !_cellWidget->realMode() ) {
_updateState = InternalEmit;
_cellWidget->setRealMode ();
}
}
}
} }

31
hurricane/src/hviewer/DynamicLabel.cpp
View File

@ -1,36 +1,9 @@
// -*- C++ -*- // -*- C++ -*-
// //
// This file is part of the Coriolis Project. // This file is part of the Coriolis Software.
// Copyright (C) Laboratoire LIP6 - Departement ASIM // Copyright (c) UPMC/LIP6 2008-2009, All Rights Reserved
// Universite Pierre et Marie Curie
// //
// Main contributors :
// Christophe Alexandre <Christophe.Alexandre@lip6.fr>
// Sophie Belloeil <Sophie.Belloeil@lip6.fr>
// Hugo Clément <Hugo.Clement@lip6.fr>
// Jean-Paul Chaput <Jean-Paul.Chaput@lip6.fr>
// Damien Dupuis <Damien.Dupuis@lip6.fr>
// Christian Masson <Christian.Masson@lip6.fr>
// Marek Sroka <Marek.Sroka@lip6.fr>
//
// The Coriolis Project is free software; you can redistribute it
// and/or modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// The Coriolis Project is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with the Coriolis Project; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
//
// License-Tag
// Authors-Tag
// =================================================================== // ===================================================================
// //
// $Id$ // $Id$

2
hurricane/src/hviewer/MousePositionWidget.cpp
View File

@ -2,7 +2,7 @@
// -*- C++ -*- // -*- C++ -*-
// //
// This file is part of the Coriolis Software. // This file is part of the Coriolis Software.
// Copyright (c) UPMC/LIP6 2008-2008, All Rights Reserved // Copyright (c) UPMC/LIP6 2008-2009, All Rights Reserved
// //
// =================================================================== // ===================================================================
// //

53
hurricane/src/hviewer/hurricane/viewer/CellWidget.h
View File

@ -131,6 +131,8 @@ namespace Hurricane {
void detachFromPalette (); void detachFromPalette ();
void bindCommand ( Command* ); void bindCommand ( Command* );
void unbindCommand ( Command* ); void unbindCommand ( Command* );
inline bool realMode () const;
inline bool symbolicMode () const;
inline bool showBoundaries () const; inline bool showBoundaries () const;
inline bool showSelection () const; inline bool showSelection () const;
inline bool cumulativeSelection () const; inline bool cumulativeSelection () const;
@ -148,6 +150,7 @@ namespace Hurricane {
inline void copyToImage ( QImage* ); inline void copyToImage ( QImage* );
inline const float& getScale () const; inline const float& getScale () const;
inline const QPoint& getMousePosition () const; inline const QPoint& getMousePosition () const;
inline void updateMousePosition ();
void setLayerVisible ( const Name& layer, bool visible ); void setLayerVisible ( const Name& layer, bool visible );
bool isDrawable ( const Name& ); bool isDrawable ( const Name& );
bool isDrawableLayer ( const Name& ); bool isDrawableLayer ( const Name& );
@ -191,6 +194,9 @@ namespace Hurricane {
Box computeVisibleArea ( float scale ) const; Box computeVisibleArea ( float scale ) const;
Box computeVisibleArea ( float scale, const Point& topLeft ) const; Box computeVisibleArea ( float scale, const Point& topLeft ) const;
Box computeVisibleArea ( const Box&, float& scale ) const; Box computeVisibleArea ( const Box&, float& scale ) const;
inline bool _underDetailedGridThreshold() const;
inline DbU::Unit _snapGridStep () const;
inline DbU::Unit _onSnapGrid ( DbU::Unit ) const;
// Qt QWidget Functions Overloads. // Qt QWidget Functions Overloads.
void pushCursor ( Qt::CursorShape cursor ); void pushCursor ( Qt::CursorShape cursor );
void popCursor (); void popCursor ();
@ -211,6 +217,7 @@ namespace Hurricane {
void stateChanged ( shared_ptr<CellWidget::State>& ); void stateChanged ( shared_ptr<CellWidget::State>& );
void styleChanged (); void styleChanged ();
void queryFilterChanged (); void queryFilterChanged ();
void layoutModeChanged ();
void updatePalette ( Cell* ); void updatePalette ( Cell* );
void mousePositionChanged ( const Point& position ); void mousePositionChanged ( const Point& position );
void selectionModeChanged (); void selectionModeChanged ();
@ -240,6 +247,7 @@ namespace Hurricane {
void _unselectAll (); void _unselectAll ();
void changeQueryFilter (); void changeQueryFilter ();
void rubberChange (); void rubberChange ();
void changeLayoutMode ();
void setStyle ( int id ); void setStyle ( int id );
void updatePalette (); void updatePalette ();
void cellPreModificate (); void cellPreModificate ();
@ -257,6 +265,8 @@ namespace Hurricane {
void setScale ( float ); void setScale ( float );
void scaleHistoryUp (); void scaleHistoryUp ();
void scaleHistoryDown (); void scaleHistoryDown ();
void setRealMode ();
void setSymbolicMode ();
void setShowBoundaries ( bool state ); void setShowBoundaries ( bool state );
void reframe (); void reframe ();
void reframe ( const Box& box, bool historyEnable=true ); void reframe ( const Box& box, bool historyEnable=true );
@ -486,6 +496,8 @@ namespace Hurricane {
inline State ( Cell* cell=NULL ); inline State ( Cell* cell=NULL );
inline void setCell ( Cell* ); inline void setCell ( Cell* );
inline void setCellWidget ( CellWidget* ); inline void setCellWidget ( CellWidget* );
inline void setRealMode ();
inline void setSymbolicMode ();
inline void setShowBoundaries ( bool ); inline void setShowBoundaries ( bool );
inline void setShowSelection ( bool ); inline void setShowSelection ( bool );
inline void setCumulativeSelection ( bool ); inline void setCumulativeSelection ( bool );
@ -502,6 +514,8 @@ namespace Hurricane {
inline Cell* getCell () const; inline Cell* getCell () const;
const Name& getName () const; const Name& getName () const;
inline SelectorCriterions& getSelection (); inline SelectorCriterions& getSelection ();
inline bool realMode () const;
inline bool symbolicMode () const;
inline bool showBoundaries () const; inline bool showBoundaries () const;
inline bool showSelection () const; inline bool showSelection () const;
inline bool cumulativeSelection () const; inline bool cumulativeSelection () const;
@ -527,6 +541,7 @@ namespace Hurricane {
Cell* _cell; Cell* _cell;
CellWidget* _cellWidget; CellWidget* _cellWidget;
SelectorCriterions _selection; SelectorCriterions _selection;
bool _symbolicMode;
bool _showBoundaries; bool _showBoundaries;
bool _showSelection; bool _showSelection;
Query::Mask _queryFilter; Query::Mask _queryFilter;
@ -796,6 +811,7 @@ namespace Hurricane {
: _cell (cell) : _cell (cell)
, _cellWidget (NULL) , _cellWidget (NULL)
, _selection () , _selection ()
, _symbolicMode (true)
, _showBoundaries (true) , _showBoundaries (true)
, _showSelection (false) , _showSelection (false)
, _queryFilter (~Query::DoTerminalCells) , _queryFilter (~Query::DoTerminalCells)
@ -811,6 +827,10 @@ namespace Hurricane {
} }
inline bool CellWidget::State::symbolicMode () const
{ return _symbolicMode; }
inline void CellWidget::State::setCell ( Cell* cell ) inline void CellWidget::State::setCell ( Cell* cell )
{ _cell = cell; } { _cell = cell; }
@ -822,6 +842,14 @@ namespace Hurricane {
} }
inline void CellWidget::State::setRealMode ()
{ _symbolicMode = false; }
inline void CellWidget::State::setSymbolicMode ()
{ _symbolicMode = true; }
inline void CellWidget::State::setShowBoundaries ( bool state ) inline void CellWidget::State::setShowBoundaries ( bool state )
{ _showBoundaries = state; } { _showBoundaries = state; }
@ -1077,6 +1105,14 @@ namespace Hurricane {
{ return _palette; } { return _palette; }
inline bool CellWidget::realMode () const
{ return !_state->symbolicMode(); }
inline bool CellWidget::symbolicMode () const
{ return _state->symbolicMode(); }
inline bool CellWidget::showBoundaries () const inline bool CellWidget::showBoundaries () const
{ return _state->showBoundaries(); } { return _state->showBoundaries(); }
@ -1105,6 +1141,15 @@ namespace Hurricane {
{ return _mousePosition; } { return _mousePosition; }
inline void CellWidget::updateMousePosition ()
{
Point mousePoint = screenToDbuPoint ( _mousePosition );
emit mousePositionChanged ( Point ( _onSnapGrid(mousePoint.getX())
, _onSnapGrid(mousePoint.getY())
) );
}
inline void CellWidget::setQueryFilter ( Query::Mask filter ) inline void CellWidget::setQueryFilter ( Query::Mask filter )
{ {
_state->setQueryFilter ( filter ); _state->setQueryFilter ( filter );
@ -1147,6 +1192,14 @@ namespace Hurricane {
} }
inline DbU::Unit CellWidget::_snapGridStep () const
{ return symbolicMode() ? DbU::getSymbolicSnapGridStep() : DbU::getRealSnapGridStep(); }
inline DbU::Unit CellWidget::_onSnapGrid ( DbU::Unit u ) const
{ return symbolicMode() ? DbU::getOnSymbolicSnapGrid(u) : DbU::getOnRealSnapGrid(u); }
} // End of Hurricane namespace. } // End of Hurricane namespace.

6
hurricane/src/hviewer/hurricane/viewer/DisplayFilterWidget.h
View File

@ -47,8 +47,10 @@ namespace Hurricane {
void setCellWidget ( CellWidget* ); void setCellWidget ( CellWidget* );
signals: signals:
void queryFilterChanged (); void queryFilterChanged ();
void layoutModeChanged ();
public slots: public slots:
void changeQueryFilter (); void changeQueryFilter ();
void changeLayoutMode ();
void startLevelChanged ( int level ); void startLevelChanged ( int level );
void stopLevelChanged ( int level ); void stopLevelChanged ( int level );
void setDoMasterCells ( int state ); void setDoMasterCells ( int state );
@ -57,6 +59,8 @@ namespace Hurricane {
void setRubberSteiner (); void setRubberSteiner ();
void setRubberCentric (); void setRubberCentric ();
void setRubberBarycentric (); void setRubberBarycentric ();
void setSymbolicMode ();
void setRealMode ();
protected: protected:
void blockAllSignals ( bool state ); void blockAllSignals ( bool state );
@ -70,6 +74,8 @@ namespace Hurricane {
QRadioButton* _steiner; QRadioButton* _steiner;
QRadioButton* _centric; QRadioButton* _centric;
QRadioButton* _barycentric; QRadioButton* _barycentric;
QRadioButton* _symbolicMode;
QRadioButton* _realMode;
UpdateState _updateState; UpdateState _updateState;
}; };