Changeset 8829


Ignore:
Timestamp:
01/21/11 19:18:42 (9 years ago)
Author:
mlg
Message:

Changes ImagesManagement access from static to object.

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

Legend:

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

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

    r6821 r8829  
    4545    private String auteur; 
    4646    private File thumbnail; 
     47    private String privacyLevel; 
     48 
     49    /** 
     50     * @return the privacyLevel 
     51     */ 
     52    public String getPrivacyLevel() { 
     53        return privacyLevel; 
     54    } 
     55 
     56    /** 
     57     * @param privacyLevel the privacyLevel to set 
     58     */ 
     59    public void setPrivacyLevel(String privacyLevel) { 
     60        this.privacyLevel = privacyLevel; 
     61    } 
    4762 
    4863    /** 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/service/ImageService.java

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

    r7223 r8829  
    55import java.util.HashMap; 
    66import java.util.List; 
     7 
    78import javax.imageio.ImageIO; 
     9 
    810import fr.mael.jiwigo.om.Image; 
    911import fr.mael.jiwigo.transverse.util.Outil; 
    10  
    1112 
    1213/** 
     
    4041 */ 
    4142public class ImagesManagement { 
    42  
    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; 
    59  
    60         /** 
    61          * cache allows to keep the images in the ram 
    62          */ 
    63         private static HashMap<Integer, BufferedImage> IMAGES_CACHE = new HashMap<Integer, BufferedImage>(); 
    64  
    65         /** 
    66          * cache allows to keep the thumbnails in the ram 
    67          */ 
    68         private static HashMap<Integer, BufferedImage> MINIATURE_CACHE = new HashMap<Integer, BufferedImage>(); 
    69  
    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; 
    75  
    76         /** 
    77          * the privacy level to apply to the pictures 
    78          */ 
    79         public static int privacyLevel = 1; 
    80  
    81         /** 
    82          * boolean that defines if the application is sending files 
    83          *  
    84          */ 
    85         public static boolean sendingFiles = false; 
    86  
    87  
    88         /** 
    89          * gets the current image 
    90          * @return the image 
    91          */ 
    92         public static Image getCurrentImage() { 
    93                 //return LIST_IMAGE.get(CURRENT_IMAGE_INDEX); 
    94                 return CURRENT_IMAGE; 
    95         } 
    96  
    97  
    98         /** 
    99          * next image 
    100          */ 
    101         public static void next() { 
    102                 if (CURRENT_IMAGE_INDEX != LIST_IMAGE.size() - 1) { 
    103                         CURRENT_IMAGE_INDEX++; 
    104                 } else { 
    105                         CURRENT_IMAGE_INDEX = 0; 
    106                 } 
    107                 CURRENT_IMAGE = LIST_IMAGE.get(CURRENT_IMAGE_INDEX); 
    108         } 
    109  
    110  
    111         /** 
    112          * previous image 
    113          */ 
    114         public static void previous() { 
    115                 if (CURRENT_IMAGE_INDEX != 0) { 
    116                         CURRENT_IMAGE_INDEX--; 
    117                 } else { 
    118                         CURRENT_IMAGE_INDEX = LIST_IMAGE.size() - 1; 
    119                 } 
    120                 CURRENT_IMAGE = LIST_IMAGE.get(CURRENT_IMAGE_INDEX); 
    121         } 
    122  
    123  
    124         /** 
    125          *  
    126          * @param image the current image 
    127          */ 
    128         public static void setCurrentImage(Image image) { 
    129                 CURRENT_IMAGE = image; 
    130                 int compteur = 0; 
    131                 for (Image im : LIST_IMAGE) { 
    132                         if (im.equals(image)) { 
    133                                 CURRENT_IMAGE_INDEX = compteur; 
    134                         } 
    135                         compteur++; 
    136                 } 
    137         } 
    138  
    139  
    140         /** 
    141          * Function that allows to load images once 
    142          * to decrease response delays 
    143          * @return the image 
    144          */ 
    145         public static BufferedImage getCurrentBufferedImage() { 
    146                 if (IMAGES_CACHE.get(CURRENT_IMAGE.getIdentifiant()) == null) { 
    147                         try { 
    148                                 BufferedImage img = ImageIO.read(new URL(CURRENT_IMAGE.getUrl())); 
    149                                 IMAGES_CACHE.put(CURRENT_IMAGE.getIdentifiant(), img); 
    150                         } catch (Exception e) { 
    151                                 LOG.error(Outil.getStackTrace(e)); 
    152                         } 
    153                 } 
    154                 return IMAGES_CACHE.get(CURRENT_IMAGE.getIdentifiant()); 
    155         } 
    156  
    157  
    158         /** 
    159          * Function that allows to load thimbnails once 
    160          * to decrease response delays 
    161          * @return the image 
    162          */ 
    163         public static BufferedImage getMiniatureBufferedImage(Image image) { 
    164                 if (MINIATURE_CACHE.get(image.getIdentifiant()) == null) { 
    165                         try { 
    166                                 BufferedImage img = ImageIO.read(new URL(image.getMiniature())); 
    167                                 MINIATURE_CACHE.put(image.getIdentifiant(), img); 
    168                         } catch (Exception e) { 
    169                                 LOG.error(Outil.getStackTrace(e)); 
    170                         } 
    171                 } 
    172  
    173                 return MINIATURE_CACHE.get(image.getIdentifiant()); 
    174         } 
     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    private int currentImageIndex; 
     52    /** 
     53     * the current image 
     54     */ 
     55    private Image currentImage; 
     56    /** 
     57     * images list 
     58     */ 
     59    private List<Image> listImage; 
     60 
     61    /** 
     62     * cache allows to keep the images in the ram 
     63     */ 
     64    private HashMap<Integer, BufferedImage> imageCache = new HashMap<Integer, BufferedImage>(); 
     65 
     66    /** 
     67     * cache allows to keep the thumbnails in the ram 
     68     */ 
     69    private HashMap<Integer, BufferedImage> thumbnailsCache = new HashMap<Integer, BufferedImage>(); 
     70 
     71    /** 
     72     * If true : the application won't ask the privacy level 
     73     * to the user each time he adds pictures 
     74     */ 
     75    private boolean rememberPrivacyLevel = false; 
     76 
     77    /** 
     78     * if true : the user is currently uploading pictures 
     79     */ 
     80    private boolean isUploading = false; 
     81    /** 
     82     * the privacy level to apply to the pictures 
     83     */ 
     84    private int privacyLevel = 1; 
     85    /** 
     86     * boolean that defines if the application is sending files 
     87     *  
     88     */ 
     89    private boolean sendingFiles = false; 
     90 
     91    /** 
     92     * singleton 
     93     */ 
     94    private static ImagesManagement instance; 
     95 
     96    private ImagesManagement() { 
     97    } 
     98 
     99    public static ImagesManagement getInstance() { 
     100        if (instance == null) { 
     101            instance = new ImagesManagement(); 
     102        } 
     103        return instance; 
     104    } 
     105 
     106    /** 
     107     * gets the current image 
     108     * @return the image 
     109     */ 
     110    public Image getCurrentImage() { 
     111        //return LIST_IMAGE.get(CURRENT_IMAGE_INDEX); 
     112        return currentImage; 
     113    } 
     114 
     115    /** 
     116     * next image 
     117     */ 
     118    public void next() { 
     119        if (currentImageIndex != listImage.size() - 1) { 
     120            currentImageIndex++; 
     121        } else { 
     122            currentImageIndex = 0; 
     123        } 
     124        currentImage = listImage.get(currentImageIndex); 
     125    } 
     126 
     127    /** 
     128     * previous image 
     129     */ 
     130    public void previous() { 
     131        if (currentImageIndex != 0) { 
     132            currentImageIndex--; 
     133        } else { 
     134            currentImageIndex = listImage.size() - 1; 
     135        } 
     136        currentImage = listImage.get(currentImageIndex); 
     137    } 
     138 
     139    /** 
     140     *  
     141     * @param image the current image 
     142     */ 
     143    public void setCurrentImage(Image image) { 
     144        currentImage = image; 
     145        int compteur = 0; 
     146        for (Image im : listImage) { 
     147            if (im.equals(image)) { 
     148                currentImageIndex = compteur; 
     149            } 
     150            compteur++; 
     151        } 
     152    } 
     153 
     154    /** 
     155     * Function that allows to load images once 
     156     * to decrease response delays 
     157     * @return the image 
     158     */ 
     159    public BufferedImage getCurrentBufferedImage() { 
     160        if (imageCache.get(currentImage.getIdentifiant()) == null) { 
     161            try { 
     162                BufferedImage img = ImageIO.read(new URL(currentImage.getUrl())); 
     163                imageCache.put(currentImage.getIdentifiant(), img); 
     164            } catch (Exception e) { 
     165                LOG.error(Outil.getStackTrace(e)); 
     166            } 
     167        } 
     168        return imageCache.get(currentImage.getIdentifiant()); 
     169    } 
     170 
     171    /** 
     172     * Function that allows to load thimbnails once 
     173     * to decrease response delays 
     174     * @return the image 
     175     */ 
     176    public BufferedImage getMiniatureBufferedImage(Image image) { 
     177        if (thumbnailsCache.get(image.getIdentifiant()) == null) { 
     178            try { 
     179                BufferedImage img = ImageIO.read(new URL(image.getMiniature())); 
     180                thumbnailsCache.put(image.getIdentifiant(), img); 
     181            } catch (Exception e) { 
     182                LOG.error(Outil.getStackTrace(e)); 
     183            } 
     184        } 
     185 
     186        return thumbnailsCache.get(image.getIdentifiant()); 
     187    } 
     188 
     189    /** 
     190     * @return the listImage 
     191     */ 
     192    public List<Image> getListImage() { 
     193        return listImage; 
     194    } 
     195 
     196    /** 
     197     * @param listImage the listImage to set 
     198     */ 
     199    public void setListImage(List<Image> listImage) { 
     200        this.listImage = listImage; 
     201    } 
     202 
     203    /** 
     204     * @return the rememberPrivacyLevel 
     205     */ 
     206    public boolean isRememberPrivacyLevel() { 
     207        return rememberPrivacyLevel; 
     208    } 
     209 
     210    /** 
     211     * @param rememberPrivacyLevel the rememberPrivacyLevel to set 
     212     */ 
     213    public void setRememberPrivacyLevel(boolean rememberPrivacyLevel) { 
     214        this.rememberPrivacyLevel = rememberPrivacyLevel; 
     215    } 
     216 
     217    /** 
     218     * @return the sendingFiles 
     219     */ 
     220    public boolean isSendingFiles() { 
     221        return sendingFiles; 
     222    } 
     223 
     224    /** 
     225     * @param sendingFiles the sendingFiles to set 
     226     */ 
     227    public void setSendingFiles(boolean sendingFiles) { 
     228        this.sendingFiles = sendingFiles; 
     229    } 
     230 
     231    /** 
     232     * @return the privacyLevel 
     233     */ 
     234    public int getPrivacyLevel() { 
     235        return privacyLevel; 
     236    } 
     237 
     238    /** 
     239     * @param privacyLevel the privacyLevel to set 
     240     */ 
     241    public void setPrivacyLevel(int privacyLevel) { 
     242        this.privacyLevel = privacyLevel; 
     243    } 
     244 
    175245} 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/mainframe/CategoriesTree.java

    r7221 r8829  
    88import java.awt.event.MouseListener; 
    99import java.util.List; 
     10 
    1011import javax.swing.JMenuItem; 
    1112import javax.swing.JOptionPane; 
     
    2021import javax.swing.tree.TreePath; 
    2122import javax.swing.tree.TreeSelectionModel; 
     23 
    2224import fr.mael.jiwigo.om.Category; 
    2325import fr.mael.jiwigo.service.CategoryService; 
    2426import fr.mael.jiwigo.transverse.util.Messages; 
    2527import fr.mael.jiwigo.transverse.util.Outil; 
    26  
    2728 
    2829/** 
     
    5758public class CategoriesTree extends JPanel implements TreeSelectionListener, MouseListener, ActionListener { 
    5859 
    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); 
     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        if (!MainFrame.getInstance().isBrowserVisible()) { 
     128            MainFrame.getInstance().setBrowserVisible(); 
     129        } 
     130        MainFrame.getInstance().addTabb(new ThumbnailCategoryPanel(category)); 
     131    } 
     132 
     133    /** 
     134     * creation of the nodes 
     135     * @param root the root  
     136     */ 
     137    private void createNodes(DefaultMutableTreeNode root) { 
     138        DefaultMutableTreeNode category = null; 
     139        try { 
     140            List<Category> list = CategoryService.getInstance().construireArbre(); 
     141            for (Category cat : list) { 
     142                if (cat.getCategoriesMeres().size() == 0) { 
     143                    category = new DefaultMutableTreeNode(cat); 
     144                    root.add(category); 
     145                    recursiveNodeCreation(category, cat); 
    152146                } 
    153147 
    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); 
     148            } 
     149        } catch (Exception e) { 
     150            LOG.error(Outil.getStackTrace(e)); 
     151            JOptionPane.showMessageDialog(null, Messages.getMessage("treeCreationError"), Messages.getMessage("error"), 
     152                    JOptionPane.ERROR_MESSAGE); 
     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    @Override 
     171    public void mouseClicked(MouseEvent arg0) { 
     172 
     173    } 
     174 
     175    @Override 
     176    public void mouseEntered(MouseEvent arg0) { 
     177        // TODO Auto-generated method stub 
     178 
     179    } 
     180 
     181    @Override 
     182    public void mouseExited(MouseEvent arg0) { 
     183        // TODO Auto-generated method stub 
     184 
     185    } 
     186 
     187    @Override 
     188    public void mousePressed(MouseEvent e) { 
     189        int selRow = tree.getRowForLocation(e.getX(), e.getY()); 
     190        TreePath selPath = tree.getPathForLocation(e.getX(), e.getY()); 
     191        //begin bug:0001832 
     192        tree.setSelectionRow(selRow); 
     193        //end 
     194 
     195        if (e.getButton() == 3) { 
     196            JPopupMenu popup = new JPopupMenu(); 
     197            menuAjouter = new JMenuItem(Messages.getMessage("categories_add")); 
     198            menuAjouter.addActionListener(this); 
     199            popup.add(menuAjouter); 
     200            menuActualiser = new JMenuItem(Messages.getMessage("categories_update")); 
     201            menuActualiser.addActionListener(this); 
     202            popup.add(menuActualiser); 
     203            popup.show(tree, e.getX(), e.getY()); 
     204            if (selRow != -1) { 
     205                DefaultMutableTreeNode node = (DefaultMutableTreeNode) (selPath.getLastPathComponent()); 
     206                this.selectedCategory = (Category) node.getUserObject(); 
     207            } else { 
     208                this.selectedCategory = null; 
     209            } 
     210        } 
     211 
     212    } 
     213 
     214    @Override 
     215    public void mouseReleased(MouseEvent arg0) { 
     216        // TODO Auto-generated method stub 
     217 
     218    } 
     219 
     220    @Override 
     221    public void actionPerformed(ActionEvent arg0) { 
     222        if (arg0.getSource().equals(menuAjouter)) { 
     223            String nomcategorie = JOptionPane.showInputDialog(null, Messages.getMessage("categories_enterName"), 
     224                    Messages.getMessage("categories_add"), JOptionPane.INFORMATION_MESSAGE); 
     225            //if the name of the category is not empty 
     226            if (!(nomcategorie == null) && !nomcategorie.equals("")) { 
     227                //if there is a parent category 
     228                if (selectedCategory != null) { 
     229                    //try to create a category 
     230                    if (CategoryService.getInstance().creer(nomcategorie, selectedCategory.getIdentifiant())) { 
     231                        setUpUi(); 
     232                    } else { 
     233                        JOptionPane.showMessageDialog(null, Messages.getMessage("categoryCreationError"), Messages 
     234                                .getMessage("error"), JOptionPane.ERROR_MESSAGE); 
     235 
     236                    } 
     237                } else { 
     238                    if (CategoryService.getInstance().creer(nomcategorie)) { 
     239                        setUpUi(); 
     240                    } else { 
     241                        JOptionPane.showMessageDialog(null, Messages.getMessage("categoryCreationError"), Messages 
     242                                .getMessage("error"), JOptionPane.ERROR_MESSAGE); 
     243 
     244                    } 
    167245                } 
    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)) { 
    254                         setUpUi(); 
    255                 } 
    256         } 
     246            } 
     247        } else if (arg0.getSource().equals(menuActualiser)) { 
     248            setUpUi(); 
     249        } 
     250    } 
    257251} 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/mainframe/DialogPrivacyLevel.java

    r7070 r8829  
    101101    public void actionPerformed(ActionEvent arg0) { 
    102102        if (arg0.getSource().equals(buttonOk)) { 
    103             ImagesManagement.privacyLevel = comboPrivacyLevel.getSelectedIndex() + 1; 
     103            ImagesManagement.getInstance().setPrivacyLevel(comboPrivacyLevel.getSelectedIndex() + 1); 
    104104            if (checkBoxRemember.isSelected()) { 
    105                 ImagesManagement.rememberPrivacyLevel = true; 
     105                ImagesManagement.getInstance().setRememberPrivacyLevel(true); 
    106106            } 
    107107            this.dispose(); 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/mainframe/IThumbnailPanel.java

    r6972 r8829  
    33import fr.mael.jiwigo.om.Category; 
    44 
     5/** 
     6    Copyright (c) 2010, Mael 
     7   All rights reserved. 
     8 
     9   Redistribution and use in source and binary forms, with or without 
     10   modification, are permitted provided that the following conditions are met: 
     11    * Redistributions of source code must retain the above copyright 
     12      notice, this list of conditions and the following disclaimer. 
     13    * Redistributions in binary form must reproduce the above copyright 
     14      notice, this list of conditions and the following disclaimer in the 
     15      documentation and/or other materials provided with the distribution. 
     16    * Neither the name of jiwigo nor the 
     17      names of its contributors may be used to endorse or promote products 
     18      derived from this software without specific prior written permission. 
     19 
     20   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
     21   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
     22   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
     23   DISCLAIMED. IN NO EVENT SHALL Mael BE LIABLE FOR ANY 
     24   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
     25   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
     26   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 
     27   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
     28   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
     29   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
     30 * @author mael 
     31 * Interface for thumbnail panels 
     32 */ 
    533public interface IThumbnailPanel { 
    634    /** 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/mainframe/MainFrame.java

    r7222 r8829  
    99import java.awt.event.KeyListener; 
    1010import java.util.HashMap; 
     11 
    1112import javax.swing.ImageIcon; 
    1213import javax.swing.JComponent; 
     
    2021import javax.swing.JScrollPane; 
    2122import javax.swing.JSplitPane; 
     23 
    2224import fr.mael.jiwigo.transverse.util.Messages; 
    2325import fr.mael.jiwigo.transverse.util.Outil; 
     26import fr.mael.jiwigo.ui.MyCollapsiblePanel; 
     27import fr.mael.jiwigo.ui.browser.BrowserPanel; 
    2428import fr.mael.jiwigo.ui.field.HintTextField; 
    2529import fr.mael.jiwigo.ui.mainframe.tab.JTabbedPaneWithCloseIcons; 
    26  
     30import fr.mael.jiwigo.ui.search.ImageSearchPanel; 
    2731 
    2832/** 
     
    5761public class MainFrame extends JFrame implements ActionListener, KeyListener { 
    5862 
    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          * label that displays additional messages 
    87          */ 
    88         private JLabel labelAdditionalMessage; 
    89  
    90         /** 
    91          * menu bar 
    92          */ 
    93         private JMenuBar jMenuBar; 
    94  
    95         /** 
    96          * edition menu 
    97          */ 
    98         private JMenu jMenuEdition; 
    99  
    100         /** 
    101          * preferences menu 
    102          */ 
    103         private JMenuItem jMenuItemPreferences; 
    104  
    105         /** 
    106          * singleton 
    107          */ 
    108         private static MainFrame instance; 
    109  
    110         private JProgressBar progressBar; 
    111  
    112         private JTabbedPaneWithCloseIcons tabbedPane; 
    113  
    114         private HashMap<Integer, Integer> mapsIdPos = new HashMap<Integer, Integer>(); 
    115  
    116         private HintTextField fieldSearch; 
    117  
    118  
    119         /** 
    120          * @return the singleton 
    121          */ 
    122         public static MainFrame getInstance() { 
    123                 if (instance == null) { 
    124                         instance = new MainFrame(); 
     63    /** 
     64     * Logger 
     65     */ 
     66    public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory 
     67            .getLog(MainFrame.class); 
     68    /** 
     69     * the categories tree 
     70     */ 
     71    private CategoriesTree categoriesTree; 
     72    /** 
     73     * Splitpane. On the left : the categories tree and on the right the thumbnails 
     74     * for the current category 
     75     */ 
     76    private JSplitPane splitPane; 
     77    /** 
     78     * Panel that contains the thumbnail of the current category 
     79     */ 
     80    public static ThumbnailCategoryPanel imagesPanel; 
     81    /** 
     82     *  Scrollpane that contains the panel above 
     83     */ 
     84    private JScrollPane scrollPaneImagesPanel; 
     85    /** 
     86     * label that displays messages 
     87     */ 
     88    private JLabel labelMessage; 
     89 
     90    /** 
     91     * label that displays additional messages 
     92     */ 
     93    private JLabel labelAdditionalMessage; 
     94 
     95    /** 
     96     * menu bar 
     97     */ 
     98    private JMenuBar jMenuBar; 
     99 
     100    /** 
     101     * edition menu 
     102     */ 
     103    private JMenu jMenuEdition; 
     104 
     105    /** 
     106     * preferences menu 
     107     */ 
     108    private JMenuItem jMenuItemPreferences; 
     109    /** 
     110     * menu to search images 
     111     */ 
     112    private JMenuItem jMenuItemSearch; 
     113 
     114    /** 
     115     * singleton 
     116     */ 
     117    private static MainFrame instance; 
     118 
     119    private JProgressBar progressBar; 
     120 
     121    private JTabbedPaneWithCloseIcons tabbedPane; 
     122 
     123    private HashMap<Integer, Integer> mapsIdPos = new HashMap<Integer, Integer>(); 
     124 
     125    private HintTextField fieldSearch; 
     126 
     127    private BrowserPanel browserPanel; 
     128 
     129    private MyCollapsiblePanel collapsiblePanel; 
     130 
     131    private ImageSearchPanel imageSearchPanel; 
     132 
     133    private boolean imageSearchPanelVisible = false; 
     134 
     135    private boolean browserVisible = false; 
     136 
     137    /** 
     138     * @return the singleton 
     139     */ 
     140    public static MainFrame getInstance() { 
     141        if (instance == null) { 
     142            instance = new MainFrame(); 
     143        } 
     144        return instance; 
     145    } 
     146 
     147    /** 
     148     * private constructor to use a singleton 
     149     */ 
     150    private MainFrame() { 
     151        this.setTitle("Jiwigo v" + Messages.getMessage("version")); 
     152        this.setIconImage(java.awt.Toolkit.getDefaultToolkit().getImage(Outil.getURL("fr/mael/jiwigo/img/icon.png"))); 
     153        this.setLayout(new BorderLayout()); 
     154        jMenuBar = new JMenuBar(); 
     155        labelMessage = new JLabel(Messages.getMessage("welcomeMessage")); 
     156        labelAdditionalMessage = new JLabel(); 
     157        splitPane = new JSplitPane(); 
     158        categoriesTree = new CategoriesTree(); 
     159        splitPane.setLeftComponent(categoriesTree); 
     160 
     161        imageSearchPanel = new ImageSearchPanel(); 
     162 
     163        tabbedPane = new JTabbedPaneWithCloseIcons(); 
     164        collapsiblePanel = new MyCollapsiblePanel(tabbedPane); 
     165        splitPane.setRightComponent(collapsiblePanel); 
     166 
     167        this.add(splitPane, BorderLayout.CENTER); 
     168        JPanel panelBas = new JPanel(new BorderLayout()); 
     169        JPanel panel = new JPanel(new FlowLayout(FlowLayout.LEFT)); 
     170        progressBar = new JProgressBar(0, 100); 
     171        panel.add(progressBar); 
     172        panel.add(labelAdditionalMessage); 
     173        panel.add(labelMessage); 
     174        panelBas.add(panel, BorderLayout.WEST); 
     175 
     176        fieldSearch = new HintTextField(Messages.getMessage("mainFrame_recherche")); 
     177        fieldSearch.setPreferredSize(new Dimension(150, 25)); 
     178        fieldSearch.addKeyListener(this); 
     179        panelBas.add(fieldSearch, BorderLayout.EAST); 
     180 
     181        jMenuEdition = new JMenu(Messages.getMessage("mainFrame_editionMenu")); 
     182        jMenuBar.add(jMenuEdition); 
     183        jMenuItemPreferences = new JMenuItem(Messages.getMessage("mainFrame_preferencesMenu")); 
     184        jMenuItemPreferences.addActionListener(this); 
     185        jMenuEdition.add(jMenuItemPreferences); 
     186        jMenuItemSearch = new JMenuItem("Search"); 
     187        jMenuItemSearch.addActionListener(this); 
     188        jMenuEdition.add(jMenuItemSearch); 
     189 
     190        this.setJMenuBar(jMenuBar); 
     191        this.add(panelBas, BorderLayout.SOUTH); 
     192        this.setSize(900, 600); 
     193        this.setLocationRelativeTo(null); 
     194        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
     195        this.setResizable(true); 
     196    } 
     197 
     198    public void setBrowserVisible() { 
     199        splitPane.setRightComponent(collapsiblePanel); 
     200        splitPane.revalidate(); 
     201        splitPane.repaint(); 
     202        imageSearchPanelVisible = false; 
     203        browserVisible = true; 
     204    } 
     205 
     206    public void setImageSearchPanelVisible() { 
     207        splitPane.setRightComponent(imageSearchPanel); 
     208        splitPane.revalidate(); 
     209        splitPane.repaint(); 
     210        imageSearchPanelVisible = true; 
     211        browserVisible = false; 
     212    } 
     213 
     214    public void addTabb(IThumbnailPanel panel) { 
     215        JScrollPane scrollPaneImagesPanel = new JScrollPane((JPanel) panel, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, 
     216                JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED); 
     217        scrollPaneImagesPanel.setPreferredSize(new Dimension(900, 600)); 
     218        boolean found = false; 
     219        boolean isSearch = false; 
     220        if (panel instanceof ThumbnailSearchPanel) { 
     221            isSearch = true; 
     222        } 
     223 
     224        for (int i = 0; i < tabbedPane.getTabCount(); i++) { 
     225            JScrollPane scroll = (JScrollPane) tabbedPane.getComponentAt(i); 
     226            IThumbnailPanel thumbPan = (IThumbnailPanel) scroll.getViewport().getComponents()[0]; 
     227            if (thumbPan.getCategory().getIdentifiant().equals(panel.getCategory().getIdentifiant())) { 
     228                //only if it's not for a re 
     229                if (!(panel instanceof ThumbnailSearchPanel)) { 
     230                    tabbedPane.setSelectedIndex(i); 
     231                    found = true; 
     232                    break; 
    125233                } 
    126                 return instance; 
    127         } 
    128  
    129  
    130         /** 
    131          * private constructor to use a singleton 
    132          */ 
    133         private MainFrame() { 
    134                 this.setTitle("Jiwigo v" + Messages.getMessage("version")); 
    135                 this.setIconImage(java.awt.Toolkit.getDefaultToolkit().getImage(Outil.getURL("fr/mael/jiwigo/img/icon.png"))); 
    136                 this.setLayout(new BorderLayout()); 
    137                 jMenuBar = new JMenuBar(); 
    138                 labelMessage = new JLabel(Messages.getMessage("welcomeMessage")); 
    139                 labelAdditionalMessage = new JLabel(); 
    140                 splitPane = new JSplitPane(); 
    141                 categoriesTree = new CategoriesTree(); 
    142                 splitPane.setLeftComponent(categoriesTree); 
    143  
    144                 tabbedPane = new JTabbedPaneWithCloseIcons(); 
    145                 splitPane.setRightComponent(tabbedPane); 
    146  
    147                 this.add(splitPane, BorderLayout.CENTER); 
    148                 JPanel panelBas = new JPanel(new BorderLayout()); 
    149                 JPanel panel = new JPanel(new FlowLayout(FlowLayout.LEFT)); 
    150                 progressBar = new JProgressBar(0, 100); 
    151                 panel.add(progressBar); 
    152                 panel.add(labelAdditionalMessage); 
    153                 panel.add(labelMessage); 
    154                 panelBas.add(panel, BorderLayout.WEST); 
    155  
    156                 fieldSearch = new HintTextField(Messages.getMessage("mainFrame_recherche")); 
    157                 fieldSearch.setPreferredSize(new Dimension(150, 25)); 
    158                 fieldSearch.addKeyListener(this); 
    159                 panelBas.add(fieldSearch, BorderLayout.EAST); 
    160  
    161                 jMenuEdition = new JMenu(Messages.getMessage("mainFrame_editionMenu")); 
    162                 jMenuBar.add(jMenuEdition); 
    163                 jMenuItemPreferences = new JMenuItem(Messages.getMessage("mainFrame_preferencesMenu")); 
    164                 jMenuItemPreferences.addActionListener(this); 
    165                 jMenuEdition.add(jMenuItemPreferences); 
    166  
    167                 this.setJMenuBar(jMenuBar); 
    168                 this.add(panelBas, BorderLayout.SOUTH); 
    169                 this.setSize(900, 600); 
    170                 this.setLocationRelativeTo(null); 
    171                 this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
    172                 this.setResizable(true); 
    173         } 
    174  
    175  
    176         public void addTabb(IThumbnailPanel panel) { 
    177                 JScrollPane scrollPaneImagesPanel = new JScrollPane((JPanel) panel, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED); 
    178                 scrollPaneImagesPanel.setPreferredSize(new Dimension(900, 600)); 
    179                 boolean found = false; 
    180                 boolean isSearch = false; 
    181                 if (panel instanceof ThumbnailSearchPanel) { 
    182                         isSearch = true; 
    183                 } 
    184  
    185                 for (int i = 0; i < tabbedPane.getTabCount(); i++) { 
    186                         JScrollPane scroll = (JScrollPane) tabbedPane.getComponentAt(i); 
    187                         IThumbnailPanel thumbPan = (IThumbnailPanel) scroll.getViewport().getComponents()[0]; 
    188                         if (thumbPan.getCategory().getIdentifiant().equals(panel.getCategory().getIdentifiant())) { 
    189                                 //only if it's not for a re 
    190                                 if (!(panel instanceof ThumbnailSearchPanel)) { 
    191                                         tabbedPane.setSelectedIndex(i); 
    192                                         found = true; 
    193                                         break; 
    194                                 } 
    195                         } 
    196                 } 
    197                 //if it's not for a research, the title of the tab 
    198                 //is the name of the category 
    199                 if (!found && !isSearch) { 
    200                         tabbedPane.addTab(panel.getCategory().getNom(), scrollPaneImagesPanel, 
    201                                         new ImageIcon(Outil.getURL("fr/mael/jiwigo/img/closetab.png"))); 
    202                         //if it's for a research, the title of the tab 
    203                         //if the query string 
    204                 } else if (!found && isSearch) { 
    205                         String queryString = ((ThumbnailSearchPanel) panel).getQueryString(); 
    206                         tabbedPane.addTab(Messages.getMessage("mainFrame_search") + queryString, scrollPaneImagesPanel, 
    207                                         new ImageIcon(Outil.getURL("fr/mael/jiwigo/img/closetab.png"))); 
    208                 } 
    209  
    210         } 
    211  
    212  
    213         /** 
    214          * displays the frame 
    215          */ 
    216         public void showUi() { 
    217                 this.setVisible(true); 
    218         } 
    219  
    220  
    221         /** 
    222          * Affichage d'un message de réussite 
    223          * @param message 
    224          */ 
    225         public void setMessage(String message) { 
    226                 this.labelMessage.setText(message); 
    227         } 
    228  
    229  
    230         public void setAdditionalMessage(String additionalMessage) { 
    231                 this.labelAdditionalMessage.setText(additionalMessage); 
    232         } 
    233  
    234  
    235         @Override 
    236         public void actionPerformed(ActionEvent arg0) { 
    237                 if (arg0.getSource().equals(jMenuItemPreferences)) { 
    238                         new PreferencesDialog(this); 
    239                 } 
    240  
    241         } 
    242  
    243  
    244         public static void reduceSizeOfComponent(JComponent comp) { 
    245                 comp.setMaximumSize(comp.getPreferredSize()); 
    246         } 
    247  
    248  
    249         /** 
    250          * @return the progressBar 
    251          */ 
    252         public JProgressBar getProgressBar() { 
    253                 return progressBar; 
    254         } 
    255  
    256  
    257         /** 
    258          * @return the mapsIdPos 
    259          */ 
    260         public HashMap<Integer, Integer> getMapsIdPos() { 
    261                 return mapsIdPos; 
    262         } 
    263  
    264  
    265         @Override 
    266         public void keyPressed(KeyEvent paramKeyEvent) { 
    267                 if (paramKeyEvent.getKeyCode() == KeyEvent.VK_ENTER) { 
    268                         String queryString = fieldSearch.getText(); 
    269                         ThumbnailSearchPanel searchPanel = new ThumbnailSearchPanel(queryString); 
    270                         addTabb(searchPanel); 
    271                 } 
    272         } 
    273  
    274  
    275         @Override 
    276         public void keyReleased(KeyEvent paramKeyEvent) { 
    277         } 
    278  
    279  
    280         @Override 
    281         public void keyTyped(KeyEvent paramKeyEvent) { 
    282         } 
     234            } 
     235        } 
     236        //if it's not for a research, the title of the tab 
     237        //is the name of the category 
     238        if (!found && !isSearch) { 
     239            tabbedPane.addTab(panel.getCategory().getNom(), scrollPaneImagesPanel, new ImageIcon(Outil 
     240                    .getURL("fr/mael/jiwigo/img/closetab.png"))); 
     241            //if it's for a research, the title of the tab 
     242            //if the query string 
     243        } else if (!found && isSearch) { 
     244            String queryString = ((ThumbnailSearchPanel) panel).getQueryString(); 
     245            tabbedPane.addTab(Messages.getMessage("mainFrame_search") + queryString, scrollPaneImagesPanel, 
     246                    new ImageIcon(Outil.getURL("fr/mael/jiwigo/img/closetab.png"))); 
     247        } 
     248 
     249    } 
     250 
     251    public void revalidate() { 
     252 
     253    } 
     254 
     255    /** 
     256     * displays the frame 
     257     */ 
     258    public void showUi() { 
     259        this.setVisible(true); 
     260    } 
     261 
     262    /** 
     263     * Affichage d'un message de réussite 
     264     * @param message 
     265     */ 
     266    public void setMessage(String message) { 
     267        this.labelMessage.setText(message); 
     268    } 
     269 
     270    public void setAdditionalMessage(String additionalMessage) { 
     271        this.labelAdditionalMessage.setText(additionalMessage); 
     272    } 
     273 
     274    @Override 
     275    public void actionPerformed(ActionEvent arg0) { 
     276        if (arg0.getSource().equals(jMenuItemPreferences)) { 
     277            new PreferencesDialog(this); 
     278        } else if (arg0.getSource().equals(jMenuItemSearch)) { 
     279            setImageSearchPanelVisible(); 
     280        } 
     281 
     282    } 
     283 
     284    public static void reduceSizeOfComponent(JComponent comp) { 
     285        comp.setMaximumSize(comp.getPreferredSize()); 
     286    } 
     287 
     288    /** 
     289     * @return the progressBar 
     290     */ 
     291    public JProgressBar getProgressBar() { 
     292        return progressBar; 
     293    } 
     294 
     295    /** 
     296     * @return the mapsIdPos 
     297     */ 
     298    public HashMap<Integer, Integer> getMapsIdPos() { 
     299        return mapsIdPos; 
     300    } 
     301 
     302    @Override 
     303    public void keyPressed(KeyEvent paramKeyEvent) { 
     304        if (paramKeyEvent.getKeyCode() == KeyEvent.VK_ENTER) { 
     305            String queryString = fieldSearch.getText(); 
     306            ThumbnailSearchPanel searchPanel = new ThumbnailSearchPanel(queryString); 
     307            addTabb(searchPanel); 
     308        } 
     309    } 
     310 
     311    @Override 
     312    public void keyReleased(KeyEvent paramKeyEvent) { 
     313    } 
     314 
     315    @Override 
     316    public void keyTyped(KeyEvent paramKeyEvent) { 
     317    } 
     318 
     319    /** 
     320     * @return the collapsiblePanel 
     321     */ 
     322    public MyCollapsiblePanel getCollapsiblePanel() { 
     323        return collapsiblePanel; 
     324    } 
     325 
     326    /** 
     327     * @return the imageSearchPanelVisible 
     328     */ 
     329    public boolean isImageSearchPanelVisible() { 
     330        return imageSearchPanelVisible; 
     331    } 
     332 
     333    /** 
     334     * @return the browserVisible 
     335     */ 
     336    public boolean isBrowserVisible() { 
     337        return browserVisible; 
     338    } 
    283339 
    284340} 
  • extensions/jiwigo/trunk/src/main/java/fr/mael/jiwigo/ui/mainframe/ThumbnailCategoryPanel.java

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

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

    r7070 r8829  
    8989        try { 
    9090            MainFrame.getInstance().setMessage(Messages.getMessage("thumbviewer_loading")); 
    91             ImagesManagement.LIST_IMAGE = ImageService.getInstance().search(queryString); 
    92             for (Image image : ImagesManagement.LIST_IMAGE) { 
     91            ImagesManagement.getInstance().setListImage(ImageService.getInstance().search(queryString)); 
     92            for (Image image : ImagesManagement.getInstance().getListImage()) { 
    9393                try { 
    9494 
Note: See TracChangeset for help on using the changeset viewer.