Changeset 7221


Ignore:
Timestamp:
10/16/10 13:08:28 (9 years ago)
Author:
mlg
Message:

implements feature : the number of thumbnails in the thumbnails viewer is adapted to the size of the frame
not perfect but better
feature:0001838

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

Legend:

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

    r6980 r7221  
    33import java.io.File; 
    44import java.io.IOException; 
    5  
    65import javax.swing.UIManager; 
    7  
    86import com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel; 
    9  
    107import fr.mael.jiwigo.transverse.session.SessionManager; 
    118import fr.mael.jiwigo.transverse.util.Outil; 
     
    1310import fr.mael.jiwigo.ui.ConnexionDialog; 
    1411import fr.mael.jiwigo.ui.mainframe.MainFrame; 
     12 
    1513 
    1614/** 
     
    4543 */ 
    4644public class Main { 
    47     /** 
    48      * Logger 
    49      */ 
    50     public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory.getLog(Main.class); 
    51     /** 
    52      * The login and session manager that allows to connect to 
    53      * the webservice and to query it 
    54      */ 
    55     public static SessionManager sessionManager; 
    5645 
    57     /** 
    58      *  the main window 
    59      */ 
    60     private static MainFrame mainFrame; 
     46        /** 
     47         * Logger 
     48         */ 
     49        public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory.getLog(Main.class); 
     50        /** 
     51         * The login and session manager that allows to connect to 
     52         * the webservice and to query it 
     53         */ 
     54        public static SessionManager sessionManager; 
    6155 
    62     public static void main(String[] args) { 
    63         try { 
    64             UIManager.setLookAndFeel(new NimbusLookAndFeel()); 
    65         } catch (Exception e) { 
    66         } 
    67         File dossierConfig = new File(System.getProperty("user.home") + "/.jiwigo"); 
    68         if (!dossierConfig.exists()) { 
    69             dossierConfig.mkdir(); 
    70         } 
    71         try { 
    72             PreferencesManagement.creerFichierParDefaut(); 
    73             //dialog de connexion 
    74             ConnexionDialog dialog = new ConnexionDialog(); 
    75             dialog.showDialog(); 
    76         } catch (IOException e) { 
    77             LOG.error(Outil.getStackTrace(e)); 
     56        /** 
     57         *  the main window 
     58         */ 
     59        private static MainFrame mainFrame; 
     60 
     61 
     62        public static void main(String[] args) { 
     63                try { 
     64                        UIManager.setLookAndFeel(new NimbusLookAndFeel()); 
     65                } catch (Exception e) { 
     66                } 
     67                File dossierConfig = new File(System.getProperty("user.home") + "/.jiwigo"); 
     68                if (!dossierConfig.exists()) { 
     69                        dossierConfig.mkdir(); 
     70                } 
     71                try { 
     72                        PreferencesManagement.creerFichierParDefaut(); 
     73                        //dialog de connexion 
     74                        ConnexionDialog dialog = new ConnexionDialog(); 
     75                        dialog.showDialog(); 
     76                } catch (IOException e) { 
     77                        LOG.error(Outil.getStackTrace(e)); 
     78                } 
     79 
    7880        } 
    7981 
    80     } 
    8182 
    82     public static void showFrame() { 
     83        public static void showFrame() { 
    8384 
    84         if (mainFrame == null) { 
    85             mainFrame = MainFrame.getInstance(); 
     85                if (mainFrame == null) { 
     86                        mainFrame = MainFrame.getInstance(); 
     87                } 
     88                if (!mainFrame.isVisible()) { 
     89                        mainFrame.showUi(); 
     90                } 
    8691        } 
    87         if (!mainFrame.isVisible()) { 
    88             mainFrame.showUi(); 
    89         } 
    90     } 
    9192} 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/dao/ImageDao.java

    r7070 r7221  
    66import java.util.HashMap; 
    77import java.util.List; 
    8  
    98import org.jdom.Document; 
    109import org.jdom.Element; 
    11  
    1210import sun.misc.BASE64Encoder; 
    1311import fr.mael.jiwigo.Main; 
     
    1816import fr.mael.jiwigo.transverse.util.Outil; 
    1917import fr.mael.jiwigo.transverse.util.preferences.PreferencesManagement; 
     18 
    2019 
    2120/** 
     
    5049 */ 
    5150public class ImageDao { 
    52     /** 
    53      * Logger 
    54      */ 
    55     public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory 
    56             .getLog(ImageDao.class); 
    57  
    58     /** 
    59      * Singleton 
    60      */ 
    61     private static ImageDao instance; 
    62  
    63     /** 
    64      * cache to avoid downloading image for each access 
    65      */ 
    66     private HashMap<Integer, List<Image>> cache; 
    67  
    68     /** 
    69      *  
    70      */ 
    71     private Integer firstCatInCache; 
    72  
    73     /** 
    74      * Private singleton, to use a singleton 
    75      */ 
    76     private ImageDao() { 
    77         cache = new HashMap<Integer, List<Image>>(); 
    78     } 
    79  
    80     /** 
    81      * @return le singleton 
    82      */ 
    83     public static ImageDao getInstance() { 
    84         if (instance == null) { 
    85             instance = new ImageDao(); 
    86         } 
    87         return instance; 
    88     } 
    89  
    90     /** 
    91      * Lists all images 
    92      * @return the list of images 
    93      * @throws IOException  
    94      */ 
    95     public List<Image> lister(boolean rafraichir) throws IOException { 
    96         return listerParCategory(null, rafraichir); 
    97     } 
    98  
    99     /** 
    100      * Listing of the images for a category 
    101      * @param categoryId the id of the category 
    102      * @return the list of images 
    103      * @throws IOException  
    104      */ 
    105     public List<Image> listerParCategory(Integer categoryId, boolean rafraichir) throws IOException { 
    106         if (rafraichir || cache.get(categoryId) == null) { 
    107             Document doc = null; 
    108             if (categoryId != null) { 
    109                 doc = Main.sessionManager.executerReturnDocument(MethodsEnum.LISTER_IMAGES.getLabel(), "cat_id", String 
    110                         .valueOf(categoryId)); 
    111             } else { 
    112                 doc = Main.sessionManager.executerReturnDocument(MethodsEnum.LISTER_IMAGES.getLabel()); 
    113             } 
    114             Element element = doc.getRootElement().getChild("images"); 
    115             List<Image> images = getImagesFromElement(element); 
    116             cache.remove(categoryId); 
    117             cache.put(categoryId, images); 
    118             if (firstCatInCache == null) { 
    119                 firstCatInCache = categoryId; 
    120             } 
    121             return images; 
    122         } else { 
    123             return cache.get(categoryId); 
    124         } 
    125     } 
    126  
    127     /** 
    128      * Creation of an image<br/> 
    129      * Sequence : <br/> 
    130      * <li> 
    131      * <ul>sending of the thumbnail in base64, thanks to the method addchunk.</ul> 
    132      * <ul>sending of the image in base64, thanks to the method addchunk</ul> 
    133      * <ul>using of the add method to add the image to the database<ul> 
    134      * </li> 
    135      * Finally, the response of the webservice is checked 
    136      *  
    137      * @param the image to create 
    138      * @return true if the creation of the image was the successful 
    139      * @throws Exception 
    140      */ 
    141     //TODO ne pas continuer si une des réponses précédentes est négative 
    142     public boolean creer(Image image) throws Exception { 
    143         //thumbnail converted to base64 
    144         BASE64Encoder base64 = new BASE64Encoder(); 
    145  
    146         String thumbnailBase64 = base64.encode(Outil.getBytesFromFile(image.getThumbnail())); 
    147         //sends the thumbnail and gets the result  
    148         Document reponseThumb = (Main.sessionManager.executerReturnDocument("pwg.images.addChunk", "data", 
    149                 thumbnailBase64, "type", "thumb", "position", "1", "original_sum", Outil.getMD5Checksum(image 
    150                         .getOriginale().getAbsolutePath()))); 
    151  
    152         //begin feature:0001827 
    153         Double doubleChunk = Double.parseDouble(PreferencesManagement.getValue(PreferencesEnum.CHUNK_SIZE.getLabel())) * 1000 * 1024; 
    154         int chunk = doubleChunk.intValue(); 
    155         ArrayList<File> fichiersAEnvoyer = Outil.splitFile(image.getOriginale(), chunk); 
    156         boolean echec = false; 
    157         for (int i = 0; i < fichiersAEnvoyer.size(); i++) { 
    158             File fichierAEnvoyer = fichiersAEnvoyer.get(i); 
    159             String originaleBase64 = base64.encode(Outil.getBytesFromFile(fichierAEnvoyer)); 
    160             Document reponseOriginale = (Main.sessionManager.executerReturnDocument("pwg.images.addChunk", "data", 
    161                     originaleBase64, "type", "file", "position", String.valueOf(i), "original_sum", Outil 
    162                             .getMD5Checksum(image.getOriginale().getAbsolutePath()))); 
    163             if (!Outil.checkOk(reponseOriginale)) { 
    164                 echec = true; 
    165                 break; 
    166             } 
    167         } 
    168         //end 
    169  
    170         //add the image in the database and get the result of the webservice 
    171         Document reponseAjout = (Main.sessionManager.executerReturnDocument("pwg.images.add", "file_sum", Outil 
    172                 .getMD5Checksum(image.getOriginale().getAbsolutePath()), "thumbnail_sum", Outil.getMD5Checksum(image 
    173                 .getThumbnail().getCanonicalPath()), "position", "1", "original_sum", Outil.getMD5Checksum(image 
    174                 .getOriginale().getAbsolutePath()), "categories", String.valueOf(image.getIdCategory()), "name", image 
    175                 .getName(), "author", Main.sessionManager.getLogin(), "level", String 
    176                 .valueOf(ImagesManagement.privacyLevel))); 
    177         LOG.debug("Response add : " + Outil.documentToString(reponseAjout)); 
    178         //      System.out.println(Main.sessionManager.executerReturnString("pwg.images.add", "file_sum", Outil 
    179         //              .getMD5Checksum(image.getOriginale().getAbsolutePath()), "thumbnail_sum", Outil.getMD5Checksum(image 
    180         //              .getThumbnail().getCanonicalPath()), "position", "1", "original_sum", Outil.getMD5Checksum(image 
    181         //              .getOriginale().getAbsolutePath()), "categories", String.valueOf(image.getIdCategory()), "name", image 
    182         //              .getName(), "author", Main.sessionManager.getLogin())); 
    183         //      Document reponsePrivacy = null; 
    184         //      if (Outil.checkOk(reponseAjout)) { 
    185         //          reponsePrivacy = Main.sessionManager.executerReturnDocument(MethodsEnum.SET_PRIVACY_LEVEL.getLabel()); 
    186         //      } 
    187         boolean reussite = true; 
    188         if (!Outil.checkOk(reponseThumb) || echec || !Outil.checkOk(reponseAjout)) { 
    189             reussite = false; 
    190         } 
    191         suppressionFichierTemporaires(); 
    192         return reussite; 
    193  
    194     } 
    195  
    196     /** 
    197      * Add tags to an image 
    198      * @param imageId id of the image 
    199      * @param tagId ids of the tags 
    200      * @throws IOException 
    201      */ 
    202     public boolean addTags(Integer imageId, String tagId) throws IOException { 
    203         Document doc = Main.sessionManager.executerReturnDocument(MethodsEnum.SET_INFO.getLabel(), "image_id", String 
    204                 .valueOf(imageId), "tag_ids", tagId); 
    205         return Outil.checkOk(doc); 
    206  
    207     } 
    208  
    209     /** 
    210      * parse an element to find images 
    211      * @param element the element to parse 
    212      * @return the list of images 
    213      */ 
    214     private List<Image> getImagesFromElement(Element element) { 
    215         List<Element> listElement = (List<Element>) element.getChildren("image"); 
    216         ArrayList<Image> images = new ArrayList<Image>(); 
    217         for (Element im : listElement) { 
    218             Image myImage = new Image(); 
    219             myImage.setMiniature(im.getAttributeValue("tn_url")); 
    220             myImage.setUrl(im.getAttributeValue("element_url")); 
    221             myImage.setWidth(Integer.valueOf(im.getAttributeValue("width"))); 
    222             myImage.setHeight(Integer.valueOf(im.getAttributeValue("height"))); 
    223             myImage.setFile(im.getAttributeValue("file")); 
    224             myImage.setVue(Integer.valueOf(im.getAttributeValue("hit"))); 
    225             myImage.setIdentifiant(Integer.valueOf(im.getAttributeValue("id"))); 
    226             myImage.setName(im.getChildText("name")); 
    227             if (myImage.getName() == null) { 
    228                 myImage.setName(myImage.getFile()); 
    229             } 
    230             images.add(myImage); 
    231  
    232         } 
    233         return images; 
    234     } 
    235  
    236     /** 
    237      * Search images 
    238      * @param searchString the string to search 
    239      * @return the list of images matching the string 
    240      * @throws IOException  
    241      */ 
    242     public List<Image> search(String searchString) throws IOException { 
    243         Document doc = Main.sessionManager.executerReturnDocument(MethodsEnum.SEARCH.getLabel(), "query", searchString); 
    244         LOG.debug(doc); 
    245         Element element = doc.getRootElement().getChild("images"); 
    246         return getImagesFromElement(element); 
    247  
    248     } 
    249  
    250     private void suppressionFichierTemporaires() { 
    251         File file = new File(System.getProperty("java.io.tmpdir") + "/originale.jpg"); 
    252         file.delete(); 
    253         file = new File(System.getProperty("java.io.tmpdir") + "/thumb.jpg"); 
    254         file.delete(); 
    255  
    256     } 
     51 
     52        /** 
     53         * Logger 
     54         */ 
     55        public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory.getLog(ImageDao.class); 
     56 
     57        /** 
     58         * Singleton 
     59         */ 
     60        private static ImageDao instance; 
     61 
     62        /** 
     63         * cache to avoid downloading image for each access 
     64         */ 
     65        private HashMap<Integer, List<Image>> cache; 
     66 
     67        /** 
     68         *  
     69         */ 
     70        private Integer firstCatInCache; 
     71 
     72 
     73        /** 
     74         * Private singleton, to use a singleton 
     75         */ 
     76        private ImageDao() { 
     77                cache = new HashMap<Integer, List<Image>>(); 
     78        } 
     79 
     80 
     81        /** 
     82         * @return le singleton 
     83         */ 
     84        public static ImageDao getInstance() { 
     85                if (instance == null) { 
     86                        instance = new ImageDao(); 
     87                } 
     88                return instance; 
     89        } 
     90 
     91 
     92        /** 
     93         * Lists all images 
     94         * @return the list of images 
     95         * @throws IOException  
     96         */ 
     97        public List<Image> lister(boolean rafraichir) throws IOException { 
     98                return listerParCategory(null, rafraichir); 
     99        } 
     100 
     101 
     102        /** 
     103         * Listing of the images for a category 
     104         * @param categoryId the id of the category 
     105         * @return the list of images 
     106         * @throws IOException  
     107         */ 
     108        public List<Image> listerParCategory(Integer categoryId, boolean rafraichir) throws IOException { 
     109                if (rafraichir || cache.get(categoryId) == null) { 
     110                        Document doc = null; 
     111 
     112                        if (categoryId != null) { 
     113                                doc = Main.sessionManager.executerReturnDocument(MethodsEnum.LISTER_IMAGES.getLabel(), "cat_id", 
     114                                                String.valueOf(categoryId)); 
     115                        } else { 
     116                                doc = Main.sessionManager.executerReturnDocument(MethodsEnum.LISTER_IMAGES.getLabel()); 
     117                        } 
     118                        Element element = doc.getRootElement().getChild("images"); 
     119                        List<Image> images = getImagesFromElement(element); 
     120                        cache.remove(categoryId); 
     121                        cache.put(categoryId, images); 
     122                        if (firstCatInCache == null) { 
     123                                firstCatInCache = categoryId; 
     124                        } 
     125                        return images; 
     126                } else { 
     127                        return cache.get(categoryId); 
     128                } 
     129        } 
     130 
     131 
     132        /** 
     133         * Creation of an image<br/> 
     134         * Sequence : <br/> 
     135         * <li> 
     136         * <ul>sending of the thumbnail in base64, thanks to the method addchunk.</ul> 
     137         * <ul>sending of the image in base64, thanks to the method addchunk</ul> 
     138         * <ul>using of the add method to add the image to the database<ul> 
     139         * </li> 
     140         * Finally, the response of the webservice is checked 
     141         *  
     142         * @param the image to create 
     143         * @return true if the creation of the image was the successful 
     144         * @throws Exception 
     145         */ 
     146        //TODO ne pas continuer si une des réponses précédentes est négative 
     147        public boolean creer(Image image) throws Exception { 
     148                //thumbnail converted to base64 
     149                BASE64Encoder base64 = new BASE64Encoder(); 
     150 
     151                String thumbnailBase64 = base64.encode(Outil.getBytesFromFile(image.getThumbnail())); 
     152                //sends the thumbnail and gets the result  
     153                Document reponseThumb = (Main.sessionManager.executerReturnDocument("pwg.images.addChunk", "data", thumbnailBase64, 
     154                                "type", "thumb", "position", "1", "original_sum", Outil.getMD5Checksum(image.getOriginale().getAbsolutePath()))); 
     155 
     156                //begin feature:0001827 
     157                Double doubleChunk = Double.parseDouble(PreferencesManagement.getValue(PreferencesEnum.CHUNK_SIZE.getLabel())) * 1000 * 1024; 
     158                int chunk = doubleChunk.intValue(); 
     159                ArrayList<File> fichiersAEnvoyer = Outil.splitFile(image.getOriginale(), chunk); 
     160                boolean echec = false; 
     161                for (int i = 0; i < fichiersAEnvoyer.size(); i++) { 
     162                        File fichierAEnvoyer = fichiersAEnvoyer.get(i); 
     163                        String originaleBase64 = base64.encode(Outil.getBytesFromFile(fichierAEnvoyer)); 
     164                        Document reponseOriginale = (Main.sessionManager.executerReturnDocument("pwg.images.addChunk", "data", 
     165                                        originaleBase64, "type", "file", "position", String.valueOf(i), "original_sum", 
     166                                        Outil.getMD5Checksum(image.getOriginale().getAbsolutePath()))); 
     167                        if (!Outil.checkOk(reponseOriginale)) { 
     168                                echec = true; 
     169                                break; 
     170                        } 
     171                } 
     172                //end 
     173 
     174                //add the image in the database and get the result of the webservice 
     175                Document reponseAjout = (Main.sessionManager.executerReturnDocument("pwg.images.add", "file_sum", 
     176                                Outil.getMD5Checksum(image.getOriginale().getAbsolutePath()), "thumbnail_sum", 
     177                                Outil.getMD5Checksum(image.getThumbnail().getCanonicalPath()), "position", "1", "original_sum", 
     178                                Outil.getMD5Checksum(image.getOriginale().getAbsolutePath()), "categories", 
     179                                String.valueOf(image.getIdCategory()), "name", image.getName(), "author", Main.sessionManager.getLogin(), 
     180                                "level", String.valueOf(ImagesManagement.privacyLevel))); 
     181                LOG.debug("Response add : " + Outil.documentToString(reponseAjout)); 
     182                //      System.out.println(Main.sessionManager.executerReturnString("pwg.images.add", "file_sum", Outil 
     183                //              .getMD5Checksum(image.getOriginale().getAbsolutePath()), "thumbnail_sum", Outil.getMD5Checksum(image 
     184                //              .getThumbnail().getCanonicalPath()), "position", "1", "original_sum", Outil.getMD5Checksum(image 
     185                //              .getOriginale().getAbsolutePath()), "categories", String.valueOf(image.getIdCategory()), "name", image 
     186                //              .getName(), "author", Main.sessionManager.getLogin())); 
     187                //      Document reponsePrivacy = null; 
     188                //      if (Outil.checkOk(reponseAjout)) { 
     189                //          reponsePrivacy = Main.sessionManager.executerReturnDocument(MethodsEnum.SET_PRIVACY_LEVEL.getLabel()); 
     190                //      } 
     191                boolean reussite = true; 
     192                if (!Outil.checkOk(reponseThumb) || echec || !Outil.checkOk(reponseAjout)) { 
     193                        reussite = false; 
     194                } 
     195                suppressionFichierTemporaires(); 
     196                return reussite; 
     197 
     198        } 
     199 
     200 
     201        /** 
     202         * Add tags to an image 
     203         * @param imageId id of the image 
     204         * @param tagId ids of the tags 
     205         * @throws IOException 
     206         */ 
     207        public boolean addTags(Integer imageId, String tagId) throws IOException { 
     208                Document doc = Main.sessionManager.executerReturnDocument(MethodsEnum.SET_INFO.getLabel(), "image_id", 
     209                                String.valueOf(imageId), "tag_ids", tagId); 
     210                return Outil.checkOk(doc); 
     211 
     212        } 
     213 
     214 
     215        /** 
     216         * parse an element to find images 
     217         * @param element the element to parse 
     218         * @return the list of images 
     219         */ 
     220        private List<Image> getImagesFromElement(Element element) { 
     221                List<Element> listElement = (List<Element>) element.getChildren("image"); 
     222                ArrayList<Image> images = new ArrayList<Image>(); 
     223                for (Element im : listElement) { 
     224                        Image myImage = new Image(); 
     225                        myImage.setMiniature(im.getAttributeValue("tn_url")); 
     226                        myImage.setUrl(im.getAttributeValue("element_url")); 
     227                        myImage.setWidth(Integer.valueOf(im.getAttributeValue("width"))); 
     228                        myImage.setHeight(Integer.valueOf(im.getAttributeValue("height"))); 
     229                        myImage.setFile(im.getAttributeValue("file")); 
     230                        myImage.setVue(Integer.valueOf(im.getAttributeValue("hit"))); 
     231                        myImage.setIdentifiant(Integer.valueOf(im.getAttributeValue("id"))); 
     232                        myImage.setName(im.getChildText("name")); 
     233                        if (myImage.getName() == null) { 
     234                                myImage.setName(myImage.getFile()); 
     235                        } 
     236                        images.add(myImage); 
     237 
     238                } 
     239                return images; 
     240        } 
     241 
     242 
     243        /** 
     244         * Search images 
     245         * @param searchString the string to search 
     246         * @return the list of images matching the string 
     247         * @throws IOException  
     248         */ 
     249        public List<Image> search(String searchString) throws IOException { 
     250                Document doc = Main.sessionManager.executerReturnDocument(MethodsEnum.SEARCH.getLabel(), "query", searchString); 
     251                LOG.debug(doc); 
     252                Element element = doc.getRootElement().getChild("images"); 
     253                return getImagesFromElement(element); 
     254 
     255        } 
     256 
     257 
     258        private void suppressionFichierTemporaires() { 
     259                File file = new File(System.getProperty("java.io.tmpdir") + "/originale.jpg"); 
     260                file.delete(); 
     261                file = new File(System.getProperty("java.io.tmpdir") + "/thumb.jpg"); 
     262                file.delete(); 
     263 
     264        } 
    257265 
    258266} 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/service/ImageService.java

    r6980 r7221  
    44import java.io.IOException; 
    55import java.util.List; 
    6  
    76import fr.mael.jiwigo.dao.ImageDao; 
    87import fr.mael.jiwigo.om.Image; 
     
    1312import fr.mael.jiwigo.transverse.util.preferences.PreferencesManagement; 
    1413import fr.mael.jiwigo.ui.mainframe.MainFrame; 
     14 
    1515 
    1616/** 
     
    4545 */ 
    4646public class ImageService { 
    47     /** 
    48      * Logger 
    49      */ 
    50     public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory 
    51             .getLog(ImageService.class); 
    5247 
    53     /** 
    54      * Singleton 
    55     */ 
    56     private static ImageService instance; 
     48        /** 
     49         * Logger 
     50        */ 
     51        public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory.getLog(ImageService.class); 
    5752 
    58     /** 
    59      * @return the singleton 
    60      */ 
    61     public static ImageService getInstance() { 
    62         if (instance == null) { 
    63             instance = new ImageService(); 
     53        /** 
     54         * Singleton 
     55         */ 
     56        private static ImageService instance; 
     57 
     58 
     59        /** 
     60         * @return the singleton 
     61         */ 
     62        public static ImageService getInstance() { 
     63                if (instance == null) { 
     64                        instance = new ImageService(); 
     65                } 
     66                return instance; 
    6467        } 
    65         return instance; 
    66     } 
    6768 
    68     /** 
    69      * private constructor to use a singleton 
    70      */ 
    71     private ImageService() { 
    7269 
    73     } 
    74  
    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      */ 
    82     public List<Image> listerParCategory(Integer categoryId, boolean rafraichir) throws IOException { 
    83         return ImageDao.getInstance().listerParCategory(categoryId, rafraichir); 
    84     } 
    85  
    86     /** 
    87      * Method called to send an image to the server. 
    88      * @param filePath 
    89      * @param idCategory 
    90      * @return 
    91      * @throws Exception 
    92      */ 
    93     public boolean creer(String filePath, Integer idCategory) throws Exception { 
    94         MainFrame.getInstance().setMessage(Messages.getMessage("mainFrame_resizing") + " " + filePath); 
    95         //get the byte array of the original file, to keep metadata 
    96         byte[] bytesFichierOriginal = Outil.getBytesFromFile(new File(filePath)); 
    97  
    98         //size taken from the user's preferences 
    99         int widthOriginale = Integer 
    100                 .valueOf(PreferencesManagement.getValue(PreferencesEnum.WIDTH_ORIGINALE.getLabel())); 
    101         int heightOriginale = Integer.valueOf(PreferencesManagement 
    102                 .getValue(PreferencesEnum.HEIGHT_ORIGINAL.getLabel())); 
    103         //resize the picture (or not) 
    104         boolean originaleRedimensionnee = ImagesUtil.scale(filePath, "originale.jpg", widthOriginale, heightOriginale); 
    105         //create the thumbnail 
    106         ImagesUtil.scale(filePath, "thumb.jpg", 120, 90); 
    107         //get the thumbnail 
    108         File thumbnail = new File(System.getProperty("java.io.tmpdir") + "/thumb.jpg"); 
    109         File originale = null; 
    110         if (originaleRedimensionnee) { 
    111             originale = new File(System.getProperty("java.io.tmpdir") + "/originale.jpg"); 
    112             //if the original file has been resized, we put the metadata in the resized file 
    113             //I use here a try catch because if the original file isn't a jpeg 
    114             //the methode Outil.enrich will fail, but the procedure has to continue 
    115             MainFrame.getInstance().setMessage(Messages.getMessage("mainFrame_addMetadata") + " " + filePath); 
    116             try { 
    117                 byte[] fichierEnrichi = Outil.enrich(bytesFichierOriginal, Outil.getBytesFromFile(new File(System 
    118                         .getProperty("java.io.tmpdir") 
    119                         + "/originale.jpg"))); 
    120                 Outil.byteToFile(System.getProperty("java.io.tmpdir") + "/originale.jpg", fichierEnrichi); 
    121             } catch (Exception e) { 
    122             } 
    123         } else { 
    124             originale = new File(filePath); 
     70        /** 
     71         * private constructor to use a singleton 
     72         */ 
     73        private ImageService() { 
    12574 
    12675        } 
    127         Image image = new Image(); 
    128         image.setName(getImageName(filePath)); 
    129         image.setThumbnail(thumbnail); 
    130         image.setOriginale(originale); 
    131         image.setIdCategory(idCategory); 
    132         MainFrame.getInstance().setMessage(Messages.getMessage("mainFrame_sendingFiles") + " " + filePath); 
    133         //now we call the dao to send the image to the webservice 
    134         return ImageDao.getInstance().creer(image); 
    135     } 
    13676 
    137     /** 
    138      * Add tags to an existing image 
    139      * @param image the image 
    140      * @param tagId the ids of the tags 
    141      * @return true if successful 
    142      * @throws IOException 
    143      */ 
    144     public boolean addTags(Image image, String tagId) throws IOException { 
    145         return ImageDao.getInstance().addTags(image.getIdentifiant(), tagId); 
    146     } 
    14777 
    148     /** 
    149      * Search images from a string 
    150      * @param queryString the string 
    151      * @return images matching the string 
    152      * @throws IOException 
    153      */ 
    154     public List<Image> search(String queryString) throws IOException { 
    155         return ImageDao.getInstance().search(queryString); 
    156     } 
     78        /** 
     79         * Lists all images for a category 
     80         * @param categoryId the id of the category 
     81         * @param rafraichir true : refresh the list of images 
     82         * @return the list of images 
     83         * @throws IOException 
     84         */ 
     85        public List<Image> listerParCategory(Integer categoryId, boolean rafraichir) throws IOException { 
     86                return ImageDao.getInstance().listerParCategory(categoryId, rafraichir); 
     87        } 
    15788 
    158     /** 
    159      * Deletes the file extension 
    160      * @param path 
    161      * @return 
    162      */ 
    163     private String getImageName(String path) { 
    164         File fichier = new File(path); 
    165         StringBuffer name = new StringBuffer(fichier.getName()); 
    166         return (name.delete(name.lastIndexOf("."), name.length())).toString(); 
    16789 
    168     } 
     90        /** 
     91         * Method called to send an image to the server. 
     92         * @param filePath 
     93         * @param idCategory 
     94         * @return 
     95         * @throws Exception 
     96         */ 
     97        public boolean creer(String filePath, Integer idCategory) throws Exception { 
     98                MainFrame.getInstance().setMessage(Messages.getMessage("mainFrame_resizing") + " " + filePath); 
     99                //get the byte array of the original file, to keep metadata 
     100                byte[] bytesFichierOriginal = Outil.getBytesFromFile(new File(filePath)); 
     101 
     102                //size taken from the user's preferences 
     103                int widthOriginale = Integer.valueOf(PreferencesManagement.getValue(PreferencesEnum.WIDTH_ORIGINALE.getLabel())); 
     104                int heightOriginale = Integer.valueOf(PreferencesManagement.getValue(PreferencesEnum.HEIGHT_ORIGINAL.getLabel())); 
     105                //resize the picture (or not) 
     106                boolean originaleRedimensionnee = ImagesUtil.scale(filePath, "originale.jpg", widthOriginale, heightOriginale); 
     107                //create the thumbnail 
     108                ImagesUtil.scale(filePath, "thumb.jpg", 120, 90); 
     109                //get the thumbnail 
     110                File thumbnail = new File(System.getProperty("java.io.tmpdir") + "/thumb.jpg"); 
     111                File originale = null; 
     112                if (originaleRedimensionnee) { 
     113                        originale = new File(System.getProperty("java.io.tmpdir") + "/originale.jpg"); 
     114                        //if the original file has been resized, we put the metadata in the resized file 
     115                        //I use here a try catch because if the original file isn't a jpeg 
     116                        //the methode Outil.enrich will fail, but the procedure has to continue 
     117                        MainFrame.getInstance().setMessage(Messages.getMessage("mainFrame_addMetadata") + " " + filePath); 
     118                        try { 
     119                                byte[] fichierEnrichi = Outil.enrich(bytesFichierOriginal, 
     120                                                Outil.getBytesFromFile(new File(System.getProperty("java.io.tmpdir") + "/originale.jpg"))); 
     121                                Outil.byteToFile(System.getProperty("java.io.tmpdir") + "/originale.jpg", fichierEnrichi); 
     122                        } catch (Exception e) { 
     123                        } 
     124                } else { 
     125                        originale = new File(filePath); 
     126 
     127                } 
     128                Image image = new Image(); 
     129                image.setName(getImageName(filePath)); 
     130                image.setThumbnail(thumbnail); 
     131                image.setOriginale(originale); 
     132                image.setIdCategory(idCategory); 
     133                MainFrame.getInstance().setMessage(Messages.getMessage("mainFrame_sendingFiles") + " " + filePath); 
     134                //now we call the dao to send the image to the webservice 
     135                return ImageDao.getInstance().creer(image); 
     136        } 
     137 
     138 
     139        /** 
     140         * Add tags to an existing image 
     141         * @param image the image 
     142         * @param tagId the ids of the tags 
     143         * @return true if successful 
     144         * @throws IOException 
     145         */ 
     146        public boolean addTags(Image image, String tagId) throws IOException { 
     147                return ImageDao.getInstance().addTags(image.getIdentifiant(), tagId); 
     148        } 
     149 
     150 
     151        /** 
     152         * Search images from a string 
     153         * @param queryString the string 
     154         * @return images matching the string 
     155         * @throws IOException 
     156         */ 
     157        public List<Image> search(String queryString) throws IOException { 
     158                return ImageDao.getInstance().search(queryString); 
     159        } 
     160 
     161 
     162        /** 
     163         * Deletes the file extension 
     164         * @param path 
     165         * @return 
     166         */ 
     167        private String getImageName(String path) { 
     168                File fichier = new File(path); 
     169                StringBuffer name = new StringBuffer(fichier.getName()); 
     170                return (name.delete(name.lastIndexOf("."), name.length())).toString(); 
     171 
     172        } 
    169173 
    170174} 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/transverse/ImagesManagement.java

    r7070 r7221  
    55import java.util.HashMap; 
    66import java.util.List; 
    7  
    87import javax.imageio.ImageIO; 
    9  
    108import fr.mael.jiwigo.om.Image; 
    119import fr.mael.jiwigo.transverse.util.Outil; 
     10 
    1211 
    1312/** 
     
    4140 */ 
    4241public class ImagesManagement { 
    43     /** 
    44      * Logger 
    45      */ 
    46     public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory 
    47             .getLog(ImagesManagement.class); 
    48     /** 
    49      * the index of the current image 
    50      */ 
    51     public static int CURRENT_IMAGE_INDEX; 
    52     /** 
    53      * the current image 
    54      */ 
    55     public static Image CURRENT_IMAGE; 
    56     /** 
    57      * images list 
    58      */ 
    59     public static List<Image> LIST_IMAGE; 
    6042 
    61     /** 
    62      * cache allows to keep the images in the ram 
    63      */ 
    64     private static HashMap<Integer, BufferedImage> IMAGES_CACHE = new HashMap<Integer, BufferedImage>(); 
     43        /** 
     44         * Logger 
     45         */ 
     46        public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory.getLog(ImagesManagement.class); 
     47        /** 
     48         * the index of the current image 
     49         */ 
     50        public static int CURRENT_IMAGE_INDEX; 
     51        /** 
     52         * the current image 
     53         */ 
     54        public static Image CURRENT_IMAGE; 
     55        /** 
     56         * images list 
     57         */ 
     58        public static List<Image> LIST_IMAGE; 
    6559 
    66     /** 
    67      * cache allows to keep the thumbnails in the ram 
    68     */ 
    69     private static HashMap<Integer, BufferedImage> MINIATURE_CACHE = new HashMap<Integer, BufferedImage>(); 
     60        /** 
     61         * cache allows to keep the images in the ram 
     62        */ 
     63        private static HashMap<Integer, BufferedImage> IMAGES_CACHE = new HashMap<Integer, BufferedImage>(); 
    7064 
    71     /** 
    72      * If true : the application won't ask the privacy level 
    73      * to the user each time he adds pictures 
    74      */ 
    75     public static boolean rememberPrivacyLevel = false; 
     65        /** 
     66         * cache allows to keep the thumbnails in the ram 
     67         */ 
     68        private static HashMap<Integer, BufferedImage> MINIATURE_CACHE = new HashMap<Integer, BufferedImage>(); 
    7669 
    77     /** 
    78      * the privacy level to apply to the pictures 
    79      */ 
    80     public static int privacyLevel = 1; 
     70        /** 
     71         * If true : the application won't ask the privacy level 
     72         * to the user each time he adds pictures 
     73         */ 
     74        public static boolean rememberPrivacyLevel = false; 
    8175 
    82     /** 
    83      * gets the current image 
    84      * @return the image 
    85      */ 
    86     public static Image getCurrentImage() { 
    87         //return LIST_IMAGE.get(CURRENT_IMAGE_INDEX); 
    88         return CURRENT_IMAGE; 
    89     } 
     76        /** 
     77         * the privacy level to apply to the pictures 
     78         */ 
     79        public static int privacyLevel = 1; 
    9080 
    91     /** 
    92      * next image 
    93      */ 
    94     public static void next() { 
    95         if (CURRENT_IMAGE_INDEX != LIST_IMAGE.size() - 1) { 
    96             CURRENT_IMAGE_INDEX++; 
    97         } else { 
    98             CURRENT_IMAGE_INDEX = 0; 
     81 
     82        /** 
     83         * gets the current image 
     84         * @return the image 
     85         */ 
     86        public static Image getCurrentImage() { 
     87                //return LIST_IMAGE.get(CURRENT_IMAGE_INDEX); 
     88                return CURRENT_IMAGE; 
    9989        } 
    100         CURRENT_IMAGE = LIST_IMAGE.get(CURRENT_IMAGE_INDEX); 
    101     } 
    10290 
    103     /** 
    104      * previous image 
    105      */ 
    106     public static void previous() { 
    107         if (CURRENT_IMAGE_INDEX != 0) { 
    108             CURRENT_IMAGE_INDEX--; 
    109         } else { 
    110             CURRENT_IMAGE_INDEX = LIST_IMAGE.size() - 1; 
     91 
     92        /** 
     93         * next image 
     94         */ 
     95        public static void next() { 
     96                if (CURRENT_IMAGE_INDEX != LIST_IMAGE.size() - 1) { 
     97                        CURRENT_IMAGE_INDEX++; 
     98                } else { 
     99                        CURRENT_IMAGE_INDEX = 0; 
     100                } 
     101                CURRENT_IMAGE = LIST_IMAGE.get(CURRENT_IMAGE_INDEX); 
    111102        } 
    112         CURRENT_IMAGE = LIST_IMAGE.get(CURRENT_IMAGE_INDEX); 
    113     } 
    114103 
    115     /** 
    116      *  
    117      * @param image the current image 
    118      */ 
    119     public static void setCurrentImage(Image image) { 
    120         CURRENT_IMAGE = image; 
    121         int compteur = 0; 
    122         for (Image im : LIST_IMAGE) { 
    123             if (im.equals(image)) { 
    124                 CURRENT_IMAGE_INDEX = compteur; 
    125             } 
    126             compteur++; 
     104 
     105        /** 
     106         * previous image 
     107         */ 
     108        public static void previous() { 
     109                if (CURRENT_IMAGE_INDEX != 0) { 
     110                        CURRENT_IMAGE_INDEX--; 
     111                } else { 
     112                        CURRENT_IMAGE_INDEX = LIST_IMAGE.size() - 1; 
     113                } 
     114                CURRENT_IMAGE = LIST_IMAGE.get(CURRENT_IMAGE_INDEX); 
    127115        } 
    128     } 
    129116 
    130     /** 
    131      * Function that allows to load images once 
    132      * to decrease response delays 
    133      * @return the image 
    134      */ 
    135     public static BufferedImage getCurrentBufferedImage() { 
    136         if (IMAGES_CACHE.get(CURRENT_IMAGE.getIdentifiant()) == null) { 
    137             try { 
    138                 BufferedImage img = ImageIO.read(new URL(CURRENT_IMAGE.getUrl())); 
    139                 IMAGES_CACHE.put(CURRENT_IMAGE.getIdentifiant(), img); 
    140             } catch (Exception e) { 
    141                 LOG.error(Outil.getStackTrace(e)); 
    142             } 
     117 
     118        /** 
     119         *  
     120         * @param image the current image 
     121         */ 
     122        public static void setCurrentImage(Image image) { 
     123                CURRENT_IMAGE = image; 
     124                int compteur = 0; 
     125                for (Image im : LIST_IMAGE) { 
     126                        if (im.equals(image)) { 
     127                                CURRENT_IMAGE_INDEX = compteur; 
     128                        } 
     129                        compteur++; 
     130                } 
    143131        } 
    144         return IMAGES_CACHE.get(CURRENT_IMAGE.getIdentifiant()); 
    145     } 
    146132 
    147     /** 
    148      * Function that allows to load thimbnails once 
    149      * to decrease response delays 
    150      * @return the image 
    151      */ 
    152     public static BufferedImage getMiniatureBufferedImage(Image image) { 
    153         if (MINIATURE_CACHE.get(image.getIdentifiant()) == null) { 
    154             try { 
    155                 BufferedImage img = ImageIO.read(new URL(image.getMiniature())); 
    156                 MINIATURE_CACHE.put(image.getIdentifiant(), img); 
    157             } catch (Exception e) { 
    158                 LOG.error(Outil.getStackTrace(e)); 
    159             } 
     133 
     134        /** 
     135         * Function that allows to load images once 
     136         * to decrease response delays 
     137         * @return the image 
     138         */ 
     139        public static BufferedImage getCurrentBufferedImage() { 
     140                if (IMAGES_CACHE.get(CURRENT_IMAGE.getIdentifiant()) == null) { 
     141                        try { 
     142                                BufferedImage img = ImageIO.read(new URL(CURRENT_IMAGE.getUrl())); 
     143                                IMAGES_CACHE.put(CURRENT_IMAGE.getIdentifiant(), img); 
     144                        } catch (Exception e) { 
     145                                LOG.error(Outil.getStackTrace(e)); 
     146                        } 
     147                } 
     148                return IMAGES_CACHE.get(CURRENT_IMAGE.getIdentifiant()); 
    160149        } 
    161         return MINIATURE_CACHE.get(image.getIdentifiant()); 
    162     } 
     150 
     151 
     152        /** 
     153         * Function that allows to load thimbnails once 
     154         * to decrease response delays 
     155         * @return the image 
     156         */ 
     157        public static BufferedImage getMiniatureBufferedImage(Image image) { 
     158                if (MINIATURE_CACHE.get(image.getIdentifiant()) == null) { 
     159                        try { 
     160                                BufferedImage img = ImageIO.read(new URL(image.getMiniature())); 
     161                                MINIATURE_CACHE.put(image.getIdentifiant(), img); 
     162                        } catch (Exception e) { 
     163                                LOG.error(Outil.getStackTrace(e)); 
     164                        } 
     165                } 
     166 
     167                return MINIATURE_CACHE.get(image.getIdentifiant()); 
     168        } 
    163169} 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/ConnexionDialog.java

    r7070 r7221  
    1616import java.util.Arrays; 
    1717import java.util.Locale; 
    18  
    1918import javax.swing.AbstractListModel; 
    2019import javax.swing.ComboBoxModel; 
     
    2726import javax.swing.JPasswordField; 
    2827import javax.swing.JTextField; 
    29  
    3028import fr.mael.jiwigo.Main; 
    3129import fr.mael.jiwigo.transverse.enumeration.PreferencesEnum; 
     
    3331import fr.mael.jiwigo.transverse.util.Messages; 
    3432import fr.mael.jiwigo.transverse.util.preferences.PreferencesManagement; 
     33 
    3534 
    3635/** 
     
    6463 */ 
    6564public class ConnexionDialog extends JDialog implements ActionListener, ItemListener, KeyListener, WindowListener { 
    66     /** 
    67      * Logger 
    68      */ 
    69     public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory 
    70             .getLog(ConnexionDialog.class); 
    71     /** 
    72      * field that contains the url 
    73      */ 
    74     private JTextField fieldUrl; 
    75     /** 
    76      * field that contains the login 
    77      */ 
    78     private JTextField loginField; 
    79     /** 
    80      * field that contains de password 
    81      */ 
    82     private JPasswordField passwordField; 
    83     /** 
    84      * label of the url field 
    85      */ 
    86     private JLabel labelUrl; 
    87     /** 
    88      * label of the login field 
    89      */ 
    90     private JLabel labelLogin; 
    91     /** 
    92      *  label of the password field 
    93      */ 
    94     private JLabel labelPass; 
    95     /** 
    96      * ok button for the connection 
    97      */ 
    98     private JButton boutonOk; 
    99  
    100     /** 
    101      * Box that allows to save informations 
    102      */ 
    103     private JCheckBox checkBoxRetenir; 
    104  
    105     /** 
    106      * Combo containing all locales 
    107      */ 
    108     private JComboBox comboLocales; 
    109  
    110     /** 
    111      * Constructor  
    112      */ 
    113     public ConnexionDialog() { 
    114         Locale defautLocale = Messages.usedLocale; 
    115         labelUrl = new JLabel(Messages.getMessage("connexionDialog_urlSite")); 
    116         labelLogin = new JLabel(Messages.getMessage("connexionDialog_login")); 
    117         labelPass = new JLabel(Messages.getMessage("connexionDialog_pass")); 
    118         comboLocales = new JComboBox(); 
    119         boutonOk = new JButton("Ok"); 
    120         String url = PreferencesManagement.getValue(PreferencesEnum.URL_SITE.getLabel()); 
    121         String login = PreferencesManagement.getValue(PreferencesEnum.LOGIN.getLabel()); 
    122         String pass = PreferencesManagement.getValue(PreferencesEnum.PASSWORD.getLabel()); 
    123         fieldUrl = new JTextField(url); 
    124         loginField = new JTextField(login); 
    125         passwordField = new JPasswordField(pass); 
    126         checkBoxRetenir = new JCheckBox(Messages.getMessage("connexionDialog_sauvegarder")); 
    127         if (!url.equals("") && !login.equals("") && !pass.equals("")) { 
    128             checkBoxRetenir.setSelected(true); 
    129         } 
    130         Dimension fieldDimensions = new Dimension(300, 30); 
    131         fieldUrl.setPreferredSize(fieldDimensions); 
    132         fieldUrl.addActionListener(this); 
    133         loginField.setPreferredSize(fieldDimensions); 
    134         loginField.addActionListener(this); 
    135         passwordField.setPreferredSize(fieldDimensions); 
    136         passwordField.addActionListener(this); 
    137         this.getContentPane().setLayout(new GridBagLayout()); 
    138         GridBagConstraints constraints = new GridBagConstraints(); 
    139         constraints.gridx = 0; 
    140         constraints.gridy = 0; 
    141         constraints.insets = new Insets(3, 3, 3, 3); 
    142         this.getContentPane().add(labelUrl, constraints); 
    143         constraints.gridx++; 
    144         this.getContentPane().add(fieldUrl, constraints); 
    145         constraints.gridx = 0; 
    146         constraints.gridy++; 
    147         this.getContentPane().add(labelLogin, constraints); 
    148         constraints.gridx++; 
    149         this.getContentPane().add(loginField, constraints); 
    150         constraints.gridx = 0; 
    151         constraints.gridy++; 
    152         this.getContentPane().add(labelPass, constraints); 
    153         constraints.gridx++; 
    154         this.getContentPane().add(passwordField, constraints); 
    155         constraints.gridx = 0; 
    156         constraints.gridy++; 
    157         this.getContentPane().add(comboLocales, constraints); 
    158         constraints.gridx++; 
    159         this.getContentPane().add(checkBoxRetenir, constraints); 
    160         constraints.gridx = 0; 
    161         constraints.gridy++;//   
    162         //      for (Locale locale : SimpleDateFormat.getAvailableLocales()) { 
    163         //          comboLocales.addItem(locale.getDisplayName(Locale.ENGLISH)); 
    164         //      } 
    165         comboLocales.setPreferredSize(new Dimension(130, 25)); 
    166         comboLocales.addItemListener(this); 
    167         localeModel model = new localeModel(); 
    168         comboLocales.setModel(model); 
    169         model.setSelectedItem(defautLocale.getDisplayLanguage(Locale.ENGLISH)); 
    170         this.getContentPane().add(boutonOk, constraints); 
    171         boutonOk.setPreferredSize(new Dimension(80, 30)); 
    172         boutonOk.addActionListener(this); 
    173         this.addWindowListener(this); 
    174     } 
    175  
    176     public void showDialog() { 
    177         this.pack(); 
    178         this.setLocationRelativeTo(null); 
    179         this.setVisible(true); 
    180     } 
    181  
    182     @Override 
    183     public void actionPerformed(ActionEvent paramActionEvent) { 
    184         //if one field is empty, an error is displayed 
    185         if (fieldUrl.getText().equals("") || loginField.getText().equals("") || passwordField.getText().equals("")) { 
    186             JOptionPane.showMessageDialog(null, Messages.getMessage("connexionDialog_emptyField"), Messages 
    187                     .getMessage("error"), JOptionPane.ERROR_MESSAGE); 
    188         } else { 
    189             if (!fieldUrl.getText().startsWith("http://")) { 
    190                 fieldUrl.setText("http://" + fieldUrl.getText()); 
    191             } 
    192             //instanciation of the session manager 
    193             Main.sessionManager = new SessionManager(loginField.getText(), passwordField.getText(), fieldUrl.getText()); 
    194             if (checkBoxRetenir.isSelected()) { 
    195                 PreferencesManagement.setValue(PreferencesEnum.LOGIN.getLabel(), loginField.getText()); 
    196                 PreferencesManagement.setValue(PreferencesEnum.PASSWORD.getLabel(), passwordField.getText()); 
    197                 PreferencesManagement.setValue(PreferencesEnum.URL_SITE.getLabel(), fieldUrl.getText()); 
    198             } else { 
    199                 PreferencesManagement.setValue(PreferencesEnum.LOGIN.getLabel(), ""); 
    200                 PreferencesManagement.setValue(PreferencesEnum.PASSWORD.getLabel(), ""); 
    201                 PreferencesManagement.setValue(PreferencesEnum.URL_SITE.getLabel(), ""); 
    202             } 
    203             if (!Main.sessionManager.processLogin()) { 
    204                 //if the login fails, an error is displayed 
    205                 JOptionPane.showMessageDialog(null, Messages.getMessage("connexionDialog_connexionError"), Messages 
    206                         .getMessage("error"), JOptionPane.ERROR_MESSAGE); 
    207             } else { 
    208                 //              Locale.setDefault((Locale) comboLocales.getSelectedItem()); 
    209                 Main.showFrame(); 
    210                 //hides the dialog 
    211                 this.dispose(); 
    212             } 
    213         } 
    214     } 
    215  
    216     /** 
    217      * @author mael 
    218      * Internal class that represents the model of the combobox that allows 
    219      * to choose a locale 
    220      */ 
    221     class localeModel extends AbstractListModel implements ComboBoxModel { 
    222         Locale[] locales = SimpleDateFormat.getAvailableLocales(); 
    223         //List<Locale> locales = Messages.getAvailableBundles(); 
    224         String[] localesNames; 
    225  
    226         String selection = null; 
    227  
    228         public localeModel() { 
    229             localesNames = new String[locales.length]; 
    230             int compteur = 0; 
    231             for (Locale locale : locales) { 
    232                 localesNames[compteur] = locale.getDisplayName(Locale.ENGLISH); 
    233                 compteur++; 
    234             } 
    235             Arrays.sort(localesNames); 
    236         } 
    237  
    238         public Object getElementAt(int index) { 
    239             return localesNames[index]; 
    240         } 
    241  
    242         public int getSize() { 
    243             return locales.length; 
    244         } 
    245  
    246         public void setSelectedItem(Object anItem) { 
    247             selection = (String) anItem; 
    248         } 
    249  
    250         public Object getSelectedItem() { 
    251             if (selection != null) 
    252                 return selection; 
    253             else 
    254                 return null; 
    255         } 
    256     } 
    257  
    258     @Override 
    259     public void itemStateChanged(ItemEvent paramItemEvent) { 
    260         for (Locale locale : SimpleDateFormat.getAvailableLocales()) { 
    261             if (locale.getDisplayName(Locale.ENGLISH).equals(paramItemEvent.getItem())) { 
    262                 Messages.usedLocale = locale; 
    263                 dispose(); 
    264                 ConnexionDialog dial = new ConnexionDialog(); 
    265                 dial.showDialog(); 
    266  
    267             } 
    268  
    269         } 
    270     } 
    271  
    272     @Override 
    273     public void keyPressed(KeyEvent arg0) { 
    274     } 
    275  
    276     @Override 
    277     public void keyReleased(KeyEvent arg0) { 
    278  
    279     } 
    280  
    281     @Override 
    282     public void keyTyped(KeyEvent arg0) { 
    283     } 
    284  
    285     @Override 
    286     public void windowActivated(WindowEvent e) { 
    287         // TODO Auto-generated method stub 
    288  
    289     } 
    290  
    291     @Override 
    292     public void windowClosed(WindowEvent e) { 
    293         System.out.println("closed"); 
    294     } 
    295  
    296     @Override 
    297     public void windowClosing(WindowEvent e) { 
    298         System.exit(0); 
    299     } 
    300  
    301     @Override 
    302     public void windowDeactivated(WindowEvent e) { 
    303         // TODO Auto-generated method stub 
    304  
    305     } 
    306  
    307     @Override 
    308     public void windowDeiconified(WindowEvent e) { 
    309         // TODO Auto-generated method stub 
    310  
    311     } 
    312  
    313     @Override 
    314     public void windowIconified(WindowEvent e) { 
    315         // TODO Auto-generated method stub 
    316  
    317     } 
    318  
    319     @Override 
    320     public void windowOpened(WindowEvent e) { 
    321         // TODO Auto-generated method stub 
    322  
    323     } 
     65 
     66        /** 
     67         * Logger 
     68         */ 
     69        public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory.getLog(ConnexionDialog.class); 
     70        /** 
     71         * field that contains the url 
     72         */ 
     73        private JTextField fieldUrl; 
     74        /** 
     75         * field that contains the login 
     76         */ 
     77        private JTextField loginField; 
     78        /** 
     79         * field that contains de password 
     80         */ 
     81        private JPasswordField passwordField; 
     82        /** 
     83         * label of the url field 
     84         */ 
     85        private JLabel labelUrl; 
     86        /** 
     87         * label of the login field 
     88         */ 
     89        private JLabel labelLogin; 
     90        /** 
     91         *  label of the password field 
     92         */ 
     93        private JLabel labelPass; 
     94        /** 
     95         * ok button for the connection 
     96         */ 
     97        private JButton boutonOk; 
     98 
     99        /** 
     100         * Box that allows to save informations 
     101         */ 
     102        private JCheckBox checkBoxRetenir; 
     103 
     104        /** 
     105         * Combo containing all locales 
     106         */ 
     107        private JComboBox comboLocales; 
     108 
     109 
     110        /** 
     111         * Constructor  
     112         */ 
     113        public ConnexionDialog() { 
     114                Locale defautLocale = Messages.usedLocale; 
     115                labelUrl = new JLabel(Messages.getMessage("connexionDialog_urlSite")); 
     116                labelLogin = new JLabel(Messages.getMessage("connexionDialog_login")); 
     117                labelPass = new JLabel(Messages.getMessage("connexionDialog_pass")); 
     118                comboLocales = new JComboBox(); 
     119                boutonOk = new JButton("Ok"); 
     120                String url = PreferencesManagement.getValue(PreferencesEnum.URL_SITE.getLabel()); 
     121                String login = PreferencesManagement.getValue(PreferencesEnum.LOGIN.getLabel()); 
     122                String pass = PreferencesManagement.getValue(PreferencesEnum.PASSWORD.getLabel()); 
     123                fieldUrl = new JTextField(url); 
     124                loginField = new JTextField(login); 
     125                passwordField = new JPasswordField(pass); 
     126                checkBoxRetenir = new JCheckBox(Messages.getMessage("connexionDialog_sauvegarder")); 
     127                if (!url.equals("") && !login.equals("") && !pass.equals("")) { 
     128                        checkBoxRetenir.setSelected(true); 
     129                } 
     130                Dimension fieldDimensions = new Dimension(300, 30); 
     131                fieldUrl.setPreferredSize(fieldDimensions); 
     132                fieldUrl.addActionListener(this); 
     133                loginField.setPreferredSize(fieldDimensions); 
     134                loginField.addActionListener(this); 
     135                passwordField.setPreferredSize(fieldDimensions); 
     136                passwordField.addActionListener(this); 
     137                this.getContentPane().setLayout(new GridBagLayout()); 
     138                GridBagConstraints constraints = new GridBagConstraints(); 
     139                constraints.gridx = 0; 
     140                constraints.gridy = 0; 
     141                constraints.insets = new Insets(3, 3, 3, 3); 
     142                this.getContentPane().add(labelUrl, constraints); 
     143                constraints.gridx++; 
     144                this.getContentPane().add(fieldUrl, constraints); 
     145                constraints.gridx = 0; 
     146                constraints.gridy++; 
     147                this.getContentPane().add(labelLogin, constraints); 
     148                constraints.gridx++; 
     149                this.getContentPane().add(loginField, constraints); 
     150                constraints.gridx = 0; 
     151                constraints.gridy++; 
     152                this.getContentPane().add(labelPass, constraints); 
     153                constraints.gridx++; 
     154                this.getContentPane().add(passwordField, constraints); 
     155                constraints.gridx = 0; 
     156                constraints.gridy++; 
     157                this.getContentPane().add(comboLocales, constraints); 
     158                constraints.gridx++; 
     159                this.getContentPane().add(checkBoxRetenir, constraints); 
     160                constraints.gridx = 0; 
     161                constraints.gridy++;//   
     162                //      for (Locale locale : SimpleDateFormat.getAvailableLocales()) { 
     163                //          comboLocales.addItem(locale.getDisplayName(Locale.ENGLISH)); 
     164                //      } 
     165                comboLocales.setPreferredSize(new Dimension(130, 25)); 
     166                comboLocales.addItemListener(this); 
     167                localeModel model = new localeModel(); 
     168                comboLocales.setModel(model); 
     169                model.setSelectedItem(defautLocale.getDisplayLanguage(Locale.ENGLISH)); 
     170                this.getContentPane().add(boutonOk, constraints); 
     171                boutonOk.setPreferredSize(new Dimension(80, 30)); 
     172                boutonOk.addActionListener(this); 
     173                this.addWindowListener(this); 
     174        } 
     175 
     176 
     177        public void showDialog() { 
     178                this.pack(); 
     179                this.setLocationRelativeTo(null); 
     180                this.setVisible(true); 
     181        } 
     182 
     183 
     184        @Override 
     185        public void actionPerformed(ActionEvent paramActionEvent) { 
     186                //if one field is empty, an error is displayed 
     187                if (fieldUrl.getText().equals("") || loginField.getText().equals("") || passwordField.getText().equals("")) { 
     188                        JOptionPane.showMessageDialog(null, Messages.getMessage("connexionDialog_emptyField"), 
     189                                        Messages.getMessage("error"), JOptionPane.ERROR_MESSAGE); 
     190                } else { 
     191                        if (!fieldUrl.getText().startsWith("http://")) { 
     192                                fieldUrl.setText("http://" + fieldUrl.getText()); 
     193                        } 
     194                        //instanciation of the session manager 
     195                        Main.sessionManager = new SessionManager(loginField.getText(), passwordField.getText(), fieldUrl.getText()); 
     196                        if (checkBoxRetenir.isSelected()) { 
     197                                PreferencesManagement.setValue(PreferencesEnum.LOGIN.getLabel(), loginField.getText()); 
     198                                PreferencesManagement.setValue(PreferencesEnum.PASSWORD.getLabel(), passwordField.getText()); 
     199                                PreferencesManagement.setValue(PreferencesEnum.URL_SITE.getLabel(), fieldUrl.getText()); 
     200                        } else { 
     201                                PreferencesManagement.setValue(PreferencesEnum.LOGIN.getLabel(), ""); 
     202                                PreferencesManagement.setValue(PreferencesEnum.PASSWORD.getLabel(), ""); 
     203                                PreferencesManagement.setValue(PreferencesEnum.URL_SITE.getLabel(), ""); 
     204                        } 
     205                        if (!Main.sessionManager.processLogin()) { 
     206                                //if the login fails, an error is displayed 
     207                                JOptionPane.showMessageDialog(null, Messages.getMessage("connexionDialog_connexionError"), 
     208                                                Messages.getMessage("error"), JOptionPane.ERROR_MESSAGE); 
     209                        } else { 
     210                                //              Locale.setDefault((Locale) comboLocales.getSelectedItem()); 
     211                                Main.showFrame(); 
     212                                //hides the dialog 
     213                                this.dispose(); 
     214                        } 
     215                } 
     216        } 
     217 
     218        /** 
     219         * @author mael 
     220         * Internal class that represents the model of the combobox that allows 
     221         * to choose a locale 
     222         */ 
     223        class localeModel extends AbstractListModel implements ComboBoxModel { 
     224 
     225                Locale[] locales = SimpleDateFormat.getAvailableLocales(); 
     226                //List<Locale> locales = Messages.getAvailableBundles(); 
     227                String[] localesNames; 
     228 
     229                String selection = null; 
     230 
     231 
     232                public localeModel() { 
     233                        localesNames = new String[locales.length]; 
     234                        int compteur = 0; 
     235                        for (Locale locale : locales) { 
     236                                localesNames[compteur] = locale.getDisplayName(Locale.ENGLISH); 
     237                                compteur++; 
     238                        } 
     239                        Arrays.sort(localesNames); 
     240                } 
     241 
     242 
     243                public Object getElementAt(int index) { 
     244                        return localesNames[index]; 
     245                } 
     246 
     247 
     248                public int getSize() { 
     249                        return locales.length; 
     250                } 
     251 
     252 
     253                public void setSelectedItem(Object anItem) { 
     254                        selection = (String) anItem; 
     255                } 
     256 
     257 
     258                public Object getSelectedItem() { 
     259                        if (selection != null) 
     260                                return selection; 
     261                        else 
     262                                return null; 
     263                } 
     264        } 
     265 
     266 
     267        @Override 
     268        public void itemStateChanged(ItemEvent paramItemEvent) { 
     269                for (Locale locale : SimpleDateFormat.getAvailableLocales()) { 
     270                        if (locale.getDisplayName(Locale.ENGLISH).equals(paramItemEvent.getItem())) { 
     271                                Messages.usedLocale = locale; 
     272                                dispose(); 
     273                                ConnexionDialog dial = new ConnexionDialog(); 
     274                                dial.showDialog(); 
     275 
     276                        } 
     277 
     278                } 
     279        } 
     280 
     281 
     282        @Override 
     283        public void keyPressed(KeyEvent arg0) { 
     284        } 
     285 
     286 
     287        @Override 
     288        public void keyReleased(KeyEvent arg0) { 
     289 
     290        } 
     291 
     292 
     293        @Override 
     294        public void keyTyped(KeyEvent arg0) { 
     295        } 
     296 
     297 
     298        @Override 
     299        public void windowActivated(WindowEvent e) { 
     300                // TODO Auto-generated method stub 
     301 
     302        } 
     303 
     304 
     305        @Override 
     306        public void windowClosed(WindowEvent e) { 
     307        } 
     308 
     309 
     310        @Override 
     311        public void windowClosing(WindowEvent e) { 
     312                System.exit(0); 
     313        } 
     314 
     315 
     316        @Override 
     317        public void windowDeactivated(WindowEvent e) { 
     318                // TODO Auto-generated method stub 
     319 
     320        } 
     321 
     322 
     323        @Override 
     324        public void windowDeiconified(WindowEvent e) { 
     325                // TODO Auto-generated method stub 
     326 
     327        } 
     328 
     329 
     330        @Override 
     331        public void windowIconified(WindowEvent e) { 
     332                // TODO Auto-generated method stub 
     333 
     334        } 
     335 
     336 
     337        @Override 
     338        public void windowOpened(WindowEvent e) { 
     339                // TODO Auto-generated method stub 
     340 
     341        } 
    324342} 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/mainframe/CategoriesTree.java

    r6980 r7221  
    88import java.awt.event.MouseListener; 
    99import java.util.List; 
    10  
    1110import javax.swing.JMenuItem; 
    1211import javax.swing.JOptionPane; 
     
    2120import javax.swing.tree.TreePath; 
    2221import javax.swing.tree.TreeSelectionModel; 
    23  
    2422import fr.mael.jiwigo.om.Category; 
    2523import fr.mael.jiwigo.service.CategoryService; 
    2624import fr.mael.jiwigo.transverse.util.Messages; 
    2725import fr.mael.jiwigo.transverse.util.Outil; 
     26 
    2827 
    2928/** 
     
    5857public class CategoriesTree extends JPanel implements TreeSelectionListener, MouseListener, ActionListener { 
    5958 
    60     /** 
    61      * Logger 
    62      */ 
    63     public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory 
    64             .getLog(CategoriesTree.class); 
    65     /** 
    66      *  the tree 
    67      */ 
    68     private JTree tree; 
    69     /** 
    70      * the menu to add a category 
    71      */ 
    72     private JMenuItem menuAjouter; 
    73     /** 
    74      * the menu to refresh the categories 
    75      */ 
    76     private JMenuItem menuActualiser; 
    77     /** 
    78      * the root of the tree which is not displayed 
    79      */ 
    80     private DefaultMutableTreeNode root = new DefaultMutableTreeNode(""); 
    81     /** 
    82      * the selected category 
    83      */ 
    84     private Category selectedCategory; 
    85  
    86     /** 
    87      * Constructor 
    88      */ 
    89     public CategoriesTree() { 
    90         super(new BorderLayout()); 
    91         //creation of the tree 
    92         createNodes(root); 
    93         tree = new JTree(root); 
    94         tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION); 
    95         tree.addTreeSelectionListener(this); 
    96         tree.setRootVisible(false); 
    97         tree.addMouseListener(this); 
    98         JScrollPane treeView = new JScrollPane(tree); 
    99         Dimension minimumSize = new Dimension(100, 50); 
    100         treeView.setMinimumSize(minimumSize); 
    101         add(treeView, BorderLayout.CENTER); 
    102     } 
    103  
    104     /** 
    105      * Method that allows to update the tree 
    106      */ 
    107     public void setUpUi() { 
    108         //begin bug:0001830 
    109         root.removeAllChildren(); 
    110         createNodes(root); 
    111         ((DefaultTreeModel) tree.getModel()).reload(); 
    112         //end 
    113  
    114     } 
    115  
    116     /* (non-Javadoc) 
    117      * @see javax.swing.event.TreeSelectionListener#valueChanged(javax.swing.event.TreeSelectionEvent) 
    118      */ 
    119     public void valueChanged(TreeSelectionEvent e) { 
    120         DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent(); 
    121         // 
    122         if (node == null) 
    123             return; 
    124         Object catSelectionnee = node.getUserObject(); 
    125         Category category = (Category) catSelectionnee; 
    126         //MainFrame.imagesPanel.rafraichir(category.getIdentifiant(), false); 
    127         MainFrame.getInstance().addTabb(new ThumbnailCategoryPanel(category)); 
    128     } 
    129  
    130     /** 
    131      * creation of the nodes 
    132      * @param root the root  
    133      */ 
    134     private void createNodes(DefaultMutableTreeNode root) { 
    135         DefaultMutableTreeNode category = null; 
    136         try { 
    137             List<Category> list = CategoryService.getInstance().construireArbre(); 
    138             for (Category cat : list) { 
    139                 if (cat.getCategoriesMeres().size() == 0) { 
    140                     category = new DefaultMutableTreeNode(cat); 
    141                     root.add(category); 
    142                     recursiveNodeCreation(category, cat); 
    143                 } 
    144  
    145             } 
    146         } catch (Exception e) { 
    147             LOG.error(Outil.getStackTrace(e)); 
    148             JOptionPane.showMessageDialog(null, Messages.getMessage("treeCreationError"), Messages.getMessage("error"), 
    149                     JOptionPane.ERROR_MESSAGE); 
    150         } 
    151  
    152     } 
    153  
    154     /** 
    155      * recursive method for the creation of the nodes 
    156      * @param categoryNode 
    157      * @param category 
    158      */ 
    159     private void recursiveNodeCreation(DefaultMutableTreeNode categoryNode, Category category) { 
    160         for (Category cat : category.getCategoriesFilles()) { 
    161             DefaultMutableTreeNode node = new DefaultMutableTreeNode(cat); 
    162             categoryNode.add(node); 
    163             recursiveNodeCreation(node, cat); 
    164         } 
    165     } 
    166  
    167     @Override 
    168     public void mouseClicked(MouseEvent arg0) { 
    169  
    170     } 
    171  
    172     @Override 
    173     public void mouseEntered(MouseEvent arg0) { 
    174         // TODO Auto-generated method stub 
    175  
    176     } 
    177  
    178     @Override 
    179     public void mouseExited(MouseEvent arg0) { 
    180         // TODO Auto-generated method stub 
    181  
    182     } 
    183  
    184     @Override 
    185     public void mousePressed(MouseEvent e) { 
    186         int selRow = tree.getRowForLocation(e.getX(), e.getY()); 
    187         TreePath selPath = tree.getPathForLocation(e.getX(), e.getY()); 
    188         //begin bug:0001832 
    189         tree.setSelectionRow(selRow); 
    190         //end 
    191  
    192         if (e.getButton() == 3) { 
    193             JPopupMenu popup = new JPopupMenu(); 
    194             menuAjouter = new JMenuItem(Messages.getMessage("categories_add")); 
    195             menuAjouter.addActionListener(this); 
    196             popup.add(menuAjouter); 
    197             menuActualiser = new JMenuItem(Messages.getMessage("categories_update")); 
    198             menuActualiser.addActionListener(this); 
    199             popup.add(menuActualiser); 
    200             popup.show(tree, e.getX(), e.getY()); 
    201             if (selRow != -1) { 
    202                 DefaultMutableTreeNode node = (DefaultMutableTreeNode) (selPath.getLastPathComponent()); 
    203                 this.selectedCategory = (Category) node.getUserObject(); 
    204             } else { 
    205                 this.selectedCategory = null; 
    206             } 
    207         } 
    208  
    209     } 
    210  
    211     @Override 
    212     public void mouseReleased(MouseEvent arg0) { 
    213         // TODO Auto-generated method stub 
    214  
    215     } 
    216  
    217     @Override 
    218     public void actionPerformed(ActionEvent arg0) { 
    219         if (arg0.getSource().equals(menuAjouter)) { 
    220             String nomcategorie = JOptionPane.showInputDialog(null, Messages.getMessage("categories_enterName"), 
    221                     Messages.getMessage("categories_add"), JOptionPane.INFORMATION_MESSAGE); 
    222             //if the name of the category is not empty 
    223             if (!(nomcategorie == null) && !nomcategorie.equals("")) { 
    224                 //if there is a parent category 
    225                 if (selectedCategory != null) { 
    226                     //try to create a category 
    227                     if (CategoryService.getInstance().creer(nomcategorie, selectedCategory.getIdentifiant())) { 
     59        /** 
     60         * Logger 
     61         */ 
     62        public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory.getLog(CategoriesTree.class); 
     63        /** 
     64         *  the tree 
     65         */ 
     66        private JTree tree; 
     67        /** 
     68         * the menu to add a category 
     69         */ 
     70        private JMenuItem menuAjouter; 
     71        /** 
     72         * the menu to refresh the categories 
     73         */ 
     74        private JMenuItem menuActualiser; 
     75        /** 
     76         * the root of the tree which is not displayed 
     77         */ 
     78        private DefaultMutableTreeNode root = new DefaultMutableTreeNode(""); 
     79        /** 
     80         * the selected category 
     81         */ 
     82        private Category selectedCategory; 
     83 
     84 
     85        /** 
     86         * Constructor 
     87         */ 
     88        public CategoriesTree() { 
     89                super(new BorderLayout()); 
     90                //creation of the tree 
     91                createNodes(root); 
     92                tree = new JTree(root); 
     93                tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION); 
     94                tree.addTreeSelectionListener(this); 
     95                tree.setRootVisible(false); 
     96                tree.addMouseListener(this); 
     97                JScrollPane treeView = new JScrollPane(tree); 
     98                Dimension minimumSize = new Dimension(100, 50); 
     99                treeView.setMinimumSize(minimumSize); 
     100                add(treeView, BorderLayout.CENTER); 
     101        } 
     102 
     103 
     104        /** 
     105         * Method that allows to update the tree 
     106         */ 
     107        public void setUpUi() { 
     108                //begin bug:0001830 
     109                root.removeAllChildren(); 
     110                createNodes(root); 
     111                ((DefaultTreeModel) tree.getModel()).reload(); 
     112                //end 
     113 
     114        } 
     115 
     116 
     117        /* (non-Javadoc) 
     118         * @see javax.swing.event.TreeSelectionListener#valueChanged(javax.swing.event.TreeSelectionEvent) 
     119         */ 
     120        public void valueChanged(TreeSelectionEvent e) { 
     121                DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent(); 
     122                // 
     123                if (node == null) 
     124                        return; 
     125                Object catSelectionnee = node.getUserObject(); 
     126                Category category = (Category) catSelectionnee; 
     127                //MainFrame.imagesPanel.rafraichir(category.getIdentifiant(), false); 
     128                MainFrame.getInstance().addTabb(new ThumbnailCategoryPanel(category)); 
     129        } 
     130 
     131 
     132        /** 
     133         * creation of the nodes 
     134         * @param root the root  
     135         */ 
     136        private void createNodes(DefaultMutableTreeNode root) { 
     137                DefaultMutableTreeNode category = null; 
     138                try { 
     139                        List<Category> list = CategoryService.getInstance().construireArbre(); 
     140                        for (Category cat : list) { 
     141                                if (cat.getCategoriesMeres().size() == 0) { 
     142                                        category = new DefaultMutableTreeNode(cat); 
     143                                        root.add(category); 
     144                                        recursiveNodeCreation(category, cat); 
     145                                } 
     146 
     147                        } 
     148                } catch (Exception e) { 
     149                        LOG.error(Outil.getStackTrace(e)); 
     150                        JOptionPane.showMessageDialog(null, Messages.getMessage("treeCreationError"), Messages.getMessage("error"), 
     151                                        JOptionPane.ERROR_MESSAGE); 
     152                } 
     153 
     154        } 
     155 
     156 
     157        /** 
     158         * recursive method for the creation of the nodes 
     159         * @param categoryNode 
     160         * @param category 
     161         */ 
     162        private void recursiveNodeCreation(DefaultMutableTreeNode categoryNode, Category category) { 
     163                for (Category cat : category.getCategoriesFilles()) { 
     164                        DefaultMutableTreeNode node = new DefaultMutableTreeNode(cat); 
     165                        categoryNode.add(node); 
     166                        recursiveNodeCreation(node, cat); 
     167                } 
     168        } 
     169 
     170 
     171        @Override 
     172        public void mouseClicked(MouseEvent arg0) { 
     173 
     174        } 
     175 
     176 
     177        @Override 
     178        public void mouseEntered(MouseEvent arg0) { 
     179                // TODO Auto-generated method stub 
     180 
     181        } 
     182 
     183 
     184        @Override 
     185        public void mouseExited(MouseEvent arg0) { 
     186                // TODO Auto-generated method stub 
     187 
     188        } 
     189 
     190 
     191        @Override 
     192        public void mousePressed(MouseEvent e) { 
     193                int selRow = tree.getRowForLocation(e.getX(), e.getY()); 
     194                TreePath selPath = tree.getPathForLocation(e.getX(), e.getY()); 
     195                //begin bug:0001832 
     196                tree.setSelectionRow(selRow); 
     197                //end 
     198 
     199                if (e.getButton() == 3) { 
     200                        JPopupMenu popup = new JPopupMenu(); 
     201                        menuAjouter = new JMenuItem(Messages.getMessage("categories_add")); 
     202                        menuAjouter.addActionListener(this); 
     203                        popup.add(menuAjouter); 
     204                        menuActualiser = new JMenuItem(Messages.getMessage("categories_update")); 
     205                        menuActualiser.addActionListener(this); 
     206                        popup.add(menuActualiser); 
     207                        popup.show(tree, e.getX(), e.getY()); 
     208                        if (selRow != -1) { 
     209                                DefaultMutableTreeNode node = (DefaultMutableTreeNode) (selPath.getLastPathComponent()); 
     210                                this.selectedCategory = (Category) node.getUserObject(); 
     211                        } else { 
     212                                this.selectedCategory = null; 
     213                        } 
     214                } 
     215 
     216        } 
     217 
     218 
     219        @Override 
     220        public void mouseReleased(MouseEvent arg0) { 
     221                // TODO Auto-generated method stub 
     222 
     223        } 
     224 
     225 
     226        @Override 
     227        public void actionPerformed(ActionEvent arg0) { 
     228                if (arg0.getSource().equals(menuAjouter)) { 
     229                        String nomcategorie = JOptionPane.showInputDialog(null, Messages.getMessage("categories_enterName"), 
     230                                        Messages.getMessage("categories_add"), JOptionPane.INFORMATION_MESSAGE); 
     231                        //if the name of the category is not empty 
     232                        if (!(nomcategorie == null) && !nomcategorie.equals("")) { 
     233                                //if there is a parent category 
     234                                if (selectedCategory != null) { 
     235                                        //try to create a category 
     236                                        if (CategoryService.getInstance().creer(nomcategorie, selectedCategory.getIdentifiant())) { 
     237                                                setUpUi(); 
     238                                        } else { 
     239                                                JOptionPane.showMessageDialog(null, Messages.getMessage("categoryCreationError"), 
     240                                                                Messages.getMessage("error"), JOptionPane.ERROR_MESSAGE); 
     241 
     242                                        } 
     243                                } else { 
     244                                        if (CategoryService.getInstance().creer(nomcategorie)) { 
     245                                                setUpUi(); 
     246                                        } else { 
     247                                                JOptionPane.showMessageDialog(null, Messages.getMessage("categoryCreationError"), 
     248                                                                Messages.getMessage("error"), JOptionPane.ERROR_MESSAGE); 
     249 
     250                                        } 
     251                                } 
     252                        } 
     253                } else if (arg0.getSource().equals(menuActualiser)) { 
    228254                        setUpUi(); 
    229                     } else { 
    230                         JOptionPane.showMessageDialog(null, Messages.getMessage("categoryCreationError"), Messages 
    231                                 .getMessage("error"), JOptionPane.ERROR_MESSAGE); 
    232  
    233                     } 
    234                 } else { 
    235                     if (CategoryService.getInstance().creer(nomcategorie)) { 
    236                         setUpUi(); 
    237                     } else { 
    238                         JOptionPane.showMessageDialog(null, Messages.getMessage("categoryCreationError"), Messages 
    239                                 .getMessage("error"), JOptionPane.ERROR_MESSAGE); 
    240  
    241                     } 
    242                 } 
    243             } 
    244         } else if (arg0.getSource().equals(menuActualiser)) { 
    245             setUpUi(); 
    246         } 
    247     } 
     255                } 
     256        } 
    248257} 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/mainframe/MainFrame.java

    r6980 r7221  
    99import java.awt.event.KeyListener; 
    1010import java.util.HashMap; 
    11  
    1211import javax.swing.ImageIcon; 
    1312import javax.swing.JComponent; 
     
    2120import javax.swing.JScrollPane; 
    2221import javax.swing.JSplitPane; 
    23  
    2422import fr.mael.jiwigo.transverse.util.Messages; 
    2523import fr.mael.jiwigo.transverse.util.Outil; 
    2624import fr.mael.jiwigo.ui.field.HintTextField; 
    2725import fr.mael.jiwigo.ui.mainframe.tab.JTabbedPaneWithCloseIcons; 
     26 
    2827 
    2928/** 
     
    5756 */ 
    5857public class MainFrame extends JFrame implements ActionListener, KeyListener { 
    59     /** 
    60      * Logger 
    61      */ 
    62     public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory 
    63             .getLog(MainFrame.class); 
    64     /** 
    65      * the categories tree 
    66      */ 
    67     private CategoriesTree categoriesTree; 
    68     /** 
    69      * Splitpane. On the left : the categories tree and on the right the thumbnails 
    70      * for the current category 
    71      */ 
    72     private JSplitPane splitPane; 
    73     /** 
    74      * Panel that contains the thumbnail of the current category 
    75      */ 
    76     public static ThumbnailCategoryPanel imagesPanel; 
    77     /** 
    78      *  Scrollpane that contains the panel above 
    79      */ 
    80     private JScrollPane scrollPaneImagesPanel; 
    81     /** 
    82      * label that displays messages 
    83      */ 
    84     private JLabel labelMessage; 
    85  
    86     /** 
    87      * menu bar 
    88      */ 
    89     private JMenuBar jMenuBar; 
    90  
    91     /** 
    92      * edition menu 
    93      */ 
    94     private JMenu jMenuEdition; 
    95  
    96     /** 
    97      * preferences menu 
    98      */ 
    99     private JMenuItem jMenuItemPreferences; 
    100  
    101     /** 
    102      * singleton 
    103      */ 
    104     private static MainFrame instance; 
    105  
    106     private JProgressBar progressBar; 
    107  
    108     private JTabbedPaneWithCloseIcons tabbedPane; 
    109  
    110     private HashMap<Integer, Integer> mapsIdPos = new HashMap<Integer, Integer>(); 
    111  
    112     private HintTextField fieldSearch; 
    113  
    114     /** 
    115      * @return the singleton 
    116      */ 
    117     public static MainFrame getInstance() { 
    118         if (instance == null) { 
    119             instance = new MainFrame(); 
    120         } 
    121         return instance; 
    122     } 
    123  
    124     /** 
    125      * private constructor to use a singleton 
    126      */ 
    127     private MainFrame() { 
    128         this.setTitle("Jiwigo v" + Messages.getMessage("version")); 
    129         this.setIconImage(java.awt.Toolkit.getDefaultToolkit().getImage(Outil.getURL("fr/mael/jiwigo/img/icon.png"))); 
    130         this.setLayout(new BorderLayout()); 
    131         jMenuBar = new JMenuBar(); 
    132         labelMessage = new JLabel(Messages.getMessage("welcomeMessage")); 
    133         splitPane = new JSplitPane(); 
    134         categoriesTree = new CategoriesTree(); 
    135         splitPane.setLeftComponent(categoriesTree); 
    136  
    137         tabbedPane = new JTabbedPaneWithCloseIcons(); 
    138         splitPane.setRightComponent(tabbedPane); 
    139  
    140         this.add(splitPane, BorderLayout.CENTER); 
    141         JPanel panelBas = new JPanel(new BorderLayout()); 
    142         JPanel panel = new JPanel(new FlowLayout(FlowLayout.LEFT)); 
    143         progressBar = new JProgressBar(0, 100); 
    144         panel.add(progressBar); 
    145         panel.add(labelMessage); 
    146         panelBas.add(panel, BorderLayout.WEST); 
    147  
    148         fieldSearch = new HintTextField(Messages.getMessage("mainFrame_recherche")); 
    149         fieldSearch.setPreferredSize(new Dimension(150, 25)); 
    150         fieldSearch.addKeyListener(this); 
    151         panelBas.add(fieldSearch, BorderLayout.EAST); 
    152  
    153         jMenuEdition = new JMenu(Messages.getMessage("mainFrame_editionMenu")); 
    154         jMenuBar.add(jMenuEdition); 
    155         jMenuItemPreferences = new JMenuItem(Messages.getMessage("mainFrame_preferencesMenu")); 
    156         jMenuItemPreferences.addActionListener(this); 
    157         jMenuEdition.add(jMenuItemPreferences); 
    158  
    159         this.setJMenuBar(jMenuBar); 
    160         this.add(panelBas, BorderLayout.SOUTH); 
    161         this.setSize(900, 600); 
    162         this.setLocationRelativeTo(null); 
    163         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
    164         this.setResizable(true); 
    165     } 
    166  
    167     public void addTabb(IThumbnailPanel panel) { 
    168         JScrollPane scrollPaneImagesPanel = new JScrollPane((JPanel) panel, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, 
    169                 JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED); 
    170         scrollPaneImagesPanel.setPreferredSize(new Dimension(900, 600)); 
    171         boolean found = false; 
    172         boolean isSearch = false; 
    173         if (panel instanceof ThumbnailSearchPanel) { 
    174             isSearch = true; 
    175         } 
    176         for (int i = 0; i < tabbedPane.getTabCount(); i++) { 
    177             JScrollPane scroll = (JScrollPane) tabbedPane.getComponentAt(i); 
    178             IThumbnailPanel thumbPan = (IThumbnailPanel) scroll.getViewport().getComponents()[0]; 
    179             if (thumbPan.getCategory().getIdentifiant().equals(panel.getCategory().getIdentifiant())) { 
    180                 //only if it's not for a re 
    181                 if (!(panel instanceof ThumbnailSearchPanel)) { 
    182                     tabbedPane.setSelectedIndex(i); 
    183                     found = true; 
    184                     break; 
    185                 } 
    186             } 
    187         } 
    188         //if it's not for a research, the title of the tab 
    189         //is the name of the category 
    190         if (!found && !isSearch) { 
    191             tabbedPane.addTab(panel.getCategory().getNom(), scrollPaneImagesPanel, new ImageIcon(Outil 
    192                     .getURL("fr/mael/jiwigo/img/closetab.png"))); 
    193             //if it's for a research, the title of the tab 
    194             //if the query string 
    195         } else if (!found && isSearch) { 
    196             String queryString = ((ThumbnailSearchPanel) panel).getQueryString(); 
    197             tabbedPane.addTab(Messages.getMessage("mainFrame_search") + queryString, scrollPaneImagesPanel, 
    198                     new ImageIcon(Outil.getURL("fr/mael/jiwigo/img/closetab.png"))); 
    199         } 
    200  
    201     } 
    202  
    203     /** 
    204      * displays the frame 
    205      */ 
    206     public void showUi() { 
    207         this.setVisible(true); 
    208     } 
    209  
    210     /** 
    211      * Affichage d'un message de réussite 
    212      * @param message 
    213      */ 
    214     public void setMessage(String message) { 
    215         this.labelMessage.setText(message); 
    216     } 
    217  
    218     @Override 
    219     public void actionPerformed(ActionEvent arg0) { 
    220         if (arg0.getSource().equals(jMenuItemPreferences)) { 
    221             new PreferencesDialog(this); 
    222         } 
    223  
    224     } 
    225  
    226     public static void reduceSizeOfComponent(JComponent comp) { 
    227         comp.setMaximumSize(comp.getPreferredSize()); 
    228     } 
    229  
    230     /** 
    231      * @return the progressBar 
    232      */ 
    233     public JProgressBar getProgressBar() { 
    234         return progressBar; 
    235     } 
    236  
    237     /** 
    238      * @return the mapsIdPos 
    239      */ 
    240     public HashMap<Integer, Integer> getMapsIdPos() { 
    241         return mapsIdPos; 
    242     } 
    243  
    244     @Override 
    245     public void keyPressed(KeyEvent paramKeyEvent) { 
    246         if (paramKeyEvent.getKeyCode() == KeyEvent.VK_ENTER) { 
    247             String queryString = fieldSearch.getText(); 
    248             ThumbnailSearchPanel searchPanel = new ThumbnailSearchPanel(queryString); 
    249             addTabb(searchPanel); 
    250         } 
    251     } 
    252  
    253     @Override 
    254     public void keyReleased(KeyEvent paramKeyEvent) { 
    255     } 
    256  
    257     @Override 
    258     public void keyTyped(KeyEvent paramKeyEvent) { 
    259     } 
     58 
     59        /** 
     60         * Logger 
     61         */ 
     62        public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory.getLog(MainFrame.class); 
     63        /** 
     64         * the categories tree 
     65         */ 
     66        private CategoriesTree categoriesTree; 
     67        /** 
     68         * Splitpane. On the left : the categories tree and on the right the thumbnails 
     69         * for the current category 
     70         */ 
     71        private JSplitPane splitPane; 
     72        /** 
     73         * Panel that contains the thumbnail of the current category 
     74         */ 
     75        public static ThumbnailCategoryPanel imagesPanel; 
     76        /** 
     77         *  Scrollpane that contains the panel above 
     78         */ 
     79        private JScrollPane scrollPaneImagesPanel; 
     80        /** 
     81         * label that displays messages 
     82         */ 
     83        private JLabel labelMessage; 
     84 
     85        /** 
     86         * menu bar 
     87         */ 
     88        private JMenuBar jMenuBar; 
     89 
     90        /** 
     91         * edition menu 
     92         */ 
     93        private JMenu jMenuEdition; 
     94 
     95        /** 
     96         * preferences menu 
     97         */ 
     98        private JMenuItem jMenuItemPreferences; 
     99 
     100        /** 
     101         * singleton 
     102         */ 
     103        private static MainFrame instance; 
     104 
     105        private JProgressBar progressBar; 
     106 
     107        private JTabbedPaneWithCloseIcons tabbedPane; 
     108 
     109        private HashMap<Integer, Integer> mapsIdPos = new HashMap<Integer, Integer>(); 
     110 
     111        private HintTextField fieldSearch; 
     112 
     113 
     114        /** 
     115         * @return the singleton 
     116         */ 
     117        public static MainFrame getInstance() { 
     118                if (instance == null) { 
     119                        instance = new MainFrame(); 
     120                } 
     121                return instance; 
     122        } 
     123 
     124 
     125        /** 
     126         * private constructor to use a singleton 
     127         */ 
     128        private MainFrame() { 
     129                this.setTitle("Jiwigo v" + Messages.getMessage("version")); 
     130                this.setIconImage(java.awt.Toolkit.getDefaultToolkit().getImage(Outil.getURL("fr/mael/jiwigo/img/icon.png"))); 
     131                this.setLayout(new BorderLayout()); 
     132                jMenuBar = new JMenuBar(); 
     133                labelMessage = new JLabel(Messages.getMessage("welcomeMessage")); 
     134                splitPane = new JSplitPane(); 
     135                categoriesTree = new CategoriesTree(); 
     136                splitPane.setLeftComponent(categoriesTree); 
     137 
     138                tabbedPane = new JTabbedPaneWithCloseIcons(); 
     139                splitPane.setRightComponent(tabbedPane); 
     140 
     141                this.add(splitPane, BorderLayout.CENTER); 
     142                JPanel panelBas = new JPanel(new BorderLayout()); 
     143                JPanel panel = new JPanel(new FlowLayout(FlowLayout.LEFT)); 
     144                progressBar = new JProgressBar(0, 100); 
     145                panel.add(progressBar); 
     146                panel.add(labelMessage); 
     147                panelBas.add(panel, BorderLayout.WEST); 
     148 
     149                fieldSearch = new HintTextField(Messages.getMessage("mainFrame_recherche")); 
     150                fieldSearch.setPreferredSize(new Dimension(150, 25)); 
     151                fieldSearch.addKeyListener(this); 
     152                panelBas.add(fieldSearch, BorderLayout.EAST); 
     153 
     154                jMenuEdition = new JMenu(Messages.getMessage("mainFrame_editionMenu")); 
     155                jMenuBar.add(jMenuEdition); 
     156                jMenuItemPreferences = new JMenuItem(Messages.getMessage("mainFrame_preferencesMenu")); 
     157                jMenuItemPreferences.addActionListener(this); 
     158                jMenuEdition.add(jMenuItemPreferences); 
     159 
     160                this.setJMenuBar(jMenuBar); 
     161                this.add(panelBas, BorderLayout.SOUTH); 
     162                this.setSize(900, 600); 
     163                this.setLocationRelativeTo(null); 
     164                this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
     165                this.setResizable(true); 
     166        } 
     167 
     168 
     169        public void addTabb(IThumbnailPanel panel) { 
     170                JScrollPane scrollPaneImagesPanel = new JScrollPane((JPanel) panel, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED); 
     171                scrollPaneImagesPanel.setPreferredSize(new Dimension(900, 600)); 
     172                boolean found = false; 
     173                boolean isSearch = false; 
     174                if (panel instanceof ThumbnailSearchPanel) { 
     175                        isSearch = true; 
     176                } 
     177 
     178                for (int i = 0; i < tabbedPane.getTabCount(); i++) { 
     179                        JScrollPane scroll = (JScrollPane) tabbedPane.getComponentAt(i); 
     180                        IThumbnailPanel thumbPan = (IThumbnailPanel) scroll.getViewport().getComponents()[0]; 
     181                        if (thumbPan.getCategory().getIdentifiant().equals(panel.getCategory().getIdentifiant())) { 
     182                                //only if it's not for a re 
     183                                if (!(panel instanceof ThumbnailSearchPanel)) { 
     184                                        tabbedPane.setSelectedIndex(i); 
     185                                        found = true; 
     186                                        break; 
     187                                } 
     188                        } 
     189                } 
     190                //if it's not for a research, the title of the tab 
     191                //is the name of the category 
     192                if (!found && !isSearch) { 
     193                        tabbedPane.addTab(panel.getCategory().getNom(), scrollPaneImagesPanel, 
     194                                        new ImageIcon(Outil.getURL("fr/mael/jiwigo/img/closetab.png"))); 
     195                        //if it's for a research, the title of the tab 
     196                        //if the query string 
     197                } else if (!found && isSearch) { 
     198                        String queryString = ((ThumbnailSearchPanel) panel).getQueryString(); 
     199                        tabbedPane.addTab(Messages.getMessage("mainFrame_search") + queryString, scrollPaneImagesPanel, 
     200                                        new ImageIcon(Outil.getURL("fr/mael/jiwigo/img/closetab.png"))); 
     201                } 
     202 
     203        } 
     204 
     205 
     206        /** 
     207         * displays the frame 
     208         */ 
     209        public void showUi() { 
     210                this.setVisible(true); 
     211        } 
     212 
     213 
     214        /** 
     215         * Affichage d'un message de réussite 
     216         * @param message 
     217         */ 
     218        public void setMessage(String message) { 
     219                this.labelMessage.setText(message); 
     220        } 
     221 
     222 
     223        @Override 
     224        public void actionPerformed(ActionEvent arg0) { 
     225                if (arg0.getSource().equals(jMenuItemPreferences)) { 
     226                        new PreferencesDialog(this); 
     227                } 
     228 
     229        } 
     230 
     231 
     232        public static void reduceSizeOfComponent(JComponent comp) { 
     233                comp.setMaximumSize(comp.getPreferredSize()); 
     234        } 
     235 
     236 
     237        /** 
     238         * @return the progressBar 
     239         */ 
     240        public JProgressBar getProgressBar() { 
     241                return progressBar; 
     242        } 
     243 
     244 
     245        /** 
     246         * @return the mapsIdPos 
     247         */ 
     248        public HashMap<Integer, Integer> getMapsIdPos() { 
     249                return mapsIdPos; 
     250        } 
     251 
     252 
     253        @Override 
     254        public void keyPressed(KeyEvent paramKeyEvent) { 
     255                if (paramKeyEvent.getKeyCode() == KeyEvent.VK_ENTER) { 
     256                        String queryString = fieldSearch.getText(); 
     257                        ThumbnailSearchPanel searchPanel = new ThumbnailSearchPanel(queryString); 
     258                        addTabb(searchPanel); 
     259                } 
     260        } 
     261 
     262 
     263        @Override 
     264        public void keyReleased(KeyEvent paramKeyEvent) { 
     265        } 
     266 
     267 
     268        @Override 
     269        public void keyTyped(KeyEvent paramKeyEvent) { 
     270        } 
    260271 
    261272} 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/mainframe/ThumbnailCategoryPanel.java

    r7070 r7221  
    11package fr.mael.jiwigo.ui.mainframe; 
    22 
     3import java.awt.Dimension; 
    34import java.awt.FlowLayout; 
     5import java.awt.Graphics; 
    46import java.io.File; 
    5  
    67import javax.swing.JOptionPane; 
    78import javax.swing.JPanel; 
    8  
    99import fr.mael.jiwigo.om.Category; 
    1010import fr.mael.jiwigo.om.Image; 
     
    1515import fr.mael.jiwigo.transverse.util.filedrop.FileDrop; 
    1616import fr.mael.jiwigo.ui.layout.VerticalLayout; 
     17 
    1718 
    1819/** 
     
    4647 */ 
    4748public class ThumbnailCategoryPanel extends JPanel implements IThumbnailPanel { 
    48     /** 
    49      * Logger 
    50      */ 
    51     public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory 
    52             .getLog(ThumbnailCategoryPanel.class); 
    53     /** 
    54      * id of the category 
    55      */ 
    56     private Integer categoryId; 
    57  
    58     private Category category; 
    59  
    60     public ThumbnailCategoryPanel(Category category) { 
    61         this(category.getIdentifiant()); 
    62         this.category = category; 
    63     } 
    64  
    65     /** 
    66      * Constructor 
    67      * @param categoryId id of the category 
    68      */ 
    69     public ThumbnailCategoryPanel(Integer categoryId) { 
    70         this.categoryId = categoryId; 
    71         this.setLayout(new VerticalLayout()); 
    72         if (categoryId != null) { 
    73             rafraichir(categoryId, false); 
    74         } 
    75         //gestion du drag'n drop 
    76         new FileDrop(System.out, this, new FileDrop.Listener() { 
    77             public void filesDropped(final java.io.File[] files) { 
    78                 if (!ImagesManagement.rememberPrivacyLevel) { 
    79                     new DialogPrivacyLevel(); 
    80                 } 
    81                 new Thread(new ThreadEnvoiPhoto(files)).start(); 
    82  
    83             } 
    84         }); 
    85  
    86     } 
    87  
    88     /** 
    89      * refreshes the panel 
    90      * @param categoryId the id of the category 
    91      */ 
    92     public void rafraichir(Integer categoryId, boolean rafraichir) { 
    93         this.categoryId = categoryId; 
    94         new Thread(new ThreadLoadThumb(this, rafraichir)).start(); 
    95     } 
    96  
    97     /** 
    98      * @return the categoryId 
    99      */ 
    100     public Integer getCategoryId() { 
    101         return categoryId; 
    102     } 
    103  
    104     /** 
    105      * @param categoryId the categoryId to set 
    106      */ 
    107     public void setCategoryId(Integer categoryId) { 
    108         this.categoryId = categoryId; 
    109     } 
    110  
    111     /** 
    112      * @return the category 
    113      */ 
    114     public Category getCategory() { 
    115         return category; 
    116     } 
    117  
    118     /** 
    119      * @param category the category to set 
    120      */ 
    121     public void setCategory(Category category) { 
    122         this.category = category; 
    123     } 
    124  
    125     /** 
    126      * @author mael 
    127      * Thread that send the photos 
    128      */ 
    129     public class ThreadEnvoiPhoto implements Runnable { 
    130         private File[] files; 
    131  
    132         public ThreadEnvoiPhoto(File[] files) { 
    133             this.files = files; 
    134         } 
     49 
     50        /** 
     51         * Logger 
     52         */ 
     53        public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory.getLog(ThumbnailCategoryPanel.class); 
     54        /** 
     55         * id of the category 
     56         */ 
     57        private Integer categoryId; 
     58 
     59        private Category category; 
     60 
     61        /** 
     62         * thumbnails per line 
     63         */ 
     64        private int thumbnailPerLine = 7; 
     65 
     66        /** 
     67         * Saved dimension of the panel, used to define the number 
     68         * of thumbnails on a line 
     69         */ 
     70        private Dimension savedDimension = new Dimension(); 
     71 
     72 
     73        public ThumbnailCategoryPanel(Category category) { 
     74                this(category.getIdentifiant()); 
     75                this.category = category; 
     76        } 
     77 
     78 
     79        /** 
     80         * Constructor 
     81         * @param categoryId id of the category 
     82         */ 
     83        public ThumbnailCategoryPanel(Integer categoryId) { 
     84                this.categoryId = categoryId; 
     85                this.setLayout(new VerticalLayout()); 
     86                if (categoryId != null) { 
     87                        rafraichir(categoryId, false); 
     88                } 
     89                //gestion du drag'n drop 
     90                new FileDrop(System.out, this, new FileDrop.Listener() { 
     91 
     92                        public void filesDropped(final java.io.File[] files) { 
     93                                if (!ImagesManagement.rememberPrivacyLevel) { 
     94                                        new DialogPrivacyLevel(); 
     95                                } 
     96                                new Thread(new ThreadEnvoiPhoto(files)).start(); 
     97 
     98                        } 
     99                }); 
     100 
     101        } 
     102 
    135103 
    136104        @Override 
    137         public void run() { 
    138  
    139             for (int i = 0; i < files.length; i++) { 
    140                 int nbProgressBar = ((i + 1) * 100) / files.length; 
     105        public void paint(Graphics g) { 
     106                super.paint(g); 
     107                if (!MainFrame.getInstance().getSize().equals(savedDimension)) { 
     108                        //                      LOG.debug("paint " + getSize()); 
     109                        savedDimension = MainFrame.getInstance().getSize(); 
     110                        int width = savedDimension.width; 
     111                        thumbnailPerLine = width / 150; 
     112                        addThumbnails(); 
     113                } 
     114        } 
     115 
     116 
     117        /** 
     118         * refreshes the panel 
     119         * @param categoryId the id of the category 
     120         */ 
     121        public void rafraichir(Integer categoryId, boolean rafraichir) { 
     122                this.categoryId = categoryId; 
    141123                try { 
    142  
    143                     ImageService.getInstance().creer(files[i].getCanonicalPath(), categoryId); 
    144                     MainFrame.getInstance() 
    145                             .setMessage(files[i].getName() + " " + Messages.getMessage("sendingSuccess")); 
     124                        MainFrame.getInstance().setMessage(Messages.getMessage("thumbviewer_loading")); 
     125                        ImagesManagement.LIST_IMAGE = ImageService.getInstance().listerParCategory(categoryId, rafraichir); 
     126                        addThumbnails(); 
     127                        this.repaint(); 
     128                        this.revalidate(); 
     129                        MainFrame.getInstance().setMessage(Messages.getMessage("loadingOk")); 
    146130                } catch (Exception e) { 
    147                     LOG.error(Outil.getStackTrace(e)); 
    148                     //displays a dialog if there is an error 
    149                     JOptionPane.showMessageDialog(null, Messages.getMessage("sendingError") + files[i].getName(), 
    150                             Messages.getMessage("error"), JOptionPane.ERROR_MESSAGE); 
    151                     MainFrame.getInstance().setMessage(Messages.getMessage("sendingError") + " " + files[i].getName()); 
    152                 } finally { 
    153                     MainFrame.getInstance().getProgressBar().setValue(nbProgressBar); 
    154                 } 
    155             } 
    156             //refresh 
    157             rafraichir(categoryId, true); 
    158             MainFrame.getInstance().getProgressBar().setValue(0); 
    159         } 
    160     } 
    161  
    162     /** 
    163      *  
    164      * @author mael 
    165      * Thread that loads the thumbs and fills the thumb panel 
    166      */ 
    167     public class ThreadLoadThumb implements Runnable { 
    168         ThumbnailCategoryPanel panel; 
    169         boolean rafraichir; 
    170  
    171         public ThreadLoadThumb(ThumbnailCategoryPanel panel, boolean rafraichir) { 
    172             this.panel = panel; 
    173             this.rafraichir = rafraichir; 
    174         } 
    175  
    176         @Override 
    177         public void run() { 
    178  
    179             panel.removeAll(); 
    180             int nb = 1; 
    181             JPanel panelh = new JPanel(new FlowLayout()); 
    182             try { 
    183                 MainFrame.getInstance().setMessage(Messages.getMessage("thumbviewer_loading")); 
    184                 ImagesManagement.LIST_IMAGE = ImageService.getInstance().listerParCategory(categoryId, rafraichir); 
     131                        LOG.error(Outil.getStackTrace(e)); 
     132                        JOptionPane.showMessageDialog(null, Messages.getMessage("imagesListingError"), Messages.getMessage("error"), 
     133                                        JOptionPane.ERROR_MESSAGE); 
     134                        MainFrame.getInstance().setMessage(Messages.getMessage("imagesListingError")); 
     135                } 
     136        } 
     137 
     138 
     139        /** 
     140         * Adds the thumbnails to the panel 
     141         */ 
     142        private void addThumbnails() { 
     143                this.removeAll(); 
     144                int nb = 1; 
     145                JPanel panelh = new JPanel(new FlowLayout()); 
    185146                for (Image image : ImagesManagement.LIST_IMAGE) { 
    186                     try { 
    187  
    188                         if (nb == 7) { 
    189                             panel.add(panelh); 
    190                             panelh = new JPanel(new FlowLayout()); 
    191                             nb = 0; 
    192                         } else { 
    193                             ThumbnailPanel panel = new ThumbnailPanel(image); 
    194                             panelh.add(panel); 
     147                        try { 
     148 
     149                                if (nb == thumbnailPerLine) { 
     150                                        this.add(panelh); 
     151                                        panelh = new JPanel(new FlowLayout()); 
     152                                        nb = 0; 
     153                                } else { 
     154                                        ThumbnailPanel panel = new ThumbnailPanel(image); 
     155                                        panelh.add(panel); 
     156                                } 
     157                                nb++; 
     158 
     159                        } catch (Exception e) { 
     160 
    195161                        } 
    196                         nb++; 
    197  
    198                     } catch (Exception e) { 
    199  
    200                     } 
    201                 } 
    202                 if (nb != 8) { 
    203                     panel.add(panelh); 
    204                 } 
    205                 panel.repaint(); 
    206                 panel.revalidate(); 
    207                 MainFrame.getInstance().setMessage(Messages.getMessage("loadingOk")); 
    208             } catch (Exception e) { 
    209                 LOG.error(Outil.getStackTrace(e)); 
    210                 JOptionPane.showMessageDialog(null, Messages.getMessage("imagesListingError"), Messages 
    211                         .getMessage("error"), JOptionPane.ERROR_MESSAGE); 
    212                 MainFrame.getInstance().setMessage(Messages.getMessage("imagesListingError")); 
    213             } 
    214  
    215         } 
    216     } 
     162                } 
     163                if (nb != thumbnailPerLine + 1) { 
     164                        this.add(panelh); 
     165                } 
     166        } 
     167 
     168 
     169        /** 
     170         * @return the categoryId 
     171         */ 
     172        public Integer getCategoryId() { 
     173                return categoryId; 
     174        } 
     175 
     176 
     177        /** 
     178         * @param categoryId the categoryId to set 
     179         */ 
     180        public void setCategoryId(Integer categoryId) { 
     181                this.categoryId = categoryId; 
     182        } 
     183 
     184 
     185        /** 
     186         * @return the category 
     187         */ 
     188        public Category getCategory() { 
     189                return category; 
     190        } 
     191 
     192 
     193        /** 
     194         * @param category the category to set 
     195         */ 
     196        public void setCategory(Category category) { 
     197                this.category = category; 
     198        } 
     199 
     200        /** 
     201         * @author mael 
     202         * Thread that send the photos 
     203         */ 
     204        public class ThreadEnvoiPhoto implements Runnable { 
     205 
     206                private File[] files; 
     207 
     208 
     209                public ThreadEnvoiPhoto(File[] files) { 
     210                        this.files = files; 
     211                } 
     212 
     213 
     214                @Override 
     215                public void run() { 
     216 
     217                        for (int i = 0; i < files.length; i++) { 
     218                                int nbProgressBar = ((i + 1) * 100) / files.length; 
     219                                try { 
     220 
     221                                        ImageService.getInstance().creer(files[i].getCanonicalPath(), categoryId); 
     222                                        MainFrame.getInstance().setMessage(files[i].getName() + " " + Messages.getMessage("sendingSuccess")); 
     223                                } catch (Exception e) { 
     224                                        LOG.error(Outil.getStackTrace(e)); 
     225                                        //displays a dialog if there is an error 
     226                                        JOptionPane.showMessageDialog(null, Messages.getMessage("sendingError") + files[i].getName(), 
     227                                                        Messages.getMessage("error"), JOptionPane.ERROR_MESSAGE); 
     228                                        MainFrame.getInstance().setMessage(Messages.getMessage("sendingError") + " " + files[i].getName()); 
     229                                } finally { 
     230                                        MainFrame.getInstance().getProgressBar().setValue(nbProgressBar); 
     231                                } 
     232                        } 
     233                        //refresh 
     234                        rafraichir(categoryId, true); 
     235                        MainFrame.getInstance().getProgressBar().setValue(0); 
     236                } 
     237        } 
    217238 
    218239} 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/mainframe/ThumbnailPanel.java

    r7070 r7221  
    1414import java.io.IOException; 
    1515import java.util.List; 
    16  
    1716import javax.swing.JButton; 
    1817import javax.swing.JDialog; 
     
    2524import javax.swing.JScrollPane; 
    2625import javax.swing.ListSelectionModel; 
    27  
    2826import fr.mael.jiwigo.om.Image; 
    2927import fr.mael.jiwigo.om.Tag; 
     
    3432import fr.mael.jiwigo.ui.browser.BrowserFrame; 
    3533import fr.mael.jiwigo.ui.layout.VerticalLayout; 
     34 
    3635 
    3736/** 
     
    6564 */ 
    6665public class ThumbnailPanel extends JLabel implements MouseListener, ActionListener { 
    67     /** 
    68      * Logger 
    69      */ 
    70     public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory 
    71             .getLog(ThumbnailPanel.class); 
    72     /** 
    73      * the image 
    74      */ 
    75     private Image image; 
    76  
    77     /** 
    78      * Popup menu to edit images info 
    79      */ 
    80     private JMenuItem menuAjouterTag; 
    81  
    82     /** 
    83      * Button to add tags 
    84      */ 
    85     private JButton boutonOkAjouterTag; 
    86  
    87     /** 
    88      * List of tags 
    89      */ 
    90     private JList listTags; 
    91  
    92     /** 
    93      * Dialog that allows to choose tags 
    94      */ 
    95     private JDialog dialogChoixTags; 
    96  
    97     /** 
    98      * Constructeur 
    99      * @param image the image 
    100      * @param imagesPanel the panel 
    101      */ 
    102     public ThumbnailPanel(Image image) { 
    103         this.image = image; 
    104         setToolTipText("<html><center>" + image.getName() + "<br/>" + image.getVue() + " " 
    105                 + Messages.getMessage("hits") + "</center></html>"); 
    106         this.addMouseListener(this); 
    107     } 
    108  
    109     protected void paintComponent(Graphics g) { 
    110         super.paintComponent(g); 
    111         Graphics2D g2 = (Graphics2D) g; 
    112         g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC); 
    113         double x = (getWidth() * ImagesManagement.getMiniatureBufferedImage(image).getWidth()) / 2; 
    114         double y = (getHeight() * ImagesManagement.getMiniatureBufferedImage(image).getHeight()) / 2; 
    115         g2.drawRenderedImage(ImagesManagement.getMiniatureBufferedImage(image), null); 
    116     } 
    117  
    118     /* (non-Javadoc) 
    119      * @see javax.swing.JComponent#getPreferredSize() 
    120      */ 
    121     public Dimension getPreferredSize() { 
    122         int w = (int) (ImagesManagement.getMiniatureBufferedImage(image).getWidth()); 
    123         int h = (int) (ImagesManagement.getMiniatureBufferedImage(image).getHeight() + 10); 
    124         return new Dimension(w, h); 
    125     } 
    126  
    127     @Override 
    128     public void mouseClicked(MouseEvent paramMouseEvent) { 
    129         // on affiche l'image en grand 
    130         ImagesManagement.setCurrentImage(image); 
    131         try { 
    132             if (paramMouseEvent.getButton() == 1) { 
    133                 new BrowserFrame(image); 
    134             } else if (paramMouseEvent.getButton() == 3) { 
    135                 JPopupMenu popup = new JPopupMenu(); 
    136                 menuAjouterTag = new JMenuItem(Messages.getMessage("thumbviewer_addTag")); 
    137                 menuAjouterTag.addActionListener(this); 
    138                 popup.add(menuAjouterTag); 
    139                 popup.show(this, paramMouseEvent.getX(), paramMouseEvent.getY()); 
    140             } 
    141         } catch (Exception e) { 
    142             e.printStackTrace(); 
    143         } 
    144  
    145     } 
    146  
    147     @Override 
    148     public void mouseEntered(MouseEvent paramMouseEvent) { 
    149         this.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR)); 
    150     } 
    151  
    152     @Override 
    153     public void mouseExited(MouseEvent paramMouseEvent) { 
    154     } 
    155  
    156     @Override 
    157     public void mousePressed(MouseEvent paramMouseEvent) { 
    158         // TODO Auto-generated method stub 
    159  
    160     } 
    161  
    162     @Override 
    163     public void mouseReleased(MouseEvent paramMouseEvent) { 
    164         // TODO Auto-generated method stub 
    165  
    166     } 
    167  
    168     @Override 
    169     public void actionPerformed(ActionEvent arg0) { 
    170         if (arg0.getSource().equals(menuAjouterTag)) { 
    171             try { 
    172                 //getting the list of tags 
    173                 List<Tag> tagsDispo = TagService.getInstance().lister(); 
    174                 //list to array (cause fucking JList does not support Lists) 
    175                 Tag[] tableauTagDispo = (Tag[]) tagsDispo.toArray(new Tag[tagsDispo.size()]); 
    176                 //getting the image's tags to preselect them 
    177                 List<Tag> tagsDeLimage = TagService.getInstance().tagsForImage(image); 
    178                 listTags = new JList(tableauTagDispo); 
    179                 //multiple selection is allowed 
    180                 listTags.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION); 
    181                 listTags.setPreferredSize(new Dimension(100, 200)); 
    182                 //construct an array of the indices to select in the jlist 
    183                 int[] indices = new int[tagsDeLimage.size()]; 
    184                 int compteur = 0; 
    185                 for (int i = 0; i < tableauTagDispo.length; i++) { 
    186                     for (Tag tag : tagsDeLimage) { 
    187                         if (tag.getId().equals(tableauTagDispo[i].getId())) { 
    188                             indices[compteur++] = i; 
    189  
    190                         } 
    191                     } 
     66 
     67        /** 
     68         * Logger 
     69         */ 
     70        public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory.getLog(ThumbnailPanel.class); 
     71        /** 
     72         * the image 
     73         */ 
     74        private Image image; 
     75 
     76        /** 
     77         * Popup menu to edit images info 
     78         */ 
     79        private JMenuItem menuAjouterTag; 
     80 
     81        /** 
     82         * Button to add tags 
     83         */ 
     84        private JButton boutonOkAjouterTag; 
     85 
     86        /** 
     87         * List of tags 
     88         */ 
     89        private JList listTags; 
     90 
     91        /** 
     92         * Dialog that allows to choose tags 
     93         */ 
     94        private JDialog dialogChoixTags; 
     95 
     96 
     97        /** 
     98         * Constructeur 
     99         * @param image the image 
     100         * @param imagesPanel the panel 
     101         */ 
     102        public ThumbnailPanel(Image image) { 
     103                this.image = image; 
     104                setToolTipText("<html><center>" + image.getName() + "<br/>" + image.getVue() + " " + Messages.getMessage("hits") 
     105                                + "</center></html>"); 
     106                this.addMouseListener(this); 
     107        } 
     108 
     109 
     110        protected void paintComponent(Graphics g) { 
     111                super.paintComponent(g); 
     112                Graphics2D g2 = (Graphics2D) g; 
     113                g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC); 
     114                double x = (getWidth() * ImagesManagement.getMiniatureBufferedImage(image).getWidth()) / 2; 
     115                double y = (getHeight() * ImagesManagement.getMiniatureBufferedImage(image).getHeight()) / 2; 
     116                g2.drawRenderedImage(ImagesManagement.getMiniatureBufferedImage(image), null); 
     117        } 
     118 
     119 
     120        /* (non-Javadoc) 
     121         * @see javax.swing.JComponent#getPreferredSize() 
     122         */ 
     123        public Dimension getPreferredSize() { 
     124                int w = (int) (ImagesManagement.getMiniatureBufferedImage(image).getWidth()); 
     125                int h = (int) (ImagesManagement.getMiniatureBufferedImage(image).getHeight() + 10); 
     126                return new Dimension(w, h); 
     127        } 
     128 
     129 
     130        @Override 
     131        public void mouseClicked(MouseEvent paramMouseEvent) { 
     132                // on affiche l'image en grand 
     133                ImagesManagement.setCurrentImage(image); 
     134                try { 
     135                        if (paramMouseEvent.getButton() == 1) { 
     136                                new BrowserFrame(image); 
     137                        } else if (paramMouseEvent.getButton() == 3) { 
     138                                JPopupMenu popup = new JPopupMenu(); 
     139                                menuAjouterTag = new JMenuItem(Messages.getMessage("thumbviewer_addTag")); 
     140                                menuAjouterTag.addActionListener(this); 
     141                                popup.add(menuAjouterTag); 
     142                                popup.show(this, paramMouseEvent.getX(), paramMouseEvent.getY()); 
     143                        } 
     144                } catch (Exception e) { 
     145                        e.printStackTrace(); 
    192146                } 
    193                 listTags.setSelectedIndices(indices); 
    194  
    195                 JScrollPane scrollPane = new JScrollPane(listTags); 
    196                 dialogChoixTags = new JDialog(); 
    197                 dialogChoixTags.setLayout(new BorderLayout()); 
    198                 JPanel panelNorth = new JPanel(new VerticalLayout()); 
    199                 panelNorth.add(new JLabel(Messages.getMessage("thumbviewer_selectTag"))); 
    200                 panelNorth.add(scrollPane); 
    201                 dialogChoixTags.add(panelNorth, BorderLayout.NORTH); 
    202                 JPanel panelBouton = new JPanel(new FlowLayout()); 
    203                 boutonOkAjouterTag = new JButton("Ok"); 
    204                 panelBouton.add(boutonOkAjouterTag); 
    205                 boutonOkAjouterTag.addActionListener(this); 
    206                 dialogChoixTags.add(panelBouton, BorderLayout.CENTER); 
    207                 dialogChoixTags.setSize(new Dimension(400, 280)); 
    208                 dialogChoixTags.setLocationRelativeTo(null); 
    209                 dialogChoixTags.setVisible(true); 
    210             } catch (IOException e) { 
    211                 e.printStackTrace(); 
    212             } 
    213         } else if (arg0.getSource().equals(boutonOkAjouterTag)) { 
    214             StringBuffer tagIds = new StringBuffer(""); 
    215             for (Object object : listTags.getSelectedValues()) { 
    216                 Tag tag = (Tag) object; 
    217                 tagIds.append(tag.getId() + ","); 
    218             } 
    219             tagIds.deleteCharAt(tagIds.lastIndexOf(",")); 
    220             try { 
    221                 if (!ImageService.getInstance().addTags(image, tagIds.toString())) { 
    222                     JOptionPane.showMessageDialog(this, Messages.getMessage("addingTagsError"), Messages 
    223                             .getMessage("error"), JOptionPane.ERROR_MESSAGE); 
    224                 } else { 
    225                     dialogChoixTags.dispose(); 
     147 
     148        } 
     149 
     150 
     151        @Override 
     152        public void mouseEntered(MouseEvent paramMouseEvent) { 
     153                this.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR)); 
     154        } 
     155 
     156 
     157        @Override 
     158        public void mouseExited(MouseEvent paramMouseEvent) { 
     159        } 
     160 
     161 
     162        @Override 
     163        public void mousePressed(MouseEvent paramMouseEvent) { 
     164                // TODO Auto-generated method stub 
     165 
     166        } 
     167 
     168 
     169        @Override 
     170        public void mouseReleased(MouseEvent paramMouseEvent) { 
     171                // TODO Auto-generated method stub 
     172 
     173        } 
     174 
     175 
     176        @Override 
     177        public void actionPerformed(ActionEvent arg0) { 
     178                if (arg0.getSource().equals(menuAjouterTag)) { 
     179                        try { 
     180                                //getting the list of tags 
     181                                List<Tag> tagsDispo = TagService.getInstance().lister(); 
     182                                //list to array (cause fucking JList does not support Lists) 
     183                                Tag[] tableauTagDispo = (Tag[]) tagsDispo.toArray(new Tag[tagsDispo.size()]); 
     184                                //getting the image's tags to preselect them 
     185                                List<Tag> tagsDeLimage = TagService.getInstance().tagsForImage(image); 
     186                                listTags = new JList(tableauTagDispo); 
     187                                //multiple selection is allowed 
     188                                listTags.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION); 
     189                                listTags.setPreferredSize(new Dimension(100, 200)); 
     190                                //construct an array of the indices to select in the jlist 
     191                                int[] indices = new int[tagsDeLimage.size()]; 
     192                                int compteur = 0; 
     193                                for (int i = 0; i < tableauTagDispo.length; i++) { 
     194                                        for (Tag tag : tagsDeLimage) { 
     195                                                if (tag.getId().equals(tableauTagDispo[i].getId())) { 
     196                                                        indices[compteur++] = i; 
     197 
     198                                                } 
     199                                        } 
     200                                } 
     201                                listTags.setSelectedIndices(indices); 
     202 
     203                                JScrollPane scrollPane = new JScrollPane(listTags); 
     204                                dialogChoixTags = new JDialog(); 
     205                                dialogChoixTags.setLayout(new BorderLayout()); 
     206                                JPanel panelNorth = new JPanel(new VerticalLayout()); 
     207                                panelNorth.add(new JLabel(Messages.getMessage("thumbviewer_selectTag"))); 
     208                                panelNorth.add(scrollPane); 
     209                                dialogChoixTags.add(panelNorth, BorderLayout.NORTH); 
     210                                JPanel panelBouton = new JPanel(new FlowLayout()); 
     211                                boutonOkAjouterTag = new JButton("Ok"); 
     212                                panelBouton.add(boutonOkAjouterTag); 
     213                                boutonOkAjouterTag.addActionListener(this); 
     214                                dialogChoixTags.add(panelBouton, BorderLayout.CENTER); 
     215                                dialogChoixTags.setSize(new Dimension(400, 280)); 
     216                                dialogChoixTags.setLocationRelativeTo(null); 
     217                                dialogChoixTags.setVisible(true); 
     218                        } catch (IOException e) { 
     219                                e.printStackTrace(); 
     220                        } 
     221                } else if (arg0.getSource().equals(boutonOkAjouterTag)) { 
     222                        StringBuffer tagIds = new StringBuffer(""); 
     223                        for (Object object : listTags.getSelectedValues()) { 
     224                                Tag tag = (Tag) object; 
     225                                tagIds.append(tag.getId() + ","); 
     226                        } 
     227                        tagIds.deleteCharAt(tagIds.lastIndexOf(",")); 
     228                        try { 
     229                                if (!ImageService.getInstance().addTags(image, tagIds.toString())) { 
     230                                        JOptionPane.showMessageDialog(this, Messages.getMessage("addingTagsError"), Messages.getMessage("error"), 
     231                                                        JOptionPane.ERROR_MESSAGE); 
     232                                } else { 
     233                                        dialogChoixTags.dispose(); 
     234                                } 
     235                        } catch (IOException e) { 
     236                                e.printStackTrace(); 
     237                        } 
     238 
    226239                } 
    227             } catch (IOException e) { 
    228                 e.printStackTrace(); 
    229             } 
    230  
    231         } 
    232     } 
     240        } 
    233241} 
Note: See TracChangeset for help on using the changeset viewer.