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/gio
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/org/expeditee/gio/InputManager.java

    r1164 r1415  
    306306        protected final void distributeInputEvent(InputEvent event)
    307307        {
     308//              if (event instanceof KBMInputEvent) {
     309//                      KBMInputEvent kEvent = (KBMInputEvent) event;
     310//                      if (kEvent.getKeyDown() != null) {
     311//                              System.err.println("distributeInputEvent:::" + kEvent.toString());
     312//                      }
     313//              }
     314               
    308315                // Allow listeners to optionally consume input before gesture translation
    309316                for (InputEventListener listener : _inputEventListeners) {

  • trunk/src/org/expeditee/gio/TextLayoutManager.java

    r1150 r1415  
    6868        public float getLineWidth(Point p, Line[] lines)
    6969        {
    70                 float width = Float.MAX_VALUE;
     70                float width = (float) Integer.MAX_VALUE;
    7171                for(Line l : lines) {
    7272                        // check for lines that cross over our y

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

    r1413 r1415  
    77import org.expeditee.gio.EcosystemManager;
    88import org.expeditee.gio.TimeoutQueue.TimeoutHandle;
     9import org.expeditee.gio.gesture.Gesture.GestureType;
    910import org.expeditee.gio.gesture.StandardGestureActions.StandardGestureType;
    1011import org.expeditee.gio.gesture.data.ChangeColourGestureData;
    … …  
    100101                                        return null;
    101102                                }
     103                               
    102104                                //System.err.println("ExpediteeKBMGestureTranslator::" + details() + ": " + kbmEvent.getCharTyped());
    103105                                // Generate a INSERT_STRING gesture
    … …  
    130132                addTranslator(new InputEventToGestureTranslator(InputType.KBM)
    131133                {
    132                         private static final int NO_CONSTRAINT = 0;
     134                        //private static final int NO_CONSTRAINT = 0;
    133135                        private SelectAreaGestureData _draggedFromData = null;
    134                         private int _constrainedDirection = NO_CONSTRAINT;
     136                        //private int _constrainedDirection = NO_CONSTRAINT;
    135137                       
    136138                        @Override
    … …  
    210212                                        newMousePos.add(1, 1);
    211213                                } else*/ {
    212                                         _constrainedDirection = NO_CONSTRAINT;
     214                                        //_constrainedDirection = NO_CONSTRAINT;
    213215                                        newMousePos = kbmEvent.getMouseMove().getSecondEnd().clone();
    214216                                }
    … …  
    682684               
    683685                // Add the F10 -> TOGGLE_XRAY_MODE gesture recogniser
    684                 addTranslator(new InputEventToGestureTranslator(InputType.KBM)
    685                 {
     686                addTranslator(new InputEventToGestureTranslator(InputType.KBM) {
     687                       
    686688                        @Override
    687689                        public String details() { return "F10 -> TOGGLE_XRAY_MODE"; }
    688 
    689                         @Override
    690                         public List<Gesture> onInputEvent(InputEvent event) {
    691                                 // Cast to keyboard/mouse event
    692                                 KBMInputEvent kbmEvent = (KBMInputEvent) event;
    693 
     690                       
     691                        @Override
     692                        public List<Gesture> onInputEvent(InputEvent event) {
     693                                // Cast to keyboard/mouse event
     694                                KBMInputEvent kbmEvent = (KBMInputEvent) event;
     695                               
    694696                                // Must be pressing F10 to xray mode
    695                                 if (kbmEvent.getKeyDown() != KBMInputEvent.Key.F10) {
    696                                         return null;
    697                                 }
    698                                
    699                                 // Return the gesture
    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                                 }
     697                                if (kbmEvent.getKeyDown() != KBMInputEvent.Key.F10 || kbmTranslator.isKeyDown(Key.SHIFT)) {
     698                                        return null;
     699                                }
     700                               
     701                                return Gesture.single(StandardGestureActions.getInstance().gestureType(StandardGestureType.TOGGLE_XRAY_MODE), null);
     702                        }
     703                });
     704               
     705                // Add the F10 -> CYCLE_SURROGATE_MODE gesture recogniser
     706                addTranslator(new InputEventToGestureTranslator(InputType.KBM) {
     707                        @Override
     708                        public String details() { return "F10 -> CYCLE_SURROGATE_MODE"; }
     709                       
     710                        @Override
     711                        public List<Gesture> onInputEvent(InputEvent event) {
     712                                // Case to keyboard/mouse event
     713                                KBMInputEvent kbmEvent = (KBMInputEvent) event;
     714                               
     715                                // Must be pressing F10 to surrogate mode
     716                                if (kbmEvent.getKeyDown() != KBMInputEvent.Key.F10 || !kbmTranslator.isKeyDown(Key.SHIFT)) {
     717                                        return null;
     718                                }
     719                               
     720                                UndoGestureData data = new UndoGestureData(kbmTranslator.isKeyDown(Key.CTRL));
     721                                return Gesture.single(StandardGestureActions.getInstance().gestureType(StandardGestureType.CYCLE_SURROGATE_MODE), data);
    706722                        }
    707723                });
    … …  
    21902206                                        return Gesture.single(vFormat);
    21912207                                }
     2208                        }
     2209                });
     2210               
     2211                // Add the ENTER_CHAR_TYPED -> ACTIVATE BUTTON -> FORMAT gesture recogniser
     2212                addTranslator(new InputEventToGestureTranslator(InputType.KBM)
     2213                {
     2214                        @Override
     2215                        public String details() { return "ENTER_CHAR_TYPED -> ACTIVATE BUTTON"; }
     2216
     2217                        @Override
     2218                        public List<Gesture> onInputEvent(InputEvent event) {
     2219                                // Cast to keyboard/mouse event
     2220                                KBMInputEvent kbmEvent = (KBMInputEvent) event;
     2221                       
     2222                                if (kbmEvent.getKeyDown() != Key.ENTER) {
     2223                                        return null;
     2224                                }
     2225                               
     2226                                GestureType gestureType = StandardGestureActions.getInstance().gestureType(StandardGestureType.ACTIVATE_BUTTON);
     2227                                ItemSpecificGestureData data = new ClickGestureData(false);
     2228                                return Gesture.single(gestureType, data);
    21922229                        }
    21932230                });

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

    r1413 r1415  
    5454import org.expeditee.gui.FreeItems;
    5555import org.expeditee.gui.MessageBay;
     56import org.expeditee.gui.ItemsList;
    5657import org.expeditee.gui.Vector;
    5758import org.expeditee.io.ExpClipReader;
    … …  
    123124                TOGGLE_ITEMS_MARK, // Show/hide the little circle indicating the item has a link and/or action
    124125                TOGGLE_XRAY_MODE, // F10
    125                 TOGGLE_SURROGATE_MODE, // Shift + F10
     126                CYCLE_SURROGATE_MODE, // Shift + F10
    126127                UNDO,
    127                 ZOOM
     128                ZOOM,
     129                ACTIVATE_BUTTON // Enter while over Item with _acceptsKeyboardEnter set to true
    128130        }
    129131        //@formatter:on
    … …  
    420422                        public void exec(Gesture gesture) {
    421423                                InsertStringGestureData data = (InsertStringGestureData) gesture.getData();
    422                                 for (char c : data.getString().toCharArray()) {
     424                               
     425                                Item currentItem = data.getCurrentItem();
     426                                char[] charArray = data.getString().toCharArray();
     427                               
     428                                if (currentItem != null) {
     429                                        // If we are over a item taht accepts keyboard enter and the only
     430                                        // character being entered is the enter key then we do not insert it.
     431                                        boolean keyboardEnter = data.getCurrentItem().acceptsKeyboardEnter();
     432                                        if (keyboardEnter && charArray.length == 1 && charArray[0] == (char) 10) {
     433                                                return;
     434                                        }
     435                                }
     436                                                               
     437                                for (char c : charArray) {
    423438                                        processChar(c, data.isShiftDown());
    424439                                }
    … …  
    967982                });
    968983               
    969                 setGestureAction(gestureType(StandardGestureType.TOGGLE_SURROGATE_MODE), new GestureAction() {
     984                // Set the ACTIVATE BUTTON action
     985                setGestureAction(gestureType(StandardGestureType.ACTIVATE_BUTTON), new GestureAction() {
     986                        @Override
     987                        public void exec(Gesture gesture) {
     988                                ItemSpecificGestureData data = (ItemSpecificGestureData) gesture.getData();
     989                                if (data.getCurrentItem().acceptsKeyboardEnter()) {
     990                                        getGestureAction(Gesture.GestureType.get("CLICK")).exec(gesture);
     991                                }
     992                        }                       
     993                });
     994               
     995                setGestureAction(gestureType(StandardGestureType.CYCLE_SURROGATE_MODE), new GestureAction() {
    970996                        @Override
    971997                        public void exec(Gesture gesture) {
    … …  
    17451771                        if (_lastHoldsHighlight) {
    17461772                                _lastHoldsHighlight = false;
    1747                                 for (Item i : DisplayController.getCurrentFrame().getItems()) {
     1773                                for (Item i : DisplayController.getCurrentFrame().getSortedItems()) {
    17481774                                        if (i.isHighlighted() && i != on) {
    17491775                                                FrameGraphics.changeHighlightMode(i, Item.HighlightMode.None);
    … …  
    18241850
    18251851                if (checkEnclosure) {
    1826                         ItemUtils.EnclosedCheck(toAnchor.getParentOrCurrentFrame().getItems());
     1852                        ItemUtils.EnclosedCheck(toAnchor.getParentOrCurrentFrame().getSortedItems());
    18271853                        DisplayController.requestRefresh(true);
    18281854                }
    … …  
    19361962                                }
    19371963                        } else if (!toUndo.contains(i)) {
    1938                                 if (addToUndo)
    1939                                  {
     1964                                if (addToUndo) {
    19401965                                        toUndo.add(i); // Why was is this a copy
    19411966                                }
    … …  
    19511976                // the current frame as well as the overlay frame
    19521977                Frame currentFrame = DisplayController.getCurrentFrame();
    1953                 currentFrame.addToUndoDelete(itemList);
     1978                currentFrame.addToUndoDelete(new ItemsList(itemList));
    19541979                itemList.clear();
    19551980                if (bReparse) {
    … …  
    32683293                        SessionStats.DeletedItems(toUndo);
    32693294                        if (parent != null) {
    3270                                 parent.addToUndoDelete(toUndo);
     3295                                parent.addToUndoDelete(new ItemsList(toUndo));
    32713296                                parent.removeAllItems(toUndo); // toDelete.getConnected()
    32723297                        }
    … …  
    36103635                                                        DisplayController.setCursorPosition(toDisconnect.getPosition(), false);
    36113636                                                        pickup(newPoint);
    3612                                                         ItemUtils.EnclosedCheck(toDisconnect.getParentOrCurrentFrame().getItems());
     3637                                                        ItemUtils.EnclosedCheck(toDisconnect.getParentOrCurrentFrame().getSortedItems());
    36133638                                                }
    36143639                                        }
    … …  
    39263951                mergee.getParent().setChanged(true);
    39273952
    3928                 ItemUtils.EnclosedCheck(mergee.getParent().getItems());
     3953                ItemUtils.EnclosedCheck(mergee.getParent().getSortedItems());
    39293954                // Mike: Why does parse frame have to be called?!?
    39303955                FrameUtils.Parse(mergee.getParent());
    … …  
    43864411                        int mouseY = position.getY();
    43874412                        // System.out.println(mouseX + "," + mouseY);
    4388                         for (Item i : DisplayController.getCurrentFrame().getItems()) {
     4413                        for (Item i : DisplayController.getCurrentFrame().getSortedItems()) {
    43894414                                // System.out.println(i.getName().toString());
    43904415                                if (i instanceof Text) {

  • trunk/src/org/expeditee/gio/input/InputEventToGestureTranslatorSet.java

    r1127 r1415  
    5757                if (_recognisers.isEmpty())
    5858                        return null;
     59               
     60//              if (event instanceof KBMInputEvent) {
     61//                      KBMInputEvent kEvent = (KBMInputEvent) event;
     62//                      if (kEvent.getKeyDown() != null) {
     63//                              System.err.println("onInputEvent:::" + kEvent.toString());
     64//                      }
     65//              }
    5966
    6067                // Only interested in monitored events

  • trunk/src/org/expeditee/gio/input/KBMInputEvent.java

    r1097 r1415  
    3737                BACKSPACE,
    3838                TAB,
     39                ENTER,
    3940                A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z
    4041        }

  • trunk/src/org/expeditee/gio/input/StandardInputEventListeners.java

    r1097 r1415  
    5252               
    5353                @Override
    54                 public boolean onInputEvent(InputEvent event)
    55                 {
     54                public boolean onInputEvent(InputEvent event) {
    5655                        // Only interested in keyboard/mouse events
    5756                        if (event.getInputType() != InputType.KBM) return false;
    … …  
    7776                }
    7877               
    79                 public boolean isKeyDown(Key key)
    80                 {
     78                public boolean isKeyDown(Key key) {
    8179                        return (key != null) && (_keyState[key.ordinal()] == Boolean.TRUE);
    8280                }
    8381               
    84                 public boolean isMouseButtonDown(MouseButton button)
    85                 {
     82                public boolean isMouseButtonDown(MouseButton button) {
    8683                        return (button != null) && (_mouseState[button.ordinal()] == Boolean.TRUE);
    8784                }
    8885               
    89                 public boolean isOnlyMouseButtonDown(MouseButton button)
    90                 {
     86                public boolean isOnlyMouseButtonDown(MouseButton button) {
    9187                        if (button == null) return false;
    9288                       
    … …  
    9894                }
    9995               
    100                 public boolean isAnyMouseButtonDown()
    101                 {
     96                public boolean isAnyMouseButtonDown() {
    10297                        for (MouseButton button : MouseButton.values()) {
    10398                                if (isMouseButtonDown(button)) return true;

  • trunk/src/org/expeditee/gio/javafx/JavaFXConversions.java

    r1144 r1415  
    137137                case Y: return org.expeditee.gio.input.KBMInputEvent.Key.Y;
    138138                case Z: return org.expeditee.gio.input.KBMInputEvent.Key.Z;
     139                case ENTER: return org.expeditee.gio.input.KBMInputEvent.Key.ENTER;
    139140                default: return null;
    140141                }

  • trunk/src/org/expeditee/gio/swing/SwingConversions.java

    r1144 r1415  
    350350                case java.awt.event.KeyEvent.VK_Y: return org.expeditee.gio.input.KBMInputEvent.Key.Y;
    351351                case java.awt.event.KeyEvent.VK_Z: return org.expeditee.gio.input.KBMInputEvent.Key.Z;
     352                case java.awt.event.KeyEvent.VK_ENTER: return org.expeditee.gio.input.KBMInputEvent.Key.ENTER;
    352353                default: return null;
    353354                }

  • trunk/src/org/expeditee/gio/swing/SwingInputManager.java

    r1248 r1415  
    44import java.awt.Color;
    55import java.awt.Dimension;
     6import java.awt.KeyEventDispatcher;
     7import java.awt.KeyboardFocusManager;
    68import java.awt.MouseInfo;
    79import java.awt.Robot;
    … …  
    3335import org.expeditee.gio.input.InputEvent.InputType;
    3436import org.expeditee.gio.input.KBMInputEvent;
     37import org.expeditee.gio.input.KBMInputEvent.Key;
     38import org.expeditee.gio.input.StandardInputEventListeners;
    3539import org.expeditee.gui.Popup;
    3640import org.expeditee.gui.PopupManager;
    … …  
    3842
    3943public class SwingInputManager extends InputManager implements ComponentListener, WindowListener, WindowStateListener,
    40                 KeyListener, MouseListener, MouseMotionListener, MouseWheelListener {
     44                KeyListener, MouseListener, MouseMotionListener, MouseWheelListener, KeyEventDispatcher {
    4145        /** Singleton instance. */
    4246        private static SwingInputManager _instance;
    … …  
    7377                // Sign up to receive input as events
    7478                SwingGraphicsManager graphicsManager = SwingMiscManager.getIfUsingSwingGraphicsManager();
    75                 if (graphicsManager != null) {
     79                if (graphicsManager != null) {                 
    7680                        graphicsManager.addWindowListener(swingInputManager);
    7781                        graphicsManager.addWindowStateListener(swingInputManager);
    … …  
    9195                        graphicsManager.getGlassPane().setVisible(true);
    9296                        graphicsManager.getContentPane().setBackground(Color.WHITE);
    93                         graphicsManager.getContentPane().setFocusTraversalKeysEnabled(false);
    94                 }
     97                }
     98                graphicsManager.getContentPane().setFocusTraversalKeysEnabled(false);
    9599
    96100                // Set up the robot (for controlling the mouse)
    … …  
    111115                });
    112116                _timer.setRepeats(false);
     117               
     118//              AWTEventListener[] listeners = Toolkit.getDefaultToolkit().getAWTEventListeners();
     119//              for (AWTEventListener listener: listeners) {
     120//                      System.err.println(listener);
     121//                      F10FriendlyKeyboardFocusManager keyboardManager = new F10FriendlyKeyboardFocusManager(listener);
     122//                      KeyboardFocusManager.setCurrentKeyboardFocusManager(keyboardManager);
     123//              }
     124//             
     125//              F10FriendlyKeyboardFocusManager keyboardManager = new F10FriendlyKeyboardFocusManager(this);
     126//              KeyboardFocusManager.setCurrentKeyboardFocusManager(keyboardManager);
     127
     128                KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(this);
    113129        }
    114130
    … …  
    222238        @Override
    223239        public void mouseWheelMoved(MouseWheelEvent e) {
     240                //ensureShiftAltStateCorrect(e);
    224241                // Give widgets first whack at input
    225242                distributeNativeInput(e);
    … …  
    247264        @Override
    248265        public void mouseMoved(MouseEvent e) {
     266                //ensureShiftAltStateCorrect(e);
     267               
    249268                // Update the cursor position
    250269                updateCursorPosition(e.getX(), e.getY());
    … …  
    271290        @Override
    272291        public void mouseClicked(MouseEvent e) {
     292                //ensureShiftAltStateCorrect(e);
    273293                // Give widgets first whack at input
    274294                distributeNativeInput(e);
    … …  
    282302        @Override
    283303        public void mousePressed(MouseEvent e) {
     304                //ensureShiftAltStateCorrect(e);
    284305                mouseAction(e, true);
    285306        }
    … …  
    287308        @Override
    288309        public void mouseReleased(MouseEvent e) {
     310                //ensureShiftAltStateCorrect(e);
    289311                mouseAction(e, false);
    290312        }
    … …  
    324346                } catch (Exception exception) {
    325347                        System.err.println("SwingInputManager::mouseAction: " + exception.getMessage());
     348                        exception.printStackTrace();
    326349                }
    327350        }
    … …  
    349372        @Override
    350373        public void keyTyped(KeyEvent e) {
    351                 //System.err.println("SwingInputManager::keyTyped::KeyEvent: " + e.getKeyChar());
     374                //System.err.println("SwingInputManager::keyTyped::" + KeyEvent.getKeyText(e.getKeyCode()));
     375                //ensureShiftAltStateCorrect(e);
     376               
    352377                // Give widgets first whack at input
    353378                distributeNativeInput(e);
    354379                if (e.isConsumed()) {
    355                         //System.err.println("SwingInputManager::keyTyped::Widget/Popup Consumed KeyEvent");
    356                         return;
    357                 }
    358 
     380                        return;
     381                }
     382               
    359383                try {
    360384                        // Ignore escape character and control characters
    … …  
    376400        @Override
    377401        public void keyPressed(KeyEvent e) {
     402                //System.err.println("SwingInputManager::keyPressed::" + KeyEvent.getKeyText(e.getKeyCode()));
     403                //ensureShiftAltStateCorrect(e);
    378404                keyAction(e, true);
    379405        }
    … …  
    381407        @Override
    382408        public void keyReleased(KeyEvent e) {
     409                //System.err.println("SwingInputManager::keyReleased::" + KeyEvent.getKeyText(e.getKeyCode()));
    383410                keyAction(e, false);
    384411        }
     412
     413//      private void ensureShiftAltStateCorrect(java.awt.event.InputEvent inputEvent) {
     414////            Component source = (Component) e.getSource();
     415////            int id = KeyEvent.KEY_RELEASED;
     416////            long when = System.currentTimeMillis();
     417////            int keyCode = KeyEvent.VK_UNDEFINED;
     418////            char keyChar = KeyEvent.CHAR_UNDEFINED;
     419//             
     420////            int modifiers = (e.getModifiers() & ~KeyEvent.SHIFT_DOWN_MASK);
     421////            KeyEvent event = new KeyEvent(source, id, when, modifiers, keyCode, keyChar);
     422////            Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(event);
     423//             
     424//              boolean shiftIsDownInRecordedState = StandardInputEventListeners.kbmStateListener.isKeyDown(Key.SHIFT);
     425//              boolean shiftIsDownEventState = inputEvent.isShiftDown();
     426//              if (shiftIsDownInRecordedState && !shiftIsDownEventState) {
     427//                      try {
     428//                              // Create an input event
     429//                              InputEvent event = new KBMInputEvent(KBMInputEvent.EventType.KEY_UP, KBMInputEvent.Key.SHIFT);
     430//                              System.err.println("SwingInputManager::ensureShiftAltStateCorrect::Sending followup Shift Up");
     431//                             
     432//                              // Translate and perform the input
     433//                              distributeInputEvent(event);
     434//                      } catch (Exception exception) {
     435//                              System.err.println(exception.getMessage());
     436//                      }
     437//              }
     438               
     439//              System.err.println("SwingInputManager::ensureShiftAltStateCorrect::datastructure shift down: " + shiftIsDownInRecordedState);
     440//              if (shiftIsDownInRecordedState != e.isShiftDown() && !e.isShiftDown()) {
     441//                      System.err.println("SwingInputManager::ensureShiftAltStateCorrect::Sending shift up event.");
     442//                      int modifiers = (e.getModifiers() & ~KeyEvent.SHIFT_DOWN_MASK);
     443//                      KeyEvent event = new KeyEvent(source, id, when, modifiers, keyCode, keyChar);
     444//                      Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(event);
     445//              }               
     446               
     447//              boolean altIsDown = StandardInputEventListeners.kbmStateListener.isKeyDown(Key.ALT);
     448//              if (altIsDown != e.isAltDown() && !e.isAltDown()) {
     449//                      System.err.println("SwingInputManager::ensureShiftAltStateCorrect::Sending alt up event.");
     450//                      int modifiers = (e.getModifiers() & ~KeyEvent.ALT_DOWN_MASK);
     451//                      KeyEvent event = new KeyEvent(source, id, when, modifiers, keyCode, keyChar);
     452//                      Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(event);
     453//              }
     454//      }
    385455
    386456        /** Handles key pressed/released events. */
    387457        private void keyAction(KeyEvent e, boolean down) {
    388                 //System.err.println("SwingInputManager::keyAction::KeyEvent: " + e.getKeyChar());
    389458                // Give widgets first whack at input
    390459                distributeNativeInput(e);
    391460                if (e.isConsumed()) {
    392                         //System.err.println("SwingInputManager::keyAction::Was consumed: " + e.isConsumed());
    393                         return;
    394                 }
    395                 //System.err.println("SwingInputManager::keyAction::Was consumed: " + e.isConsumed());
    396 
     461                        return;
     462                }
     463               
    397464                KBMInputEvent.Key key = SwingConversions.fromSwingVirtualKey(e.getKeyCode());
    398465                if (key == null) {
    399466                        return;
    400467                }
    401 
     468               
    402469                try {
    403470                        // Create an input event
    … …  
    424491        /** Forwards the given input event to the listener if it is listening for it. */
    425492        private void forwardNativeInputToListener(Object listener, java.awt.event.InputEvent event) {
    426                 //System.err.println("SwingInputManager::forwardNativeInputToListener");
    427493                if (listener == null || event == null) {
    428494                        return;
    429495                }
    430                 //System.err.println("SwingInputManager::forwardNativeInputToListener::Recieving input: " + event.toString());
     496               
    431497                if (listener instanceof KeyListener && event instanceof KeyEvent) {
    432498
    433499                        KeyListener keyListener = (KeyListener) listener;
    434500                        KeyEvent ke = (KeyEvent) event;
    435 
     501                       
    436502                        switch (event.getID()) {
    437503                        case KeyEvent.KEY_PRESSED:
    … …  
    442508                                return;
    443509                        case KeyEvent.KEY_TYPED:
    444                                 //System.err.println("SwingInputManager::forwardNativeInputToListener::Recieving key typed: " + event.toString());
    445510                                keyListener.keyTyped(ke);
    446511                                return;
    … …  
    632697
    633698        }
     699
     700        @Override
     701        public boolean dispatchKeyEvent(KeyEvent e) {
     702                if (e.getKeyCode() == KeyEvent.VK_F10) {
     703                        if (KeyEvent.KEY_PRESSED == e.getID()) {
     704                                keyPressed(e);
     705                        } else if (KeyEvent.KEY_RELEASED == e.getID()) {
     706                                keyReleased(e);
     707                        } else if (KeyEvent.KEY_TYPED == e.getID()) {
     708                                keyTyped(e);
     709                        } else {
     710                                System.err.println("SwingInputManager::dispatchKeyEvent::Found Key that is not pressed, "
     711                                                + "released or typed.  What is it?  " + e.getID());
     712                        }
     713                        return true;
     714                }
     715                return false;
     716        }
    634717}

  • trunk/src/org/expeditee/gio/swing/SwingTextLayoutManager.java

    r1206 r1415  
    262262                        }
    263263                       
    264                         java.awt.font.TextLayout layout = lineBreaker.nextLayout(width, end, dontBreakWords);
     264                        java.awt.font.TextLayout layout = null;
     265
     266                        try {
     267                                layout = lineBreaker.nextLayout(width, end, dontBreakWords);
     268                        } catch (ArrayIndexOutOfBoundsException e) {
     269                                e.printStackTrace();
     270                        }
    265271                       
    266272                        // If it's impossible to layout any more text without breaking a word, just do it
Note: See TracChangeset for help on using the changeset viewer.