Changeset 4932 in josm


Ignore:
Timestamp:
Feb 14, 2012 9:27:53 PM (15 months ago)
Author:
stoecker
Message:

fix 6833 - use WindowGeometry for toggle dialogs and mainwindow replacing old custom methods, improve dual screen handling

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

Legend:

Unmodified
Added
Removed

  • trunk/src/org/openstreetmap/josm/Main.java

    r4908 r4932  
    55import java.awt.BorderLayout; 
    66import java.awt.Component; 
    7 import java.awt.Dimension; 
    87import java.awt.GridBagConstraints; 
    98import java.awt.GridBagLayout; 
    10 import java.awt.Rectangle; 
    11 import java.awt.Toolkit; 
    129import java.awt.event.ComponentEvent; 
    1310import java.awt.event.ComponentListener; 
    … …  
    9087import org.openstreetmap.josm.tools.Shortcut; 
    9188import org.openstreetmap.josm.tools.Utils; 
     89import org.openstreetmap.josm.tools.WindowGeometry; 
    9290 
    9391abstract public class Main { 
    … …  
    421419    public static final JPanel panel = new JPanel(new BorderLayout()); 
    422420 
    423     protected static Rectangle bounds; 
     421    protected static WindowGeometry geometry; 
    424422    protected static int windowState = JFrame.NORMAL; 
    425423 
    … …  
    474472        } 
    475473 
    476         Dimension screenDimension = Toolkit.getDefaultToolkit().getScreenSize(); 
    477         String geometry = null; 
    478         if (args.containsKey("geometry")) { 
    479             geometry = args.get("geometry").iterator().next(); 
    480         } else { 
    481             geometry = Main.pref.get("gui.geometry"); 
    482         } 
    483         if (geometry.length() != 0) { 
    484             final Matcher m = Pattern.compile("(\\d+)x(\\d+)(([+-])(\\d+)([+-])(\\d+))?").matcher(geometry); 
    485             if (m.matches()) { 
    486                 int w = Integer.valueOf(m.group(1)); 
    487                 int h = Integer.valueOf(m.group(2)); 
    488                 int x = 0, y = 0; 
    489                 if (m.group(3) != null) { 
    490                     x = Integer.valueOf(m.group(5)); 
    491                     y = Integer.valueOf(m.group(7)); 
    492                     if (m.group(4).equals("-")) { 
    493                         x = screenDimension.width - x - w; 
    494                     } 
    495                     if (m.group(6).equals("-")) { 
    496                         y = screenDimension.height - y - h; 
    497                     } 
    498                 } 
    499                 // copied from WindowsGeometry.applySafe() 
    500                 if (x > Toolkit.getDefaultToolkit().getScreenSize().width - 10) { 
    501                     x = 0; 
    502                 } 
    503                 if (y > Toolkit.getDefaultToolkit().getScreenSize().height - 10) { 
    504                     y = 0; 
    505                 } 
    506                 bounds = new Rectangle(x,y,w,h); 
    507                 if(!Main.pref.get("gui.geometry").equals(geometry)) { 
    508                     // remember this geometry 
    509                     Main.pref.put("gui.geometry", geometry); 
    510                 } 
    511             } else { 
    512                 System.out.println("Ignoring malformed geometry: "+geometry); 
    513             } 
    514         } 
    515         if (bounds == null) { 
    516             bounds = !args.containsKey("no-maximize") ? new Rectangle(0,0,screenDimension.width,screenDimension.height) : new Rectangle(1000,740); 
    517         } 
     474        geometry = WindowGeometry.mainWindow("gui.geometry", 
     475            (args.containsKey("geometry") ? args.get("geometry").iterator().next() : null), 
     476            !args.containsKey("no-maximize")); 
    518477    } 
    519478 
    … …  
    608567    public static boolean exitJosm(boolean exit) { 
    609568        if (Main.saveUnsavedModifications()) { 
    610             Main.saveGuiGeometry(); 
     569            geometry.remember("gui.geometry"); 
     570            if (map  != null) { 
     571                map.rememberToggleDialogWidth(); 
     572            } 
     573            pref.put("gui.maximized", (windowState & JFrame.MAXIMIZED_BOTH) != 0); 
    611574            // Remove all layers because somebody may rely on layerRemoved events (like AutosaveTask) 
    612575            if (Main.isDisplayingMapView()) { 
    … …  
    714677    } 
    715678 
    716     static public void saveGuiGeometry() { 
    717         // save the current window geometry and the width of the toggle dialog area 
    718         String newGeometry = ""; 
    719         String newToggleDlgWidth = null; 
    720         try { 
    721             Dimension screenDimension = Toolkit.getDefaultToolkit().getScreenSize(); 
    722             int width = (int)bounds.getWidth(); 
    723             int height = (int)bounds.getHeight(); 
    724             int x = (int)bounds.getX(); 
    725             int y = (int)bounds.getY(); 
    726             if (width > screenDimension.width) { 
    727                 width = screenDimension.width; 
    728             } 
    729             if (height > screenDimension.height) { 
    730                 width = screenDimension.height; 
    731             } 
    732             if (x < 0) { 
    733                 x = 0; 
    734             } 
    735             if (y < 0) { 
    736                 y = 0; 
    737             } 
    738             newGeometry = width + "x" + height + "+" + x + "+" + y; 
    739  
    740             if (map  != null) { 
    741                 newToggleDlgWidth = Integer.toString(map.getToggleDlgWidth()); 
    742                 if (newToggleDlgWidth.equals(Integer.toString(MapFrame.DEF_TOGGLE_DLG_WIDTH))) { 
    743                     newToggleDlgWidth = ""; 
    744                 } 
    745             } 
    746         } 
    747         catch (Exception e) { 
    748             System.out.println("Failed to get GUI geometry: " + e); 
    749             e.printStackTrace(); 
    750         } 
    751         boolean maximized = (windowState & JFrame.MAXIMIZED_BOTH) != 0; 
    752         // Main.debug("Main window: saving geometry \"" + newGeometry + "\" " + (maximized?"maximized":"normal")); 
    753         pref.put("gui.maximized", maximized); 
    754         pref.put("gui.geometry", newGeometry); 
    755         if (newToggleDlgWidth != null) { 
    756             pref.put("toggleDialogs.width", newToggleDlgWidth); 
    757         } 
    758     } 
    759679    private static class WindowPositionSizeListener extends WindowAdapter implements 
    760680    ComponentListener { 
    761  
    762681        @Override 
    763682        public void windowStateChanged(WindowEvent e) { 
    764683            Main.windowState = e.getNewState(); 
    765             // Main.debug("Main window state changed to " + Main.windowState); 
    766         } 
    767  
     684        } 
     685 
     686        @Override 
    768687        public void componentHidden(ComponentEvent e) { 
    769688        } 
    770689 
     690        @Override 
    771691        public void componentMoved(ComponentEvent e) { 
    772692            handleComponentEvent(e); 
    773693        } 
    774694 
     695        @Override 
    775696        public void componentResized(ComponentEvent e) { 
    776697            handleComponentEvent(e); 
    777698        } 
    778699 
     700        @Override 
    779701        public void componentShown(ComponentEvent e) { 
    780702        } 
    … …  
    782704        private void handleComponentEvent(ComponentEvent e) { 
    783705            Component c = e.getComponent(); 
    784             if (c instanceof JFrame) { 
    785                 if (Main.windowState == JFrame.NORMAL) { 
    786                     Main.bounds = ((JFrame) c).getBounds(); 
    787                     // Main.debug("Main window: new geometry " + Main.bounds); 
    788                 } else { 
    789                     // Main.debug("Main window state is " + Main.windowState); 
    790                 } 
    791             } 
    792         } 
    793  
     706            if (c instanceof JFrame && c.isVisible() && Main.windowState == JFrame.NORMAL) { 
     707                Main.geometry = new WindowGeometry((JFrame) c); 
     708            } 
     709        } 
    794710    } 
    795711    public static void addListener() { 

  • trunk/src/org/openstreetmap/josm/actions/AutoScaleAction.java

    r4921 r4932  
    214214        } 
    215215        else if (mode.equals("download")) { 
    216             if (Main.pref.hasKey("osm-download.bounds")) { 
     216            if (!Main.pref.get("osm-download.bounds").isEmpty()) { 
    217217                try { 
    218218                    v.visit(new Bounds(Main.pref.get("osm-download.bounds"), ";")); 

  • trunk/src/org/openstreetmap/josm/data/Preferences.java

    r4920 r4932  
    334334    } 
    335335 
     336 /*   @Deprecated 
    336337    synchronized public boolean hasKey(final String key) { 
    337338        return properties.containsKey(key); 
    338     } 
     339    }*/ 
    339340 
    340341    /** 
    … …  
    638639            } 
    639640        } 
     641        removeObsolete(); 
    640642    } 
    641643 
    … …  
    17271729        return b.toString(); 
    17281730    } 
     1731 
     1732    /** 
     1733     * Removes obsolete preference settings. If you throw out a once-used preference 
     1734     * setting, add it to the list here with an expiry date (written as comment). If you 
     1735     * see something with an expiry date in the past, remove it from the list. 
     1736     */ 
     1737    public void removeObsolete() { 
     1738        String[] obsolete = { 
     1739                "edit.make-parallel-way-action.snap-threshold",  // 10/2011 - replaced by snap-threshold-percent. Can be removed mid 2012 
     1740        }; 
     1741        for (String key : obsolete) { 
     1742            boolean removed = false; 
     1743            if(properties.containsKey(key)) { properties.remove(key); removed = true; } 
     1744            if(collectionProperties.containsKey(key)) { collectionProperties.remove(key); removed = true; } 
     1745            if(arrayProperties.containsKey(key)) { arrayProperties.remove(key); removed = true; } 
     1746            if(listOfStructsProperties.containsKey(key)) { listOfStructsProperties.remove(key); removed = true; } 
     1747            if(removed) 
     1748                System.out.println(tr("Preference setting {0} has been removed since it is no longer used.", key)); 
     1749        } 
     1750    } 
    17291751} 

  • trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/MapRendererFactory.java

    r4310 r4932  
    115115    private MapRendererFactory() { 
    116116        registerDefaultRenderers(); 
    117         boolean drawWireframe = false; 
    118         if (Main.pref.hasKey("draw.wireframe")) { 
    119             drawWireframe = Main.pref.getBoolean("draw.wireframe",false); 
    120             /* 
    121              * transition 05/2011 - 'draw.wireframe' isn't supported anymore. Remove 
    122              * it from the preferences. 
    123              * Can be removed after ~ 01/2012 
    124              */ 
    125             Main.pref.put("draw.wireframe", null); 
    126         } 
    127         if (drawWireframe){ 
    128             activate(WireframeMapRenderer.class); 
    129             return; 
    130         } 
    131  
    132117        String rendererClassName = Main.pref.get(PREF_KEY_RENDERER_CLASS_NAME, null); 
    133118        if (rendererClassName != null) { 

  • trunk/src/org/openstreetmap/josm/data/preferences/AbstractProperty.java

    r4282 r4932  
    1919 
    2020    public boolean isSet() { 
    21         return Main.pref.hasKey(key); 
     21        return !Main.pref.get(key).isEmpty(); 
    2222    } 
    2323 

  • trunk/src/org/openstreetmap/josm/data/preferences/CachedProperty.java

    r4282 r4932  
    2020 
    2121    protected void updateValue() { 
    22         if (Main.pref.hasKey(key)) { 
     22        if (!Main.pref.get(key).isEmpty()) { 
    2323            this.value = fromString(Main.pref.get(key)); 
    2424        } else { 

  • trunk/src/org/openstreetmap/josm/gui/ExtendedDialog.java

    r4571 r4932  
    456456            if(visible) { 
    457457                new WindowGeometry(rememberSizePref, 
    458                         defaultWindowGeometry).applySafeMultiScreen(this); 
     458                        defaultWindowGeometry).applySafe(this); 
    459459            } else { 
    460460                new WindowGeometry(this).remember(rememberSizePref); 

  • trunk/src/org/openstreetmap/josm/gui/MainApplet.java

    r4220 r4932  
    5050            setContentPane(contentPanePrivate); 
    5151            setJMenuBar(menu); 
    52             setBounds(bounds); 
    5352        } 
    5453    } 

  • trunk/src/org/openstreetmap/josm/gui/MainApplication.java

    r4906 r4932  
    6565        mainFrame.setContentPane(contentPanePrivate); 
    6666        mainFrame.setJMenuBar(menu); 
    67         mainFrame.setBounds(bounds); 
     67        geometry.applySafe(mainFrame); 
    6868        LinkedList<Image> l = new LinkedList<Image>(); 
    6969        l.add(ImageProvider.get("logo_16x16x32").getImage()); 
    … …  
    7474        l.add(ImageProvider.get("logo_48x48x8").getImage()); 
    7575        l.add(ImageProvider.get("logo").getImage()); 
    76         //mainFrame.setIconImage(ImageProvider.get("logo").getImage()); 
    7776        mainFrame.setIconImages(l); 
    7877        mainFrame.addWindowListener(new WindowAdapter(){ 
    … …  
    247246        monitor.indeterminateSubTask(tr("Setting defaults")); 
    248247        preConstructorInit(args); 
    249         removeObsoletePreferences(); 
    250248 
    251249        monitor.indeterminateSubTask(tr("Creating main GUI")); 
    … …  
    319317            RepaintManager.setCurrentManager(new CheckThreadViolationRepaintManager()); 
    320318        } 
    321  
    322     } 
    323  
    324     /** 
    325      * Removes obsolete preference settings. If you throw out a once-used preference 
    326      * setting, add it to the list here with an expiry date (written as comment). If you 
    327      * see something with an expiry date in the past, remove it from the list. 
    328      */ 
    329     public static void removeObsoletePreferences() { 
    330  
    331         String[] obsolete = { 
    332                 "edit.make-parallel-way-action.snap-threshold"  // 10/2011 - replaced by snap-threshold-percent. Can be removed mid 2012 
    333         }; 
    334         for (String key : obsolete) { 
    335             if (Main.pref.hasKey(key)) { 
    336                 Main.pref.removeFromCollection(key, Main.pref.get(key)); 
    337                 System.out.println(tr("Preference setting {0} has been removed since it is no longer used.", key)); 
    338             } 
    339         } 
    340319    } 
    341320} 

  • trunk/src/org/openstreetmap/josm/gui/MapFrame.java

    r4850 r4932  
    479479 
    480480    /** 
    481      * Returns the current width of the (possibly resized) toggle dialog area 
    482      */ 
    483     public int getToggleDlgWidth() { 
    484         return dialogsPanel.getWidth(); 
     481     * Remember the current width of the (possibly resized) toggle dialog area 
     482     */ 
     483    public void rememberToggleDialogWidth() { 
     484        Main.pref.putInteger("toggleDialogs.width", dialogsPanel.getWidth()); 
    485485    } 
    486486 

  • trunk/src/org/openstreetmap/josm/gui/SplashScreen.java

    r4681 r4932  
    2929import org.openstreetmap.josm.gui.progress.SwingRenderingProgressMonitor; 
    3030import org.openstreetmap.josm.tools.ImageProvider; 
     31import org.openstreetmap.josm.tools.WindowGeometry; 
    3132 
    3233/** 
    … …  
    5859        GridBagConstraints gbc = new GridBagConstraints(); 
    5960        gbc.gridheight = 2; 
     61        gbc.insets = new Insets(0, 0, 0, 70); 
    6062        innerContentPane.add(logo, gbc); 
    6163 
    … …  
    9294        pack(); 
    9395 
    94         // Center the splash screen 
    95         setLocationRelativeTo(null); 
     96        WindowGeometry.centerOnScreen(this, "gui.geometry"); 
    9697 
    9798        // Add ability to hide splash screen by clicking it 

  • trunk/src/org/openstreetmap/josm/gui/dialogs/ToggleDialog.java

    r4897 r4932  
    5151import org.openstreetmap.josm.tools.ImageProvider; 
    5252import org.openstreetmap.josm.tools.Shortcut; 
     53import org.openstreetmap.josm.tools.WindowGeometry; 
     54import org.openstreetmap.josm.tools.WindowGeometry.WindowGeometryException; 
    5355 
    5456/** 
    … …  
    507509            }); 
    508510 
    509             String bounds = Main.pref.get(preferencePrefix+".bounds",null); 
    510             if (bounds != null) { 
    511                 String[] b = bounds.split(","); 
    512                 setBounds(getDetachedGeometry(new Rectangle( 
    513                         Integer.parseInt(b[0]),Integer.parseInt(b[1]),Integer.parseInt(b[2]),Integer.parseInt(b[3])))); 
    514             } else { 
     511            try { 
     512                new WindowGeometry(preferencePrefix+".geometry").applySafe(this); 
     513            } catch (WindowGeometryException e) { 
    515514                ToggleDialog.this.setPreferredSize(ToggleDialog.this.getDefaultDetachedSize()); 
    516515                pack(); 
    … …  
    523522        protected void rememberGeometry() { 
    524523            if (detachedDialog != null) { 
    525                 Main.pref.put(preferencePrefix+".bounds", detachedDialog.getX()+","+detachedDialog.getY()+","+detachedDialog.getWidth()+","+detachedDialog.getHeight()); 
     524                new WindowGeometry(detachedDialog).remember(preferencePrefix+".geometry"); 
    526525            } 
    527526        } 

  • trunk/src/org/openstreetmap/josm/gui/download/DownloadDialog.java

    r4906 r4932  
    328328            boundingBoxChanged(currentBounds,null); 
    329329        } 
    330         else if (Main.pref.hasKey("osm-download.bounds")) { 
     330        else if (!Main.pref.get("osm-download.bounds").isEmpty()) { 
    331331            // read the bounding box from the preferences 
    332332            try { 

  • trunk/src/org/openstreetmap/josm/gui/history/HistoryBrowserDialogManager.java

    r4760 r4932  
    7474    public void placeOnScreen(HistoryBrowserDialog dialog) { 
    7575        WindowGeometry geometry = WindowGeometry.centerOnScreen(new Dimension(800,500)); 
    76         geometry.apply(dialog); 
     76        geometry.applySafe(dialog); 
    7777        Point p = dialog.getLocation(); 
    7878        while(hasDialogWithCloseUpperLeftCorner(p)) { 

  • trunk/src/org/openstreetmap/josm/gui/io/CredentialDialog.java

    r4690 r4932  
    7575    public void setVisible(boolean visible) { 
    7676        if (visible) { 
    77             WindowGeometry.centerInWindow(Main.parent, new Dimension(350,300)).apply(this); 
     77            WindowGeometry.centerInWindow(Main.parent, new Dimension(350,300)).applySafe(this); 
    7878        } 
    7979        super.setVisible(visible); 

  • trunk/src/org/openstreetmap/josm/gui/io/SaveLayersDialog.java

    r4618 r4932  
    7272    protected void build() { 
    7373        WindowGeometry geometry = WindowGeometry.centerOnScreen(new Dimension(600,300)); 
    74         geometry.apply(this); 
     74        geometry.applySafe(this); 
    7575        getContentPane().setLayout(new BorderLayout()); 
    7676 

  • trunk/src/org/openstreetmap/josm/gui/preferences/GPXSettingsPanel.java

    r4844 r4932  
    297297    public void loadPreferences () { 
    298298        makeAutoMarkers.setSelected(Main.pref.getBoolean("marker.makeautomarkers", true)); 
    299         if(layerName!=null && !Main.pref.hasKey("draw.rawgps.lines."+layerName) 
    300                 && !Main.pref.hasKey("draw.rawgps.lines.local."+layerName)){ 
     299        if(layerName!=null && Main.pref.get("draw.rawgps.lines."+layerName).isEmpty() 
     300                && Main.pref.get("draw.rawgps.lines.local."+layerName).isEmpty()){ 
    301301            // no line preferences for layer is found 
    302302            drawRawGpsLinesGlobal.setSelected(true); 
    … …  
    323323        drawRawGpsLinesActionListener.actionPerformed(null); 
    324324 
    325         if(layerName!=null && !Main.pref.hasKey("draw.rawgps.colors."+layerName)) { 
     325        if(layerName!=null && Main.pref.get("draw.rawgps.colors."+layerName).isEmpty()) { 
    326326            colorTypeGlobal.setSelected(true); 
    327327            colorDynamic.setSelected(false); 

  • trunk/src/org/openstreetmap/josm/io/CacheFiles.java

    r4818 r4932  
    189189    public void setExpire(int amount, boolean force) { 
    190190        String key = "cache." + ident + "." + "expire"; 
    191         if(Main.pref.hasKey(key) && !force) 
     191        if(!Main.pref.get(key).isEmpty() && !force) 
    192192            return; 
    193193 
    … …  
    203203    public void setMaxSize(int amount, boolean force) { 
    204204        String key = "cache." + ident + "." + "maxsize"; 
    205         if(Main.pref.hasKey(key) && !force) 
     205        if(!Main.pref.get(key).isEmpty() && !force) 
    206206            return; 
    207207 

  • trunk/src/org/openstreetmap/josm/tools/WindowGeometry.java

    r4634 r4932  
    138138    } 
    139139 
     140    static public WindowGeometry mainWindow(String preferenceKey, String arg, boolean maximize) { 
     141        Dimension screenDimension = getScreenSize(null); 
     142        if (arg != null) { 
     143            final Matcher m = Pattern.compile("(\\d+)x(\\d+)(([+-])(\\d+)([+-])(\\d+))?").matcher(arg); 
     144            if (m.matches()) { 
     145                int w = Integer.valueOf(m.group(1)); 
     146                int h = Integer.valueOf(m.group(2)); 
     147                int x = 0, y = 0; 
     148                if (m.group(3) != null) { 
     149                    x = Integer.valueOf(m.group(5)); 
     150                    y = Integer.valueOf(m.group(7)); 
     151                    if (m.group(4).equals("-")) { 
     152                        x = screenDimension.width - x - w; 
     153                    } 
     154                    if (m.group(6).equals("-")) { 
     155                        y = screenDimension.height - y - h; 
     156                    } 
     157                } 
     158                return new WindowGeometry(new Point(x,y), new Dimension(w,h)); 
     159            } else { 
     160                System.out.println(tr("Ignoring malformed geometry: {0}", arg)); 
     161            } 
     162        } 
     163        WindowGeometry def; 
     164        if(maximize) 
     165            def = new WindowGeometry(new Point(0,0), screenDimension); 
     166        else 
     167            def = new WindowGeometry(new Point(0,0), new Dimension(1000, 740)); 
     168        return new WindowGeometry(preferenceKey, def); 
     169    } 
     170 
    140171    /** 
    141172     * Creates a window geometry from the values kept in the preference store under the 
    … …  
    163194            initFromPreferences(preferenceKey); 
    164195        } catch(WindowGeometryException e) { 
    165             //            System.out.println(tr("Warning: Failed to restore window geometry from key ''{0}''. Falling back to default geometry. Details: {1}", preferenceKey, e.getMessage())); 
    166196            initFromWindowGeometry(defaultGeometry); 
    167197        } 
    … …  
    201231 
    202232    /** 
    203      * Applies this geometry to a window 
    204      * 
     233     * Center window on screen. When preferenceKey is given, the window is centered 
     234     * on the screen where the corresponding window is. 
     235     *  
    205236     * @param window the window 
    206      */ 
    207     public void apply(Window window) { 
    208         window.setLocation(topLeft); 
    209         window.setSize(extent); 
    210     } 
    211  
    212     /** 
    213      * Applies this geometry to a window. Makes sure that the window is not placed outside 
    214      * of the coordinate range of the current screen. 
    215      * 
    216      * @param window the window 
    217      */ 
    218     public void applySafe(Window window) { 
    219         Point p = new Point(topLeft); 
    220         if (p.x < 0 || p.x > Toolkit.getDefaultToolkit().getScreenSize().width - 10) { 
    221             p.x  = 0; 
    222         } 
    223         if (p.y < 0 || p.y > Toolkit.getDefaultToolkit().getScreenSize().height - 10) { 
    224             p.y = 0; 
    225         } 
    226         window.setLocation(p); 
    227         window.setSize(extent); 
    228     } 
    229      
     237     * @param preferenceKey the key to get size and position from 
     238     */ 
     239    public static void centerOnScreen(Window window, String preferenceKey) { 
     240        Dimension dim = getScreenSize(preferenceKey); 
     241        Dimension size = window.getSize(); 
     242        window.setLocation(new Point((dim.width-size.width)/2,(dim.height-size.height)/2)); 
     243    } 
     244 
    230245    /** 
    231246     * Applies this geometry to a window. Makes sure that the window is not 
    … …  
    234249     * @param window the window 
    235250     */ 
    236     public void applySafeMultiScreen(Window window) { 
     251    public void applySafe(Window window) { 
    237252        Point p = new Point(topLeft); 
    238253 
    … …  
    265280    } 
    266281 
     282    /** 
     283     * Find the size of the screen the for given coordinates. Use first screen, 
     284     * when no coordinates are stored or null is passed. 
     285     *  
     286     * @param preferenceKey the key to get size and position from 
     287     */ 
     288    public static Dimension getScreenSize(String preferenceKey) { 
     289        /* TODO: implement this function properly */ 
     290        return Toolkit.getDefaultToolkit().getScreenSize(); 
     291    } 
     292 
    267293    public String toString() { 
    268294        return "WindowGeometry{topLeft="+topLeft+",extent="+extent+"}"; 
Note: See TracChangeset for help on using the changeset viewer.