<html>
  <head>

    <meta http-equiv="content-type" content="text/html; charset=ISO-8859-2">
  </head>
  <body text="#000000" bgcolor="#FFFFFF">
    I have a class hierarchy like this:<br>
    <br>
    Widget <- VisualWidget <- BsWidget<br>
    <br>
    and then BsWidget has many descendants: Desktop, Row, Column, Navbar
    etc.<br>
    <br>
    Widgets can have children. They are stored in a tree. In order to
    manage the order of widgets, I need methods to append children. (And
    later: insert or prepend because they also have an order). So I
    would like to have methods like this:<br>
    <br>
    BsWidget.AppendNavbar(....)<br>
    BsWidget.AppendRow(...)<br>
    <br>
    Here is the problem: these methods should create instances of Row,
    Column and Navbar. But this leads to circular imports.<br>
    <br>
    Here is code for BsWidget:<br>
    <tt><br>
    </tt><tt>from shopzeus.yaaf.ui.visualwidget import VisualWidget</tt><tt><br>
    </tt><tt><br>
    </tt><tt>from shopzeus.yaaf.ui.bootstrap.row import Row</tt><tt><br>
    </tt><tt>from shopzeus.yaaf.ui.bootstrap.column import Column</tt><tt><br>
    </tt><tt>from shopzeus.yaaf.ui.bootstrap.navbar import Navbar</tt><tt><br>
    </tt><tt><br>
    </tt><tt>class BsWidget(VisualWidget):</tt><tt><br>
    </tt><tt>    """Visual widget for bootstrap.</tt><tt><br>
    </tt><tt><br>
    </tt><tt>    Adds extra methods for adding/removing content like
      rows columns</tt><tt> </tt><tt>etc."""</tt><tt><br>
          def __init__(self,parent):<br>
              <more code here><br>
    </tt><tt><br>
    </tt><tt>    def AppendRow(self):</tt><tt><br>
    </tt><tt>        return Row(self)</tt><tt><br>
    </tt><br>
    <tt><tt>    def AppendColumn(self):</tt><tt><br>
      </tt><tt>        return Row(self)</tt><tt><br>
      </tt></tt><br>
    <tt><tt><tt>    def PrependRow(self):</tt><tt><br>
        </tt><tt>        return Row(self,position=-1)</tt><tt><br>
          <br>
        </tt></tt>    <more code here><br>
      <br>
    </tt><br>
    Here is code for ClassX (where ClassX can be: Row, Column, Desktop,
    Navbar etc.):<br>
    <br>
    <tt>from shopzeus.yaaf.ui.bootstrap.bswidget import BsWidget</tt><tt><br>
      <more imports here><br>
    </tt><tt><br>
    </tt><tt>class ClassX(BsWidget):</tt><tt><br>
    </tt><tt>    <more code here></tt><br>
    <br>
    The circular import is as follows:<br>
    <br>
    <ul>
      <li>I want to create a Desktop instance</li>
      <li>I try to import shopzeus.yaaf.ui.bootstrap.desktop</li>
      <li>That tries to import BsWidget</li>
      <li>That tries to import Row</li>
      <li>That tries to import BsWidget, which is importing -> I get
        an "ImportError: cannot import name BsWidger"</li>
    </ul>
    <p>Of course, instead of "AppendRow()" method I could just use this
      pattern:<br>
    </p>
    <p><tt>from shopzeus.yaaf.ui.bootstrap.desktop import Desktop</tt><br>
      <tt>from shopzeus.yaaf.ui.bootstrap.row import Row</tt><br>
    </p>
    <p>desktop = Desktop(None)<br>
      row = Row(desktop)<br>
    </p>
    <p>However, I really want to avoid this, because there will be at
      least 100 different widget classes. For a usual UI, I would have
      to use many of them and then I would have to start any UI builder
      code like this:<br>
    </p>
    <p><tt>from shopzeus.yaaf.ui.bootstrap.class1 import Class1</tt><tt><br>
        from shopzeus.yaaf.ui.bootstrap.class2 import Class2<tt><br>
          ...</tt><tt><br>
        </tt></tt><tt><tt><tt>from shopzeus.yaaf.ui.bootstrap.class100
            import Class1</tt><tt>00</tt></tt></tt></p>
    Most of the UI building code should look like this instead:<br>
    <tt><br>
    </tt><tt>with self.desktop.AddRow() as row:</tt><tt><br>
    </tt><tt>    with row.AddColumn() as col1</tt><tt>:</tt><tt><br>
    </tt><tt>        ....</tt><tt><br>
    </tt><tt>    with row.AddColumn() as col2:</tt><tt><br>
    </tt><tt>
    </tt><tt>        ....</tt><tt><br>
    </tt><br>
    The child can only be created with its parent anyway, and UI
    building code will have to focus of the strucutre of the UI. So to
    me, it seems logical to create children using methods of the parent.
    But how do I avoid circular imports and achieve my goal at the same
    time?<br>
    <br>
    Here are my expectations:<br>
    <p>
    </p>
    <p>
    </p>
    <ul>
      <li>I want to put different widget classes into their
        corresponding different source files<br>
      </li>
      <li>I want to have a base class (BsWidget) with methods that can
        prepend/append/insert all kinds of other subclasses</li>
      <li>I do NOT want to import all classes of all used widgets in UI
        building code, just use the above methods<br>
      </li>
    </ul>
    <p>This might be a bad idea, but then please tell me why it is bad,
      and what would be the right code pattern for this task.<br>
    </p>
    <p>Thanks,<br>
    </p>
    <p>   Laszlo<br>
      <br>
    </p>
    <p><br>
    </p>
  </body>
</html>