def __init__(self, parent = None, **kw):
optiondefs = (('pgFunc', PGEntry, None),
('numStates', 3, None),
('state', DGG.NORMAL, None),
('entryFont', None, DGG.INITOPT),
('width', 10, self.setup),
('numLines', 1, self.setup),
('focus', 0, self.setFocus),
('cursorKeys', 1, self.setCursorKeysActive),
('obscured', 0, self.setObscureMode),
('backgroundFocus', 0, self.setBackgroundFocus),
('initialText', '', DGG.INITOPT),
('command', None, None),
('extraArgs', [], None),
('failedCommand', None, None),
('failedExtraArgs', [], None),
('focusInCommand', None, None),
('focusInExtraArgs', [], None),
('focusOutCommand', None, None),
('focusOutExtraArgs', [], None),
('rolloverSound', DGG.getDefaultRolloverSound(), self.setRolloverSound),
('clickSound', DGG.getDefaultClickSound(), self.setClickSound),
('autoCapitalize', 0, self.autoCapitalizeFunc),
('autoCapitalizeAllowPrefixes', DirectEntry.AllowCapNamePrefixes, None),
('autoCapitalizeForcePrefixes', DirectEntry.ForceCapNamePrefixes, None))
self.defineoptions(kw, optiondefs)
DirectFrame.__init__(self, parent)
if self['entryFont'] == None:
font = DGG.getDefaultFont()
else:
font = self['entryFont']
self.onscreenText = self.createcomponent('text', (), None, OnscreenText, (), parent=hidden, text='', align=TextNode.ALeft, font=font, scale=1, mayChange=1)
self.onscreenText.removeNode()
self.bind(DGG.ACCEPT, self.commandFunc)
self.bind(DGG.ACCEPTFAILED, self.failedCommandFunc)
self.accept(self.guiItem.getFocusInEvent(), self.focusInCommandFunc)
self.accept(self.guiItem.getFocusOutEvent(), self.focusOutCommandFunc)
self._autoCapListener = DirectObject()
self.initialiseoptions(DirectEntry)
if not hasattr(self, 'autoCapitalizeAllowPrefixes'):
self.autoCapitalizeAllowPrefixes = DirectEntry.AllowCapNamePrefixes
if not hasattr(self, 'autoCapitalizeForcePrefixes'):
self.autoCapitalizeForcePrefixes = DirectEntry.ForceCapNamePrefixes
for i in range(self['numStates']):
self.guiItem.setTextDef(i, self.onscreenText.textNode)
self.setup()
self.unicodeText = 0
if self['initialText']:
self.enterText(self['initialText'])
return None
def __init__(self, text = '', style = Plain, pos = (0, 0), roll = 0, scale = None, fg = None, bg = None, shadow = None, shadowOffset = (0.040000000000000001, 0.040000000000000001), frame = None, align = None, wordwrap = None, drawOrder = None, decal = 0, font = None, parent = None, sort = 0, mayChange = True):
if parent == None:
parent = aspect2d
textNode = TextNode('')
self.textNode = textNode
NodePath.__init__(self)
if style == Plain:
if not scale:
pass
scale = 0.070000000000000007
if not fg:
pass
fg = (0, 0, 0, 1)
if not bg:
pass
bg = (0, 0, 0, 0)
if not shadow:
pass
shadow = (0, 0, 0, 0)
if not frame:
pass
frame = (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
elif style == ScreenTitle:
if not scale:
pass
scale = 0.14999999999999999
if not fg:
pass
fg = (1, 0.20000000000000001, 0.20000000000000001, 1)
if not bg:
pass
bg = (0, 0, 0, 0)
if not shadow:
pass
shadow = (0, 0, 0, 1)
if not frame:
pass
frame = (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
elif style == ScreenPrompt:
if not scale:
pass
scale = 0.10000000000000001
if not fg:
pass
fg = (1, 1, 0, 1)
if not bg:
pass
bg = (0, 0, 0, 0)
if not shadow:
pass
shadow = (0, 0, 0, 1)
if not frame:
pass
frame = (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
elif style == NameConfirm:
if not scale:
pass
scale = 0.10000000000000001
if not fg:
pass
fg = (0, 1, 0, 1)
if not bg:
pass
bg = (0, 0, 0, 0)
if not shadow:
pass
shadow = (0, 0, 0, 0)
if not frame:
pass
frame = (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
elif style == BlackOnWhite:
if not scale:
pass
scale = 0.10000000000000001
if not fg:
pass
fg = (0, 0, 0, 1)
if not bg:
pass
bg = (1, 1, 1, 1)
if not shadow:
pass
shadow = (0, 0, 0, 0)
if not frame:
pass
frame = (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
else:
raise ValueError
if not isinstance(scale, types.TupleType):
scale = (scale, scale)
self.scale = scale
self.pos = pos
self.roll = roll
self.wordwrap = wordwrap
if decal:
textNode.setCardDecal(1)
if font == None:
font = DGG.getDefaultFont()
textNode.setFont(font)
textNode.setTextColor(fg[0], fg[1], fg[2], fg[3])
textNode.setAlign(align)
if wordwrap:
textNode.setWordwrap(wordwrap)
if bg[3] != 0:
textNode.setCardColor(bg[0], bg[1], bg[2], bg[3])
textNode.setCardAsMargin(0.10000000000000001, 0.10000000000000001, 0.10000000000000001, 0.10000000000000001)
if shadow[3] != 0:
textNode.setShadowColor(shadow[0], shadow[1], shadow[2], shadow[3])
textNode.setShadow(*shadowOffset)
if frame[3] != 0:
textNode.setFrameColor(frame[0], frame[1], frame[2], frame[3])
textNode.setFrameAsMargin(0.10000000000000001, 0.10000000000000001, 0.10000000000000001, 0.10000000000000001)
self.updateTransformMat()
if drawOrder != None:
textNode.setBin('fixed')
textNode.setDrawOrder(drawOrder)
self.setText(text)
if not text:
self.mayChange = 1
else:
self.mayChange = mayChange
if not self.mayChange:
self.textNode = textNode.generate()
self.isClean = 0
self.assign(parent.attachNewNode(self.textNode, sort))
def __init__(self, parent=None, **kw):
# Inherits from DirectFrame
# A Direct Frame can have:
# - A background texture (pass in path to image, or Texture Card)
# - A midground geometry item (pass in geometry)
# - A foreground text Node (pass in text string or Onscreen Text)
# For a direct entry:
# Each button has 3 states (focus, noFocus, disabled)
# The same image/geom/text can be used for all three states or each
# state can have a different text/geom/image
# State transitions happen automatically based upon mouse interaction
optiondefs = (
# Define type of DirectGuiWidget
('pgFunc', PGEntry, None),
('numStates', 3, None),
('state', DGG.NORMAL, None),
('entryFont', None, DGG.INITOPT),
('width', 10, self.setup),
('numLines', 1, self.setup),
('focus', 0, self.setFocus),
('cursorKeys', 1, self.setCursorKeysActive),
('obscured', 0, self.setObscureMode),
# Setting backgroundFocus allows the entry box to get keyboard
# events that are not handled by other things (i.e. events that
# fall through to the background):
('backgroundFocus', 0, self.setBackgroundFocus),
# Text used for the PGEntry text node
# NOTE: This overrides the DirectFrame text option
('initialText', '', DGG.INITOPT),
# Command to be called on hitting Enter
('command', None, None),
('extraArgs', [], None),
# Command to be called when enter is hit but we fail to submit
('failedCommand', None, None),
('failedExtraArgs', [], None),
# commands to be called when focus is gained or lost
('focusInCommand', None, None),
('focusInExtraArgs', [], None),
('focusOutCommand', None, None),
('focusOutExtraArgs', [], None),
# Sounds to be used for button events
('rolloverSound', DGG.getDefaultRolloverSound(),
self.setRolloverSound),
('clickSound', DGG.getDefaultClickSound(), self.setClickSound),
('autoCapitalize', 0, self.autoCapitalizeFunc),
('autoCapitalizeAllowPrefixes', DirectEntry.AllowCapNamePrefixes,
None),
('autoCapitalizeForcePrefixes', DirectEntry.ForceCapNamePrefixes,
None),
)
# Merge keyword options with default options
self.defineoptions(kw, optiondefs)
# Initialize superclasses
DirectFrame.__init__(self, parent)
if self['entryFont'] == None:
font = DGG.getDefaultFont()
else:
font = self['entryFont']
# Create Text Node Component
self.onscreenText = self.createcomponent(
'text',
(),
None,
OnscreenText,
(),
parent=hidden,
# Pass in empty text to avoid extra work, since its really
# The PGEntry which will use the TextNode to generate geometry
text='',
align=TextNode.ALeft,
font=font,
scale=1,
# Don't get rid of the text node
mayChange=1)
# We can get rid of the node path since we're just using the
# onscreenText as an easy way to access a text node as a
# component
self.onscreenText.removeNode()
# Bind command function
self.bind(DGG.ACCEPT, self.commandFunc)
self.bind(DGG.ACCEPTFAILED, self.failedCommandFunc)
self.accept(self.guiItem.getFocusInEvent(), self.focusInCommandFunc)
self.accept(self.guiItem.getFocusOutEvent(), self.focusOutCommandFunc)
# listen for auto-capitalize events on a separate object to prevent
# clashing with other parts of the system
self._autoCapListener = DirectObject()
# Call option initialization functions
self.initialiseoptions(DirectEntry)
if not hasattr(self, 'autoCapitalizeAllowPrefixes'):
self.autoCapitalizeAllowPrefixes = DirectEntry.AllowCapNamePrefixes
if not hasattr(self, 'autoCapitalizeForcePrefixes'):
self.autoCapitalizeForcePrefixes = DirectEntry.ForceCapNamePrefixes
# Update TextNodes for each state
for i in range(self['numStates']):
self.guiItem.setTextDef(i, self.onscreenText.textNode)
# Now we should call setup() again to make sure it has the
# right font def.
self.setup()
# Update initial text
self.unicodeText = 0
if self['initialText']:
self.enterText(self['initialText'])
def __init__(self, parent = None, **kw):
# Inherits from DirectFrame
# A Direct Frame can have:
# - A background texture (pass in path to image, or Texture Card)
# - A midground geometry item (pass in geometry)
# - A foreground text Node (pass in text string or Onscreen Text)
# For a direct entry:
# Each button has 3 states (focus, noFocus, disabled)
# The same image/geom/text can be used for all three states or each
# state can have a different text/geom/image
# State transitions happen automatically based upon mouse interaction
optiondefs = (
# Define type of DirectGuiWidget
('pgFunc', PGEntry, None),
('numStates', 3, None),
('state', DGG.NORMAL, None),
('entryFont', None, DGG.INITOPT),
('width', 10, self.setup),
('numLines', 1, self.setup),
('focus', 0, self.setFocus),
('cursorKeys', 1, self.setCursorKeysActive),
('obscured', 0, self.setObscureMode),
# Setting backgroundFocus allows the entry box to get keyboard
# events that are not handled by other things (i.e. events that
# fall through to the background):
('backgroundFocus', 0, self.setBackgroundFocus),
# Text used for the PGEntry text node
# NOTE: This overrides the DirectFrame text option
('initialText', '', DGG.INITOPT),
# Command to be called on hitting Enter
('command', None, None),
('extraArgs', [], None),
# Command to be called when enter is hit but we fail to submit
('failedCommand', None, None),
('failedExtraArgs',[], None),
# commands to be called when focus is gained or lost
('focusInCommand', None, None),
('focusInExtraArgs', [], None),
('focusOutCommand', None, None),
('focusOutExtraArgs', [], None),
# Sounds to be used for button events
('rolloverSound', DGG.getDefaultRolloverSound(), self.setRolloverSound),
('clickSound', DGG.getDefaultClickSound(), self.setClickSound),
('autoCapitalize', 0, self.autoCapitalizeFunc),
('autoCapitalizeAllowPrefixes', DirectEntry.AllowCapNamePrefixes, None),
('autoCapitalizeForcePrefixes', DirectEntry.ForceCapNamePrefixes, None),
)
# Merge keyword options with default options
self.defineoptions(kw, optiondefs)
# Initialize superclasses
DirectFrame.__init__(self, parent)
if self['entryFont'] == None:
font = DGG.getDefaultFont()
else:
font = self['entryFont']
# Create Text Node Component
self.onscreenText = self.createcomponent(
'text', (), None,
OnscreenText,
(), parent = hidden,
# Pass in empty text to avoid extra work, since its really
# The PGEntry which will use the TextNode to generate geometry
text = '',
align = TextNode.ALeft,
font = font,
scale = 1,
# Don't get rid of the text node
mayChange = 1)
# We can get rid of the node path since we're just using the
# onscreenText as an easy way to access a text node as a
# component
self.onscreenText.removeNode()
# Bind command function
self.bind(DGG.ACCEPT, self.commandFunc)
self.bind(DGG.ACCEPTFAILED, self.failedCommandFunc)
self.accept(self.guiItem.getFocusInEvent(), self.focusInCommandFunc)
self.accept(self.guiItem.getFocusOutEvent(), self.focusOutCommandFunc)
# listen for auto-capitalize events on a separate object to prevent
# clashing with other parts of the system
self._autoCapListener = DirectObject()
# Call option initialization functions
self.initialiseoptions(DirectEntry)
if not hasattr(self, 'autoCapitalizeAllowPrefixes'):
self.autoCapitalizeAllowPrefixes = DirectEntry.AllowCapNamePrefixes
if not hasattr(self, 'autoCapitalizeForcePrefixes'):
self.autoCapitalizeForcePrefixes = DirectEntry.ForceCapNamePrefixes
# Update TextNodes for each state
for i in range(self['numStates']):
self.guiItem.setTextDef(i, self.onscreenText.textNode)
# Now we should call setup() again to make sure it has the
# right font def.
self.setup()
# Update initial text
self.unicodeText = 0
if self['initialText']:
self.enterText(self['initialText'])
def __init__(self, text = '',
style = Plain,
pos = (0, 0),
roll = 0,
scale = None,
fg = None,
bg = None,
shadow = None,
shadowOffset = (0.04, 0.04),
frame = None,
align = None,
wordwrap = None,
drawOrder = None,
decal = 0,
font = None,
parent = None,
sort = 0,
mayChange = True):
"""
Make a text node from string, put it into the 2d sg and set it
up with all the indicated parameters.
The parameters are as follows:
text: the actual text to display. This may be omitted and
specified later via setText() if you don't have it
available, but it is better to specify it up front.
style: one of the pre-canned style parameters defined at the
head of this file. This sets up the default values for
many of the remaining parameters if they are
unspecified; however, a parameter may still be specified
to explicitly set it, overriding the pre-canned style.
pos: the x, y position of the text on the screen.
scale: the size of the text. This may either be a single
float (and it will usually be a small number like 0.07)
or it may be a 2-tuple of floats, specifying a different
x, y scale.
fg: the (r, g, b, a) foreground color of the text. This is
normally a 4-tuple of floats or ints.
bg: the (r, g, b, a) background color of the text. If the
fourth value, a, is nonzero, a card is created to place
behind the text and set to the given color.
shadow: the (r, g, b, a) color of the shadow behind the text.
If the fourth value, a, is nonzero, a little drop shadow
is created and placed behind the text.
frame: the (r, g, b, a) color of the frame drawn around the
text. If the fourth value, a, is nonzero, a frame is
created around the text.
align: one of TextNode.ALeft, TextNode.ARight, or TextNode.ACenter.
wordwrap: either the width to wordwrap the text at, or None
to specify no automatic word wrapping.
drawOrder: the drawing order of this text with respect to
all other things in the 'fixed' bin within render2d.
The text will actually use drawOrder through drawOrder +
2.
decal: if this is True, the text is decalled onto its
background card. Useful when the text will be parented
into the 3-D scene graph.
font: the font to use for the text.
parent: the NodePath to parent the text to initially.
mayChange: pass true if the text or its properties may need
to be changed at runtime, false if it is static once
created (which leads to better memory optimization).
"""
if parent == None:
parent = aspect2d
# make a text node
textNode = TextNode('')
self.textNode = textNode
# We ARE a node path. Initially, we're an empty node path.
NodePath.__init__(self)
# Choose the default parameters according to the selected
# style.
if style == Plain:
scale = scale or 0.07
fg = fg or (0, 0, 0, 1)
bg = bg or (0, 0, 0, 0)
shadow = shadow or (0, 0, 0, 0)
frame = frame or (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
elif style == ScreenTitle:
scale = scale or 0.15
fg = fg or (1, 0.2, 0.2, 1)
bg = bg or (0, 0, 0, 0)
shadow = shadow or (0, 0, 0, 1)
frame = frame or (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
elif style == ScreenPrompt:
scale = scale or 0.1
fg = fg or (1, 1, 0, 1)
bg = bg or (0, 0, 0, 0)
shadow = shadow or (0, 0, 0, 1)
frame = frame or (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
elif style == NameConfirm:
scale = scale or 0.1
fg = fg or (0, 1, 0, 1)
bg = bg or (0, 0, 0, 0)
shadow = shadow or (0, 0, 0, 0)
frame = frame or (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
elif style == BlackOnWhite:
scale = scale or 0.1
fg = fg or (0, 0, 0, 1)
bg = bg or (1, 1, 1, 1)
shadow = shadow or (0, 0, 0, 0)
frame = frame or (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
else:
raise ValueError
if not isinstance(scale, types.TupleType):
# If the scale is already a tuple, it's a 2-d (x, y) scale.
# Otherwise, it's a uniform scale--make it a tuple.
scale = (scale, scale)
# Save some of the parameters for posterity.
self.scale = scale
self.pos = pos
self.roll = roll
self.wordwrap = wordwrap
if decal:
textNode.setCardDecal(1)
if font == None:
font = DGG.getDefaultFont()
textNode.setFont(font)
textNode.setTextColor(fg[0], fg[1], fg[2], fg[3])
textNode.setAlign(align)
if wordwrap:
textNode.setWordwrap(wordwrap)
if bg[3] != 0:
# If we have a background color, create a card.
textNode.setCardColor(bg[0], bg[1], bg[2], bg[3])
textNode.setCardAsMargin(0.1, 0.1, 0.1, 0.1)
if shadow[3] != 0:
# If we have a shadow color, create a shadow.
# Can't use the *shadow interface because it might be a VBase4.
#textNode.setShadowColor(*shadow)
textNode.setShadowColor(shadow[0], shadow[1], shadow[2], shadow[3])
textNode.setShadow(*shadowOffset)
if frame[3] != 0:
# If we have a frame color, create a frame.
textNode.setFrameColor(frame[0], frame[1], frame[2], frame[3])
textNode.setFrameAsMargin(0.1, 0.1, 0.1, 0.1)
# Create a transform for the text for our scale and position.
# We'd rather do it here, on the text itself, rather than on
# our NodePath, so we have one fewer transforms in the scene
# graph.
self.updateTransformMat()
if drawOrder != None:
textNode.setBin('fixed')
textNode.setDrawOrder(drawOrder)
self.setText(text)
if not text:
# If we don't have any text, assume we'll be changing it later.
self.mayChange = 1
else:
self.mayChange = mayChange
# Ok, now update the node.
if not self.mayChange:
# If we aren't going to change the text later, we can
# throw away the TextNode.
self.textNode = textNode.generate()
self.isClean = 0
# Set ourselves up as the NodePath that points to this node.
self.assign(parent.attachNewNode(self.textNode, sort))
def __init__(self, parent=None, **kw):
optiondefs = (
(
'pgFunc', PGEntry, None),
('numStates', 3, None),
(
'state', DGG.NORMAL, None),
(
'entryFont', None, DGG.INITOPT),
(
'width', 10, self.setup),
(
'numLines', 1, self.setup),
(
'focus', 0, self.setFocus),
(
'cursorKeys', 1, self.setCursorKeysActive),
(
'obscured', 0, self.setObscureMode),
(
'backgroundFocus', 0, self.setBackgroundFocus),
(
'initialText', '', DGG.INITOPT),
('command', None, None),
(
'extraArgs', [], None),
('failedCommand', None, None),
(
'failedExtraArgs', [], None),
('focusInCommand', None, None),
(
'focusInExtraArgs', [], None),
('focusOutCommand', None, None),
(
'focusOutExtraArgs', [], None),
(
'rolloverSound', DGG.getDefaultRolloverSound(), self.setRolloverSound),
(
'clickSound', DGG.getDefaultClickSound(), self.setClickSound),
(
'autoCapitalize', 0, self.autoCapitalizeFunc),
(
'autoCapitalizeAllowPrefixes', DirectEntry.AllowCapNamePrefixes, None),
(
'autoCapitalizeForcePrefixes', DirectEntry.ForceCapNamePrefixes, None))
self.defineoptions(kw, optiondefs)
DirectFrame.__init__(self, parent)
if self['entryFont'] == None:
font = DGG.getDefaultFont()
else:
font = self['entryFont']
self.onscreenText = self.createcomponent('text', (), None, OnscreenText, (), parent=hidden, text='', align=TextNode.ALeft, font=font, scale=1, mayChange=1)
self.onscreenText.removeNode()
self.bind(DGG.ACCEPT, self.commandFunc)
self.bind(DGG.ACCEPTFAILED, self.failedCommandFunc)
self.accept(self.guiItem.getFocusInEvent(), self.focusInCommandFunc)
self.accept(self.guiItem.getFocusOutEvent(), self.focusOutCommandFunc)
self._autoCapListener = DirectObject()
self.initialiseoptions(DirectEntry)
if not hasattr(self, 'autoCapitalizeAllowPrefixes'):
self.autoCapitalizeAllowPrefixes = DirectEntry.AllowCapNamePrefixes
if not hasattr(self, 'autoCapitalizeForcePrefixes'):
self.autoCapitalizeForcePrefixes = DirectEntry.ForceCapNamePrefixes
for i in range(self['numStates']):
self.guiItem.setTextDef(i, self.onscreenText.textNode)
self.setup()
self.unicodeText = 0
if self['initialText']:
self.enterText(self['initialText'])
return
def __init__(
self,
text="",
style=Plain,
pos=(0, 0),
scale=None,
fg=None,
bg=None,
shadow=None,
shadowOffset=(0.040000000000000001, 0.040000000000000001),
frame=None,
align=None,
wordwrap=None,
drawOrder=None,
font=None,
parent=None,
sort=0,
mayChange=0,
):
if parent == None:
parent = aspect2d
textNode = TextNode("")
self.textNode = textNode
NodePath.__init__(self)
if style == Plain:
if not scale:
pass
scale = 0.070000000000000007
if not fg:
pass
fg = (0, 0, 0, 1)
if not bg:
pass
bg = (0, 0, 0, 0)
if not shadow:
pass
shadow = (0, 0, 0, 0)
if not frame:
pass
frame = (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
elif style == ScreenTitle:
if not scale:
pass
scale = 0.14999999999999999
if not fg:
pass
fg = (1, 0.20000000000000001, 0.20000000000000001, 1)
if not bg:
pass
bg = (0, 0, 0, 0)
if not shadow:
pass
shadow = (0, 0, 0, 1)
if not frame:
pass
frame = (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
elif style == ScreenPrompt:
if not scale:
pass
scale = 0.10000000000000001
if not fg:
pass
fg = (1, 1, 0, 1)
if not bg:
pass
bg = (0, 0, 0, 0)
if not shadow:
pass
shadow = (0, 0, 0, 1)
if not frame:
pass
frame = (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
elif style == NameConfirm:
if not scale:
pass
scale = 0.10000000000000001
if not fg:
pass
fg = (0, 1, 0, 1)
if not bg:
pass
bg = (0, 0, 0, 0)
if not shadow:
pass
shadow = (0, 0, 0, 0)
if not frame:
pass
frame = (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
elif style == BlackOnWhite:
if not scale:
pass
scale = 0.10000000000000001
if not fg:
pass
fg = (0, 0, 0, 1)
if not bg:
pass
bg = (1, 1, 1, 1)
if not shadow:
pass
shadow = (0, 0, 0, 0)
if not frame:
pass
frame = (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
else:
raise ValueError
if not isinstance(scale, types.TupleType):
scale = (scale, scale)
self.scale = scale
self.pos = pos
if font == None:
font = DirectGuiGlobals.getDefaultFont()
textNode.freeze()
textNode.setFont(font)
textNode.setTextColor(fg[0], fg[1], fg[2], fg[3])
textNode.setAlign(align)
if wordwrap:
textNode.setWordwrap(wordwrap)
if bg[3] != 0:
textNode.setCardColor(bg[0], bg[1], bg[2], bg[3])
textNode.setCardAsMargin(0.10000000000000001, 0.10000000000000001, 0.10000000000000001, 0.10000000000000001)
if shadow[3] != 0:
textNode.setShadowColor(shadow[0], shadow[1], shadow[2], shadow[3])
textNode.setShadow(*shadowOffset)
if frame[3] != 0:
textNode.setFrameColor(frame[0], frame[1], frame[2], frame[3])
textNode.setFrameAsMargin(
0.10000000000000001, 0.10000000000000001, 0.10000000000000001, 0.10000000000000001
)
mat = Mat4.scaleMat(scale[0], 1, scale[1]) * Mat4.translateMat(pos[0], 0, pos[1])
textNode.setTransform(mat)
if drawOrder != None:
textNode.setBin("fixed")
textNode.setDrawOrder(drawOrder)
textNode.setText(text)
if not text:
self.mayChange = 1
else:
self.mayChange = mayChange
if self.mayChange:
textNode.thaw()
else:
self.textNode = textNode.generate()
self.isClean = 0
self.assign(parent.attachNewNode(self.textNode, sort))
def __init__(self, text='', style=Plain, pos=(0, 0), scale=None, fg=None, bg=None, shadow=None, shadowOffset=(0.04, 0.04), frame=None, align=None, wordwrap=None, drawOrder=None, font=None, parent=None, sort=0, mayChange=0):
if parent == None:
parent = aspect2d
textNode = TextNode('')
self.textNode = textNode
NodePath.__init__(self)
if style == Plain:
scale = scale or 0.07
fg = fg or (0, 0, 0, 1)
bg = bg or (0, 0, 0, 0)
shadow = shadow or (0, 0, 0, 0)
frame = frame or (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
else:
if style == ScreenTitle:
scale = scale or 0.15
fg = fg or (1, 0.2, 0.2, 1)
bg = bg or (0, 0, 0, 0)
shadow = shadow or (0, 0, 0, 1)
frame = frame or (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
else:
if style == ScreenPrompt:
scale = scale or 0.1
fg = fg or (1, 1, 0, 1)
bg = bg or (0, 0, 0, 0)
shadow = shadow or (0, 0, 0, 1)
frame = frame or (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
else:
if style == NameConfirm:
scale = scale or 0.1
fg = fg or (0, 1, 0, 1)
bg = bg or (0, 0, 0, 0)
shadow = shadow or (0, 0, 0, 0)
frame = frame or (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
else:
if style == BlackOnWhite:
scale = scale or 0.1
fg = fg or (0, 0, 0, 1)
bg = bg or (1, 1, 1, 1)
shadow = shadow or (0, 0, 0, 0)
frame = frame or (0, 0, 0, 0)
if align == None:
align = TextNode.ACenter
else:
raise ValueError
if not isinstance(scale, types.TupleType):
scale = (
scale, scale)
self.scale = scale
self.pos = pos
if font == None:
font = DirectGuiGlobals.getDefaultFont()
textNode.freeze()
textNode.setFont(font)
textNode.setTextColor(fg[0], fg[1], fg[2], fg[3])
textNode.setAlign(align)
if wordwrap:
textNode.setWordwrap(wordwrap)
if bg[3] != 0:
textNode.setCardColor(bg[0], bg[1], bg[2], bg[3])
textNode.setCardAsMargin(0.1, 0.1, 0.1, 0.1)
if shadow[3] != 0:
textNode.setShadowColor(shadow[0], shadow[1], shadow[2], shadow[3])
textNode.setShadow(*shadowOffset)
if frame[3] != 0:
textNode.setFrameColor(frame[0], frame[1], frame[2], frame[3])
textNode.setFrameAsMargin(0.1, 0.1, 0.1, 0.1)
mat = Mat4.scaleMat(scale[0], 1, scale[1]) * Mat4.translateMat(pos[0], 0, pos[1])
textNode.setTransform(mat)
if drawOrder != None:
textNode.setBin('fixed')
textNode.setDrawOrder(drawOrder)
textNode.setText(text)
if not text:
self.mayChange = 1
else:
self.mayChange = mayChange
if self.mayChange:
textNode.thaw()
else:
self.textNode = textNode.generate()
self.isClean = 0
self.assign(parent.attachNewNode(self.textNode, sort))
return
