def __init__(self, **kwargs): Builder.load_file(WIRELESS_CONFIG_VIEW_KV) super(WirelessConfigView, self).__init__(**kwargs) self.register_event_type("on_config_updated") self.base_dir = kwargs.get("base_dir") btEnable = kvFind(self, "rcid", "btEnable") btEnable.bind(on_setting=self.on_bt_enable) btEnable.setControl(SettingsSwitch()) # btConfig = kvFind(self, 'rcid', 'btconfig') # btConfig.bind(on_setting=self.on_bt_configure) # btConfig.setControl(SettingsButton(text='Configure', disabled=True)) cellEnable = kvFind(self, "rcid", "cellEnable") cellEnable.bind(on_setting=self.on_cell_enable) cellEnable.setControl(SettingsSwitch()) cellProvider = kvFind(self, "rcid", "cellprovider") cellProvider.bind(on_setting=self.on_cell_provider) apnSpinner = SettingsMappedSpinner() self.loadApnSettingsSpinner(apnSpinner) self.apnSpinner = apnSpinner cellProvider.setControl(apnSpinner) self.apnHostField = kvFind(self, "rcid", "apnHost") self.apnUserField = kvFind(self, "rcid", "apnUser") self.apnPassField = kvFind(self, "rcid", "apnPass")
def __init__(self, **kwargs): Builder.load_file(DASHBOARD_VIEW_KV) super(DashboardView, self).__init__(**kwargs) self.register_event_type('on_tracks_updated') self._databus = kwargs.get('dataBus') self._settings = kwargs.get('settings') self.init_view()
def __init__(self, **kwargs): Builder.load_file(WIRELESS_CONFIG_VIEW_KV) super(WirelessConfigView, self).__init__(**kwargs) self.register_event_type('on_config_updated') self.base_dir = kwargs.get('base_dir') btEnable = kvFind(self, 'rcid', 'btEnable') btEnable.bind(on_setting=self.on_bt_enable) btEnable.setControl(SettingsSwitch()) #btConfig = kvFind(self, 'rcid', 'btconfig') #btConfig.bind(on_setting=self.on_bt_configure) #btConfig.setControl(SettingsButton(text='Configure', disabled=True)) cellEnable = kvFind(self, 'rcid', 'cellEnable') cellEnable.bind(on_setting=self.on_cell_enable) cellEnable.setControl(SettingsSwitch()) cellProvider = kvFind(self, 'rcid', 'cellprovider') cellProvider.bind(on_setting=self.on_cell_provider) apnSpinner = SettingsMappedSpinner() self.loadApnSettingsSpinner(apnSpinner) self.apnSpinner = apnSpinner cellProvider.setControl(apnSpinner) self.apnHostField = kvFind(self, 'rcid', 'apnHost') self.apnUserField = kvFind(self, 'rcid', 'apnUser') self.apnPassField = kvFind(self, 'rcid', 'apnPass')
def __init__(self, settings, **kwargs): Builder.load_file(PREFERENCES_KV_FILE) super(PreferencesView, self).__init__(**kwargs) self.settings = settings self.base_dir = kwargs.get('base_dir') self.register_event_type('on_pref_change') self.settings_view = SettingsWithNoMenu() self.settings_view.bind(on_config_change=self._on_preferences_change) # So, Kivy's Settings object doesn't allow you to add multiple json panels at a time, only 1. If you add # multiple, the last one added 'wins'. So what we do is load the settings JSON ourselves and then merge it # with any platform-specific settings (if applicable). It's silly, but works. settings_json = json.loads( open( os.path.join(self.base_dir, 'resource', 'settings', 'settings.json')).read()) if platform == 'android': android_settings_json = json.loads( open( os.path.join(self.base_dir, 'resource', 'settings', 'android_settings.json')).read()) settings_json = settings_json + android_settings_json self.settings_view.add_json_panel('Preferences', self.settings.userPrefs.config, data=json.dumps(settings_json)) self.content = kvFind(self, 'rcid', 'preferences') self.content.add_widget(self.settings_view)
def build(self) -> App: self.title = "PathFinder" Builder.load_file('ui/ui_path_finder.kv') app = UiPathFinder() return app
def build(self): Builder.load_file(os.path.join(KV_DIRECTORY, "main.kv")) layout = Main() game = Game() layout.ventures = game.ventures game.calculate() return layout
def __init__(self, **kwargs): Builder.load_file(CAN_CONFIG_VIEW_KV) super(CANConfigView, self).__init__(**kwargs) self.register_event_type('on_config_updated') btEnable = self.ids.can_enabled btEnable.bind(on_setting=self.on_can_enabled) btEnable.setControl(SettingsSwitch())
def __init__(self, **kwargs): Builder.load_file(ANALYSIS_VIEW_KV) super(AnalysisView, self).__init__(**kwargs) self.register_event_type('on_tracks_updated') self._databus = kwargs.get('dataBus') self._settings = kwargs.get('settings') self._trackmanager = kwargs.get('trackmanager') self.init_view()
def __init__(self, **kwargs): Builder.load_file(LAPSTATS_VIEW_KV) super(LapStatsView, self).__init__(**kwargs) self.register_event_type('on_config_updated') self.ids.lapstats.setControl(SettingsSwitch()) self.ids.lapstats.bind(on_setting=self.on_lapstats_enabled) self.ids.predtime.setControl(SettingsSwitch()) self.ids.predtime.bind(on_setting=self.on_predtime_enabled)
def __init__(self, **kwargs): Builder.load_file(LAPSTATS_VIEW_KV) super(LapStatsView, self).__init__(**kwargs) self.register_event_type("on_config_updated") self.ids.lapstats.setControl(SettingsSwitch()) self.ids.lapstats.bind(on_setting=self.on_lapstats_enabled) self.ids.predtime.setControl(SettingsSwitch()) self.ids.predtime.bind(on_setting=self.on_predtime_enabled)
def __init__(self, track_manager, status_pump, **kwargs): Builder.load_file(STATUS_KV_FILE) super(StatusView, self).__init__(**kwargs) self.track_manager = track_manager self.register_event_type("on_tracks_updated") self._menu_node = self.ids.menu self._menu_node.bind(selected_node=self._on_menu_select) status_pump.add_listener(self.status_updated)
def __init__(self, track_manager, status_pump, **kwargs): Builder.load_file(STATUS_KV_FILE) super(StatusView, self).__init__(**kwargs) self.track_manager = track_manager self.register_event_type('on_tracks_updated') self._menu_node = self.ids.menu self._menu_node.bind(selected_node=self._on_menu_select) status_pump.add_listener(self.status_updated)
def __init__(self, **kwargs): Builder.load_file(IMU_CHANNELS_VIEW_KV) super(ImuChannelsView, self).__init__(**kwargs) self.register_event_type('on_config_updated') imu_container = self.ids.imu_channels self.appendImuChannels(imu_container, self.editors, IMU_ACCEL_CHANNEL_IDS) self.appendImuChannels(imu_container, self.editors, IMU_GYRO_CHANNEL_IDS) self.ids.sr.bind(on_sample_rate = self.on_sample_rate)
def __init__(self, app): Builder.load_file("Dossier/Dossier.kv") super(Dossier, self).__init__() self.App = app self.grid = self.ids.grid self.grid.bind(minimum_height=self.grid.setter("height")) for i in self.load_chars(): btn = DossierButton(text=i.Name, char=i) btn.bind(on_press=self.btn_press) self.ids.grid.add_widget(btn)
def __init__(self, **kwargs): Builder.load_file(IMU_CHANNELS_VIEW_KV) super(ImuChannelsView, self).__init__(**kwargs) self.register_event_type('on_config_updated') imu_container = self.ids.imu_channels self.appendImuChannels(imu_container, self.editors, IMU_ACCEL_CHANNEL_IDS) self.appendImuChannels(imu_container, self.editors, IMU_GYRO_CHANNEL_IDS) self.ids.sr.bind(on_sample_rate=self.on_sample_rate)
def __init__(self, **kwargs): Builder.load_file(SCRIPT_VIEW_KV) super(LuaScriptingView, self).__init__(**kwargs) self.register_event_type('on_config_updated') self.register_event_type('on_run_script') self.register_event_type('on_poll_logfile') self.register_event_type('on_logfile') self.register_event_type('on_set_logfile_level') self.logfileView = kvFind(self, 'rcid', 'logfile') self.script_view = kvFind(self, 'rcid', 'script') self.logfileScrollView = kvFind(self, 'rcid', 'logfileSv')
def __init__(self, settings, **kwargs): Builder.load_file(PREFERENCES_KV_FILE) super(PreferencesView, self).__init__(**kwargs) self.settings = settings self.base_dir = kwargs.get('base_dir') self.settings_view = SettingsWithNoMenu() self.settings_view.add_json_panel('Preferences', self.settings.userPrefs.config, os.path.join(self.base_dir, 'resource', 'settings', 'settings.json')) self.content = kvFind(self, 'rcid', 'preferences') self.content.add_widget(self.settings_view)
def __init__(self, **kwargs): Builder.load_file(TELEMETRY_CONFIG_VIEW_KV) super(TelemetryConfigView, self).__init__(**kwargs) self.register_event_type('on_config_updated') deviceId = kvFind(self, 'rcid', 'deviceId') deviceId.bind(on_setting=self.on_device_id) deviceId.setControl(SettingsTextField()) bgStream = kvFind(self, 'rcid', 'bgStream') bgStream.bind(on_setting=self.on_bg_stream) bgStream.setControl(SettingsSwitch())
def __init__(self, **kwargs): Builder.load_file(OBD2_CHANNELS_VIEW_KV) super(OBD2ChannelsView, self).__init__(**kwargs) self.register_event_type("on_config_updated") self.obd2_grid = self.ids.obd2grid obd2_enable = self.ids.obd2enable obd2_enable.bind(on_setting=self.on_obd2_enabled) obd2_enable.setControl(SettingsSwitch()) self.base_dir = kwargs.get("base_dir") self.obd2_settings = OBD2Settings(base_dir=self.base_dir) self.update_view_enabled()
def __init__(self, **kwargs): Builder.load_file(ANALYSIS_VIEW_KV) super(AnalysisView, self).__init__(**kwargs) self._datastore = CachingAnalysisDatastore() self.register_event_type('on_tracks_updated') self._databus = kwargs.get('dataBus') self._settings = kwargs.get('settings') self._track_manager = kwargs.get('track_manager') self.ids.sessions_view.bind(on_lap_selected=self.lap_selected) self.ids.channelvalues.color_sequence = self._color_sequence self.ids.mainchart.color_sequence = self._color_sequence self.stream_connecting = False self.init_view()
def __init__(self, **kwargs): Builder.load_file(OBD2_CHANNELS_VIEW_KV) super(OBD2ChannelsView, self).__init__(**kwargs) self.register_event_type('on_config_updated') self.obd2_grid = self.ids.obd2grid obd2_enable = self.ids.obd2enable obd2_enable.bind(on_setting=self.on_obd2_enabled) obd2_enable.setControl(SettingsSwitch()) self.base_dir = kwargs.get('base_dir') self.obd2_settings = OBD2Settings(base_dir=self.base_dir) self.update_view_enabled()
def __init__(self, settings, **kwargs): Builder.load_file(PREFERENCES_KV_FILE) super(PreferencesView, self).__init__(**kwargs) self.settings = settings self.base_dir = kwargs.get('base_dir') self.settings_view = SettingsWithNoMenu() self.settings_view.add_json_panel( 'Preferences', self.settings.userPrefs.config, os.path.join(self.base_dir, 'resource', 'settings', 'settings.json')) self.content = kvFind(self, 'rcid', 'preferences') self.content.add_widget(self.settings_view)
def __init__(self, **kwargs): Builder.load_file(ANALYSIS_VIEW_KV) super(AnalysisView, self).__init__(**kwargs) self._datastore = CachingAnalysisDatastore() self.register_event_type('on_tracks_updated') self._databus = kwargs.get('dataBus') self._settings = kwargs.get('settings') self._track_manager = kwargs.get('track_manager') self.ids.sessions_view.bind(on_lap_selection=self.lap_selection) self.ids.channelvalues.color_sequence = self._color_sequence self.ids.mainchart.color_sequence = self._color_sequence self.stream_connecting = False Window.bind(mouse_pos=self.on_mouse_pos) Window.bind(on_motion=self.on_motion) self.init_view()
class LapStatsView(BaseConfigView): lap_config = None gps_config = None Builder.load_file(LAPSTATS_VIEW_KV) def __init__(self, **kwargs): super(LapStatsView, self).__init__(**kwargs) self.view_loaded = False self.register_event_type('on_config_updated') self.ids.lapstats.setControl(SettingsSwitch()) self.ids.lapstats.bind(on_setting=self.on_lapstats_enabled) self.ids.predtime.setControl(SettingsSwitch()) self.ids.predtime.bind(on_setting=self.on_predtime_enabled) def on_lapstats_enabled(self, instance, value): if not self.view_loaded: return if self.lap_config: lap_cfg = self.lap_config self._normalize_lap_config(lap_cfg, self.gps_config, value) lap_cfg.stale = True self.dispatch('on_modified') if not value: self.ids.predtime.setValue(False) def on_predtime_enabled(self, instance, value): if not self.view_loaded: return if self.lap_config: if value: # force lapstats enabled if we enable prdictive timing self.ids.lapstats.setValue(True) rate = LapConfig.DEFAULT_PREDICTED_TIME_SAMPLE_RATE if value else 0 config = self.lap_config config.predTime.sampleRate = rate config.stale = True self.dispatch('on_modified') def _normalize_lap_config(self, lap_cfg, gps_cfg, lapstats_enabled): gps_sample_rate = gps_cfg.sampleRate rate = gps_sample_rate if lapstats_enabled else 0 lap_cfg.set_primary_stats(rate) def on_config_updated(self, rcp_cfg): self.view_loaded = False lap_config = rcp_cfg.lapConfig gps_config = rcp_cfg.gpsConfig primary_stats_enabled = lap_config.primary_stats_enabled() self._normalize_lap_config(lap_config, gps_config, primary_stats_enabled) self.ids.lapstats.setValue(primary_stats_enabled) if lap_config.predTime.sampleRate > 0: self.ids.predtime.setValue(True) self.gps_config = rcp_cfg.gpsConfig self.lap_config = lap_config self.view_loaded = True
def __init__(self, **kwargs): Builder.load_file(CONFIG_VIEW_KV) super(ConfigView, self).__init__(**kwargs) self._databus = kwargs.get('databus') self.rc_config = kwargs.get('rcpConfig', None) self.rc_api = kwargs.get('rc_api', None) self._settings = kwargs.get('settings') self.base_dir = kwargs.get('base_dir') self.register_event_type('on_config_updated') self.register_event_type('on_channels_updated') self.register_event_type('on_config_written') self.register_event_type('on_tracks_updated') self.register_event_type('on_config_modified') self.register_event_type('on_read_config') self.register_event_type('on_write_config')
class TrackConfigView(BaseConfigView): Builder.load_file(TRACK_CONFIG_VIEW_KV) trackCfg = None trackDb = None screenManager = None manualTrackConfigView = None autoConfigView = None _databus = None def __init__(self, **kwargs): super(TrackConfigView, self).__init__(**kwargs) self._databus = kwargs.get('databus') self.register_event_type('on_config_updated') self.manualTrackConfigView = ManualTrackConfigScreen( name='manual', databus=self._databus) self.manualTrackConfigView.bind(on_modified=self.on_modified) self.autoConfigView = AutomaticTrackConfigScreen(name='auto') self.autoConfigView.bind(on_modified=self.on_modified) screenMgr = kvFind(self, 'rcid', 'screenmgr') screenMgr.add_widget(self.manualTrackConfigView) self.screenManager = screenMgr autoDetect = kvFind(self, 'rcid', 'autoDetect') autoDetect.bind(on_setting=self.on_auto_detect) autoDetect.setControl(SettingsSwitch()) self.autoConfigView.track_manager = kwargs.get('track_manager') def on_tracks_updated(self, track_manager): self.autoConfigView.track_manager = track_manager def on_config_updated(self, rcpCfg): trackCfg = rcpCfg.trackConfig trackDb = rcpCfg.trackDb autoDetectSwitch = kvFind(self, 'rcid', 'autoDetect') autoDetectSwitch.setValue(trackCfg.autoDetect) self.manualTrackConfigView.on_config_updated(rcpCfg) self.autoConfigView.on_config_updated(rcpCfg) self.trackCfg = trackCfg self.trackDb = trackDb def on_auto_detect(self, instance, value): if value: self.screenManager.switch_to(self.autoConfigView) else: self.screenManager.switch_to(self.manualTrackConfigView) if self.trackCfg: self.trackCfg.autoDetect = value self.trackCfg.stale = True self.dispatch('on_modified')
class WirelessConfigView(BaseConfigView): Builder.load_file(WIRELESS_CONFIG_VIEW_KV) def __init__(self, base_dir, config, capabilities, **kwargs): super(WirelessConfigView, self).__init__(**kwargs) self.register_event_type('on_config_updated') self.register_event_type('on_config_modified') self.base_dir = base_dir self.rcp_capabilities = capabilities self.rcp_config = config self._views = [] self._render() self._attach_event_handlers() def _render(self): if not self.rcp_capabilities or (self.rcp_capabilities and self.rcp_capabilities.has_bluetooth): bluetooth_view = BluetoothConfigView(self.rcp_config) self.ids.wireless_settings.add_widget(bluetooth_view, index=0) self._views.append(bluetooth_view) if not self.rcp_capabilities or (self.rcp_capabilities and self.rcp_capabilities.has_wifi): wifi_view = WifiConfigView(self.base_dir, self.rcp_config) self.ids.wireless_settings.add_widget(wifi_view, index=0) self._views.append(wifi_view) if not self.rcp_capabilities or (self.rcp_capabilities and self.rcp_capabilities.has_cellular): cellular_view = CellularConfigView(self.base_dir, self.rcp_config) self.ids.wireless_settings.add_widget(cellular_view, index=0) self._views.append(cellular_view) def _attach_event_handlers(self): for view in self._views: view.bind(on_modified=self._on_views_modified) def on_config_updated(self, config): # Just destroy everything, re-render self.rcp_config = config self._update_view_configs() def _update_view_configs(self): for view in self._views: view.config_updated(self.rcp_config) def _on_views_modified(self, *args): Logger.debug( "WirelessConfigView: _on_views_modified args: {}".format(args)) Logger.debug("Got view modified") self.dispatch('on_config_modified') def on_config_modified(self, *args): pass
def build(self): self.init_view_builders() Builder.load_file('racecapture.kv') root = self.root status_bar = root.ids.status_bar status_bar.bind(on_main_menu=self.on_main_menu) self.status_bar = status_bar root.ids.main_menu.bind(on_main_menu_item=self.on_main_menu_item) self.mainNav = root.ids.main_nav # reveal_below_anim # reveal_below_simple # slide_above_anim # slide_above_simple # fade_in self.mainNav.anim_type = 'slide_above_anim' rc_api = self._rc_api rc_api.on_progress = lambda value: status_bar.dispatch( 'on_progress', value) rc_api.on_rx = lambda value: status_bar.dispatch('on_data_rx', value) screenMgr = root.ids.main # NoTransition # SlideTransition # SwapTransition # FadeTransition # WipeTransition # FallOutTransition # RiseInTransition screenMgr.transition = NoTransition( ) # FallOutTransition() # NoTransition() self.screenMgr = screenMgr self.icon = ('resource/images/app_icon_128x128.ico' if sys.platform == 'win32' else 'resource/images/app_icon_128x128.png') Clock.schedule_once(lambda dt: self.post_launch(), 1.0)
def __init__(self, settings, **kwargs): Builder.load_file(PREFERENCES_KV_FILE) super(PreferencesView, self).__init__(**kwargs) self.settings = settings self.base_dir = kwargs.get('base_dir') self.settings_view = SettingsWithNoMenu() # So, Kivy's Settings object doesn't allow you to add multiple json panels at a time, only 1. If you add # multiple, the last one added 'wins'. So what we do is load the settings JSON ourselves and then merge it # with any platform-specific settings (if applicable). It's silly, but works. settings_json = json.loads(open(os.path.join(self.base_dir, 'resource', 'settings', 'settings.json')).read()) if platform == 'android': android_settings_json = json.loads(open(os.path.join(self.base_dir, 'resource', 'settings', 'android_settings.json')).read()) settings_json = settings_json + android_settings_json self.settings_view.add_json_panel('Preferences', self.settings.userPrefs.config, data=json.dumps(settings_json)) self.content = kvFind(self, 'rcid', 'preferences') self.content.add_widget(self.settings_view)
def __init__(self, **kwargs): Builder.load_file(TRACK_CONFIG_VIEW_KV) super(TrackConfigView, self).__init__(**kwargs) self._databus = kwargs.get('databus') self.register_event_type('on_config_updated') self.manualTrackConfigView = ManualTrackConfigScreen(name='manual', databus=self._databus) self.manualTrackConfigView.bind(on_modified=self.on_modified) self.autoConfigView = AutomaticTrackConfigScreen(name='auto') self.autoConfigView.bind(on_modified=self.on_modified) screenMgr = kvFind(self, 'rcid', 'screenmgr') screenMgr.add_widget(self.manualTrackConfigView) self.screenManager = screenMgr autoDetect = kvFind(self, 'rcid', 'autoDetect') autoDetect.bind(on_setting=self.on_auto_detect) autoDetect.setControl(SettingsSwitch()) self.autoConfigView.track_manager = kwargs.get('track_manager')
class CANConfigView(BaseConfigView): can_config = None can_settings = [] Builder.load_file(CAN_CONFIG_VIEW_KV) def __init__(self, **kwargs): super(CANConfigView, self).__init__(**kwargs) self.register_event_type('on_config_updated') btEnable = self.ids.can_enabled btEnable.bind(on_setting=self.on_can_enabled) btEnable.setControl(SettingsSwitch()) def on_can_enabled(self, instance, value): if self.can_config: self.can_config.enabled = value self.can_config.stale = True self.dispatch('on_modified') def on_can_baud(self, instance, value): if self.can_config: channel_id = instance.channel_id self.can_config.baudRate[channel_id] = value self.can_config.stale = True self.dispatch('on_modified') def on_config_updated(self, rcpCfg): can_config = rcpCfg.canConfig self.ids.can_enabled.setValue(can_config.enabled) self.update_can_baud_rates(rcpCfg) self.can_config = can_config def update_can_baud_rates(self, rcpCfg): can_config = rcpCfg.canConfig capabilities = rcpCfg.capabilities can_baud_container = self.ids.can_bauds current_children = can_baud_container.children can_channel_count = capabilities.channels.can if len(current_children) != can_channel_count: self.can_settings = [] can_baud_container.clear_widgets for i in range(0, can_channel_count): can_baud_rate_setting = CANBaudRateSettings() self.can_settings.append(can_baud_rate_setting) can_baud_rate_setting.channel_id = i can_baud_rate_setting.label_text = 'CAN {} Baud Rate'.format( i + 1) can_baud_rate_setting.setControl(CANBaudRateSpinner()) can_baud_rate_setting.bind(on_setting=self.on_can_baud) can_baud_container.add_widget(can_baud_rate_setting) for settings, baud in zip(self.can_settings, can_config.baudRate): settings.setValue(baud)
class TelemetryConfigView(BaseConfigView): connectivityConfig = None Builder.load_file(TELEMETRY_CONFIG_VIEW_KV) def __init__(self, capabilities, **kwargs): super(TelemetryConfigView, self).__init__(**kwargs) self.register_event_type('on_config_updated') deviceId = kvFind(self, 'rcid', 'deviceId') deviceId.bind(on_setting=self.on_device_id) deviceId.setControl(SettingsTextField()) self._bg_stream_view = None self.capabilities = capabilities self._render() def _render(self): if self.capabilities.has_cellular: separator = HLineSeparator() self.ids.content.add_widget(separator) bg_stream_view = BackgroundStreamingView() self.ids.content.add_widget(bg_stream_view) bg_stream_view.bind(on_modified=self._on_bg_stream_modified) self._bg_stream_view = bg_stream_view def _on_bg_stream_modified(self, *args): self.dispatch('on_config_modified') def on_device_id(self, instance, value): if self.connectivityConfig and value != self.connectivityConfig.telemetryConfig.deviceId: value = strip_whitespace(value) if len(value) > 0 and not self.validate_device_id(value): instance.set_error('Only numbers / letters allowed') else: #instance.setValue(value) self.connectivityConfig.telemetryConfig.deviceId = value self.connectivityConfig.stale = True self.dispatch('on_modified') instance.clear_error() def on_config_updated(self, rcpCfg): connectivityConfig = rcpCfg.connectivityConfig kvFind(self, 'rcid', 'deviceId').setValue( connectivityConfig.telemetryConfig.deviceId) self.connectivityConfig = connectivityConfig if self._bg_stream_view: self._bg_stream_view.on_config_updated(rcpCfg) def validate_device_id(self, device_id): return device_id.isalnum()
def build(self): self.init_view_builders() Builder.load_file('racecapture.kv') root = self.root status_bar = root.ids.status_bar status_bar.bind(on_main_menu=self.on_main_menu) self.status_bar = status_bar root.ids.main_menu.bind(on_main_menu_item=self.on_main_menu_item) self.mainNav = root.ids.main_nav #reveal_below_anim #reveal_below_simple #slide_above_anim #slide_above_simple #fade_in self.mainNav.anim_type = 'slide_above_anim' rc_api = self._rc_api rc_api.on_progress = lambda value: status_bar.dispatch('on_progress', value) rc_api.on_rx = lambda value: status_bar.dispatch('on_rc_rx', value) rc_api.on_tx = lambda value: status_bar.dispatch('on_rc_tx', value) screenMgr = root.ids.main #NoTransition #SlideTransition #SwapTransition #FadeTransition #WipeTransition #FallOutTransition #RiseInTransition screenMgr.transition=NoTransition() self.screenMgr = screenMgr self.icon = ('resource/images/app_icon_128x128.ico' if sys.platform == 'win32' else 'resource/images/app_icon_128x128.png') Clock.schedule_once(lambda dt: self.post_launch(), 1.0)
def __init__(self, **kwargs): Builder.load_file(TRACK_CONFIG_VIEW_KV) super(TrackConfigView, self).__init__(**kwargs) self._databus = kwargs.get('databus') self.register_event_type('on_config_updated') self.manualTrackConfigView = ManualTrackConfigScreen( name='manual', databus=self._databus) self.manualTrackConfigView.bind(on_modified=self.on_modified) self.autoConfigView = AutomaticTrackConfigScreen(name='auto') self.autoConfigView.bind(on_modified=self.on_modified) screenMgr = kvFind(self, 'rcid', 'screenmgr') screenMgr.add_widget(self.manualTrackConfigView) self.screenManager = screenMgr autoDetect = kvFind(self, 'rcid', 'autoDetect') autoDetect.bind(on_setting=self.on_auto_detect) autoDetect.setControl(SettingsSwitch()) self.autoConfigView.track_manager = kwargs.get('track_manager')
def build(self): Config.set("graphics", "width", X) Config.set("graphics", "height", Y) self.x = X self.y = Y self.home_country = "" self.destination_country = "" self.home_code = "" self.destination_code = "" self.title = "App" self.root = Builder.load_file('gui.kv') self.currency_rates = [] self.app_can_run = True return self.root
class PulseChannelsView(BaseMultiChannelConfigView): Builder.load_file(TIMER_CHANNELS_VIEW_KV) def __init__(self, **kwargs): super(PulseChannelsView, self).__init__(**kwargs) self.channel_title = 'Timer ' self.accordion_item_height = sp(150) def channel_builder(self, index, max_sample_rate): editor = PulseChannel(id='timer' + str(index), channels=self.channels) editor.bind(on_modified=self.on_modified) if self.config: editor.on_config_updated(self.config.channels[index], max_sample_rate) return editor def get_specific_config(self, rcp_cfg): return rcp_cfg.timerConfig
class GPIOChannelsView(BaseMultiChannelConfigView): Builder.load_file(GPIO_CHANNELS_VIEW_KV) def __init__(self, **kwargs): super(GPIOChannelsView, self).__init__(**kwargs) self.channel_title = 'Digital Input/Output ' self.accordion_item_height = sp(120) def channel_builder(self, index, max_sample_rate): editor = GPIOChannel(id='gpio' + str(index), channels=self.channels) editor.bind(on_modified=self.on_modified) if self.config: editor.on_config_updated(self.config.channels[index], max_sample_rate) return editor def get_specific_config(self, rcp_cfg): return rcp_cfg.gpioConfig
class AnalogPulseOutputChannelsView(BaseMultiChannelConfigView): Builder.load_file(ANALOG_PULSE_CHANNELS_VIEW_KV) def __init__(self, **kwargs): super(AnalogPulseOutputChannelsView, self).__init__(**kwargs) self.channel_title = 'Pulse / Analog Output ' self.accordion_item_height = sp(200) def channel_builder(self, index, max_sample_rate): editor = AnalogPulseOutputChannel(id='pwm' + str(index), channels=self.channels) editor.bind(on_modified=self.on_modified) if self.config: editor.on_config_updated(self.config.channels[index], max_sample_rate) return editor def get_specific_config(self, rcp_cfg): return rcp_cfg.pwmConfig
from autosportlabs.racecapture.views.util.alertview import alertPopup from autosportlabs.racecapture.views.analysis.analysiswidget import ChannelAnalysisWidget from autosportlabs.racecapture.views.analysis.markerevent import MarkerEvent from autosportlabs.racecapture.datastore import Filter from autosportlabs.racecapture.views.analysis.analysisdata import ChannelData from autosportlabs.uix.progressspinner import ProgressSpinner from autosportlabs.uix.options.optionsview import OptionsView, BaseOptionsScreen from autosportlabs.racecapture.views.analysis.customizechannelsview import CustomizeChannelsView from autosportlabs.uix.button.widgetbuttons import LabelButton from autosportlabs.racecapture.theme.color import ColorScheme from autosportlabs.uix.toast.kivytoast import toast from fieldlabel import FieldLabel from iconbutton import IconButton, LabelIconButton from autosportlabs.racecapture.views.util.viewutils import format_laptime Builder.load_file('autosportlabs/racecapture/views/analysis/linechart.kv') class ChannelPlot(object): def __init__(self, plot, channel, min_value, max_value, sourceref): self.lap = None self.chart_x_index = None self.plot = plot self.channel = channel self.min_value = min_value self.max_value = max_value self.sourceref = sourceref def __str__(self): return "{}_{}".format(str(self.sourceref), self.channel)
# See the GNU General Public License for more details. You should #have received a copy of the GNU General Public License along with #this code. If not, see <http://www.gnu.org/licenses/>. import kivy kivy.require('1.9.0') from kivy.logger import Logger from kivy.app import Builder from kivy.clock import Clock from kivy.uix.anchorlayout import AnchorLayout from iconbutton import IconButton from autosportlabs.racecapture.views.channels.channelselectview import ChannelSelectView from autosportlabs.racecapture.views.analysis.customizechannelsview import CustomizeChannelsView from autosportlabs.racecapture.views.analysis.markerevent import SourceRef from kivy.uix.popup import Popup from kivy.properties import BooleanProperty, ObjectProperty Builder.load_file('autosportlabs/racecapture/views/analysis/analysiswidget.kv') class OptionsButton(AnchorLayout): pass class AnalysisWidget(AnchorLayout): """ The base for all analysis UI widgets This base class can handle the addition / removal of laps selected for viewing. Selected laps are the basis for determining what data is displayed in a particular widget. Extend this class directly when you want to create a widget that specifically controls the data to be displayed, such as the analysis map. """ options_enabled = BooleanProperty(None)
from kivy.metrics import dp from kivy.uix.boxlayout import BoxLayout from kivy.uix.listview import ListView, ListItemButton from kivy.uix.screenmanager import Screen, SwapTransition from utils import kvFind from kivy.adapters.listadapter import ListAdapter from iconbutton import IconButton from autosportlabs.uix.button.featurebutton import FeatureButton from autosportlabs.racecapture.views.util.alertview import alertPopup from autosportlabs.racecapture.views.file.loaddialogview import LoadDialog from autosportlabs.racecapture.views.file.savedialogview import SaveDialog from autosportlabs.racecapture.views.channels.channelselectview import ChannelSelectorView from iconbutton import IconButton from fieldlabel import FieldLabel Builder.load_file('autosportlabs/racecapture/views/analysis/customizechannelsview.kv') class CustomizeChannelsView(BoxLayout): def __init__(self, **kwargs): super(CustomizeChannelsView, self).__init__(**kwargs) self.register_event_type('on_channels_customized') self.datastore = kwargs.get('datastore') channels = kwargs.get('current_channels') screen_manager = self.ids.screens screen_manager.transition = SwapTransition() add_channels_view = AddChannelsView(name='add') current_channels_view = CurrentChannelsView(name='current') current_channels_view.bind(on_confirm_customize=self.confirm_customize) current_channels_view.bind(on_add_channels=self.add_channels)
import kivy kivy.require('1.9.0') from iconbutton import IconButton from kivy.app import Builder from kivy.metrics import dp from kivy.uix.floatlayout import FloatLayout from kivy.uix.boxlayout import BoxLayout from kivy.uix.listview import ListView, ListItemButton from utils import kvFind from kivy.adapters.listadapter import ListAdapter from kivy.properties import ListProperty from kivy.logger import Logger Builder.load_file('autosportlabs/racecapture/views/channels/channelselectview.kv') class ChannelItemButton(ListItemButton): def __init__(self, **kwargs): super(ChannelItemButton, self).__init__(**kwargs) class ChannelSelectorView(BoxLayout): channels = ListProperty() def __init__(self, **kwargs): super(ChannelSelectorView, self).__init__(**kwargs) self.multi_select = False self.register_event_type('on_channel_selected') self.multi_select = kwargs.get('multi_select', self.multi_select) def select_channel(self, channels): ''' Select one or more channels to show as selected in the view. the view.trigger_action is some voodoo that simulates a UI selection.
#this code. If not, see <http://www.gnu.org/licenses/>. import kivy kivy.require('1.9.1') from kivy.logger import Logger from kivy.graphics import Color from kivy.app import Builder from kivy.clock import Clock from kivy.uix.boxlayout import BoxLayout from kivy.properties import ObjectProperty from autosportlabs.widgets.scrollcontainer import ScrollContainer from autosportlabs.racecapture.datastore import DataStore, Filter from autosportlabs.racecapture.views.analysis.markerevent import SourceRef from autosportlabs.racecapture.views.analysis.analysiswidget import ChannelAnalysisWidget from autosportlabs.uix.gauge.bargraphgauge import BarGraphGauge Builder.load_file('autosportlabs/racecapture/views/analysis/channelvaluesview.kv') class ChannelValueView(BoxLayout): def __init__(self, **kwargs): super(ChannelValueView, self).__init__(**kwargs) self.session_view = self.ids.session self.lap_view = self.ids.lap self.channel_view = self.ids.channel self.value_view = self.ids.value @property def session(self): return self.session_view.text @session.setter
def __init__(self, **kwargs): Builder.load_file(ANALOG_CHANNELS_VIEW_KV) super(AnalogChannelsView, self).__init__(**kwargs) self.channel_title = 'Analog ' self.accordion_item_height = dp(80)
import kivy kivy.require('1.9.0') from kivy.uix.boxlayout import BoxLayout from kivy.uix.label import Label from kivy.app import Builder from kivy.uix.screenmanager import Screen, ScreenManager from kivy.clock import Clock from utils import kvFind from kivy.properties import ObjectProperty from autosportlabs.racecapture.views.dashboard.widgets.digitalgauge import DigitalGauge from kivy.properties import StringProperty from kivy.graphics import Color, Rectangle Builder.load_file('autosportlabs/racecapture/views/dashboard/rawchannelview.kv') NO_DATA_MSG = 'No Data' DATA_MSG = '' RAW_GRID_BGCOLOR_1 = [0 , 0 , 0 , 1.0] RAW_GRID_BGCOLOR_2 = [0.1, 0.1, 0.1, 1.0] RAW_NORMAL_COLOR = [0.0, 1.0, 0.0, 1.0] class RawGauge(DigitalGauge): backgroundColor = ObjectProperty(RAW_GRID_BGCOLOR_1) def __init__(self, **kwargs): super(RawGauge , self).__init__(**kwargs) self.normal_color = RAW_NORMAL_COLOR def update_colors(self): color = self.select_alert_color()
import kivy kivy.require('1.9.1') from iconbutton import IconButton from kivy.app import Builder from kivy.metrics import dp from kivy.uix.floatlayout import FloatLayout from kivy.uix.boxlayout import BoxLayout from kivy.uix.listview import ListView, ListItemButton from utils import kvFind from kivy.adapters.listadapter import ListAdapter from kivy.properties import ListProperty from kivy.logger import Logger Builder.load_file( 'autosportlabs/racecapture/views/channels/channelselectview.kv') class ChannelItemButton(ListItemButton): def __init__(self, **kwargs): super(ChannelItemButton, self).__init__(**kwargs) class ChannelSelectorView(BoxLayout): channels = ListProperty() def __init__(self, **kwargs): super(ChannelSelectorView, self).__init__(**kwargs) self.multi_select = False self.register_event_type('on_channel_selected') self.multi_select = kwargs.get('multi_select', self.multi_select)
import kivy kivy.require('1.8.0') from iconbutton import IconButton from kivy.app import Builder from kivy.metrics import dp from kivy.uix.popup import Popup from kivy.uix.floatlayout import FloatLayout from kivy.uix.relativelayout import RelativeLayout from fieldlabel import FieldLabel from kivy.uix.slider import Slider from utils import kvFind from autosportlabs.racecapture.views.color.colorpickerview import ColorBlock from autosportlabs.racecapture.settings.prefs import Range from autosportlabs.racecapture.views.color.colorpickerview import ColorPickerView Builder.load_file( 'autosportlabs/racecapture/views/channels/channelcustomizationview.kv') class RangeLabel(FieldLabel): pass class ChannelCustomizationView(FloatLayout): _popup = None def __init__(self, **kwargs): self.settings = None self.channel = None self.channelMeta = None self.warnRange = Range()
def __init__(self, **kwargs): Builder.load_file(ANALOG_PULSE_CHANNELS_VIEW_KV) super(AnalogPulseOutputChannelsView, self).__init__(**kwargs) self.channel_title = "Pulse / Analog Output " self.accordion_item_height = dp(100)
import kivy kivy.require('1.9.0') from kivy.uix.boxlayout import BoxLayout from kivy.app import Builder from kivy.metrics import dp from utils import kvFind, kvquery from kivy.properties import NumericProperty, ObjectProperty from autosportlabs.racecapture.views.dashboard.widgets.gauge import CustomizableGauge Builder.load_file('autosportlabs/racecapture/views/dashboard/widgets/digitalgauge.kv') DEFAULT_BACKGROUND_COLOR = [0, 0, 0, 0] class DigitalGauge(CustomizableGauge): alert_background_color = ObjectProperty(DEFAULT_BACKGROUND_COLOR) def __init__(self, **kwargs): super(DigitalGauge, self).__init__(**kwargs) self.normal_color = DEFAULT_BACKGROUND_COLOR def update_title(self, channel, channel_meta): try: self.title = channel if channel else '' except Exception as e: print('Failed to update digital gauge title ' + str(e)) def updateColors(self): self.alert_background_color = self.select_alert_color()
import kivy kivy.require('1.9.0') from kivy.uix.boxlayout import BoxLayout from kivy.uix.label import Label from kivy.app import Builder from kivy.uix.screenmanager import Screen, ScreenManager from kivy.clock import Clock from autosportlabs.racecapture.views.dashboard.widgets.tachometer import Tachometer from autosportlabs.racecapture.views.dashboard.widgets.bignumberview import BigNumberView from autosportlabs.racecapture.views.dashboard.widgets.laptime import Laptime from autosportlabs.racecapture.views.dashboard.widgets.timedelta import TimeDelta from autosportlabs.racecapture.views.dashboard.widgets.gauge import Gauge from utils import kvFind, kvFindClass Builder.load_file('autosportlabs/racecapture/views/dashboard/tachometerview.kv') class TachometerView(Screen): _databus = None _settings = None def __init__(self, databus, settings, **kwargs): super(TachometerView, self).__init__(**kwargs) self._databus = databus self._settings = settings self.initScreen() def on_meta(self, channelMetas): pass def initScreen(self):
def build(self): self.title="Convert Miles to Kilometres" self.root=Builder.load_file("km_converter.kv") return self.root
import math kivy.require('1.9.1') from autosportlabs.uix.color import colorgradient from kivy.uix.label import Label from kivy.uix.floatlayout import FloatLayout from kivy.uix.widget import Widget from kivy.uix.scatter import Scatter from kivy.app import Builder from kivy.metrics import sp from kivy.properties import ListProperty, NumericProperty from kivy.graphics import Color, Line, Bezier, Rectangle from autosportlabs.racecapture.geo.geopoint import GeoPoint from autosportlabs.uix.color.colorgradient import HeatColorGradient, SimpleColorGradient from utils import * Builder.load_file('autosportlabs/uix/track/trackmap.kv') class Point(object): x = 0.0 y = 0.0 def __init__(self, x, y): self.x = x self.y = y class MarkerPoint(Point): def __init__(self, color): super(MarkerPoint, self).__init__(0, 0) self.color = color class TrackPath(object): def __init__(self, path, color):
import kivy kivy.require('1.8.0') from kivy.uix.anchorlayout import AnchorLayout from kivy.uix.label import Label from kivy.app import Builder from collections import OrderedDict from kivy.metrics import dp from kivy.graphics import Color from autosportlabs.racecapture.views.dashboard.widgets.fontgraphicalgauge import FontGraphicalGauge Builder.load_file( 'autosportlabs/racecapture/views/dashboard/widgets/tachometer.kv') TACH_RANGES = OrderedDict([(7000, 'resource/fonts/tach_7000.ttf'), (10000, 'resource/fonts/tach_10000.ttf'), (15000, 'resource/fonts/tach_15000.ttf')]) class Tachometer(FontGraphicalGauge): def __init__(self, **kwargs): super(Tachometer, self).__init__(**kwargs) self.initWidgets() def initWidgets(self): pass def configureRangeFont(self, max): graphView = self.graphView lastRangeFont = None lastRange = 0
import kivy kivy.require('1.9.0') from kivy.uix.boxlayout import BoxLayout from kivy.app import Builder from kivy.properties import StringProperty, ListProperty, BooleanProperty from autosportlabs.racecapture.theme.color import ColorScheme from fieldlabel import FieldLabel from utils import kvFind import mainfonts Builder.load_file('autosportlabs/racecapture/menu/mainmenu.kv') class MainMenuItem(BoxLayout): disabledColor = (0.3, 0.3, 0.3, 1.0) enabledColor = (1.0, 1.0, 1.0, 1.0) rcid = None icon = StringProperty('') description = StringProperty('') enabled = BooleanProperty(True) def __init__(self, **kwargs): super(MainMenuItem, self).__init__(**kwargs) self.bind(icon = self.on_icon_text) self.bind(description = self.on_description_text) rcid = kwargs.get('rcid', None) self.register_event_type('on_main_menu_item_selected') def setEnabledDisabledColor(self, widget): if self.enabled: widget.color = self.enabledColor