ItsNatTextBasedSharedImpl.java :  » Ajax » ItsNat » org » itsnat » impl » comp » Java Open Source

Java Open Source » Ajax » ItsNat 
ItsNat » org » itsnat » impl » comp » ItsNatTextBasedSharedImpl.java
/*
  ItsNat Java Web Application Framework
  Copyright (C) 2007 Innowhere Software Services S.L., Spanish Company
  Author: Jose Maria Arranz Santamaria

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU Affero General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version. See the GNU Affero General Public 
  License for more details. See the copy of the GNU Affero General Public License
  included in this program. If not, see <http://www.gnu.org/licenses/>.
*/

package org.itsnat.impl.comp;

import org.itsnat.comp.ui.ItsNatTextComponentUI;
import org.itsnat.core.ItsNatException;
import javax.swing.event.DocumentEvent;
import javax.swing.text.AbstractDocument;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import org.itsnat.impl.comp.html.ItsNatHTMLFormComponentImpl;

/**
 *
 * @author jmarranz
 */
public class ItsNatTextBasedSharedImpl
{
    
    /**
     * Creates a new instance of ItsNatTextBasedSharedImpl
     */
    public ItsNatTextBasedSharedImpl()
    {
    }
    
    public static void bindDataModel(ItsNatTextComponentInternal comp)
    {
        // A partir de ahora los cambios los repercutimos en el DOM por eventos
        // No se debe cambiar el DOM por otra va que por el objeto dataModel
        Document dataModel = comp.getDocument();        
        dataModel.addDocumentListener(comp);         
    }   
    
    public static void unbindDataModel(ItsNatTextComponentInternal comp)
    {
        Document dataModel = comp.getDocument();        
        dataModel.removeDocumentListener(comp);         
    }    
    
    public static void syncUIWithDataModel(ItsNatTextComponentInternal comp)    
    {
        ItsNatTextComponentUI compUI = comp.getItsNatTextComponentUI();         
        Document dataModel = comp.getDocument();

        String str;
        try
        {
            str = dataModel.getText(0,dataModel.getLength());            
        }
        catch(BadLocationException ex)
        {
            throw new ItsNatException(ex);
        }        
        
        
        ItsNatHTMLFormComponentImpl compHTML = (ItsNatHTMLFormComponentImpl)comp; // A da de hoy todos los componentes texto son elementos de formulario HTML, en el futuro ya veremos
        // Sincronizamos con el DOM        
        boolean wasDisabled = compHTML.disableSendCodeToRequesterIfServerUpdating(); 
        try
        {          
            compUI.setText(str);
        }
        finally
        {
            if (wasDisabled) compHTML.enableSendCodeToRequester();           
        }        
    }        
        
    public static void insertUpdate(ItsNatTextComponentInternal comp,DocumentEvent e)
    {
        ItsNatTextComponentUI compUI = comp.getItsNatTextComponentUI();         
        // Sincronizamos con el DOM     
        Document dataModel = e.getDocument();
        int offset = e.getOffset();   
        int len = e.getLength();  
        
        String str;
        try
        {        
            str = dataModel.getText(offset,len);                       
        }
        catch(BadLocationException ex)
        {
            throw new ItsNatException(ex);
        }  
        
        // Sincronizamos con el DOM  
        ItsNatHTMLFormComponentImpl compHTML = (ItsNatHTMLFormComponentImpl)comp; // A da de hoy todos los componentes texto son elementos de formulario HTML, en el futuro ya veremos        
        boolean wasDisabled = compHTML.disableSendCodeToRequesterIfServerUpdating(); 
        try
        {             
            compUI.insertString(offset,str);
        }
        finally
        {
            if (wasDisabled) compHTML.enableSendCodeToRequester();           
        }          
    }

    public static void removeUpdate(ItsNatTextComponentInternal comp,DocumentEvent e)
    {
        ItsNatTextComponentUI compUI = comp.getItsNatTextComponentUI();        
        // Sincronizamos con el DOM    
        int offset = e.getOffset();   
        int len = e.getLength();    
                     
        ItsNatHTMLFormComponentImpl compHTML = (ItsNatHTMLFormComponentImpl)comp; // A da de hoy todos los componentes texto son elementos de formulario HTML, en el futuro ya veremos        
        boolean wasDisabled = compHTML.disableSendCodeToRequesterIfServerUpdating(); 
        try
        {        
            compUI.removeString(offset,len); 
        }
        finally
        {
            if (wasDisabled) compHTML.enableSendCodeToRequester();           
        }
    }

    public static void changedUpdate(ItsNatTextComponentInternal comp,DocumentEvent e)
    {
        // No hacemos nada pues no se gestionan atributos
    }
    
    public static String getText(ItsNatTextComponentInternal comp) 
    {
        Document dataModel = comp.getDocument();        
        return getText(comp,0,dataModel.getLength());
    }
    
    public static void setText(ItsNatTextComponentInternal comp,String t) 
    {
        Document dataModel = comp.getDocument();
        replaceString(comp,t,0,dataModel.getLength());
    }    
    
    public static String getText(ItsNatTextComponentInternal comp,int offs, int len)
    {
        Document dataModel = comp.getDocument();
        try
        {
            return dataModel.getText(offs, len);
        }
        catch(BadLocationException ex)
        {
            throw new ItsNatException(ex);
        }            
    }    
    
    public static void appendString(ItsNatTextComponentInternal comp,String str) 
    {
        Document dataModel = comp.getDocument();        
        insertString(comp,str,dataModel.getLength());
    }    
    
    public static void replaceString(ItsNatTextComponentInternal comp,String str, int start, int end)
    {
        if (end < start) 
            throw new ItsNatException("end before start");
        
        Document dataModel = comp.getDocument();
        try 
        {
            if (dataModel instanceof AbstractDocument) 
            {
                ((AbstractDocument)dataModel).replace(start, end - start, str, null);
            }
            else 
            {
                dataModel.remove(start, end - start);
                dataModel.insertString(start, str, null);
            }
        } 
        catch (BadLocationException ex) 
        {
            throw new ItsNatException(ex);
        }      
    }    
    
    public static void insertString(ItsNatTextComponentInternal comp,String str, int pos)
    {    
        Document dataModel = comp.getDocument();
        try 
        {
            dataModel.insertString(pos, str, null);
        }
        catch (BadLocationException ex) 
        {
            throw new ItsNatException(ex);
        }    
    }
    
    public static void remove(ItsNatTextComponentInternal comp,int pos,int length)
    {    
        Document dataModel = comp.getDocument();
        try 
        {
            dataModel.remove(pos,length);
        }
        catch (BadLocationException ex) 
        {
            throw new ItsNatException(ex);
        }    
    }    
    
    public static void fullChange(ItsNatTextComponentInternal comp,String newValue)
    {    
        // Llamado por el evento "change"
        String oldValue = comp.getText(); 
        
        if (oldValue.equals(newValue))
            return; // No ha habido cambio alguno, evitamos repercutir falsos eventos "change" que al parecer se producen
        
        setText(comp,newValue);
    }
    
    public static void incrementalChange(ItsNatTextComponentInternal comp,String newValue)
    {
        // Es especialmente til cuando es llamado por la pulsacin de una tecla, dicha
        // tecla puede ser un cursor que no cambia el texto,
        // un CTRL-V que pega un trozo de texto, un CTRL-X que quita un trozo, el texto seleccionado que
        // es cambiado completamente al pegar otro 
        // etc, adems no sabemos donde se ha puesto el cursor inicialmente pues puede
        // ponerse en el medio del texto box por ejemplo. Por tanto no es posible 
        // "aadir" o "quitar" algo a partir de la tecla pues newValue puede ser muy diferente al valor actual no slo con un caracter cambiado.
        // Cada vez que se pulsa una tecla (keyup) se trae el valor actual del texto en el control
        // sin embargo dicho valor no incluye la posible "nueva" letra (el cambio en general) porque el evento keydown
        // es cancelable por lo que hasta que no se procesa totalmente con xito no se aade
        // al control. Pero el valor actual bien puede ser el valor tras una tecla anterior
        // con lo cual este cambio incremental es interesante porque aunque vayamos con una tecla
        // de retraso vamos cambiando el valor en el servidor.
                
        // Suponemos que una sola parte ha cambiado: o bien eliminada, o bien
        // insertada o bien substituida
        // El objetivo es modificar el Document de forma incremental para que
        // un posible listener sepa qu ha cambiado exactamente
        
        String oldValue = comp.getText(); 
        
        // Si oldValue is igual a newValue se detecta 
        
        int lenOld = oldValue.length();
        int lenNew = newValue.length();       
        if (lenOld > lenNew)
        {
            // Se ha borrado una parte de oldValue
            int start; // Posicin del comienzo de la zona quitada en oldValue
            for(start = 0; start < lenNew; start++)
            {
                if (oldValue.charAt(start) != newValue.charAt(start))
                    break;
            }
            
            int length = lenOld - lenNew;
            String newValueCalc = oldValue.substring(0,start) + oldValue.substring(start + length);
            if (newValueCalc.equals(newValue))
                remove(comp,start,length);
            else
                fullChange(comp,newValue); // Ha habido un cambio ms complicado                                               
        }
        else if (lenOld < lenNew)
        {
            // Se ha insertado una parte en oldValue
            int start; // Posicin del comienzo de la zona insertada en oldValue
            for(start = 0; start < lenOld; start++)
            {
                if (oldValue.charAt(start) != newValue.charAt(start))
                    break;
            }
            int length = lenNew - lenOld;
            String strIns = newValue.substring(start,start + length);
            String newValueCalc = oldValue.substring(0,start) + strIns + oldValue.substring(start);
            if (newValueCalc.equals(newValue))
                insertString(comp,strIns,start);
            else
                fullChange(comp,newValue); // Ha habido un cambio ms complicado                                                       
        }
        else // Se ha cambiado una parte en oldValue
        {
            int start; // Posicin del comienzo de la zona insertada en oldValue
            for(start = 0; start < lenOld; start++)
            {
                if (oldValue.charAt(start) != newValue.charAt(start))
                    break;
            }
            if (start >= lenOld)
                return; // Son iguales, no ha cambiado nada
            
            int end;
            for(end = start; end < lenOld; end++)
            {
                if (oldValue.charAt(end) == newValue.charAt(end))
                    break;
            }            
            String strReplace = newValue.substring(start,end);
            String newValueCalc = oldValue.substring(0,start) + strReplace + oldValue.substring(start + end - start);
            if (newValueCalc.equals(newValue))
                replaceString(comp,strReplace,start,end);  
            else
                fullChange(comp,newValue); // Ha habido un cambio ms complicado                                                       
        }
    }
}
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.