Changeset 6980


Ignore:
Timestamp:
09/20/10 20:51:41 (9 years ago)
Author:
mlg
Message:

Translation of the comments
French -> English

Location:
extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo
Files:
30 edited

Legend:

Unmodified
Added
Removed
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/Main.java

    r6821 r6980  
    5050    public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory.getLog(Main.class); 
    5151    /** 
    52      * Le manager de login, qui permet de se connecter et  
    53      * de lancer les requetes vers les méthodes du webservice 
     52     * The login and session manager that allows to connect to 
     53     * the webservice and to query it 
    5454     */ 
    5555    public static SessionManager sessionManager; 
    5656 
    5757    /** 
    58      *  La fenetre principale 
     58     *  the main window 
    5959     */ 
    6060    private static MainFrame mainFrame; 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/dao/CategoryDao.java

    r6962 r6980  
    1010import fr.mael.jiwigo.Main; 
    1111import fr.mael.jiwigo.om.Category; 
     12import fr.mael.jiwigo.transverse.enumeration.CategoryEnum; 
    1213import fr.mael.jiwigo.transverse.enumeration.MethodsEnum; 
    1314import fr.mael.jiwigo.transverse.util.Outil; 
     
    4950    public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory.getLog(Main.class); 
    5051    /** 
    51      * Instance, afin d'utiliser un singleton 
     52     * Instance to use a singleton 
    5253     */ 
    5354    private static CategoryDao instance; 
    5455 
    5556    /** 
    56      * Constructeur privé, afin que seule l'instance soit accessible 
     57     * Private constructor to use a singleton 
    5758     */ 
    5859    private CategoryDao() { 
     
    6162 
    6263    /** 
    63      * @return l'instance 
     64     * @return the instance 
    6465     */ 
    6566    public static CategoryDao getInstance() { 
     
    7172 
    7273    /** 
    73      * Lister les catégorie 
    74      * @param rafraichir permet de dire si on utilise les catégories présentes dans le cache ou pas 
    75      * @param recursive listing récursif des catégories 
    76      * @return la liste des catégories 
     74     * Lists the categories 
     75     * @param rafraichir true : uses the categories of the cache 
     76     * @param recursive true : recursive listing of the categories  
     77     * @return the list of categories 
    7778     * @throws IOException  
    7879     */ 
     
    8485        ArrayList<Category> categories = new ArrayList<Category>(); 
    8586        for (Element cat : listElement) { 
    86             Category myCat = new Category(cat); 
     87            Category myCat = new Category(); 
     88            myCat.setIdentifiant(Integer.valueOf(cat.getAttributeValue(CategoryEnum.ID.getLabel()))); 
     89            myCat.setUrlCategory(cat.getAttributeValue(CategoryEnum.URL.getLabel())); 
     90            myCat.setNbImages(Integer.valueOf(cat.getAttributeValue(CategoryEnum.NB_IMAGES.getLabel()))); 
     91            myCat.setNbTotalImages(Integer.valueOf(cat.getAttributeValue(CategoryEnum.NB_TOTAL_IMAGES.getLabel()))); 
     92            myCat.setNom(cat.getChildText(CategoryEnum.NAME.getLabel())); 
     93            String catMeres = cat.getChildText(CategoryEnum.CAT_MERES.getLabel()); 
     94            ArrayList<Integer> idCategoriesMeres = new ArrayList<Integer>(); 
     95            for (String catA : catMeres.split(",")) { 
     96                if (!catA.equals("")) { 
     97                    idCategoriesMeres.add(Integer.valueOf(catA)); 
     98                } 
     99            } 
     100            myCat.setIdCategoriesMeres(idCategoriesMeres); 
    87101            categories.add(myCat); 
    88102        } 
     
    91105 
    92106    /** 
    93      * Création d'une catégorie 
    94      * @param category la catégorie à créer 
    95      * @return true si la catégorie a bien été créée 
     107     * Creation of a category 
     108     * @param category the category to create 
     109     * @return true if the category is successfully created 
    96110     */ 
    97111    public boolean creer(Category category) { 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/dao/CommentDao.java

    r6821 r6980  
    3939   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
    4040    
    41  * Dao des commentaires 
     41 * Dao for the comments 
    4242 * @author mael 
    4343 * 
     
    5050            .getLog(CommentDao.class); 
    5151    /** 
    52      *  Instance qui permet d'utiliser un singleton 
     52     *  Instance that allows to use a singleton 
    5353     */ 
    5454    private static CommentDao instance; 
    5555 
    5656    /** 
    57      * Constructeur privé, pour n'avoir accès qu'au singleton 
     57     * private constructor, to use a singleton 
    5858     */ 
    5959    private CommentDao() { 
     
    6262 
    6363    /** 
    64      * @return le singleton 
     64     * @return the singleton 
    6565     */ 
    6666    public static CommentDao getInstance() { 
     
    7272 
    7373    /** 
    74      * Listing des commentaires pour une image donnée 
    75      * @param idImage identifiant de l'image 
    76      * @return liste des commentaires 
     74     * Listing of the comments for the given image 
     75     * @param idImage id of the  image 
     76     * @return list of comments 
    7777     * @throws IOException  
    7878     */ 
     
    9595 
    9696    /** 
    97      * Recupération de la clé pour l'ajout d'un com 
    98      * @param idImage 
    99      * @return 
     97     * Gets the key essential to add a comment 
     98     * @param idImage the id of the image 
     99     * @return the key 
    100100     * @throws IOException  
    101101     */ 
     
    107107    } 
    108108 
     109    /** 
     110     * Creates a comment 
     111     * @param commentaire the comment to add 
     112     * @return true if the comment is successfully added 
     113     * @throws IOException 
     114     */ 
    109115    public boolean creer(Comment commentaire) throws IOException { 
    110116        String key = getKey(commentaire.getImageId()); 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/dao/ImageDao.java

    r6972 r6980  
    6161 
    6262    /** 
    63      * cache 
     63     * cache to avoid downloading image for each access 
    6464     */ 
    6565    private HashMap<Integer, List<Image>> cache; 
     
    7171 
    7272    /** 
    73      * Constructeur privé, pour n'avoir accès qu'au singleton 
     73     * Private singleton, to use a singleton 
    7474     */ 
    7575    private ImageDao() { 
     
    8888 
    8989    /** 
    90      * Lister toutes les images 
    91      * @return la liste des images 
     90     * Lists all images 
     91     * @return the list of images 
    9292     * @throws IOException  
    9393     */ 
     
    9797 
    9898    /** 
    99      * Listing des images d'une catégorie 
    100      * @param categoryId l'id de la catégorie 
    101      * @return la liste des images 
     99     * Listing of the images for a category 
     100     * @param categoryId the id of the category 
     101     * @return the list of images 
    102102     * @throws IOException  
    103103     */ 
     
    125125 
    126126    /** 
    127      * Creation d'une image.<br/> 
    128      * Dans l'ordre : <br/> 
     127     * Creation of an image<br/> 
     128     * Sequence : <br/> 
    129129     * <li> 
    130      * <ul>envoi de la miniature en base64, grace à la méthode addchunk.</ul> 
    131      * <ul>envoi de l'image originale en base64, grace à la méthode addchunk</ul> 
    132      * <ul>utilisation de la methode add pour ajouter l'image dans la base<ul> 
     130     * <ul>sending of the thumbnail in base64, thanks to the method addchunk.</ul> 
     131     * <ul>sending of the image in base64, thanks to the method addchunk</ul> 
     132     * <ul>using of the add method to add the image to the database<ul> 
    133133     * </li> 
    134      * Pour finir, on vérifie les réponses du webservice. 
     134     * Finally, the response of the webservice is checked 
    135135     *  
    136      * @param image l'image à créer 
    137      * @return true si l'insertiopn de l'image s'est bien passée 
     136     * @param the image to create 
     137     * @return true if the creation of the image was the successful 
    138138     * @throws Exception 
    139139     */ 
    140140    //TODO ne pas continuer si une des réponses précédentes est négative 
    141141    public boolean creer(Image image) throws Exception { 
    142         //on convertit la miniature en string base64 
     142        //thumbnail converted to base64 
    143143        BASE64Encoder base64 = new BASE64Encoder(); 
    144144 
    145145        String thumbnailBase64 = base64.encode(Outil.getBytesFromFile(image.getThumbnail())); 
    146         //on envoie la miniature et on recupere la reponse 
     146        //sends the thumbnail and gets the result  
    147147        Document reponseThumb = (Main.sessionManager.executerReturnDocument("pwg.images.addChunk", "data", 
    148148                thumbnailBase64, "type", "thumb", "position", "1", "original_sum", Outil.getMD5Checksum(image 
     
    167167        //end 
    168168 
    169         //on ajoute l'image en base et on recupere la reponse 
     169        //add the image in the database and get the result of the webservice 
    170170        Document reponseAjout = (Main.sessionManager.executerReturnDocument("pwg.images.add", "file_sum", Outil 
    171171                .getMD5Checksum(image.getOriginale().getAbsolutePath()), "thumbnail_sum", Outil.getMD5Checksum(image 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/dao/TagDao.java

    r6972 r6980  
    1212import fr.mael.jiwigo.om.Tag; 
    1313import fr.mael.jiwigo.transverse.enumeration.MethodsEnum; 
     14import fr.mael.jiwigo.transverse.enumeration.TagEnum; 
    1415import fr.mael.jiwigo.transverse.util.Outil; 
    1516 
     
    5051    public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory.getLog(Main.class); 
    5152    /** 
    52      * Instance, afin d'utiliser un singleton 
     53     * Instance, to use a singleton 
    5354     */ 
    5455    private static TagDao instance; 
    5556 
    5657    /** 
    57      * Constructeur privé, afin que seule l'instance soit accessible 
     58     * private constructor to use a singleton 
    5859     */ 
    5960    private TagDao() { 
     
    6263 
    6364    /** 
    64      * @return l'instance 
     65     * @return the instance 
    6566     */ 
    6667    public static TagDao getInstance() { 
     
    7273 
    7374    /** 
    74      * Lister les tag 
    75      * @return la liste des tags 
     75     * lists the tags 
     76     * @return the list of tags 
    7677     * @throws IOException  
    7778     */ 
     
    9293        List<Element> listElement = (List<Element>) element.getChildren("tag"); 
    9394        ArrayList<Tag> tags = new ArrayList<Tag>(); 
    94         for (Element t : listElement) { 
    95             Tag tag = new Tag(t); 
     95        for (Element tagElement : listElement) { 
     96            Tag tag = new Tag(); 
     97            tag.setId(Integer.valueOf(tagElement.getAttributeValue(TagEnum.ID.getLabel()))); 
     98            tag.setNom(tagElement.getAttributeValue(TagEnum.NAME.getLabel())); 
    9699            tags.add(tag); 
    97100        } 
     
    101104 
    102105    /** 
    103      * Création d'un tag 
    104      * @param tag le tag à créer 
    105      * @return true si le tag a bien été créé 
     106     * Creation of a tag 
     107     * @param tag the tag to create 
     108     * @return true if the tag as been successfully created 
    106109     */ 
    107110    public boolean creer(Tag tag) { 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/om/Category.java

    r6962 r6980  
    44 
    55import org.jdom.Element; 
    6  
    7 import fr.mael.jiwigo.transverse.enumeration.CategoryEnum; 
    86 
    97/** 
     
    4947    private Integer parentDirect; 
    5048 
    51     /** 
    52      * Constructeur. Une categorie est cree a partir de son element xml 
    53      * @param element 
    54      */ 
    55     public Category(Element element) { 
    56         this.element = element; 
    57         this.identifiant = Integer.valueOf(element.getAttributeValue(CategoryEnum.ID.getLabel())); 
    58         this.urlCategory = element.getAttributeValue(CategoryEnum.URL.getLabel()); 
    59         this.nbImages = Integer.valueOf(element.getAttributeValue(CategoryEnum.NB_IMAGES.getLabel())); 
    60         this.nbTotalImages = Integer.valueOf(element.getAttributeValue(CategoryEnum.NB_TOTAL_IMAGES.getLabel())); 
    61         this.nom = element.getChildText(CategoryEnum.NAME.getLabel()); 
    62         String catMeres = element.getChildText(CategoryEnum.CAT_MERES.getLabel()); 
    63         idCategoriesMeres = new ArrayList<Integer>(); 
    64         for (String cat : catMeres.split(",")) { 
    65             if (!cat.equals("")) { 
    66                 idCategoriesMeres.add(Integer.valueOf(cat)); 
    67             } 
    68         } 
     49    public Category() { 
    6950        categoriesFilles = new ArrayList<Category>(); 
    7051        categoriesMeres = new ArrayList<Category>(); 
    71     } 
    72  
    73     public Category() { 
    74         // TODO Auto-generated constructor stub 
    7552    } 
    7653 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/om/Comment.java

    r6821 r6980  
    11package fr.mael.jiwigo.om; 
    2  
    3 import org.jdom.Element; 
    42 
    53/** 
     
    4038    private Integer identifiant; 
    4139    private String date; 
    42  
    43     public Comment(Element element) { 
    44         this.identifiant = Integer.valueOf(element.getAttributeValue("id")); 
    45         this.date = element.getAttributeValue("date"); 
    46         this.author = element.getChildText("author"); 
    47         this.content = element.getChildText("content"); 
    48  
    49     } 
    50  
    51     public Comment() { 
    52  
    53     } 
    5440 
    5541    /** 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/om/Tag.java

    r6968 r6980  
    11package fr.mael.jiwigo.om; 
    2  
    3 import org.jdom.Element; 
    4  
    5 import fr.mael.jiwigo.transverse.enumeration.TagEnum; 
    62 
    73/** 
     
    4642 
    4743    /** 
    48      * Empty constructor 
    49      */ 
    50     public Tag() { 
    51     } 
    52  
    53     /** 
    54      * @param element the element in the RPC response 
    55      */ 
    56     public Tag(Element element) { 
    57         this.identifiant = Integer.valueOf(element.getAttributeValue(TagEnum.ID.getLabel())); 
    58         this.nom = element.getAttributeValue(TagEnum.NAME.getLabel()); 
    59     } 
    60  
    61     /** 
    62      * @param nom the name of the tag 
    63      */ 
    64     public Tag(String nom) { 
    65         this.nom = nom; 
    66     } 
    67  
    68     /** 
    6944     * @return the nom 
    7045     */ 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/service/CategoryService.java

    r6962 r6980  
    5050 
    5151    /** 
    52      * @return le singleton 
     52     * @return the singleton 
    5353     */ 
    5454    public static CategoryService getInstance() { 
     
    6060 
    6161    /** 
    62      * Constructeur privé, pour n'avoir accès qu'au singleton 
     62     * private constructor to use a singleton 
    6363     */ 
    6464    private CategoryService() { 
     
    6767 
    6868    /** 
    69      * Listing des categories 
    70      * @param rafraichir utilisation du cache ou non 
    71      * @param recursive 
    72      * @return la liste des catégories 
     69     * Lists all categories 
     70     * @param rafraichir true to refresh 
     71     * @param recursive true : recursive listing 
     72     * @return the list of categories 
    7373     * @throws IOException  
    7474     */ 
     
    7878 
    7979    /** 
    80      * Fonction qui permet de construire l'arbre des categorie 
    81      * En association catégories mères/catégories filles 
    82      * @return la liste des catégories 
     80     * Allows to create the categories tree 
     81     * @return list of categories 
    8382     * @throws IOException  
    8483     */ 
     
    102101 
    103102    /** 
    104      * Création d'une catégorie 
    105      * @param nom nom de la catégorie 
    106      * @param parent catégorie parent 
    107      * @return true si la catégorie a bien été créée 
     103     * creation of a category 
     104     * @param nom name of the category 
     105     * @param parent parent category 
     106     * @return true if successful 
    108107     */ 
    109108    public boolean creer(String nom, Integer parent) { 
     
    115114 
    116115    /** 
    117      * Création d'une catégorie 
    118      * @param nom nom de la catégorie 
    119      * @param parent catégorie parent 
    120      * @return true si la catégorie a bien été créée 
     116     * creation of a category without parent 
     117     * @param nom name of the category 
     118     * @return true if successful 
    121119     */ 
    122120    public boolean creer(String nom) { 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/service/CommentService.java

    r6821 r6980  
    5050 
    5151    /** 
    52      * @return le singleton 
     52     * @return the singleton 
    5353     */ 
    5454    public static CommentService getInstance() { 
     
    6060 
    6161    /** 
    62      * Constructeur privé, pour n'avoir accès qu'au singleton 
     62     * private constructor, to use a singleton 
    6363     */ 
    6464    private CommentService() { 
     
    6767 
    6868    /** 
    69      * Listing des commentaires pour une image 
    70      * @param imageId id de l'image 
    71      * @return la liste des commentaires 
     69     * Lists all comments for an image 
     70     * @param imageId the id of the image 
     71     * @return the list of comments 
    7272     * @throws IOException  
    7373     */ 
     
    7676    } 
    7777 
     78    /** 
     79     * Creates a comment for an image 
     80     * @param content the comment 
     81     * @param imageId the id of the image 
     82     * @param auteur the author of the comment 
     83     * @return true if successful 
     84     * @throws IOException 
     85     */ 
    7886    public boolean creer(String content, Integer imageId, String auteur) throws IOException { 
    7987        Comment commentaire = new Comment(); 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/service/ImageService.java

    r6972 r6980  
    5151            .getLog(ImageService.class); 
    5252 
     53    /** 
     54     * Singleton 
     55     */ 
    5356    private static ImageService instance; 
    5457 
     58    /** 
     59     * @return the singleton 
     60     */ 
    5561    public static ImageService getInstance() { 
    5662        if (instance == null) { 
     
    6066    } 
    6167 
     68    /** 
     69     * private constructor to use a singleton 
     70     */ 
    6271    private ImageService() { 
    6372 
    6473    } 
    6574 
     75    /** 
     76     * Lists all images for a category 
     77     * @param categoryId the id of the category 
     78     * @param rafraichir true : refresh the list of images 
     79     * @return the list of images 
     80     * @throws IOException 
     81     */ 
    6682    public List<Image> listerParCategory(Integer categoryId, boolean rafraichir) throws IOException { 
    6783        return ImageDao.getInstance().listerParCategory(categoryId, rafraichir); 
     
    7086    /** 
    7187     * Method called to send an image to the server. 
    72       
    7388     * @param filePath 
    7489     * @param idCategory 
     
    7792     */ 
    7893    public boolean creer(String filePath, Integer idCategory) throws Exception { 
    79         MainFrame.getInstance().setReussiteMessage(Messages.getMessage("mainFrame_resizing") + " " + filePath); 
     94        MainFrame.getInstance().setMessage(Messages.getMessage("mainFrame_resizing") + " " + filePath); 
    8095        //get the byte array of the original file, to keep metadata 
    8196        byte[] bytesFichierOriginal = Outil.getBytesFromFile(new File(filePath)); 
     
    98113            //I use here a try catch because if the original file isn't a jpeg 
    99114            //the methode Outil.enrich will fail, but the procedure has to continue 
    100             MainFrame.getInstance().setReussiteMessage(Messages.getMessage("mainFrame_addMetadata") + " " + filePath); 
     115            MainFrame.getInstance().setMessage(Messages.getMessage("mainFrame_addMetadata") + " " + filePath); 
    101116            try { 
    102117                byte[] fichierEnrichi = Outil.enrich(bytesFichierOriginal, Outil.getBytesFromFile(new File(System 
     
    115130        image.setOriginale(originale); 
    116131        image.setIdCategory(idCategory); 
    117         MainFrame.getInstance().setReussiteMessage(Messages.getMessage("mainFrame_sendingFiles") + " " + filePath); 
     132        MainFrame.getInstance().setMessage(Messages.getMessage("mainFrame_sendingFiles") + " " + filePath); 
    118133        //now we call the dao to send the image to the webservice 
    119134        return ImageDao.getInstance().creer(image); 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/service/TagService.java

    r6968 r6980  
    4545            .getLog(TagService.class); 
    4646 
     47    /** 
     48     * The instance, to use a singleton 
     49     */ 
    4750    private static TagService instance; 
    4851 
     52    /** 
     53     * @return the singleton 
     54     */ 
    4955    public static TagService getInstance() { 
    5056        if (instance == null) { 
     
    7783     */ 
    7884    public boolean creer(String nom) throws IOException { 
    79         Tag tag = new Tag(nom); 
     85        Tag tag = new Tag(); 
     86        tag.setNom(nom); 
    8087        return TagDao.getInstance().creer(tag); 
    8188    } 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/transverse/enumeration/MethodsEnum.java

    r6972 r6980  
    3030   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
    3131    
    32  * Listing des méthodes du webservice 
     32 * Lists the methods of the webservice 
    3333 * @author mael 
    3434 * 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/transverse/session/SessionManager.java

    r6965 r6980  
    5252            .getLog(SessionManager.class); 
    5353    /** 
    54      * Le login entré 
     54     * the entered login 
    5555     */ 
    5656    private String login; 
    5757    /** 
    58      * Le mot de passe entré 
     58     * the entered password 
    5959     */ 
    6060    private String motDePasse; 
    6161    /** 
    62      * l'url du site 
     62     * the url of the site 
    6363     */ 
    6464    private String url; 
    6565    /** 
    66      * le client http 
     66     * the http client 
    6767     */ 
    6868    private HttpClient client; 
    6969 
    7070    /** 
    71      * Constructeur 
    72      * @param login le login 
    73      * @param motDePasse le mot de passe 
    74      * @param url l'url du site 
     71     * Constructor 
     72     * @param login the login 
     73     * @param motDePasse the password 
     74     * @param url the url of the site 
    7575     */ 
    7676    public SessionManager(String login, String motDePasse, String url) { 
     
    7979        this.url = url + "/ws.php"; 
    8080        client = new HttpClient(); 
    81         //utilisation d'un useragent linux, parce que c'est mieux 8) 
     81        //Using of a Linux user agent. cause... it's better 8) 
    8282        client.getParams().setParameter("http.useragent", 
    8383                "Mozilla/5.0 (X11; U; Linux i686; fr; rv:1.9.1.1) Gecko/20090715 Firefox/3.5.1"); 
     
    8585 
    8686    /** 
    87      * Methode de connexion 
    88      * @return true si la connexion s'est bien deroulee 
     87     * Connection method 
     88     * @return true if successful 
    8989     */ 
    9090    public boolean processLogin() { 
     
    101101 
    102102    /** 
    103      * Execute une methode sur le web service et retourne le resultat sous forme de string 
    104      * @param methode la methode a executer 
    105      * @param parametres les parametres a  ajouter a la methode. doit etre un nombre pair : la cle suivie de sa valeur 
    106      * @return le resultat 
     103     * Executes a method on the webservice and returns the result as a string 
     104     * @param methode the method to execute 
     105     * @param parametres the parameters of the method. Must be even : the name of the parameter followed by its value 
     106     * @return the result 
    107107     */ 
    108108    public String executerReturnString(String methode, String... parametres) { 
     
    150150 
    151151    /** 
    152      * Execute une methode sur le webservice et renvoie le resultat sous form de document jdom 
    153      * @param methode la methode a executer 
    154      * @param parametres les parametres a  ajouter a la methode. doit etre un nombre pair : la cle suivie de sa valeur 
    155      * @return le resultat 
     152     * Executes a method on the webservice and returns the result as a Dom document 
     153     * @param methode the method to execute 
     154     * @param parametres the parameters of the method. Must be even : the name of the parameter followed by its value 
     155     * @return the result 
    156156     * @throws IOException  
    157157     */ 
     
    168168 
    169169    /** 
    170      * Execute une methode sur le webservice et renvoie le resultat sous form de document jdom 
    171      * @param methode la methode a executer 
    172      * @return le resultat 
     170     * Executes a method on the webservice and returns the result as a Dom document 
     171     * @param methode the method to execute 
     172     * @return the result 
    173173     */ 
    174174    public Document executerReturnDocument(String methode) { 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/transverse/util/ImagesUtil.java

    r6958 r6980  
    6565 
    6666    /** 
    67      * Fonction de rotation d'une image 
    68      * @param image l'image à tourner 
    69      * @param angle l'angle de rotation 
    70      * @return l'image pivotée 
     67     * rotates an image 
     68     * @param image the image to rotate 
     69     * @param angle the angle of rotation 
     70     * @return the rotated image 
    7171     */ 
    7272    public static BufferedImage rotate(BufferedImage image, double angle) { 
     
    9494 
    9595    /** 
    96      * Ecriture d'une image dans un fichier png 
    97      * @param file le fichier 
    98      * @param bufferedImage l'image 
     96     * Writes an image in a file 
     97     * @param file the file 
     98     * @param bufferedImage the image 
    9999     * @throws IOException 
    100100     */ 
     
    104104 
    105105    /** 
    106      * Mise à l'échelle d'une image 
    107      * @param filePath le chemin vers le fichier de l'image 
    108      * @param tempName le nom du fichier résultat 
    109      * @param width la largeur 
    110      * @param height la hauteur 
    111      * @return true si l'image a effectivement ete redimensionnee 
     106     * scales an image 
     107     * @param filePath the path to the file of the image 
     108     * @param tempName the name of the resulting file 
     109     * @param width the width 
     110     * @param height the height 
     111     * @return true if successful 
    112112     * @throws Exception 
    113113     */ 
     
    120120        int imageWidth = image.getWidth(null); 
    121121        int imageHeight = image.getHeight(null); 
    122         //on n'agrandit pas l'image 
    123122        if (imageWidth < width || imageHeight < height) { 
    124123            return false; 
     
    141140    } 
    142141 
     142    /** 
     143     * Save an image 
     144     * @param fileName the name of the file 
     145     * @param img the img 
     146     * @throws FileNotFoundException 
     147     * @throws IOException 
     148     */ 
    143149    private static void saveImage(String fileName, BufferedImage img) throws FileNotFoundException, IOException { 
    144150        Iterator iter = ImageIO.getImageWritersByFormatName("jpeg"); 
     
    205211    } 
    206212 
    207     // This method returns true if the specified image has transparent pixels 
     213    /** 
     214     *  This method returns true if the specified image has transparent pixels 
     215     * @param image the image to check 
     216     * @return true or false 
     217     */ 
    208218    public static boolean hasAlpha(Image image) { 
    209219        // If buffered image, the color model is readily available 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/transverse/util/Messages.java

    r6979 r6980  
    3737    
    3838 * @author mael 
    39  * Gestion des messages pour les traductions 
     39 * management of the messages for the translations 
    4040 */ 
    4141public class Messages { 
     
    4444 
    4545    /** 
    46      * Recuperation d'un message 
    47      * @param key clé du message 
    48      * @return le message 
     46     * returns a message 
     47     * @param key the key of the message 
     48     * @return the message 
    4949     */ 
    5050    public static String getMessage(String key) { 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/transverse/util/Outil.java

    r6965 r6980  
    6969 
    7070    /** 
    71      * Transformation d'un inputstream en string.<br/> 
    72      * Util pour lire la réponse du webservice 
    73      * @param input le stream 
    74      * @return la string 
     71     * Transformation of an inpustream into string.<br/> 
     72     * useful to read the result of the webservice 
     73     * @param input the stream 
     74     * @return the string 
    7575     * @throws IOException 
    7676     */ 
    7777    public static String readInputStreamAsString(InputStream input) throws IOException { 
    78         //      DataInputStream dis = new DataInputStream(new BufferedInputStream(input)); 
    79         // 
    80         //      String temp; 
    81         //      StringBuffer buffer = new StringBuffer(); 
    82         //      while ((temp = dis.readLine()) != null) { 
    83         //          buffer.append(temp); 
    84         //      } 
    85         //      return buffer.toString(); 
    8678        StringWriter writer = new StringWriter(); 
    8779        InputStreamReader streamReader = new InputStreamReader(input); 
    88         //le buffer permet le readline 
    8980        BufferedReader buffer = new BufferedReader(streamReader); 
    9081        String line = ""; 
     
    9283            writer.write(line); 
    9384        } 
    94         // Sortie finale dans le String 
    9585        return writer.toString(); 
    9686    } 
    9787 
    9888    /** 
    99      * Transformation d'une string en document 
    100      * @param string la string 
    101      * @return le document correspondant 
     89     * String to document 
     90     * @param string the string 
     91     * @return the corresponding document 
    10292     * @throws JDOMException 
    10393     * @throws IOException 
     
    10595    public static Document stringToDocument(String string) throws JDOMException, IOException { 
    10696        SAXBuilder sb = new SAXBuilder(); 
    107         //      System.out.println(string); 
    10897        Document doc = sb.build(new StringReader(string)); 
    10998        return doc; 
     
    112101 
    113102    /** 
    114      * Transformation d'un inputstream en document 
    115      * @param input l'inputstream 
    116      * @return le document 
     103     * Inputstream to document 
     104     * @param input the inputStream 
     105     * @return the document 
    117106     * @throws JDOMException 
    118107     * @throws IOException 
     
    123112 
    124113    /** 
    125      * Transformation d'un document en string 
    126      * @param doc le document à transformer 
    127      * @return la string 
     114     * Document to string 
     115     * @param doc the document to transform 
     116     * @return the string 
    128117     */ 
    129118    public static String documentToString(Document doc) { 
     
    133122 
    134123    /** 
    135      * Fonction qui retour l'url d'un fichier donné. 
    136      * Utile pour récupérer le chemin des images à l'intérieur du jar 
    137      * @param fileName le chemin du fichier 
    138      * @return l'url 
     124     * Function that gets the url of a file 
     125     * Useful to get the images that are in the jar 
     126     * @param fileName the path of the file 
     127     * @return the url of the file 
    139128     */ 
    140129    public static URL getURL(String fileName) { 
     
    145134 
    146135    /** 
    147      * Fonction qui retourne la somme de controle MD5 d'un fichier donné 
    148      * @param filename le chemin du fichier 
    149      * @return la somme de controle 
     136     * gets the md5 sum of a file 
     137     * @param filename the path of the file 
     138     * @return the checksum 
    150139     * @throws Exception 
    151140     */ 
     
    160149 
    161150    /** 
    162      * Creation de la somme de controle d'un fichier 
    163      * @param filename le chemin du fichier 
    164      * @return la somme de controle sous forme de byte[] 
     151     * Creation of the checksum of a file 
     152     * @param filename the path of the file 
     153     * @return the checksum as array byte 
    165154     * @throws Exception 
    166155     */ 
     
    182171 
    183172    /** 
    184      * Fonction qui transforme un fichier en tableau de bytes 
    185      * @param file le fichier 
    186      * @return le tableau de bytes 
     173     * File to array bytes 
     174     * @param file the file 
     175     * @return the array bytes 
    187176     * @throws IOException 
    188177     */ 
     
    206195 
    207196    /** 
    208      * Fonction qui vérifie que si la réponse du webservice est positive 
    209      * @param doc le document que retourne le webservice 
    210      * @return true si c'est ok 
     197     * Function that checks if the webservice response is ok 
     198     * @param doc the document from the webservice 
     199     * @return true if ok 
    211200     */ 
    212201    public static boolean checkOk(Document doc) { 
     
    298287    } 
    299288 
     289    /** 
     290     * Bytes to file 
     291     * @param fichier the file path 
     292     * @param bytes the array bytes 
     293     * @throws IOException 
     294     */ 
    300295    public static void byteToFile(String fichier, byte[] bytes) throws IOException { 
    301296        FileOutputStream fos = new FileOutputStream(fichier); 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/transverse/util/preferences/PreferencesManagement.java

    r6959 r6980  
    4949 
    5050    /** 
    51      * fonction qui retourne le chemin du fichier de configuration 
     51     * function that returns the path of the configuration file 
    5252     * @return 
    5353     */ 
     
    5757 
    5858    /** 
    59      * Creation du fichier de configuration par défaut 
     59     * Creation of the default file configuration 
    6060     * @throws IOException 
    6161     */ 
     
    8282 
    8383    /** 
    84      * Fonction qui retourne la valeur d'une préférence 
    85      * @param key la cle de la preference 
    86      * @return la valeur 
     84     * Function that returns the value of a preference 
     85     * @param key the key of the preference 
     86     * @return the value 
    8787     */ 
    8888    public static String getValue(String key) { 
     
    9898 
    9999    /** 
    100      * Fonction qui attribue une valeur à une préférence 
    101      * @param key la cle 
    102      * @param text la valeur 
     100     * Function that gives a value to a preference key 
     101     * @param key the key 
     102     * @param text the value 
    103103     */ 
    104104    public static void setValue(String key, String text) { 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/ConnexionDialog.java

    r6979 r6980  
    6969            .getLog(ConnexionDialog.class); 
    7070    /** 
    71      * field contenant l'url 
     71     * field that contains the url 
    7272     */ 
    7373    private JTextField fieldUrl; 
    7474    /** 
    75      * field contenant le login 
     75     * field that contains the login 
    7676     */ 
    7777    private JTextField loginField; 
    7878    /** 
    79      * field contenant le mot de passe 
     79     * field that contains de password 
    8080     */ 
    8181    private JPasswordField passwordField; 
    8282    /** 
    83      * label de l'url 
     83     * label of the url field 
    8484     */ 
    8585    private JLabel labelUrl; 
    8686    /** 
    87      * label du login 
     87     * label of the login field 
    8888     */ 
    8989    private JLabel labelLogin; 
    9090    /** 
    91      *  label du mot de passe 
     91     *  label of the password field 
    9292     */ 
    9393    private JLabel labelPass; 
    9494    /** 
    95      * bouton ok, pour la connexion 
     95     * ok button for the connection 
    9696     */ 
    9797    private JButton boutonOk; 
    9898 
    9999    /** 
    100      * Box qui permet de retenir les informations 
     100     * Box that allows to save informations 
    101101     */ 
    102102    private JCheckBox checkBoxRetenir; 
     
    108108 
    109109    /** 
    110      * Constructeur  
     110     * Constructor  
    111111     */ 
    112112    public ConnexionDialog() { 
     
    181181    @Override 
    182182    public void actionPerformed(ActionEvent paramActionEvent) { 
    183         //si un des champs est vide, on affiche une erreur 
     183        //if one field is empty, an error is displayed 
    184184        if (fieldUrl.getText().equals("") || loginField.getText().equals("") || passwordField.getText().equals("")) { 
    185185            JOptionPane.showMessageDialog(null, Messages.getMessage("connexionDialog_emptyField"), Messages 
     
    189189                fieldUrl.setText("http://" + fieldUrl.getText()); 
    190190            } 
    191             //sinon, on instancie le session manager de la classe principale 
     191            //instanciation of the session manager 
    192192            Main.sessionManager = new SessionManager(loginField.getText(), passwordField.getText(), fieldUrl.getText()); 
    193193            if (checkBoxRetenir.isSelected()) { 
     
    201201            } 
    202202            if (!Main.sessionManager.processLogin()) { 
    203                 //si le login a échoué, on affiche une erreur 
     203                //if the login fails, an error is displayed 
    204204                JOptionPane.showMessageDialog(null, Messages.getMessage("connexionDialog_connexionError"), Messages 
    205205                        .getMessage("error"), JOptionPane.ERROR_MESSAGE); 
     
    207207                //              Locale.setDefault((Locale) comboLocales.getSelectedItem()); 
    208208                Main.showFrame(); 
    209                 //on cache le dialog de connexion 
     209                //hides the dialog 
    210210                this.dispose(); 
    211211            } 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/ImagesManagement.java

    r6958 r6980  
    3838    
    3939 * @author mael 
    40  * Classe de gestion des images à taille relle. 
    41  * mettre tout en static permet d'y accéder depuis les différentes classes qui en ont besoin 
     40 * Management of the real sized pictures 
    4241 */ 
    4342public class ImagesManagement { 
     
    4847            .getLog(ImagesManagement.class); 
    4948    /** 
    50      * L'index de l'image courante dans la liste 
     49     * the index of the current image 
    5150     */ 
    5251    public static int CURRENT_IMAGE_INDEX; 
    5352    /** 
    54      * l'image courante 
     53     * the current image 
    5554     */ 
    5655    public static Image CURRENT_IMAGE; 
    5756    /** 
    58      * la liste des images 
     57     * images list 
    5958     */ 
    6059    public static List<Image> LIST_IMAGE; 
    6160 
    6261    /** 
    63      * cache permettant de ne pas recharger les images à chaque fois 
     62     * cache allows to keep the images in the ram 
    6463     */ 
    6564    private static HashMap<Integer, BufferedImage> IMAGES_CACHE = new HashMap<Integer, BufferedImage>(); 
    6665 
    6766    /** 
    68      * cache permettant de ne pas recharger les images à chaque fois 
     67     * cache allows to keep the thumbnails in the ram 
    6968     */ 
    7069    private static HashMap<Integer, BufferedImage> MINIATURE_CACHE = new HashMap<Integer, BufferedImage>(); 
    7170 
    7271    /** 
    73      * Récupération de l'image courante 
    74      * @return l'image 
     72     * gets the current image 
     73     * @return the image 
    7574     */ 
    7675    public static Image getCurrentImage() { 
     
    8079 
    8180    /** 
    82      * passage à l'image suivante 
     81     * next image 
    8382     */ 
    8483    public static void next() { 
     
    9291 
    9392    /** 
    94      * passage à l'image précédente 
     93     * previous image 
    9594     */ 
    9695    public static void previous() { 
     
    105104    /** 
    106105     *  
    107      * @param image l'image courante 
     106     * @param image the current image 
    108107     */ 
    109108    public static void setCurrentImage(Image image) { 
     
    119118 
    120119    /** 
    121      * Fonction qui permet de ne charger les images qu'une seule fois 
    122      * afin d'améliorer les temps de réponses en ne consommant pas de bande passante. 
    123      * @return l'image 
     120     * Function that allows to load images once 
     121     * to decrease response delays 
     122     * @return the image 
    124123     */ 
    125124    public static BufferedImage getCurrentBufferedImage() { 
     
    136135 
    137136    /** 
    138      * Fonction qui permet de ne charger les images qu'une seule fois 
    139      * afin d'améliorer les temps de réponses en ne consommant pas de bande passante. 
    140      * @return l'image 
     137     * Function that allows to load thimbnails once 
     138     * to decrease response delays 
     139     * @return the image 
    141140     */ 
    142141    public static BufferedImage getMiniatureBufferedImage(Image image) { 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/browser/BrowserFrame.java

    r6966 r6980  
    7575            .getLog(BrowserFrame.class); 
    7676    /** 
    77      * bouton pour passer à l'image suivante 
     77     * bouton to go to the  next image 
    7878     */ 
    7979    private JButton next = new JButton(); 
    8080    /** 
    81      * bouton pour passer à l'image précédente 
     81     * bouton to go to the previous image 
    8282     */ 
    8383    private JButton previous = new JButton(); 
    8484    /** 
    85      * rotation de l'image vers la gauche 
     85     * rotation on the left 
    8686     */ 
    8787    private JButton rotateLeft = new JButton(); 
    8888    /** 
    89      * rotation de l'image vers la droite 
     89     * rotation on the right 
    9090     */ 
    9191    private JButton rotateRight = new JButton(); 
    9292    /** 
    93      * sauvegarde de l'image 
     93     * saves the image 
    9494     */ 
    9595    private JButton save = new JButton(); 
    9696    /** 
    97      * affichage des commentaire de l'image 
     97     * displays the comments for the current image 
    9898     */ 
    9999    private JButton comment = new JButton(); 
    100100    /** 
    101      * panel contenant tous les boutons précédents 
     101     * panel that contains the previous buttons 
    102102     */ 
    103103    private JPanel panelBoutons; 
    104104 
    105105    /** 
    106      * rogner l'image 
     106     * clip the image 
    107107     */ 
    108108    private JButton cut = new JButton(); 
     
    129129     * Il est instancié et ajouté à la création de la frame, et retiré lorsqu'on la quitte 
    130130     */ 
     131    @Deprecated 
    131132    private AWTEventListener generalListener; 
    132133 
     
    206207        this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 
    207208        setUpMenu(); 
    208         //instanciation du listener general 
    209209        this.generalListener = new AWTEventListener() { 
    210210 
     
    222222        this.setVisible(true); 
    223223 
    224         //ajout du listener general 
    225224        //Toolkit.getDefaultToolkit().addAWTEventListener(generalListener, AWTEvent.KEY_EVENT_MASK); 
    226225 
     
    290289    public void dispose() { 
    291290        super.dispose(); 
    292         //on enleve le listener general 
    293291        Toolkit.getDefaultToolkit().removeAWTEventListener(generalListener); 
    294292    } 
     
    299297            new CommentsDialog(this, ImagesManagement.getCurrentImage().getIdentifiant()); 
    300298        } else if (e.getSource().equals(save)) { 
    301             //ouverture du dialog de sauvegarde d'une image 
     299            //opens the dialog to save the file 
    302300            JFileChooser chooser = new JFileChooser(); 
    303301            if (JFileChooser.APPROVE_OPTION == chooser.showSaveDialog(null)) { 
     
    305303                if (chosenFile.getName().endsWith(".png")) { 
    306304                    try { 
    307                         //sauvegarde de l'image 
     305                        //saves the image 
    308306                        ImagesUtil.writeImageToPNG(chosenFile, imagePanel.getImage()); 
    309307                    } catch (IOException ex) { 
     
    321319        } else if (e.getSource().equals(next)) { 
    322320            imagePanel.setDrawSelection(false); 
    323             //on appelle d'abord la fonction de l'images panel qui increment l'image courante 
    324321            ImagesManagement.next(); 
    325             //on rafraichit le panel qui contient l'image 
    326322            BufferedImage img; 
    327323            try { 
     
    334330        } else if (e.getSource().equals(previous)) { 
    335331            imagePanel.setDrawSelection(false); 
    336             //on appelle d'abord la fonction de l'images panel qui décrémente l'image courante 
    337332            ImagesManagement.previous(); 
    338             //on rafraichit le panel qui contient l'image 
    339333            BufferedImage img; 
    340334            try { 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/browser/BrowserImagePanel.java

    r6966 r6980  
    7272 
    7373    /** 
    74      * Constructeur 
    75      * @param image 
     74     * Constructor 
     75     * @param image the image 
    7676     */ 
    7777    public BrowserImagePanel(BufferedImage image) { 
     
    122122    public void rogner() { 
    123123        if (scale == 1.0) { 
    124             //récupération des dimensions de l'image 
     124            //gets the dimensions of the image 
    125125            Double width = getSize().getWidth(); 
    126126            Double height = getSize().getHeight(); 
    127             //recuperation du coin haut gauche de l'image 
     127            //get the top left corner 
    128128            Double xZeroImage = ((width - image.getWidth()) / 2); 
    129129            Double yZeroImage = ((height - image.getHeight()) / 2); 
    130             //les positions du premier clic 
    131             //sur l'image. Les positions récupérées précédemment étaient 
    132             //les positions sur le panel, il faut donc calculer les positions sur l'image 
     130            //the position of the first click on the imagee 
     131            //The previous positions where the ones on the panel 
     132            //have to calculate the position on the image 
    133133            int positionX, positionY; 
    134             //largeur et longueur du rognage sur l'image 
     134            //width and height of the clip 
    135135            int largeur, longueur; 
    136             //si jamais la sélection commence avant le début de l'image  
    137             //en x, on prend comme position 0, sinon, on calcule la position 
    138             //du clic selon le calcul position sur l'image = position sur le panel - position du x de l'image 
     136            //if the selection begins before the beginning of the image in x 
     137            //0 is taken. Otherwise the position of the click is calculated : 
     138            //position on the image = position on the panel - position of the x of the image 
    139139            if (xTopPosition - xZeroImage.intValue() < 0) { 
    140140                positionX = 0; 
     
    142142                positionX = xTopPosition - xZeroImage.intValue(); 
    143143            } 
    144             //si jamais la sélection commence avant le début de l'image  
    145             //en y, on prend comme position 0, sinon, on calcule la position 
    146             //du clic selon le calcul position sur l'image = position sur le panel - position du y de l'image 
     144            //if the selection begins before the beginning of the image in y 
     145            //0 is taken. Otherwise the position of the click is calculated : 
     146            //position on the image = position on the panel - position of the y of the image 
    147147            if (yTopPosition - yZeroImage.intValue() < 0) { 
    148148                positionY = 0; 
     
    150150                positionY = yTopPosition - yZeroImage.intValue(); 
    151151            } 
    152             //on calcule la largeur 
     152            //calculates the width 
    153153            largeur = xDragPosition - xTopPosition; 
    154             //si ça dépasse de l'image 
     154            //if it goes past the image 
    155155            if ((positionX + largeur) > image.getWidth()) { 
    156                 //on recalcule la largeur 
     156                //the width is recalculated 
    157157                largeur = image.getWidth() - positionX; 
    158158            } 
    159             //on calcule la longueur 
     159            //calculate the height 
    160160            longueur = yDragPosition - yTopPosition; 
    161             //si ça dépasse en hauteur 
     161            ////if it goes past the image 
    162162            if ((positionY + longueur) > image.getHeight()) { 
    163                 //on recalcule la hauteur 
     163                //the height is recalculated 
    164164                longueur = image.getHeight() - positionY; 
    165165            } 
    166             //recuperation de l'image coupée 
     166            //gets the cutted imagee 
    167167            image = image.getSubimage(positionX, positionY, largeur, longueur); 
    168168            repaint(); 
     
    176176 
    177177    /** 
    178      * Récupération du slider 
    179      * @return le slider 
     178     * gets the slider 
     179     * @return the slider 
    180180     */ 
    181181    public JSlider getSlider() { 
     
    223223 
    224224    /** 
    225      * Label du slider 
     225     * Label of the slider 
    226226     * @param min 
    227227     * @param max 
     
    239239 
    240240    /** 
    241      *  Rotation vers la droite 
     241     *  right rotation 
    242242     */ 
    243243    public void rotationDroite() { 
     
    246246 
    247247    /** 
    248      * Rotation vers la gauche 
     248     * left rotation 
    249249     */ 
    250250    public void rotationGauche() { 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/comments/CommentPanel.java

    r6821 r6980  
    3838    
    3939 * @author mael 
    40  * Un panel affichant un commentaire 
     40 * a panel that displays a comment of an image 
    4141 */ 
    4242public class CommentPanel extends JPanel { 
     
    4848 
    4949    /** 
    50      * Constructeur 
    51      * @param color la couleur de la zone de commentaire 
    52      * @param text le commentaire 
    53      * @param auteur l'auteur du commentaire 
    54      * @param date la date du commentaire 
     50     * Constructor 
     51     * @param color The color of the panel 
     52     * @param text the comment 
     53     * @param auteur the author of the comment 
     54     * @param date the date of the comment 
    5555     */ 
    5656    public CommentPanel(Color color, String text, String auteur, String date) { 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/comments/CommentsDialog.java

    r6821 r6980  
    5454    
    5555 * @author mael 
    56  * dialog affichant les commentaires d'une image et permettant d'en ajouter un 
     56 * dialog that displays the comments of an image and allows to add one 
    5757 */ 
    5858public class CommentsDialog extends JDialog implements ActionListener { 
     
    6363            .getLog(CommentsDialog.class); 
    6464    /** 
    65      * booleen permettant d'alterner les couleurs des commentaires 
     65     * booleen that allows to alernate the colors 
    6666     */ 
    6767    private boolean alternate = true; 
    6868    /** 
    69      * area permettant d'écrire un nouveau commentaire 
     69     * area to write a new comment 
    7070     */ 
    7171    private JTextArea textArea = new JTextArea(); 
    7272    /** 
    73      * bouton d'envoi d'un commentaire 
     73     * sends the new comment 
    7474     */ 
    7575    private JButton boutonEnvoyer = new JButton("Ok"); 
    7676 
    7777    /** 
    78      * id de l'image 
     78     * id of the image 
    7979     */ 
    8080    private Integer imageId; 
    8181    /** 
    82      * panel qui permet de scroller sur les commentaires 
     82     * panel that allows to scroll 
    8383     */ 
    8484    private JPanel panelScrollCommentaires = new JPanel(new GridBagLayout()); 
    8585    /** 
    86      * panel qui permet d'ajouter un commentaire 
     86     * panel that allows to add a comment 
    8787     */ 
    8888    private JPanel panelAjouterCommentaire = new JPanel(new FlowLayout()); 
    8989 
    9090    /** 
    91      * Scrollpane qui permet de scroller sur l'area  
     91     * Scrollpane  
    9292     */ 
    9393    private JScrollPane scrollPaneArea; 
    9494    /** 
    95      * scrollpane qui permet de scroller sur les commentaires 
     95     * scrollpane that allows to scroll 
    9696     */ 
    9797    private JScrollPane scrollPaneCommentaires; 
    9898 
    9999    /** 
    100      * Constructeur 
    101      * @param imageId id de l'image 
     100     * Constructor 
     101     * @param imageId the id of the image 
    102102     */ 
    103103    public CommentsDialog(JFrame parent, Integer imageId) { 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/mainframe/CategoriesTree.java

    r6962 r6980  
    6464            .getLog(CategoriesTree.class); 
    6565    /** 
    66      *  L'arbre 
     66     *  the tree 
    6767     */ 
    6868    private JTree tree; 
    6969    /** 
    70      * le menu permettant d'ajouter une catégorie 
     70     * the menu to add a category 
    7171     */ 
    7272    private JMenuItem menuAjouter; 
    7373    /** 
    74      * Le menu permettant d'actualiser les catégories 
     74     * the menu to refresh the categories 
    7575     */ 
    7676    private JMenuItem menuActualiser; 
    7777    /** 
    78      * la racine du tree, qu'on n'affiche pas 
     78     * the root of the tree which is not displayed 
    7979     */ 
    8080    private DefaultMutableTreeNode root = new DefaultMutableTreeNode(""); 
    8181    /** 
    82      * La catégorie selectionnée 
     82     * the selected category 
    8383     */ 
    8484    private Category selectedCategory; 
    8585 
    8686    /** 
    87      * Constructeur 
     87     * Constructor 
    8888     */ 
    8989    public CategoriesTree() { 
    9090        super(new BorderLayout()); 
    91         //creation de l'arbre 
     91        //creation of the tree 
    9292        createNodes(root); 
    9393        tree = new JTree(root); 
     
    103103 
    104104    /** 
    105      * Methode qui permet de mettre à jour l'arbre 
     105     * Method that allows to update the tree 
    106106     */ 
    107107    public void setUpUi() { 
     
    129129 
    130130    /** 
    131      * Creation des noeuds 
    132      * @param root noeud racine 
     131     * creation of the nodes 
     132     * @param root the root  
    133133     */ 
    134134    private void createNodes(DefaultMutableTreeNode root) { 
     
    153153 
    154154    /** 
    155      * Méthode récursive de creation des noeuds de l'arbre 
     155     * recursive method for the creation of the nodes 
    156156     * @param categoryNode 
    157157     * @param category 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/mainframe/MainFrame.java

    r6972 r6980  
    6363            .getLog(MainFrame.class); 
    6464    /** 
    65      * l'arbre des catégories 
     65     * the categories tree 
    6666     */ 
    6767    private CategoriesTree categoriesTree; 
    6868    /** 
    69      * Splitpane avec à gauche l'arbre et à droite les miniatures pour la catégorie 
    70      * courante 
     69     * Splitpane. On the left : the categories tree and on the right the thumbnails 
     70     * for the current category 
    7171     */ 
    7272    private JSplitPane splitPane; 
    7373    /** 
    74      * Panel contenant les miniatures de la catégorie courante 
     74     * Panel that contains the thumbnail of the current category 
    7575     */ 
    7676    public static ThumbnailCategoryPanel imagesPanel; 
    7777    /** 
    78      *  Scrollpane contenant le panel ci dessus 
     78     *  Scrollpane that contains the panel above 
    7979     */ 
    8080    private JScrollPane scrollPaneImagesPanel; 
    8181    /** 
    82      * label qui affiche des messages 
     82     * label that displays messages 
    8383     */ 
    8484    private JLabel labelMessage; 
    8585 
    8686    /** 
    87      * Barre de menu 
     87     * menu bar 
    8888     */ 
    8989    private JMenuBar jMenuBar; 
    9090 
    9191    /** 
    92      * Menu d'édition 
     92     * edition menu 
    9393     */ 
    9494    private JMenu jMenuEdition; 
    9595 
    9696    /** 
    97      * menu des preferences 
     97     * preferences menu 
    9898     */ 
    9999    private JMenuItem jMenuItemPreferences; 
     
    113113 
    114114    /** 
    115      * @return le singleton 
     115     * @return the singleton 
    116116     */ 
    117117    public static MainFrame getInstance() { 
     
    123123 
    124124    /** 
    125      * COnstructeur privé, permettant de n'avoir accès qu'au singleton 
     125     * private constructor to use a singleton 
    126126     */ 
    127127    private MainFrame() { 
     
    202202 
    203203    /** 
    204      * affichage de la frame 
     204     * displays the frame 
    205205     */ 
    206206    public void showUi() { 
     
    209209 
    210210    /** 
    211      * Affichage d'un message d'erreur 
    212      * @param message 
    213      */ 
    214     public void setErrorMessage(String message) { 
    215         this.labelMessage.setText(message); 
    216     } 
    217  
    218     /** 
    219211     * Affichage d'un message de réussite 
    220212     * @param message 
    221213     */ 
    222     public void setReussiteMessage(String message) { 
     214    public void setMessage(String message) { 
    223215        this.labelMessage.setText(message); 
    224216    } 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/mainframe/PreferencesDialog.java

    r6831 r6980  
    6161 
    6262    /** 
    63      * Les onglets 
     63     * the tabs 
    6464     */ 
    6565    private JTabbedPane tabPane; 
    6666 
    6767    /** 
    68      * l'onglet de gestion des preferences des images 
     68     * preferences of the images tab 
    6969     */ 
    7070    private JPanel panelImage; 
    7171 
    7272    /** 
    73      * largeur des images 
     73     * width of the images 
    7474     */ 
    7575    private JTextField fieldWidth; 
    7676 
    7777    /** 
    78      * hauteur des images 
     78     * height of the images 
    7979     */ 
    8080    private JTextField fieldHeight; 
    8181 
    8282    /** 
    83      * taille des morceaux 
     83     * size of the chunks 
    8484     */ 
    8585    private JTextField fieldChunkSize; 
     
    101101 
    102102    /** 
    103      * bouton d'enregistrement des preferences 
     103     * save the preferences 
    104104     */ 
    105105    private JButton boutonOk = new JButton("Ok"); 
    106106 
    107107    /** 
    108      * panel contenant les boutons 
     108     * panel that contains the buttons 
    109109     */ 
    110110    private JPanel panelBoutons; 
    111111 
    112112    /** 
    113      * bouton pour annuler  
     113     * bouton to cancel  
    114114     */ 
    115115    private JButton boutonAnnuler; 
    116116 
    117117    /** 
    118      * Constructeur 
     118     * Constructor 
    119119     * @param parent frame parent 
    120120     */ 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/mainframe/ThumbnailCategoryPanel.java

    r6972 r6980  
    4343    
    4444 * @author mael 
    45  * Classe qui affiche toutes les miniatures d'une catégorie 
     45 * Class that display the thumbnails of a category 
    4646 */ 
    4747public class ThumbnailCategoryPanel extends JPanel implements IThumbnailPanel { 
     
    5252            .getLog(ThumbnailCategoryPanel.class); 
    5353    /** 
    54      * L'id de la catégorie pour laquelle les miniatures doivent être affichées 
     54     * id of the category 
    5555     */ 
    5656    private Integer categoryId; 
     
    6464 
    6565    /** 
    66      * Constructeur 
    67      * @param categoryId l'id de la catégorie 
     66     * Constructor 
     67     * @param categoryId id of the category 
    6868     */ 
    6969    public ThumbnailCategoryPanel(Integer categoryId) { 
     
    8484 
    8585    /** 
    86      * rafraichissement, afin d'afficher les nouvelles images 
    87      * @param categoryId 
     86     * refreshes the panel 
     87     * @param categoryId the id of the category 
    8888     */ 
    8989    public void rafraichir(Integer categoryId, boolean rafraichir) { 
     
    139139 
    140140                    ImageService.getInstance().creer(files[i].getCanonicalPath(), categoryId); 
    141                     MainFrame.getInstance().setReussiteMessage( 
    142                             files[i].getName() + " " + Messages.getMessage("sendingSuccess")); 
     141                    MainFrame.getInstance() 
     142                            .setMessage(files[i].getName() + " " + Messages.getMessage("sendingSuccess")); 
    143143                } catch (Exception e) { 
    144144                    LOG.error(Outil.getStackTrace(e)); 
    145                     //s'il y a une erreur lors de l'envoi 
     145                    //displays a dialog if there is an error 
    146146                    JOptionPane.showMessageDialog(null, Messages.getMessage("sendingError") + files[i].getName(), 
    147147                            Messages.getMessage("error"), JOptionPane.ERROR_MESSAGE); 
    148                     MainFrame.getInstance().setErrorMessage( 
    149                             Messages.getMessage("sendingError") + " " + files[i].getName()); 
     148                    MainFrame.getInstance().setMessage(Messages.getMessage("sendingError") + " " + files[i].getName()); 
    150149                } finally { 
    151150                    MainFrame.getInstance().getProgressBar().setValue(nbProgressBar); 
    152151                } 
    153152            } 
    154             //on rafraichit 
     153            //refresh 
    155154            rafraichir(categoryId, true); 
    156155            MainFrame.getInstance().getProgressBar().setValue(0); 
     
    179178            JPanel panelh = new JPanel(new FlowLayout()); 
    180179            try { 
    181                 MainFrame.getInstance().setReussiteMessage(Messages.getMessage("thumbviewer_loading")); 
     180                MainFrame.getInstance().setMessage(Messages.getMessage("thumbviewer_loading")); 
    182181                ImagesManagement.LIST_IMAGE = ImageService.getInstance().listerParCategory(categoryId, rafraichir); 
    183182                for (Image image : ImagesManagement.LIST_IMAGE) { 
     
    203202                panel.repaint(); 
    204203                panel.revalidate(); 
    205                 MainFrame.getInstance().setReussiteMessage(Messages.getMessage("loadingOk")); 
     204                MainFrame.getInstance().setMessage(Messages.getMessage("loadingOk")); 
    206205            } catch (Exception e) { 
    207206                LOG.error(Outil.getStackTrace(e)); 
    208207                JOptionPane.showMessageDialog(null, Messages.getMessage("imagesListingError"), Messages 
    209208                        .getMessage("error"), JOptionPane.ERROR_MESSAGE); 
    210                 MainFrame.getInstance().setErrorMessage(Messages.getMessage("imagesListingError")); 
     209                MainFrame.getInstance().setMessage(Messages.getMessage("imagesListingError")); 
    211210            } 
    212211 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/mainframe/ThumbnailPanel.java

    r6968 r6980  
    6262    
    6363 * @author mael 
    64  * Panel contenant la miniature d'une image. 
    65  * C'est un panel "cliquable", qui permet d'afficher l'image à taille réelle 
     64 * Panel that contains the thumbnail of an image 
    6665 */ 
    6766public class ThumbnailPanel extends JLabel implements MouseListener, ActionListener { 
     
    7271            .getLog(ThumbnailPanel.class); 
    7372    /** 
    74      * l'image 
     73     * the image 
    7574     */ 
    7675    private Image image; 
     
    9897    /** 
    9998     * Constructeur 
    100      * @param image l'image 
    101      * @param imagesPanel le panel 
     99     * @param image the image 
     100     * @param imagesPanel the panel 
    102101     */ 
    103102    public ThumbnailPanel(Image image) { 
     
    148147    @Override 
    149148    public void mouseEntered(MouseEvent paramMouseEvent) { 
    150         //changement du curseur, pour signifier à l'utilisateur que l'image est cliquable 
    151149        this.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR)); 
    152150    } 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/mainframe/ThumbnailSearchPanel.java

    r6972 r6980  
    8080 
    8181    /** 
    82      * rafraichissement, afin d'afficher les nouvelles images 
    83      * @param categoryId 
     82     *refreshes 
     83     * @param categoryId the id of the category 
    8484     */ 
    8585    public void rechercher() { 
     
    8888        JPanel panelh = new JPanel(new FlowLayout()); 
    8989        try { 
    90             MainFrame.getInstance().setReussiteMessage(Messages.getMessage("thumbviewer_loading")); 
     90            MainFrame.getInstance().setMessage(Messages.getMessage("thumbviewer_loading")); 
    9191            ImagesManagement.LIST_IMAGE = ImageService.getInstance().search(queryString); 
    9292            for (Image image : ImagesManagement.LIST_IMAGE) { 
     
    112112            this.repaint(); 
    113113            this.revalidate(); 
    114             MainFrame.getInstance().setReussiteMessage(Messages.getMessage("loadingOk")); 
     114            MainFrame.getInstance().setMessage(Messages.getMessage("loadingOk")); 
    115115        } catch (Exception e) { 
    116116            LOG.error(Outil.getStackTrace(e)); 
    117117            JOptionPane.showMessageDialog(null, Messages.getMessage("imagesListingError"), 
    118118                    Messages.getMessage("error"), JOptionPane.ERROR_MESSAGE); 
    119             MainFrame.getInstance().setErrorMessage(Messages.getMessage("imagesListingError")); 
     119            MainFrame.getInstance().setMessage(Messages.getMessage("imagesListingError")); 
    120120        } 
    121121    } 
Note: See TracChangeset for help on using the changeset viewer.