name lookup in templates (g++ 3.4 and greater)

I apologize if this subject has been discussed to death. I read some of
the postings and went and slogged through stuff on the gnu website and
I beleive I understand what is happening.... unfortunately I do not
understand WHY.

Look at line 20 in the .inl file to see the 1st error

Here is the code:
------------------Header----------------------------------------------------
-
#ifndef X3DTK_X3DSFNODEFUNCTOR_H
#define X3DTK_X3DSFNODEFUNCTOR_H

namespace X3DTK {

class X3DAbstractNode;

class X3DTK_API X3DSFNodeFunctor
{
public:
  virtual X3DAbstractNode *getNode(X3DAbstractNode const *N) = 0;
  virtual bool setNode(X3DAbstractNode *N, X3DAbstractNode *C) = 0;
  virtual bool removeNode(X3DAbstractNode *N, X3DAbstractNode *C) = 0;
  virtual void removeThisNode(X3DAbstractNode *N) = 0;
};

template<class T, class V>
class SFNodeFunctor : public X3DSFNodeFunctor
{
public:
  SFNodeFunctor(V *T:: *node);

  X3DAbstractNode *getNode(X3DAbstractNode const *N);
  bool setNode(X3DAbstractNode *N, X3DAbstractNode *C);
  bool removeNode(X3DAbstractNode *N, X3DAbstractNode *C);
  void removeThisNode(X3DAbstractNode *N);

private:
  V *T::*_node;
};

}

#include "X3DSFNodeFunctor.inl"

#endif

---------------------------------INL
FILE-----------------------------------------------------
namespace X3DTK {

template<class T, class V>
SFNodeFunctor<T, V>::SFNodeFunctor(V *T:: *node)
: _node(node)
{
}

template<class T, class V>
X3DAbstractNode *SFNodeFunctor<T, V>::getNode(X3DAbstractNode const *N)
{
  return static_cast<T const *>(N)->*_node;
}

template<class T, class V>
bool SFNodeFunctor<T, V>::setNode(X3DAbstractNode *N, X3DAbstractNode
*C)
{
  if (dynamic_cast<V *>(C) != 0)
  {
    X3DAbstractNode::removeParentFromChild(N, static_cast<T
*>(N)->*_node); /20
    static_cast<T *>(N)->*_node = static_cast<V *>(C);
    X3DAbstractNode::addParentToChild(N, static_cast<T *>(N)->*_node);
    return true;
  }

  return false;
}

template<class T, class V>
bool SFNodeFunctor<T, V>::removeNode(X3DAbstractNode *N,
X3DAbstractNode *C)
{
  if (C == static_cast<T *>(N)->*_node)
  {
    X3DAbstractNode::removeParentFromChild(N, static_cast<T
*>(N)->*_node);
    static_cast<T *>(N)->*_node = 0;
    return true;
  }

  return false;
}

template<class T, class V>
void SFNodeFunctor<T, V>::removeThisNode(X3DAbstractNode *N)
{
  if (dynamic_cast<T *>(N) != 0)
  {
    X3DAbstractNode::removeParentFromChild(N, static_cast<T
*>(N)->*_node);
    static_cast<T *>(N)->*_node = 0;
  }
}

}

This causes this error in g++:

    In file included from kernel/abstractNode/X3DSFNodeFunctor.h:54,
                     from kernel/abstractNode/SFType.h:31,
                     from kernel/abstractNode/X3DAbstractNode.h:24,
                     from kernel/processor/X3DComponentVisitor.h:27,
                     from kernel/processor/AbstractVisitor.h:22,
                     from
functionalities/generic/Cloner/ClonerAbstractVisitor.h:26,
                     from
functionalities/generic/Cloner/ClonerAbstractVisitor.cpp:1:
    kernel/abstractNode/X3DSFNodeFunctor.inl: In member function `bool
X3DTK::SFNodeFunctor<T, V>::setNode(X3DTK::X3DAbstractNode*,
X3DTK::X3DAbstractNode*)':
    kernel/abstractNode/X3DSFNodeFunctor.inl:20: error: incomplete type
`X3DTK::X3DAbstractNode' used in nested name specifier
    kernel/abstractNode/X3DSFNodeFunctor.inl:22: error: incomplete type
`X3DTK::X3DAbstractNode' used in nested name specifier

So what is happening is AbstractNode includes SFType which then
includes X3DSFNodeFunctor.h. However, it looks to me like line 20
should be a DEPENDENT lookup since the template type is used as a
paramater to the function. Thus it should delay this untill
X3DAbstractNode is actaully declared and not just forward referenced.

If you are so kind to respond to this please answer 2 things:

1) Why is the compiler doing what it is doing? (what kind of lookup is
going on here and why?)

2) What would you recomend to fix this? Unfortunately this is not my
code, I recently took over the X3DToolKit and we noticed that it won't
compile at all on g++ 3.4 and later due to this more conforming parse
behaviour. (I imaging that there is a MSVC++ that will break it also
but 7.1 seems to work for now) I would for it to be as simple as
scattering some template and typename keywords all over but I simply
can't match any of the examples I have been able to find to this code
well enough to what the heck I should do.

Thanks much,
Larry E. Ramey

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]