def createGui(self):
self.thicknessOfExternalBorder = 3 # factor related to the border of the entire board
self.thicknessOfInternalBorder = 2 # factor related to the border of every button
self.textFieldWidth = self.winWidth
self.textFieldHeight = 0.2 * ( self.winHeight - 20 ) # -20 because of the Unity upper bar
self.buttonsBoardWidth = self.winWidth - self.thicknessOfExternalBorder * 2 - self.thicknessOfInternalBorder * ( self.numberOfColumns[ 0 ] - 1 )
self.buttonsBoardHeight = ( self.winHeight - 20 ) - self.textFieldHeight - self.thicknessOfExternalBorder * 3 - self.thicknessOfInternalBorder * ( self.numberOfRows[ 0 ] - 1 ) # -20 because of the Unity upper bar
self.mainSizer = wx.BoxSizer( wx.VERTICAL )
self.textField = wx.TextCtrl( self, style = wx.TE_LEFT, size = ( self.textFieldWidth, self.textFieldHeight ) )
self.textField.SetFont( wx.Font( 60, wx.SWISS, wx.NORMAL, wx.NORMAL ) )
self.mainSizer.Add( self.textField, flag = wx.EXPAND | wx.TOP | wx.BOTTOM, border = self.thicknessOfExternalBorder )
self.subSizers = [ ]
subSizer = wx.GridBagSizer( 3, 3 )
for index_1, item in enumerate( self.labels[ 0 ][ :-7 ] ):
b = bt.GenButton( self, -1, item, name = item, size = ( self.buttonsBoardWidth / float( self.numberOfColumns[ 0 ] ), self.buttonsBoardHeight / float( self.numberOfRows[ 0 ] ) ) )
b.SetFont( wx.Font( 35, wx.FONTFAMILY_ROMAN, wx.FONTWEIGHT_LIGHT, False ) )
b.SetBezelWidth( 3 )
b.SetBackgroundColour( self.backgroundColour )
b.SetForegroundColour( self.textColour )
b.Bind( wx.EVT_LEFT_DOWN, self.onPress )
subSizer.Add( b, ( index_1 / self.numberOfColumns[ 0 ], index_1 % self.numberOfColumns[ 0 ] ), wx.DefaultSpan, wx.EXPAND )
for index_2, item in enumerate( self.labels[ 0 ][ -7 : -3 ], start = 1 ):
b = bt.GenBitmapButton( self, -1, bitmap = self.labelBitmaps[ item ], size = ( self.buttonsBoardWidth / float( self.numberOfColumns[ 0 ] ), self.buttonsBoardHeight / float( self.numberOfRows[ 0 ] ) ) )
b.SetBackgroundColour( self.backgroundColour )
b.SetBezelWidth( 3 )
b.Bind( wx.EVT_LEFT_DOWN, self.onPress )
subSizer.Add( b, ( ( index_1 + index_2 ) / self.numberOfColumns[ 0 ], ( index_1 + index_2 ) % self.numberOfColumns[ 0 ] ), wx.DefaultSpan, wx.EXPAND )
for item in ( self.labels[ 0 ][ -3 ], ):
b = bt.GenButton( self, -1, item, name = item, size = ( 3 * ( self.buttonsBoardWidth / float( self.numberOfColumns[ 0 ] ) ), self.buttonsBoardHeight / float( self.numberOfRows[ 0 ] ) ) )
b.SetFont( wx.Font( 35, wx.FONTFAMILY_ROMAN, wx.FONTWEIGHT_LIGHT, False ) )
b.SetBezelWidth( 3 )
b.SetBackgroundColour( self.backgroundColour )
b.SetForegroundColour( self.textColour )
b.Bind( wx.EVT_LEFT_DOWN, self.onPress )
subSizer.Add( b, ( ( index_1 + index_2 ) / self.numberOfColumns[ 0 ], ( index_1 + index_2 + 1 ) % self.numberOfColumns[ 0 ] ), ( 1, 3 ), wx.EXPAND )
for index_3, item in enumerate( self.labels[ 0 ][ -2: ], start = 4 ):
b = bt.GenBitmapButton( self, -1, bitmap = self.labelBitmaps[ item ], size = ( self.buttonsBoardWidth / float( self.numberOfColumns[ 0 ] ), self.buttonsBoardHeight / float( self.numberOfRows[ 0 ] ) ) )
b.SetBackgroundColour( self.backgroundColour )
b.SetBezelWidth( 3 )
b.Bind( wx.EVT_LEFT_DOWN, self.onPress )
subSizer.Add( b, ( ( index_1 + index_2 + index_3 ) / self.numberOfColumns[ 0 ], ( index_1 + index_2 + index_3 ) % self.numberOfColumns[ 0 ] ), wx.DefaultSpan, wx.EXPAND )
self.subSizers.append( subSizer )
self.mainSizer.Add( self.subSizers[ 0 ], proportion = 1, flag = wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, border = self.thicknessOfExternalBorder )
self.SetSizer( self.mainSizer )
self.Center( )
subSizer2 = wx.GridBagSizer( 3, 3 )
for index_1, item in enumerate( self.labels[ 1 ][ :-6 ] ):
b = bt.GenButton( self, -1, item, name = item, size = ( 0.985*self.winWidth / self.numberOfColumns[ 1 ], 0.7 * self.winHeight / self.numberOfRows[ 1 ] ) )
b.SetFont( wx.Font( 35, wx.FONTFAMILY_ROMAN, wx.FONTWEIGHT_LIGHT, False ) )
b.SetBezelWidth( 3 )
b.SetBackgroundColour( self.backgroundColour )
b.SetForegroundColour( self.textColour )
b.Bind( wx.EVT_LEFT_DOWN, self.onPress )
subSizer2.Add( b, ( index_1 / self.numberOfColumns[ 1 ], index_1 % self.numberOfColumns[ 1 ] ), wx.DefaultSpan, wx.EXPAND )
for index_2, item in enumerate( self.labels[ 1 ][ -6 : -3 ], start = 1 ):
b = bt.GenBitmapButton( self, -1, bitmap = self.labelBitmaps2[ item ] )
b.SetBackgroundColour( self.backgroundColour )
b.SetBezelWidth( 3 )
b.Bind( wx.EVT_LEFT_DOWN, self.onPress )
subSizer2.Add( b, ( ( index_1 + index_2 ) / self.numberOfColumns[ 1 ], ( index_1 + index_2 ) % self.numberOfColumns[ 1 ] ), wx.DefaultSpan, wx.EXPAND )
for item in ( self.labels[ 1 ][ -3 ], ):
b = bt.GenButton( self, -1, item, name = item, size = ( 3 * 0.985*self.winWidth / self.numberOfColumns[ 1 ], 0.7 * self.winHeight / self.numberOfRows[ 1 ] ) )
b.SetFont( wx.Font( 35, wx.FONTFAMILY_ROMAN, wx.FONTWEIGHT_LIGHT, False ) )
b.SetBezelWidth( 3 )
b.SetBackgroundColour( self.backgroundColour )
b.SetForegroundColour( self.textColour )
b.Bind( wx.EVT_LEFT_DOWN, self.onPress )
subSizer2.Add( b, ( ( index_1 + index_2 ) / self.numberOfColumns[ 1 ], ( index_1 + index_2 + 1 ) % self.numberOfColumns[ 1 ] ), ( 1, 4 ), wx.EXPAND )
for index_3, item in enumerate( self.labels[ 1 ][ -2: ], start = 5 ):
b = bt.GenBitmapButton( self, -1, bitmap = self.labelBitmaps2[ item ] )
b.SetBackgroundColour( self.backgroundColour )
b.SetBezelWidth( 3 )
b.Bind( wx.EVT_LEFT_DOWN, self.onPress )
subSizer2.Add( b, ( ( index_1 + index_2 + index_3 ) / self.numberOfColumns[ 1 ], ( index_1 + index_2 + index_3 ) % self.numberOfColumns[ 1 ] ), wx.DefaultSpan, wx.EXPAND )
self.subSizers.append( subSizer2 )
self.mainSizer.Add( self.subSizers[ 1 ], proportion = 1, flag = wx.EXPAND )
self.mainSizer.Show( item = self.subSizers[ 1 ], show = False, recursive = True )
self.SetSizer( self.mainSizer )
self.Center( )
def __init__(self, parent):
wx.Dialog.__init__(self, parent, -1, title='About')
about_panel = self
sizer_about = wx.BoxSizer(wx.VERTICAL)
font1 = wx.Font(10, wx.SWISS, wx.NORMAL, wx.FONTWEIGHT_BOLD, False,
u'')
sizer_header = wx.BoxSizer(wx.HORIZONTAL)
logo = bt.GenBitmapButton(about_panel,
-1,
bitmap=wx.Bitmap(ABOUT_ICON),
size=(50, 50),
style=wx.NO_BORDER)
logo.SetBitmapDisabled(wx.Bitmap(ABOUT_ICON))
logo.Disable()
sizer_header.Add(logo)
sizer_header_right = wx.BoxSizer(wx.VERTICAL)
ctrl = wx.StaticText(about_panel,
label='Secure GAppProxy %s' % common.VERSION)
ctrl.SetFont(font1)
sizer_header_right.Add(ctrl)
sizer_copyright = wx.BoxSizer()
sizer_copyright.Add(
wx.StaticText(about_panel, label='Copyright (C) 2011 '))
sizer_copyright.Add(
wx.HyperlinkCtrl(about_panel,
-1,
label='nleven',
url='http://www.nleven.com/'))
sizer_header_right.Add(sizer_copyright, flag=wx.TOP, border=10)
description = """An anti-censorship software running on Google App Engine.
It's a branch of GAppProxy focused on improving security by
utilizing state-of-the-art cryptographic techniques.
"""
sizer_header_right.Add(wx.StaticText(about_panel, label=description),
flag=wx.TOP,
border=10)
sizer_header_right.Add(
wx.HyperlinkCtrl(
about_panel,
-1,
label='Project Home on Google Code',
url='https://code.google.com/p/secure-gappproxy/'))
sizer_header.Add(sizer_header_right, flag=wx.LEFT, border=10)
sizer_about.Add(sizer_header, flag=wx.ALL, border=10)
licence = """LICENCE
Secure GAppProxy is free software: you can redistribute it and/or
modify it under the terms of the GNU General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>."""
sizer_about.Add(wx.StaticText(about_panel, label=licence),
flag=wx.ALL,
border=10)
acknowledgement = """ACKNOWLEDGEMENT
SecureGAppProxy is based on GAppProxy and WallProxy.
Some icons are from www.icons-land.com, Oliver Scholtz and Capital18."""
sizer_about.Add(wx.StaticText(about_panel, label=acknowledgement),
flag=wx.ALL,
border=10)
self.okbtn = wx.Button(about_panel, label='Okay', size=(-1, 35))
self.okbtn.Bind(wx.EVT_BUTTON, self.on_ok)
sizer_about.Add(self.okbtn, flag=wx.ALIGN_CENTER | wx.ALL, border=20)
self.SetSizer(sizer_about)
sizer_about.Fit(self)
self.CenterOnParent()
def createGui(self):
self.mainSizer = wx.BoxSizer(wx.VERTICAL)
self.textField = wx.TextCtrl(self,
style=wx.TE_LEFT,
size=(self.winWidth,
0.2 * self.winHeight))
self.textField.SetFont(wx.Font(60, wx.SWISS, wx.NORMAL, wx.NORMAL))
self.mainSizer.Add(self.textField,
flag=wx.EXPAND | wx.TOP | wx.BOTTOM,
border=3)
self.subSizers = []
subSizer = wx.GridBagSizer(3, 3)
for index_1, item in enumerate(self.labels[0][:-7]):
b = bt.GenButton(
self,
-1,
item,
name=item,
size=(0.985 * self.winWidth / self.numberOfColumns[0],
0.745 * self.winHeight / self.numberOfRows[0]))
b.SetFont(
wx.Font(35, wx.FONTFAMILY_ROMAN, wx.FONTWEIGHT_LIGHT, False))
b.SetBezelWidth(3)
b.SetBackgroundColour(self.backgroundColour)
if item in self.colouredLabels and self.vowelColour != 'False':
b.SetForegroundColour(self.vowelColour)
else:
b.SetForegroundColour(self.textColour)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
subSizer.Add(b, (index_1 / self.numberOfColumns[0],
index_1 % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
for index_2, item in enumerate(self.labels[0][-7:-3], start=1):
b = bt.GenBitmapButton(self, -1, bitmap=self.labelBitmaps[item])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
subSizer.Add(b, ((index_1 + index_2) / self.numberOfColumns[0],
(index_1 + index_2) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
for item in (self.labels[0][-3], ):
b = bt.GenButton(
self,
-1,
item,
name=item,
size=(3 * 0.985 * self.winWidth / self.numberOfColumns[0],
0.745 * self.winHeight / self.numberOfRows[0]))
b.SetFont(
wx.Font(35, wx.FONTFAMILY_ROMAN, wx.FONTWEIGHT_LIGHT, False))
b.SetBezelWidth(3)
b.SetBackgroundColour(self.backgroundColour)
b.SetForegroundColour(self.textColour)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
subSizer.Add(b,
((index_1 + index_2) / self.numberOfColumns[0],
(index_1 + index_2 + 1) % self.numberOfColumns[0]),
(1, 3), wx.EXPAND)
for index_3, item in enumerate(self.labels[0][-2:], start=4):
b = bt.GenBitmapButton(self, -1, bitmap=self.labelBitmaps[item])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
subSizer.Add(
b, ((index_1 + index_2 + index_3) / self.numberOfColumns[0],
(index_1 + index_2 + index_3) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
self.subSizers.append(subSizer)
self.mainSizer.Add(self.subSizers[0], proportion=1, flag=wx.EXPAND)
self.SetSizer(self.mainSizer)
self.Center()
subSizer2 = wx.GridBagSizer(3, 3)
for index_1, item in enumerate(self.labels[1][:-6]):
b = bt.GenButton(
self,
-1,
item,
name=item,
size=(0.985 * self.winWidth / self.numberOfColumns[1],
0.7 * self.winHeight / self.numberOfRows[1]))
b.SetFont(
wx.Font(35, wx.FONTFAMILY_ROMAN, wx.FONTWEIGHT_LIGHT, False))
b.SetBezelWidth(3)
b.SetBackgroundColour(self.backgroundColour)
b.SetForegroundColour(self.textColour)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
subSizer2.Add(b, (index_1 / self.numberOfColumns[1],
index_1 % self.numberOfColumns[1]),
wx.DefaultSpan, wx.EXPAND)
for index_2, item in enumerate(self.labels[1][-6:-3], start=1):
b = bt.GenBitmapButton(self, -1, bitmap=self.labelBitmaps2[item])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
subSizer2.Add(b, ((index_1 + index_2) / self.numberOfColumns[1],
(index_1 + index_2) % self.numberOfColumns[1]),
wx.DefaultSpan, wx.EXPAND)
for item in (self.labels[1][-3], ):
b = bt.GenButton(
self,
-1,
item,
name=item,
size=(3 * 0.985 * self.winWidth / self.numberOfColumns[1],
0.7 * self.winHeight / self.numberOfRows[1]))
b.SetFont(
wx.Font(35, wx.FONTFAMILY_ROMAN, wx.FONTWEIGHT_LIGHT, False))
b.SetBezelWidth(3)
b.SetBackgroundColour(self.backgroundColour)
b.SetForegroundColour(self.textColour)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
subSizer2.Add(b,
((index_1 + index_2) / self.numberOfColumns[1],
(index_1 + index_2 + 1) % self.numberOfColumns[1]),
(1, 4), wx.EXPAND)
for index_3, item in enumerate(self.labels[1][-2:], start=5):
b = bt.GenBitmapButton(self, -1, bitmap=self.labelBitmaps2[item])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
subSizer2.Add(
b, ((index_1 + index_2 + index_3) / self.numberOfColumns[1],
(index_1 + index_2 + index_3) % self.numberOfColumns[1]),
wx.DefaultSpan, wx.EXPAND)
self.subSizers.append(subSizer2)
self.mainSizer.Add(self.subSizers[1], proportion=1, flag=wx.EXPAND)
self.mainSizer.Show(item=self.subSizers[1], show=False, recursive=True)
self.SetSizer(self.mainSizer)
self.Center()
def createGui(self):
self.thicknessOfExternalBorder = self.yBorder # factor related to the border of the entire board
self.thicknessOfInternalBorder = self.xBorder # factor related to the border of every button
self.textFieldWidth = self.winWidth
self.textFieldHeight = 0.2 * (self.winHeight - 20
) # -20 because of the Unity upper bar
self.buttonsBoardWidth = self.winWidth - self.thicknessOfExternalBorder * 2 - self.thicknessOfInternalBorder * (
self.numberOfColumns[0] - 1)
self.buttonsBoardHeight = (
self.winHeight - 20
) - self.textFieldHeight - self.thicknessOfExternalBorder * 3 - self.thicknessOfInternalBorder * (
self.numberOfRows[0] - 1) # -20 because of the Unity upper bar
self.textField = wx.TextCtrl(self.parent,
style=wx.TE_CENTRE | wx.TE_RICH2,
size=(self.textFieldWidth,
self.textFieldHeight))
self.textField.SetFont(
wx.Font(self.textFontSize, eval(self.textFont), wx.NORMAL,
wx.NORMAL))
self.parent.mainSizer.Add(self.textField,
flag=wx.EXPAND | wx.TOP | wx.BOTTOM,
border=self.xBorder)
self.subSizers = []
subSizer = wx.GridBagSizer(self.xBorder, self.yBorder)
if self.control != 'tracker':
event = eval('wx.EVT_LEFT_DOWN')
else:
event = eval('wx.EVT_BUTTON')
for index_1, item in enumerate(self.labels[0][:self.startIndex]):
b = bt.GenButton(
self.parent,
-1,
item,
name=item,
size=(self.buttonsBoardWidth / float(self.numberOfColumns[0]),
self.buttonsBoardHeight / float(self.numberOfRows[0])))
b.SetFont(
wx.Font(self.tableFontSize, eval(self.tableFont),
wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, False))
b.SetBezelWidth(3)
b.SetBackgroundColour(self.backgroundColour)
if item in self.colouredLabels and self.vowelColour != 'False':
b.SetForegroundColour(self.vowelColour)
else:
b.SetForegroundColour(self.textColour)
b.Bind(event, self.onPress)
subSizer.Add(b, (index_1 / self.numberOfColumns[0],
index_1 % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
for index_2, item in enumerate(self.labels[0][self.startIndex:]):
if index_2 == self.spaceButton:
b = bt.GenBitmapButton(
self.parent,
-1,
name=item,
bitmap=self.labelBitmaps[item],
size=(3 * (self.buttonsBoardWidth /
float(self.numberOfColumns[0])),
self.buttonsBoardHeight /
float(self.numberOfRows[0])))
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(event, self.onPress)
subSizer.Add(
b, ((index_1 + index_2 + 1) / self.numberOfColumns[0],
(index_1 + index_2 + 1) % self.numberOfColumns[0]),
(1, 3), wx.EXPAND)
elif index_2 > self.spaceButton:
b = bt.GenBitmapButton(self.parent,
-1,
name=item,
bitmap=self.labelBitmaps[item],
size=(self.buttonsBoardWidth /
float(self.numberOfColumns[0]),
self.buttonsBoardHeight /
float(self.numberOfRows[0])))
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(event, self.onPress)
subSizer.Add(
b, ((index_1 + index_2 + 3) / self.numberOfColumns[0],
(index_1 + index_2 + 3) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
else:
b = bt.GenBitmapButton(self.parent,
-1,
name=item,
bitmap=self.labelBitmaps[item],
size=(self.buttonsBoardWidth /
float(self.numberOfColumns[0]),
self.buttonsBoardHeight /
float(self.numberOfRows[0])))
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(event, self.onPress)
subSizer.Add(
b, ((index_1 + index_2 + 1) / self.numberOfColumns[0],
(index_1 + index_2 + 1) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
self.subSizers.append(subSizer)
self.parent.mainSizer.Add(self.subSizers[0],
proportion=1,
flag=wx.EXPAND | wx.LEFT,
border=self.yBorder)
self.parent.SetSizer(self.parent.mainSizer)
subSizer2 = wx.GridBagSizer(self.xBorder, self.yBorder)
self.buttonsBoardWidth2 = self.winWidth - self.thicknessOfExternalBorder * 2 - self.thicknessOfInternalBorder * (
self.numberOfColumns[1] - 1)
self.buttonsBoardHeight2 = (
self.winHeight - 20
) - self.textFieldHeight - self.thicknessOfExternalBorder * 3 - self.thicknessOfInternalBorder * (
self.numberOfRows[1] - 1) # -20 because of the Unity upper bar
for index_1, item in enumerate(self.labels[1][:-6]):
b = bt.GenButton(
self.parent,
-1,
item,
name=item,
size=(self.buttonsBoardWidth2 / float(self.numberOfColumns[1]),
self.buttonsBoardHeight2 / float(self.numberOfRows[1])))
b.SetFont(
wx.Font(self.tableFontSize, eval(self.tableFont),
wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, False))
b.SetBezelWidth(3)
b.SetBackgroundColour(self.backgroundColour)
b.SetForegroundColour(self.textColour)
b.Bind(event, self.onPress)
subSizer2.Add(b, (index_1 / self.numberOfColumns[1],
index_1 % self.numberOfColumns[1]),
wx.DefaultSpan, wx.EXPAND)
for index_2, item in enumerate(self.labels[1][-6:]):
if index_2 == 2:
b = bt.GenBitmapButton(
self.parent,
-1,
name=item,
bitmap=self.labelBitmaps2[item],
size=(3 * (self.buttonsBoardWidth2 /
float(self.numberOfColumns[1])),
self.buttonsBoardHeight2 /
float(self.numberOfRows[1])))
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(event, self.onPress)
subSizer2.Add(
b, ((index_1 + index_2 + 1) / self.numberOfColumns[1],
(index_1 + index_2 + 1) % self.numberOfColumns[1]),
(1, 4), wx.EXPAND)
elif index_2 > 2:
b = bt.GenBitmapButton(self.parent,
-1,
name=item,
bitmap=self.labelBitmaps2[item],
size=(self.buttonsBoardWidth2 /
float(self.numberOfColumns[1]),
self.buttonsBoardHeight2 /
float(self.numberOfRows[1])))
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(event, self.onPress)
subSizer2.Add(
b, ((index_1 + index_2 + 4) / self.numberOfColumns[1],
(index_1 + index_2 + 4) % self.numberOfColumns[1]),
wx.DefaultSpan, wx.EXPAND)
else:
b = bt.GenBitmapButton(self.parent,
-1,
name=item,
bitmap=self.labelBitmaps2[item],
size=(self.buttonsBoardWidth2 /
float(self.numberOfColumns[1]),
self.buttonsBoardHeight2 /
float(self.numberOfRows[1])))
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(event, self.onPress)
subSizer2.Add(
b, ((index_1 + index_2 + 1) / self.numberOfColumns[1],
(index_1 + index_2 + 1) % self.numberOfColumns[1]),
wx.DefaultSpan, wx.EXPAND)
self.subSizers.append(subSizer2)
self.parent.mainSizer.Add(self.subSizers[1],
proportion=1,
flag=wx.EXPAND | wx.LEFT,
border=self.yBorder)
self.parent.mainSizer.Show(item=self.subSizers[1],
show=False,
recursive=True)
self.parent.SetSizer(self.parent.mainSizer)
ktore = [] #ktore litery wykropkowac
if len(self.SLOWO) == 2:
ktore = [1]
else:
while len(ktore) < self.ileLuk:
ktore.append(np.random.randint(0, len(self.SLOWO), 1)[0])
ktore = list(set(ktore))
SLOWO = list(self.SLOWO)
ktore = sorted(ktore)
self.samogloski = []
for i in ktore:
SLOWO[i] = '_'
self.ktore = ktore
self.textField.WriteText(''.join(SLOWO))
self.ilejuz = 0
self.czyjuz = False
self.parent.Layout()
def createGui(self):
self.mainSizer = wx.BoxSizer(wx.VERTICAL)
self.subSizer = wx.GridBagSizer(self.xBorder, self.yBorder)
if self.control != 'tracker':
event = eval('wx.EVT_LEFT_DOWN')
else:
event = eval('wx.EVT_BUTTON')
for key, value in self.buttons.items():
if key == 1 or key == 2 or key == 3 or key == 4:
b = bt.GenBitmapButton(self,
-1,
name=value[0],
bitmap=value[1])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(event, self.onPress)
self.subSizer.Add(b, ((key - 1) / self.numberOfColumns[0],
(key - 1) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
elif key == 5:
b = bt.GenBitmapButton(self,
-1,
name=value[0],
bitmap=value[1])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(event, self.onPress)
self.subSizer.Add(b, ((key - 1) / self.numberOfColumns[0],
(key - 1) % self.numberOfColumns[0]),
(1, 2), wx.EXPAND)
elif key == 6 or key == 7 or key == 8 or key == 9 or key == 10 or key == 11:
b = bt.GenBitmapButton(self,
-1,
name=value[0],
bitmap=value[1])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(event, self.onPress)
self.subSizer.Add(b, ((key) / self.numberOfColumns[0],
(key) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
elif key == 12:
b = bt.GenBitmapButton(self,
-1,
name=value[0],
bitmap=value[1])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(event, self.onPress)
self.subSizer.Add(b, ((key) / self.numberOfColumns[0],
(key) % self.numberOfColumns[0]), (1, 2),
wx.EXPAND)
for number in range(self.numberOfRows[0]):
self.subSizer.AddGrowableRow(number)
for number in range(self.numberOfColumns[0]):
self.subSizer.AddGrowableCol(number)
self.mainSizer.Add(self.subSizer,
proportion=1,
flag=wx.EXPAND | wx.LEFT | wx.RIGHT | wx.TOP
| wx.BOTTOM,
border=self.xBorder)
self.SetSizer(self.mainSizer)
def createSideControls(self):
self._leftPanel.Freeze()
colour = wx.Colour(145, 145, 145)
self._leftPanel.SetBackgroundColour(colour)
#Creating a Sizer for panel
ans = False
sizer = self._leftPanel.GetSizer()
if sizer == None:
ans = True
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Clear(True)
sizer.Add(wx.StaticText(self._leftPanel), flag=wx.EXPAND, proportion=1)
#Creating Add Music Button
bitmap = wx.Bitmap(os.path.join(bitmapDir, 'music.png'))
self._musicBtn = buttons.GenBitmapButton(self._leftPanel,
name='Music',
bitmap=bitmap)
self._musicBtn.SetBezelWidth(0)
self._musicBtn.SetBackgroundColour(colour)
#Adding the music button in sizer
sizer.Add(self._musicBtn, flag=wx.TOP | wx.LEFT | wx.RIGHT, border=10)
sizer.Add(wx.StaticText(self._leftPanel), flag=wx.EXPAND, proportion=1)
#Setting the handler
self._musicBtn.Bind(wx.EVT_BUTTON, self.OnMusic)
bitmap = wx.Bitmap(os.path.join(bitmapDir, 'playlist.png'))
self._playlistBtn = buttons.GenBitmapButton(self._leftPanel,
name='Playlist',
bitmap=bitmap)
self._playlistBtn.SetBackgroundColour(colour)
self._playlistBtn.SetBezelWidth(0)
self._playlistBtn.Bind(wx.EVT_BUTTON, self.OnPlaylist)
sizer.Add(self._playlistBtn,
flag=wx.TOP | wx.LEFT | wx.RIGHT,
border=10)
bitmap = wx.Bitmap(os.path.join(bitmapDir, 'createPlaylist.png'))
self._createPlaylistBtn = buttons.GenBitmapButton(
self._leftPanel, name='Create Playlist', bitmap=bitmap)
self._createPlaylistBtn.SetBackgroundColour(colour)
self._createPlaylistBtn.SetBezelWidth(0)
self._createPlaylistBtn.Bind(wx.EVT_BUTTON, self.OnCreatePlaylist)
sizer.Add(wx.StaticText(self._leftPanel), flag=wx.EXPAND, proportion=1)
sizer.Add(self._createPlaylistBtn,
flag=wx.TOP | wx.LEFT | wx.RIGHT,
border=10)
sizer.Add(wx.StaticText(self._leftPanel), flag=wx.EXPAND, proportion=1)
#Setting the sizer to the panel
if ans:
self._leftPanel.SetSizer(sizer)
if self.GetSizer() != None:
self.GetSizer().Layout()
self._leftPanel.Thaw()
def __init__(self):
wx.Frame.__init__(self,
None, -1, 'Affect Expression: Interval Data Entry',
size=(1100, 781)
)
global maps, errorReview, coderIDlist, activityList, theclass, nearList,\
childIDList, affectList, taskList,\
adultList,affectIntListPos, affectIntListNeg
errorReview = 0
panel = wx.Panel(self, -1)
""" Let's make it look good """
self.SetBackgroundColour( (217, 241 , 255))
maps = []
#get configuration file information
self.global_paramters = self.GetConfiguration()
self.panel_length = 60 # should be 30 for interaction/near neighbor
self.maxcount = 60 # should be 30 for interaction/near neighbor
if self.global_paramters.has_key('panel_length'):
self.panel_length = self.global_paramters['panel_length']
if self.global_paramters.has_key('maxcount'):
self.maxcount = self.global_paramters['maxcount']
""" Begin data acquistion section """
""" Mapping Buttons """
## Quad 1
bmpQ11I = AffExpMaps.getbmpQ11IBitmap()
bQ11 = buttons.GenBitmapButton(panel, -1, bmpQ11I, (0, 0))
self.Bind(wx.EVT_BUTTON, self.OnMapButton11, bQ11)
bmpQ12I = AffExpMaps.getbmpQ12IBitmap()
bQ12 = buttons.GenBitmapButton(panel, -1, bmpQ12I, (193, 0))
self.Bind(wx.EVT_BUTTON, self.OnMapButton12, bQ12)
bmpQ13I = AffExpMaps.getbmpQ13IBitmap()
bQ13 = buttons.GenBitmapButton(panel, -1, bmpQ13I, (0, 105))
self.Bind(wx.EVT_BUTTON, self.OnMapButton13, bQ13)
bmpQ14I = AffExpMaps.getbmpQ14IBitmap()
bQ14 = buttons.GenBitmapButton(panel, -1, bmpQ14I, (193, 105))
self.Bind(wx.EVT_BUTTON, self.OnMapButton14, bQ14)
## Quad 2
bmpQ21I = AffExpMaps.getbmpQ21IBitmap()
bQ21 = buttons.GenBitmapButton(panel, -1, bmpQ21I, (386, 0))
self.Bind(wx.EVT_BUTTON, self.OnMapButton21, bQ21)
bmpQ22I = AffExpMaps.getbmpQ22IBitmap()
bQ22 = buttons.GenBitmapButton(panel, -1, bmpQ22I, (579, 0))
self.Bind(wx.EVT_BUTTON, self.OnMapButton22, bQ22)
bmpQ23I = AffExpMaps.getbmpQ23IBitmap()
bQ23 = buttons.GenBitmapButton(panel, -1, bmpQ23I, (386, 105))
self.Bind(wx.EVT_BUTTON, self.OnMapButton23, bQ23)
bmpQ24I = AffExpMaps.getbmpQ24IBitmap()
bQ24 = buttons.GenBitmapButton(panel, -1, bmpQ24I, (579, 105))
self.Bind(wx.EVT_BUTTON, self.OnMapButton24, bQ24)
## Quad 3
bmpQ31I = AffExpMaps.getbmpQ31IBitmap()
bQ31 = buttons.GenBitmapButton(panel, -1, bmpQ31I, (0, 210))
self.Bind(wx.EVT_BUTTON, self.OnMapButton31, bQ31)
bmpQ32I = AffExpMaps.getbmpQ32IBitmap()
bQ32 = buttons.GenBitmapButton(panel, -1, bmpQ32I, (193, 210))
self.Bind(wx.EVT_BUTTON, self.OnMapButton32, bQ32)
bmpQ33I = AffExpMaps.getbmpQ33IBitmap()
bQ33 = buttons.GenBitmapButton(panel, -1, bmpQ33I, (0, 315))
self.Bind(wx.EVT_BUTTON, self.OnMapButton33, bQ33)
## Quad 4
bmpQ41I = AffExpMaps.getbmpQ41IBitmap()
bQ41 = buttons.GenBitmapButton(panel, -1, bmpQ41I, (386, 210))
self.Bind(wx.EVT_BUTTON, self.OnMapButton41, bQ41)
bmpQ42I = AffExpMaps.getbmpQ42IBitmap()
bQ42 = buttons.GenBitmapButton(panel, -1, bmpQ42I, (579, 210))
self.Bind(wx.EVT_BUTTON, self.OnMapButton42, bQ42)
##__________________________________________________________
""" Select Random Child """
wx.StaticText(panel, -1, "Pick Child Randomly", (30,600))
ranKid = AffExpMaps.getsmall_red_diceBitmap()
ranKidGet = buttons.GenBitmapButton(panel, -1, ranKid,\
(40, 615), style = 1)
self.Bind(wx.EVT_BUTTON, self.OnRanButton, ranKidGet)
""" Data Selection Section """
self.playLocation = 101
notice = wx.StaticText(panel, -1,
"Classroom: " + str(self.playLocation),
(850, 300)
)
notice.SetFont(wx.Font(15, wx.SWISS, wx.NORMAL, wx.BOLD, False))
""" Interval List """
eventList = []
for x in range(0,61):
eventList.append(str(x))
self.labelInterv = wx.StaticText(panel, -1, " Interval ", (960, 150))
self.event = wx.Choice(panel, -1, (965, 165), choices = eventList)
self.event.SetSelection(1)
""" Coder List """
coderID = []; coderIDlist = []
coders = csv.reader(open(list_dir + 'coderList.txt'), delimiter=';')
for each in coders:
coderID.append(int(each[0]))
coderIDlist.append(each[1])
wx.StaticText(panel, -1, "Coder ID List:", (785, 150))
self.coderID = wx.Choice(panel, -1, (790, 165), choices = coderIDlist)
self.coderID.SetSelection(0)
""" Child List; add new names at the end """
child = []; childIDList = []
children = csv.reader(open
(list_dir + 'room101List.txt'),
delimiter = ';'
)
for each in children:
child.append(int(each[0]))
childIDList.append(each[1])
wx.StaticText(panel, -1, "Child List:", (885, 150))
self.child = wx.Choice(panel, -1, (890, 165), choices = childIDList)
self.child.SetSelection(0)
""" Activity List """
activityValue = []; activityList = []
activity = csv.reader(open
(list_dir + 'activityList.txt'),
delimiter = ';'
)
for each in activity:
activityValue.append(int(each[0]))
activityList.append(each[1])
wx.StaticText(panel, -1, "Activity", (785, 200))
self.playActivity = wx.Choice(panel, -1, (790, 215), choices = activityList)
self.playActivity.SetSelection(0)
""" AffectIntListPositive """
affectIntensityPos = []; affectIntListPos = []
affectIntPos = csv.reader(open
(list_dir + "affectIntList.txt"),
delimiter = ';'
)
for each in affectIntPos:
affectIntensityPos.append(int(each[0]))
affectIntListPos.append(each[1])
wx.StaticText(panel, -1, "Child Affect: Positive", (210, 350))
self.affectIntensityPos = wx.Choice(panel, -1, (225, 365),
choices = affectIntListPos)
self.affectIntensityPos.SetSelection(0)
""" AffectIntListNegative """
affectIntensityNeg = []; affectIntListNeg = []
affectIntNeg = csv.reader(open
(list_dir + "affectIntList.txt"),
delimiter = ';'
)
for each in affectIntNeg:
affectIntensityNeg.append(int(each[0]))
affectIntListNeg.append(each[1])
wx.StaticText(panel, -1, "Child Affect: Negative", (340, 350))
self.affectIntensityNeg = wx.Choice(panel, -1, (355, 365),
choices = affectIntListNeg)
self.affectIntensityNeg.SetSelection(0)
""" Task List """
taskValue = []; taskList = []
task = csv.reader(open
(list_dir + "taskList.txt"),
delimiter = ';'
)
for each in task:
taskValue.append(int(each[0]))
taskList.append(each[1])
""" Affective Tone List """
affectTone = []; affectList = []
affect = csv.reader(open
(list_dir + "affectList.txt"),
delimiter = ';'
)
for each in affect:
affectTone.append(int(each[0]))
affectList.append(each[1])
""" Nearby List """
nearValue = []; nearList = []
near = csv.reader(open
(list_dir + "room101List.txt"),
delimiter = ';'
)
for each in near:
nearValue.append(int(each[0]))
nearList.append(each[1])
""" Peers """
""" Initiate 1 """
wx.StaticText(panel, -1, "Initiate 1", (200, 410))
self.initiate1 = wx.Choice(panel, -1, (200, 425), choices = childIDList)
self.initiate1.SetSelection(0)
""" Initiate 2 """
wx.StaticText(panel, -1, "Initiate 2", (350, 410))
self.initiate2 = wx.Choice(panel, -1, (350, 425), choices = childIDList)
self.initiate2.SetSelection(0)
""" Receive 1 """
wx.StaticText(panel, -1, "Receive 1", (500, 410))
self.receive1 = wx.Choice(panel, -1, (500, 425), choices = childIDList)
self.receive1.SetSelection(0)
""" Receive 2 """
wx.StaticText(panel, -1, "Receive 2", (650, 410))
self.receive2 = wx.Choice(panel, -1, (650, 425), choices = childIDList)
self.receive2.SetSelection(0)
""" Receive 3 """
wx.StaticText(panel, -1, "Receive 3", (805, 410))
self.receive3 = wx.Choice(panel, -1, (805, 425), choices = childIDList)
self.receive3.SetSelection(0)
""" Initiate Tone """
""" Initiate 1 """
wx.StaticText(panel, -1, "Tone", (225, 460))
self.toneinitiate1 = wx.Choice(panel, -1, (200, 475), choices = affectList)
self.toneinitiate1.SetSelection(0)
""" Initiate 2 """
wx.StaticText(panel, -1, "Tone", (375, 460))
self.toneinitiate2 = wx.Choice(panel, -1, (350, 475), choices = affectList)
self.toneinitiate2.SetSelection(0)
""" Receive 1 """
wx.StaticText(panel, -1, "Tone", (525, 460))
self.tonereceive1 = wx.Choice(panel, -1, (500, 475), choices = affectList)
self.tonereceive1.SetSelection(0)
""" Receive 2 """
wx.StaticText(panel, -1, "Tone", (675, 460))
self.tonereceive2 = wx.Choice(panel, -1, (650, 475), choices = affectList)
self.tonereceive2.SetSelection(0)
""" Receive 3 """
wx.StaticText(panel, -1, "Tone", (830, 460))
self.tonereceive3 = wx.Choice(panel, -1, (805, 475), choices = affectList)
self.tonereceive3.SetSelection(0)
""" Category """
""" Category Initiate 1 """
wx.StaticText(panel, -1, "Category", (200, 510))
self.categoryinitiate1 = wx.Choice(panel, -1, (188, 525), choices = taskList)
self.categoryinitiate1.SetSelection(0)
""" Category Initiate 2 """
wx.StaticText(panel, -1, "Category", (352, 510))
self.categoryinitiate2 = wx.Choice(panel, -1, (340, 525), choices = taskList)
self.categoryinitiate2.SetSelection(0)
""" Category Receive 1 """
wx.StaticText(panel, -1, "Category", (504, 510))
self.categoryreceive1 = wx.Choice(panel, -1, (492, 525), choices = taskList)
self.categoryreceive1.SetSelection(0)
""" Category Receive 2 """
wx.StaticText(panel, -1, "Category", (656, 510))
self.categoryreceive2 = wx.Choice(panel, -1, (644, 525), choices = taskList)
self.categoryreceive2.SetSelection(0)
""" Category Receive 3 """
wx.StaticText(panel, -1, "Category", (808, 510))
self.categoryreceive3 = wx.Choice(panel, -1, (796, 525), choices = taskList)
self.categoryreceive3.SetSelection(0)
""" Near Persons """
""" Near Persons 1 """
wx.StaticText(panel, -1, "Nearby", (200, 560))
self.Nearbyinitiate1 = wx.Choice(panel, -1, (188, 575), choices = nearList)
self.Nearbyinitiate1.SetSelection(0)
""" Near Persons 2 """
wx.StaticText(panel, -1, "Nearby", (352, 560))
self.Nearbyinitiate2 = wx.Choice(panel, -1, (340, 575), choices = nearList)
self.Nearbyinitiate2.SetSelection(0)
""" Near Persons 3 """
wx.StaticText(panel, -1, "Nearby", (504, 560))
self.Nearbyreceive1 = wx.Choice(panel, -1, (492, 575), choices = nearList)
self.Nearbyreceive1.SetSelection(0)
""" Near Persons 4 """
wx.StaticText(panel, -1, "Nearby", (656, 560))
self.Nearbyreceive2 = wx.Choice(panel, -1, (644, 575), choices = nearList)
self.Nearbyreceive2.SetSelection(0)
""" Near Persons 5 """
wx.StaticText(panel, -1, "Nearby", (808, 560))
self.Nearbyreceive3 = wx.Choice(panel, -1, (796, 575), choices = nearList)
self.Nearbyreceive3.SetSelection(0)
""" Manipulate Data and Store: Buttons """
errCheck = wx.Button(panel, -1, "Error Check", (830, 3))
errCheck.SetDefault()
self.Bind(wx.EVT_BUTTON, self.OnErrorCheck, errCheck) # Uses OnErrorCheck
errCheck.SetFont(wx.Font(15, wx.SWISS, wx.NORMAL, wx.BOLD, False))
errCheck.SetToolTipString("Error Check")
errCheck.SetSize(errCheck.GetBestSize())
done = wx.Button(panel, -1, "Submit Data", (830, 53))
self.Bind(wx.EVT_BUTTON, self.OnComplete, done) # Uses OnComplete
done.SetFont(wx.Font(15, wx.SWISS, wx.NORMAL, wx.BOLD, False))
done.SetToolTipString("Compile event data")
done.SetSize(done.GetBestSize())
ano = wx.Button(panel, -1, "Another Interval", (810, 106))
self.Bind(wx.EVT_BUTTON, self.OnAnother, ano) #Uses OnAnother
ano.SetFont(wx.Font(15, wx.SWISS, wx.NORMAL, wx.BOLD, False))
ano.SetToolTipString("Refresh entry values")
ano.SetSize(ano.GetBestSize())
q = wx.Button(panel, -1, "Quit", (975, 650))
self.Bind(wx.EVT_BUTTON, self.OnClose, q) #Uses OnClose
q.SetFont(wx.Font(15, wx.SWISS, wx.NORMAL, wx.BOLD, False))
q.SetToolTipString("This exits the program...")
q.SetSize(q.GetBestSize())
############ gauge #######################
self.count = 0
wx.StaticText(panel, -1, "Seconds", (5, 535))
self.buttonG = wx.Button(panel, -1, "Press to start timer", (25, 550))
self.buttonG.Bind(wx.EVT_BUTTON, self.buttonGClick)
self.gauge1 = wx.Gauge(panel, -1, self.panel_length, (5, 500), (165, 35))
self.gauge1.SetValue(0)
self.gauge1.SetBezelFace(3)
self.gauge1.SetShadowWidth(3)
self.Bind(wx.EVT_TIMER, self.OnTimer)
self.timerG = wx.Timer(self, -1)
self.timerG.Start(1000)
############### clock ######################
self.led = gizmos.LEDNumberCtrl(panel, -1, (5,460), (165, 35),
gizmos.LED_ALIGN_CENTER)
self.led.SetBackgroundColour("red")
self.red_flag = True
self.led.SetForegroundColour("black")
self.OnTimer(None)
self.timer = wx.Timer(self, -1)
# update clock digits every second (1000ms)
self.timer.Start(1000)
self.Bind(wx.EVT_TIMER, self.OnTimer)
def AddLayer(self, layer, active=True, multiple=True, lchecked=True):
self._Map.AddMapLayer(layer)
self._layerList.append(layer)
self._activeIndex = len(self._layerList) - 1
if layer.name and not multiple:
# check for duplicates
item = self.GetFirstVisibleItem()
while item and item.IsOk():
if self.GetLayerInfo(item, key='type') == 'vector':
name = self.GetLayerInfo(item, key='maplayer').GetName()
if name == lname:
return
item = self.GetNextVisible(item)
self.first = True
# deselect active item
if self._activeLayer:
self.SelectItem(self._activeLayer, select=False)
Debug.msg(3, "LayerTree().AddLayer(): ltype=%s" % (layer.type))
if layer.type == 'command':
# generic command item
ctrl = wx.TextCtrl(
self,
id=wx.ID_ANY,
value='',
pos=wx.DefaultPosition,
size=(self.GetSize()[0] - 100, 25),
# style = wx.TE_MULTILINE|wx.TE_WORDWRAP)
style=wx.TE_PROCESS_ENTER | wx.TE_DONTWRAP)
ctrl.Bind(wx.EVT_TEXT_ENTER, self.OnCmdChanged)
# ctrl.Bind(wx.EVT_TEXT, self.OnCmdChanged)
elif layer.type == 'group':
# group item
ctrl = None
grouptext = _('Layer group:') + str(self.groupnode)
self.groupnode += 1
else:
btnbmp = LMIcons["layerOptions"].GetBitmap((16, 16))
ctrl = buttons.GenBitmapButton(self,
id=wx.ID_ANY,
bitmap=btnbmp,
size=(24, 24))
ctrl.SetToolTipString(_("Click to edit layer settings"))
#rashad self.Bind(wx.EVT_BUTTON, self.OnLayerContextMenu, ctrl)
# add layer to the layer tree
if self._activeLayer and self._activeLayer != self.GetRootItem():
if self.GetLayerInfo(self._activeLayer, key = 'type') == 'group' \
and self.IsExpanded(self._activeLayer):
# add to group (first child of self._activeLayer) if group expanded
layeritem = self.PrependItem(parent=self._activeLayer,
text='',
ct_type=1,
wnd=ctrl)
else:
# prepend to individual layer or non-expanded group
if lgroup == -1:
# -> last child of root (loading from workspace)
layeritem = self.AppendItem(parentId=self.root,
text='',
ct_type=1,
wnd=ctrl)
elif lgroup > -1:
# -> last child of group (loading from workspace)
parent = self.FindItemByIndex(index=lgroup)
if not parent:
parent = self.root
layeritem = self.AppendItem(parentId=parent,
text='',
ct_type=1,
wnd=ctrl)
elif lgroup is None:
# -> previous sibling of selected layer
parent = self.GetItemParent(self._activeLayer)
layeritem = self.InsertItem(parentId=parent,
input=self.GetPrevSibling(
self._activeLayer),
text='',
ct_type=1,
wnd=ctrl)
else: # add first layer to the layer tree (first child of root)
layeritem = self.PrependItem(parent=self.root,
text='',
ct_type=1,
wnd=ctrl)
# layer is initially unchecked as inactive (beside 'command')
# use predefined value if given
if lchecked is not None:
checked = lchecked
else:
checked = True
self.forceCheck = True
self.CheckItem(layeritem, checked=checked)
# add text and icons for each layer layer.type
label = _('(double click to set properties)') + ' ' * 15
if layer.type == 'raster':
self.SetItemImage(layeritem, self.rast_icon)
self.SetItemText(layeritem, '%s %s' % (_('raster'), label))
elif layer.type == '3d-raster':
self.SetItemImage(layeritem, self.rast3d_icon)
self.SetItemText(layeritem, '%s %s' % (_('3D raster'), label))
elif layer.type == 'rgb':
self.SetItemImage(layeritem, self.rgb_icon)
self.SetItemText(layeritem, '%s %s' % (_('RGB'), label))
elif layer.type == 'his':
self.SetItemImage(layeritem, self.his_icon)
self.SetItemText(layeritem, '%s %s' % (_('HIS'), label))
elif layer.type == 'shaded':
self.SetItemImage(layeritem, self.shaded_icon)
self.SetItemText(layeritem, '%s %s' % (_('shaded relief'), label))
elif layer.type == 'rastnum':
self.SetItemImage(layeritem, self.rnum_icon)
self.SetItemText(layeritem,
'%s %s' % (_('raster cell numbers'), label))
elif layer.type == 'rastarrow':
self.SetItemImage(layeritem, self.rarrow_icon)
self.SetItemText(layeritem,
'%s %s' % (_('raster flow arrows'), label))
elif layer.type == 'vector':
self.SetItemImage(layeritem, self.vect_icon)
self.SetItemText(layeritem, '%s %s' % (_('vector'), label))
elif layer.type == 'thememap':
self.SetItemImage(layeritem, self.theme_icon)
self.SetItemText(
layeritem,
'%s %s' % (_('thematic area (choropleth) map'), label))
elif layer.type == 'themechart':
self.SetItemImage(layeritem, self.chart_icon)
self.SetItemText(layeritem,
'%s %s' % (_('thematic charts'), label))
elif layer.type == 'grid':
self.SetItemImage(layeritem, self.grid_icon)
self.SetItemText(layeritem, '%s %s' % (_('grid'), label))
elif layer.type == 'geodesic':
self.SetItemImage(layeritem, self.geodesic_icon)
self.SetItemText(layeritem, '%s %s' % (_('geodesic line'), label))
elif layer.type == 'rhumb':
self.SetItemImage(layeritem, self.rhumb_icon)
self.SetItemText(layeritem, '%s %s' % (_('rhumbline'), label))
elif layer.type == 'labels':
self.SetItemImage(layeritem, self.labels_icon)
self.SetItemText(layeritem, '%s %s' % (_('vector labels'), label))
elif layer.type == 'command':
self.SetItemImage(layeritem, self.cmd_icon)
elif layer.type == 'group':
self.SetItemImage(layeritem, self.folder, CT.TreeItemIcon_Normal)
self.SetItemImage(layeritem, self.folder_open,
CT.TreeItemIcon_Expanded)
self.SetItemText(layeritem, grouptext)
elif layer.type == 'wms':
self.SetItemImage(layeritem, self.ws_icon)
self.SetItemText(layeritem, '%s %s' % (_('wms'), label))
self.first = False
if layer.type != 'group':
if layer.cmd and len(layer.cmd) > 1:
cmd = layer.cmd
render = False
name, found = layer.name, True
else:
cmd = []
if layer.type == 'command' and layer.name:
for c in lname.split(';'):
cmd.append(c.split(' '))
render = False
name = None
if ctrl:
ctrlId = ctrl.GetId()
else:
ctrlId = None
# add a data object to hold the layer's command (does not apply to generic command layers)
self.SetPyData(layeritem, ({
'cmd': cmd,
'type': layer.type,
'ctrl': ctrlId,
'label': None,
'maplayer': None,
'vdigit': None,
'nviz': None,
'propwin': None
}, None))
# find previous map layer instance
prevItem = self.GetFirstChild(self.root)[0]
prevMapLayer = None
pos = -1
while prevItem and prevItem.IsOk() and prevItem != layeritem:
if self.GetLayerInfo(prevItem, key='maplayer'):
prevMapLayer = self.GetLayerInfo(prevItem, key='maplayer')
prevItem = self.GetNextSibling(prevItem)
if prevMapLayer:
pos = self.Map.GetLayerIndex(prevMapLayer)
else:
pos = -1
# maplayer = self.Map.AddLayer(pos = pos,
# ltype = ltype, command = self.GetLayerInfo(prevItem, key = 'cmd'), name = name,
# active = checked, hidden = False,
# opacity = lopacity, render = render)
# self.SetLayerInfo(layer, key = 'maplayer', value = maplayer)
#
# # run properties dialog if no properties given
# if len(cmd) == 0:
# self.PropertiesDialog(layer, show = True)
else: # group
self.SetPyData(layeritem, ({
'cmd': None,
'type': ltype,
'ctrl': None,
'label': None,
'maplayer': None,
'propwin': None
}, None))
# select new item
self.SelectItem(layeritem, select=True)
# use predefined layer name if given
if layer.name:
if layer.type == 'group':
self.SetItemText(layeritem, layer.name)
elif layer.type == 'command':
ctrl.SetValue(layer.name)
else:
self.SetItemText(layeritem, 'ELEVATIOM@PERMANENT')
else:
if layer.type == 'group':
self.OnRenameLayer(None)
return layeritem
def createGui(self):
self.mainSizer = wx.BoxSizer(wx.VERTICAL)
self.subSizer = wx.GridBagSizer(4, 4)
# print self.radios.keys()[-5:]
for key, value in self.radios.items():
if key == 1 or key == 2 or key == 3 or key == 4:
b = bt.GenBitmapButton(self,
-1,
name=value[0],
bitmap=value[1])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
self.subSizer.Add(b, ((key - 1) / self.numberOfColumns[0],
(key - 1) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
elif key == 5:
b = bt.GenBitmapButton(self,
-1,
name=value[0],
bitmap=value[1])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
self.subSizer.Add(b, ((key - 1) / self.numberOfColumns[0],
(key - 1) % self.numberOfColumns[0]),
(1, 2), wx.EXPAND)
elif key == 6:
b = bt.GenBitmapButton(self,
-1,
name=value[0],
bitmap=value[1])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
self.subSizer.Add(b, ((key) / self.numberOfColumns[0],
(key) % self.numberOfColumns[0]), (1, 2),
wx.EXPAND)
# elif key == 7 or key == 8:
# b = bt.GenBitmapButton( self, -1, name = value[0], bitmap = value[1] )
# b.SetBackgroundColour( self.backgroundColour )
# b.SetBezelWidth( 3 )
# b.Bind( wx.EVT_LEFT_DOWN, self.onPress )
# self.subSizer.Add(b, ( (key+1) / self.numberOfColumns[0], (key+1) % self.numberOfColumns[0] ), wx.DefaultSpan, wx.EXPAND)
elif key == 9 or key == 10:
b = bt.GenBitmapButton(self,
-1,
name=value[0],
bitmap=value[1])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
self.subSizer.Add(b, ((key - 1) / self.numberOfColumns[0],
(key - 1) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
for number in range(self.numberOfRows[0]):
self.subSizer.AddGrowableRow(number)
for number in range(self.numberOfColumns[0]):
self.subSizer.AddGrowableCol(number)
self.mainSizer.Add(self.subSizer, proportion=1, flag=wx.EXPAND)
self.SetSizer(self.mainSizer)
def createGui(self):
self.textField = wx.TextCtrl( self.parent, style = wx.TE_CENTRE|wx.TE_RICH2, size = ( self.winWidth, 0.2 * ( self.winHeight - 100 ) ) )
self.textField.SetFont( wx.Font( 69, wx.SWISS, wx.NORMAL, wx.NORMAL ) )
self.parent.mainSizer.Add( self.textField, flag = wx.EXPAND | wx.TOP | wx.BOTTOM, border = 3 )
self.subSizers = [ ]
subSizer = wx.GridBagSizer( 3, 3 )
self.pomieszane=[ ]
for i in self.slowo:
self.pomieszane.append( self.labels[ 0 ].index( i ) )
shuffle( self.pomieszane )
for litera in self.pomieszane:
if self.pomieszane.count( litera ) > 1:
self.pomieszane.remove( litera )
zakres = ( self.numberOfRows[ 0 ] - 1 ) * self.numberOfColumns[ 0 ] - 1
dodaj=np.random.randint( 0, zakres, 1 )[ 0 ]
while dodaj in self.pomieszane:
dodaj = np.random.randint( 0, zakres, 1 )[ 0 ]
self.pomieszane.append( dodaj )
slowoList = list( self.slowo )
shuffle( slowoList )
zmieszane_slowo = ''.join( slowoList )
for i in self.pomieszane:
self.labels[ 0 ][ i ] = zmieszane_slowo[ -1 ]
zmieszane_slowo=zmieszane_slowo[ :-1 ]
self.pomieszane.sort( )
ile = 0
for index_1, item in enumerate( self.labels[ 0 ][ :-7 ] ):
ile += 1
b = bt.GenButton( self.parent, -1, item , name = item + str( ile ), size = ( 0.985*self.winWidth / self.numberOfColumns[ 0 ], 0.79 * self.winHeight / self.numberOfRows[ 0 ] ) )
b.SetFont( wx.Font( 35, wx.FONTFAMILY_ROMAN, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, False ) )
b.SetBezelWidth( 3 )
if index_1 not in self.pomieszane:
b.SetBackgroundColour( 'grey' )
else:
b.SetBackgroundColour( self.backgroundColour )
if item in self.colouredLabels and self.vowelColour != 'False':
if index_1 not in self.pomieszane:
b.SetForegroundColour( 'grey' )
else:
b.SetForegroundColour( self.vowelColour )
else:
if index_1 not in self.pomieszane:
b.SetForegroundColour( 'grey' )
else:
b.SetForegroundColour( self.textColour )
b.Bind( wx.EVT_LEFT_DOWN, self.onPress )
subSizer.Add( b, ( index_1 / self.numberOfColumns[ 0 ], index_1 % self.numberOfColumns[ 0 ] ), wx.DefaultSpan, wx.EXPAND )
for index_2, item in enumerate( self.labels[ 0 ][ -7 : ] ):
if item == 'SPECIAL_CHARACTERS':
b = bt.GenButton( self.parent, -1, item, name = item, size = ( 0.985*self.winWidth / self.numberOfColumns[ 0 ], 0.79 * self.winHeight / self.numberOfRows[ 0 ] ) )
b.SetFont( wx.Font( 35, wx.FONTFAMILY_ROMAN, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, False ) )
b.SetForegroundColour( 'grey' )
b.SetBackgroundColour( 'grey' )
else:
b = bt.GenBitmapButton( self.parent, -1, bitmap = self.labelBitmaps[ item ] )
b.SetBackgroundColour( self.backgroundColour )
b.SetBezelWidth( 3 )
b.Bind( wx.EVT_LEFT_DOWN, self.onPress )
if index_2 == 3:
subSizer.Add( b, ( ( index_1 + index_2 +1) / self.numberOfColumns[ 0 ], ( index_1 + index_2+1 ) % self.numberOfColumns[ 0 ] ), ( 1, 3 ), wx.EXPAND )
elif index_2 > 3:
subSizer.Add( b, ( ( index_1 + index_2 +3) / self.numberOfColumns[ 0 ], ( index_1 + index_2 +3) % self.numberOfColumns[ 0 ] ), wx.DefaultSpan, wx.EXPAND )
else:
subSizer.Add( b, ( ( index_1 + index_2+1 ) / self.numberOfColumns[ 0 ], ( index_1 + index_2 +1) % self.numberOfColumns[ 0 ] ), wx.DefaultSpan, wx.EXPAND )
self.subSizers.append( subSizer )
self.parent.mainSizer.Add( self.subSizers[ 0 ], proportion = 1, flag = wx.EXPAND )
self.parent.SetSizer( self.parent.mainSizer )
subSizer2 = wx.GridBagSizer( 3, 3 )
for index_1, item in enumerate( self.labels[ 1 ][ :-6 ] ):
b = bt.GenButton( self.parent, -1, item, name = item, size = ( 0.985*self.winWidth / self.numberOfColumns[ 1 ], 0.75 * self.winHeight / self.numberOfRows[ 1 ] ) )
b.SetFont( wx.Font( 35, wx.FONTFAMILY_ROMAN, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, False ) )
b.SetBezelWidth( 3 )
b.SetBackgroundColour( self.backgroundColour )
b.SetForegroundColour( self.textColour )
b.Bind( wx.EVT_LEFT_DOWN, self.onPress )
subSizer2.Add( b, ( index_1 / self.numberOfColumns[ 1 ], index_1 % self.numberOfColumns[ 1 ] ), wx.DefaultSpan, wx.EXPAND )
for index_2, item in enumerate( self.labels[ 1 ][ -6 : ] ):
b = bt.GenBitmapButton( self.parent, -1, bitmap = self.labelBitmaps2[ item ] )
b.SetBackgroundColour( self.backgroundColour )
b.SetBezelWidth( 3 )
b.Bind( wx.EVT_LEFT_DOWN, self.onPress )
if index_2 == 2:
subSizer2.Add( b, ( ( index_1 + index_2 + 1 ) / self.numberOfColumns[ 1 ], ( index_1 + index_2 + 1 ) % self.numberOfColumns[ 1 ] ), ( 1, 4 ), wx.EXPAND )
elif index_2 > 2:
subSizer2.Add( b, ( ( index_1 + index_2 + 4 ) / self.numberOfColumns[ 1 ], ( index_1 + index_2 + 4 ) % self.numberOfColumns[ 1 ] ), wx.DefaultSpan, wx.EXPAND )
else:
subSizer2.Add( b, ( ( index_1 + index_2+1 ) / self.numberOfColumns[ 1 ], ( index_1 + index_2 + 1 ) % self.numberOfColumns[ 1 ] ), wx.DefaultSpan, wx.EXPAND )
self.subSizers.append( subSizer2 )
self.parent.mainSizer.Add( self.subSizers[ 1 ], proportion = 1, flag = wx.EXPAND )
self.parent.mainSizer.Show( item = self.subSizers[ 1 ], show = False, recursive = True )
self.parent.SetSizer( self.parent.mainSizer )
ikony = range( self.numberOfColumns[ 0 ] * self.numberOfRows[ 0 ] - 8, self.numberOfColumns[ 0 ] * self.numberOfRows[ 0 ] - 2 )
self.ktore = self.pomieszane
for i in ikony:
self.ktore.append( i )
self.parent.Layout( )
self.usuniete=[ ]
def createGui(self):
self.subSizers = []
self.mainSizer = wx.BoxSizer(wx.VERTICAL)
self.numberOfCells = self.numberOfRows[0] * self.numberOfColumns[0]
for panel in self.panels.keys():
subSizer = wx.GridBagSizer(4, 4)
self.subSizers.append(subSizer)
if self.panels != {1: [[], []]}:
index = 0
for index, logo in enumerate(self.panels[panel][1]):
b = bt.GenBitmapButton(self,
-1,
name=self.panels[panel][0][index],
bitmap=logo)
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
subSizer.Add(b, (index / self.numberOfColumns[0],
index % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
else:
index = -1
index_2 = 0
while index + index_2 < self.numberOfCells - 7:
index_2 += 1
b = bt.GenButton(self, -1)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
b.SetBackgroundColour(self.backgroundColour)
subSizer.Add(b, ((index + index_2) / self.numberOfColumns[0],
(index + index_2) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
b = bt.GenBitmapButton(self, -1, bitmap=self.functionButtonPath[0])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
subSizer.Add(b, ((index + index_2 + 1) / self.numberOfColumns[0],
(index + index_2 + 1) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
b = bt.GenBitmapButton(self, -1, bitmap=self.functionButtonPath[1])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
subSizer.Add(b, ((index + index_2 + 2) / self.numberOfColumns[0],
(index + index_2 + 2) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
b = bt.GenBitmapButton(self, -1, bitmap=self.functionButtonPath[2])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
subSizer.Add(b, ((index + index_2 + 3) / self.numberOfColumns[0],
(index + index_2 + 3) % self.numberOfColumns[0]),
(1, 2), wx.EXPAND)
b = bt.GenBitmapButton(self, -1, bitmap=self.functionButtonPath[3])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
subSizer.Add(b, ((index + index_2 + 5) / self.numberOfColumns[0],
(index + index_2 + 5) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
b = bt.GenBitmapButton(self, -1, bitmap=self.functionButtonPath[4])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
subSizer.Add(b, ((index + index_2 + 6) / self.numberOfColumns[0],
(index + index_2 + 6) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
for number in range(self.numberOfRows[0] - 1):
subSizer.AddGrowableRow(number)
for number in range(self.numberOfColumns[0]):
subSizer.AddGrowableCol(number)
self.Layout()
self.mainSizer.Add(subSizer, proportion=1, flag=wx.EXPAND)
self.SetSizer(self.mainSizer)
self.Center(True)
if panel != 1:
self.mainSizer.Show(item=self.subSizers[panel - 1],
show=False,
recursive=True)
self.SetSizer(self.mainSizer)
def createGui(self):
self.textField = wx.TextCtrl(
self.parent,
style=wx.TE_CENTRE | wx.TE_RICH2 | wx.TE_MULTILINE,
size=(self.winWidth, 0.2 * (self.winHeight - 100)))
self.textField.SetFont(wx.Font(69, wx.SWISS, wx.NORMAL, wx.NORMAL))
self.parent.mainSizer.Add(self.textField,
flag=wx.EXPAND | wx.TOP | wx.BOTTOM,
border=4)
self.textField.SetStyle(0, len(self.SLOWO),
wx.TextAttr('black', 'white'))
self.textField.Refresh()
self.slowoZBledem = '' #slowo z jedna bledna litera
ktora_zmienic = np.random.randint(0, len(self.SLOWO), 1)[0]
for i, j in enumerate(self.SLOWO):
if i == ktora_zmienic:
litera = self.labels[0][np.random.randint(
0,
(self.numberOfRows[0] - 1) * self.numberOfColumns[0] - 1,
1)[0]]
while litera == j:
litera = self.labels[0][np.random.randint(
0,
(self.numberOfRows[0] - 1) * self.numberOfColumns[0] -
1, 1)[0]]
self.slowoZBledem += litera
else:
self.slowoZBledem += j
self.textField.WriteText(self.slowoZBledem)
self.ktora_bledna = ktora_zmienic #numer litery ktora jest bledna
self.ileNumerow = len(self.SLOWO) #ile liter ma dane slowo
self.ktore = range(
8,
len(self.SLOWO) + 8
) #ktore indeksy itemow iterowac w cyfrach, plus 9 bo pierwszy rzad pusty
for i in range(self.numberOfRows[1] * self.numberOfColumns[1] - 8,
self.numberOfRows[1] * self.numberOfColumns[1] -
6): #####
self.ktore.append(i)
self.subSizers = []
subSizer = wx.GridBagSizer(3, 3)
for index_1, item in enumerate(self.labels[0][:-7]):
b = bt.GenButton(
self.parent,
-1,
item,
name=item,
size=(0.985 * self.winWidth / self.numberOfColumns[0],
0.79 * self.winHeight / self.numberOfRows[0]))
b.SetFont(wx.Font(35, wx.SWISS, wx.NORMAL, wx.NORMAL))
b.SetBezelWidth(3)
b.SetBackgroundColour(self.backgroundColour)
if item in self.colouredLabels and self.vowelColour != 'False':
b.SetForegroundColour(self.vowelColour)
else:
b.SetForegroundColour(self.textColour)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
subSizer.Add(b, (index_1 / self.numberOfColumns[0],
index_1 % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
for index_2, item in enumerate(self.labels[0][-7:]):
b = bt.GenBitmapButton(self.parent,
-1,
bitmap=self.labelBitmaps[item])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
if index_2 == 3:
subSizer.Add(
b, ((index_1 + index_2 + 1) / self.numberOfColumns[0],
(index_1 + index_2 + 1) % self.numberOfColumns[0]),
(1, 3), wx.EXPAND)
elif index_2 > 3:
subSizer.Add(
b, ((index_1 + index_2 + 3) / self.numberOfColumns[0],
(index_1 + index_2 + 3) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
else:
subSizer.Add(
b, ((index_1 + index_2 + 1) / self.numberOfColumns[0],
(index_1 + index_2 + 1) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
self.subSizers.append(subSizer)
self.parent.mainSizer.Add(self.subSizers[0],
proportion=1,
flag=wx.EXPAND)
self.parent.SetSizer(self.parent.mainSizer)
subSizer2 = wx.GridBagSizer(3, 3)
for index_1, item in enumerate(self.labels[1][:-2]):
try:
if index_1 >= 8:
item = self.slowoZBledem[index_1 - 8]
b = bt.GenButton(
self.parent,
-1,
item,
name=item,
size=(0.985 * self.winWidth / self.numberOfColumns[1],
0.79 * self.winHeight / self.numberOfRows[1]))
else:
b = bt.GenButton(
self.parent,
-1,
item,
name=item,
size=(0.985 * self.winWidth / self.numberOfColumns[1],
0.79 * self.winHeight / self.numberOfRows[1]))
except (IndexError, ValueError):
b = bt.GenButton(
self.parent,
-1,
item,
name=item,
size=(0.985 * self.winWidth / self.numberOfColumns[1],
0.79 * self.winHeight / self.numberOfRows[1]))
b.SetFont(wx.Font(35, wx.SWISS, wx.NORMAL, wx.NORMAL))
b.SetBezelWidth(3)
if index_1 in self.ktore:
b.SetForegroundColour(self.textColour)
b.SetBackgroundColour(self.backgroundColour)
else:
b.SetBackgroundColour('grey')
b.SetForegroundColour('grey')
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
subSizer2.Add(b, (index_1 / self.numberOfColumns[1],
index_1 % self.numberOfColumns[1]),
wx.DefaultSpan, wx.EXPAND)
for index_2, item in enumerate(self.labels[1][-2:]):
b = bt.GenBitmapButton(self.parent,
-1,
bitmap=self.labelBitmaps2[item])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
if index_2 == 0:
subSizer2.Add(
b, ((index_1 + index_2 + 1) / self.numberOfColumns[1],
(index_1 + index_2 + 1) % self.numberOfColumns[1]),
(1, 4), wx.EXPAND)
elif index_2 == 1:
subSizer2.Add(
b, ((index_1 + index_2 + 4) / self.numberOfColumns[1],
(index_1 + index_2 + 4) % self.numberOfColumns[1]),
(1, 4), wx.EXPAND)
self.subSizers.append(subSizer2)
self.parent.mainSizer.Add(self.subSizers[1],
proportion=1,
flag=wx.EXPAND)
self.parent.mainSizer.Show(item=self.subSizers[1],
show=True,
recursive=True)
self.parent.mainSizer.Show(item=self.subSizers[0],
show=False,
recursive=True)
self.parent.SetSizer(self.parent.mainSizer)
self.parent.Layout()
self.textField.SetStyle(0, len(self.SLOWO),
wx.TextAttr('black', 'white'))
self.textField.Refresh()
def createGui(self):
if self.PicNr == len(self.WordsList):
self.PicNr = 0
if self.control != 'tracker':
event = eval('wx.EVT_LEFT_DOWN')
else:
event = eval('wx.EVT_BUTTON')
self.picture = self.WordsList[self.PicNr]
self.PicNr += 1
self.path = self.pathToAP + 'multimedia/ewriting/pictures/'
im = wx.ImageFromStream(open(self.path + self.picture, "rb"))
x = im.GetWidth()
y = im.GetHeight()
if x > y:
im = im.Scale(500, 400)
elif x == y:
im = im.Scale(500, 500)
else:
im = im.Scale(400, 500)
picture = wx.BitmapFromImage(im)
self.word = self.picture[:self.picture.index('.')]
self.WORD = self.word.upper()
self.extraWords = [] #wybiera dodatkowe slowa
while len(self.extraWords) < self.numberOfExtraWords:
slowo = self.WordsList[np.random.randint(0, len(self.WordsList),
1)[0]]
slowo = slowo[:slowo.index('.')]
SLOWO = slowo.upper()
if SLOWO not in self.extraWords and SLOWO != self.WORD:
self.extraWords.append(SLOWO)
b = bt.GenBitmapButton(self, -1, bitmap=picture)
obiekty_wyrazow = []
self.wyrazy_w_kolejnosci = []
gdzie_poprawne = np.random.randint(0, self.numberOfExtraWords, 1)[0]
for i, j in enumerate(self.extraWords):
be = bt.GenButton(self, -1, j)
be.name = j
be.SetFont(
wx.Font(self.tableFontSize, eval(self.tableFont),
wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, False))
be.SetBackgroundColour(self.backgroundColour)
be.Bind(event, self.onPress)
obiekty_wyrazow.append(be)
self.wyrazy_w_kolejnosci.append(j)
be = bt.GenButton(self, -1, self.WORD)
be.SetFont(
wx.Font(self.tableFontSize, eval(self.tableFont),
wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, False))
be.name = self.WORD
be.SetBackgroundColour(self.backgroundColour)
be.Bind(event, self.onPress)
obiekty_wyrazow.insert(gdzie_poprawne, be)
self.wyrazy_w_kolejnosci.insert(gdzie_poprawne, self.WORD)
res = bt.GenButton(
self, -1,
u'TWÓJ WYNIK: ' + str(self.result) + ' / ' + str(self.maxPoints))
res.SetFont(
wx.Font(int(self.tableFontSize * 0.6), eval(self.tableFont),
wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, False))
self.wordSizer = wx.GridSizer(self.numberOfExtraWords + 1, 1,
self.xBorder, self.yBorder)
for item in obiekty_wyrazow:
self.wordSizer.Add(item, proportion=1, flag=wx.EXPAND)
try:
self.subSizerP.Hide(0)
self.subSizerP.Remove(0)
self.subSizerP.Add(res, 0, wx.EXPAND) #dodanie wyniku
self.subSizer0.Hide(0)
self.subSizer0.Remove(0)
self.subSizer0.Hide(0)
self.subSizer0.Remove(0)
self.subSizer0.Add(
self.wordSizer, 0, wx.EXPAND
) #tutaj trzeba dodac caly zagniezdzony subsizer ze slowami
self.subSizer0.Add(b, 0, wx.EXPAND) #dodanie zdjecia
items = self.subSizer.GetChildren()
for item in items:
b = item.GetWindow()
b.SetBackgroundColour(self.backgroundColour)
b.Update
except AttributeError:
if self.czyBack:
self.czyBack = False
else:
self.mainSizer = wx.BoxSizer(wx.VERTICAL)
self.subSizerP = wx.GridSizer(1, 1, self.xBorder, self.yBorder)
self.subSizer0 = wx.GridSizer(1, 2, self.xBorder, self.yBorder)
self.subSizer = wx.GridSizer(1, 4, self.xBorder, self.yBorder)
self.subSizerP.Add(res, 0, wx.EXPAND)
self.subSizer0.Add(self.wordSizer, 0, wx.EXPAND)
self.subSizer0.Add(b, 0, wx.EXPAND)
self.icons = sorted(os.listdir(self.pathToAP + 'icons/ewriting/'))[
1:] #bo pierwszy to 1speller a tu ma go nie byc
self.path = self.pathToAP + 'icons/ewriting/'
for idx, icon in enumerate(self.icons):
if icon[0].isdigit():
k = wx.BitmapFromImage(
wx.ImageFromStream(open(self.path + icon, "rb")))
b = bt.GenBitmapButton(self, -1, bitmap=k)
b.name = self.labels[idx]
b.SetBackgroundColour(self.backgroundColour)
b.Bind(event, self.onPress)
self.subSizer.Add(b, 0, wx.EXPAND)
self.mainSizer.Add(self.subSizerP,
1,
wx.EXPAND | wx.TOP | wx.RIGHT | wx.LEFT,
border=self.xBorder)
self.mainSizer.Add(self.subSizer0,
7,
wx.EXPAND | wx.TOP | wx.BOTTOM | wx.LEFT
| wx.RIGHT,
border=self.xBorder)
self.mainSizer.Add(self.subSizer,
2,
wx.EXPAND | wx.BOTTOM | wx.LEFT | wx.RIGHT,
border=self.xBorder)
self.SetSizer(self.mainSizer, deleteOld=True)
self.SetBackgroundColour('black')
self.Layout()
self.Refresh()
self.Center()
self.MakeModal(True)
self.flaga = 0
self.poczatek = True
def __init__(self, parent, id, title):
wx.Frame.__init__(self,
parent,
id,
title,
style=wx.CAPTION | wx.CLOSE_BOX | wx.MINIMIZE_BOX
| wx.SYSTEM_MENU | wx.FULL_REPAINT_ON_RESIZE)
#Initialize proxy core
self.core = proxycore.ProxyCore(Notifier(self))
self.start_thread = None
self.SetIcon(wx.Icon(WND_ICON, wx.BITMAP_TYPE_ICO))
self.Bind(wx.EVT_CLOSE, self.on_close)
self.out_panel = wx.Panel(self)
simple_panel = wx.Panel(self.out_panel)
self.simple_panel = simple_panel
sizer_opts = wx.FlexGridSizer(rows=2, cols=2, vgap=10, hgap=5)
sizer_opts.Add(wx.StaticText(simple_panel, label='Fetch Server:'),
flag=wx.EXPAND | wx.TOP,
border=3)
self.servertext = wx.TextCtrl(simple_panel,
value='your-appspot-id.appspot.com',
size=(210, -1),
style=wx.TE_PROCESS_ENTER)
self.servertext.Bind(wx.EVT_TEXT_ENTER, self.OnEnterSubmit)
sizer_opts.Add(self.servertext, flag=wx.EXPAND)
sizer_opts.Add(wx.StaticText(simple_panel, label='Password:'******'',
size=(210, -1),
style=wx.TE_PASSWORD | wx.TE_PROCESS_ENTER)
self.pwdtext.Bind(wx.EVT_SET_FOCUS, self.OnPwdFocus)
self.pwdtext.Bind(wx.EVT_TEXT_ENTER, self.OnEnterSubmit)
self.pwdfake = False
sizer_pwd.Add(self.pwdtext, flag=wx.EXPAND | wx.BOTTOM, border=10)
self.rememberchk = wx.CheckBox(simple_panel,
label="Remember password.")
sizer_pwd.Add(self.rememberchk, flag=wx.EXPAND)
self.rememberchk.Bind(wx.EVT_CHECKBOX, self.OnCheckRememberPwd)
sizer_pwd.Add(wx.StaticText(
simple_panel,
label="Do NOT check this if it's a public computer."),
flag=wx.TOP,
border=3)
sizer_opts.Add(sizer_pwd, flag=wx.EXPAND)
self.optbtn = bt.GenBitmapTextToggleButton(simple_panel,
-1,
bitmap=wx.Bitmap(OPT_ICON),
style=wx.NO_BORDER,
label='Options')
self.optbtn.Bind(wx.EVT_BUTTON, self.OnToggleOptions)
sizer_opts.Add(self.optbtn)
sizer_start = wx.BoxSizer(wx.HORIZONTAL)
sizer_start.Add(sizer_opts, flag=wx.EXPAND | wx.ALL, border=10)
self.startbtn = bt.GenBitmapButton(simple_panel,
-1,
bitmap=wx.Bitmap(PLAY_ICON),
size=(81, 81),
style=wx.NO_BORDER)
if wx.Platform != '__WXMSW__':
#Some hack
self.startbtn.SetBackgroundColour(COLOUR_NORMAL)
self.startbtn.faceDnClr = COLOUR_NORMAL
else:
self.startbtn.faceDnClr = self.startbtn.GetBackgroundColour()
self.startbtn.Bind(wx.EVT_BUTTON, self.OnStart)
sizer_start.Add(self.startbtn, flag=wx.ALIGN_TOP | wx.ALL, border=10)
sizer_out = wx.BoxSizer(wx.VERTICAL)
sizer_out.Add(sizer_start, flag=wx.EXPAND | wx.ALL, border=10)
simple_panel.SetSizer(sizer_out)
adv_panel = wx.Panel(self.out_panel)
self.adv_panel = adv_panel
sizer_adv = wx.FlexGridSizer(rows=5, cols=2, vgap=10, hgap=5)
sizer_adv.Add(wx.StaticText(adv_panel, label='Local Proxy:'),
flag=wx.EXPAND | wx.TOP,
border=3)
sizer_proxy_out = wx.BoxSizer(wx.VERTICAL)
self.proxycheck = wx.CheckBox(
adv_panel, label='Check this if you are behind a proxy.')
self.proxycheck.Bind(wx.EVT_CHECKBOX, self.on_check_proxy)
sizer_proxy_out.Add(self.proxycheck, flag=wx.EXPAND | wx.TOP, border=5)
sizer_proxy = wx.BoxSizer(wx.HORIZONTAL)
sizer_proxy.Add(wx.StaticText(adv_panel, label='Host:'),
flag=wx.EXPAND | wx.TOP,
border=3)
self.proxytext = wx.TextCtrl(adv_panel, value='', size=(160, -1))
MyTipWindow(self,
self.proxytext,
text='Your local proxy. e.g. proxy.company.com')
sizer_proxy.Add(self.proxytext,
flag=wx.EXPAND | wx.LEFT | wx.RIGHT,
border=5)
sizer_proxy.Add(wx.StaticText(adv_panel, label='Port:'),
flag=wx.EXPAND | wx.TOP,
border=3)
self.proxyporttext = nc.NumCtrl(adv_panel,
id=-1,
value=None,
integerWidth=5,
allowNone=True,
limited=True,
limitOnFieldChange=True,
selectOnEntry=True,
groupDigits=False,
min=1,
max=65535)
MyTipWindow(self,
self.proxyporttext,
text='The port of the proxy. e.g. 8080')
sizer_proxy.Add(self.proxyporttext,
flag=wx.EXPAND | wx.LEFT | wx.RIGHT,
border=5)
sizer_proxy_out.Add(sizer_proxy, flag=wx.TOP, border=5)
self.proxyauthcheck = wx.CheckBox(
adv_panel, label='Check this if proxy requires authentication.')
sizer_proxy_out.Add(self.proxyauthcheck,
flag=wx.EXPAND | wx.TOP,
border=5)
self.proxyauthcheck.Bind(wx.EVT_CHECKBOX, self.on_check_proxy)
sizer_auth = wx.BoxSizer(wx.HORIZONTAL)
sizer_auth.Add(wx.StaticText(adv_panel, label='Username:'******'', size=(90, -1))
sizer_auth.Add(self.proxyusertext,
flag=wx.EXPAND | wx.LEFT | wx.RIGHT,
border=5)
sizer_auth.Add(wx.StaticText(adv_panel, label='Password:'******'',
size=(90, -1),
style=wx.TE_PASSWORD)
sizer_auth.Add(self.proxypwdtext,
flag=wx.EXPAND | wx.LEFT | wx.RIGHT,
border=5)
sizer_proxy_out.Add(sizer_auth, flag=wx.EXPAND | wx.TOP, border=5)
sizer_adv.Add(sizer_proxy_out)
sizer_adv.Add(wx.StaticText(adv_panel, label='Listen port:'),
flag=wx.EXPAND | wx.TOP,
border=3)
self.porttext = nc.NumCtrl(adv_panel,
id=-1,
value=8000,
limited=True,
limitOnFieldChange=True,
selectOnEntry=True,
groupDigits=False,
min=1,
max=65535)
MyTipWindow(
self,
self.porttext,
text=
'The local port Secure GAppProxy listens on. There\'re very few reasons to change this.\nPort number should be from 1 to 65535.'
)
sizer_adv.Add(self.porttext)
sizer_adv.Add(wx.StaticText(adv_panel, label='Options:'),
flag=wx.EXPAND | wx.TOP,
border=3)
sizer_advopts = wx.BoxSizer(wx.VERTICAL)
self.httpschk = wx.CheckBox(adv_panel,
label='Connect fetch server with HTTPS.')
sizer_advopts.Add(self.httpschk, flag=wx.EXPAND | wx.BOTTOM, border=10)
self.hostchk = wx.CheckBox(
adv_panel,
label='Try to detect and resolve connectivity issues on startup.')
sizer_advopts.Add(self.hostchk, flag=wx.EXPAND | wx.BOTTOM, border=10)
if wx.Platform == '__WXMSW__' and common.we_are_frozen():
self.autostartchk = wx.CheckBox(adv_panel,
label='Start proxy with Windows.')
sizer_advopts.Add(self.autostartchk)
sizer_adv.Add(sizer_advopts)
##sizer_adv.Add(wx.StaticText(adv_panel, label='Certificate:'), flag=wx.EXPAND | wx.TOP, border=3)
##sizer_certopts = wx.BoxSizer(wx.VERTICAL)
##self.clearcachebtn = wx.Button(adv_panel, label='Clear Certificate Cache')
##self.clearcachebtn.Bind(wx.EVT_BUTTON, self.on_clear_cert)
##sizer_certopts.Add(self.clearcachebtn)
##self.installcertbtn = wx.Button(adv_panel, label='Install Root Certificate')
##self.installcertbtn.Bind(wx.EVT_BUTTON, self.on_install_cert)
##sizer_certopts.Add(self.installcertbtn)
##sizer_adv.Add(sizer_certopts)
sizer_adv_box = wx.BoxSizer(wx.VERTICAL)
sizer_adv_box.Add(sizer_adv, flag=wx.EXPAND | wx.ALL, border=20)
self.savebtn = wx.Button(adv_panel,
size=(-1, 35),
label='Save and Apply')
self.savebtn.Bind(wx.EVT_BUTTON, self.OnSaveApply)
sizer_adv_box.Add((-1, 30))
sizer_adv_box.Add(self.savebtn,
flag=wx.ALIGN_RIGHT | wx.BOTTOM | wx.RIGHT,
border=20)
adv_panel.SetSizer(sizer_adv_box)
sizer_final = wx.BoxSizer(wx.VERTICAL)
sizer_final.Add(simple_panel, flag=wx.EXPAND)
sizer_final.Add(adv_panel, flag=wx.EXPAND)
self.out_panel.SetSizer(sizer_final)
MyTipWindow(
self,
self.servertext,
text='Fetch server running on GAE. e.g. your-appspot-id.appspot.com'
)
self.min_size = sizer_out.GetMinSize().Get()
w1, h1 = sizer_out.GetMinSize().Get()
w2, h2 = sizer_adv_box.GetMinSize().Get()
self.expand_size = (max(w1, w2), h1 + h2)
self.Notify()
self.Center()
self.Show(True)
self.startbtn.SetFocus()
w, h = self.min_size
self.statusbar = wx.Panel(simple_panel,
style=wx.NO_BORDER,
size=(300, 25),
pos=(w - 300, h - 35))
self.statustext = 'SecureGAppProxy is not running.'
self.statusicon = wx.Bitmap(RED_ICON)
self.statusbar.Bind(wx.EVT_PAINT, self.on_paint_status)
self.statusbar.Refresh()
self.about_btn = bt.GenBitmapTextButton(
adv_panel,
-1,
bitmap=wx.Bitmap(ABOUTBTN_ICON),
style=wx.NO_BORDER,
label='About')
self.about_btn.Bind(wx.EVT_BUTTON, self.on_about)
if wx.Platform != '__WXMSW__':
self.about_btn.SetBackgroundColour(COLOUR_NORMAL)
self.about_btn.faceDnClr = COLOUR_NORMAL
self.about_btn.SetBestSize((-1, -1))
p1, p2 = adv_panel.GetClientRect().GetBottomLeft().Get()
q1, q2 = self.about_btn.GetSizeTuple()
self.about_btn.SetPosition((0, p2 - q2))
if wx.Platform != '__WXMSW__':
#Set background colour
self.out_panel.SetBackgroundColour(COLOUR_NORMAL)
simple_panel.SetBackgroundColour(COLOUR_NORMAL)
adv_panel.SetBackgroundColour(COLOUR_NORMAL)
self.statusbar.SetBackgroundColour(COLOUR_NORMAL)
self.LoadConfig()
#If we have the parameters needed, automatically connect
if config.GetParam('password') != None and config.GetParam(
'fetch_server') != '':
self.OnStart(None)
def createAnnotationToolbar(self):
"""
Method to create a toolbar for the annotations
"""
icondir = scripting.get_icon_dir()
def createBtn(bid,
pngname,
tooltip,
btnclass=buttons.GenBitmapToggleButton):
bmp = wx.Image(os.path.join(icondir, pngname),
wx.BITMAP_TYPE_PNG).ConvertToBitmap()
btn = btnclass(self, bid, bmp)
btn.SetBestSize((32, 32))
#btn.SetBitmapLabel()
btn.SetToolTipString(tooltip)
return btn
self.circleBtn = createBtn(MenuManager.ID_ROI_CIRCLE,
"Annotation_Circle.png",
"Select a circular area of the image")
self.sizer.Add(self.circleBtn, (0, 0))
self.rectangleBtn = createBtn(MenuManager.ID_ROI_RECTANGLE, "Annotation_Rectangle.png", \
"Select a rectangular area of the image")
self.sizer.Add(self.rectangleBtn, (0, 1))
self.polygonBtn = createBtn(MenuManager.ID_ROI_POLYGON, "Annotation_Polygon.png", \
"Select a polygonal area of the image")
self.sizer.Add(self.polygonBtn, (1, 0))
self.scaleBtn = createBtn(MenuManager.ID_ADD_SCALE,
"Annotation_Scalebar.png",
"Draw a scale bar on the image")
self.sizer.Add(self.scaleBtn, (1, 1))
icon = wx.Image(os.path.join(icondir, "Annotation_Delete.png"),
wx.BITMAP_TYPE_PNG).ConvertToBitmap()
self.deleteAnnotationBtn = buttons.GenBitmapButton(
self, MenuManager.ID_DEL_ANNOTATION, icon)
self.deleteAnnotationBtn.SetBestSize((32, 32))
self.deleteAnnotationBtn.SetToolTipString("Delete an annotation")
self.sizer.Add(self.deleteAnnotationBtn, (2, 0))
self.colorSelect = csel.ColourSelect(self,
-1,
"",
self.annotateColor,
size=(32, 32))
self.colorSelect.Bind(csel.EVT_COLOURSELECT, self.setAnnotationColor)
self.sizer.Add(self.colorSelect, (2, 1))
if not scripting.TFLag:
self.threeDPolygonBtn = createBtn(
MenuManager.ID_ROI_THREE_D_POLYGON, "three_d_polygon.png",
"Select one or several polygonal areas of the image in different slices to perform a 3D crop"
)
self.sizer.Add(self.threeDPolygonBtn, (3, 0))
self.threeDCircleBtn = createBtn(
MenuManager.ID_ROI_THREE_D_CIRCLE, "three_d_circle.png",
"Select one or several circle areas of the image in different slices to perform a 3D crop"
)
self.sizer.Add(self.threeDCircleBtn, (3, 1))
self.threeDRectangleBtn = createBtn(
MenuManager.ID_ROI_THREE_D_RECTANGLE, "three_d_rectangle.png",
"Select one or several rectangle areas of the image in different slices to perform a 3D crop"
)
self.sizer.Add(self.threeDRectangleBtn, (4, 0))
# Interpolation stuff. :)
self.interpolationStart = wx.SpinCtrl(
self,
wx.ID_ANY,
size=(64, -1),
min=1,
max=self.visualizer.dataUnit.getDimensions()[2]
if self.visualizer.dataUnit != None else 1)
self.interpolationStart.SetValue(1)
self.sizer.Add(self.interpolationStart, (5, 0), span=(1, 2))
self.interpolationEnd = wx.SpinCtrl(
self,
wx.ID_ANY,
size=(64, -1),
min=1,
max=self.visualizer.dataUnit.getDimensions()[2]
if self.visualizer.dataUnit != None else 1)
self.interpolationEnd.SetValue(1)
self.sizer.Add(self.interpolationEnd, (6, 0), span=(1, 2))
self.interpolateButton = wx.Button(self,
wx.ID_ANY,
"Interpolate",
size=(64, 24))
self.sizer.Add(self.interpolateButton, (7, 0), span=(1, 2))
self.interpolateButton.Bind(wx.EVT_BUTTON, self.onInterpolate)
self.copyToAllButton = wx.Button(self,
wx.ID_ANY,
"Copy to all",
size=(64, 24))
self.sizer.Add(self.copyToAllButton, (8, 0), span=(1, 2))
self.copyToAllButton.Bind(wx.EVT_BUTTON, self.onCopyAll)
#self.textBtn = createBtn(MenuManager.ID_ANNOTATION_TEXT, "text.gif", "Add a text annotation")
#self.sizer.Add(self.textBtn, (2, 0))
#self.roiToMaskBtn = createBtn(MenuManager.ID_ROI_TO_MASK, "roitomask.gif", \
# "Convert the selected Region of Interest to a Mask", \
# btnclass = buttons.GenBitmapButton)
#self.sizer.Add(self.roiToMaskBtn, (4, 0))
#self.fontBtn = createBtn(MenuManager.ID_ANNOTATION_FONT,"fonts.gif",\
# "Set the font for annotations", btnclass=buttons.GenBitmapButton)
#self.sizer.Add(self.fontBtn, (3,1))
#self.resamplingBtn = createBtn(MenuManager.ID_RESAMPLING, "resample.gif", \
# "Enable or disable the resampling of image data")
#self.resamplingBtn.SetToggle(1)
#self.resampleToFitBtn = createBtn(MenuManager.ID_RESAMPLE_TO_FIT, "resample_tofit.gif", \
# "Enable or disable the resampling of image data")
#self.sizer.Add(self.resamplingBtn, (6, 0))
#self.sizer.Add(self.resampleToFitBtn, (6, 1))
# self.recordBtn = buttons.GenToggleButton(self, MenuManager.ID_RECORD_EVENTS, "Record", size=(64,-1))
# self.sizer.Add(self.recordBtn, (7,0), span=(1,2))
# self.playBtn = createBtn(MenuManager.ID_PLAY_EVENTS,"player_play.gif", \
# "Play the recorded events", btnclass=buttons.GenBitmapButton)
# self.stopBtn = createBtn(MenuManager.ID_PLAY_EVENTS,"player_pause.gif", \
# "Stop playing the recorded events", btnclass=buttons.GenBitmapButton)
# self.sizer.Add(self.playBtn, (8,0))
# self.sizer.Add(self.stopBtn, (8,1))
# self.playBtn.Bind(wx.EVT_BUTTON, self.onPlayRecording)
# self.stopBtn.Bind(wx.EVT_BUTTON, self.onStopPlaying)
# self.recordBtn.Bind(wx.EVT_BUTTON, self.onRecord)
# bmp = wx.Image(os.path.join(iconpath,"resample.gif")).ConvertToBitmap()
# tb.DoAddTool(MenuManager.ID_RESAMPLING, "Resampling", bmp, kind = wx.ITEM_CHECK, \
# shortHelp = "Enable or disable the resampling of image data")
# wx.EVT_TOOL(self,MenuManager.ID_RESAMPLING,self.onResampleData)
# tb.EnableTool(MenuManager.ID_RESAMPLING,0)
# tb.ToggleTool(MenuManager.ID_RESAMPLING,1)
# sbox = wx.StaticBox(self,-1,"Resampling")
# sboxsizer = wx.StaticBoxSizer(sbox, wx.VERTICAL)
# self.resamplingOff = wx.RadioButton(self,-1,"Disabled", style = wx.RB_GROUP)
# self.resamplingOn = wx.RadioButton(self,-1,"Enabled")
# self.resampleToFit = wx.RadioButton(self,-1,"To fit")
# sboxsizer.Add(self.resamplingOn)
# sboxsizer.Add(self.resamplingOff)
# sboxsizer.Add(self.resampleToFit)
# self.sizer.Add(sboxsizer, (6,0),span=(1,2))
# self.sizer.Add(self.resamplingOn, (7,0),span=(1,2))
# self.sizer.Add(self.resampleToFit, (8,0),span=(1,2))
# self.dimInfo = UIElements.DimensionInfo(self,-1, size=(120,50))
# self.sizer.Add(self.dimInfo, (6,0), span=(1,2))
self.sizerCount = 8
#self.resamplingBtn.Bind(wx.EVT_BUTTON, self.onResampleData)
#self.resampleToFitBtn.Bind(wx.EVT_BUTTON, self.onResampleToFit)
self.circleBtn.Bind(wx.EVT_BUTTON, self.addAnnotation)
self.rectangleBtn.Bind(wx.EVT_BUTTON, self.addAnnotation)
self.polygonBtn.Bind(wx.EVT_BUTTON, self.addAnnotation)
self.scaleBtn.Bind(wx.EVT_BUTTON, self.addAnnotation)
if not scripting.TFLag:
self.threeDPolygonBtn.Bind(wx.EVT_BUTTON, self.addAnnotation)
self.threeDCircleBtn.Bind(wx.EVT_BUTTON, self.addAnnotation)
self.threeDRectangleBtn.Bind(wx.EVT_BUTTON, self.addAnnotation)
#self.roiToMaskBtn.Bind(wx.EVT_BUTTON, self.roiToMask)
# wx.EVT_TOOL(self.parent,MenuManager.ID_ADD_SCALE,self.addAnnotation)
self.deleteAnnotationBtn.Bind(wx.EVT_BUTTON, self.deleteAnnotation)
def __init__(self, parent, log):
wx.Panel.__init__(self, parent, -1)
self.log = log
##self.SetBackgroundColour("sky blue")
sizer = wx.FlexGridSizer(1, 3, 20, 20)
# A regular button, selected as the default button
b = wx.Button(self, -1, "A real button")
b.SetDefault()
self.Bind(wx.EVT_BUTTON, self.OnButton, b)
sizer.Add(b)
# Same thing, but NOT set as the default button
b = wx.Button(self, -1, "non-default")
self.Bind(wx.EVT_BUTTON, self.OnButton, b)
sizer.Add(b)
sizer.Add((10, 10))
# Plain old text button based off GenButton()
b = buttons.GenButton(self, -1, 'Hello')
self.Bind(wx.EVT_BUTTON, self.OnButton, b)
sizer.Add(b)
# Plain old text button, disabled.
b = buttons.GenButton(self, -1, 'disabled')
self.Bind(wx.EVT_BUTTON, self.OnButton, b)
b.Enable(False)
sizer.Add(b)
# This time, we let the botton be as big as it can be.
# Also, this one is fancier, with custom colors and bezel size.
b = buttons.GenButton(self, -1, 'bigger')
self.Bind(wx.EVT_BUTTON, self.OnBiggerButton, b)
b.SetFont(wx.Font(20, wx.SWISS, wx.NORMAL, wx.BOLD, False))
b.SetBezelWidth(5)
b.SetMinSize(wx.DefaultSize)
b.SetBackgroundColour("Navy")
b.SetForegroundColour(wx.WHITE)
b.SetToolTipString("This is a BIG button...")
# let the sizer set best size
sizer.Add(b, flag=wx.ADJUST_MINSIZE)
# An image button
bmp = images.Test2.GetBitmap()
b = buttons.GenBitmapButton(self, -1, bmp)
self.Bind(wx.EVT_BUTTON, self.OnButton, b)
sizer.Add(b)
# An image button, disabled.
bmp = images.Test2.GetBitmap()
b = buttons.GenBitmapButton(self, -1, bmp)
self.Bind(wx.EVT_BUTTON, self.OnButton, b)
sizer.Add(b)
b.Enable(False)
# An image button, using a mask to get rid of the
# undesireable part of the image
b = buttons.GenBitmapButton(self, -1, None)
self.Bind(wx.EVT_BUTTON, self.OnButton, b)
bmp = images.Bulb1.GetBitmap()
mask = wx.Mask(bmp, wx.BLUE)
bmp.SetMask(mask)
b.SetBitmapLabel(bmp)
bmp = images.Bulb2.GetBitmap()
mask = wx.Mask(bmp, wx.BLUE)
bmp.SetMask(mask)
b.SetBitmapSelected(bmp)
b.SetInitialSize()
sizer.Add(b)
# A toggle button
b = buttons.GenToggleButton(self, -1, "Toggle Button")
self.Bind(wx.EVT_BUTTON, self.OnToggleButton, b)
sizer.Add(b)
# An image toggle button
b = buttons.GenBitmapToggleButton(self, -1, None)
self.Bind(wx.EVT_BUTTON, self.OnToggleButton, b)
bmp = images.Bulb1.GetBitmap()
mask = wx.Mask(bmp, wx.BLUE)
bmp.SetMask(mask)
b.SetBitmapLabel(bmp)
bmp = images.Bulb2.GetBitmap()
mask = wx.Mask(bmp, wx.BLUE)
bmp.SetMask(mask)
b.SetBitmapSelected(bmp)
b.SetToggle(True)
b.SetInitialSize()
sizer.Add(b)
# A bitmap button with text.
b = buttons.GenBitmapTextButton(self,
-1,
None,
"Bitmapped Text",
size=(200, 45))
self.Bind(wx.EVT_BUTTON, self.OnButton, b)
bmp = images.Bulb1.GetBitmap()
mask = wx.Mask(bmp, wx.BLUE)
bmp.SetMask(mask)
b.SetBitmapLabel(bmp)
bmp = images.Bulb2.GetBitmap()
mask = wx.Mask(bmp, wx.BLUE)
bmp.SetMask(mask)
b.SetBitmapSelected(bmp)
b.SetUseFocusIndicator(False)
b.SetInitialSize()
sizer.Add(b)
# a flat text button
b = buttons.GenButton(self,
-1,
'Flat buttons too!',
style=wx.BORDER_NONE)
self.Bind(wx.EVT_BUTTON, self.OnButton, b)
sizer.Add(b, flag=wx.ALIGN_CENTER_VERTICAL)
# A flat image button
bmp = images.Test2.GetBitmap()
bmp.SetMaskColour("blue")
b = buttons.GenBitmapButton(self, -1, bmp, style=wx.BORDER_NONE)
self.Bind(wx.EVT_BUTTON, self.OnButton, b)
sizer.Add(b)
##b.SetBackgroundColour("sky blue")
##b.SetBackgroundColour("pink")
vbox = wx.BoxSizer(wx.VERTICAL)
sizer.Add(vbox)
b = buttons.ThemedGenButton(self, -1, 'Drawn with native renderer')
self.Bind(wx.EVT_BUTTON, self.OnButton, b)
vbox.Add(b, 0, wx.ALL, 5)
b = buttons.ThemedGenToggleButton(self, -1, 'native renderered toggle')
self.Bind(wx.EVT_BUTTON, self.OnButton, b)
vbox.Add(b, 0, wx.ALL, 5)
border = wx.BoxSizer(wx.VERTICAL)
border.Add(sizer, 0, wx.ALL, 25)
self.SetSizer(border)
def createGui(self):
if self.PicNr == len(self.WordsList):
self.PicNr = 0
self.picture = self.WordsList[self.PicNr]
self.PicNr += 1
self.path = self.pathToAP + 'multimedia/ewriting/pictures/'
im = wx.ImageFromStream(open(self.path + self.picture, "rb"))
x = im.GetWidth()
y = im.GetHeight()
if x > y:
im = im.Scale(500, 400)
elif x == y:
im = im.Scale(500, 500)
else:
im = im.Scale(400, 500)
picture = wx.BitmapFromImage(im)
self.word = self.picture[:self.picture.index('.')]
self.WORD = self.word.upper()
b = bt.GenBitmapButton(self, -1, bitmap=picture, name='picture')
# b.SetBackgroundColour( self.backgroundColour )
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
be = bt.GenButton(self, -1, self.WORD)
be.SetFont(
wx.Font(self.textSize, wx.FONTFAMILY_ROMAN, wx.FONTSTYLE_NORMAL,
wx.FONTWEIGHT_NORMAL, False))
# be.SetBackgroundColour( self.backgroundColour )
be.Bind(wx.EVT_LEFT_DOWN, self.onPress)
res = bt.GenButton(
self, -1,
u'TWÓJ WYNIK: ' + str(self.result) + ' / ' + str(self.maxPoints))
res.SetFont(
wx.Font(27, wx.FONTFAMILY_ROMAN, wx.FONTSTYLE_NORMAL,
wx.FONTWEIGHT_NORMAL, False))
res.Bind(wx.EVT_LEFT_DOWN, self.onPress)
try:
self.subSizerP.Hide(0)
self.subSizerP.Remove(0)
self.subSizerP.Add(res, 0, wx.EXPAND)
self.subSizer0.Hide(0)
self.subSizer0.Remove(0)
self.subSizer0.Hide(0)
self.subSizer0.Remove(0)
self.subSizer0.Add(b, 0, wx.EXPAND)
self.subSizer0.Add(be, 0, wx.EXPAND)
items = self.subSizer.GetChildren()
for i in items:
b = i.GetWindow()
b.SetBackgroundColour(self.backgroundColour)
b.Update
except AttributeError:
if self.czyBack:
self.czyBack = False
else:
self.mainSizer = wx.BoxSizer(wx.VERTICAL)
self.subSizerP = wx.GridSizer(1, 1, 3, 3)
self.subSizer0 = wx.GridSizer(1, 2, 3, 3)
self.subSizer = wx.GridSizer(1, 5, 3, 3)
self.subSizerP.Add(res, 0, wx.EXPAND)
self.subSizer0.Add(b, 0, wx.EXPAND)
self.subSizer0.Add(be, 0, wx.EXPAND)
self.icons = sorted(os.listdir(self.pathToAP + '/icons/ewriting'))
self.path = self.pathToAP + 'icons/ewriting/'
for idx, icon in enumerate(self.icons):
if icon[0].isdigit():
i = wx.BitmapFromImage(
wx.ImageFromStream(open(self.path + icon, "rb")))
b = bt.GenBitmapButton(self, -1, bitmap=i)
b.SetBackgroundColour(self.backgroundColour)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
self.subSizer.Add(b, 0, wx.EXPAND)
self.mainSizer.Add(self.subSizerP,
proportion=1,
flag=wx.EXPAND | wx.BOTTOM,
border=3)
self.mainSizer.Add(self.subSizer0, proportion=7, flag=wx.EXPAND)
self.mainSizer.Add(self.subSizer,
proportion=2,
flag=wx.EXPAND | wx.TOP,
border=3)
self.SetSizer(self.mainSizer, deleteOld=True)
self.SetBackgroundColour('black')
self.Layout()
self.Refresh()
self.Center()
self.MakeModal(True)
self.flaga = 0
self.poczatek = True
def createGui(self):
self.mainSizer = wx.BoxSizer(wx.VERTICAL)
self.panel = wx.Panel(self, 1, style=wx.SUNKEN_BORDER)
self.panel.SetSizeWH(self.winWidth, 0.22 * self.winHeight)
self.panelSize = self.panel.GetSize()
self.displaySizer = wx.BoxSizer(wx.HORIZONTAL)
self.displaySizer.SetMinSize(self.panelSize)
self.displaySizer.Fit(self.panel)
self.displaySizer.Add(self.panel, 1, wx.EXPAND)
self.mainSizer.Add(self.displaySizer,
1,
wx.EXPAND | wx.BOTTOM | wx.TOP,
border=1)
self.subSizers = []
for item in range(len(self.numberOfRows)):
subSizer = wx.GridSizer(self.numberOfRows[item],
self.numberOfColumns[item], 1, 1)
subSizer.SetMinSize(
(self.winWidth, 0.768 * self.winHeight)
) #this should not be done like this. Sizer should fit automatically.
self.subSizers.append(subSizer)
i, j = 0, 1
self.numberOfCells = self.numberOfRows[
item] * self.numberOfColumns[item]
while j <= self.numberOfCells:
try:
if i < len(self.blissBook[item]):
while j != self.blissBook[item][i][1]:
b = bt.GenButton(self, -1)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
b.SetBackgroundColour(self.backgroundColour)
self.subSizers[item].Add(
b, 0, wx.EXPAND | wx.ALIGN_CENTER)
j += 1
b = bt.GenBitmapButton(
self, -1, bitmap=self.blissBook[item][i][0])
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
b.SetBackgroundColour(self.backgroundColour)
self.subSizers[item].Add(b, 0,
wx.EXPAND | wx.ALIGN_CENTER)
i += 1
j += 1
else:
b = bt.GenButton(self, -1)
b.Bind(wx.EVT_LEFT_DOWN, self.onPress)
b.SetBackgroundColour(self.backgroundColour)
self.subSizers[item].Add(b, 0,
wx.EXPAND | wx.ALIGN_CENTER)
j += 1
except IndexError:
print 'IndexError'
print i, j
self.Layout()
self.mainSizer.Add(self.subSizers[item],
proportion=0,
flag=wx.EXPAND | wx.LEFT,
border=3)
if item != 0:
self.mainSizer.Show(item=self.subSizers[item],
show=False,
recursive=True)
self.SetSizer(self.mainSizer)
def build_media_control(self, sizer):
"""
buttondata is the dictionary for button containing image of the button, handler and name
"""
# ------ Buttons ------
button_data = [{
"image": "previous.png",
"handler": self.previous_song,
"name": "prev_btn"
}, {
"image": "stop.png",
"handler": self.on_stop,
"name": "stop_btn"
}, {
"image": "next.png",
"handler": self.next_song,
"name": "next_btn"
}]
shuffle_data = {
"image": "shuffle.png",
"handler": self.when_shuffle,
"name": "shuffle_btn"
}
img = wx.Bitmap(os.path.join(imgdirectory, "shuffle.png"))
self.shuffle_btn = buttons.GenBitmapButton(self,
bitmap=img,
name="shuffle",
size=(40, 40))
self.shuffle_btn.Bind(wx.EVT_BUTTON, handler=self.when_shuffle)
sizer.Add(self.shuffle_btn, wx.LEFT)
self.build_button(button_data[0], sizer)
img = wx.Bitmap(os.path.join(imgdirectory, "play.png"))
self.playpause_btn = buttons.GenBitmapToggleButton(self,
bitmap=img,
name="play",
size=(40, 40))
img = wx.Bitmap(os.path.join(imgdirectory, "pause.png"))
self.playpause_btn.SetBitmapSelected(img)
self.playpause_btn.Bind(wx.EVT_BUTTON, handler=self.on_play)
sizer.Add(self.playpause_btn, wx.LEFT)
self.build_button(button_data[1], sizer)
self.build_button(button_data[2], sizer)
img = wx.Bitmap(os.path.join(imgdirectory, "loop.png"))
self.loop_btn = buttons.GenBitmapToggleButton(self,
bitmap=img,
name="loop",
size=(40, 40))
img = wx.Bitmap(os.path.join(imgdirectory, "on_loop.png"))
self.loop_btn.SetBitmapSelected(img)
self.loop_btn.Bind(wx.EVT_BUTTON, handler=self.is_loop_down)
sizer.Add(self.loop_btn, wx.LEFT)
# ------ Volume Slider ------
# Image of volume slider
low_vol = wx.Bitmap(os.path.join(imgdirectory, "low_vol.png"))
high_vol = wx.Bitmap(os.path.join(imgdirectory, "high_vol.png"))
static_low = wx.StaticBitmap(self)
static_low.SetBitmap(low_vol)
static_high = wx.StaticBitmap(self)
static_high.SetBitmap(high_vol)
sizer.Add((100, 0))
sizer.Add(static_low, wx.LEFT)
# Volume slider
self.vol_slider = wx.Slider(self)
self.vol_slider.SetRange(0, 100)
self.vol_slider.SetValue(self.volume)
self.vol_slider.Bind(wx.EVT_SLIDER, self.vol_control)
sizer.Add(self.vol_slider, wx.LEFT)
sizer.Add((30, 0))
sizer.Add(static_high, wx.LEFT)
def __init__(self,
parent,
id,
title,
mp4box,
categories=["1", "2", "3", "4", "5", "split"],
input_directory=None,
review_folder=None):
"""
@args mp4box %(__mp4box_doc__)s
""" % {
"__mp4box_doc__": __mp4box_doc__
}
wx.Frame.__init__(self, parent, id, title, size=(600, 500))
if os_utils.which(mp4box) is None:
raise ValueError(
"mp4box binary '%s' not found or not executable (on Ubuntu make sure the package `gpac` is installed)"
% (mp4box, ))
self.mp4box = mp4box
self.undoStack = collections.deque() # the undo stack to track un- and
# redoable categorization
self.redoStack = collections.deque() # the redo stack to track un- and
# redoable categorization
# there's no need to manage state of redo components with a flag (they
# only ought to be enabled if an undoing request has been processed and
# no new categorization has been performed) because information can be
# stored in the enabled state of the redo menu item
mainSplitter = wx.SplitterWindow(self,
wx.ID_ANY,
style=wx.SP_LIVE_UPDATE)
mainSplitter.SetMinimumPaneSize(100)
self.listsPanel = wx.Panel(mainSplitter)
self.videoPanel = wx.Panel(mainSplitter)
self.workingSet = set([])
if input_directory is None:
logger.debug("using empty initial working set")
working_set = set([]) # don't add to self.workingSet before
# addFilesToWorkingSet has been called below
else:
logger.debug("using '%s' as initial input directory" %
(input_directory, ))
working_set = set(
filter(lambda x: os.path.isfile(x), [
os.path.abspath(os.path.join(input_directory, i))
for i in os.listdir(input_directory)
])
) # filter necessary in order to avoid failure of retrieval of min and max in __split_item__
standardPaths = wx.StandardPaths.Get()
self.reviewFolder = review_folder # the folder where video which aren't splitted
# correctly or need other reviewing are moved to; a default value
# is too confusing and setting value by the user should be enforced
self.currentFolder = standardPaths.GetDocumentsDir(
) # stores the folder of the
# last selection of input files (initially set to a convenient
# default value, like $HOME)
self.currentVolume = 0.5
self.menuBar = wx.MenuBar()
self.fileMenu = wx.Menu()
add_files_menu_item = self.fileMenu.Append(wx.ID_ANY, "&Add files",
"Add media file(s)")
add_from_directory_menu_item = self.fileMenu.Append(
wx.ID_ANY, "Add from &directory",
"Add all media files of a directory")
set_review_folder_menu_item = self.fileMenu.Append(
wx.ID_ANY, "&Set review folder", "Set review folder")
self.menuBar.Append(self.fileMenu, '&File')
self.editMenu = wx.Menu()
self.editMenuItemUndo = self.editMenu.Append(wx.ID_ANY, "Undo")
self.editMenuItemRedo = self.editMenu.Append(wx.ID_ANY, "Redo")
self.Bind(wx.EVT_MENU, self.onEditMenuItemUndoClick,
self.editMenuItemUndo)
self.Bind(wx.EVT_MENU, self.onEditMenuItemRedoClick,
self.editMenuItemRedo)
self.menuBar.Append(self.editMenu, "&Edit")
self.helpMenu = wx.Menu()
self.helpMenuAboutItem = self.helpMenu.Append(-1, '&About')
self.Bind(wx.EVT_MENU, self.onAboutBox, self.helpMenuAboutItem)
self.menuBar.Append(self.helpMenu, '&Help')
self.SetMenuBar(self.menuBar)
self.Bind(wx.EVT_MENU, self.onAddFiles, add_files_menu_item)
self.Bind(wx.EVT_MENU, self.onAddFromDirectory,
add_from_directory_menu_item)
self.Bind(wx.EVT_MENU, self.onSetReviewFolder,
set_review_folder_menu_item)
# create sizers (no need for a sizer for splitter)
videoSizer = wx.BoxSizer(wx.VERTICAL)
controlSizer = wx.BoxSizer(wx.HORIZONTAL)
sliderSizer = wx.BoxSizer(wx.HORIZONTAL)
# build the audio bar controls
playButtonImg = self.getBmpFromSvg(
resource_string(
"video_splitter",
os.path.join("resources", "icons", 'play-button.svg')),
icon_size_default, icon_size_default)
self.playButton = buttons.GenBitmapButton(self.videoPanel,
bitmap=playButtonImg,
name="play")
self.playButton.SetInitialSize()
self.playButton.Bind(
wx.EVT_BUTTON,
self.
onPause # handles both play and pause depending on state of the button
)
self.playButton.Disable()
controlSizer.Add(self.playButton, 0, wx.LEFT, 3)
stopButtonImg = self.getBmpFromSvg(
resource_string(
"video_splitter",
os.path.join("resources", "icons", 'stop-button.svg')),
icon_size_default, icon_size_default)
self.stopButton = buttons.GenBitmapButton(self.videoPanel,
bitmap=stopButtonImg,
name="stop")
self.stopButton.SetInitialSize()
self.stopButton.Bind(wx.EVT_BUTTON, self.onStop)
self.stopButton.Disable()
controlSizer.Add(self.stopButton, 0, wx.LEFT, 3)
self.mplayerCtrl = wx.media.MediaCtrl(
self.videoPanel,
-1, #szBackend=wx.media.MEDIABACKEND_GSTREAMER
# `wx.media.MEDIABACKEND_DIRECTSHOW`, `wx.media.MEDIABACKEND_MCI` and `wx.media.MEDIABACKEND_QUICKTIME` fail due to `(video-manager:1392): Gtk-CRITICAL **: IA__gtk_range_set_range: assertion 'min < max' failed` at every video start
)
#self.mplayerCtrl.ShowPlayerControls(wx.media.MEDIACTRLPLAYERCONTROLS_DEFAULT)
self.trackPath = None
self.playbackState = PLAYBACK_STATE_STOPPED
# could be checked with self.playbackTime.IsRunning, but then the
# status depends on using the timer and it's harder to debug issues
# with it
self.playbackSlider = wx.Slider(self.videoPanel, size=wx.DefaultSize)
self.playbackSlider.Bind(wx.EVT_SLIDER, self.onOffsetSet)
sliderSizer.Add(self.playbackSlider, 1, wx.ALL | wx.EXPAND, 5)
# create volume control
self.volumeCtrl = wx.Slider(self.videoPanel, size=(200, -1))
self.volumeCtrl.SetRange(0, 100) # slider only seems to take integers
# (multiply and divide with/by 100)
self.volumeCtrl.SetValue(self.currentVolume * 100)
self.volumeCtrl.Bind(wx.EVT_SLIDER, self.onVolumeSet)
controlSizer.Add(self.volumeCtrl, 0, wx.ALL | wx.EXPAND, 5)
# create track counter
self.trackCounter = wx.StaticText(self.videoPanel, label="00:00")
sliderSizer.Add(self.trackCounter, 0, wx.ALL | wx.CENTER, 5)
# set up playback timer
videoSizer.Add(self.mplayerCtrl, 1, wx.ALL | wx.EXPAND, 5)
videoSizer.Add(sliderSizer, 0, wx.ALL | wx.EXPAND, 5)
videoSizer.Add(controlSizer, 0, wx.ALL | wx.CENTER, 5)
self.videoPanel.SetSizer(videoSizer)
# setup file lists (a splitter has to be used in order to provide
# minimal flexibility; the resize control should be left or right of
# the select and deselect buttons, but it's just a question of decision
# -> use left)
listsButtonSizer = wx.BoxSizer(wx.VERTICAL)
listsPanelSizer = wx.BoxSizer(wx.HORIZONTAL)
listsSplitterPanelRightSizer = wx.BoxSizer(wx.HORIZONTAL)
listsSplitter = wx.SplitterWindow(
self.listsPanel, style=wx.SP_LIVE_UPDATE
) # doesn't expand automatically (although should because it's the only component in listPanel) -> use listsPanelSizer
listsSplitter.SetMinimumPaneSize(100)
listsPanelSizer.Add(listsSplitter, 1, wx.ALL | wx.EXPAND, 5)
self.listsPanel.SetSizer(listsPanelSizer)
listsSplitterPanelLeft = wx.Panel(parent=listsSplitter)
listsSplitterPanelRight = wx.Panel(parent=listsSplitter)
self.workingSetList = wx.ListCtrl(
parent=listsSplitterPanelLeft, id=wx.ID_ANY,
style=wx.LC_REPORT) # don't make entries editable
workingSetListSizer = wx.BoxSizer(wx.VERTICAL)
categoryButtonSizer = wx.WrapSizer(wx.HORIZONTAL)
mergeListSizer = wx.BoxSizer(wx.VERTICAL)
self.selectButton = wx.Button(parent=listsSplitterPanelRight,
id=wx.ID_ANY,
label=">",
size=wx.Size(icon_size_default,
icon_size_default))
self.deselectButton = wx.Button(parent=listsSplitterPanelRight,
id=wx.ID_ANY,
label="<",
size=wx.Size(icon_size_default,
icon_size_default))
self.mergeList = wx.ListCtrl(parent=listsSplitterPanelRight,
id=wx.ID_ANY,
style=wx.LC_REPORT)
self.workingSetList.InsertColumn(0,
heading="File",
width=wx.LIST_AUTOSIZE)
self.mergeList.InsertColumn(0, heading="File", width=wx.LIST_AUTOSIZE)
self.mergeButton = wx.Button(parent=listsSplitterPanelRight,
id=wx.ID_ANY,
label="merge")
for category in categories:
category_button = wx.Button(parent=listsSplitterPanelLeft,
id=wx.ID_ANY,
label=str(category))
categoryButtonSizer.Add(category_button, 0, wx.ALL, 5)
# unable to determine minimal width at this point
def __createCategoryButtonClickCallback__(category):
def __onCategoryButtonClick__(event):
if self.reviewFolder is None:
wx.MessageBox("review folder isn't set", 'Info',
wx.OK | wx.ICON_INFORMATION)
return
selected_index = self.workingSetList.GetNextSelected(-1)
if selected_index == -1:
logger.debug(
"no item selected in working set list, so nothing to categorize"
)
return
selected_item = self.workingSetList.GetItem(selected_index,
col=0)
# playback should be stopped before moving file
selected_item_playbacked = False # store info for later (much simpler code for the price of one flag)
if selected_item.GetText() == self.trackPath:
selected_item_playbacked = True
self.stopPlayback()
category_folder = os.path.join(self.reviewFolder,
str(category))
if not os.path.exists(category_folder):
os.makedirs(category_folder)
logger.debug("moving '%s' into category folder '%s'" %
(selected_item.GetText(), category_folder))
shutil.move(
selected_item.GetText(),
os.path.join(category_folder,
os.path.basename(
selected_item.GetText())))
self.workingSetList.DeleteItem(selected_index)
self.undoStack.append(
(selected_item.GetText(), category, selected_index))
self.editMenuItemRedo.Enable(False)
self.redoStack.clear()
# automatically start the next item after the categorized in workingSetList in order to proceed faster and select it (but only if the just moved item is currently playbacked because otherwise the playback of another item would be interrupted)
if self.workingSetList.GetItemCount() > 0 \
and selected_index < self.workingSetList.GetItemCount()-1 \
and selected_item_playbacked: # there needs to be one more item after the categorized one (refers to item count after removal of categorized item)
selected_item = self.workingSetList.GetItem(
selected_index, col=0)
self.trackPath = selected_item.GetText()
logger.info("starting video '%s'" % (self.trackPath, ))
self.startVideo(self.trackPath)
self.workingSetList.SetItemState(
selected_index, # item
wx.LIST_STATE_SELECTED, # state
wx.LIST_STATE_SELECTED # stateMask
)
return __onCategoryButtonClick__
category_button.Bind(
wx.EVT_BUTTON, __createCategoryButtonClickCallback__(category))
workingSetListSizer.Add(categoryButtonSizer, 0, wx.ALL | wx.EXPAND, 5)
workingSetListSizer.Add(self.workingSetList, 1, wx.ALL | wx.EXPAND, 5)
listsSplitterPanelLeft.SetSizer(workingSetListSizer)
listsButtonSizer.Add(self.selectButton, 0, wx.ALL, 5)
listsButtonSizer.Add(self.deselectButton, 0, wx.ALL, 5)
listsSplitterPanelRightSizer.Add(listsButtonSizer, 0, wx.ALL, 5)
mergeListSizer.Add(self.mergeList, 1, wx.ALL | wx.EXPAND, 5)
mergeListSizer.Add(self.mergeButton, 0, wx.ALIGN_BOTTOM | wx.ALL, 5)
listsSplitterPanelRightSizer.Add(mergeListSizer, 1, wx.EXPAND, 5)
listsSplitterPanelRight.SetSizer(listsSplitterPanelRightSizer)
self.workingSetList.Bind(
wx.
EVT_LIST_ITEM_ACTIVATED, #The item has been activated (ENTER or double click). Processes a wxEVT_LIST_ITEM_ACTIVATED event type.
self.onWorkingSetListDoubleClick)
self.workingSetList.Bind(wx.EVT_LIST_ITEM_SELECTED,
self.onWorkingSetListSelect)
self.workingSetList.Bind(wx.EVT_LIST_ITEM_DESELECTED,
self.onWorkingSetListDeselect)
self.mergeList.Bind(
wx.
EVT_LIST_ITEM_ACTIVATED, #The item has been activated (ENTER or double click). Processes a wxEVT_LIST_ITEM_ACTIVATED event type.
self.onMergeListDoubleClick)
self.mergeList.Bind(wx.EVT_LIST_ITEM_SELECTED, self.onMergeListSelect)
self.mergeList.Bind(wx.EVT_LIST_ITEM_DESELECTED,
self.onMergeListDeselect)
self.selectButton.Bind(wx.EVT_BUTTON, self.onSelectButtonClick)
self.deselectButton.Bind(wx.EVT_BUTTON, self.onDeselectButtonClick)
self.mergeButton.Bind(wx.EVT_BUTTON, self.onMergeButtonClick)
self.workingSetList.Bind(wx.EVT_LIST_ITEM_RIGHT_CLICK,
self.onWorkingSetListRightClick)
listsSplitter.SplitVertically(listsSplitterPanelLeft,
listsSplitterPanelRight)
mainSplitter.SplitVertically(self.listsPanel, self.videoPanel)
self.Bind(wx.media.EVT_MEDIA_PLAY, self.onMediaStarted)
self.Bind(wx.media.EVT_MEDIA_FINISHED, self.onMediaFinished)
# working set list popup menu
self.workingSetListPopupMenu = wx.Menu()
self.workingSetListPopupMenuItemClear = self.workingSetListPopupMenu.Append(
wx.ID_ANY, "Clear working set")
self.workingSetListPopupMenuItemDelete = self.workingSetListPopupMenu.Append(
wx.ID_ANY, "Move to trash")
self.Bind(wx.EVT_MENU, self.onWorkingSetListPopupMenuItemClearClick,
self.workingSetListPopupMenuItemClear
) # MenuItem doesn't have a Bind function
self.Bind(wx.EVT_MENU, self.onWorkingSetListPopupMenuItemDeleteClick,
self.workingSetListPopupMenuItemDelete)
# set up components
self.statusBar = self.CreateStatusBar(style=wx.STB_DEFAULT_STYLE)
self.statusBar.SetFieldsCount(1)
self.statusBar.SetStatusStyles(
[wx.SB_NORMAL]
) # @TODO: wx.SB_SUNKEN only available after 2.9.5<ref>http://wxpython.org/Phoenix/docs/html/StatusBar.html</ref> -> assert 3.0.x at run and compile time somewhere
self.addFilesToWorkingSet(
working_set) # run after self.workingSetList has been initialized
self.workingSet = working_set
self.updateReviewFolderStatusText()
self.Show(True)
def createGui(self):
self.subSizers = []
self.mainSizer = wx.BoxSizer(wx.VERTICAL)
self.numberOfCells = self.numberOfRows[0] * self.numberOfColumns[0]
if self.control != 'tracker':
event = eval('wx.EVT_LEFT_DOWN')
else:
event = eval('wx.EVT_BUTTON')
for page in self.panels.keys():
subSizer = wx.GridBagSizer(self.xBorder, self.yBorder)
self.subSizers.append(subSizer)
if self.panels != {1: [[], []]}:
index = 0
for index, logo in enumerate(self.panels[page][1]):
b = bt.GenBitmapButton(self,
-1,
name=self.panels[page][0][index],
bitmap=logo)
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(event, self.onPress)
subSizer.Add(b, (index / self.numberOfColumns[0],
index % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
else:
index = -1
index_2 = 0
while index + index_2 < self.numberOfCells - (
self.numberOfColumns[0] + 1):
index_2 += 1
b = bt.GenButton(self, -1, name='empty')
b.Bind(event, self.onPress)
b.SetBackgroundColour(self.backgroundColour)
subSizer.Add(b, ((index + index_2) / self.numberOfColumns[0],
(index + index_2) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
b = bt.GenBitmapButton(self,
-1,
bitmap=self.functionButtonPath[0],
name=self.functionButtonName[0])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(event, self.onPress)
subSizer.Add(b, ((index + index_2 + 1) / self.numberOfColumns[0],
(index + index_2 + 1) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
b = bt.GenBitmapButton(self,
-1,
bitmap=self.functionButtonPath[1],
name=self.functionButtonName[1])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(event, self.onPress)
subSizer.Add(b, ((index + index_2 + 2) / self.numberOfColumns[0],
(index + index_2 + 2) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
b = bt.GenBitmapButton(self,
-1,
bitmap=self.functionButtonPath[2],
name=self.functionButtonName[2])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(event, self.onPress)
subSizer.Add(b, ((index + index_2 + 3) / self.numberOfColumns[0],
(index + index_2 + 3) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
b = bt.GenBitmapButton(self,
-1,
bitmap=self.functionButtonPath[3],
name=self.functionButtonName[3])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(event, self.onPress)
subSizer.Add(b, ((index + index_2 + 4) / self.numberOfColumns[0],
(index + index_2 + 4) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
b = bt.GenBitmapButton(self,
-1,
bitmap=self.functionButtonPath[4],
name=self.functionButtonName[4])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(event, self.onPress)
subSizer.Add(b, ((index + index_2 + 5) / self.numberOfColumns[0],
(index + index_2 + 5) % self.numberOfColumns[0]),
wx.DefaultSpan, wx.EXPAND)
for number in range(self.numberOfRows[0]):
subSizer.AddGrowableRow(number)
for number in range(self.numberOfColumns[0]):
subSizer.AddGrowableCol(number)
self.Layout()
self.mainSizer.Add(subSizer,
proportion=1,
flag=wx.EXPAND | wx.LEFT | wx.RIGHT | wx.TOP
| wx.BOTTOM,
border=self.xBorder)
self.SetSizer(self.mainSizer)
self.Center(True)
if page != 1:
self.mainSizer.Show(item=self.subSizers[page - 1],
show=False,
recursive=True)
self.SetSizer(self.mainSizer)
def layoutControls(self):
#Setting Background Colours
backColour = wx.CYAN
self._bottomPanel.SetBackgroundColour(backColour)
try:
self._mediaPlayer = wx.media.MediaCtrl(
self._bottomPanel,
style=wx.SIMPLE_BORDER,
szBackend=wx.media.MEDIABACKEND_WMP10)
except:
self._bottomPanel.Destroy()
self._rightPanel.Destroy()
self._leftPanel.Destroy()
self.Destroy()
raise
self.Bind(wx.media.EVT_MEDIA_LOADED, self.OnPlayPause)
self.Bind(wx.media.EVT_MEDIA_FINISHED, self.OnForward)
#Creating Main Sizer
hbox = wx.BoxSizer()
#Creating a sizer
sizer = wx.GridBagSizer(0, 20)
#Static Text for showing Song name and Artist name
self._st = wx.StaticText(self._bottomPanel, label='')
self._st.SetFont(self._font)
self._st2 = wx.StaticText(self._bottomPanel, label='')
self._st3 = wx.StaticText(self._bottomPanel, label='')
#Adding the static text to sizer
hbox.Add(self._st,
proportion=1,
flag=wx.EXPAND | wx.TOP | wx.BOTTOM | wx.LEFT,
border=20)
sizer.Add(self._st2, pos=(1, 0), span=(1, 1), flag=wx.TOP, border=5)
#Creating previous button for music control
bitmap = wx.Bitmap(os.path.join(bitmapDir, 'previous.png'))
self._backBtn = buttons.GenBitmapButton(self._bottomPanel,
bitmap=bitmap,
name='Previous')
self._backBtn.SetBackgroundColour(backColour)
self._backBtn.SetBezelWidth(0)
#Binding the button to the handler
self._backBtn.Bind(wx.EVT_BUTTON, self.OnBack)
#Adding the button in sizer
sizer.Add(self._backBtn,
pos=(0, 1),
span=(1, 1),
flag=wx.TOP,
border=7)
#Creating the play-pause button
img = wx.Bitmap(os.path.join(bitmapDir, 'play-button.png'))
self._playPauseBtn = buttons.GenBitmapToggleButton(self._bottomPanel,
bitmap=img,
name='Play')
#If there is no music the button is disabled
if len(self.musicList) == 0:
self._playPauseBtn.Enable(False)
img = wx.Bitmap(os.path.join(bitmapDir, 'pause-button.png'))
self._playPauseBtn.SetBitmapSelected(img)
self._playPauseBtn.SetBackgroundColour(backColour)
self._playPauseBtn.SetBezelWidth(0)
#Binding the play-pause button to the handler
self._playPauseBtn.Bind(wx.EVT_BUTTON, self.OnPlayPause)
#Adding the play-pause button to the sizer
sizer.Add(self._playPauseBtn, pos=(0, 2), span=(1, 1))
#Creating the forward button for music control
bitmap = wx.Bitmap(os.path.join(bitmapDir, 'forward.png'))
self._forwardBtn = buttons.GenBitmapButton(self._bottomPanel,
bitmap=bitmap,
name='Forward')
self._forwardBtn.SetBackgroundColour(backColour)
self._forwardBtn.SetBezelWidth(0)
#Binding the button to its handler
self._forwardBtn.Bind(wx.EVT_BUTTON, self.OnForward)
#Adding the button to the sizer
sizer.Add(self._forwardBtn,
pos=(0, 3),
span=(1, 1),
flag=wx.TOP,
border=5)
#Creating music slider
self._musicSlider = Slider(parent=self._bottomPanel,
leftGap=8,
rightGap=9)
#Adding the slider to its handler
self._musicSlider.Bind(wx.EVT_SLIDER, self.OnSeek)
#Adding the slider to the sizer
sizer.Add(self._musicSlider,
pos=(1, 1),
span=(1, 3),
flag=wx.EXPAND | wx.BOTTOM,
border=10)
self.timer = wx.Timer(self._bottomPanel)
self.timer.Start(1000)
#Binding the Timer
self._bottomPanel.Bind(wx.EVT_TIMER, self.OnTimer)
sizer.Add(self._st3, pos=(1, 4), span=(1, 1), flag=wx.TOP, border=5)
#Creating a button for mute
bitmap = wx.Bitmap(os.path.join(bitmapDir, 'sound-level3.png'))
self._soundBtn = buttons.GenBitmapToggleButton(self._bottomPanel,
bitmap=bitmap,
name='Sound')
self._soundBtn.SetBackgroundColour(backColour)
self._soundBtn.SetBezelWidth(0)
bitmap = wx.Bitmap(os.path.join(bitmapDir, 'no-sound.png'))
self._soundBtn.SetBitmapSelected(bitmap)
#Adding the button to its handler
self._soundBtn.Bind(wx.EVT_BUTTON, self.OnMute)
#Adding the button to the sizer
sizer.Add(self._soundBtn,
pos=(0, 5),
span=(1, 1),
flag=wx.TOP,
border=5)
#Creating a volume slider
self._volumeSlider = Slider(parent=self._bottomPanel,
leftGap=8,
rightGap=9,
style=wx.SL_VALUE_LABEL)
self._volumeSlider.SetRange(0, 100)
self._volumeSlider.SetValue(self.volume)
#Adding the volume slider to its handler
self._volumeSlider.Bind(wx.EVT_SLIDER, self.OnVolume)
#Adding the volume slider to the sizer
sizer.Add(self._volumeSlider,
pos=(0, 6),
span=(1, 2),
flag=wx.RIGHT | wx.TOP,
border=10)
sizer.AddGrowableCol(4)
hbox.Add(sizer, proportion=3, flag=wx.EXPAND)
self._bottomPanel.SetSizer(hbox)
self._bottomPanel.SetBackgroundColour(backColour)
def __init__(self, parent, n): """ Method that initializes the class """ wx.Panel.__init__(self, parent, -1, size = (1024, 34)) #wx.SashLayoutWind#ow.__init__(self,parent,-1) self.sizer = wx.BoxSizer(wx.HORIZONTAL) #self.SetBackgroundColour((255,0,0)) iconpath = scripting.get_icon_dir() self.rangeMax = n self.buttonPanel = wx.Panel(self, -1, size = (48, -1), style = wx.RAISED_BORDER) self.buttonSizer = wx.BoxSizer(wx.HORIZONTAL) self.buttonPanel.SetSizer(self.buttonSizer) self.buttonPanel.SetAutoLayout(1) self.nextIcon = wx.Image(os.path.join(iconpath, "next.gif"), wx.BITMAP_TYPE_GIF).ConvertToBitmap() self.prevIcon = wx.Image(os.path.join(iconpath, "previous.gif"), wx.BITMAP_TYPE_GIF).ConvertToBitmap() self.playIcon = wx.Image(os.path.join(iconpath, "player_play.gif"), wx.BITMAP_TYPE_GIF).ConvertToBitmap() self.pauseIcon = wx.Image(os.path.join(iconpath, "player_pause.gif"), wx.BITMAP_TYPE_GIF).ConvertToBitmap() #self.stopicon = wx.Image(os.path.join(iconpath,"stop.gif"),wx.BITMAP_TYPE_GIF).ConvertToBitmap() self.beginIcon = wx.Image(os.path.join(iconpath, "player_start.gif"), wx.BITMAP_TYPE_GIF).ConvertToBitmap() self.endIcon = wx.Image(os.path.join(iconpath, "player_end.gif"), wx.BITMAP_TYPE_GIF).ConvertToBitmap() #self.playpause=buttons.GenBitmapButton(self,-1,self.playicon) #self.stop = buttons.GenBitmapButton(self,-1,self.stopicon) self.beginButton = buttons.GenBitmapButton(self.buttonPanel, -1, self.beginIcon, style = wx.BORDER_NONE) self.prevButton = buttons.GenBitmapButton(self.buttonPanel, -1, self.prevIcon, style = wx.BORDER_NONE) self.playButton = buttons.GenBitmapButton(self.buttonPanel, -1, self.playIcon, style = wx.BORDER_NONE) self.pauseButton = buttons.GenBitmapButton(self.buttonPanel, -1, self.pauseIcon, style = wx.BORDER_NONE) self.nextButton = buttons.GenBitmapButton(self.buttonPanel, -1, self.nextIcon, style = wx.BORDER_NONE) self.endButton = buttons.GenBitmapButton(self.buttonPanel, -1, self.endIcon, style = wx.BORDER_NONE) self.nextButton.Bind(wx.EVT_BUTTON, self.onNextFrame) self.prevButton.Bind(wx.EVT_BUTTON, self.onPrevFrame) self.beginButton.Bind(wx.EVT_BUTTON, self.onFirstFrame) self.endButton.Bind(wx.EVT_BUTTON, self.onLastFrame) self.playButton.Bind(wx.EVT_BUTTON, self.onPlay) self.pauseButton.Bind(wx.EVT_BUTTON, self.onPause) self.timeslider = wx.Slider(self, size = (32, -1), value = 1, minValue = 1, maxValue = n, style = wx.SL_HORIZONTAL | wx.SL_AUTOTICKS | wx.SL_LABELS) #self.sizer.Add(self.playpause,) #self.sizer.Add(self.stop) for btn in [self.beginButton, self.prevButton, self.playButton, self.pauseButton, self.nextButton, self.endButton]: btn.SetBestSize((24, 24)) self.buttonSizer.Add(btn) self.buttonSizer.Fit(self.buttonPanel) self.sizer.Add(self.buttonPanel, 0, flag = wx.ALIGN_CENTER_VERTICAL) self.sizer.Add(self.timeslider, 1, flag = wx.EXPAND | wx.ALIGN_CENTER_VERTICAL) self.callback = None self.changing = 0 #self.playpause.Bind(wx.EVT_BUTTON,self.onPlayPause) #self.stop.Bind(wx.EVT_BUTTON,self.onStop) #self.stop.Enable(0) self.pauseButton.Enable(0) self.SetSizer(self.sizer) self.SetAutoLayout(1) self.sizer.Fit(self) lib.messenger.connect(None, "set_timeslider_value", self.onSetTimeslider) lib.messenger.connect(None, "set_frames", self.onSetFrames) lib.messenger.connect(None, "timepoint_changed", self.onSetTimepoint) lib.messenger.connect(None, "set_play_mode", self.onSetPlay)
def createGui(self):
self.thicknessOfExternalBorder = self.xBorder # factor related to the border of the entire board
self.thicknessOfInternalBorder = self.xBorder # factor related to the border of every button
self.mainSizer = wx.BoxSizer(wx.VERTICAL)
self.subSizer = wx.GridBagSizer(self.xBorder, self.yBorder)
if self.control != 'tracker':
event = eval('wx.EVT_LEFT_DOWN')
else:
event = eval('wx.EVT_BUTTON')
self.buttonsBoardWidth = self.winWidth - self.thicknessOfExternalBorder * 2 - self.thicknessOfInternalBorder * (
self.numberOfColumns - 1)
self.buttonsBoardHeight = (
self.winHeight - 20
) - self.thicknessOfExternalBorder * 3 - self.thicknessOfInternalBorder * (
self.numberOfRows - 1) # -20 because of the Unity upper bar
for index_1, item in enumerate(self.labels):
if item in self.indexes:
name = str(int(item))
b = bt.GenBitmapButton(
self,
-1,
bitmap=self.iconBitmaps[name],
size=(self.buttonsBoardWidth / float(self.numberOfColumns),
self.buttonsBoardHeight / float(self.numberOfRows)))
else:
if item == -1.0:
name = 'empty'
b = bt.GenBitmapButton(
self,
-1,
bitmap=self.iconBitmaps[name],
size=(self.buttonsBoardWidth / float(self.numberOfColumns),
self.buttonsBoardHeight / float(self.numberOfRows)))
b.SetFont(
wx.Font(65, wx.FONTFAMILY_ROMAN, wx.FONTSTYLE_NORMAL,
wx.FONTWEIGHT_NORMAL, False))
b.name = (index_1 /
self.numberOfColumns), (index_1 % self.numberOfRows) + 1
b.SetBezelWidth(1)
b.SetBackgroundColour(self.backgroundColour)
b.Bind(event, self.onPress)
self.subSizer.Add(b, (index_1 / self.numberOfColumns,
index_1 % self.numberOfColumns),
wx.DefaultSpan, wx.EXPAND)
for index_2, item in enumerate(self.options, start=1):
if index_2 == 1:
if self.winstate:
b = bt.GenButton(self,
-1,
u'WYGRYWASZ!',
size=(self.buttonsBoardWidth /
float(self.numberOfColumns),
self.buttonsBoardHeight /
float(self.numberOfRows)))
b.SetFont(
wx.Font(27, wx.FONTFAMILY_ROMAN, wx.FONTSTYLE_NORMAL,
wx.FONTWEIGHT_NORMAL, False))
else:
b = bt.GenBitmapButton(self,
-1,
bitmap=self.iconBitmaps['restart'])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(event, self.onPress)
self.subSizer.Add(b,
((index_1 + index_2) / self.numberOfColumns,
(index_1 + index_2) % self.numberOfColumns),
(1, 3), wx.EXPAND)
else:
b = bt.GenBitmapButton(self,
-1,
bitmap=self.iconBitmaps['exit'])
b.SetBackgroundColour(self.backgroundColour)
b.SetBezelWidth(3)
b.Bind(event, self.onPress)
self.subSizer.Add(
b, ((index_1 + index_2 + 2) / self.numberOfColumns,
(index_1 + index_2 + 2) % self.numberOfColumns),
(1, 2), wx.EXPAND)
b.name = ((index_1 + index_2) / self.numberOfRows), (
(index_1 + index_2) % self.numberOfColumns) + 1
self.mainSizer.Add(self.subSizer,
proportion=1,
flag=wx.EXPAND | wx.TOP | wx.LEFT,
border=self.xBorder)
self.SetSizer(self.mainSizer, deleteOld=True)
self.Layout()
self.Refresh()
self.Center()
def __init__(self, *args, **kwds):
# from *args
if len(args) == 0:
dlg = wx.MessageDialog(self, 'Parameters setting error', 'Error',
wx.OK)
dlg.ShowModal()
dlg.Destroy()
return False
#self.classid = args[0][0]
#self.kidList = args[0][1]
#self.adultList = args[0][2]
self.recordFileName = args[0][0] #args[0][3]
# local variables
self.siteList = self.GetSiteList()
self.kidList = self.GetKidList()
self.adultList = self.GetAdultList()
self.observerList = self.GetObserverList()
self.classList = self.GetClassList()
self.activityList = self.GetActivityList()
self.rndKidList = self.kidList[:]
self.rndKidList.insert(0, 'Random Select Child')
self.vaKidList = self.kidList + self.adultList
self.vaKidList.insert(0, '')
self.vaKidList.insert(1, '?')
self.record = None
self.currentGauge = 1
self.observerDict = self.GetRoundInfo()
self.currentObserver = ''
# GUI
kwds["style"] = wx.DEFAULT_FRAME_STYLE
wx.Frame.__init__(self, None, -1, **kwds)
self.CreateStatusBar()
panel = wx.Panel(self, -1)
self.SetBackgroundColour((217, 241, 255))
self.label_30 = wx.StaticText(panel, -1, '')
self.label_31 = wx.StaticText(panel, -1, "Current observation #:")
self.input1 = wx.TextCtrl(panel, -1, '', (95, 105))
self.label_20 = wx.StaticText(panel, -1, "Date:")
self.label_21 = wx.StaticText(panel, -1, "")
self.label_22 = wx.StaticText(panel, -1, "Observer:")
self.combo_box_ObserverList = wx.ComboBox(panel,
-1,
choices=self.observerList,
style=wx.CB_DROPDOWN)
self.label_23 = wx.StaticText(panel, -1, "Class:")
self.combo_box_ClassList = wx.ComboBox(panel,
-1,
choices=self.classList,
style=wx.CB_DROPDOWN)
self.label_24 = wx.StaticText(panel, -1, "Round# (today):")
#roundList = [str(i) for i in range(1,21)]
#roundList.insert(0,'')
#self.combo_box_RoundList= wx.ComboBox(panel, -1, choices=roundList, style=wx.CB_DROPDOWN)
self.label_26 = wx.StaticText(panel, -1, "# Children present:")
#self.label_27 = wx.StaticText(panel, -1, "")
numOfChild = [str(i) for i in range(1, len(self.kidList))]
numOfChild.insert(0, '')
self.combo_box_ChildrenPresent = wx.ComboBox(panel,
-1,
choices=numOfChild,
style=wx.CB_DROPDOWN)
self.label_28 = wx.StaticText(panel, -1, "Site:")
self.combo_box_SiteList = wx.ComboBox(panel,
-1,
choices=self.siteList,
style=wx.CB_DROPDOWN)
self.label_29 = wx.StaticText(panel, -1, "Activity setting:")
self.combo_box_ActivityList = wx.ComboBox(panel,
-1,
choices=self.activityList,
style=wx.CB_DROPDOWN)
self.button_randSelKid = buttons.GenBitmapButton(
panel, -1, bitRedDice.getsmall_red_diceBitmap(), style=1)
self.combo_box_RndChildList = wx.ComboBox(panel,
-1,
choices=self.rndKidList,
style=wx.CB_DROPDOWN)
self.button_StartRecord = wx.Button(panel, -1, "Start Recording")
self.button_SaveRecord = wx.Button(panel, -1, "Save Record")
self.button_DiscardRecord = wx.Button(panel, -1, "Discard Record")
self.gauge_Timer = wx.Gauge(panel, -1, size=(100, 30))
self.gauge_Timer1 = wx.Gauge(panel, -1, size=(100, 30))
self.label_6 = wx.StaticText(panel, -1, "Attention:")
self.radio_box_Attend = wx.RadioBox(panel,
-1,
"",
choices=["N/A", "Glance", "Look"],
majorDimension=0,
style=wx.RA_SPECIFY_ROWS)
self.label_1 = wx.StaticText(panel, -1, "Joint Attention To:")
self.label_2 = wx.StaticText(panel, -1, "Attend Target 1:")
self.combo_box_TargetChildList1 = wx.ComboBox(panel,
-1,
choices=self.vaKidList,
style=wx.CB_DROPDOWN)
self.label_3 = wx.StaticText(panel, -1, "Attend Target 2:")
self.combo_box_TargetChildList2 = wx.ComboBox(panel,
-1,
choices=self.vaKidList,
style=wx.CB_DROPDOWN)
self.label_4 = wx.StaticText(panel, -1, "Attend Target 3:")
self.combo_box_TargetChildList3 = wx.ComboBox(panel,
-1,
choices=self.vaKidList,
style=wx.CB_DROPDOWN)
self.label_5 = wx.StaticText(panel, -1, "Attend Target 4:")
self.combo_box_TargetChildList4 = wx.ComboBox(panel,
-1,
choices=self.vaKidList,
style=wx.CB_DROPDOWN)
self.label_7 = wx.StaticText(panel, -1, "Affect:")
self.radio_box_Affect = wx.RadioBox(
panel,
-1,
"",
choices=["N/A", "Positive", "Neutral", "Negtive"],
majorDimension=0,
style=wx.RA_SPECIFY_ROWS)
self.label_8 = wx.StaticText(panel, -1, "6 seconds timer:")
self.label_9 = wx.StaticText(
panel, -1, """
Coder Note: Observe the target child for a period 6-sec.\
Identify each person with whom the target child follows attending behavior.\
Episodes of joint attention are coded as "G" if the child looks briefly (<3-sec) \
at the reference object and coded as "L"\
if the child looks for a longer (>=3-sec). \
After scoring "G" or "L", record affect.
""")
self.led = gizmos.LEDNumberCtrl(panel, -1)
self.__set_properties()
#self.__do_layout()
self.Bind(wx.EVT_BUTTON, self.RandomSelectChild,
self.button_randSelKid)
self.Bind(wx.EVT_COMBOBOX, self.RandomChildSelected,
self.combo_box_RndChildList)
self.Bind(wx.EVT_BUTTON, self.StartRecord, self.button_StartRecord)
self.Bind(wx.EVT_BUTTON, self.SaveRecord, self.button_SaveRecord)
self.Bind(wx.EVT_BUTTON, self.DiscardRecord, self.button_DiscardRecord)
self.Bind(wx.EVT_COMBOBOX, self.SelectVisualTarget1,
self.combo_box_TargetChildList1)
self.Bind(wx.EVT_COMBOBOX, self.SelectVisualTarget2,
self.combo_box_TargetChildList2)
self.Bind(wx.EVT_COMBOBOX, self.SelectVisualTarget3,
self.combo_box_TargetChildList3)
self.Bind(wx.EVT_COMBOBOX, self.SelectVisualTarget4,
self.combo_box_TargetChildList4)
self.Bind(wx.EVT_RADIOBOX, self.SelectAttend, self.radio_box_Attend)
self.Bind(wx.EVT_RADIOBOX, self.SelectAffect, self.radio_box_Affect)
self.Bind(wx.EVT_COMBOBOX, self.ObserverSelected,
self.combo_box_ObserverList)
id1 = wx.NewId()
wx.RegisterId(id1)
self.timer = wx.Timer(self, id1)
self.Bind(wx.EVT_TIMER, self.OnTimer, self.timer, id1)
id2 = wx.NewId()
wx.RegisterId(id1)
self.statusTimer = wx.Timer(self, id2)
self.Bind(wx.EVT_TIMER, self.OnStatusTimer, self.statusTimer, id2)
self.count = 0
self.statusTimer.Start(1000)
self.OnStatusTimer(None)
