Application: gvSIG desktop

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 * 

 */

/*

 * AUTHORS (In addition to CIT):

 * 2010 {Prodevelop}   {Task}

 */

package org.gvsig.installer.swing.impl.execution.panel.selectPackages2.model;

import java.io.File;

import java.net.URL;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Comparator;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.swing.table.AbstractTableModel;

import org.gvsig.installer.lib.api.InstallerLocator;

import org.gvsig.installer.lib.api.InstallerManager;

import org.gvsig.installer.lib.api.PackageInfo;

import org.gvsig.installer.lib.api.creation.MakePluginPackageServiceException;

import org.gvsig.installer.lib.api.execution.InstallPackageService;

import org.gvsig.installer.swing.api.SwingInstallerManager;

import org.gvsig.installer.swing.impl.execution.panel.selectPackages2.PackageFilter;

public class PackagesTableModel extends AbstractTableModel {

    private static final long serialVersionUID = -454014676003979512L;

    public enum PackageStatus {

        INSTALLED, NOT_INSTALLED, TO_REINSTALL, TO_INSTALL, INSTALLED_NOT_INSTALLABLE;

    }

    public enum PackageOfficialRecommended {

        OFFICIAL_NOT_RECOMMENDED, OFFICIAL_RECOMMENDED, NOT_OFFICIAL_RECOMMENDED, NOT_OFFICIAL_NOT_RECOMMENDED

    }

    public enum PackageOsAndArchitecture {

        WINDOLS_32, WINDOLS_64, LINUX_32, LINUX_64, ALL, OTHER

    }

    private TablePackageInfo[] installerInfos = null;

    private final String[] columnNames;

    private InstallerManager installerManager =

        InstallerLocator.getInstallerManager();

    InstallPackageService installerExecutionService;

    boolean isOfficial;

    File pluginsFolder;

    private PackageFilter packageFilter = null;

    public PackagesTableModel(SwingInstallerManager swingInstallerManager,

        InstallPackageService installerExecutionService, boolean isOfficial,

        File pluginsFolder) {

        this.installerExecutionService = installerExecutionService;

        this.isOfficial = isOfficial;

        this.pluginsFolder = pluginsFolder;

        Map<String, TablePackageInfo> infos = getDefaultPackages();

        installerInfos =

            infos.values().toArray(new TablePackageInfo[infos.size()]);

        sortInstallerInfos();

        columnNames =

            new String[] {

                "", // Check column

                "", "", swingInstallerManager.getText("name"),

                swingInstallerManager.getText("version"),

                swingInstallerManager.getText("type") };

    }

    private void sortInstallerInfos() {

        Arrays.sort(this.installerInfos, new Comparator<TablePackageInfo>() {

            public int compare(TablePackageInfo o1, TablePackageInfo o2) {

                return o1.getPackageInfo().getName().compareToIgnoreCase(

                    o2.getPackageInfo().getName());

            }

        });

    }

    private Map<String, TablePackageInfo> getDefaultPackages() {

        List<String> defaultIDs =

            installerExecutionService.getDefaultSelectedPackagesIDs();

        Map<String, TablePackageInfo> infos =

            new HashMap<String, TablePackageInfo>();

        // Add installable package infos

        for (int i = 0; i < installerExecutionService.getPackageCount(); i++) {

            PackageInfo installerInfo =

                installerExecutionService.getPackageInfo(i);

            if (installerInfo.isOfficial() == isOfficial) {

                TablePackageInfo info =

                    new TablePackageInfo(installerInfo, false, true);

                if (defaultIDs != null) {

                    for (int j = 0; j < defaultIDs.size(); j++) {

                        if (info.getPackageInfo().matchID(defaultIDs.get(j))) {

                            if (info.getPackageInfo().getOperatingSystem()

                                .equals(installerManager.getOperatingSystem())

                                || info.getPackageInfo().getOperatingSystem()

                                    .equals("all")) {

                                info.setDefault(true);

                                break;

                            }

                        }

                    }

                }

                infos.put(info.getID(), info);

            }

        }

        // Add already installed package infos

        try {

            PackageInfo[] installedPackages =

                installerManager.getInstalledPackages(pluginsFolder);

            for (int i = 0; i < installedPackages.length; i++) {

                if (installedPackages[i].isOfficial() == isOfficial) {

                    TablePackageInfo info =

                        new TablePackageInfo(installedPackages[i], true, false);

                    TablePackageInfo x = infos.get(info.getID());

                    if (x == null) {

                        infos.put(info.getID(), info);

                    } else {

                        x.setInstalled(true);

                    }

                }

            }

        } catch (MakePluginPackageServiceException e) {

            throw new RuntimeException(e);

        }

        return infos;

    }

    // get filtered packages

    private Map<String, TablePackageInfo> getFilteredPackages(

        Map<String, TablePackageInfo> packageInfos) {

        Map<String, TablePackageInfo> infos =

            new HashMap<String, TablePackageInfo>();

        TablePackageInfo[] packs =

            packageInfos.values().toArray(new TablePackageInfo[infos.size()]);

        for (int i = 0; i < packs.length; i++) {

            PackageInfo installerInfo = packs[i].getPackageInfo();

            if (packageFilter.match(installerInfo)) {

                TablePackageInfo info = packs[i];

                infos.put(installerInfo.getID(), info);

            }

        }

        return infos;

    }

    // selects default packages

    public void selectDefaultPackages() {

        for (int i = 0; i < installerInfos.length; i++) {

            if (installerInfos[i].isDefault()) {

                installerInfos[i].setSelected(true);

            } else {

                installerInfos[i].setSelected(false);

            }

        }

    }

    public void selectPackage(PackageInfo pkg) {

        for (int i = 0; i < installerInfos.length; i++) {

            if (pkg.equals(installerInfos[i].getPackageInfo())) {

                installerInfos[i].setSelected(true);

                return;

            }

        }

    }

    public void updatePackages() {

        Map<String, TablePackageInfo> infos = getDefaultPackages();

        if (isFilterSet()) {

            infos = getFilteredPackages(infos);

        }

        for (int i = 0; i < installerInfos.length; i++) {

            TablePackageInfo installerInfo =

                infos.get(installerInfos[i].getID());

            if (installerInfo != null) {

                installerInfo.setSelected(installerInfos[i].isSelected());

            }

        }

        installerInfos =

            infos.values().toArray(new TablePackageInfo[infos.size()]);

        sortInstallerInfos();

        List<String> idList =

            installerExecutionService.getDefaultSelectedPackagesIDs();

        if (idList != null) {

            for (int i = 0; i < installerInfos.length; i++) {

                for (int j = 0; j < idList.size(); j++) {

                    if (installerInfos[i].getPackageInfo().matchID(

                        idList.get(j))) {

                        if (installerInfos[i].getPackageInfo()

                            .getOperatingSystem().equals(

                                installerManager.getOperatingSystem())

                            || installerInfos[i].getPackageInfo()

                                .getOperatingSystem().equals("all")) {

                            installerInfos[i].setDefault(true);

                        }

                    }

                }

            }

        }

    }

    public Class<?> getColumnClass(int columnIndex) {

        switch (columnIndex) {

        case 0:

            return PackageStatus.class;

        case 1:

            return PackageOfficialRecommended.class;

        case 2:

            return PackageOsAndArchitecture.class;

        default:

            return String.class;

        }

    }

    public int getColumnCount() {

        return columnNames.length;

    }

    public String getColumnName(int columnIndex) {

        return columnIndex >= columnNames.length ? ""

            : columnNames[columnIndex];

    }

    public int getRowCount() {

        return installerInfos.length;

    }

    public Object getValueAt(int rowIndex, int columnIndex) {

        TablePackageInfo tableInfo = installerInfos[rowIndex];

        PackageInfo installerInfo = tableInfo.getPackageInfo();

        switch (columnIndex) {

        case 0:

            PackageStatus installStatus = checkStatus(rowIndex);

            return installStatus;

        case 1:

            PackageOfficialRecommended officialRecommended =

                checkOfficialRecommended(rowIndex);

            return officialRecommended;

        case 2:

            PackageOsAndArchitecture packageSystem =

                checkPackageSystem(rowIndex);

            return packageSystem;

        case 3:

            return installerInfo.getName();

        case 4:

            return installerInfo.getVersion();

        case 5:

            return installerInfo.getType();

            // case 5:

            // if (installerInfo.getOperatingSystem().equals(

            // installerInfo.getArchitecture())) {

            // return "all";

            // } else {

            // return installerInfo.getOperatingSystem() + " "

            // + installerInfo.getArchitecture();

            // }

        default:

            return "";

        }

    }

    /**

     * @param rowIndex

     * @return

     */

    private PackageOsAndArchitecture checkPackageSystem(int rowIndex) {

        TablePackageInfo tableInfo = installerInfos[rowIndex];

        PackageInfo installerInfo = tableInfo.getPackageInfo();

        PackageOsAndArchitecture oSArch;

        if (installerInfo.getOperatingSystem().equals(

            installerInfo.getArchitecture())) {

            oSArch = PackageOsAndArchitecture.ALL;

        } else

            if ((installerInfo.getOperatingSystem().equals("lin"))) {

                if (installerInfo.getArchitecture().equals("x86")) {

                    oSArch = PackageOsAndArchitecture.LINUX_32;

                } else {

                    oSArch = PackageOsAndArchitecture.LINUX_64;

                }

            } else

                if ((installerInfo.getOperatingSystem().equals("win"))) {

                    if (installerInfo.getArchitecture().equals("x86")) {

                        oSArch = PackageOsAndArchitecture.WINDOLS_32;

                    } else {

                        oSArch = PackageOsAndArchitecture.WINDOLS_64;

                    }

                } else {

                    oSArch = PackageOsAndArchitecture.OTHER;

                }

        return oSArch;

    }

    /**

     * @return

     */

    private PackageStatus checkStatus(int rowIndex) {

        TablePackageInfo tableInfo = installerInfos[rowIndex];

        if (tableInfo.isInstalled()) {

            if (tableInfo.isInstallable()) {

                if (tableInfo.isSelected()) {

                    return PackageStatus.TO_REINSTALL;

                } else {

                    return PackageStatus.INSTALLED;

                }

            } else {

                return PackageStatus.INSTALLED_NOT_INSTALLABLE;

            }

        } else {

            if (tableInfo.isSelected()) {

                return PackageStatus.TO_INSTALL;

            } else {

                return PackageStatus.NOT_INSTALLED;

            }

        }

    }

    private PackageOfficialRecommended checkOfficialRecommended(int rowIndex) {

        TablePackageInfo tableInfo = installerInfos[rowIndex];

        PackageInfo packageInfo = tableInfo.getPackageInfo();

        if (packageInfo.isOfficial()) {

            if (installerInfos[rowIndex].isDefault()) {

                return PackageOfficialRecommended.OFFICIAL_RECOMMENDED;

            } else {

                return PackageOfficialRecommended.OFFICIAL_NOT_RECOMMENDED;

            }

        } else {

            if (installerInfos[rowIndex].isDefault()) {

                return PackageOfficialRecommended.NOT_OFFICIAL_RECOMMENDED;

            } else {

                return PackageOfficialRecommended.NOT_OFFICIAL_NOT_RECOMMENDED;

            }

        }

    }

    public PackageInfo getPackageInfoAt(int rowIndex) {

        return installerInfos[rowIndex].getPackageInfo();

    }

    public String getDescriptionAt(int rowIndex) {

        return getPackageInfoAt(rowIndex).getDescription();

    }

    public URL getSourcesAt(int rowIndex) {

        return getPackageInfoAt(rowIndex).getSourcesURL();

    }

    public String getOwnerAt(int rowIndex) {

        return getPackageInfoAt(rowIndex).getOwner();

    }

    public boolean isCellEditable(int rowIndex, int columnIndex) {

        return (columnIndex == 0) && installerInfos[rowIndex].isInstallable();

    }

    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {

        if (columnIndex == 0) {

            PackageStatus status = (PackageStatus) aValue;

            TablePackageInfo tableInfo = installerInfos[rowIndex];

            switch (status) {

            case INSTALLED:

            case NOT_INSTALLED:

                tableInfo.setSelected(false);

                break;

            case TO_REINSTALL:

            case TO_INSTALL:

                tableInfo.setSelected(true);

                break;

            }

        }

    }

    public List<PackageInfo> getPackagesToInstall() {

        List<PackageInfo> packageInfosToInstall = new ArrayList<PackageInfo>();

        for (int i = 0; i < installerInfos.length; i++) {

            TablePackageInfo tableInfo = installerInfos[i];

            if (tableInfo.isSelected()) {

                packageInfosToInstall.add(tableInfo.getPackageInfo());

            }

        }

        return packageInfosToInstall;

    }

    public boolean hasAnyPackageSelected() {

        for (int i = 0; i < installerInfos.length; i++) {

            if (installerInfos[i].isSelected) {

                return true;

            }

        }

        return false;

    }

    public static final class TablePackageInfo {

        private final PackageInfo packageInfo;

        private boolean isInstalled;

        private final boolean isInstallable;

        private boolean isSelected;

        private boolean isDefault;

        public TablePackageInfo(PackageInfo packageInfo, boolean isInstalled,

            boolean isInstallable) {

            this(packageInfo, isInstalled, isInstallable, false, false);

        }

        public void setInstalled(boolean installed) {

            this.isInstalled = installed;

        }

        public TablePackageInfo(PackageInfo packageInfo, boolean isInstalled,

            boolean isInstallable, boolean isSelected, boolean isDefault) {

            this.packageInfo = packageInfo;

            this.isInstalled = isInstalled;

            this.isInstallable = isInstallable;

            this.isSelected = isSelected;

            this.isDefault = isDefault;

        }

        public String getID() {

            PackageInfo pkg = this.getPackageInfo();

            return pkg.getID();

        }

        public PackageInfo getPackageInfo() {

            return packageInfo;

        }

        public boolean isInstalled() {

            return isInstalled;

        }

        public boolean isInstallable() {

            return isInstallable;

        }

        public boolean isSelected() {

            return isSelected;

        }

        public void setSelected(boolean isSelected) {

            this.isSelected = isSelected;

        }

        public void setDefault(boolean isDefault) {

            this.isDefault = isDefault;

        }

        public boolean isDefault() {

            return isDefault;

        }

    }

    /**

     * Returns the TablePackageInfo located in the given row.

     * 

     * @param row

     *            the TablePackageInfo located in the given row

     */

    public TablePackageInfo getPackageInfo(int row) {

        return installerInfos[row];

    }

    public void setFilter(PackageFilter filter) {

        this.packageFilter = filter;

        // updatePackages();

    }

    public Boolean isFilterSet() {

        return this.packageFilter != null;

    }

    public PackageFilter getFilter() {

        return this.packageFilter;

    }

}