Changeset 1911 in josm


Ignore:
Timestamp:
2009-08-05T10:05:50+02:00 (11 years ago)
Author:
Gubaer
Message:

fixed #3193: No layer is left highlighted when the bottom most one is deleted
fixed some references to Way.nodes
clean up of warnings
added documentation in LayerListDialog

Location:
trunk/src/org/openstreetmap/josm
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/actions/CombineWayAction.java

    r1862 r1911  
    5454    }
    5555
     56    @SuppressWarnings("unchecked")
    5657    public void actionPerformed(ActionEvent event) {
    5758        if (getCurrentDataSet() == null)
  • trunk/src/org/openstreetmap/josm/data/conflict/Conflict.java

    r1750 r1911  
    5151    }
    5252
     53    @SuppressWarnings("unchecked")
    5354    @Override
    5455    public boolean equals(Object obj) {
     
    5960        if (getClass() != obj.getClass())
    6061            return false;
    61         Conflict<T> other = (Conflict) obj;
     62        Conflict<T> other = (Conflict<T>) obj;
    6263        if (my != other.my)
    6364            return false;
  • trunk/src/org/openstreetmap/josm/data/gpx/GpxData.java

    r1724 r1911  
    4040    public Collection<WayPoint> waypoints = new LinkedList<WayPoint>();
    4141
     42    @SuppressWarnings("unchecked")
    4243    public void mergeFrom(GpxData other) {
    4344        if (storageFile == null && other.storageFile != null) {
     
    5152            if (k.equals(META_LINKS) && attr.containsKey(META_LINKS)) {
    5253                ((Collection<GpxLink>) attr.get(META_LINKS)).addAll(
    53                     (Collection<GpxLink>) ent.getValue());
     54                        (Collection<GpxLink>) ent.getValue());
    5455            } else {
    5556                attr.put(k, ent.getValue());
  • trunk/src/org/openstreetmap/josm/data/osm/Way.java

    r1910 r1911  
    7171    public Node getNode(int index) {
    7272        return nodes.get(index);
     73    }
     74
     75    /**
     76     * Replies true if this way contains the node <code>node</code>, false
     77     * otherwise. Replies false if  <code>node</code> is null.
     78     *
     79     * @param node the node. May be null.
     80     * @return true if this way contains the node <code>node</code>, false
     81     * otherwise
     82     * @since 1909
     83     */
     84    public boolean containsNode(Node node) {
     85        if (node == null) return false;
     86        return nodes.contains(node);
    7387    }
    7488
  • trunk/src/org/openstreetmap/josm/gui/FileDrop.java

    r1231 r1911  
    1 /* code from: http://iharder.sourceforge.net/current/java/filedrop/ 
     1/* code from: http://iharder.sourceforge.net/current/java/filedrop/
    22  (public domain) with only very small additions */
    33package org.openstreetmap.josm.gui;
     
    2626 *      new FileDrop( myPanel, new FileDrop.Listener()
    2727 *      {   public void filesDropped( java.io.File[] files )
    28  *          {   
     28 *          {
    2929 *              // handle file drop
    3030 *              ...
     
    5555    private transient javax.swing.border.Border normalBorder;
    5656    private transient java.awt.dnd.DropTargetListener dropListener;
    57    
    58    
     57
     58
    5959    /** Discover if the running JVM is modern enough to have drag and drop. */
    6060    private static Boolean supportsDnD;
    61    
     61
    6262    // Default border color
    6363    private static java.awt.Color defaultBorderColor = new java.awt.Color( 0f, 0f, 1f, 0.25f );
    64    
     64
    6565
    6666    /* Constructor for JOSM file drop */
     
    7272            true, // Recursive
    7373            new FileDrop.Listener()
    74             {   
     74            {
    7575                public void filesDropped( java.io.File[] files )
    76                 {   
     76                {
    7777                    OpenFileAction ofa = new OpenFileAction();
    7878                    for( int i = 0; i < files.length; i++ )
    79                     {   
     79                    {
    8080                        ofa.openFile(files[i]);
    8181                    }   // end for: through each dropped file
     
    8484    }
    8585
    86    
     86
    8787    /**
    8888     * Constructs a {@link FileDrop} with a default light-blue border
     
    9696     */
    9797    public FileDrop(
    98     final java.awt.Component c,
    99     final Listener listener )
     98            final java.awt.Component c,
     99            final Listener listener )
    100100    {   this( null,  // Logging stream
    101               c,     // Drop target
    102               javax.swing.BorderFactory.createMatteBorder( 2, 2, 2, 2, defaultBorderColor ), // Drag border
    103               true, // Recursive
    104               listener );
     101            c,     // Drop target
     102            javax.swing.BorderFactory.createMatteBorder( 2, 2, 2, 2, defaultBorderColor ), // Drag border
     103            true, // Recursive
     104            listener );
    105105    }   // end constructor
    106    
    107    
    108    
    109    
     106
     107
     108
     109
    110110    /**
    111111     * Constructor with a default border and the option to recursively set drop targets.
     
    119119     */
    120120    public FileDrop(
    121     final java.awt.Component c,
    122     final boolean recursive,
    123     final Listener listener )
     121            final java.awt.Component c,
     122            final boolean recursive,
     123            final Listener listener )
    124124    {   this( null,  // Logging stream
    125               c,     // Drop target
    126               javax.swing.BorderFactory.createMatteBorder( 2, 2, 2, 2, defaultBorderColor ), // Drag border
    127               recursive, // Recursive
    128               listener );
     125            c,     // Drop target
     126            javax.swing.BorderFactory.createMatteBorder( 2, 2, 2, 2, defaultBorderColor ), // Drag border
     127            recursive, // Recursive
     128            listener );
    129129    }   // end constructor
    130    
    131    
     130
     131
    132132    /**
    133133     * Constructor with a default border and debugging optionally turned on.
     
    138138     *
    139139     * @param out PrintStream to record debugging info or null for no debugging.
    140      * @param out 
     140     * @param out
    141141     * @param c Component on which files will be dropped.
    142142     * @param listener Listens for <tt>filesDropped</tt>.
     
    144144     */
    145145    public FileDrop(
    146     final java.io.PrintStream out,
    147     final java.awt.Component c,
    148     final Listener listener )
     146            final java.io.PrintStream out,
     147            final java.awt.Component c,
     148            final Listener listener )
    149149    {   this( out,  // Logging stream
    150               c,    // Drop target
    151               javax.swing.BorderFactory.createMatteBorder( 2, 2, 2, 2, defaultBorderColor ),
    152               false, // Recursive
    153               listener );
     150            c,    // Drop target
     151            javax.swing.BorderFactory.createMatteBorder( 2, 2, 2, 2, defaultBorderColor ),
     152            false, // Recursive
     153            listener );
    154154    }   // end constructor
    155    
    156        
    157    
     155
     156
     157
    158158    /**
    159159     * Constructor with a default border, debugging optionally turned on
     
    167167     *
    168168     * @param out PrintStream to record debugging info or null for no debugging.
    169      * @param out 
     169     * @param out
    170170     * @param c Component on which files will be dropped.
    171171     * @param recursive Recursively set children as drop targets.
     
    174174     */
    175175    public FileDrop(
    176     final java.io.PrintStream out,
    177     final java.awt.Component c,
    178     final boolean recursive,
    179     final Listener listener)
     176            final java.io.PrintStream out,
     177            final java.awt.Component c,
     178            final boolean recursive,
     179            final Listener listener)
    180180    {   this( out,  // Logging stream
    181               c,    // Drop target
    182               javax.swing.BorderFactory.createMatteBorder( 2, 2, 2, 2, defaultBorderColor ), // Drag border
    183               recursive, // Recursive
    184               listener );
     181            c,    // Drop target
     182            javax.swing.BorderFactory.createMatteBorder( 2, 2, 2, 2, defaultBorderColor ), // Drag border
     183            recursive, // Recursive
     184            listener );
    185185    }   // end constructor
    186    
    187    
    188    
    189    
    190     /**
    191      * Constructor with a specified border 
     186
     187
     188
     189
     190    /**
     191     * Constructor with a specified border
    192192     *
    193193     * @param c Component on which files will be dropped.
     
    197197     */
    198198    public FileDrop(
    199     final java.awt.Component c,
    200     final javax.swing.border.Border dragBorder,
    201     final Listener listener)
     199            final java.awt.Component c,
     200            final javax.swing.border.Border dragBorder,
     201            final Listener listener)
    202202    {   this(
    203203            null,   // Logging stream
     
    207207            listener );
    208208    }   // end constructor
    209    
    210    
    211        
    212    
     209
     210
     211
     212
    213213    /**
    214214     * Constructor with a specified border and the option to recursively set drop targets.
     
    223223     */
    224224    public FileDrop(
    225     final java.awt.Component c,
    226     final javax.swing.border.Border dragBorder,
    227     final boolean recursive,
    228     final Listener listener)
     225            final java.awt.Component c,
     226            final javax.swing.border.Border dragBorder,
     227            final boolean recursive,
     228            final Listener listener)
    229229    {   this(
    230230            null,
     
    234234            listener );
    235235    }   // end constructor
    236    
    237            
    238    
     236
     237
     238
    239239    /**
    240240     * Constructor with a specified border and debugging optionally turned on.
     
    251251     */
    252252    public FileDrop(
    253     final java.io.PrintStream out,
    254     final java.awt.Component c,
    255     final javax.swing.border.Border dragBorder,
    256     final Listener listener)
     253            final java.io.PrintStream out,
     254            final java.awt.Component c,
     255            final javax.swing.border.Border dragBorder,
     256            final Listener listener)
    257257    {   this(
    258258            out,    // Logging stream
     
    262262            listener );
    263263    }   // end constructor
    264    
    265    
    266    
    267    
    268    
     264
     265
     266
     267
     268
    269269    /**
    270270     * Full constructor with a specified border and debugging optionally turned on.
     
    282282     */
    283283    public FileDrop(
    284     final java.io.PrintStream out,
    285     final java.awt.Component c,
    286     final javax.swing.border.Border dragBorder,
    287     final boolean recursive,
    288     final Listener listener)
    289     {   
    290        
     284            final java.io.PrintStream out,
     285            final java.awt.Component c,
     286            final javax.swing.border.Border dragBorder,
     287            final boolean recursive,
     288            final Listener listener)
     289    {
     290
    291291        if( supportsDnD() )
    292292        {   // Make a drop listener
    293293            dropListener = new java.awt.dnd.DropTargetListener()
    294294            {   public void dragEnter( java.awt.dnd.DropTargetDragEvent evt )
    295                 {       log( out, "FileDrop: dragEnter event." );
    296 
    297                     // Is this an acceptable drag event?
    298                     if( isDragOk( out, evt ) )
    299                     {
    300                         // If it's a Swing component, set its border
    301                         if( c instanceof javax.swing.JComponent )
    302                         {   javax.swing.JComponent jc = (javax.swing.JComponent) c;
    303                             normalBorder = jc.getBorder();
    304                             log( out, "FileDrop: normal border saved." );
    305                             jc.setBorder( dragBorder );
    306                             log( out, "FileDrop: drag border set." );
    307                         }   // end if: JComponent   
    308 
    309                         // Acknowledge that it's okay to enter
    310                         //evt.acceptDrag( java.awt.dnd.DnDConstants.ACTION_COPY_OR_MOVE );
    311                         evt.acceptDrag( java.awt.dnd.DnDConstants.ACTION_COPY );
    312                         log( out, "FileDrop: event accepted." );
    313                     }   // end if: drag ok
    314                     else
    315                     {   // Reject the drag event
    316                         evt.rejectDrag();
    317                         log( out, "FileDrop: event rejected." );
    318                     }   // end else: drag not ok
    319                 }   // end dragEnter
    320 
    321                 public void dragOver( java.awt.dnd.DropTargetDragEvent evt )
    322                 {   // This is called continually as long as the mouse is
    323                     // over the drag target.
    324                 }   // end dragOver
    325 
    326                 public void drop( java.awt.dnd.DropTargetDropEvent evt )
    327                 {   log( out, "FileDrop: drop event." );
    328                     try
    329                     {   // Get whatever was dropped
    330                         java.awt.datatransfer.Transferable tr = evt.getTransferable();
    331 
    332                         // Is it a file list?
    333                         if (tr.isDataFlavorSupported (java.awt.datatransfer.DataFlavor.javaFileListFlavor))
    334                         {
     295            {       log( out, "FileDrop: dragEnter event." );
     296
     297            // Is this an acceptable drag event?
     298            if( isDragOk( out, evt ) )
     299            {
     300                // If it's a Swing component, set its border
     301                if( c instanceof javax.swing.JComponent )
     302                {   javax.swing.JComponent jc = (javax.swing.JComponent) c;
     303                normalBorder = jc.getBorder();
     304                log( out, "FileDrop: normal border saved." );
     305                jc.setBorder( dragBorder );
     306                log( out, "FileDrop: drag border set." );
     307                }   // end if: JComponent
     308
     309                // Acknowledge that it's okay to enter
     310                //evt.acceptDrag( java.awt.dnd.DnDConstants.ACTION_COPY_OR_MOVE );
     311                evt.acceptDrag( java.awt.dnd.DnDConstants.ACTION_COPY );
     312                log( out, "FileDrop: event accepted." );
     313            }   // end if: drag ok
     314            else
     315            {   // Reject the drag event
     316                evt.rejectDrag();
     317                log( out, "FileDrop: event rejected." );
     318            }   // end else: drag not ok
     319            }   // end dragEnter
     320
     321            public void dragOver( java.awt.dnd.DropTargetDragEvent evt )
     322            {   // This is called continually as long as the mouse is
     323                // over the drag target.
     324            }   // end dragOver
     325
     326            public void drop( java.awt.dnd.DropTargetDropEvent evt )
     327            {   log( out, "FileDrop: drop event." );
     328            try
     329            {   // Get whatever was dropped
     330                java.awt.datatransfer.Transferable tr = evt.getTransferable();
     331
     332                // Is it a file list?
     333                if (tr.isDataFlavorSupported (java.awt.datatransfer.DataFlavor.javaFileListFlavor))
     334                {
     335                    // Say we'll take it.
     336                    //evt.acceptDrop ( java.awt.dnd.DnDConstants.ACTION_COPY_OR_MOVE );
     337                    evt.acceptDrop ( java.awt.dnd.DnDConstants.ACTION_COPY );
     338                    log( out, "FileDrop: file list accepted." );
     339
     340                    // Get a useful list
     341                    java.util.List<Object> fileList = (java.util.List<Object>)
     342                    tr.getTransferData(java.awt.datatransfer.DataFlavor.javaFileListFlavor);
     343
     344                    // Convert list to array
     345                    java.io.File[] filesTemp = new java.io.File[ fileList.size() ];
     346                    fileList.toArray( filesTemp );
     347                    final java.io.File[] files = filesTemp;
     348
     349                    // Alert listener to drop.
     350                    if( listener != null ) {
     351                        listener.filesDropped( files );
     352                    }
     353
     354                    // Mark that drop is completed.
     355                    evt.getDropTargetContext().dropComplete(true);
     356                    log( out, "FileDrop: drop complete." );
     357                }   // end if: file list
     358                else // this section will check for a reader flavor.
     359                {
     360                    // Thanks, Nathan!
     361                    // BEGIN 2007-09-12 Nathan Blomquist -- Linux (KDE/Gnome) support added.
     362                    DataFlavor[] flavors = tr.getTransferDataFlavors();
     363                    boolean handled = false;
     364                    for (int zz = 0; zz < flavors.length; zz++) {
     365                        if (flavors[zz].isRepresentationClassReader()) {
    335366                            // Say we'll take it.
    336367                            //evt.acceptDrop ( java.awt.dnd.DnDConstants.ACTION_COPY_OR_MOVE );
    337                             evt.acceptDrop ( java.awt.dnd.DnDConstants.ACTION_COPY );
    338                             log( out, "FileDrop: file list accepted." );
    339 
    340                             // Get a useful list
    341                             java.util.List fileList = (java.util.List)
    342                                 tr.getTransferData(java.awt.datatransfer.DataFlavor.javaFileListFlavor);
    343                             java.util.Iterator iterator = fileList.iterator();
    344 
    345                             // Convert list to array
    346                             java.io.File[] filesTemp = new java.io.File[ fileList.size() ];
    347                             fileList.toArray( filesTemp );
    348                             final java.io.File[] files = filesTemp;
    349 
    350                             // Alert listener to drop.
    351                             if( listener != null )
    352                                 listener.filesDropped( files );
     368                            evt.acceptDrop(java.awt.dnd.DnDConstants.ACTION_COPY);
     369                            log(out, "FileDrop: reader accepted.");
     370
     371                            Reader reader = flavors[zz].getReaderForText(tr);
     372
     373                            BufferedReader br = new BufferedReader(reader);
     374
     375                            if(listener != null) {
     376                                listener.filesDropped(createFileArray(br, out));
     377                            }
    353378
    354379                            // Mark that drop is completed.
    355380                            evt.getDropTargetContext().dropComplete(true);
    356                             log( out, "FileDrop: drop complete." );
    357                         }   // end if: file list
    358                         else // this section will check for a reader flavor.
    359                         {
    360                             // Thanks, Nathan!
    361                             // BEGIN 2007-09-12 Nathan Blomquist -- Linux (KDE/Gnome) support added.
    362                             DataFlavor[] flavors = tr.getTransferDataFlavors();
    363                             boolean handled = false;
    364                             for (int zz = 0; zz < flavors.length; zz++) {
    365                                 if (flavors[zz].isRepresentationClassReader()) {
    366                                     // Say we'll take it.
    367                                     //evt.acceptDrop ( java.awt.dnd.DnDConstants.ACTION_COPY_OR_MOVE );
    368                                     evt.acceptDrop(java.awt.dnd.DnDConstants.ACTION_COPY);
    369                                     log(out, "FileDrop: reader accepted.");
    370 
    371                                     Reader reader = flavors[zz].getReaderForText(tr);
    372 
    373                                     BufferedReader br = new BufferedReader(reader);
    374                                    
    375                                     if(listener != null)
    376                                         listener.filesDropped(createFileArray(br, out));
    377                                    
    378                                     // Mark that drop is completed.
    379                                     evt.getDropTargetContext().dropComplete(true);
    380                                     log(out, "FileDrop: drop complete.");
    381                                     handled = true;
    382                                     break;
    383                                 }
    384                             }
    385                             if(!handled){
    386                                 log( out, "FileDrop: not a file list or reader - abort." );
    387                                 evt.rejectDrop();
    388                             }
    389                             // END 2007-09-12 Nathan Blomquist -- Linux (KDE/Gnome) support added.
    390                         }   // end else: not a file list
    391                     }   // end try
    392                     catch ( java.io.IOException io)
    393                     {   log( out, "FileDrop: IOException - abort:" );
    394                         io.printStackTrace( out );
     381                            log(out, "FileDrop: drop complete.");
     382                            handled = true;
     383                            break;
     384                        }
     385                    }
     386                    if(!handled){
     387                        log( out, "FileDrop: not a file list or reader - abort." );
    395388                        evt.rejectDrop();
    396                     }   // end catch IOException
    397                     catch (java.awt.datatransfer.UnsupportedFlavorException ufe)
    398                     {   log( out, "FileDrop: UnsupportedFlavorException - abort:" );
    399                         ufe.printStackTrace( out );
    400                         evt.rejectDrop();
    401                     }   // end catch: UnsupportedFlavorException
    402                     finally
    403                     {
    404                         // If it's a Swing component, reset its border
    405                         if( c instanceof javax.swing.JComponent )
    406                         {   javax.swing.JComponent jc = (javax.swing.JComponent) c;
    407                             jc.setBorder( normalBorder );
    408                             log( out, "FileDrop: normal border restored." );
    409                         }   // end if: JComponent
    410                     }   // end finally
    411                 }   // end drop
    412 
    413                 public void dragExit( java.awt.dnd.DropTargetEvent evt )
    414                 {   log( out, "FileDrop: dragExit event." );
    415                     // If it's a Swing component, reset its border
    416                     if( c instanceof javax.swing.JComponent )
    417                     {   javax.swing.JComponent jc = (javax.swing.JComponent) c;
    418                         jc.setBorder( normalBorder );
    419                         log( out, "FileDrop: normal border restored." );
    420                     }   // end if: JComponent
    421                 }   // end dragExit
    422 
    423                 public void dropActionChanged( java.awt.dnd.DropTargetDragEvent evt )
    424                 {   log( out, "FileDrop: dropActionChanged event." );
    425                     // Is this an acceptable drag event?
    426                     if( isDragOk( out, evt ) )
    427                     {   //evt.acceptDrag( java.awt.dnd.DnDConstants.ACTION_COPY_OR_MOVE );
    428                         evt.acceptDrag( java.awt.dnd.DnDConstants.ACTION_COPY );
    429                         log( out, "FileDrop: event accepted." );
    430                     }   // end if: drag ok
    431                     else
    432                     {   evt.rejectDrag();
    433                         log( out, "FileDrop: event rejected." );
    434                     }   // end else: drag not ok
    435                 }   // end dropActionChanged
     389                    }
     390                    // END 2007-09-12 Nathan Blomquist -- Linux (KDE/Gnome) support added.
     391                }   // end else: not a file list
     392            }   // end try
     393            catch ( java.io.IOException io)
     394            {   log( out, "FileDrop: IOException - abort:" );
     395            io.printStackTrace( out );
     396            evt.rejectDrop();
     397            }   // end catch IOException
     398            catch (java.awt.datatransfer.UnsupportedFlavorException ufe)
     399            {   log( out, "FileDrop: UnsupportedFlavorException - abort:" );
     400            ufe.printStackTrace( out );
     401            evt.rejectDrop();
     402            }   // end catch: UnsupportedFlavorException
     403            finally
     404            {
     405                // If it's a Swing component, reset its border
     406                if( c instanceof javax.swing.JComponent )
     407                {   javax.swing.JComponent jc = (javax.swing.JComponent) c;
     408                jc.setBorder( normalBorder );
     409                log( out, "FileDrop: normal border restored." );
     410                }   // end if: JComponent
     411            }   // end finally
     412            }   // end drop
     413
     414            public void dragExit( java.awt.dnd.DropTargetEvent evt )
     415            {   log( out, "FileDrop: dragExit event." );
     416            // If it's a Swing component, reset its border
     417            if( c instanceof javax.swing.JComponent )
     418            {   javax.swing.JComponent jc = (javax.swing.JComponent) c;
     419            jc.setBorder( normalBorder );
     420            log( out, "FileDrop: normal border restored." );
     421            }   // end if: JComponent
     422            }   // end dragExit
     423
     424            public void dropActionChanged( java.awt.dnd.DropTargetDragEvent evt )
     425            {   log( out, "FileDrop: dropActionChanged event." );
     426            // Is this an acceptable drag event?
     427            if( isDragOk( out, evt ) )
     428            {   //evt.acceptDrag( java.awt.dnd.DnDConstants.ACTION_COPY_OR_MOVE );
     429                evt.acceptDrag( java.awt.dnd.DnDConstants.ACTION_COPY );
     430                log( out, "FileDrop: event accepted." );
     431            }   // end if: drag ok
     432            else
     433            {   evt.rejectDrag();
     434            log( out, "FileDrop: event rejected." );
     435            }   // end else: drag not ok
     436            }   // end dropActionChanged
    436437            }; // end DropTargetListener
    437438
     
    444445    }   // end constructor
    445446
    446    
     447
    447448    private static boolean supportsDnD()
    448449    {   // Static Boolean
    449450        if( supportsDnD == null )
    450         {   
     451        {
    451452            boolean support = false;
    452453            try
    453454            {   Class arbitraryDndClass = Class.forName( "java.awt.dnd.DnDConstants" );
    454                 support = true;
     455            support = true;
    455456            }   // end try
    456457            catch( Exception e )
     
    461462        return supportsDnD.booleanValue();
    462463    }   // end supportsDnD
    463    
    464    
    465      // BEGIN 2007-09-12 Nathan Blomquist -- Linux (KDE/Gnome) support added.
    466      private static String ZERO_CHAR_STRING = "" + (char)0;
    467      private static File[] createFileArray(BufferedReader bReader, PrintStream out)
    468      {
    469         try { 
    470             java.util.List list = new java.util.ArrayList();
     464
     465
     466    // BEGIN 2007-09-12 Nathan Blomquist -- Linux (KDE/Gnome) support added.
     467    private static String ZERO_CHAR_STRING = "" + (char)0;
     468    private static File[] createFileArray(BufferedReader bReader, PrintStream out)
     469    {
     470        try {
     471            java.util.List<File> list = new java.util.ArrayList<File>();
    471472            java.lang.String line = null;
    472473            while ((line = bReader.readLine()) != null) {
    473474                try {
    474475                    // kde seems to append a 0 char to the end of the reader
    475                     if(ZERO_CHAR_STRING.equals(line)) continue;
    476                    
     476                    if(ZERO_CHAR_STRING.equals(line)) {
     477                        continue;
     478                    }
     479
    477480                    java.io.File file = new java.io.File(new java.net.URI(line));
    478481                    list.add(file);
     
    482485            }
    483486
    484             return (java.io.File[]) list.toArray(new File[list.size()]);
     487            return list.toArray(new File[list.size()]);
    485488        } catch (IOException ex) {
    486489            log(out, "FileDrop: IOException");
    487490        }
    488491        return new File[0];
    489      }
    490      // END 2007-09-12 Nathan Blomquist -- Linux (KDE/Gnome) support added.
    491      
    492    
     492    }
     493    // END 2007-09-12 Nathan Blomquist -- Linux (KDE/Gnome) support added.
     494
     495
    493496    private void makeDropTarget( final java.io.PrintStream out, final java.awt.Component c, boolean recursive )
    494497    {
     
    500503        catch( java.util.TooManyListenersException e )
    501504        {   e.printStackTrace();
    502             log(out, "FileDrop: Drop will not work due to previous error. Do you have another listener attached?" );
     505        log(out, "FileDrop: Drop will not work due to previous error. Do you have another listener attached?" );
    503506        }   // end catch
    504        
     507
    505508        // Listen for hierarchy changes and remove the drop target when the parent gets cleared out.
    506509        c.addHierarchyListener( new java.awt.event.HierarchyListener()
    507510        {   public void hierarchyChanged( java.awt.event.HierarchyEvent evt )
    508             {   log( out, "FileDrop: Hierarchy changed." );
    509                 java.awt.Component parent = c.getParent();
    510                 if( parent == null )
    511                 {   c.setDropTarget( null );
    512                     log( out, "FileDrop: Drop target cleared from component." );
    513                 }   // end if: null parent
    514                 else
    515                 {   new java.awt.dnd.DropTarget(c, dropListener);
    516                     log( out, "FileDrop: Drop target added to component." );
    517                 }   // end else: parent not null
    518             }   // end hierarchyChanged
     511        {   log( out, "FileDrop: Hierarchy changed." );
     512        java.awt.Component parent = c.getParent();
     513        if( parent == null )
     514        {   c.setDropTarget( null );
     515        log( out, "FileDrop: Drop target cleared from component." );
     516        }   // end if: null parent
     517        else
     518        {   new java.awt.dnd.DropTarget(c, dropListener);
     519        log( out, "FileDrop: Drop target added to component." );
     520        }   // end else: parent not null
     521        }   // end hierarchyChanged
    519522        }); // end hierarchy listener
    520         if( c.getParent() != null )
     523        if( c.getParent() != null ) {
    521524            new java.awt.dnd.DropTarget(c, dropListener);
    522        
     525        }
     526
    523527        if( recursive && (c instanceof java.awt.Container ) )
    524         {   
     528        {
    525529            // Get the container
    526530            java.awt.Container cont = (java.awt.Container) c;
    527            
     531
    528532            // Get it's components
    529533            java.awt.Component[] comps = cont.getComponents();
    530            
     534
    531535            // Set it's components as listeners also
    532             for( int i = 0; i < comps.length; i++ )
     536            for( int i = 0; i < comps.length; i++ ) {
    533537                makeDropTarget( out, comps[i], recursive );
     538            }
    534539        }   // end if: recursively set components as listener
    535540    }   // end dropListener
    536    
    537    
    538    
     541
     542
     543
    539544    /** Determine if the dragged data is a file list. */
    540545    private boolean isDragOk( final java.io.PrintStream out, final java.awt.dnd.DropTargetDragEvent evt )
    541546    {   boolean ok = false;
    542        
    543         // Get data flavors being dragged
    544         java.awt.datatransfer.DataFlavor[] flavors = evt.getCurrentDataFlavors();
    545        
    546         // See if any of the flavors are a file list
    547         int i = 0;
    548         while( !ok && i < flavors.length )
    549         {   
    550             // BEGIN 2007-09-12 Nathan Blomquist -- Linux (KDE/Gnome) support added.
    551             // Is the flavor a file list?
    552             final DataFlavor curFlavor = flavors[i];
    553             if( curFlavor.equals( java.awt.datatransfer.DataFlavor.javaFileListFlavor ) ||
     547
     548    // Get data flavors being dragged
     549    java.awt.datatransfer.DataFlavor[] flavors = evt.getCurrentDataFlavors();
     550
     551    // See if any of the flavors are a file list
     552    int i = 0;
     553    while( !ok && i < flavors.length )
     554    {
     555        // BEGIN 2007-09-12 Nathan Blomquist -- Linux (KDE/Gnome) support added.
     556        // Is the flavor a file list?
     557        final DataFlavor curFlavor = flavors[i];
     558        if( curFlavor.equals( java.awt.datatransfer.DataFlavor.javaFileListFlavor ) ||
    554559                curFlavor.isRepresentationClassReader()){
    555                 ok = true;
    556             }
    557             // END 2007-09-12 Nathan Blomquist -- Linux (KDE/Gnome) support added.
    558             i++;
    559         }   // end while: through flavors
    560        
    561         // If logging is enabled, show data flavors
    562         if( out != null )
    563         {   if( flavors.length == 0 )
    564                 log( out, "FileDrop: no data flavors." );
    565             for( i = 0; i < flavors.length; i++ )
    566                 log( out, flavors[i].toString() );
    567         }   // end if: logging enabled
    568        
    569         return ok;
     560            ok = true;
     561        }
     562        // END 2007-09-12 Nathan Blomquist -- Linux (KDE/Gnome) support added.
     563        i++;
     564    }   // end while: through flavors
     565
     566    // If logging is enabled, show data flavors
     567    if( out != null )
     568    {   if( flavors.length == 0 ) {
     569        log( out, "FileDrop: no data flavors." );
     570    }
     571    for( i = 0; i < flavors.length; i++ ) {
     572        log( out, flavors[i].toString() );
     573    }
     574    }   // end if: logging enabled
     575
     576    return ok;
    570577    }   // end isDragOk
    571    
    572    
     578
     579
    573580    /** Outputs <tt>message</tt> to <tt>out</tt> if it's not null. */
    574581    private static void log( java.io.PrintStream out, String message )
    575582    {   // Log message if requested
    576         if( out != null )
     583        if( out != null ) {
    577584            out.println( message );
     585        }
    578586    }   // end log
    579587
    580    
    581    
    582    
     588
     589
     590
    583591    /**
    584592     * Removes the drag-and-drop hooks from the component and optionally
     
    594602    {   return remove( null, c, true );
    595603    }   // end remove
    596    
    597    
    598    
     604
     605
     606
    599607    /**
    600608     * Removes the drag-and-drop hooks from the component and optionally
     
    611619        if( supportsDnD() )
    612620        {   log( out, "FileDrop: Removing drag-and-drop hooks." );
    613             c.setDropTarget( null );
    614             if( recursive && ( c instanceof java.awt.Container ) )
    615             {   java.awt.Component[] comps = ((java.awt.Container)c).getComponents();
    616                 for( int i = 0; i < comps.length; i++ )
    617                     remove( out, comps[i], recursive );
    618                 return true;
    619             }   // end if: recursive
    620             else return false;
     621        c.setDropTarget( null );
     622        if( recursive && ( c instanceof java.awt.Container ) )
     623        {   java.awt.Component[] comps = ((java.awt.Container)c).getComponents();
     624        for( int i = 0; i < comps.length; i++ ) {
     625            remove( out, comps[i], recursive );
     626        }
     627        return true;
     628        }   // end if: recursive
     629        else return false;
    621630        }   // end if: supports DnD
    622631        else return false;
    623632    }   // end remove
    624    
    625    
    626 
    627    
    628 /* ********  I N N E R   I N T E R F A C E   L I S T E N E R  ******** */   
    629    
    630    
     633
     634
     635
     636
     637    /* ********  I N N E R   I N T E R F A C E   L I S T E N E R  ******** */
     638
     639
    631640    /**
    632641     * Implement this inner interface to listen for when files are dropped. For example
     
    645654     */
    646655    public static interface Listener {
    647        
     656
    648657        /**
    649658         * This method is called when files have been successfully dropped.
     
    653662         */
    654663        public abstract void filesDropped( java.io.File[] files );
    655        
    656        
     664
     665
    657666    }   // end inner-interface Listener
    658    
    659    
    660 /* ********  I N N E R   C L A S S  ******** */   
    661    
    662    
     667
     668
     669    /* ********  I N N E R   C L A S S  ******** */
     670
     671
    663672    /**
    664673     * This is the event that is passed to the
     
    701710            return files;
    702711        }   // end getFiles
    703    
     712
    704713    }   // end inner class Event
    705    
    706    
    707    
    708 /* ********  I N N E R   C L A S S  ******** */
    709    
     714
     715
     716
     717    /* ********  I N N E R   C L A S S  ******** */
     718
    710719
    711720    /**
     
    737746     * </code></pre>
    738747     *
    739      * The {@link java.awt.datatransfer.DataFlavor} associated with 
     748     * The {@link java.awt.datatransfer.DataFlavor} associated with
    740749     * {@link TransferableObject} has the representation class
    741750     * <tt>net.iharder.dnd.TransferableObject.class</tt> and MIME type
     
    754763    {
    755764        /**
    756          * The MIME type for {@link #DATA_FLAVOR} is 
     765         * The MIME type for {@link #DATA_FLAVOR} is
    757766         * <tt>application/x-net.iharder.dnd.TransferableObject</tt>.
    758767         *
     
    766775         * {@link TransferableObject} has the representation class
    767776         * <tt>net.iharder.dnd.TransferableObject.class</tt>
    768          * and the MIME type 
     777         * and the MIME type
    769778         * <tt>application/x-net.iharder.dnd.TransferableObject</tt>.
    770779         *
    771780         * @since 1.1
    772781         */
    773         public final static java.awt.datatransfer.DataFlavor DATA_FLAVOR = 
     782        public final static java.awt.datatransfer.DataFlavor DATA_FLAVOR =
    774783            new java.awt.datatransfer.DataFlavor( FileDrop.TransferableObject.class, MIME_TYPE );
    775784
     
    778787        private Object data;
    779788
    780         private java.awt.datatransfer.DataFlavor customFlavor; 
     789        private java.awt.datatransfer.DataFlavor customFlavor;
    781790
    782791
     
    785794         * Creates a new {@link TransferableObject} that wraps <var>data</var>.
    786795         * Along with the {@link #DATA_FLAVOR} associated with this class,
    787          * this creates a custom data flavor with a representation class 
     796         * this creates a custom data flavor with a representation class
    788797         * determined from <code>data.getClass()</code> and the MIME type
    789798         * <tt>application/x-net.iharder.dnd.TransferableObject</tt>.
     
    794803        public TransferableObject( Object data )
    795804        {   this.data = data;
    796             this.customFlavor = new java.awt.datatransfer.DataFlavor( data.getClass(), MIME_TYPE );
     805        this.customFlavor = new java.awt.datatransfer.DataFlavor( data.getClass(), MIME_TYPE );
    797806        }   // end constructor
    798807
     
    830839        public TransferableObject( Class dataClass, Fetcher fetcher )
    831840        {   this.fetcher = fetcher;
    832             this.customFlavor = new java.awt.datatransfer.DataFlavor( dataClass, MIME_TYPE );
     841        this.customFlavor = new java.awt.datatransfer.DataFlavor( dataClass, MIME_TYPE );
    833842        }   // end constructor
    834843
     
    846855
    847856
    848     /* ********  T R A N S F E R A B L E   M E T H O D S  ******** */   
     857        /* ********  T R A N S F E R A B L E   M E T H O D S  ******** */
    849858
    850859
     
    859868         * @since 1.1
    860869         */
    861         public java.awt.datatransfer.DataFlavor[] getTransferDataFlavors() 
    862         {   
     870        public java.awt.datatransfer.DataFlavor[] getTransferDataFlavors()
     871        {
    863872            if( customFlavor != null )
    864873                return new java.awt.datatransfer.DataFlavor[]
    865                 {   customFlavor,
     874                                                            {   customFlavor,
    866875                    DATA_FLAVOR,
    867876                    java.awt.datatransfer.DataFlavor.stringFlavor
    868                 };  // end flavors array
     877                                                            };  // end flavors array
    869878            else
    870879                return new java.awt.datatransfer.DataFlavor[]
    871                 {   DATA_FLAVOR,
     880                                                            {   DATA_FLAVOR,
    872881                    java.awt.datatransfer.DataFlavor.stringFlavor
    873                 };  // end flavors array
     882                                                            };  // end flavors array
    874883        }   // end getTransferDataFlavors
    875884
     
    888897         */
    889898        public Object getTransferData( java.awt.datatransfer.DataFlavor flavor )
    890         throws java.awt.datatransfer.UnsupportedFlavorException, java.io.IOException 
    891         {   
     899        throws java.awt.datatransfer.UnsupportedFlavorException, java.io.IOException
     900        {
    892901            // Native object
    893902            if( flavor.equals( DATA_FLAVOR ) )
     
    898907                return fetcher == null ? data.toString() : fetcher.getObject().toString();
    899908
    900             // We can't do anything else
    901             throw new java.awt.datatransfer.UnsupportedFlavorException(flavor);
     909                // We can't do anything else
     910                throw new java.awt.datatransfer.UnsupportedFlavorException(flavor);
    902911        }   // end getTransferData
    903912
     
    913922         * @since 1.1
    914923         */
    915         public boolean isDataFlavorSupported( java.awt.datatransfer.DataFlavor flavor ) 
     924        public boolean isDataFlavorSupported( java.awt.datatransfer.DataFlavor flavor )
    916925        {
    917926            // Native object
     
    928937
    929938
    930     /* ********  I N N E R   I N T E R F A C E   F E T C H E R  ******** */   
     939        /* ********  I N N E R   I N T E R F A C E   F E T C H E R  ******** */
    931940
    932941        /**
     
    959968    }   // end class TransferableObject
    960969
    961    
    962    
    963    
    964    
     970
     971
     972
     973
    965974}   // end class FileDrop
  • trunk/src/org/openstreetmap/josm/gui/SelectionManager.java

    r1910 r1911  
    145145     */
    146146    public void mousePressed(MouseEvent e) {
    147         if (e.getButton() == MouseEvent.BUTTON1)
     147        if (e.getButton() == MouseEvent.BUTTON1) {
    148148            mousePosStart = mousePos = e.getPoint();
     149        }
    149150    }
    150151
     
    157158
    158159        if (buttonPressed != 0) {
    159             if (mousePosStart == null)
     160            if (mousePosStart == null) {
    160161                mousePosStart = mousePos = e.getPoint();
     162            }
    161163            paintRect();
    162164        }
     
    191193        boolean alt = (e.getModifiersEx() & MouseEvent.ALT_DOWN_MASK) != 0;
    192194        boolean ctrl = (e.getModifiersEx() & MouseEvent.CTRL_DOWN_MASK) != 0;
    193         if ((e.getModifiersEx() & MouseEvent.BUTTON3_DOWN_MASK) == 0)
     195        if ((e.getModifiersEx() & MouseEvent.BUTTON3_DOWN_MASK) == 0) {
    194196            selectionEndedListener.selectionEnded(r, alt, shift, ctrl);
     197        }
    195198    }
    196199
     
    235238            if ((double)w/h < aspectRatio) {
    236239                int neww = (int)(h*aspectRatio);
    237                 if (mousePos.x < mousePosStart.x)
     240                if (mousePos.x < mousePosStart.x) {
    238241                    x += w - neww;
     242                }
    239243                w = neww;
    240244            } else {
    241245                int newh = (int)(w/aspectRatio);
    242                 if (mousePos.y < mousePosStart.y)
     246                if (mousePos.y < mousePosStart.y) {
    243247                    y += h - newh;
     248                }
    244249                h = newh;
    245250            }
     
    275280        if (clicked) {
    276281            OsmPrimitive osm = nc.getNearest(center);
    277             if (osm != null)
     282            if (osm != null) {
    278283                selection.add(osm);
     284            }
    279285        } else {
    280286            // nodes
    281287            for (Node n : nc.getCurrentDataSet().nodes) {
    282                 if (!n.deleted && !n.incomplete && r.contains(nc.getPoint(n)))
     288                if (!n.deleted && !n.incomplete && r.contains(nc.getPoint(n))) {
    283289                    selection.add(n);
     290                }
    284291            }
    285292
    286293            // ways
    287294            for (Way w : nc.getCurrentDataSet().ways) {
    288                 if (w.deleted || w.getNodesCount() == 0 || w.incomplete)
    289                         continue;
     295                if (w.deleted || w.getNodesCount() == 0 || w.incomplete) {
     296                    continue;
     297                }
    290298                if (alt) {
    291299                    for (Node n : w.getNodes()) {
     
    303311                        }
    304312                    }
    305                     if (allIn) selection.add(w);
     313                    if (allIn) {
     314                        selection.add(w);
     315                    }
    306316                }
    307317            }
  • trunk/src/org/openstreetmap/josm/gui/conflict/nodes/NodeListTableCellRenderer.java

    r1790 r1911  
    167167        reset();
    168168        switch(column) {
    169         case 0:
    170             renderRowId(getModel(table),row, isSelected);
    171             break;
    172         case 1:
    173             if (node == null) {
    174                 renderEmptyRow();
    175             } else {
    176                 renderNode(getModel(table), node, row, isSelected);
    177             }
    178             break;
    179         default:
    180             // should not happen
    181             throw new RuntimeException(tr("unexpected column index. Got {0}", column));
     169            case 0:
     170                renderRowId(getModel(table),row, isSelected);
     171                break;
     172            case 1:
     173                if (node == null) {
     174                    renderEmptyRow();
     175                } else {
     176                    renderNode(getModel(table), node, row, isSelected);
     177                }
     178                break;
     179            default:
     180                // should not happen
     181                throw new RuntimeException(tr("unexpected column index. Got {0}", column));
    182182        }
    183183        return this;
     
    189189     * @return the table model
    190190     */
     191    @SuppressWarnings("unchecked")
    191192    protected ListMergeModel<Node>.EntriesTableModel getModel(JTable table) {
    192193        return (ListMergeModel.EntriesTableModel)table.getModel();
  • trunk/src/org/openstreetmap/josm/gui/conflict/relation/RelationMemberTableCellRenderer.java

    r1790 r1911  
    198198        renderForeground(getModel(table), member, row, column, isSelected);
    199199        switch(column) {
    200         case 0:
    201             renderRowId(row);
    202             break;
    203         case 1:
    204             if (member == null) {
    205                 renderEmptyRow();
    206             } else {
    207                 renderRole(member);
    208             }
    209             break;
    210         case 2:
    211             if (member == null) {
    212                 renderEmptyRow();
    213             } else {
    214                 renderPrimitive(member);
    215             }
    216             break;
    217         default:
    218             // should not happen
     200            case 0:
     201                renderRowId(row);
     202                break;
     203            case 1:
     204                if (member == null) {
     205                    renderEmptyRow();
     206                } else {
     207                    renderRole(member);
     208                }
     209                break;
     210            case 2:
     211                if (member == null) {
     212                    renderEmptyRow();
     213                } else {
     214                    renderPrimitive(member);
     215                }
     216                break;
     217            default:
     218                // should not happen
    219219        }
    220220        return this;
     
    226226     * @return the table model
    227227     */
     228    @SuppressWarnings("unchecked")
    228229    protected ListMergeModel<Node>.EntriesTableModel getModel(JTable table) {
    229230        return (ListMergeModel.EntriesTableModel)table.getModel();
  • trunk/src/org/openstreetmap/josm/gui/dialogs/LayerListDialog.java

    r1896 r1911  
    3232import javax.swing.ListModel;
    3333import javax.swing.ListSelectionModel;
    34 import javax.swing.SwingUtilities;
    3534import javax.swing.UIManager;
    3635import javax.swing.event.ListDataEvent;
     
    314313            );
    315314            switch(ret) {
    316             case ConditionalOptionPaneUtil.DIALOG_DISABLED_OPTION: return DeleteDecision.deleteAll;
    317             case JOptionPane.CLOSED_OPTION: return DeleteDecision.cancel;
    318             case 0: return DeleteDecision.deleteCurrent;
    319             case 1: return DeleteDecision.dontDeleteCurrent;
    320             case 2: return DeleteDecision.deleteAll;
    321             case 3: return DeleteDecision.cancel;
    322             default:
    323                 // shouldn't happen. This is the safest option.
    324                 return DeleteDecision.cancel;
     315                case ConditionalOptionPaneUtil.DIALOG_DISABLED_OPTION: return DeleteDecision.deleteAll;
     316                case JOptionPane.CLOSED_OPTION: return DeleteDecision.cancel;
     317                case 0: return DeleteDecision.deleteCurrent;
     318                case 1: return DeleteDecision.dontDeleteCurrent;
     319                case 2: return DeleteDecision.deleteAll;
     320                case 3: return DeleteDecision.cancel;
     321                default:
     322                    // shouldn't happen. This is the safest option.
     323                    return DeleteDecision.cancel;
    325324            }
    326325        }
     
    360359                    DeleteDecision decision = confirmDeleteMultipleLayer(layer, i, layers.size());
    361360                    switch(decision) {
    362                     case deleteCurrent: /* do nothing */ break;
    363                     case deleteAll: doAskConfirmation = false; break;
    364                     case dontDeleteCurrent: continue;
    365                     case cancel: return;
     361                        case deleteCurrent: /* do nothing */ break;
     362                        case deleteAll: doAskConfirmation = false; break;
     363                        case dontDeleteCurrent: continue;
     364                        case cancel: return;
    366365                    }
    367366                }
     
    674673    public class LayerListModel extends DefaultListModel implements LayerChangeListener, PropertyChangeListener{
    675674
    676         //private ArrayList<Layer> layers;
     675        /** manages list selection state*/
    677676        private DefaultListSelectionModel selectionModel;
    678677        private CopyOnWriteArrayList<LayerListModelListener> listeners;
    679678
     679        /**
     680         * constructor
     681         *
     682         * @param selectionModel the list selection model
     683         */
    680684        private LayerListModel(DefaultListSelectionModel selectionModel) {
    681685            this.selectionModel = selectionModel;
     
    683687        }
    684688
     689        /**
     690         * Adds a listener to this model
     691         *
     692         * @param listener the listener
     693         */
    685694        public void addLayerListModelListener(LayerListModelListener listener) {
    686695            synchronized(listeners) {
     
    691700        }
    692701
     702        /**
     703         * removes a listener from  this model
     704         * @param listener the listener
     705         *
     706         */
    693707        public void removeLayerListModelListener(LayerListModelListener listener) {
    694708            synchronized(listeners) {
     
    699713        }
    700714
     715        /**
     716         * Fires a make visible event to listeners
     717         *
     718         * @param index the index of the row to make visible
     719         * @param layer the layer at this index
     720         * @see LayerListModelListener#makeVisible(int, Layer)
     721         */
    701722        protected void fireMakeVisible(int index, Layer layer) {
    702723            for (LayerListModelListener listener : listeners) {
     
    705726        }
    706727
     728        /**
     729         * Fires a refresh event to listeners of this model
     730         *
     731         * @see LayerListModelListener#refresh()
     732         */
    707733        protected void fireRefresh() {
    708734            for (LayerListModelListener listener : listeners) {
     
    711737        }
    712738
     739        /**
     740         * Populates the model with the current layers managed by
     741         * {@see MapView}.
     742         *
     743         */
    713744        public void populate() {
    714             if (getLayers() != null) {
    715                 for (Layer layer: getLayers()) {
    716                     // make sure the model is registered exactly once
    717                     //
    718                     layer.removePropertyChangeListener(this);
    719                     layer.addPropertyChangeListener(this);
    720                 }
     745            for (Layer layer: getLayers()) {
     746                // make sure the model is registered exactly once
     747                //
     748                layer.removePropertyChangeListener(this);
     749                layer.addPropertyChangeListener(this);
    721750            }
    722751            fireContentsChanged(this, 0, getSize());
    723752        }
    724753
     754        /**
     755         * Marks <code>layer</code> as selected layer. Ignored, if
     756         * layer is null.
     757         *
     758         * @param layer the layer.
     759         */
    725760        public void setSelectedLayer(Layer layer) {
    726             if (layer == null || getLayers() == null)
     761            if (layer == null)
    727762                return;
    728763            int idx = getLayers().indexOf(layer);
     
    734769        }
    735770
     771        /**
     772         * Replies the list of currently selected layers. Never null, but may
     773         * be empty.
     774         *
     775         * @return the list of currently selected layers. Never null, but may
     776         * be empty.
     777         */
    736778        public List<Layer> getSelectedLayers() {
    737779            ArrayList<Layer> selected = new ArrayList<Layer>();
    738             if (getLayers() == null) return selected;
    739780            for (int i=0; i<getLayers().size(); i++) {
    740781                if (selectionModel.isSelectedIndex(i)) {
     
    745786        }
    746787
     788        /**
     789         * Replies a the list of indices of the selected rows. Never null,
     790         * but may be empty.
     791         *
     792         * @return  the list of indices of the selected rows. Never null,
     793         * but may be empty.
     794         */
    747795        public List<Integer> getSelectedRows() {
    748796            ArrayList<Integer> selected = new ArrayList<Integer>();
    749             if (getLayers() == null) return selected;
    750797            for (int i=0; i<getLayers().size();i++) {
    751798                if (selectionModel.isSelectedIndex(i)) {
     
    756803        }
    757804
    758         protected void removeLayer(Layer layer) {
     805        /**
     806         * Invoked if a layer managed by {@see MapView} is removed
     807         *
     808         * @param layer the layer which is removed
     809         */
     810        protected void onRemoveLayer(Layer layer) {
    759811            if (layer == null)
    760812                return;
     813            int size = getSize();
     814            List<Integer> rows = getSelectedRows();
     815            if (rows.isEmpty() && size > 0) {
     816                selectionModel.setSelectionInterval(size-1, size-1);
     817            }
    761818            fireRefresh();
    762819            ensureSelectedIsVisible();
    763820        }
    764821
    765         protected void addLayer(Layer layer) {
     822        /**
     823         * Invoked when a layer managed by {@see MapView} is added
     824         *
     825         * @param layer the layer
     826         */
     827        protected void onAddLayer(Layer layer) {
    766828            if (layer == null) return;
    767829            layer.addPropertyChangeListener(this);
     
    769831        }
    770832
     833        /**
     834         * Replies the first layer. Null if no layers are present
     835         *
     836         * @return the first layer. Null if no layers are present
     837         */
    771838        public Layer getFirstLayer() {
    772839            if (getSize() == 0) return null;
     
    774841        }
    775842
     843        /**
     844         * Replies the layer at position <code>index</code>
     845         *
     846         * @param index the index
     847         * @return the layer at position <code>index</code>. Null,
     848         * if index is out of range.
     849         */
    776850        public Layer getLayer(int index) {
    777851            if (index < 0 || index >= getSize())
     
    780854        }
    781855
     856        /**
     857         * Replies true if the the currently selected layers can move up
     858         * by one position
     859         *
     860         * @return true if the the currently selected layers can move up
     861         * by one position
     862         */
    782863        public boolean canMoveUp() {
    783864            List<Integer> sel = getSelectedRows();
     
    785866        }
    786867
     868        /**
     869         * Move up the currently selected layers by one position
     870         *
     871         */
    787872        public void moveUp() {
    788873            if (!canMoveUp()) return;
     
    802887        }
    803888
     889        /**
     890         * Replies true if the currently selected layers can move down
     891         * by one position
     892         *
     893         * @return true if the currently selected layers can move down
     894         * by one position
     895         */
    804896        public boolean canMoveDown() {
    805897            List<Integer> sel = getSelectedRows();
     
    807899        }
    808900
     901        /**
     902         * Move down the currently selected layers by one position
     903         *
     904         */
    809905        public void moveDown() {
    810906            if (!canMoveDown()) return;
     
    825921        }
    826922
     923        /**
     924         * Make sure the first of the selected layers is visible in the
     925         * views of this model.
     926         *
     927         */
    827928        protected void ensureSelectedIsVisible() {
    828929            int index = selectionModel.getMinSelectionIndex();
    829930            if (index <0 )return;
    830             if (getLayers() == null) return;
    831931            if (index >= getLayers().size()) return;
    832932            Layer layer = getLayers().get(index);
     
    834934        }
    835935
    836         public List<Layer> getPossibleMergeTargets(Layer layer) {
     936        /**
     937         * Replies a list of layers which are possible merge targets
     938         * for <code>source</code>
     939         *
     940         * @param source the source layer
     941         * @return a list of layers which are possible merge targets
     942         * for <code>source</code>. Never null, but can be empty.
     943         */
     944        public List<Layer> getPossibleMergeTargets(Layer source) {
    837945            ArrayList<Layer> targets = new ArrayList<Layer>();
    838             if (layer == null)
     946            if (source == null)
    839947                return targets;
    840948            for(Layer target: getLayers()) {
    841                 if (layer == target) {
     949                if (source == target) {
    842950                    continue;
    843951                }
    844                 if (target.isMergable(layer)) {
     952                if (target.isMergable(source)) {
    845953                    targets.add(target);
    846954                }
     
    849957        }
    850958
     959        /**
     960         * Activates the layer <code>layer</code>
     961         *
     962         * @param layer the layer
     963         */
    851964        public void activateLayer(Layer layer) {
     965            if (layer == null)
     966                return;
    852967            Main.map.mapView.moveLayer(layer,0);
    853968            Main.map.mapView.setActiveLayer(layer);
     
    857972        }
    858973
     974        /**
     975         * Replies the list of layers currently managed by {@see MapView}.
     976         * Never null, but can be empty.
     977         *
     978         * @return the list of layers currently managed by {@see MapView}.
     979         * Never null, but can be empty.
     980         */
    859981        protected List<Layer> getLayers() {
    860             if (Main.map == null) return null;
    861             if (Main.map.mapView == null) return null;
     982            if (Main.map == null || Main.map.mapView == null)
     983                return Collections.<Layer>emptyList();
    862984            return Main.map.mapView.getAllLayersAsList();
    863985        }
     
    8981020
    8991021        public void layerAdded(Layer newLayer) {
    900             addLayer(newLayer);
     1022            onAddLayer(newLayer);
    9011023        }
    9021024
    9031025        public void layerRemoved(final Layer oldLayer) {
    904             SwingUtilities.invokeLater(
    905                     new Runnable() {
    906                         public void run() {
    907                             removeLayer(oldLayer);
    908                         }
    909                     }
    910             );
    911         }
    912 
     1026            onRemoveLayer(oldLayer);
     1027        }
    9131028
    9141029        /* ------------------------------------------------------------------------------ */
  • trunk/src/org/openstreetmap/josm/gui/dialogs/PropertiesDialog.java

    r1861 r1911  
    133133     * @param row The row of the table from which the value is edited.
    134134     */
     135    @SuppressWarnings("unchecked")
    135136    void propertyEdit(int row) {
    136137        Collection<OsmPrimitive> sel = Main.main.getCurrentDataSet().getSelected();
     
    488489                    String str = null;
    489490                    switch (column) {
    490                     case 0:
    491                         str = (String) value;
    492                         break;
    493                     case 1:
    494                         Map<String, Integer> v = (Map<String,Integer>) value;
    495                         if (v.size()!=1) {
    496                             str=tr("<different>");
    497                             c.setFont(c.getFont().deriveFont(Font.ITALIC));
    498                         } else {
    499                             str=v.entrySet().iterator().next().getKey();
    500                         }
    501                         break;
     491                        case 0:
     492                            str = (String) value;
     493                            break;
     494                        case 1:
     495                            Map<String, Integer> v = (Map<String,Integer>) value;
     496                            if (v.size()!=1) {
     497                                str=tr("<different>");
     498                                c.setFont(c.getFont().deriveFont(Font.ITALIC));
     499                            } else {
     500                                str=v.entrySet().iterator().next().getKey();
     501                            }
     502                            break;
    502503                    }
    503504                    ((JLabel)c).setText(str);
     
    524525
    525526        membershipTable.getColumnModel().getColumn(1).setCellRenderer(new DefaultTableCellRenderer() {
     527            @SuppressWarnings("unchecked")
    526528            @Override public Component getTableCellRendererComponent(JTable table, Object value,
    527529                    boolean isSelected, boolean hasFocus, int row, int column) {
  • trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/Marker.java

    r1724 r1911  
    7070
    7171    public final void setCoor(LatLon coor) {
    72         if(this.coor == null)
     72        if(this.coor == null) {
    7373            this.coor = new CachedLatLon(coor);
    74         else
     74        } else {
    7575            this.coor.setCoor(coor);
     76        }
    7677    }
    7778
     
    9899    static {
    99100        Marker.markerProducers.add(new MarkerProducers() {
     101            @SuppressWarnings("unchecked")
    100102            public Marker createMarker(WayPoint wpt, File relativePath, MarkerLayer parentLayer, double time, double offset) {
    101103                String uri = null;
     
    110112
    111113                // Try a relative file:// url, if the link is not in an URL-compatible form
    112                 if (relativePath != null && uri != null && !isWellFormedAddress(uri))
     114                if (relativePath != null && uri != null && !isWellFormedAddress(uri)) {
    113115                    uri = new File(relativePath.getParentFile(), uri).toURI().toString();
     116                }
    114117
    115118                String name_desc = "";
     
    147150        this.time = time;
    148151        Icon symbol = ImageProvider.getIfAvailable("markers",iconName);
    149         if (symbol == null)
     152        if (symbol == null) {
    150153            symbol = ImageProvider.getIfAvailable("symbols",iconName);
    151         if (symbol == null)
     154        }
     155        if (symbol == null) {
    152156            symbol = ImageProvider.getIfAvailable("nodes",iconName);
     157        }
    153158        this.symbol = symbol;
    154159        this.parentLayer = parentLayer;
     
    190195        }
    191196
    192         if ((text != null) && (show.equalsIgnoreCase("show")))
     197        if ((text != null) && (show.equalsIgnoreCase("show"))) {
    193198            g.drawString(text, screen.x+4, screen.y+2);
     199        }
    194200    }
    195201
  • trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/MarkerLayer.java

    r1890 r1911  
    6363    public GpxLayer fromLayer = null;
    6464
     65    @SuppressWarnings("unchecked")
    6566    public MarkerLayer(GpxData indata, String name, File associatedFile, GpxLayer fromLayer) {
    6667
Note: See TracChangeset for help on using the changeset viewer.