class Switch_implementare(GridLayout):
def __init__(self, **kwargs):
super(Switch_implementare, self).__init__(**kwargs)
self.cols = 1
self.padding = 150
self.switch1 = Switch()
self.switch1.active = True
self.add_widget(self.switch1)
self.arata_volum = Label(text="volum: 10")
self.add_widget(self.arata_volum)
self.slide_muzica = Slider(min=0, max=100, value=10)
self.slide_muzica.step = 5
self.slide_muzica.orientation = "horizontal" # alte optiuni 'vertical'
self.add_widget(self.slide_muzica)
self.switch1.bind(active=self.dezactiveaza_volum)
self.slide_muzica.bind(value=self.valoare_volum)
def valoare_volum(self, x, y):
'''utilziat pentru a vedea volumul'''
self.arata_volum.text = "volum: " + str(int(self.slide_muzica.value))
def dezactiveaza_volum(self, x, y):
'''utilziat pentru a acctiva sau a dezactiva slider-ul'''
if (self.switch1.active == False):
self.slide_muzica.disabled = True
else:
self.slide_muzica.disabled = False
self.slide_muzica.value = 0
def build(self):
Config.set('graphics', 'width', 320)
Config.set('graphics', 'height', 512)
print(kivy.__version__)
# -------- funciones -------------
def sw(instance, value):
print('the switch', instance, 'is', value)
print(layout.size)
if value:
labelMensaje.text = "ACTIVADO."
print(kivy.__version__)
else:
labelMensaje.text = "DESACTIVADO."
# capas layout
layout = BoxLayout(spacing=2, orientation="horizontal", padding=30)
layout2 = BoxLayout(spacing=10, orientation="vertical", padding=30)
# elementos widgets
labelsw1 = Label(text="Luz del pasillo:")
btn1 = Button(text='Entrar')
labelMensaje = Label(text="DESACTIVADO.", font_size=30)
switch = Switch()
layout.add_widget(switch, index=0)
layout.add_widget(labelsw1, index=1)
layout2.add_widget(layout, index=2)
layout2.add_widget(btn1, index=0)
layout2.add_widget(labelMensaje, index=1)
switch.bind(active=sw)
return layout2
def build(self):
if platform == "android":
from android import AndroidService
service = AndroidService('desire sensors service', 'running')
service.start('service started')
self.service = service
status_page = StatusPage()
accelerometer.enable()
compass.enable()
self.gps = gps
self.gps.configure(on_location=self.on_gps_location,
on_status=self.on_gps_status)
self.gps.start()
notification.notify(title="Hello",message="Just Checking")
#vibrator.vibrate(0.2) # vibrate for 0.2 seconds
print("Hello World")
status_page.gps_data = self.gps_data
# Clock.schedule_interval(status_page.update, 1.0 / 10.0) # 10H
Clock.schedule_interval(status_page.update, 1.0) # 1Hz
button=Button(text='Service',size_hint=(0.12,0.12))
button.bind(on_press=self.callback)
status_page.add_widget(button)
switch = Switch()
switch.bind(active=self.callback)
status_page.add_widget(switch)
return status_page
def build_overview(self):
alarm_overview = self.ids['Alarm_Overview_Stack']
alarm_overview.bind(minimum_height=alarm_overview.setter('height'))
alarm_overview.clear_widgets(children=None)
SortedAlarms = sorted(Alarms,
key=lambda Alarm: Alarm.MinutesAfterMidnight())
for alarm in SortedAlarms:
alarm_overview.add_widget(
Label(text=alarm.to_string(),
font_size=25,
height=80,
size_hint=(0.4, None)))
alarm_switch = Switch(active=alarm.IsActive,
height=80,
size_hint=(0.3, None))
alarm_switch.bind(active=alarm.toggle_active)
alarm_delete = Button(
background_normal='images/AccordionSelected.png',
height=64,
size_hint=(0.2, None))
alarm_delete.bind(on_press=partial(self.delete_alarm, alarm))
alarm_overview.add_widget(alarm_switch)
alarm_overview.add_widget(alarm_delete)
def build(self):
if platform == "android":
from android import AndroidService
service = AndroidService('desire sensors service', 'running')
service.start('service started')
self.service = service
status_page = StatusPage()
accelerometer.enable()
compass.enable()
self.gps = gps
self.gps.configure(on_location=self.on_gps_location,
on_status=self.on_gps_status)
self.gps.start()
notification.notify(title="Hello", message="Just Checking")
#vibrator.vibrate(0.2) # vibrate for 0.2 seconds
print("Hello World")
status_page.gps_data = self.gps_data
# Clock.schedule_interval(status_page.update, 1.0 / 10.0) # 10H
Clock.schedule_interval(status_page.update, 1.0) # 1Hz
button = Button(text='Service', size_hint=(0.12, 0.12))
button.bind(on_press=self.callback)
status_page.add_widget(button)
switch = Switch()
switch.bind(active=self.callback)
status_page.add_widget(switch)
return status_page
class FftWidget(GridLayout):
def __init__(self, **kwargs):
self.rows = 1
self.cols = 1
GridLayout.__init__(self, **kwargs)
topLayout = BoxLayout(orientation="vertical")
midLayout = BoxLayout(orientation="horizontal", size_hint=(1.0, 0.8))
swLayout = BoxLayout(orientation="vertical", size_hint=(0.2, 1.0))
swLayout.add_widget(Label(text="Zoom"))
self.zs = Switch()
self.zs.bind(active=self.zoomSwitchLogic)
swLayout.add_widget(self.zs)
swLayout.add_widget(Label(text="Pan"))
self.ps = Switch()
self.ps.bind(active=self.panSwitchLogic)
swLayout.add_widget(self.ps)
midLayout.add_widget(Renderer(self.zs, self.ps, size_hint=(0.8, 1.0)))
midLayout.add_widget(swLayout)
topLayout.add_widget(Button(text="first", size_hint=(1.0, 0.1)))
#topLayout.add_widget(Renderer(size_hint=(1.0, 0.8)))
topLayout.add_widget(midLayout)
topLayout.add_widget(Button(text="second", size_hint=(1.0, 0.1)))
self.add_widget(topLayout)
def zoomSwitchLogic(self, a, b):
if self.zs.active and self.ps.active:
self.ps.active = False
def panSwitchLogic(self, a, b):
if self.zs.active and self.ps.active:
self.zs.active = False
class SwitchContainer(GridLayout):
def __init__(self, **kwargs):
super(SwitchContainer, self).__init__(**kwargs)
self.cols = 2
self.add_widget(Label(text="Auto jump status:"))
self.settings_sample = Switch(active=False)
self.add_widget(self.settings_sample)
self.settings_sample.bind(active=switch_callback)
def sw_factory(self):
def cb(ins, val):
self.value = val
print(self.value)
ti = Switch(size_hint_y=None, height=30)
ti.bind(active=cb)
return ti
def __init__(self, **kwargs):
super(SettingsLiteScreen, self).__init__(**kwargs)
# Set up the settings in a grid
popup = GridLayout(cols=1, size_hint_y=None)
# Make sure the height is such that there is something to scroll.
popup.bind(minimum_height=popup.setter('height'))
# Set up setting buttons
with open(join(dirname(__file__), 'camera.json')) as json_file:
json_data = json.load(json_file)
for setting in json_data:
if setting['settings_lite'] == '1':
# Check if the setting is boolean
if setting['type'] == 'bool':
# Check if the current setting is on or off
if main.App.get_running_app().config.getint('Camera', setting['key']) == 1:
cur_state = True
else:
cur_state = False
# Create the widgets
label = Label(text=setting['title'],
size_hint_y=None,
height=48)
switch = Switch(active=cur_state,
size_hint_y=None,
height=48)
switch.bind(active=partial(self.settings_lite_switch_toggle, setting['key']))
# Add to main settings_lite widget
popup.add_widget(label)
popup.add_widget(switch)
# Else just make the setting a button
else:
btn = Button(text=setting['title'],
size_hint_y=None,
height=96)
btn.bind(on_release=self.settings_lite_button_push)
popup.add_widget(btn)
# Setup the scrollable section and add to floatlayout.
scrolly = ScrollView(size_hint=(0.2, 0.83),
pos_hint={'x':0.8, 'y':0.17})
scrolly.add_widget(popup)
floaty = FloatLayout()
floaty.add_widget(scrolly)
# Add the close button to the bottom
close_button = Button(text='Close',
size_hint=(0.2, 0.16),
pos_hint={'x':0.8, 'y':0})
close_button.bind(on_release=self.close_settings_lite)
floaty.add_widget(close_button)
self.add_widget(floaty)
def dashboard_speed_tab(self):
canvas = BoxLayout(orientation='vertical')
# 1st layer
setup = BoxLayout(orientation='horizontal')
#setup.height = 20
setup.size_hint = (1, None)
btnPlus = Button(text='-', id="minus")
self.w_spd_targetspeed = Label(text='10', font_size="20sp")
btnMinus = Button(text='+', id="plus")
btnAspd = ToggleButton(text='AirSpeed',
id="aspd",
group='speed_source',
state='down')
btnGspd = ToggleButton(text='GndSpeed',
id="gspd",
group='speed_source')
btnAspd.bind(state=self.cb_set_speed_source)
btnGspd.bind(state=self.cb_set_speed_source)
btnPlus.bind(state=self.cb_set_speed_source)
btnMinus.bind(state=self.cb_set_speed_source)
swRead = Switch(active=False)
swRead.bind(active=self.toggle_reading)
setup.add_widget(btnPlus)
setup.add_widget(self.w_spd_targetspeed)
setup.add_widget(btnMinus)
setup.add_widget(btnAspd)
setup.add_widget(btnGspd)
setup.add_widget(swRead)
# zaskrtavatko - hlas, tón, pipani
# Ukazatel
data = BoxLayout(orientation='horizontal')
data_actual = BoxLayout(orientation='vertical')
self.w_spd_release_status = Label(text="--Release--", markup=True)
self.w_spd_speed_info = Label(text="info",
markup=True,
halign="center")
data_actual.add_widget(self.w_spd_release_status)
data_actual.add_widget(self.w_spd_speed_info)
data_offset = BoxLayout(orientation='vertical')
self.w_spd_offset = Label(text="Err", font_size="50sp", markup=True)
data_offset.add_widget(self.w_spd_offset)
self.w_spd_range = Range()
data.add_widget(data_actual)
data.add_widget(data_offset)
data.add_widget(self.w_spd_range)
canvas.add_widget(setup)
canvas.add_widget(data)
return canvas
class FlashApp(App):
def build(self):
self.root = Switch()
self.service = AndroidService('Kivy FlashLight', 'I haz a FlashLight!')
self.root.bind(active=self.toggle_flash)
return self.root
def toggle_flash(self, *args):
if self.root.active:
self.service.start()
else:
self.service.stop()
class Tela(FloatLayout):
def __init__(self, **kwargs):
super(Tela, self).__init__(**kwargs)
self.switch = Switch(active=False)
self.switch.bind(active=self.esta_ativo)
self.add_widget(self.switch)
def esta_ativo(self, instance, value):
if value == True:
print('O switch Ativo')
else:
print('O switch Desativado')
def BrowserPop(self):
layout = GridLayout(cols=1, size_hint=(None, 1.0), width=700)
layout.bind(minimum_height=layout.setter("height"))
panel = SettingsPanel(title="Browser Mods", settings=self)
main = BoxLayout(orientation="vertical")
root = ScrollView(
size_hint=(None, None), bar_margin=-11, bar_color=(47 / 255.0, 167 / 255.0, 212 / 255.0, 1.0), do_scroll_x=False
)
root.size = (600, 400)
root.add_widget(layout)
main.add_widget(root)
done = Button(text="Done Choosing Options")
main.add_widget(done)
if "const/4 v0, 0x4" in open("%s/BrowserSettings.smali" % (Browser)).read():
fp = open("%s/BrowserSettings.smali" % (Browser), "r")
lines = fp.readlines()
fp.close()
tabs = SettingItem(
panel=panel,
title="Unlimited Browser Tabs",
disabled=False,
desc="Allows Unlimited number of browser tabs to be open",
)
for i in range(len(lines)):
if "const/4 v0, 0x4" in open("%s/BrowserSettings.smali" % (Browser)).read():
tabs_switch = Switch(active=False)
continue
if "const/4 v0, 0x4" in open("%s/BrowserSettings.smali" % (Browser)).read():
tabs_switch = Switch(active=True)
tabs.add_widget(tabs_switch)
layout.add_widget(tabs)
def callback(instance, value):
tabs_state(instance, value)
tabs_switch.bind(active=callback)
popup = Popup(
background="atlas://images/eds/pop",
title="Browser Mods",
content=main,
auto_dismiss=False,
size_hint=(None, None),
size=(630, 500),
)
popup.open()
def finish(self):
finish_browser(self)
popup.dismiss()
done.bind(on_release=finish)
class BoxLayoutItemBoolean(BoxLayoutItem):
def __init__(self, section, item_name, item_value):
super(BoxLayoutItemBoolean, self).__init__(section, item_name,
item_value)
self.item_value = Switch(active=item_value)
self.add_widget(self.item_value)
self.item_value.bind(active=self.item_activated)
def item_activated(self, *args):
self.changed_value(args[1])
def restore_item_value(self):
self.item_value.active = self.server_value
def __init__(self, **kwargs):
super(WhiteNoise, self).__init__(**kwargs)
pos_hint = {"x": .5, "y": .1}
def callback(instance, value):
if (value is True):
noise1.play()
elif (value is False):
noise1.stop()
self.text = "white noise"
noise1 = SoundLoader.load('sounds/noise1.wav')
noise1.loop = True
switch = Switch()
switch.bind(active=callback)
self.add_widget(switch)
def show_plugins(self, plugins_list):
def on_active(sw, value):
self.plugins.toggle_enabled(self.electrum_config, sw.name)
run_hook('init_kivy', self)
for item in self.plugins.descriptions:
if 'kivy' not in item.get('available_for', []):
continue
name = item.get('__name__')
label = Label(text=item.get('fullname'), height='48db', size_hint=(1, None))
plugins_list.add_widget(label)
sw = Switch()
sw.name = name
p = self.plugins.get(name)
sw.active = (p is not None) and p.is_enabled()
sw.bind(active=on_active)
plugins_list.add_widget(sw)
class LabeledSwitch(BoxLayout):
def __init__(self,
text,
color=[1] * 4,
pos_hint={
"x": 0,
"y": 0
},
size_hint=[1, 1],
*args,
**kwargs):
super(LabeledSwitch, self).__init__(pos_hint=pos_hint,
size_hint=size_hint,
*args,
**kwargs)
# self.Initialize(*args,**kwargs)
#def Initialize(self,*args,**kwargs):
self.Label = Label(text=text, color=color)
self.add_widget(self.Label)
self.Switch = Switch(*args, **kwargs)
self.add_widget(self.Switch)
#print self.size, self.Switch.size
def bindSwitch(self, *args, **kwargs):
return self.Switch.bind(*args, **kwargs)
def IsActive(self):
return self.Switch.active
class RamdomFacePage(GridLayout):
def __init__(self, **kwargs):
super().__init__(**kwargs)
Window.size = (640, 700)
self.cross_img = Image(source="", size=(640, 640), pos=(0, 120))
self.add_widget(self.cross_img)
self.noise_slider = Slider(min=-1, max=1, value=0, pos=(290, 40))
self.add_widget(self.noise_slider)
self.Generate_button = Button(text="Generate",
size=(320, 60),
pos=(0, 0),
font_size=default_font_size)
self.Generate_button.bind(on_press=self.Generate_image)
self.add_widget(self.Generate_button)
self.back_button = Button(text="Back",
size=(320, 60),
pos=(320, 0),
font_size=default_font_size)
self.back_button.bind(on_press=self.back)
self.add_widget(self.back_button)
self.switch = Switch(size=(50, 60), pos=(30, 50))
self.switch.bind(active=self.switch_training)
self.add_widget(self.switch)
def Generate_image(self, instance):
if cgan.test(is_training=is_training,
desc='',
noise=self.noise_slider.value,
alt_path=alt_path):
# self.cross_img = Image(source=cgan.test_dir + cgan.version + '/test.jpg', size=(640, 640), pos=(0, 120))
self.cross_img.source = cgan.test_dir + cgan.version + '/test.jpg'
print(self.cross_img.source)
self.cross_img.reload()
def back(self, instance):
chat_app.screen_manager.current = 'MainMenu'
def switch_training(self, instance, value):
global is_training
is_training = value
def create_save_image_buttons(self):
time_lapse_layout = BoxLayout(orientation = 'vertical', size_hint_y = 0.6)
save_image_button = Button(text = 'save image', size_hint_y = 0.2, background_color = [0, 0.3, 1, 1])
time_lapse_interval_input = TextInput(text = str(self.time_lapse_interval), multiline = False, size_hint_y = 0.3)
time_lapse_interval_label = Label(text = 'time_lapse\ninterval(sec)', size_hint_y = 0.15, color = [0, 1, 0, 1])
time_lapse_button = Switch(size_hint_y = 0.2) # need to make a popup to choose time_interval etc.
time_lapse_button_label = Label(text = 'on/off\ntime_lapse', size_hint_y = 0.15, color = [0, 1, 0, 1])
def save_image(instance):
''' Callback for save_image_button'''
self.filepath_update = False # this prevents saving image mess up naming
self.filepath = self.format_filepath(update = False)
if debug_mode is True:
print('save image to {}'.format(self.filepath))
if debug_mode is False:
mc.camera_library('save_image', self.folder, self.filepath)
self.image_number = self.image_number + 1
def start_time_lapse(instance, value):
''' Callback for time_lapse_button'''
update_time_lapse_interval(time_lapse_interval_input)
if value is True:
# start time lapse
save_image('')
self.event = Clock.schedule_interval(save_image, self.time_lapse_interval)
if value is False:
Clock.unschedule(self.event)
def update_time_lapse_interval(instance):
try:
self.time_lapse_interval = float(time_lapse_interval_input.text)
except:
# if the text_input is not a valid value, use 60 as default value
time_lapse_interval_input.text = str(self.time_lapse_interval)
self.time_lapse_interval = float(time_lapse_interval_input.text)
print(self.time_lapse_interval)
save_image_button.bind(on_release = save_image)
time_lapse_button.bind(active = start_time_lapse)
if debug_mode is False:
# When click the time_lapse_interval_input, stop the preview
time_lapse_interval_input.bind(focus = partial(mc.camera_library, 'stop_preview'))
time_lapse_interval_input.bind(on_text_validate = update_time_lapse_interval)
for i in [save_image_button, time_lapse_interval_label, time_lapse_interval_input, time_lapse_button_label, time_lapse_button]:
time_lapse_layout.add_widget(i)
return time_lapse_layout
def MmsPop(self):
layout = GridLayout(cols=1, size_hint=(None, 1.0), width=700)
layout.bind(minimum_height=layout.setter('height'))
panel = SettingsPanel(title="Mms Mods", settings=self)
main = BoxLayout(orientation = 'vertical')
root = ScrollView(size_hint=(None, None),bar_margin=-11, bar_color=(47 / 255., 167 / 255., 212 / 255., 1.), do_scroll_x=False)
root.size = (600, 400)
root.add_widget(layout)
main.add_widget(root)
done = Button(text ='Done Choosing Options')
main.add_widget(done)
if """ .line 77
const/4 v0, 0x1
sput-boolean v0, Lcom/android/mms/model/ImageModel;->mCheckResolution:Z""" in open("%s/ImageModel.smali" % (Mms)).read():
fp = open("%s/ImageModel.smali" % (Mms), "r")
lines = fp.readlines()
fp.close()
comp = SettingItem(panel = panel, title = "Remove Mms Compression",disabled=False, desc = "Disables Compression of Mms Messages")
for i in range(len(lines)):
if """ .line 77
const/4 v0, 0x1
sput-boolean v0, Lcom/android/mms/model/ImageModel;->mCheckResolution:Z""" in open("%s/ImageModel.smali" % (Mms)).read():
comp_switch = Switch(active=False)
continue
if """ .line 77
const/4 v0, 0x1
sput-boolean v0, Lcom/android/mms/model/ImageModel;->mCheckResolution:Z""" in open("%s/ImageModel.smali" % (Mms)).read():
comp_switch = Switch(active=True)
comp.add_widget(comp_switch)
layout.add_widget(comp)
def callback(instance, value):
comp_state(instance, value)
comp_switch.bind(active=callback)
popup = Popup(background='atlas://images/eds/pop', title='Mms Mods', content=main, auto_dismiss=False, size_hint=(None, None), size=(630, 500))
popup.open()
def finish(self):
finish_comp(self)
popup.dismiss()
done.bind(on_release=finish)
class RVViewClass(BoxLayout):
user_id = NumericProperty(None, allownone=True)
estimator_id = NumericProperty(None, allownone=True)
db = ObjectProperty(None, allownone=True)
def __init__(self, **kwargs):
super(RVViewClass, self).__init__(**kwargs)
self.label_user_info = Label(text='', bold=True, italic=True)
self.add_widget(self.label_user_info)
self.label_estimator_info = Label(text='', bold=True, italic=True)
self.add_widget(self.label_estimator_info)
self.switch_is_accessible = Switch(active=True)
self.add_widget(self.switch_is_accessible)
self.bind(user_id=self.represent_info)
self.bind(estimator_id=self.represent_info)
self.bind(db=self.represent_info)
self.switch_is_accessible.bind(active=self.switch_is_accessible_bind)
def switch_is_accessible_bind(self, *args):
user = self.db.get_user_by_id(self.user_id)
estimator = self.db.get_estimator_by_id(self.estimator_id)
if self.switch_is_accessible.active:
if not (estimator in user.estimators):
user.estimators.append(estimator)
else:
if estimator in user.estimators:
user.estimators.remove(estimator)
def represent_info(self, *args):
if self.user_id and self.estimator_id and self.db:
user = self.db.get_user_by_id(self.user_id)
estimator = self.db.get_estimator_by_id(self.estimator_id)
self.label_user_info.text = represent_user_in_rv(user)
self.label_estimator_info.text = represent_estimator_in_rv(
estimator)
self.switch_is_accessible.active = estimator in user.estimators
def on_enter(self):
try:
#Clear all labels
self.ids.groupName.clear_widgets()
self.ids.devicesConnected.clear_widgets()
#Add back labels for the group and devices connectedf
self.ids.groupName.add_widget(Label(text="Name:", font_size=35))
#self.ids.groupName.add_widget(Label(text="Group " + str(self.currentGroupNo),font_size=35))
#NEEDS TO BE CHANGED TO DISPLAY ACTUAL GROUP DATA
self.ids.groupName.add_widget(
Label(
text=self.manager.create_group_screen.ids.group_name.text,
font_size=20))
self.ids.devicesConnected.add_widget(
Label(text="Status:", font_size=35))
self.ids.devicesConnected.add_widget(
Label(text=str(' Inactive'), font_size=20))
self.ids.devicelisting.clear_widgets()
for i in xrange(0, len(ConnectDevicesScreen().applied_list)):
addedGroup = BoxLayout(size_hint_y=None,
height='75sp',
orientation='horizontal')
addedGroup.add_widget(
Label(text="Device " +
ConnectDevicesScreen().applied_list[i],
font_size=10,
color=(0, 0, 0, 1)))
switch = Switch(active=False,
id=ConnectDevicesScreen().applied_list[i])
switch.bind(active=self.switch_on)
addedGroup.add_widget(switch)
self.ids.devicelisting.add_widget(addedGroup)
except Exception:
print('Error in the on_enter function!')
def settings(self):
screen = Screen(name=ROOT + 'Settings')
settings_background = Image(source='settings_background.jpg',
allow_stretch=True,
keep_ratio=False)
layout = FloatLayout(size=(500, 500))
layout.add_widget(settings_background)
btn_singleplayer = Button(text='Single Player',
size_hint=(.15, .08),
pos_hint={
'x': .65,
'y': .45
})
btn_singleplayer.bind(on_press=self.singleplayer)
btn_multiplayer = Button(text='Multiplayer',
size_hint=(.15, .08),
pos_hint={
'x': .825,
'y': .45
})
btn_multiplayer.bind(on_press=self.multiplayer)
label_switch = Label(text='Random Map Generator',
size_hint=(.15, .08),
pos_hint={
'x': .5,
'y': .1
})
switch = Switch(active=False,
size_hint=(.15, .08),
pos_hint={
'x': .7,
'y': .1
})
switch.bind(active=self.map_setting)
layout.add_widget(btn_multiplayer)
layout.add_widget(btn_singleplayer)
layout.add_widget(label_switch)
layout.add_widget(switch)
screen.add_widget(layout)
return screen
def set_settings_layout(self):
looping_switch_layout = BoxLayout()
looping_switch_layout.spacing = 2
looping_switch_layout.size_hint = (.2, 1)
looping_switch_layout.orientation = "horizontal"
looping_switch_label = Label()
looping_switch_label.color = [.6, .2, 1, .5]
looping_switch_label.text = "Loop Sound"
looping_switch_label.size_hint = (.3, 1)
looping_switch_layout.add_widget(looping_switch_label)
looping_switch = Switch(active=False)
looping_switch.bind(active=self.toggle_looping_sound)
looping_switch.size_hint = (.3, 1)
looping_switch_layout.add_widget(looping_switch)
empty_label = Label()
empty_label.size_hint = (.4, 1)
looping_switch_layout.add_widget(empty_label)
self.title_layout.add_widget(looping_switch_layout)
class Switch_implementare(GridLayout):
def __init__(self, **kwargs):
super(Switch_implementare, self).__init__(**kwargs)
global x
self.cols = 1
self.padding = 150
self.switch1 = Switch(text="muzica")
self.switch1.active =True
self.add_widget(self.switch1)
self.arata_volum = Label (text = "volum: 50")
self.add_widget(self.arata_volum)
self.slide_muzica = Slider(min=0, max=100, value=50)
self.slide_muzica.step = 5
self.slide_muzica.orientation="horizontal" # alte optiuni 'vertical'
self.add_widget(self.slide_muzica)
self.switch1.bind(active=self.dezactiveaza_volum)
self.slide_muzica.bind(value=self.valoare_volum)
self.sound = SoundLoader.load('JO_-_09_-_Fortitude.ogg')
self.sound.play()
self.sound.loop = True
self.sound.volume=0.5
x = self.sound
def valoare_volum (self,x,y):
'''utiliziat pentru seta volumul'''
self.arata_volum.text = "volum: "+str(int(self.slide_muzica.value))
self.sound.volume = self.slide_muzica.value/100
def dezactiveaza_volum (self,x,y):
'''utilziat pentru a acctiva sau a dezactiva slider-ul'''
if (self.switch1.active == False) :
self.slide_muzica.disabled =True
self.sound.stop()
else:
self.slide_muzica.disabled =False
self.slide_muzica.value = 0
self.sound.play()
class Switch_implementare(GridLayout):
def __init__(self, **kwargs):
super(Switch_implementare, self).__init__(**kwargs)
global x
self.cols = 1
self.padding = 150
self.switch1 = Switch(text="muzica")
self.switch1.active = True
self.add_widget(self.switch1)
self.arata_volum = Label(text="volum: 50")
self.add_widget(self.arata_volum)
self.slide_muzica = Slider(min=0, max=100, value=50)
self.slide_muzica.step = 5
self.slide_muzica.orientation = "horizontal" # alte optiuni 'vertical'
self.add_widget(self.slide_muzica)
self.switch1.bind(active=self.dezactiveaza_volum)
self.slide_muzica.bind(value=self.valoare_volum)
self.sound = SoundLoader.load('JO_-_09_-_Fortitude.ogg')
self.sound.play()
self.sound.loop = True
self.sound.volume = 0.5
x = self.sound
def valoare_volum(self, x, y):
'''utiliziat pentru seta volumul'''
self.arata_volum.text = "volum: " + str(int(self.slide_muzica.value))
self.sound.volume = self.slide_muzica.value / 100
def dezactiveaza_volum(self, x, y):
'''utilziat pentru a acctiva sau a dezactiva slider-ul'''
if (self.switch1.active == False):
self.slide_muzica.disabled = True
self.sound.stop()
else:
self.slide_muzica.disabled = False
self.slide_muzica.value = 0
self.sound.play()
def BrowserPop(self):
layout = GridLayout(cols=1, size_hint=(None, 1.0), width=700)
layout.bind(minimum_height=layout.setter('height'))
panel = SettingsPanel(title="Browser Mods", settings=self)
main = BoxLayout(orientation = 'vertical')
root = ScrollView(size_hint=(None, None),bar_margin=-11, bar_color=(47 / 255., 167 / 255., 212 / 255., 1.), do_scroll_x=False)
root.size = (600, 400)
root.add_widget(layout)
main.add_widget(root)
done = Button(text ='Done Choosing Options')
main.add_widget(done)
if 'const/4 v0, 0x4' in open("%s/BrowserSettings.smali" % (Browser)).read():
fp = open("%s/BrowserSettings.smali" % (Browser), "r")
lines = fp.readlines()
fp.close()
tabs = SettingItem(panel = panel, title = "Unlimited Browser Tabs",disabled=False, desc = "Allows Unlimited number of browser tabs to be open")
for i in range(len(lines)):
if 'const/4 v0, 0x4' in open("%s/BrowserSettings.smali" % (Browser)).read():
tabs_switch = Switch(active=False)
continue
if 'const/4 v0, 0x4' in open("%s/BrowserSettings.smali" % (Browser)).read():
tabs_switch = Switch(active=True)
tabs.add_widget(tabs_switch)
layout.add_widget(tabs)
def callback(instance, value):
tabs_state(instance, value)
tabs_switch.bind(active=callback)
popup = Popup(background='atlas://images/eds/pop', title='Browser Mods', content=main, auto_dismiss=False, size_hint=(None, None), size=(630, 500))
popup.open()
def finish(self):
finish_browser(self)
popup.dismiss()
done.bind(on_release=finish)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.cols = 2
self.pref = Prefences()
# App will speak pref
ch = Switch(active=self.getSettingValue('speak'))
ch.bind(active=self.callback)
self.add_widget(Label(text='app will speak words'))
self.add_widget(ch)
chMakeCaps = Switch(active=self.getSettingValue('makeCaps'))
chMakeCaps.bind(active=self.callbackMakeCaps)
self.add_widget(Label(text='app will show all words in Caps'))
self.add_widget(chMakeCaps)
self.add_widget(
Label(text="URL importing")
)
self.urlLayout = UrlLayout()
self.add_widget(self.urlLayout)
def on_enter(self):
try:
#Clear all widgets
self.ids.devicetestlisting.clear_widgets()
for i in xrange(0, len(ConnectDevicesScreen.applied_list)):
addedGroup = BoxLayout(size_hintOK_y=None,
height='75sp',
orientation='horizontal')
addedGroup.add_widget(
Label(text="" + ConnectDevicesScreen.applied_list[i],
font_size=10,
color=(0, 0, 0, 1)))
switch = Switch(active=True,
id=ConnectDevicesScreen.applied_list[i])
switch.bind(active=self.switch_on)
addedGroup.add_widget(switch)
self.ids.devicetestlisting.add_widget(addedGroup)
self.deviceTestedValues.append(True)
except Exception:
print('Error in the on_enter function!')
class DeviceBox(BoxLayout):
nexa_controllers = ['Nexa3ButtonRemote',
'Nexa2ButtonSwitch']
nexa_sensors = ['NexaOpeningSensor',
'NexaMovementSensor']
nexa_devices = ['NexaDevice']
def __init__(self, json_device, *args, **kwargs):
super(DeviceBox, self).__init__(*args, **kwargs)
self.app = App.get_running_app()
print 'building device box'
print json_device
print '\n'
self.maj_id = json_device['id']
self.model = json_device['device_key']
self.name = json_device['name']
self.orientation = 'vertical'
self.add_widget(Label(text = self.name,
text_size = (self.width-dp(10), 35)))
if self.model in self.nexa_controllers:
self.switches = []
for switch in json_device['switches']:
if switch['state'] != None: state = switch['state']
else: state = False
new_switch = Switch(id = switch['id'], active = state, disabled = True)
self.switches.append(new_switch)
self.add_widget(new_switch)
elif self.model in self.nexa_sensors:
self.last_activated = Label(text = json_device['last_activated'],
size_hint = (None, 1),
text_size = (self.width-dp(10), 100),
pos_hint = {'center_x': 0.5})
self.add_widget(self.last_activated)
elif self.model in self.nexa_devices:
self.switch = Switch(id = json_device['id'])
self.switch.bind(active = self.user_action)
self.add_widget(self.switch)
def update(self, json_update):
if self.model in self.nexa_controllers:
for switch in json_update['switches']:
for my_switch in self.switches:
if switch['id'] == my_switch.id:
if switch['state'] != None:
my_switch.active = switch['state']
elif self.model in self.nexa_sensors:
self.last_activated.text = json_update['last_activated']
elif self.model in self.nexa_devices:
if json_update['state'] != None:
self.switch.unbind(active = self.user_action)
self.switch.active = json_update['state']
self.switch.bind(active = self.user_action)
def user_action(self, instance, value):
print 'sending action request'
print {'command': 'device_action',
'model': self.model,
'id': instance.id}
self.app.send_request(None,
{'command': 'device_action',
'model': self.model,
'id': instance.id})
class InteractionScreen(
Screen
): #This is the main screen for drawing and user input. Next steps include nesting layouts and adding/binding buttons
def __init__(self, **kwargs):
super(InteractionScreen, self).__init__(**kwargs)
### CREATE LAYOUTS
self.layout = FloatLayout(
) #creates a Float Layout called self.layout (self. allows reference for entire class?)
self.layout.width = Window.width
self.layout.height = Window.height
self.layout.x = 0
self.layout.y = 0
self.rightlayout = FloatLayout(
) #creates Float Layout for object selector, speed and angle labels, go button
self.rightlayout.width = self.layout.width * (1. / 6.)
self.rightlayout.height = self.layout.height
self.rightlayout.x = Window.width - self.rightlayout.width
self.rightlayout.y = Window.height / 2 - self.rightlayout.height / 2
self.leftlayout = FloatLayout(
) # float layout for drawing area and background images
self.leftlayout.width = self.layout.width * (5. / 6.)
self.leftlayout.height = self.layout.height
self.leftlayout.x = 0 #Window.width - self.centerlayout.width
self.leftlayout.y = 0 #Window.width/2 - self.centerlayout.height/2
with self.rightlayout.canvas: #sets canvas instructions for the rightlayout and draws a blue rect. filling the entire layout
Color(0, 0, .5, 1) #BLUE
Rectangle(pos=(self.rightlayout.x, self.rightlayout.y),
size=(self.rightlayout.width, self.rightlayout.height))
### LEFT LAYOUT CONTENT
# DRAWING FUNCTIONALITY
global drawUtility
drawUtility = DrawingApp()
drawUtility.size_hint = (5. / 6., 1)
self.leftlayout.add_widget(drawUtility, 0)
self.layout.add_widget(self.leftlayout, 2)
self.layout.add_widget(self.rightlayout)
self.add_widget(self.layout)
# DEFAULT BACKGROUND IMAGE
self.bg_image_default = Image(source=assetsdirectory +
str('starfield.jpg'))
self.bg_image_default.allow_stretch = True
self.bg_image_default.keep_ratio = False
self.bg_image_default.size_hint = ((5. / 6.), 1)
self.bg_image_default.pos = (0, 0)
self.bg_image_default.opacity = 1.0
self.leftlayout.add_widget(self.bg_image_default,
1) #ADDS DEFAULT BACKGROUND IMAGE
# BACKGROUND IMAGE UPDATE FUNCTION
self.imageNumber = 1 #default image number
self.event = Clock.schedule_interval(
self.imageUpdate,
1.0 / 5.0) #SCHEDULES THE IMAGE UPDATING TO OCCUR
# HOME BUTTON AND IMAGE
homeBtn = Button(text='',
size_hint=((1. / 24.), (.06)),
pos_hint={
'x': 0,
'y': .94
},
opacity=.5) #back button to the interaction screen
homeBtn.bind(
on_press=self.changer
) #binds this button to change the screen back to the welcome screen
self.layout.add_widget(homeBtn,
0) #adds the button to the float layout
self.homeImage = Image(
source=assetsdirectory + str('explosion1.png')
) # adds slightly transparent home icon over the back button
self.homeImage.size_hint = ((1. / 24.), .06)
self.homeImage.pos_hint = {'x': 0, 'y': .94}
self.homeImage.opacity = .5
self.layout.add_widget(self.homeImage)
### RIGHT LAYOUT CONTENT
# OBJECT BUTTON (Must be in same order for correct layout)
objButton = Spinner(text='PLEASE SELECT\nAN OBJECT',
halign='center',
font_size='18',
values=('Particle', 'Planet', 'Comet', 'Star',
'Black Hole',
'Elephant')) # object spinner
objButton.pos_hint = {'x': 0, 'y': .8}
objButton.size_hint = ((1. / 6.), .2)
objButton.background_color = [.4, .4, .4, 1]
self.rightlayout.add_widget(objButton, 0)
# TOPOGRAPHY TOGGLE SWITCH
self.topoSwitch = Switch(
active=True
) # switch to toggle between updating topography and static star field
self.topoSwitch.pos_hint = {'x': 0, 'y': .6}
self.topoSwitch.size_hint = ((1. / 6.), .15)
self.topoSwitch.background_color = [.4, .4, .4, 1]
self.rightlayout.add_widget(self.topoSwitch)
self.topoSwitch.bind(
active=self.topoChange) # bind switch to topoChange function
# SPEED LABEL
self.spdLabel = Label(text='Speed:\n' + str(drawUtility.speed),
font_size='20',
halign='center') # label showing current speed
self.spdLabel.pos_hint = {'x': 0, 'y': .4}
self.spdLabel.size_hint = ((1. / 6.), .2)
self.spdLabel.background_color = [.4, .4, .4, 1]
self.rightlayout.add_widget(self.spdLabel)
def update_speed(
value, instance): # callback function to bind speed to vector
self.spdLabel.text = 'Speed:\n' + str(drawUtility.speed)
drawUtility.bind(speed=update_speed) # bind speed to vector length
# ANGLE LABEL
self.angLabel = Label(text='Angle:\n' + str(drawUtility.angle),
font_size='20',
halign='center') # label showing current angle
self.angLabel.pos_hint = {'x': 0, 'y': .2}
self.angLabel.size_hint = ((1. / 6.), .2)
self.angLabel.background_color = [.4, .4, .4, 1]
self.rightlayout.add_widget(self.angLabel)
def update_angle(
value, instance): # callback function to bind angle to vector
self.angLabel.text = 'Angle:\n' + str(drawUtility.angle)
drawUtility.bind(angle=update_angle) # bind angle to vector
# GO BUTTON
self.goButton = MyButton(
text='Go!') # go button to send user input to algorithm
self.goButton.pos_hint = {'x': 0, 'y': 0}
self.goButton.size_hint = ((1. / 6.), .2)
self.goButton.background_color = [.4, .4, .4, 1]
self.goButton.bind(
on_release=self.userInput
) # when the button is released the USERINPUT function is called
self.rightlayout.add_widget(self.goButton)
### FUNCTIONS
def massSelect(self, *args):
print('Mass Selector Function called')
def userInput(
self, *args
): # function to save user input and take output from algorithm
name_of_file = 'algorithm_input' # USER INPUT FILENAME
inputFileName = os.path.join(assetsdirectory,
name_of_file + '.txt') #TOTAL PATH NAME
with open(
inputFileName, 'w'
) as f: # create file and write initial and final coordinate positions
f.write('%f\t%f\t%f\t%f' %
(drawUtility.x_initial, drawUtility.y_initial,
drawUtility.x_final, drawUtility.y_final))
drawUtility.canvas.clear()
particle = Particle(
pos=(drawUtility.x_initial, drawUtility.y_initial),
size=(10, 10)) # draw a particle at chosen initial position
drawUtility.add_widget(particle)
while os.path.isfile(
'algorithm_output.npy') == False: # search for output file
sleep(1)
print("Still no file")
else:
x = np.load('mylistx.npy')
xs = np.split(x,
len(x) / 200, 0) # test data
y = np.load('mylisty.npy')
ys = np.split(y,
len(y) / 200, 0)
print("File found!")
#x,y = np.load('algorithm_output.npy') # load in algorithm output
#xs = np.split(x, len(x)/200, 0); ys = np.split(y, len(y)/200, 0) # split x and y arrays into manageable chunks for animation
self.animate(xs, ys, 0,
particle) # call animation function with output data
def animate(self, x_coords, y_coords, index,
instance): # function to animate particle through orbit
if index < len(x_coords): # check if reached last coordinate chunk
animation = Animation(
pos=(int(x_coords[index][0]), int(y_coords[index][0])),
t='linear',
duration=.02
) # create animation instance beginning at first coordinate of chunk
for i in np.arange(
1, len(x_coords[index])
): # add all points in chunk to animation instance in sequence
animation += Animation(pos=(int(x_coords[index][i]),
int(y_coords[index][i])),
t='linear',
duration=.02)
animation.bind(
on_complete=lambda x, y:
(self.animate(x_coords, y_coords, index + 1, instance)
)) # once one chunk is animated, animate next
animation.start(instance) # begin animation
def changer(self, *args): # function to go back to home screen
self.manager.current = 'screen1'
self.manager.transition.direction = 'right'
def topoChange(
self, instance,
value): # function for turning updating topography on and off
if self.topoSwitch.active == True: # if topography active, call image update function once every .2 seconds
self.event = Clock.schedule_interval(self.imageUpdate, 1.0 / 5.0)
elif self.topoSwitch.active == False: # if topography not active,
self.event.cancel() # cancel clock event
self.leftlayout.remove_widget(
self.bg_image) # remove the updating background image widget
self.leftlayout.add_widget(self.bg_image_default,
1) # add default image widget
def imageUpdate(self, dt): # function for live topography updating
#TESTING MULTIPLE IMAGE UPDATE
try:
self.leftlayout.remove_widget(
self.bg_image_default
) # try to remove both image widgets, ensures proper layering of widgets
self.leftlayout.remove_widget(self.bg_image)
except:
pass
self.imageNumber ^= 1
imageStr = assetsdirectory + str('color_field_') + str(
self.imageNumber) + '.jpg' # randomly choose sandstone image
#print('imageNumber: %s' % self.imageNumber)
self.bg_image = Image(source=imageStr)
self.bg_image.allow_stretch = True
self.bg_image.keep_ratio = False
self.bg_image.size_hint = ((5. / 6.), 1)
self.bg_image.pos = (0, 0)
self.bg_image.opacity = 1.0
#self.bg_image.reload()
self.leftlayout.add_widget(self.bg_image,
1) # add topography image widget
class MainBox(BoxLayout):
'''
Mainbox class
'''
def __init__(self, **kwargs):
'''
Init main class ui
'''
super(MainBox, self).__init__(**kwargs)
self.f_size = '15sp'
# Shape Widget
self.shape = Shape(size_hint=(0.7, 1))
self.add_widget(self.shape)
# Right Menu
self.panel = TabbedPanel(size_hint=(0.3, 1), do_default_tab=False)
self.tab_param = TabbedPanelItem(text='Parameters')
self.tab_color = TabbedPanelItem(text='Shape')
self.tab_color_bg = TabbedPanelItem(text='Background')
self.tab_export = TabbedPanelItem(text='Export')
self.panel.add_widget(self.tab_param)
self.panel.add_widget(self.tab_color)
self.panel.add_widget(self.tab_color_bg)
self.panel.add_widget(self.tab_export)
self.menu_right = RightMenu(
padding=15,
orientation="vertical")
# Switch mode line
self.box_switch = BoxLayout(orientation='horizontal')
self.mode_label = Label(
text="Line mode",
font_size=self.f_size,
markup=True)
self.box_switch.add_widget(self.mode_label)
self.switch_mode = Switch(active=False)
self.switch_mode.bind(active=self.on_switch)
self.box_switch.add_widget(self.switch_mode)
self.menu_right.add_widget(self.box_switch)
# Size value
self.box_size = BoxLayout(orientation='horizontal')
self.size_label = Label(
text="Shape size",
font_size=self.f_size,
markup=True)
self.size_label_value = Label(
text=str(self.shape.shape_size),
font_size=self.f_size,
markup=True)
self.box_size.add_widget(self.size_label)
self.box_size.add_widget(self.size_label_value)
self.slider_shape_size = Slider(
min=self.shape.property('shape_size').get_min(self.shape),
max=self.shape.property('shape_size').get_max(self.shape),
value=self.shape.shape_size, step=1)
self.slider_shape_size.bind(value=self.change_shape_size)
self.menu_right.add_widget(self.box_size)
self.menu_right.add_widget(self.slider_shape_size)
# Width point or line
self.box_stroke = BoxLayout(orientation='horizontal')
self.wdth_label = Label(
text="Stroke width",
font_size=self.f_size,
markup=True)
self.wdth_label_value = Label(
text=str(self.shape.wdth),
font_size=self.f_size,
markup=True)
self.box_stroke.add_widget(self.wdth_label)
self.box_stroke.add_widget(self.wdth_label_value)
self.slider_wdth = Slider(
min=self.shape.property('wdth').get_min(self.shape),
max=self.shape.property('wdth').get_max(self.shape),
value=self.shape.wdth, step=1)
self.slider_wdth.bind(value=self.change_wdth)
self.menu_right.add_widget(self.box_stroke)
self.menu_right.add_widget(self.slider_wdth)
# a value
self.box_a = BoxLayout(orientation='horizontal')
self.a_label = Label(
text="Param a ",
font_size=self.f_size,
markup=True)
self.a_label_value = Label(
text=str(self.shape.a),
font_size=self.f_size,
markup=True)
self.box_a.add_widget(self.a_label)
self.box_a.add_widget(self.a_label_value)
self.slider_a = Slider(
min=self.shape.property('a').get_min(self.shape),
max=self.shape.property('a').get_max(self.shape),
value=self.shape.a)
self.slider_a.bind(value=self.change_a)
self.menu_right.add_widget(self.box_a)
self.menu_right.add_widget(self.slider_a)
# b value
self.box_b = BoxLayout(orientation='horizontal')
self.b_label = Label(
text="Param b ",
font_size=self.f_size,
markup=True)
self.b_label_value = Label(
text=str(self.shape.b),
font_size=self.f_size,
markup=True)
self.box_b.add_widget(self.b_label)
self.box_b.add_widget(self.b_label_value)
self.slider_b = Slider(
min=self.shape.property('b').get_min(self.shape),
max=self.shape.property('b').get_max(self.shape),
value=self.shape.b)
self.slider_b.bind(value=self.change_b)
self.menu_right.add_widget(self.box_b)
self.menu_right.add_widget(self.slider_b)
# m value
self.box_m = BoxLayout(orientation='horizontal')
self.m_label = Label(
text="Param m ",
font_size=self.f_size,
markup=True)
self.m_label_value = Label(
text=str(self.shape.m),
font_size=self.f_size,
markup=True)
self.box_m.add_widget(self.m_label)
self.box_m.add_widget(self.m_label_value)
self.slider_m = Slider(
min=self.shape.property('m').get_min(self.shape),
max=self.shape.property('m').get_max(self.shape),
value=self.shape.m)
self.slider_m.bind(value=self.change_m)
self.menu_right.add_widget(self.box_m)
self.menu_right.add_widget(self.slider_m)
# n1 value
self.box_n1 = BoxLayout(orientation='horizontal')
self.n1_label = Label(
text="Param n1 ",
font_size=self.f_size,
markup=True)
self.n1_label_value = Label(
text=str(self.shape.n1),
font_size=self.f_size,
markup=True)
self.box_n1.add_widget(self.n1_label)
self.box_n1.add_widget(self.n1_label_value)
self.slider_n1 = Slider(
min=self.shape.property('n1').get_min(self.shape),
max=self.shape.property('n1').get_max(self.shape),
value=self.shape.n1)
self.slider_n1.bind(value=self.change_n1)
self.menu_right.add_widget(self.box_n1)
self.menu_right.add_widget(self.slider_n1)
# n2 value
self.box_n2 = BoxLayout(orientation='horizontal')
self.n2_label = Label(
text="Param n2 ",
font_size=self.f_size,
markup=True)
self.n2_label_value = Label(
text=str(self.shape.n2),
font_size=self.f_size,
markup=True)
self.box_n2.add_widget(self.n2_label)
self.box_n2.add_widget(self.n2_label_value)
self.slider_n2 = Slider(
min=self.shape.property('n2').get_min(self.shape),
max=self.shape.property('n2').get_max(self.shape),
value=self.shape.n2)
self.slider_n2.bind(value=self.change_n2)
self.menu_right.add_widget(self.box_n2)
self.menu_right.add_widget(self.slider_n2)
# n3 value
self.box_n3 = BoxLayout(orientation='horizontal')
self.n3_label = Label(
text="Param n3 ",
font_size=self.f_size,
markup=True)
self.n3_label_value = Label(
text=str(self.shape.n3),
font_size=self.f_size,
markup=True)
self.box_n3.add_widget(self.n3_label)
self.box_n3.add_widget(self.n3_label_value)
self.slider_n3 = Slider(
min=self.shape.property('n3').get_min(self.shape),
max=self.shape.property('n3').get_max(self.shape),
value=self.shape.n3)
self.slider_n3.bind(value=self.change_n3)
self.menu_right.add_widget(self.box_n3)
self.menu_right.add_widget(self.slider_n3)
# Nb points
self.box_nbp = BoxLayout(orientation='horizontal')
self.nbp_label = Label(
text="Points number ",
font_size=self.f_size,
markup=True)
self.nbp_label_value = Label(
text=str(self.shape.nbp),
font_size=self.f_size,
markup=True)
self.box_nbp.add_widget(self.nbp_label)
self.box_nbp.add_widget(self.nbp_label_value)
self.slider_nbp = Slider(
min=self.shape.property('nbp').get_min(self.shape),
max=self.shape.property('nbp').get_max(self.shape),
value=self.shape.nbp, step=2)
self.slider_nbp.bind(value=self.change_nbp)
self.menu_right.add_widget(self.box_nbp)
self.menu_right.add_widget(self.slider_nbp)
# Percent
self.box_percent = BoxLayout(orientation='horizontal')
self.percent_label = Label(
text="Percent ",
font_size=self.f_size,
markup=True)
self.percent_label_value = Label(
text=str(self.shape.percent),
font_size=self.f_size,
markup=True)
self.box_percent.add_widget(self.percent_label)
self.box_percent.add_widget(self.percent_label_value)
self.slider_percent = Slider(
min=self.shape.property('percent').get_min(self.shape),
max=self.shape.property('percent').get_max(self.shape),
value=self.shape.percent, step=1)
self.slider_percent.bind(value=self.change_percent)
self.menu_right.add_widget(self.box_percent)
self.menu_right.add_widget(self.slider_percent)
# Travel
self.box_travel = BoxLayout(orientation='horizontal')
self.travel_label = Label(
text="Travel ",
font_size=self.f_size,
markup=True)
self.travel_label_value = Label(
text=str(self.shape.travel),
font_size=self.f_size,
markup=True)
self.box_travel.add_widget(self.travel_label)
self.box_travel.add_widget(self.travel_label_value)
self.slider_travel = Slider(
min=self.shape.property('travel').get_min(self.shape),
max=self.shape.property('travel').get_max(self.shape),
value=self.shape.travel, step=2)
self.slider_travel.bind(value=self.change_travel)
self.menu_right.add_widget(self.box_travel)
self.menu_right.add_widget(self.slider_travel)
# ColorPicker for Shape
self.picker = ColorPicker()
self.picker.bind(color=self.on_color)
# ColorPicker for background
self.picker_bg = ColorPicker()
self.picker_bg.bind(color=self.on_color_bg)
# Export svg button
self.export_button = Button(text='Export', size_hint=(1, 0.15))
self.export_button.bind(on_press=self.export)
# Tab packs
self.tab_param.add_widget(self.menu_right)
self.tab_color.add_widget(self.picker)
self.tab_color_bg.add_widget(self.picker_bg)
self.tab_export.add_widget(self.export_button)
self.add_widget(self.panel)
# Popups
self.pop_export = Popup(
title="Export file",
content=Label(text="File exported"),
size_hint=(None, None),
size=(640, 240))
def change_wdth(self, *args):
'''
Change stroke width
'''
self.shape.wdth = self.slider_wdth.value
self.wdth_label_value.text = str(self.slider_wdth.value)
def on_switch(self, *args):
'''
Switch mode line or point
'''
self.shape.line = self.switch_mode.active
def on_color(self, *args):
'''
Shape color
'''
self.shape.color = self.picker.hex_color
def on_color_bg(self, *args):
'''
Shape background color
'''
self.shape.bg_color = self.picker_bg.hex_color
def change_shape_size(self, *args):
'''
Shape size
'''
self.shape.shape_size = self.slider_shape_size.value
self.size_label_value.text = str(self.slider_shape_size.value)
def change_a(self, *args):
'''
a value
'''
self.shape.a = self.slider_a.value
self.a_label_value.text = str(self.slider_a.value)
def change_b(self, *args):
'''
b value
'''
self.shape.b = self.slider_b.value
self.b_label_value.text = str(self.slider_b.value)
def change_m(self, *args):
'''
m value
'''
self.shape.m = self.slider_m.value
self.m_label_value.text = str(self.slider_m.value)
def change_n1(self, *args):
'''
n1 value
'''
self.shape.n1 = self.slider_n1.value
self.n1_label_value.text = str(self.slider_n1.value)
def change_n2(self, *args):
'''
n2 value
'''
self.shape.n2 = self.slider_n2.value
self.n2_label_value.text = str(self.slider_n2.value)
def change_n3(self, *args):
'''
n3 value
'''
self.shape.n3 = self.slider_n3.value
self.n3_label_value.text = str(self.slider_n3.value)
def change_nbp(self, *args):
'''
point number
'''
self.shape.nbp = self.slider_nbp.value
self.nbp_label_value.text = str(self.slider_nbp.value)
def change_percent(self, *args):
'''
Percent value
'''
self.shape.percent = self.slider_percent.value
self.percent_label_value.text = str(self.slider_percent.value)
def change_travel(self, *args):
'''
Travel number
'''
self.shape.travel = self.slider_travel.value
self.travel_label_value.text = str(self.slider_travel.value)
def export(self, *args):
'''
Export to svg file
'''
document = svgwrite.Drawing(filename='export.svg', debug=True)
tmp = [(float("%.4g" % e)) for e in self.shape.path]
# Export polygon
if self.shape.line:
svg_path = coupled(tmp)
document.add(document.polygon(points=svg_path))
else: # Export points
svg_path = coupled(coupled(tmp))
for elem in svg_path:
document.add(document.line(
start=elem[0],
end=elem[1]
))
document.save()
self.shape.export_to_png('export.png')
self.pop_export.open()
class InteractionScreen(
Screen
): #This is the main screen for drawing and user input. Next steps include nesting layouts and adding/binding buttons
def __init__(self, **kwargs):
super(InteractionScreen, self).__init__(**kwargs)
self.INTERVAL = 2.6 #THIS INTERVAL IS USED FOR SYNCING IMAGE UPDATING W/ ALGORITHM
### CREATE LAYOUTS
self.layout = FloatLayout(
) #creates a Float Layout called self.layout (self. allows reference for entire class?)
self.layout.width = Window.width
self.layout.height = Window.height
self.layout.x = 0
self.layout.y = 0
self.rightlayout = FloatLayout(
) #creates Float Layout for object selector, speed and angle labels, go button
self.rightlayout.width = self.layout.width * (1. / 6.)
self.rightlayout.height = self.layout.height
self.rightlayout.x = Window.width - self.rightlayout.width
self.rightlayout.y = Window.height / 2 - self.rightlayout.height / 2
self.leftlayout = FloatLayout(
) # float layout for drawing area and background images
self.leftlayout.width = self.layout.width * (5. / 6.)
self.leftlayout.height = self.layout.height
self.leftlayout.x = 0 #Window.width - self.centerlayout.width
self.leftlayout.y = 0 #Window.width/2 - self.centerlayout.height/2
with self.rightlayout.canvas: #sets canvas instructions for the rightlayout and draws a blue rect. filling the entire layout
Color(.125, .184, .31, 1) #BLUE
Rectangle(pos=(self.rightlayout.x, self.rightlayout.y),
size=(self.rightlayout.width, self.rightlayout.height))
### LEFT LAYOUT CONTENT
# DRAWING FUNCTIONALITY
global drawUtility
drawUtility = DrawingApp()
drawUtility.size_hint = (5. / 6., 1)
self.leftlayout.add_widget(drawUtility, 0)
self.layout.add_widget(self.leftlayout, 2)
self.layout.add_widget(self.rightlayout)
self.add_widget(self.layout)
# DEFAULT BACKGROUND IMAGE
self.bg_image_default = Image(source=assetsdirectory +
str('starfield.jpg'))
self.bg_image_default.allow_stretch = True
self.bg_image_default.keep_ratio = False
self.bg_image_default.size_hint = ((5. / 6.), 1)
self.bg_image_default.pos = (0, 0)
self.bg_image_default.opacity = 1.0
self.leftlayout.add_widget(self.bg_image_default,
1) #ADDS DEFAULT BACKGROUND IMAGE
#### BACKGROUND IMAGE UPDATE FUNCTION
self.imageNumber = 1 #default image number, used in XOR function to alternate images in imageUpdate function
self.event = Clock.schedule_interval(
self.imageUpdate, self.INTERVAL
) #SCHEDULES THE IMAGE UPDATING TO OCCUR, INTERVAL DEFINED AT START OF CLASS
### RIGHT LAYOUT CONTENT
# HOME BUTTON
homeButton = Button(text='HOME', font_size='25sp')
homeButton.pos_hint = {'x': 0, 'y': .8}
homeButton.color = [.937, .804, .769, 1]
homeButton.size_hint = ((1. / 6.), .2)
homeButton.background_color = [.353, .396, .522, 1]
homeButton.bind(on_press=self.changer)
self.rightlayout.add_widget(homeButton, 0)
# TOPOGRAPHY LABEL
self.topoLabel = Label(text='TOPOGRAPHY', halign='center')
self.topoLabel.pos_hint = {'x': 0, 'y': .65}
self.topoLabel.color = [.937, .804, .769, 1]
self.topoLabel.font_size = '17sp'
self.topoLabel.size_hint = ((.1 / .6), .2)
self.topoLabel.background_color = [.353, .396, .522, 1]
self.rightlayout.add_widget(self.topoLabel)
# TOPOGRAPHY TOGGLE SWITCH
self.topoSwitch = Switch(
active=True
) # switch to toggle between updating topography and static star field
self.topoSwitch.pos_hint = {'x': 0, 'y': .6}
self.topoSwitch.size_hint = ((1. / 6.), .15)
self.topoSwitch.background_color = [.125, .184, .31, 1]
self.rightlayout.add_widget(self.topoSwitch)
self.topoSwitch.bind(
active=self.topoChange) # bind switch to topoChange function
# SPEED LABEL
self.spdLabel = Label(text='SPEED:\n' + str(drawUtility.speed),
halign='center') # label showing current speed
self.spdLabel.pos_hint = {'x': 0, 'y': .4}
self.spdLabel.font_size = '17sp'
self.spdLabel.color = [.937, .804, .769, 1]
self.spdLabel.size_hint = ((1. / 6.), .2)
self.spdLabel.background_color = [.4, .4, .4, 1]
self.rightlayout.add_widget(self.spdLabel)
def update_speed(
value, instance): # callback function to bind speed to vector
self.spdLabel.text = 'SPEED:\n' + str(drawUtility.speed)
drawUtility.bind(speed=update_speed) # bind speed to vector length
# ANGLE LABEL
self.angLabel = Label(text='ANGLE:\n' + str(drawUtility.angle),
halign='center') # label showing current angle
self.angLabel.pos_hint = {'x': 0, 'y': .2}
self.angLabel.font_size = '17sp'
self.angLabel.size_hint = ((1. / 6.), .2)
self.angLabel.color = [.937, .804, .769, 1]
self.angLabel.background_color = [.4, .4, .4, 1]
self.rightlayout.add_widget(self.angLabel)
def update_angle(
value, instance): # callback function to bind angle to vector
self.angLabel.text = 'ANGLE:\n' + str(drawUtility.angle)
drawUtility.bind(angle=update_angle) # bind angle to vector
# GO! BUTTON
self.goButton = MyButton(
text='GO!') # go button to send user input to algorithm
self.goButton.pos_hint = {'x': 0, 'y': 0}
self.goButton.font_size = '30sp'
self.goButton.size_hint = ((1. / 6.), .2)
self.goButton.color = [.937, .804, .769, 1]
self.goButton.background_color = [.353, .396, .522, 1]
self.goButton.bind(
on_release=self.userInput
) # when the button is released the USERINPUT function is called
self.rightlayout.add_widget(self.goButton)
### FUNCTIONS
def userInput(
self, *args
): # function to save user input and take output from algorithm
name_of_file = 'algorithm_input' # USER INPUT FILENAME
inputFileName = os.path.join(assetsdirectory,
name_of_file + '.txt') #TOTAL PATH NAME
with open(
inputFileName, 'w'
) as f: # create file and write initial and final coordinate positions
f.write('%f\t%f\t%f\t%f' %
(drawUtility.x_initial, drawUtility.y_initial,
drawUtility.x_final, drawUtility.y_final))
drawUtility.canvas.clear()
particle = Particle(
pos=(drawUtility.x_initial, drawUtility.y_initial),
size=(10, 10)) # draw a particle at chosen initial position
drawUtility.add_widget(particle)
while os.path.isfile(
'algorithm_output.npy') == False: # search for output file
sleep(1)
print("Still no file")
else:
#x = np.load('mylistx.npy'); xs = np.split(x, len(x)/200, 0) # test data
#y = np.load('mylisty.npy'); ys = np.split(y, len(y)/200, 0)
print("File found!")
x, y = np.load('algorithm_output.npy') # load in algorithm output
xs = np.split(x,
len(x) / 200, 0)
ys = np.split(
y,
len(y) / 200,
0) # split x and y arrays into manageable chunks for animation
#self.animate(xs, ys, 0, particle) # call animation function with output data
'''
def animate(self, x_coords, y_coords, index, instance): # function to animate particle through orbit
if index < len(x_coords): # check if reached last coordinate chunk
animation = Animation(pos=(int(x_coords[index][0]), int(y_coords[index][0])), t='linear', duration=.02) # create animation instance beginning at first coordinate of chunk
for i in np.arange(1, len(x_coords[index])): # add all points in chunk to animation instance in sequence
animation += Animation(pos=(int(x_coords[index][i]), int(y_coords[index][i])), t='linear', duration=.02)
animation.bind(on_complete=lambda x, y: (self.animate(x_coords, y_coords, index+1, instance))) # once one chunk is animated, animate next
animation.start(instance) # begin animation
'''
def changer(self, *args): # function to go back to home screen
self.manager.current = 'screen1'
self.manager.transition.direction = 'right'
def topoChange(
self, instance,
value): # function for turning updating topography on and off
if self.topoSwitch.active == True: # if topography active, call image update function once every .2 seconds
self.event = Clock.schedule_interval(self.imageUpdate,
self.INTERVAL)
elif self.topoSwitch.active == False: # if topography not active,
self.event.cancel() # cancel clock event
self.leftlayout.remove_widget(
self.bg_image) # remove the updating background image widget
self.leftlayout.add_widget(self.bg_image_default,
1) # add default image widget
def imageUpdate(self, dt): # function for live topography updating
#TESTING MULTIPLE IMAGE UPDATE
try:
self.leftlayout.remove_widget(
self.bg_image_default
) # try to remove both image widgets, ensures proper layering of widgets
self.leftlayout.remove_widget(self.bg_image)
except:
pass
self.imageNumber ^= 1 # XOR function for switching background images between color_field_0 and color_field_1
imageStr = assetsdirectory + str('color_field_') + str(
self.imageNumber) + '.jpg' #color_field_ + 1 or 0
#print('imageNumber: %s' % self.imageNumber)
self.bg_image = Image(source=imageStr)
self.bg_image.allow_stretch = True
self.bg_image.keep_ratio = False
self.bg_image.size_hint = ((5. / 6.), 1)
self.bg_image.pos = (0, 0)
self.bg_image.opacity = 1.0
self.bg_image.nocache = True
#self.bg_image.reload()
self.leftlayout.add_widget(self.bg_image,
1) # add topography image widget
class Anritsu(AbstractSource):
def __init__(self, **kwargs):
super(Anritsu, self).__init__(kwargs=kwargs)
self.is_source_active = False
on_off_label = Label(text="Use Source")
self.on_off_switch = Switch(active=False)
self.on_off_switch.bind(active=self.on_off)
on_off_layout = BoxLayout(orientation="horizontal", size_hint=(1, None), size=(1, 40))
on_off_layout.add_widget(on_off_label)
on_off_layout.add_widget(self.on_off_switch)
init_frec_label = Label(text="Frequency")
self.init_frec_value = TextInput(multiline=False)
self.init_frec_value.disabled = True
self.init_frec_value.text = "0.0"
self.init_frec_unit = UnitSpinner(UnitSpinner.hz)
amplitud_frec_label = Label(text="Power")
self.amplitud_frec_value = TextInput(multiline=False)
self.amplitud_frec_value.disabled = True
self.amplitud_frec_value.bind(text=self._check_input_number)
self.amplitud_frec_unit = UnitSpinner(UnitSpinner.db)
buttons_configuration = GridLayout(cols=3, row_force_default=True, row_default_height=40)
buttons_configuration.add_widget(init_frec_label)
buttons_configuration.add_widget(self.init_frec_value)
buttons_configuration.add_widget(self.init_frec_unit)
buttons_configuration.add_widget(amplitud_frec_label)
buttons_configuration.add_widget(self.amplitud_frec_value)
buttons_configuration.add_widget(self.amplitud_frec_unit)
main_layout = BoxLayout(orientation="vertical")
main_layout.add_widget(on_off_layout)
main_layout.add_widget(buttons_configuration)
self.add_widget(main_layout)
def do_sweep(self):
return False
def is_active(self):
return self.is_source_active
def get_source_config(self):
return_dic = {}
return_dic["ip_direction"] = "TCPIP0::192.168.1.36::inst0::INSTR"
return_dic["power"] = self.amplitud_frec_value.text
return_dic["frequency"] = float(self.init_frec_value.text) * self.init_frec_unit.get_unit_norm()
return_dic["instance"] = AnritsuTone
return return_dic
def save_config_dictionary(self):
data_dic = {}
data_dic["active"] = self.is_source_active
data_dic["power"] = self.amplitud_frec_value.text
data_dic["frequency"] = float(self.init_frec_value.text) * self.init_frec_unit.get_unit_norm()
return {self.get_my_name(): data_dic}
def get_my_name(self):
return "Anritsu"
def set_configuration(self, config_dictionary):
if self.get_my_name() in config_dictionary:
config_dictionary_ = config_dictionary[self.get_my_name()]
self.is_source_active = config_dictionary_["active"]
self.on_off_switch.active = self.is_source_active
self.amplitud_frec_value.text = config_dictionary_["power"]
self.init_frec_value.text = str(config_dictionary_["frequency"])
self.init_frec_unit.text = "Hz"
def on_off(self, spinner, text):
self.is_source_active = text
self.init_frec_value.disabled = not text
self.amplitud_frec_value.disabled = not text
def _check_input_number(self, instance, value):
try:
if len(value) > 0:
float(value)
except ValueError:
if not value == "-":
instance.text = value[0:-1]
popup = Popup(
title="Error",
content=Label(text="Mal valor,\nsolo numeros"),
size_hint=(None, None),
size=(120, 100),
)
popup.open()
class VpnApp(App):
def __init__(self, **kwargs):
super(VpnApp, self).__init__(**kwargs)
self.client = None
self.server = None
self.message_receiver = None
self.debug = False
self.continue_pressed = False
def client_connected_callback(self, ip_addr, port):
self.enable_disable_widgets(
chat_input=True,
send_button=True,
debug_continue=False,
)
sender = "SERVER"
conn = self.client
chat_panel = self.chat_panel
if self.servermode.state == "down":
self.chat_panel.write_info("Client connected from (%s, %i)" % (ip_addr, port))
sender = "CLIENT"
conn = self.server
self.message_receiver = MessageReceiver(sender, conn, chat_panel)
self.message_receiver.start()
# specify which widgets to enable. All unspecified widgets will get disabled
def enable_disable_widgets(
self,
clientmode=None,
servermode=None,
ip_address=None,
port=None,
shared_value=None,
connect=None,
disconnect=None,
chat_panel=None,
chat_input=None,
send_button=None,
debug_switch=None,
debug_continue=None,
):
def enable_widget(enable, widget):
if enable is None:
return
if enable:
widget.disabled = False
else:
widget.disabled = True
enable_widget(clientmode, self.clientmode)
enable_widget(servermode, self.servermode)
enable_widget(ip_address, self.ip_address)
enable_widget(port, self.port)
enable_widget(shared_value, self.shared_value)
enable_widget(connect, self.connect)
enable_widget(disconnect, self.disconnect)
enable_widget(chat_panel, self.chat_panel)
enable_widget(chat_input, self.chat_input)
enable_widget(send_button, self.send_button)
enable_widget(debug_continue, self.debug_continue)
enable_widget(debug_switch, self.debug_switch)
# called when 'Client' toggle button is pressed
def client_callback(self, *args):
state = args[1]
if state == "down":
self.settings_panel.add_widget(self.ip_address, 7)
self.settings_panel.remove_widget(self.debug_boxlayout)
self.settings_panel.remove_widget(self.debug_continue)
self.chat_panel.write_info("Switched to Client Mode")
# called when 'Server' toggle button is pressed
def server_callback(self, *args):
state = args[1]
if state == "down":
self.settings_panel.remove_widget(self.ip_address)
self.settings_panel.add_widget(self.debug_boxlayout, 3)
self.settings_panel.add_widget(self.debug_continue, 3)
self.chat_panel.write_info("Switched to Server Mode")
def debug_continue_callback(self, instance):
self.continue_pressed = True
# called when 'debug' toggled
def debug_callback(self, btn, value):
if value:
self.debug = True
else:
self.debug = False
# called when 'Connect' button is pressed
def connect_callback(self, btn):
self.disconnect.disabled = True
# get inserted port number
port = 0
for child in self.port.children:
if isinstance(child, TextInput):
try:
port = int(child.text)
except ValueError:
self.chat_panel.write_info("Invalid port: " + child.text)
return
# get the shared key value
shared_key = ""
for child in self.shared_value.children:
if isinstance(child, TextInput):
shared_key = str(child.text)
if not shared_key:
self.chat_panel.write_info("Shared key must have some value")
return
# get the inserted ip address
if (self.clientmode.state == 'down'):
ip_address = ""
for child in self.ip_address.children:
if isinstance(child, TextInput):
try:
ip_address = child.text
ipaddress.ip_address(unicode(child.text, 'utf-8'))
except ValueError:
#TODO: print error to chat panel
self.chat_panel.write_info("Invalid IP Address: " + child.text)
return
if (self.servermode.state == 'down'):
# vpn is in 'server' mode
self.server = VpnServer(
port,
shared_key,
self.client_connected_callback,
self.broken_conn_callback,
self.debug_continue,
self.debug,
self
)
error, message = self.server.setup()
if (error != 0):
# error while setting up socket
self.chat_panel.write_info(message)
return
else:
self.chat_panel.write_info(message)
self.enable_disable_widgets(
clientmode=False,
servermode=False,
port=False,
shared_value=False,
connect=False,
disconnect=True,
chat_input=False,
send_button=False,
debug_switch=False,
debug_continue=False,
)
self.server.start(callback=self.client_connected_callback)
else:
# vpn is in 'client' mode
self.client = VpnClient(
ip_address,
port,
shared_key,
self.broken_conn_callback,
self
)
error, message = self.client.connect()
if (error != 0):
self.chat_panel.write_info(message)
return
else:
self.chat_panel.write_info(message)
self.enable_disable_widgets(
clientmode=False,
servermode=False,
ip_address=False,
port=False,
shared_value=False,
connect=False,
disconnect=True,
chat_input=False,
send_button=False,
debug_switch=False,
debug_continue=True,
)
self.client_connected_callback(ip_address, port)
def send_msg(self, btn):
msg = self.chat_input.text
if (len(msg) > 500):
self.chat_panel.write_info("Input cannot be more than 500 characters")
else:
if self.servermode.state == 'down':
self.chat_panel.write_server(msg)
self.server.send(msg)
else:
self.chat_panel.write_client(msg)
self.client.send(msg)
self.chat_input.text = ""
def SettingsEntry(self,text=None):
boxlayout = BoxLayout(orientation="vertical", padding=30)
self.label = Label(text=text, size=(300, 50),size_hint=(1, None))
boxlayout.add_widget(self.label)
self.textinput = TextInput(multiline=False, size=(300, 50), size_hint=(1, None))
boxlayout.add_widget(self.textinput)
return boxlayout
def build(self):
# create the root window for the app
self.root = BoxLayout(
orientation="horizontal",
spacing=10,
padding=10
)
# create settings panel
self.settings_panel = ColoredBoxLayout(
orientation="vertical",
background_color=(0,169,184,0.5),
size_hint=(0.3, 1),
padding=10,
)
self.root.add_widget(self.settings_panel)
# client and server toggle buttons
self.clientmode = ClientServerToggle(
text='Client',
group='mode',
state='down',
allow_no_selection=False,
size=(300,100),
size_hint=(1, None)
)
self.servermode = ClientServerToggle(
text='Server',
group='mode',
allow_no_selection=False,
size=(300,100),
size_hint=(1, None)
)
self.clientmode.bind(state=self.client_callback)
self.servermode.bind(state=self.server_callback)
self.settings_panel.add_widget(self.clientmode)
self.settings_panel.add_widget(self.servermode)
# add empty space
empty_widget = Widget()
self.settings_panel.add_widget(empty_widget)
# add ip address input
self.ip_address = self.SettingsEntry(text="VPN Server IP Address")
self.settings_panel.add_widget(self.ip_address)
# add port input
self.port = self.SettingsEntry(text="VPN Server Port")
self.settings_panel.add_widget(self.port)
# add shared value
self.shared_value = self.SettingsEntry(text="Shared Secret Value")
self.settings_panel.add_widget(self.shared_value)
# add debug mode
self.debug_boxlayout = BoxLayout(orientation="vertical", padding=30)
self.debug_label = Label(text="Debug Mode", size=(300, 50), size_hint=(1, None))
self.debug_boxlayout.add_widget(self.debug_label)
self.debug_switch = Switch(active=False, size=(300, 50), size_hint=(1, None))
self.debug_switch.bind(active=self.debug_callback)
self.debug_boxlayout.add_widget(self.debug_switch)
#self.settings_panel.add_widget(self.debug_boxlayout)
# add debug continue button
self.debug_continue = Button(
text="Continue",
background_color=(0,0,1,1),
size=(300, 100),
size_hint=(1, None),
disabled=True,
)
self.debug_continue.bind(on_press=self.debug_continue_callback)
#self.settings_panel.add_widget(self.debug_continue)
# add empty space
empty_widget = Widget()
self.settings_panel.add_widget(empty_widget)
# add connect and disconnect buttons
self.connect = Button(
text="Connect",
background_color=(0,1,0,1),
size=(300, 150),
size_hint=(1, None)
)
self.connect.bind(on_press=self.connect_callback)
self.disconnect = Button(
text="Disconnect",
background_color=(1,0,0,1),
size=(300, 150),
size_hint=(1, None),
disabled=True,
)
self.disconnect.bind(on_press=self.disconnect_callback)
self.settings_panel.add_widget(self.connect)
self.settings_panel.add_widget(self.disconnect)
# create chat panel
self.chat_layout = BoxLayout(
orientation="vertical",
spacing=10,
size_hint=(0.7, 1)
)
self.chat_panel = ChatPanel(
markup=True,
readonly=True,
scroll_y=1,
focused=True,
cursor_color=(0,0,0,0),
bar_color=(1,0,0,1),
)
self.input_layout = BoxLayout(
orientation="horizontal",
spacing=10,
size=(0, 50),
size_hint=(1, None)
)
self.chat_input = TextInput(size_hint=(0.8, 1))
self.send_button = Button(size_hint=(0.2, 1), text="Send")
self.send_button.bind(on_press=self.send_msg)
self.input_layout.add_widget(self.chat_input)
self.input_layout.add_widget(self.send_button)
self.chat_layout.add_widget(self.chat_panel)
self.chat_layout.add_widget(self.input_layout)
self.root.add_widget(self.chat_layout)
self.chat_input.disabled=True
self.send_button.disabled=True
return self.root
def broken_conn_callback(self):
if self.message_receiver:
self.message_receiver.close()
if self.server:
self.server.broken_conn()
self.server.start(callback=self.client_connected_callback)
self.chat_panel.write_info("Client disconnected")
self.chat_panel.write_info("Listening for connections...")
self.enable_disable_widgets(
chat_input=False,
send_button=False,
debug_continue=False,
)
else:
self.client.close()
self.enable_disable_widgets(
clientmode=True,
servermode=True,
ip_address=True,
port=True,
shared_value=True,
connect=True,
disconnect=False,
chat_input=False,
send_button=False,
debug_switch=True,
debug_continue=False,
)
self.chat_panel.write_info("Lost connection to server")
def disconnect_callback(self, instance):
if self.servermode.state == 'down':
self.server.close()
self.chat_panel.write_info("Closing Server...")
else:
self.client.close()
self.chat_panel.write_info("Disconnecting from server...")
if self.message_receiver:
self.message_receiver.close()
self.clientmode.disabled=False
self.servermode.disabled=False
self.ip_address.disabled=False
self.port.disabled=False
self.shared_value.disabled=False
self.connect.disabled=False
self.disconnect.disabled=True
self.chat_input.disabled=True
self.send_button.disabled=True
self.debug_switch.disabled=False
self.debug_continue.disabled=True
def close(self):
if self.server:
self.server.close()
if self.client:
self.client.close()
if self.message_receiver:
self.message_receiver.close()
class Screen(FloatLayout):
def build(self):
self.object1 = BoxLayout()
return self.object1
def __init__(self, **kwargs):
super(Screen, self).__init__(**kwargs)
#Fundal image
with self.canvas.before:
self.fundal_image = Image(source = "E:/PROGRAMMIN/Curs/Pentru examen/fisiere proiect/fundal.jpg")
self.fundal_image.opacity = 0.7
self.add_widget(self.fundal_image)
self.rect = Rectangle(size = self.size, pos = self.pos)
self.bind(size = self._update_rect, pos = self._update_rect)
self.layout = FloatLayout()
self.layout.size_hint = (None, None)
self.layout.size = (600, 500)
self.layout.padding = 20
self.fundal_image.add_widget(self.layout)
self.sound = SoundLoader.load("E:/PROGRAMMIN/Curs/Pentru examen/fisiere proiect/JO_-_09_-_Fortitude.ogg")
self.sound.play()
self.sound.loop = True
self.sound.volume = 0.5
self.Menu(None)
def Menu(self, buton):
self.layout.clear_widgets()
self.button1 = Button(text = 'Carousel', bold = True, background_color =(0, 0, 1, 1))
self.button1.pos = (290, 380)
self.button1.size_hint = (0.3, 0.1)
self.layout.add_widget(self.button1)
self.button2 = Button(text = 'Optiuni', bold = True, background_color =(0, 0, 1, 1))
self.button2.pos = (290, 280)
self.button2.size_hint = (0.3, 0.1)
self.layout.add_widget(self.button2)
self.button3 = Button(text = 'About', bold = True, background_color =(0, 0, 1, 1))
self.button3.pos = (290, 180)
self.button3.size_hint = (0.3, 0.1)
self.layout.add_widget(self.button3)
self.button4 = Button(text = 'Iesi', bold = True, background_color =(0, 0, 1, 1))
self.button4.pos = (290, 80)
self.button4.size_hint = (0.3, 0.1)
self.layout.add_widget(self.button4)
self.button1.bind(on_press = self.Carousel)
self.button2.bind(on_press = self.Options)
self.button3.bind(on_press = self.About)
self.button4.bind(on_press = self.Exit)
def Carousel(self, buton):
self.layout.clear_widgets()
self.carousel = Carousel(direction = 'right')
self.carousel.anim_move_duration = 1
self.carousel.loop = True
self.carousel.size_hint = (0.7, 0.7)
self.carousel.pos = (200, 120)
self.layout.add_widget(self.carousel)
self.image1 = Image(source = 'E:/PROGRAMMIN/Curs/Pentru examen/fisiere proiect/nature1.jpg')
self.carousel.add_widget(self.image1)
self.image2 = Image(source= 'E:/PROGRAMMIN/Curs/Pentru examen/fisiere proiect/nature2.jpg')
self.carousel.add_widget(self.image2)
self.image3 = Image(source = 'E:/PROGRAMMIN/Curs/Pentru examen/fisiere proiect/nature3.jpg')
self.carousel.add_widget(self.image3)
self.image4 = Image(source = 'E:/PROGRAMMIN/Curs/Pentru examen/fisiere proiect/nature4.jpg')
self.carousel.add_widget(self.image4)
self.label = Label(text = 'This is the end of the list!', font_size = 30)
self.carousel.add_widget(self.label)
self.backbutton = Button(text = 'Back', bold = True, background_color = (0, 0, 1, 1))
self.backbutton.pos = (200, 100)
self.backbutton.size_hint = (0.7, 0.1)
self.layout.add_widget(self.backbutton)
self.backbutton.bind(on_press = self.Menu)
def Options(self, buton):
self.layout.clear_widgets()
self.switch = Switch(text = 'Music')
self.switch.active = True
self.switch.size_hint = (0.3, 0.2)
self.switch.pos = (300, 360)
self.layout.add_widget(self.switch)
self.show_volume = Label(text = 'Volume = 50')
self.layout.add_widget(self.show_volume)
self.music_slide = Slider(min = 0, max = 100, value = 50)
self.music_slide.step = 5
self.music_slide.size_hint = (0.3, 0.1)
self.music_slide.pos = (300, 180)
self.music_slide.orientation = 'horizontal'
self.layout.add_widget(self.music_slide)
self.button = Button(text = 'Back', bold = True, background_color = (0, 0, 1, 1))
self.button.pos = (300, 120)
self.button.size_hint = (0.3, 0.1)
self.button.opacity = 0.7
self.layout.add_widget(self.button)
self.switch.bind(active = self.mute)
self.music_slide.bind(value = self.volume_value)
self.button.bind(on_press = self.Menu)
def volume_value(self,x,y):
self.show_volume.text = 'Volume ' + str(int(self.music_slide.value))
self.sound.volume = self.music_slide.value / 100
def mute(self,x,y):
if (self.switch.active == False):
self.music_slide.disabled = True
self.sound.stop()
else:
self.music_slide.disabled = False
self.music_slide.value = 0
self.sound.play()
def About(self, buton):
self.layout.clear_widgets()
self.backbutton = Button(text = 'Back', background_color = (0, 0, 1, 1))
self.backbutton.size_hint = (1, 0.1)
self.label = Label(text = 'Thanks InfoAcademy!', bold = True, font_size = 24)
self.blayout = BoxLayout()
self.blayout.orientation = 'vertical'
self.blayout.padding = 40
self.blayout.add_widget(self.backbutton)
self.blayout.add_widget(self.label)
self.backbutton.bind(on_press = self.Menu)
self.popup = Popup(background = 'E:/PROGRAMMIN/Curs/Pentru examen/fisiere proiect/fundal4_tema.jpg')
self.popup.size_hint =(None, None)
self.popup.size = (400, 400)
self.popup.title = 'Who made this aplication?'
self.popup.content = self.blayout
self.popup.open()
self.popup.bind(on_press = self.close_popup)
self.backbutton.bind(on_press = self.close_popup)
def close_popup(self, buton):
self.popup.dismiss()
def Exit(self, buton):
sys.exit()
def _update_rect(self, instance, value):
self.rect.pos = instance.pos
self.rect.size = instance.size
class ProtectorApp(App):
def build(self):
#Creates a grid layout to hold the app interfaces like buttons,switches,labels etc,.
rl = GridLayout(rows = 14)
#creates a main label for app title
l = Label(text = "The Protector Dashboard",
font_size = 30,
size_hint =(.3, .3),
pos_hint ={'right_x':.5, 'center_y':.5},
)
#creates a label for displaying limit
n = Label(text = "Customer Limit",
size_hint =(.2, .2),
pos_hint ={'right_x':.5, 'center_y':.5},
)
#creates a dyanamic label for updating limit
self.limit = Label(text = '', size_hint =(.1, .1))
#creates a label for switch1 title
l2 = Label(text = "Socket",
size_hint =(.2, .2),
pos_hint ={'right_x':.5, 'center_y':.5},
)
#creates a label for switch2 title
l3 = Label(text = "Light",
size_hint =(.2, .2),
pos_hint ={'right_x':.5, 'center_y':.5},
)
#creates a label for switch3 title
l4 = Label(text = "Fan",
size_hint =(.2, .2),
pos_hint ={'right_x':.5, 'center_y':.5},
)
#creates a label to display persons count
l5 = Label(text = "Number of Persons",
size_hint =(.2, .2),
pos_hint ={'right_x':.5, 'center_y':.5},
)
#creates a dynamic label to show the person count
self.output_label = Label(text = '', size_hint =(.1, .1))
#creates a label for High temperature warning
self.warn_label = Label(text = '', size_hint =(.1, .1))
#creates a button instance
b1 = Button(size_hint = (.2, .1),
text ="+")
#binds a function to the instance
b1.bind(state=self.on_up)
#creates a button instance
b2 = Button(size_hint = (.2, .1),
text ="-")
#binds a function to the instance
b2.bind(state=self.on_down)
#creates switch instance
self.s = Switch(active = False, size_hint = (.1,.1))
self.s2 = Switch(active = False, size_hint = (.1,.1))
self.s3 = Switch(active = False, size_hint = (.1,.1))
#adds all the widgets to the layout
rl.add_widget(l)
rl.add_widget(n)
rl.add_widget(b1)
rl.add_widget(self.limit)
rl.add_widget(b2)
rl.add_widget(l5)
rl.add_widget(self.output_label)
rl.add_widget(l2)
rl.add_widget(self.s)
rl.add_widget(l3)
rl.add_widget(self.s2)
rl.add_widget(l4)
rl.add_widget(self.s3)
rl.add_widget(self.warn_label)
#binds functions to the switch instances
self.s.bind(active_norm_pos = self.on_press_sw1)
self.s2.bind(active_norm_pos = self.on_press_sw2)
self.s3.bind(active_norm_pos = self.on_press_sw3)
#create a scheduled clock to update label parameters
Clock.schedule_interval(self.person, 1)
return rl
#function called during switch actions
def on_press_sw1(self,instance,value):
if (value == True):
sendRequest(root_url+"/H")
if (value == False):
sendRequest(root_url+"/L")
#function called during switch actions
def on_press_sw2(self,instance,value):
if (value == True):
sendRequest(root_url+"/O")
if (value == False):
sendRequest(root_url+"/C")
#function called during switch actions
def on_press_sw3(self,instance,value):
if (value == True):
sendRequest(root_url+"/F")
if (value == False):
sendRequest(root_url+"/B")
#function called during button action
def on_up(self,instance,value):
if (value == "down"):
sendRequest(root_url+"/U")
#function called during button action
def on_down(self,instance,value):
if (value == "down"):
sendRequest(root_url+"/D")
#function accessed by clock at an interval of 1 sec
def person(self,instance):
#access the devices IP address and reads the data
html_doc = urllib.request.urlopen(root_url)
soup = BeautifulSoup(html_doc, 'html.parser')
#extracts data from the particular tags
x = soup.find('t1')
l = soup.find('t2')
cc1 = soup.find('c1')
cc2 = soup.find('c2')
cc3 = soup.find('c3')
alt = soup.find('alt')
#removes spaces from the retrived data
c1 = cc1.string.strip()
c2 = cc2.string.strip()
c3 = cc3.string.strip()
al = alt.string.strip()
txt = str(x.string.lstrip())
n = str(l.string.lstrip())
#update the data to labels
self.output_label.text = txt
self.limit.text = n
#checks the data with reference value
if (al > "0"):
#if true updates warning label
self.warn_label.text = "Alert! " + al + " Person"
#checks the data with reference value
if (c1 == "1"):
#if true changes state of switch
self.s.active = True
#checks the data with reference value
if (c1 == "0"):
#if true changes state of switch
self.s.active = False
#checks the data with reference value
if (c2 == "1"):
#if true changes state of switch
self.s2.active = True
#checks the data with reference value
if (c2 == "0"):
#if true changes state of switch
self.s2.active = False
#checks the data with reference value
if (c3 == "1"):
#if true changes state of switch
self.s3.active = True
#checks the data with reference value
if (c3 == "0"):
#if true changes state of switch
self.s3.active = False
class SettingsScreen(Screen):
def __init__(self, theme, data, **kwargs):
super(SettingsScreen, self).__init__(**kwargs)
# the main container
self.root = BoxLayout(orientation='vertical')
# the top bar with the back button
bar = BoxLayout(orientation='horizontal', size_hint=[1, None], size=[150, 50], padding=[20, -20])
self.back_button = Button(
size_hint=[None, None],
size=[50, 50],
on_release=lambda n: self.change_to_menu(theme),
background_normal=f'C:/Users/Nutzer/PycharmProjects/Minesweeper/assets/img/buttons/return_button_normal_{theme.current}.png',
background_down=f'C:/Users/Nutzer/PycharmProjects/Minesweeper/assets/img/buttons/return_button_pressed_{theme.current}.png'
)
bar.add_widget(self.back_button)
self.root.add_widget(bar)
# to display a nice heading
self.heading = Label(
text='Settings',
font_size='50sp',
font_name='gothic',
color=theme.get_secondary(),
halign='center',
valign='bottom',
padding_y=20,
size_hint=[1, None],
size=[150, 150]
)
self.heading.bind(size=self.heading.setter('text_size'))
self.root.add_widget(self.heading)
# to make the settings panel scrollable
settings = ScrollView(
size_hint=[1, 1]
)
# to place the settings groups beneath each other
settings_gridlayout = GridLayout(cols=1, size_hint_y=None)
settings_gridlayout.bind(minimum_height=settings_gridlayout.setter('height'))
# setup the group for the general game settings
self.game_group = SettingsGroup(name='Game settings', theme=theme, size_y=180)
# the grid size settings
grid_size_setting = BoxLayout(orientation='horizontal', size_hint=[1, None], size=[50, 50], padding=[20, 0])
self.grid_size_setting_name = SettingName(name='Grid size', theme=theme, size_hint=[0.33, None], size=[150, 50])
self.grid_size_setting_value = SettingLabel(text=str(data['grid_size']), theme=theme, size_hint=[0.1, None], size=[30, 50],
halign='right')
self.grid_size_setting_slider = Slider(
min=3,
max=20,
step=1,
on_touch_up=lambda instance, touch: self.grid_size_setting_change(self.grid_size_setting_slider,
self.grid_size_setting_value, instance,
touch),
on_touch_move=lambda instance, touch: self.grid_size_setting_update_value_label(
self.grid_size_setting_slider,
self.grid_size_setting_value,
instance, touch),
value=data['grid_size'])
grid_size_setting.add_widget(self.grid_size_setting_name)
grid_size_setting.add_widget(self.grid_size_setting_slider)
grid_size_setting.add_widget(self.grid_size_setting_value)
self.game_group.root.add_widget(grid_size_setting)
# the mines percentage settings
mines_percentage_setting = BoxLayout(orientation='horizontal', size_hint=[1, None], size=[50, 50],
padding=[20, 0])
self.mines_percentage_setting_name = SettingName(name='Mines percentage', theme=theme, size_hint=[0.8, None],
size=[150, 50])
self.mines_percentage_setting_value = SettingLabel(text=str(data['mines_percentage']) + '%', theme=theme, size_hint=[0.2, None],
size=[30, 50], halign='right')
self.mines_percentage_setting_slider = Slider(
min=1,
max=50,
step=1,
on_touch_up=lambda instance, touch: self.mines_percentage_setting_change(
self.mines_percentage_setting_slider,
self.mines_percentage_setting_value,
instance, touch),
on_touch_move=lambda instance, touch: self.mines_percentage_setting_update_value_label(
self.mines_percentage_setting_slider,
self.mines_percentage_setting_value, instance, touch),
value=data['mines_percentage'])
mines_percentage_setting.add_widget(self.mines_percentage_setting_name)
mines_percentage_setting.add_widget(self.mines_percentage_setting_slider)
mines_percentage_setting.add_widget(self.mines_percentage_setting_value)
self.game_group.root.add_widget(mines_percentage_setting)
# self.game_group.root.add_widget(Button(size_hint=[None, None], size=[450, 50]))
# self.game_group.root.add_widget(Button(size_hint=[None, None], size=[450, 50]))
# self.game_group.root.add_widget(Button(size_hint=[None, None], size=[450, 50]))
# self.game_group.root.add_widget(Button(size_hint=[None, None], size=[450, 50]))
# self.game_group.root.add_widget(Button(size_hint=[None, None], size=[450, 50]))
settings_gridlayout.add_widget(self.game_group)
# setup the group for the leaderboard settings
self.leaderboard_group = SettingsGroup(name='Leaderboard', theme=theme, size_y=130)
# the button to clear the leaderboard
leaderboard_clear_setting = AnchorLayout(anchor_x='center', anchor_y='center', size_hint=[1, None],
size=[50, 60], padding=[20, 5])
self.leaderboard_clear_setting_button = Button(text='Clear leaderboard', font_name='gothic', font_size='16sp',
size_hint=[None, None], size=[250, 50],
on_release=self.clear_leaderboard, color=theme.get_secondary(),
background_normal=f'C:/Users/Nutzer/PycharmProjects/Minesweeper/assets/img/buttons/button_normal_{theme.current}.png',
background_down=f'C:/Users/Nutzer/PycharmProjects/Minesweeper/assets/img/buttons/button_pressed_{theme.current}.png', )
leaderboard_clear_setting.add_widget(self.leaderboard_clear_setting_button)
self.leaderboard_group.root.add_widget(leaderboard_clear_setting)
# some placeholders
# self.leaderboard_group.root.add_widget(Button(size_hint=[None, None], size=[450, 50]))
# self.leaderboard_group.root.add_widget(Button(size_hint=[None, None], size=[450, 50]))
# self.leaderboard_group.root.add_widget(Button(size_hint=[None, None], size=[450, 50]))
# self.leaderboard_group.root.add_widget(Button(size_hint=[None, None], size=[450, 50]))
# self.leaderboard_group.root.add_widget(Button(size_hint=[None, None], size=[450, 50]))
settings_gridlayout.add_widget(self.leaderboard_group)
# setup the group for the dark mode settings
self.dark_mode_group = SettingsGroup(name='Appearance', theme=theme, size_y=120)
# the switch for the dark mode
dark_mode_settings = BoxLayout(orientation='horizontal', size_hint=[1, None], size=[50, 50], padding=[20, 5])
# get the state of the switch, according to the settings file
if data['theme'] == 'light':
dark_mode_state = False
else:
dark_mode_state = True
self.dark_mode_settings_name = SettingName(name='Dark mode', theme=theme, size_hint=[1, None], size=[50, 50])
self.dark_mode_setting_switch = Switch(active=dark_mode_state, size_hint=[0.3, None], size=[50, 50])
self.dark_mode_setting_switch.bind(
active=lambda instance, value: self.dark_mode_settings_change(theme, instance, value))
dark_mode_settings.add_widget(self.dark_mode_settings_name)
dark_mode_settings.add_widget(self.dark_mode_setting_switch)
self.dark_mode_group.root.add_widget(dark_mode_settings)
# some placeholders
# self.dark_mode_group.root.add_widget(Button(size_hint=[None, None], size=[450, 50]))
# self.dark_mode_group.root.add_widget(Button(size_hint=[None, None], size=[450, 50]))
# self.dark_mode_group.root.add_widget(Button(size_hint=[None, None], size=[450, 50]))
# self.dark_mode_group.root.add_widget(Button(size_hint=[None, None], size=[450, 50]))
# self.dark_mode_group.root.add_widget(Button(size_hint=[None, None], size=[450, 50]))
settings_gridlayout.add_widget(self.dark_mode_group)
settings.add_widget(settings_gridlayout)
self.root.add_widget(settings)
self.add_widget(self.root)
# apply the given settings
# self.apply_settings(data)
def change_to_menu(self, theme):
self.save_settings(theme)
self.manager.current = 'menu_screen'
# GRID SIZE SETTINGS
# grid size settings, fired when the mouse leaves the slider
def grid_size_setting_change(self, slider, label, instance, touch):
if instance.collide_point(*touch.pos):
print('current grid size', slider.value)
self.manager.get_screen('game_screen').weeper.reset_game(grid_size=slider.value)
label.text = str(slider.value)
# calculate the least possible value for the mines percentage slider (so that there is always 1 mine in the
# field)
least_mine_percentage = math.ceil(
(1 * 100) / (self.grid_size_setting_slider.value * self.grid_size_setting_slider.value))
# apply the value to the slider
self.mines_percentage_setting_slider.min = least_mine_percentage
self.mines_percentage_setting_slider.step = least_mine_percentage
# set the value to the value nearest to 15%
self.mines_percentage_setting_slider.value = ((50 - (50 % least_mine_percentage)) * 0.3) - (
(50 - (50 % least_mine_percentage)) * 0.3) % least_mine_percentage
# apply the new value to the minesweeper game and change the value displayed on the side
self.manager.get_screen('game_screen').weeper.reset_game(
mines_percent=self.mines_percentage_setting_slider.value / 100)
self.mines_percentage_setting_value.text = str(int(self.mines_percentage_setting_slider.value)) + '%'
# fired when the slider is moved
def grid_size_setting_update_value_label(self, slider, label, instance, touch):
if instance.collide_point(*touch.pos):
label.text = str(slider.value)
# MINES PERCENTAGE SETTINGS
# fired when the slider is moved
def mines_percentage_setting_change(self, slider, label, instance, touch):
if instance.collide_point(*touch.pos):
print('current mines percent', slider.value / 100)
self.manager.get_screen('game_screen').weeper.reset_game(mines_percent=slider.value / 100)
label.text = str(slider.value) + '%'
# fired when the mouse leaves the slider
def mines_percentage_setting_update_value_label(self, slider, label, instance, touch):
print(instance)
if instance.collide_point(*touch.pos):
label.text = str(slider.value) + '%'
# CLEAR LEADERBOARD SETTINGS
# fires when the button is released, deletes the whole leaderboard
def clear_leaderboard(self, *args):
self.manager.get_screen('leaderboard_screen').entries.clear_all()
self.manager.get_screen('leaderboard_screen').update_list()
# DARK MODE SETTINGS
# fired when the switch is activated
def dark_mode_settings_change(self, theme, instance, value):
print(value)
if value:
theme.current = 'dark'
else:
theme.current = 'light'
Window.clearcolor = theme.get_primary()
self.apply_theme(theme)
# UNIVERSAL: to update the theme when switched
def apply_theme(self, theme):
self.heading.color = theme.get_secondary()
self.game_group.apply_theme(theme)
self.grid_size_setting_name.color = theme.get_secondary()
self.grid_size_setting_value.color = theme.get_secondary()
self.grid_size_setting_slider.color = theme.get_secondary()
self.mines_percentage_setting_name.color = theme.get_secondary()
self.mines_percentage_setting_value.color = theme.get_secondary()
self.mines_percentage_setting_slider.color = theme.get_secondary()
self.leaderboard_group.apply_theme(theme)
self.leaderboard_clear_setting_button.color = theme.get_secondary()
# recolor button
self.leaderboard_clear_setting_button.background_normal = f'C:/Users/Nutzer/PycharmProjects/Minesweeper/assets/img/buttons/button_normal_{theme.current}.png'
self.leaderboard_clear_setting_button.background_down = f'C:/Users/Nutzer/PycharmProjects/Minesweeper/assets/img/buttons/button_pressed_{theme.current}.png'
self.back_button.background_normal = f'C:/Users/Nutzer/PycharmProjects/Minesweeper/assets/img/buttons/return_button_normal_{theme.current}.png'
self.back_button.background_down = f'C:/Users/Nutzer/PycharmProjects/Minesweeper/assets/img/buttons/return_button_pressed_{theme.current}.png'
self.dark_mode_group.apply_theme(theme)
self.dark_mode_settings_name.color = theme.get_secondary()
self.manager.get_screen('menu_screen').apply_theme(theme)
self.manager.get_screen('game_screen').apply_theme(theme)
self.manager.get_screen('pause_screen').apply_theme(theme)
self.manager.get_screen('game_over_screen').apply_theme(theme)
self.manager.get_screen('leaderboard_screen').apply_theme(theme)
# save the current settings
def save_settings(self, theme):
data = {}
data['grid_size'] = self.grid_size_setting_slider.value
data['mines_percentage'] = self.mines_percentage_setting_slider.value
data['theme'] = theme.current
with open('saves\settings.json', 'w') as settings_file:
json.dump(data, settings_file)
class ZhonxGUIApp(App):
def connect(self, instance, value):
print('the switch', instance, 'is', value)
if value == True:
try:
self.connection = serial.Serial(self.dlPort.text, self.dlBaudrate.text)
except Exception as e:
# instance.active = False
print(e)
else:
try:
self.connection.close()
except Exception as e:
# instance.active = True
print(e)
def build(self):
self.availablePorts = listSerialPorts()
if len(self.availablePorts) == 0:
self.availablePorts.append("----")
tabbedPannel = TabbedPanel(do_default_tab=False)
# Connection Tab
self.connectionTab = TabbedPanelItem(text="Connection")
self.layout1 = BoxLayout(orientation='vertical', spacing=10, padding=(200, 200))
self.connectionTab.add_widget(self.layout1)
self.lblSerialSettings = Label(text="Connection settings")
self.layout1.add_widget(self.lblSerialSettings)
self.dlBaudrate = Spinner(values = ["57600", "115200", "230400", "460800", "921600"],
text = "115200")
self.layout1.add_widget(self.dlBaudrate)
self.dlPort = Spinner(values = self.availablePorts,
text = self.availablePorts[0])
self.layout1.add_widget(self.dlPort)
self.btnConnect = Switch()
self.btnConnect.bind(active = self.connect)
self.layout1.add_widget(self.btnConnect)
# Graph tab
self.graphTab = TabbedPanelItem(text = "Graph")
# self.layout2 = BoxLayout(orientation='vertical', spacing=10, padding=(200, 200))
# self.graphTab.add_widget(self.layout2)
graph = Graph(xlabel='X', ylabel='Y', x_ticks_minor=5,
x_ticks_major=25, y_ticks_major=1,
y_grid_label=True, x_grid_label=True, padding=5,
x_grid=True, y_grid=True, xmin=-0, xmax=100, ymin=-1, ymax=1)
plot = MeshLinePlot(color=[1, 1, 0, 1])
plot.points = [(x, sin(x / 10.)) for x in range(0, 101)]
graph.add_plot(plot)
self.graphTab.add_widget(graph)
tabbedPannel.add_widget(self.connectionTab)
tabbedPannel.add_widget(self.graphTab)
return tabbedPannel
def MmsPop(self):
layout = GridLayout(cols=1, size_hint=(None, 1.0), width=700)
layout.bind(minimum_height=layout.setter('height'))
panel = SettingsPanel(title="Mms Mods", settings=self)
main = BoxLayout(orientation='vertical')
root = ScrollView(size_hint=(None, None),
bar_margin=-11,
bar_color=(47 / 255., 167 / 255., 212 / 255., 1.),
do_scroll_x=False)
root.size = (600, 400)
root.add_widget(layout)
main.add_widget(root)
done = Button(text='Done Choosing Options')
main.add_widget(done)
if """ .line 77
const/4 v0, 0x1
sput-boolean v0, Lcom/android/mms/model/ImageModel;->mCheckResolution:Z""" in open(
"%s/ImageModel.smali" % (Mms)).read():
fp = open("%s/ImageModel.smali" % (Mms), "r")
lines = fp.readlines()
fp.close()
comp = SettingItem(panel=panel,
title="Remove Mms Compression",
disabled=False,
desc="Disables Compression of Mms Messages")
for i in range(len(lines)):
if """ .line 77
const/4 v0, 0x1
sput-boolean v0, Lcom/android/mms/model/ImageModel;->mCheckResolution:Z""" in open(
"%s/ImageModel.smali" % (Mms)).read():
comp_switch = Switch(active=False)
continue
if """ .line 77
const/4 v0, 0x1
sput-boolean v0, Lcom/android/mms/model/ImageModel;->mCheckResolution:Z""" in open(
"%s/ImageModel.smali" % (Mms)).read():
comp_switch = Switch(active=True)
comp.add_widget(comp_switch)
layout.add_widget(comp)
def callback(instance, value):
comp_state(instance, value)
comp_switch.bind(active=callback)
popup = Popup(background='atlas://images/eds/pop',
title='Mms Mods',
content=main,
auto_dismiss=False,
size_hint=(None, None),
size=(630, 500))
popup.open()
def finish(self):
finish_comp(self)
popup.dismiss()
done.bind(on_release=finish)
from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.switch import Switch
from var import var
layout = BoxLayout()
switch = Switch(text="setting")
if var == 0:
switch.active = False
elif var == 1:
switch.active = True
layout.add_widget(switch)
def fun(x, y):
if y == True:
f = opne("var.py", "w")
switch.bind(active=fun)
class MyApp(App):
def build(self):
return layout
if __name__ == "__main__":
MyApp().run()
def __init__(self, **kwargs):
super(MainScreen, self).__init__(**kwargs)
self.cols = 1
self.rows = 1
self._data_queue = queue.Queue()
self.gps_location = None
self.gps_status = None
self.default_sensor = "Accelerometer"
self.default_protocol = "terminal"
self.default_server = "test.mosquitto.org"
self.default_port = "1883"
self.default_topic_url = "ie/dcu/ee513"
#Layouts
self._main_layout = BoxLayout(orientation='vertical', padding=0, size_hint=(1, 1))
if (platform == 'android') or (platform == 'ios'):
_terminal_layout = BoxLayout(orientation='vertical', padding=0, size_hint=(1, 0.7))
_partition_layout = GridLayout(cols=2, rows=6, padding=0, size_hint=(1, 1), row_force_default=True, \
rows_minimum={0: 150, 1: 150, 2: 150, 3: 150}, row_default_height=150, spacing=25)
else:
_terminal_layout = BoxLayout(orientation='vertical', padding=0, size_hint=(1, 0.4))
_partition_layout = GridLayout(cols=2, rows=6, padding=0, size_hint=(1, 1), row_force_default=True, \
rows_minimum={0: 50, 1: 50, 2: 50, 3: 50}, row_default_height=50, spacing=25)
_action_previous = ActionPrevious(title='EE513 LABS', with_previous=False, app_icon='icons/sxmitter-logo-app-small.png', padding=0)
_action_overflow = ActionOverflow()
_action_view = ActionView(overflow_group=_action_overflow, use_separator=True)
_action_button = ActionButton(text='debug')
_action_overflow.add_widget(_action_button)
_action_button_about = ActionButton(text='About')
_action_button_about.bind(on_release=self._popup_about)
_action_button_quit = ActionButton(text='Quit')
_action_button_quit.bind(on_release=self.quitApp)
_action_view.add_widget(_action_previous)
_action_view.add_widget(_action_button_about)
_action_view.add_widget(_action_button_quit)
_action_view.add_widget(_action_overflow)
_action_bar = ActionBar(pos_hint={'top': 1})
_action_bar.add_widget(_action_view)
_partition_layout.add_widget(Label(text='Server', size_hint_x=None, width=400))
self._data_object["server"] = self.default_server
self.server = TextInput(text='test.mosquitto.org', multiline=False, cursor_blink=True)
self.server.bind(text=self.callback_server_text)
_partition_layout.add_widget(self.server)
_partition_layout.add_widget(Label(text='Port', size_hint_x=None, width=400))
self._data_object["port"] = self.default_port
self.port = TextInput(text='1883', multiline=False)
self.port.bind(text=self.callback_port_text)
_partition_layout.add_widget(self.port)
_partition_layout.add_widget(Label(text='Sensor', size_hint_x=None, width=400))
self._data_object["sensor"] = self.default_sensor
sensor_spinner = Spinner(
text=self.default_sensor,
values=('Accelerometer', 'Compass', 'GPS', 'Barometer', 'Gravity', 'Gyroscope'),
size_hint=(0.3, 0.5), sync_height=True)
sensor_spinner.bind(text=self.callback_sensor_spinner_text)
_partition_layout.add_widget(sensor_spinner)
_partition_layout.add_widget(Label(text='Protocol', size_hint_x=None, width=400))
self._data_object["protocol"] = self.default_protocol
protocol_spinner = Spinner(
text=self.default_protocol,
values=('http', 'https', 'mqtt', 'udp', 'terminal'),
size_hint=(0.3, 0.5), sync_height=True)
protocol_spinner.bind(text=self.callback_protocol_spinner_text)
_partition_layout.add_widget(protocol_spinner)
_partition_layout.add_widget(Label(text='Topic/URL', size_hint_x=None, width=400))
self._data_object["topic_url"] = self.default_topic_url
self.topic_url = TextInput(text='ie/dcu/ee513', multiline=False)
self.topic_url.bind(text=self.callback_topic_url_text)
_partition_layout.add_widget(self.topic_url)
_partition_layout.add_widget(Label(text='Connect', size_hint_x=None, width=400))
switch = Switch()
switch.bind(active=self.callback_switch)
_partition_layout.add_widget(switch)
self.terminal = TextInput(text='Terminal output...', multiline=True, readonly=False, size_hint=(1, 1))
self.global_terminal = self.terminal
_terminal_layout.add_widget(self.terminal)
self._main_layout.add_widget(_action_bar)
self._main_layout.add_widget(_partition_layout)
self._main_layout.add_widget(_terminal_layout)
self.add_widget(self._main_layout)
from kivy.app import App
from kivy.uix.switch import Switch
sw = Switch(active=True)
# Let's define the callback functions.
def down_callback(instance, value):
print('*****')
def active_callback(instance, value):
if value:
print('activated')
else:
print('deactivated')
# Let's bind the events to the callback functions.
sw.bind(on_touch_down=down_callback)
sw.bind(active=active_callback)
class TestApp(App):
def build(self):
return sw
if __name__ == '__main__':
TestApp().run()
class CustomLayout(FloatLayout):
def __init__(self, **kwargs):
# suprascrierea initului vechi din modul
super(CustomLayout, self).__init__(**kwargs)
# var muzica_activa este o definita in acest namespace pt a avea efect in dezactivarea_volumului
self.muzica_activa = 0
# obiectul layout0 este de tipul FloatLayout()
self.layout0 = FloatLayout()
# setam atributul source al obiect imag1
self.imag1 = Image(source="fundal.jpg")
# adaugam fundalul ca si widget
self.add_widget(self.imag1)
# setam atributele layout0
self.layout0.size = (600, 500)
self.layout0.size_hint = (None, None)
self.layout0.padding = 200
self.imag1.add_widget(self.layout0)
# incarcam widgetul SoundLoader si atributele sale
self.sound = SoundLoader.load('And_So_YouCode Rap_Tarzi.wav')
self.sound.play()
self.sound.loop = True
self.sound.volume = 0.5
# anulam functionalitatile cu care vine metoda
self.Menu(None)
def Menu(self, Buton):
# am curatat layoutul
self.layout0.clear_widgets()
# creare but1 si atributelor sale
self.but1 = Button(text="Carusel",
bold=True,
background_color=(0, 0, 1, 1))
self.but1.pos = (300, 380)
self.but1.size_hint = (0.3, 0.1)
self.but1.opacity = 0.7
#adaugarea ca si widget a but1 pe layout0
self.layout0.add_widget(self.but1)
# creare but2 si atributelor sale
self.but2 = Button(text="Optiuni",
bold=True,
background_color=(0, 0, 1, 1))
self.but2.pos = (300, 300)
self.but2.size_hint = (0.3, 0.1)
self.but2.opacity = 0.7
self.layout0.add_widget(self.but2)
# creare but3 si atributelor sale
self.but3 = Button(text="About",
bold=True,
background_color=(0, 0, 1, 1))
self.but3.pos = (300, 220)
self.but3.size_hint = (0.3, 0.1)
self.but3.opacity = 0.7
self.layout0.add_widget(self.but3)
# creare but4 si atributelor sale
self.but4 = Button(text="Iesi",
bold=True,
background_color=(0, 0, 1, 1))
self.but4.pos = (300, 140)
self.but4.size_hint = (0.3, 0.1)
self.but4.opacity = 0.7
self.layout0.add_widget(self.but4)
# se leaga evenimentele de apasare a butoanelor de metodele de mai jos
self.but1.bind(on_press=self.CatreCarusel)
self.but2.bind(on_press=self.Optiuni)
self.but3.bind(on_press=self.About)
self.but4.bind(on_press=self.Iesi)
def CatreCarusel(self, Buton):
# am curatat layoutul
self.layout0.clear_widgets()
# am adaptat programul din clasa folosind obiecte dar nu merge
# setam directia in care vom misca cu mouse-ul imaginile
self.carousel = Carousel(direction='right')
# setam viteza de miscare
self.carousel.anim_move_duration = 1
self.carousel.loop = True
self.carousel.size_hint = (0.7, 0.7)
self.carousel.pos = (200, 120)
self.carousel.add_widget(self.layout0)
self.image1 = Image(source="nature1.jpg")
self.carousel.add_widget(self.image1)
self.image2 = Image(source="nature2.jpg")
self.carousel.add_widget(self.image2)
self.image3 = Image(source="nature3.jpg")
self.carousel.add_widget(self.image3)
self.image1 = Image(source="nature4.jpg")
self.carousel.add_widget(self.image4)
self.eticheta_final = Label(text="Am ajuns la finalul listei!",
font_size=30)
self.carousel.add_widget(self.eticheta_final)
# cream widgetul inapoiButon
self.inapoiButon = Button(text="Inapoi",
bold=True,
background_color=(0, 0, 1, 1))
self.inapoiButon.pos = (200, 100)
self.inapoiButon.size_hint = (0.7, 0.1)
self.inapoiButon.opacity = 0.7
self.layout0.add_widget(self.inapoiButon)
#legam apasarea butonului de intoarcerea la meniul principal
self.inapoiButon.bind(on_press=self.Menu)
def Optiuni(self, Buton):
self.layout0.clear_widgets()
# Cream un widget Switch si atributele sale
self.switch1 = Switch(text="muzica")
self.switch1.active = True
self.switch1.size_hint = (0.3, 0.2)
self.switch1.pos = (300, 360)
self.layout0.add_widget(self.switch1)
# leaga Switch-ul de metoda dezactiveaza_volum
self.switch1.bind(active=self.dezactiveaza_volum)
# cream un widget Label si atributele sale
# textul de pe acesta urmand sa se schimbe odata cu volumul
self.arata_volum = Label(text="volum: 50")
self.arata_volum.size_hint = (0.3, 0.1)
self.arata_volum.pos = (300, 260)
self.layout0.add_widget(self.arata_volum)
# cream un widget Slider si atributele sale
# nu am urmat exact indicatiile din cerinta pt. a crea atributele
# am incercercat sa fac fereastra sa semene cu poza
self.slide_muzica = Slider(min=0, max=100, value=50)
self.slide_muzica.step = 5
self.slide_muzica.pos = (300, 100)
self.slide_muzica.size_hint = (0.3, 0.5)
self.slide_muzica.orientation = "horizontal"
self.layout0.add_widget(self.slide_muzica)
# leaga Slider-ul de metoda valoare_volum
self.slide_muzica.bind(value=self.valoare_volum)
# crearea widgetu-lui inapoiButon si atributelor sale
self.inapoiButon = Button(text="Inapoi",
bold=True,
background_color=(0, 0, 1, 1))
self.inapoiButon.pos = (300, 120)
self.inapoiButon.size_hint = (0.3, 0.1)
self.inapoiButon.opacity = 0.7
self.layout0.add_widget(self.inapoiButon)
# legam apasarea butonului de intoarcerea la meniul principal
self.inapoiButon.bind(on_press=self.Menu)
def Iesi(self, Buton):
# Apelam sys.exit()
sys.exit()
def valoare_volum(self, x, y):
# modificam Labelul arata_volum aratand valoarea integer a slide-ului
self.arata_volum.text = "volum: " + str(int(self.slide_muzica.value))
self.sound.volume = self.slide_muzica.value / 100
def dezactiveaza_volum(self, x, y):
if (self.muzica_activa % 2 == 0):
# slide-ul este dezactivat
self.slide_muzica.disabled = True
# stocam valoarea slidu-lui intr-o var temporara
self.slide_muzica.value_temp = int(self.slide_muzica.value)
# setam valorea volumului la 0
self.slide_muzica.value = 0
else:
# facem slide-ul iar available
self.slide_muzica.disabled = False
# reluam volumul melodiei din variabila temporara
self.slide_muzica.value = int(self.slide_muzica.value_temp)
self.sound.play()
# folosim aceasta variabila pt. a contoriza switch-ul
self.muzica_activa += 1
def About(self, Buton):
# crearea widgetu-lui inchide si atributelor sale
self.inchide = Button(text="Inapoi", background_color=(0, 0, 1, 1))
self.inchide.pos = (300, 120)
self.inchide.size_hint = (1, 0.1)
# legam apasarea butonului de intoarcerea la meniul principal
self.inchide.bind(on_press=self.inchide_popup)
# cream Label
self.eticheta = Label(text="Multumiri InfoAcademy",
bold=True,
font_size=24)
self.layout1 = BoxLayout()
self.layout1.orientation = "vertical"
self.layout1.padding = 40
self.layout1.add_widget(self.eticheta)
self.layout1.add_widget(self.inchide)
self.popup = Popup()
self.popup.background = "fundal4_tema.jpg"
self.popup.size_hint = (None, None)
self.popup.size = (400, 400)
self.popup.title = 'Cine a creat aplicatia?'
self.popup.content = self.layout1
self.popup.open()
def inchide_popup(self, Buton):
self.popup.dismiss()
class CommonSource(AbstractSource):
def __init__(self, **kwargs):
super(CommonSource, self).__init__(kwargs=kwargs)
main_layout = BoxLayout(orientation='vertical')
on_off_layout = BoxLayout(orientation='horizontal', size_hint=(1,None), size=(1,40))
sweep_layout = BoxLayout(orientation='horizontal', size_hint=(1,None), size=(1,40))
buttons_configuration = GridLayout(cols=3, row_force_default=True, row_default_height=40)
self.is_source_active = False
self.do_a_sweep = False
on_off_label = Label(text='Use Source')
self.on_off_switch = Switch(active=False)
self.on_off_switch.bind(active=self.on_off)
on_off_layout.add_widget(on_off_label)
on_off_layout.add_widget(self.on_off_switch)
sweep_label = Label(text='Do Sweep')
self.sweep_switch = Switch(active=False)
self.sweep_switch.bind(active=self.sweepe_or_not)
sweep_layout.add_widget(sweep_label)
sweep_layout.add_widget(self.sweep_switch)
init_frec_label = Label(text='Initial\nFrequency',)
self.init_frec_value = TextInput(multiline=False)
self.init_frec_value.disabled = True
self.init_frec_value.bind(text=self.update_values)
self.init_frec_unit = UnitSpinner(UnitSpinner.hz)
final_frec_label = Label(text='Final\nFrequency')
self.final_frec_value = TextInput(multiline=False)
self.final_frec_value.disabled = True
self.final_frec_value.bind(text=self.update_values)
self.final_frec_unit = UnitSpinner(UnitSpinner.hz)
delta_frec_label = Label(text='Frequency\nStep')
self.delta_frec_value = TextInput(multiline=False)
self.delta_frec_value.disabled = True
self.delta_frec_value.bind(text=self.change_delta_frec)
self.delta_frec_unit = UnitSpinner(UnitSpinner.hz)
puntos_frec_label = Label(text='Number\nof Points')
self.puntos_frec_value = TextInput(multiline=False)
self.puntos_frec_value.disabled = True
self.puntos_frec_value.bind(text=self.change_points_number)
self.puntos_frec_unit = UnitSpinner(UnitSpinner.simple)
amplitud_frec_label = Label(text='Power')
self.amplitud_frec_value = TextInput(multiline=False)
self.amplitud_frec_value.disabled = True
self.amplitud_frec_value.bind(text=self._check_input_number)
self.amplitud_frec_unit = UnitSpinner(UnitSpinner.db)
buttons_configuration.add_widget(init_frec_label)
buttons_configuration.add_widget(self.init_frec_value)
buttons_configuration.add_widget(self.init_frec_unit)
buttons_configuration.add_widget(final_frec_label)
buttons_configuration.add_widget(self.final_frec_value)
buttons_configuration.add_widget(self.final_frec_unit)
buttons_configuration.add_widget(delta_frec_label)
buttons_configuration.add_widget(self.delta_frec_value)
buttons_configuration.add_widget(self.delta_frec_unit)
buttons_configuration.add_widget(puntos_frec_label)
buttons_configuration.add_widget(self.puntos_frec_value)
buttons_configuration.add_widget(self.puntos_frec_unit)
buttons_configuration.add_widget(amplitud_frec_label)
buttons_configuration.add_widget(self.amplitud_frec_value)
buttons_configuration.add_widget(self.amplitud_frec_unit)
main_layout.add_widget(on_off_layout)
main_layout.add_widget(sweep_layout)
main_layout.add_widget(buttons_configuration)
self.add_widget(main_layout)
self.manual_change_delta = False
self.manual_change_puntos = False
self.manual_change_init = False
self.manual_change_final = False
def get_my_name(self):
pass
def get_my_ip(self):
pass
def get_my_port(self):
pass
def sweepe_or_not(self, spinner, text):
self.do_a_sweep = text
self.final_frec_value.disabled = not (text and self.is_source_active)
self.delta_frec_value.disabled = not (text and self.is_source_active)
self.puntos_frec_value.disabled = not (text and self.is_source_active)
def on_off(self, spinner, text):
self.is_source_active = text
self.final_frec_value.disabled = not (text and self.do_a_sweep)
self.delta_frec_value.disabled = not (text and self.do_a_sweep)
self.puntos_frec_value.disabled = not (text and self.do_a_sweep)
self.init_frec_value.disabled = not text
self.amplitud_frec_value.disabled = not text
def _check_input_number(self,instance, value):
try:
if len(value) > 0:
float(value)
except ValueError:
if not value == '-':
instance.text = value[0:-1]
popup = Popup(title='Error', content=Label(text='Mal valor,\nsolo numeros'),\
size_hint=(None, None), size=(120, 100))
popup.open()
def update_values(self, instance, value):
self._check_input_number(instance, value)
def change_delta_frec(self, instance, value):
self._check_input_number(instance, value)
print 'frec'
if self.manual_change_delta:
self.manual_change_delta = False
return
frec_init = self.init_frec_value._get_text()
frec_final = self.final_frec_value._get_text()
if len(frec_init) < 1 or len(frec_final) < 1:
return
frec_init = float(frec_init)*self.init_frec_unit.get_unit_norm()
frec_final = float(frec_final)*self.final_frec_unit.get_unit_norm()
delta = float(self.delta_frec_value.text)*self.delta_frec_unit.get_unit_norm()
npoints = int((delta + frec_final - frec_init)/delta) + 1
power10 = 1
while npoints >= 1000 or npoints < 1:
if npoints >= 1000:
power10 *= 10**3
npoints *= 10**-3
elif npoints < 1:
power10 *=10**-3
npoints *= 10**3
self.manual_change_puntos = True
self.puntos_frec_value.text = str(npoints)
self.puntos_frec_unit.set_unit(power10)
print 'end'
def change_points_number(self, instance, value):
self._check_input_number(instance, value)
if self.manual_change_puntos:
self.manual_change_puntos = False
return
frec_init = self.init_frec_value._get_text()
frec_final = self.final_frec_value._get_text()
if len(frec_init) < 1 or len(frec_final) < 1:
return
frec_init = float(frec_init)*self.init_frec_unit.get_unit_norm()
frec_final = float(frec_final)*self.final_frec_unit.get_unit_norm()
if frec_init > frec_final:
return
npoint = float(self.puntos_frec_value.text)*self.puntos_frec_unit.get_unit_norm()
if npoint < 2:
return
delta = (frec_final - frec_init)/(npoint - 1)
power10 = 1
while delta >= 1000 or delta < 1:
if delta >= 1000:
power10 *= 10**3
delta *= 10**-3
elif delta < 1:
power10 *=10**-3
delta *= 10**3
self.manual_change_delta = True
self.delta_frec_unit.set_unit(power10)
self.delta_frec_value.text = str(delta)
print 'end pp'
def is_active(self):
return self.is_source_active
def do_sweep(self):
return self.do_a_sweep
def get_source_config(self):
data_dic = {}
data_dic['ip'] = self.get_my_ip()
data_dic['port'] = self.get_my_port()
data_dic['power'] = self.amplitud_frec_value._get_text()
if self.do_a_sweep:
data_dic['frec_init'] = float(self.init_frec_value._get_text())*self.init_frec_unit.get_unit_norm()
data_dic['frec_end'] = float(self.final_frec_value._get_text())*self.final_frec_unit.get_unit_norm()
data_dic['frec_number_point'] = int(self.puntos_frec_value._get_text())*self.puntos_frec_unit.get_unit_norm()
data_dic['instance'] = SourceThread
else:
data_dic['frec'] = float(self.init_frec_value._get_text())*self.init_frec_unit.get_unit_norm()
data_dic['instance'] = ToneDCSource
data_dic['name'] = self.get_my_name()
return data_dic
def save_config_dictionary(self):
data_dic = {}
data_dic['use_source'] = self.is_source_active
data_dic['sweep'] = self.do_a_sweep
data_dic['ip'] = self.get_my_ip()
data_dic['port'] = self.get_my_port()
data_dic['power'] = self.amplitud_frec_value._get_text()
data_dic['frec_init'] = self.init_frec_value._get_text()
data_dic['frec_init_unit'] = self.init_frec_unit.get_unit()
data_dic['frec_end'] = self.final_frec_value._get_text()
data_dic['frec_end_unit'] = self.final_frec_unit.get_unit()
data_dic['frec_number_point'] = self.puntos_frec_value._get_text()
data_dic['frec_numer_points_unit'] = self.puntos_frec_unit.get_unit()
return {self.get_my_name():data_dic}
def set_configuration(self, config_dictionary):
if self.get_my_name() in config_dictionary:
config_dictionary_ = config_dictionary[self.get_my_name()]
self.is_source_active = config_dictionary_['use_source']
self.on_off_switch.active = self.is_source_active
self.do_a_sweep = config_dictionary_['sweep']
self.sweep_switch.active = self.do_a_sweep
self.amplitud_frec_value.text = config_dictionary_['power']
self.init_frec_value.text = config_dictionary_['frec_init']
self.init_frec_unit.text = config_dictionary_['frec_init_unit']
self.final_frec_value.text = config_dictionary_['frec_end']
self.final_frec_unit.text = config_dictionary_['frec_end_unit']
self.puntos_frec_value.text = config_dictionary_['frec_number_point']
self.puntos_frec_unit.text = config_dictionary_['frec_numer_points_unit']
class BeamScanner(AbstractSource):
def __init__(self, **kwargs):
super(BeamScanner, self).__init__(kwargs=kwargs)
# activate the beam scanner
self.active_state = False
self.sweep_state = False
sweep_label = Label(text='Do Sweep')
self.sweep_switch = Switch(active=False)
self.sweep_switch.bind(active=self.sweepe_or_not)
sweep_layout = BoxLayout(orientation='horizontal', size_hint=(1,None), size=(1,40))
sweep_layout.add_widget(sweep_label)
sweep_layout.add_widget(self.sweep_switch)
# this is the controll to move the beam scanner
self.set_center = Button(text='Set Center', size_hint=(1, None), size=(1, 30))
self.set_center.bind(on_press=self.set_zero_xy)
self.move_up = Button(text='/\\', size_hint=(0.33, None), size=(1, 30))
self.move_up.bind(on_press=self.move_up_beam)
move_up_padding_l = Label(size_hint=(0.33, None), size=(1, 30))
move_up_padding_r = Label(size_hint=(0.33, None), size=(1, 30))
self.move_left = Button(text='<', size_hint=(0.33, None), size=(1, 30))
self.move_left.bind(on_press=self.move_left_beam)
self.move_rigth = Button(text='>', size_hint=(0.33, None), size=(1, 30))
self.move_rigth.bind(on_press=self.move_rigth_beam)
self.step_size = TextInput(size_hint=(0.33, None), size=(1, 30), multiline=False)
self.step_size.text = '0.0'
self.move_down = Button(text='\\/', size_hint=(0.33, None), size=(1, 30))
self.move_down.bind(on_press=self.move_down_beam)
move_down_padding_l = Label(size_hint=(0.33, None), size=(1, 30))
move_down_padding_r = Label(size_hint=(0.33, None), size=(1, 30))
move_top = BoxLayout(orientation='horizontal', size_hint=(1, None), size=(1, 30))
move_top.add_widget(move_up_padding_l)
move_top.add_widget(self.move_up)
move_top.add_widget(move_up_padding_r)
move_middle = BoxLayout(orientation='horizontal', size_hint=(1, None), size=(1, 30))
move_middle.add_widget(self.move_left)
move_middle.add_widget(self.step_size)
move_middle.add_widget(self.move_rigth)
move_bottom = BoxLayout(orientation='horizontal', size_hint=(1, None), size=(1, 30))
move_bottom.add_widget(move_down_padding_l)
move_bottom.add_widget(self.move_down)
move_bottom.add_widget(move_down_padding_r)
move_xy_layes = BoxLayout(orientation='vertical', size_hint=(1, None), size=(1, 120))
move_xy_layes.add_widget(self.set_center)
move_xy_layes.add_widget(move_top)
move_xy_layes.add_widget(move_middle)
move_xy_layes.add_widget(move_bottom)
# this is the controll to rotate the beam scanner
self.set_origin = Button(text='Set Zero', size_hint=(0.33, None), size=(1, 30))
self.set_origin.bind(on_press=self.set_zero_ang)
self.do_rotation = Button(text='Rotate to:', size_hint=(0.33, None), size=(1, 30))
self.do_rotation.bind(on_press=self.rotate)
self.destination_angle = TextInput(size_hint=(0.33, None), size=(1, 30), multiline=False)
self.destination_angle.text = '0.0'
rotation_layou = BoxLayout(orientation='horizontal', size_hint=(1, None), size=(1, 30))
rotation_layou.add_widget(self.set_origin)
rotation_layou.add_widget(self.do_rotation)
rotation_layou.add_widget(self.destination_angle)
# rotation speed
speed_rotation = Label(text='Angular Speed', size_hint=(1, None), size=(1, 30))
self.speed_rotation_value = TextInput(size_hint=(1, None), size=(1, 30))
self.speed_rotation_value.text = '10.0'
rotation_speed = BoxLayout(orientaion='horizontal', size_hint=(1, None), size=(1, 30))
rotation_speed.add_widget(speed_rotation)
rotation_speed.add_widget(self.speed_rotation_value)
# check the plane movility
size_of_plane_label = Label(text='Plane size [mm]', size=(1, 30))
self.size_of_plane_val = TextInput(size=(1, 30), multiline=False)
self.size_of_plane_val.text = '0.0'
self.size_of_plane_val.bind(focus=self.set_number_of_points)
plane_size = BoxLayout(orientaion='horizontal', size_hint=(1, None), size=(1, 30))
plane_size.add_widget(size_of_plane_label)
plane_size.add_widget(self.size_of_plane_val)
# configuration
# frecuency
frec_label = Label(text='Set Lambda [mm]: ', size_hint=(1, None), size=(1, 30))
self.frec_value = TextInput(size_hint=(1, None), size=(1, 30), multiline=False)
self.frec_value.text = '0.0'
self.frec_value.bind(focus=self.set_number_of_points)
frec_step = Label(text='Step factor: ', size_hint=(1, None), size=(1, 30))
self.frec_step_value = TextInput(size_hint=(1, None), size=(1, 30), multiline=False)
self.frec_step_value.text = '0.45'
self.frec_step_value.bind(focus=self.set_number_of_points)
frec_layout_val = BoxLayout(orientation='horizontal', size_hint=(1, None), size=(1, 30))
frec_layout_val.add_widget(frec_label)
frec_layout_val.add_widget(self.frec_value)
frec_layout_step = BoxLayout(orientation='horizontal', size_hint=(1, None), size=(1, 30))
frec_layout_step.add_widget(frec_step)
frec_layout_step.add_widget(self.frec_step_value)
frec_layout = BoxLayout(orientation='vertical', size_hint=(1, None), size=(1, 60))
frec_layout.add_widget(frec_layout_val)
frec_layout.add_widget(frec_layout_step)
# display step
step_label = Label(text='Number of Points: ')
self.step_val = Label(text='0')
display_step = BoxLayout(orientation='horizontal', size_hint=(1, None), size=(1, 30))
display_step.add_widget(step_label)
display_step.add_widget(self.step_val)
# fast sweep enable
self.fast_sweepp = ToggleButton(text='fast sweep', size_hint=(1,None), size=(1,30))
# goto configuration
goto_label = Label(text='Go to Position')
self.goto_switch = Switch(active=False)
self.goto_switch.bind(active=self.goto_or_not)
x_dest = Label(text = 'x position [mm]')
y_dest = Label(text = 'y position [mm]')
theta_dest = Label(text = 'angle [Degree]')
self.x_dest_val = TextInput(size_hint=(0.33, None), size=(1, 30), multiline=False)
self.x_dest_val.text = '0.0'
self.y_dest_val = TextInput(size_hint=(0.33, None), size=(1, 30), multiline=False)
self.y_dest_val.text = '0.0'
self.theta_dest_val = TextInput(size_hint=(0.33, None), size=(1, 30), multiline=False)
self.theta_dest_val.text = '0.0'
goto_layout = BoxLayout(orientation='horizontal', size_hint=(1, None), size=(1, 30))
goto_layout.add_widget(goto_label)
goto_layout.add_widget(self.goto_switch)
goto_layout_x = BoxLayout(orientation='horizontal', size_hint=(1, None), size=(1, 30))
goto_layout_x.add_widget(x_dest)
goto_layout_x.add_widget(self.x_dest_val)
goto_layout_y = BoxLayout(orientation='horizontal', size_hint=(1, None), size=(1, 30))
goto_layout_y.add_widget(y_dest)
goto_layout_y.add_widget(self.y_dest_val)
goto_layout_theta = BoxLayout(orientation='horizontal', size_hint=(1, None), size=(1, 30))
goto_layout_theta.add_widget(theta_dest)
goto_layout_theta.add_widget(self.theta_dest_val)
goto_switch = BoxLayout(orientation='vertical', size_hint=(1, None), size=(1, 120))
goto_switch.add_widget(goto_layout)
goto_switch.add_widget(goto_layout_x)
goto_switch.add_widget(goto_layout_y)
goto_switch.add_widget(goto_layout_theta)
# big container configuration
paddind = BoxLayout(size_hint=(1, 1), size=(1, 1000))
self.big_one = BoxLayout(orientation='vertical')
self.big_one.add_widget(sweep_layout)
self.big_one.add_widget(move_xy_layes)
self.big_one.add_widget(rotation_layou)
self.big_one.add_widget(rotation_speed)
self.big_one.add_widget(plane_size)
self.big_one.add_widget(frec_layout)
self.big_one.add_widget(display_step)
self.big_one.add_widget(self.fast_sweepp)
self.big_one.add_widget(goto_switch)
self.big_one.add_widget(paddind)
self.add_widget(self.big_one)
# attributes that lets you connect to beam scanner
self.ip_beam = '192.168.1.62'
self.ip_port = 9988
self.move_xy = MoveXY(self.ip_beam, self.ip_port)
self.move_ang = Rotate(self.ip_beam, self.ip_port)
# disconnect thread configuration
self.monitor = threading.Event()
self.disconnect = True
self.launch_thread = False
def sweepe_or_not(self, instance, value):
if value:
self.sweep_state = value
self.goto_switch.active = False
self.active_state = value
def goto_or_not(self, instance, value):
if value:
self.sweep_state = False
self.sweep_switch.active = False
self.active_state = value
def is_active(self):
return self.active_state
def do_sweep(self):
return self.sweep_state
# connecto to configure and move around
def start_connection(self):
self.disconnect = False
if not self.launch_thread:
try:
self.move_xy.start_connection()
self.move_ang.start_connection()
threading.Thread(target=self.close_connection_timer).start()
self.launch_thread = True
try:
self.move_ang.set_hspd(float(self.speed_rotation_value.text))
except:
pass
return True
except socket.error as e:
Popup(title='Error BeamScanner', content=Label(text=e.message),
size_hint=(None, None), size=(200, 200)).open()
return False
return True
def stop_connection(self):
self.move_xy.close_connection()
self.move_ang.close_connection()
# movement of the beam scanner
def move_left_beam(self, instance):
if self.start_connection():
try:
if not self.move_xy.move_relative(float(self.step_size.text), 0):
self.stop_connection()
self.disconnect = True
except Exception as e:
self.stop_connection()
def move_rigth_beam(self, instance):
if self.start_connection():
try:
if not self.move_xy.move_relative(-float(self.step_size.text), 0):
self.stop_connection()
self.disconnect = True
except Exception:
self.stop_connection()
def move_up_beam(self, instance):
if self.start_connection():
try:
if not self.move_xy.move_relative(0, -float(self.step_size.text)):
self.stop_connection()
self.disconnect = True
except Exception as e:
self.stop_connection()
def move_down_beam(self, instance):
if self.start_connection():
try:
if not self.move_xy.move_relative(0, float(self.step_size.text)):
self.stop_connection()
self.disconnect = True
except Exception as e:
self.stop_connection()
def rotate(self, instance):
if self.start_connection():
try:
if not self.move_ang.move_absolute(float(self.destination_angle.text)):
self.stop_connection()
self.disconnect = True
except Exception:
self.stop_connection()
def set_zero_xy(self, instance):
if self.start_connection():
try:
if not self.move_xy.set_origin():
self.stop_connection()
self.disconnect = True
except Exception:
self.stop_connection()
def set_zero_ang(self, instance):
if self.start_connection():
try:
if not self.move_ang.set_origin():
self.stop_connection()
self.disconnect = True
except Exception:
self.stop_connection()
def set_number_of_points(self, instance, value):
try:
lambda_ = float(self.frec_value.text)
factor = float(self.frec_step_value.text)
if lambda_*factor > 0:
size = float(self.size_of_plane_val.text)
points = int(0.5 + size/(lambda_*factor)) + 1
self.step_val.text = str(points*points)
except:
pass
# thead de apagado
def close_connection_timer(self):
print 'close function initiated'
while 1:
if self.disconnect:
print 'closing function'
self.stop_connection()
break
self.disconnect = True
self.monitor.wait(15)
self.launch_thread = False
def get_source_config(self):
return_dic = {}
try :
if self.sweep_state:
return_dic['size'] = float(self.size_of_plane_val.text)
return_dic['frec_number_point'] = (int(self.step_val.text))
return_dic['angle_to_measure'] = float(self.destination_angle.text)
return_dic['instance'] = BeamScannerController
return_dic['angle_speed'] = float(self.speed_rotation_value.text)
return_dic['name'] = self.get_my_name()
return_dic['fast'] = self.fast_sweepp.state != 'normal'
if return_dic['fast']:
return_dic['total_points'] = sqrt(int(self.step_val.text))*2
return_dic['frec_number_point'] = sqrt(int(self.step_val.text))*2
else:
return_dic['total_points'] = int(self.step_val.text)
return_dic['frec_number_point'] = int(self.step_val.text)
else:
return_dic['angle_speed'] = float(self.speed_rotation_value.text)
return_dic['name'] = self.get_my_name()
return_dic['instance'] = BeamScannerControllerTone
return_dic['x'] = float(self.x_dest_val.text)
return_dic['y'] = float(self.y_dest_val.text)
return_dic['theta'] = float(self.theta_dest_val.text)
except:
raise Exception('Please Enter Numbers only')
return return_dic
def get_my_name(self):
return 'BeamScanner'
def save_config_dictionary(self):
dic_return = {}
dic_return['on_off'] = self.active_state
dic_return['sweep'] = self.sweep_state
dic_return['size'] = self.size_of_plane_val.text
dic_return['total_points'] = self.step_val.text
dic_return['angle_to_measure'] = self.destination_angle.text
dic_return['angle_speed'] = self.speed_rotation_value.text
dic_return['x'] = float(self.x_dest_val.text)
dic_return['y'] = float(self.y_dest_val.text)
dic_return['theta'] = float(self.theta_dest_val.text)
dic_return['lambda'] = self.frec_value.text
dic_return['step_factor'] = self.step_size.text
return {self.get_my_name():dic_return}
def set_configuration(self, config_dictionary):
if self.get_my_name() in config_dictionary:
config_dictionary_ = config_dictionary[self.get_my_name()]
self.active_state = config_dictionary_['on_off']
self.sweep_state = config_dictionary_['sweep']
self.size_of_plane_val.text = config_dictionary_['size']
self.step_val.text = config_dictionary_['total_points']
self.destination_angle.text = config_dictionary_['angle_to_measure']
self.speed_rotation_value.text = config_dictionary_['angle_speed']
self.x_dest_val.text = str(config_dictionary_['x'])
self.y_dest_val.text = str(config_dictionary_['y'])
self.theta_dest_val.text = str(config_dictionary_['theta'])
self.frec_value.text = config_dictionary_['lambda']
self.step_size.text = config_dictionary_['step_factor']
if self.active_state:
if self.sweep_state:
self.sweep_switch.active = True
else:
self.goto_switch.active = True
else:
self.sweep_switch.active = False
self.goto_switch.active = False
else:
self.sweep_switch.active = False
self.goto_switch.active = False
