From 4fe14af91ed1086595abe40cae514a764405eaa9 Mon Sep 17 00:00:00 2001 From: Kenzo Kowal Date: Fri, 3 Nov 2023 16:49:06 +0100 Subject: [PATCH] commit initial de la premiere version de la AstroVisioBox --- Keyboard.py | 3049 +++++++++++++++++++++++++++++++++++++++++ README | 5 + Whiteboard-Alpha.svg | 420 ++++++ Whiteboard.onboard | 211 +++ bt.svg | 7 + btJabra.py | 27 + cam.png | Bin 0 -> 29228 bytes chat.png | Bin 0 -> 9096 bytes enter.png | Bin 0 -> 3450 bytes exit.png | Bin 0 -> 3784 bytes hand.png | Bin 0 -> 13009 bytes key_defs.xml | 215 +++ micro.png | Bin 0 -> 12981 bytes people.png | Bin 0 -> 7892 bytes quit.png | Bin 0 -> 6018 bytes script.sh | 35 + scripts/btconnect.sh | 5 + scripts/connect.py | 26 + scripts/quit.sh | 6 + scripts/quitScript.py | 27 + scripts/typescript | 0 typescript | 655 +++++++++ 22 files changed, 4688 insertions(+) create mode 100755 Keyboard.py create mode 100644 README create mode 100755 Whiteboard-Alpha.svg create mode 100755 Whiteboard.onboard create mode 100644 bt.svg create mode 100644 btJabra.py create mode 100644 cam.png create mode 100644 chat.png create mode 100644 enter.png create mode 100644 exit.png create mode 100644 hand.png create mode 100755 key_defs.xml create mode 100644 micro.png create mode 100644 people.png create mode 100644 quit.png create mode 100755 script.sh create mode 100755 scripts/btconnect.sh create mode 100755 scripts/connect.py create mode 100755 scripts/quit.sh create mode 100755 scripts/quitScript.py create mode 100644 scripts/typescript create mode 100644 typescript diff --git a/Keyboard.py b/Keyboard.py new file mode 100755 index 0000000..26759f8 --- /dev/null +++ b/Keyboard.py @@ -0,0 +1,3049 @@ +# -*- coding: utf-8 -*- + +# Copyright © 2007 Martin Böhme +# Copyright © 2007-2009 Chris Jones +# Copyright © 2010 Francesco Fumanti +# Copyright © 2012 Gerd Kohlberger +# Copyright © 2009, 2011-2017 marmuta +# +# This file is part of Onboard. +# +# Onboard is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# Onboard is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +from __future__ import division, print_function, unicode_literals + +import time +import weakref +import gc +from contextlib import contextmanager + +from gi.repository import Gdk, GLib + +import logging +_logger = logging.getLogger(__name__) + +from Onboard.Version import require_gi_versions +require_gi_versions() +try: + from gi.repository import Atspi +except ImportError as e: + _logger.warning("Atspi typelib missing, at-spi key-synth unavailable") + +from Onboard import KeyCommon +from Onboard.KeyCommon import StickyBehavior +from Onboard.KeyboardPopups import TouchFeedback +from Onboard.Sound import Sound +from Onboard.ClickSimulator import (ClickSimulator, + CSButtonMapper, CSFloatingSlave) +from Onboard.Scanner import Scanner +from Onboard.Timer import Timer, ProgressiveDelayTimer +from Onboard.utils import (Modifiers, LABEL_MODIFIERS, + parse_key_combination) +from Onboard.definitions import (Handle, UIMask, KeySynthEnum, + UINPUT_DEVICE_NAME) +from Onboard.AutoShow import AutoShow +from Onboard.AutoHide import AutoHide +from Onboard.WordSuggestions import WordSuggestions +from Onboard.canonical_equivalents import canonical_equivalents + +import Onboard.osk as osk + +try: + from Onboard.utils import run_script, get_keysym_from_name, dictproperty +except DeprecationWarning: + pass + +from Onboard.Config import Config +config = Config() + + +class EventType: + """ enum of event types for key press/release """ + ( + CLICK, + DOUBLE_CLICK, + DWELL, + ) = range(3) + + +class DockMode: + """ enum dock mode """ + ( + FLOATING, + BOTTOM, + TOP, + ) = range(3) + + +class ModSource: + """ enum of sources of modifier changes """ + ( + KEYBOARD, + KEYSYNTH, + ) = range(2) + + +class UnpressTimers: + """ + Redraw keys unpressed after a short while. + There are multiple timers to suppurt multi-touch. + """ + + def __init__(self, keyboard): + self._keyboard = keyboard + self._timers = {} + + def start(self, key): + timer = self._timers.get(key) + if not timer: + timer = Timer() + self._timers[key] = timer + timer.start(config.UNPRESS_DELAY, self.on_timer, key) + + def stop(self, key): + timer = self._timers.get(key) + if timer: + timer.stop() + del self._timers[key] + + def cancel_all(self): + for key, timer in self._timers.items(): + Timer.stop(timer) + key.pressed = False + + def finish(self, key): + timer = self._timers.get(key) + if timer: + timer.stop() + self.unpress(key) + + def on_timer(self, key): + self.unpress(key) + self.stop(key) + return False + + def unpress(self, key): + if key.pressed: + key.pressed = False + self._keyboard.on_key_unpressed(key) + + +class KeySynth(object): + + _last_press_time = 0 + _suppress_keypress_delay = False + + @staticmethod + @contextmanager + def no_delay(): + """ + Temporarily disable the keypress delay. Do not nest. + Mainly used for single key-strokes as there are far fewer calls + for these than the bulk text insertion calls. + """ + KeySynth._suppress_keypress_delay = True + yield None + KeySynth._suppress_keypress_delay = False + + def _delay_keypress(self): + """ + Pause between multiple key-strokes. + Firefox and Thunderbird may need this to not miss key-strokes. + """ + delay = config.keyboard.inter_key_stroke_delay + if delay: + # not just single presses? + if not KeySynth._suppress_keypress_delay: + elapsed = time.time() - KeySynth._last_press_time + remaining = delay - elapsed + if remaining > 0.0: + time.sleep(remaining) + + KeySynth._last_press_time = time.time() + + +class KeySynthVirtkey(KeySynth): + """ Synthesize key strokes with python-virtkey """ + + def __init__(self, keyboard, vk): + self._keyboard = keyboard + self._vk = vk + + def cleanup(self): + self._vk = None + + def press_unicode(self, char): + _logger.debug("KeySynthVirtkey.press_unicode({})".format(repr(char))) + if self._vk: + keysym = self._vk.keysym_from_unicode(char) + self.press_keysym(keysym) + + def release_unicode(self, char): + _logger.debug("KeySynthVirtkey.release_unicode({})".format(repr(char))) + if self._vk: + keysym = self._vk.keysym_from_unicode(char) + self.release_keysym(keysym) + + def press_keysym(self, keysym): + _logger.debug("KeySynthVirtkey.press_keysym({})".format(keysym)) + if self._vk: + keycode, mod_mask = self._vk.keycode_from_keysym(keysym) + + # need modifiers for this keysym? + if mod_mask: + self._keyboard.lock_temporary_modifiers( + ModSource.KEYSYNTH, mod_mask) + + self.press_keycode(keycode) + + def release_keysym(self, keysym): + _logger.debug("KeySynthVirtkey.release_keysym({})".format(keysym)) + if self._vk: + keycode, mod_mask = self._vk.keycode_from_keysym(keysym) + self.release_keycode(keycode) + + self._keyboard.unlock_temporary_modifiers(ModSource.KEYSYNTH) + + def press_keycode(self, keycode): + _logger.debug("KeySynthVirtkey.press_keycode({})".format(keycode)) + if self._vk: + self._delay_keypress() + self._vk.press_keycode(keycode) + + def release_keycode(self, keycode): + _logger.debug("KeySynthVirtkey.release_keycode({})".format(keycode)) + if self._vk: + self._vk.release_keycode(keycode) + + def get_current_group(self): + return self._vk.get_current_group() + + def lock_group(self, group): + if self._vk: + self._vk.lock_group(group) + + def lock_mod(self, mod_mask): + if self._vk: + self._vk.lock_mod(mod_mask) + + def unlock_mod(self, mod_mask): + if self._vk: + self._vk.unlock_mod(mod_mask) + + def press_key_string(self, keystr): + """ + Send key presses for all characters in a unicode string. + """ + keystr = keystr.replace("\\n", "\n") # for new lines in snippets + + if self._vk: # may be None in the last call before exiting + for ch in keystr: + if ch == "\b": # backspace? + keysym = get_keysym_from_name("backspace") + self.press_keysym(keysym) + self.release_keysym(keysym) + + elif ch == "\n": + # press_unicode("\n") fails in gedit. + # -> explicitely send the key symbol instead + keysym = get_keysym_from_name("return") + self.press_keysym(keysym) + self.release_keysym(keysym) + else: # any other printable keys + self.press_unicode(ch) + self.release_unicode(ch) + + +class KeySynthAtspi(KeySynthVirtkey): + """ + Synthesize key strokes with AT-SPI + + Not really useful anymore, as key generation there doesn't fit + Onboard's requirements very well, e.g. there is no consistent + separation between press and release events. + + Also some unexpected key sequences are not faithfully reproduced. + """ + + def __init__(self, keyboard, vk): + super(KeySynthAtspi, self).__init__(keyboard, vk) + + def press_keycode(self, keycode): + if "Atspi" not in globals(): + return + self._delay_keypress() + Atspi.generate_keyboard_event(keycode, "", Atspi.KeySynthType.PRESS) + + def release_keycode(self, keycode): + if "Atspi" not in globals(): + return + Atspi.generate_keyboard_event(keycode, "", Atspi.KeySynthType.RELEASE) + + def press_key_string(self, string): + if "Atspi" not in globals(): + return + Atspi.generate_keyboard_event(0, string, Atspi.KeySynthType.STRING) + + +class TextChanger(): + """ + Abstract base class of TextChangers. + """ + + def __init__(self, keyboard, vk): + self.keyboard = keyboard + self.vk = vk + + def cleanup(self): + self.keyboard = None + self.vk = None + + +class TextChangerKeyStroke(TextChanger): + """ + Insert and delete text with key-strokes. + - KeySynthVirtkey + - KeySynthAtspi (not used by default) + """ + + def __init__(self, keyboard, vk): + TextChanger.__init__(self, keyboard, vk) + + self._key_synth_virtkey = KeySynthVirtkey(keyboard, vk) + self._key_synth_atspi = KeySynthAtspi(keyboard, vk) + + self._update_key_synth() + + def _update_key_synth(self): + key_synth_id = KeySynthEnum(config.keyboard.key_synth) + if key_synth_id == KeySynthEnum.AUTO: + key_synth_candidates = [ + KeySynthEnum.XTEST, + KeySynthEnum.UINPUT, + KeySynthEnum.ATSPI] + else: + key_synth_candidates = [key_synth_id] + + _logger.debug("Key-synth candidates: {}" + .format(key_synth_candidates)) + + key_synth_id = None + key_synth = None + vk = self.vk + for id_ in key_synth_candidates: + if id_ == KeySynthEnum.ATSPI: + key_synth = self._key_synth_atspi + key_synth_id = id_ + break + else: + if not vk: + _logger.debug("Key-synth '{}' unavailable: vk is None") + else: + key_synth = self._key_synth_virtkey + try: + if id_ == KeySynthEnum.XTEST: + vk.select_backend(vk.BACKEND_XTEST) + elif id_ == KeySynthEnum.UINPUT: + vk.select_backend(vk.BACKEND_UINPUT, + UINPUT_DEVICE_NAME) + key_synth_id = id_ + break + except osk.error as ex: + _logger.debug("Key-synth '{}' unavailable: {}" + .format(id_, ex)) + + _logger.info("Using key-synth '{}'" + .format(key_synth_id)) + + self._key_synth = key_synth + + def cleanup(self): + # Somehow keyboard objects don't get released + # when switching layouts, there are still + # excess references/memory leaks somewhere. + # We need to manually release virtkey references or + # Xlib runs out of client connections after a couple + # dozen layout switches. + if self._key_synth_virtkey: + self._key_synth_virtkey.cleanup() + self._key_synth_virtkey = None + if self._key_synth_atspi: + self._key_synth_atspi.cleanup() + self._key_synth_atspi = None + + TextChanger.cleanup(self) + + # KeySynth interface + def press_unicode(self, char): + self._key_synth.press_unicode(char) + + def release_unicode(self, char): + self._key_synth.release_unicode(char) + + def press_keycode(self, keycode): + self._key_synth.press_keycode(keycode) + + def release_keycode(self, keycode): + self._key_synth.release_keycode(keycode) + + def press_keysym(self, keysym): + self._key_synth.press_keysym(keysym) + + def release_keysym(self, keysym): + self._key_synth.release_keysym(keysym) + + def get_current_group(self): + return self._key_synth.get_current_group() + + def lock_group(self, group): + self._key_synth.lock_group(group) + + def lock_mod(self, mod): + self._key_synth.lock_mod(mod) + + def unlock_mod(self, mod): + self._key_synth.unlock_mod(mod) + + # Higher-level functions + def press_key_string(self, string): + self._key_synth.press_key_string(string) + + def press_keysyms(self, key_name, count=1): + """ + Generate any number of full key-strokes for the given named key symbol. + """ + keysym = get_keysym_from_name(key_name) + for i in range(count): + self.press_keysym(keysym) + self.release_keysym(keysym) + + def insert_string_at_caret(self, text): + """ + Insert text at the caret position. + """ + self._key_synth.press_key_string(text) + + def delete_at_caret(self): + with self.keyboard.suppress_modifiers(): + self.press_keysyms("backspace") + + +class TextChangerDirectInsert(TextChanger): + """ + Insert and delete text by direct insertion/deletion. + - Direct insertion/deletion via AtspiTextContext + """ + + def __init__(self, keyboard, vk, tcks): + TextChanger.__init__(self, keyboard, vk) + self.text_changer_key_stroke = tcks + + delay, interval = vk.get_auto_repeat_rate() \ + if vk else (500, 30) + self._auto_repeat_delay = delay * 0.001 + self._auto_repeat_interval = interval * 0.001 + + self._auto_repeat_delay_timer = Timer() + self._auto_repeat_timer = Timer() + + _logger.debug("keyboard auto-repeat: delay {}, interval {}" + .format(self._auto_repeat_delay, + self._auto_repeat_interval)) + + def cleanup(self): + self.stop_auto_repeat() + TextChanger.cleanup(self) + + def get_text_context(self): + return self.keyboard.text_context + + def _insert_unicode(self, char): + text_context = self.get_text_context() + if text_context: + text_context.insert_text_at_caret(char) + + def _start_auto_repeat(self, char): + self._auto_repeat_delay_timer.start(self._auto_repeat_delay, + self._on_auto_repeat_delay_timer, + char) + + def stop_auto_repeat(self): + self._auto_repeat_delay_timer.stop() + self._auto_repeat_timer.stop() + + def _on_auto_repeat_delay_timer(self, char): + self._auto_repeat_timer.start(self._auto_repeat_interval, + self._on_auto_repeat_timer, char) + return False + + def _on_auto_repeat_timer(self, char): + self._insert_unicode(char) + return True + + # KeySynth interface + def press_keycode(self, keycode): + """ + Use key-strokes because of dead keys, hot keys and editing keys. + """ + self.stop_auto_repeat() + self.text_changer_key_stroke.press_keycode(keycode) + + def release_keycode(self, keycode): + self.text_changer_key_stroke.release_keycode(keycode) + + def press_keysym(self, keysym): + """ + Use key-strokes because of dead keys, hot keys and editing keys. + """ + self.stop_auto_repeat() + self.text_changer_key_stroke.press_keysym(keysym) + + def release_keysym(self, keysym): + self.text_changer_key_stroke.release_keysym(keysym) + + def press_unicode(self, char): + self._insert_unicode(char) + self._start_auto_repeat(char) + + def release_unicode(self, char): + self.stop_auto_repeat() + + def get_current_group(self): + return self.text_changer_key_stroke.get_current_group() + + def lock_group(self, group): + self.text_changer_key_stroke.lock_group(group) + + def lock_mod(self, mod): + """ + We still have to lock mods for pointer clicks with modifiers + and hot-keys. + """ + self.text_changer_key_stroke.lock_mod(mod) + + def unlock_mod(self, mod): + self.text_changer_key_stroke.unlock_mod(mod) + + # Higher-level functions + def press_key_string(self, string): + pass + + def press_keysyms(self, key_name, count=1): + """ + Generate any number of full key-strokes for the given named key symbol. + """ + self.text_changer_key_stroke.press_keysyms(key_name, count) + + def insert_string_at_caret(self, text): + """ + Insert text at the caret position. + """ + text_context = self.get_text_context() + text = text.replace("\\n", "\n") + text_context.insert_text_at_caret(text) + + def delete_at_caret(self): + text_context = self.get_text_context() + text_context.delete_text_before_caret(1) + + +class Keyboard(WordSuggestions): + """ Central keyboard model """ + + color_scheme = None + + _layer_locked = False + _last_alt_key = None + _alt_locked = False + _click_sim = None + + LOCK_REASON_KEY_PRESSED = "key-pressed" + + # Properties + + # The number of pressed keys per modifier + _mods = {1: 0, 2: 0, 4: 0, 8: 0, + 16: 0, 32: 0, 64: 0, 128: 0} + + # Same to keep track of modifier changes triggered from the outside. + # Doesn't include modifier changes caused by Onboard itself, so this is + # not a complete representation of the modifier state. + _external_mod_changes = {1: 0, 2: 0, 4: 0, 8: 0, + 16: 0, 32: 0, 64: 0, 128: 0} + + def _get_mod(self, key): + return self._mods[key] + + def _set_mod(self, key, value): + self._mods[key] = value + self.on_mods_changed() + mods = dictproperty(_get_mod, _set_mod) + + def on_mods_changed(self): + pass + + def get_mod_mask(self): + """ Bit-mask of curently active modifers. """ + return sum(mask for mask in (1 << bit for bit in range(8)) + if self.mods[mask]) # bit mask of current modifiers + + @contextmanager + def suppress_modifiers(self, modifiers=LABEL_MODIFIERS): + """ Turn modifiers off temporarily. May be nested. """ + self._push_and_clear_modifiers(modifiers) + yield None + self._pop_and_restore_modifiers() + + def _push_and_clear_modifiers(self, modifiers): + mods = {mod : key for mod, key in self._mods.items() + if mod & modifiers} + self._suppress_modifiers_stack.append(mods) + for mod, nkeys in mods.items(): + if nkeys: + self._mods[mod] = 0 + self.get_text_changer().unlock_mod(mod) + + def _pop_and_restore_modifiers(self): + mods = self._suppress_modifiers_stack.pop() + for mod, nkeys in mods.items(): + if nkeys: + self._mods[mod] = nkeys + self.get_text_changer().lock_mod(mod) + + # currently active layer + def _get_active_layer_index(self): + return config.active_layer_index + + def _set_active_layer_index(self, index): + config.active_layer_index = index + active_layer_index = property(_get_active_layer_index, + _set_active_layer_index) + + def _get_active_layer(self): + layers = self.get_layers() + if not layers: + return None + index = self.active_layer_index + if index < 0 or index >= len(layers): + index = 0 + return layers[index] + + def _set_active_layer(self, layer): + index = 0 + for i, layer in enumerate(self.get_layers()): + if layer is layer: + index = i + break + self.active_layer_index = index + active_layer = property(_get_active_layer, _set_active_layer) + + def assure_valid_active_layer(self): + """ + Reset layer index if it is out of range. e.g. due to + loading a layout with fewer panes. + """ + index = self.active_layer_index + if index < 0 or index >= len(self.get_layers()): + self.active_layer_index = 0 + +################## + + def __init__(self, application): + WordSuggestions.__init__(self) + + self._application = weakref.ref(application) + self._pressed_key = None + self._last_typing_time = 0 + self._last_typed_was_separator = False + + self._temporary_modifiers = None + self._locked_temporary_modifiers = {} + self._suppress_modifiers_stack = [] + self._capitalization_requested = False + + self.layout = None + self.scanner = None + self.button_controllers = {} + self.editing_snippet = False + + self._layout_views = [] + + self._unpress_timers = UnpressTimers(self) + self._touch_feedback = TouchFeedback() + + self._raise_timer = ProgressiveDelayTimer() + + self._auto_show = AutoShow(self) + self._auto_show.enable(config.is_auto_show_enabled()) + self._auto_hide = AutoHide(self) + self._auto_hide.enable(config.is_auto_hide_enabled()) + + self.text_changer_key_stroke = None + self.text_changer_direct_insert = None + + self._invalidated_ui = 0 + + self._pressed_keys = [] + self._latched_sticky_keys = [] + self._locked_sticky_keys = [] + self._non_modifier_released = False + self._disabled_keys = None + + self._pending_modifier_redraws = {} + self._pending_modifier_redraws_timer = Timer() + + self._visibility_locked = False + self._visibility_requested = None + + self.reset() + + def reset(self): + """ init/reset on layout change """ + WordSuggestions.reset(self) + + if self._auto_show: + self._auto_show.reset() + + self.stop_raise_attempts() + + # Keep caps-lock state on layout change to prevent LP #1313176. + # Otherwise, a caps press causes a layout change, cleanup + # triggers another caps press that again causes a layout change, + # and so on... + # See OnboardGtk.reload_layout_delayed for the other part of the + # puzzle for this bug report. + self.ignore_capslock() + + # reset still latched and locked modifier keys on exit + self.release_latched_sticky_keys() + + # NumLock is special. Keep its state on exit, except when + # sticky_key_release_delay is set, then we assume to be + # in kiosk mode and everything has to be cleaned up. + release_all = bool(config.keyboard.sticky_key_release_delay) + self.release_locked_sticky_keys(release_all) + + self.release_pressed_keys() + + self._pressed_keys = [] + self._latched_sticky_keys = [] + self._locked_sticky_keys = [] + self._non_modifier_released = False + self._disabled_keys = None + + self.layout = None + + self._pending_modifier_redraws_timer.stop() + self._pending_modifier_redraws = {} + + self.unlock_visibility() + + def cleanup(self): + """ final cleanup on exit """ + self.reset() + + WordSuggestions.cleanup(self) + + if self._auto_show: + self._auto_show.cleanup() + self._auto_show = None + + if self._auto_hide: + self._auto_hide.cleanup() + self._auto_hide = None + + if self.text_changer_key_stroke: + self.text_changer_key_stroke.cleanup() + self.text_changer_key_stroke = None + + if self.text_changer_direct_insert: + self.text_changer_direct_insert.cleanup() + self.text_changer_direct_insert = None + + if self._click_sim: + self._click_sim.cleanup() + self._click_sim = None + + def get_application(self): + return self._application() + + def register_view(self, layout_view): + self._layout_views.append(layout_view) + + def deregister_view(self, layout_view): + if layout_view in self._layout_views: + self._layout_views.remove(layout_view) + + def get_main_view(self): + layout_views = self._layout_views + if layout_views: + return layout_views[0] + return None + + def is_visible(self): + for view in self._layout_views: + visible = view.is_visible() + if visible is not None: + return visible + + def set_visible(self, visible): + self.unlock_visibility() # unlock frequenty in case of stuck keys + self.update_auto_show_on_visibility_change(visible) + + if not visible: + self.hide_touch_feedback() + + for view in self._layout_views: + view.set_visible(visible) + + def toggle_visible(self): + """ main method to show/hide onboard manually """ + self.set_visible(not self.is_visible()) + + def request_visibility(self, visible): + """ Request to change visibility when all keys have been released. """ + if self._visibility_locked: + self._visibility_requested = visible + else: + self.set_visible(visible) + + def request_visibility_toggle(self): + if self._visibility_locked and \ + self._visibility_requested is not None: + visible = self._visibility_requested + else: + visible = self.is_visible() + self.request_visibility(not visible) + + def lock_visibility(self): + """ Lock all showing/hiding, but remember requests to do so. """ + self._visibility_locked = True + self.auto_show_lock(self.LOCK_REASON_KEY_PRESSED) + + def unlock_visibility(self): + """ Unlock all showing/hiding. """ + self._visibility_locked = False + self._visibility_requested = None + + def unlock_and_apply_visibility(self): + """ Unlock all showing/hiding and apply the last request to do so. """ + if self._visibility_locked: + visible = self._visibility_requested + + self.unlock_visibility() + + if visible is not None: + self.set_visible(visible) + + # Unlock auto-show, and if the state has changed since locking, + # transition to hide the keyboard. + self.auto_show_unlock_and_apply_visibility( + self.LOCK_REASON_KEY_PRESSED) + + def redraw(self, keys=None, invalidate=True): + for view in self._layout_views: + view.redraw(keys, invalidate) + + def process_updates(self): + for view in self._layout_views: + view.process_updates() + + def redraw_labels(self, invalidate=True): + for view in self._layout_views: + view.redraw_labels(invalidate) + + def has_input_sequences(self): + for view in self._layout_views: + if view.has_input_sequences(): + return True + return False + + def update_transparency(self): + for view in self._layout_views: + view.update_transparency() + + def update_input_event_source(self): + """ Input event source changed, tell all views. """ + for view in self._layout_views: + view.update_input_event_source() + self.update_click_sim() + self.update_auto_hide() + + def update_touch_input_mode(self): + """ Touch input mode has changed, tell all views. """ + for view in self._layout_views: + view.update_touch_input_mode() + + def update_click_sim(self): + if config.is_event_source_xinput(): + # XInput click simulator + # Recommended, but requires the XInput event source. + clicksim = CSFloatingSlave(self) + + # Fall back to button mapper if XInput 2.2 is unavaliable + if not clicksim.is_valid(): + _logger.warning("XInput click simulator CSFloatingSlave " + "unavailable, " + "falling back to CSButtonMapper.") + clicksim = CSButtonMapper() + + else: + # Button mapper + # Works with any event source, but may fail on touch-screens. + clicksim = CSButtonMapper() + + if self._click_sim: + self._click_sim.cleanup() + self._click_sim = clicksim + self._click_sim.state_notify_add(self._on_click_sim_state_notify) + + _logger.info("using click simulator '{}'" + .format(type(self._click_sim).__name__)) + + def _on_click_sim_state_notify(self, x): + self.invalidate_context_ui() + self.commit_ui_updates() + + def show_touch_handles(self, show, auto_hide=True): + for view in self._layout_views: + view.show_touch_handles(show, auto_hide) + + def set_layout(self, layout, color_scheme, vk): + """ set or replace the current keyboard layout """ + self.reset() + self.set_virtkey(vk) + self.layout = layout + self.color_scheme = color_scheme + self.on_layout_loaded() + + def on_layout_loaded(self): + """ called when the layout has been loaded """ + + # hide all still visible feedback popups; keys have changed. + self._touch_feedback.hide() + + self._connect_button_controllers() + self.assure_valid_active_layer() + + WordSuggestions.on_layout_loaded(self) + + self.update_modifiers() + + self.update_scanner_enabled() + + # notify views + for view in self._layout_views: + view.on_layout_loaded() + + # redraw everything + self.invalidate_ui() + self.commit_ui_updates() + + def set_virtkey(self, vk): + self._init_text_changers(vk) + + def _init_text_changers(self, vk): + self.text_changer_key_stroke = \ + TextChangerKeyStroke(self, vk) + self.text_changer_direct_insert = \ + TextChangerDirectInsert(self, vk, self.text_changer_key_stroke) + + def get_text_changer(self): + text_context = self.text_context + if text_context.can_insert_text(): + return self.text_changer_direct_insert + else: + return self.text_changer_key_stroke + + def _connect_button_controllers(self): + """ connect button controllers to button keys """ + self.button_controllers = {} + + # connect button controllers to button keys + types = {type.id : type for type in + [BCMiddleClick, BCSingleClick, BCSecondaryClick, + BCDoubleClick, BCDragClick, BCHoverClick, + BCHide, BCShowClick, BCMove, BCBluetooth, BCTest, BCPreferences, BCQuit, + BCExpandCorrections, BCPreviousPredictions, + BCNextPredictions, BCPauseLearning, BCLanguage, + BCStealthMode, BCAutoLearn, BCAutoPunctuation, BCInputline, + ]} + for key in self.layout.iter_global_keys(): + if key.is_layer_button(): + bc = BCLayer(self, key) + bc.layer_index = key.get_layer_index() + self.button_controllers[key] = bc + else: + type = types.get(key.id) + if type: + self.button_controllers[key] = type(self, key) + + def update_scanner_enabled(self): + """ Enable keyboard scanning if it is enabled in gsettings. """ + self.update_input_event_source() + self.enable_scanner(config.scanner.enabled) + + def enable_scanner(self, enable): + """ Enable keyboard scanning. """ + if enable: + if not self.scanner: + self.scanner = Scanner(self._on_scanner_redraw, + self._on_scanner_activate) + if self.layout: + self.scanner.update_layer(self.layout, self.active_layer) + else: + _logger.warning("Failed to update scanner. No layout.") + else: + if self.scanner: + self.scanner.finalize() + self.scanner = None + + def _on_scanner_enabled(self, enabled): + """ Config callback for scanner.enabled changes. """ + self.update_scanner_enabled() + self.update_transparency() + + def _on_scanner_redraw(self, keys): + """ Scanner callback for redraws. """ + self.redraw(keys) + + def _on_scanner_activate(self, key): + """ Scanner callback for key activation. """ + self.key_down(key) + self.key_up(key) + + def get_layers(self): + if self.layout: + return self.layout.get_layer_ids() + return [] + + def iter_keys(self, group_name=None): + """ iterate through all keys or all keys of a group """ + if self.layout: + return self.layout.iter_keys(group_name) + else: + return [] + + def _on_mods_changed(self): + self.invalidate_context_ui() + self.commit_ui_updates() + + def get_pressed_key(self): + return self._pressed_key + + def set_currently_typing(self): + """ Remember it was us that just typed text. """ + self._last_typing_time = time.time() + + def is_typing(self): + """ Is Onboard currently or was it just recently sending any text? """ + key = self.get_pressed_key() + return key and self._is_text_insertion_key(key) or \ + time.time() - self._last_typing_time <= 0.5 + + def set_last_typed_was_separator(self, value): + self._last_typed_was_separator = value + + def get_last_typed_was_separator(self): + return self._last_typed_was_separator + + def _is_text_insertion_key(self, key): + """ Does key actually insert any characters (not a navigation key)? """ + return key and key.is_text_changing() + + def key_down(self, key, view=None, sequence=None, action=True): + """ + Press down on one of Onboard's key representations. + This may be either an initial press, or a switch of the active_key + due to dragging. + """ + self.on_any_key_down() + self.stop_raise_attempts() + + if sequence: + button = sequence.button + event_type = sequence.event_type + else: + button = 1 + event_type = EventType.CLICK + + # Stop garbage collection delays until key release. They might cause + # unexpected key repeats on slow systems. + if gc.isenabled(): + gc.disable() + + if key and \ + key.sensitive: + + # Stop hiding the keyboard until all keys have been released. + self.lock_visibility() + + # stop timed redrawing for this key + self._unpress_timers.stop(key) + + # announce temporary modifiers + temp_mod_mask = 0 + if config.keyboard.can_upper_case_on_button(button): + temp_mod_mask = Modifiers.SHIFT + self._set_temporary_modifiers(temp_mod_mask) + self._update_temporary_key_label(key, temp_mod_mask) + + # mark key pressed + key.pressed = True + self.on_key_pressed(key, view, sequence, action) + + # Get drawing behind us now, so it can't delay processing key_up() + # and cause unwanted key repeats on slow systems. + self.redraw([key]) + self.process_updates() + + # perform key action (not just dragging)? + if action: + self._do_key_down_action(key, view, button, event_type) + + # Make note that it was us who just sent text + # (vs. at-spi update due to scrolling, physical typing, ...). + # -> disables set_modifiers() for the case that virtkey + # just locked temporary modifiers. + if self._is_text_insertion_key(key): + self.set_currently_typing() + + # remember as pressed key + if key not in self._pressed_keys: + self._pressed_keys.append(key) + + def key_up(self, key, view=None, sequence=None, action=True): + """ Release one of Onboard's key representations. """ + if sequence: + button = sequence.button + event_type = sequence.event_type + else: + button = 1 + event_type = EventType.CLICK + + if key and \ + key.sensitive: + + # Was the key nothing but pressed before? + extend_pressed_state = key.is_pressed_only() + + # perform key action? + # (not just dragging or canceled due to long press) + if action: + # If there was no down action yet (dragging), catch up now + if not key.activated: + self._do_key_down_action(key, view, button, event_type) + + self._do_key_up_action(key, view, button, event_type) + + # Skip context and button controller updates for the common + # letter press to improve responsiveness on slow systems. + if key.type == KeyCommon.BUTTON_TYPE: + self.invalidate_context_ui() + + # no action but key was activated: must have been a long press + elif key.activated: + # switch to layer 0 after long pressing snippet buttons + if key.type == KeyCommon.MACRO_TYPE: + self.maybe_switch_to_first_layer(key) + + # Is the key still nothing but pressed? + extend_pressed_state = (extend_pressed_state and + key.is_pressed_only() and + action) + + # Draw key unpressed to remove the visual feedback. + if extend_pressed_state and \ + not config.scanner.enabled: + # Keep key pressed for a little longer for clear user feedback. + self._unpress_timers.start(key) + else: + # Unpress now to avoid flickering of the + # pressed color after key release. + key.pressed = False + self.on_key_unpressed(key) + + # no more actions left to finish + key.activated = False + + # remove from list of pressed keys + if key in self._pressed_keys: + self._pressed_keys.remove(key) + + # Make note that it was us who just sent text + # (vs. at-spi update due to scrolling, physical typing, ...). + if self._is_text_insertion_key(key): + self.set_currently_typing() + + # This key might have caused a completion popup to open, + # e.g. the firefox URL-bar popup. + # -> attempt to raise the keyboard over the popup + # Disabled because only raising isn't enough for most + # drop-downs. + if False and \ + action and \ + config.is_force_to_top() and \ + not self.has_focusable_gui() and \ + not config.xid_mode: + self.raise_ui_delayed() + + # Was this the final touch sequence? + if not self.has_input_sequences(): + self._non_modifier_released = False + self._pressed_keys = [] + self._pressed_key = None + self.on_all_keys_up() + gc.enable() + + # Allow hiding the keyboard again (LP #1648543). + self.unlock_and_apply_visibility() + + # Process pending UI updates + self.commit_ui_updates() + + def key_long_press(self, key, view=None, button=1): + """ Long press of one of Onboard's key representations. """ + long_pressed = False + key_type = key.type + + if not config.xid_mode: + # Is there a popup definition in the layout? + sublayout = key.get_popup_layout() + if sublayout: + view.show_popup_layout(key, sublayout) + long_pressed = True + + elif key_type == KeyCommon.BUTTON_TYPE: + # Buttons decide for themselves what is to happen. + controller = self.button_controllers.get(key) + if controller: + controller.long_press(view, button) + + elif key.is_prediction_key(): + view.show_prediction_menu(key, button) + long_pressed = True + + elif key_type == KeyCommon.MACRO_TYPE: + snippet_id = int(key.code) + self._edit_snippet(view, snippet_id) + long_pressed = True + else: + # All other keys get hard-coded long press menus + # (where available). + action = self.get_key_action(key) + if action == KeyCommon.DELAYED_STROKE_ACTION and \ + not key.is_word_suggestion(): + label = key.get_label() + alternatives = self.find_canonical_equivalents(label) + if alternatives: + self._touch_feedback.hide(key) + view.show_popup_alternative_chars(key, alternatives) + long_pressed = True + + if long_pressed: + key.activated = True # no more drag selection + + return long_pressed + + def _do_key_down_action(self, key, view, button, event_type): + + # generate key-stroke + action = self.get_key_action(key) + can_send_key = ((not key.sticky or not key.active) and + not action == KeyCommon.DELAYED_STROKE_ACTION) + if can_send_key: + self.send_key_down(key, view, button, event_type) + + # Modifier keys may change multiple keys + # -> redraw all dependent keys + # no danger of key repeats due to delays + # -> redraw asynchronously + if can_send_key and key.is_modifier(): + self.redraw_labels(False) + + if key.type == KeyCommon.BUTTON_TYPE: + controller = self.button_controllers.get(key) + if controller: + key.activated = controller.is_activated_on_press() + + def _do_key_up_action(self, key, view, button, event_type): + if key.sticky: + # Multi-touch release? + if key.is_modifier() and \ + not self._can_cycle_modifiers(): + can_send_key = True + else: # single touch/click + can_send_key = self.step_sticky_key(key, button, event_type) + + if can_send_key: + self.send_key_up(key, view) + if key.is_modifier(): + self.redraw_labels(False) + else: + self._release_non_sticky_key(key, view, button, event_type) + + # Multi-touch: temporarily stop cycling modifiers if + # a non-modifier key was pressed. This way we get both, + # cycling latched and locked state with single presses + # and press-only action for multi-touch modifer + key press. + if not key.is_modifier(): + self._non_modifier_released = True + + def send_key_down(self, key, view, button, event_type): + if self.is_key_disabled(key): + _logger.debug("send_key_down: " + "rejecting blacklisted key action for '{}'" + .format(key.id)) + return + + modifier = key.modifier + + if modifier == Modifiers.ALT and \ + self._is_alt_special(): + self._last_alt_key = key + else: + action = self.get_key_action(key) + if action != KeyCommon.DELAYED_STROKE_ACTION: + WordSuggestions.on_before_key_press(self, key) + self._maybe_send_alt_press_for_key(key, view, + button, event_type) + self._maybe_lock_temporary_modifiers_for_key(key) + + self.send_key_press(key, view, button, event_type) + + if action == KeyCommon.DOUBLE_STROKE_ACTION: # e.g. CAPS + self.send_key_release(key, view, button, event_type) + + if modifier: + self._do_lock_modifiers(modifier) + + # Update word suggestions on shift press. + self.invalidate_context_ui() + + key.activated = True # modifiers set -> can't undo press anymore + + def send_key_up(self, key, view=None, button=1, + event_type=EventType.CLICK): + if self.is_key_disabled(key): + _logger.debug("send_key_up: " + "rejecting blacklisted key action for '{}'" + .format(key.id)) + return + + key_type = key.type + modifier = key.modifier + action = self.get_key_action(key) + + # Unlock most modifiers before key release, otherwise Compiz wall + # plugin's viewport switcher window doesn't close after + # Alt+Ctrl+Up/Down (LP: #1532254). + if modifier and \ + action != KeyCommon.DOUBLE_STROKE_ACTION: # not NumLock, CAPS + self._do_unlock_modifiers(modifier) + + # Update word suggestions on shift unlatch or release. + self.invalidate_context_ui() + + # generate key event(s) + if modifier == Modifiers.ALT and \ + self._is_alt_special(): + pass + else: + if action == KeyCommon.DOUBLE_STROKE_ACTION or \ + action == KeyCommon.DELAYED_STROKE_ACTION: + + WordSuggestions.on_before_key_press(self, key) + self._maybe_send_alt_press_for_key(key, view, + button, event_type) + self._maybe_lock_temporary_modifiers_for_key(key) + + if key_type == KeyCommon.CHAR_TYPE: + # allow direct text insertion by AT-SPI for char keys + self.get_text_changer().insert_string_at_caret(key.code) + else: + self.send_key_press(key, view, button, event_type) + self.send_key_release(key, view, button, event_type) + else: + self.send_key_release(key, view, button, event_type) + + # Unlock NumLock, CAPS, etc. after key events were sent, + # else they are toggled right back on. + if modifier and \ + action == KeyCommon.DOUBLE_STROKE_ACTION: + self._do_unlock_modifiers(modifier) + + # Update word suggestions on shift unlatch or release. + self.invalidate_context_ui() + + self._maybe_unlock_temporary_modifiers() + self._maybe_send_alt_release_for_key(key, view, button, event_type) + + # Check modifier counts for plausibility. + # There might be a bug lurking that gets certain modifers stuck + # with negative counts. Work around this and be verbose about it + # so we can fix it eventually. + # Seems fixed in 0.99, but keep the check just in case. + # Happens again since 1.1.0 when using physical keyboards in + # parallel with Onboard. Occasionally we fail to detect where a + # modifier change originated from. + for mod, nkeys in self._mods.items(): + if nkeys < 0: + _logger.warning("Negative count {} for modifier {}, reset." + .format(self.mods[modifier], modifier)) + self.mods[mod] = 0 + + # Reset this too, else unlatching won't happen until restart. + self._external_mod_changes[mod] = 0 + + def _update_temporary_key_label(self, key, temp_mod_mask): + """ update label for temporary modifiers """ + mod_mask = self.get_mod_mask() + temp_mod_mask |= mod_mask + if key.mod_mask != temp_mod_mask: + key.configure_label(temp_mod_mask) + + def _set_temporary_modifiers(self, mod_mask): + """ Announce the intention to lock these modifiers on key-press. """ + # only some single modifiers supported at this time + if not mod_mask or \ + mod_mask in (Modifiers.SHIFT, Modifiers.CAPS, Modifiers.CTRL, + Modifiers.SUPER, Modifiers.ALTGR): + self._temporary_modifiers = mod_mask + + def _maybe_lock_temporary_modifiers_for_key(self, key): + """ Lock modifier before a single key-press """ + modifier = self._temporary_modifiers + if modifier and \ + not key.modifier == modifier and \ + not key.is_button(): + self.lock_temporary_modifiers(ModSource.KEYBOARD, modifier) + + def _maybe_unlock_temporary_modifiers(self): + """ Unlock modifier after a single key-press """ + self.unlock_all_temporary_modifiers() + + def lock_temporary_modifiers(self, mod_source_id, mod_mask): + """ Lock temporary modifiers """ + stack = self._locked_temporary_modifiers.setdefault(mod_source_id, []) + stack.append(mod_mask) + _logger.debug("lock_temporary_modifiers({}, {}) {}" + .format(mod_source_id, mod_mask, + self._locked_temporary_modifiers)) + self._do_lock_modifiers(mod_mask) + + def unlock_temporary_modifiers(self, mod_source_id): + """ Unlock temporary modifiers """ + stack = self._locked_temporary_modifiers.get(mod_source_id) + if stack: + mod_mask = stack.pop() + _logger.debug("unlock_temporary_modifiers({}, {}) {}" + .format(mod_source_id, mod_mask, + self._locked_temporary_modifiers)) + self._do_unlock_modifiers(mod_mask) + + def unlock_all_temporary_modifiers(self): + """ Unlock all temporary modifiers """ + if self._locked_temporary_modifiers: + mod_counts = {} + for mod_source_id, stack in \ + self._locked_temporary_modifiers.items(): + for mod_mask in stack: + for mod_bit in (1 << bit for bit in range(8)): + if mod_mask & mod_bit: + mod_counts[mod_bit] = \ + mod_counts.setdefault(mod_bit, 0) + 1 + + self._locked_temporary_modifiers = {} + + _logger.debug("unlock_all_temporary_modifiers() {}" + .format(self._locked_temporary_modifiers)) + + self._do_unlock_modifier_counts(mod_counts) + + def _do_lock_modifiers(self, mod_mask): + """ Lock modifiers and track their state. """ + mods_to_lock = 0 + for mod_bit in (1 << bit for bit in range(8)): + if mod_mask & mod_bit: + if not self.mods[mod_bit]: + # Alt is special because it activates the + # window manager's move mode. + if mod_bit != Modifiers.ALT or \ + not self._is_alt_special(): # not Alt? + mods_to_lock |= mod_bit + + self.mods[mod_bit] += 1 + + if mods_to_lock: + _logger.debug("_do_lock_modifiers({}) {} {}" + .format(mod_mask, self._mods, mods_to_lock)) + self.get_text_changer().lock_mod(mods_to_lock) + + def _do_unlock_modifiers(self, mod_mask): + """ Unlock modifier in response to modifier releases. """ + mod_counts = {} + for mod_bit in (1 << bit for bit in range(8)): + if mod_mask & mod_bit: + mod_counts[mod_bit] = 1 + + if mod_counts: + self._do_unlock_modifier_counts(mod_counts) + + def _do_unlock_modifier_counts(self, mod_counts): + """ Unlock modifier in response to modifier releases. """ + mods_to_unlock = 0 + for mod_bit, count in mod_counts.items(): + + self.mods[mod_bit] -= count + + if not self.mods[mod_bit]: + # Alt is special because it activates the + # window manager's move mode. + if mod_bit != Modifiers.ALT or \ + not self._is_alt_special(): # not Alt? + mods_to_unlock |= mod_bit + + if mods_to_unlock: + _logger.debug("_do_unlock_modifier_counts({}) {} {}" + .format(mod_counts, self._mods, mods_to_unlock)) + self.get_text_changer().unlock_mod(mods_to_unlock) + + def _is_alt_special(self): + """ + Does the ALT key need special treatment due to it + """ + return not config.is_override_redirect() + + def _maybe_send_alt_press_for_key(self, key, view, button, event_type): + """ handle delayed Alt press """ + if self.mods[8] and \ + self._is_alt_special() and \ + not key.active and \ + not key.type == KeyCommon.BUTTON_TYPE and \ + not self.is_key_disabled(key): + self.maybe_send_alt_press(view, button, event_type) + + def _maybe_send_alt_release_for_key(self, key, view, button, event_type): + """ handle delayed Alt release """ + if self._alt_locked: + self.maybe_send_alt_release(view, button, event_type) + + def maybe_send_alt_press(self, view, button, event_type): + if self.mods[8] and \ + not self._alt_locked: + self._alt_locked = True + if self._last_alt_key: + self.send_key_press(self._last_alt_key, view, + button, event_type) + self.get_text_changer().lock_mod(8) + + def maybe_send_alt_release(self, view, button, event_type): + if self._alt_locked: + self._alt_locked = False + if self._last_alt_key: + self.send_key_release(self._last_alt_key, + view, button, event_type) + self.get_text_changer().unlock_mod(8) + + def send_key_press(self, key, view, button, event_type): + """ Actually generate a fake key press """ + activated = True + key_type = key.type + + if key_type == KeyCommon.KEYCODE_TYPE: + with KeySynth.no_delay(): + self.get_text_changer().press_keycode(key.code) + + elif key_type == KeyCommon.KEYSYM_TYPE: + with KeySynth.no_delay(): + self.get_text_changer().press_keysym(key.code) + + elif key_type == KeyCommon.CHAR_TYPE: + if len(key.code) == 1: + with KeySynth.no_delay(): + self.get_text_changer().press_unicode(key.code) + + elif key_type == KeyCommon.KEYPRESS_NAME_TYPE: + with KeySynth.no_delay(): + self.get_text_changer().press_keysym( + get_keysym_from_name(key.code)) + + elif key_type == KeyCommon.BUTTON_TYPE: + activated = False + controller = self.button_controllers.get(key) + if controller: + activated = controller.is_activated_on_press() + controller.press(view, button, event_type) + + elif key_type == KeyCommon.MACRO_TYPE: + activated = False + + elif key_type == KeyCommon.SCRIPT_TYPE: + activated = False + + elif key_type == KeyCommon.WORD_TYPE: + activated = False + + elif key_type == KeyCommon.CORRECTION_TYPE: + activated = False + + key.activated = activated + + def send_key_release(self, key, view, button=1, + event_type=EventType.CLICK): + """ Actually generate a fake key release """ + key_type = key.type + if key_type == KeyCommon.CHAR_TYPE: + if len(key.code) == 1: + self.get_text_changer().release_unicode(key.code) + else: + self.get_text_changer().insert_string_at_caret(key.code) + + elif key_type == KeyCommon.KEYSYM_TYPE: + self.get_text_changer().release_keysym(key.code) + + elif key_type == KeyCommon.KEYPRESS_NAME_TYPE: + self.get_text_changer().release_keysym( + get_keysym_from_name(key.code)) + + elif key_type == KeyCommon.KEYCODE_TYPE: + self.get_text_changer().release_keycode(key.code) + + elif key_type == KeyCommon.BUTTON_TYPE: + controller = self.button_controllers.get(key) + if controller: + controller.release(view, button, event_type) + + elif key_type == KeyCommon.MACRO_TYPE: + snippet_id = int(key.code) + if self.insert_snippet(snippet_id): + pass + + # Block dialog in xembed mode. + # Don't allow to open multiple dialogs in force-to-top mode. + else: + self._edit_snippet(view, snippet_id) + + elif key_type == KeyCommon.SCRIPT_TYPE: + if not config.xid_mode: # block settings dialog in xembed mode + if key.code: + run_script(key.code) + + def _edit_snippet(self, view, snippet_id): + if not config.xid_mode and \ + not self.editing_snippet and \ + view: + view.show_snippets_dialog(snippet_id) + self.editing_snippet = True + + def insert_snippet(self, snippet_id): + mlabel, mString = config.snippets.get(snippet_id, (None, None)) + if mString: + self.get_text_changer().insert_string_at_caret(mString) + return True + return False + + def _release_non_sticky_key(self, key, view, button, event_type): + # Request capitalization before keys are unlatched, so we can + # prevent modifiers from toggling more than once and confuse + # set_modifiers(). + WordSuggestions.on_before_key_release(self, key) + + # release key + self.send_key_up(key, view, button, event_type) + + # Don't release latched modifiers for click buttons yet, + # keep them unchanged until the actual click happens. + # -> allow clicks with modifiers + if not key.is_layer_button() and \ + not (key.type == KeyCommon.BUTTON_TYPE and + key.is_click_type_key()) and \ + key not in self.get_text_displays(): + + # Don't release SHIFT if we're going to enable + # capitalization anyway. + except_keys = None + if self._capitalization_requested: + except_keys = [key for key in self._latched_sticky_keys + if key.modifier == Modifiers.SHIFT] + + # release latched modifiers + self.release_latched_sticky_keys(only_unpressed=True, + except_keys=except_keys) + + # undo temporary suppression of the text display + WordSuggestions.show_input_line_on_key_release(self, key) + + self.set_last_typed_was_separator(key.is_separator()) + + # Insert words on button release to avoid having the wordlist + # change between button press and release. + # Make sure latched modifiers have been released, else they will + # affect the whole inserted string. + WordSuggestions.send_key_up(self, key, button, event_type) + + # switch to layer 0 on (almost) any key release + self.maybe_switch_to_first_layer(key) + + # punctuation assistance and collapse corrections + WordSuggestions.on_after_key_release(self, key) + + # capitalization requested by punctuator? + if self._capitalization_requested: + self._capitalization_requested = False + if not self.mods[Modifiers.SHIFT]: # SHIFT not active yet? + self._enter_caps_mode() + + def request_capitalization(self, capitalize): + """ + Request entering upper-caps mode after next key-release. + """ + self._capitalization_requested = capitalize + + def _enter_caps_mode(self): + """ + Do what has to be done so that the next pressed + character will be capitalized. + + Don't call key_down+up for this, because modifiers may be + configured not to latch. + """ + lfsh_keys = self.find_items_from_ids(["LFSH"]) + rtsh_keys = self.find_items_from_ids(["RTSH"]) + + # unlatch all shift keys + for key in rtsh_keys + lfsh_keys: + if key.active: + key.active = False + key.locked = False + if key in self._latched_sticky_keys: + self._latched_sticky_keys.remove(key) + if key in self._locked_sticky_keys: + self._locked_sticky_keys.remove(key) + self.redraw([key]) + + # Latch right shift for capitalization, + # if there is no right shift latch left shift instead. + shift_keys = rtsh_keys if rtsh_keys else lfsh_keys + for key in shift_keys: + if not key.active: + key.active = True + if key not in self._latched_sticky_keys: + self._latched_sticky_keys.append(key) + self.redraw([key]) + + self.mods[Modifiers.SHIFT] = 1 + self.get_text_changer().lock_mod(1) + self.redraw_labels(False) + + def maybe_switch_to_first_layer(self, key): + """ + Activate the first layer if key allows it. + """ + if self.active_layer_index != 0 and \ + not self._layer_locked: + + unlatch = key.can_unlatch_layer() + if unlatch is None: + # for backwards compatibility with Onboard <0.99 + unlatch = (not key.is_layer_button() and + key.id not in ["move", "showclick"]) + + if unlatch: + self.active_layer_index = 0 + self.invalidate_visible_layers() + self.invalidate_canvas() + self.invalidate_context_ui() # update layer button state + + return unlatch + + def update_modifiers(self): + """ + Synchronize our keys with externally activated modifiers, + e.g. by physical keyboards or tools like xte. + """ + keymap = Gdk.Keymap.get_default() + if keymap: + mod_mask = keymap.get_modifier_state() + self.set_modifiers(mod_mask) + + def set_modifiers(self, mod_mask): + """ + Sync Onboard with modifiers of the given modifier mask. + Used to sync changes of system modifier state with Onboard. + """ + _logger.debug("set_modifiers({}) {} {} {}" + .format(mod_mask, self._alt_locked, + self._temporary_modifiers, + self.is_typing())) + + # The special handling of ALT in Onboard confuses the detection of + # modifier presses from the outside. + # Test case: press ALT, then LSHIFT + # Expected: LSHIFT latched + # Result: LSHIFT locked and RSHIFT latched + # -> stop all modifier synchronization while the ALT key is active. + if self._alt_locked: + return + + if self._temporary_modifiers: + return + + # SHIFT doesn't unlatch in Firefox, launchpad question entry, typing + # "?" after inserting "collection" with Small layout, Xenial, + if self.is_typing(): + return + + for mod_bit in (1 << bit for bit in range(8)): + # Directly redraw locking modifiers only. All other modifiers + # redraw after a short delay. This is meant to prevent + # Onboard from busily flashing keys and using CPU while + # typing with a hardware keyboard. + if (mod_bit & (Modifiers.CAPS | Modifiers.NUMLK)): + delay = 0 + else: + delay = config.keyboard.modifier_update_delay + + # -1.0 restores the onboard 1.0.0 behavior, no updates + if delay >= 0: + self.set_modifier(mod_bit, bool(mod_mask & mod_bit), delay) + + def set_modifier(self, mod_bit, active, draw_delay=0.0): + """ + Update Onboard to reflect the state of the given modifier in the ui. + """ + # find all keys assigned to the modifier bit + keys = [] + for key in self.layout.iter_keys(): + if key.modifier == mod_bit: + keys.append(key) + + active_before = bool(self._mods[mod_bit]) + + # Was modifier turned on? + if not active_before and active: + self._mods[mod_bit] += 1 + self._external_mod_changes[mod_bit] = 1 + for key in keys: + if key.sticky: + self.step_sticky_key(key, 1, EventType.CLICK) + + # Was modifier turned off? + elif active_before and not active: + self._mods[mod_bit] = 0 + self._external_mod_changes[mod_bit] = 0 + for key in keys: + if key in self._latched_sticky_keys: + self._latched_sticky_keys.remove(key) + if key in self._locked_sticky_keys: + self._locked_sticky_keys.remove(key) + key.active = False + key.locked = False + + # Was it a change from the outside, i.e. not us? + # For this to work, we always have to update self._mods _before_ + # lock_mod calls when our modifier keys are clicked. + if active != active_before: + + # re-draw delayed? + if active and \ + draw_delay > 0.0: + self._queue_pending_modifier_redraw(mod_bit, active, + keys, draw_delay) + else: + self._redraw_modifier_keys(keys) + + def _queue_pending_modifier_redraw(self, mod_bit, active, keys, delay): + item = self._pending_modifier_redraws.get(mod_bit) + if item is None: + # draw affected keys delayed + self._pending_modifier_redraws[mod_bit] = (active, keys) + else: + pending_active, keys = item + + # discard redraw if the modifier change didn't have + # any lasting effects + if active != pending_active: + del self._pending_modifier_redraws[mod_bit] + + # start/restart/stop timer + if self._pending_modifier_redraws: + self._pending_modifier_redraws_timer.start( + delay, self._redraw_pending_modifier_keys) + else: + self._pending_modifier_redraws_timer.stop() + + def _redraw_pending_modifier_keys(self): + for pending_active, keys in self._pending_modifier_redraws.values(): + self._redraw_modifier_keys(keys) + self._pending_modifier_redraws = {} + + def _redraw_modifier_keys(self, keys): + # redraw modifier keys + self.redraw(keys) + # redraw keys where labels are affected by the modifier change + self.redraw_labels(False) + + def step_sticky_key(self, key, button, event_type): + """ + One cycle step when pressing a sticky (latchabe/lockable) + modifier key (all sticky keys except layer buttons). + """ + active, locked = self.step_sticky_key_state(key, + key.active, key.locked, + button, event_type) + # apply the new states + was_active = key.active + deactivated = False + key.active = active + key.locked = locked + if active: + if locked: + if key in self._latched_sticky_keys: + self._latched_sticky_keys.remove(key) + if key not in self._locked_sticky_keys: + self._locked_sticky_keys.append(key) + else: + if key not in self._latched_sticky_keys: + self._latched_sticky_keys.append(key) + if key in self._locked_sticky_keys: + self._locked_sticky_keys.remove(key) + else: + if key in self._latched_sticky_keys: + self._latched_sticky_keys.remove(key) + if key in self._locked_sticky_keys: + self._locked_sticky_keys.remove(key) + + deactivated = (was_active or + not self.can_activate_key(key)) # push-button + + return deactivated + + def can_activate_key(self, key): + """ Can key be latched or locked? """ + behavior = self._get_sticky_key_behavior(key) + return (StickyBehavior.can_latch(behavior) or + StickyBehavior.can_lock(behavior)) + + def step_sticky_key_state(self, key, active, locked, button, event_type): + """ One cycle step when pressing a sticky (latchabe/lockable) key """ + behavior = self._get_sticky_key_behavior(key) + double_click = event_type == EventType.DOUBLE_CLICK + + # double click usable? + if double_click and \ + StickyBehavior.can_lock_on_double_click(behavior): + + # any state -> locked + active = True + locked = True + + # single click or unused double click + else: + # off -> latched or locked + if not active: + + if StickyBehavior.can_latch(behavior): + active = True + + elif StickyBehavior.can_lock_on_single_click(behavior): + active = True + locked = True + + # latched -> locked + elif (not key.locked and + StickyBehavior.can_lock_on_single_click(behavior)): + locked = True + + # latched or locked -> off + elif StickyBehavior.can_cycle(behavior): + active = False + locked = False + + return active, locked + + def _get_sticky_key_behavior(self, key): + """ Return sticky behavior for the given key """ + # try the individual key id + behavior = self._get_sticky_behavior_for(key.id) + + # default to the layout's behavior + # CAPS was hard-coded here to LOCK_ONLY until v0.98. + if (behavior is None and + key.sticky_behavior is not None): + behavior = key.sticky_behavior + + # try the key group + if behavior is None: + if key.is_modifier(): + behavior = self._get_sticky_behavior_for("modifiers") + if key.is_layer_button(): + behavior = self._get_sticky_behavior_for("layers") + + # try the 'all' group + if behavior is None: + behavior = self._get_sticky_behavior_for("all") + + # else fall back to hard coded default + if not StickyBehavior.is_valid(behavior): + behavior = StickyBehavior.CYCLE + + return behavior + + def _get_sticky_behavior_for(self, group): + behavior = None + value = config.keyboard.sticky_key_behavior.get(group) + if value: + try: + behavior = StickyBehavior.from_string(value) + except KeyError: + _logger.warning("Invalid sticky behavior '{}' for group '{}'" + .format(value, group)) + return behavior + + def on_snippets_dialog_closed(self): + self.editing_snippet = False + + def is_key_disabled(self, key): + """ Check for blacklisted key combinations """ + if self._disabled_keys is None: + self._disabled_keys = self.create_disabled_keys_set() + _logger.debug("disabled keys: {}" + .format(repr(self._disabled_keys))) + + set_key = (key.id, self.get_mod_mask()) + return set_key in self._disabled_keys + + def create_disabled_keys_set(self): + """ + Precompute a set of (modmask, key_id) tuples for fast + testing against the key blacklist. + """ + disabled_keys = set() + available_key_ids = [key.id for key in self.layout.iter_keys()] + for combo in config.lockdown.disable_keys: + results = parse_key_combination(combo, available_key_ids) + if results is not None: + disabled_keys.update(results) + else: + _logger.warning("ignoring unrecognized key combination '{}' " + "in lockdown.disable-keys" + .format(combo)) + return disabled_keys + + def get_key_action(self, key): + action = key.action + if action is None: + if key.type == KeyCommon.BUTTON_TYPE: + action = KeyCommon.DELAYED_STROKE_ACTION + controller = self.button_controllers.get(key) + if controller and \ + controller.is_activated_on_press(): + action = KeyCommon.SINGLE_STROKE_ACTION + + elif (key.type != KeyCommon.WORD_TYPE and + key.type != KeyCommon.CORRECTION_TYPE): + label = key.get_label() + alternatives = self.find_canonical_equivalents(label) + if (len(label) == 1 and label.isalnum()) or \ + key.id == "SPCE" or \ + bool(alternatives): + action = config.keyboard.default_key_action + else: + action = KeyCommon.SINGLE_STROKE_ACTION + + # Is there a popup defined for this key? + if action != KeyCommon.DELAYED_STROKE_ACTION and \ + key.get_popup_layout(): + action = KeyCommon.DELAYED_STROKE_ACTION + + return action + + def has_latched_sticky_keys(self, except_keys=None): + """ any sticky keys latched? """ + return len(self._latched_sticky_keys) > 0 + + def release_latched_sticky_keys(self, except_keys=None, + only_unpressed=False, + skip_externally_set_modifiers=True): + """ release latched sticky (modifier) keys """ + if len(self._latched_sticky_keys) > 0: + for key in self._latched_sticky_keys[:]: + if not except_keys or key not in except_keys: + + # Don't release still pressed modifiers, they may be + # part of a multi-touch key combination. + if not only_unpressed or not key.pressed: + + # Don't release modifiers that where latched by + # set_modifiers due to external (physical keyboard) + # action. + # Else the latched modifiers go out of sync in + # on_outside_click() while an external tool like + # xte holds them down (LP: #1331549). + if not skip_externally_set_modifiers or \ + not key.is_modifier() or \ + not self._external_mod_changes[key.modifier]: + + # Keep shift pressed if we're going to continue + # upper-case anyway. Else multiple locks and + # unlocks of SHIFT may happen when the punctuator + # is active. We can change the modifier state at + # most once per key release, else we can't + # distinguish our changes from physical + # keyboard actions in set_modifiers. + if not key.modifier == Modifiers.SHIFT or \ + not self._capitalization_requested: + + self.send_key_up(key) + self._latched_sticky_keys.remove(key) + key.active = False + self.redraw([key]) + + # modifiers may change many key labels -> redraw everything + self.redraw_labels(False) + + def release_locked_sticky_keys(self, release_all=False): + """ release locked sticky (modifier) keys """ + if len(self._locked_sticky_keys) > 0: + for key in self._locked_sticky_keys[:]: + # NumLock is special, keep its state on exit + # if not told otherwise. + if release_all or \ + not key.modifier == Modifiers.NUMLK: + self.send_key_up(key) + self._locked_sticky_keys.remove(key) + key.active = False + key.locked = False + key.pressed = False + self.redraw([key]) + + # modifiers may change many key labels -> redraw everything + self.redraw_labels(False) + + def _can_cycle_modifiers(self): + """ + Modifier cycling enabled? + Not enabled for multi-touch with at least one pressed non-modifier key. + """ + # Any non-modifier currently held down? + for key in self._pressed_keys: + if not key.is_modifier(): + return False + + # Any non-modifier released before? + if self._non_modifier_released: + return False + + return True + + def find_canonical_equivalents(self, char): + return canonical_equivalents["all"].get(char) + + def invalidate_ui(self): + """ + Update everything. + Quite expensive, don't call this while typing. + """ + self._invalidated_ui |= UIMask.ALL + + def invalidate_ui_no_resize(self): + """ + Update everything assuming key sizes don't change. + Doesn't invalidate cached surfaces. + """ + self._invalidated_ui |= UIMask.ALL & ~UIMask.SIZE + + def invalidate_context_ui(self): + """ Update text-context dependent ui """ + self._invalidated_ui |= (UIMask.CONTROLLERS | + UIMask.SUGGESTIONS | + UIMask.LAYOUT) + + def invalidate_layout(self): + """ + Recalculate item rectangles. + """ + self._invalidated_ui |= UIMask.LAYOUT + + def invalidate_visible_layers(self): + """ + Update visibility of layers in the layout tree, + e.g. when the active layer changed. + """ + self._invalidated_ui |= UIMask.LAYERS + + def invalidate_canvas(self): + """ Just redraw everything """ + self._invalidated_ui |= UIMask.REDRAW + + def commit_ui_updates(self): + keys = set() + mask = self._invalidated_ui + + if mask & UIMask.CONTROLLERS: + # update buttons + for controller in self.button_controllers.values(): + controller.update() + mask = self._invalidated_ui # may have been changed by controllers + + if mask & UIMask.SUGGESTIONS: + keys.update(WordSuggestions.update_suggestions_ui(self)) + + # update buttons that depend on suggestions + for controller in self.button_controllers.values(): + controller.update_late() + + if mask & UIMask.LAYERS: + self.update_visible_layers() + + if mask & UIMask.LAYOUT: + self.update_layout() # after suggestions! + + if mask & (UIMask.SUGGESTIONS | UIMask.LAYERS): + self.update_scanner() + + for view in self._layout_views: + view.apply_ui_updates(mask) + + if mask & UIMask.REDRAW: + self.redraw() + elif keys: + self.redraw(list(keys)) + + self._invalidated_ui = 0 + + def update_layout(self): + """ + Update layout, key sizes are probably changing. + """ + for view in self._layout_views: + view.update_layout() + + def update_visible_layers(self): + """ show/hide layers """ + layout = self.layout + if layout: + layers = layout.get_layer_ids() + if layers: + layout.set_visible_layers([layers[0], self.active_layer]) + + def update_scanner(self): + """ tell scanner to update on layout changes """ + # notify the scanner about layer changes + if self.scanner: + layout = self.layout + if layout: + self.scanner.update_layer(layout, self.active_layer, True) + else: + _logger.warning("Failed to update scanner. No layout.") + + def hide_touch_feedback(self): + self._touch_feedback.hide() + + def on_key_pressed(self, key, view, sequence, action): + """ pressed state of a key instance was set """ + if sequence: # Not a simulated key press, scanner? + feedback = self.can_give_keypress_feedback() + + # audio feedback + if action and \ + config.keyboard.audio_feedback_enabled: + pt = sequence.root_point \ + if feedback else (-1, -1) # keep passwords privat + pts = pt \ + if config.keyboard.audio_feedback_place_in_space \ + else (-1, -1) + Sound().play(Sound.key_feedback, pt[0], pt[1], pts[0], pts[1]) + + # key label popup + if not config.xid_mode and \ + config.keyboard.touch_feedback_enabled and \ + sequence.event_type != EventType.DWELL and \ + key.can_show_label_popup() and \ + feedback: + self._touch_feedback.show(key, view) + + def on_key_unpressed(self, key): + """ pressed state of a key instance was cleard """ + self._set_temporary_modifiers(0) + self._update_temporary_key_label(key, 0) + self.redraw([key]) + self._touch_feedback.hide(key) + + def on_outside_click(self, button): + """ + Called by outside click polling. + Keep this as Francesco likes to have modifiers + reset when clicking outside of onboard. + """ + self.release_latched_sticky_keys() + self._click_sim.end_mapped_click() + WordSuggestions.on_outside_click(self, button) + + def on_cancel_outside_click(self): + """ Called when outside click polling times out. """ + WordSuggestions.on_cancel_outside_click(self) + + def get_click_simulator(self): + if config.mousetweaks and \ + config.mousetweaks.is_active(): + return config.mousetweaks + return self._click_sim + + def ignore_capslock(self): + """ Keep capslock from causing another send_key_up call on exit """ + for key in self.iter_keys(): + if key.modifier == Modifiers.CAPS: + key.pressed = False + key.active = False + key.locked = False + if key in self._latched_sticky_keys: + self._latched_sticky_keys.remove(key) + if key in self._locked_sticky_keys: + self._locked_sticky_keys.remove(key) + + def release_pressed_keys(self, redraw=False): + """ + Release pressed keys on exit, or when recreating the main window. + """ + self.hide_touch_feedback() + + # Clear key.pressed for all keys that have already been released + # but are still waiting for redrawing the unpressed state. + self._unpress_timers.cancel_all() + + # Release keys that haven't been released yet + for key in self.iter_keys(): + if key.pressed and key.type in \ + [KeyCommon.CHAR_TYPE, + KeyCommon.KEYSYM_TYPE, + KeyCommon.KEYPRESS_NAME_TYPE, + KeyCommon.KEYCODE_TYPE]: + + # Release still pressed enter key when onboard gets killed + # on enter key press. + _logger.warning("Releasing still pressed key '{}'" + .format(key.id)) + self.send_key_up(key) + key.pressed = False + + if redraw: + self.redraw([key]) + + def update_auto_show(self): + """ + Turn on/off auto-show in response to user action (preferences) + and show/hide the views accordingly. + """ + enable = config.is_auto_show_enabled() + self._auto_show.enable(enable) + self._auto_show.show_keyboard(not enable) + self.update_auto_hide() + + def update_tablet_mode_detection(self): + enable = config.is_tablet_mode_detection_enabled() + self._auto_show.enable_tablet_mode_detection(enable) + + def update_keyboard_device_detection(self): + enable = config.is_keyboard_device_detection_enabled() + self._auto_show.enable_tablet_mode_detection(enable) + + def update_auto_hide(self): + enabled_before = self._auto_hide.is_enabled() + enabled_after = config.is_auto_hide_enabled() + + self._auto_hide.enable(enabled_after) + + if enabled_before and not enabled_after: + self._auto_hide.auto_show_unlock() + + def update_auto_show_on_visibility_change(self, visible): + if config.is_auto_show_enabled(): + # showing keyboard while auto-hide is pausing auto-show? + if visible and self._auto_hide.is_auto_show_locked(): + self.auto_show_lock_visible(False) + self._auto_hide.auto_show_unlock() + else: + self.auto_show_lock_visible(visible) + + # Make sure to drop the 'key-pressed' lock in case it still + # exists due to e.g. stuck keys. + if not visible: + self.auto_show_unlock(self.LOCK_REASON_KEY_PRESSED) + + def auto_show_lock(self, reason, duration=None, + lock_show=True, lock_hide=True): + """ + Reenable both, hiding and showing. + """ + if config.is_auto_show_enabled(): + if duration is not None: + if duration == 0.0: + return # do nothing + + if duration < 0.0: # negative means auto-hide is off + duration = None + + self._auto_show.lock(reason, duration, lock_show, lock_hide) + + def auto_show_unlock(self, reason): + """ + Remove a specific lock named by "reason". + """ + if config.is_auto_show_enabled(): + self._auto_show.unlock(reason) + + def auto_show_unlock_and_apply_visibility(self, reason): + """ + Remove lock and apply the last requested auto-show state while the + lock was applied. + """ + if config.is_auto_show_enabled(): + visibility = self._auto_show.unlock(reason) + if visibility is not None: + self._auto_show.request_keyboard_visible(visibility, delay=0) + + def auto_show_lock_and_hide(self, reason, duration=None): + """ + Helper for locking auto-show from AutoHide (hide-on-key-press) + and D-Bus property. + """ + if config.is_auto_show_enabled(): + _logger.debug("auto_show_lock_and_hide({}, {})" + .format(repr(reason), duration)) + + # Attempt to hide the keyboard. + # If it doesn't hide immediately, e.g. due to currently + # pressed keys, we get a second chance the next time + # apply_pending_state() is called, i.e. on key-release. + if not self._auto_show.is_locked(reason): + self._auto_show.request_keyboard_visible(False, delay=0) + + # Block showing the keyboard. + self._auto_show.lock(reason, duration, True, False) + + def is_auto_show_locked(self, reason): + return self._auto_show.is_locked(reason) + + def auto_show_lock_visible(self, visible): + """ + If the user unhides onboard, don't auto-hide it until + he manually hides it again. + """ + if config.is_auto_show_enabled(): + self._auto_show.lock_visible(visible) + + def auto_position(self): + self._broadcast_to_views("auto_position") + + def stop_auto_positioning(self): + self._broadcast_to_views("stop_auto_positioning") + + def get_auto_show_repositioned_window_rect(self, view, home, limit_rects, + test_clearance, move_clearance, + horizontal=True, + vertical=True): + if not self._auto_show: # may happen on exit, rarely + return None + + return self._auto_show.get_repositioned_window_rect( + view, home, limit_rects, + test_clearance, move_clearance, + horizontal, vertical) + + def transition_visible_to(self, show): + return self._broadcast_to_views("transition_visible_to", show) + + def commit_transition(self): + return self._broadcast_to_views("commit_transition") + + def raise_ui_delayed(self): + """ + Attempt to raise keyboard over popups like the one from the firefox + URL bar. Give it a moment for the popup to appear after a keypress. + """ + self._raise_timer.growth = 2.0 + self._raise_timer.max_duration = 2.0 + self._raise_timer.start(0.1, self._on_raise_timer) + + def _on_raise_timer(self): + _logger.warning("raising window - current delay {}s" + .format(self._raise_timer._current_delay)) + self._broadcast_to_views("raise_to_top") + self._touch_feedback.raise_all() + return True + + def stop_raise_attempts(self): + self._raise_timer.stop() + + def _broadcast_to_views(self, func_name, *params): + for view in self._layout_views: + if hasattr(view, func_name): + getattr(view, func_name)(*params) + + def find_items_from_ids(self, ids): + if self.layout is None: + return [] + return list(self.layout.find_ids(ids)) + + def find_items_from_classes(self, item_classes): + if self.layout is None: + return [] + return list(self.layout.find_classes(item_classes)) + + def find_key_from_id(self, id): + """ + Find the first key matching the given id. Id may be a complete + theme_id (key.theme_id) or just the regular item id (key.id). + """ + for key in self.iter_keys(): + if key.theme_id: + if key.theme_id == id: + return key + elif key.id == id: + return key + return None + + +class ButtonController(object): + """ + MVC inspired controller that handles events and the resulting + state changes of buttons. + """ + def __init__(self, keyboard, key): + self.keyboard = keyboard + self.key = key + + def press(self, view, button, event_type): + """ button pressed """ + pass + + def long_press(self, view, button): + """ button pressed long """ + pass + + def release(self, view, button, event_type): + """ button released """ + pass + + def update(self): + """ asynchronous ui update """ + pass + + def update_late(self): + """ after suggestions have been updated """ + pass + + def can_dwell(self): + """ can start dwelling? """ + return False + + def is_activated_on_press(self): + """ Cannot cancel already called press() without consequences? """ + return False + + def set_visible(self, visible): + if self.key.visible != visible: + _logger.debug("ButtonController: {}.visible = {}" + .format(self.key, visible)) + layout = self.keyboard.layout + layout.set_item_visible(self.key, visible) + self.keyboard.redraw([self.key]) + + def set_sensitive(self, sensitive): + if self.key.sensitive != sensitive: + _logger.debug("ButtonController: {}.sensitive = {}" + .format(self.key, sensitive)) + self.key.sensitive = sensitive + self.keyboard.redraw([self.key]) + + def set_active(self, active=None): + if active is not None and self.key.active != active: + _logger.debug("ButtonController: {}.active = {}" + .format(self.key, active)) + self.key.active = active + self.keyboard.redraw([self.key]) + + def set_locked(self, locked=None): + if locked is not None and self.key.locked != locked: + _logger.debug("ButtonController: {}.locked = {}" + .format(self.key, locked)) + self.key.active = locked + self.key.locked = locked + self.keyboard.redraw([self.key]) + + +class BCClick(ButtonController): + """ Controller for click buttons """ + def release(self, view, button, event_type): + cs = self.keyboard.get_click_simulator() + if not cs: + return + if self.is_active(): + # stop click mapping, reset to primary button and single click + cs.map_primary_click(view, + ClickSimulator.PRIMARY_BUTTON, + ClickSimulator.CLICK_TYPE_SINGLE) + else: + # Exclude click type buttons from the click mapping + # to be able to reliably cancel the click. + # -> They will receive only single left clicks. + rects = view.get_click_type_button_rects() + self.keyboard._click_sim.set_exclusion_rects(rects) + + # start click mapping + cs.map_primary_click(view, self.button, self.click_type) + + # Mark current event handled to stop ClickMapper from receiving it. + view.set_xi_event_handled(True) + + def update(self): + cs = self.keyboard.get_click_simulator() + if cs: # gone on exit + self.set_active(self.is_active()) + self.set_sensitive( + cs.supports_click_params(self.button, self.click_type)) + + def is_active(self): + cs = self.keyboard.get_click_simulator() + return (cs and + cs.get_click_button() == self.button and + cs.get_click_type() == self.click_type) + + +class BCSingleClick(BCClick): + id = "singleclick" + button = ClickSimulator.PRIMARY_BUTTON + click_type = ClickSimulator.CLICK_TYPE_SINGLE + + +class BCMiddleClick(BCClick): + id = "middleclick" + button = ClickSimulator.MIDDLE_BUTTON + click_type = ClickSimulator.CLICK_TYPE_SINGLE + + +class BCSecondaryClick(BCClick): + id = "secondaryclick" + button = ClickSimulator.SECONDARY_BUTTON + click_type = ClickSimulator.CLICK_TYPE_SINGLE + + +class BCDoubleClick(BCClick): + id = "doubleclick" + button = ClickSimulator.PRIMARY_BUTTON + click_type = ClickSimulator.CLICK_TYPE_DOUBLE + + +class BCDragClick(BCClick): + id = "dragclick" + button = ClickSimulator.PRIMARY_BUTTON + click_type = ClickSimulator.CLICK_TYPE_DRAG + + def release(self, view, button, event_type): + BCClick.release(self, view, button, event_type) + self.keyboard.show_touch_handles(show=self._can_show_handles(), + auto_hide=False) + + def update(self): + active_before = self.key.active + BCClick.update(self) + active_now = self.key.active + + if active_before and not active_now: + # hide the touch handles + self.keyboard.show_touch_handles(self._can_show_handles()) + + def _can_show_handles(self): + return (self.is_active() and + config.is_mousetweaks_active() and + not config.xid_mode) + + +class BCHoverClick(ButtonController): + + id = "hoverclick" + + def release(self, view, button, event_type): + config.enable_hover_click(not config.mousetweaks.is_active()) + + def update(self): + available = bool(config.mousetweaks) + active = config.mousetweaks.is_active() \ + if available else False # noqa: flake8 + + self.set_sensitive(available and + not config.lockdown.disable_hover_click) + # force locked color for better visibility + self.set_locked(active) + + def can_dwell(self): + return not (config.mousetweaks and config.mousetweaks.is_active()) + + +class BCHide(ButtonController): + + id = "hide" + + def release(self, view, button, event_type): + if config.unity_greeter: + config.unity_greeter.onscreen_keyboard = False + else: + # No request_keyboard_visible() here, so hide button can + # unlock_visibility in case of stuck keys. + self.keyboard.set_visible(False) + + def update(self): + # insensitive in XEmbed mode except in unity-greeter + self.set_sensitive(not config.xid_mode or + config.unity_greeter) + + +class BCShowClick(ButtonController): + + id = "showclick" + + def release(self, view, button, event_type): + config.keyboard.show_click_buttons = \ + not config.keyboard.show_click_buttons + + # enable hover click when the key was dwell-activated + # disabled for now, seems too confusing + if False: + if event_type == EventType.DWELL and \ + config.keyboard.show_click_buttons and \ + not config.mousetweaks.is_active(): + config.enable_hover_click(True) + + def update(self): + allowed = not config.lockdown.disable_click_buttons + + self.set_visible(allowed) + + # Don't show active state. Toggling the click column + # should be enough feedback. + # self.set_active(config.keyboard.show_click_buttons) + + # show/hide click buttons + show_click = config.keyboard.show_click_buttons and allowed + layout = self.keyboard.layout + if layout: + for item in layout.iter_items(): + if item.group == 'click': + layout.set_item_visible(item, show_click) + elif item.group == 'noclick': + layout.set_item_visible(item, not show_click) + + def can_dwell(self): + return not config.mousetweaks or not config.mousetweaks.is_active() + + +class BCMove(ButtonController): + + id = "move" + + def press(self, view, button, event_type): + if not config.xid_mode: + # not called from popup? + if hasattr(view, "start_move_window"): + view.start_move_window() + + def long_press(self, view, button): + if not config.xid_mode: + self.keyboard.show_touch_handles(True) + + def release(self, view, button, event_type): + if not config.xid_mode: + if hasattr(view, "start_move_window"): + view.stop_move_window() + else: + # pressed in a popup just show touch handles + self.keyboard.show_touch_handles(True) + + def update(self): + self.set_visible(not config.has_window_decoration() and + not config.xid_mode and + Handle.MOVE in config.window.window_handles) + + def is_activated_on_press(self): + return True # cannot undo on press, dragging is already in progress + + +class BCLayer(ButtonController): + """ layer switch button, switches to layer when released """ + + layer_index = None + + def _get_id(self): + return "layer" + str(self.layer_index) + id = property(_get_id) + + def release(self, view, button, event_type): + keyboard = self.keyboard + + active_before = keyboard.active_layer_index == self.layer_index + locked_before = active_before and keyboard._layer_locked + + active, locked = \ + keyboard.step_sticky_key_state(self.key, + active_before, locked_before, + button, event_type) + + # push buttons switch layers even though they don't activate the key + if not keyboard.can_activate_key(self.key): + active = True + + keyboard.active_layer_index = (self.layer_index + if active else 0) + + keyboard._layer_locked = (locked + if self.layer_index else False) + + if active_before != active: + keyboard.invalidate_visible_layers() + keyboard.invalidate_canvas() + + def update(self): + # don't show active state for layer 0, it'd be visible all the time + active = self.key.show_active and \ + self.key.get_layer_index() == self.keyboard.active_layer_index + if active: + active = self.keyboard.can_activate_key(self.key) + + self.set_active(active) + self.set_locked(active and self.keyboard._layer_locked) +class BCTest(ButtonController): + + id = "decline" + + def release(self, view, button, event_type): + run_script("quitScript") + + def update(self): + self.set_visible(not config.xid_mode and + not config.running_under_gdm and + not config.lockdown.disable_preferences) + +class BCBluetooth(ButtonController): + + id = "bt" + + def release(self, view, button, event_type): + run_script("connect") + + def update(self): + self.set_visible(not config.xid_mode and + not config.running_under_gdm and + not config.lockdown.disable_preferences) + + + + +class BCPreferences(ButtonController): + + id = "settings" + + def release(self, view, button, event_type): + run_script("sokSettings") + + def update(self): + self.set_visible(not config.xid_mode and + not config.running_under_gdm and + not config.lockdown.disable_preferences) + + +class BCQuit(ButtonController): + + id = "quit" + + def release(self, view, button, event_type): + app = self.keyboard.get_application() + if app: + # finish current key processing then quit + GLib.idle_add(app.do_quit_onboard) + + def update(self): + self.set_visible(not config.xid_mode and + not config.lockdown.disable_quit) + + +class BCExpandCorrections(ButtonController): + + id = "expand-corrections" + + def release(self, view, button, event_type): + wordlist = self.key.get_parent() + wordlist.expand_corrections(not wordlist.are_corrections_expanded()) + + +class BCPreviousPredictions(ButtonController): + + id = "previous-predictions" + + def release(self, view, button, event_type): + wordlist = self.key.get_parent() + wordlist.goto_previous_predictions() + self.keyboard.invalidate_context_ui() + + def update_late(self): + wordlist = self.key.get_parent() + self.set_sensitive(wordlist.can_goto_previous_predictions()) + + +class BCNextPredictions(ButtonController): + + id = "next-predictions" + + def release(self, view, button, event_type): + wordlist = self.key.get_parent() + wordlist.goto_next_predictions() + self.keyboard.invalidate_context_ui() + + def update_late(self): + key = self.key + wordlist = key.get_parent() + self.set_sensitive(wordlist.can_goto_next_predictions()) + + +class BCPauseLearning(ButtonController): + + id = "pause-learning" + + def release(self, view, button, event_type): + keyboard = self.keyboard + key = self.key + + active, locked = keyboard.step_sticky_key_state(key, + key.active, key.locked, + button, event_type) + key.active = active + key.locked = locked + + value = 0 + if active: + value += 1 + if locked: + value += 1 + + pause_started = (config.word_suggestions.get_pause_learning() == 0 and + value > 0) + + config.word_suggestions.set_pause_learning(value) + + # immediately forget changes + if pause_started: + keyboard.discard_changes() + + def update(self): + co = config.word_suggestions + self.set_active(co.get_pause_learning() >= 1) + self.set_locked(co.get_pause_learning() == 2) + + +class BCLanguage(ButtonController): + + id = "language" + + def __init__(self, keyboard, key): + ButtonController.__init__(self, keyboard, key) + self._menu_close_time = 0 + + def release(self, view, button, event_type): + if time.time() - self._menu_close_time > 0.5: + self.set_active(not self.key.active) + if self.key.active: + self._show_menu(view, self.key, button) + self._menu_close_time = 0 + + def _show_menu(self, view, key, button): + self.keyboard.hide_touch_feedback() + view.show_language_menu(key, button, self._on_menu_closed) + + def _on_menu_closed(self): + self.set_active(False) + self._menu_close_time = time.time() + + def update(self): + if config.are_word_suggestions_enabled(): + key = self.key + keyboard = self.keyboard + langdb = keyboard._languagedb + + lang_id = keyboard.get_lang_id() + label = langdb.get_language_code(lang_id).capitalize() + + if label != key.get_label() or \ + not key.tooltip: + key.set_labels({0: label}) + key.tooltip = langdb.get_language_full_name(lang_id) + keyboard.invalidate_ui() + + +# deprecated buttons + +class BCInputline(ButtonController): + + id = "inputline" + + def release(self, view, button, event_type): + # hide the input line display when it is clicked + self.keyboard.hide_input_line() + + +class BCAutoLearn(ButtonController): + + id = "learnmode" + + def release(self, view, button, event_type): + config.wp.auto_learn = not config.wp.auto_learn + + # don't learn when turning auto_learn off + if not config.wp.auto_learn: + self.keyboard.discard_changes() + + # turning on auto_learn disables stealth_mode + if config.wp.auto_learn and config.wp.stealth_mode: + config.wp.stealth_mode = False + + def update(self): + self.set_active(config.wp.auto_learn) + + +class BCAutoPunctuation(ButtonController): + + id = "punctuation" + + def release(self, view, button, event_type): + config.wp.auto_punctuation = not config.wp.auto_punctuation + self.keyboard.punctuator.reset() + + def update(self): + self.set_active(config.wp.auto_punctuation) + + +class BCStealthMode(ButtonController): + + id = "stealthmode" + + def release(self, view, button, event_type): + config.wp.stealth_mode = not config.wp.stealth_mode + + # don't learn, forget words when stealth mode is enabled + if config.wp.stealth_mode: + self.keyboard.discard_changes() + + def update(self): + self.set_active(config.wp.stealth_mode) + diff --git a/README b/README new file mode 100644 index 0000000..ecebf43 --- /dev/null +++ b/README @@ -0,0 +1,5 @@ +Lancez le script.sh pour installer sur le raspberry pi les fichiers nécessaires +pour la mise en place de la JitsiBox. +Si vous voulez faire des modifications sur les boutons, vous devez modifier les fichiers key_defs ( fonction des touches ), Whiteboard.onboard et Whiteboard-Alpha.svg ( disposition des touches ). +Pour modifier l'appareil à lequel vous allez vous connecter en bluetooth, modifiez l'adresse MAC qui se situe dans le fichier scripts/btconnect.sh. + diff --git a/Whiteboard-Alpha.svg b/Whiteboard-Alpha.svg new file mode 100755 index 0000000..e628915 --- /dev/null +++ b/Whiteboard-Alpha.svg @@ -0,0 +1,420 @@ + + + + + + + + + + image/svg+xml + + Whiteboard-Alpha.svg + + + + Johannes Almer + + + + + GPL-3+ license + + + + + Onboard Devel Team + + + https://launchpad.net/onboard + This file is part of Onboard + + + Copyright © 2016, Francesco Fumanti <francesco.fumanti@gmx.net> +Copyright © 2014, Johannes Almer + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Whiteboard.onboard b/Whiteboard.onboard new file mode 100755 index 0000000..e165cb0 --- /dev/null +++ b/Whiteboard.onboard @@ -0,0 +1,211 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/bt.svg b/bt.svg new file mode 100644 index 0000000..5566bc1 --- /dev/null +++ b/bt.svg @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/btJabra.py b/btJabra.py new file mode 100644 index 0000000..3dcf5f1 --- /dev/null +++ b/btJabra.py @@ -0,0 +1,27 @@ + GNU nano 5.4 /usr/share/onboard/scripts/btJabra.py +#!/usr/bin/python3 +# Copyright © 2009 Chris Jones +# Copyright © 2012-2013 marmuta +# +# This file is part of Onboard. +# +# Onboard is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# Onboard is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +PYTHON_EXECUTABLE = "python3" + +import subprocess + +def run(): + exit_code = subprocess.call('/usr/share/onboard/scripts/btconnect.sh') + diff --git a/cam.png b/cam.png new file mode 100644 index 0000000000000000000000000000000000000000..a3e4a673b6c05aa22dc9c73543219407a736890f GIT binary patch literal 29228 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 literal 0 HcmV?d00001 diff --git a/enter.png b/enter.png new file mode 100644 index 0000000000000000000000000000000000000000..45cd94f36cb6a2c30e65200daf200b72290e549a GIT binary patch literal 3450 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 b{~kQGhj@pK(7vpE1^5>m9UpZhQoH3pm0*n* literal 0 HcmV?d00001 diff --git a/hand.png b/hand.png new file mode 100644 index 0000000000000000000000000000000000000000..814f6ca7651b9eb07fb7a702f9d0b958363c7300 GIT binary patch literal 13009 zcmbt)c{r49^zbt?W+poovV=7DJ%nT{WJs8Ztdm|zGRD3$LyM4QED0e^Wr-9ak*896 zRb&#fPGrq8LM8^^GkSl&>-zruu5Yf(W#(SaIrrJmx$hfxr%v#4iE#k{z>Bps!vO#s z`U(ejp`d>&5k2eBKaSvISchHECuY|_NziXjqUG6O0N`t5|G{#U`NW|?(GYXzkkbJd zLc-4lc?03$;cC7Fzu@!dh~8=eK|TcwN5ud@8o-*FIz$xC4~OT;Io_^Wiazv_=M8ZD z)SCn|(@X_>!5@3v5%#^!DRW{*q3%L%eOJ!ew@C=^wRa0QZ@al zxYAuI)KmGpBw#}(EM&an6CS<9kPTA`Mo2?2LUo4RJk8B=K96L$<9~9kAE!`zqxp!6 zOCl>WTJU1Th1_9H3g%gNK3Gl-pmmEZ9r7|FUMx4nU~wPjU_%xx^B2i_2p$7)s!OLEUyTPtkn*zcP z{f8A(k)*xnb!l(otGc(|@-Yt(wP$49uKAM@BzLk8tc&A;Ftho(#_)|y^odi(n6Oji68EI^WHp#%6C?(@eY&QKWp6h#LOE-u#%)K_PICb9={&C-!J=o1}60V zB`~MWlNyv1zwg1eT;^}H_uiS*6w4Qfttdwpl-oSBgKn6Ee8<-p%t0I8i%#l+Ml*NK zusHPoQ>?2B4UMQ~dKOyaGPI5>xP4CW?20GCL`02g$nhTMHQ03^K8cXjGrfGb8kA{2t8 z+6h=rxbWxMy8N*fOP>I($)08q1Udwv`ux(^aUY>!yBX8O$Ry# zj)Nmqchvn3XP|7p_n`l)7o5I|z286{n&G-HHFQc!l&R0`(#=x)@uB_pPdl1!qg)ic zabM$=y6P==aGZMH4UvaDis-*x=Q8|T^HUEbB14k=J#iVVem_ryAtRLD0K%g@%e+Nr z47X~r(JhO|*RL5=njtz{em$cUOlZ$PbXl+*ta31x zHnwmXSo3GiYj20-hdwDpH^(&ZKa#2sDuT%Ze&PPyoN=Cxc-|#|UWAfx?HjYFeayv#_L|WZXiv+#6MuC)Aw^w~wn#Ce8@7Zo z_Faa%^^wNsTw(%LS|zZT3KXdu>$-x*0=kAHy{;nZ9|pix)Aqgzy^A~3DI$mlL1X5m zfc$EIdrN26n6jmmwMo%vuip^ohP2+}8C&j)5SWv_koM}OI-3Y(5KvVur_xh>b zqx|kE_uj1(WLns-B_5~QZNp+PO@g9+uU{fskqfB9X@vKBLnoqg0wsMz+r6nd5`CEY z>oo@_)Ts^+`d~g5y2mI{nu1LD(kL}3eg56xlF*;SOR<_RZs_KeI?bMoa)@Yn@q^os z4bEaobo>`UV_X|hx&s}E6lf+}5{SFie2<0I-gh3e9Lok^}$?WS^r%QqI& z?*{7DSev&;@qCK7_$$58}6)#+LnTs}n#Mu_Y>~hj%hBt0itZ4Y!mp7@RM0PYh(>F`60;NJvXzB}zvN>Z0pu#t7ozsVjorXi42ntoZ*;QU36qaIm>s@{ba$U1udv;3ee5SwR6w;My>KsM|p6a ztZWXQ7tr~sMO%DI_)VsE9w}z7(yzb!3aO8gMgT{QuyZfzyr^1!od~$qwqn{7yY_v~ z>ZFwRgy=5s_dbBbwVT+{!U8;}Z|rYFQgJ5gUymU~b7Eatx8sC%)w7s|H==;|d+6wT zNf%hE!^oo|%%c;-SuL=BwB9pnm)}A4INY^-jf=|hXfs_>9Y1RXlu~BSd4t9XsY-h7 zS3Y6Wjx>lx0*0IM>O>7+REZU2P32<}`oG5H*?`Uc5tn!8wem;k5Kq|r8G*UsPOIH~ zghi6fGoGG@m6ZP8)w!)mchZ@R=891DMeLI`;!yazZ%^KaB>f7hIUFeFd0#mhgfjW| z1hBIoL`@pqZk)gyBaZIQe&O59eEWpIM~fQ}64F7`a4@6n2&8sW0CLi)RxNG>WgiA< zR+}0AL&?yTKr7ckL*laTRS{#wDB|0}u!ip|MM zLn*9Z;85Z^@iv}_GU=eO#|BbjkVIFu0_+_o@huNNjxB*h;LRLhj9oR_3TqwtbqC$| z`T)(y5}va_SyGuRVE=fFcWP-G6_O`nTn<1~YAPxOoHf|Yxr_C`F~&pE0y;8~B&wUv z%$ScLb

ERO$$54V*))euSG)l7pc`-3;upmHn~Zg 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 literal 0 HcmV?d00001 diff --git a/key_defs.xml b/key_defs.xml new file mode 100755 index 0000000..2b222c1 --- /dev/null +++ b/key_defs.xml @@ -0,0 +1,215 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/micro.png b/micro.png new file mode 100644 index 0000000000000000000000000000000000000000..77b0111ae01e9c7c01f554c6204c10de96e31dee GIT binary patch literal 12981 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 literal 0 HcmV?d00001 diff --git a/people.png b/people.png new file mode 100644 index 0000000000000000000000000000000000000000..12be719539183363a138897c7a460ed5409a2cda GIT binary patch literal 7892 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 ScZTcko%zM>B=I=v_x}Q*xHX{w literal 0 HcmV?d00001 diff --git a/quit.png b/quit.png new file mode 100644 index 0000000000000000000000000000000000000000..528f8d047ba87bc455f53a5bb0552825f9eaade2 GIT binary patch literal 6018 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 TT7VktpU;;{nu=fKEyMo>/etc/xdg/lxsession/LXDE-pi/autostart +echo 'onboard &'>>/etc/xdg/lxsession/LXDE-pi/autostart +echo 'chromium-browser --kiosk --window-position=0,0 --noerrdialogs --disable-translate --disable-infobars --disable-features=TranslateUI --disk-cache-dir=/dev/null --disable-pinch --overscroll-history-navigation=disabled --disable-features=TouchpadOverscrollHistoryNavigation https://talk.fdn.fr/ '>>/etc/xdg/lxsession/LXDE-pi/autostart +sudo reboot diff --git a/scripts/btconnect.sh b/scripts/btconnect.sh new file mode 100755 index 0000000..b9bf442 --- /dev/null +++ b/scripts/btconnect.sh @@ -0,0 +1,5 @@ +#!/bin/bash +export XDG_RUNTIME_DIR="/run/user/$(id -u)" +/usr/bin/bluetoothctl connect C8:7B:23:48:F6:30 >> /tmp/bluetoothConnexion.log 2>&1 +/usr/bin/pacmd set-card-profile bluez_card.C8_7B_23_48_F6_30 headset_head_unit >> /tmp/bluetoothCo + diff --git a/scripts/connect.py b/scripts/connect.py new file mode 100755 index 0000000..795429e --- /dev/null +++ b/scripts/connect.py @@ -0,0 +1,26 @@ +#!/usr/bin/python3 + +# Copyright © 2009 Chris Jones +# Copyright © 2012-2013 marmuta +# +# This file is part of Onboard. +# +# Onboard is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# Onboard is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +PYTHON_EXECUTABLE = "python3" + +import subprocess + +def run(): + exit_code = subprocess.call('/usr/share/onboard/scripts/btconnect.sh') diff --git a/scripts/quit.sh b/scripts/quit.sh new file mode 100755 index 0000000..2ba6333 --- /dev/null +++ b/scripts/quit.sh @@ -0,0 +1,6 @@ +#!/bin/bash +#pkill chromium +#chromium --kiosk --noerrdialogs --disable-translate --disable-infobars --disable-features=TranslateUI --disk-cache-dir=/dev/null --disable-pinch --overscroll-history-navigation=disabled --disable-features=TouchpadOverscrollHistoryNavigation https://talk.fdn.fr/ +xdotool key alt+Left + + diff --git a/scripts/quitScript.py b/scripts/quitScript.py new file mode 100755 index 0000000..02f83d2 --- /dev/null +++ b/scripts/quitScript.py @@ -0,0 +1,27 @@ +#!/usr/bin/python3 + +# Copyright © 2009 Chris Jones +# Copyright © 2012-2013 marmuta +# +# This file is part of Onboard. +# +# Onboard is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# Onboard is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +PYTHON_EXECUTABLE = "python3" + +import subprocess + +def run(): + exit_code = subprocess.call('/usr/share/onboard/scripts/quit.sh') + diff --git a/scripts/typescript b/scripts/typescript new file mode 100644 index 0000000..e69de29 diff --git a/typescript b/typescript new file mode 100644 index 0000000..54a6f95 --- /dev/null +++ b/typescript @@ -0,0 +1,655 @@ +Script started on 2023-06-16 14:57:21+02:00 [TERM="xterm-256color" TTY="/dev/pts/0" COLUMNS="238" LINES="57"] +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ ./script.sh +[?2004l [sudo] Mot de passe de kenzo : ***********            + 0% [En cours] Atteint :1 http://ftp.rezopole.net/ubuntu jammy InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à security.ubuntu.com (91.189.91.39)] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :2 http://ftp.rezopole.net/ubuntu jammy-updates InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à security.ubuntu.com (91.189.91.39)] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :3 http://ftp.rezopole.net/ubuntu jammy-backports InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à security.ubuntu.com (91.189.91.39)] [Connexion à www.synaptics.com (54.245.106.105)] Ign :4 https://mirror.cyberbits.eu/linuxmint/packages vera InRelease + 0% [Connexion à security.ubuntu.com (91.189.91.39)] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :5 https://mirror.cyberbits.eu/linuxmint/packages vera Release + 0% [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Réception de :6 http://security.ubuntu.com/ubuntu jammy-security InRelease [110 kB] + 0% [6 InRelease 1 137 B/110 kB 1%] [Connecté à www.synaptics.com (54.245.106.105)] 0% [6 InRelease 14,2 kB/110 kB 13%] [Connecté à www.synaptics.com (54.245.106.105)] 0% [6 InRelease 38,8 kB/110 kB 35%] [Connecté à www.synaptics.com (54.245.106.105)] 0% [6 InRelease 88,0 kB/110 kB 80%] [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Attente des fichiers d'en-tête] Atteint :8 https://www.synaptics.com/sites/default/files/Ubuntu stable InRelease + 0% [En cours] 0% [En cours] 100% [En cours] 110 ko réceptionnés en 1s (132 ko/s) + Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 3% Lecture des listes de paquets… 3% Lecture des listes de paquets… 5% Lecture des listes de paquets… 5% Lecture des listes de paquets… 7% Lecture des listes de paquets… 7% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 25% Lecture des listes de paquets… 38% Lecture des listes de paquets… 38% Lecture des listes de paquets… 54% Lecture des listes de paquets… 54% Lecture des listes de paquets… 64% Lecture des listes de paquets… 64% Lecture des listes de paquets… 67% Lecture des listes de paquets… 77% Lecture des listes de paquets… 77% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 80% Lecture des listes de paquets… 80% Lecture des listes de paquets… 81% Lecture des listes de paquets… 81% Lecture des listes de paquets… 82% Lecture des listes de paquets… 82% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 84% Lecture des listes de paquets… 84% Lecture des listes de paquets… 86% Lecture des listes de paquets… 86% Lecture des listes de paquets… 88% Lecture des listes de paquets… 88% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 92% Lecture des listes de paquets… 92% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 94% Lecture des listes de paquets… 94% Lecture des listes de paquets… 96% Lecture des listes de paquets… 96% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +Tous les paquets sont à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait + Calcul de la mise à jour… 0% Calcul de la mise à jour… 10% Calcul de la mise à jour... Fait +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +Les paquets supplémentaires suivants seront installés : + onboard-common onboard-data +Les NOUVEAUX paquets suivants seront installés : + onboard onboard-common onboard-data +0 mis à jour, 3 nouvellement installés, 0 à enlever et 0 non mis à jour. +Il est nécessaire de prendre 5 234 ko dans les archives. +Après cette opération, 26,2 Mo d'espace disque supplémentaires seront utilisés. +Souhaitez-vous continuer ? [O/n] o + 0% [En cours] Réception de :1 https://mirror.cyberbits.eu/linuxmint/packages vera/upstream amd64 onboard-common all 1.4.1+mint2+vanessa [608 kB] + 0% [1 onboard-common 32,5 kB/608 kB 5%] 16% [En cours] Réception de :2 https://mirror.cyberbits.eu/linuxmint/packages vera/upstream amd64 onboard amd64 1.4.1+mint2+vanessa [379 kB] + 16% [2 onboard 16,1 kB/379 kB 4%] 28% [Attente des fichiers d'en-tête] Réception de :3 https://mirror.cyberbits.eu/linuxmint/packages vera/upstream amd64 onboard-data all 1.4.1+mint2+vanessa [4 247 kB] + 28% [3 onboard-data 0 B/4 247 kB 0%] 51% [3 onboard-data 1 474 kB/4 247 kB 35%] 71% [3 onboard-data 2 785 kB/4 247 kB 66%] 100% [En cours] 5 234 ko réceptionnés en 2s (2 655 ko/s) + +78Sélection du paquet onboard-common précédemment désélectionné. +(Lecture de la base de données... (Lecture de la base de données... 5% (Lecture de la base de données... 10% (Lecture de la base de données... 15% (Lecture de la base de données... 20% (Lecture de la base de données... 25% (Lecture de la base de données... 30% (Lecture de la base de données... 35% (Lecture de la base de données... 40% (Lecture de la base de données... 45% (Lecture de la base de données... 50% (Lecture de la base de données... 55% (Lecture de la base de données... 60% (Lecture de la base de données... 65% (Lecture de la base de données... 70% (Lecture de la base de données... 75% (Lecture de la base de données... 80% (Lecture de la base de données... 85% (Lecture de la base de données... 90% (Lecture de la base de données... 95% (Lecture de la base de données... 100% (Lecture de la base de données... 668271 fichiers et répertoires déjà installés.) +Préparation du dépaquetage de .../onboard-common_1.4.1+mint2+vanessa_all.deb ... +7Progression : [ 0%] [....................................................................................................................................................................................................................] 87Progression : [ 8%] [################....................................................................................................................................................................................................] 8Dépaquetage de onboard-common (1.4.1+mint2+vanessa) ... +7Progression : [ 15%] [################################....................................................................................................................................................................................] 8Sélection du paquet onboard précédemment désélectionné. +Préparation du dépaquetage de .../onboard_1.4.1+mint2+vanessa_amd64.deb ... +7Progression : [ 23%] [################################################....................................................................................................................................................................] 8Dépaquetage de onboard (1.4.1+mint2+vanessa) ... +7Progression : [ 27%] [########################################################............................................................................................................................................................] 8Sélection du paquet onboard-data précédemment désélectionné. +Préparation du dépaquetage de .../onboard-data_1.4.1+mint2+vanessa_all.deb ... +7Progression : [ 33%] [######################################################################..............................................................................................................................................] 8Dépaquetage de onboard-data (1.4.1+mint2+vanessa) ... +7Progression : [ 40%] [####################################################################################................................................................................................................................] 8Paramétrage de onboard-common (1.4.1+mint2+vanessa) ... +7Progression : [ 47%] [##################################################################################################..................................................................................................................] 87Progression : [ 53%] [#################################################################################################################...................................................................................................] 8Paramétrage de onboard (1.4.1+mint2+vanessa) ... +7Progression : [ 60%] [###############################################################################################################################.....................................................................................] 8/usr/lib/python3/dist-packages/Onboard/LayoutLoaderSVG.py:447: SyntaxWarning: 'str' object is not callable; perhaps you missed a comma? + raise Exceptions.LayoutFileError("Unrecognized modifier %s in" \ +Traitement des actions différées (« triggers ») pour mailcap (3.70+nmu1ubuntu1) ... +Traitement des actions différées (« triggers ») pour desktop-file-utils (0.26+mint2+vera) ... +Traitement des actions différées (« triggers ») pour hicolor-icon-theme (0.17-2) ... +Traitement des actions différées (« triggers ») pour gnome-menus (3.36.0-1ubuntu3) ... +Traitement des actions différées (« triggers ») pour libglib2.0-0:amd64 (2.72.4-0ubuntu2.2) ... +7Progression : [ 67%] [#############################################################################################################################################.......................................................................] 87Progression : [ 73%] [###########################################################################################################################################################.........................................................] 87Progression : [ 80%] [#########################################################################################################################################################################...........................................] 8Traitement des actions différées (« triggers ») pour man-db (2.10.2-1) ... +Paramétrage de onboard-data (1.4.1+mint2+vanessa) ... +7Progression : [ 87%] [#######################################################################################################################################################################################.............................] 87Progression : [ 93%] [#####################################################################################################################################################################################################...............] 8 +78cp: impossible d'évaluer '/Document/jitsiBox/*.png': Aucun fichier ou dossier de ce type +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ ./script.sh ./script.sh ssh pi2@192.168.10.201./script.sh ./script.sh ssh pi2@192.168.10.201onboardssh pi2@192.168.10.201./script.sh ./script.sh +[?2004l  0% [En cours] Atteint :1 http://ftp.rezopole.net/ubuntu jammy InRelease + 0% [Connecté à mirror.cyberbits.eu (62.210.124.230)] [Connexion à security.ubuntu.com (91.189.91.38)] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :2 http://ftp.rezopole.net/ubuntu jammy-updates InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à security.ubuntu.com (91.189.91.38)] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :3 http://ftp.rezopole.net/ubuntu jammy-backports InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à security.ubuntu.com (91.189.91.38)] [Connexion à www.synaptics.com (54.245.106.105)] Ign :4 https://mirror.cyberbits.eu/linuxmint/packages vera InRelease + 0% [Connexion à security.ubuntu.com (91.189.91.38)] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :5 https://mirror.cyberbits.eu/linuxmint/packages vera Release + 0% [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :6 http://security.ubuntu.com/ubuntu jammy-security InRelease + 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Attente des fichiers d'en-tête] 0% [Attente des fichiers d'en-tête] Atteint :8 https://www.synaptics.com/sites/default/files/Ubuntu stable InRelease + 0% [En cours] 20% [En cours] Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 3% Lecture des listes de paquets… 3% Lecture des listes de paquets… 5% Lecture des listes de paquets… 5% Lecture des listes de paquets… 7% Lecture des listes de paquets… 7% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 29% Lecture des listes de paquets… 38% Lecture des listes de paquets… 38% Lecture des listes de paquets… 54% Lecture des listes de paquets… 54% Lecture des listes de paquets… 64% Lecture des listes de paquets… 64% Lecture des listes de paquets… 77% Lecture des listes de paquets… 77% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 80% Lecture des listes de paquets… 80% Lecture des listes de paquets… 81% Lecture des listes de paquets… 81% Lecture des listes de paquets… 82% Lecture des listes de paquets… 82% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 84% Lecture des listes de paquets… 84% Lecture des listes de paquets… 86% Lecture des listes de paquets… 86% Lecture des listes de paquets… 87% Lecture des listes de paquets… 88% Lecture des listes de paquets… 88% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 92% Lecture des listes de paquets… 92% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 94% Lecture des listes de paquets… 94% Lecture des listes de paquets… 96% Lecture des listes de paquets… 96% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +Tous les paquets sont à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait + Calcul de la mise à jour… 0% Calcul de la mise à jour… 10% Calcul de la mise à jour... Fait +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +onboard est déjà la version la plus récente (1.4.1+mint2+vanessa). +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. +cp: impossible d'évaluer '/Documents/jitsiBox/*.png': Aucun fichier ou dossier de ce type +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ ./script.sh +[?2004l  0% [En cours] Atteint :1 http://ftp.rezopole.net/ubuntu jammy InRelease + 0% [Connecté à mirror.cyberbits.eu (62.210.124.230)] [Connexion à security.ubuntu.com (91.189.91.38)] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :2 http://ftp.rezopole.net/ubuntu jammy-updates InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à security.ubuntu.com (91.189.91.38)] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :3 http://ftp.rezopole.net/ubuntu jammy-backports InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à security.ubuntu.com (91.189.91.38)] [Connexion à www.synaptics.com (54.245.106.105)] Ign :4 https://mirror.cyberbits.eu/linuxmint/packages vera InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :5 https://mirror.cyberbits.eu/linuxmint/packages vera Release + 0% [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :6 http://security.ubuntu.com/ubuntu jammy-security InRelease + 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Attente des fichiers d'en-tête] Atteint :8 https://www.synaptics.com/sites/default/files/Ubuntu stable InRelease + 0% [En cours] 0% [En cours] 20% [En cours] Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 3% Lecture des listes de paquets… 3% Lecture des listes de paquets… 5% Lecture des listes de paquets… 5% Lecture des listes de paquets… 7% Lecture des listes de paquets… 7% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 36% Lecture des listes de paquets… 38% Lecture des listes de paquets… 38% Lecture des listes de paquets… 54% Lecture des listes de paquets… 54% Lecture des listes de paquets… 64% Lecture des listes de paquets… 64% Lecture des listes de paquets… 77% Lecture des listes de paquets… 77% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 80% Lecture des listes de paquets… 80% Lecture des listes de paquets… 81% Lecture des listes de paquets… 81% Lecture des listes de paquets… 82% Lecture des listes de paquets… 82% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 84% Lecture des listes de paquets… 84% Lecture des listes de paquets… 86% Lecture des listes de paquets… 86% Lecture des listes de paquets… 88% Lecture des listes de paquets… 88% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 92% Lecture des listes de paquets… 92% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 94% Lecture des listes de paquets… 94% Lecture des listes de paquets… 96% Lecture des listes de paquets… 96% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 99% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +Tous les paquets sont à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait + Calcul de la mise à jour… 0% Calcul de la mise à jour… 10% Calcul de la mise à jour... Fait +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +onboard est déjà la version la plus récente (1.4.1+mint2+vanessa). +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. +cp: la cible '/usr/share/onboard/layers/images' n'est pas un répertoire +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ ./script.sh +[?2004l  0% [En cours] Atteint :1 http://ftp.rezopole.net/ubuntu jammy InRelease + 0% [Connecté à mirror.cyberbits.eu (62.210.124.230)] [Connexion à security.ubuntu.com (185.125.190.36)] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :2 http://ftp.rezopole.net/ubuntu jammy-updates InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à security.ubuntu.com (185.125.190.36)] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :3 http://ftp.rezopole.net/ubuntu jammy-backports InRelease + 0% [Attente des fichiers d'en-tête] [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :4 http://security.ubuntu.com/ubuntu jammy-security InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Ign :5 https://mirror.cyberbits.eu/linuxmint/packages vera InRelease + 0% [Connexion à www.synaptics.com (54.245.106.105)] Atteint :6 https://mirror.cyberbits.eu/linuxmint/packages vera Release + 0% [Connexion à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Attente des fichiers d'en-tête] 0% [Attente des fichiers d'en-tête] Atteint :8 https://www.synaptics.com/sites/default/files/Ubuntu stable InRelease + 0% [En cours] 20% [En cours] Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 3% Lecture des listes de paquets… 3% Lecture des listes de paquets… 5% Lecture des listes de paquets… 5% Lecture des listes de paquets… 7% Lecture des listes de paquets… 7% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 37% Lecture des listes de paquets… 38% Lecture des listes de paquets… 38% Lecture des listes de paquets… 54% Lecture des listes de paquets… 54% Lecture des listes de paquets… 64% Lecture des listes de paquets… 64% Lecture des listes de paquets… 77% Lecture des listes de paquets… 77% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 80% Lecture des listes de paquets… 80% Lecture des listes de paquets… 81% Lecture des listes de paquets… 81% Lecture des listes de paquets… 82% Lecture des listes de paquets… 82% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 84% Lecture des listes de paquets… 84% Lecture des listes de paquets… 86% Lecture des listes de paquets… 86% Lecture des listes de paquets… 88% Lecture des listes de paquets… 88% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 92% Lecture des listes de paquets… 92% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 94% Lecture des listes de paquets… 94% Lecture des listes de paquets… 96% Lecture des listes de paquets… 96% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +Tous les paquets sont à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait + Calcul de la mise à jour… 0% Calcul de la mise à jour… 10% Calcul de la mise à jour... Fait +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +onboard est déjà la version la plus récente (1.4.1+mint2+vanessa). +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. +cp: impossible de créer le fichier standard '/usr/share/onboard/layouts/images/cam.png': Permission non accordée +cp: impossible de créer le fichier standard '/usr/share/onboard/layouts/images/chat.png': Permission non accordée +cp: impossible de créer le fichier standard '/usr/share/onboard/layouts/images/enter.png': Permission non accordée +cp: impossible de créer le fichier standard '/usr/share/onboard/layouts/images/exit.png': Permission non accordée +cp: impossible de créer le fichier standard '/usr/share/onboard/layouts/images/hand.png': Permission non accordée +cp: impossible de créer le fichier standard '/usr/share/onboard/layouts/images/micro.png': Permission non accordée +cp: impossible de créer le fichier standard '/usr/share/onboard/layouts/images/people.png': Permission non accordée +cp: impossible de créer le fichier standard '/usr/share/onboard/layouts/images/quit.png': Permission non accordée +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ ./script.sh +[?2004l  0% [En cours] Atteint :1 http://ftp.rezopole.net/ubuntu jammy InRelease + 0% [Connecté à mirror.cyberbits.eu (62.210.124.230)] [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :2 http://security.ubuntu.com/ubuntu jammy-security InRelease + 0% [Attente des fichiers d'en-tête] [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :3 http://ftp.rezopole.net/ubuntu jammy-updates InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :4 http://ftp.rezopole.net/ubuntu jammy-backports InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Ign :5 https://mirror.cyberbits.eu/linuxmint/packages vera InRelease + 0% [Connexion à www.synaptics.com (54.245.106.105)] 0% [Attente des fichiers d'en-tête] [Connecté à www.synaptics.com (54.245.106.105)] 0% [Attente des fichiers d'en-tête] [Connecté à www.synaptics.com (54.245.106.105)] 0% [Attente des fichiers d'en-tête] [Connecté à www.synaptics.com (54.245.106.105)] Atteint :6 https://mirror.cyberbits.eu/linuxmint/packages vera Release + 0% [Attente des fichiers d'en-tête] 0% [Attente des fichiers d'en-tête] 0% [Attente des fichiers d'en-tête] Atteint :8 https://www.synaptics.com/sites/default/files/Ubuntu stable InRelease + 0% [En cours] 20% [En cours] Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 3% Lecture des listes de paquets… 3% Lecture des listes de paquets… 5% Lecture des listes de paquets… 5% Lecture des listes de paquets… 7% Lecture des listes de paquets… 7% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 38% Lecture des listes de paquets… 38% Lecture des listes de paquets… 41% Lecture des listes de paquets… 54% Lecture des listes de paquets… 54% Lecture des listes de paquets… 64% Lecture des listes de paquets… 64% Lecture des listes de paquets… 77% Lecture des listes de paquets… 77% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 80% Lecture des listes de paquets… 80% Lecture des listes de paquets… 81% Lecture des listes de paquets… 81% Lecture des listes de paquets… 82% Lecture des listes de paquets… 82% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 84% Lecture des listes de paquets… 84% Lecture des listes de paquets… 86% Lecture des listes de paquets… 86% Lecture des listes de paquets… 88% Lecture des listes de paquets… 88% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 92% Lecture des listes de paquets… 92% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 94% Lecture des listes de paquets… 94% Lecture des listes de paquets… 96% Lecture des listes de paquets… 96% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +Tous les paquets sont à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait + Calcul de la mise à jour… 0% Calcul de la mise à jour… 10% Calcul de la mise à jour... Fait +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +onboard est déjà la version la plus récente (1.4.1+mint2+vanessa). +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ onboard +[?2004l ^C[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ onbo_-ard-szettings +[?2004l [?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ onboard-settings  +[?2004l b ^C[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ onboard-settings ./script.sh +[?2004l  0% [En cours] Atteint :1 http://ftp.rezopole.net/ubuntu jammy InRelease + 0% [Connecté à mirror.cyberbits.eu (62.210.124.230)] [Connexion à security.ubuntu.com (91.189.91.38)] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :2 http://ftp.rezopole.net/ubuntu jammy-updates InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à security.ubuntu.com (91.189.91.38)] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :3 http://ftp.rezopole.net/ubuntu jammy-backports InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à security.ubuntu.com (91.189.91.38)] [Connexion à www.synaptics.com (54.245.106.105)] Ign :4 https://mirror.cyberbits.eu/linuxmint/packages vera InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :5 https://mirror.cyberbits.eu/linuxmint/packages vera Release + 0% [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :6 http://security.ubuntu.com/ubuntu jammy-security InRelease + 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Attente des fichiers d'en-tête] 0% [Attente des fichiers d'en-tête] Atteint :8 https://www.synaptics.com/sites/default/files/Ubuntu stable InRelease + 0% [En cours] 20% [En cours] Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 3% Lecture des listes de paquets… 3% Lecture des listes de paquets… 5% Lecture des listes de paquets… 5% Lecture des listes de paquets… 7% Lecture des listes de paquets… 7% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 38% Lecture des listes de paquets… 38% Lecture des listes de paquets… 38% Lecture des listes de paquets… 54% Lecture des listes de paquets… 54% Lecture des listes de paquets… 64% Lecture des listes de paquets… 64% Lecture des listes de paquets… 77% Lecture des listes de paquets… 77% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 80% Lecture des listes de paquets… 80% Lecture des listes de paquets… 81% Lecture des listes de paquets… 81% Lecture des listes de paquets… 82% Lecture des listes de paquets… 82% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 84% Lecture des listes de paquets… 84% Lecture des listes de paquets… 86% Lecture des listes de paquets… 86% Lecture des listes de paquets… 88% Lecture des listes de paquets… 88% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 92% Lecture des listes de paquets… 92% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 94% Lecture des listes de paquets… 94% Lecture des listes de paquets… 96% Lecture des listes de paquets… 96% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +Tous les paquets sont à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait + Calcul de la mise à jour… 0% Calcul de la mise à jour… 10% Calcul de la mise à jour... Fait +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +onboard est déjà la version la plus récente (1.4.1+mint2+vanessa). +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. +rm : supprimer '/usr/share/onboard/layouts/Whiteboard.onboard' qui est protégé en écriture et est du type « fichier » ? +cp: impossible de créer le fichier standard '/usr/share/onboard/layouts/Whiteboard.onboard': Permission non accordée +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ ./script.sh +[?2004l  0% [En cours] Atteint :1 http://ftp.rezopole.net/ubuntu jammy InRelease + 0% [Connecté à mirror.cyberbits.eu (62.210.124.230)] [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :2 http://security.ubuntu.com/ubuntu jammy-security InRelease + 0% [Connecté à mirror.cyberbits.eu (62.210.124.230)] [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :3 http://ftp.rezopole.net/ubuntu jammy-updates InRelease + 0% [Connecté à mirror.cyberbits.eu (62.210.124.230)] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :4 http://ftp.rezopole.net/ubuntu jammy-backports InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Ign :5 https://mirror.cyberbits.eu/linuxmint/packages vera InRelease + 0% [Connexion à www.synaptics.com (54.245.106.105)] Atteint :6 https://mirror.cyberbits.eu/linuxmint/packages vera Release + 0% [Connexion à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Attente des fichiers d'en-tête] Atteint :7 https://www.synaptics.com/sites/default/files/Ubuntu stable InRelease + 0% [En cours] 0% [En cours] 20% [En cours] Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 3% Lecture des listes de paquets… 3% Lecture des listes de paquets… 5% Lecture des listes de paquets… 5% Lecture des listes de paquets… 7% Lecture des listes de paquets… 7% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 38% Lecture des listes de paquets… 38% Lecture des listes de paquets… 38% Lecture des listes de paquets… 54% Lecture des listes de paquets… 54% Lecture des listes de paquets… 64% Lecture des listes de paquets… 64% Lecture des listes de paquets… 77% Lecture des listes de paquets… 77% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 80% Lecture des listes de paquets… 80% Lecture des listes de paquets… 81% Lecture des listes de paquets… 81% Lecture des listes de paquets… 82% Lecture des listes de paquets… 82% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 84% Lecture des listes de paquets… 84% Lecture des listes de paquets… 86% Lecture des listes de paquets… 86% Lecture des listes de paquets… 88% Lecture des listes de paquets… 88% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 92% Lecture des listes de paquets… 92% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 94% Lecture des listes de paquets… 94% Lecture des listes de paquets… 96% Lecture des listes de paquets… 96% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 99% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +Tous les paquets sont à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait + Calcul de la mise à jour… 0% Calcul de la mise à jour… 10% Calcul de la mise à jour... Fait +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +onboard est déjà la version la plus récente (1.4.1+mint2+vanessa). +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ ./script.sh +[?2004l  0% [En cours] Atteint :1 http://ftp.rezopole.net/ubuntu jammy InRelease + 0% [Connecté à mirror.cyberbits.eu (62.210.124.230)] [Connexion à security.ubuntu.com (185.125.190.36)] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :2 http://ftp.rezopole.net/ubuntu jammy-updates InRelease + 0% [Connecté à mirror.cyberbits.eu (62.210.124.230)] [Attente des fichiers d'en-tête] [Connexion à security.ubuntu.com (185.125.190.36)] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :3 http://ftp.rezopole.net/ubuntu jammy-backports InRelease + 0% [Connecté à mirror.cyberbits.eu (62.210.124.230)] [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :4 http://security.ubuntu.com/ubuntu jammy-security InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Ign :5 https://mirror.cyberbits.eu/linuxmint/packages vera InRelease + 0% [Connexion à www.synaptics.com (54.245.106.105)] Atteint :6 https://mirror.cyberbits.eu/linuxmint/packages vera Release + 0% [Connexion à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Attente des fichiers d'en-tête] Atteint :8 https://www.synaptics.com/sites/default/files/Ubuntu stable InRelease + 0% [En cours] 20% [En cours] Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 3% Lecture des listes de paquets… 3% Lecture des listes de paquets… 5% Lecture des listes de paquets… 5% Lecture des listes de paquets… 7% Lecture des listes de paquets… 7% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 37% Lecture des listes de paquets… 38% Lecture des listes de paquets… 38% Lecture des listes de paquets… 54% Lecture des listes de paquets… 54% Lecture des listes de paquets… 64% Lecture des listes de paquets… 64% Lecture des listes de paquets… 77% Lecture des listes de paquets… 77% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 80% Lecture des listes de paquets… 80% Lecture des listes de paquets… 81% Lecture des listes de paquets… 81% Lecture des listes de paquets… 82% Lecture des listes de paquets… 82% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 84% Lecture des listes de paquets… 84% Lecture des listes de paquets… 86% Lecture des listes de paquets… 86% Lecture des listes de paquets… 88% Lecture des listes de paquets… 88% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 92% Lecture des listes de paquets… 92% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 94% Lecture des listes de paquets… 94% Lecture des listes de paquets… 96% Lecture des listes de paquets… 96% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +Tous les paquets sont à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait + Calcul de la mise à jour… 0% Calcul de la mise à jour… 10% Calcul de la mise à jour... Fait +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +onboard est déjà la version la plus récente (1.4.1+mint2+vanessa). +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ sudo apt purge onboard* +[?2004l Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +Note : sélection de onboard-common pour l'expression rationnelle « onboard* » +Note : sélection de onboard-data pour l'expression rationnelle « onboard* » +Note : sélection de onboard-keyman pour l'expression rationnelle « onboard* » +Note : sélection de onboard-prediction-data pour l'expression rationnelle « onboard* » +Note : sélection de onboard pour l'expression rationnelle « onboard* » +Le paquet « onboard-prediction-data » n'est pas installé, et ne peut donc être supprimé +Le paquet « onboard-keyman » n'est pas installé, et ne peut donc être supprimé +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +Les paquets suivants seront ENLEVÉS : + onboard* onboard-common* onboard-data* +0 mis à jour, 0 nouvellement installés, 3 à enlever et 0 non mis à jour. +Après cette opération, 26,2 Mo d'espace disque seront libérés. +Souhaitez-vous continuer ? [O/n] o + +78(Lecture de la base de données... (Lecture de la base de données... 5% (Lecture de la base de données... 10% (Lecture de la base de données... 15% (Lecture de la base de données... 20% (Lecture de la base de données... 25% (Lecture de la base de données... 30% (Lecture de la base de données... 35% (Lecture de la base de données... 40% (Lecture de la base de données... 45% (Lecture de la base de données... 50% (Lecture de la base de données... 55% (Lecture de la base de données... 60% (Lecture de la base de données... 65% (Lecture de la base de données... 70% (Lecture de la base de données... 75% (Lecture de la base de données... 80% (Lecture de la base de données... 85% (Lecture de la base de données... 90% (Lecture de la base de données... 95% (Lecture de la base de données... 100% (Lecture de la base de données... 668624 fichiers et répertoires déjà installés.) +Suppression de onboard-data (1.4.1+mint2+vanessa) ... +7Progression : [ 0%] [....................................................................................................................................................................................................................] 87Progression : [ 8%] [################....................................................................................................................................................................................................] 87Progression : [ 15%] [################################....................................................................................................................................................................................] 87Progression : [ 23%] [################################################....................................................................................................................................................................] 87Progression : [ 31%] [#################################################################...................................................................................................................................................] 8Suppression de onboard (1.4.1+mint2+vanessa) ... +7Progression : [ 38%] [#################################################################################...................................................................................................................................] 87Progression : [ 46%] [#################################################################################################...................................................................................................................] 8Suppression de onboard-common (1.4.1+mint2+vanessa) ... +7Progression : [ 53%] [#################################################################################################################...................................................................................................] 87Progression : [ 60%] [###############################################################################################################################.....................................................................................] 87Progression : [ 67%] [#############################################################################################################################################.......................................................................] 8dpkg: avertissement: lors de la suppression de onboard-common, le répertoire « /usr/share/onboard/scripts » n'était pas vide, donc il n'a pas été supprimé +dpkg: avertissement: lors de la suppression de onboard-common, le répertoire « /usr/share/onboard/layouts/images » n'était pas vide, donc il n'a pas été supprimé +7Progression : [ 73%] [###########################################################################################################################################################.........................................................] 8Traitement des actions différées (« triggers ») pour hicolor-icon-theme (0.17-2) ... +Traitement des actions différées (« triggers ») pour gnome-menus (3.36.0-1ubuntu3) ... +Traitement des actions différées (« triggers ») pour libglib2.0-0:amd64 (2.72.4-0ubuntu2.2) ... +7Progression : [ 80%] [#########################################################################################################################################################################...........................................] 87Progression : [ 87%] [#######################################################################################################################################################################################.............................] 8Traitement des actions différées (« triggers ») pour man-db (2.10.2-1) ... +Traitement des actions différées (« triggers ») pour mailcap (3.70+nmu1ubuntu1) ... +Traitement des actions différées (« triggers ») pour desktop-file-utils (0.26+mint2+vera) ... +(Lecture de la base de données... (Lecture de la base de données... 5% (Lecture de la base de données... 10% (Lecture de la base de données... 15% (Lecture de la base de données... 20% (Lecture de la base de données... 25% (Lecture de la base de données... 30% (Lecture de la base de données... 35% (Lecture de la base de données... 40% (Lecture de la base de données... 45% (Lecture de la base de données... 50% (Lecture de la base de données... 55% (Lecture de la base de données... 60% (Lecture de la base de données... 65% (Lecture de la base de données... 70% (Lecture de la base de données... 75% (Lecture de la base de données... 80% (Lecture de la base de données... 85% (Lecture de la base de données... 90% (Lecture de la base de données... 95% (Lecture de la base de données... 100% (Lecture de la base de données... 668272 fichiers et répertoires déjà installés.) +Purge des fichiers de configuration de onboard (1.4.1+mint2+vanessa) ... +7Progression : [ 93%] [#####################################################################################################################################################################################################...............] 8 +78[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ ls +[?2004l cam.png chat.png enter.png exit.png hand.png Keyboard.py key_defs.xml micro.png people.png quit.png scripts script.sh typescript Whiteboard-Alpha.svg Whiteboard.onboard +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ scrip./script +[?2004l bash: ./script: Aucun fichier ou dossier de ce type +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ ./script.sh +[?2004l  0% [En cours] Atteint :1 http://ftp.rezopole.net/ubuntu jammy InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à security.ubuntu.com (91.189.91.39)] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :2 http://ftp.rezopole.net/ubuntu jammy-updates InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à security.ubuntu.com (91.189.91.39)] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :3 http://ftp.rezopole.net/ubuntu jammy-backports InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à security.ubuntu.com (91.189.91.39)] [Connexion à www.synaptics.com (54.245.106.105)] Ign :4 https://mirror.cyberbits.eu/linuxmint/packages vera InRelease + 0% [Connexion à security.ubuntu.com (91.189.91.39)] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :5 https://mirror.cyberbits.eu/linuxmint/packages vera Release + 0% [Connexion à security.ubuntu.com (91.189.91.39)] [Connexion à www.synaptics.com (54.245.106.105)] 0% [Attente des fichiers d'en-tête] [Connecté à www.synaptics.com (54.245.106.105)] Atteint :6 http://security.ubuntu.com/ubuntu jammy-security InRelease + 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Attente des fichiers d'en-tête] Atteint :8 https://www.synaptics.com/sites/default/files/Ubuntu stable InRelease + 0% [En cours] 20% [En cours] Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 3% Lecture des listes de paquets… 3% Lecture des listes de paquets… 5% Lecture des listes de paquets… 5% Lecture des listes de paquets… 7% Lecture des listes de paquets… 7% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 36% Lecture des listes de paquets… 38% Lecture des listes de paquets… 38% Lecture des listes de paquets… 54% Lecture des listes de paquets… 54% Lecture des listes de paquets… 64% Lecture des listes de paquets… 64% Lecture des listes de paquets… 77% Lecture des listes de paquets… 77% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 80% Lecture des listes de paquets… 80% Lecture des listes de paquets… 81% Lecture des listes de paquets… 81% Lecture des listes de paquets… 82% Lecture des listes de paquets… 82% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 84% Lecture des listes de paquets… 84% Lecture des listes de paquets… 86% Lecture des listes de paquets… 86% Lecture des listes de paquets… 87% Lecture des listes de paquets… 88% Lecture des listes de paquets… 88% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 92% Lecture des listes de paquets… 92% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 94% Lecture des listes de paquets… 94% Lecture des listes de paquets… 96% Lecture des listes de paquets… 96% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +Tous les paquets sont à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait + Calcul de la mise à jour… 0% Calcul de la mise à jour… 10% Calcul de la mise à jour... Fait +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +Les paquets supplémentaires suivants seront installés : + onboard-common onboard-data +Les NOUVEAUX paquets suivants seront installés : + onboard onboard-common onboard-data +0 mis à jour, 3 nouvellement installés, 0 à enlever et 0 non mis à jour. +Il est nécessaire de prendre 5 234 ko dans les archives. +Après cette opération, 26,2 Mo d'espace disque supplémentaires seront utilisés. +Souhaitez-vous continuer ? [O/n] o + 0% [En cours] Réception de :1 https://mirror.cyberbits.eu/linuxmint/packages vera/upstream amd64 onboard-common all 1.4.1+mint2+vanessa [608 kB] + 0% [1 onboard-common 32,5 kB/608 kB 5%] 16% [En cours] Réception de :2 https://mirror.cyberbits.eu/linuxmint/packages vera/upstream amd64 onboard amd64 1.4.1+mint2+vanessa [379 kB] + 16% [2 onboard 16,1 kB/379 kB 4%] 28% [Attente des fichiers d'en-tête] Réception de :3 https://mirror.cyberbits.eu/linuxmint/packages vera/upstream amd64 onboard-data all 1.4.1+mint2+vanessa [4 247 kB] + 29% [3 onboard-data 16,1 kB/4 247 kB 0%] 48% [3 onboard-data 1 294 kB/4 247 kB 30%] 62% [3 onboard-data 2 179 kB/4 247 kB 51%] 80% [3 onboard-data 3 375 kB/4 247 kB 79%] 100% [En cours] 5 234 ko réceptionnés en 2s (2 134 ko/s) + +78Sélection du paquet onboard-common précédemment désélectionné. +(Lecture de la base de données... (Lecture de la base de données... 5% (Lecture de la base de données... 10% (Lecture de la base de données... 15% (Lecture de la base de données... 20% (Lecture de la base de données... 25% (Lecture de la base de données... 30% (Lecture de la base de données... 35% (Lecture de la base de données... 40% (Lecture de la base de données... 45% (Lecture de la base de données... 50% (Lecture de la base de données... 55% (Lecture de la base de données... 60% (Lecture de la base de données... 65% (Lecture de la base de données... 70% (Lecture de la base de données... 75% (Lecture de la base de données... 80% (Lecture de la base de données... 85% (Lecture de la base de données... 90% (Lecture de la base de données... 95% (Lecture de la base de données... 100% (Lecture de la base de données... 668271 fichiers et répertoires déjà installés.) +Préparation du dépaquetage de .../onboard-common_1.4.1+mint2+vanessa_all.deb ... +7Progression : [ 0%] [....................................................................................................................................................................................................................] 87Progression : [ 8%] [################....................................................................................................................................................................................................] 8Dépaquetage de onboard-common (1.4.1+mint2+vanessa) ... +7Progression : [ 15%] [################################....................................................................................................................................................................................] 8Sélection du paquet onboard précédemment désélectionné. +Préparation du dépaquetage de .../onboard_1.4.1+mint2+vanessa_amd64.deb ... +7Progression : [ 23%] [################################################....................................................................................................................................................................] 8Dépaquetage de onboard (1.4.1+mint2+vanessa) ... +7Progression : [ 27%] [########################################################............................................................................................................................................................] 8Sélection du paquet onboard-data précédemment désélectionné. +Préparation du dépaquetage de .../onboard-data_1.4.1+mint2+vanessa_all.deb ... +7Progression : [ 33%] [######################################################################..............................................................................................................................................] 8Dépaquetage de onboard-data (1.4.1+mint2+vanessa) ... +7Progression : [ 40%] [####################################################################################................................................................................................................................] 8Paramétrage de onboard-common (1.4.1+mint2+vanessa) ... +7Progression : [ 47%] [##################################################################################################..................................................................................................................] 87Progression : [ 53%] [#################################################################################################################...................................................................................................] 8Paramétrage de onboard (1.4.1+mint2+vanessa) ... +7Progression : [ 60%] [###############################################################################################################################.....................................................................................] 8/usr/lib/python3/dist-packages/Onboard/LayoutLoaderSVG.py:447: SyntaxWarning: 'str' object is not callable; perhaps you missed a comma? + raise Exceptions.LayoutFileError("Unrecognized modifier %s in" \ +Traitement des actions différées (« triggers ») pour mailcap (3.70+nmu1ubuntu1) ... +Traitement des actions différées (« triggers ») pour desktop-file-utils (0.26+mint2+vera) ... +Traitement des actions différées (« triggers ») pour hicolor-icon-theme (0.17-2) ... +Traitement des actions différées (« triggers ») pour gnome-menus (3.36.0-1ubuntu3) ... +Traitement des actions différées (« triggers ») pour libglib2.0-0:amd64 (2.72.4-0ubuntu2.2) ... +7Progression : [ 67%] [#############################################################################################################################################.......................................................................] 87Progression : [ 73%] [###########################################################################################################################################################.........................................................] 87Progression : [ 80%] [#########################################################################################################################################################################...........................................] 8Traitement des actions différées (« triggers ») pour man-db (2.10.2-1) ... +Paramétrage de onboard-data (1.4.1+mint2+vanessa) ... +7Progression : [ 87%] [#######################################################################################################################################################################################.............................] 87Progression : [ 93%] [#####################################################################################################################################################################################################...............] 8 +78cp: -r non spécifié ; omission du répertoire '/home/kenzo/Documents/jitsiBox/scripts' +rm : supprimer '/usr/lib/python3/dist-packages/Onboard/Keyboard.py' qui est protégé en écriture et est du type « fichier » ? ^C +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ ./script.sh +[?2004l  0% [En cours] Atteint :1 http://ftp.rezopole.net/ubuntu jammy InRelease + 0% [Connecté à mirror.cyberbits.eu (62.210.124.230)] [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :2 http://security.ubuntu.com/ubuntu jammy-security InRelease + 0% [Connecté à mirror.cyberbits.eu (62.210.124.230)] [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :3 http://ftp.rezopole.net/ubuntu jammy-updates InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :4 http://ftp.rezopole.net/ubuntu jammy-backports InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Ign :5 https://mirror.cyberbits.eu/linuxmint/packages vera InRelease + 0% [Connexion à www.synaptics.com (54.245.106.105)] Atteint :6 https://mirror.cyberbits.eu/linuxmint/packages vera Release + 0% [Connexion à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Attente des fichiers d'en-tête] 0% [Attente des fichiers d'en-tête] Atteint :8 https://www.synaptics.com/sites/default/files/Ubuntu stable InRelease + 0% [En cours] 20% [En cours] Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 3% Lecture des listes de paquets… 3% Lecture des listes de paquets… 5% Lecture des listes de paquets… 5% Lecture des listes de paquets… 7% Lecture des listes de paquets… 7% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 38% Lecture des listes de paquets… 38% Lecture des listes de paquets… 42% Lecture des listes de paquets… 54% Lecture des listes de paquets… 54% Lecture des listes de paquets… 64% Lecture des listes de paquets… 64% Lecture des listes de paquets… 77% Lecture des listes de paquets… 77% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 80% Lecture des listes de paquets… 80% Lecture des listes de paquets… 81% Lecture des listes de paquets… 81% Lecture des listes de paquets… 82% Lecture des listes de paquets… 82% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 84% Lecture des listes de paquets… 84% Lecture des listes de paquets… 86% Lecture des listes de paquets… 86% Lecture des listes de paquets… 88% Lecture des listes de paquets… 88% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 92% Lecture des listes de paquets… 92% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 94% Lecture des listes de paquets… 94% Lecture des listes de paquets… 96% Lecture des listes de paquets… 96% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +Tous les paquets sont à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait + Calcul de la mise à jour… 0% Calcul de la mise à jour… 10% Calcul de la mise à jour... Fait +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +onboard est déjà la version la plus récente (1.4.1+mint2+vanessa). +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. +rm : supprimer '/usr/lib/python3/dist-packages/Onboard/Keyboard.py' qui est protégé en écriture et est du type « fichier » ? o ^C +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ ./script.sh +[?2004l  0% [En cours] Atteint :1 http://ftp.rezopole.net/ubuntu jammy InRelease + 0% [Connecté à mirror.cyberbits.eu (62.210.124.230)] [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :2 http://security.ubuntu.com/ubuntu jammy-security InRelease + 0% [Connecté à mirror.cyberbits.eu (62.210.124.230)] [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :3 http://ftp.rezopole.net/ubuntu jammy-updates InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Atteint :4 http://ftp.rezopole.net/ubuntu jammy-backports InRelease + 0% [Attente des fichiers d'en-tête] [Connexion à www.synaptics.com (54.245.106.105)] Ign :5 https://mirror.cyberbits.eu/linuxmint/packages vera InRelease + 0% [Connexion à www.synaptics.com (54.245.106.105)] Atteint :6 https://mirror.cyberbits.eu/linuxmint/packages vera Release + 0% [Connexion à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Connecté à www.synaptics.com (54.245.106.105)] 0% [Attente des fichiers d'en-tête] 0% [Attente des fichiers d'en-tête] Atteint :8 https://www.synaptics.com/sites/default/files/Ubuntu stable InRelease + 0% [En cours] 20% [En cours] Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 0% Lecture des listes de paquets… 3% Lecture des listes de paquets… 3% Lecture des listes de paquets… 5% Lecture des listes de paquets… 5% Lecture des listes de paquets… 7% Lecture des listes de paquets… 7% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 8% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 9% Lecture des listes de paquets… 37% Lecture des listes de paquets… 38% Lecture des listes de paquets… 38% Lecture des listes de paquets… 54% Lecture des listes de paquets… 54% Lecture des listes de paquets… 64% Lecture des listes de paquets… 64% Lecture des listes de paquets… 77% Lecture des listes de paquets… 77% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 78% Lecture des listes de paquets… 80% Lecture des listes de paquets… 80% Lecture des listes de paquets… 81% Lecture des listes de paquets… 81% Lecture des listes de paquets… 82% Lecture des listes de paquets… 82% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 83% Lecture des listes de paquets… 84% Lecture des listes de paquets… 84% Lecture des listes de paquets… 86% Lecture des listes de paquets… 86% Lecture des listes de paquets… 88% Lecture des listes de paquets… 88% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 89% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 90% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 91% Lecture des listes de paquets… 92% Lecture des listes de paquets… 92% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 93% Lecture des listes de paquets… 94% Lecture des listes de paquets… 94% Lecture des listes de paquets… 96% Lecture des listes de paquets… 96% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets… 98% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +Tous les paquets sont à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait + Calcul de la mise à jour… 0% Calcul de la mise à jour… 10% Calcul de la mise à jour... Fait +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. + Lecture des listes de paquets… 0% Lecture des listes de paquets… 100% Lecture des listes de paquets... Fait + Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 0% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances… 50% Construction de l'arbre des dépendances... Fait + Lecture des informations d'état… 0% Lecture des informations d'état… 0% Lecture des informations d'état... Fait +onboard est déjà la version la plus récente (1.4.1+mint2+vanessa). +Les paquets suivants ont été installés automatiquement et ne sont plus nécessaires : + linux-headers-5.15.0-72 linux-headers-5.15.0-72-generic linux-image-5.15.0-72-generic linux-modules-5.15.0-72-generic linux-modules-extra-5.15.0-72-generic +Veuillez utiliser « sudo apt autoremove » pour les supprimer. +0 mis à jour, 0 nouvellement installés, 0 à enlever et 0 non mis à jour. +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ onboard +[?2004l +rrmmcc^[^[^[^[ + +^[[1;3D^[[1;3D^C[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ sudo apt isntall pulseaudnstall pulseaudio +pulseaudio pulseaudio-equalizer pulseaudio-module-gsettings pulseaudio-module-lirc pulseaudio-module-zeroconf +pulseaudio-dlna pulseaudio-module-bluetooth pulseaudio-module-jack pulseaudio-module-raop pulseaudio-utils +]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ sudo apt install pulseaudio-mlododule-bluetooth onboard./script.shlssudo apt purge onboard*./script.sh onboard-settings ./script.sh ssh pi2@192.168.10.201onboardsudo nano /usr/share/onboard/scripts/practice.sh onboardssh pi2@192.168.10.201 +[?2004l ssh: connect to host 192.168.10.201 port 22: No route to host +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ ssh pi2@192.168.10.201pi +[?2004l ssh: Could not resolve hostname 192.168.10.201pi: Name or service not known +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ ssh pi2@192.168.10.201pi +[?2004l ssh: connect to host 192.168.10.201 port 22: No route to host +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ ssh pi2@192.168.10.201 +[?2004l ssh: connect to host 192.168.10.201 port 22: No route to host +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ ssh pi2@192.168.10.201 +[?2004l pi2@192.168.10.201's password: +Linux raspberrypi 6.1.21-v8+ #1642 SMP PREEMPT Mon Apr 3 17:24:16 BST 2023 aarch64 + +The programs included with the Debian GNU/Linux system are free software; +the exact distribution terms for each program are described in the +individual files in /usr/share/doc/*/copyright. + +Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent +permitted by applicable law. +Last login: Fri Jun 16 11:23:58 2023 + +Wi-Fi is currently blocked by rfkill. +Use raspi-config to set the country before use. + +[?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ ls +[?2004l Bookshelf btconnect.sh Desktop Documents Downloads Music Pictures Public Templates Videos +[?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ sudo nanonano vbtconnect.sh +[?2004l [?2004h[?1049h(B[?7h[?1h=[?1h=[?25l(B(B[ Lecture... ](B(B[ Lecture de 4 lignes ](B(B GNU nano 5.4 btconnect.sh (B (B^G(B Aide(B^O(B Écrire(B^W(B Chercher(B^K(B Couper(B^T(B Exécuter(B^C(B Emplacement (BM-U(B Annuler(BM-A(B Placer la marq(BM-](B -> Crochet (BM-Q(B Précédent (B^B(B En arrière (B^◀(B Mot précédent (B^A(B Début doc. (B^X(B Quitter(B^R(B Lire fich. (B^\(B Remplacer(B^U(B Coller(B^J(B Justifier(B^_(B Aller ligne (BM-E(B Refaire(BM-6(B Copier(B^Q(B Retrouver(BM-W(B Suivant(B^F(B En avant(B^▶(B Mot suivant (B^E(B Fin #!/bin/bash export(B XDG_RUNTIME_DIR=(B"/run/user/$(id -u)" (B/usr/bin/bluetoothctl connect 30:(B50:(B75:(BB5:(BB3:(BA0 >>(B /tmp/bluetoothConnexion.log 2>&(B1 /usr/bin/pacmd (Bset(B-card-profile bluez_card.30_50_75_B5_B3_A0 headset_head_unit >>(B /tmp/bluetoothCo [?12l[?25h[?25l[?12l[?25h[?1049l [?1l>[?2004l[?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ ^C[?2004l [?2004h[?2004l +[?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ exit +[?2004l déconnexion +Connection to 192.168.10.201 closed. +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ ls +[?2004l cam.png chat.png enter.png exit.png hand.png Keyboard.py key_defs.xml micro.png people.png quit.png scripts script.sh typescript Whiteboard-Alpha.svg Whiteboard.onboard +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ exitsudo nano btconnect +[?2004l [?2004h[?1049h(B[?7h[?1h=[?1h=[?25l(B(B[ Nouveau fichier ](B(B GNU nano 6.2 btconnect (B (B^G(B Aide(B^O(B Écrire(B^W(B Chercher(B^K(B Couper(B^T(B Exécuter(B^C(B Emplacement (BM-U(B Annuler(BM-A(B Marquer(BM-](B -> Crochet (BM-Q(B Précédent (B^B(B En arrière (B^◂(B Mot précédent (B^A(B Début de ligne (B^X(B Quitter(B^R(B Lire fich. (B^\(B Remplacer(B^U(B Coller(B^J(B Justifier(B^/(B Aller ligne (BM-E(B Refaire(BM-6(B Copier(B^Q(B Retrouver(BM-W(B Suivant(B^F(B En avant(B^▸(B Mot suivant (B^E(B Fin de ligne [?12l[?25h[?25l(B*(B[?12l[?25h .[?25l[?12l[?25hs[?25l (BSauver l'espace modifié ?  O(B Oui (B N(B Non (B^C(B Annuler[?12l[?25h[?25l (B[ Annulé ](B (B^G(B Aide(B^O(B Écrire(B^W(B Chercher(B^K(B Couper(B^T(B Exécuter(B^C(B Emplacement (BM-U(B Annuler(BM-A(B Marquer(BM-](B -> Crochet (BM-Q(B Précédent (B^B(B En arrière (B^◂(B Mot précédent (B^A(B Début de ligne (B^X(B Quitter (B^R(B Lire fich. (B^\(B Remplacer(B^U(B Coller(B^J(B Justifier(B^/(B Aller ligne (BM-E(B Refaire(BM-6(B Copier(B^Q(B Retrouver(BM-W(B Suivant(B^F(B En avant(B^▸(B Mot suivant (B^E(B Fin de ligne[?12l[?25h[?25l (BSauver l'espace modifié ?  O(B Oui (B N(B Non (B^C(B Annuler[?12l[?25h[?25l [?12l[?25h[?1049l [?1l>[?2004l[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ sudo nano btconnect.sh +[?2004l [?2004h[?1049h(B[?7h[?1h=[?1h=[?25l(B(B[ Nouveau fichier ](B(B GNU nano 6.2 btconnect.sh (B (B^G(B Aide(B^O(B Écrire(B^W(B Chercher(B^K(B Couper(B^T(B Exécuter(B^C(B Emplacement (BM-U(B Annuler(BM-A(B Marquer(BM-](B -> Crochet (BM-Q(B Précédent (B^B(B En arrière (B^◂(B Mot précédent (B^A(B Début de ligne (B^X(B Quitter(B^R(B Lire fich. (B^\(B Remplacer(B^U(B Coller(B^J(B Justifier(B^/(B Aller ligne (BM-E(B Refaire(BM-6(B Copier(B^Q(B Retrouver(BM-W(B Suivant(B^F(B En avant(B^▸(B Mot suivant (B^E(B Fin de ligne [?12l[?25h[?25l(B* (BGNU nano 5.4btconnect.sh #!/bin/bash export(B XDG_RUNTIME_DIR=(B"/run/user/$(id -u)" (B/usr/bin/bluetoothctl connect 30:(B50:(B75:(BB5:(BB3:(BA0 >>(B /tmp/bluetoothConnexion.log 2>&(B1 /usr/bin/pacmd (Bset(B-card-profile bluez_card.30_50_75_B5_B3_A0 headset_head_unit >>(B /tmp/bluetoothCo [?12l[?25h[?25l(BSauver l'espace modifié ?  O(B Oui (B N(B Non (B^C(B Annuler[?12l[?25h[?25l (B[ Annulé ](B (B^G(B Aide(B^O(B Écrire(B^W(B Chercher(B^K(B Couper(B^T(B Exécuter(B^C(B Emplacement (BM-U(B Annuler(BM-A(B Marquer(BM-](B -> Crochet (BM-Q(B Précédent (B^B(B En arrière (B^◂(B Mot précédent (B^A(B Début de ligne (B^X(B Quitter (B^R(B Lire fich. (B^\(B Remplacer(B^U(B Coller(B^J(B Justifier(B^/(B Aller ligne (BM-E(B Refaire(BM-6(B Copier(B^Q(B Retrouver(BM-W(B Suivant(B^F(B En avant(B^▸(B Mot suivant (B^E(B Fin de ligne[?12l[?25h [?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l +(B<(B  #!/bin/bash(B[?12l[?25h[?25l[?12l[?25h [?25l[?12l[?25h [?25l[?12l[?25h GNU nano 5.4 btconnect.sh #!(B>(B[?25l[?12l[?25h #!/(B[?25l[?12l[?25h #!/b(B[?25l[?12l[?25h #!/bi(B[?25l[?12l[?25h #!/bin(B[?25l[?12l[?25h #!/bin/(B[?25l[?12l[?25h #!/bin/b(B[?25l[?12l[?25h #!/bin/ba(B[?25l [?12l[?25h #!/bin/bash(B[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h#!(B/bin/bash[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25hn[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h #!/bin/bash(B[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h#!(B/bin/bash[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h #!/bin/bash(B[?25l[?12l[?25h#!(B/bin/bash[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h #!/bin/bash(B[?25l[?12l[?25h#!(B/bin/bash[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h #!/bin/bash(B[?25l[?12l[?25h [?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l(BSauver l'espace modifié ?  O(B Oui (B N(B Non (B^C(B Annuler[?12l[?25h[?25l (B^G(B Aide(BM-D(B Format DOS(BM-A(B Ajout (à la fin)(BM-B(B Copie de sécu. (B^C(B Annuler (BM-M(B Format Mac(BM-P(B Ajout (au début)(B^T(B Parcourir (BNom du fichier à écrire: btconnect.sh(B[?12l[?25h[?25l (B[ Écriture... ](B(B (B(B[ 5 lignes écrites ](B [?12l[?25h[?1049l [?1l>[?2004l[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ sudo nano btconnect.sh.shnano .et/etc/xdg/lxdse/ +autostart/ menus/ systemd/ user-dirs.conf user-dirs.defaults xdg-default/ xdg-default.desktop/ xdg-xfce/ Xwayland-session.d/ +]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ nano /etc/xdg/autostart/ +at-spi-dbus-bus.desktop cinnamon-settings-daemon-power.desktop mintreport.desktop print-applet.desktop +blueman.desktop cinnamon-settings-daemon-print-notifications.desktop mintupdate.desktop pulseaudio.desktop +caribou-autostart.desktop cinnamon-settings-daemon-screensaver-proxy.desktop mintwelcome.desktop sticky.desktop +cinnamon-settings-daemon-a11y-settings.desktop cinnamon-settings-daemon-smartcard.desktop nm-applet.desktop tracker-miner-fs-3.desktop +cinnamon-settings-daemon-automount.desktop cinnamon-settings-daemon-wacom.desktop nvidia-prime.desktop user-dirs-update-gtk.desktop +cinnamon-settings-daemon-background.desktop cinnamon-settings-daemon-xsettings.desktop onboard-autostart.desktop warpinator-autostart.desktop +cinnamon-settings-daemon-clipboard.desktop geoclue-demo-agent.desktop orca-autostart.desktop xapp-sn-watcher.desktop +cinnamon-settings-daemon-color.desktop gnome-keyring-pkcs11.desktop org.gnome.Evolution-alarm-notify.desktop xdg-user-dirs.desktop +cinnamon-settings-daemon-housekeeping.desktop gnome-keyring-secrets.desktop org.gnome.SettingsDaemon.DiskUtilityNotify.desktop +cinnamon-settings-daemon-keyboard.desktop gnome-keyring-ssh.desktop polkit-gnome-authentication-agent-1.desktop +cinnamon-settings-daemon-media-keys.desktop im-launch.desktop polkit-mate-authentication-agent-1.desktop +]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ nano /etc/xdg/autostart/xwWXwayland-session.d/00- +00-at-spi 00-pulseaudio-x11 +]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ nano /etc/xdg/Xwayland-session.d/00-at-spi  +cam.png enter.png hand.png key_defs.xml people.png scripts/ typescript Whiteboard.onboard +chat.png exit.png Keyboard.py micro.png quit.png script.sh Whiteboard-Alpha.svg +]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ nano /etc/xdg/Xwayland-session.d/00-at-spi  +Display all 257 possibilities? (y or n) +]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ nano /etc/ +Display all 257 possibilities? (y or n) +]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ nano /etc/xdg/ +autostart/ menus/ systemd/ user-dirs.conf user-dirs.defaults xdg-default/ xdg-default.desktop/ xdg-xfce/ Xwayland-session.d/ +]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ nano /etc/xdg/zuautostart/ +at-spi-dbus-bus.desktop cinnamon-settings-daemon-power.desktop mintreport.desktop print-applet.desktop +blueman.desktop cinnamon-settings-daemon-print-notifications.desktop mintupdate.desktop pulseaudio.desktop +caribou-autostart.desktop cinnamon-settings-daemon-screensaver-proxy.desktop mintwelcome.desktop sticky.desktop +cinnamon-settings-daemon-a11y-settings.desktop cinnamon-settings-daemon-smartcard.desktop nm-applet.desktop tracker-miner-fs-3.desktop +cinnamon-settings-daemon-automount.desktop cinnamon-settings-daemon-wacom.desktop nvidia-prime.desktop user-dirs-update-gtk.desktop +cinnamon-settings-daemon-background.desktop cinnamon-settings-daemon-xsettings.desktop onboard-autostart.desktop warpinator-autostart.desktop +cinnamon-settings-daemon-clipboard.desktop geoclue-demo-agent.desktop orca-autostart.desktop xapp-sn-watcher.desktop +cinnamon-settings-daemon-color.desktop gnome-keyring-pkcs11.desktop org.gnome.Evolution-alarm-notify.desktop xdg-user-dirs.desktop +cinnamon-settings-daemon-housekeeping.desktop gnome-keyring-secrets.desktop org.gnome.SettingsDaemon.DiskUtilityNotify.desktop +cinnamon-settings-daemon-keyboard.desktop gnome-keyring-ssh.desktop polkit-gnome-authentication-agent-1.desktop +cinnamon-settings-daemon-media-keys.desktop im-launch.desktop polkit-mate-authentication-agent-1.desktop +]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ nano /etc/xdg/autostart/sudo nano btconnect.shlsssh pi2@192.168.10.201pi +[?2004l pi2@192.168.10.201's password: +Linux raspberrypi 6.1.21-v8+ #1642 SMP PREEMPT Mon Apr 3 17:24:16 BST 2023 aarch64 + +The programs included with the Debian GNU/Linux system are free software; +the exact distribution terms for each program are described in the +individual files in /usr/share/doc/*/copyright. + +Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent +permitted by applicable law. +Last login: Fri Jun 16 11:24:42 2023 from 192.168.10.240 + +Wi-Fi is currently blocked by rfkill. +Use raspi-config to set the country before use. + +[?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ sduudo nano ./usr/libb/opypy +pypy/ python2.7/ python3/ python3.9/ +]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ sudo nano /usr/lib/python3/dist-packages/onboard-1.4.1.egg-info Onboard/shdare/onboard/scripts/brt +btconnect.sh btJabra.py __pycache__/ quitter.py refreshPage.sh sokSettings.py +]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ sudo nano /usr/share/onboard/scripts/btJabra.py +[?2004l [?2004h[?1049h(B[?7h[?1h=[?1h=[?25l(B(B[ Lecture... ](B(B[ Lecture de 25 lignes ](B(B GNU nano 5.4 /usr/share/onboard/scripts/btJabra.py (B (B^G(B Aide(B^O(B Écrire(B^W(B Chercher(B^K(B Couper(B^T(B Exécuter(B^C(B Emplacement (BM-U(B Annuler(BM-A(B Placer la marq(BM-](B -> Crochet (BM-Q(B Précédent (B^B(B En arrière (B^◀(B Mot précédent (B^A(B Début doc. (B^X(B Quitter(B^R(B Lire fich. (B^\(B Remplacer(B^U(B Coller(B^J(B Justifier(B^_(B Aller ligne (BM-E(B Refaire(BM-6(B Copier(B^Q(B Retrouver(BM-W(B Suivant(B^F(B En avant(B^▶(B Mot suivant (B^E(B Fin (B#!/usr/bin/python3 # Copyright © 2009 Chris Jones # Copyright © 2012-2013 marmuta ## This file is part of Onboard. ## Onboard is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 3 of the License, or # (at your option) any later version. ## Onboard is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. ## You should have received a copy of the GNU General Public License # along with this program. If not, see . (BPYTHON_EXECUTABLE = (B"python3" import(B subprocess (Bdef run(B():exit_code = subprocess.call((B'/usr/share/onboard/scripts/btconnect.sh'(B) [?12l[?25h[?25l[?12l[?25h[?25l(B[ ligne 1/26 (3%), col. 1/19 (5%), car. 0/916 (0%) ](B [?12l[?25h[?25l[?12l[?25h[?1049l [?1l>[?2004l[?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ sudo nano /usr/share/onboard/scripts/btJabra.py  +btconnect.sh btJabra.py __pycache__/ quitter.py refreshPage.sh sokSettings.py +]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ sudo nano /usr/share/onboard/scripts/ sudo nano /boot/config.txt +[?2004l [?2004h[?1049h(B[?7h[?1h=[?1h=[?25l(B(B[ Lecture... ](B(B[ Lecture de 84 lignes ](B(B GNU nano 5.4 /boot/config.txt (B (B^G(B Aide(B^O(B Écrire(B^W(B Chercher(B^K(B Couper(B^T(B Exécuter(B^C(B Emplacement (BM-U(B Annuler(BM-A(B Placer la marq(BM-](B -> Crochet (BM-Q(B Précédent (B^B(B En arrière (B^◀(B Mot précédent (B^A(B Début doc. (B^X(B Quitter(B^R(B Lire fich. (B^\(B Remplacer(B^U(B Coller(B^J(B Justifier(B^_(B Aller ligne (BM-E(B Refaire(BM-6(B Copier(B^Q(B Retrouver(BM-W(B Suivant(B^F(B En avant(B^▶(B Mot suivant (B^E(B Fin # For more options and information see # http://rpf.io/configtxt # Some settings may impact device functionality. See link above for details # uncomment if you get no picture on HDMI for a default "safe" mode #hdmi_safe=1 # uncomment the following to adjust overscan. Use positive numbers if console # goes off screen, and negative if there is too much border #overscan_left=16 #overscan_right=16 #overscan_top=16 #overscan_bottom=16 # uncomment to force a console size. By default it will be display's size minus # overscan. #framebuffer_width=1280 #framebuffer_height=720 # uncomment if hdmi display is not detected and composite is being output #hdmi_force_hotplug=1 # uncomment to force a specific HDMI mode (this will force VGA) #hdmi_group=1 #hdmi_mode=1 # uncomment to force a HDMI mode rather than DVI. This can make audio work in # DMT (computer monitor) modes #hdmi_drive=2 # uncomment to increase signal to HDMI, if you have interference, blanking, or # no display #config_hdmi_boost=4 # uncomment for composite PAL #sdtv_mode=2 #uncomment to overclock the arm. 700 MHz is the default. #arm_freq=800 # Uncomment some or all of these to enable the optional hardware interfaces #dtparam=i2c_arm=on #dtparam=i2s=on #dtparam=spi=on # Uncomment this to enable infrared communication. #dtoverlay=gpio-ir,gpio_pin=17 #dtoverlay=gpio-ir-tx,gpio_pin=18 # Additional overlays and parameters are documented /boot/overlays/README # Enable audio (loads snd_bcm2835) (Bdtparam=audio=on [?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l78 +[?12l[?25h[?25l78 +# Automatically load overlays for detected cameras (B[?12l[?25h[?25l78 +camera_auto_detect=1 [?12l[?25h[?25l78 +[?12l[?25h[?25l78 +# Automatically load overlays for detected DSI displays (B[?12l[?25h[?25l78 +display_auto_detect=1 [?12l[?25h[?25l78 +[?12l[?25h[?25l78 +# Enable DRM VC4 V3D driver (B[?12l[?25h[?25l78 +dtoverlay=vc4-kms-v3d [?12l[?25h[?25l78 +max_framebuffers=2 [?12l[?25h[?25l78 +[?12l[?25h[?25l78 +# Run in 64-bit mode (B[?12l[?25h[?25l78 +arm_64bit=1 [?12l[?25h[?25l78 +[?12l[?25h[?25l78 +# Disable compensation for displays with overscan (B[?12l[?25h[?25l78 +disable_overscan=1 [?12l[?25h[?25l78 +[?12l[?25h[?25l78 +(B[cm4] (B[?12l[?25h[?25l78 +# Enable host mode on the 2711 built-in XHCI USB controller. (B[?12l[?25h[?25l78 +# This line should be removed if the legacy DWC2 controller is required (B[?12l[?25h[?25l78 +# (e.g. for USB device mode) or if USB support is not required. (B[?12l[?25h[?25l78 +otg_mode=1 [?12l[?25h[?25l78 +[?12l[?25h[?25l78 +(B[all] (B[?12l[?25h[?25l78 +[?12l[?25h[?25l78 +(B[pi4] (B[?12l[?25h[?25l78 +# Run as fast as firmware / board allows (B[?12l[?25h[?25l78 +arm_boost=1 [?12l[?25h[?25l78 +[?12l[?25h[?25l78 +(B[all] (B[?12l[?25h[?25l78 +gpu_mem=128 [?12l[?25h[?25l78 +[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l(B*(B l[?12l[?25h[?25lc[?12l[?25h[?25ld[?12l[?25h[?25l_[?12l[?25h[?25ld[?12l[?25h[?25li[?12l[?25h[?25ls[?12l[?25h[?25lp[?12l[?25h[?25ll[?12l[?25h[?25la[?12l[?25h[?25ly[?12l[?25h[?25l=[?12l[?25h[?25l2[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l=2[?12l[?25h[?25l=2[?12l[?25h[?25l=2[?12l[?25h[?25l=2[?12l[?25h[?25l=2[?12l[?25h[?25l=2[?12l[?25h[?25l=2[?12l[?25h[?25lr=2[?12l[?25h[?25lo=2[?12l[?25h[?25lt=2[?12l[?25h[?25la=2[?12l[?25h[?25lt=2[?12l[?25h[?25le=2[?12l[?25h[?25l (BSauver l'espace modifié ?  O(B Oui (B N(B Non (B^C(B Annuler[?12l[?25h[?25l (B^G(B Aide(BM-D(B Format DOS(BM-A(B Ajout (à la fin)(BM-B(B Copie de sécu. (B^C(B Annuler (BM-M(B Format Mac(BM-P(B Ajout (au début)(B^T(B Parcourir (BNom du fichier à écrire: /boot/config.txt(B[?12l[?25h[?25l (B[ Écriture... ](B(B (B(B[ 85 lignes écrites ](B [?12l[?25h[?1049l [?1l>[?2004l[?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ sudo reboot +[?2004l Connection to 192.168.10.201 closed by remote host. +Connection to 192.168.10.201 closed. +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ cdls +[?2004l btJabra.py cam.png chat.png enter.png exit.png hand.png Keyboard.py key_defs.xml micro.png people.png quit.png scripts script.sh typescript Whiteboard-Alpha.svg Whiteboard.onboard +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ cd cd ^[[200~echo 'onboard &' /etc/xdg/lxsession/LXDE-pi/autostart~Documents/jitsiBox/btJabra.py +[?2004l onboard & /Documents/jitsiBox/btJabra.py +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ echo 'onboard &' /Documents/jitsiBox/btJabra.py [1@>[1@>[1@' +[?2004l bash: /Documents/jitsiBox/btJabra.py: Aucun fichier ou dossier de ce type +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ echo 'onboard &'>> /Documents/jitsiBox/btJabra.py  +[?2004l bash: /Documents/jitsiBox/btJabra.py: Aucun fichier ou dossier de ce type +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ echo 'onboard &'>>/Documents/jitsiBox/btJabra.py [1@~ +[?2004l [?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ echo 'onboard &'>>~/Documents/jitsiBox/btJabra.py [1@ lsssh pi2@192.168.10.201udo nano btconnect.shsh pi2@192.168.10.201 +[?2004l pi2@192.168.10.201's password: +Linux raspberrypi 6.1.21-v8+ #1642 SMP PREEMPT Mon Apr 3 17:24:16 BST 2023 aarch64 + +The programs included with the Debian GNU/Linux system are free software; +the exact distribution terms for each program are described in the +individual files in /usr/share/doc/*/copyright. + +Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent +permitted by applicable law. +Last login: Fri Jun 16 15:36:34 2023 + +Wi-Fi is currently blocked by rfkill. +Use raspi-config to set the country before use. + +[?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ echo 'onboard &'>>/etc/xdg/lxsession/LXDE-pi/autostart echo 'onboard &'>>/etc/xdg/lxsession/LXDE-pi/autostart +[?2004l -bash: /etc/xdg/lxsession/LXDE-pi/autostart: Permission non accordée +[?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ sudo echo 'onboard &'>>/etc/xdg/lxsession/LXDE-pi/autostart echo 'onboard &'>>/etc/xdg/lxsession/LXDE-pi/autostart +[?2004l -bash: /etc/xdg/lxsession/LXDE-pi/autostart: Permission non accordée +[?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ sudo chmod 777 echo 'onboard &'>>/etc/xdg/lxsession/LXDE-pi/autostart echo 'onboard &'>>/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart +[?2004l chmod: impossible d'accéder à 'echo': Aucun fichier ou dossier de ce type +[?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ sudo chmod 777 echo /etc/xdg/lxsession/LXDE-pi/autostart /etc/xdg/lxsession/LXDE-pi/autostart /etc/xdg/lxsession/LXDE-pi/autostart /etc/xdg/lxsession/LXDE-pi/autostart /etc/xdg/lxsession/LXDE-pi/autostart /etc/xdg/lxsession/LXDE-pi/autostart  +[?2004l [?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ sudo chmod 777 /etc/xdg/lxsession/LXDE-pi/autostartecho /etc/xdg/lxsession/LXDE-pi/autostart echo 'onboard &'>>/etc/xdg/lxsession/LXDE-pi/autostart  +[?2004l [?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ sucat echo 'onboard &'>>/etc/xdg/lxsession/LXDE-pi/autostart echo 'onboard &'>>/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart/etc/xdg/lxsession/LXDE-pi/autostart /etc/xdg/lxsession/LXDE-pi/autostart /etc/xdg/lxsession/LXDE-pi/autostart /etc/xdg/lxsession/LXDE-pi/autostart /etc/xdg/lxsession/LXDE-pi/autostart /etc/xdg/lxsession/LXDE-pi/autostart /etc/xdg/lxsession/LXDE-pi/autostart /etc/xdg/lxsession/LXDE-pi/autostart /etc/xdg/lxsession/LXDE-pi/autostart /etc/xdg/lxsession/LXDE-pi/autostart /etc/xdg/lxsession/LXDE-pi/autostart  +[?2004l @lxpanel --profile LXDE-pi +@pcmanfm --desktop --profile LXDE-pi +@xscreensaver -no-splash +chromium-browser --noerrdialogs --disable-translate --disable-infobars --disable-features=TranslateUI --disk-cache-dir=/dev/null --disable-pinch --overscroll-history-navigation=disabled --disable-features=TouchpadOverscrollHistoryNavigation talk.fdn.fr +onboard & +onboard & +[?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ sudo cat /etc/xdg/lxsession/LXDE-pi/autostart /etc/xdg/lxsession/LXDE-pi/autostart  /etc/xdg/lxsession/LXDE-pi/autostart  /etc/xdg/lxsession/LXDE-pi/autostart n /etc/xdg/lxsession/LXDE-pi/autostart a /etc/xdg/lxsession/LXDE-pi/autostart n /etc/xdg/lxsession/LXDE-pi/autostart o /etc/xdg/lxsession/LXDE-pi/autostart  +[?2004l [?2004h[?1049h(B[?7h[?1h=[?1h=[?25l(B(B[ Le répertoire « /etc/xdg/lxsession/LXDE-pi » n'est pas accessible en écriture ](B(B GNU nano 5.4 /etc/xdg/lxsession/LXDE-pi/autostart (B (B^G(B Aide(B^O(B Écrire(B^W(B Chercher(B^K(B Couper(B^T(B Exécuter(B^C(B Emplacement (BM-U(B Annuler(BM-A(B Placer la marq(BM-](B -> Crochet (BM-Q(B Précédent (B^B(B En arrière (B^◀(B Mot précédent (B^A(B Début doc. (B^X(B Quitter(B^R(B Lire fich. (B^\(B Remplacer(B^U(B Coller(B^J(B Justifier(B^_(B Aller ligne (BM-E(B Refaire(BM-6(B Copier(B^Q(B Retrouver(BM-W(B Suivant(B^F(B En avant(B^▶(B Mot suivant (B^E(B Fin @lxpanel --profile LXDE-pi @pcmanfm --desktop --profile LXDE-pi @xscreensaver -no-splash chromium-browser --noerrdialogs --disable-translate --disable-infobars --disable-features=TranslateUI --disk-cache-dir=/dev/null --disable-pinch --overscroll-history-navigation=disabled --disable-features=TouchpadOverscrollHistoryNavigat(B>(Bonboard & onboard & [?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l(B* (B [?12l[?25h[?25l[?12l[?25h[?25l [?12l[?25h[?25l [?12l[?25h[?25l [?12l[?25h[?25l [?12l[?25h[?25l [?12l[?25h[?25l [?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l (BSauver l'espace modifié ?  O(B Oui (B N(B Non (B^C(B Annuler[?12l[?25h[?25l (B^G(B Aide(BM-D(B Format DOS(BM-A(B Ajout (à la fin)(BM-B(B Copie de sécu. (B^C(B Annuler (BM-M(B Format Mac(BM-P(B Ajout (au début)(B^T(B Parcourir (BNom du fichier à écrire: /etc/xdg/lxsession/LXDE-pi/autostart(B[?12l[?25h[?25l (B[ Écriture... ](B(B (B(B[ 5 lignes écrites ](B [?12l[?25h[?1049l [?1l>[?2004l[?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ nano /etc/xdg/lxsession/LXDE-pi/autostart cat echo 'onboard &'>>/etc/xdg/lxsession/LXDE-pi/autostart sudo chmod 777 /etc/xdg/lxsession/LXDE-pi/autostartecho /etc/xdg/lxsession/LXDE-pi/autostart echo 'onboard &'>>/etc/xdg/lxsession/LXDE-pi/autostart  sudo rebootnano /boot/config.txt usr/share/onboard/scripts/boot/config.txt rebootecho 'onboard &'>>/etc/xdg/lxsession/LXDE-pi/autostart [5@sudo  chmod 777 echo /etc/xdg/lxsession/LXDE-pi/autostart /etc/xdg/lxsession/LXDE-pi/autostart echo 'onboard &'>>/etc/xdg/lxsession/LXDE-pi/autostart cat /etc/xdg/lxsession/LXDE-pi/autostart [1@nano nano /etc/xdg/lxsession/LXDE-pi/autostart cat echo 'onboard &'>>/etc/xdg/lxsession/LXDE-pi/autostart sudo chmod 777 /etc/xdg/lxsession/LXDE-pi/autostartecho /etc/xdg/lxsession/LXDE-pi/autostart echo 'onboard &'>>/etc/xdg/lxsession/LXDE-pi/autostart  sudo rebootnano /boot/config.txt usr/share/onboard/scripts/boot/config.txt +[?2004l [?2004h[?1049h(B[?7h[?1h=[?1h=[?25l(B(B[ Lecture... ](B(B[ Lecture de 85 lignes ](B(B GNU nano 5.4 /boot/config.txt (B (B^G(B Aide(B^O(B Écrire(B^W(B Chercher(B^K(B Couper(B^T(B Exécuter(B^C(B Emplacement (BM-U(B Annuler(BM-A(B Placer la marq(BM-](B -> Crochet (BM-Q(B Précédent (B^B(B En arrière (B^◀(B Mot précédent (B^A(B Début doc. (B^X(B Quitter(B^R(B Lire fich. (B^\(B Remplacer(B^U(B Coller(B^J(B Justifier(B^_(B Aller ligne (BM-E(B Refaire(BM-6(B Copier(B^Q(B Retrouver(BM-W(B Suivant(B^F(B En avant(B^▶(B Mot suivant (B^E(B Fin # For more options and information see # http://rpf.io/configtxt # Some settings may impact device functionality. See link above for details # uncomment if you get no picture on HDMI for a default "safe" mode #hdmi_safe=1 # uncomment the following to adjust overscan. Use positive numbers if console # goes off screen, and negative if there is too much border #overscan_left=16 #overscan_right=16 #overscan_top=16 #overscan_bottom=16 # uncomment to force a console size. By default it will be display's size minus # overscan. #framebuffer_width=1280 #framebuffer_height=720 # uncomment if hdmi display is not detected and composite is being output #hdmi_force_hotplug=1 # uncomment to force a specific HDMI mode (this will force VGA) #hdmi_group=1 #hdmi_mode=1 # uncomment to force a HDMI mode rather than DVI. This can make audio work in # DMT (computer monitor) modes #hdmi_drive=2 # uncomment to increase signal to HDMI, if you have interference, blanking, or # no display #config_hdmi_boost=4 # uncomment for composite PAL #sdtv_mode=2 #uncomment to overclock the arm. 700 MHz is the default. #arm_freq=800 # Uncomment some or all of these to enable the optional hardware interfaces #dtparam=i2c_arm=on #dtparam=i2s=on #dtparam=spi=on # Uncomment this to enable infrared communication. #dtoverlay=gpio-ir,gpio_pin=17 #dtoverlay=gpio-ir-tx,gpio_pin=18 # Additional overlays and parameters are documented /boot/overlays/README # Enable audio (loads snd_bcm2835) (Bdtparam=audio=on [?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l# Automatically load overlays for detected cameras (B[?12l[?25h[?25l78camera_auto_detect=1 # Automatically load overlays for detected DSI displays (Bdisplay_auto_detect=1 # Enable DRM VC4 V3D driver (Bdtoverlay=vc4-kms-v3d max_framebuffers=2 # Run in 64-bit mode (Barm_64bit=1 [?12l[?25h[?25l78# Disable compensation for displays with overscan (Bdisable_overscan=1 (B[cm4] (B# Enable host mode on the 2711 built-in XHCI USB controller. # This line should be removed if the legacy DWC2 controller is required # (e.g. for USB device mode) or if USB support is not required. (Botg_mode=1 (B[all] [pi4] (B[?12l[?25h[?25l78# Run as fast as firmware / board allows (Barm_boost=1 (B[all] (Bgpu_mem=128 lcd_rotate=2 [?12l[?25h[?25l78 +[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l(B*(B [?12l[?25h[?25l [?12l[?25h[?25l [?12l[?25h[?25l [?12l[?25h[?25l [?12l[?25h[?25l [?12l[?25h[?25l [?12l[?25h[?25l [?12l[?25h[?25l [?12l[?25h[?25l [?12l[?25h[?25l [?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25llcd_rotate=2[?12l[?25h[?25l (BSauver l'espace modifié ?  O(B Oui (B N(B Non (B^C(B Annuler[?12l[?25h[?25l (B^G(B Aide(BM-D(B Format DOS(BM-A(B Ajout (à la fin)(BM-B(B Copie de sécu. (B^C(B Annuler (BM-M(B Format Mac(BM-P(B Ajout (au début)(B^T(B Parcourir (BNom du fichier à écrire: /boot/config.txt(B[?12l[?25h[?25l (B[ Écriture... ](B(B (B(B[ 85 lignes écrites ](B [?12l[?25h[?1049l [?1l>[?2004l[?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ sudo reboot +[?2004l Connection to 192.168.10.201 closed by remote host. +Connection to 192.168.10.201 closed. +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ ssh pi2@192.168.10.201 +[?2004l pi2@192.168.10.201's password: +Linux raspberrypi 6.1.21-v8+ #1642 SMP PREEMPT Mon Apr 3 17:24:16 BST 2023 aarch64 + +The programs included with the Debian GNU/Linux system are free software; +the exact distribution terms for each program are described in the +individual files in /usr/share/doc/*/copyright. + +Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent +permitted by applicable law. +Last login: Fri Jun 16 16:08:43 2023 + +Wi-Fi is currently blocked by rfkill. +Use raspi-config to set the country before use. + +[?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ sudo rebootnano /boot/config.txt +[?2004l [?2004h[?1049h(B[?7h[?1h=[?1h=[?25l(B(B[ Lecture... ](B(B[ Lecture de 85 lignes ](B(B GNU nano 5.4 /boot/config.txt (B (B^G(B Aide(B^O(B Écrire(B^W(B Chercher(B^K(B Couper(B^T(B Exécuter(B^C(B Emplacement (BM-U(B Annuler(BM-A(B Placer la marq(BM-](B -> Crochet (BM-Q(B Précédent (B^B(B En arrière (B^◀(B Mot précédent (B^A(B Début doc. (B^X(B Quitter(B^R(B Lire fich. (B^\(B Remplacer(B^U(B Coller(B^J(B Justifier(B^_(B Aller ligne (BM-E(B Refaire(BM-6(B Copier(B^Q(B Retrouver(BM-W(B Suivant(B^F(B En avant(B^▶(B Mot suivant (B^E(B Fin # For more options and information see # http://rpf.io/configtxt # Some settings may impact device functionality. See link above for details # uncomment if you get no picture on HDMI for a default "safe" mode #hdmi_safe=1 # uncomment the following to adjust overscan. Use positive numbers if console # goes off screen, and negative if there is too much border #overscan_left=16 #overscan_right=16 #overscan_top=16 #overscan_bottom=16 # uncomment to force a console size. By default it will be display's size minus # overscan. #framebuffer_width=1280 #framebuffer_height=720 # uncomment if hdmi display is not detected and composite is being output #hdmi_force_hotplug=1 # uncomment to force a specific HDMI mode (this will force VGA) #hdmi_group=1 #hdmi_mode=1 # uncomment to force a HDMI mode rather than DVI. This can make audio work in # DMT (computer monitor) modes #hdmi_drive=2 # uncomment to increase signal to HDMI, if you have interference, blanking, or # no display #config_hdmi_boost=4 # uncomment for composite PAL #sdtv_mode=2 #uncomment to overclock the arm. 700 MHz is the default. #arm_freq=800 # Uncomment some or all of these to enable the optional hardware interfaces #dtparam=i2c_arm=on #dtparam=i2s=on #dtparam=spi=on # Uncomment this to enable infrared communication. #dtoverlay=gpio-ir,gpio_pin=17 #dtoverlay=gpio-ir-tx,gpio_pin=18 # Additional overlays and parameters are documented /boot/overlays/README # Enable audio (loads snd_bcm2835) (Bdtparam=audio=on [?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l# Automatically load overlays for detected cameras (B[?12l[?25h[?25l78camera_auto_detect=1 # Automatically load overlays for detected DSI displays (Bdisplay_auto_detect=1 lcd_rotate=2 # Enable DRM VC4 V3D driver (B[?12l[?25h[?25l78dtoverlay=vc4-kms-v3d max_framebuffers=2 # Run in 64-bit mode (Barm_64bit=1 [?12l[?25h[?25l78# Disable compensation for displays with overscan (Bdisable_overscan=1 (B[cm4] (B# Enable host mode on the 2711 built-in XHCI USB controller. # This line should be removed if the legacy DWC2 controller is required # (e.g. for USB device mode) or if USB support is not required. (Botg_mode=1 (B[all] [pi4] (B[?12l[?25h[?25l78# Run as fast as firmware / board allows (Barm_boost=1 (B[all] (Bgpu_mem=128 [?12l[?25h[?25l78 +[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l(B*(B [?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25late=2 [?12l[?25h[?25lte=2 [?12l[?25h[?25le=2 [?12l[?25h[?25l=2 [?12l[?25h[?25l2[?12l[?25h[?25l2[?12l[?25h[?25l +# Enable DRM VC4 V3D driver 2[?12l[?25h[?25l# Enable DRM VC4 V3D driver(B [?12l[?25h[?25l78M[?12l[?25h[?25l[?12l[?25h[?25ldtoverlay=rpi-ft5406,touchscreen-swapped-x-y=1,touchscreen-inverted-x=1[?12l[?25h[?25l (BSauver l'espace modifié ?  O(B Oui (B N(B Non (B^C(B Annuler[?12l[?25h[?25l (B^G(B Aide(BM-D(B Format DOS(BM-A(B Ajout (à la fin)(BM-B(B Copie de sécu. (B^C(B Annuler (BM-M(B Format Mac(BM-P(B Ajout (au début)(B^T(B Parcourir (BNom du fichier à écrire: /boot/config.txt(B[?12l[?25h[?25l (B[ Écriture... ](B(B (B(B[ 85 lignes écrites ](B [?12l[?25h[?1049l [?1l>[?2004l[?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ sudo reboot +[?2004l Connection to 192.168.10.201 closed by remote host. +Connection to 192.168.10.201 closed. +[?2004h]0;kenzo@astrolabe-Latitude: ~/Documents/jitsiBoxkenzo@astrolabe-Latitude:~/Documents/jitsiBox$ ssh pi2@192.168.10.201 +[?2004l pi2@192.168.10.201's password: +Linux raspberrypi 6.1.21-v8+ #1642 SMP PREEMPT Mon Apr 3 17:24:16 BST 2023 aarch64 + +The programs included with the Debian GNU/Linux system are free software; +the exact distribution terms for each program are described in the +individual files in /usr/share/doc/*/copyright. + +Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent +permitted by applicable law. +Last login: Fri Jun 16 16:10:38 2023 + +Wi-Fi is currently blocked by rfkill. +Use raspi-config to set the country before use. + +[?2004h]0;pi2@raspberrypi: ~pi2@raspberrypi:~ $ sudo rebootnano /boot/config.txt +[?2004l [?2004h[?1049h(B[?7h[?1h=[?1h=[?25l(B(B[ Lecture... ](B(B[ Lecture de 85 lignes ](B(B GNU nano 5.4 /boot/config.txt (B (B^G(B Aide(B^O(B Écrire(B^W(B Chercher(B^K(B Couper(B^T(B Exécuter(B^C(B Emplacement (BM-U(B Annuler(BM-A(B Placer la marq(BM-](B -> Crochet (BM-Q(B Précédent (B^B(B En arrière (B^◀(B Mot précédent (B^A(B Début doc. (B^X(B Quitter(B^R(B Lire fich. (B^\(B Remplacer(B^U(B Coller(B^J(B Justifier(B^_(B Aller ligne (BM-E(B Refaire(BM-6(B Copier(B^Q(B Retrouver(BM-W(B Suivant(B^F(B En avant(B^▶(B Mot suivant (B^E(B Fin # For more options and information see # http://rpf.io/configtxt # Some settings may impact device functionality. See link above for details # uncomment if you get no picture on HDMI for a default "safe" mode #hdmi_safe=1 # uncomment the following to adjust overscan. Use positive numbers if console # goes off screen, and negative if there is too much border #overscan_left=16 #overscan_right=16 #overscan_top=16 #overscan_bottom=16 # uncomment to force a console size. By default it will be display's size minus # overscan. #framebuffer_width=1280 #framebuffer_height=720 # uncomment if hdmi display is not detected and composite is being output #hdmi_force_hotplug=1 # uncomment to force a specific HDMI mode (this will force VGA) #hdmi_group=1 #hdmi_mode=1 # uncomment to force a HDMI mode rather than DVI. This can make audio work in # DMT (computer monitor) modes #hdmi_drive=2 # uncomment to increase signal to HDMI, if you have interference, blanking, or # no display #config_hdmi_boost=4 # uncomment for composite PAL #sdtv_mode=2 #uncomment to overclock the arm. 700 MHz is the default. #arm_freq=800 # Uncomment some or all of these to enable the optional hardware interfaces #dtparam=i2c_arm=on #dtparam=i2s=on #dtparam=spi=on # Uncomment this to enable infrared communication. #dtoverlay=gpio-ir,gpio_pin=17 #dtoverlay=gpio-ir-tx,gpio_pin=18 # Additional overlays and parameters are documented /boot/overlays/README # Enable audio (loads snd_bcm2835) (Bdtparam=audio=on [?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l# Automatically load overlays for detected cameras (B[?12l[?25h[?25l78camera_auto_detect=1 # Automatically load overlays for detected DSI displays (Bdisplay_auto_detect=1 dtoverlay=rpi-ft5406,touchscreen-swapped-x-y=1,touchscreen-inverted-x=1 # Enable DRM VC4 V3D driver (B[?12l[?25h[?25l78dtoverlay=vc4-kms-v3d max_framebuffers=2 # Run in 64-bit mode (Barm_64bit=1 [?12l[?25h[?25l78# Disable compensation for displays with overscan (Bdisable_overscan=1 (B[cm4] (B# Enable host mode on the 2711 built-in XHCI USB controller. # This line should be removed if the legacy DWC2 controller is required (B[?12l[?25h[?25l78# (e.g. for USB device mode) or if USB support is not required. (Botg_mode=1 (B[all] [pi4] (B[?12l[?25h[?25l78# Run as fast as firmware / board allows (Barm_boost=1 (B[all] (Bgpu_mem=128 [?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?25l[?12l[?25h[?2 \ No newline at end of file