def __init__(self):
self.itemFrame = DirectScrolledFrame(
text="Inventory",
text_scale=0.25,
text_pos=(0, 0.75, 0),
text_bg=(1, 1, 1, 1),
# make the frame occupy the whole window
frameSize=(-0.6, 0.6, -0.8, 0.8),
pos=(-0.7, 0, 0),
# make the canvas as big as the frame
canvasSize=(-0.6, 0.6, -0.8, 0.8),
# set the frames color to white
frameColor=(1, 1, 1, 1))
self.itemList = []
self.craftFrame = DirectFrame(
text="Crafting",
text_scale=0.25,
text_pos=(0, 0.75, 0),
text_bg=(1, 1, 1, 1),
# make the frame occupy the whole window
frameSize=(-0.6, 0.6, -0.8, 0.8),
pos=(0.7, 0, 0),
# set the frames color to white
frameColor=(1, 1, 1, 1))
self.craftDrop = DirectFrame(text="drop ore",
text_scale=0.1,
pos=(0, 0.4, 0),
frameSize=(-0.25, 0.25, -0.25, 0.25),
frameColor=(1, 0, 0, 1))
self.craftDrop.reparentTo(self.craftFrame)
def create_device_menu(self):
self.current_panel = None
self.buttons = {}
self.devices_frame = DirectScrolledFrame(
frameSize=VBase4(
0,
base.a2dLeft*-0.75,
base.a2dBottom - base.a2dTop,
0,
),
frameColor=VBase4(0, 0, 0.25, 1.0),
canvasSize=VBase4(
0,
base.a2dLeft*-0.75,
0,
0,
),
scrollBarWidth=0.08,
manageScrollBars=True,
autoHideScrollBars=True,
pos=(base.a2dLeft, 0, base.a2dTop),
parent=base.aspect2d,
)
self.devices_frame.setCanvasSize()
def __init__(self):
self.defaultBtnMap = base.loader.loadModel("gui/button_map")
self.buttonGeom = (self.defaultBtnMap.find("**/button_ready"),
self.defaultBtnMap.find("**/button_click"),
self.defaultBtnMap.find("**/button_rollover"),
self.defaultBtnMap.find("**/button_disabled"))
defaultFont = loader.loadFont('gui/eufm10.ttf')
self.logFrame = DirectScrolledFrame(
canvasSize=(0, base.a2dRight * 2, -5, 0),
frameSize=(0, base.a2dRight * 2, (base.a2dBottom + .2) * 2, 0),
frameColor=(0.1, 0.1, 0.1, 1))
self.logFrame.reparentTo(base.a2dTopLeft)
# create the info and server debug output
self.textscale = 0.1
self.txtinfo = OnscreenText(scale=self.textscale,
pos=(0.1, -0.1),
text="",
align=TextNode.ALeft,
fg=(0.1, 1.0, 0.15, 1),
bg=(0, 0, 0, 0),
shadow=(0, 0, 0, 1),
shadowOffset=(-0.02, -0.02))
self.txtinfo.setTransparency(1)
self.txtinfo.reparentTo(self.logFrame.getCanvas())
# create a close Server button
self.btnBackPos = Vec3(0.4, 0, 0.2)
self.btnBackScale = 0.25
self.btnBack = DirectButton(
# Scale and position
scale=self.btnBackScale,
pos=self.btnBackPos,
# Text
text="Quit Server",
text_scale=0.45,
text_pos=(0, -0.1),
text_fg=(0.82, 0.85, 0.87, 1),
text_shadow=(0, 0, 0, 1),
text_shadowOffset=(-0.02, -0.02),
text_font=defaultFont,
# Frame
geom=self.buttonGeom,
frameColor=(0, 0, 0, 0),
relief=0,
pressEffect=False,
# Functionality
command=self.back,
rolloverSound=None,
clickSound=None)
self.btnBack.setTransparency(1)
self.btnBack.reparentTo(base.a2dBottomLeft)
# catch window resizes and recalculate the aspectration
self.accept("window-event", self.recalcAspectRatio)
self.accept("addLog", self.addLog)
def __init__(self,
frame_size=(1, 1.5),
frame_color=(0.2, 0.2, 0.2, 0.8),
pos=(0, 0, 0),
item_v_padding=0.02,
item_h_padding=0.04,
item_scale=1,
item_side_ratio=0.2,
item_background=(0.3, 0.3, 0.3, 1),
item_background_active=(0.6, 0.6, 0.6, 1),
command=lambda: None):
self.f_x, self.f_y = frame_size
self.c_x = self.f_x
self.c_y = self.f_y
self.item_v_padding = item_v_padding
self.item_h_padding = item_h_padding
self.item_scale = item_scale
self.item_background = item_background
self.item_background_active = item_background_active
self.frame = DirectScrolledFrame(
frameSize=(-self.f_x / 2, self.f_x / 2, -self.f_y / 2,
self.f_y / 2),
canvasSize=(-self.c_x / 2, self.c_x / 2, -self.c_y / 2,
self.c_y / 2),
frameColor=frame_color,
pos=pos,
scrollBarWidth=(0),
manageScrollBars=False,
state=DGG.NORMAL)
self.frame.verticalScroll.destroy()
self.frame.horizontalScroll.destroy()
self.frame.bind(DGG.WITHIN, self._start_listening)
self.frame.bind(DGG.WITHOUT, self._stop_listening)
self.canvas = self.frame.getCanvas()
self.i_x = self.f_x * (1 - item_h_padding)
self.i_y = self.f_y * item_side_ratio
self.i_size = (-self.i_x / 2, self.i_x / 2, -self.i_y / 2,
self.i_y / 2)
self.i_start = self.c_y / 2 + self.i_y / 2
self.active_item = None
self.item_list = []
self.value_list = []
self.start_mY = None
self.old_mY = None
self.m_diff = 0
self.is_scrolling = False
self.command = command
def __init__(self):
self.itemFrame = DirectScrolledFrame(
text = "Inventory",
text_scale = 0.25,
text_pos = (0, 0.75, 0),
text_bg = (1,1,1,1),
# make the frame occupy the whole window
frameSize = (-1.2, 1.2, -0.8, 0.8),
# make the canvas as big as the frame
canvasSize = (-1.2, 1.2, -0.8, 0.8),
# set the frames color to white
frameColor = (1, 1, 1, 1))
self.itemList = []
def __init__(
self,
pos=(0, 0, 0),
parent=None,
frameSize=(1, 1),
treeStructure=DirectTreeItem(),
):
if parent is None:
parent = aspect2d
self.treeStructure = treeStructure
self.treeStructureNodes = dict()
self.highlightedNodes = list()
self.frameWidth = frameSize[0] #0.8
self.frameHeight = frameSize[1] #1.5
self.itemIndent = 0.05
self.itemScale = 0.03
self.itemTextScale = 1.2
self.verticalSpacing = 0.0375
self.__createTreeLines()
self.childrenFrame = DirectScrolledFrame(
parent=parent,
pos=pos,
relief=DGG.GROOVE,
state=DGG.NORMAL, # to create a mouse watcher region
manageScrollBars=0,
enableEdit=0,
#suppressMouse=1,
sortOrder=1000,
frameColor=(0, 0, 0, .7),
borderWidth=(0.005, 0.005),
frameSize=(0, self.frameWidth, 0, self.frameHeight),
canvasSize=(0, self.frameWidth - self.itemScale * 2, 0,
self.frameHeight),
verticalScroll_frameSize=[0, self.itemScale, 0, 1],
horizontalScroll_frameSize=[0, 1, 0, self.itemScale],
)
self.childrenCanvas = self.childrenFrame.getCanvas().attachNewNode(
'myCanvas')
self.childrenCanvas.setX(0.05)
self.childrenCanvas.setZ(self.frameHeight -
1) # some fix to have the list in the window
self.accept(EVENT_DIRECTTREE_REFRESH, self.update)
def loadFormationSelectionFrame(manager):
"""Loads all formations files in the same directory as this .py file and builds a UI element with buttons for each formation.
Formations are .csv files where the nth line is the x, y, z coordinate of the nth drone."""
manager = manager
formations = [
] # a list of formations, which are lists consisting of the name and the positions as a numpy array
# load all .txt files in the formations folder
directory = os.path.dirname(
os.path.abspath(__file__)
) # the directory this.py file is in, which also contains the formation files
for file in os.listdir(directory):
if file.endswith(".csv"):
path = os.path.join(directory, file)
formations.append(_loadFormation(path))
# size and position of the buttons and the scrollable frame
buttonSize = (-8, 8, -.2, .8)
buttonDistance = 0.15
scrolledFrame = DirectScrolledFrame(frameColor=(.2, .2, .2, 1),
canvasSize=(-.7, .7, -buttonDistance *
len(formations), 0),
frameSize=(-.9, .9, -.5, .5),
pos=(.8, 0, -.7),
scale=.5)
canvas = scrolledFrame.getCanvas()
# add a button for each formation
for i in range(0, len(formations)):
button = DirectButton(text=formations[i][0],
scale=.1,
frameSize=buttonSize,
command=manager.applyFormation,
extraArgs=[formations[i]])
button.reparentTo(canvas)
button.setPos(0.15, 0, -(i + 0.75) * buttonDistance)
print("{} formations loaded.".format(len(formations)))
def __init__(self,
parent=None,
scale=.05,
limitText=1,
frameSize=(0, 1.3, .2, .697),
pos=(0, 0, .1)):
self.__scale = scale
self.__frameSize = frameSize
self.__canvasSize = (frameSize[0], frameSize[2] - .01, frameSize[2],
frameSize[3])
self.__limitText = limitText
self.__countLine = []
self.dsf = DirectScrolledFrame(
parent=parent,
canvasSize=self.__canvasSize,
frameSize=self.__frameSize,
pos=pos,
frameColor=COR_OPACITY_03_PRETO,
autoHideScrollBars=1,
scrollBarWidth=0.05,
borderWidth=(0, 0),
verticalScroll_value=1,
verticalScroll_decButton_frameColor=(1, 1, 1, 0.3),
verticalScroll_decButton_rolloverSound=None,
verticalScroll_decButton_clickSound=None,
verticalScroll_incButton_frameColor=(1, 1, 1, 0.3),
verticalScroll_incButton_rolloverSound=None,
verticalScroll_incButton_clickSound=None,
verticalScroll_thumb_frameColor=(1, 1, 1, 0.3),
verticalScroll_thumb_rolloverSound=None,
verticalScroll_thumb_clickSound=None)
self.__textoHeight = scale
self.__canvasHeight = self.dsf.getHeight()
self.__canvas = self.dsf.getCanvas()
def __init__(
self,
pos=(-.5, .5),
title='Title',
curSize=(1, 1),
maxSize=(1, 1),
minSize=(.5, .5),
backgroundColor=(1, 1, 1, 1),
borderColor=(1, 1, 1, 1),
titleColor=(1, 1, 1, 1),
borderSize=0.04,
titleSize=0.06,
closeButton=False,
windowParent=aspect2d,
preserve=True,
preserveWhole=True,
):
self.preserve = preserve
self.preserveWhole = preserveWhole
self.windowParent = windowParent
self.windowPos = pos
DirectFrame.__init__(
self,
parent=windowParent,
pos=(self.windowPos[0], 0, self.windowPos[1]),
frameColor=(0, 0, 0, 0),
frameTexture=loader.loadTexture(DIRECTORY + 'transparent.png'))
self.setTransparency(True)
# the title part of the window, drag around to move the window
self.headerHeight = titleSize
h = -self.headerHeight
self.windowHeaderLeft = DirectButton(
parent=self,
frameTexture=DEFAULT_TITLE_GEOM_LEFT,
frameSize=(-.5, .5, -.5, .5),
borderWidth=(0, 0),
relief=DGG.FLAT,
frameColor=titleColor,
)
self.windowHeaderCenter = DirectButton(
parent=self,
frameTexture=DEFAULT_TITLE_GEOM_CENTER,
frameSize=(-.5, .5, -.5, .5),
borderWidth=(0, 0),
relief=DGG.FLAT,
frameColor=titleColor,
)
if closeButton:
rightTitleGeom = DEFAULT_TITLE_GEOM_RIGHT_CLOSE
command = self.destroy
else:
rightTitleGeom = DEFAULT_TITLE_GEOM_RIGHT
command = None
self.windowHeaderRight = DirectButton(parent=self,
frameTexture=rightTitleGeom,
frameSize=(-.5, .5, -.5, .5),
borderWidth=(0, 0),
relief=DGG.FLAT,
frameColor=titleColor,
command=command)
self.windowHeaderLeft.setTransparency(True)
self.windowHeaderCenter.setTransparency(True)
self.windowHeaderRight.setTransparency(True)
self.windowHeaderLeft.bind(DGG.B1PRESS, self.startWindowDrag)
self.windowHeaderCenter.bind(DGG.B1PRESS, self.startWindowDrag)
self.windowHeaderRight.bind(DGG.B1PRESS, self.startWindowDrag)
# this is not handled correctly, if a window is dragged which has been
# created before another it will not be released
# check the bugfixed startWindowDrag function
#self.windowHeader.bind(DGG.B1RELEASE,self.stopWindowDrag)
text = TextNode('WindowTitleTextNode')
text.setText(title)
text.setAlign(TextNode.ACenter)
text.setTextColor(0, 0, 0, 1)
text.setShadow(0.05, 0.05)
text.setShadowColor(1, 1, 1, 1)
self.textNodePath = self.attachNewNode(text)
self.textNodePath.setScale(self.headerHeight * 0.8)
# the content part of the window, put stuff beneath
# contentWindow.getCanvas() to put it into it
self.maxVirtualSize = maxSize
self.minVirtualSize = minSize
self.resizeSize = borderSize
self.contentWindow = DirectScrolledFrame(
parent=self,
pos=(0, 0, -self.headerHeight),
canvasSize=(0, self.maxVirtualSize[0], 0, self.maxVirtualSize[1]),
frameColor=(
0, 0, 0,
0), # defines the background color of the resize-button
relief=DGG.FLAT,
borderWidth=(0, 0),
verticalScroll_frameSize=[0, self.resizeSize, 0, 1],
horizontalScroll_frameSize=[0, 1, 0, self.resizeSize],
# resize the scrollbar according to window size
verticalScroll_resizeThumb=False,
horizontalScroll_resizeThumb=False,
# define the textures for the scrollbars
verticalScroll_frameTexture=VERTICALSCROLL_FRAMETEXTURE,
verticalScroll_incButton_frameTexture=
VERTICALSCROLL_INCBUTTON_FRAMETEXTURE,
verticalScroll_decButton_frameTexture=
VERTICALSCROLL_DECBUTTON_FRAMETEXTURE,
verticalScroll_thumb_frameTexture=VERTICALSCROLL_TUMB_FRAMETEXTURE,
horizontalScroll_frameTexture=HORIZONTALSCROLL_FRAMETEXTURE,
horizontalScroll_incButton_frameTexture=
HORIZONTALSCROLL_INCBUTTON_FRAMETEXTURE,
horizontalScroll_decButton_frameTexture=
HORIZONTALSCROLL_DECBUTTON_FRAMETEXTURE,
horizontalScroll_thumb_frameTexture=
HORIZONTALSCROLL_TUMB_FRAMETEXTURE,
# make all flat, so the texture is as we want it
verticalScroll_relief=DGG.FLAT,
verticalScroll_thumb_relief=DGG.FLAT,
verticalScroll_decButton_relief=DGG.FLAT,
verticalScroll_incButton_relief=DGG.FLAT,
horizontalScroll_relief=DGG.FLAT,
horizontalScroll_thumb_relief=DGG.FLAT,
horizontalScroll_decButton_relief=DGG.FLAT,
horizontalScroll_incButton_relief=DGG.FLAT,
# colors
verticalScroll_frameColor=borderColor,
verticalScroll_incButton_frameColor=borderColor,
verticalScroll_decButton_frameColor=borderColor,
verticalScroll_thumb_frameColor=borderColor,
horizontalScroll_frameColor=borderColor,
horizontalScroll_incButton_frameColor=borderColor,
horizontalScroll_decButton_frameColor=borderColor,
horizontalScroll_thumb_frameColor=borderColor,
)
self.contentWindow.setTransparency(True)
# background color
self.backgroundColor = DirectFrame(
parent=self.contentWindow.getCanvas(),
frameSize=(0, self.maxVirtualSize[0], 0, self.maxVirtualSize[1]),
frameColor=backgroundColor,
relief=DGG.FLAT,
borderWidth=(.01, .01),
)
self.backgroundColor.setTransparency(True)
# Add a box
self.box = boxes.VBox(parent=self.getCanvas())
# is needed for some nicer visuals of the resize button (background)
self.windowResizeBackground = DirectButton(
parent=self,
frameSize=(-.5, .5, -.5, .5),
borderWidth=(0, 0),
scale=(self.resizeSize, 1, self.resizeSize),
relief=DGG.FLAT,
frameColor=backgroundColor,
)
# the resize button of the window
self.windowResize = DirectButton(
parent=self,
frameSize=(-.5, .5, -.5, .5),
borderWidth=(0, 0),
scale=(self.resizeSize, 1, self.resizeSize),
relief=DGG.FLAT,
frameTexture=DEFAULT_RESIZE_GEOM,
frameColor=borderColor,
)
self.windowResize.setTransparency(True)
self.windowResize.bind(DGG.B1PRESS, self.startResizeDrag)
self.windowResize.bind(DGG.B1RELEASE, self.stopResizeDrag)
# offset then clicking on the resize button from the mouse to the resizebutton
# position, required to calculate the position / scaling
self.offset = None
self.taskName = "resizeTask-%s" % str(hash(self))
# do sizing of the window (minimum)
#self.resize( Vec3(0,0,0), Vec3(0,0,0) )
# maximum
#self.resize( Vec3(100,0,-100), Vec3(0,0,0) )
self.resize(Vec3(curSize[0], 0, -curSize[1]), Vec3(0, 0, 0))
def __init__(self, winned=False):
self._is_shown = False
self._read_coordinates = False
self._winned = winned
self._opened_num = None
self._main_fr = DirectFrame(
parent=base.a2dTopLeft, # noqa: F821
frameSize=(-0.37, 0.38, -0.6, 0.6),
state=DGG.NORMAL,
pos=(0.37, 0, -1),
frameTexture="gui/tex/paper1.png",
)
self._main_fr.setTransparency(TransparencyAttrib.MAlpha)
self._main_fr.hide()
self._fr = DirectScrolledFrame(
parent=self._main_fr,
frameSize=(-0.35, 0.3, -0.46, 0.5),
frameColor=(0, 0, 0, 0),
canvasSize=(-0.31, 0.3, -3, 1.5),
state=DGG.NORMAL,
pos=(0, 0, -0.1),
verticalScroll_frameSize=(-0.003, 0.003, -0.5, 0.5),
verticalScroll_frameColor=(0.46, 0.41, 0.37, 1),
verticalScroll_thumb_frameColor=(0.31, 0.26, 0.22, 1),
verticalScroll_incButton_relief=None,
verticalScroll_decButton_relief=None,
horizontalScroll_relief=None,
horizontalScroll_thumb_relief=None,
horizontalScroll_incButton_relief=None,
horizontalScroll_decButton_relief=None,
)
DirectLabel( # Journal
parent=self._main_fr,
text=base.labels.JOURNAL[0], # noqa: F821
text_font=base.cursive_font, # noqa: F821
text_scale=0.053,
text_bg=(0, 0, 0, 0),
text_fg=(0, 0, 0.25, 1),
frameSize=(0.1, 0.1, 0.1, 0.1),
pos=(-0.34, 0, 0.52),
text_align=TextNode.ALeft,
)
DirectButton(
parent=self._main_fr,
text="<",
text_scale=0.06,
text_bg=(0, 0, 0, 0),
text_fg=(0, 0, 0.25, 1),
pos=(-0.15, 0, 0.45),
frameSize=(-0.2, 0.2, -0.2, 0.2),
relief=None,
command=self._open_page,
extraArgs=[-1],
)
DirectButton(
parent=self._main_fr,
text=">",
text_scale=0.06,
text_bg=(0, 0, 0, 0),
text_fg=(0, 0, 0.25, 1),
pos=(0.15, 0, 0.45),
frameSize=(-0.2, 0.2, -0.2, 0.2),
relief=None,
command=self._open_page,
extraArgs=[1],
)
self._page_title = DirectLabel(
parent=self._main_fr,
text="",
text_scale=0.043,
text_font=base.cursive_font, # noqa: F821
text_fg=(0, 0, 0.25, 1),
frameSize=(-0.02, 0.02, -3.5, 0.5),
frameColor=(0, 0, 0, 0),
pos=(0, 0, 0.45),
)
self._page_text = DirectLabel(
parent=self._fr.getCanvas(),
text="",
text_scale=0.045,
text_font=base.cursive_font, # noqa: F821
text_align=TextNode.ALeft,
text_fg=(0, 0, 0.25, 1),
frameSize=(-0.02, 0.02, -3.5, 0.5),
frameColor=(0, 0, 0, 0),
pos=(-0.27, 0, 1.45),
)
self._pages = []
self._open_snd = loader.loadSfx("sounds/GUI/journal.ogg") # noqa: F821
self._page_snd = loader.loadSfx("sounds/GUI/journal_page.ogg") # noqa: F821
self._close_snd = loader.loadSfx("sounds/GUI/journal_close.ogg") # noqa: F821
def create_panel(self):
panel_width = base.a2dLeft * -0.25 + base.a2dRight
scroll_bar_width = 0.08
# NOTE: -0.001 because thanks to inaccuracy the vertical bar appears...
canvas_width = panel_width - scroll_bar_width - 0.001
canvas_height = base.a2dBottom - base.a2dTop
self.panel = DirectScrolledFrame(
frameSize=VBase4(
0,
panel_width,
canvas_height,
0,
),
frameColor=VBase4(0.8, 0.8, 0.8, 1),
canvasSize=VBase4(
0,
canvas_width,
canvas_height,
0,
),
scrollBarWidth=scroll_bar_width,
manageScrollBars=True,
autoHideScrollBars=True,
pos=(base.a2dLeft * 0.25, 0, base.a2dTop),
parent=base.aspect2d,
)
panel_canvas = self.panel.getCanvas()
offset = -0.0
# Style sheets
half_width_entry = dict(
frameSize=VBase4(
0,
canvas_width / 2,
-0.1,
0,
),
parent=panel_canvas,
frameColor=VBase4(0.8, 0.8, 0.8, 1),
)
left_aligned_small_text = dict(
text_align=TextNode.ALeft,
text_scale=0.05,
text_fg=VBase4(0,0,0,1),
text_pos=(0.05, -0.06),
)
half_width_text_frame = dict(
**half_width_entry,
**left_aligned_small_text,
)
header = dict(
frameSize=VBase4(
0,
canvas_width,
-0.1,
0,
),
parent=panel_canvas,
frameColor=VBase4(0.6, 0.6, 0.6, 1),
text_align=TextNode.ALeft,
text_scale=0.1,
text_fg=VBase4(0,0,0,1),
text_pos=(0.05, -0.075),
)
# Basic device data (name, device class, manufacturer, USB ID)
self.device_header = DirectLabel(
text="Device data",
pos=(0, 0, offset),
**header,
)
offset -= 0.1
def add_data_entry(offset, label, text):
self.name = DirectLabel(
text=label,
pos=(0, 0, offset),
**half_width_text_frame,
)
self.name = DirectLabel(
text=text,
pos=(canvas_width / 2, 0, offset),
**half_width_text_frame,
)
metadata = [
('Name', self.device.name),
('Device class', self.device.device_class.name),
('Manufacturer', self.device.manufacturer),
('USB ID',
"{:04x}:{:04x}".format(
self.device.vendor_id,
self.device.product_id,
),
),
]
for label, text in metadata:
add_data_entry(offset, label, text)
offset -= 0.1
# Axes
self.axis_sliders = []
if len(self.device.axes) > 0:
offset -= 0.1
self.axes_header = DirectLabel(
text="Axes",
pos=(0, 0, offset),
**header,
)
offset -= 0.1
def add_axis(offset, axis_name):
slider_width = canvas_width / 2
label = DirectLabel(
text=axis_name,
**left_aligned_small_text,
pos=(0.05, 0, offset),
parent=panel_canvas,
)
slider = DirectSlider(
value=0.0,
range=(-1.0, 1.0),
state=DGG.DISABLED,
frameSize=VBase4(
0,
slider_width,
-0.1,
0,
),
thumb_frameSize=VBase4(
0.0,
0.04,
-0.04,
0.04),
frameColor=VBase4(0.3, 0.3, 0.3, 1),
pos=(canvas_width - slider_width, 0, offset),
parent=panel_canvas,
)
return slider
for axis in self.device.axes:
axis_slider = add_axis(offset, axis.axis.name)
self.axis_sliders.append(axis_slider)
offset -= 0.1
# Buttons
self.button_buttons = []
if len(self.device.buttons) > 0:
offset -= 0.1
self.buttons_header = DirectLabel(
text="Buttons",
pos=(0, 0, offset),
**header,
)
offset -= 0.1
def add_button(offset, button_name):
button_width = canvas_width / 2
label = DirectLabel(
text=button_name,
**left_aligned_small_text,
pos=(0.05, 0, offset),
parent=panel_canvas,
)
button = DirectFrame(
frameSize=VBase4(
0,
button_width,
-0.1,
0,
),
text="",
text_align=TextNode.ACenter,
text_scale=0.05,
text_fg=VBase4(0,0,0,1),
text_pos=(button_width / 2, -0.06),
frameColor=VBase4(0.3, 0.3, 0.3, 1),
pos=(canvas_width - button_width, 0, offset),
parent=panel_canvas,
)
return button
for i in range(len(self.device.buttons)):
button_name = self.device.buttons[i].handle.name
button_button = add_button(offset, button_name)
self.button_buttons.append(button_button)
offset -= 0.1
# Vibration
self.vibration = []
if self.device.has_feature(InputDevice.Feature.vibration):
offset -= 0.1
self.vibration_header = DirectLabel(
text="Vibration",
pos=(0, 0, offset),
**header,
)
offset -= 0.1
def add_vibration(offset, axis_name, index):
slider_width = canvas_width / 2
label = DirectLabel(
text=axis_name,
**left_aligned_small_text,
pos=(0.05, 0, offset),
parent=panel_canvas,
)
slider = DirectSlider(
value=0.0,
range=(0.0, 1.0),
command=self.update_vibration,
frameSize=VBase4(
0,
slider_width,
-0.1,
0,
),
thumb_frameSize=VBase4(
0.0,
0.04,
-0.04,
0.04),
frameColor=VBase4(0.3, 0.3, 0.3, 1),
pos=(canvas_width - slider_width, 0, offset),
parent=panel_canvas,
)
return slider
for index, name in enumerate(["low frequency", "high frequency"]):
self.vibration.append(add_vibration(offset, name, index))
offset -= 0.1
# Resize the panel's canvas to the widgets actually in it.
if -offset > -canvas_height:
self.panel['canvasSize'] = VBase4(
0,
canvas_width,
offset,
0,
)
self.panel.setCanvasSize()
def __init__(self):
ShowBase.__init__(self)
self.setBackgroundColor(0, 0, 0)
# make the font look nice at a big scale
DGG.getDefaultFont().setPixelsPerUnit(100)
# Store our mapping, with some sensible defaults. In a real game, you
# will want to load these from a configuration file.
self.mapping = InputMapping()
self.mapping.mapAxis("Move forward", InputDevice.Axis.left_y)
self.mapping.mapAxis("Move backward", InputDevice.Axis.left_y)
self.mapping.mapAxis("Move left", InputDevice.Axis.left_x)
self.mapping.mapAxis("Move right", InputDevice.Axis.left_x)
self.mapping.mapButton("Jump", GamepadButton.face_a())
self.mapping.mapButton("Use", GamepadButton.face_b())
self.mapping.mapButton("Break", GamepadButton.face_x())
self.mapping.mapButton("Fix", GamepadButton.face_y())
# The geometry for our basic buttons
maps = loader.loadModel("models/button_map")
self.buttonGeom = (maps.find("**/ready"), maps.find("**/click"),
maps.find("**/hover"), maps.find("**/disabled"))
# Change the default dialog skin.
DGG.setDefaultDialogGeom("models/dialog.png")
# create a sample title
self.textscale = 0.1
self.title = DirectLabel(scale=self.textscale,
pos=(base.a2dLeft + 0.05, 0.0,
base.a2dTop - (self.textscale + 0.05)),
frameColor=VBase4(0, 0, 0, 0),
text="Button Mapping",
text_align=TextNode.ALeft,
text_fg=VBase4(1, 1, 1, 1),
text_shadow=VBase4(0, 0, 0, 0.75),
text_shadowOffset=Vec2(0.05, 0.05))
self.title.setTransparency(1)
# Set up the list of actions that we can map keys to
# create a frame that will create the scrollbars for us
# Load the models for the scrollbar elements
thumbMaps = loader.loadModel("models/thumb_map")
thumbGeom = (thumbMaps.find("**/thumb_ready"),
thumbMaps.find("**/thumb_click"),
thumbMaps.find("**/thumb_hover"),
thumbMaps.find("**/thumb_disabled"))
incMaps = loader.loadModel("models/inc_map")
incGeom = (incMaps.find("**/inc_ready"), incMaps.find("**/inc_click"),
incMaps.find("**/inc_hover"),
incMaps.find("**/inc_disabled"))
decMaps = loader.loadModel("models/dec_map")
decGeom = (decMaps.find("**/dec_ready"), decMaps.find("**/dec_click"),
decMaps.find("**/dec_hover"),
decMaps.find("**/dec_disabled"))
# create the scrolled frame that will hold our list
self.lstActionMap = DirectScrolledFrame(
# make the frame occupy the whole window
frameSize=VBase4(base.a2dLeft, base.a2dRight, 0.0, 1.55),
# make the canvas as big as the frame
canvasSize=VBase4(base.a2dLeft, base.a2dRight, 0.0, 0.0),
# set the frames color to white
frameColor=VBase4(0, 0, 0.25, 0.75),
pos=(0, 0, -0.8),
verticalScroll_scrollSize=0.2,
verticalScroll_frameColor=VBase4(0.02, 0.02, 0.02, 1),
verticalScroll_thumb_relief=1,
verticalScroll_thumb_geom=thumbGeom,
verticalScroll_thumb_pressEffect=False,
verticalScroll_thumb_frameColor=VBase4(0, 0, 0, 0),
verticalScroll_incButton_relief=1,
verticalScroll_incButton_geom=incGeom,
verticalScroll_incButton_pressEffect=False,
verticalScroll_incButton_frameColor=VBase4(0, 0, 0, 0),
verticalScroll_decButton_relief=1,
verticalScroll_decButton_geom=decGeom,
verticalScroll_decButton_pressEffect=False,
verticalScroll_decButton_frameColor=VBase4(0, 0, 0, 0),
)
# creat the list items
idx = 0
self.listBGEven = base.loader.loadModel("models/list_item_even")
self.listBGOdd = base.loader.loadModel("models/list_item_odd")
self.actionLabels = {}
for action in self.mapping.actions:
mapped = self.mapping.formatMapping(action)
item = self.__makeListItem(action, mapped, idx)
item.reparentTo(self.lstActionMap.getCanvas())
idx += 1
# recalculate the canvas size to set scrollbars if necesary
self.lstActionMap["canvasSize"] = (base.a2dLeft + 0.05,
base.a2dRight - 0.05,
-(len(self.mapping.actions) * 0.1),
0.09)
self.lstActionMap.setCanvasSize()
def __init__(self, services: Services,
mouse1_press_callbacks: List[Callable[[], None]]):
self.__services = services
self.__services.ev_manager.register_listener(self)
self.__base = self.__services.graphics.window
self.__window = Window(self.__base,
"view_editor",
mouse1_press_callbacks,
borderWidth=(0.0, 0.0),
frameColor=WINDOW_BG_COLOUR,
pos=(1.1, 0.5, 0.5),
frameSize=(-1.1, 1.1, -5.79, 1.56))
self.__colour_picker = AdvancedColourPicker(
self.__base, self.__window.frame, self.__colour_picker_callback,
mouse1_press_callbacks)
# spacers
DirectFrame(parent=self.__window.frame,
borderWidth=(.0, .0),
frameColor=WIDGET_BG_COLOUR,
frameSize=(-1., 1., -0.01, 0.01),
pos=(0.0, 0.0, -1.75))
DirectFrame(parent=self.__window.frame,
borderWidth=(.0, .0),
frameColor=WIDGET_BG_COLOUR,
frameSize=(-1., 1., -0.01, 0.01),
pos=(0.0, 0.0, 1.1))
DirectFrame(parent=self.__window.frame,
borderWidth=(.0, .0),
frameColor=WIDGET_BG_COLOUR,
frameSize=(-1., 1., -0.01, 0.01),
pos=(0.0, 0.0, -4.1))
# ViewElements listing
self.__elems_frame = DirectScrolledFrame(parent=self.__window.frame,
frameColor=WINDOW_BG_COLOUR,
frameSize=(-1, 1, -1.125,
1.1),
pos=(0, 0, -2.9),
autoHideScrollBars=True)
# selected colour view frame
self.__selected_cv_outline = DirectFrame(
parent=self.__elems_frame.getCanvas(),
relief=DGG.SUNKEN,
frameColor=WHITE,
borderWidth=(0.15, 0.15),
frameSize=(-0.62, 0.62, -0.54, 0.54),
scale=(0.18, 1.0, 0.18))
# selected view frame
self.__selected_view_outline = DirectFrame(parent=self.__window.frame,
relief=DGG.SUNKEN,
frameColor=WHITE,
borderWidth=(0.15, 0.15),
frameSize=(-0.62, 0.62,
-0.54, 0.54),
scale=(0.3, 2.0, 0.35))
self.heading = DirectLabel(parent=self.__window.frame,
text="View Editor",
text_fg=WHITE,
text_bg=WINDOW_BG_COLOUR,
frameColor=WINDOW_BG_COLOUR,
borderWidth=(.0, .0),
pos=(-0.42, 0.0, 1.27),
scale=(0.2, 3, 0.2))
self.__save_outline = DirectFrame(parent=self.__window.frame,
frameColor=WHITE,
pos=(-0.57, 0, -5.45),
borderWidth=(0.25, 0.15),
frameSize=(-0.62, 0.62, -0.54, 0.54),
scale=(0.50, 2.1, 0.25))
self.__restore_outline = DirectFrame(parent=self.__window.frame,
frameColor=WHITE,
pos=(0.50, 0, -5.45),
borderWidth=(0.25, 0.15),
frameSize=(-0.62, 0.62, -0.54,
0.54),
scale=(0.65, 2.1, 0.25))
# save and restore
self.btn_s = DirectButton(text="Save",
text_fg=(0.3, 0.3, 0.3, 1.0),
pressEffect=1,
command=self.__save,
pos=(-0.575, 0, -5.5),
parent=self.__window.frame,
scale=(0.20, 2.1, 0.15),
frameColor=TRANSPARENT)
self.btn_r = DirectButton(text="Restore",
text_fg=(0.3, 0.3, 0.3, 1.0),
pressEffect=1,
command=self.__reset,
pos=(0.50, 0, -5.5),
parent=self.__window.frame,
scale=(0.20, 2.1, 0.15),
frameColor=TRANSPARENT)
# zoom window in / out
self.btn_zoom_out = DirectButton(text="-",
text_fg=WHITE,
pressEffect=1,
command=self.__window.zoom_out,
pos=(0.5, 0., 1.25),
parent=self.__window.frame,
scale=(0.38, 4.25, 0.45),
frameColor=TRANSPARENT)
self.btn_zoom_in = DirectButton(text="+",
text_fg=WHITE,
pressEffect=1,
command=self.__window.zoom_in,
pos=(0.71, 0., 1.28),
parent=self.__window.frame,
scale=(0.35, 4.19, 0.38),
frameColor=TRANSPARENT)
# Quit button
self.btn = DirectButton(text='x',
text_fg=WHITE,
command=self.__window.toggle_visible,
pos=(0.91, 0.4, 1.3),
parent=self.__window.frame,
scale=(0.3, 2.9, 0.2),
pressEffect=1,
frameColor=TRANSPARENT)
# Creating view selectors
self.__view_selectors = []
for i in range(0, PersistentStateViews.MAX_VIEWS):
num = os.path.join(GUI_DATA_PATH, str(i + 1) + ".png")
self.__view_selectors.append(
DirectButton(image=num,
pos=(-0.7 + (i % 3) * 0.7, 0.4,
-4.4 - 0.5 * (i // 3)),
parent=self.__window.frame,
scale=0.16,
frameColor=TRANSPARENT,
command=lambda v: setattr(self, "view_idx", v),
extraArgs=[i]))
self.__elems = []
self.__reset()
def __init__(self, parent=None, frameSize=(.8,1.2), buttonTextColor=(1,1,1,1),
font=None, itemScale=.045, itemTextScale=0.85, itemTextZ=0,
command=None, contextMenu=None, autoFocus=0,
colorChange=1, colorChangeDuration=1, newItemColor=globals.colors['guiblue1'],
rolloverColor=globals.colors['guiyellow'],
suppressMouseWheel=1, modifier='control'):
self.mode = None
self.focusButton=None
self.command=command
self.contextMenu=contextMenu
self.autoFocus=autoFocus
self.colorChange=colorChange
self.colorChangeDuration=colorChangeDuration*.5
self.newItemColor=newItemColor
self.rolloverColor=rolloverColor
self.rightClickTextColors=(Vec4(0,1,0,1),Vec4(0,35,100,1))
self.font=font
if font:
self.fontHeight=font.getLineHeight()
else:
self.fontHeight=TextNode.getDefaultFont().getLineHeight()
self.fontHeight*=1.2 # let's enlarge font height a little
self.xtraSideSpace=.2*self.fontHeight
self.itemTextScale=itemTextScale
self.itemTextZ=itemTextZ
self.buttonTextColor=buttonTextColor
self.suppressMouseWheel=suppressMouseWheel
self.modifier=modifier
self.buttonsList=[]
self.numItems=0
self.__eventReceivers={}
# DirectScrolledFrame to hold items
self.itemScale=itemScale
self.itemVertSpacing=self.fontHeight*self.itemScale
self.frameWidth,self.frameHeight=frameSize
# I set canvas' Z size smaller than the frame to avoid the auto-generated vertical slider bar
self.childrenFrame = DirectScrolledFrame(
parent=parent,pos=(-self.frameWidth*.5,0,.5*self.frameHeight), relief=DGG.GROOVE,
state=DGG.NORMAL, # to create a mouse watcher region
frameSize=(0, self.frameWidth, -self.frameHeight, 0), frameColor=(0,0,0,.7),
canvasSize=(0, 0, -self.frameHeight*.5, 0), borderWidth=(0.01,0.01),
manageScrollBars=0, enableEdit=0, suppressMouse=0, sortOrder=1000 )
# the real canvas is "self.childrenFrame.getCanvas()",
# but if the frame is hidden since the beginning,
# no matter how I set the canvas Z pos, the transform would be resistant,
# so just create a new node under the canvas to be my canvas
self.canvas=self.childrenFrame.getCanvas().attachNewNode('myCanvas')
# slider background
SliderBG=DirectFrame( parent=self.childrenFrame,frameSize=(-.025,.025,-self.frameHeight,0),
frameColor=(0,0,0,.7), pos=(-.03,0,0),enableEdit=0, suppressMouse=0)
# slider thumb track
sliderTrack = DirectFrame( parent=SliderBG, relief=DGG.FLAT, #state=DGG.NORMAL,
frameColor=(1,1,1,.2), frameSize=(-.015,.015,-self.frameHeight+.01,-.01),
enableEdit=0, suppressMouse=0)
# page up
self.pageUpRegion=DirectFrame( parent=SliderBG, relief=DGG.FLAT, state=DGG.NORMAL,
frameColor=(1,.8,.2,.1), frameSize=(-.015,.015,0,0),
enableEdit=0, suppressMouse=0)
self.pageUpRegion.setAlphaScale(0)
self.pageUpRegion.bind(DGG.B1PRESS,self.__startScrollPage,[-1])
self.pageUpRegion.bind(DGG.WITHIN,self.__continueScrollUp)
self.pageUpRegion.bind(DGG.WITHOUT,self.__suspendScrollUp)
# page down
self.pageDnRegion=DirectFrame( parent=SliderBG, relief=DGG.FLAT, state=DGG.NORMAL,
frameColor=(1,.8,.2,.1), frameSize=(-.015,.015,0,0),
enableEdit=0, suppressMouse=0)
self.pageDnRegion.setAlphaScale(0)
self.pageDnRegion.bind(DGG.B1PRESS,self.__startScrollPage,[1])
self.pageDnRegion.bind(DGG.WITHIN,self.__continueScrollDn)
self.pageDnRegion.bind(DGG.WITHOUT,self.__suspendScrollDn)
self.pageUpDnSuspended=[0,0]
# slider thumb
self.vertSliderThumb=DirectButton(parent=SliderBG, relief=DGG.FLAT,
frameColor=(1,1,1,.6), frameSize=(-.015,.015,0,0),
enableEdit=0, suppressMouse=0, rolloverSound=None, clickSound=None)
self.vertSliderThumb.bind(DGG.B1PRESS,self.__startdragSliderThumb)
self.vertSliderThumb.bind(DGG.WITHIN,self.__enteringThumb)
self.vertSliderThumb.bind(DGG.WITHOUT,self.__exitingThumb)
self.oldPrefix=base.buttonThrowers[0].node().getPrefix()
self.sliderThumbDragPrefix='draggingSliderThumb-'
# GOD & I DAMN IT !!!
# These things below don't work well if the canvas has a lot of buttons.
# So I end up checking the mouse region every frame by myself using a continuous task.
# self.accept(DGG.WITHIN+self.childrenFrame.guiId,self.__enteringFrame)
# self.accept(DGG.WITHOUT+self.childrenFrame.guiId,self.__exitingFrame)
self.isMouseInRegion=False
self.mouseOutInRegionCommand=(self.__exitingFrame,self.__enteringFrame)
taskMgr.doMethodLater(.2,self.__getFrameRegion,'getFrameRegion')
def __init__(self, parent=None, **kwargs):
optiondefs = (
('frameSize', (-0.5, 0.5, -0.5, 0.5), None),
('tabClickOffsetColor', Vec4(0.1, 0.1, 0.1, 0), None),
('tabRolloverOffsetColor', Vec4(0.1, 0.1, 0.1, 0), None),
('tabInactiveColor', Vec4(0.2, 0.2, 0.2, 1), None),
('tabUnselectedColor', Vec4(0.7, 0.7, 0.7, 1), None),
('tabSelectedColor', Vec4(0.4, 0.7, 1.0, 1), None),
('tab_scale', 0.05, None),
('tab_frameSize', (0, 5, 0, 2), None),
('tab_geom_scale', 1, None),
('tabHighlightFrameTexture', None, None),
('tabFrameTexture', None, None),
('tabHighlightGeom', None, None),
('tabGeom', None, None),
)
# Button colours: Selected, unselected, rollover-offset, clicked-offset, inactive
if "scrollFrameConstructor" in kwargs:
self.scrollFrameConstructor = kwargs["scrollFrameConstructor"]
del kwargs["scrollFrameConstructor"]
else:
self.scrollFrameConstructor = None #type(DirectScrolledFrame)
if "pageChangeCallback" in kwargs:
self.pageChangeCallback = kwargs["pageChangeCallback"]
del kwargs["pageChangeCallback"]
else:
self.pageChangeCallback = None #type(DirectScrolledFrame)
viewingArgs = {}
for key, arg in list(kwargs.items()):
if key.startswith("scroll_"):
key = key[7:]
viewingArgs[key] = arg
for key in viewingArgs:
del kwargs["scroll_" + key]
if not "canvasSize" in viewingArgs:
viewingArgs["canvasSize"] = (0, 0, 0, 0)
self.defineoptions(kwargs, optiondefs)
DirectFrame.__init__(self, parent)
if self.scrollFrameConstructor is not None:
self.viewingArea = self.scrollFrameConstructor(parent=self,
**viewingArgs)
else:
self.viewingArea = DirectScrolledFrame(parent=self, **viewingArgs)
self.pages = []
self.pageButtons = []
self.currentPageIndex = -1
self.tabArgs = {}
for key, arg in self._constructorKeywords.items():
if key.startswith("tab_") and \
not key.endswith("highlightGeom") and \
not key.endswith("unselectedColor") and \
not key.endswith("selectedColor") and \
not key.endswith("highlightFrameTexture") and \
not key.endswith("highlightGeom"):
self.tabArgs[key[4:]] = arg[0]
self.addPage(DirectFrame(), "<stand-in>")
self.initialiseoptions(TabbedFrame)
def __init__( self
, pos = ( -.5, .5)
, title = 'Title'
, bgColor = (.5,.5,.5,1)
, buttonColor = (1,1,1,1) #( .6, .6, .6, 1 )
#, minSize = ( .5, .5 )
#, maxSize = ( 1, 1 )
, minWindowSize = (0,0)
, maxWindowSize = (10000,10000)
, virtualSize = (1,1)
, windowBorderTextureFiles = [ DEFAULT_TITLE_TEXTURE_LEFT
, DEFAULT_TITLE_TEXTURE_CENTER
, DEFAULT_TITLE_TEXTURE_RIGHT
, DEFAULT_RESIZE_GEOM ]
, windowBorderGeomFiles = [ DEFAULT_TITLE_GEOM_RIGHT ]
, windowColors = [ ( 1, 1, 1, 1 )
, ( 1, 1, 1, 1 )
, ( 1, 1, 1, 1 )
, ( 1, 1, 1, 1 ) ]
, borderSize = 0.01
, dragbarSize = 0.05
, parent=None):
self.windowPos = pos
self.minWindowSize = minWindowSize
self.maxWindowSize = maxWindowSize
self.virtualSize = virtualSize
self.borderSize = borderSize
self.dragbarSize = dragbarSize
if parent is None:
parent=aspect2d
self.parent=parent
self.previousSize = (10,10)
self.collapsed = False
# maybe we should check if aspect2d doesnt already contain the aspect2dMouseNode
self.mouseNode = self.parent.attachNewNode( 'aspect2dMouseNode', sort = 999999 )
taskMgr.add( self.mouseNodeTask, 'mouseNodeTask' )
windowBorderTextures = list()
for windowBorder in windowBorderTextureFiles:
if windowBorder is not None:
mdlFile = loader.loadTexture(windowBorder)
windowBorderTextures.append(mdlFile)
else:
windowBorderTextures.append(None)
windowBorderGeoms = list()
for windowGeom in windowBorderGeomFiles:
if windowGeom is not None:
mdlFile = loader.loadModel(windowGeom)
mdls = ( mdlFile.find('**/**-default'),
mdlFile.find('**/**-click'),
mdlFile.find('**/**-rollover'),
mdlFile.find('**/**-disabled') )
windowBorderGeoms.append(mdls)
else:
windowBorderGeoms.append((None,None,None,None,),)
# the main window we want to move around
self.parentWindow = DirectFrame(
parent=self.parent, pos=(self.windowPos[0], 0, self.windowPos[1]),
#frameSize=# is defined in resize
scale=(1, 1, -1),
frameColor=bgColor,
borderWidth=(0, 0), relief=DGG.FLAT, sortOrder=1, )
# header of the window (drag&drop with it)
# the title part of the window, drag around to move the window
self.headerParent = DirectButton(
parent=self.parentWindow, pos=(0, 0, 0),
#frameSize=# is defined in resize
scale=(1, 1, self.dragbarSize),
frameColor=(1, 1, 1, 1),
borderWidth=(0, 0), relief=DGG.FLAT, )
self.headerParent.bind(DGG.B1PRESS,self.startWindowDrag)
# images in the headerParent
self.headerCenter = DirectFrame(
parent=self.headerParent, pos=(0, 0, 1),
#frameSize=# is defined in resize
scale=(1,1,-1),
frameColor=windowColors[1], frameTexture=windowBorderTextures[1],
borderWidth=(0, 0), relief=DGG.FLAT, )
self.headerLeft = DirectFrame(
parent=self.headerParent, pos=(0, 0, 1),
frameSize=(0, self.dragbarSize, 0, 1), scale=(1,1,-1),
frameColor=windowColors[0], frameTexture=windowBorderTextures[0],
borderWidth=(0, 0), relief=DGG.FLAT, )
# collapse button
self.headerRight = DirectButton(
parent=self.headerParent, #pos=# is defined in resize
frameSize=(0, self.dragbarSize, 0, 1), scale=(1,1,-1),
frameColor=windowColors[2], #frameTexture=windowBorderTextures[2],
borderWidth=(0, 0), relief=DGG.FLAT,
command=self.toggleCollapsed,
geom=windowBorderGeoms[0], geom_scale=(self.dragbarSize,1,1) )
# the resize button of the window
self.resizeButton = DirectButton(
parent=self.parentWindow, pos=(1-self.dragbarSize, 0, 1),
frameSize=(0, 1, 0, 1), scale=(self.dragbarSize,1,-self.dragbarSize),
frameColor=windowColors[3], frameTexture=windowBorderTextures[3],
borderWidth=(0, 0), relief=DGG.FLAT, sortOrder=1, )
self.resizeButton.bind(DGG.B1PRESS,self.startResizeDrag)
# text in the center of the window
text = TextNode('WindowTitleTextNode')
text.setText(title)
text.setAlign(TextNode.ACenter)
text.setTextColor( 0, 0, 0, 1 )
text.setShadow(0.05, 0.05)
text.setShadowColor( 1, 1, 1, 1 )
self.textNodePath = self.headerCenter.attachNewNode(text)
self.textNodePath.setPos(.5,0,.3)
self.textNodePath.setScale(0.8*self.dragbarSize,1,0.8)
if Y_INVERTED:
scale = (1,1,-1)
else:
scale = (1,1,1)
# the content part of the window, put stuff beneath
# contentWindow.getCanvas() to put it into it
self.contentWindow = DirectScrolledFrame(
parent = self.parentWindow,
#pos = # is defined in resize
scale = scale,
canvasSize = (0,self.virtualSize[0],0,self.virtualSize[1]),
frameColor = buttonColor,
relief = DGG.RAISED,
borderWidth = (0,0),
verticalScroll_frameSize = [0,self.dragbarSize,0,1],
verticalScroll_frameTexture = loader.loadTexture( 'rightBorder.png' ),
verticalScroll_incButton_frameTexture = loader.loadTexture( 'scrollDown.png' ),
verticalScroll_decButton_frameTexture = loader.loadTexture( 'scrollDown.png' ),
verticalScroll_thumb_frameTexture = loader.loadTexture( 'scrollBar.png' ),
horizontalScroll_frameSize = [0,1,0,self.dragbarSize],
horizontalScroll_frameTexture = loader.loadTexture( 'bottomBorder.png' ),
horizontalScroll_incButton_frameTexture = loader.loadTexture( 'scrollDown.png' ),
horizontalScroll_decButton_frameTexture = loader.loadTexture( 'scrollDown.png' ),
horizontalScroll_thumb_frameTexture = loader.loadTexture( 'scrollBar.png' ),
)
# child we attach should be inside the window
DirectFrame.__init__( self,
parent = self.contentWindow.getCanvas(),
pos = (0,0,self.virtualSize[1]),
scale = (1,1,1),
frameSize = ( 0, self.virtualSize[0]+2*self.borderSize, 0, self.virtualSize[1] ),
#frameColor = (0,0,0,1),
relief = DGG.RIDGE,
borderWidth = (0,0),
)
self.initialiseoptions(DirectWindow)
# offset then clicking on the resize button from the mouse to the resizebutton
# position, required to calculate the position / scaling
self.offset = None
self.resizeButtonTaskName = "resizeTask-%s" % str(hash(self))
# do sizing of the window to virtualSize
#self.resize( self.virtualSize[0]+2*self.borderSize
# , self.virtualSize[1]+self.dragbarSize+2*self.borderSize )
self.resize(10,10)
