Changeset 1413 for trunk


Ignore:
Timestamp:
06/25/19 13:57:37 (5 years ago)
Author:
bln4
Message:

Changed surrogates to work the way discussed with David. EncryptedExpReader/Writer updated to work with this.

Location:
trunk/src/org/expeditee
Files:
1 deleted
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/org/expeditee/encryption/io/EncryptedExpReader.java

    r1409 r1413  
    2626import org.expeditee.encryption.items.surrogates.EncryptionDetail;
    2727import org.expeditee.encryption.items.surrogates.Label;
    28 import org.expeditee.encryption.items.surrogates.Surrogate;
    2928import org.expeditee.encryption.items.surrogates.Label.LabelResult;
    3029import org.expeditee.gui.Frame;
    … …  
    3736
    3837public class EncryptedExpReader extends ExpReader implements CryptographyConstants {
     38       
    3939        private static final String ENCRYPTED_EXP_FLAG = "EncryptedExp";
    4040        private static final String labelProfile = "Profile";
    … …  
    4343        private boolean accessDenied = false;
    4444
    45         public EncryptedExpReader(String frameName) {
    46                 super(frameName);
    47         }
    48 
    4945        public static boolean isEncryptedExpediteeFile(final String path) throws IOException {
    5046                final BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(path), "UTF-8"));
    … …  
    5248                in.close();
    5349                return firstLine.startsWith(ENCRYPTED_EXP_FLAG);
     50        }
     51       
     52        public EncryptedExpReader(String frameName) {
     53                super(frameName);
    5454        }
    5555       
    … …  
    132132                                continue;
    133133                        }
     134                       
    134135                        String tag = getTagEnc(next);
    135                         if (tag.equals("S")) {
     136                        if (next.startsWith("S ")) {
    136137                                currentItem = newItem(next);
    137138                                _linePoints.put(currentItem.getID(), currentItem);
    138139                                newFrame.addItem(currentItem);
    139140                                currentItem.setEncryptionDetailForTag(tag + "", EncryptionDetail.UnencryptedOnSave);
     141                        } else if (next.startsWith("SurrogateFor")) {
     142                                int parentID = Integer.parseInt(next.split(" ")[1]);
     143                                newFrame.getItemWithID(parentID).addToSurrogates(currentItem);
    140144                        } else if (currentItem != null && actionShouldBeDelayed(tag.charAt(0))) {
    141145                                delayedActions.add(new DelayedAction(currentItem, next));
    … …  
    147151                }
    148152               
    149                 if (next.equals("Z...")) {
    150                         next = readTheSurrogateItems(newFrame, delayedActions);
     153                if (next.equals(EncryptedExpWriter.SURROGATE_TERMINATOR)) {
     154                        next = readTheItems(newFrame, delayedActions);
    151155                }
    152156               
    … …  
    159163                String tag = getTagEnc(line);
    160164                String value = getValue(line);
     165               
     166                if (item.isSurrogate() && item.isTagInherited(tag)) {
     167                        return;
     168                }
    161169               
    162170                // Attempt to decrypt the line if necessary.
    … …  
    192200                }
    193201        }
    194                
    195         private String readTheSurrogateItems(Frame newFrame, List<DelayedAction> delayedActions) throws IOException {
    196                 String next = null;
    197                 Item currentItem = null;
    198                
    199                 Predicate<String> endOfSection = s -> s.equals("Z") || s.equals("Z...");
    200                 while (_reader.ready() && !endOfSection.test(next = _reader.readLine())) {
    201                         if (!isValidLine(next)) {
    202                                 continue;
    203                         }
    204                        
    205                         String tag = getTagEnc(next);
    206                         if (tag.equals("S") && !next.startsWith("SurrogateFor")) {
    207                                 currentItem = newItem(next);
    208                                 currentItem.setEncryptionDetailForTag(tag + "", EncryptionDetail.UnencryptedOnSave);
    209                         } else if (next.startsWith("SurrogateFor")) {
    210                                 String id = next.split(" ")[1];
    211                                 Item classic = newFrame.getItemWithID(Integer.parseInt(id));
    212                                 if (id == null) {
    213                                         System.err.println("WARNING: Attempted to create surrogate for classic ID " +
    214                                                         id + " but was no item on frame " + newFrame.getName() + " exists.");
    215                                         continue;
    216                                 }
    217                                 currentItem.setAsSurrogateFor(classic);
    218                                 classic.addToSurrogates(new Surrogate(currentItem));
    219                         } else if (currentItem != null && actionShouldBeDelayed(getTag(next))) {
    220                                 delayedActions.add(new DelayedAction(currentItem, next));
    221                         } else if (currentItem != null) {
    222                                 processBodyLine(currentItem, next);
    223                         } else {
    224                                 System.err.println("Error while reading in frame (ExpReader): Found body line but no current item to apply it to.");
    225                         }
    226                 }
    227 
    228                 return next;
    229         }
    230        
    231         protected static String getTagEnc(String line) {
    232                 char charAtZero = line.charAt(0);
    233                 if (charAtZero == '_') {
    234                         return line.split(" ")[0];
    235                 } else {
    236                         return charAtZero + "";
    237                 }
    238         }
    239202       
    240203        protected static String getValue(String line) {
    … …  
    247210        }
    248211       
    249         protected static boolean isEncryptedLine(String line) {
     212        private static String getTagEnc(String line) {
     213                char charAtZero = line.charAt(0);
     214                if (charAtZero == '_') {
     215                        return line.split(" ")[0];
     216                } else {
     217                        return charAtZero + "";
     218                }
     219        }
     220               
     221        private static boolean isEncryptedLine(String line) {
    250222                if (line.startsWith("S") || line.startsWith("_el")) {
    251223                        return false;
    … …  
    278250                }
    279251        }
    280        
     252
    281253        private class EncryptedLineReader extends BufferedReader {
    282254                private boolean noneMode = false;

  • trunk/src/org/expeditee/encryption/io/EncryptedExpWriter.java

    r1410 r1413  
    66import java.security.InvalidKeyException;
    77import java.security.NoSuchAlgorithmException;
    8 import java.util.ArrayList;
    98import java.util.Arrays;
    109import java.util.Base64;
    1110import java.util.LinkedHashMap;
    1211import java.util.List;
    13 import java.util.Set;
    14 import java.util.function.Consumer;
     12import java.util.function.BinaryOperator;
     13import java.util.function.Function;
     14import java.util.stream.Collectors;
    1515
    1616import javax.crypto.BadPaddingException;
    … …  
    2424import org.expeditee.encryption.items.surrogates.EncryptionDetail;
    2525import org.expeditee.encryption.items.surrogates.Label;
    26 import org.expeditee.encryption.items.surrogates.Surrogate;
    2726import org.expeditee.encryption.items.surrogates.Label.LabelResult;
    2827import org.expeditee.gui.Frame;
    … …  
    7675       
    7776        @Override
    78         public void outputFrame(Frame frame) throws IOException {
    79                 if (_writer == null) { return; }
    80                
    81                 preOutputFrame();
    82                 writeHeader(frame);
    83                
    84                 // write item
    85                 writeItemData(frame);
    86                 writeTerminator();
    87                
    88                 // write lines and constraints
    89                 writeLineData();
    90                 writeTerminator();
    91                 writeConstraintData();
    92                 writeTerminator();
    93                
    94                 writeLine(SessionStats.getFrameEventList(frame));
    95         }
    96        
    97         @Override
    9877        protected void preOutputFrame() {
    9978                try {
    … …  
    10786       
    10887        @Override
     88        public void outputFrame(Frame frame) throws IOException {
     89                if (_writer == null) { return; }
     90               
     91                preOutputFrame();
     92                writeHeader(frame);
     93               
     94                // write item
     95                writeItemData(frame);
     96                writeTerminator();
     97               
     98                // write lines and constraints
     99                writeLineData();
     100                writeTerminator();
     101                writeConstraintData();
     102                writeTerminator();
     103               
     104                writeLine(SessionStats.getFrameEventList(frame));
     105        }
     106       
     107        @Override
    109108        protected void writeLine(String line) throws IOException {
    110109                // do not write empty lines
    … …  
    125124        }
    126125       
    127         @Override
    128         protected void writeLineData() throws IOException {
    129                 super.writeLineData();
    130                
    131                 writeSurrogateLineData();
    132         }
    133        
    134         @Override
    135126        protected void writeClass(Item toWrite) throws IOException {
    136127                LinkedHashMap<Character,Method> itemTags = new LinkedHashMap<Character, Method>(getItemTags());
    137128                LinkedHashMap<String,Method> itemTagsExt = new LinkedHashMap<String, Method>(getItemTagsExt());
    138129               
    139                 // Perform final update on surrogates to ensure inheritance works.
    140                 Set<Surrogate> surrogates = toWrite.getSurrogates();
    141                 for (Surrogate s: surrogates) {
    142                         s.toString();
    143                 }
    144                
    145130                writeTag(toWrite, new Object[] {}, itemTags, 'S');
    146131                writeTag(toWrite, new Object[] {}, itemTagsExt, "_el");
    147132               
     133                if (toWrite.isSurrogate()) {
     134                        writeLine("SurrogateFor " + toWrite.getClassic().getID());
     135                }
     136               
    148137                itemTags.remove('S');
    149138                itemTagsExt.remove("_el");
    150                
     139                               
    151140                writeTags(toWrite, new Object[] {}, itemTags);
    152141                writeTags(toWrite, new Object[] {}, itemTagsExt);
    … …  
    155144        @Override
    156145        protected <T> void writeTag(Item toWrite, Object[] param, LinkedHashMap<T, Method> tags, T tag) {
     146                if (toWrite.isSurrogate() && toWrite.isTagInherited(tag + "")) {
     147                        return;
     148                }
    157149                EncryptionDetail encryptionDetail = toWrite.getEncryptionDetailForTag(tag + "");
    158                 switch (encryptionDetail) {
     150                               
     151                switch(encryptionDetail) {
    159152                case UnencryptedOnSave:
    160                         super.writeTag(toWrite, param, tags, tag);
     153                        writeTagUnencryptedOnSave(toWrite, param, tags, tag);
     154                        break;
     155                case InheritanceCheckOnSave:
     156                        writeTagInheritanceCheckOnSave(toWrite, tags, tag);
    161157                        break;
    162158                case ReencryptOnSave:
    163                         Method toRun = tags.get(tag);
    164                         Class<?> declarer = toRun.getDeclaringClass();
    165                         LabelResult res = Label.resolveKey(toWrite.getEncryptionLabel());
    166                         if (declarer.isAssignableFrom(toWrite.getClass()) && res == LabelResult.SuccessResolveLabelToKey) {
    167                                 SecretKey key = new SecretKeySpec(res.key, SymmetricAlgorithm);
    168                                 try {
    169                                         Object o = toRun.invoke(toWrite, new Object[] {});
    170                                         o = Conversion.ConvertToExpeditee(toRun, o);
    171                                         if (o != null) {
    172                                                 if (o instanceof List) {
    173                                                         for (Object line: (List<?>)o) {
    174                                                                 byte[] encryptedBytes = EncryptSymmetric(line.toString().getBytes(), key);
    175                                                                 writeLine(tag + "E", Base64.getEncoder().encodeToString(encryptedBytes));
    176                                                         }
    177                                                 } else {
    178                                                         byte[] encryptedBytes = EncryptSymmetric(o.toString().getBytes(), key);
    179                                                         writeLine(tag + "E", Base64.getEncoder().encodeToString(encryptedBytes));
    180                                                 }
    181                                         }
    182                                 } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
    183                                         e.printStackTrace();
    184                                 } catch (IOException e) {
    185                                         e.printStackTrace();
    186                                 }
    187                         }
     159                        writeTagReencryptOnSave(toWrite, tags, tag);
    188160                        break;
    189161                case UseUndecipheredValueOnSave:
    190                         try {
    191                                 writeLine(tag + "E", encryptionDetail.getUndecipheredValue());
    192                         } catch (IOException e) {
    193                                 e.printStackTrace();
    194                         }
     162                        writeTagUseUndecipheredValueOnSave(toWrite, tags, tag);
    195163                        break;
    196164                }
    … …  
    204172                }
    205173               
    206                 for (final Item i: frame.getBodyItemsWithInsufficientPermissions()) {
     174                for (Item i: frame.getBodyItemsWithInsufficientPermissions()) {
    207175                        assert (!(i instanceof Line));
    208176                        writeItem(i);
    209177                }
    210178               
    211                 writeSurrogateItemsData(frame);
    212         }
    213        
    214         private void writeSurrogateItemsData(Frame frame) throws IOException {
    215                 List<Surrogate> surrogates = new ArrayList<Surrogate>();
    216                
    217                 Consumer<? super Item> store = item -> surrogates.addAll(item.getSurrogates());
    218                 frame.getItemsToSave().forEach(store);
    219                 frame.getBodyItemsWithInsufficientPermissions().forEach(store);
    220                
     179                List<Item> surrogates = frame.getSurrogateItemsToSave();
    221180                if (!surrogates.isEmpty()) {
    222                         // If there is some surrogates, write the surrogate
    223                         // terminator, then write out the surrogates.
    224181                        writeSurrogateTerminator();
    225                        
    226                         for (Surrogate surrogate: surrogates) {
    227                                 String output = surrogate.toString();
    228                                 writeLine(output);
    229                         }
    230                 }
    231         }
    232 
    233         private void writeSurrogateLineData() throws IOException {
    234                 List<Surrogate> surrogateLines = new ArrayList<Surrogate>();
    235                
    236                 for(Item lineEnd: _lineEnds) {
    237                         List<Line> lines = lineEnd.getLines();
    238                         for (Line line: lines) {
    239                                 surrogateLines.addAll(line.getSurrogates());
    240                         }
    241                 }
    242                
    243                 if (!surrogateLines.isEmpty()) {
    244                         // If there is some surrogates, write the surrogate
    245                         // terminator, then write out the surrogates.
    246                         writeSurrogateTerminator();
    247                        
    248                         for (Surrogate surrogate: surrogateLines) {
    249                                 String output = surrogate.toString();
    250                                 writeLine(output);
    251                         }
    252                 }
     182                        for (Item i: surrogates) {
     183                                assert (!(i instanceof Line));
     184                                writeItem(i);
     185                        }
     186                }
     187        }
     188       
     189        private <T> void writeTagInheritanceCheckOnSave(Item toWrite, LinkedHashMap<T, Method> tags, T tag) {   
     190                List<Item> surrogateItems = toWrite.getSurrogates().stream().collect(Collectors.toList());
     191                Function<Item, Boolean> isTagInherited = surrogate -> surrogate.isTagInherited(tag + "");
     192                BinaryOperator<Boolean> trueExists = (a, b) -> a || b;
     193                boolean surrogatesInherit = surrogateItems.stream().map(isTagInherited).collect(Collectors.reducing(trueExists)).get();
     194                if (surrogatesInherit &&
     195                                Label.resolveKey(toWrite.getEncryptionLabel()) == LabelResult.SuccessResolveLabelToKey) {
     196                        toWrite.setEncryptionDetailForTag(tag + "", EncryptionDetail.UnencryptedOnSave);
     197                        writeTagUnencryptedOnSave(toWrite, new Object[] {}, tags, tag);
     198                } else {
     199                        toWrite.setEncryptionDetailForTag(tag + "", EncryptionDetail.ReencryptOnSave);
     200                        writeTagReencryptOnSave(toWrite, tags, tag);
     201                }
     202        }
     203       
     204        private <T> void writeTagReencryptOnSave(Item toWrite, LinkedHashMap<T, Method> tags, T tag) {
     205                Method toRun = tags.get(tag);
     206                Class<?> declarer = toRun.getDeclaringClass();
     207                LabelResult res = Label.resolveKey(toWrite.getEncryptionLabel());
     208                if (declarer.isAssignableFrom(toWrite.getClass()) && res == LabelResult.SuccessResolveLabelToKey) {
     209                        try {
     210                                Object o = toRun.invoke(toWrite, new Object[] {});
     211                                o = Conversion.ConvertToExpeditee(toRun, o);
     212                                if (o == null) {
     213                                        return;
     214                                }
     215                                if (o instanceof List) {
     216                                        for (Object line: (List<?>) o) {
     217                                                writeLineEnc(tag, line, res.key);
     218                                        }
     219                                } else {
     220                                        writeLineEnc(tag, o, res.key);
     221                                }
     222                        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
     223                                e.printStackTrace();
     224                        } catch (IOException e) {
     225                                e.printStackTrace();
     226                        }
     227                }
     228        }
     229       
     230        private <T> void writeTagUseUndecipheredValueOnSave(Item toWrite, LinkedHashMap<T, Method> tags, T tag) {
     231                EncryptionDetail encryptionDetail = toWrite.getEncryptionDetailForTag(tag + "");
     232                try {
     233                        writeLine(tag + "E", encryptionDetail.getUndecipheredValue());
     234                } catch (IOException e) {
     235                        e.printStackTrace();
     236                }
     237        }
     238       
     239        private <T> void writeTagUnencryptedOnSave(Item toWrite, Object[] param, LinkedHashMap<T, Method> tags, T tag) {
     240                super.writeTag(toWrite, param, tags, tag);
    253241        }
    254242       
    255243        private void writeSurrogateTerminator() throws IOException {
    256244                writeLine(SURROGATE_TERMINATOR + nl);
     245        }
     246       
     247        private <T> void writeLineEnc(T tag, Object line, byte[] keyBytes) throws IOException {
     248                SecretKey key = new SecretKeySpec(keyBytes, SymmetricAlgorithm);
     249                byte[] lineEncryptedBytes = EncryptSymmetric(line.toString().getBytes(), key);
     250                line = Base64.getEncoder().encodeToString(lineEncryptedBytes);
     251                writeLine(tag + "E", line.toString());
    257252        }
    258253       
    … …  
    271266                        return null;
    272267                }
    273         }       
     268        }
    274269}

  • trunk/src/org/expeditee/encryption/items/surrogates/EncryptionDetail.java

    r1408 r1413  
    22
    33public enum EncryptionDetail {
    4         UnencryptedOnSave, ReencryptOnSave, UseUndecipheredValueOnSave;
     4        // If the property needs to be unencrypted due to inheritance then do not try to encrypt it.
     5        UnencryptedOnSave,
     6       
     7        // If the property is not inherited by any surrogates then we can try to encrypt it. 
     8        // If we do not have key then default to UnencryptedOnSave.
     9        ReencryptOnSave,
     10       
     11        // If the property is no longer inherited by at least one surrogate then this value is present. 
     12        // If it turns out there is no longer any surrogates who inherit the value then this value can be replaced with ReencryptOnSave.
     13        // Otherwise, this value must be replaced with UnencryptedOnSave.
     14        InheritanceCheckOnSave,
     15       
     16        // If we could not decrypt the value on load then EncryptionDetail.getUndecipheredValue() can be used to get the value for saving.
     17        UseUndecipheredValueOnSave;
    518       
    619        private String undecipheredValue = null;

  • trunk/src/org/expeditee/encryption/items/surrogates/Label.java

    r1409 r1413  
    11package org.expeditee.encryption.items.surrogates;
    22
     3import java.util.ArrayList;
    34import java.util.Base64;
    45import java.util.Collection;
     6import java.util.List;
     7import java.util.Set;
     8import java.util.stream.Collectors;
    59
    610import org.expeditee.auth.AuthenticatorBrowser;
     11import org.expeditee.gui.DisplayController;
    712import org.expeditee.gui.Frame;
    813import org.expeditee.gui.FrameIO;
     14import org.expeditee.gui.MessageBay;
     15import org.expeditee.items.Item;
    916import org.expeditee.items.Text;
    1017import org.expeditee.settings.UserSettings;
    … …  
    1219public class Label {
    1320       
     21        private static List<LabelResult> labelCache = new ArrayList<LabelResult>();
     22        private static List<String> forbiddenLabels = new ArrayList<String>();
     23       
    1424        public static LabelResult resolveKey(String label) {
     25               
     26                if (forbiddenLabels.contains(label)) {
     27                        return LabelResult.ErrorUnableToFindLabel;
     28                }
     29               
     30                LabelResult fromCache = getFromCache(label);
     31                if (fromCache != null) {
     32                        return fromCache;
     33                }
     34
     35               
    1536                String credentialsFrameName = UserSettings.ProfileName.get() +
    1637                                AuthenticatorBrowser.CREDENTIALS_FRAME;
    … …  
    4465                                LabelResult res = LabelResult.SuccessResolveLabelToKey;
    4566                                res.key = Base64.getDecoder().decode(data);
     67                                res.name = label;
     68                                labelCache.add(res);
    4669                                return res;
    4770                        } catch (IllegalArgumentException e) {
    … …  
    5073                }
    5174        }
     75       
     76        public static void progressSurrogateMode() {
     77                Collection<Item> allItems = DisplayController.getCurrentFrame().getAllItems();
     78                allItems.removeIf(item -> item.getEncryptionLabel() == null);
     79                MessageBay.displayMessage("Encryption labels found on items on current frame: ");
     80                Set<String> allLabels = allItems.stream().map(i -> i.getEncryptionLabel()).collect(Collectors.toSet());
     81                StringBuilder sb = new StringBuilder();
     82                for (String label: allLabels) {
     83                        sb.append(label + ",");
     84                }
     85                MessageBay.displayMessage(sb.deleteCharAt(sb.length() - 1).toString());
     86        }
     87       
     88        public static void resetSurrogateMode() {
     89                // TODO Auto-generated method stub
     90               
     91        }
     92       
     93        private static LabelResult getFromCache(String label) {
     94                List<LabelResult> cacheCanditates = labelCache.stream().filter(labelResult -> labelResult.name.equals(label)).collect(Collectors.toList());
     95                if (!cacheCanditates.isEmpty()) {
     96                        return cacheCanditates.get(0);
     97                } else {
     98                        return null;
     99                }
     100        }
     101       
     102//      private static List<List<String>> permutation(List<String> strings, List<List<String>> acc) {
     103//              for (int i = 0; i < strings.size(); i++) {
     104//                     
     105//              }
     106//      }
    52107       
    53108        public enum LabelResult {
    … …  
    58113               
    59114                public byte[] key;
     115                public String name;
    60116               
    61117                @Override

  • trunk/src/org/expeditee/gio/gesture/ExpediteeKBMGestureTranslator.java

    r1186 r1413  
    698698                               
    699699                                // Return the gesture
    700                                 return Gesture.single(StandardGestureActions.getInstance().gestureType(StandardGestureType.TOGGLE_XRAY_MODE), null);
     700                                if (kbmTranslator.isKeyDown(Key.SHIFT)) {
     701                                        UndoGestureData data = new UndoGestureData(kbmTranslator.isKeyDown(Key.CTRL));
     702                                        return Gesture.single(StandardGestureActions.getInstance().gestureType(StandardGestureType.TOGGLE_SURROGATE_MODE), data);
     703                                } else {
     704                                        return Gesture.single(StandardGestureActions.getInstance().gestureType(StandardGestureType.TOGGLE_XRAY_MODE), null);
     705                                }
    701706                        }
    702707                });

  • trunk/src/org/expeditee/gio/gesture/StandardGestureActions.java

    r1406 r1413  
    123123                TOGGLE_ITEMS_MARK, // Show/hide the little circle indicating the item has a link and/or action
    124124                TOGGLE_XRAY_MODE, // F10
     125                TOGGLE_SURROGATE_MODE, // Shift + F10
    125126                UNDO,
    126127                ZOOM
    … …  
    965966                        }
    966967                });
     968               
     969                setGestureAction(gestureType(StandardGestureType.TOGGLE_SURROGATE_MODE), new GestureAction() {
     970                        @Override
     971                        public void exec(Gesture gesture) {
     972                                if (((UndoGestureData) gesture.getData()).getRedo()) {
     973                                        DisplayController.ResetSurrogateMode();
     974                                } else {
     975                                        DisplayController.ToggleSurrogateMode();
     976                                }
     977                        }
     978                });
    967979
    968980        }

  • trunk/src/org/expeditee/gui/DisplayController.java

    r1363 r1413  
    4242import org.expeditee.core.bounds.AxisAlignedBoxBounds;
    4343import org.expeditee.core.bounds.Bounds;
     44import org.expeditee.encryption.items.surrogates.Label;
    4445import org.expeditee.gio.EcosystemManager;
    4546import org.expeditee.gio.GraphicsManager;
    … …  
    12281229        }
    12291230       
     1231        public static void ToggleSurrogateMode() {
     1232                // Turn off x-ray mode if it is on
     1233                if (_audienceMode) {
     1234                        ToggleAudienceMode();
     1235                }
     1236               
     1237                Label.progressSurrogateMode();
     1238               
     1239                getCurrentFrame().parse();
     1240                getCurrentFrame().refreshSize();
     1241                updateTitle();
     1242                StandardGestureActions.refreshHighlights();
     1243                StandardGestureActions.updateCursor();
     1244                requestRefresh(false);
     1245        }
     1246       
     1247        public static void ResetSurrogateMode() {
     1248                // Turn off x-ray mode if it is on
     1249                if (_audienceMode) {
     1250                        ToggleAudienceMode();
     1251                }
     1252               
     1253                Label.resetSurrogateMode();
     1254               
     1255                getCurrentFrame().parse();
     1256                getCurrentFrame().refreshSize();
     1257                updateTitle();
     1258                StandardGestureActions.refreshHighlights();
     1259                StandardGestureActions.updateCursor();
     1260                requestRefresh(false);
     1261        }
     1262       
    12301263        /** Whether audience mode is currently on. */
    12311264        public static boolean isAudienceMode()

  • trunk/src/org/expeditee/gui/Frame.java

    r1408 r1413  
    25542554         * @return the list of items to be saved to a text file
    25552555         */
    2556         public List<Item> getItemsToSave()
    2557         {
     2556        public List<Item> getItemsToSave() {
    25582557                if (!_sorted) {
    25592558                        Collections.sort(_body);
    … …  
    25952594
    25962595                return toSave;
     2596        }
     2597       
     2598        public List<Item> getSurrogateItemsToSave() {
     2599                List<Item> surrogates = new ArrayList<Item>();
     2600                _body.forEach(item -> surrogates.addAll(item.getSurrogates()));
     2601                return surrogates;
    25972602        }
    25982603

  • trunk/src/org/expeditee/gui/FrameGraphics.java

    r1410 r1413  
    3232import org.expeditee.core.Image;
    3333import org.expeditee.core.bounds.PolygonBounds;
    34 import org.expeditee.encryption.items.surrogates.Label.LabelResult;
    35 import org.expeditee.encryption.items.surrogates.Label;
    36 import org.expeditee.encryption.items.surrogates.Surrogate;
    3734import org.expeditee.gio.EcosystemManager;
    3835import org.expeditee.gio.input.KBMInputEvent.Key;
    … …  
    457454                if (i == null) {
    458455                        return;
    459                 }
    460                
    461                 String encryptionLabel = i.getEncryptionLabel();
    462                 if (encryptionLabel != null && encryptionLabel.length() > 0 && !i.isSurrogate()) {
    463                         LabelResult result = Label.resolveKey(encryptionLabel);
    464                         if (result != LabelResult.SuccessResolveLabelToKey) {
    465                                 for(Surrogate s: i.getSurrogates()) {
    466                                         PaintItem(s.getSurrogateItem());
    467                                 }
    468                                 return;
    469                         }
    470456                }
    471457

  • trunk/src/org/expeditee/io/DefaultFrameReader.java

    r1408 r1413  
    9999
    100100                        // Note: As of 26/11/18 there are no unused letter item tags.  Use other characters.
    101                         _ItemTags.put('S', Item.class.getMethod("setID", pInt));
    102                         _ItemTags.put('s', Item.class.getMethod("setDateCreated", pString));
    103                         _ItemTags.put('d', Item.class.getMethod("setColor", pColor));
    104                         _ItemTags.put('G', Item.class.getMethod("setBackgroundColor",
     101                        _ItemTags.put(DefaultFrameWriter.TYPE_AND_ID, Item.class.getMethod("setID", pInt));
     102                        _ItemTags.put(DefaultFrameWriter.DATE_CREATED, Item.class.getMethod("setDateCreated", pString));
     103                        _ItemTags.put(DefaultFrameWriter.COLOR, Item.class.getMethod("setColor", pColor));
     104                        _ItemTags.put(DefaultFrameWriter.BACKGROUND_COLOR, Item.class.getMethod("setBackgroundColor",
    105105                                        pColor));
    106                         _ItemTags.put('K', Item.class.getMethod("setBorderColor",
     106                        _ItemTags.put(DefaultFrameWriter.BORDER_COLOR, Item.class.getMethod("setBorderColor",
    107107                                        pColor));
    108108
    109                         _ItemTags.put('R', Item.class.getMethod("setAnchorLeft", pIntO));
    110                         _ItemTags.put('H', Item.class.getMethod("setAnchorRight", pIntO));
    111                         _ItemTags.put('N', Item.class.getMethod("setAnchorTop", pIntO));
    112                         _ItemTags.put('I', Item.class.getMethod("setAnchorBottom", pIntO));
    113 
    114                         _ItemTags.put('P', Item.class.getMethod("setPosition", pPoint));
    115                         _ItemTags.put('F', Item.class.getMethod("setLink", pString));
    116                         _ItemTags.put('J', Item.class.getMethod("setFormula", pString));
    117                        
    118                         _ItemTags.put('X', Item.class.getMethod("setActions", pList));
    119                         _ItemTags.put('x', Item.class.getMethod("setActionMark", pBool));
    120                         _ItemTags.put('U', Item.class.getMethod("setActionCursorEnter",
    121                                         pList));
    122                         _ItemTags.put('V', Item.class.getMethod("setActionCursorLeave",
    123                                         pList));
    124                         _ItemTags.put('W', Item.class.getMethod("setActionEnterFrame",
    125                                         pList));
    126                         _ItemTags.put('Y', Item.class.getMethod("setActionLeaveFrame",
    127                                         pList));
    128                         _ItemTags.put('D', Item.class.getMethod("addToData", pString));
    129                         _ItemTags.put('u', Item.class.getMethod("setHighlight", pBool));
    130                         _ItemTags.put('e', Item.class.getMethod("setFillColor", pColor));
    131                         _ItemTags.put('E', Item.class.getMethod("setGradientColor", pColor));
    132                         _ItemTags.put('Q', Item.class.getMethod("setGradientAngle", pDouble));
    133                        
    134                         _ItemTags.put('i', Item.class.getMethod("setFillPattern", pString));
    135                         _ItemTags.put('o', Item.class.getMethod("setOwner", pString));
    136                         _ItemTags.put('n', Item.class.getMethod("setLinkMark", pBool));
     109                        _ItemTags.put(DefaultFrameWriter.ANCHOR_LEFT, Item.class.getMethod("setAnchorLeft", pIntO));
     110                        _ItemTags.put(DefaultFrameWriter.ANCHOR_RIGHT, Item.class.getMethod("setAnchorRight", pIntO));
     111                        _ItemTags.put(DefaultFrameWriter.ANCHOR_TOP, Item.class.getMethod("setAnchorTop", pIntO));
     112                        _ItemTags.put(DefaultFrameWriter.ANCHOR_BOTTOM, Item.class.getMethod("setAnchorBottom", pIntO));
     113
     114                        _ItemTags.put(DefaultFrameWriter.POSITION, Item.class.getMethod("setPosition", pPoint));
     115                        _ItemTags.put(DefaultFrameWriter.LINK, Item.class.getMethod("setLink", pString));
     116                        _ItemTags.put(DefaultFrameWriter.FORMULA, Item.class.getMethod("setFormula", pString));
     117                       
     118                        _ItemTags.put(DefaultFrameWriter.ACTION, Item.class.getMethod("setActions", pList));
     119                        _ItemTags.put(DefaultFrameWriter.ACTION_MARK, Item.class.getMethod("setActionMark", pBool));
     120                        _ItemTags.put(DefaultFrameWriter.ACTION_CURSOR_ENTER, Item.class.getMethod("setActionCursorEnter",
     121                                        pList));
     122                        _ItemTags.put(DefaultFrameWriter.ACTION_CURSOR_LEAVE, Item.class.getMethod("setActionCursorLeave",
     123                                        pList));
     124                        _ItemTags.put(DefaultFrameWriter.ACTION_ENTER_FRAME, Item.class.getMethod("setActionEnterFrame",
     125                                        pList));
     126                        _ItemTags.put(DefaultFrameWriter.ACTION_LEAVE_FRAME, Item.class.getMethod("setActionLeaveFrame",
     127                                        pList));
     128                        _ItemTags.put(DefaultFrameWriter.DATA, Item.class.getMethod("addToData", pString));
     129                        _ItemTags.put(DefaultFrameWriter.HIGHLIGHT, Item.class.getMethod("setHighlight", pBool));
     130                        _ItemTags.put(DefaultFrameWriter.FILL_COLOR, Item.class.getMethod("setFillColor", pColor));
     131                        _ItemTags.put(DefaultFrameWriter.GRADIENT_COLOR, Item.class.getMethod("setGradientColor", pColor));
     132                        _ItemTags.put(DefaultFrameWriter.GRADIENT_ANGLE, Item.class.getMethod("setGradientAngle", pDouble));
     133                       
     134                        _ItemTags.put(DefaultFrameWriter.FILL_PATTERN, Item.class.getMethod("setFillPattern", pString));
     135                        _ItemTags.put(DefaultFrameWriter.OWNER, Item.class.getMethod("setOwner", pString));
     136                        _ItemTags.put(DefaultFrameWriter.LINK_MARK, Item.class.getMethod("setLinkMark", pBool));
    137137                        _ItemTags
    138                                         .put('q', Item.class.getMethod("setLinkFrameset", pString));
     138                                        .put(DefaultFrameWriter.LINK_FRAMESET, Item.class.getMethod("setLinkFrameset", pString));
    139139                        _ItemTags
    140                                         .put('y', Item.class.getMethod("setLinkTemplate", pString));
    141                         _ItemTags.put('g', Item.class.getMethod("setLinePattern", pIntArray));
    142 
    143                         _ItemTags.put('j', Item.class.getMethod("setArrow", pArrow));
    144 
    145                         _ItemTags.put('v', Dot.class.getMethod("setDotType", pDotType));
    146                         _ItemTags.put('z', Dot.class.getMethod("setFilled", pBool));
    147                        
    148                         _ItemTags.put('f', Text.class.getMethod("setFont", pFont));
    149                         _ItemTags.put('t', Text.class.getMethod("setSpacing", pFloat));
    150                         _ItemTags.put('T', Text.class.getMethod("appendLine", pString));
    151                         _ItemTags.put('a', Text.class.getMethod("setWordSpacing", pInt));
    152                         _ItemTags.put('b', Text.class.getMethod("setLetterSpacing", pFloat));
    153                         _ItemTags.put('m', Text.class.getMethod("setInitialSpacing", pFloat));
    154                         _ItemTags.put('w', Text.class.getMethod("setWidth", pIntO));
    155                         _ItemTags.put('M', Text.class.getMethod("setMinWidth", pIntO));
    156                         _ItemTags.put('k', Text.class.getMethod("setJustification", pJustification));
    157                         _ItemTags.put('r', Text.class.getMethod("setAutoWrap", pBool));
    158 
    159                         _ItemTags.put('h', Item.class.getMethod("setThickness", pFloat));
    160                         _ItemTags.put('l', Item.class.getMethod("setLineIDs", pString));
    161                         _ItemTags.put('c', Item.class.getMethod("setConstraintIDs", pString));
    162                        
    163                         _ItemTags.put('A', Item.class.getMethod("setTooltip", pString));
    164                         _ItemTags.put('B', Item.class.getMethod("setLinkHistory", pBool));
    165                        
    166                         _ItemTags.put('p', Item.class.getMethod("setPermission", pPermission));
    167                        
    168                         _ItemTags.put('O', Text.class.getMethod("setMask", pIntO));
     140                                        .put(DefaultFrameWriter.LINK_TEMPLATE, Item.class.getMethod("setLinkTemplate", pString));
     141                        _ItemTags.put(DefaultFrameWriter.LINE_PATTERN, Item.class.getMethod("setLinePattern", pIntArray));
     142
     143                        _ItemTags.put(DefaultFrameWriter.ARROW, Item.class.getMethod("setArrow", pArrow));
     144
     145                        _ItemTags.put(DefaultFrameWriter.DOT_TYPE, Dot.class.getMethod("setDotType", pDotType));
     146                        _ItemTags.put(DefaultFrameWriter.FILLED, Dot.class.getMethod("setFilled", pBool));
     147                       
     148                        _ItemTags.put(DefaultFrameWriter.FONT, Text.class.getMethod("setFont", pFont));
     149                        _ItemTags.put(DefaultFrameWriter.SPACING, Text.class.getMethod("setSpacing", pFloat));
     150                        _ItemTags.put(DefaultFrameWriter.TEXT, Text.class.getMethod("appendLine", pString));
     151                        _ItemTags.put(DefaultFrameWriter.WORD_SPACING, Text.class.getMethod("setWordSpacing", pInt));
     152                        _ItemTags.put(DefaultFrameWriter.LETTER_SPACING, Text.class.getMethod("setLetterSpacing", pFloat));
     153                        _ItemTags.put(DefaultFrameWriter.INITIAL_SPACING, Text.class.getMethod("setInitialSpacing", pFloat));
     154                        _ItemTags.put(DefaultFrameWriter.WIDTH_TO_SAVE, Text.class.getMethod("setWidth", pIntO));
     155                        _ItemTags.put(DefaultFrameWriter.MIN_WIDTH_TO_SAVE, Text.class.getMethod("setMinWidth", pIntO));
     156                        _ItemTags.put(DefaultFrameWriter.JUSTIFICATION, Text.class.getMethod("setJustification", pJustification));
     157                        _ItemTags.put(DefaultFrameWriter.AUTO_WRAP_TO_SAVE, Text.class.getMethod("setAutoWrap", pBool));
     158
     159                        _ItemTags.put(DefaultFrameWriter.THICKNESS, Item.class.getMethod("setThickness", pFloat));
     160                        _ItemTags.put(DefaultFrameWriter.LINE_IDS, Item.class.getMethod("setLineIDs", pString));
     161                        _ItemTags.put(DefaultFrameWriter.CONSTRAINT_IDS, Item.class.getMethod("setConstraintIDs", pString));
     162                       
     163                        _ItemTags.put(DefaultFrameWriter.TOOLTIP, Item.class.getMethod("setTooltip", pString));
     164                        _ItemTags.put(DefaultFrameWriter.LINK_HISTORY, Item.class.getMethod("setLinkHistory", pBool));
     165                       
     166                        _ItemTags.put(DefaultFrameWriter.PERMISSION, Item.class.getMethod("setPermission", pPermission));
     167                       
     168                        _ItemTags.put(DefaultFrameWriter.MASK, Text.class.getMethod("setMask", pIntO));
    169169                       
    170170                        // Lines and constraints are created differently
    … …  
    172172                        _ItemTags.put('C', Constraint.class.getMethod("getID", (Class[]) null));
    173173                       
    174                         _ItemTags.put('[', Item.class.getMethod("setMagnetizedItemLeft", pInt));
     174                        _ItemTags.put(DefaultFrameWriter.MAGNETIZED_ITEM_LEFT, Item.class.getMethod("setMagnetizedItemLeft", pInt));
    175175                        _DelayedItemTags.add('[');
    176                         _ItemTags.put(']', Item.class.getMethod("setMagnetizedItemRight", pInt));
     176                        _ItemTags.put(DefaultFrameWriter.MAGNETIZED_ITEM_RIGHT, Item.class.getMethod("setMagnetizedItemRight", pInt));
    177177                        _DelayedItemTags.add(']');
    178                         _ItemTags.put('^', Item.class.getMethod("setMagnetizedItemTop", pInt));
     178                        _ItemTags.put(DefaultFrameWriter.MAGNETIZED_ITEM_TOP, Item.class.getMethod("setMagnetizedItemTop", pInt));
    179179                        _DelayedItemTags.add('^');
    180                         _ItemTags.put('/', Item.class.getMethod("setMagnetizedItemBottom", pInt));
     180                        _ItemTags.put(DefaultFrameWriter.MAGNETIZED_ITEM_BOTTOM, Item.class.getMethod("setMagnetizedItemBottom", pInt));
    181181                        _DelayedItemTags.add('/');
    182182                       
    183                         _ItemTagsExt.put("_el", Item.class.getMethod("setEncryptionLabelOnLoad", pString));
    184                        
    185                         _ItemTagsExt.put("_ph", Text.class.getMethod("setPlaceholder", pString));
    186                         _ItemTagsExt.put("_sl", Text.class.getMethod("setSingleLineOnly", pBool));
    187                         _ItemTagsExt.put("_ti", Text.class.getMethod("setTabIndex", pInt));
     183                        _ItemTagsExt.put(DefaultFrameWriter.ENCRYPTION_LABEL_STR, Item.class.getMethod("setEncryptionLabelOnLoad", pString));
     184                       
     185                        _ItemTagsExt.put(DefaultFrameWriter.PLACEHOLDER_STR, Text.class.getMethod("setPlaceholder", pString));
     186                        _ItemTagsExt.put(DefaultFrameWriter.SINGLE_LINE_ONLY_STR, Text.class.getMethod("setSingleLineOnly", pBool));
     187                        _ItemTagsExt.put(DefaultFrameWriter.TAB_INDEX_STR, Text.class.getMethod("setTabIndex", pInt));
    188188                } catch (Exception e) {
    189189                        e.printStackTrace();

  • trunk/src/org/expeditee/io/DefaultFrameWriter.java

    r1410 r1413  
    4141public abstract class DefaultFrameWriter extends ItemWriter implements
    4242                FrameWriter {
    43 
    44         public static final String TAB_INDEX = "_ti";
    45         public static final String SINGLE_LINE_ONLY = "_sl";
    46         public static final String PLACEHOLDER = "_ph";
    47         public static final String ENCRYPTION_LABEL = "_el";
    48         public static final char MAGNETIZED_ITEM_BOTTOM = '/';
    49         public static final char MAGNETIZED_ITEM_TOP = '^';
    50         public static final char MAGNETIZED_ITEM_RIGHT = ']';
    51         public static final char MAGNETIZED_ITEM_LEFT = '[';
    52         public static final char PERMISSION = 'p';
    53         public static final char LINK_HISTORY = 'B';
    54         public static final char TOOLTIP = 'A';
    55         public static final char CONSTRAINT_IDS = 'c';
    56         public static final char LINE_IDS = 'l';
    57         public static final char THICKNESS = 'h';
    58         public static final char AUTO_WRAP_TO_SAVE = 'r';
    59         public static final char JUSTIFICATION = 'k';
    60         public static final char MIN_WIDTH_TO_SAVE = 'M';
    61         public static final char WIDTH_TO_SAVE = 'w';
    62         public static final char INITIAL_SPACING = 'm';
    63         public static final char LETTER_SPACING = 'b';
    64         public static final char WORD_SPACING = 'a';
    65         public static final char FORMULA = 'J';
    66         public static final char MASK = 'O';
    67         public static final char SPACING = 't';
    68         public static final char FONT = 'f';
    69         public static final char FILLED = 'z';
    70         public static final char DOT_TYPE = 'v';
    71         public static final char ARROW = 'j';
    72         public static final char LINE_PATTERN = 'g';
    73         public static final char LINK_TEMPLATE = 'y';
    74         public static final char LINK_FRAMESET = 'q';
    75         public static final char LINK_MARK = 'n';
    76         public static final char OWNER = 'o';
    77         public static final char FILL_PATTERN = 'i';
    78         public static final char ANCHOR_BOTTOM = 'I';
    79         public static final char ANCHOR_TOP = 'N';
    80         public static final char ANCHOR_RIGHT = 'H';
    81         public static final char ANCHOR_LEFT = 'R';
    82         public static final char GRADIENT_ANGLE = 'Q';
    83         public static final char GRADIENT_COLOR = 'E';
    84         public static final char FILL_COLOR = 'e';
    85         public static final char HIGHLIGHT = 'u';
    86         public static final char DATA = 'D';
    87         public static final char ACTION_LEAVE_FRAME = 'Y';
    88         public static final char ACTION_ENTER_FRAME = 'W';
    89         public static final char ACTION_CURSOR_LEAVE = 'V';
    90         public static final char ACTION_CURSOR_ENTER = 'U';
    91         public static final char ACTION_MARK = 'x';
    92         public static final char ACTION = 'X';
    93         public static final char LINK = 'F';
    94         public static final char TEXT = 'T';
    95         public static final char POSITION = 'P';
    96         public static final char BORDER_COLOR = 'K';
    97         public static final char BACKGROUND_COLOR = 'G';
    98         public static final char COLOR = 'd';
    99         public static final char DATE_CREATED = 's';
    100         public static final char TYPE_AND_ID = 'S';
     43        protected static final char MAGNETIZED_ITEM_BOTTOM = '/';
     44        protected static final char MAGNETIZED_ITEM_TOP = '^';
     45        protected static final char MAGNETIZED_ITEM_RIGHT = ']';
     46        protected static final char MAGNETIZED_ITEM_LEFT = '[';
     47        protected static final char PERMISSION = 'p';
     48        protected static final char LINK_HISTORY = 'B';
     49        protected static final char TOOLTIP = 'A';
     50        protected static final char CONSTRAINT_IDS = 'c';
     51        protected static final char LINE_IDS = 'l';
     52        protected static final char THICKNESS = 'h';
     53        protected static final char AUTO_WRAP_TO_SAVE = 'r';
     54        protected static final char JUSTIFICATION = 'k';
     55        protected static final char MIN_WIDTH_TO_SAVE = 'M';
     56        protected static final char WIDTH_TO_SAVE = 'w';
     57        protected static final char INITIAL_SPACING = 'm';
     58        protected static final char LETTER_SPACING = 'b';
     59        protected static final char WORD_SPACING = 'a';
     60        protected static final char FORMULA = 'J';
     61        protected static final char MASK = 'O';
     62        protected static final char SPACING = 't';
     63        protected static final char FONT = 'f';
     64        protected static final char FILLED = 'z';
     65        protected static final char DOT_TYPE = 'v';
     66        protected static final char ARROW = 'j';
     67        protected static final char LINE_PATTERN = 'g';
     68        protected static final char LINK_TEMPLATE = 'y';
     69        protected static final char LINK_FRAMESET = 'q';
     70        protected static final char LINK_MARK = 'n';
     71        protected static final char OWNER = 'o';
     72        protected static final char FILL_PATTERN = 'i';
     73        protected static final char ANCHOR_BOTTOM = 'I';
     74        protected static final char ANCHOR_TOP = 'N';
     75        protected static final char ANCHOR_RIGHT = 'H';
     76        protected static final char ANCHOR_LEFT = 'R';
     77        protected static final char GRADIENT_ANGLE = 'Q';
     78        protected static final char GRADIENT_COLOR = 'E';
     79        protected static final char FILL_COLOR = 'e';
     80        protected static final char HIGHLIGHT = 'u';
     81        protected static final char DATA = 'D';
     82        protected static final char ACTION_LEAVE_FRAME = 'Y';
     83        protected static final char ACTION_ENTER_FRAME = 'W';
     84        protected static final char ACTION_CURSOR_LEAVE = 'V';
     85        protected static final char ACTION_CURSOR_ENTER = 'U';
     86        protected static final char ACTION_MARK = 'x';
     87        protected static final char ACTION = 'X';
     88        protected static final char LINK = 'F';
     89        protected static final char TEXT = 'T';
     90        protected static final char POSITION = 'P';
     91        protected static final char BORDER_COLOR = 'K';
     92        protected static final char BACKGROUND_COLOR = 'G';
     93        protected static final char COLOR = 'd';
     94        protected static final char DATE_CREATED = 's';
     95        protected static final char TYPE_AND_ID = 'S';
     96       
     97        public static final String TAB_INDEX_STR = "_ti";
     98        public static final String SINGLE_LINE_ONLY_STR = "_sl";
     99        public static final String PLACEHOLDER_STR = "_ph";
     100        public static final String ENCRYPTION_LABEL_STR = "_el";
     101        public static final String MAGNETIZED_ITEM_BOTTOM_STR = MAGNETIZED_ITEM_BOTTOM + "";
     102        public static final String MAGNETIZED_ITEM_TOP_STR = MAGNETIZED_ITEM_TOP + "";
     103        public static final String MAGNETIZED_ITEM_RIGHT_STR = MAGNETIZED_ITEM_RIGHT + "";
     104        public static final String MAGNETIZED_ITEM_LEFT_STR = MAGNETIZED_ITEM_LEFT + "";
     105        public static final String PERMISSION_STR = PERMISSION + "";
     106        public static final String LINK_HISTORY_STR = LINK_HISTORY + "";
     107        public static final String TOOLTIP_STR = TOOLTIP + "";
     108        public static final String CONSTRAINT_IDS_STR = CONSTRAINT_IDS + "";
     109        public static final String LINE_IDS_STR = LINE_IDS + "";
     110        public static final String THICKNESS_STR = THICKNESS + "";
     111        public static final String AUTO_WRAP_TO_SAVE_STR = AUTO_WRAP_TO_SAVE + "";
     112        public static final String JUSTIFICATION_STR = JUSTIFICATION + "";
     113        public static final String MIN_WIDTH_TO_SAVE_STR = MIN_WIDTH_TO_SAVE + "";
     114        public static final String WIDTH_TO_SAVE_STR = WIDTH_TO_SAVE + "";
     115        public static final String INITIAL_SPACING_STR = INITIAL_SPACING + "";
     116        public static final String LETTER_SPACING_STR = LETTER_SPACING + "";
     117        public static final String WORD_SPACING_STR = WORD_SPACING + "";
     118        public static final String FORMULA_STR = FORMULA + "";
     119        public static final String MASK_STR = MASK + "";
     120        public static final String SPACING_STR = SPACING + "";
     121        public static final String FONT_STR = FONT + "";
     122        public static final String FILLED_STR = FILLED + "";
     123        public static final String DOT_TYPE_STR = DOT_TYPE + "";
     124        public static final String ARROW_STR = ARROW + "";
     125        public static final String LINE_PATTERN_STR = LINE_PATTERN + "";
     126        public static final String LINK_TEMPLATE_STR = LINK_TEMPLATE + "";
     127        public static final String LINK_FRAMESET_STR = LINK_FRAMESET + "";
     128        public static final String LINK_MARK_STR = LINK_MARK + "";
     129        public static final String OWNER_STR = OWNER + "";
     130        public static final String FILL_PATTERN_STR = FILL_PATTERN + "";
     131        public static final String ANCHOR_BOTTOM_STR = ANCHOR_BOTTOM + "";
     132        public static final String ANCHOR_TOP_STR = ANCHOR_TOP + "";
     133        public static final String ANCHOR_RIGHT_STR = ANCHOR_RIGHT + "";
     134        public static final String ANCHOR_LEFT_STR = ANCHOR_LEFT + "";
     135        public static final String GRADIENT_ANGLE_STR = GRADIENT_ANGLE + "";
     136        public static final String GRADIENT_COLOR_STR = GRADIENT_COLOR + "";
     137        public static final String FILL_COLOR_STR = FILL_COLOR + "";
     138        public static final String HIGHLIGHT_STR = HIGHLIGHT + "";
     139        public static final String DATA_STR = DATA + "";
     140        public static final String ACTION_LEAVE_FRAME_STR = ACTION_LEAVE_FRAME + "";
     141        public static final String ACTION_ENTER_FRAME_STR = ACTION_ENTER_FRAME + "";
     142        public static final String ACTION_CURSOR_LEAVE_STR = ACTION_CURSOR_LEAVE + "";
     143        public static final String ACTION_CURSOR_ENTER_STR = ACTION_CURSOR_ENTER + "";
     144        public static final String ACTION_MARK_STR = ACTION_MARK + "";
     145        public static final String ACTION_STR = ACTION + "";
     146        public static final String LINK_STR = LINK + "";
     147        public static final String TEXT_STR = TEXT + "";
     148        public static final String POSITION_STR = POSITION + "";
     149        public static final String BORDER_COLOR_STR = BORDER_COLOR + "";
     150        public static final String BACKGROUND_COLOR_STR = BACKGROUND_COLOR + "";
     151        public static final String COLOR_STR = COLOR + "";
     152        public static final String DATE_CREATED_STR = DATE_CREATED + "";
     153        public static final String TYPE_AND_ID_STR = TYPE_AND_ID + "";
    101154
    102155        protected String _filename = null;
    … …  
    113166
    114167        // keep track of methods that are put on the same line
    115         private static LinkedHashMap<Character, Method> _ItemTags = null;
     168        private static LinkedHashMap<Character, Method> _ItemTags = new LinkedHashMap<Character, Method>();
    116169        // IMPORTANT: keys in _ItemTagsExt must start with underscore as their first character
    117         private static LinkedHashMap<String, Method> _ItemTagsExt = null;
    118 
    119         protected static LinkedHashMap<Character, Method> _FrameTags = null;
    120 
    121         public DefaultFrameWriter() {
    122                
    123                 if (_ItemTags != null && _FrameTags != null)
    124                         return;
    125 
    126                 _ItemTags = new LinkedHashMap<Character, Method>();
    127                 _ItemTagsExt = new LinkedHashMap<String, Method>();
    128                 _FrameTags = new LinkedHashMap<Character, Method>();
    129 
     170        private static LinkedHashMap<String, Method> _ItemTagsExt = new LinkedHashMap<String, Method>();
     171
     172        protected static LinkedHashMap<Character, Method> _FrameTags = new LinkedHashMap<Character, Method>();
     173       
     174        {
    130175                try {
    131176                        _FrameTags.put('V', Frame.class.getMethod("getVersion"));
    … …  
    213258                        _ItemTags.put(DefaultFrameWriter.MAGNETIZED_ITEM_BOTTOM, Item.class.getMethod("getMagnetizedItemBottom"));
    214259                       
    215                         _ItemTagsExt.put(DefaultFrameWriter.ENCRYPTION_LABEL, Item.class.getMethod("getEncryptionLabel"));
    216                        
    217                         _ItemTagsExt.put(DefaultFrameWriter.PLACEHOLDER, Text.class.getMethod("getPlaceholder"));
    218                         _ItemTagsExt.put(DefaultFrameWriter.SINGLE_LINE_ONLY, Text.class.getMethod("isSingleLineOnly"));
    219                         _ItemTagsExt.put(DefaultFrameWriter.TAB_INDEX, Text.class.getMethod("getTabIndex"));
     260                        _ItemTagsExt.put(DefaultFrameWriter.ENCRYPTION_LABEL_STR, Item.class.getMethod("getEncryptionLabel"));
     261                       
     262                        _ItemTagsExt.put(DefaultFrameWriter.PLACEHOLDER_STR, Text.class.getMethod("getPlaceholder"));
     263                        _ItemTagsExt.put(DefaultFrameWriter.SINGLE_LINE_ONLY_STR, Text.class.getMethod("isSingleLineOnly"));
     264                        _ItemTagsExt.put(DefaultFrameWriter.TAB_INDEX_STR, Text.class.getMethod("getTabIndex"));
    220265                } catch (Exception e) {
    221266                        e.printStackTrace();
    222267                }
     268        }
     269
     270        public DefaultFrameWriter() {
     271               
     272
    223273        }
    224274

  • trunk/src/org/expeditee/items/Item.java

    r1412 r1413  
    4848import org.expeditee.core.bounds.PolygonBounds;
    4949import org.expeditee.encryption.items.surrogates.EncryptionDetail;
    50 import org.expeditee.encryption.items.surrogates.Surrogate;
     50//import org.expeditee.encryption.items.surrogates.Surrogate;
    5151import org.expeditee.gio.EcosystemManager;
    5252import org.expeditee.gio.GraphicsManager;
    … …  
    319319
    320320        private Item surrogateFor = null;
    321         private Set<Surrogate> surrogateItems = new HashSet<Surrogate>();
    322         private Map<String, EncryptionDetail> propertyEncryption = new HashMap<String, EncryptionDetail>();
     321        private Set<Item> surrogateItems = new HashSet<Item>();
     322        private static Map<String, EncryptionDetail> classicPropertyEncryptionDefault = new HashMap<String, EncryptionDetail>();
     323        private static Map<String, Boolean> surrogatePropertyInheritanceDefault = new HashMap<String, Boolean>();
     324        protected Map<String, EncryptionDetail> classicPropertyEncryption = new HashMap<String, EncryptionDetail>(classicPropertyEncryptionDefault);
     325        protected Map<String, Boolean> surrogatePropertyInheritance = new HashMap<String, Boolean>(surrogatePropertyInheritanceDefault);
     326       
     327        {
     328                for(Character tag: DefaultFrameWriter.getItemTags().keySet()) {
     329                        if (tag == 'T' || tag == 'S') {
     330                                surrogatePropertyInheritanceDefault.put(tag + "", false);
     331                        } else {
     332                                surrogatePropertyInheritanceDefault.put(tag + "", true);
     333                        }
     334                        classicPropertyEncryptionDefault.put(tag + "", EncryptionDetail.UnencryptedOnSave);
     335                }
     336               
     337                for(String tag: DefaultFrameWriter.getItemTagsExt().keySet()) {
     338                        surrogatePropertyInheritanceDefault.put(tag, true);
     339                        classicPropertyEncryptionDefault.put(tag, EncryptionDetail.UnencryptedOnSave);
     340                }
     341        }
    323342       
    324343        /** Just calls source.duplicateOnto(dest). */
    … …  
    415434                _type = type;
    416435                invalidateAll();
     436                if (isSurrogate()) {
     437                        surrogatePropertyInheritance.put(DefaultFrameWriter.DOT_TYPE_STR, false);
     438                        Item classic = getClassic();
     439                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.DOT_TYPE_STR)) {
     440                                classic.classicPropertyEncryption.put(DefaultFrameWriter.DOT_TYPE_STR, EncryptionDetail.InheritanceCheckOnSave);
     441                        }
     442                }
    417443        }
    418444
    419445        public DotType getDotType() {
    420                 Surrogate surrogate = Surrogate.of(this);
    421                 if (surrogate != null &&
    422                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.DOT_TYPE + "")) {
     446                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.DOT_TYPE_STR)) {
    423447                        return this.getClassic().getDotType();
    424448                } else {
    … …  
    428452
    429453       
    430         public void setFilled(boolean filled)
    431         {
     454        public void setFilled(boolean filled) {
    432455                invalidateAll();
    433456                _filled = filled;
    434457                invalidateAll();
     458               
     459                if (isSurrogate()) {
     460                        surrogatePropertyInheritance.put(DefaultFrameWriter.FILLED_STR, false);
     461                        Item classic = getClassic();
     462                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.DOT_TYPE_STR)) {
     463                                classic.classicPropertyEncryption.put(DefaultFrameWriter.FILLED_STR, EncryptionDetail.InheritanceCheckOnSave);
     464                        }
     465                }
    435466        }
    436467
    437468        public boolean getFilled() {
    438                 Surrogate surrogate = Surrogate.of(this);
    439                 if (surrogate != null &&
    440                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.FILLED + "")) {
     469                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.FILLED_STR)) {
    441470                        return this.getClassic().getFilled();
    442471                } else {
    … …  
    450479         * @param gradientAngle The new angle of colour change.
    451480         */
    452         public void setGradientAngle(double gradientAngle)
    453         {
     481        public void setGradientAngle(double gradientAngle) {
    454482                _gradientAngle = gradientAngle;
    455483
    … …  
    461489                invalidateCommonTrait(ItemAppearence.GradientColor);
    462490                invalidateFill();
     491               
     492                if (isSurrogate()) {
     493                        surrogatePropertyInheritance.put(DefaultFrameWriter.GRADIENT_ANGLE_STR, false);
     494                        Item classic = getClassic();
     495                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.DOT_TYPE_STR)) {
     496                                classic.classicPropertyEncryption.put(DefaultFrameWriter.GRADIENT_ANGLE_STR, EncryptionDetail.InheritanceCheckOnSave);
     497                        }
     498                }
    463499        }
    464500
    … …  
    469505         */
    470506        public double getGradientAngle() {
    471                 Surrogate surrogate = Surrogate.of(this);
    472                 if (surrogate != null &&
    473                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.GRADIENT_ANGLE + "")) {
     507                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.GRADIENT_ANGLE_STR)) {
    474508                        return this.getClassic().getGradientAngle();
    475509                } else {
    … …  
    528562                        this.getParent().moveItemToBodyHiddenDueToPermission(this);
    529563                }
     564               
     565                if (isSurrogate()) {
     566                        surrogatePropertyInheritance.put(DefaultFrameWriter.PERMISSION_STR, false);
     567                        Item classic = getClassic();
     568                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.DOT_TYPE_STR)) {
     569                                classic.classicPropertyEncryption.put(DefaultFrameWriter.PERMISSION_STR, EncryptionDetail.InheritanceCheckOnSave);
     570                        }
     571                }
    530572        }
    531573       
    532574        public PermissionTriple getPermission() {
    533                 Surrogate surrogate = Surrogate.of(this);
    534                 if (surrogate != null &&
    535                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.PERMISSION + "")) {
     575                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.PERMISSION_STR)) {
    536576                        return this.getClassic().getPermission();
    537577                } else {
    … …  
    683723         */
    684724        public List<String> getAction() {
    685                 Surrogate surrogate = Surrogate.of(this);
    686                 if (surrogate != null &&
    687                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.ACTION + "")) {
     725                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ACTION_STR)) {
    688726                        return this.getClassic().getAction();
    689727                } else {
    … …  
    693731
    694732        public List<String> getData() {
    695                 Surrogate surrogate = Surrogate.of(this);
    696                 if (surrogate != null &&
    697                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.DATA + "")) {
     733                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.DATA_STR)) {
    698734                        return this.getClassic().getData();
    699735                } else {
    700                         return _data.getData();
     736                        return  _data.getData();
    701737                }
    702738        }
    703739
    704740        public List<String> getActionCursorEnter() {
    705                 Surrogate surrogate = Surrogate.of(this);
    706                 if (surrogate != null &&
    707                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.ACTION_CURSOR_ENTER + "")) {
     741                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ACTION_CURSOR_ENTER_STR)) {
    708742                        return this.getClassic().getActionCursorEnter();
    709743                } else {
    710                         return _actionCursorEnter;
     744                        return  _actionCursorEnter;
    711745                }
    712746        }
    713747
    714748        public List<String> getActionCursorLeave() {
    715                 Surrogate surrogate = Surrogate.of(this);
    716                 if (surrogate != null &&
    717                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.ACTION_CURSOR_LEAVE + "")) {
     749                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ACTION_CURSOR_LEAVE_STR)) {
    718750                        return this.getClassic().getActionCursorLeave();
    719751                } else {
    720                         return _actionCursorLeave;
     752                        return  _actionCursorLeave;
    721753                }
    722754        }
    723755
    724756        public List<String> getActionEnterFrame() {
    725                 Surrogate surrogate = Surrogate.of(this);
    726                 if (surrogate != null &&
    727                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.ACTION_ENTER_FRAME + "")) {
     757                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ACTION_ENTER_FRAME_STR)) {
    728758                        return this.getClassic().getActionEnterFrame();
    729759                } else {
    730                         return _actionEnterFrame;
     760                        return  _actionEnterFrame;
    731761                }
    732762        }
    733763
    734764        public List<String> getActionLeaveFrame() {
    735                 Surrogate surrogate = Surrogate.of(this);
    736                 if (surrogate != null &&
    737                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.ACTION_LEAVE_FRAME + "")) {
     765                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ACTION_LEAVE_FRAME_STR)) {
    738766                        return this.getClassic().getActionLeaveFrame();
    739767                } else {
    740                         return _actionLeaveFrame;
     768                        return  _actionLeaveFrame;
    741769                }
    742770        }
    743771
    744772        public boolean getActionMark() {
    745                 Surrogate surrogate = Surrogate.of(this);
    746                 if (surrogate != null &&
    747                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.ACTION_MARK + "")) {
     773                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ACTION_MARK_STR)) {
    748774                        return this.getClassic().getActionMark();
    749775                } else {
    750                         return _actionMark;
     776                        return  _actionMark;
    751777                }
    752778        }
    … …  
    770796
    771797        public String getArrow() {
    772                 Surrogate surrogate = Surrogate.of(this);
    773                 if (surrogate != null &&
    774                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.ARROW + "")) {
     798                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ARROW_STR)) {
    775799                        return this.getClassic().getArrow();
    776800                } else {
    … …  
    807831       
    808832        public Colour getBackgroundColor() {
    809                 Surrogate surrogate = Surrogate.of(this);
    810                 if (surrogate != null &&
    811                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.BACKGROUND_COLOR + "")) {
     833                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.BACKGROUND_COLOR_STR)) {
    812834                        return this.getClassic().getBackgroundColor();
    813835                } else {
    814                         return _backgroundColour;
     836                        return  _backgroundColour;
    815837                }
    816838        }
    817839
    818840        public Colour getBorderColor() {
    819                 Surrogate surrogate = Surrogate.of(this);
    820                 if (surrogate != null &&
    821                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.TYPE_AND_ID + "")) {
     841                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.BORDER_COLOR_STR)) {
    822842                        return this.getClassic().getBorderColor();
    823843                } else {
    824                         return _colorBorder;
     844                        return  _colorBorder;
    825845                }
    826846        }
    … …  
    896916
    897917        public Colour getColor() {
    898                 Surrogate surrogate = Surrogate.of(this);
    899                 if (surrogate != null &&
    900                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.COLOR + "")) {
     918                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.COLOR_STR)) {
    901919                        return this.getClassic().getColor();
    902920                } else {
    903                         return _foregroundColour;
     921                        return  _foregroundColour;
    904922                }
    905923        }
    … …  
    915933
    916934        public String getConstraintIDs() {
    917                 Surrogate surrogate = Surrogate.of(this);
    918                 if (surrogate != null &&
    919                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.CONSTRAINT_IDS + "")) {
     935                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.CONSTRAINT_IDS_STR)) {
    920936                        return this.getClassic().getConstraintIDs();
    921937                } else {
    … …  
    954970
    955971        public String getDateCreated() {
    956                 Surrogate surrogate = Surrogate.of(this);
    957                 if (surrogate != null &&
    958                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.DATE_CREATED + "")) {
     972                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.DATE_CREATED_STR)) {
    959973                        return this.getClassic().getDateCreated();
    960974                } else {
    961                         return _creationDate;
     975                        return  _creationDate;
    962976                }
    963977        }
    964978
    965979        public Colour getFillColor() {
    966                 Surrogate surrogate = Surrogate.of(this);
    967                 if (surrogate != null &&
    968                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.FILL_COLOR + "")) {
     980                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.FILL_COLOR_STR)) {
    969981                        return this.getClassic().getFillColor();
    970982                } else {
    971                         return _fillColour;
     983                        return  _fillColour;
    972984                }
    973985        }
    974986
    975987        public String getFillPattern() {
    976                 Surrogate surrogate = Surrogate.of(this);
    977                 if (surrogate != null &&
    978                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.FILL_PATTERN + "")) {
     988                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.FILL_PATTERN_STR)) {
    979989                        return this.getClassic().getFillPattern();
    980990                } else {
    981                         return _fillPattern;
     991                        return  _fillPattern;
    982992                }
    983993        }
    … …  
    9971007         */
    9981008        public boolean getHighlight() {
    999                 Surrogate surrogate = Surrogate.of(this);
    1000                 if (surrogate != null &&
    1001                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.HIGHLIGHT + "")) {
     1009                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.HIGHLIGHT_STR)) {
    10021010                        return this.getClassic().getHighlight();
    10031011                } else {
    1004                         return _highlight;
     1012                        return  _highlight;
    10051013                }
    10061014        }
    … …  
    10311039         */
    10321040        public String getLineIDs() {
    1033                 Surrogate surrogate = Surrogate.of(this);
    1034                 if (surrogate != null &&
    1035                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.LINE_IDS + "")) {
     1041                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.LINE_IDS_STR)) {
    10361042                        return this.getClassic().getLineIDs();
    10371043                } else {
    … …  
    10501056
    10511057        public int[] getLinePattern() {
    1052                 Surrogate surrogate = Surrogate.of(this);
    1053                 if (surrogate != null &&
    1054                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.LINE_PATTERN + "")) {
     1058                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.LINE_PATTERN_STR)) {
    10551059                        return this.getClassic().getLinePattern();
    10561060                } else {
    1057                         return _linePattern;
     1061                        return  _linePattern;
    10581062                }
    10591063        }
    … …  
    10781082         */
    10791083        public String getLink() {
    1080                 Surrogate surrogate = Surrogate.of(this);
    1081                 if (surrogate != null &&
    1082                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.LINK + "")) {
     1084                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.LINK_STR)) {
    10831085                        return this.getClassic().getLink();
    10841086                } else {
    1085                         return _link;
     1087                        return  _link;
    10861088                }
    10871089        }
    10881090
    10891091        public String getFormula() {
    1090                 Surrogate surrogate = Surrogate.of(this);
    1091                 if (surrogate != null &&
    1092                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.FORMULA + "")) {
     1092                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.FORMULA_STR)) {
    10931093                        return this.getClassic().getFormula();
    10941094                } else {
    1095                         return _formula;
     1095                        return  _formula;
    10961096                }
    10971097        }
    … …  
    11071107        }
    11081108
    1109         public void setFormula(String formula)
    1110         {
     1109        public void setFormula(String formula) {
    11111110                _formula = formula;
     1111               
     1112                if (isSurrogate()) {
     1113                        surrogatePropertyInheritance.put(DefaultFrameWriter.FORMULA_STR, false);
     1114                        Item classic = getClassic();
     1115                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.FORMULA_STR)) {
     1116                                classic.classicPropertyEncryption.put(DefaultFrameWriter.FORMULA_STR, EncryptionDetail.InheritanceCheckOnSave);
     1117                        }
     1118                }
    11121119        }
    11131120
    … …  
    11191126
    11201127        public String getLinkFrameset() {
    1121                 Surrogate surrogate = Surrogate.of(this);
    1122                 if (surrogate != null &&
    1123                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.LINK_FRAMESET + "")) {
     1128                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.LINK_FRAMESET_STR)) {
    11241129                        return this.getClassic().getLinkFrameset();
    11251130                } else {
    1126                         return _link_frameset;
     1131                        return  _link_frameset;
    11271132                }
    11281133        }
    11291134
    11301135        public boolean getLinkMark() {
    1131                 Surrogate surrogate = Surrogate.of(this);
    1132                 if (surrogate != null &&
    1133                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.LINK_MARK + "")) {
     1136                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.LINK_MARK_STR)) {
    11341137                        return this.getClassic().getLinkMark();
    11351138                } else {
    1136                         return _linkMark;
     1139                        return  _linkMark;
    11371140                }
    11381141        }
    11391142
    11401143        public String getLinkTemplate() {
    1141                 Surrogate surrogate = Surrogate.of(this);
    1142                 if (surrogate != null &&
    1143                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.LINK_TEMPLATE + "")) {
     1144                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.LINK_TEMPLATE_STR)) {
    11441145                        return this.getClassic().getLinkTemplate();
    11451146                } else {
    1146                         return _link_template;
    1147                 }
    1148         }
    1149 
    1150         // public int getMaxWidth()
    1151         // {
    1152         // return _maxWidth;
    1153         // }
     1147                        return  _link_template;
     1148                }
     1149        }
    11541150
    11551151        public Point getOffset()
    … …  
    11591155
    11601156        public String getOwner() {
    1161                 Surrogate surrogate = Surrogate.of(this);
    1162                 if (surrogate != null &&
    1163                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.OWNER + "")) {
     1157                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.OWNER_STR)) {
    11641158                        return this.getClassic().getOwner();
    11651159                } else {
    1166                         return _owner;
     1160                        return  _owner;
    11671161                }
    11681162        }
    … …  
    12811275        /** Gets the position of this item. */
    12821276        public final Point getPosition() {
    1283                 Surrogate surrogate = Surrogate.of(this);
    1284                 if (surrogate != null &&
    1285                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.POSITION + "")) {
     1277                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.POSITION_STR)) {
    12861278                        return this.getClassic().getPosition();
    12871279                } else {
    … …  
    13131305
    13141306        public String getTypeAndID() {
    1315                 Surrogate surrogate = Surrogate.of(this);
    1316                 if (surrogate != null &&
    1317                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.TYPE_AND_ID + "")) {
     1307                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.TYPE_AND_ID_STR)) {
    13181308                        return this.getClassic().getTypeAndID();
    13191309                } else {
    … …  
    13231313
    13241314        public Integer getWidthToSave() {
    1325                 Surrogate surrogate = Surrogate.of(this);
    1326                 if (surrogate != null &&
    1327                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.WIDTH_TO_SAVE + "")) {
     1315                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.WIDTH_TO_SAVE_STR)) {
    13281316                        return this.getClassic().getWidthToSave();
    13291317                } else {
    … …  
    13331321       
    13341322        public Integer getMinWidthToSave() {
    1335                 Surrogate surrogate = Surrogate.of(this);
    1336                 if (surrogate != null &&
    1337                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.MIN_WIDTH_TO_SAVE + "")) {
     1323                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.MIN_WIDTH_TO_SAVE_STR)) {
    13381324                        return this.getClassic().getMinWidthToSave();
    13391325                } else {
    … …  
    13621348         */
    13631349        public int getX() {
    1364                 Surrogate surrogate = Surrogate.of(this);
    1365                 if (surrogate != null &&
    1366                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.POSITION + "")) {
     1350                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.POSITION_STR)) {
    13671351                        return this.getClassic().getX();
    13681352                } else {
    … …  
    13771361         */
    13781362        public int getY() {
    1379                 Surrogate surrogate = Surrogate.of(this);
    1380                 if (surrogate != null &&
    1381                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.POSITION + "")) {
     1363                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.POSITION_STR)) {
    13821364                        return this.getClassic().getY();
    13831365                } else {
    … …  
    15321514        }
    15331515       
    1534         public void setTooltip(final String tooltip)
    1535         {
     1516        public void setTooltip(final String tooltip) {
    15361517                if(tooltip != null && tooltip.trim().length() > 0) {
    15371518                        _tooltip.addTooltip(tooltip, this);
    15381519                }
     1520               
     1521                if (isSurrogate()) {
     1522                        surrogatePropertyInheritance.put(DefaultFrameWriter.TOOLTIP_STR, false);
     1523                        Item classic = getClassic();
     1524                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.TOOLTIP_STR)) {
     1525                                classic.classicPropertyEncryption.put(DefaultFrameWriter.TOOLTIP_STR, EncryptionDetail.InheritanceCheckOnSave);
     1526                        }
     1527                }
    15391528        }
    15401529       
    15411530        public List<String> getTooltip() {
    1542                 Surrogate surrogate = Surrogate.of(this);
    1543                 if (surrogate != null &&
    1544                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.TOOLTIP + "")) {
     1531                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.TOOLTIP_STR)) {
    15451532                        return this.getClassic().getTooltip();
    15461533                } else {
    … …  
    18241811         *            The lines of code to associate with this Item
    18251812         */
    1826         public void setActions(List<String> actions)
    1827         {
     1813        public void setActions(List<String> actions) {
    18281814                if (actions == null || actions.size() == 0) {
    18291815                        invalidateCommonTrait(ItemAppearence.LinkChanged);
    … …  
    18361822                invalidateBounds();
    18371823                invalidateCommonTrait(ItemAppearence.LinkChanged);
     1824               
     1825                if (isSurrogate()) {
     1826                        surrogatePropertyInheritance.put(DefaultFrameWriter.ACTION_STR, false);
     1827                        Item classic = getClassic();
     1828                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ACTION_STR)) {
     1829                                classic.classicPropertyEncryption.put(DefaultFrameWriter.ACTION_STR, EncryptionDetail.InheritanceCheckOnSave);
     1830                        }
     1831                }
    18381832        }
    18391833
    … …  
    18481842        public void addToData(String dataItem) {
    18491843                _data.addToData(dataItem);
     1844               
     1845                if (isSurrogate()) {
     1846                        surrogatePropertyInheritance.put(DefaultFrameWriter.DATA_STR, false);
     1847                        Item classic = getClassic();
     1848                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.DATA_STR)) {
     1849                                classic.classicPropertyEncryption.put(DefaultFrameWriter.DATA_STR, EncryptionDetail.InheritanceCheckOnSave);
     1850                        }
     1851                }
    18501852        }
    18511853       
    … …  
    18561858        public void setActionCursorEnter(List<String> enter) {
    18571859                _actionCursorEnter = enter;
     1860               
     1861                if (isSurrogate()) {
     1862                        surrogatePropertyInheritance.put(DefaultFrameWriter.ACTION_CURSOR_ENTER_STR, false);
     1863                        Item classic = getClassic();
     1864                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ACTION_CURSOR_ENTER_STR)) {
     1865                                classic.classicPropertyEncryption.put(DefaultFrameWriter.ACTION_CURSOR_ENTER_STR, EncryptionDetail.InheritanceCheckOnSave);
     1866                        }
     1867                }
    18581868        }
    18591869
    18601870        public void setActionCursorLeave(List<String> leave) {
    18611871                _actionCursorLeave = leave;
     1872               
     1873                if (isSurrogate()) {
     1874                        surrogatePropertyInheritance.put(DefaultFrameWriter.ACTION_CURSOR_LEAVE_STR, false);
     1875                        Item classic = getClassic();
     1876                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ACTION_CURSOR_LEAVE_STR)) {
     1877                                classic.classicPropertyEncryption.put(DefaultFrameWriter.ACTION_CURSOR_LEAVE_STR, EncryptionDetail.InheritanceCheckOnSave);
     1878                        }
     1879                }
    18621880        }
    18631881
    18641882        public void setActionEnterFrame(List<String> enter) {
    18651883                _actionEnterFrame = enter;
     1884               
     1885                if (isSurrogate()) {
     1886                        surrogatePropertyInheritance.put(DefaultFrameWriter.ACTION_ENTER_FRAME_STR, false);
     1887                        Item classic = getClassic();
     1888                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ACTION_ENTER_FRAME_STR)) {
     1889                                classic.classicPropertyEncryption.put(DefaultFrameWriter.ACTION_ENTER_FRAME_STR, EncryptionDetail.InheritanceCheckOnSave);
     1890                        }
     1891                }
    18661892        }
    18671893
    18681894        public void setActionLeaveFrame(List<String> leave) {
    18691895                _actionLeaveFrame = leave;
    1870         }
    1871 
    1872         public void setActionMark(boolean val)
    1873         {
     1896               
     1897                if (isSurrogate()) {
     1898                        surrogatePropertyInheritance.put(DefaultFrameWriter.ACTION_LEAVE_FRAME_STR, false);
     1899                        Item classic = getClassic();
     1900                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ACTION_LEAVE_FRAME_STR)) {
     1901                                classic.classicPropertyEncryption.put(DefaultFrameWriter.ACTION_LEAVE_FRAME_STR, EncryptionDetail.InheritanceCheckOnSave);
     1902                        }
     1903                }
     1904        }
     1905
     1906        public void setActionMark(boolean val) {
    18741907                if (!val) invalidateCommonTrait(ItemAppearence.LinkChanged);
    18751908                invalidateBounds();
    18761909                _actionMark = val;
    18771910                if (val) invalidateCommonTrait(ItemAppearence.LinkChanged);
     1911               
     1912                if (isSurrogate()) {
     1913                        surrogatePropertyInheritance.put(DefaultFrameWriter.ACTION_MARK_STR, false);
     1914                        Item classic = getClassic();
     1915                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ACTION_MARK_STR)) {
     1916                                classic.classicPropertyEncryption.put(DefaultFrameWriter.ACTION_MARK_STR, EncryptionDetail.InheritanceCheckOnSave);
     1917                        }
     1918                }
    18781919        }
    18791920
    … …  
    19011942                _arrowheadNibPerc = nib_perc;
    19021943                updateArrowPolygon();
     1944               
     1945                if (isSurrogate()) {
     1946                        surrogatePropertyInheritance.put(DefaultFrameWriter.ARROW_STR, false);
     1947                        Item classic = getClassic();
     1948                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ARROW_STR)) {
     1949                                classic.classicPropertyEncryption.put(DefaultFrameWriter.ARROW_STR, EncryptionDetail.InheritanceCheckOnSave);
     1950                        }
     1951                }
    19031952        }
    19041953
    … …  
    19311980                        invalidateCommonTrait(ItemAppearence.BackgroundColorChanged);
    19321981                }
     1982               
     1983                if (isSurrogate()) {
     1984                        surrogatePropertyInheritance.put(DefaultFrameWriter.BACKGROUND_COLOR_STR, false);
     1985                        Item classic = getClassic();
     1986                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.BACKGROUND_COLOR_STR)) {
     1987                                classic.classicPropertyEncryption.put(DefaultFrameWriter.BACKGROUND_COLOR_STR, EncryptionDetail.InheritanceCheckOnSave);
     1988                        }
     1989                }
    19331990        }
    19341991
    … …  
    19371994                        _colorBorder = c;
    19381995                        invalidateCommonTrait(ItemAppearence.BorderColorChanged);
     1996                }
     1997               
     1998                if (isSurrogate()) {
     1999                        surrogatePropertyInheritance.put(DefaultFrameWriter.BORDER_COLOR_STR, false);
     2000                        Item classic = getClassic();
     2001                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.BORDER_COLOR_STR)) {
     2002                                classic.classicPropertyEncryption.put(DefaultFrameWriter.BORDER_COLOR_STR, EncryptionDetail.InheritanceCheckOnSave);
     2003                        }
    19392004                }
    19402005        }
    … …  
    19702035
    19712036        public void setConstraintIDs(String IDs) {
     2037                if (isSurrogate()) {
     2038                        surrogatePropertyInheritance.put(DefaultFrameWriter.CONSTRAINT_IDS_STR, false);
     2039                        Item classic = getClassic();
     2040                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.CONSTRAINT_IDS_STR)) {
     2041                                classic.classicPropertyEncryption.put(DefaultFrameWriter.CONSTRAINT_IDS_STR, EncryptionDetail.InheritanceCheckOnSave);
     2042                        }
     2043                }
    19722044        }
    19732045
    … …  
    19912063        public void setDateCreated(String date) {
    19922064                _creationDate = date;
     2065               
     2066                if (isSurrogate()) {
     2067                        surrogatePropertyInheritance.put(DefaultFrameWriter.DATE_CREATED_STR, false);
     2068                        Item classic = getClassic();
     2069                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.DATE_CREATED_STR)) {
     2070                                classic.classicPropertyEncryption.put(DefaultFrameWriter.DATE_CREATED_STR, EncryptionDetail.InheritanceCheckOnSave);
     2071                        }
     2072                }
    19932073        }
    19942074
    … …  
    20062086                invalidateCommonTrait(ItemAppearence.FillColor);
    20072087                invalidateFill();
    2008         }
    2009 
    2010         public void setGradientColor(Colour c)
    2011         {
     2088               
     2089                if (isSurrogate()) {
     2090                        surrogatePropertyInheritance.put(DefaultFrameWriter.FILL_COLOR_STR, false);
     2091                        Item classic = getClassic();
     2092                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.FILL_COLOR_STR)) {
     2093                                classic.classicPropertyEncryption.put(DefaultFrameWriter.FILL_COLOR_STR, EncryptionDetail.InheritanceCheckOnSave);
     2094                        }
     2095                }
     2096        }
     2097
     2098        public void setGradientColor(Colour c) {
    20122099                _gradientColour = c;
    20132100
    … …  
    20202107                invalidateCommonTrait(ItemAppearence.GradientColor);
    20212108                invalidateFill();
     2109               
     2110                if (isSurrogate()) {
     2111                        surrogatePropertyInheritance.put(DefaultFrameWriter.GRADIENT_COLOR_STR, false);
     2112                        Item classic = getClassic();
     2113                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.GRADIENT_COLOR_STR)) {
     2114                                classic.classicPropertyEncryption.put(DefaultFrameWriter.GRADIENT_COLOR_STR, EncryptionDetail.InheritanceCheckOnSave);
     2115                        }
     2116                }
    20222117        }
    20232118
    20242119        public Colour getGradientColor() {
    2025                 Surrogate surrogate = Surrogate.of(this);
    2026                 if (surrogate != null &&
    2027                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.GRADIENT_COLOR + "")) {
     2120                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.GRADIENT_COLOR_STR)) {
    20282121                        return this.getClassic().getGradientColor();
    20292122                } else {
    … …  
    20362129                invalidateCommonTrait(ItemAppearence.FillPattern);
    20372130                invalidateFill();
     2131               
     2132                if (isSurrogate()) {
     2133                        surrogatePropertyInheritance.put(DefaultFrameWriter.FILL_PATTERN_STR, false);
     2134                        Item classic = getClassic();
     2135                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.FILL_PATTERN_STR)) {
     2136                                classic.classicPropertyEncryption.put(DefaultFrameWriter.FILL_PATTERN_STR, EncryptionDetail.InheritanceCheckOnSave);
     2137                        }
     2138                }
    20382139        }
    20392140
    … …  
    20502151        public void setHighlight(boolean val) {
    20512152                _highlight = val;
     2153               
     2154                if (isSurrogate()) {
     2155                        surrogatePropertyInheritance.put(DefaultFrameWriter.HIGHLIGHT_STR, false);
     2156                        Item classic = getClassic();
     2157                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.HIGHLIGHT_STR)) {
     2158                                classic.classicPropertyEncryption.put(DefaultFrameWriter.HIGHLIGHT_STR, EncryptionDetail.InheritanceCheckOnSave);
     2159                        }
     2160                }
    20522161        }
    20532162
    … …  
    20612170        public void setID(int newID) {
    20622171                _id = newID;
     2172               
     2173                if (isSurrogate()) {
     2174                        surrogatePropertyInheritance.put(DefaultFrameWriter.TYPE_AND_ID_STR, false);
     2175                        Item classic = getClassic();
     2176                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.TYPE_AND_ID_STR)) {
     2177                                classic.classicPropertyEncryption.put(DefaultFrameWriter.TYPE_AND_ID_STR, EncryptionDetail.InheritanceCheckOnSave);
     2178                        }
     2179                }
    20632180        }
    20642181
    … …  
    20702187         */
    20712188        public void setLineIDs(String lineID) {
     2189                if (isSurrogate()) {
     2190                        surrogatePropertyInheritance.put(DefaultFrameWriter.LINE_IDS_STR, false);
     2191                        Item classic = getClassic();
     2192                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.LINE_IDS_STR)) {
     2193                                classic.classicPropertyEncryption.put(DefaultFrameWriter.LINE_IDS_STR, EncryptionDetail.InheritanceCheckOnSave);
     2194                        }
     2195                }
    20722196        }
    20732197
    … …  
    20772201                for (Line line : getLines())
    20782202                        line.setLinePattern(pattern);
     2203               
     2204                if (isSurrogate()) {
     2205                        surrogatePropertyInheritance.put(DefaultFrameWriter.LINE_PATTERN_STR, false);
     2206                        Item classic = getClassic();
     2207                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.LINE_PATTERN_STR)) {
     2208                                classic.classicPropertyEncryption.put(DefaultFrameWriter.LINE_PATTERN_STR, EncryptionDetail.InheritanceCheckOnSave);
     2209                        }
     2210                }
    20792211        }
    20802212
    … …  
    20942226         *            The name of the Frame to link this item to.
    20952227         */
    2096         public void setLink(String frameName)
    2097         {
     2228        public void setLink(String frameName) {
    20982229                if (frameName == null) invalidateCommonTrait(ItemAppearence.LinkChanged);
    20992230
    … …  
    21102241
    21112242                invalidateCommonTrait(ItemAppearence.LinkChanged);
     2243               
     2244                if (isSurrogate()) {
     2245                        surrogatePropertyInheritance.put(DefaultFrameWriter.LINK_STR, false);
     2246                        Item classic = getClassic();
     2247                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.LINK_STR)) {
     2248                                classic.classicPropertyEncryption.put(DefaultFrameWriter.LINK_STR, EncryptionDetail.InheritanceCheckOnSave);
     2249                        }
     2250                }
    21122251        }
    21132252       
    21142253        public void setLinkHistory(boolean value) {
    21152254                _linkHistory = value;
     2255               
     2256                if (isSurrogate()) {
     2257                        surrogatePropertyInheritance.put(DefaultFrameWriter.LINK_HISTORY_STR, false);
     2258                        Item classic = getClassic();
     2259                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.LINK_HISTORY_STR)) {
     2260                                classic.classicPropertyEncryption.put(DefaultFrameWriter.LINK_HISTORY_STR, EncryptionDetail.InheritanceCheckOnSave);
     2261                        }
     2262                }
    21162263        }
    21172264       
    21182265        public boolean getLinkHistory() {
    2119                 Surrogate surrogate = Surrogate.of(this);
    2120                 if (surrogate != null &&
    2121                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.LINK_HISTORY + "")) {
     2266                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.LINK_HISTORY_STR)) {
    21222267                        return this.getClassic().getLinkHistory();
    21232268                } else {
    … …  
    21342279                }
    21352280                // TODO make this throw exceptions etc...
    2136         }
    2137 
    2138         public void setLinkMark(boolean val)
    2139         {
     2281               
     2282                if (isSurrogate()) {
     2283                        surrogatePropertyInheritance.put(DefaultFrameWriter.LINK_FRAMESET_STR, false);
     2284                        Item classic = getClassic();
     2285                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.LINK_FRAMESET_STR)) {
     2286                                classic.classicPropertyEncryption.put(DefaultFrameWriter.LINK_FRAMESET_STR, EncryptionDetail.InheritanceCheckOnSave);
     2287                        }
     2288                }
     2289        }
     2290
     2291        public void setLinkMark(boolean val) {
    21402292                if (!val) invalidateCommonTrait(ItemAppearence.LinkChanged);
    21412293                invalidateBounds();
    21422294                _linkMark = val;
    21432295                if (val) invalidateCommonTrait(ItemAppearence.LinkChanged);
    2144         }
    2145 
    2146         public void setLinkTemplate(String template)
    2147         {
     2296               
     2297                if (isSurrogate()) {
     2298                        surrogatePropertyInheritance.put(DefaultFrameWriter.LINK_MARK_STR, false);
     2299                        Item classic = getClassic();
     2300                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.LINK_MARK_STR)) {
     2301                                classic.classicPropertyEncryption.put(DefaultFrameWriter.LINK_MARK_STR, EncryptionDetail.InheritanceCheckOnSave);
     2302                        }
     2303                }
     2304        }
     2305
     2306        public void setLinkTemplate(String template) {
    21482307                if (FrameIO.isValidLink(template)) {
    21492308                        _link_template = template;
    … …  
    21522311                }
    21532312                // TODO make this throw exceptions etc...
     2313               
     2314                if (isSurrogate()) {
     2315                        surrogatePropertyInheritance.put(DefaultFrameWriter.LINK_TEMPLATE_STR, false);
     2316                        Item classic = getClassic();
     2317                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.LINK_TEMPLATE_STR)) {
     2318                                classic.classicPropertyEncryption.put(DefaultFrameWriter.LINK_TEMPLATE_STR, EncryptionDetail.InheritanceCheckOnSave);
     2319                        }
     2320                }
    21542321        }
    21552322
    … …  
    21782345        public void setOwner(String own) {
    21792346                _owner = own;
     2347               
     2348                if (isSurrogate()) {
     2349                        surrogatePropertyInheritance.put(DefaultFrameWriter.OWNER_STR, false);
     2350                        Item classic = getClassic();
     2351                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.OWNER_STR)) {
     2352                                classic.classicPropertyEncryption.put(DefaultFrameWriter.OWNER_STR, EncryptionDetail.InheritanceCheckOnSave);
     2353                        }
     2354                }
    21802355        }
    21812356
    … …  
    22582433         *            The new Y coordinate
    22592434         */
    2260         public void setPosition(float x, float y)
    2261         {
     2435        public void setPosition(float x, float y) {
    22622436                float deltaX = x - _x;
    22632437                float deltaY = y - _y;
    … …  
    23632537                invalidateCommonTraitForAll(ItemAppearence.PostMoved);
    23642538
     2539                if (isSurrogate()) {
     2540                        surrogatePropertyInheritance.put(DefaultFrameWriter.POSITION_STR, false);
     2541                        Item classic = getClassic();
     2542                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.POSITION_STR)) {
     2543                                classic.classicPropertyEncryption.put(DefaultFrameWriter.POSITION_STR, EncryptionDetail.InheritanceCheckOnSave);
     2544                        }
     2545                }
    23652546        }
    23662547
    … …  
    23992580        public final void setThickness(float thick) {
    24002581                setThickness(thick, true);
     2582               
     2583                if (isSurrogate()) {
     2584                        surrogatePropertyInheritance.put(DefaultFrameWriter.THICKNESS_STR, false);
     2585                        Item classic = getClassic();
     2586                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.THICKNESS_STR)) {
     2587                                classic.classicPropertyEncryption.put(DefaultFrameWriter.THICKNESS_STR, EncryptionDetail.InheritanceCheckOnSave);
     2588                        }
     2589                }
    24012590        }
    24022591
    … …  
    24512640         */
    24522641        public float getThickness()     {
    2453                 Surrogate surrogate = Surrogate.of(this);
    2454                 if (surrogate != null &&
    2455                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.THICKNESS + "")) {
     2642                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.THICKNESS_STR)) {
    24562643                        return this.getClassic().getThickness();
    24572644                } else {
    … …  
    25052692        public void setX(float newX) {
    25062693                setPosition(newX, getY());
     2694               
     2695                if (isSurrogate()) {
     2696                        surrogatePropertyInheritance.put(DefaultFrameWriter.POSITION_STR, false);
     2697                        Item classic = getClassic();
     2698                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.POSITION_STR)) {
     2699                                classic.classicPropertyEncryption.put(DefaultFrameWriter.POSITION_STR, EncryptionDetail.InheritanceCheckOnSave);
     2700                        }
     2701                }
    25072702        }
    25082703
    … …  
    25152710        public void setY(float newY) {
    25162711                setPosition(getX(), newY);
     2712               
     2713                if (isSurrogate()) {
     2714                        surrogatePropertyInheritance.put(DefaultFrameWriter.POSITION_STR, false);
     2715                        Item classic = getClassic();
     2716                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.POSITION_STR)) {
     2717                                classic.classicPropertyEncryption.put(DefaultFrameWriter.POSITION_STR, EncryptionDetail.InheritanceCheckOnSave);
     2718                        }
     2719                }
    25172720        }
    25182721
    … …  
    33133516        }
    33143517
    3315         public void setAnchorLeft(Integer anchor)
    3316         {
     3518        public void setAnchorLeft(Integer anchor) {
    33173519                this._anchoring.setLeftAnchor(anchor);
    33183520                if (anchor != null) {
    … …  
    33203522                    setX(anchor);
    33213523                }
    3322         }
    3323 
    3324         public void setAnchorRight(Integer anchor)
    3325         {
     3524               
     3525                if (isSurrogate()) {
     3526                        surrogatePropertyInheritance.put(DefaultFrameWriter.ANCHOR_LEFT_STR, false);
     3527                        Item classic = getClassic();
     3528                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ANCHOR_LEFT_STR)) {
     3529                                classic.classicPropertyEncryption.put(DefaultFrameWriter.ANCHOR_LEFT_STR, EncryptionDetail.InheritanceCheckOnSave);
     3530                        }
     3531                }
     3532        }
     3533
     3534        public void setAnchorRight(Integer anchor) {
    33263535                this._anchoring.setRightAnchor(anchor);
    33273536                if (anchor != null) {
    … …  
    33293538                        setX(DisplayController.getFramePaintArea().getMaxX() - anchor - getBoundsWidth());
    33303539                }
    3331         }
    3332 
    3333         public void setAnchorTop(Integer anchor)
    3334         {
     3540               
     3541                if (isSurrogate()) {
     3542                        surrogatePropertyInheritance.put(DefaultFrameWriter.ANCHOR_RIGHT_STR, false);
     3543                        Item classic = getClassic();
     3544                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ANCHOR_RIGHT_STR)) {
     3545                                classic.classicPropertyEncryption.put(DefaultFrameWriter.ANCHOR_RIGHT_STR, EncryptionDetail.InheritanceCheckOnSave);
     3546                        }
     3547                }
     3548        }
     3549
     3550        public void setAnchorTop(Integer anchor) {
    33353551                this._anchoring.setTopAnchor(anchor);
    33363552                if (anchor != null) {
    … …  
    33383554                        setY(anchor);
    33393555                }
    3340         }
    3341 
    3342 
    3343         public void setAnchorBottom(Integer anchor)
    3344         {
     3556               
     3557                if (isSurrogate()) {
     3558                        surrogatePropertyInheritance.put(DefaultFrameWriter.ANCHOR_TOP_STR, false);
     3559                        Item classic = getClassic();
     3560                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ANCHOR_TOP_STR)) {
     3561                                classic.classicPropertyEncryption.put(DefaultFrameWriter.ANCHOR_TOP_STR, EncryptionDetail.InheritanceCheckOnSave);
     3562                        }
     3563                }
     3564        }
     3565
     3566
     3567        public void setAnchorBottom(Integer anchor) {
    33453568                this._anchoring.setBottomAnchor(anchor);
    33463569                if (anchor != null) {
    … …  
    33483571                        setY(DisplayController.getFramePaintArea().getMaxY() - anchor);
    33493572                }
     3573               
     3574                if (isSurrogate()) {
     3575                        surrogatePropertyInheritance.put(DefaultFrameWriter.ANCHOR_BOTTOM_STR, false);
     3576                        Item classic = getClassic();
     3577                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ANCHOR_BOTTOM_STR)) {
     3578                                classic.classicPropertyEncryption.put(DefaultFrameWriter.ANCHOR_BOTTOM_STR, EncryptionDetail.InheritanceCheckOnSave);
     3579                        }
     3580                }
    33503581        }
    33513582
    … …  
    33643595
    33653596        public Integer getAnchorLeft() {
    3366                 Surrogate surrogate = Surrogate.of(this);
    3367                 if (surrogate != null &&
    3368                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.ANCHOR_LEFT + "")) {
     3597                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ANCHOR_LEFT_STR)) {
    33693598                        return this.getClassic().getAnchorLeft();
    33703599                } else {
    … …  
    33743603
    33753604        public Integer getAnchorRight() {
    3376                 Surrogate surrogate = Surrogate.of(this);
    3377                 if (surrogate != null &&
    3378                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.ANCHOR_RIGHT + "")) {
     3605                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ANCHOR_RIGHT_STR)) {
    33793606                        return this.getClassic().getAnchorRight();
    33803607                } else {
    … …  
    33843611
    33853612        public Integer getAnchorTop() {
    3386                 Surrogate surrogate = Surrogate.of(this);
    3387                 if (surrogate != null &&
    3388                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.ANCHOR_TOP + "")) {
     3613                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ANCHOR_TOP_STR)) {
    33893614                        return this.getClassic().getAnchorTop();
    33903615                } else {
    … …  
    33943619
    33953620        public Integer getAnchorBottom() {
    3396                 Surrogate surrogate = Surrogate.of(this);
    3397                 if (surrogate != null &&
    3398                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.ANCHOR_BOTTOM + "")) {
     3621                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ANCHOR_BOTTOM_STR)) {
    33993622                        return this.getClassic().getAnchorBottom();
    34003623                } else {
    … …  
    34043627
    34053628        public String getText() {
    3406                 Surrogate surrogate = Surrogate.of(this);
    3407                 if (surrogate != null &&
    3408                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.TEXT + "")) {
     3629                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.TEXT_STR)) {
    34093630                        return this.getClassic().getText();
    34103631                } else {
    … …  
    36463867       
    36473868        public int getMagnetizedItemLeft() {
    3648                 Surrogate surrogate = Surrogate.of(this);
    3649                 if (surrogate != null &&
    3650                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.MAGNETIZED_ITEM_LEFT + "")) {
     3869                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.MAGNETIZED_ITEM_LEFT_STR)) {
    36513870                        return this.getClassic().getMagnetizedItemLeft();
    36523871                } else {
    … …  
    36623881        public void setMagnetizedItemLeft(final int id) {
    36633882                setMagnetizedItemLeft(this.getParent().getItemWithID(id));
     3883               
     3884                if (isSurrogate()) {
     3885                        surrogatePropertyInheritance.put(DefaultFrameWriter.MAGNETIZED_ITEM_LEFT_STR, false);
     3886                        Item classic = getClassic();
     3887                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.MAGNETIZED_ITEM_LEFT_STR)) {
     3888                                classic.classicPropertyEncryption.put(DefaultFrameWriter.MAGNETIZED_ITEM_LEFT_STR, EncryptionDetail.InheritanceCheckOnSave);
     3889                        }
     3890                }
    36643891        }
    36653892       
    36663893        public int getMagnetizedItemRight() {
    3667                 Surrogate surrogate = Surrogate.of(this);
    3668                 if (surrogate != null &&
    3669                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.MAGNETIZED_ITEM_RIGHT + "")) {
     3894                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.MAGNETIZED_ITEM_RIGHT_STR)) {
    36703895                        return this.getClassic().getMagnetizedItemRight();
    36713896                } else {
    … …  
    36813906        public void setMagnetizedItemRight(final int id) {
    36823907                setMagnetizedItemRight(this.getParent().getItemWithID(id));
     3908               
     3909                if (isSurrogate()) {
     3910                        surrogatePropertyInheritance.put(DefaultFrameWriter.MAGNETIZED_ITEM_RIGHT_STR, false);
     3911                        Item classic = getClassic();
     3912                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.MAGNETIZED_ITEM_RIGHT_STR)) {
     3913                                classic.classicPropertyEncryption.put(DefaultFrameWriter.MAGNETIZED_ITEM_RIGHT_STR, EncryptionDetail.InheritanceCheckOnSave);
     3914                        }
     3915                }
    36833916        }
    36843917       
    36853918        public int getMagnetizedItemTop() {
    3686                 Surrogate surrogate = Surrogate.of(this);
    3687                 if (surrogate != null &&
    3688                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.MAGNETIZED_ITEM_TOP + "")) {
     3919                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.MAGNETIZED_ITEM_TOP_STR)) {
    36893920                        return this.getClassic().getMagnetizedItemTop();
    36903921                } else {
    … …  
    37003931        public void setMagnetizedItemTop(final int id) {
    37013932                setMagnetizedItemTop(this.getParent().getItemWithID(id));
     3933               
     3934                if (isSurrogate()) {
     3935                        surrogatePropertyInheritance.put(DefaultFrameWriter.MAGNETIZED_ITEM_TOP_STR, false);
     3936                        Item classic = getClassic();
     3937                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.MAGNETIZED_ITEM_TOP_STR)) {
     3938                                classic.classicPropertyEncryption.put(DefaultFrameWriter.MAGNETIZED_ITEM_TOP_STR, EncryptionDetail.InheritanceCheckOnSave);
     3939                        }
     3940                }
    37023941        }
    37033942       
    37043943        public int getMagnetizedItemBottom() {
    3705                 Surrogate surrogate = Surrogate.of(this);
    3706                 if (surrogate != null &&
    3707                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.MAGNETIZED_ITEM_BOTTOM + "")) {
     3944                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.MAGNETIZED_ITEM_BOTTOM_STR)) {
    37083945                        return this.getClassic().getMagnetizedItemBottom();
    37093946                } else {
    … …  
    37193956        public void setMagnetizedItemBottom(final int id) {
    37203957                setMagnetizedItemBottom(this.getParent().getItemWithID(id));
     3958               
     3959                if (isSurrogate()) {
     3960                        surrogatePropertyInheritance.put(DefaultFrameWriter.MAGNETIZED_ITEM_BOTTOM_STR, false);
     3961                        Item classic = getClassic();
     3962                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.MAGNETIZED_ITEM_BOTTOM_STR)) {
     3963                                classic.classicPropertyEncryption.put(DefaultFrameWriter.MAGNETIZED_ITEM_BOTTOM_STR, EncryptionDetail.InheritanceCheckOnSave);
     3964                        }
     3965                }
    37213966        }
    37223967       
    37233968        public String getEncryptionLabel() {
    3724                 Surrogate surrogate = Surrogate.of(this);
    3725                 if (surrogate != null &&
    3726                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.ENCRYPTION_LABEL + "")) {
     3969                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ENCRYPTION_LABEL_STR)) {
    37273970                        return this.getClassic().getEncryptionLabel();
    37283971                } else {
    … …  
    37343977                this._encryptionLabel = label;
    37353978                if (this.getSurrogates().isEmpty()) {
    3736                         Surrogate surrogate = Surrogate.forItem(this);
    3737                         this.addToSurrogates(surrogate);
    3738                 }
     3979                        Item copy = this.copy();
     3980                        if (copy instanceof Text) {     copy.setText("Encrypted"); }
     3981                        this.addToSurrogates(copy);
     3982                }
     3983               
     3984               
    37393985               
    37403986                for (Character tag: DefaultFrameWriter.getItemTags().keySet()) {
    37413987                        if (tag == 'S') {
    3742                                 propertyEncryption.put(tag + "", EncryptionDetail.UnencryptedOnSave);
     3988                                classicPropertyEncryption.put(tag + "", EncryptionDetail.UnencryptedOnSave);
    37433989                        } else {
    3744                                 propertyEncryption.put(tag + "", EncryptionDetail.ReencryptOnSave);
     3990                                classicPropertyEncryption.put(tag + "", EncryptionDetail.ReencryptOnSave);
     3991                        }
     3992                       
     3993                        for (Item surrogate: this.getSurrogates()) {
     3994                                if (tag == 'T') {
     3995                                        surrogate.surrogatePropertyInheritance.put(tag + "", false);
     3996                                } else {
     3997                                        surrogate.surrogatePropertyInheritance.put(tag + "", true);
     3998                                }
    37453999                        }
    37464000                }
    … …  
    37484002                for (String tag: DefaultFrameWriter.getItemTagsExt().keySet()) {
    37494003                        if (tag == "_el") {
    3750                                 propertyEncryption.put(tag, EncryptionDetail.UnencryptedOnSave);
     4004                                classicPropertyEncryption.put(tag, EncryptionDetail.UnencryptedOnSave);
    37514005                        } else {
    3752                                 propertyEncryption.put(tag, EncryptionDetail.ReencryptOnSave);
    3753                         }
    3754                 }
     4006                                classicPropertyEncryption.put(tag, EncryptionDetail.ReencryptOnSave);
     4007                        }
     4008                       
     4009                        for (Item surrogate: this.getSurrogates()) {
     4010                                surrogate.surrogatePropertyInheritance.put(tag + "", true);
     4011                        }
     4012                }
     4013               
     4014/*              if (isSurrogate()) {
     4015                        surrogatePropertyInheritance.put(DefaultFrameWriter.ENCRYPTION_LABEL_STR, false);
     4016                        Item classic = getClassic();
     4017                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ENCRYPTION_LABEL_STR)) {
     4018                                classic.classicPropertyEncryption.put(DefaultFrameWriter.ENCRYPTION_LABEL_STR, EncryptionDetail.InheritanceCheckOnSave);
     4019                        }
     4020                }*/
    37554021        }
    37564022       
    … …  
    37604026                for (Character tag: DefaultFrameWriter.getItemTags().keySet()) {
    37614027                        if (tag == 'S') {
    3762                                 propertyEncryption.put(tag + "", EncryptionDetail.UnencryptedOnSave);
     4028                                classicPropertyEncryption.put(tag + "", EncryptionDetail.UnencryptedOnSave);
    37634029                        } else {
    3764                                 propertyEncryption.put(tag + "", EncryptionDetail.ReencryptOnSave);
     4030                                classicPropertyEncryption.put(tag + "", EncryptionDetail.ReencryptOnSave);
    37654031                        }
    37664032                }
    … …  
    37684034                for (String tag: DefaultFrameWriter.getItemTagsExt().keySet()) {
    37694035                        if (tag == "_el") {
    3770                                 propertyEncryption.put(tag, EncryptionDetail.UnencryptedOnSave);
     4036                                classicPropertyEncryption.put(tag, EncryptionDetail.UnencryptedOnSave);
    37714037                        } else {
    3772                                 propertyEncryption.put(tag, EncryptionDetail.ReencryptOnSave);
     4038                                classicPropertyEncryption.put(tag, EncryptionDetail.ReencryptOnSave);
    37734039                        }
    37744040                }
    … …  
    38264092        }
    38274093
    3828         public Set<Surrogate> getSurrogates() {
     4094        public Set<Item> getSurrogates() {
    38294095                return surrogateItems;
    38304096        }
    38314097               
    3832         public void setAsSurrogateFor(Item classic) {
     4098        private void setAsSurrogateFor(Item classic) {
    38334099                this.surrogateFor = classic;
    38344100        }
    38354101
    3836         public void addToSurrogates(Surrogate surrogate) {
     4102        public void addToSurrogates(Item surrogate) {
    38374103                this.surrogateItems.add(surrogate);
     4104                surrogate.setAsSurrogateFor(this);
    38384105        }
    38394106       
    … …  
    38474114       
    38484115        public EncryptionDetail getEncryptionDetailForTag(String tag) {
    3849                 EncryptionDetail encryptionDetail = propertyEncryption.get(tag);
     4116                EncryptionDetail encryptionDetail = classicPropertyEncryption.get(tag);
    38504117               
    38514118                if (encryptionDetail == null) {
    … …  
    38574124       
    38584125        public void setEncryptionDetailForTag(String tag, EncryptionDetail encryptionDetail) {
    3859                 propertyEncryption.put(tag, encryptionDetail);
     4126                classicPropertyEncryption.put(tag, encryptionDetail);
     4127        }
     4128       
     4129        public boolean isTagInherited(String tag) {
     4130                return surrogatePropertyInheritance.get(tag);
     4131        }
     4132       
     4133
     4134        /**
     4135         * If when setting a property, we find that the classic has a undeciphered value, when we must containue using that undeciphered value
     4136         * when eventually saving.
     4137         * @return
     4138         */
     4139        protected boolean subjectToInheritanceCheckOnSave(String tag) {
     4140                if (getClassic() == null) return false;
     4141                return getClassic().classicPropertyEncryption.get(tag) != EncryptionDetail.UseUndecipheredValueOnSave;
    38604142        }
    38614143}

  • trunk/src/org/expeditee/items/Text.java

    r1410 r1413  
    4141import org.expeditee.core.bounds.AxisAlignedBoxBounds;
    4242import org.expeditee.core.bounds.PolygonBounds;
    43 import org.expeditee.encryption.items.surrogates.Surrogate;
     43import org.expeditee.encryption.items.surrogates.EncryptionDetail;
    4444import org.expeditee.gio.EcosystemManager;
    4545import org.expeditee.gio.GraphicsManager;
    … …  
    404404                rebuild(true);
    405405                invalidateAll();
     406               
     407                if (isSurrogate()) {
     408                        surrogatePropertyInheritance.put(DefaultFrameWriter.WIDTH_TO_SAVE_STR, false);
     409                        Item classic = getClassic();
     410                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.WIDTH_TO_SAVE_STR)) {
     411                                classic.classicPropertyEncryption.put(DefaultFrameWriter.WIDTH_TO_SAVE_STR, EncryptionDetail.InheritanceCheckOnSave);
     412                        }
     413                }
    406414        }
    407415
    … …  
    419427                rebuild(true);
    420428                invalidateAll();
     429               
     430                if (isSurrogate()) {
     431                        surrogatePropertyInheritance.put(DefaultFrameWriter.MIN_WIDTH_TO_SAVE_STR, false);
     432                        Item classic = getClassic();
     433                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.MIN_WIDTH_TO_SAVE_STR)) {
     434                                classic.classicPropertyEncryption.put(DefaultFrameWriter.MIN_WIDTH_TO_SAVE_STR, EncryptionDetail.InheritanceCheckOnSave);
     435                        }
     436                }
    421437        }
    422438
    … …  
    434450        @Override
    435451        public Integer getWidth() {
    436                 if (_width == null || _width <= 0) {
    437                         return null;
    438                 }
    439 
    440                 return _width;
     452                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.WIDTH_TO_SAVE_STR)) {
     453                        return this.getClassic().getWidth();
     454                } else {
     455                        return _width;
     456                }
    441457        }
    442458
    … …  
    450466
    451467        public Integer getMinWidth() {
    452                 if (_minWidth == null || _minWidth <= 0) {
    453                         return null;
    454                 }
    455                 return _minWidth;
     468                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.MIN_WIDTH_TO_SAVE_STR)) {
     469                        return this.getClassic().getMinWidth();
     470                } else {
     471                        return _minWidth;
     472                }
    456473        }
    457474
    … …  
    465482        @Override
    466483        public Colour getHighlightColor() {
    467                 if (_highlightColour.equals(getPaintBackgroundColor())) {
    468                         return ALTERNATE_HIGHLIGHT;
    469                 }
    470                 return _highlightColour;
     484                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.HIGHLIGHT_STR)) {
     485                        return this.getClassic().getHighlightColor();
     486                } else {
     487                        return _highlightColour;
     488                }
    471489        }
    472490
    … …  
    490508                rebuild(true);
    491509                invalidateAll();
     510               
     511                if (isSurrogate()) {
     512                        surrogatePropertyInheritance.put(DefaultFrameWriter.JUSTIFICATION_STR, false);
     513                        Item classic = getClassic();
     514                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.JUSTIFICATION_STR)) {
     515                                classic.classicPropertyEncryption.put(DefaultFrameWriter.JUSTIFICATION_STR, EncryptionDetail.InheritanceCheckOnSave);
     516                        }
     517                }
    492518        }
    493519
    … …  
    501527         */
    502528        public Justification getJustification() {
    503                 Surrogate surrogate = Surrogate.of(this);
    504                 if (surrogate != null &&
    505                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.JUSTIFICATION + "")) {
     529                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.JUSTIFICATION_STR)) {
    506530                        return ((Text) this.getClassic()).getJustification();
    507531                } else {
    … …  
    665689
    666690                rebuild(true);
     691               
     692                if (isSurrogate()) {
     693                        surrogatePropertyInheritance.put(DefaultFrameWriter.TEXT_STR, false);
     694                        Item classic = getClassic();
     695                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.TEXT_STR)) {
     696                                classic.classicPropertyEncryption.put(DefaultFrameWriter.TEXT_STR, EncryptionDetail.InheritanceCheckOnSave);
     697                        }
     698                }
    667699        }
    668700
    … …  
    12951327
    12961328                invalidateAll();
     1329               
     1330                if (isSurrogate()) {
     1331                        surrogatePropertyInheritance.put(DefaultFrameWriter.FONT_STR, false);
     1332                        Item classic = getClassic();
     1333                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.FONT_STR)) {
     1334                                classic.classicPropertyEncryption.put(DefaultFrameWriter.FONT_STR, EncryptionDetail.InheritanceCheckOnSave);
     1335                        }
     1336                }
    12971337        }
    12981338
    … …  
    13031343         */
    13041344        public Font getFont() {
    1305                 Surrogate surrogate = Surrogate.of(this);
    1306                 if (surrogate != null &&
    1307                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.FONT + "")) {
     1345                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.FONT_STR)) {
    13081346                        return ((Text) this.getClassic()).getFont();
    13091347                } else {
    … …  
    14691507        @Override
    14701508        public String getText() {
    1471                 return _text.toString();
     1509                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.TEXT_STR)) {
     1510                        return this.getClassic().getText();
     1511                } else {
     1512                        return _text.toString();
     1513                }
    14721514        }
    14731515
    … …  
    15071549                _spacing = spacing;
    15081550                invalidateBounds();
     1551               
     1552                if (isSurrogate()) {
     1553                        surrogatePropertyInheritance.put(DefaultFrameWriter.SPACING_STR, false);
     1554                        Item classic = getClassic();
     1555                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.SPACING_STR)) {
     1556                                classic.classicPropertyEncryption.put(DefaultFrameWriter.SPACING_STR, EncryptionDetail.InheritanceCheckOnSave);
     1557                        }
     1558                }
    15091559        }
    15101560
    … …  
    15151565         */
    15161566        public float getSpacing() {
    1517                 Surrogate surrogate = Surrogate.of(this);
    1518                 if (surrogate != null &&
    1519                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.SPACING + "")) {
     1567                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.SPACING_STR)) {
    15201568                        return ((Text) this.getClassic()).getSpacing();
    15211569                } else {
    … …  
    15421590        public void setWordSpacing(int spacing) {
    15431591                _word_spacing = spacing;
     1592               
     1593                if (isSurrogate()) {
     1594                        surrogatePropertyInheritance.put(DefaultFrameWriter.WORD_SPACING_STR, false);
     1595                        Item classic = getClassic();
     1596                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.WORD_SPACING_STR)) {
     1597                                classic.classicPropertyEncryption.put(DefaultFrameWriter.WORD_SPACING_STR, EncryptionDetail.InheritanceCheckOnSave);
     1598                        }
     1599                }
    15441600        }
    15451601
    15461602        public int getWordSpacing() {
    1547                 Surrogate surrogate = Surrogate.of(this);
    1548                 if (surrogate != null &&
    1549                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.WORD_SPACING + "")) {
     1603                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.WORD_SPACING_STR)) {
    15501604                        return ((Text) this.getClassic()).getWordSpacing();
    15511605                } else {
    … …  
    15671621                currentFont.setSpacing(spacing);
    15681622                // setFont(currentFont);
     1623               
     1624                if (isSurrogate()) {
     1625                        surrogatePropertyInheritance.put(DefaultFrameWriter.LETTER_SPACING_STR, false);
     1626                        Item classic = getClassic();
     1627                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.LETTER_SPACING_STR)) {
     1628                                classic.classicPropertyEncryption.put(DefaultFrameWriter.LETTER_SPACING_STR, EncryptionDetail.InheritanceCheckOnSave);
     1629                        }
     1630                }
    15691631        }
    15701632
    … …  
    15741636         */
    15751637        public float getLetterSpacing() {
    1576                 Surrogate surrogate = Surrogate.of(this);
    1577                 if (surrogate != null &&
    1578                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.LETTER_SPACING + "")) {
     1638                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.LETTER_SPACING_STR)) {
    15791639                        return ((Text) this.getClassic()).getLetterSpacing();
    15801640                } else {
    … …  
    15851645        public void setInitialSpacing(float spacing) {
    15861646                _initial_spacing = spacing;
     1647               
     1648                if (isSurrogate()) {
     1649                        surrogatePropertyInheritance.put(DefaultFrameWriter.INITIAL_SPACING_STR, false);
     1650                        Item classic = getClassic();
     1651                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.INITIAL_SPACING_STR)) {
     1652                                classic.classicPropertyEncryption.put(DefaultFrameWriter.INITIAL_SPACING_STR, EncryptionDetail.InheritanceCheckOnSave);
     1653                        }
     1654                }
    15871655        }
    15881656
    15891657        public float getInitialSpacing() {
    1590                 Surrogate surrogate = Surrogate.of(this);
    1591                 if (surrogate != null &&
    1592                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.INITIAL_SPACING + "")) {
     1658                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.INITIAL_SPACING_STR)) {
    15931659                        return ((Text) this.getClassic()).getInitialSpacing();
    15941660                } else {
    … …  
    27952861                invalidateCommonTrait(ItemAppearence.PostMoved);
    27962862                invalidateFill();
     2863               
     2864                if (isSurrogate()) {
     2865                        surrogatePropertyInheritance.put(DefaultFrameWriter.ANCHOR_LEFT_STR, false);
     2866                        Item classic = getClassic();
     2867                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ANCHOR_LEFT_STR)) {
     2868                                classic.classicPropertyEncryption.put(DefaultFrameWriter.ANCHOR_LEFT_STR, EncryptionDetail.InheritanceCheckOnSave);
     2869                        }
     2870                }
    27972871        }
    27982872
    … …  
    28212895                invalidateCommonTrait(ItemAppearence.PostMoved);
    28222896                invalidateFill();
     2897               
     2898                if (isSurrogate()) {
     2899                        surrogatePropertyInheritance.put(DefaultFrameWriter.ANCHOR_RIGHT_STR, false);
     2900                        Item classic = getClassic();
     2901                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ANCHOR_RIGHT_STR)) {
     2902                                classic.classicPropertyEncryption.put(DefaultFrameWriter.ANCHOR_RIGHT_STR, EncryptionDetail.InheritanceCheckOnSave);
     2903                        }
     2904                }
    28232905        }
    28242906
    … …  
    28542936                invalidateCommonTrait(ItemAppearence.PostMoved);
    28552937                invalidateFill();
     2938               
     2939                if (isSurrogate()) {
     2940                        surrogatePropertyInheritance.put(DefaultFrameWriter.ANCHOR_TOP_STR, false);
     2941                        Item classic = getClassic();
     2942                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ANCHOR_TOP_STR)) {
     2943                                classic.classicPropertyEncryption.put(DefaultFrameWriter.ANCHOR_TOP_STR, EncryptionDetail.InheritanceCheckOnSave);
     2944                        }
     2945                }
    28562946        }
    28572947
    … …  
    28922982                invalidateCommonTrait(ItemAppearence.PostMoved);
    28932983                invalidateFill();
     2984               
     2985                if (isSurrogate()) {
     2986                        surrogatePropertyInheritance.put(DefaultFrameWriter.ANCHOR_BOTTOM_STR, false);
     2987                        Item classic = getClassic();
     2988                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ANCHOR_BOTTOM_STR)) {
     2989                                classic.classicPropertyEncryption.put(DefaultFrameWriter.ANCHOR_BOTTOM_STR, EncryptionDetail.InheritanceCheckOnSave);
     2990                        }
     2991                }
    28942992        }
    28952993
    … …  
    30473145
    30483146        public boolean getAutoWrap() {
    3049                 Surrogate surrogate = Surrogate.of(this);
    3050                 if (surrogate != null &&
    3051                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.AUTO_WRAP_TO_SAVE + "")) {
     3147                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.AUTO_WRAP_TO_SAVE_STR)) {
    30523148                        return ((Text) this.getClassic()).getAutoWrap();
    30533149                } else {
    … …  
    30593155        // normally
    30603156        public String getAutoWrapToSave() {
    3061                 if (!_autoWrap) {
     3157                if (!getAutoWrap()) {
    30623158                        return null;
    30633159                }
    … …  
    30673163        public void setAutoWrap(boolean autoWrap) {
    30683164                _autoWrap = autoWrap;
     3165               
     3166                if (isSurrogate()) {
     3167                        surrogatePropertyInheritance.put(DefaultFrameWriter.AUTO_WRAP_TO_SAVE_STR, false);
     3168                        Item classic = getClassic();
     3169                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.AUTO_WRAP_TO_SAVE_STR)) {
     3170                                classic.classicPropertyEncryption.put(DefaultFrameWriter.AUTO_WRAP_TO_SAVE_STR, EncryptionDetail.InheritanceCheckOnSave);
     3171                        }
     3172                }
    30693173        }
    30703174
    … …  
    31893293
    31903294        public Integer getMask() {
    3191                 Surrogate surrogate = Surrogate.of(this);
    3192                 if (surrogate != null &&
    3193                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.MASK + "")) {
     3295                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.MASK_STR)) {
    31943296                        return ((Text) this.getClassic()).getMask();
    31953297                } else {
    3196                         if (_mask == null) {
    3197                                 return null;
    3198                         } else {
    3199                                 return _mask;
    3200                         }
    3201                 }
    3202 
     3298                        return _mask;
     3299                }
    32033300        }
    32043301
    32053302        public void setMask(final Integer c) {
    32063303                _mask = c;
     3304               
     3305                if (isSurrogate()) {
     3306                        surrogatePropertyInheritance.put(DefaultFrameWriter.MASK_STR, false);
     3307                        Item classic = getClassic();
     3308                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.MASK_STR)) {
     3309                                classic.classicPropertyEncryption.put(DefaultFrameWriter.MASK_STR, EncryptionDetail.InheritanceCheckOnSave);
     3310                        }
     3311                }
    32073312        }
    32083313       
    32093314        public String getPlaceholder() {
    3210                 Surrogate surrogate = Surrogate.of(this);
    3211                 if (surrogate != null &&
    3212                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.PLACEHOLDER + "")) {
     3315                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.PLACEHOLDER_STR)) {
    32133316                        return ((Text) this.getClassic()).getPlaceholder();
    32143317                } else {
    … …  
    32223325        public void setPlaceholder(String _placeholder) {
    32233326                this._placeholder = new StringBuffer(_placeholder);
     3327               
     3328                if (isSurrogate()) {
     3329                        surrogatePropertyInheritance.put(DefaultFrameWriter.PLACEHOLDER_STR, false);
     3330                        Item classic = getClassic();
     3331                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.PLACEHOLDER_STR)) {
     3332                                classic.classicPropertyEncryption.put(DefaultFrameWriter.PLACEHOLDER_STR, EncryptionDetail.InheritanceCheckOnSave);
     3333                        }
     3334                }
    32243335        }
    32253336
    … …  
    32353346
    32363347        public boolean isSingleLineOnly() {
    3237                 Surrogate surrogate = Surrogate.of(this);
    3238                 if (surrogate != null &&
    3239                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.SINGLE_LINE_ONLY + "")) {
     3348                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.SINGLE_LINE_ONLY_STR)) {
    32403349                        return ((Text) this.getClassic()).isSingleLineOnly();
    32413350                } else {
    … …  
    32463355        public void setSingleLineOnly(boolean _singleLine) {
    32473356                this._singleLine = _singleLine;
     3357               
     3358                if (isSurrogate()) {
     3359                        surrogatePropertyInheritance.put(DefaultFrameWriter.SINGLE_LINE_ONLY_STR, false);
     3360                        Item classic = getClassic();
     3361                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.SINGLE_LINE_ONLY_STR)) {
     3362                                classic.classicPropertyEncryption.put(DefaultFrameWriter.SINGLE_LINE_ONLY_STR, EncryptionDetail.InheritanceCheckOnSave);
     3363                        }
     3364                }
    32483365        }
    32493366       
    32503367        public int getTabIndex() {
    3251                 Surrogate surrogate = Surrogate.of(this);
    3252                 if (surrogate != null &&
    3253                                 surrogate.isPropertyIsInherited(DefaultFrameWriter.TAB_INDEX + "")) {
     3368                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.TAB_INDEX_STR)) {
    32543369                        return ((Text) this.getClassic()).getTabIndex();
    32553370                } else {
    … …  
    32603375        public void setTabIndex(int index) {
    32613376                this._tabIndex = index;
     3377               
     3378                if (isSurrogate()) {
     3379                        surrogatePropertyInheritance.put(DefaultFrameWriter.TAB_INDEX_STR, false);
     3380                        Item classic = getClassic();
     3381                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.TAB_INDEX_STR)) {
     3382                                classic.classicPropertyEncryption.put(DefaultFrameWriter.TAB_INDEX_STR, EncryptionDetail.InheritanceCheckOnSave);
     3383                        }
     3384                }
    32623385        }
    32633386       
Note: See TracChangeset for help on using the changeset viewer.