Fresco/Berlin/src DrawTraversalImpl.cc,1.49,1.50 TraversalImpl.cc,1.44,1.45

Update of /cvs/fresco/Fresco/Berlin/src
In directory purcel:/tmp/cvs-serv28902/Berlin/src

Modified Files:
	DrawTraversalImpl.cc TraversalImpl.cc 
Log Message:
Styleguideify TraversalImpl and DrawTraversalImpl. No real changes, just
'fixing' the indention.


Index: DrawTraversalImpl.cc
===================================================================
RCS file: /cvs/fresco/Fresco/Berlin/src/DrawTraversalImpl.cc,v
retrieving revision 1.49
retrieving revision 1.50
diff -u -d -r1.49 -r1.50
--- DrawTraversalImpl.cc	29 May 2002 06:49:41 -0000	1.49
+++ DrawTraversalImpl.cc	10 Dec 2003 18:12:26 -0000	1.50
@@ -25,128 +25,131 @@
 #include <Fresco/DrawingKit.hh>
 #include <Fresco/Region.hh>
 #include <Fresco/IO.hh>
-#include "Berlin/DrawTraversalImpl.hh"
-#include "Berlin/RegionImpl.hh"
-#include "Berlin/Provider.hh"
-#include "Berlin/Console.hh"
+#include <Berlin/DrawTraversalImpl.hh>
+#include <Berlin/RegionImpl.hh>
+#include <Berlin/Provider.hh>
+#include <Berlin/Console.hh>
 
 using namespace Prague;
 using namespace Fresco;
 
-DrawTraversalImpl::DrawTraversalImpl(Graphic_ptr g, Region_ptr r, Transform_ptr t, DrawingKit_ptr kit)
-  : TraversalImpl(g, r, t),
-    _drawing(DrawingKit::_duplicate(kit)),
-    _clipping(Region_var(current_allocation())),
-    _id(new TransformImpl)
+DrawTraversalImpl::DrawTraversalImpl(Graphic_ptr g, Region_ptr r,
+				     Transform_ptr t, DrawingKit_ptr kit) :
+    TraversalImpl(g, r, t),
+    my_drawing(DrawingKit::_duplicate(kit)),
+    my_clipping(Region_var(current_allocation())),
+    my_id(new TransformImpl)
 {
-  Trace trace("DrawTraversalImpl::DrawTraversalImpl");
-  Color fg = {0., 0., 0., 1.};
-  _drawing->foreground(fg);
-  Color white = {1., 1., 1., 1.};
-  _drawing->lighting(white);
-  _drawing->transformation(Transform_var(_id->_this()));
-  _drawing->surface_fillstyle(DrawingKit::solid);
+    Trace trace("DrawTraversalImpl::DrawTraversalImpl");
+    Color fg = {0., 0., 0., 1.};
+    my_drawing->foreground(fg);
+    Color white = {1., 1., 1., 1.};
+    my_drawing->lighting(white);
+    my_drawing->transformation(Transform_var(my_id->_this()));
+    my_drawing->surface_fillstyle(DrawingKit::solid);
 }
 
 void DrawTraversalImpl::damage(Fresco::Region_ptr d)
 {
-  assert(size() == 1);
-  get_allocation(0)->copy(d);
-  _drawing->clipping(_clipping);
+    assert(size() == 1);
+    get_allocation(0)->copy(d);
+    my_drawing->clipping(my_clipping);
 }
 
 void DrawTraversalImpl::init()
 {
-  Trace trace("DrawTraversalImpl::init");
-  __this = _this();
-  _drawing->save();
-  Vertex l, u;
-  _clipping->bounds(l, u);
-  /*
-   * clear the background of the damaged region...
-   */
-  _drawing->draw_rectangle(l, u);
+    Trace trace("DrawTraversalImpl::init");
+    my_this = _this();
+    my_drawing->save();
+    Vertex l, u;
+    my_clipping->bounds(l, u);
+    // clear the background of the damaged region...
+    my_drawing->draw_rectangle(l, u);
 #if 0
-  _drawing->flush();
-  Console::drawable()->flush();
-  sleep(1);
+    my_drawing->flush();
+    Console::drawable()->flush();
+    sleep(1);
 #endif
 }
 
 void DrawTraversalImpl::finish()
 {
-  Trace trace("DrawTraversalImpl::finish");
-  _drawing->restore();
+    Trace trace("DrawTraversalImpl::finish");
+    my_drawing->restore();
 }
 
-DrawTraversalImpl::DrawTraversalImpl(const DrawTraversalImpl &traversal)
-  : TraversalImpl(traversal),
-    _drawing(traversal._drawing),
-    _clipping(traversal._clipping)
+DrawTraversalImpl::DrawTraversalImpl(const DrawTraversalImpl &traversal) :
+    TraversalImpl(traversal),
+    my_drawing(traversal.my_drawing),
+    my_clipping(traversal.my_clipping)
 {
 //   drawing->clipping(clipping);
 }
 
 DrawTraversalImpl::~DrawTraversalImpl()
 {
-  _drawing->restore();
+    my_drawing->restore();
 }
 
 CORBA::Boolean DrawTraversalImpl::intersects_allocation()
 {
-  Trace trace("DrawTraversalImpl::intersects_allocation");
-  Region_var r = current_allocation();
-  Transform_var t = current_transformation();
-  Lease_var<RegionImpl> region( Provider<RegionImpl>::provide() );
-  region->copy(r);
-  region->apply_transform(t);
-  return region->intersects(_clipping);
+    Trace trace("DrawTraversalImpl::intersects_allocation");
+    Region_var r = current_allocation();
+    Transform_var t = current_transformation();
+    Lease_var<RegionImpl> region( Provider<RegionImpl>::provide() );
+    region->copy(r);
+    region->apply_transform(t);
+    return region->intersects(my_clipping);
 }
 
 CORBA::Boolean DrawTraversalImpl::intersects_region(Region_ptr r)
 {
-  RegionImpl region(r, get_transformation(size() - 1));
-//   RegionImpl cl(clipping);
-//   std::cout << "DrawTraversalImpl::intersects_region " << region << ' '
-// 	    << _clipping << std::endl;
-  return region.intersects(_clipping);
+    RegionImpl region(r, get_transformation(size() - 1));
+//    RegionImpl cl(clipping);
+//    std::cout << "DrawTraversalImpl::intersects_region " << region << ' '
+// 	        << my_clipping << std::endl;
+    return region.intersects(my_clipping);
 }
 
-void DrawTraversalImpl::traverse_child(Graphic_ptr child, Tag tag, Region_ptr region, Transform_ptr transform)
+void DrawTraversalImpl::traverse_child(Graphic_ptr child, Tag tag,
+				       Region_ptr region,
+				       Transform_ptr transform)
 {
-  Trace trace("DrawTraversalImpl::traverse_child");
-  if (CORBA::is_nil(region)) region = Region_var(current_allocation());
-  Lease_var<RegionImpl> allocation(Provider<RegionImpl>::provide());
-  allocation->copy(region);
-  Lease_var<TransformImpl> cumulative(Provider<TransformImpl>::provide());
+    Trace trace("DrawTraversalImpl::traverse_child");
+    if (CORBA::is_nil(region)) region = Region_var(current_allocation());
+    Lease_var<RegionImpl> allocation(Provider<RegionImpl>::provide());
+    allocation->copy(region);
+    Lease_var<TransformImpl> cumulative(Provider<TransformImpl>::provide());
 #if 0
-  *cumulative = *get_transformation(size() - 1);
-  if (!CORBA::is_nil(transform)) cumulative->premultiply(transform);
+    *cumulative = *get_transformation(size() - 1);
+    if (!CORBA::is_nil(transform)) cumulative->premultiply(transform);
 #elif 1
-  cumulative->set_and_premult(get_transformation(size()-1), transform);
+    cumulative->set_and_premult(get_transformation(size()-1), transform);
 #elif 0
-  Vertex lower, upper;
-  region->bounds(lower, upper);
-  *cumulative = *get_transformation(size()-1);
-  cumulative->translate(lower);
+    Vertex lower, upper;
+    region->bounds(lower, upper);
+    *cumulative = *get_transformation(size()-1);
+    cumulative->translate(lower);
 #endif
-  _drawing->transformation(Transform_var(cumulative->_this()));
-  // drawable->clipping(region, Transform_var(tx->_this()));
-  push(child, tag, allocation, cumulative); // Keep ownership of cumulative!
-  try
+    my_drawing->transformation(Transform_var(cumulative->_this()));
+    // drawable->clipping(region, Transform_var(tx->_this()));
+    push(child, tag, allocation, cumulative); // Keep ownership of cumulative!
+    try
     {
-      child->traverse(__this);
+	child->traverse(my_this);
     }
-  catch (...)
+    catch (...)
     {
-      // Make sure cumulative does not go out of scope before the pop() ;-)
-      pop();
-      throw;
+	// Make sure cumulative does not go out of scope before the pop() ;-)
+	pop();
+	throw;
     }
-  pop(); // cumulative still in scope...
+    pop(); // cumulative still in scope...
 };
 
-void DrawTraversalImpl::visit(Graphic_ptr g) { g->draw(__this);}
-Fresco::Traversal::order DrawTraversalImpl::direction() { return Fresco::Traversal::up;}
-CORBA::Boolean DrawTraversalImpl::ok() { return true;}
-DrawingKit_ptr DrawTraversalImpl::drawing() { return DrawingKit::_duplicate(_drawing);}
+void DrawTraversalImpl::visit(Graphic_ptr g) { g->draw(my_this); }
+Fresco::Traversal::order DrawTraversalImpl::direction()
+{ return Fresco::Traversal::up; }
+CORBA::Boolean DrawTraversalImpl::ok() { return true; }
+DrawingKit_ptr DrawTraversalImpl::drawing()
+{ return DrawingKit::_duplicate(my_drawing); }

Index: TraversalImpl.cc
===================================================================
RCS file: /cvs/fresco/Fresco/Berlin/src/TraversalImpl.cc,v
retrieving revision 1.44
retrieving revision 1.45
diff -u -d -r1.44 -r1.45
--- TraversalImpl.cc	29 May 2002 06:49:41 -0000	1.44
+++ TraversalImpl.cc	10 Dec 2003 18:12:26 -0000	1.45
@@ -38,141 +38,148 @@
 
 TraversalImpl::TraversalImpl(Graphic_ptr g, Region_ptr a, Transform_ptr t)
 {
-  Trace trace("TraversalImpl::TraversalImpl");
-  Lease_var<RegionImpl> allocation(Provider<RegionImpl>::provide());
-  allocation->copy(a);
-  Lease_var<TransformImpl> transform(Provider<TransformImpl>::provide());
-  transform->copy(t);
-  push(g, 0, allocation._retn(), transform._retn());
+    Trace trace("TraversalImpl::TraversalImpl");
+    Lease_var<RegionImpl> allocation(Provider<RegionImpl>::provide());
+    allocation->copy(a);
+    Lease_var<TransformImpl> transform(Provider<TransformImpl>::provide());
+    transform->copy(t);
+    push(g, 0, allocation._retn(), transform._retn());
 }
 
-TraversalImpl::TraversalImpl(const TraversalImpl &traversal)
-  : _stack(traversal.size())
+TraversalImpl::TraversalImpl(const TraversalImpl &traversal) :
+    my_stack(traversal.size())
 {
-  Trace trace("TraversalImpl::TraversalImpl(const TraversalImpl &)");
-  // explicitely copy the stack so we are the owner and can delete it in the destructor
-  stack_t::iterator i = _stack.begin();
-  stack_t::const_iterator j = traversal._stack.begin();
-  for (; i != _stack.end(); ++i, ++j)
+    Trace trace("TraversalImpl::TraversalImpl(const TraversalImpl &)");
+    // explicitely copy the stack so we are the owner and can delete it
+    // in the destructor
+    my_stack.reserve(traversal.my_stack.size());
+    stack_t::iterator i = my_stack.begin();
+    stack_t::const_iterator j = traversal.my_stack.begin();
+    for (; i != my_stack.end(); ++i, ++j)
     {
-      (*i).graphic = Fresco::Graphic::_duplicate((*j).graphic);
-      (*i).id      = (*j).id;
-      (*i).allocation = Provider<RegionImpl>::provide();
-      *(*i).allocation = *(*j).allocation;
-      (*i).transformation = Provider<TransformImpl>::provide();
-      *(*i).transformation = *(*j).transformation;
+	(*i).graphic = Fresco::Graphic::_duplicate((*j).graphic);
+	(*i).id      = (*j).id;
+	(*i).allocation = Provider<RegionImpl>::provide();
+	*(*i).allocation = *(*j).allocation;
+	(*i).transformation = Provider<TransformImpl>::provide();
+	*(*i).transformation = *(*j).transformation;
     };
 }
 
 TraversalImpl::~TraversalImpl()
 {
-  clear();
-  State &state = _stack.front();
-  CORBA::release(state.graphic);
-  Provider<RegionImpl>::adopt(state.allocation);
-  Provider<TransformImpl>::adopt(state.transformation);
+    clear();
+    State &state = my_stack.front();
+    CORBA::release(state.graphic);
+    Provider<RegionImpl>::adopt(state.allocation);
+    Provider<TransformImpl>::adopt(state.transformation);
 }
 
 TraversalImpl &TraversalImpl::operator = (const TraversalImpl &traversal)
 {
-  Trace trace("TraversalImpl::operator = (const TraversalImpl &)");
-  clear();
-  // explicitely copy the stack so we are the owner and can delete it in the destructor
-  _stack.resize(traversal._stack.size());
-  stack_t::iterator i = _stack.begin();
-  stack_t::const_iterator j = traversal._stack.begin();
-  if (i == _stack.end() || j == traversal._stack.end()) return *this;
-  for (++i, ++j; i != _stack.end(); ++i, ++j)
+    Trace trace("TraversalImpl::operator = (const TraversalImpl &)");
+    clear();
+    // explicitely copy the stack so we are the owner and can delete it
+    // in the destructor
+    my_stack.resize(traversal.my_stack.size());
+    stack_t::iterator i = my_stack.begin();
+    stack_t::const_iterator j = traversal.my_stack.begin();
+    if (i == my_stack.end() || j == traversal.my_stack.end()) return *this;
+    for (++i, ++j; i != my_stack.end(); ++i, ++j)
     {
-      (*i).graphic = Fresco::Graphic::_duplicate((*j).graphic);
-      (*i).id      = (*j).id;
-      (*i).allocation = Provider<RegionImpl>::provide();
-      *(*i).allocation = *(*j).allocation;
-      (*i).transformation = Provider<TransformImpl>::provide();
-      *(*i).transformation = *(*j).transformation;
+	(*i).graphic = Fresco::Graphic::_duplicate((*j).graphic);
+	(*i).id      = (*j).id;
+	(*i).allocation = Provider<RegionImpl>::provide();
+	*(*i).allocation = *(*j).allocation;
+	(*i).transformation = Provider<TransformImpl>::provide();
+	*(*i).transformation = *(*j).transformation;
     };
-  return *this;
+    return *this;
 }
 
 Region_ptr TraversalImpl::current_allocation()
 {
-  Trace trace("TraversalImpl::current_allocation");
-  return _stack.back().allocation->_this();
+    Trace trace("TraversalImpl::current_allocation");
+    return my_stack.back().allocation->_this();
 }
 
 Transform_ptr TraversalImpl::current_transformation() 
 {
-  Trace trace("TraversalImpl::current_transformation");
-  return _stack.back().transformation->_this();
+    Trace trace("TraversalImpl::current_transformation");
+    return my_stack.back().transformation->_this();
 }
 
 Graphic_ptr TraversalImpl::current_graphic()
 {
-  Trace trace("TraversalImpl::current_graphic");
-  return Graphic::_duplicate(_stack.back().graphic);
+    Trace trace("TraversalImpl::current_graphic");
+    return Graphic::_duplicate(my_stack.back().graphic);
 }
 
-CORBA::Boolean TraversalImpl::bounds(Vertex &lower, Vertex &upper, Vertex &origin) 
+CORBA::Boolean TraversalImpl::bounds(Vertex &lower, Vertex &upper,
+				     Vertex &origin) 
 {
-  Trace trace("TraversalImpl::bounds");
-  _stack.back().allocation->bounds(lower, upper);
-  return true;
+    Trace trace("TraversalImpl::bounds");
+    my_stack.back().allocation->bounds(lower, upper);
+    return true;
 }
 
 void TraversalImpl::push(Graphic_ptr g, Tag id, RegionImpl *r, TransformImpl *t)
 {
-  Trace trace("TraversalImpl::push");
-  // We do not own anything but we push onto the stack.
-  // Exception: The transformation at the very first push. That won't get
-  // popped, so that's OK;-)
-  _stack.push_back(State(g, id, r, t));
+    Trace trace("TraversalImpl::push");
+    // We do not own anything but we push onto the stack.
+    // Exception: The transformation at the very first push. That won't get
+    // popped, so that's OK;-)
+    my_stack.push_back(State(g, id, r, t));
 }
 
 void TraversalImpl::pop()
 {
-  Trace trace("TraversalImpl::pop");
-  // We do not own anything, so we don't clean up after ourselves.
-  _stack.erase(_stack.end() - 1);
+    Trace trace("TraversalImpl::pop");
+    // We do not own anything, so we don't clean up after ourselves.
+    my_stack.erase(my_stack.end() - 1);
 }
 
 void TraversalImpl::update()
 {
-  Trace trace("TraversalImpl::update");
-  if (_stack.size() == 1) return;
-  stack_t::iterator parent = _stack.begin();
-  Lease_var<RegionImpl> allocation(Provider<RegionImpl>::provide());
-  *allocation = *(*parent).allocation;
-  Lease_var<TransformImpl> transformation(Provider<TransformImpl>::provide());
-  *transformation = *(*parent).transformation;
-  Allocation::Info info;
-  info.allocation = allocation->_this();
-  info.transformation = transformation->_this();
-  for (stack_t::iterator child = parent + 1; child != _stack.end(); ++parent, ++child)
+    Trace trace("TraversalImpl::update");
+    if (my_stack.size() == 1) return;
+    stack_t::iterator parent = my_stack.begin();
+    Lease_var<RegionImpl> allocation(Provider<RegionImpl>::provide());
+    *allocation = *(*parent).allocation;
+    Lease_var<TransformImpl>
+	transformation(Provider<TransformImpl>::provide());
+    *transformation = *(*parent).transformation;
+    Allocation::Info info;
+    info.allocation = allocation->_this();
+    info.transformation = transformation->_this();
+    for (stack_t::iterator child = parent + 1;
+	 child != my_stack.end();
+	 ++parent, ++child)
     {
-      // recompute the allocation info for the child, given the (just updated)
-      // allocation for the parent
-      (*parent).graphic->allocate((*child).id, info);
-      *(*child).allocation = *allocation;
-      *(*child).transformation = *transformation;
+	// recompute the allocation info for the child, given the (just
+	// updated) allocation for the parent
+	(*parent).graphic->allocate((*child).id, info);
+	*(*child).allocation = *allocation;
+	*(*child).transformation = *transformation;
     }
 }
 
 void TraversalImpl::clear()
 {
-  // DO NOT CALL DURING A TRAVERSAL.
-
-  // After the Traversal is done it is empty anyway (except for the
-  // very first push done in the constructor), so we won't
-  // delete anything we do not own. If there is something left, then
-  // we were a momento, a deep copy of another partial
-  // Traversal: We own everything and must release it on our
-  // own.
-  if (_stack.begin() == _stack.end()) return;
-  for (stack_t::iterator i = _stack.begin() + 1; i != _stack.end(); ++i)
+    // DO NOT CALL DURING A TRAVERSAL.
+    
+    // After the Traversal is done it is empty anyway (except for the
+    // very first push done in the constructor), so we won't
+    // delete anything we do not own. If there is something left, then
+    // we were a momento, a deep copy of another partial
+    // Traversal: We own everything and must release it on our
+    // own.
+    if (my_stack.begin() == my_stack.end()) return;
+    for (stack_t::iterator i = my_stack.begin() + 1; i != my_stack.end(); ++i)
     {
-      CORBA::release((*i).graphic);
-      Provider<RegionImpl>::adopt((*i).allocation);
-      Provider<TransformImpl>::adopt((*i).transformation);
-    };
-  _stack.erase(_stack.begin() + 1, _stack.end());
+	CORBA::release((*i).graphic);
+	Provider<RegionImpl>::adopt((*i).allocation);
+	Provider<TransformImpl>::adopt((*i).transformation);
+    }
+    my_stack.erase(my_stack.begin() + 1, my_stack.end());
 }