Changeset 1108 for trunk/src/org/expeditee/actions

Timestamp:

09/05/18 12:56:49 (6 years ago)

Author:

bln4

Message:

org.expeditee.actions.Misc ->

Added new action MigrateImages.

Three categories of @i's: relative, absolute internal and absolute internal.
Relative is ideal as it makes it easier to move Framesets around. Relative @i's reference images in Expeditee.home's images directory.
Absolute internal can be adjusted to Relative without any problems. The images are stored in Expeditee.home's image directory but are addressed absolutely.
Absolute external are images that are stored somewhere on the computer that is not Expeditee.home's image directory.

This action, when run, will transition absolute external and absolute internal to relative.

File:

• trunk/src/org/expeditee/actions/Misc.java (modified) (3 diffs)

trunk/src/org/expeditee/actions/Misc.java

@@ -28 +28 @@
 import java.net.URL;
 import java.net.URLClassLoader;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 import java.util.Map.Entry;
 import java.util.jar.Attributes;
@@ -57 +61 @@
 import org.expeditee.items.ItemUtils;
 import org.expeditee.items.Line;
+import org.expeditee.items.Picture;
 import org.expeditee.items.Text;
 import org.expeditee.items.XRayable;
@@ -686 +691 @@
         public static void MessageLn2(String message, String message2) {
                 MessageBay.displayMessage(message + " " + message2);
+        }
+        
+        public static void MigrateImages() { MigrateImages(DisplayController.getCurrentFrame()); }
+        
+        public static void MigrateImages(Frame frame) {
+                //Collect the images on frame
+                final Collection<Item> items = frame.getItems();
+                final Collection<Item> imagesTextItems = new LinkedList<Item>();
+                items.forEach(i -> { if(i.getText().startsWith("@i")) imagesTextItems.add(i); });
+                final Map<Item, Collection<Path>> images = new HashMap<Item, Collection<Path>>();
+                imagesTextItems.forEach(it -> { 
+                        final Collection<? extends XRayable> enclosures = it.getEnclosures();
+                        final Collection<Path> paths = new LinkedList<Path>();
+                        enclosures.forEach(enc -> { if(enc instanceof Picture) paths.add(Paths.get(enc.getName())); });
+                        images.put(it, paths);
+                });
+                
+                //Separate into categories: absolute external, absolute internal.  Discard relative.
+                final Map<Item, Collection<Path>> imagesAbsolute = new HashMap<Item, Collection<Path>>();
+                images.keySet().forEach(key -> images.get(key).forEach(path -> {
+                        if(path.isAbsolute())
+                                if(imagesAbsolute.containsKey(key)) imagesAbsolute.get(key).add(path);
+                                else {
+                                        final Collection<Path> paths = new LinkedList<Path>();
+                                        paths.add(path);
+                                        imagesAbsolute.put(key, paths);
+                                }
+                }));
+                final Path imagesPath = Paths.get(FrameIO.IMAGES_PATH);
+                final Map<Item, Collection<Path>> imagesAbsoluteInternal = new HashMap<Item, Collection<Path>>();
+                imagesAbsolute.keySet().forEach(key -> imagesAbsolute.get(key).forEach(path -> { 
+                        if(path.startsWith(imagesPath)) 
+                                if(imagesAbsoluteInternal.containsKey(key)) imagesAbsoluteInternal.get(key).add(path);
+                                else {
+                                        final Collection<Path> paths = new LinkedList<Path>();
+                                        paths.add(path);
+                                        imagesAbsoluteInternal.put(key, paths);
+                                }
+                }));
+                final Map<Item, Collection<Path>> imagesAbsoluteExternal = new HashMap<Item, Collection<Path>>();
+                imagesAbsolute.keySet().forEach(key -> imagesAbsolute.get(key).forEach(path -> { 
+                        if(!path.startsWith(imagesPath))
+                                if(imagesAbsoluteExternal.containsKey(key)) imagesAbsoluteExternal.get(key).add(path);
+                                else {
+                                        final Collection<Path> paths = new LinkedList<Path>();
+                                        paths.add(path);
+                                        imagesAbsoluteExternal.put(key, paths);
+                                }
+                }));
+                
+                //Bryce: I am not sure why each Item is programmed to be able to have a collection of XRayables rather
+                //than a single one.  Up until this point I have programmed defensively to retain this possibility.  At
+                //this point the code will begin to simply use the first XRayable to determine the content of the @i.
+                
+                //Transform absolute internal images into relative.
+                imagesAbsoluteInternal.keySet().forEach(key -> {
+                        final Path imagePath = imagesAbsoluteInternal.get(key).iterator().next();
+                        final Path relative = imagesPath.relativize(imagePath);
+                        key.setText(key.getText().replace(imagePath.toString(), relative.toString()));
+                        MessageBay.displayMessage("Migrated image: " + imagePath + ".  It now uses the relative path: " + relative);
+                });
+                
+                //Transform absolute external images into relative
+                imagesAbsoluteExternal.keySet().forEach(key -> { 
+                        final Path imagePath = imagesAbsoluteExternal.get(key).iterator().next();
+                        try {
+                                FrameIO.copyFile(imagePath.toString(), imagesPath.resolve(imagePath.getFileName()).toString());
+                                final Path relative = imagesPath.relativize(imagePath);
+                                key.setText(key.getText().replace(imagePath.toString(), relative.toString()));
+                                MessageBay.displayMessage("Migrated image: " + imagePath + ".  It now uses the relative path: " + relative);
+                        } catch (IOException e) {
+                                MessageBay.displayMessage("Unable to Migrate file: " + imagePath);
+                        }
+                });
         }