menu default
Archivo para definir las configuraciones de la instalacion:
# Configuración básica del instalador
d-i debian-installer/locale string es_ES
d-i console-setup/ask_detect boolean false
d-i keyboard-configuration/layoutcode string es
d-i netcfg/get_hostname string mint
d-i netcfg/get_domain string localdomain
d-i time/zone string Europe/Madrid
d-i clock-setup/utc boolean true
# Configuración de particionado automático (Funciona correctamente, no la modificamos)
d-i partman-auto/disk string /dev/sda
d-i partman-lvm/device_remove_lvm boolean true
d-i partman-md/device_remove_md boolean true
d-i partman-auto/init_automatically_partition select Guided - use entire disk
d-i partman-auto/choose_recipe select all-in-one # Puedes mantener 'home' si prefieres esa receta
d-i partman/confirm boolean true
d-i partman/confirm_nooverwrite boolean true
d-i partman/confirm_write_new_label boolean true
d-i partman-auto/method string regular
d-i partman-auto/choose_recipe select atomic # Esta línea es importante para la selección automática
ubiquity partman_auto_config/text boolean true
ubiquity partman_auto_config/select_target boolean true
ubiquity partman_auto_config/confirm boolean true
d-i partman/choose_partition select finish
d-i partman/confirm boolean true
# Configuración de usuario
d-i passwd/user-fullname string alumno
d-i passwd/username string alumno
d-i passwd/user-password password alumno
d-i passwd/user-password-again password alumno
# Configuración del cargador de arranque (GRUB)
d-i grub-installer/only_debian boolean true
# Finalización de la instalación
d-i finish-install/reboot_in_progress note
d-i debconf/frontend string noninteractive # Mantiene el instalador en modo no interactivo
d-i debconf/priority critical # Forzar la prioridad a critical aquí también
# Configuración de repositorios y paquetes
d-i apt-setup/restricted boolean true
d-i apt-setup/universe boolean true
d-i apt-setup/multiverse boolean true
d-i apt-setup/partner boolean true
d-i apt-setup/security_updates boolean true
d-i apt-setup/proposed_updates boolean false
d-i apt-setup/backports boolean false
d-i pkgsel/install-language-support boolean false
# Incluimos los códecs explícitamente.
d-i pkgsel/include string openssh-server build-essential htop vim curl wget software-properties-common apt-transport-https ubuntu-restricted-extras
d-i pkgsel/upgrade select full-upgrade
# Configuración de Ubiquity (para el instalador de Ubuntu/Mint)
ubiquity automatic boolean true
ubiquity frontend gtk
ubiquity languagechooser/enabled boolean false
ubiquity languagechooser/ask boolean false
ubiquity debconf priority=critical
# Las siguientes líneas son CRUCIALES para evitar la pregunta de software de terceros/códecs
ubiquity ubiquity/skip_nonfree boolean true
ubiquity ubiquity/nonfree_packages string ubuntu-restricted-extras
ubiquity ubiquity/ask_nonfree boolean false
ubiquity ubiquity/ask_nonfree_mirror boolean false
ubiquity ubiquity/disable_hooks boolean true # Esto puede ayudar a evitar algunos diálogos
# Comando final (late_command) después de la instalación principal
# Esta sección es nuestra última garantía de que los códecs se instalen.
d-i preseed/late_command string \
in-target sh -c ' \
# Asegurar que las selecciones de debconf para ubiquity se apliquen \
echo "ubiquity ubiquity/nonfree_packages string ubuntu-restricted-extras" | debconf-set-selections; \
echo "ubiquity ubiquity/skip_nonfree boolean true" | debconf-set-selections; \
\
# Forzar la actualización de los repositorios y la instalación de los códecs multimedia \
apt-get update; \
DEBIAN_FRONTEND=noninteractive apt-get -y install ubuntu-restricted-extras; \
\
sync; \
reboot;'
Para definir el arranque i la ubicacion de el archivo preseed:
Para definir el arranque i la ubucacion de el archivo preseed:
Para definir el temporizador de el menu de instalacion:
Para definir la seleccion por defecto:
Script de INSTALL OR UNINSTALL
#!/bin/bash
# ----------------------------------------------------------------------------
# Script: install-and-uninstall.sh
# Descripción:
# - Gestiona la instalación y desinstalación de paquetes mediante menús
# organizados en categorías y subcategorías (usando solo echo/read).
# - Las listas de paquetes para instalación están extendidas, y al seleccionar
# un paquete se muestra una descripción breve y se pregunta al usuario si
# está seguro de proceder.
# - La categoría "Externos" se maneja con procedimientos especiales en la instalación,
# mientras que en la desinstalación se descarta.
# ----------------------------------------------------------------------------
# -------------------------------------
# Definición de colores ANSI (más variedad)
# -------------------------------------
GREEN='\033[0;32m'
RED='\033[0;31m'
YELLOW='\033[0;33m'
BLUE='\033[0;34m'
MAGENTA='\033[0;35m'
CYAN='\033[0;36m'
NC='\033[0m' # Sin color
# ----------------------------------------------------------------------------
# Creación del archivo .desktop global y su copia en los escritorios
# ----------------------------------------------------------------------------
DESKTOP_FILE="/usr/share/applications/gestor-paquetes.desktop"
self_path=$(readlink -f "$0")
echo -e "${BLUE}Creando archivo .desktop global...${NC}"
if [ "$(id -u)" -eq 0 ]; then
cat <<EOF > "$DESKTOP_FILE"
[Desktop Entry]
Version=1.0
Type=Application
Name=Gestor de Paquetes
Comment=Ejecuta el script de instalación/desinstalación de paquetes
Exec=$self_path
Icon=utilities-terminal
Terminal=true
EOF
else
echo -e "${YELLOW}Se requieren permisos de root para crear el .desktop. Solicitando elevación...${NC}"
sudo bash -c "cat <<EOF > $DESKTOP_FILE
[Desktop Entry]
Version=1.0
Type=Application
Name=Gestor de Paquetes
Comment=Ejecuta el script de instalación/desinstalación de paquetes
Exec=$self_path
Icon=utilities-terminal
Terminal=true
EOF"
fi
echo -e "${GREEN}Archivo .desktop creado/actualizado en: $DESKTOP_FILE${NC}"
desktop_dir="$(xdg-user-dir DESKTOP 2>/dev/null)"
if [ -z "$desktop_dir" ]; then
desktop_dir="$HOME/Desktop"
fi
if [ -d "$desktop_dir" ]; then
cp "$DESKTOP_FILE" "$desktop_dir/"
echo -e "${GREEN}Acceso directo copiado al escritorio del usuario actual: $desktop_dir${NC}"
else
echo -e "${YELLOW}No se encontró el directorio de escritorio para el usuario actual.${NC}"
fi
for user_home in /home/*; do
if [ -d "$user_home" ]; then
if [ -d "$user_home/Desktop" ]; then
sudo cp "$DESKTOP_FILE" "$user_home/Desktop/"
echo -e "${CYAN}Acceso directo copiado en: $user_home/Desktop${NC}"
elif [ -d "$user_home/Escritorio" ]; then
sudo cp "$DESKTOP_FILE" "$user_home/Escritorio/"
echo -e "${CYAN}Acceso directo copiado en: $user_home/Escritorio${NC}"
fi
fi
done
# ----------------------------------------------------------------------------
# Funciones de apoyo para sugerir correcciones en nombres
# ----------------------------------------------------------------------------
filtrar_paquete() {
local input="$1"
shift
local lista=("$@")
local suggestions=()
for pkg in "${lista[@]}"; do
if [[ "${pkg,,}" == *"${input,,}"* ]]; then
suggestions+=("$pkg")
fi
done
echo "${suggestions[@]}"
}
verificar_paquete() {
local input="$1"
shift
local lista=("$@")
local found=0
for pkg in "${lista[@]}"; do
if [[ "${pkg,,}" == "${input,,}" ]]; then
found=1
break
fi
done
if [ $found -eq 0 ]; then
suggestions=( $(filtrar_paquete "$input" "${lista[@]}") )
if [ ${#suggestions[@]} -gt 0 ]; then
echo -e "${YELLOW}No se encontró \"$input\" exactamente. Quizás quisiste decir:${NC}"
local index=1
for s in "${suggestions[@]}"; do
echo -e " $index) $s"
((index++))
done
read -p "Elige la opción (ingresa el número) o escribe nuevamente el nombre: " resp
if [[ "$resp" =~ ^[0-9]+$ ]]; then
input=${suggestions[$((resp-1))]}
else
input="$resp"
fi
else
echo -e "${YELLOW}No se encontraron sugerencias para '$input'. Se usará la entrada tal cual.${NC}"
fi
fi
echo "$input"
}
# ----------------------------------------------------------------------------
# Configuración de categorías para INSTALACIÓN (listas extendidas)
# ----------------------------------------------------------------------------
declare -A categorias
# Categoría Herramientas
categorias["Herramientas"]="Edición Texto|nano vim emacs neovim kate mousepad gedit leafpad pluma geany sublime-text atom micro pico mc ranger nemo thunar
Monitoreo|htop glances atop iotop sysstat conky nmon bmon iftop nload vnstat iptraf nethogs ifstat"
# Categoría Desarrollo
categorias["Desarrollo"]="Lenguajes|python3 gcc g++ nodejs npm ruby rails perl lua go rust swift php tcl java openjdk mono fortran ocaml clojure elixir r scala kotlin c cpp haskell erlang dart crystal nim
Control de versiones|git svn mercurial bazaar fossil cvs darcs git-lfs"
# Categoría Redes
categorias["Redes"]="Utilidades|net-tools traceroute iproute2 dnsutils iftop tcpdump mtr tcptraceroute curl wget arp-scan iperf iperf3 speedtest-cli
Seguridad|nmap openssh-client fail2ban ufw wireshark aircrack-ng john hydra sqlmap netcat tor proxychains snort iptables"
# Categoría Multimedia
categorias["Multimedia"]="Audio|audacity vlc sox pulseaudio lame ffmpeg mplayer mpv rhythmbox cmus audacious qtractor hydrogen mixxx jack LMMS ardour
Imagen|gimp inkscape krita darktable blender rawtherapee shotwell digiKam pinta nomacs imagemagick feh sxiv gThumb geeqie"
# Categoría Externos (procedimientos especiales)
categorias["Externos"]="Software Externo|google-chrome-stable code slack spotify zoom discord opera"
# ----------------------------------------------------------------------------
# Array asociativo con descripciones para cada paquete
# ----------------------------------------------------------------------------
declare -A descripciones
# Herramientas - Edición Texto
descripciones["nano"]="Nano: Editor de texto básico, ideal para principiantes."
descripciones["vim"]="Vim: Editor de texto avanzado y altamente configurable basado en vi."
descripciones["emacs"]="Emacs: Editor extensible con múltiples funciones y plugins."
descripciones["neovim"]="Neovim: Versión modernizada de Vim con mejoras en usabilidad."
descripciones["kate"]="Kate: Editor gráfico con resaltado de sintaxis y múltiples pestañas."
descripciones["mousepad"]="Mousepad: Editor de texto simple y ligero para entornos gráficos."
descripciones["gedit"]="Gedit: Editor predeterminado en GNOME, intuitivo y eficaz."
descripciones["leafpad"]="Leafpad: Editor minimalista y rápido, ideal para tareas simples."
descripciones["pluma"]="Pluma: Editor sencillo del entorno MATE."
descripciones["geany"]="Geany: Editor y entorno de desarrollo ligero y rápido."
descripciones["sublime-text"]="Sublime Text: Editor elegante y potente con soporte de plugins."
descripciones["atom"]="Atom: Editor hackeable para el siglo XXI, altamente personalizable."
descripciones["micro"]="Micro: Editor moderno de terminal con una experiencia intuitiva."
descripciones["pico"]="Pico: Editor básico, parte del conjunto Pine."
descripciones["mc"]="Midnight Commander: Gestor de archivos en modo texto con interfaz dual."
descripciones["ranger"]="Ranger: Gestor de archivos en terminal con vista en miniatura."
descripciones["nemo"]="Nemo: Gestor de archivos para Cinnamon, rápido y eficiente."
descripciones["thunar"]="Thunar: Gestor de archivos ligero utilizado en XFCE."
# Herramientas - Monitoreo
descripciones["htop"]="htop: Monitor de procesos interactivo, con efectos visuales y opciones de gestión."
descripciones["glances"]="Glances: Herramienta de monitoreo en tiempo real que muestra el status del sistema."
descripciones["atop"]="atop: Avanzado monitor de sistema que registra estadísticas de procesos."
descripciones["sysstat"]="sysstat: Colección de herramientas para monitoreo del rendimiento."
descripciones["conky"]="Conky: Monitor personalizable que muestra información del sistema en el escritorio."
descripciones["nmon"]="nmon: Monitor de rendimiento en tiempo real que muestra datos del sistema."
descripciones["bmon"]="bmon: Monitor de ancho de banda con representación gráfica en terminal."
descripciones["iftop"]="iftop: Visualiza en tiempo real el tráfico de red por conexión."
descripciones["nload"]="nload: Muestra la velocidad de subida y bajada de las interfaces de red."
descripciones["vnstat"]="vnStat: Registra estadísticas históricas de tráfico de red."
descripciones["iptraf"]="iptraf: Monitor en tiempo real basado en terminal para tráfico de red."
descripciones["nethogs"]="nethogs: Muestra el uso de red por proceso, ideal para detectar cuellos de botella."
descripciones["ifstat"]="ifstat: Mide el rendimiento de las interfaces de red continuamente."
# Desarrollo - Lenguajes
descripciones["python3"]="Python3: Lenguaje interpretado ampliamente usado para scripting, web, y ciencia de datos."
descripciones["gcc"]="GCC: El compilador estándar para lenguajes C y C++ en Linux."
descripciones["g++"]="G++: Complemento de GCC específico para programas en C++."
descripciones["nodejs"]="Node.js: Entorno para ejecutar JavaScript en el servidor."
descripciones["npm"]="npm: Gestor de paquetes para Node.js, esencial en el ecosistema JavaScript."
descripciones["ruby"]="Ruby: Lenguaje dinámico, muy conocido por su framework Rails."
descripciones["rails"]="Ruby on Rails: Framework web que facilita el desarrollo rápido de aplicaciones."
descripciones["perl"]="Perl: Lenguaje orientado a texto, usado en administración y scripting."
descripciones["lua"]="Lua: Lenguaje de scripting ligero, ideal para aplicaciones embebidas."
descripciones["go"]="Go: Lenguaje desarrollado por Google, orientado a sistemas concurrentes."
descripciones["rust"]="Rust: Lenguaje moderno enfocado en la seguridad y el rendimiento."
descripciones["swift"]="Swift: Lenguaje de Apple para desarrollar aplicaciones en iOS y macOS."
descripciones["php"]="PHP: Lenguaje de scripting ampliamente usado para el desarrollo web."
descripciones["tcl"]="Tcl: Lenguaje sencillo de scripting, utilizado en automatización."
descripciones["java"]="Java: Potente lenguaje orientado a objetos, común en aplicaciones empresariales."
descripciones["openjdk"]="OpenJDK: Implementación open source del SDK de Java."
descripciones["mono"]="Mono: Permite ejecutar aplicaciones .NET en Linux."
descripciones["fortran"]="Fortran: Lenguaje veterano enfocado en cálculos científicos."
descripciones["ocaml"]="OCaml: Lenguaje funcional con soporte de programación imperativa."
descripciones["clojure"]="Clojure: Lenguaje de la familia Lisp, óptimo para la programación concurrente."
descripciones["elixir"]="Elixir: Lenguaje funcional y concurrente basado en Erlang."
descripciones["r"]="R: Lenguaje especializado en análisis estadístico y gráficos."
descripciones["scala"]="Scala: Combina programación funcional y orientada a objetos sobre la JVM."
descripciones["kotlin"]="Kotlin: Lenguaje moderno para la JVM, muy popular en desarrollo Android."
descripciones["c"]="C: Lenguaje clásico de bajo nivel, esencial en sistemas operativos."
descripciones["cpp"]="C++: Extensión de C con soporte para la programación orientada a objetos."
descripciones["haskell"]="Haskell: Lenguaje puramente funcional, con tipado fuerte e inferencia automática."
descripciones["erlang"]="Erlang: Diseñado para sistemas de alta concurrencia y tolerancia a fallos."
descripciones["dart"]="Dart: Lenguaje de Google, optimizado para el desarrollo web y móvil (Flutter)."
descripciones["crystal"]="Crystal: Lenguaje compilado con sintaxis similar a Ruby y rendimiento cercano a C."
descripciones["nim"]="Nim: Lenguaje que ofrece balance entre eficiencia y facilidad de uso."
# Desarrollo - Control de versiones
descripciones["git"]="Git: Sistema de versionado distribuido, estándar en el desarrollo moderno."
descripciones["svn"]="SVN: Sistema centralizado de control de versiones, usado en proyectos legacy."
descripciones["mercurial"]="Mercurial: Sistema de versionado distribuido, elegante y simple."
descripciones["bazaar"]="Bazaar: Sistema distribuido enfocado en facilidad y flexibilidad."
descripciones["fossil"]="Fossil: Sistema de versiones integrado con seguimiento de bugs y wiki."
descripciones["cvs"]="CVS: Uno de los primeros sistemas de control de versiones colaborativo."
descripciones["darcs"]="Darcs: Sistema de control de versiones basado en parches, único en su enfoque."
descripciones["git-lfs"]="Git LFS: Extensión para Git que gestiona archivos grandes de manera eficiente."
# Redes - Utilidades
descripciones["net-tools"]="net-tools: Conjunto de utilidades básicas para la administración de red."
descripciones["traceroute"]="traceroute: Determina la ruta y el retardo de paquetes en la red."
descripciones["iproute2"]="iproute2: Herramientas modernas para administración de red en Linux."
descripciones["dnsutils"]="dnsutils: Conjunto de utilidades para diagnosticar y resolver DNS."
descripciones["iftop"]="iftop: Monitor en tiempo real del tráfico de red por conexión."
descripciones["tcpdump"]="tcpdump: Captura y muestra paquetes de red para su análisis."
descripciones["mtr"]="mtr: Combina traceroute y ping para diagnosticar problemas de red."
descripciones["tcptraceroute"]="tcptraceroute: Variante de traceroute utilizando TCP en lugar de ICMP."
descripciones["curl"]="curl: Herramienta para transferir datos con URL, versátil y robusta."
descripciones["wget"]="wget: Herramienta de descarga de archivos desde la web, ideal para scripts."
descripciones["arp-scan"]="arp-scan: Descubre dispositivos en la red mediante ARP."
descripciones["iperf"]="iperf: Herramienta para medir el rendimiento del ancho de banda de la red."
descripciones["iperf3"]="iperf3: Versión mejorada y actualizada de iperf."
descripciones["speedtest-cli"]="speedtest-cli: Realiza pruebas de velocidad de conexión desde la terminal."
# Redes - Seguridad
descripciones["nmap"]="nmap: Escáner de redes y auditor de seguridad ampliamente utilizado."
descripciones["openssh-client"]="openssh-client: Permite conexiones seguras a través de SSH."
descripciones["fail2ban"]="fail2ban: Previene ataques automatizados bloqueando IPs sospechosas."
descripciones["ufw"]="ufw: Interfaz amigable para configurar el firewall en Ubuntu."
descripciones["wireshark"]="wireshark: Analizador de protocolos de red con interfaz gráfica y filtros potentes."
descripciones["aircrack-ng"]="aircrack-ng: Suite de herramientas para evaluar la seguridad en redes inalámbricas."
descripciones["john"]="John the Ripper: Herramienta de cracking de contraseñas para evaluaciones de seguridad."
descripciones["hydra"]="Hydra: Realiza ataques de fuerza bruta contra múltiples protocolos de red."
descripciones["sqlmap"]="sqlmap: Automatiza la detección y explotación de inyecciones SQL."
descripciones["netcat"]="netcat: Herramienta de red para conexión y transferencia de datos de forma sencilla."
descripciones["tor"]="Tor: Red de anonimato que permite navegar y comunicarse de forma privada."
descripciones["proxychains"]="proxychains: Redirige la conexión de aplicaciones a través de proxies."
descripciones["snort"]="snort: Sistema de detección y prevención de intrusiones en la red."
descripciones["iptables"]="iptables: Herramienta de filtrado y gestión de tráfico en Linux."
# Multimedia - Audio
descripciones["audacity"]="Audacity: Editor y grabador de audio de código abierto, ideal para edición musical."
descripciones["vlc"]="VLC: Reproductor multimedia versátil que reproduce casi cualquier formato."
descripciones["sox"]="SoX: Herramienta de conversión y procesamiento de audio desde la línea de comandos."
descripciones["pulseaudio"]="PulseAudio: Servidor de sonido moderno y flexible para Linux."
descripciones["lame"]="LAME: Codificador MP3 de alta calidad y ampliamente usado."
descripciones["ffmpeg"]="FFmpeg: Conjunto de herramientas para convertir y procesar audio y video."
descripciones["mplayer"]="MPlayer: Reproductor multimedia robusto y eficiente en la línea de comandos."
descripciones["mpv"]="MPV: Reproductor basado en MPlayer con interfaz minimalista y potentes opciones."
descripciones["rhythmbox"]="Rhythmbox: Reproductor de música predeterminado en GNOME, con soporte de podcasts y radio."
descripciones["cmus"]="cmus: Ligero reproductor de música en la terminal, altamente configurable."
descripciones["audacious"]="Audacious: Reproductor de audio clásico con interfaz simple y rápida."
descripciones["qtractor"]="Qtractor: DAW open source para grabación, edición y mezcla de audio."
descripciones["hydrogen"]="Hydrogen: Batería electrónica avanzada con interfaz gráfica y soporte MIDI."
descripciones["mixxx"]="Mixxx: Software de DJ para mezclar música en vivo y gestionar listas de reproducción."
descripciones["jack"]="Jack: Servidor de audio para aplicaciones de baja latencia en entornos profesionales."
descripciones["LMMS"]="LMMS: Estación de trabajo para la producción musical, similar a FL Studio."
descripciones["ardour"]="Ardour: DAW profesional para grabación y mezcla de múltiples pistas de audio."
# Multimedia - Imagen
descripciones["gimp"]="GIMP: Potente editor de imágenes open source, similar a Photoshop."
descripciones["inkscape"]="Inkscape: Editor de gráficos vectoriales con herramientas avanzadas de dibujo."
descripciones["krita"]="Krita: Aplicación profesional de pintura digital y edición gráfica."
descripciones["darktable"]="Darktable: Software para procesamiento y revelado de imágenes en formato RAW."
descripciones["blender"]="Blender: Suite completa para modelado, animación y renderizado 3D."
descripciones["rawtherapee"]="RawTherapee: Editor avanzado para imágenes RAW con ajustes precisos."
descripciones["shotwell"]="Shotwell: Organizador de fotografías simple y eficaz para Linux."
descripciones["digiKam"]="digiKam: Solución para la gestión y edición de fotografías, ideal para profesionales."
descripciones["pinta"]="Pinta: Editor de imágenes sencillo y funcional, similar a Paint.NET."
descripciones["nomacs"]="Nomacs: Visor de imágenes rápido y ligero para Linux."
descripciones["imagemagick"]="ImageMagick: Herramientas para crear, editar y convertir imágenes desde la línea de comandos."
descripciones["feh"]="feh: Visor de imágenes para entornos de terminal, configurable y ligero."
descripciones["sxiv"]="sxiv: Visor rápido de imágenes, ideal para sistemas minimalistas."
descripciones["gThumb"]="gThumb: Visor y organizador de imágenes para entornos GNOME."
descripciones["geeqie"]="Geeqie: Visor de imágenes óptimo en entornos Linux, ligero y rápido."
# Externos - Software Externo
descripciones["google-chrome-stable"]="Google Chrome: Navegador web rápido y seguro, de Google."
descripciones["code"]="Visual Studio Code: Editor de código moderno, extensible y multiplataforma."
descripciones["slack"]="Slack: Herramienta de comunicación y colaboración para equipos."
descripciones["spotify"]="Spotify: Servicio de música en streaming con amplio catálogo y alta calidad."
descripciones["zoom"]="Zoom: Plataforma de videoconferencia que facilita reuniones virtuales."
descripciones["discord"]="Discord: Plataforma con chat de voz y texto para comunidades y gamers."
descripciones["opera"]="Opera: Navegador web innovador con características únicas y VPN integrada."
# ----------------------------------------------------------------------------
# Menú principal (Instalación y Desinstalación) utilizando echo/read y colores
# ----------------------------------------------------------------------------
echo -e "\n${MAGENTA}=== Gestor de Paquetes ===${NC}"
echo -e "${GREEN}1) Instalar un paquete${NC}"
echo -e "${RED}2) Desinstalar un paquete${NC}"
read -p "Elige una opción (1 o 2): " opcion
if [ "$opcion" == "1" ]; then
# --- Sección de Instalación ---
echo -e "\n${CYAN}Categorías disponibles:${NC}"
categorias_keys=()
i=1
for key in "${!categorias[@]}"; do
echo -e " ${YELLOW}$i) $key${NC}"
categorias_keys+=("$key")
((i++))
done
read -p "Elige una categoría (ingresa el número): " cat_choice
categoria_seleccionada=${categorias_keys[$((cat_choice-1))]}
echo -e "\n${CYAN}Subcategorías en ${categoria_seleccionada}:${NC}"
subcats=$(echo -e "${categorias[$categoria_seleccionada]}")
IFS=$'\n' read -d '' -r -a subcategorias_array < <(echo -e "$subcats")
i=1
for sub in "${subcategorias_array[@]}"; do
subcat_name=$(echo "$sub" | cut -d'|' -f1)
echo -e " ${YELLOW}$i) $subcat_name${NC}"
((i++))
done
read -p "Elige una subcategoría (número): " sub_choice
selected_line="${subcategorias_array[$((sub_choice-1))]}"
selected_subcat=$(echo "$selected_line" | cut -d'|' -f1)
paquetes_str=$(echo "$selected_line" | cut -d'|' -f2)
read -a paquetes_array <<< "$paquetes_str"
echo -e "\n${CYAN}Paquetes disponibles en ${categoria_seleccionada} -> ${selected_subcat}:${NC}"
i=1
for pkg in "${paquetes_array[@]}"; do
echo -e " ${YELLOW}$i) $pkg${NC}"
((i++))
done
read -p "Elige el paquete a instalar (ingresa el número o escribe el nombre): " entrada
if [[ "$entrada" =~ ^[0-9]+$ ]]; then
paquete_seleccionado=${paquetes_array[$((entrada-1))]}
else
paquete_seleccionado=$(verificar_paquete "$entrada" "${paquetes_array[@]}")
fi
# Mostrar descripción y solicitar confirmación
echo -e "\n${CYAN}Obteniendo descripción del paquete...${NC}"
if [ "$categoria_seleccionada" != "Externos" ]; then
description=$(apt-cache show "$paquete_seleccionado" 2>/dev/null | awk -F': ' '/Description:/{print $2; exit}')
if [ -z "$description" ]; then
description="No hay descripción disponible en el repositorio."
fi
else
description=${descripciones[$paquete_seleccionado]}
if [ -z "$description" ]; then
description="No hay descripción disponible para este paquete externo."
fi
fi
echo -e "${CYAN}Descripción:${NC} $description"
read -p "¿Estás seguro de instalar el paquete '$paquete_seleccionado'? (S/n): " confirm
if ! [[ "$confirm" =~ ^[Ss]$ || -z "$confirm" ]]; then
echo -e "${YELLOW}Instalación cancelada.${NC}"
exit 0
fi
echo -e "\n${CYAN}Instalando ${GREEN}$paquete_seleccionado${NC}..."
if [ "$categoria_seleccionada" == "Externos" ]; then
case "$paquete_seleccionado" in
google-chrome-stable)
echo -e "${GREEN}Descargando e instalando Google Chrome...${NC}"
wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb -O /tmp/google-chrome.deb
sudo dpkg -i /tmp/google-chrome.deb
sudo apt-get -f install -y
;;
code)
echo -e "${GREEN}Instalando VS Code...${NC}"
wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > /tmp/packages.microsoft.gpg
sudo install -o root -g root -m 644 /tmp/packages.microsoft.gpg /etc/apt/trusted.gpg.d/
sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/vscode stable main" > /etc/apt/sources.list.d/vscode.list'
sudo apt update
sudo apt install -y code
;;
slack)
echo -e "${GREEN}Descargando e instalando Slack...${NC}"
wget https://downloads.slack-edge.com/linux_releases/slack-desktop-4.33.73-amd64.deb -O /tmp/slack.deb
sudo dpkg -i /tmp/slack.deb
sudo apt-get -f install -y
;;
spotify)
echo -e "${GREEN}Instalando Spotify...${NC}"
curl -sS https://download.spotify.com/debian/pubkey.gpg | sudo apt-key add -
echo "deb http://repository.spotify.com stable non-free" | sudo tee /etc/apt/sources.list.d/spotify.list
sudo apt update
sudo apt install -y spotify-client
;;
zoom)
echo -e "${GREEN}Descargando e instalando Zoom...${NC}"
wget https://zoom.us/client/latest/zoom_amd64.deb -O /tmp/zoom.deb
sudo dpkg -i /tmp/zoom.deb
sudo apt-get -f install -y
;;
discord)
echo -e "${GREEN}Descargando e instalando Discord...${NC}"
wget -O /tmp/discord.deb "https://discordapp.com/api/download?platform=linux&format=deb"
sudo dpkg -i /tmp/discord.deb
sudo apt-get -f install -y
;;
opera)
echo -e "${GREEN}Instalando Opera...${NC}"
wget -O /tmp/opera.deb "https://download.opera.com/pub/opera/desktop/90.0.4480.54/linux/opera-stable_90.0.4480.54_amd64.deb"
sudo dpkg -i /tmp/opera.deb
sudo apt-get -f install -y
;;
*)
echo -e "${YELLOW}Paquete externo '$paquete_seleccionado' no reconocido. Instálalo manualmente.${NC}"
;;
esac
else
sudo apt update && sudo apt install -y "$paquete_seleccionado"
fi
echo -e "${GREEN}¡Instalación completada!${NC}"
elif [ "$opcion" == "2" ]; then
# --- Sección de Desinstalación (descarta "Externos") ---
echo -e "\n${CYAN}Recabando información de paquetes instalados según la clasificación...${NC}"
declare -A inst_categorias
for cat in "${!categorias[@]}"; do
if [ "$cat" == "Externos" ]; then
continue
fi
subcats=$(echo -e "${categorias[$cat]}")
IFS=$'\n' read -d '' -r -a subs_array < <(echo -e "$subcats")
result=""
for sub in "${subs_array[@]}"; do
subcat_name=$(echo "$sub" | cut -d'|' -f1)
pkg_list=$(echo "$sub" | cut -d'|' -f2)
pkg_array=($pkg_list)
installed_packages=()
for pkg in "${pkg_array[@]}"; do
if dpkg -l "$pkg" 2>/dev/null | grep -q "^ii"; then
installed_packages+=("$pkg")
fi
done
if [ ${#installed_packages[@]} -gt 0 ]; then
result+="${subcat_name}|$(echo ${installed_packages[@]})"$'\n'
fi
done
if [ -n "$result" ]; then
inst_categorias["$cat"]="$result"
fi
done
if [ ${#inst_categorias[@]} -eq 0 ]; then
echo -e "${RED}No se encontraron paquetes instalados en las categorías predefinidas.${NC}"
exit 1
fi
echo -e "\n${CYAN}Categorías disponibles para desinstalación:${NC}"
available_categories=()
i=1
for cat in "${!inst_categorias[@]}"; do
echo -e " ${YELLOW}$i) $cat${NC}"
available_categories+=("$cat")
((i++))
done
read -p "Elige una categoría (número): " cat_choice_inst
chosen_cat="${available_categories[$((cat_choice_inst-1))]}"
echo -e "\n${CYAN}Subcategorías en ${chosen_cat}:${NC}"
subcats_inst=$(echo -e "${inst_categorias[$chosen_cat]}")
IFS=$'\n' read -d '' -r -a subs_inst_array < <(echo -e "$subcats_inst")
i=1
for sub in "${subs_inst_array[@]}"; do
subcat_inst=$(echo "$sub" | cut -d'|' -f1)
echo -e " ${YELLOW}$i) $subcat_inst${NC}"
((i++))
done
read -p "Elige una subcategoría (número): " sub_choice_inst
selected_line_inst="${subs_inst_array[$((sub_choice_inst-1))]}"
selected_subcat_inst=$(echo "$selected_line_inst" | cut -d'|' -f1)
pkg_line_inst=$(echo "$selected_line_inst" | cut -d'|' -f2)
read -a pkg_array_inst <<< "$pkg_line_inst"
echo -e "\n${CYAN}Paquetes instalados en ${chosen_cat} -> ${selected_subcat_inst}:${NC}"
i=1
for pkg in "${pkg_array_inst[@]}"; do
echo -e " ${YELLOW}$i) $pkg${NC}"
((i++))
done
read -p "Elige el paquete a desinstalar (ingresa el número o escribe el nombre): " entrada
if [[ "$entrada" =~ ^[0-9]+$ ]]; then
paquete_seleccionado=${pkg_array_inst[$((entrada-1))]}
else
paquete_seleccionado=$(verificar_paquete "$entrada" "${pkg_array_inst[@]}")
fi
echo -e "\n${BLUE}Desinstalando ${RED}$paquete_seleccionado${NC}..."
sudo apt remove -y "$paquete_seleccionado"
echo -e "${GREEN}¡Desinstalación completada!${NC}"
else
echo -e "${RED}Opción no válida. Usa 1 para instalar o 2 para desinstalar.${NC}"
fi
echo -e "\n${MAGENTA}Fin del script.${NC}"
Script de Comparticion de pantalla:
#!/bin/bash
# Configuración avanzada de pantalla con menú visual mejorado en Linux
# Definir colores ANSI
RED='\033[1;31m'
GREEN='\033[1;32m'
BLUE='\033[1;34m'
YELLOW='\033[1;33m'
CYAN='\033[1;36m'
MAGENTA='\033[1;35m'
WHITE='\033[1;37m'
NC='\033[0m' # Resetear color
# Directorio para guardar perfiles de configuración
PROFILES_DIR="$HOME/.config/display-profiles"
mkdir -p "$PROFILES_DIR"
# ===============================================
# FUNCIONES DE UTILIDAD Y COMPROBACIÓN
# ===============================================
# Función para verificar si un comando existe
command_exists () {
type "$1" &> /dev/null
}
# Verificar herramientas esenciales
check_dependencies() {
if ! command_exists xrandr; then
echo -e "${RED}ERROR: 'xrandr' no encontrado. Por favor, instala xorg-xrandr o x11-xserver-utils.${NC}"
exit 1
fi
if ! command_exists notify-send; then
echo -e "${YELLOW}ADVERTENCIA: 'notify-send' no encontrado. Las notificaciones de escritorio no funcionarán. (Instala libnotify-bin).${NC}"
# No salimos, solo advertimos
fi
if ! command_exists awk; then
echo -e "${RED}ERROR: 'awk' no encontrado. Este script lo necesita.${NC}"
exit 1
fi
}
# Función para obtener la salida principal conectada (la que no es virtual)
# Prioriza eDP (pantalla interna), luego toma la primera conectada no virtual.
get_primary_display_output() {
if xrandr | grep -q "eDP-1 connected"; then
echo "eDP-1"
return
fi
xrandr | grep " connected" | grep -v " disconnected" | awk '{print $1}' | head -n 1
}
# Función para seleccionar una pantalla de una lista
select_display_output() {
local outputs=()
local i=1
clear
echo -e "${YELLOW}Detectando pantallas conectadas...${NC}"
echo -e "${WHITE}-------------------------------${NC}"
while IFS= read -r line; do
outputs+=("$line")
echo -e "${CYAN}$i. ${line}${NC}"
i=$((i+1))
done < <(xrandr | grep " connected" | awk '{print $1}')
if [ ${#outputs[@]} -eq 0 ]; then
echo -e "${RED}❌ No se detectaron pantallas conectadas. Asegúrate de que estén físicamente conectadas.${NC}"
read -p "Presiona Enter para continuar..."
return 1
fi
echo -e "${WHITE}-------------------------------${NC}"
read -p "Selecciona el NÚMERO de la pantalla que deseas configurar: " selection
if [[ "$selection" -ge 1 && "$selection" -le ${#outputs[@]} ]]; then
echo "${outputs[$((selection-1))]}"
return 0
else
echo -e "${RED}❌ Selección no válida.${NC}"
read -p "Presiona Enter para continuar..."
return 1
fi
}
# Función para mostrar y seleccionar resoluciones disponibles
select_resolution() {
local output="$1"
local modes=()
local i=1
echo -e "${YELLOW}Resoluciones disponibles para ${output}:${NC}"
echo -e "${WHITE}-------------------------------${NC}"
# Obtener modos de xrandr, quitar duplicados y ordenar
while IFS= read -r line; do
modes+=("$line")
echo -e "${CYAN}$i. ${line}${NC}"
i=$((i+1))
done < <(xrandr | grep "^ " | grep -A 10 "$output" | awk '{print $1}' | grep -E '^[0-9]+x[0-9]+$' | sort -V | uniq)
if [ ${#modes[@]} -eq 0 ]; then
echo -e "${RED}❌ No se encontraron resoluciones para ${output}.${NC}"
read -p "Presiona Enter para continuar..."
return 1
fi
echo -e "${WHITE}-------------------------------${NC}"
read -p "Selecciona el NÚMERO de la resolución deseada: " selection
if [[ "$selection" -ge 1 && "$selection" -le ${#modes[@]} ]]; then
echo "${modes[$((selection-1))]}"
return 0
else
echo -e "${RED}❌ Selección no válida.${NC}"
read -p "Presiona Enter para continuar..."
return 1
fi
}
# Función para mostrar y seleccionar tasas de refresco disponibles
select_refresh_rate() {
local output="$1"
local rates=()
local i=1
echo -e "${YELLOW}Tasas de refresco disponibles para ${output}:${NC}"
echo -e "${WHITE}-------------------------------${NC}"
# Obtener tasas de refresco de xrandr
while IFS= read -r line; do
rates+=("$line")
echo -e "${CYAN}$i. ${line} Hz${NC}"
i=$((i+1))
done < <(xrandr | grep "^ " | grep -A 10 "$output" | awk '{print $NF}' | grep -E '^[0-9]+(\.[0-9]+)?\*?$' | sed 's/\*//g' | sort -g | uniq)
if [ ${#rates[@]} -eq 0 ]; then
echo -e "${RED}❌ No se encontraron tasas de refresco para ${output}.${NC}"
read -p "Presiona Enter para continuar..."
return 1
fi
echo -e "${WHITE}-------------------------------${NC}"
read -p "Selecciona el NÚMERO de la tasa de refresco deseada: " selection
if [[ "$selection" -ge 1 && "$selection" -le ${#rates[@]} ]]; then
echo "${rates[$((selection-1))]}"
return 0
else
echo -e "${RED}❌ Selección no válida.${NC}"
read -p "Presiona Enter para continuar..."
return 1
fi
}
# ===============================================
# CONFIGURACIÓN INICIAL DEL SCRIPT
# ===============================================
# 1. Crear el archivo .desktop global
DESKTOP_FILE="/usr/share/applications/configuracion-pantalla.desktop"
SCRIPT_PATH="/usr/local/bin/configuracion-pantalla.sh"
# Asegúrate de que el script principal esté en la ubicación deseada ANTES de crear el .desktop
# Esto es para cuando el script se ejecuta por primera vez y aún no se ha movido a /usr/local/bin
CURRENT_SCRIPT_LOCATION="$(readlink -f "$0")"
if [ "$CURRENT_SCRIPT_LOCATION" != "$SCRIPT_PATH" ]; then
echo -e "${YELLOW}INFO: Moviendo script a $SCRIPT_PATH para configuración inicial...${NC}"
sudo mkdir -p "$(dirname "$SCRIPT_PATH")"
sudo cp "$CURRENT_SCRIPT_LOCATION" "$SCRIPT_PATH"
sudo chmod +x "$SCRIPT_PATH"
echo -e "${GREEN}✅ Script movido y permisos establecidos.${NC}"
fi
cat <<EOF > "$DESKTOP_FILE"
[Desktop Entry]
Version=1.0
Type=Application
Name=Configuración de Pantalla
Comment=Administra la configuración y compartición de pantalla
Exec=$SCRIPT_PATH
Icon=display
Terminal=true
Categories=Settings;Utility;
EOF
sudo chmod +x "$DESKTOP_FILE"
echo -e "${GREEN}✅ Archivo .desktop global creado en $DESKTOP_FILE${NC}"
# 2. Copiar el .desktop al escritorio de usuarios nuevos
DESKTOP_DIR="/etc/skel/Desktop"
if [ ! -d "$DESKTOP_DIR" ]; then
DESKTOP_DIR="/etc/skel/Escritorio"
fi
sudo mkdir -p "$DESKTOP_DIR"
sudo cp "$DESKTOP_FILE" "$DESKTOP_DIR/configuracion-pantalla.desktop"
sudo chmod +x "$DESKTOP_DIR/configuracion-pantalla.desktop"
echo -e "${GREEN}✅ Archivo .desktop copiado en $DESKTOP_DIR (para nuevos usuarios)${NC}"
# 3. Copiar el acceso directo para usuarios existentes
for user_dir in /home/*; do
if [ -d "$user_dir" ]; then
USER_NAME=$(basename "$user_dir")
if [ -d "$user_dir/Desktop" ]; then
sudo cp "$DESKTOP_FILE" "$user_dir/Desktop/"
sudo chmod +x "$user_dir/Desktop/configuracion-pantalla.desktop"
echo -e "${GREEN}✅ Archivo .desktop copiado en $user_dir/Desktop${NC}"
elif [ -d "$user_dir/Escritorio" ]; then
sudo cp "$DESKTOP_FILE" "$user_dir/Escritorio/"
sudo chmod +x "$user_dir/Escritorio/configuracion-pantalla.desktop"
echo -e "${GREEN}✅ Archivo .desktop copiado en $user_dir/Escritorio${NC}"
fi
fi
done
# ===============================================
# FUNCIONES DE PERFILES DE CONFIGURACIÓN
# ===============================================
save_profile() {
clear
echo -e "${YELLOW}Descripción: Guarda la configuración actual de todas tus pantallas en un perfil.${NC}"
echo -e "${WHITE}Esto incluye resolución, brillo, rotación y disposición (duplicar/extender).${NC}"
read -p "Introduce un nombre para el perfil: " profile_name
if [ -z "$profile_name" ]; then
echo -e "${RED}❌ Nombre de perfil no puede estar vacío.${NC}"
sleep 2
return
fi
local profile_file="$PROFILES_DIR/$profile_name.sh" # Cambiado a .sh para que sea ejecutable
# Generar el contenido del script de perfil
echo "#!/bin/bash" > "$profile_file"
echo "# Perfil de pantalla: $profile_name" >> "$profile_file"
echo "# Generado el $(date)" >> "$profile_file"
echo "" >> "$profile_file"
# Comando para apagar todas las pantallas antes de aplicar la nueva configuración
echo "xrandr --current | grep ' connected' | awk '{print \$1}' | while read output; do xrandr --output \$output --off; done" >> "$profile_file"
echo "sleep 1" # Pequeña pausa para que los cambios se apliquen
# Obtener la configuración actual de todas las pantallas conectadas
# y construir los comandos xrandr para restaurarlas
xrandr | grep " connected" | while read -r line; do
output_name=$(echo "$line" | awk '{print $1}')
# Obtener los parámetros de configuración de xrandr para cada salida
# Esto es un poco más complejo ya que xrandr --query tiene un formato específico.
# Vamos a intentar construir el comando de la forma más fiable.
local current_config=$(xrandr --query | grep -A 1 "$output_name connected" | head -n 2)
local mode_info=$(echo "$current_config" | awk 'NR==2 {print $1}' | grep -E '^[0-9]+x[0-9]+$')
local rate_info=$(echo "$current_config" | awk 'NR==2 {print $2}' | sed 's/\*//g' | grep -E '^[0-9]+(\.[0-9]+)?$')
local command_parts="--output $output_name"
# Modo y tasa de refresco
if [ -n "$mode_info" ]; then
command_parts="$command_parts --mode $mode_info"
if [ -n "$rate_info" ]; then
command_parts="$command_parts --rate $rate_info"
fi
fi
# Posición (si está extendida)
if echo "$line" | grep -q '\-\-pos'; then
local pos=$(echo "$line" | grep -oP '\-\-pos [0-9]+x[0-9]+')
if [ -n "$pos" ]; then
command_parts="$command_parts $pos"
fi
fi
# Rotación
if echo "$line" | grep -q '\-\-rotate'; then
local rot=$(echo "$line" | grep -oP '\-\-rotate (normal|inverted|left|right)')
if [ -n "$rot" ]; then
command_parts="$command_parts $rot"
fi
fi
# Brillo
if echo "$line" | grep -q '\-\-brightness'; then
local brightness=$(echo "$line" | grep -oP '\-\-brightness [0-9]+\.?[0-9]*')
if [ -n "$brightness" ]; then
command_parts="$command_parts $brightness"
fi
fi
# Primaria
if echo "$line" | grep -q 'primary'; then
command_parts="$command_parts --primary"
fi
# Asegurarse de que la pantalla esté encendida por defecto al aplicar el perfil
command_parts="$command_parts --auto"
echo "xrandr $command_parts" >> "$profile_file"
done
# Asegurar que el script de perfil sea ejecutable
chmod +x "$profile_file"
echo -e "${GREEN}✅ Perfil '$profile_name' guardado en '$profile_file'.${NC}"
notify-send "💾 Perfil de pantalla guardado: $profile_name"
sleep 2
}
load_profile() {
clear
echo -e "${YELLOW}Descripción: Carga y aplica una configuración de pantalla previamente guardada.${NC}"
echo -e "${WHITE}Esto restaurará la resolución, brillo, rotación y disposición de tus pantallas.${NC}"
local profiles=()
local i=1
echo -e "${YELLOW}Perfiles de pantalla disponibles:${NC}"
echo -e "${WHITE}-------------------------------${NC}"
for file in "$PROFILES_DIR"/*.sh; do # Buscar .sh en lugar de .xrandr
if [ -f "$file" ]; then
profile=$(basename "$file" .sh)
profiles+=("$profile")
echo -e "${CYAN}$i. $profile${NC}"
i=$((i+1))
fi
done
if [ ${#profiles[@]} -eq 0 ]; then
echo -e "${RED}❌ No hay perfiles guardados.${NC}"
read -p "Presiona Enter para continuar..."
return
fi
echo -e "${WHITE}-------------------------------${NC}"
read -p "Selecciona el NÚMERO del perfil para cargar: " selection
if [[ "$selection" -ge 1 && "$selection" -le ${#profiles[@]} ]]; then
local profile_to_load="${profiles[$((selection-1))]}"
local profile_path="$PROFILES_DIR/$profile_to_load.sh"
echo -e "${YELLOW}Aplicando perfil '$profile_to_load'....${NC}"
bash "$profile_path" # Ejecuta el archivo de perfil como un script
notify-send "✅ Perfil de pantalla cargado: $profile_to_load"
echo -e "${GREEN}✅ Perfil '$profile_to_load' cargado.${NC}"
else
echo -e "${RED}❌ Selección no válida.${NC}"
fi
read -p "Presiona Enter para continuar..."
}
delete_profile() {
clear
echo -e "${YELLOW}Descripción: Elimina un perfil de configuración de pantalla guardado.${NC}"
echo -e "${WHITE}Una vez eliminado, no podrás restaurar esa configuración fácilmente.${NC}"
local profiles=()
local i=1
echo -e "${YELLOW}Perfiles de pantalla disponibles para eliminar:${NC}"
echo -e "${WHITE}-------------------------------${NC}"
for file in "$PROFILES_DIR"/*.sh; do # Buscar .sh en lugar de .xrandr
if [ -f "$file" ]; then
profile=$(basename "$file" .sh)
profiles+=("$profile")
echo -e "${CYAN}$i. $profile${NC}"
i=$((i+1))
fi
done
if [ ${#profiles[@]} -eq 0 ]; then
echo -e "${RED}❌ No hay perfiles guardados para eliminar.${NC}"
read -p "Presiona Enter para continuar..."
return
fi
echo -e "${WHITE}-------------------------------${NC}"
read -p "Selecciona el NÚMERO del perfil para eliminar: " selection
if [[ "$selection" -ge 1 && "$selection" -le ${#profiles[@]} ]]; then
local profile_to_delete="${profiles[$((selection-1))]}"
rm "$PROFILES_DIR/$profile_to_delete.sh" # Eliminar .sh
echo -e "${GREEN}✅ Perfil '$profile_to_delete' eliminado.${NC}"
notify-send "🗑️ Perfil de pantalla eliminado: $profile_to_delete"
else
echo -e "${RED}❌ Selección no válida.${NC}"
fi
read -p "Presiona Enter para continuar..."
}
# ===============================================
# MENÚ PRINCIPAL Y SUBMENÚS
# ===============================================
# Verificar dependencias al inicio del script
check_dependencies
# Menú principal
while true; do
clear
echo -e "${CYAN}🔧 Menú Principal de Configuración de Pantalla${NC}"
echo -e "${WHITE}-------------------------------${NC}"
echo -e "${GREEN}1. ⚙️ Configuración de Pantalla (Resolución, Brillo, Rotación, Refresco)${NC}"
echo " Permite ajustar las propiedades individuales de una pantalla seleccionada."
echo -e "${BLUE}2. 📡 Compartición de Pantalla (Duplicar, Extender, Solo)${NC}"
echo " Controla cómo se muestran tus pantallas, ideal para presentaciones o multi-monitor."
echo -e "${MAGENTA}3. 💾 Perfiles de Configuración (Guardar/Cargar/Eliminar)${NC}"
echo " Guarda y restaura tus configuraciones de pantalla favoritas con facilidad."
echo -e "${YELLOW}4. 🚀 Configurar al Inicio de Sesión${NC}"
echo " Define una configuración de pantalla para que se aplique automáticamente al iniciar tu sesión."
echo -e "${RED}5. ❌ Salir${NC}"
echo " Cierra esta herramienta."
echo -e "${WHITE}-------------------------------${NC}"
read -p "Selecciona una opción: " main_option
case $main_option in
1) # Menú de configuración de pantalla
while true; do
clear
echo -e "${GREEN}⚙️ Configuración de Pantalla Individual${NC}"
echo -e "${WHITE}-------------------------------${NC}"
echo "Aquí puedes ajustar las propiedades de una pantalla específica."
echo -e "${CYAN}1. 🎚️ Modificar resolución${NC}"
echo -e "${YELLOW}2. 🌅 Ajustar brillo${NC}"
echo -e "${BLUE}3. 🔄 Rotar pantalla${NC}"
echo -e "${MAGENTA}4. 🏳️ Cambiar tasa de refresco${NC}"
echo -e "${RED}5. ↩️ Volver al menú principal${NC}"
echo -e "${WHITE}-------------------------------${NC}"
read -p "Selecciona una opción: " config_option
case $config_option in
1) # Modificar resolución
clear
echo -e "${CYAN}--- Modificar Resolución ---${NC}"
echo "Descripción: Cambia el tamaño y la claridad de la imagen en la pantalla seleccionada."
echo "Instrucciones: Primero, selecciona la pantalla de la lista numerada."
echo " Luego, selecciona la resolución deseada de la nueva lista numerada."
echo -e "${WHITE}-------------------------------${NC}"
SELECTED_OUTPUT=$(select_display_output)
if [ $? -ne 0 ]; then continue; fi # Si falla la selección de pantalla
SELECTED_RESOLUTION=$(select_resolution "$SELECTED_OUTPUT")
if [ $? -ne 0 ]; then continue; fi # Si falla la selección de resolución
xrandr --output "$SELECTED_OUTPUT" --mode "$SELECTED_RESOLUTION"
notify-send "🎚️ Resolución cambiada en $SELECTED_OUTPUT a $SELECTED_RESOLUTION"
sleep 2
;;
2) # Ajustar brillo
clear
echo -e "${YELLOW}--- Ajustar Brillo ---${NC}"
echo "Descripción: Controla la intensidad de la luz emitida por la pantalla."
echo "Instrucciones: Primero, selecciona la pantalla de la lista numerada."
echo " Luego, introduce un valor numérico para el brillo."
echo " Ejemplo: '1.0' para brillo normal (100%), '0.5' para 50%, '0.2' para 20%."
echo -e "${WHITE}-------------------------------${NC}"
SELECTED_OUTPUT=$(select_display_output)
if [ $? -ne 0 ]; then continue; fi
read -p "Introduce el nivel de brillo (Ejemplo: 0.5 para 50%): " brightness
if ! [[ "$brightness" =~ ^[0-9]+(\.[0-9]+)?$ ]]; then
echo -e "${RED}❌ Brillo no válido. Usa un número (ej. 0.8).${NC}"
sleep 2; continue
fi
xrandr --output "$SELECTED_OUTPUT" --brightness "$brightness"
notify-send "🌅 Brillo ajustado en $SELECTED_OUTPUT a $brightness"
sleep 2
;;
3) # Rotar pantalla
clear
echo -e "${BLUE}--- Rotar Pantalla ---${NC}"
echo "Descripción: Gira la orientación de la pantalla."
echo "Instrucciones: Primero, selecciona la pantalla de la lista numerada."
echo " Luego, introduce una de las siguientes palabras para la rotación:"
echo " - 'normal': Orientación estándar (0 grados)."
echo " - 'inverted': Pantalla rotada 180 grados."
echo " - 'left': Pantalla rotada 90 grados a la izquierda (en sentido antihorario)."
echo " - 'right': Pantalla rotada 90 grados a la derecha (en sentido horario)."
echo -e "${WHITE}-------------------------------${NC}"
SELECTED_OUTPUT=$(select_display_output)
if [ $? -ne 0 ]; then continue; fi
read -p "Introduce el ángulo de rotación (normal, inverted, left, right): " rotation
case "$rotation" in
normal|inverted|left|right)
xrandr --output "$SELECTED_OUTPUT" --rotate "$rotation"
notify-send "🔄 Pantalla $SELECTED_OUTPUT rotada: $rotation"
;;
*) echo -e "${RED}❌ Rotación no válida. Usa 'normal', 'inverted', 'left' o 'right'.${NC}" ;;
esac
sleep 2
;;
4) # Cambiar tasa de refresco
clear
echo -e "${MAGENTA}--- Cambiar Tasa de Refresco ---${NC}"
echo "Descripción: Ajusta la suavidad del movimiento en la pantalla (medido en Herzios - Hz)."
echo "Instrucciones: Primero, selecciona la pantalla de la lista numerada."
echo " Luego, selecciona la tasa de refresco deseada de la nueva lista numerada."
echo -e "${WHITE}-------------------------------${NC}"
SELECTED_OUTPUT=$(select_display_output)
if [ $? -ne 0 ]; then continue; fi
SELECTED_RATE=$(select_refresh_rate "$SELECTED_OUTPUT")
if [ $? -ne 0 ]; then continue; fi
xrandr --output "$SELECTED_OUTPUT" --rate "$SELECTED_RATE"
notify-send "🏳️ Tasa de refresco de $SELECTED_OUTPUT cambiada a $SELECTED_RATE Hz"
sleep 2
;;
5) break ;;
*) echo -e "${RED}❌ Opción no válida, intenta de nuevo.${NC}" ;;
esac # FIN DE CASE DE OPCIONES DE CONFIGURACIÓN
done
;;
2) # Menú de compartición de pantalla
while true; do
clear
echo -e "${BLUE}📡 Compartición de Pantalla${NC}"
echo -e "${WHITE}-------------------------------${NC}"
echo "Estas opciones te permiten gestionar cómo se muestran tus pantallas, ideal para trabajar con múltiples monitores o realizar presentaciones."
echo -e "${CYAN}📺 Modos de visualización${NC}"
echo -e "${GREEN}1. 🔵 Duplicar pantalla (primaria y secundaria)${NC}"
echo " Muestra el mismo contenido en ambas pantallas. Útil para proyectores o compartir lo que ves."
echo -e "${GREEN}2. 🟢 Pantalla extendida (primaria y secundaria)${NC}"
echo " Extiende tu escritorio a una segunda pantalla, dándote más espacio de trabajo."
echo -e "${YELLOW}3. 📽️ Solo pantalla secundaria${NC}"
echo " Desactiva la pantalla principal y utiliza solo la secundaria. Ideal para presentaciones."
echo -e "${YELLOW}4. 🖥️ Solo pantalla primaria${NC}"
echo " Desactiva las pantallas secundarias y utiliza solo la principal."
echo -e "${MAGENTA}5. 📊 Modo presentación (ej. apagar otras pantallas, notificaciones)${NC}"
echo " Activa un modo optimizado para presentaciones (puede requerir configuración adicional)."
echo -e "${WHITE}-------------------------------${NC}"
echo -e "${CYAN}🌍 Opciones de transmisión/servicios${NC}"
echo -e "${BLUE}6. 🔗 Compartir pantalla en red (Requiere VNC/RDP)${NC}"
echo " Habilita la compartición de tu escritorio a través de la red para que otros usuarios puedan verlo o controlarlo de forma remota."
echo -e "${BLUE}7. 🎥 Activar transmisión a otro dispositivo (Requiere software adicional)${NC}"
echo " Prepara tu sistema para enviar la pantalla a dispositivos como Smart TVs o dongles de streaming."
echo -e "${BLUE}8. 💡 Alternar DPMS (Standby/Suspend/Off)${NC}"
echo " Controla el estado de ahorro de energía de tus pantallas."
echo -e "${RED}9. ↩️ Volver al menú principal${NC}"
echo -e "${WHITE}-------------------------------${NC}"
read -p "Selecciona una opción: " share_option
PRIMARY_OUTPUT=$(get_primary_display_output)
SECONDARY_OUTPUT=$(xrandr | grep " connected" | awk '{if ($1 != "'"$PRIMARY_OUTPUT"'") print $1;}' | head -n 1)
if [ -z "$PRIMARY_OUTPUT" ]; then
echo -e "${RED}❌ No se detectó una pantalla principal conectada. Asegúrate de tener al menos una pantalla conectada.${NC}"
sleep 3
continue
fi
case $share_option in
1) # Duplicar pantalla
clear
echo -e "${BLUE}--- Duplicar Pantalla ---${NC}"
echo "Descripción: Muestra el mismo contenido en tu pantalla principal y una secundaria."
echo "Instrucciones: Esta opción se aplica automáticamente si detecta una pantalla secundaria."
echo -e "${WHITE}-------------------------------${NC}"
if [ -n "$SECONDARY_OUTPUT" ]; then
xrandr --output "$SECONDARY_OUTPUT" --same-as "$PRIMARY_OUTPUT" --auto
notify-send "🔵 Pantalla duplicada: $PRIMARY_OUTPUT y $SECONDARY_OUTPUT"
else
echo -e "${RED}❌ No se detectó una pantalla secundaria para duplicar.${NC}"
fi ;;
2) # Pantalla extendida
clear
echo -e "${GREEN}--- Pantalla Extendida ---${NC}"
echo "Descripción: Extiende tu escritorio a una segunda pantalla, dándote más espacio de trabajo."
echo "Instrucciones: El sistema extenderá automáticamente la pantalla secundaria a la derecha de la principal."
echo -e "${WHITE}-------------------------------${NC}"
if [ -n "$SECONDARY_OUTPUT" ]; then
xrandr --output "$SECONDARY_OUTPUT" --right-of "$PRIMARY_OUTPUT" --auto
notify-send "🟢 Pantalla extendida: $PRIMARY_OUTPUT y $SECONDARY_OUTPUT"
else
echo -e "${RED}❌ No se detectó una pantalla secundaria para extender.${NC}"
fi ;;
3) # Solo pantalla secundaria
clear
echo -e "${YELLOW}--- Solo Pantalla Secundaria ---${NC}"
echo "Descripción: Desactiva la pantalla principal y utiliza solo la secundaria. Útil para proyectores."
echo "Instrucciones: Si hay una pantalla secundaria conectada, se activará como principal y la otra se apagará."
echo -e "${WHITE}-------------------------------${NC}"
if [ -n "$SECONDARY_OUTPUT" ]; then
xrandr --output "$PRIMARY_OUTPUT" --off
xrandr --output "$SECONDARY_OUTPUT" --primary --auto
notify-send "📽️ Solo pantalla secundaria activada: $SECONDARY_OUTPUT"
else
echo -e "${RED}❌ No se detectó una pantalla secundaria para activar.${NC}"
fi ;;
4) # Solo pantalla primaria
clear
echo -e "${YELLOW}--- Solo Pantalla Primaria ---${NC}"
echo "Descripción: Desactiva todas las pantallas secundarias y utiliza solo la principal."
echo "Instrucciones: Esta opción se aplica automáticamente, apagando cualquier otra pantalla conectada."
echo -e "${WHITE}-------------------------------${NC}"
if [ -n "$PRIMARY_OUTPUT" ]; then
xrandr --output "$PRIMARY_OUTPUT" --primary --auto
xrandr | grep " connected" | awk '{print $1}' | while read output; do
if [ "$output" != "$PRIMARY_OUTPUT" ]; then
xrandr --output "$output" --off
fi
done
notify-send "🖥️ Solo pantalla primaria activada: $PRIMARY_OUTPUT"
else
echo -e "${RED}❌ No se detectó una pantalla primaria para activar.${NC}"
fi ;;
5) # Modo presentación
clear
echo -e "${MAGENTA}--- Modo Presentación ---${NC}"
echo "Descripción: Activa un modo optimizado para presentaciones."
echo "Instrucciones: Actualmente, esta opción solo muestra una notificación."
echo " Puedes expandirla manualmente en el script para, por ejemplo, deshabilitar el salvapantallas o las notificaciones del sistema durante una presentación."
echo -e "${WHITE}-------------------------------${NC}"
notify-send "📊 Modo presentación activado (Funcionalidad avanzada pendiente: Por ejemplo, puedes agregar aquí comandos para deshabilitar el salvapantallas, las notificaciones de escritorio, etc.)"
# Ejemplo: xset dpms force off (para apagar la pantalla) o configurar un fondo de escritorio específico.
# Para deshabilitar salvapantallas temporalmente: xset s off && xset -dpms
;;
6) # Compartir pantalla en red
clear
echo -e "${BLUE}--- Compartir Pantalla en Red ---${NC}"
echo "Descripción: Habilita la compartición de tu escritorio a través de la red."
echo "Instrucciones: Esta función requiere un servidor VNC/RDP (ej. 'x11vnc' o 'vino-server') instalado y configurado en tu sistema. Este script solo te informa al respecto."
echo -e "${WHITE}-------------------------------${NC}"
notify-send "🔗 Compartición de pantalla en red: Esta función requiere un servidor VNC/RDP (ej. 'x11vnc' o 'vino-server') para compartir tu escritorio en la red. ¡Instálalo y configúralo!"
;;
7) # Activar transmisión a otro dispositivo
clear
echo -e "${BLUE}--- Activar Transmisión ---${NC}"
echo "Descripción: Prepara tu sistema para enviar la pantalla a dispositivos externos como Smart TVs o dongles de streaming."
echo "Instrucciones: Esta función requiere software de streaming adicional (como FFmpeg, GStreamer, o herramientas para Miracast/Chromecast). Este script solo te informa al respecto."
echo -e "${WHITE}-------------------------------${NC}"
notify-send "🎥 Transmisión a otro dispositivo: Esta función requiere software de streaming como FFmpeg, GStreamer, o herramientas para Miracast/Chromecast. ¡Instálalo y configúralo!"
;;
8) # Alternar DPMS
clear
echo -e "${BLUE}--- Alternar DPMS (Display Power Management Signaling) ---${NC}"
echo "Descripción: DPMS permite controlar el estado de ahorro de energía de tus pantallas (Standby, Suspend, Off)."
echo "Instrucciones: Selecciona la opción deseada para aplicar el modo de ahorro de energía."
echo -e "${WHITE}-------------------------------${NC}"
echo -e "${CYAN}1. Standby (ahorro de energía moderado)${NC}"
echo -e "${CYAN}2. Suspend (ahorro de energía significativo)${NC}"
echo -e "${CYAN}3. Off (apagar pantalla)${NC}"
echo -e "${RED}4. Volver${NC}"
read -p "Selecciona una opción DPMS: " dpms_option
case $dpms_option in
1) xset dpms force standby; notify-send "💡 DPMS: Pantalla en Standby.";;
2) xset dpms force suspend; notify-send "💡 DPMS: Pantalla en Suspend.";;
3) xset dpms force off; notify-send "💡 DPMS: Pantalla apagada.";;
4) ;;
*) echo -e "${RED}❌ Opción DPMS no válida.${NC}";;
esac
;;
9) break ;;
*) echo -e "${RED}❌ Opción no válida, intenta de nuevo.${NC}" ;;
esac
sleep 2
done
;;
3) # Menú de perfiles de configuración
while true; do
clear
echo -e "${MAGENTA}💾 Perfiles de Configuración${NC}"
echo -e "${WHITE}-------------------------------${NC}"
echo "Gestiona tus configuraciones de pantalla guardadas para aplicarlas rápidamente cuando las necesites."
echo -e "${GREEN}1. Guardar configuración actual${NC}"
echo -e "${BLUE}2. Cargar perfil guardado${NC}"
echo -e "${RED}3. Eliminar perfil${NC}"
echo -e "${YELLOW}4. ↩️ Volver al menú principal${NC}"
echo -e "${WHITE}-------------------------------${NC}"
read -p "Selecciona una opción: " profile_option
case $profile_option in
1)
clear
echo -e "${GREEN}--- Guardar Configuración Actual ---${NC}"
echo "Descripción: Crea un nuevo perfil basado en la configuración actual de tus pantallas."
echo "Instrucciones: Introduce un nombre único para tu nuevo perfil."
echo -e "${WHITE}-------------------------------${NC}"
save_profile ;;
2)
clear
echo -e "${BLUE}--- Cargar Perfil Guardado ---${NC}"
echo "Descripción: Aplica una configuración de pantalla guardada anteriormente."
echo "Instrucciones: Se te presentará una lista numerada de tus perfiles. Introduce el número del perfil que deseas cargar."
echo -e "${WHITE}-------------------------------${NC}"
load_profile ;;
3)
clear
echo -e "${RED}--- Eliminar Perfil ---${NC}"
echo "Descripción: Borra un perfil de configuración que ya no necesites."
echo "Instrucciones: Se te presentará una lista numerada de tus perfiles. Introduce el número del perfil que deseas eliminar."
echo -e "${WHITE}-------------------------------${NC}"
delete_profile ;;
4) break ;;
*) echo -e "${RED}❌ Opción no válida, intenta de nuevo.${NC}" ;;
esac
sleep 2
done
;;
4) # Configurar al inicio de sesión
clear
echo -e "${YELLOW}🚀 Configuración al Inicio de Sesión${NC}"
echo -e "${WHITE}-------------------------------${NC}"
echo "Esta opción permite que tu configuración de pantalla se aplique automáticamente al iniciar sesión."
echo "Para ello, se creará un archivo de autoinicio en tu directorio de usuario."
echo -e "${WHITE}-------------------------------${NC}"
echo -e "${GREEN}1. Establecer configuración al inicio${NC}"
echo -e "${RED}2. Deshabilitar configuración al inicio${NC}"
echo -e "${YELLOW}3. ↩️ Volver al menú principal${NC}"
echo -e "${WHITE}-------------------------------${NC}"
read -p "Selecciona una opción: " autostart_option
case $autostart_option in
1)
clear
echo -e "${GREEN}--- Establecer Configuración al Inicio ---${NC}"
echo "Descripción: Configura el script para aplicar un perfil de pantalla (o una configuración por defecto) cada vez que inicies sesión."
echo "Instrucciones: A continuación, se te preguntará si quieres aplicar un perfil guardado o simplemente usar la configuración predeterminada del sistema."
echo -e "${WHITE}-------------------------------${NC}"
AUTORUN_SCRIPT="$HOME/.config/autostart/display_autostart.desktop"
echo -e "${YELLOW}Elige la configuración a aplicar al inicio de sesión:${NC}"
echo -e "${CYAN}1. Aplicar un perfil guardado.${NC}"
echo " Selecciona uno de tus perfiles existentes para cargar al inicio."
echo -e "${CYAN}2. No aplicar ningún perfil (usar la configuración predeterminada o la última manual).${NC}"
echo " El sistema operativo gestionará la configuración de pantalla al inicio, sin cargar un perfil específico de este script."
read -p "Selecciona una opción: " profile_autostart_choice
local AUTORUN_COMMAND=""
case $profile_autostart_choice in
1)
# Permite al usuario seleccionar un perfil existente para el inicio
local profiles_autostart=()
local i=1
echo -e "${YELLOW}Perfiles disponibles para aplicar al inicio:${NC}"
for file in "$PROFILES_DIR"/*.sh; do
if [ -f "$file" ]; then
profile=$(basename "$file" .sh)
profiles_autostart+=("$profile")
echo -e "${CYAN}$i. $profile${NC}"
i=$((i+1))
# Muestra las descripciones de los perfiles si fuera necesario
# (Podrías añadir un comentario al perfil en save_profile para mostrarlo aquí)
fi
done
if [ ${#profiles_autostart[@]} -eq 0 ]; then
echo -e "${RED}❌ No hay perfiles guardados. No se puede configurar el inicio automático con un perfil.${NC}"
notify-send "❌ Fallo al configurar inicio: No hay perfiles."
sleep 3
continue
fi
echo -e "${WHITE}-------------------------------${NC}"
read -p "Selecciona el NÚMERO del perfil a cargar al inicio: " autostart_profile_num
if [[ "$autostart_profile_num" -ge 1 && "$autostart_profile_num" -le ${#profiles_autostart[@]} ]]; then
selected_autostart_profile="${profiles_autostart[$((autostart_profile_num-1))]}"
AUTORUN_COMMAND="bash $PROFILES_DIR/$selected_autostart_profile.sh"
echo -e "${GREEN}✅ Se configurará el perfil '$selected_autostart_profile' al inicio.${NC}"
else
echo -e "${RED}❌ Selección de perfil no válida. No se configurará el inicio automático con perfil.${NC}"
notify-send "❌ Fallo al configurar inicio: Perfil no válido."
sleep 3
continue
fi
;;
2)
AUTORUN_COMMAND="echo 'No se aplica ningún perfil específico al inicio de sesión por este script.'" # Un comando que no hace nada visual, solo para que el .desktop sea válido
echo -e "${YELLOW}Se usará la configuración por defecto o la última aplicada manualmente al inicio.${NC}"
;;
*)
echo -e "${RED}❌ Opción no válida. Volviendo al menú anterior.${NC}"
sleep 2
continue
;;
esac
mkdir -p "$(dirname "$AUTORUN_SCRIPT")"
cat <<EOF > "$AUTORUN_SCRIPT"
[Desktop Entry]
Type=Application
Exec=$AUTORUN_COMMAND
Hidden=false
NoDisplay=false
X-GNOME-Autostart-enabled=true
Name[es_ES]=Configuración de Pantalla al Inicio
Comment[es_ES]=Aplica la configuración de pantalla al inicio de sesión
EOF
chmod +x "$AUTORUN_SCRIPT"
notify-send "🚀 Configuración de pantalla habilitada al inicio de sesión."
echo -e "${GREEN}✅ Configuración habilitada al inicio de sesión. (Archivo: $AUTORUN_SCRIPT)${NC}"
;;
2)
clear
echo -e "${RED}--- Deshabilitar Configuración al Inicio ---${NC}"
echo "Descripción: Elimina la configuración de autoinicio para que las pantallas no se ajusten automáticamente al iniciar sesión."
echo "Instrucciones: No se requiere entrada adicional. La acción se realizará inmediatamente si existe una configuración previa."
echo -e "${WHITE}-------------------------------${NC}"
if [ -f "$HOME/.config/autostart/display_autostart.desktop" ]; then
rm "$HOME/.config/autostart/display_autostart.desktop"
notify-send "⛔ Configuración de pantalla deshabilitada al inicio."
echo -e "${GREEN}✅ Configuración deshabilitada al inicio de sesión.${NC}"
else
echo -e "${YELLOW}ℹ️ No hay configuración de inicio de sesión activa para deshabilitar.${NC}"
fi
;;
3) break ;;
*) echo -e "${RED}❌ Opción no válida, intenta de nuevo.${NC}" ;;
esac
sleep 2
;;
5) echo -e "${RED}Saliendo... ¡Hasta pronto!${NC}"; exit ;;
*) echo -e "${RED}❌ Opción no válida, intenta de nuevo.${NC}" ;;
esac
sleep 2
done
chmod +x nombre_del_script.sh
sudo ./nombre_del_script.sh
