Ignore:
Timestamp:
07/24/19 11:23:45 (5 years ago)
Author:
bln4
Message:

Renamed Frame.getItems() to Frame.getSortedItems() to better represent its functionality.

-> org.apollo.ApolloGestureActions
-> org.apollo.ApolloSystem
-> org.expeditee.actions.Actions
-> org.expeditee.actions.Debug
-> org.expeditee.actions.ExploratorySearchActions
-> org.expeditee.actions.JfxBrowserActions
-> org.expeditee.actions.Misc
-> org.expeditee.actions.Navigation
-> org.expeditee.actions.ScriptBase
-> org.expeditee.actions.Simple
-> org.expeditee.agents.ComputeTree
-> org.expeditee.agents.CopyTree
-> org.expeditee.agents.DisplayComet
-> org.expeditee.agents.DisplayTree
-> org.expeditee.agents.DisplayTreeLeaves
-> org.expeditee.agents.GraphFramesetLinks
-> org.expeditee.agents.TreeProcessor
-> org.expeditee.gio.gesture.StandardGestureActions
-> org.expeditee.gui.DisplayController
-> org.expeditee.gui.FrameCreator
-> org.expeditee.gui.FrameIO
-> org.expeditee.io.DefaultTreeWriter
-> org.expeditee.io.JavaWriter
-> org.expeditee.io.PDF2Writer
-> org.expeditee.io.TXTWriter
-> org.expeditee.io.WebParser
-> org.expeditee.io.flowlayout.XGroupItem
-> org.expeditee.items.Dot
-> org.expeditee.items.Item
-> org.expeditee.items.ItemUtils
-> org.expeditee.network.FrameShare
-> org.expeditee.stats.TreeStats


Created ItemsList class to wrap ArrayList<Item>. Frames now use this new class to store its body list (used for display) as well as its primaryBody and surrogateBody.

-> org.expeditee.agents.Format
-> org.expeditee.agents.HFormat
-> org.expeditee.gio.gesture.StandardGestureActions
-> org.expeditee.gui.Frame
-> org.expeditee.gui.FrameUtils


Refactorted Frame.setResort(bool) to Frame.invalidateSorted() to better function how it is intended to with a more accurate name.

-> org.expeditee.agents.Sort


When writing out .exp files and getting attributes to respond to LEFT + RIGHT click, boolean items are by default true. This has always been the case. An ammendment to this is that defaults can now be established.
Also added 'EnterClick' functionality. If cursored over a item with this property and you press enter, it acts as if you have clicked on it instead.

-> org.expeditee.assets.resources-public.framesets.authentication.1.exp to 6.exp
-> org.expeditee.gio.gesture.StandardGestureActions
-> org.expeditee.gio.input.KBMInputEvent
-> org.expeditee.gio.javafx.JavaFXConversions
-> org.expeditee.gio.swing.SwingConversions
-> org.expeditee.gui.AttributeUtils
-> org.expeditee.io.Conversion
-> org.expeditee.io.DefaultFrameWriter
-> org.expeditee.items.Item


Fixed a bug caused by calling Math.abs on Integer.MIN_VALUE returning unexpected result. Due to zero being a thing, you cannot represent Math.abs(Integer.MIN_VALUE) in a Integer object. The solution is to use Integer.MIN_VALUE + 1 instead of Integer.MIN_VALUE.

-> org.expeditee.core.bounds.CombinationBounds
-> org.expeditee.io.flowlayout.DimensionExtent


Recoded the contains function in EllipticalBounds so that intersection tests containing circles work correctly.

-> org.expeditee.core.bounds.EllipticalBounds


Added toString() to PolygonBounds to allow for useful printing during debugging.

-> org.expeditee.core.bounds.PolygonBounds

Implemented Surrogate Mode!

-> org.expeditee.encryption.io.EncryptedExpReader
-> org.expeditee.encryption.io.EncryptedExpWriter
-> org.expeditee.encryption.items.surrogates.EncryptionDetail
-> org.expeditee.encryption.items.surrogates.Label
-> org.expeditee.gui.FrameUtils
-> org.expeditee.gui.ItemsList
-> org.expeditee.items.Item
-> org.expeditee.items.Text


???? Use Integer.MAX_VALUE cast to a float instead of Float.MAX_VALUE. This fixed some bug which I cannot remember.

-> org.expeditee.gio.TextLayoutManager
-> org.expeditee.gio.swing.SwingTextLayoutManager


Improved solution for dealing with the F10 key taking focus away from Expeditee due to it being a assessibility key.

-> org.expeditee.gio.swing.SwingInputManager


Renamed variable visibleItems in FrameGraphics.paintFrame to itemsToPaintCanditates to better represent functional intent.

-> org.expeditee.gui.FrameGraphics


Improved checking for if personal resources exist before recreating them

-> org.expeditee.gui.FrameIO


Repeated messages to message bay now have a visual feedback instead of just a beep. This visual feedback is in the form of a count of the amount of times it has repeated.

-> org.expeditee.gui.MessageBay


Updated comment on the Vector class to explain what vectors are.

-> org.expeditee.gui.Vector


Added constants to represent all of the property keys in DefaultFrameReader and DefaultFrameWriter.

-> org.expeditee.io.DefaultFrameReader
-> org.expeditee.io.DefaultFrameWriter


Updated the KeyList setting to be more heirarcial with how users will store their Secrets.

-> org.expeditee.settings.identity.secrets.KeyList

Location:
trunk/src/org/expeditee/gui
Files:
1 added
10 edited

Legend:

Unmodified
Added
Removed

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

    r1405 r1415  
    1919package org.expeditee.gui;
    2020
     21import java.lang.reflect.Field;
    2122import java.lang.reflect.InvocationTargetException;
    2223import java.lang.reflect.Method;
    … …  
    331332                        _Attrib.put("TabIndex",                         Text.class.getMethod("getTabIndex"),
    332333                                                                                                Text.class.getMethod("setTabIndex", pInt));
     334                        _Attrib.put("EnterClick",                       Item.class.getMethod("acceptsKeyboardEnter"),
     335                                                                                                Item.class.getMethod("setAcceptsEnter", pBool));
    333336                       
    334337                        // Aliases for attribute setting
    … …  
    566569                        sb.deleteCharAt(sb.length() - 1);
    567570                        o = sb.toString();
    568                 } else if (o instanceof Boolean) {
    569                         // true is the default for boolean values
    570                         if (((Boolean) o).booleanValue()) {
    571                                 return null;
     571                } else if (o instanceof Boolean) {     
     572                        try {
     573                                Class<?> parentClass = item.getClass();
     574                                Field defaultValueField = parentClass.getField(a.getter.getName() + "Default");
     575                                boolean defaultValue = defaultValueField.getBoolean(null);
     576                                if (defaultValue == (boolean) o) {
     577                                        return null;
     578                                }
     579                        } catch (IllegalArgumentException e) {
     580                                e.printStackTrace();
     581                        } catch (SecurityException e) {
     582                                e.printStackTrace();
     583                        } catch (NoSuchFieldException e) {
     584                                // true is the default for boolean values when no other default is provided
     585                                if ((boolean) o) {
     586                                        return null;
     587                                }
     588                        } catch (IllegalAccessException e) {
     589                                e.printStackTrace();
    572590                        }
    573591                }

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

    r1329 r1415  
    274274                if (!AuthenticatorBrowser.isAuthenticationRequired() && UserSettings.PublicAndPrivateResources) {
    275275                        String userName = UserSettings.ProfileName.get();
    276                         FrameIO.setupPersonalResources(userName);
     276                        if (!FrameIO.personalResourcesExist(userName)) {
     277                                FrameIO.setupPersonalResources(userName);
     278                        }
    277279                }
    278280                // Listen for save status to display during and after runtime

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

    r1413 r1415  
    583583                        // frames differ.
    584584                        if (getCurrentFrame() != null && !bothSidesHaveSameFrame()) {
    585                                 for (Item i : getCurrentFrame().getItems()) {
     585                                for (Item i : getCurrentFrame().getSortedItems()) {
    586586                                        i.onParentStateChanged(new ItemParentStateChangedEvent(getCurrentFrame(), ItemParentStateChangedEvent.EVENT_TYPE_HIDDEN));
    587587                                }
    … …  
    590590
    591591                        // BROOK : TODO... overlays and loadable widgets
    592                         for (Item i : getCurrentFrame().getItems()) {
     592                        for (Item i : getCurrentFrame().getSortedItems()) {
    593593                                i.onParentStateChanged(new ItemParentStateChangedEvent(getCurrentFrame(), ItemParentStateChangedEvent.EVENT_TYPE_SHOWN));
    594594                        }
    … …  
    671671                        }
    672672
    673                         for (Item i : frame.getItems()) {
     673                        for (Item i : frame.getSortedItems()) {
    674674                                i.onParentStateChanged(new ItemParentStateChangedEvent(frame,
    675675                                                ItemParentStateChangedEvent.EVENT_TYPE_SHOWN));
    … …  
    925925                StandardGestureActions.setHighlightHold(true);
    926926
    927                 for (Item i : frame.getItems()) {
     927                for (Item i : frame.getSortedItems()) {
    928928                        if (i.getLink() != null && i.getAbsoluteLink().toLowerCase().equals(oldFrame)) {
    929929                                if (i.getHighlightMode() != Item.HighlightMode.Normal) {
    … …  
    11311131                } else {
    11321132                        ToggleAudienceMode();
    1133                         ItemUtils.UpdateConnectedToAnnotations(current.getItems());
     1133                        ItemUtils.UpdateConnectedToAnnotations(current.getSortedItems());
    11341134                        for (Overlay o : current.getOverlays()) {
    1135                                 ItemUtils.UpdateConnectedToAnnotations(o.Frame.getItems());
     1135                                ItemUtils.UpdateConnectedToAnnotations(o.Frame.getSortedItems());
    11361136                        }
    11371137                        for (Vector v : current.getVectorsDeep()) {
    1138                                 ItemUtils.UpdateConnectedToAnnotations(v.Frame.getItems());
     1138                                ItemUtils.UpdateConnectedToAnnotations(v.Frame.getSortedItems());
    11391139                        }
    11401140                }
    … …  
    12071207         * This results in the Frame being re-parsed and repainted.
    12081208         */
    1209         public static void ToggleXRayMode()
    1210         {
     1209        public static void ToggleXRayMode()     {
    12111210                // Turn off x-ray mode if it is on
    12121211                if (_audienceMode) {

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

    r1414 r1415  
    7777 *
    7878 */
    79 public class Frame /*implements Cloneable*/ {
     79public class Frame {
    8080       
    8181        /** The frame number to indicate this is a virtual frame. */
    … …  
    126126
    127127        private boolean _isLocal = true;
    128 
    129         private boolean _sorted = true;
    130128       
    131129        /** Whether the frame has changed and therefore needs saving. */
    … …  
    139137        private Stack<History> _redo = new Stack<History>();
    140138
    141         private List<Item> _body = new ArrayList<Item>();
    142         private List<Item> _bodyHiddenDueToPermissions = new ArrayList<Item>();
    143         private List<Item> _surrogates = new ArrayList<Item>();
     139        private ItemsList _body = new ItemsList();
     140        private ItemsList _bodyHiddenDueToPermissions = new ItemsList();
     141        private ItemsList _primaryItemsBody = new ItemsList();
     142        private ItemsList _surrogateItemsBody = new ItemsList();
     143       
     144        //private List<Item> _body = new ArrayList<Item>();
     145        //private List<Item> _bodyHiddenDueToPermissions = new ArrayList<Item>();
     146        //private List<Item> _primaryItemsBody = new ArrayList<Item>();
     147        //private List<Item> _surrogateItemsBody = new ArrayList<Item>();
    144148
    145149        // for drawing purposes
    … …  
    184188        private String _groupFrameName;
    185189        private Frame _groupFrame = null;
     190       
     191        public enum BodyType {
     192                BodyDisplay, PrimaryBody, SurrogateBody;
     193        }
    186194
    187195        /** Default constructor, nothing is set. */
    188196        public Frame() {
    189197        }
    190        
    191 //      public Frame clone() {
    192 //              Frame clone = new Frame();
    193 //              for (Item i: this._body) {
    194 //                      Item copy = i.copy();
    195 //                      copy.setID(i.getID()); 
    196 //                      clone._body.add(copy);
    197 //              }
    198 //              for(Item i: this._bodyHiddenDueToPermissions) {
    199 //                      Item copy = i.copy();
    200 //                      copy.setID(i.getID());
    201 //                      clone._bodyHiddenDueToPermissions.add(i);
    202 //              }
    203 //              if (this._frameName != null) {
    204 //                      clone._frameName = this._frameName.copy();
    205 //              }
    206 //              for(Overlay key: this._overlays.keySet()) {
    207 //                      clone._overlays.put(key, this._overlays.get(key));
    208 //              }
    209 //              for(Vector v: this._vectors) {
    210 //                      clone._vectors.add(v);
    211 //              }
    212 //              for (Item i: this._interactableItems) {
    213 //                      clone._interactableItems.add(i.copy());
    214 //              }
    215 //              for (Item i: this._overlayItems) {
    216 //                      clone._overlayItems.add(i.copy());
    217 //              }
    218 //              for (Item i: this._vectorItems) {
    219 //                      clone._vectorItems.add(i.copy());
    220 //              }
    221 //              clone._frameData = this._frameData;
    222 //              clone._frameset = this._frameset;
    223 //              clone._number = this._number;
    224 //              clone._version = this._version;
    225 //              clone._permissionTriple = this._permissionTriple;
    226 //              clone._owner = this._owner;
    227 //              clone._creationDate = this._creationDate;
    228 //              clone._modifiedUser = this._modifiedUser;
    229 //              clone._modifiedDate = this._modifiedDate;
    230 //              clone._modifiedDatePrecise = this._modifiedDatePrecise;
    231 //              clone._frozenDate = this._frozenDate;
    232 //              clone._background = this._background;
    233 //              clone._foreground = this._foreground;
    234 //              clone.path = this.path;
    235 //              clone._isLocal = this._isLocal;
    236 //              clone._sorted = this._sorted;
    237 //              clone._change = this._change;
    238 //              clone._saved = this._saved;
    239 //              clone._lineCount = this._lineCount;
    240 //              clone._itemCount = this._itemCount;
    241 //              clone._buffer = this._buffer;
    242 //              clone._validBuffer = this._validBuffer;
    243 //              clone._activeTime = (Time) this._activeTime.clone();
    244 //              clone._darkTime = (Time) this._darkTime.clone();
    245 //              clone._dotTemplate = this._dotTemplate.copy();
    246 //             
    247 //              return clone;
    248 //      }
    249 
    250         public boolean isReadOnly()
    251         {
     198
     199        public boolean isReadOnly() {
    252200                return !_frameName.hasPermission(UserAppliedPermission.full) && !_protectionChanged;
    253201        }
    254202
    255         public void reset()
    256         {
     203        public void reset()     {
    257204                refreshItemPermissions(UserAppliedPermission.full);
    258205                resetDot();
    … …  
    403350         * @return The list of Item objects that are on this Frame.
    404351         */
    405         public List<Item> getItems(boolean visible)
    406         {
    407                 if (!_sorted) {
    408                         for(int i = 0; i < _body.size();) {
    409                                 if(_body.get(i) == null) {
    410                                         _body.remove(i);
    411                                 } else {
    412                                         i++;
    413                                 }
    414                         }
    415                         Collections.sort(_body);
    416                         _sorted = true;
    417                 }
    418 
     352        public List<Item> getSortedItems(boolean requireVisible) {
     353                ItemsList listToLoopOver = _body;
     354                listToLoopOver.sort();
     355                return getItems(requireVisible, listToLoopOver);
     356        }
     357       
     358        public List<Item> getItems(boolean requireVisible, ItemsList listToLoopOver) {
    419359                List<Item> items = new ArrayList<Item>();
    420360
    421                 for (Item i : _body) {
     361                for (Item i: listToLoopOver) {
    422362                        if (i == null) {
    423363                                continue;
    424364                        }
    425365                       
    426                         if (i.isVisible() || (!visible && !i.isDeleted())) {
     366                        if (meetsVisibilityRequirements(requireVisible, i)) {
    427367                                items.add(i);
    428368                        }
    … …  
    431371                return items;
    432372        }
    433 
     373       
    434374        /** TODO: Comment. cts16 */
    435         public List<Item> getItems()
    436         {
    437                 return getItems(false);
     375        public List<Item> getSortedItems()
     376        {
     377                return getSortedItems(false);
    438378        }
    439379
    … …  
    443383         * @return True if this frame contains i.
    444384         */
    445         public boolean containsItem(Item i)
    446         {
     385        public boolean containsItem(Item i) {
    447386                if (i == null) {
    448387                        throw new NullPointerException("i");
    449                 }
    450                
     388                }       
    451389                return _body.contains(i);
    452390        }
    … …  
    468406                List<Text> bodyTextItems = new ArrayList<Text>();
    469407               
    470                 for (Item i : getItems(true)) {
     408                for (Item i : getSortedItems(true)) {
    471409                        // only add up normal body text items
    472410                        if ((i instanceof Text) && ((includeAnnotations && !((Text) i).isSpecialAnnotation()) || !i.isAnnotation()) && !i.isLineEnd()) {
    … …  
    483421        {
    484422                Collection<Item> items = new ArrayList<Item>();
    485                 for (Item i : getItems(true)) {
     423                for (Item i : getSortedItems(true)) {
    486424                        // only add up normal body text items
    487425                        if (!i.isAnnotation()) {
    … …  
    505443        public Item getLastNonAnnotationTextItem()
    506444        {
    507                 List<Item> items = getItems();
     445                List<Item> items = getSortedItems();
    508446
    509447                // find the last non-annotation text item
    … …  
    910848         *            The date to set as the last frozen date.
    911849         */
    912         public void setFrozenDate(String date)  {
     850        public void setFrozenDate(String date) {
    913851                _frozenDate = date;
    914852        }
    915853
    916         public void setResort(boolean value)
    917         {
    918                 _sorted = !value;
     854        public void invalidateSorted() {
     855                _body.invalidateSorted();
    919856        }
    920857
    … …  
    925862         *            The Item to add to this Frame.
    926863         */
    927         public void addItem(Item item)
    928         {
     864        public void addItem(Item item) {
    929865                addItem(item, true);
    930866        }
    931867
    932         public void addItem(Item item, boolean recalculate)
    933         {
    934                 if (item == null || item.equals(_frameName) || _body.contains(item)) {
     868        public void addItem(Item item, boolean recalculate)     {
     869                if (item == null) { return; }
     870               
     871                addItem(item, recalculate, _body);
     872                if (item.isSurrogate()) {
     873                        addItem(item, recalculate, _surrogateItemsBody);
     874                } else {
     875                        addItem(item, recalculate, _primaryItemsBody);
     876                }
     877        }
     878       
     879        protected void addItem(Item item, boolean recalculate, ItemsList list) {
     880                if (item == null || item.equals(_frameName) || list.contains(item)) {
    935881                        return;
    936882                }
    … …  
    948894                _itemCount = Math.max(_itemCount, item.getID());
    949895
    950                 _body.add(item);
     896                list.add(item);
    951897                item.setParent(this);
    952898                item.setFloating(false); // esnure that it is anchored
    … …  
    959905                        item.setPosition(item.getPosition());
    960906                }
    961 
    962                 _sorted = false;
     907               
     908                list.invalidateSorted();
    963909
    964910                // item.setMaxWidth(FrameGraphics.getMaxFrameSize().width);
    … …  
    983929        }
    984930       
    985         public void addToSurrogates(Item surrogate) {
    986                 this._surrogates.add(surrogate);
     931        public void addToSurrogatesOnLoad(Item surrogate, Item parent) {
     932                parent.addToSurrogates(surrogate);
    987933        }
    988934
    … …  
    991937                boolean bReparse = false;
    992938               
    993                 for (Item i : getItems()) {
     939                for (Item i : getSortedItems()) {
    994940                        Integer anchorLeft   = i.getAnchorLeft();
    995941                        Integer anchorRight  = i.getAnchorRight();
    … …  
    1039985        }
    1040986
    1041         public void addAllItems(Collection<Item> toAdd)
    1042         {
     987        public void addAllItems(Collection<Item> toAdd) {
     988                addAllItems(toAdd, _body);
     989                addAllItems(toAdd, _primaryItemsBody);
     990        }
     991       
     992        protected void addAllItems(Collection<Item> toAdd, ItemsList list) {
    1043993                for (Item i : toAdd) {
    1044994                        // If an annotation is being deleted clear the annotation list
    … …  
    1047997                        }
    1048998                        // TODO Improve efficiency when addAll is called
    1049                         addItem(i);
    1050                 }
    1051         }
    1052 
    1053         public void removeAllItems(Collection<Item> toRemove)
    1054         {
     999                        addItem(i, true, list);
     1000                }
     1001        }
     1002
     1003        public void removeAllItems(Collection<Item> toRemove) {
    10551004                for (Item i : toRemove) {
    10561005                        // If an annotation is being deleted clear the annotation list
    … …  
    10661015        }
    10671016
    1068         public void removeItem(Item item, boolean recalculate)
    1069         {
     1017        public void removeItem(Item item, boolean recalculate) {
     1018                removeItem(item, recalculate, _body);
     1019                if (item.isSurrogate()) {
     1020                        removeItem(item, recalculate, _surrogateItemsBody);
     1021                } else {
     1022                        removeItem(item, recalculate, _primaryItemsBody);
     1023                }
     1024        }
     1025       
     1026        protected void removeItem(Item item, boolean recalculate, ItemsList toRemoveFrom) {
    10701027                // If an annotation is being deleted clear the annotation list
    10711028                if (item.isAnnotation()) {
    … …  
    10731030                }
    10741031
    1075                 if (_body.remove(item)) {
     1032                if (toRemoveFrom.remove(item)) {
    10761033                        change();
    10771034                        // Remove widgets from the widget list
    … …  
    10981055         * @param type  The type of event that occurred
    10991056         */
    1100         private void addToUndo(Collection<Item> items, History.Type type)
    1101         {
     1057        private void addToUndo(ItemsList items, History.Type type) {
    11021058                if (items.size() < 1) {
    11031059                        return;
    … …  
    11071063        }
    11081064       
    1109         public void addToUndoDelete(Collection<Item> items)
    1110         {
     1065        public void addToUndoDelete(ItemsList items) {
    11111066                addToUndo(items, History.Type.deletion);
    11121067        }
    11131068       
    1114         public void addToUndoMove(Collection<Item> items)
    1115         {
     1069        public void addToUndoMove(ItemsList items) {
    11161070                addToUndo(items, History.Type.movement);
    11171071        }
    … …  
    11471101                break;
    11481102                case movement:
    1149                         List<Item> changed = new LinkedList<Item>(_body);
    1150                         changed.retainAll(undo.items);
     1103                        ItemsList changed = new ItemsList(_body);
     1104                        changed.retainHistory(undo.items);
    11511105                        _redo.push(new History(changed, History.Type.movement));
    11521106                        for(Item i : undo.items) {
    … …  
    12071161                break;
    12081162                case movement:
    1209                         List<Item> changed = new LinkedList<Item>(_body);
    1210                         changed.retainAll(redo.items);
     1163                        ItemsList changed = new ItemsList(_body);
     1164                        changed.retainHistory(redo.items);
    12111165                        _undo.push(new History(changed, History.Type.movement));
    12121166                        for(Item i : redo.items) {
    … …  
    16771631        {
    16781632                for (Overlay o : _overlays.keySet()) {
    1679                         for (Item i : o.Frame.getItems()) {
     1633                        for (Item i : o.Frame.getSortedItems()) {
    16801634                                i.onParentStateChanged(new ItemParentStateChangedEvent(
    16811635                                                                this,
    … …  
    16951649                                _overlays.remove(o);
    16961650                               
    1697                                 for (Item i : f.getItems()) {
     1651                                for (Item i : f.getSortedItems()) {
    16981652                                        _overlayItems.remove(i);
    16991653                                        i.onParentStateChanged(new ItemParentStateChangedEvent(
    … …  
    17881742                }
    17891743
    1790                 List<Item> copies = ItemUtils.CopyItems(toMergeWith.getItems());
     1744                List<Item> copies = ItemUtils.CopyItems(toMergeWith.getSortedItems());
    17911745                copies.remove(toMergeWith.getNameItem());
    17921746
    … …  
    18341788        public void clear(boolean keepAnnotations)
    18351789        {
    1836                 List<Item> newBody = new ArrayList<Item>(0);
     1790                ItemsList newBody = new ItemsList();
    18371791               
    18381792                Item title = getTitleItem();
    … …  
    20101964                // reset attributes
    20111965                dot.setParent(this);
     1966                dot.setOwner(template.getOwner());
    20121967                return dot;
    20131968        }
    … …  
    20181973
    20191974                // check for an updated template...
    2020                 for (Item i : this.getItems()) {
     1975                for (Item i : this.getSortedItems()) {
    20211976                        if (ItemUtils.startsWithTag(i, templateTag)) {
    20221977                                t = (Text) i;
    … …  
    20321987                        t = defaultTemplate;
    20331988                }
    2034 
     1989               
    20351990                // If the item is linked apply any attribute pairs on the child frame
    20361991                String link = t.getAbsoluteLink();
    … …  
    20381993                // need to get link first because copy doesnt copy the link
    20391994                t = t.copy();
     1995                // If the template does not have a owner then it should be set to the current user.
     1996                if (t.getOwner() == null) {
     1997                        t.setOwner(UserSettings.UserName.get());
     1998                }
    20401999                t.setTooltip(null);
    20412000                if (link != null) {
    … …  
    22022161        public boolean moveMouseToTextItem(int index)
    22032162        {
    2204                 List<Item> items = getItems();
     2163                List<Item> items = getSortedItems();
    22052164                int itemsFound = 0;
    22062165                for (int i = 0; i < items.size(); i++) {
    … …  
    22282187        public boolean moveMouseToDefaultLocation()
    22292188        {
    2230                 List<Item> items = getItems();
     2189                List<Item> items = getSortedItems();
    22312190
    22322191                for (Item it : items) {
    … …  
    25272486        public List<Item> getVisibleItems()
    25282487        {
    2529                 return getItems(true);
     2488                return getSortedItems(true);
    25302489        }
    25312490
    … …  
    25592518         * @return the list of items to be saved to a text file
    25602519         */
    2561         public List<Item> getItemsToSave() {
     2520        /*public List<Item> getItemsToSave() {
    25622521                if (!_sorted) {
    25632522                        Collections.sort(_body);
    … …  
    25992558
    26002559                return toSave;
    2601         }
    2602        
    2603         public List<Item> getSurrogateItemsToSave() {
    2604                 List<Item> surrogates = new ArrayList<Item>();
    2605                 _body.forEach(item -> surrogates.addAll(item.getSurrogates()));
    2606                 return surrogates;
     2560        }*/
     2561       
     2562        public List<Item> getItemsToSave() {
     2563                return getItemsToSave(BodyType.PrimaryBody);
     2564        }
     2565       
     2566        public List<Item> getItemsToSave(BodyType type) {
     2567                assert(!type.equals(BodyType.BodyDisplay));
     2568                switch (type) {
     2569                case SurrogateBody:
     2570                        return getItemsToSave(_surrogateItemsBody);
     2571                case BodyDisplay:
     2572                        return getItemsToSave(_body);
     2573                case PrimaryBody:
     2574                default:
     2575                        return getItemsToSave(_primaryItemsBody);
     2576                }
     2577        }
     2578       
     2579        private List<Item> getItemsToSave(ItemsList body) {
     2580                body.sort();
     2581                List<Widget> seenWidgets = new ArrayList<Widget>();
     2582               
     2583                List<Item> toSave = new ArrayList<Item>();
     2584               
     2585                body.removeIf(item -> item.dontSave());
     2586                for (Item item: body) {
     2587                        if (item instanceof WidgetCorner) {
     2588                                // Save the widget source. 
     2589                                // Each widget has multiple WidgetCorner's..ignore them if we already have the source.
     2590                                Widget iw = ((WidgetCorner) item).getWidgetSource();
     2591                                if (seenWidgets.contains(iw)) { continue; }
     2592                                seenWidgets.add(iw);
     2593                                toSave.add(iw.getSource());
     2594                        } else if (item instanceof XRayable) {
     2595                                // XRayable Items have their sources saved.
     2596                                XRayable x = (XRayable) item;
     2597                                toSave.addAll(x.getItemsToSave());
     2598                        } else if (item.hasEnclosures()) {
     2599                                // Deals with Circle objects only?
     2600                                continue;
     2601                        } else {
     2602                                toSave.add(item);
     2603                        }
     2604                }
     2605               
     2606                return toSave;
    26072607        }
    26082608
    … …  
    26232623        }
    26242624
    2625         public Collection<Item> getAllItems()
    2626         {
    2627                 Collection<Item> allItems = new LinkedHashSet<Item>(_body);
     2625        public Collection<Item> getAllItems() {
     2626                ItemsList allItems = new ItemsList(_body);
    26282627               
    26292628                allItems.addAll(_overlayItems);
    26302629                allItems.addAll(_vectorItems);
    2631                 return allItems;
     2630                return allItems.underlying();
    26322631        }
    26332632
    … …  
    26482647                Collection<Text> textItems = new ArrayList<Text>();
    26492648               
    2650                 for (Item i : getItems(true)) {
     2649                for (Item i : getSortedItems(true)) {
    26512650                        // only add up normal body text items
    26522651                        if ((i instanceof Text)) {
    … …  
    26692668        public void recalculate()
    26702669        {
    2671                 for (Item i : getItems()) {
     2670                for (Item i : getSortedItems()) {
    26722671                        if (i.hasFormula() && !i.isAnnotation()) {
    26732672                                i.calculate(i.getFormula());
    … …  
    27002699                Collection<Text> items = new LinkedHashSet<Text>();
    27012700               
    2702                 for (Item i : getItems(true)) {
     2701                for (Item i : getSortedItems(true)) {
    27032702                        // only add up normal body text items
    27042703                        if (i instanceof Text && !i.isAnnotation()) {
    … …  
    27882787        }
    27892788       
    2790         public List<Item> getBodyItemsWithInsufficientPermissions() {
    2791                 return _bodyHiddenDueToPermissions;
     2789        public Collection<Item> getBodyItemsWithInsufficientPermissions() {
     2790                return _bodyHiddenDueToPermissions.underlying();
    27922791        }
    27932792       
    … …  
    28982897                return members;
    28992898        }
     2899       
     2900        public boolean hasSurrogates() {
     2901                return !_surrogateItemsBody.isEmpty();
     2902        }
     2903
     2904        private boolean meetsVisibilityRequirements(boolean requireVisible, Item i) {
     2905                return i.isVisible() || (!requireVisible && !i.isDeleted());
     2906        }
    29002907
    29012908        private static final class History {
    … …  
    29062913                }
    29072914               
    2908                 public final List<Item> items;
     2915                public final ItemsList items;
    29092916               
    29102917                public final Type type;
    29112918               
    2912                 public History(Collection<Item> items, Type type)
     2919                public History(ItemsList changed, Type type)
    29132920                {
    2914                         this.items = new LinkedList<Item>(items);
     2921                        this.items = new ItemsList(changed);
    29152922                        this.type = type;
    29162923                }
    … …  
    29222929                }
    29232930        }
     2931
     2932        protected boolean hasAnnotations() {
     2933                return _annotations != null && _annotations.size() > 0;
     2934        }
     2935
     2936        protected ItemsList getBody() {
     2937                return _body;
     2938        }
     2939        protected ItemsList getPrimaryBody() {
     2940                return _primaryItemsBody;
     2941        }
     2942        protected ItemsList getSurrogateBody() {
     2943                return _surrogateItemsBody;
     2944        }
    29242945}

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

    r1304 r1415  
    276276                _lastX = START_X;
    277277                // Check for @Start
    278                 for (Item it : toUse.getItems()) {
     278                for (Item it : toUse.getSortedItems()) {
    279279                        if (it instanceof Text) {
    280280                                Text t = (Text) it;

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

    r1413 r1415  
    141141                EcosystemManager.getGraphicsManager().clear(backgroundColor);
    142142
    143                 List<Item> visibleItems = new LinkedList<Item>();
     143                List<Item> itemsToPaintCanditates = new LinkedList<Item>();
    144144                List<Widget> paintWidgets;
    145145
    … …  
    147147                        // Add all the items for this frame and any other from other
    148148                        // frames
    149                         visibleItems.addAll(toPaint.getAllItems());
     149                        itemsToPaintCanditates.addAll(toPaint.getAllItems());
    150150                        paintWidgets = toPaint.getAllOverlayWidgets();
    151151                        paintWidgets.addAll(toPaint.getInteractiveWidgets());
    152152                } else {
    153                         visibleItems.addAll(toPaint.getVisibleItems());
    154                         visibleItems.addAll(toPaint.getVectorItems());
     153                        itemsToPaintCanditates.addAll(toPaint.getVisibleItems());
     154                        itemsToPaintCanditates.addAll(toPaint.getVectorItems());
    155155                        paintWidgets = toPaint.getInteractiveWidgets();
    156156                }
    … …  
    181181
    182182                if (clip == null) {
    183                         paintItems = visibleItems;
     183                        paintItems = itemsToPaintCanditates;
    184184                } else {
    185185                        fillOnlyItems = new HashSet<Item>();
    186186                        paintItems = new LinkedList<Item>();
    187                         for (Item i : visibleItems) {
     187                        for (Item i : itemsToPaintCanditates) {
    188188                                if (clip == null || i.isInDrawingArea(clip.getBounds())) {
    189189                                        paintItems.add(i);
    … …  
    201201                // Only paint files and lines once ... between anchored AND free items
    202202                PaintPictures(paintItems, fillOnlyItems, paintedFillsAndLines);
    203                 PaintLines(visibleItems);
     203                PaintLines(itemsToPaintCanditates);
    204204
    205205
    … …  
    380380
    381381                List<Item> toFill = new LinkedList<Item>();
     382               
    382383                for (Item i : toPaint) {
    383384                        // Ignore items that have already been done!

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

    r1406 r1415  
    8888 */
    8989
    90 
    9190public class FrameIO {
    9291
    … …  
    214213        }
    215214       
    216 //      public static void changeParentAndSubFolders(String newFolder) {
    217 //              // Partial Paths.
    218 //              PARENT_FOLDER = newFolder;     
    219 //              String resourcesPublicPath = PARENT_FOLDER + "resources-public" + File.separator;
    220 //              String resourcesPrivateIndividualPath = PARENT_FOLDER + "resources-" + UserSettings.UserName.get() + File.separator;
    221 //
    222 //              // Standard paths.
    223 //              PUBLIC_PATH = PARENT_FOLDER + "public" + File.separator;
    224 //              TRASH_PATH = PARENT_FOLDER + "trash" + File.separator;
    225 //              HELP_PATH = PARENT_FOLDER + "documentation" + File.separator;
    226 //              PROFILE_PATH = PARENT_FOLDER + "profiles" + File.separator;
    227 //              EXPORTS_PATH = PARENT_FOLDER + "exports" + File.separator;
    228 //              STATISTICS_PATH = PARENT_FOLDER + "statistics" + File.separator;
    229 //              LOGS_PATH = PARENT_FOLDER + "logs" + File.separator;
    230 //                             
    231 //             
    232 //              // Conditional paths
    233 //              if (UserSettings.PublicAndPrivateResources) {
    234 //                      // Work with a system of public and private folders
    235 //                     
    236 //                      FONT_PATH = resourcesPublicPath + "fonts" + File.separator;
    237 //                      DICT_PATH = resourcesPublicPath + "dict" + File.separator;
    238 //                      IMAGES_PATH = resourcesPublicPath + "images" + File.separator;
    239 //                      AUDIO_PATH = resourcesPublicPath + "audio" + File.separator;
    240 //                      FRAME_PATH = resourcesPublicPath + "framesets" + File.separator;
    241 //              } else {
    242 //                      FONT_PATH = PARENT_FOLDER + "fonts" + File.separator;
    243 //                      DICT_PATH = PARENT_FOLDER + "dict" + File.separator;
    244 //                      IMAGES_PATH = PARENT_FOLDER + "images" + File.separator;
    245 //                      AUDIO_PATH = PARENT_FOLDER + "audio" + File.separator;
    246 //                      FRAME_PATH = PARENT_FOLDER + "framesets" + File.separator;
    247 //                      DEAD_DROPS_PATH = PARENT_FOLDER + "deaddrops" + File.separator;
    248 //              }
    249 //             
    250 //              if (!UserSettings.PublicAndPrivateResources || (AuthenticatorBrowser.isAuthenticationRequired() && !AuthenticatorBrowser.isAuthenticated())) {
    251 //                     
    252 //                      if (UserSettings.UserName.get().equals(AuthenticatorBrowser.USER_NOBODY)) {
    253 //                              System.err.println("**** FrameIO::changeParentAndSubFolders(): Not setting subfolders for user '"+AuthenticatorBrowser.USER_NOBODY+"'");
    254 //                      }
    255 //                     
    256 //                      // If we are using the old regime, or user.name set to Browser.USER_NOBODY
    257 //                      // => then these paths should not be used.
    258 //                      RESOURCES_PATH = null;
    259 //                      SHARED_FRAMESETS_PATH = null;
    260 //                      RESOURCES_PRIVATE_PATH = null;         
    261 //                      FRAME_PRIVATE_PATH = null;
    262 //                      IMAGES_PRIVATE_PATH = null;
    263 //                      AUDIO_PRIVATE_PATH = null;
    264 //                      CONTACTS_PATH = null;
    265 //                      HELP_PRIVATE_PATH = null;
    266 //                     
    267 //                      if (!UserSettings.PublicAndPrivateResources) {
    268 //                              MESSAGES_PATH = PARENT_FOLDER + "messages" + File.separator;
    269 //                      } else {
    270 //                              MESSAGES_PATH = resourcesPrivateIndividualPath + "messages" + File.separator;
    271 //                      }
    272 //                     
    273 //              } else {
    274 //                      RESOURCES_PATH = resourcesPublicPath + "documentation" + File.separator;
    275 //                      SHARED_FRAMESETS_PATH = resourcesPrivateIndividualPath + "framesets-shared" + File.separator;
    276 //                     
    277 //                      RESOURCES_PRIVATE_PATH = PARENT_FOLDER + "resources-private" + File.separator;
    278 //                      FRAME_PRIVATE_PATH = resourcesPrivateIndividualPath + "framesets" + File.separator;
    279 //                      IMAGES_PRIVATE_PATH = resourcesPrivateIndividualPath + "images" + File.separator;
    280 //                      AUDIO_PRIVATE_PATH = resourcesPrivateIndividualPath + "audio" + File.separator;
    281 //                      CONTACTS_PATH = resourcesPrivateIndividualPath + "contacts" + File.separator;
    282 //                      HELP_PRIVATE_PATH = resourcesPrivateIndividualPath + "documentation" + File.separator;
    283 //                      MESSAGES_PATH = resourcesPrivateIndividualPath + "messages" + File.separator;
    284 //                      MAIL_PATH = resourcesPrivateIndividualPath + "mail" + File.separator;
    285 //                      DEAD_DROPS_PATH = resourcesPrivateIndividualPath + "deaddrops" + File.separator;
    286 //              }
    287 //                     
    288 //             
    289 //              System.err.println("**** FrameIO::changeParentAndSubFolder(): Calling AudioPathManger.changeParentAndSubFolder()");
    290 //              AudioPathManager.changeParentAndSubFolders(newFolder);
    291 //      }
    292        
    293215        // All methods are static, this should not be instantiated
    294216        private FrameIO() {
    … …  
    1001923                template.resetDateCreated();
    1002924
    1003                 for (Item i : template.getItems()) {
     925                for (Item i : template.getSortedItems()) {
    1004926                        if (ItemUtils.startsWithTag(i, ItemUtils.TAG_PARENT)) {
    1005927                                i.setLink(null);
    … …  
    1009931                // do auto shrinking of the title IF not in twin frames mode and the title is not centred
    1010932                Item titleItem = template.getTitleItem();
    1011 
    1012                 if (!DisplayController.isTwinFramesOn() && !Justification.center.equals(((Text)titleItem).getJustification())) {
     933                if (titleItem == null) {
     934                        return template;
     935                }
     936               
     937                boolean titleItemJustified = titleItem == null || !Justification.center.equals(((Text)titleItem).getJustification());
     938                if (!DisplayController.isTwinFramesOn() && titleItemJustified) {
    1013939                        if ((titleItem.getX() + 1) < template.getNameItem().getX()) {
    1014940                                int title_item_xr = titleItem.getX() + titleItem.getBoundsWidth(); // should really be '... -1'
    … …  
    13071233                                EcosystemManager.getMiscManager().beep();
    13081234                        } else if (checkBackup
    1309                                         && ItemUtils.ContainsExactTag(toSave.getItems(),
     1235                                        && ItemUtils.ContainsExactTag(toSave.getSortedItems(),
    13101236                                                        ItemUtils.TAG_BACKUP)) {
    13111237                                SuspendCache();
    … …  
    13381264                                }
    13391265
    1340                                 Item i = ItemUtils.FindExactTag(toSave.getItems(),
     1266                                Item i = ItemUtils.FindExactTag(toSave.getSortedItems(),
    13411267                                                ItemUtils.TAG_BACKUP);
    13421268                                i.setLink(original.getName());
    … …  
    14801406        }
    14811407
    1482         public static Frame CreateNewProfile(String username, Map<String, Setting> initialSettings, Map<String, Consumer<Frame>> toNotifyOnSet) throws InvalidFramesetNameException, ExistingFramesetException  {
     1408        public static Frame CreateNewProfile(String username, Map<String, Setting> initialSettings, Map<String, Consumer<Frame>> toNotifyOnSet) throws InvalidFramesetNameException, ExistingFramesetException {
    14831409                Frame profile = CreateFrameset(username, PROFILE_PATH, true);
    14841410                if (profile != null) {
    … …  
    21102036        }
    21112037       
     2038        public static boolean personalResourcesExist(String username) {
     2039                Path personalResources = Paths.get(FrameIO.PARENT_FOLDER).resolve("resources-" + username);
     2040                File personalResourcesFile = personalResources.toFile();
     2041                boolean directoryExists = personalResourcesFile.exists() && personalResourcesFile.isDirectory();
     2042                return directoryExists;
     2043        }
     2044       
    21122045        public static Path setupPersonalResources(String username) {
    21132046                Path personalResources = Paths.get(FrameIO.PARENT_FOLDER).resolve("resources-" + username);

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

    r1407 r1415  
    6060import org.expeditee.core.bounds.AxisAlignedBoxBounds;
    6161import org.expeditee.core.bounds.PolygonBounds;
     62import org.expeditee.encryption.items.surrogates.Label;
    6263import org.expeditee.gio.EcosystemManager;
    6364import org.expeditee.gio.gesture.StandardGestureActions;
    … …  
    384385                }
    385386
    386                 for (Item i : current.getItems()) {
     387                for (Item i : current.getSortedItems()) {
    387388                        i.setHighlightMode(Item.HighlightMode.None);
    388389                        i.setHighlightColorToDefault();
    … …  
    642643         * @return True if the image was created successfully, false otherwise
    643644         */
    644         private static boolean createPicture(Frame frame, Text txt) {
     645        private static boolean createPicture(Frame frame, Text txt, ItemsList items) {
    645646                // attempt to create the picture
    646647                Picture pic = ItemUtils.CreatePicture(txt);
    … …  
    659660                        return false;
    660661                }
    661                 frame.addItem(pic);
     662                frame.addItem(pic, true, items);
    662663
    663664                return true;
     665        }
     666       
     667        private static boolean createPictureInBody(Frame frame, Text txt) {
     668                return createPicture(frame, txt, frame.getBody());
    664669        }
    665670
    … …  
    678683         * @author Brook Novak
    679684         */
    680         private static boolean createWidget(Frame frame, Text txt) {
     685        private static boolean createWidget(Frame frame, Text txt, ItemsList list) {
    681686
    682687                if (frame == null) {
    … …  
    713718                }
    714719
    715                 frame.removeItem(txt);
    716 
    717                 frame.addAllItems(iw.getItems());
     720                frame.removeItem(txt, true, list);
     721
     722                frame.addAllItems(iw.getItems(), list);
    718723
    719724                return true;
     725        }
     726       
     727        private static boolean createWidgetInBody(Frame frame, Text txt) {
     728                return createWidget(frame, txt, frame.getBody());
    720729        }
    721730
    … …  
    857866                return dirsToAdd;
    858867        }
    859 
    860         public static void Parse(Frame toParse) {
    861                 Parse(toParse, false);
    862         }
    863 
    864         /**
    865          * Checks for any special Annotation items and updates the display as necessary.
    866          * Special Items: Images, overlays, sort.
    867          *
    868          */
    869         public static void Parse(Frame toParse, boolean firstParse) {
    870                 Parse(toParse, firstParse, false);
    871         }
    872 
    873         /**
    874          *
    875          * @param toParse
    876          * @param firstParse
    877          * @param ignoreAnnotations
    878          *            used to prevent infinate loops such as when performing TDFC with
    879          *            an ao tag linked to a frame with an frameImage of a frame which
    880          *            also has an ao tag on it.
    881          */
    882         public static void Parse(Frame toParse, boolean firstParse, boolean ignoreAnnotations) {
    883                 // TODO check why we are getting toParse == null... when profile frame
    884                 // is being created and change the lines below
    885                 if (toParse == null) {
    886                         return;
    887                 }
    888 
    889                 if (firstParse) {
    890                         ItemUtils.EnclosedCheck(toParse.getItems());
    891                 }
    892 
    893                 List<Item> items = toParse.getItems();
    894 
     868       
     869        private static void transformOutOfPlaceItems(Frame toParse, ItemsList toTransform) {
     870                // Get all items from toTransform that have not been marked as deleted.
     871                List<Item> items = toParse.getItems(false, toTransform);
     872               
    895873                // if XRayMode is on, replace pictures with their underlying text
    896874                if (DisplayController.isXRayMode()) {
    … …  
    901879                        for (Item i : items) {
    902880                                if (i instanceof XRayable) {
    903                                         toParse.removeItem(i);
     881                                        toParse.removeItem(i, true, toTransform);
    904882                                        // Show the items
    905883                                        for (Item item : ((XRayable) i).getConnected()) {
    … …  
    908886                                        }
    909887                                } else if (i instanceof WidgetCorner) {
    910                                         toParse.removeItem(i);
     888                                        toParse.removeItem(i, true, toTransform);
    911889                                } else if (i instanceof WidgetEdge) {
    912                                         toParse.removeItem(i);
     890                                        toParse.removeItem(i, true, toTransform);
    913891                                } else if (i.hasFormula()) {
    914892                                        i.setText(i.getFormula());
    … …  
    920898
    921899                        for (Widget iw : widgets) {
    922                                 toParse.addItem(iw.getSource());
    923                         }
    924                 }
    925 
    926                 // Text title = null;
    927                 // Text template = UserSettingsTemplate.copy();
    928 
    929                 List<Overlay> overlays = new ArrayList<Overlay>();
    930                 List<Vector> vectors = new ArrayList<Vector>();
     900                                toParse.addItem(iw.getSource(), true, toTransform);
     901                        }
     902                }
     903
    931904
    932905                // disable reading of cached overlays if in twinframes mode
    … …  
    935908                }
    936909
    937                 // DotType pointtype = DotType.square;
    938                 // boolean filledPoints = true;
    939 
    940                 UserAppliedPermission permission = toParse.getUserAppliedPermission();
    941910                toParse.clearAnnotations();
    942911
    943912                // check for any new overlay items
    944                 for (Item i : toParse.getItems()) {
     913                items = toParse.getItems(false, toTransform);
     914                for (Item i : items) {
    945915                        try {
    946                                 // reset overlay permission
    947                                 i.setOverlayPermission(null);
    948                                 // i.setPermission(permission);
    949916                                if (i instanceof WidgetCorner) {
    950917                                        // TODO improve efficiency so it only updates once... using
    … …  
    952919                                        i.update();
    953920                                } else if (i instanceof Text) {
     921                                        if (!DisplayController.isXRayMode() && i.isAnnotation()) {
     922                                                if (ItemUtils.startsWithTag(i, ItemUtils.TAG_IMAGE, true)) {
     923                                                        if (!i.hasEnclosures()) {
     924                                                                createPicture(toParse, (Text) i, toTransform);
     925                                                        }
     926                                                        // check for frame images
     927                                                } else if (ItemUtils.startsWithTag(i, ItemUtils.TAG_FRAME_IMAGE) && i.getLink() != null
     928                                                                && !i.getAbsoluteLink().equalsIgnoreCase(toParse.getName())) {
     929                                                        XRayable image = null;
     930                                                        if (i.hasEnclosures()) {
     931                                                                // i.setHidden(true);
     932                                                                // image =
     933                                                                // i.getEnclosures().iterator().next();
     934                                                                // image.refresh();
     935                                                        } else {
     936                                                                image = new FrameImage((Text) i, null);
     937                                                        }
     938                                                        // TODO Add the image when creating new
     939                                                        // FrameImage
     940                                                        toParse.addItem(image, true, toTransform);
     941                                                } else if (ItemUtils.startsWithTag(i, ItemUtils.TAG_BITMAP_IMAGE) && i.getLink() != null
     942                                                                && !i.getAbsoluteLink().equalsIgnoreCase(toParse.getName())) {
     943                                                        XRayable image = null;
     944                                                        if (i.hasEnclosures()) {
     945                                                                // image =
     946                                                                // i.getEnclosures().iterator().next();
     947                                                                // image.refresh();
     948                                                                // i.setHidden(true);
     949                                                        } else {
     950                                                                // If a new bitmap is created for a
     951                                                                // frame which already has a bitmap dont
     952                                                                // recreate the bitmap
     953                                                                image = new FrameBitmap((Text) i, null);
     954                                                        }
     955                                                        toParse.addItem(image, true, toTransform);
     956                                                } else if (ItemUtils.startsWithTag(i, "@c")) {
     957                                                        // Can only have a @c
     958                                                        if (!i.hasEnclosures() && i.getLines().size() == 1) {
     959                                                                Circle circle = new Circle((Text) i);
     960                                                                toParse.addItem(circle, true, toTransform);
     961                                                        }
     962                                                        // Check for JSItem
     963                                                } else if (ItemUtils.startsWithTag(i, "@js")) {
     964                                                        JSItem jsItem = new JSItem((Text) i);
     965                                                        toParse.addItem(jsItem, true, toTransform);
     966                                                        // Check for interactive widgets
     967                                                } else if (ItemUtils.startsWithTag(i, ItemUtils.TAG_IWIDGET)) {
     968                                                        createWidget(toParse, (Text) i, toTransform);
     969                                                }
     970
     971                                                // TODO decide exactly what to do here!!
     972                                                toParse.addAnnotation((Text) i);
     973                                        } else if (!DisplayController.isXRayMode() && i.hasFormula()) {
     974                                                i.calculate(i.getFormula());
     975                                        }
     976                                }
     977                        } catch (Exception e) {
     978                                Logger.Log(e);
     979                                e.printStackTrace();
     980                                System.err
     981                                                .println("**** Have temporarily supressed MessageBay call, as resulted in infinite recursion");
     982                                // MessageBay.warningMessage("Exception occured when loading " +
     983                                // i.getClass().getSimpleName() + "(ID: "
     984                                // + i.getID() + ") " + e.getMessage() != null ? e.getMessage() : "");
     985                        }
     986                }
     987
     988                /*
     989                 * for (Item i : items) { if (i instanceof Dot) { ((Dot)
     990                 * i).setPointType(pointtype); ((Dot) i).useFilledPoints(filledPoints); } }
     991                 */
     992
     993                if (DisplayController.isTwinFramesOn()) {
     994                        FrameIO.ResumeCache();
     995                }
     996
     997
     998        }
     999       
     1000        private static void generatingSupportingItems(Frame toParse,
     1001                        ItemsList toBuildOff, boolean ignoreAnnotations) {
     1002                // Get all items from toBuildOff that have not been marked as deleted.
     1003                List<Item> items = toParse.getItems(false, toBuildOff);
     1004
     1005                List<Overlay> overlays = new ArrayList<Overlay>();
     1006                List<Vector> vectors = new ArrayList<Vector>();
     1007
     1008                // disable reading of cached overlays if in twinframes mode
     1009                if (DisplayController.isTwinFramesOn()) {
     1010                        FrameIO.SuspendCache();
     1011                }
     1012
     1013                UserAppliedPermission permission = toParse.getUserAppliedPermission();
     1014                // check for any new overlay items
     1015                for (Item i : items) {
     1016                        try {
     1017                                // reset overlay permission
     1018                                i.setOverlayPermission(null);
     1019                                if (i instanceof Text) {
    9541020                                        if (i.isAnnotation()) {
    955                                                 if (ItemUtils.startsWithTag(i, ItemUtils.TAG_POINTTYPE)) {
    956                                                         Text txt = (Text) i;
    957                                                         String line = txt.getFirstLine();
    958                                                         line = ItemUtils.StripTag(line, ItemUtils.GetTag(ItemUtils.TAG_POINTTYPE));
    959 
    960                                                         if (line != null) {
    961                                                                 line = line.toLowerCase();
    962                                                                 if (line.indexOf(" ") > 0) {
    963                                                                         String fill = line.substring(line.indexOf(" ") + 1);
    964                                                                         if (fill.startsWith("nofill")) {
    965                                                                                 // filledPoints = false;
    966                                                                         } else {
    967                                                                                 // filledPoints = true;
    968                                                                         }
    969                                                                 }
    970 
    971                                                                 if (line.startsWith("circle")) {
    972                                                                         // pointtype = DotType.circle;
    973                                                                 } else {
    974                                                                         // pointtype = DotType.square;
    975                                                                 }
    976                                                         }
    977                                                 } // check for new VECTOR items
    978                                                 else if (!DisplayController.isXRayMode() && ItemUtils.startsWithTag(i, ItemUtils.TAG_VECTOR)
     1021                                                if (!DisplayController.isXRayMode() && ItemUtils.startsWithTag(i, ItemUtils.TAG_VECTOR)
    9791022                                                                && i.getLink() != null) {
    9801023                                                        if (!i.getAbsoluteLink().equals(toParse.getName())) {
    … …  
    10471090                                                        }
    10481091                                                }
    1049                                                 // check for Images and widgets
    1050                                                 else {
    1051                                                         if (!DisplayController.isXRayMode()) {
    1052                                                                 if (ItemUtils.startsWithTag(i, ItemUtils.TAG_IMAGE, true)) {
    1053                                                                         if (!i.hasEnclosures()) {
    1054                                                                                 createPicture(toParse, (Text) i);
    1055                                                                         }
    1056                                                                         // check for frame images
    1057                                                                 } else if (ItemUtils.startsWithTag(i, ItemUtils.TAG_FRAME_IMAGE) && i.getLink() != null
    1058                                                                                 && !i.getAbsoluteLink().equalsIgnoreCase(toParse.getName())) {
    1059                                                                         XRayable image = null;
    1060                                                                         if (i.hasEnclosures()) {
    1061                                                                                 // i.setHidden(true);
    1062                                                                                 // image =
    1063                                                                                 // i.getEnclosures().iterator().next();
    1064                                                                                 // image.refresh();
    1065                                                                         } else {
    1066                                                                                 image = new FrameImage((Text) i, null);
    1067                                                                         }
    1068                                                                         // TODO Add the image when creating new
    1069                                                                         // FrameImage
    1070                                                                         toParse.addItem(image);
    1071                                                                 } else if (ItemUtils.startsWithTag(i, ItemUtils.TAG_BITMAP_IMAGE) && i.getLink() != null
    1072                                                                                 && !i.getAbsoluteLink().equalsIgnoreCase(toParse.getName())) {
    1073                                                                         XRayable image = null;
    1074                                                                         if (i.hasEnclosures()) {
    1075                                                                                 // image =
    1076                                                                                 // i.getEnclosures().iterator().next();
    1077                                                                                 // image.refresh();
    1078                                                                                 // i.setHidden(true);
    1079                                                                         } else {
    1080                                                                                 // If a new bitmap is created for a
    1081                                                                                 // frame which already has a bitmap dont
    1082                                                                                 // recreate the bitmap
    1083                                                                                 image = new FrameBitmap((Text) i, null);
    1084                                                                         }
    1085                                                                         toParse.addItem(image);
    1086                                                                 } else if (ItemUtils.startsWithTag(i, "@c")) {
    1087                                                                         // Can only have a @c
    1088                                                                         if (!i.hasEnclosures() && i.getLines().size() == 1) {
    1089                                                                                 toParse.addItem(new Circle((Text) i));
    1090                                                                         }
    1091                                                                         // Check for JSItem
    1092                                                                 } else if (ItemUtils.startsWithTag(i, "@js")) {
    1093                                                                         toParse.addItem(new JSItem((Text) i));
    1094                                                                         // Check for interactive widgets
    1095                                                                 } else if (ItemUtils.startsWithTag(i, ItemUtils.TAG_IWIDGET)) {
    1096                                                                         createWidget(toParse, (Text) i);
    1097                                                                 }
    1098                                                         }
    1099                                                         // TODO decide exactly what to do here!!
    1100                                                         toParse.addAnnotation((Text) i);
    1101                                                 }
    1102                                         } else if (!DisplayController.isXRayMode() && i.hasFormula()) {
    1103                                                 i.calculate(i.getFormula());
     1092                                               
    11041093                                        }
    11051094                                }
    … …  
    11181107                 */
    11191108
    1120                 FrameIO.ResumeCache();
     1109                if (DisplayController.isTwinFramesOn()) {
     1110                        FrameIO.ResumeCache();
     1111                }
    11211112
    11221113                toParse.clearOverlays();
    … …  
    11241115                toParse.addAllOverlays(overlays);
    11251116                toParse.addAllVectors(vectors);
    1126 
     1117        }
     1118
     1119        public static void Parse(Frame toParse) {
     1120                Parse(toParse, false);
     1121        }
     1122
     1123        /**
     1124         * Checks for any special Annotation items and updates the display as necessary.
     1125         * Special Items: Images, overlays, sort.
     1126         *
     1127         */
     1128        public static void Parse(Frame toParse, boolean firstParse) {
     1129                Parse(toParse, firstParse, false);
     1130        }
     1131
     1132        /**
     1133         *
     1134         * @param toParse
     1135         * @param firstParse
     1136         * @param ignoreAnnotations
     1137         *            used to prevent infinate loops such as when performing TDFC with
     1138         *            an ao tag linked to a frame with an frameImage of a frame which
     1139         *            also has an ao tag on it.
     1140         */     
     1141        public static void Parse(Frame toParse, boolean firstParse, boolean ignoreAnnotations) {
     1142                List<String> accessList = Label.getAccessibleLabelsNames(new ItemsList(toParse.getPrimaryBody()));
     1143               
     1144                ItemsList primaries = toParse.getPrimaryBody();
     1145                ItemsList surrogates = toParse.getSurrogateBody();
     1146               
     1147                transformOutOfPlaceItems(toParse, primaries);
     1148                transformOutOfPlaceItems(toParse, surrogates);
     1149               
     1150                toParse.getInteractableItems().clear();
     1151                List<Item> newBody = parseFromPrimary(primaries, accessList);
     1152                toParse.getBody().clear();
     1153                toParse.getBody().addAll(newBody);
     1154                generatingSupportingItems(toParse, toParse.getBody(), ignoreAnnotations);
     1155               
     1156                if (firstParse) {
     1157                        ItemUtils.EnclosedCheck(toParse.getSortedItems());
     1158                }
     1159        }
     1160
     1161        private static List<Item> parseFromPrimary(ItemsList primaryBody, List<String> access) {
     1162                List<Item> parsedBody = new ArrayList<Item>();
     1163               
     1164                for (Item item: primaryBody) {
     1165                        String encryptionLabel = item.getEncryptionLabel();
     1166                        if (encryptionLabel == null || encryptionLabel.isEmpty()) {
     1167                                parsedBody.add(item);
     1168                        } else if (access.contains(encryptionLabel)) {
     1169                                parsedBody.add(item);
     1170                        } else {
     1171                                parsedBody.addAll(item.getSurrogates());
     1172                        }
     1173                }
     1174               
     1175                return parsedBody;
    11271176        }
    11281177
    … …  
    12251274                                if (LastEdited.contains(x, y) && !FreeItems.getInstance().contains(LastEdited)
    12261275                                                && LastEdited.getParent() == DisplayController.getCurrentFrame()
    1227                                                 && LastEdited.getParent().getItems().contains(LastEdited)) {
     1276                                                && LastEdited.getParent().getSortedItems().contains(LastEdited)) {
    12281277                                        LastEdited.setOverlayPermission(UserAppliedPermission.full);
    12291278                                        return LastEdited;
    … …  
    14121461                        return null;
    14131462                }
    1414                 List<Item> items = current.getItems();
     1463                List<Item> items = current.getSortedItems();
    14151464
    14161465                // Remove all items that are connected to freeItems
    … …  
    15721621                        MessageBay.suppressMessages(true);
    15731622                        int lastNumber = FrameIO.getLastNumber(defaultFrame.getFramesetName());
    1574                         for (int i = 1; i <= lastNumber; i++) {
     1623                        for (int i = 1; i <= lastNumber; i++) {                         
    15751624                                // Load in next default, if it doesn't exist continue loop.
    15761625                                defaultFrame = FrameIO.LoadFrame(defaultFrame.getFramesetName() + i);
    … …  
    16701719                                                Frame indexFrame = FrameIO.LoadFrame(framesetName + '1');
    16711720                                                // Look through the folder for help index pages
    1672                                                 if (indexFrame != null && ItemUtils.FindTag(indexFrame.getItems(), "@HelpIndex") != null) {
     1721                                                if (indexFrame != null && ItemUtils.FindTag(indexFrame.getSortedItems(), "@HelpIndex") != null) {
    16731722                                                        // yPos += spacing;
    16741723                                                        yPos += 30;

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

    r1314 r1415  
    279279
    280280                if (!displayAlways && message.equals(_lastMessage)) {
     281                        Item lastMessage = _messages.get(_messages.size() - 1);
     282                        String text = lastMessage.getText();
     283                        if (text.endsWith("}")) {
     284                                int startOfRepeat = text.lastIndexOf("{");
     285                                String repeatString = text.substring(startOfRepeat);
     286                                repeatString = repeatString.substring(1, repeatString.length() - 1);
     287                                try {
     288                                        int repeatCount = Integer.parseInt(repeatString) + 1;
     289                                        text = text.substring(0, startOfRepeat).trim() + " {" + repeatCount + "}";
     290                                } catch (NumberFormatException e) {
     291                                        e.printStackTrace();
     292                                }
     293                        } else {
     294                                text = text.trim() + " {2}";
     295                        }
     296                        lastMessage.setText(text);
    281297                        DisplayController.DisableMailMode();
    282                         Misc.beep();
    283298                        return null;
    284299                }

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

    r1144 r1415  
    2828
    2929/**
    30  * TODO: Explain WTF this is. cts16
     30 * A vector is a type of overlay with additional features:
     31 *      - a location (origin)
     32 *  - size (scaled from frame)
     33 *  - etc
    3134 */
    3235public class Vector extends Overlay {
Note: See TracChangeset for help on using the changeset viewer.