    001/*****************************************************************************
    002 * Copyright by The HDF Group.                                               *
    003 * Copyright by the Board of Trustees of the University of Illinois.         *
    004 * All rights reserved.                                                      *
    005 *                                                                           *
    006 * This file is part of the HDF Java Products distribution.                  *
    007 * The full copyright notice, including terms governing use, modification,   *
    008 * and redistribution, is contained in the COPYING file, which can be found  *
    009 * at the root of the source code distribution tree,                         *
    010 * or in https://www.hdfgroup.org/licenses.                                  *
    011 * If you do not have access to either file, you may request a copy from     *
    012 * help@hdfgroup.org.                                                        *
    013 ****************************************************************************/
    014
    015package hdf.view;
    016
    017import java.io.File;
    018import java.io.IOException;
    019import java.io.InputStream;
    020import java.net.MalformedURLException;
    021import java.net.URL;
    022import java.net.URLClassLoader;
    023import java.util.ArrayList;
    024import java.util.Arrays;
    025import java.util.Enumeration;
    026import java.util.List;
    027import java.util.jar.JarEntry;
    028import java.util.jar.JarFile;
    029
    030import org.slf4j.Logger;
    031import org.slf4j.LoggerFactory;
    032
    033import org.eclipse.jface.preference.PreferenceStore;
    034import org.eclipse.swt.graphics.Image;
    035
    036import hdf.HDFVersions;
    037import hdf.object.FileFormat;
    038import hdf.view.ImageView.ImageViewFactory;
    039import hdf.view.MetaDataView.MetaDataViewFactory;
    040import hdf.view.PaletteView.PaletteViewFactory;
    041import hdf.view.TableView.TableViewFactory;
    042import hdf.view.TreeView.TreeViewFactory;
    043
    044/** A class to maintain the list of preferences for data and display */
    045public class ViewProperties extends PreferenceStore
    046{
    047    private static final long   serialVersionUID     = -6411465283887959066L;
    048
    049    private static final Logger log = LoggerFactory.getLogger(ViewProperties.class);
    050
    051    /** the version of the HDFViewer */
    052    public static final String  VERSION              = HDFVersions.getPropertyVersionView();
    053
    054    /** the local property file name */
    055    private static final String USER_PROPERTY_FILE   = ".hdfview" + VERSION;
    056
    057    /** the maximum number of most recent files */
    058    public static final int     MAX_RECENT_FILES     = 15;
    059
    060    /** name of the tab delimiter */
    061    public static final String  DELIMITER_TAB        = "Tab";
    062
    063    /** name of the tab delimiter */
    064    public static final String  DELIMITER_COMMA      = "Comma";
    065
    066    /** name of the tab delimiter */
    067    public static final String  DELIMITER_SPACE      = "Space";
    068
    069    /** name of the tab delimiter */
    070    public static final String  DELIMITER_COLON      = "Colon";
    071
    072    /** image origin: UpperLeft */
    073    public static final String  ORIGIN_UL            = "UpperLeft";
    074
    075    /** image origin: LowerLeft */
    076    public static final String  ORIGIN_LL            = "LowerLeft";
    077
    078    /** image origin: UpperRight */
    079    public static final String  ORIGIN_UR            = "UpperRight";
    080
    081    /** image origin: LowerRight */
    082    public static final String  ORIGIN_LR            = "LowerRight";
    083
    084    /** name of the tab delimiter */
    085    public static final String  DELIMITER_SEMI_COLON = "Semi-Colon";
    086
    087    /**
    088     * The names of the various default classes for each HDFView module interface
    089     */
    090
    091    /** Text for default selection of modules */
    092    public static final String DEFAULT_MODULE_TEXT = "Default";
    093
    094    /** Default TreeView class names */
    095    public static final String DEFAULT_TREEVIEW_NAME = "hdf.view.TreeView.DefaultTreeView";
    096
    097    /** Default Scalar TableView class names */
    098    public static final String DEFAULT_SCALAR_DATASET_TABLEVIEW_NAME = "hdf.view.TableView.DefaultScalarDSTableView";
    099    /** Default Compound TableView class names */
    100    public static final String DEFAULT_COMPOUND_DATASET_TABLEVIEW_NAME = "hdf.view.TableView.DefaultCompoundDSTableView";
    101
    102    /** Default Group MetaDataView class names */
    103    public static final String DEFAULT_GROUP_METADATAVIEW_NAME = "hdf.view.MetaDataView.DefaultGroupMetaDataView";
    104    /** Default Dataset MetaDataView class names */
    105    public static final String DEFAULT_DATASET_METADATAVIEW_NAME = "hdf.view.MetaDataView.DefaultDatasetMetaDataView";
    106    /** Default Datatype MetaDataView class names */
    107    public static final String DEFAULT_DATATYPE_METADATAVIEW_NAME = "hdf.view.MetaDataView.DefaultDatatypeMetaDataView";
    108    /** Default Link MetaDataView class names */
    109    public static final String DEFAULT_LINK_METADATAVIEW_NAME = "hdf.view.MetaDataView.DefaultLinkMetaDataView";
    110
    111    /** Default ImageView class names */
    112    public static final String DEFAULT_IMAGEVIEW_NAME = "hdf.view.ImageView.DefaultImageView";
    113
    114    /** Default PaletteView class names */
    115    public static final String DEFAULT_PALETTEVIEW_NAME = "hdf.view.PaletteView.DefaultPaletteView";
    116
    117    /**
    118     * Used to create different DataViews for a given HObject.
    119     */
    120    public static enum DataViewType {
    121        /** */
    122        TABLE,
    123        /** */
    124        IMAGE,
    125        /** */
    126        PALETTE,
    127        /** */
    128        METADATA,
    129        /** */
    130        TREEVIEW
    131    }
    132
    133    /**
    134     * Property keys control how the data is displayed.
    135     */
    136    public static enum DATA_VIEW_KEY {
    137        /** */
    138        CHAR,
    139        /** */
    140        CONVERTBYTE,
    141        /** */
    142        TRANSPOSED,
    143        /** */
    144        READONLY,
    145        /** */
    146        OBJECT,
    147        /** */
    148        BITMASK,
    149        /** */
    150        BITMASKOP,
    151        /** */
    152        BORDER,
    153        /** */
    154        INFO,
    155        /** */
    156        INDEXBASE1,
    157        /** */
    158        VIEW_NAME
    159    }
    160
    161    /**
    162     * Property keys control how the data is displayed.
    163     */
    164    public static enum BITMASK_OP {
    165        /** */
    166        AND,
    167        /** */
    168        EXTRACT
    169    }
    170
    171    /** the root directory of the HDFView */
    172    private static String            rootDir                = System.getProperty("user.dir");
    173
    174    /** user's guide */
    175    private static String            usersGuide             = "/share/doc/UsersGuide/index.html";
    176
    177    /** the font size */
    178    private static int               fontSize               = 12;
    179
    180    /** the font type */
    181    private static String            fontType               = "Serif";
    182
    183    /** the full path of H4toH5 converter */
    184    private static String            h4toh5                 = "";
    185
    186    /** data delimiter */
    187    private static String            delimiter              = DELIMITER_TAB;
    188
    189    /** image origin */
    190    private static String            origin                 = ORIGIN_UL;
    191
    192    /** default index type */
    193    private static String            indexType              = "H5_INDEX_NAME";
    194
    195    /** default index order */
    196    private static String            indexOrder             = "H5_ITER_INC";
    197
    198    /** a list of most recent files */
    199    private static ArrayList<String> recentFiles            = new ArrayList<>(MAX_RECENT_FILES + 5);
    200
    201    /** default starting file directory */
    202    private static String            workDir                = System.getProperty("user.dir");
    203
    204    /** default HDF file extensions */
    205    private static String            fileExt                = "hdf, h4, hdf4, h5, hdf5, he2, he5";
    206
    207    private static ClassLoader       extClassLoader         = null;
    208
    209    /** a list of srb accounts */
    210    private static ArrayList<String[]> srbAccountList       = new ArrayList<>(5);
    211
    212    /** the timer refreshrate in msec */
    213    private static int               timerRefresh           = 10000;
    214
    215    private static boolean           isMac                  = System.getProperty("os.name").toLowerCase().contains("mac");
    216
    217    /**
    218     * flag to indicate if auto contrast is used in image processing. Do not use
    219     * autocontrast by default (2.6 change).
    220     */
    221    private static boolean           isAutoContrast         = false;
    222
    223    private static boolean           showImageValues        = false;
    224
    225    private static boolean           showRegRefValues       = false;
    226
    227    /**
    228     * flag to indicate if default open file mode is read only. By default, use read
    229     * only to prevent accidental modifications to the file.
    230     */
    231    private static boolean           isReadOnly             = true;
    232
    233    /**
    234     * flag to indicate if default open file mode is read SWMR.
    235     */
    236    private static boolean           isReadSWMR             = true;
    237
    238    private static String            EarlyLib               = "Latest";
    239
    240    private static String            LateLib                = "Latest";
    241
    242    /** a list of palette files */
    243    private static ArrayList<String> paletteList            = new ArrayList<>(5);
    244
    245    /** flag to indicate if enum data is converted to strings */
    246    private static boolean           convertEnum            = true;
    247
    248    /** flag to indicate if data is 1-based index */
    249    private static boolean           isIndexBase1           = false;
    250
    251    /**
    252     * Current Java applications such as HDFView cannot handle files with a large
    253     * number of objects such as 1,000,000 objects. max_members defines the maximum
    254     * number of objects that will be loaded into memory.
    255     */
    256    private static int               maxMembers            = Integer.MAX_VALUE;   // load all by default
    257    /**
    258     * Current Java applications such as HDFView cannot handle files with a large
    259     * number of objects such 1,000,000 objects. start_members defines the
    260     * starting index of objects that will be loaded into memory.
    261     */
    262    private static int               startMembers          = 0;
    263
    264    private static Image
    265    hdfviewIcon,
    266    h4Icon, h4IconR, h5Icon, h5IconR, ncIcon, ncIconR,
    267    blankIcon, helpIcon, fileopenIcon, filesaveIcon, filenewIcon, filecloseIcon, foldercloseIcon,
    268    folderopenIcon, foldercloseIconA, folderopenIconA, datasetIcon, imageIcon, tableIcon, textIcon, datasetIconA,
    269    imageIconA, tableIconA, textIconA, zoominIcon, zoomoutIcon, paletteIcon, chartIcon, brightIcon, autocontrastIcon,
    270    copyIcon, cutIcon, pasteIcon, previousIcon, nextIcon, firstIcon, lastIcon, animationIcon, datatypeIcon,
    271    datatypeIconA, linkIcon, iconAPPS, iconURL, iconVIDEO, iconXLS, iconPDF, iconAUDIO, questionIcon;
    272
    273    private static Image[] hdfIcons = new Image[6];
    274
    275    private static String            propertyFile;
    276
    277    /** a list of treeview modules */
    278    private static ArrayList<String> moduleListTreeView = new ArrayList<>(5);
    279
    280    /** a list of metaview modules */
    281    private static ArrayList<String> moduleListMetaDataView = new ArrayList<>(5);
    282
    283    /** a list of tableview modules */
    284    private static ArrayList<String> moduleListTableView = new ArrayList<>(5);
    285
    286    /** a list of imageview modules */
    287    private static ArrayList<String> moduleListImageView = new ArrayList<>(5);
    288
    289    /** a list of paletteview modules */
    290    private static ArrayList<String> moduleListPaletteView = new ArrayList<>(5);
    291
    292    /** a list of helpview modules */
    293    private static ArrayList<String> moduleListHelpView = new ArrayList<>(5);
    294
    295    /**
    296     * Creates a property list with given root directory of the HDFView.
    297     *
    298     * @param viewRoot
    299     *            the root directory of the HDFView
    300     * @param viewStart
    301     *            the starting directory for file searches
    302     */
    303    public ViewProperties(String viewRoot, String viewStart) {
    304        super();
    305
    306        // look for the property file in the user's home directory
    307        String propertyFileName = USER_PROPERTY_FILE;
    308        String userHomeFile = System.getProperty("user.home") + File.separator + propertyFileName;
    309        String userDirFile = System.getProperty("user.dir") + File.separator + propertyFileName;
    310
    311        setFilename(createPropertyFile(userHomeFile, userDirFile));
    312
    313        setRootDir(viewRoot);
    314        log.trace("rootDir is {}", rootDir);
    315        if (viewStart != null)
    316            setWorkDir(viewStart);
    317        setDefault("work.dir", getWorkDir());
    318
    319        setUsersGuide(rootDir + usersGuide);
    320
    321        setDefault("users.guide", viewRoot + "/UsersGuide/index.html");
    322        setDefault("image.contrast", false);
    323        setDefault("image.showvalues", false);
    324        setDefault("file.mode", "r");
    325        setDefault("lib.lowversion", "Earliest");
    326        setDefault("lib.highversion", "Latest");
    327        setDefault("enum.conversion", false);
    328        setDefault("regref.showvalues", false);
    329        setDefault("index.base1", false);
    330        setDefault("image.origin", ORIGIN_UL);
    331        setDefault("h5file.indexType", "H5_INDEX_NAME");
    332        setDefault("h5file.indexOrder", "H5_ITER_INC");
    333        setDefault("h4toh5.converter", "");
    334        setDefault("file.extension", "hdf, h4, hdf4, h5, hdf5, he2, he5");
    335        setDefault("timer.refresh", 1000);
    336        setDefault("font.size", 12);
    337        setDefault("font.type", "Serif");
    338        setDefault("max.members", Integer.MAX_VALUE);
    339        setDefault("recent.file", "");
    340        setDefault("palette.file", "");
    341        setDefault("data.delimiter", DELIMITER_TAB);
    342    }
    343
    344    /**
    345     * Creates a property list file in a directory.
    346     *
    347     * @param userHomeFile
    348     *            the user home directory
    349     * @param userDirFile
    350     *            the user directory
    351     *
    352     * @return property list file
    353     */
    354    public static String createPropertyFile(String userHomeFile, String userDirFile) {
    355        String propFile = System.getProperty("hdfview.propfile");
    356
    357        if ((propFile != null) && ((new File(propFile)).exists()))
    358            propertyFile = propFile;
    359        else if ((new File(userHomeFile)).exists())
    360            propertyFile = userHomeFile;
    361        else if ((new File(userDirFile)).exists())
    362            propertyFile = userDirFile;
    363        else {
    364            File pFile = null;
    365
    366            // If the user specified a property file, but it didn't exist,
    367            // try to create a new one where specified.
    368            if (propFile != null) {
    369                pFile = new File(propFile);
    370
    371                try {
    372                    pFile.createNewFile();
    373                    propertyFile = propFile;
    374                }
    375                catch (Exception ex) {
    376                    log.debug("createPropertyFile(): unable to create property file {}", propFile);
    377                    pFile = null;
    378                }
    379            }
    380
    381            if (pFile == null) {
    382                // Create new property file at user home directory
    383                pFile = new File(userHomeFile);
    384                try {
    385                    pFile.createNewFile();
    386                    propertyFile = userHomeFile;
    387                }
    388                catch (Exception ex) {
    389                    log.debug("createPropertyFile(): unable to create property file in home directory");
    390                    propertyFile = null;
    391                }
    392            }
    393        }
    394
    395        log.trace("propertyFile is {}", propertyFile);
    396        return propertyFile;
    397    }
    398
    399    /**
    400     * load module classes
    401     *
    402     * @return the ClassLoader
    403     */
    404    public static ClassLoader loadExtClass() {
    405        if (extClassLoader != null)
    406            return extClassLoader;
    407        else
    408            // default classloader
    409            extClassLoader = ClassLoader.getSystemClassLoader();
    410        log.trace("loadExtClass: default classloader is {}", extClassLoader);
    411
    412        String rootPath = System.getProperty("hdfview.root");
    413        if (rootPath == null) {
    414            rootPath = rootDir;
    415            log.debug("loadExtClass: rootDir rootPath is {}", rootPath);
    416        }
    417        log.debug("loadExtClass: rootPath is {}", rootPath);
    418
    419        String dirname = rootPath + File.separator + "lib" + File.separator + "ext" + File.separator;
    420        String[] jars = null;
    421        File extdir = null;
    422        try {
    423            extdir = new File(dirname);
    424            jars = extdir.list();
    425        }
    426        catch (Exception ex0) {
    427            log.debug("loadExtClass: load dirname: {}+lib/ext failed", rootPath, ex0);
    428        }
    429
    430        if ((jars == null) || (jars.length <= 0))
    431            return extClassLoader;
    432
    433        ArrayList<String> jarList = new ArrayList<>(50);
    434        ArrayList<String> classList = new ArrayList<>(50);
    435        for (int i = 0; i < jars.length; i++) {
    436            log.trace("loadExtClass: load jar[{}]", i);
    437            if (jars[i].endsWith(".jar")) {
    438                jarList.add(jars[i]);
    439                // add class names to the list of classes
    440                File tmpFile = new File(extdir, jars[i]);
    441                try (JarFile jarFile = new JarFile(tmpFile, false, JarFile.OPEN_READ)) {
    442                    Enumeration<?> emu = jarFile.entries();
    443                    while (emu.hasMoreElements()) {
    444                        JarEntry jarEntry = (JarEntry) emu.nextElement();
    445                        String entryName = jarEntry.getName();
    446                        log.trace("loadExtClass: reading jar[{}] class={}", i, entryName);
    447                        int idx = entryName.indexOf(".class");
    448                        if ((idx > 0) && (entryName.indexOf('$') <= 0)) {
    449                            entryName = entryName.replace('/', '.');
    450                            classList.add(entryName.substring(0, idx));
    451                        }
    452                    }
    453                }
    454                catch (Exception ex) {
    455                    log.debug("loadExtClass: load jar[{}] failed", i, ex);
    456                }
    457            } // (jars[i].endsWith(".jar"))
    458        } // (int i=0; i<jars.length; i++)
    459
    460        int n = jarList.size();
    461        if (n <= 0) {
    462            log.debug("loadExtClass: jarList empty");
    463            return extClassLoader;
    464        }
    465
    466        URL[] urls = new URL[n];
    467        for (int i = 0; i < n; i++) {
    468            try {
    469                urls[i] = new URL("file:///" + rootPath + "/lib/ext/" + jarList.get(i));
    470                log.trace("loadExtClass: load urls[{}] is {}", i, urls[i]);
    471            }
    472            catch (MalformedURLException mfu) {
    473                log.debug("loadExtClass: load urls[{}] failed", i, mfu);
    474            }
    475        }
    476
    477        try {
    478            extClassLoader = URLClassLoader.newInstance(urls);
    479        }
    480        catch (Exception ex) {
    481            ex.printStackTrace();
    482        }
    483
    484        // load user modules into their list
    485        n = classList.size();
    486        for (int i = 0; i < n; i++) {
    487            String theName = classList.get(i);
    488            log.trace("loadExtClass: load classList[{}] is {}", i, theName);
    489            try {
    490                // enables use of JHDF5 in JNLP (Web Start) applications, the
    491                // system class loader with reflection first.
    492                Class<?> theClass = null;
    493                try {
    494                    theClass = Class.forName(theName);
    495                }
    496                catch (Exception ex) {
    497                    try {
    498                        theClass = extClassLoader.loadClass(theName);
    499                    }
    500                    catch (Exception exc) {
    501                        log.debug("load: loadClass({}) failed", theName, ex);
    502                    }
    503                }
    504
    505                if(theClass != null) {
    506                    if (TableViewFactory.class.isAssignableFrom(theClass)) {
    507                        if (!moduleListTableView.contains(theName))
    508                            moduleListTableView.add(theName);
    509                        log.trace("loadExtClass: TableViewFactory class {}", theName);
    510                    }
    511                    else if (MetaDataViewFactory.class.isAssignableFrom(theClass)) {
    512                        if (!moduleListMetaDataView.contains(theName))
    513                            moduleListMetaDataView.add(theName);
    514                        log.trace("loadExtClass: MetaDataViewFactory class {}", theName);
    515                    }
    516                    else if (ImageViewFactory.class.isAssignableFrom(theClass)) {
    517                        if (!moduleListImageView.contains(theName))
    518                            moduleListImageView.add(theName);
    519                        log.trace("loadExtClass: ImageViewFactory class {}", theName);
    520                    }
    521                    else if (TreeViewFactory.class.isAssignableFrom(theClass)) {
    522                        if (!moduleListTreeView.contains(theName))
    523                            moduleListTreeView.add(theName);
    524                        log.trace("loadExtClass: TreeViewFactory class {}", theName);
    525                    }
    526                    else if (PaletteViewFactory.class.isAssignableFrom(theClass)) {
    527                        if (!moduleListPaletteView.contains(theName))
    528                            moduleListPaletteView.add(theName);
    529                        log.trace("loadExtClass: PaletteViewFactory class {}", theName);
    530                    }
    531                }
    532            }
    533            catch (Exception ex) {
    534                log.debug("loadExtClass: load classList[{}] of {} failed", i, theName, ex);
    535            }
    536        } //  (int i=0; i<n; i++)
    537
    538        return extClassLoader;
    539    }
    540
    541    /** @return the Folder Close Icon */
    542    public static Image getFoldercloseIcon() {
    543        return foldercloseIcon;
    544    }
    545
    546    /** @return the Folder Close with Attribute Icon */
    547    public static Image getFoldercloseIconA() {
    548        return foldercloseIconA;
    549    }
    550
    551    /** @return the Folder Open Icon */
    552    public static Image getFolderopenIcon() {
    553        return folderopenIcon;
    554    }
    555
    556    /** @return the Folder Open with Attribute Icon */
    557    public static Image getFolderopenIconA() {
    558        return folderopenIconA;
    559    }
    560
    561    /** @return the HDF Icon */
    562    public static Image getHdfIcon() {
    563        return hdfIcons[1];
    564    }
    565
    566    /** @return the HDF Icons */
    567    public static Image[] getHdfIcons() {
    568        return hdfIcons;
    569    }
    570
    571    /** @return the HDF4 Icon */
    572    public static Image getH4Icon() {
    573        return h4Icon;
    574    }
    575
    576    /** @return the read-only HDF4 Icon */
    577    public static Image getH4IconR() {
    578        return h4IconR;
    579    }
    580
    581    /** @return the HDF5 Icon */
    582    public static Image getH5Icon() {
    583        return h5Icon;
    584    }
    585
    586    /** @return the read-only HDF5 Icon */
    587    public static Image getH5IconR() {
    588        return h5IconR;
    589    }
    590
    591    /** @return the netcdf Icon */
    592    public static Image getNC3Icon() {
    593        return ncIcon;
    594    }
    595
    596    /** @return the read-only netcdf Icon */
    597    public static Image getNC3IconR() {
    598        return ncIconR;
    599    }
    600
    601    /** @return the Dataset Icon */
    602    public static Image getDatasetIcon() {
    603        return datasetIcon;
    604    }
    605
    606    /** @return the Dataset with Attribute Icon */
    607    public static Image getDatasetIconA() {
    608        return datasetIconA;
    609    }
    610
    611    /** @return the Datatype Icon */
    612    public static Image getDatatypeIcon() {
    613        return datatypeIcon;
    614    }
    615
    616    /** @return the Datatype with Attribute Icon */
    617    public static Image getDatatypeIconA() {
    618        return datatypeIconA;
    619    }
    620
    621    /** @return the Link Icon */
    622    public static Image getLinkIcon() {
    623        return linkIcon;
    624    }
    625
    626    /** @return the File Open Icon */
    627    public static Image getFileopenIcon() {
    628        return fileopenIcon;
    629    }
    630
    631    /** @return the File Save Icon */
    632    public static Image getFilesaveIcon() {
    633        return filesaveIcon;
    634    }
    635
    636    /** @return the File New Icon */
    637    public static Image getFilenewIcon() {
    638        return filenewIcon;
    639    }
    640
    641    /** @return the File Close Icon */
    642    public static Image getFilecloseIcon() {
    643        return filecloseIcon;
    644    }
    645
    646    /** @return the Palette Icon */
    647    public static Image getPaletteIcon() {
    648        return paletteIcon;
    649    }
    650
    651    /** @return the Bright Icon */
    652    public static Image getBrightIcon() {
    653        return brightIcon;
    654    }
    655
    656    /** @return the Autocontrast Icon */
    657    public static Image getAutocontrastIcon() {
    658        return autocontrastIcon;
    659    }
    660
    661    /** @return the Image Icon */
    662    public static Image getImageIcon() {
    663        return imageIcon;
    664    }
    665
    666    /** @return the Table Icon */
    667    public static Image getTableIcon() {
    668        return tableIcon;
    669    }
    670
    671    /** @return the Text Icon */
    672    public static Image getTextIcon() {
    673        return textIcon;
    674    }
    675
    676    /** @return the Image with Attribute Icon */
    677    public static Image getImageIconA() {
    678        return imageIconA;
    679    }
    680
    681    /** @return the Table with Attribute Icon */
    682    public static Image getTableIconA() {
    683        return tableIconA;
    684    }
    685
    686    /** @return the Text with Attribute Icon */
    687    public static Image getTextIconA() {
    688        return textIconA;
    689    }
    690
    691    /** @return the Zoom In Icon */
    692    public static Image getZoominIcon() {
    693        return zoominIcon;
    694    }
    695
    696    /** @return the Zoom Out Icon */
    697    public static Image getZoomoutIcon() {
    698        return zoomoutIcon;
    699    }
    700
    701    /** @return the Blank Icon */
    702    public static Image getBlankIcon() {
    703        return blankIcon;
    704    }
    705
    706    /** @return the Help Icon */
    707    public static Image getHelpIcon() {
    708        return helpIcon;
    709    }
    710
    711    /** @return the Copy Icon */
    712    public static Image getCopyIcon() {
    713        return copyIcon;
    714    }
    715
    716    /** @return the Cut Icon */
    717    public static Image getCutIcon() {
    718        return cutIcon;
    719    }
    720
    721    /** @return the Paste Icon */
    722    public static Image getPasteIcon() {
    723        return pasteIcon;
    724    }
    725
    726    /** @return the HDFView Icon */
    727    public static Image getHDFViewIcon() {
    728        return hdfviewIcon;
    729    }
    730
    731    /** @return the Large HDF Icon */
    732    public static Image getLargeHdfIcon() {
    733        return hdfIcons[2];
    734    }
    735
    736    /** @return the Previous Icon */
    737    public static Image getPreviousIcon() {
    738        return previousIcon;
    739    }
    740
    741    /** @return the Next Icon */
    742    public static Image getNextIcon() {
    743        return nextIcon;
    744    }
    745
    746    /** @return the First Icon */
    747    public static Image getFirstIcon() {
    748        return firstIcon;
    749    }
    750
    751    /** @return the Last Icon */
    752   public static Image getLastIcon() {
    753        return lastIcon;
    754    }
    755
    756    /** @return the Chart Icon */
    757    public static Image getChartIcon() {
    758        return chartIcon;
    759    }
    760
    761    /** @return the Animation Icon */
    762    public static Image getAnimationIcon() {
    763        return animationIcon;
    764    }
    765
    766    /** @return the Apps Icon */
    767    public static Image getAppsIcon() {
    768        return iconAPPS;
    769    }
    770
    771    /** @return the Url Icon */
    772    public static Image getUrlIcon() {
    773        return iconURL;
    774    }
    775
    776    /** @return the Video Icon */
    777    public static Image getVideoIcon() {
    778        return iconVIDEO;
    779    }
    780
    781    /** @return the Xls Icon */
    782    public static Image getXlsIcon() {
    783        return iconXLS;
    784    }
    785
    786    /** @return the Pdf Icon */
    787    public static Image getPdfIcon() {
    788        return iconPDF;
    789    }
    790
    791    /** @return the Audio Icon */
    792    public static Image getAudioIcon() {
    793        return iconAUDIO;
    794    }
    795
    796    /** @return the Question Icon */
    797    public static Image getQuestionIcon() {
    798        return questionIcon;
    799    }
    800
    801    /** Load the Icons */
    802    public static void loadIcons() {
    803        InputStream s = null;
    804        // load icon images
    805        try {
    806            s = ViewProperties.class.getResourceAsStream("icons/hdfview.gif");
    807            hdfviewIcon = new Image(null, s);
    808        }
    809        catch (Exception ex) {
    810            hdfviewIcon = null;
    811            log.trace("hdfviewIcon: null");
    812        }
    813
    814        try {
    815            s = ViewProperties.class.getResourceAsStream("icons/hdfview16.png");
    816            hdfIcons[0] = new Image(null, s);
    817        }
    818        catch (Exception ex) {
    819            hdfIcons[0] = null;
    820            log.trace("hdfIcons[0]: null");
    821        }
    822
    823        try {
    824            s = ViewProperties.class.getResourceAsStream("icons/hdfview32.png");
    825            hdfIcons[1] = new Image(null, s);
    826        }
    827        catch (Exception ex) {
    828            hdfIcons[1] = null;
    829            log.trace("hdfIcons[1]: null");
    830        }
    831
    832        try {
    833            s = ViewProperties.class.getResourceAsStream("icons/hdfview64.png");
    834            hdfIcons[2] = new Image(null, s);
    835        }
    836        catch (Exception ex) {
    837            hdfIcons[2] = null;
    838            log.trace("hdfIcons[3]: null");
    839        }
    840
    841        try {
    842            s = ViewProperties.class.getResourceAsStream("icons/hdfview128.png");
    843            hdfIcons[3] = new Image(null, s);
    844        }
    845        catch (Exception ex) {
    846            hdfIcons[3] = null;
    847            log.trace("hdfIcons[3]: null");
    848        }
    849
    850        try {
    851            s = ViewProperties.class.getResourceAsStream("icons/hdfview512.png");
    852            hdfIcons[4] = new Image(null, s);
    853        }
    854        catch (Exception ex) {
    855            hdfIcons[4] = null;
    856            log.trace("hdfIcons[4]: null");
    857        }
    858
    859        try {
    860            s = ViewProperties.class.getResourceAsStream("icons/hdfview1024.png");
    861            hdfIcons[5] = new Image(null, s);
    862        }
    863        catch (Exception ex) {
    864            hdfIcons[5] = null;
    865            log.trace("hdfIcons[5]: null");
    866        }
    867
    868        try {
    869            s = ViewProperties.class.getResourceAsStream("icons/hdf4.gif");
    870            h4Icon = new Image(null, s);
    871        }
    872        catch (Exception ex) {
    873            h4Icon = null;
    874            log.trace("h4Icon: null");
    875        }
    876
    877        try {
    878            s = ViewProperties.class.getResourceAsStream("icons/hdf4R.gif");
    879            h4IconR = new Image(null, s);
    880        }
    881        catch (Exception ex) {
    882            h4IconR = null;
    883            log.trace("h4IconR: null");
    884        }
    885
    886        try {
    887            s = ViewProperties.class.getResourceAsStream("icons/hdf5.gif");
    888            h5Icon = new Image(null, s);
    889        }
    890        catch (Exception ex) {
    891            h5Icon = null;
    892            log.trace("h5Icon: null");
    893        }
    894
    895        try {
    896            s = ViewProperties.class.getResourceAsStream("icons/hdf5R.gif");
    897            h5IconR = new Image(null, s);
    898        }
    899        catch (Exception ex) {
    900            h5IconR = null;
    901            log.trace("h5IconR: null");
    902        }
    903
    904        try {
    905            s = ViewProperties.class.getResourceAsStream("icons/hdfnc.gif");
    906            ncIcon = new Image(null, s);
    907        }
    908        catch (Exception ex) {
    909            ncIcon = null;
    910            log.trace("ncIcon: null");
    911        }
    912
    913        try {
    914            s = ViewProperties.class.getResourceAsStream("icons/hdfncR.gif");
    915            ncIconR = new Image(null, s);
    916        }
    917        catch (Exception ex) {
    918            ncIconR = null;
    919            log.trace("ncIconR: null");
    920        }
    921
    922        try {
    923            s = ViewProperties.class.getResourceAsStream("icons/folderclose.gif");
    924            foldercloseIcon = new Image(null, s);
    925        }
    926        catch (Exception ex) {
    927            foldercloseIcon = null;
    928            log.trace("foldercloseIcon: null");
    929        }
    930
    931        try {
    932            s = ViewProperties.class.getResourceAsStream("icons/foldercloseA.gif");
    933            foldercloseIconA = new Image(null, s);
    934        }
    935        catch (Exception ex) {
    936            foldercloseIconA = null;
    937            log.trace("foldercloseIconA: null");
    938        }
    939
    940        try {
    941            s = ViewProperties.class.getResourceAsStream("icons/folderopen.gif");
    942            folderopenIcon = new Image(null, s);
    943        }
    944        catch (Exception ex) {
    945            folderopenIcon = null;
    946            log.trace("folderopenIcon: null");
    947        }
    948
    949        try {
    950            s = ViewProperties.class.getResourceAsStream("icons/folderopenA.gif");
    951            folderopenIconA = new Image(null, s);
    952        }
    953        catch (Exception ex) {
    954            folderopenIconA = null;
    955            log.trace("folderopenIconA: null");
    956        }
    957
    958        try {
    959            s = ViewProperties.class.getResourceAsStream("icons/dataset.gif");
    960            datasetIcon = new Image(null, s);
    961        }
    962        catch (Exception ex) {
    963            datasetIcon = null;
    964            log.trace("datasetIcon: null");
    965        }
    966
    967        try {
    968            s = ViewProperties.class.getResourceAsStream("icons/datasetA.gif");
    969            datasetIconA = new Image(null, s);
    970        }
    971        catch (Exception ex) {
    972            datasetIconA = null;
    973            log.trace("datasetIconA: null");
    974        }
    975
    976        try {
    977            s = ViewProperties.class.getResourceAsStream("icons/datatype.gif");
    978            datatypeIcon = new Image(null, s);
    979        }
    980        catch (Exception ex) {
    981            datatypeIcon = null;
    982            log.trace("datatypeIcon: null");
    983        }
    984
    985        try {
    986            s = ViewProperties.class.getResourceAsStream("icons/datatypeA.gif");
    987            datatypeIconA = new Image(null, s);
    988        }
    989        catch (Exception ex) {
    990            datatypeIconA = null;
    991            log.trace("datatypeIconA: null");
    992        }
    993
    994        try {
    995            s = ViewProperties.class.getResourceAsStream("icons/link.gif");
    996            linkIcon = new Image(null, s);
    997        }
    998        catch (Exception ex) {
    999            linkIcon = null;
    1000            log.trace("linkIcon: null");
    1001        }
    1002
    1003        try {
    1004            s = ViewProperties.class.getResourceAsStream("icons/fileopen.gif");
    1005            fileopenIcon = new Image(null, s);
    1006        }
    1007        catch (Exception ex) {
    1008            fileopenIcon = null;
    1009            log.trace("fileopenIcon: null");
    1010        }
    1011
    1012        try {
    1013            s = ViewProperties.class.getResourceAsStream("icons/filesave.gif");
    1014            filesaveIcon = new Image(null, s);
    1015        }
    1016        catch (Exception ex) {
    1017            filesaveIcon = null;
    1018            log.trace("filesaveIcon: null");
    1019        }
    1020
    1021        try {
    1022            s = ViewProperties.class.getResourceAsStream("icons/filenew.gif");
    1023            filenewIcon = new Image(null, s);
    1024        }
    1025        catch (Exception ex) {
    1026            filenewIcon = null;
    1027            log.trace("filenewIcon: null");
    1028        }
    1029
    1030        try {
    1031            s = ViewProperties.class.getResourceAsStream("icons/fileclose.gif");
    1032            filecloseIcon = new Image(null, s);
    1033        }
    1034        catch (Exception ex) {
    1035            filecloseIcon = null;
    1036            log.trace("filecloseIcon: null");
    1037        }
    1038
    1039        try {
    1040            s = ViewProperties.class.getResourceAsStream("icons/palette.gif");
    1041            paletteIcon = new Image(null, s);
    1042        }
    1043        catch (Exception ex) {
    1044            paletteIcon = null;
    1045            log.trace("paletteIcon: null");
    1046        }
    1047
    1048        try {
    1049            s = ViewProperties.class.getResourceAsStream("icons/brightness.gif");
    1050            brightIcon = new Image(null, s);
    1051        }
    1052        catch (Exception ex) {
    1053            brightIcon = null;
    1054            log.trace("brightIcon: null");
    1055        }
    1056
    1057        try {
    1058            s = ViewProperties.class.getResourceAsStream("icons/autocontrast.gif");
    1059            autocontrastIcon = new Image(null, s);
    1060        }
    1061        catch (Exception ex) {
    1062            autocontrastIcon = null;
    1063            log.trace("autocontrastIcon: null");
    1064        }
    1065
    1066        try {
    1067            s = ViewProperties.class.getResourceAsStream("icons/image.gif");
    1068            imageIcon = new Image(null, s);
    1069        }
    1070        catch (Exception ex) {
    1071            imageIcon = null;
    1072            log.trace("imageIcon: null");
    1073        }
    1074
    1075        try {
    1076            s = ViewProperties.class.getResourceAsStream("icons/imageA.gif");
    1077            imageIconA = new Image(null, s);
    1078        }
    1079        catch (Exception ex) {
    1080            imageIconA = null;
    1081            log.trace("imageIconA: null");
    1082        }
    1083
    1084        try {
    1085            s = ViewProperties.class.getResourceAsStream("icons/table.gif");
    1086            tableIcon = new Image(null, s);
    1087        }
    1088        catch (Exception ex) {
    1089            tableIcon = null;
    1090            log.trace("tableIcon: null");
    1091        }
    1092
    1093        try {
    1094            s = ViewProperties.class.getResourceAsStream("icons/tableA.gif");
    1095            tableIconA = new Image(null, s);
    1096        }
    1097        catch (Exception ex) {
    1098            tableIconA = null;
    1099            log.trace("tableIconA: null");
    1100        }
    1101
    1102        try {
    1103            s = ViewProperties.class.getResourceAsStream("icons/text.gif");
    1104            textIcon = new Image(null, s);
    1105        }
    1106        catch (Exception ex) {
    1107            textIcon = null;
    1108            log.trace("textIcon: null");
    1109        }
    1110
    1111        try {
    1112            s = ViewProperties.class.getResourceAsStream("icons/textA.gif");
    1113            textIconA = new Image(null, s);
    1114        }
    1115        catch (Exception ex) {
    1116            textIconA = null;
    1117            log.trace("textIconA: null");
    1118        }
    1119
    1120        try {
    1121            s = ViewProperties.class.getResourceAsStream("icons/zoomin.gif");
    1122            zoominIcon = new Image(null, s);
    1123        }
    1124        catch (Exception ex) {
    1125            zoominIcon = null;
    1126            log.trace("iconAUzoominIconDIO: null");
    1127        }
    1128
    1129        try {
    1130            s = ViewProperties.class.getResourceAsStream("icons/zoomout.gif");
    1131            zoomoutIcon = new Image(null, s);
    1132        }
    1133        catch (Exception ex) {
    1134            zoomoutIcon = null;
    1135            log.trace("zoomoutIcon: null");
    1136        }
    1137
    1138        try {
    1139            s = ViewProperties.class.getResourceAsStream("icons/blank.gif");
    1140            blankIcon = new Image(null, s);
    1141        }
    1142        catch (Exception ex) {
    1143            blankIcon = null;
    1144            log.trace("blankIcon: null");
    1145        }
    1146
    1147        try {
    1148            s = ViewProperties.class.getResourceAsStream("icons/help.gif");
    1149            helpIcon = new Image(null, s);
    1150        }
    1151        catch (Exception ex) {
    1152            helpIcon = null;
    1153            log.trace("helpIcon: null");
    1154        }
    1155
    1156        try {
    1157            s = ViewProperties.class.getResourceAsStream("icons/copy.gif");
    1158            copyIcon = new Image(null, s);
    1159        }
    1160        catch (Exception ex) {
    1161            copyIcon = null;
    1162            log.trace("copyIcon: null");
    1163        }
    1164
    1165        try {
    1166            s = ViewProperties.class.getResourceAsStream("icons/cut.gif");
    1167            cutIcon = new Image(null, s);
    1168        }
    1169        catch (Exception ex) {
    1170            cutIcon = null;
    1171            log.trace("cutIcon: null");
    1172        }
    1173
    1174        try {
    1175            s = ViewProperties.class.getResourceAsStream("icons/paste.gif");
    1176            pasteIcon = new Image(null, s);
    1177        }
    1178        catch (Exception ex) {
    1179            pasteIcon = null;
    1180            log.trace("pasteIcon: null");
    1181        }
    1182
    1183
    1184        try {
    1185            s = ViewProperties.class.getResourceAsStream("icons/previous.gif");
    1186            previousIcon = new Image(null, s);
    1187        }
    1188        catch (Exception ex) {
    1189            previousIcon = null;
    1190            log.trace("previousIcon: null");
    1191        }
    1192
    1193        try {
    1194            s = ViewProperties.class.getResourceAsStream("icons/next.gif");
    1195            nextIcon = new Image(null, s);
    1196        }
    1197        catch (Exception ex) {
    1198            nextIcon = null;
    1199            log.trace("nextIcon: null");
    1200        }
    1201
    1202        try {
    1203            s = ViewProperties.class.getResourceAsStream("icons/first.gif");
    1204            firstIcon = new Image(null, s);
    1205        }
    1206        catch (Exception ex) {
    1207            firstIcon = null;
    1208            log.trace("firstIcon: null");
    1209        }
    1210
    1211        try {
    1212            s = ViewProperties.class.getResourceAsStream("icons/last.gif");
    1213            lastIcon = new Image(null, s);
    1214        }
    1215        catch (Exception ex) {
    1216            lastIcon = null;
    1217            log.trace("lastIcon: null");
    1218        }
    1219
    1220        try {
    1221            s = ViewProperties.class.getResourceAsStream("icons/chart.gif");
    1222            chartIcon = new Image(null, s);
    1223        }
    1224        catch (Exception ex) {
    1225            chartIcon = null;
    1226            log.trace("chartIcon: null");
    1227        }
    1228
    1229        try {
    1230            s = ViewProperties.class.getResourceAsStream("icons/animation.gif");
    1231            animationIcon = new Image(null, s);
    1232        }
    1233        catch (Exception ex) {
    1234            animationIcon = null;
    1235            log.trace("animationIcon: null");
    1236        }
    1237
    1238        try {
    1239            s = ViewProperties.class.getResourceAsStream("icons/question.gif");
    1240            questionIcon = new Image(null, s);
    1241        }
    1242        catch (Exception ex) {
    1243            questionIcon = null;
    1244            log.trace("questionIcon: null");
    1245        }
    1246
    1247        try {
    1248            s = ViewProperties.class.getResourceAsStream("icons/audio.gif");
    1249            iconAUDIO = new Image(null, s);
    1250        }
    1251        catch (Exception ex) {
    1252            iconAUDIO = null;
    1253            log.trace("iconAUDIO: null");
    1254        }
    1255
    1256        try {
    1257            s = ViewProperties.class.getResourceAsStream("icons/xls.gif");
    1258            iconXLS = new Image(null, s);
    1259        }
    1260        catch (Exception ex) {
    1261            iconXLS = null;
    1262            log.trace("iconXLS: null");
    1263        }
    1264
    1265        try {
    1266            s = ViewProperties.class.getResourceAsStream("icons/pdf.gif");
    1267            iconPDF = new Image(null, s);
    1268        }
    1269        catch (Exception ex) {
    1270            iconPDF = null;
    1271            log.trace("iconPDF: null");
    1272        }
    1273
    1274        try {
    1275            s = ViewProperties.class.getResourceAsStream("icons/apps.gif");
    1276            iconAPPS = new Image(null, s);
    1277        }
    1278        catch (Exception ex) {
    1279            iconAPPS = null;
    1280            log.trace("iconAPPS: null");
    1281        }
    1282
    1283        try {
    1284            s = ViewProperties.class.getResourceAsStream("icons/url.gif");
    1285            iconURL = new Image(null, s);
    1286        }
    1287        catch (Exception ex) {
    1288            iconURL = null;
    1289            log.trace("iconURL: null");
    1290        }
    1291
    1292        try {
    1293            s = ViewProperties.class.getResourceAsStream("icons/video.gif");
    1294            iconVIDEO = new Image(null, s);
    1295        }
    1296        catch (Exception ex) {
    1297            iconVIDEO = null;
    1298            log.trace("iconVIDEO: null");
    1299        }
    1300    }
    1301
    1302    /**
    1303     * Load user properties from property file
    1304     *
    1305     * @throws IOException
    1306     *             if a failure occurred
    1307     */
    1308    @Override
    1309    @SuppressWarnings({ "rawtypes", "unchecked" })
    1310    public void load() throws IOException {
    1311        super.load();
    1312
    1313        if (propertyFile == null)
    1314            return;
    1315
    1316        String propVal = null;
    1317
    1318        // add default module.
    1319        log.trace("load user properties: add default modules");
    1320        String[] moduleKeys = { "module.treeview", "module.metadataview", "module.tableview",
    1321                "module.imageview", "module.paletteview" };
    1322        ArrayList[] moduleList = { moduleListTreeView, moduleListMetaDataView, moduleListTableView,
    1323                moduleListImageView, moduleListPaletteView };
    1324        String[] moduleNames = { DEFAULT_MODULE_TEXT, DEFAULT_MODULE_TEXT, DEFAULT_MODULE_TEXT,
    1325                DEFAULT_MODULE_TEXT, DEFAULT_MODULE_TEXT };
    1326
    1327        // add default implementation of modules
    1328        log.trace("load user properties: modules");
    1329        for (int i = 0; i < moduleNames.length; i++) {
    1330            if (!moduleList[i].contains(moduleNames[i]))
    1331                moduleList[i].add(moduleNames[i]);
    1332            log.trace("load: add default moduleList[{}] is {}", i, moduleNames[i]);
    1333        }
    1334        log.trace("load Ext Class modules");
    1335        if (extClassLoader == null) loadExtClass();
    1336
    1337        // set default selection of data views
    1338        log.trace("load user properties: set default selection of data views");
    1339        for (int i = 0; i < moduleNames.length; i++) {
    1340            ArrayList<String> theList = moduleList[i];
    1341            propVal = getString(moduleKeys[i]);
    1342            if (log.isTraceEnabled()) {
    1343                log.trace("load: default theList is {}", Arrays.toString(theList.toArray()));
    1344            }
    1345
    1346            if ((propVal != null) && (propVal.length() > 0)) {
    1347                // set default to the module specified in property file
    1348                if (theList.size() > 1) {
    1349                    if (theList.contains(propVal))
    1350                        theList.remove(propVal);
    1351                    theList.add(0, propVal);
    1352                }
    1353                log.trace("load user properties: module[{}]={}", i, propVal);
    1354            }
    1355            else {
    1356                // use default module
    1357                if (theList.size() > 1) {
    1358                    if (theList.contains(moduleNames[i]))
    1359                        theList.remove(moduleNames[i]);
    1360                    theList.add(0, moduleNames[i]);
    1361                }
    1362                log.trace("load user properties: default module[{}]={}", i, moduleNames[i]);
    1363            }
    1364            if (log.isTraceEnabled()) {
    1365                log.trace("load: final theList is {}", Arrays.toString(theList.toArray()));
    1366            }
    1367        }
    1368
    1369        // add fileformat modules
    1370        log.trace("load user properties: fileformat modules");
    1371        String[] localEnum = this.preferenceNames();
    1372        String fExt = null;
    1373        for (String theKey : localEnum) {
    1374            log.trace("load: add prop {}", theKey);
    1375            if (theKey.startsWith("module.fileformat")) {
    1376                fExt = theKey.substring(18);
    1377                try {
    1378                    // enables use of JHDF5 in JNLP (Web Start) applications,
    1379                    // the system class loader with reflection first.
    1380                    String className = getString(theKey);
    1381                    Class theClass = null;
    1382                    try {
    1383                        theClass = Class.forName(className);
    1384                    }
    1385                    catch (Exception ex) {
    1386                        try {
    1387                            theClass = extClassLoader.loadClass(className);
    1388                        }
    1389                        catch (Exception ex2) {
    1390                            log.debug("load: extClassLoader.loadClass({}) failed", className, ex2);
    1391                        }
    1392                    }
    1393
    1394                    Object theObject = theClass.newInstance();
    1395                    if (theObject instanceof FileFormat) {
    1396                        FileFormat.addFileFormat(fExt, (FileFormat) theObject);
    1397                    }
    1398                }
    1399                catch (Exception err) {
    1400                    log.debug("load: load file format failed", err);
    1401                }
    1402            }
    1403        }
    1404
    1405        propVal = getString("users.guide");
    1406        if (!isDefault("users.guide"))
    1407            setUsersGuide(propVal);
    1408
    1409        propVal = getString("image.contrast");
    1410        if (!isDefault("image.contrast"))
    1411            setAutoContrast("auto".equalsIgnoreCase(propVal));
    1412
    1413        setShowImageValue(getBoolean("image.showvalues"));
    1414
    1415        propVal = getString("file.mode");
    1416        if (!isDefault("file.mode"))
    1417            setReadOnly("r".equalsIgnoreCase(propVal));
    1418
    1419        setEarlyLib(getString("lib.lowversion"));
    1420
    1421        setLateLib(getString("lib.highversion"));
    1422
    1423        setConvertEnum(getBoolean("enum.conversion"));
    1424
    1425        setShowRegRefValue(getBoolean("regref.showvalues"));
    1426
    1427        setIndexBase1(getBoolean("index.base1"));
    1428
    1429        propVal = getString("data.delimiter");
    1430        if (!isDefault("data.delimiter"))
    1431            setDataDelimiter(propVal);
    1432
    1433        propVal = getString("image.origin");
    1434        if (!isDefault("image.origin"))
    1435            setImageOrigin(propVal);
    1436
    1437        propVal = getString("h5file.indexType");
    1438        if (!isDefault("h5file.indexType"))
    1439            setIndexType(propVal);
    1440
    1441        propVal = getString("h5file.indexOrder");
    1442        if (!isDefault("h5file.indexOrder"))
    1443            setIndexOrder(propVal);
    1444
    1445        propVal = getString("h4toh5.converter");
    1446        if (!isDefault("h4toh5.converter"))
    1447            setH4toH5(propVal);
    1448
    1449        propVal = getString("work.dir");
    1450        if (!isDefault("work.dir"))
    1451            setWorkDir(propVal);
    1452
    1453        propVal = getString("file.extension");
    1454        if (!isDefault("file.extension")) {
    1455            setFileExtension(propVal);
    1456            FileFormat.addFileExtension(fileExt);
    1457        }
    1458
    1459        setTimerRefresh(getInt("timer.refresh"));
    1460
    1461        setFontSize(getInt("font.size"));
    1462
    1463        propVal = getString("font.type");
    1464        if (!isDefault("font.type"))
    1465            setFontType(propVal.trim());
    1466
    1467        setMaxMembers(getInt("max.members"));
    1468
    1469        // load the most recent file list from the property file
    1470        log.trace("load user properties: most recent file list with {}", getWorkDir());
    1471        String theFile = null;
    1472        // first entry should be the working dir
    1473        recentFiles.add(getWorkDir());
    1474        for (int i = 0; i < MAX_RECENT_FILES; i++) {
    1475            theFile = getString("recent.file" + i);
    1476            if ((theFile != null) && !recentFiles.contains(theFile)) {
    1477                if (theFile.startsWith("http://") || theFile.startsWith("ftp://") || (new File(theFile)).exists()) {
    1478                    recentFiles.add(theFile);
    1479                }
    1480            }
    1481        }
    1482
    1483        // load the most recent palette file list from the property file
    1484        log.trace("load user properties: most recent palette file list");
    1485        for (int i = 0; i < MAX_RECENT_FILES; i++) {
    1486            theFile = getString("palette.file" + i);
    1487            if (theFile != null) theFile = theFile.trim();
    1488
    1489            if ((theFile != null && theFile.length() > 0) && !paletteList.contains(theFile)) {
    1490                if ((new File(theFile)).exists()) {
    1491                    paletteList.add(theFile);
    1492                }
    1493            }
    1494        }
    1495    }
    1496
    1497    /**
    1498     * Save user properties into property file
    1499     *
    1500     * @throws IOException
    1501     *             if a failure occurred
    1502     */
    1503    @Override
    1504    public void save() throws IOException {
    1505        if (propertyFile == null)
    1506            return;
    1507
    1508        // update data saving options
    1509        if (delimiter == null)
    1510            setDefault("data.delimiter", DELIMITER_TAB);
    1511        else
    1512            setValue("data.delimiter", delimiter);
    1513
    1514        if (origin == null)
    1515            setDefault("image.origin", ORIGIN_UL);
    1516        else
    1517            setValue("image.origin", origin);
    1518
    1519        if (indexType != null) setValue("h5file.indexType", indexType);
    1520
    1521        if (indexOrder != null) setValue("h5file.indexOrder", indexOrder);
    1522
    1523        if (usersGuide != null) setValue("users.guide", usersGuide);
    1524
    1525        if (workDir != null) setValue("work.dir", workDir);
    1526
    1527        if (fileExt != null) setValue("file.extension", fileExt);
    1528
    1529        if (h4toh5 != null) setValue("h4toh5.converter", h4toh5);
    1530
    1531        setValue("timer.refresh", timerRefresh);
    1532
    1533        setValue("font.size", fontSize);
    1534
    1535        if (fontType != null) setValue("font.type", fontType);
    1536
    1537        setValue("max.members", maxMembers);
    1538
    1539        if (isAutoContrast)
    1540            setValue("image.contrast", "auto");
    1541        else
    1542            setValue("image.contrast", "general");
    1543
    1544        setValue("image.showvalues", showImageValues);
    1545
    1546        if (isReadOnly)
    1547            setValue("file.mode", "r");
    1548        else if (isReadSWMR)
    1549            setValue("file.mode", "rs");
    1550        else
    1551            setValue("file.mode", "rw");
    1552
    1553        log.trace("save user properties: lib.lowversion={}", EarlyLib);
    1554        setValue("lib.lowversion", EarlyLib);
    1555        log.trace("save user properties: lib.highversion={}", LateLib);
    1556        setValue("lib.highversion", LateLib);
    1557
    1558        setValue("enum.conversion", convertEnum);
    1559        setValue("regref.showvalues", showRegRefValues);
    1560        setValue("index.base1", isIndexBase1);
    1561
    1562        // save the list of most recent files
    1563        log.trace("save user properties: most recent files");
    1564        String theFile;
    1565        int size = recentFiles.size();
    1566        int minSize = Math.min(size, MAX_RECENT_FILES);
    1567        log.trace("save user properties: most recent files size={}", size);
    1568        // The first entry is always the working dir
    1569        for (int i = 0; i < minSize - 1; i++) {
    1570            theFile = recentFiles.get(i+1);
    1571            log.trace("save user properties: save recent file={}", theFile);
    1572            if ((theFile != null) && (theFile.length() > 0)) setValue("recent.file" + i, theFile);
    1573        }
    1574
    1575        // save the list of most recent palette files
    1576        log.trace("save user properties: most recent palette files");
    1577        size = paletteList.size();
    1578        minSize = Math.min(size, MAX_RECENT_FILES);
    1579        for (int i = 0; i < minSize; i++) {
    1580            theFile = paletteList.get(i);
    1581            if ((theFile != null) && (theFile.length() > 0)) setValue("palette.file" + i, theFile);
    1582        }
    1583
    1584        // save default modules
    1585        log.trace("save user properties: default modules");
    1586        String moduleName = moduleListTreeView.get(0);
    1587        if ((moduleName != null) && (moduleName.length() > 0)) setValue("module.treeview", moduleName);
    1588        log.trace("save user properties: module.treeview={}", moduleName);
    1589
    1590        moduleName = moduleListMetaDataView.get(0);
    1591        if ((moduleName != null) && (moduleName.length() > 0)) setValue("module.metadataview", moduleName);
    1592        log.trace("save user properties: module.metadataview={}", moduleName);
    1593
    1594        moduleName = moduleListTableView.get(0);
    1595        if ((moduleName != null) && (moduleName.length() > 0)) setValue("module.tableview", moduleName);
    1596        log.trace("save user properties: module.tableview={}", moduleName);
    1597
    1598        moduleName = moduleListImageView.get(0);
    1599        if ((moduleName != null) && (moduleName.length() > 0)) setValue("module.imageview", moduleName);
    1600        log.trace("save user properties: module.imageview={}", moduleName);
    1601
    1602        moduleName = moduleListPaletteView.get(0);
    1603        if ((moduleName != null) && (moduleName.length() > 0)) setValue("module.paletteview", moduleName);
    1604        log.trace("save user properties: module.paletteview={}", moduleName);
    1605
    1606        // save the current supported fileformat
    1607        log.trace("save user properties: supported fileformat");
    1608        Enumeration<?> keys = FileFormat.getFileFormatKeys();
    1609        String theKey = null;
    1610        while (keys.hasMoreElements()) {
    1611            theKey = (String) keys.nextElement();
    1612            FileFormat theformat = FileFormat.getFileFormat(theKey);
    1613            setValue("module.fileformat." + theKey, theformat.getClass().getName());
    1614        }
    1615
    1616        super.save();
    1617    }
    1618
    1619    /** @return the name of the user property file */
    1620    public static String getPropertyFile() {
    1621        return propertyFile;
    1622    }
    1623
    1624    /** @return the root directory where the HDFView is installed. */
    1625    public static String getViewRoot() {
    1626        return rootDir;
    1627    }
    1628
    1629    /** @return the default work directory, where the open file starts. */
    1630    public static String getWorkDir() {
    1631        String workPath = workDir;
    1632        log.trace("getWorkDir: workDir={}", workDir);
    1633        if (workPath == null) {
    1634            workPath = System.getProperty("hdfview.workdir");
    1635            log.trace("getWorkDir: hdfview.workdir={}", workPath);
    1636            if (workPath == null) {
    1637                workPath = System.getProperty("user.dir");
    1638            }
    1639        }
    1640        log.trace("getWorkDir: final workPath={}", workPath);
    1641        return workPath;
    1642    }
    1643
    1644    /** @return the maximum number of the most recent file */
    1645    public static int getMaxRecentFiles() {
    1646        return MAX_RECENT_FILES;
    1647    }
    1648
    1649    /** @return the path of the HDFView users guide */
    1650    public static String getUsersGuide() {
    1651        return usersGuide;
    1652    };
    1653
    1654    /** @return the delimiter of data values */
    1655    public static String getDataDelimiter() {
    1656        return delimiter;
    1657    }
    1658
    1659    /** @return the image origin */
    1660    public static String getImageOrigin() {
    1661        return origin;
    1662    }
    1663
    1664    /** @return the default index type for display */
    1665    public static String getIndexType() {
    1666        return indexType;
    1667    }
    1668
    1669    /** @return the default index order for display */
    1670    public static String getIndexOrder() {
    1671        return indexOrder;
    1672    }
    1673
    1674    /** @return the timer refresh size */
    1675    public static int getTimerRefresh() {
    1676        return timerRefresh;
    1677    }
    1678
    1679    /** sets the timer refresh
    1680     *
    1681     * @param trefresh
    1682     *            the timer refresh
    1683     */
    1684    public static void setTimerRefresh(int trefresh) {
    1685        timerRefresh = trefresh;
    1686    }
    1687
    1688    /** @return the font size */
    1689    public static int getFontSize() {
    1690        return fontSize;
    1691    }
    1692
    1693    /** @return the font type */
    1694    public static String getFontType() {
    1695        return fontType;
    1696    }
    1697
    1698    /** @return the file extensions of supported file formats */
    1699    public static String getFileExtension() {
    1700        return fileExt;
    1701    }
    1702
    1703    /** sets the font size
    1704     *
    1705     * @param fsize
    1706     *            the font size
    1707     */
    1708    public static void setFontSize(int fsize) {
    1709        fontSize = (fsize / 2) * 2;
    1710
    1711        if (fontSize < 8) {
    1712            fontSize = 8;
    1713        }
    1714    }
    1715
    1716    /** sets the font type
    1717     *
    1718     * @param ftype
    1719     *            the font type
    1720     */
    1721    public static void setFontType(String ftype) {
    1722        if (ftype != null) {
    1723            fontType = ftype.trim();
    1724        }
    1725    }
    1726
    1727    /** @return the path of the H5toH5 converter */
    1728    public static String getH4toH5() {
    1729        return h4toh5;
    1730    }
    1731
    1732    /** @return the list of most recent files */
    1733    public static List<String> getMRF() {
    1734        return recentFiles;
    1735    }
    1736
    1737    /** @return the list of palette files */
    1738    public static List<String> getPaletteList() {
    1739        return paletteList;
    1740    }
    1741
    1742    /** @return the SRB account list */
    1743    public static List<String[]> getSrbAccount() {
    1744        return srbAccountList;
    1745    }
    1746
    1747    /** @return a list of treeview modules */
    1748    public static List<String> getTreeViewList() {
    1749        return moduleListTreeView;
    1750    }
    1751
    1752    /** @return a list of metadataview modules */
    1753    public static List<String> getMetaDataViewList() {
    1754        return moduleListMetaDataView;
    1755    }
    1756
    1757    /** @return a list of tableview modules */
    1758    public static List<String> getTableViewList() {
    1759        return moduleListTableView;
    1760    }
    1761
    1762    /** @return a list of imageview modules */
    1763    public static List<String> getImageViewList() {
    1764        return moduleListImageView;
    1765    }
    1766
    1767    /** @return a list of paletteview modules */
    1768    public static List<String> getPaletteViewList() {
    1769        return moduleListPaletteView;
    1770    }
    1771
    1772    /** @return a list of helpview modules */
    1773    public static List<String> getHelpViewList() {
    1774        return moduleListHelpView;
    1775    }
    1776
    1777    /** set the path of H5View User's guide
    1778     *
    1779     * @param str
    1780     *            the path
    1781     */
    1782    public static void setUsersGuide(String str) {
    1783        if ((str == null) || (str.length() <= 0)) {
    1784            return;
    1785        }
    1786        usersGuide = str;
    1787    }
    1788
    1789    /** set the path of the H4 to H5 converter
    1790     *
    1791     * @param tool
    1792     *            the path of the H4 to H5 converter
    1793     */
    1794    public static void setH4toH5(String tool) {
    1795        h4toh5 = tool;
    1796    }
    1797
    1798    /**
    1799     * set the path of the default root directory
    1800     *
    1801     * @param rDir
    1802     *            the default root directory
    1803     */
    1804    public static void setRootDir(String rDir) {
    1805        log.trace("ViewProperties:setRootDir rDir={}", rDir);
    1806        rootDir = rDir;
    1807    }
    1808
    1809    /** set the path of the default work directory
    1810     *
    1811     * @param wDir
    1812     *            the default work directory
    1813     */
    1814    public static void setWorkDir(String wDir) {
    1815        log.trace("ViewProperties:setWorkDir wDir={}", wDir);
    1816        workDir = wDir;
    1817    }
    1818
    1819    /** set the file extension
    1820     *
    1821     * @param ext
    1822     *            the file extension
    1823     */
    1824    public static void setFileExtension(String ext) {
    1825        fileExt = ext;
    1826    }
    1827
    1828    /** set the delimiter of data values
    1829     *
    1830     * @param delim
    1831     *            the delimiter of data values
    1832     */
    1833    public static void setDataDelimiter(String delim) {
    1834        delimiter = delim;
    1835    }
    1836
    1837    /** set the image origin
    1838     *
    1839     * @param o
    1840     *            the image origin
    1841     */
    1842    public static void setImageOrigin(String o) {
    1843        origin = o;
    1844    }
    1845
    1846    /** set the index type
    1847     *
    1848     * @param idxType
    1849     *            the index type
    1850     */
    1851    public static void setIndexType(String idxType) {
    1852        indexType = idxType;
    1853    }
    1854
    1855    /** set the index order
    1856     *
    1857     * @param idxOrder
    1858     *            the index order
    1859     */
    1860    public static void setIndexOrder(String idxOrder) {
    1861        indexOrder = idxOrder;
    1862    }
    1863
    1864    /**
    1865     * Current Java applications such as HDFView cannot handle files with large
    1866     * number of objects such as 1,000,000 objects. setMaxMembers() sets the
    1867     * maximum number of objects that will be loaded into memory.
    1868     *
    1869     * @param n
    1870     *            the maximum number of objects to load into memory
    1871     */
    1872    public static void setMaxMembers(int n) {
    1873        maxMembers = n;
    1874    }
    1875
    1876    /**
    1877     * Current Java applications such as HDFView cannot handle files with large
    1878     * number of objects such as 1,000,000 objects. setStartMember() sets the
    1879     * starting index of objects that will be loaded into memory.
    1880     *
    1881     * @param idx
    1882     *            the maximum number of objects to load into memory
    1883     */
    1884    public static void setStartMembers(int idx) {
    1885        if (idx < 0) {
    1886            idx = 0;
    1887        }
    1888
    1889        startMembers = idx;
    1890    }
    1891
    1892    /**
    1893     * Current Java applications such as HDFView cannot handle files with large
    1894     * number of objects such as 1,000,000 objects. getMaxMembers() returns the
    1895     * maximum number of objects that will be loaded into memory.
    1896     *
    1897     * @return the maximum members
    1898     */
    1899    public static int getMaxMembers() {
    1900        if (maxMembers < 0)
    1901            return Integer.MAX_VALUE; // load the whole file
    1902
    1903        return maxMembers;
    1904    }
    1905
    1906    /**
    1907     * Current Java applications such as HDFView cannot handle files with large
    1908     * number of objects such as 1,000,000 objects. getStartMembers() returns the
    1909     * starting index of objects that will be loaded into memory.
    1910     *
    1911     * @return the start members
    1912     */
    1913    public static int getStartMembers() {
    1914        return startMembers;
    1915    }
    1916
    1917    /**
    1918     * Returns true if auto contrast is used in image processing.
    1919     *
    1920     * @return true if auto contrast is used in image processing; otherwise,
    1921     *         returns false.
    1922     */
    1923    public static boolean isAutoContrast() {
    1924        return isAutoContrast;
    1925    }
    1926
    1927    /**
    1928     * Returns true if "show image values" is set.
    1929     *
    1930     * @return true if "show image values" is set; otherwise, returns false.
    1931     */
    1932    public static boolean showImageValues() {
    1933        return showImageValues;
    1934    }
    1935
    1936    /**
    1937     * Set the flag to indicate if auto contrast is used in image process.
    1938     *
    1939     * @param b
    1940     *            the flag to indicate if auto contrast is used in image
    1941     *            process.
    1942     */
    1943    public static void setAutoContrast(boolean b) {
    1944        isAutoContrast = b;
    1945    }
    1946
    1947    /**
    1948     * Set the flag to indicate if "show image values" is set.
    1949     *
    1950     * @param b
    1951     *            the flag to indicate if if "show image values" is set.
    1952     */
    1953    public static void setShowImageValue(boolean b) {
    1954        showImageValues = b;
    1955    }
    1956
    1957    /**
    1958     * Returns true if default file access is read only.
    1959     *
    1960     * @return true if default file access is read only; otherwise, returns
    1961     *         false.
    1962     */
    1963    public static boolean isReadOnly() {
    1964        return isReadOnly;
    1965    }
    1966
    1967    /**
    1968     * Set the flag to indicate if default file access is read only.
    1969     *
    1970     * @param b
    1971     *            the flag to indicate if default file access is read only.
    1972     */
    1973    public static void setReadOnly(boolean b) {
    1974        isReadOnly = b;
    1975    }
    1976
    1977    /**
    1978     * Returns true if default file access is read SWMR.
    1979     *
    1980     * @return true if default file access is read SWMR; otherwise, returns
    1981     *         false.
    1982     */
    1983    public static boolean isReadSWMR() {
    1984        return isReadSWMR;
    1985    }
    1986
    1987    /**
    1988     * Set the flag to indicate if default file access is read SWMR.
    1989     *
    1990     * @param b
    1991     *            the flag to indicate if default file access is read SWMR.
    1992     */
    1993    public static void setReadSWMR(boolean b) {
    1994        isReadSWMR = b;
    1995    }
    1996
    1997    /**
    1998     * Returns value of default lib version for the earliest.
    1999     *
    2000     * @return value of default lib version for the earliest.
    2001     */
    2002    public static String getEarlyLib() {
    2003        return EarlyLib;
    2004    }
    2005
    2006    /**
    2007     * Set the value of default lib version for the earliest.
    2008     *
    2009     * @param vers
    2010     *            the value of default lib version for the earliest.
    2011     */
    2012    public static void setEarlyLib(String vers) {
    2013        EarlyLib = vers;
    2014    }
    2015
    2016    /**
    2017     * Returns value of default lib version for the latest.
    2018     *
    2019     * @return value of default lib version for the latest.
    2020     */
    2021    public static String getLateLib() {
    2022        return LateLib;
    2023    }
    2024
    2025    /**
    2026     * Set the value of default lib version for the latest.
    2027     *
    2028     * @param vers
    2029     *            the value of default lib version for the latest.
    2030     */
    2031    public static void setLateLib(String vers) {
    2032        LateLib = vers;
    2033    }
    2034
    2035    /**
    2036     * @return the convertEnum
    2037     */
    2038    public static boolean isConvertEnum() {
    2039        return convertEnum;
    2040    }
    2041
    2042    /**
    2043     * Returns true if "show regref values" is set.
    2044     *
    2045     * @return true if "show regref values" is set; otherwise, returns false.
    2046     */
    2047    public static boolean showRegRefValues() {
    2048        return showRegRefValues;
    2049    }
    2050
    2051    /**
    2052     * @return the isIndexBase1
    2053     */
    2054    public static boolean isIndexBase1() {
    2055        return isIndexBase1;
    2056    }
    2057
    2058    /**
    2059     * @param convertEnum
    2060     *            the convertEnum to set
    2061     */
    2062    public static void setConvertEnum(boolean convertEnum) {
    2063        ViewProperties.convertEnum = convertEnum;
    2064    }
    2065
    2066    /**
    2067     * Set the flag to indicate if "show RegRef values" is set.
    2068     *
    2069     * @param b
    2070     *            the flag to indicate if if "show RegRef values" is set.
    2071     */
    2072    public static void setShowRegRefValue(boolean b) {
    2073        showRegRefValues = b;
    2074    }
    2075
    2076    /**
    2077     * Set the flag to indicate if IndexBase should start at 1.
    2078     *
    2079     * @param b
    2080     *            the flag to indicate if IndexBase should start at 1.
    2081     */
    2082    public static void setIndexBase1(boolean b) {
    2083        ViewProperties.isIndexBase1 = b;
    2084    }
    2085
    2086    /**
    2087     * Sets the list of most recently accessed files.
    2088     *
    2089     * @param recentFilesList
    2090     *               The list of most recently accessed files.
    2091     */
    2092    public static void setRecentFiles(ArrayList<String> recentFilesList) {
    2093        recentFiles = recentFilesList;
    2094    }
    2095}