No initopts and some bugfixes/improvements

DesignerWidgets/DirectCollapsibleFrame.widget

@@ -10,7 +10,6 @@
             "displayName":"Header Height",
             "internalName":"headerheight",
             "editType":"float",
-            "postProcessFunctionName": "setCollapsed",
             "defaultPixel": 20
         },
         {
@@ -21,14 +20,12 @@
         {
             "displayName":"Collapse Text",
             "internalName":"collapseText",
-            "editType":"str",
-            "postProcessFunctionName": "setCollapsed"
+            "editType":"text"
         },
         {
             "displayName":"Extend Text",
             "internalName":"extendText",
-            "editType":"str",
-            "postProcessFunctionName": "setCollapsed"
+            "editType":"text"
         },
         {
             "displayName":"Update Frame Size",

DesignerWidgets/DirectDiagram.widget

@@ -35,7 +35,8 @@
         {
             "displayName":"Num Text Scale",
             "internalName":"numtextScale",
-            "editType":"float"
+            "editType":"float",
+            "defaultPixel": 10.0
         },
         {
             "displayName":"Show Data Numbers",
@@ -50,7 +51,8 @@
         {
             "displayName":"Data Num Text Scale",
             "internalName":"dataNumtextScale",
-            "editType":"float"
+            "editType":"float",
+            "defaultPixel": 10
         },
         {
             "displayName":"Step Accuracy",
@@ -69,7 +71,14 @@
         {
             "displayName":"Number Area Width",
             "internalName":"numberAreaWidth",
-            "editType":"float"
+            "editType":"float",
+            "defaultPixel": 20
+        },
+        {
+            "displayName":"Number Area Pad",
+            "internalName":"numberAreaPad",
+            "editType":"float",
+            "defaultPixel": 10
         },
         {
             "displayName":"Refresh position",
@@ -80,6 +89,10 @@
         {
             "internalName": "frameSize",
             "defaultPixel": [-100, 100, -100, 100]
+        },
+        {
+            "internalName": "pad",
+            "defaultPixel": [10, 10]
         }
     ],
     "importPath":"from DirectGuiExtension.DirectDiagram import DirectDiagram"

DesignerWidgets/DirectMenuItem.widget

@@ -27,12 +27,22 @@
         {
             "displayName":"Item Frame Color",
             "internalName":"itemFrameColor",
+            "defaultValue": [0.8, 0.8, 0.8, 1],
             "editType":"base4"
         },
         {
             "displayName":"Separator Frame Color",
             "internalName":"separatorFrameColor",
             "editType":"base4"
+        },
+        {
+            "internalName": "scale",
+            "defaultAspect": 0.1,
+            "defaultPixel": 24
+        },
+        {
+            "internalName": "text",
+            "defaultValue": "Menu Item"
         }
     ],
     "importPath":"from DirectGuiExtension.DirectMenuItem import DirectMenuItem"

DesignerWidgets/DirectScrolledWindowFrame.widget

@@ -33,8 +33,28 @@
             "editType":"float"
         },
         {
-        "internalName": "scale",
-        "defaultPixel": 200
+        "internalName": "dragAreaHeight",
+        "defaultPixel": 30
+        },
+        {
+        "internalName": "frameSize",
+        "defaultPixel": [-150, 150, -150, 150]
+        },
+        {
+        "internalName": "canvasSize",
+        "defaultPixel": [-300,300,-300,300]
+        },
+        {
+        "internalName": "scrollBarWidth",
+        "defaultPixel": 20
+        },
+        {
+        "internalName": "borderWidth",
+        "defaultPixel": [2, 2]
+        },
+        {
+        "internalName": "closeButtonScale",
+        "defaultPixel": 20
         }
     ],
     "addItemNode": "canvas",

DesignerWidgets/DirectTabbedFrame.widget

@@ -33,8 +33,12 @@
             "valueOptions": "reposition_tabs"
         },
         {
-        "internalName": "scale",
-        "defaultPixel": 100
+        "internalName": "frameSize",
+        "defaultPixel": [-150, 150, -150, 150]
+        },
+        {
+        "internalName": "tabHeight",
+        "defaultPixel": 20
         }
     ],
     "addItemFunctionName":"_add_tab",

DesignerWidgets/DirectTreeView.widget

@@ -9,14 +9,12 @@
         {
             "displayName": "Image Collapse",
             "internalName": "imageCollapse",
-            "editType": "str",
-            "isInitOption": true
+            "editType": "text"
         },
         {
             "displayName": "Image Collapsed",
             "internalName": "imageCollapsed",
-            "editType": "str",
-            "isInitOption": true
+            "editType": "text"
         },
         {
             "displayName": "Indentation Width",

DirectGuiExtension/DirectAutoSizer.py

@@ -135,15 +135,7 @@ def refresh(self):
         if childSize is None:
             childSize = DGH.getBounds(self.child)
 
-        if type(self.child["scale"]) == LVecBase3f:
-            childScale = self.child["scale"]
-        elif self.child["scale"] is not None:
-            try:
-                childScale = LVecBase3f(self.child["scale"])
-            except:
-                childScale = self.child["scale"]
-        else:
-            childScale = LVecBase3f(1.0)
+        childScale = self.child.getScale()
 
         if not self['extendHorizontal']:
             l = childSize[0] * childScale.getX()
@@ -173,7 +165,7 @@ def refresh(self):
 
         # actual resizing of our child element
         self.child["frameSize"] = [l/childScale.getX(),r/childScale.getX(),b/childScale.getZ(),t/childScale.getZ()]
-        self["frameSize"] = self.child["frameSize"]
+        self["frameSize"] = [l, r, b, t]
 
         base.messenger.send(self.getUpdateSizeEvent())
         if self['childUpdateSizeFunc'] is not None:
@@ -185,3 +177,4 @@ def getUpdateSizeEvent(self):
     def destroy(self):
         self.ignoreAll()
         self.removeChild()
+        DirectFrame.destroy(self)

DirectGuiExtension/DirectBoxSizer.py

@@ -109,20 +109,31 @@ def getRemainingSpace(self):
         or self['orientation'] == DGG.HORIZONTAL_INVERTED:
             # Horizontal
             width = self.__get_items_width()
-            return DGH.getRealWidth(self) - width
+            return DGH.getRealWidth(self) / self.getScale().x - width
         elif self['orientation'] == DGG.VERTICAL \
         or self['orientation'] == DGG.VERTICAL_INVERTED:
             height = self.__get_items_height()
-            return DGH.getRealHeight(self) - height
+            return DGH.getRealHeight(self) / self.getScale().z - height
 
     def refresh(self):
+        """
+        Recalculate the position of every item in this panel and set the frame-
+        size of the panel accordingly if auto update is enabled.
+        """
+        # do a normal refresh to handle all normal directGUI widgets
+        self._refresh()
+        # DirectAutoSizers might have been updated by a window resize, so we have to refresh again after that
+        self.doMethodLater(0, self._refresh, "refresh", extraArgs=[])
+
+    def _refresh(self):
         """
         Recalculate the position of every item in this panel and set the frame-
         size of the panel accordingly if auto update is enabled.
         """
         if self.skipInitRefresh: return
         # sanity check so we don't get here to early
         if not hasattr(self, "bounds") and not self["autoUpdateFrameSize"]: return
+        if not hasattr(self, "_optionInfo"): return
         if len(self["items"]) == 0: return
 
         for item in self["items"]:
@@ -214,101 +225,110 @@ def __get_items_height(self):
     def __refresh_horizontal_ltr(self):
         # Horizontal - Left to Right placement
         # get the left side of the box sizer frame
-        nextX = DGH.getRealLeft(self)
+        nextX = DGH.getRealLeft(self) / self.getScale().x
+        itemMargin = self["itemMargin"]
 
         # go through all items in the box and place them
         for item in self["items"]:
             # place the element and calculate the next x position
             y = self.__get_vertical_item_alignment(item.element)
-            item.element.setPos(nextX - DGH.getRealLeft(item.element), 0, y)
-            nextX += DGH.getRealWidth(item.element)
-
+            item.element.setPos(nextX - DGH.getRealLeft(item.element) + itemMargin[0], 0, y)
+            nextX += DGH.getRealWidth(item.element) + itemMargin[1] + itemMargin[0]
 
     def __refresh_horizontal_rtl(self):
         # Horizontal - Right to Left
         # get the right side of the box sizer frame
-        nextX = DGH.getRealRight(self)
+        nextX = DGH.getRealRight(self) / self.getScale().x
+        itemMargin = self["itemMargin"]
 
         # go through all items in the box and place them
         for item in self["items"]:
             # place the element and calculate the next x position
             y = self.__get_vertical_item_alignment(item.element)
-            item.element.setPos(nextX - DGH.getRealRight(item.element), 0, y)
-            nextX -= DGH.getRealWidth(item.element)
+            item.element.setPos(nextX - DGH.getRealRight(item.element) - itemMargin[1], 0, y)
+            nextX -= DGH.getRealWidth(item.element) + itemMargin[1] + itemMargin[0]
 
     # VERTICAL
     def __refresh_vertical_ttb(self):
         # Vertical - Top to Bottom
         # get the top side of the box sizer frame
-        nextY = DGH.getRealTop(self)
+        nextY = DGH.getRealTop(self) / self.getScale().z
+        itemMargin = self["itemMargin"]
 
         # go through all items in the box and place them
         for item in self["items"]:
             # place the element and calculate the next y position
             x = self.__get_horizontal_item_alignment(item.element)
-            item.element.setPos(x, 0, nextY - DGH.getRealTop(item.element))
-            nextY -= DGH.getRealHeight(item.element)
+            item.element.setPos(x, 0, nextY - DGH.getRealTop(item.element) - itemMargin[3])
+            nextY -= DGH.getRealHeight(item.element) + itemMargin[2] + itemMargin[3]
 
     def __refresh_vertical_btt(self):
         # Vertical - Bottom to Top
         # get the bottom side of the box sizer frame
-        nextY = DGH.getRealBottom(self)
+        nextY = DGH.getRealBottom(self) / self.getScale().z
+        itemMargin = self["itemMargin"]
 
         # go through all items in the box and place them
         for item in self["items"]:
             # place the element and calculate the next y position
             x = self.__get_horizontal_item_alignment(item.element)
-            item.element.setPos(x, 0, nextY - DGH.getRealBottom(item.element))
-            nextY += DGH.getRealHeight(item.element)
+            item.element.setPos(x, 0, nextY - DGH.getRealBottom(item.element) + itemMargin[2])
+            nextY += DGH.getRealHeight(item.element) + itemMargin[2] + itemMargin[3]
 
     #
     # ITEM ALIGN POSITION CALCULATIONS
     #
     def __get_horizontal_item_alignment(self, curElem):
+        itemMargin = self["itemMargin"]
         # Horizontal Alingment
         if self["itemAlign"] & self.A_Left:
             # get the left side of the frame
             x = self["frameSize"][0]
             # shift x right to be aligned with the items left side
             x -= DGH.getRealLeft(curElem)
+            x += itemMargin[0]
             return x
         elif self["itemAlign"] & self.A_Right:
             # get the right side of the frame
             x = self["frameSize"][1]
             # shift x left to be aligned with the items right side
             x -= DGH.getRealRight(curElem)
+            x -= itemMargin[0]
             return x
         elif self["itemAlign"] & self.A_Center:
             # aligned by the center of the frame
-            self_l = DGH.getRealLeft(self)
-            self_r = DGH.getRealRight(self)
+            self_l = DGH.getRealLeft(self) / self.getScale().x
+            self_r = DGH.getRealRight(self) / self.getScale().z
             x = (self_l + self_r) / 2
             # shift x by items center shift
             item_l = DGH.getRealLeft(curElem)
             item_r = DGH.getRealRight(curElem)
             x += (item_l + item_r) / 2
+            x -= itemMargin[0]
             return x
         return 0
 
     def __get_vertical_item_alignment(self, curElem):
+        itemMargin = self["itemMargin"]
         # Vertical Alingment
         if self["itemAlign"] & self.A_Bottom:
             # Vertical adjustment to the box' size
-            y = DGH.getRealBottom(self)# self["frameSize"][2]
+            y = DGH.getRealBottom(self) / self.getScale().z # self["frameSize"][2]
             # shift y up to be aligned with the items bottom side
             y += DGH.getRealBottom(curElem)
             return y
         elif self["itemAlign"] & self.A_Top:
             # Items are alligned by their upper edge
-            y = DGH.getRealTop(self)# self["frameSize"][3]
+            y = DGH.getRealTop(self) / self.getScale().z # self["frameSize"][3]
             # shift y down to be aligned with the items top side
             y -= DGH.getRealTop(curElem)
+            y -= itemMargin[3]
             return y
         elif self["itemAlign"] & self.A_Middle:
             # Items are alligned by their center
             # aligned by the center of the frame
-            self_t = DGH.getRealTop(self)
-            self_b = DGH.getRealBottom(self)
+            self_t = DGH.getRealTop(self) / self.getScale().z
+            self_b = DGH.getRealBottom(self) / self.getScale().z
             y = (self_t + self_b) / 2
             # shift y by items center shift
             item_t = DGH.getRealTop(curElem)

DirectGuiExtension/DirectCollapsibleFrame.py

@@ -17,11 +17,11 @@ class DirectCollapsibleFrame(DirectFrame):
     def __init__(self, parent = None, **kw):
         self.skipInitRefresh = True
         optiondefs = (
-            ('headerheight',           0.1, None),
+            ('headerheight',           0.1, self.setCollapsed),
             ('collapsed',           False, self.setCollapsed),
 
-            ('collapseText',   'collapse >>', None),
-            ('extendText',     'extend <<', None),
+            ('collapseText',   'collapse >>', self.setCollapsed),
+            ('extendText',     'extend <<', self.setCollapsed),
             ('frameSize',      (-0.5, 0.5, -0.5, 0.5), self.setFrameSize)
             )
         # Merge keyword options with default options
@@ -56,12 +56,19 @@ def __init__(self, parent = None, **kw):
 
         self.originalFrameSize = self['frameSize']
 
+        # Make sure we are in the correct state
+        self.setCollapsed()
+
     def updateFrameSize(self):
+        left = DGH.getRealLeft(self) / self.getScale().x
+        right = DGH.getRealRight(self) / self.getScale().x
+        top = DGH.getRealTop(self) / self.getScale().z
+
         self.toggleCollapseButton['frameSize'] = (
-            DGH.getRealLeft(self), DGH.getRealRight(self),
-            DGH.getRealTop(self)-self['headerheight'], DGH.getRealTop(self))
+            left, right,
+            top-self['headerheight'], top)
         self.originalFrameSize = self['frameSize']
-        self.toggleCollapseButton["text_pos"] = (DGH.getRealLeft(self)+0.02, DGH.getRealTop(self)-self['headerheight']/2.0)
+        self.toggleCollapseButton["text_pos"] = (left+0.02, top-self['headerheight']/2.0)
 
     def toggleCollapsed(self):
         self['collapsed'] = not self['collapsed']