Páginas

Traducir

Cambiar de orden las cuentas de correo con Thunderbird

El cliente de correo Thunderbird no viene con un sistema en el panel de opciones para cambiar de orden las cuentas de correo. Para ello se tendrá que hacer manualmente editando el fichero prefs.js o añadir algún complemento como Manually sort folders 1.1



  • Descargar el complemento Manually sort folders 1.1que será un fichero con extensión .xpi
  • Abrimos Thunderbird
  • En el panel superior hacer clic en icono Mostrar el menú Thunderbird
  • En el desplegable de opciones hacer clic en Complementos
  • Se muestra ventana "Administrador de complementos"
  • Ir a rueda dentada y hacer clic herramientas para todos los complementos
  • En el desplegable de opciones hacer clic en "Instalar complemento desde archivo..."
  • Instalar buscando el complemento que habíamos descargado
  • Una vez instalado ir a ventana "Administrador de complementos"
  • Ir a menú panel izquierdo opción "Extensiones"
  • Seleccionamos el complemento instalado
  • Hacer clic en botón opciones
  • Se muestra nueva ventana "Manually sort folders"
  • Hacer clic en pestaña Ordenar cuentas
  • Mover la cuenta que queremos cambiar de orden con los botones flecha arriba o abajo
  • Por ultimo hacer clic en botón Reiniciar Thunderbird


Acceder a Yahoo Mail o Gmail con Thunderbird. Usar cuenta de correo web en escritorio.

Para acceder a una cuenta de correo web casi siempre se utiliza un navegador tipo Explorer, Firefox, Opera... necesitaremos tener conexión para consultar los correos. Si tenemos varias cuentas de distintos proveedores es difícil de gestionar. Además algunas veces pasa que el acceso mediante navegador es lento especialmente si en el servidor se abusa de la tecnología Ajax.

Si accedemos mediante un programa desde el escritorio a la cuenta lo haremos mediante un cliente de correo y el acceso es algo mas rápido. Además los mensajes se almacenan de forma física en el ordenador pudiéndose consultar sin necesidad de conexión. Es posible la gestión centralizada de varias cuentas de distintos proveedores desde el mismo programa. El cliente siempre deberá estar abierto para que se sincronize con los servidores de correo de cada proveedor recibiendo y enviando mensajes.

En el siguiente ejemplo usaremos una cuenta de correo Yahoo Mail con un cliente de correo gratuito para escritorio llamado Thunderbird.

Preparamos cuenta Yahoo Mail para el cliente de correo.

  • Iniciar sesión de Yahoo Mail
  • Ir al menú superior en el icono de configuración
  • Seleccionar Configuración
  • Elegir Cuentas
  • Ir a Buzones de Correo y hacer clic en la cuenta
  • Vamos a "Acceder a Yahoo Mail desde cualquier otro sitio" para seleccionar POP
  • Elegimos como gestionar los mensajes de spam. Por ejemplo "Descargar spam, pero añadir 'Spam' como prefijo"
  • Hacemos clic en Guardar

Agregaremos Yahoo Mail al cliente de correo Thunderbird.

  • Iniciar Thunderbird
  • Hacer clic en Correo electrónico en "Crear una cuenta nueva"
  • Saldrá una nueva ventana "¿ Le gustaría tener una nueva dirección de correo ?", hacer clic en Saltarse esto y usar mi cuenta de correo existente
  • Seguidamente en la ventana "Configuración de cuenta de correo" rellenamos el formulario con Su nombre:Dirección de correo:Contraseña:
  • Hacer clic en Continuar
  • Se configura automáticamente ya que el proveedor Yahoo esta en la base de datos de Thunderbird
  • Queda seleccionado el protocolo IMAP. Se recomienda IMAP ya que POP3 descarga los mensajes eliminándolos del servidor de Yahoo
  • Hacer clic en Hecho

Gmail con Thunderbird

La configuración de Thunderbird con otros proveedores de cuentas de correo como por ejemplo "Gmail" se hace igual. En el proceso de agregar la cuenta "Gmail" se abrirá automaticamente el navegador pidiendo la contraseña para conectarse al servidor de Gmail y nos avisara que Thunderbird pide permiso para usar la cuenta. Damos el permiso y la cuenta quedará agregada.

Miniprograma que apuesta quinielas de futbol en Java

Vamos a crear un pequeño programa en Java para generar apuestas de futbol. Las apuestas serán del tipo quinielísticas igual que los boletos que se venden en España.

Cada boleto esta compuesto de 8 columnas con 14 partidos. Los partidos de cada columna son apuestas con tres valores 1, X, 2. Si un equipo gana en casa es un 1, si empata es una X y si pierde es un 2. La ultima apuesta o pleno al 15 son los números de goles marcados por cada equipo que juega ese partido 0, 1, 2, M. Donde M es 3 o mas goles.

Lenguaje

Escribiremos el código con programación estructurada en funciones y lenguaje Java SE por ser ejecutable tanto en Windows como en Linux. Usaremos un editor de texto o Eclipse.

Diseño

Nada mas empezar mostraremos un mensaje de bienvenida y el menú con las opciones de pronosticar apuestas, configuración e información sobre la versión del programa.

Sobre las opciones: Apuesta, 1x2%, ?.

  • Apuesta: Elegir 'Empezar' que será la que nos calcule el pronostico y salga por pantalla.
  • 1X2 %: Configuraciones que nos calculara pronósticos al azar según porcentaje elegido.
  • ?: Información sobre la versión del programa.

Código

Escribiremos casi todo el código dentro del método main(). Nombramos a la ventana de la aplicación como 'Quiniela 2000'. La ventana tendrá un tamaño de 220 x 300 pixels no redimensionable.

  
  JFrame ventana = new JFrame("Quiniela 2000");  // Ventana
  ventana.setSize(220, 300); // 220 ancho x 300 alto   
  ventana.setResizable(false); // No dimensionable
  ventana.setVisible(true); // Visible
  ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Lo siguiente será escribir el código del menú con sus tres opciones.

  JMenuBar barraMenu=new JMenuBar(); // Barra menu
  ventana.setJMenuBar(barraMenu);
  JMenu calcular= new JMenu("Apuesta"); // Menu Apuesta
  barraMenu.add(calcular);
  JMenuItem empezar=new JMenuItem("Empezar"); // Submenu Empezar
  calcular.add(empezar);
  JMenu configurar= new JMenu("1X2 %");  // Menu Configurar
  barraMenu.add(configurar);
  ButtonGroup grupo = new ButtonGroup(); // Grupo radioButton
  JRadioButtonMenuItem rbMenuItem1,rbMenuItem2,rbMenuItem3;
  rbMenuItem1=new JRadioButtonMenuItem("55,56 - 33,33 - 11,11"); // Submenu 5-3-1
  rbMenuItem1.setSelected(true); // Por defecto esta opción seleccionada
  grupo.add(rbMenuItem1);
  configurar.add(rbMenuItem1); 
  rbMenuItem2=new JRadioButtonMenuItem("55,56 - 22,22 - 22,22"); // Submenu 5-2-2
  grupo.add(rbMenuItem2); 
  configurar.add(rbMenuItem2);
  rbMenuItem3=new JRadioButtonMenuItem("33,33 - 33,33 - 33,33"); // Submenu 3-3-3
  grupo.add(rbMenuItem3);
  configurar.add(rbMenuItem3); 
  JMenu acercaDe= new JMenu("?"); // Menu Acerca de... 
  barraMenu.add(acercaDe);
  JMenuItem sobreQuiniela=new JMenuItem("Sobre Quiniela"); // Submenu Sobre..
  acercaDe.add(sobreQuiniela);

El mensaje de bienvenida lo escribiremos como una etiqueta centrada en horizontal y vertical dentro de un contenedor tipo JPanel. Este contenedor será el mismo donde también visualizaremos los pronósticos de las apuestas.

  JPanel panel=new JPanel(new GridLayout(1,1));  // Tipo Panel
  JLabel labelBienvenido= new JLabel("¡ Bienvenido a Quiniela 2000 !",SwingConstants.CENTER);
  labelBienvenido.setVerticalAlignment(SwingConstants.CENTER);
  panel.add(labelBienvenido); // Agregar etiqueta a Panel
  ventana.add(panel); // Agregar Panel a Ventana

Ahora nos toca añadir los eventos a cada opción del menú para según lo que se elija hacer una cosa u otra.Con ActionListener y ActionPerformed crearemos la subrutinas de la opciones para los eventos de menú.

Evento accionEmpezar.

Declaramos una variable global llamada 'modoApuesta' que vamos a necesitar en la subrutina del evento para saber que configuración tomar a la hora de representar el pronostico de la apuesta.

  public class Programa  { 
    static int modoApuesta=1;
 
    // Metodo principal 
    public static void main(String[] args) {

Dentro del método principal declaramos el objeto evento accionEmpezar con su código.

  JLabel labelPartido = new JLabel("Partido",SwingConstants.CENTER);
  JLabel labelPronostico= new JLabel("Pronostico",SwingConstants.CENTER);
  Border border = LineBorder.createGrayLineBorder();
  labelPartido.setBorder(border);
  labelPronostico.setBorder(border);

  ActionListener accionEmpezar=new ActionListener() {
    public void actionPerformed(ActionEvent e) {
      panel.setLayout(new GridLayout(17,2));
      panel.removeAll();
      panel.add(labelPartido);
      panel.add(labelPronostico);
      for (int i=1, c;i<=16;i++) {
        if (i<15) c=i; else c=15;
        panel.add(new JLabel(""+c,SwingConstants.CENTER));
        panel.add(new JLabel(generaCasilla(modoApuesta,c),SwingConstants.CENTER));
      }  
      panel.revalidate();
    }
  };

Dentro de la Clase creamos un método generaCasilla() que va a utilizar el evento accionEmpezar que nos da el resultado de la casilla apostada según la variable modoApuesta

  public static String generaCasilla(int modo, int casilla) {
    Random rnd = new Random();
    int num;
  
    if (casilla<15) {
      num = rnd.nextInt(9); // Devuelve 0 a 8 
      switch(modo) {
        case 1: // 55,56 - 33,33 - 11,11
          switch(num) { 
            case 0: case 1: case 2: case 3: case 4: return "1"; 
            case 5: case 6: case 7: return "X"; 
            case 8: return "2"; 
          } break; 
        case 2: // 55,56 - 22,22 - 22,22
          switch(num) {
            case 0: case 1: case 2: case 3: case 4: return "1"; 
            case 5: case 6: return "X";
            case 7: case 8: return "2";
          } break;
        case 3: // 33,33 - 33,33 - 33,33
          switch(num) { 
            case 0: case 1: case 2:   return "1"; 
            case 3: case 4: case 5:   return "X"; 
            case 6: case 7: case 8:   return "2"; 
          } break;
      }
    }
    else {
     num=rnd.nextInt(4); // Devuelve 0 a 3
       switch(num) {
         case 0: return "0";
         case 1: return "1";
         case 2: return "2";
         case 3: return "M";
       }
    }
    return "";
  }

Evento accionConfigura.

Damos valor a la variable global modoApuesta según la opción del menú configura

  String primero = new String("Boton1");
  String segundo = new String("Boton2");
  String tercero = new String("Boton3");
   
  ActionListener accionConfigura=new ActionListener() {
    public void actionPerformed(ActionEvent e) {
      if (e.getActionCommand() == primero) modoApuesta=1;
      else
        if (e.getActionCommand() == segundo) modoApuesta=2;
        else
          if (e.getActionCommand() == tercero) modoApuesta=3;
    }
  };

Evento accionAcercaDe.

Visualizamos una ventana con información del programa con el método JOptionPane.showMessageDialog()

  ActionListener accionAcercaDe=new ActionListener() {
    public void actionPerformed(ActionEvent e) {
      JOptionPane.showMessageDialog(ventana, "Quiniela 2000 Version 1.0",
      "Sobre Quiniela",JOptionPane.INFORMATION_MESSAGE); 
      // El primer parametro muestra ventana en medio
    }
  };

Por último nos queda asignar a cada evento de la opción del menú su rutina.

  empezar.addActionListener(accionEmpezar);
  
  rbMenuItem1.addActionListener(accionConfigura);
  rbMenuItem1.setActionCommand(primero);
   
  rbMenuItem2.addActionListener(accionConfigura);
  rbMenuItem2.setActionCommand(segundo);
   
  rbMenuItem3.addActionListener(accionConfigura);
  rbMenuItem3.setActionCommand(tercero);
      
  sobreQuiniela.addActionListener(accionAcercaDe); 

Código completo

Aquí esta el código completo del programa.

  package com.popularfan.quiniela1;

  import java.awt.GridLayout;
  import java.util.Random;
  import javax.swing.*;
  import java.awt.event.*;
  import javax.swing.border.LineBorder;
  import javax.swing.border.Border;

  public class Programa  { 
 
    static int modoApuesta=1;
 
    // Metodo principal 
 
    public static void main(String[] args) {
 
      // ##################### VENTANA #############################
  
      JFrame ventana = new JFrame("Quiniela 2000");  // Ventana
      ventana.setSize(220, 300); // 220 ancho x 300 alto  
      ventana.setResizable(false); // No dimensionable
      ventana.setVisible(true); // Visible
      ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  
      // ##################### BARRA MENU ##########################
  
      JMenuBar barraMenu=new JMenuBar(); // Barra menu
      ventana.setJMenuBar(barraMenu);
      JMenu calcular= new JMenu("Apuesta"); // Menu Apuesta
      barraMenu.add(calcular);
      JMenuItem empezar=new JMenuItem("Empezar"); // Submenu Empezar
      calcular.add(empezar);
      JMenu configurar= new JMenu("1X2 %");  // Menu Configurar
      barraMenu.add(configurar);
      ButtonGroup grupo = new ButtonGroup(); // Grupo radioButton
      JRadioButtonMenuItem rbMenuItem1,rbMenuItem2,rbMenuItem3;
      rbMenuItem1=new JRadioButtonMenuItem("55,56 - 33,33 - 11,11"); // Submenu 5-3-1
      rbMenuItem1.setSelected(true); // Por defecto esta opción seleccionada
      grupo.add(rbMenuItem1);
      configurar.add(rbMenuItem1); 
      rbMenuItem2=new JRadioButtonMenuItem("55,56 - 22,22 - 22,22"); // Submenu 5-2-2
      grupo.add(rbMenuItem2);
      configurar.add(rbMenuItem2);
      rbMenuItem3=new JRadioButtonMenuItem("33,33 - 33,33 - 33,33"); // Submenu 3-3-3
      grupo.add(rbMenuItem3);
      configurar.add(rbMenuItem3);
      JMenu acercaDe= new JMenu("?"); // Menu Acerca de...
      barraMenu.add(acercaDe);
      JMenuItem sobreQuiniela=new JMenuItem("Sobre Quiniela"); // Submenu Sobre..
      acercaDe.add(sobreQuiniela);
     
      // ##################### PANEL ###############################
  
      JPanel panel=new JPanel(new GridLayout(1,1));  // Tipo Panel
      JLabel labelBienvenido= new JLabel("¡ Bienvenido a Quiniela 2000 !",SwingConstants.CENTER);
      labelBienvenido.setVerticalAlignment(SwingConstants.CENTER);
      panel.add(labelBienvenido); // Agregar etiqueta a Panel
      ventana.add(panel); // Agregar Panel a Ventana
  
      // ##################### EVENTOS MENU  #######################
  
      // Evento Empezar
  
      JLabel labelPartido = new JLabel("Partido",SwingConstants.CENTER);
      JLabel labelPronostico= new JLabel("Pronostico",SwingConstants.CENTER);
      Border border = LineBorder.createGrayLineBorder();
      labelPartido.setBorder(border);
      labelPronostico.setBorder(border);
  
      ActionListener accionEmpezar=new ActionListener() {
        public void actionPerformed(ActionEvent e) {
          panel.setLayout(new GridLayout(17,2));
          panel.removeAll();
          panel.add(labelPartido);
          panel.add(labelPronostico);
          for (int i=1, c;i<=16;i++) {
            if (i<15) c=i; else c=15;
            panel.add(new JLabel(""+c,SwingConstants.CENTER));
            panel.add(new JLabel(generaCasilla(modoApuesta,c),SwingConstants.CENTER));
          }  
          panel.revalidate();
        }
      };
  
      // Evento Configura
    
      String primero = new String("Boton1");
      String segundo = new String("Boton2");
      String tercero = new String("Boton3");
     
      ActionListener accionConfigura=new ActionListener() {
        public void actionPerformed(ActionEvent e) {
          if (e.getActionCommand() == primero) modoApuesta=1;
          else
            if (e.getActionCommand() == segundo) modoApuesta=2;
            else
              if (e.getActionCommand() == tercero) modoApuesta=3;
        }
      };
   
      // Evento Acerca De.. 
  
      ActionListener accionAcercaDe=new ActionListener() {
        public void actionPerformed(ActionEvent e) {
          JOptionPane.showMessageDialog(ventana, "Quiniela 2000 Version 1.0",
          "Sobre Quiniela",JOptionPane.INFORMATION_MESSAGE); // El primer parametro muestra ventana en medio
        }
      };
     
  
      // Asignar cada evento con su opcion de menu
  
      empezar.addActionListener(accionEmpezar);
  
      rbMenuItem1.addActionListener(accionConfigura);
      rbMenuItem1.setActionCommand(primero);
   
      rbMenuItem2.addActionListener(accionConfigura);
      rbMenuItem2.setActionCommand(segundo);
   
      rbMenuItem3.addActionListener(accionConfigura);
      rbMenuItem3.setActionCommand(tercero);
  
      sobreQuiniela.addActionListener(accionAcercaDe);  
    
    }

    // Metodo calcular pronostico casillas
 
    public static String generaCasilla(int modo, int casilla) {
  
      Random rnd = new Random();
      int num;
  
      if (casilla<15) {
        num = rnd.nextInt(9); // Devuelve 0 a 8 
        switch(modo) {
          case 1: // 55,56 - 33,33 - 11,11
            switch(num) { 
              case 0: case 1: case 2: case 3: case 4: return "1"; 
              case 5: case 6: case 7: return "X"; 
              case 8: return "2"; 
            } break; 
          case 2: // 55,56 - 22,22 - 22,22
            switch(num) {
              case 0: case 1: case 2: case 3: case 4: return "1"; 
              case 5: case 6: return "X";
              case 7: case 8: return "2";
            } break;
          case 3: // 33,33 - 33,33 - 33,33
            switch(num) { 
              case 0: case 1: case 2:   return "1"; 
              case 3: case 4: case 5:   return "X"; 
              case 6: case 7: case 8:   return "2"; 
            } break;
       }
     }
     else {
       num=rnd.nextInt(4); // Devuelve 0 a 3
       switch(num) {
         case 0: return "0";
         case 1: return "1";
         case 2: return "2";
         case 3: return "M";
       }
     }
     return "";
   }
 }

"Hola Mundo" en Java e interfaz grafica editado con Eclipse

Se muestra un código de ejemplo en Java SE donde aparece el típico mensaje 'Hola Mundo".

Como editor para introducir el código usaremos el IDE Eclipse. En caso de no tenerlo se puede descargar gratuitamente.

Abrimos el entorno y en la barra de menú superior elegimos: New - Java Project

Se nos abrirá una ventana llamada nuevo proyecto Java ( New Java Project ). Escribimos un nombre de proyecto en el campo de texto Nombre Proyecto ( Project Name ) en este caso lo llamaremos Ventana.

Ahora tendremos una zona en la parte izquierda del editor llamada Explorador de paquetes ( Package Explorer ) donde aparecerá un arbol desplegable con el nombre del paquete Ventana. Pulsamos en el escrito Ventana y aparece desplegado una lista de elementos entre ellos uno llamado src. Pulsamos con el boton derecho del raton y elegimos las opciones New - Class para crear una nueva clase.

En la ventana que se nos abrirá llamada Nueva Clase Java ( New Java Class ) rellenaremos el campo de texto paquete ( Package ) con un nombre. En este caso ponemos com.popularfan.ejemplo1

En el campo de texto Nombre ( Name ) escribimos el nombre de la clase principal que contendrá nuestro programa. Le llamaremos Programa

Ahora con el editor configurado nos queda solo escribir el código para que nos aparezca un ' Hola Mundo ' dentro de una ventana.

Empezamos poniendo el comando

package com.popularfan.ejemplo1; 
que es donde se encontrara el archivo con el código que creamos.

Para mostrar la ventana trabajaremos con la interfaz visual de java llamada Swing. Luego importamos algunos paquetes que contienen clases de esta interfaz que vamos a necesitar como JFrame, JPanel y JLahel.

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JLabel;

La clase JFrame es la encargada de implementar la Ventana que nos mostrara en el sistema operativo.

La clase JPanel es un contenedor de componentes donde podemos poner objetos como etiquetas, botones, cajas de texto, etc..

La clase JLabel es la que define una etiqueta o letrero en nuestro caso tendremos una etiqueta que contiene la frase ' Hola Mundo '

Definimos la clase Programa y dentro definimos el método especial llamado main que será el punto de partida de nuestro programa.

public class Programa {

  public static void main(String[] args) {

  }
}

Dentro del método main creamos tres objetos ventana, panel y etiqueta. Estos objetos los declararemos del tipo que correspondan según la clase JFrame, JPanel o JLabel ademas les reservaremos memoria ( instanciaremos ) con new y las iniciaremos con un valor entre paréntesis si hace falta.

JFrame ventana = new JFrame("Ventana Principal");
JPanel panel = new JPanel();
JLabel etiqueta = new JLabel("¡ Hola Mundo !");

En el código vemos como al objeto ventana le hemos puesto el nombre de "Ventana Principal". El objeto etiqueta contiene la frase "¡ Hola Mundo !".

Seguidamente agregamos el objeto etiqueta al objeto panel que es el que contiene los objetos para mostrar en la ventana.

panel.add(etiqueta);

Finalmente configuramos el objeto ventana con algunos métodos.

ventana.setContentPane(panel);
ventana.setSize(320,200);
ventana.setVisible(true);
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Con el método setContentPane() insertamos el panel que debe visualizar la ventana. Con setSize() configuramos el ancho y alto de la ventana. Con setVisible() hacemos la ventana visible. Con setDafaultCloseOperation() cuando se pulse el botón correspondiente cerrara la ventana y saldremos del programa.

El código final quedara así:

package com.popularfan.ejemplo1; 

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JLabel;

public class Programa {

  public static void main(String[] args) {

    JFrame ventana = new JFrame("Ventana Principal");
    JPanel panel = new JPanel();
    JLabel etiqueta = new JLabel("¡ Hola Mundo !");

    panel.add(etiqueta);
    ventana.setContentPane(panel);
    ventana.setSize(320,200);
    ventana.setVisible(true);
    ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}

Para correr el programa iremos al menú superior con iconos de eclipse y pulsamos el icono verde con triangulito blanco.

Texto en movimiento o 'scroll' con Javascript

" Cuando hablamos de 'scroll' nos referimos al movimiento de un texto, grafico o contenido de un videojuego que se desplaza en horizontal, vertical o ambos por la pantalla. "

Cuando hablamos de 'scroll' nos referimos al movimiento de un texto, grafico o contenido de un videojuego que se desplaza en horizontal, vertical o ambos por la pantalla.

En HTML esto se puede hacer con la etiqueta llamada marquesina o <marquee> pero le falta alguna opción sofisticada, el movimiento puede ser algo brusco y con el nuevo HTML5 pasa a estar obsoleta.

He creado una rutina de 'scroll' simple para agregarla en alguna pagina que estemos realizando, se pueden combinar varios 'scrolls' para hacer efectos interesantes.

Para que funcione tendremos que darle un nombre de identificador en CSS, añadir el 'scroll' a una clase llamada 'Scroll' en Javascript y por ultimo declararlo en HTML para que lo muestre.

Empezamos creando en CSS un nombre de identificador cualquiera por ejemplo 'scroll1' para el contenedor que albergara el texto.

Seguidamente ponemos otro nombre de identificador para una etiqueta <span> que albergara el texto a mover.

Debe quedar asi:

#scroll1
  {
    width:300px;
    background: #cccccc;
    direction: ltr; 
  }
    
#scroll1Frase
  {
    font-style: italic;
    font-weight: bold;
    font-size: 200px;  
    font-family: Arial, sans-serif;
  }  

Se puede ver que en #scroll1 declaramos el sentido en el que se movera el texto que será de derecha a izquierda con 'ltr' para hacerlo de izquierda a derecha simplemente se modifica con 'rtl'. En #scroll1Frase declaramos el formato de texto.

Luego creamos el código JavaScript que nos moverá el texto:

function Scroll(nombre)
  {
    this.id=nombre;
    this.avanza=avanza;
    this.anchoContenedor=document.getElementById(this.id)
    .parentNode.offsetWidth; 
    document.getElementById(this.id)
    .parentNode.style.overflow="hidden";  
    document.getElementById(this.id)
    .parentNode.style.whiteSpace="nowrap";
    document.getElementById(this.id)
    .parentNode.style.textIndent="0px";
    this.el=document.getElementById(this.id).parentNode;
    this.as=this.el.getElementsByTagName("span");     
    this.xo=this.anchoContenedor;
    this.contenido=this.as[0].innerHTML;
    this.anchoTexto=this.as[0].offsetWidth;
    this.dif=this.as[0].offsetWidth-this.xo; 
  }
   
function avanza(velocidad,modo)
  {
    this.as[0].parentNode.style.textIndent=""+this.xo+"px";
    if (this.anchoTexto>this.anchoContenedor) 
      {
        if (modo==0)
          {
            if (this.xo<=-this.dif) 
              this.as[0].innerHTML=this.contenido+this.contenido;

            if (this.xo<=-this.dif-this.anchoContenedor)
             {
               this.as[0].innerHTML=this.contenido;
               this.xo=0;
             } 
          }
     
        if (modo==1)
          if (this.xo<=-this.dif-this.anchoContenedor) 
            this.xo=this.anchoContenedor;
    
        if (modo==2)
          if (this.xo<=-this.dif-this.anchoContenedor) 
            { 
              this.xo=this.xo-velocidad; 
              velocidad=0; 
            }
      }
    else
      { 
        if (modo!=2)
          if (this.xo<=-this.anchoTexto) 
            this.xo=this.anchoContenedor;
          else 
            if (this.xo<=-this.anchoTexto) 
              { 
                this.xo=this.xo-velocidad; 
                velocidad=0; 
              }
      }
    this.xo=this.xo-velocidad;
  }  
  
window.onload=function()
  {
    var scroll1= new Scroll('scroll1Frase');
    window.setInterval( function (){ scroll1.avanza(5,0) }, 10 ); 
    // 5=salto o velocidad en pixels, 10=msg.
  }

Como se puede ver en la parte de codigo de carga en 'window.onload' hemos creado una clase Scroll y luego un objeto de esa clase llamado 'scroll1' en este caso coincide con el nombre declarado en la parte de CSS pero no tiene porque ser igual. En el constructor de la clase tenemos que poner el nombre del identificador de la etiqueta <span> que contendrá el texto. En nuestro caso se llamara 'scroll1Frase' como lo habíamos escrito en CSS.

Con 'window.setInterval' llamamos al método 'avanza()' de la clase Scroll que es el método que nos desplazara el texto.

El método avanza tiene dos parámetros:

El primer parámetro '5' el numero de pixels de desplazamiento.

El segundo parámetro puede ser 0,1 o 2.

0: Repite texto inmediatamente después de acabar.

1: Repite texto pero espera a que la frase acabe.

2: No repite texto.

El numero '10' en setInterval corresponde a una llamada cada 10 milisegundos.

Por ultimo escribiremos la parte de código en HTML que nos falta:

<div id="scroll1">
   <span id="scroll1Frase" >
     Esto es una prueba de texto que se desplaza.
   </span>
</div>

IMPORTANTE: Se tendra siempre que crear un contenedor <div> con identificador y dentro solo una etiqueta <span> con identificador para cada texto en movimiento, sino el resultado no será el esperado. Habrá que crear tambien un objeto nuevo para cada texto que se quiera desplazar por ejemplo scroll2, scroll3...