0001: /*
0002: * SalomeTMF is a Test Management Framework
0003: * Copyright (C) 2007 EDF / France Telecom R&D
0004: *
0005: * This library is free software; you can redistribute it and/or
0006: * modify it under the terms of the GNU Lesser General Public
0007: * License as published by the Free Software Foundation; either
0008: * version 2 of the License, or (at your option) any later version.
0009: *
0010: * This library is distributed in the hope that it will be useful,
0011: * but WITHOUT ANY WARRANTY; without even the implied warranty of
0012: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
0013: * Lesser General Public License for more details.
0014: *
0015: * You should have received a copy of the GNU Lesser General Public
0016: * License along with this library; if not, write to the Free Software
0017: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0018: *
0019: * @author Jérémie DEFAYE
0020: *
0021: * Contact: mikael.marche@rd.francetelecom.com
0022: */
0023:
0024: package salomeTMF_plug.pluginxlsxml.Import;
0025:
0026: import java.awt.BorderLayout;
0027: import java.awt.Container;
0028: import java.awt.FlowLayout;
0029: import java.awt.event.ActionEvent;
0030: import java.awt.event.ActionListener;
0031: import java.io.File;
0032: import java.io.FileInputStream;
0033: import java.net.URL;
0034: import java.util.ArrayList;
0035: import java.util.Vector;
0036:
0037: import javax.swing.BorderFactory;
0038: import javax.swing.Box;
0039: import javax.swing.BoxLayout;
0040: import javax.swing.ButtonGroup;
0041: import javax.swing.JButton;
0042: import javax.swing.JCheckBox;
0043: import javax.swing.JDialog;
0044: import javax.swing.JFileChooser;
0045: import javax.swing.JLabel;
0046: import javax.swing.JOptionPane;
0047: import javax.swing.JPanel;
0048: import javax.swing.JProgressBar;
0049: import javax.swing.JRadioButton;
0050: import javax.swing.JTabbedPane;
0051: import javax.swing.JTextField;
0052: import javax.swing.border.TitledBorder;
0053: import javax.swing.tree.DefaultMutableTreeNode;
0054:
0055: import org.dom4j.Document;
0056: import org.dom4j.io.SAXReader;
0057: import org.java.plugin.Extension;
0058: import org.objectweb.salome_tmf.data.AdminVTData;
0059: import org.objectweb.salome_tmf.data.Family;
0060: import org.objectweb.salome_tmf.data.Test;
0061: import org.objectweb.salome_tmf.data.TestList;
0062: import org.objectweb.salome_tmf.ihm.main.SalomeTMFContext;
0063: import org.objectweb.salome_tmf.ihm.main.datawrapper.DataModel;
0064: import org.objectweb.salome_tmf.ihm.models.ScriptFileFilter;
0065: import org.objectweb.salome_tmf.ihm.tools.Tools;
0066: import org.objectweb.salome_tmf.plugins.IPlugObject;
0067: import org.objectweb.salome_tmf.plugins.JPFManager;
0068: import org.objectweb.salome_tmf.plugins.core.ReqManager;
0069: import org.objectweb.salome_tmf.plugins.core.XMLLoaderPlugin;
0070: import org.objectweb.salome_tmf.plugins.core.XMLPrinterPlugin;
0071:
0072: import salomeTMF_plug.pluginxlsxml.Commun.TestPresencePlugin;
0073: import salomeTMF_plug.pluginxlsxml.language.Language;
0074: import salomeTMF_plug.requirements.ImportXMLReq;
0075: import salomeTMF_plug.requirements.ReqPlugin;
0076: import salomeTMF_plug.requirements.ihm.RequirementPanel;
0077: import salomeTMF_plug.pluginxlsxml.Import.ImportXML2;
0078:
0079: /**
0080: * Open a dialog box for selecting a XlS file to import data
0081: */
0082: public class ImportXLSDialog extends JDialog {
0083:
0084: // Partie ImportXML
0085: //private boolean supprElement = false;
0086: //private boolean supprAction = false;
0087: //private boolean creer_copy = false;
0088: //private boolean majPossible = false;
0089:
0090: ImportXMLReq pImportXMLReq;
0091: ReqPlugin pReqPlugin;
0092: RequirementPanel pRequirementPanel;
0093: XMLLoaderPlugin pXMLLoader;
0094:
0095: private XMLPrinterPlugin pXMLPrinterPlugin;
0096: private XMLLoaderPlugin pXMLLoaderPlugin;
0097: private ReqManager pReqManager;
0098: private Vector listXMLPlugin = new Vector();
0099: private Vector panelsPluginsForImport = new Vector();
0100:
0101: // Salome GUI
0102: IPlugObject pIhm = null;
0103: private URL urlDeBase;
0104: private String url_text;
0105: private String xlsFile;
0106: private JLabel xlsSauvLabel;
0107: private JTextField xlsSauvTF;
0108: private JButton xlsSauvButton;
0109: private JLabel choixImport;
0110: private String xlsErrorMessage = "";
0111: private String exigenceNonTrouvePourTest;
0112: private Document xlsDoc;
0113: private JProgressBar xlsProgress;
0114: private JCheckBox importTest;
0115: private JCheckBox importExigence;
0116: private JCheckBox importParametre;
0117: private JCheckBox importEnvironnement;
0118: private JCheckBox importExecutionCampagnes;
0119: private boolean selectionImportTest = true;
0120: private boolean selectionImportExigence = true;
0121: private boolean selectionImportParametre = true;
0122: private boolean selectionImportEnvironnement = true;
0123: private boolean selectionExecutionCampagnes = true;
0124: private JButton xlsValider;
0125: private JButton xlsAnnuler;
0126: private boolean ok;
0127: private boolean xlsAnnule = false;
0128: private boolean xlsErreurTraitement = false;
0129: private ArrayList<TestList> suiteSelectionList = new ArrayList<TestList>();
0130: private ArrayList<Family> familySelectionList = new ArrayList<Family>();
0131: private ArrayList<Test> testSelectionList = new ArrayList<Test>();
0132: private boolean isErreurTraitementImport = false;
0133:
0134: // partie campagne
0135: private JLabel campagneLabel;
0136: private JRadioButton CampagneneRienFaire;
0137: private JLabel CampagneneRienFaireLabel;
0138: private JRadioButton CampagneImport;
0139: private JLabel CampagneImportLabel;
0140: private JRadioButton CampagneUneParFamille;
0141: private JLabel CampagneUneParFamilleLabel;
0142: private JRadioButton CampagneUneParExigence;
0143: private JLabel CampagneUneParExigenceLabel;
0144: private JRadioButton CampagneUneParProjet;
0145: private JLabel CampagneUneParProjetLabel;
0146: private ButtonGroup buttonGroupCampagne;
0147:
0148: // Partie Gestion Conflit
0149: private JLabel conflitLabel;
0150: private JCheckBox suppr;
0151: private JRadioButton keepOriginal;
0152: private JRadioButton keepOriginalAndImport;
0153: private JRadioButton keepOriginalAndUpdate;
0154: private JRadioButton updateOriginal;
0155: private JRadioButton eraseOriginalAndImport;
0156:
0157: private String fs = System.getProperties().getProperty(
0158: "file.separator");
0159: ImportXML2 traitement;
0160: DefaultMutableTreeNode chosenRoot;
0161:
0162: /**
0163: * Creates a new instance of ExportDialog
0164: *
0165: * @param vt
0166: * Interface Homme Machine
0167: * @throws Exception
0168: * Exception for super command
0169: */
0170: public ImportXLSDialog(IPlugObject vt) throws Exception {
0171: super (SalomeTMFContext.getInstance().getSalomeFrame(), true);
0172: // super(vt);
0173: pIhm = vt;
0174:
0175: Vector listExtXMLPlugin = pIhm.getXMLPrintersExtension();
0176: int size = listExtXMLPlugin.size();
0177: for (int i = 0; i < size; i++) {
0178: Extension pXMLExt = (Extension) listExtXMLPlugin
0179: .elementAt(i);
0180: JPFManager pJPFManager = pIhm.getPluginManager();
0181: try {
0182: pXMLPrinterPlugin = (XMLPrinterPlugin) pJPFManager
0183: .activateExtension(pXMLExt);
0184: if (!listXMLPlugin.contains(pXMLPrinterPlugin)) {
0185: listXMLPlugin.add(pXMLPrinterPlugin);
0186: }
0187:
0188: JPanel pPanel = pXMLPrinterPlugin
0189: .getImportOptionPanel();
0190: if (pPanel != null
0191: && !panelsPluginsForImport.contains(pPanel)) {
0192: panelsPluginsForImport.add(pPanel);
0193: }
0194: } catch (Exception e) {
0195:
0196: }
0197: }
0198:
0199: // size = listExtXMLPlugin.size();
0200: for (int i = 0; i < size; i++) {
0201: Extension pXMLExt = (Extension) listExtXMLPlugin
0202: .elementAt(i);
0203: JPFManager pJPFManager = pIhm.getPluginManager();
0204: try {
0205: pReqManager = (ReqManager) pJPFManager
0206: .activateExtension(pXMLExt);
0207: if (!listXMLPlugin.contains(pReqManager)) {
0208: listXMLPlugin.add(pReqManager);
0209: }
0210: } catch (Exception e) {
0211:
0212: }
0213: }
0214:
0215: urlDeBase = SalomeTMFContext.getInstance().getUrlBase();
0216: String _urlBase = urlDeBase.toString();
0217: url_text = _urlBase.substring(0, _urlBase.lastIndexOf("/"));
0218:
0219: DataModel.reloadFromBase(false);
0220:
0221: xlsSauvLabel = new JLabel(Language.getInstance().getText(
0222: "Fichier_a_importer"));
0223: xlsSauvTF = new JTextField(30);
0224: xlsSauvButton = new JButton(Language.getInstance().getText(
0225: "Choisir..."));
0226: xlsSauvButton.addActionListener(new ActionListener() {
0227: public void actionPerformed(ActionEvent e) {
0228: JFileChooser fileChooser = new JFileChooser();
0229: fileChooser
0230: .addChoosableFileFilter(new ScriptFileFilter(
0231: Language.getInstance().getText(
0232: "Fichier_XLS_[*.xls]"), ".xls"));
0233: int returnVal = fileChooser.showDialog(
0234: ImportXLSDialog.this , Language.getInstance()
0235: .getText("Sélectionner"));
0236: if (returnVal == JFileChooser.APPROVE_OPTION) {
0237: xlsFile = fileChooser.getSelectedFile()
0238: .getAbsolutePath();
0239: if (xlsFile.indexOf(".") != -1) {
0240: if (!xlsFile
0241: .substring(xlsFile.lastIndexOf("."))
0242: .equals(".xls")) {
0243: xlsFile += ".xls";
0244: }
0245: } else {
0246: xlsFile += ".xls";
0247: }
0248: xlsSauvTF.setText(xlsFile);
0249: }
0250: }
0251: });
0252:
0253: JPanel xlsSauvLabelPanel = new JPanel(new FlowLayout(
0254: FlowLayout.LEFT));
0255: xlsSauvLabelPanel.add(xlsSauvLabel);
0256: JPanel xlsSauvTFPanel = new JPanel(new FlowLayout(
0257: FlowLayout.LEFT));
0258: xlsSauvTFPanel.add(xlsSauvTF);
0259: JPanel xlsSauvButtonPanel = new JPanel(new FlowLayout(
0260: FlowLayout.LEFT));
0261: xlsSauvButtonPanel.add(xlsSauvButton);
0262:
0263: JPanel xlsSauvPanel = new JPanel();
0264: xlsSauvPanel.setLayout(new BoxLayout(xlsSauvPanel,
0265: BoxLayout.Y_AXIS));
0266: xlsSauvPanel.setBorder(BorderFactory.createTitledBorder(""));
0267: xlsSauvPanel.add(xlsSauvLabelPanel);
0268: xlsSauvPanel.add(xlsSauvTFPanel);
0269: xlsSauvPanel.add(xlsSauvButtonPanel);
0270:
0271: // Parte création groupe icone
0272: campagneLabel = new JLabel(Language.getInstance().getText(
0273: "Creation_des_campagnes"));
0274: CampagneneRienFaire = new JRadioButton();
0275: CampagneneRienFaireLabel = new JLabel(Language.getInstance()
0276: .getText("Pas_Campagne"));
0277: CampagneneRienFaire.addActionListener(new ActionListener() {
0278: public void actionPerformed(ActionEvent e) {
0279: importExecutionCampagnes.setEnabled(false);
0280: importExecutionCampagnes.setSelected(false);
0281: selectionExecutionCampagnes = false;
0282: keepOriginalAndUpdate.setEnabled(true);
0283: updateOriginal.setEnabled(true);
0284: eraseOriginalAndImport.setEnabled(true);
0285: }
0286: });
0287: CampagneUneParFamille = new JRadioButton();
0288: CampagneUneParFamilleLabel = new JLabel(Language.getInstance()
0289: .getText("Creer_une_campagne_par_Famille"));
0290: CampagneUneParFamille.addActionListener(new ActionListener() {
0291: public void actionPerformed(ActionEvent e) {
0292: importExecutionCampagnes.setEnabled(false);
0293: importExecutionCampagnes.setSelected(false);
0294: selectionExecutionCampagnes = false;
0295: }
0296: });
0297: CampagneUneParExigence = new JRadioButton();
0298: CampagneUneParExigenceLabel = new JLabel(Language.getInstance()
0299: .getText("Creer_une_campagne_par_exigence"));
0300: CampagneUneParExigence.addActionListener(new ActionListener() {
0301: public void actionPerformed(ActionEvent e) {
0302: importExecutionCampagnes.setEnabled(false);
0303: importExecutionCampagnes.setSelected(false);
0304: selectionExecutionCampagnes = false;
0305: }
0306: });
0307: CampagneUneParProjet = new JRadioButton();
0308: CampagneUneParProjetLabel = new JLabel(
0309: Language.getInstance().getText(
0310: "Creer_une_seule_campagne_pour_tout_le_projet"));
0311: CampagneUneParProjet.addActionListener(new ActionListener() {
0312: public void actionPerformed(ActionEvent e) {
0313: importExecutionCampagnes.setEnabled(false);
0314: importExecutionCampagnes.setSelected(false);
0315: selectionExecutionCampagnes = false;
0316: }
0317: });
0318: CampagneImport = new JRadioButton();
0319: CampagneImportLabel = new JLabel(Language.getInstance()
0320: .getText("Importer_Campagnes"));
0321: CampagneImport.setSelected(true);
0322: CampagneImport.addActionListener(new ActionListener() {
0323: public void actionPerformed(ActionEvent e) {
0324: importExecutionCampagnes.setEnabled(true);
0325: ;
0326: importExecutionCampagnes.setSelected(true);
0327: selectionExecutionCampagnes = true;
0328: keepOriginalAndUpdate.setEnabled(false);
0329: updateOriginal.setEnabled(false);
0330: eraseOriginalAndImport.setEnabled(false);
0331: }
0332: });
0333:
0334: buttonGroupCampagne = new ButtonGroup();
0335: buttonGroupCampagne.add(CampagneneRienFaire);
0336: buttonGroupCampagne.add(CampagneUneParFamille);
0337: buttonGroupCampagne.add(CampagneUneParExigence);
0338: buttonGroupCampagne.add(CampagneUneParProjet);
0339: buttonGroupCampagne.add(CampagneImport);
0340:
0341: importExecutionCampagnes = new JCheckBox(Language.getInstance()
0342: .getText("Execution_Des_Campagnes"));
0343: importExecutionCampagnes.setSelected(true);
0344: importExecutionCampagnes
0345: .addActionListener(new ActionListener() {
0346: public void actionPerformed(ActionEvent e) {
0347: if (importExecutionCampagnes.isSelected()) {
0348: selectionExecutionCampagnes = true;
0349: }
0350: }
0351: });
0352:
0353: JPanel campagnePanel = new JPanel(new FlowLayout(
0354: FlowLayout.LEFT));
0355: campagnePanel.add(campagneLabel);
0356:
0357: JPanel campagneneRienFairePanel = new JPanel(new FlowLayout(
0358: FlowLayout.LEFT));
0359: campagneneRienFairePanel.add(CampagneneRienFaire);
0360: campagneneRienFairePanel.add(CampagneneRienFaireLabel);
0361:
0362: JPanel campagneUneParFamillePanel = new JPanel(new FlowLayout(
0363: FlowLayout.LEFT));
0364: campagneUneParFamillePanel.add(CampagneUneParFamille);
0365: campagneUneParFamillePanel.add(CampagneUneParFamilleLabel);
0366:
0367: JPanel campagneUneParExigencePanel = new JPanel(new FlowLayout(
0368: FlowLayout.LEFT));
0369: campagneUneParExigencePanel.add(CampagneUneParExigence);
0370: campagneUneParExigencePanel.add(CampagneUneParExigenceLabel);
0371:
0372: JPanel campagneUneParProjetPanel = new JPanel(new FlowLayout(
0373: FlowLayout.LEFT));
0374: campagneUneParProjetPanel.add(CampagneUneParProjet);
0375: campagneUneParProjetPanel.add(CampagneUneParProjetLabel);
0376:
0377: JPanel CampagneImportPanel = new JPanel(new FlowLayout(
0378: FlowLayout.LEFT));
0379: CampagneImportPanel.add(CampagneImport);
0380: CampagneImportPanel.add(CampagneImportLabel);
0381:
0382: JPanel ExecCampagneImportPanel = new JPanel(new FlowLayout(
0383: FlowLayout.LEFT));
0384: ExecCampagneImportPanel.add(importExecutionCampagnes);
0385:
0386: JPanel gestionChoixCampagne = new JPanel();
0387: gestionChoixCampagne.setLayout(new BoxLayout(
0388: gestionChoixCampagne, BoxLayout.Y_AXIS));
0389: gestionChoixCampagne.add(campagnePanel);
0390: gestionChoixCampagne.add(campagneneRienFairePanel);
0391: gestionChoixCampagne.add(campagneUneParFamillePanel);
0392: if (TestPresencePlugin.testDeLaPresenceDuPluginRequirement()) {
0393: gestionChoixCampagne.add(campagneUneParExigencePanel);
0394: }
0395: gestionChoixCampagne.add(campagneUneParProjetPanel);
0396: gestionChoixCampagne.add(CampagneImportPanel);
0397: gestionChoixCampagne.add(ExecCampagneImportPanel);
0398:
0399: // concerne la gestion des conflits
0400: suppr = new JCheckBox(
0401: Language
0402: .getInstance()
0403: .getText(
0404: "Supprimer_les_éléments_qui_ne_sont_pas_dans_le_document_XML"));
0405: conflitLabel = new JLabel(Language.getInstance().getText(
0406: "En_cas_de_conflit_:_"));
0407: keepOriginal = new JRadioButton(Language.getInstance().getText(
0408: "Conserver_l_original"));
0409: keepOriginalAndImport = new JRadioButton(
0410: Language
0411: .getInstance()
0412: .getText(
0413: "Garder_une_copie_et_importer_le_nouvel_element"));
0414: keepOriginalAndUpdate = new JRadioButton(
0415: Language
0416: .getInstance()
0417: .getText(
0418: "Garder_un_copie_et_mettre_a_jour_une_copie_de_l_original_avec_l_element_importe"));
0419: updateOriginal = new JRadioButton(
0420: Language
0421: .getInstance()
0422: .getText(
0423: "Mettre_a_jour_l_original_avec_l_element_importe"));
0424: eraseOriginalAndImport = new JRadioButton(Language
0425: .getInstance().getText(
0426: "Remplacer_l_original_par_l_element_importe"));
0427: keepOriginal.setSelected(true);
0428:
0429: ButtonGroup conflictGroup = new ButtonGroup();
0430: conflictGroup.add(keepOriginal);
0431: conflictGroup.add(keepOriginalAndImport);
0432: conflictGroup.add(keepOriginalAndUpdate);
0433: conflictGroup.add(updateOriginal);
0434: conflictGroup.add(eraseOriginalAndImport);
0435:
0436: JPanel supprOptionPanel = new JPanel(new FlowLayout(
0437: FlowLayout.LEFT));
0438: supprOptionPanel.add(suppr);
0439: JPanel conflictPanel = new JPanel(new FlowLayout(
0440: FlowLayout.LEFT));
0441: conflictPanel.add(conflitLabel);
0442: JPanel conflictOption1Panel = new JPanel(new FlowLayout(
0443: FlowLayout.LEFT));
0444: conflictOption1Panel.add(Box.createHorizontalStrut(10));
0445: conflictOption1Panel.add(keepOriginal);
0446: JPanel conflictOption2Panel = new JPanel(new FlowLayout(
0447: FlowLayout.LEFT));
0448: conflictOption2Panel.add(Box.createHorizontalStrut(10));
0449: conflictOption2Panel.add(keepOriginalAndImport);
0450: JPanel conflictOption3Panel = new JPanel(new FlowLayout(
0451: FlowLayout.LEFT));
0452: conflictOption3Panel.add(Box.createHorizontalStrut(10));
0453: conflictOption3Panel.add(keepOriginalAndUpdate);
0454: JPanel conflictOption4Panel = new JPanel(new FlowLayout(
0455: FlowLayout.LEFT));
0456: conflictOption4Panel.add(Box.createHorizontalStrut(10));
0457: conflictOption4Panel.add(updateOriginal);
0458: JPanel conflictOption5Panel = new JPanel(new FlowLayout(
0459: FlowLayout.LEFT));
0460: conflictOption5Panel.add(Box.createHorizontalStrut(10));
0461: conflictOption5Panel.add(eraseOriginalAndImport);
0462:
0463: JPanel optionsPanel = new JPanel();
0464: optionsPanel.setLayout(new BoxLayout(optionsPanel,
0465: BoxLayout.Y_AXIS));
0466: optionsPanel.setBorder(new TitledBorder("Options"));
0467: optionsPanel.add(supprOptionPanel);
0468: optionsPanel.add(Box.createVerticalStrut(10));
0469: optionsPanel.add(conflictPanel);
0470: optionsPanel.add(conflictOption1Panel);
0471: optionsPanel.add(conflictOption2Panel);
0472: optionsPanel.add(conflictOption3Panel);
0473: optionsPanel.add(conflictOption4Panel);
0474: optionsPanel.add(conflictOption5Panel);
0475:
0476: xlsValider = new JButton(Language.getInstance().getText("OK"));
0477: xlsValider.addActionListener(new ActionListener() {
0478: public void actionPerformed(ActionEvent e) {
0479: if ((selectionImportTest == false)
0480: && (selectionImportExigence == false)
0481: && (selectionImportParametre == false)
0482: && (selectionImportEnvironnement == false)) {
0483: JOptionPane
0484: .showMessageDialog(
0485: ImportXLSDialog.this ,
0486: Language
0487: .getInstance()
0488: .getText(
0489: "Vous_devez_selectionner_un_element_a_importer"),
0490: Language.getInstance().getText(
0491: "Erreur_!"),
0492: JOptionPane.ERROR_MESSAGE);
0493: } else if (xlsSauvTF.getText().equals("")) {
0494:
0495: JOptionPane
0496: .showMessageDialog(
0497: ImportXLSDialog.this ,
0498: Language
0499: .getInstance()
0500: .getText(
0501: "Vous_devez_entrez_un_nom_de_fichier"),
0502: Language.getInstance().getText(
0503: "Erreur_!"),
0504: JOptionPane.ERROR_MESSAGE);
0505: ok = false;
0506: } else {
0507: Thread t = new Thread() {
0508: public void run() {
0509: // Instanciation et lancement du traitement
0510: try {
0511: xlsSauvTF.setEnabled(false);
0512: CampagneneRienFaire.setEnabled(false);
0513: CampagneUneParFamille.setEnabled(false);
0514: CampagneUneParExigence
0515: .setEnabled(false);
0516: CampagneUneParProjet.setEnabled(false);
0517: CampagneImport.setEnabled(false);
0518: xlsProgress.setIndeterminate(true);
0519: xlsSauvButton.setEnabled(false);
0520: xlsValider.setEnabled(false);
0521: xlsAnnuler.setEnabled(false);
0522: importTest.setEnabled(false);
0523: importExigence.setEnabled(false);
0524: importParametre.setEnabled(false);
0525: importEnvironnement.setEnabled(false);
0526: importExecutionCampagnes
0527: .setEnabled(false);
0528: /*if (keepOriginalAndImport.isSelected()) {
0529: creer_copy = true;
0530: } else if (keepOriginalAndUpdate.isSelected()) {
0531: majPossible = true;
0532: }
0533: if (eraseOriginalAndImport.isSelected()) {
0534: supprAction = true;
0535: }
0536: if (suppr.isSelected()) {
0537: supprElement = true;
0538: }*/
0539: suppr.setEnabled(false);
0540: keepOriginal.setEnabled(false);
0541: keepOriginalAndImport.setEnabled(false);
0542: keepOriginalAndUpdate.setEnabled(false);
0543: updateOriginal.setEnabled(false);
0544: eraseOriginalAndImport
0545: .setEnabled(false);
0546:
0547: importXLS();
0548:
0549: } catch (Exception ex) {
0550: Tools.ihmExceptionView(ex);
0551: }
0552: }
0553: };
0554: t.start();
0555:
0556: }
0557: }
0558: });
0559:
0560: xlsAnnuler = new JButton(Language.getInstance().getText(
0561: "Annuler"));
0562: xlsAnnuler.addActionListener(new ActionListener() {
0563: public void actionPerformed(ActionEvent e) {
0564: ImportXLSDialog.this .dispose();
0565: }
0566: });
0567:
0568: // Choix donnes à importer
0569: choixImport = new JLabel(Language.getInstance().getText(
0570: "Importer"));
0571: importTest = new JCheckBox(Language.getInstance().getText(
0572: "Tests"));
0573: importTest.setSelected(true);
0574: importTest.addActionListener(new ActionListener() {
0575: public void actionPerformed(ActionEvent e) {
0576: try {
0577: if (!importTest.isSelected()) {
0578: selectionImportTest = false;
0579: //buttonGroupCampagne.clearSelection();
0580: buttonGroupCampagne.setSelected(
0581: CampagneneRienFaire.getModel(), true);
0582: CampagneneRienFaire.setEnabled(false);
0583: CampagneUneParFamille.setEnabled(false);
0584: CampagneUneParExigence.setEnabled(false);
0585: CampagneUneParProjet.setEnabled(false);
0586: CampagneImport.setEnabled(false);
0587: importExecutionCampagnes.setEnabled(false);
0588: importExecutionCampagnes.setSelected(false);
0589: selectionExecutionCampagnes = false;
0590:
0591: } else {
0592: selectionImportTest = true;
0593: CampagneneRienFaire.setEnabled(true);
0594: CampagneUneParFamille.setEnabled(true);
0595: CampagneUneParExigence.setEnabled(true);
0596: CampagneUneParProjet.setEnabled(true);
0597: CampagneImport.setEnabled(true);
0598: if (CampagneImport.isSelected()) {
0599: importExecutionCampagnes.setEnabled(true);
0600: }
0601:
0602: }
0603: } catch (Exception ex) {
0604: Tools.ihmExceptionView(ex);
0605: }
0606: }
0607: });
0608: importExigence = new JCheckBox(Language.getInstance().getText(
0609: "Exigences"));
0610: if (TestPresencePlugin.testDeLaPresenceDuPluginRequirement()) {
0611: importExigence.setSelected(true);
0612:
0613: importExigence.addActionListener(new ActionListener() {
0614: public void actionPerformed(ActionEvent e) {
0615: try {
0616: if (!importExigence.isSelected()) {
0617: selectionImportExigence = false;
0618: if (listXMLPlugin
0619: .contains(pXMLPrinterPlugin)) {
0620: listXMLPlugin.remove(pXMLPrinterPlugin);
0621: }
0622: } else {
0623: selectionImportExigence = true;
0624: if (!listXMLPlugin
0625: .contains(pXMLPrinterPlugin)) {
0626: listXMLPlugin.add(pXMLPrinterPlugin);
0627: }
0628: }
0629: } catch (Exception ex) {
0630: Tools.ihmExceptionView(ex);
0631: }
0632: }
0633: });
0634: } else {
0635: importExigence.setSelected(false);
0636: selectionImportExigence = false;
0637: }
0638:
0639: importParametre = new JCheckBox(Language.getInstance().getText(
0640: "Parametres"));
0641: importParametre.setSelected(true);
0642:
0643: importParametre.addActionListener(new ActionListener() {
0644: public void actionPerformed(ActionEvent e) {
0645: try {
0646: if (!importParametre.isSelected()) {
0647: selectionImportParametre = false;
0648: } else {
0649: selectionImportParametre = true;
0650: }
0651: } catch (Exception ex) {
0652: Tools.ihmExceptionView(ex);
0653: }
0654: }
0655: });
0656:
0657: importEnvironnement = new JCheckBox(Language.getInstance()
0658: .getText("Environnements"));
0659: importEnvironnement.setSelected(true);
0660:
0661: importEnvironnement.addActionListener(new ActionListener() {
0662: public void actionPerformed(ActionEvent e) {
0663: try {
0664: if (!importEnvironnement.isSelected()) {
0665: selectionImportEnvironnement = false;
0666: } else {
0667: selectionImportEnvironnement = true;
0668: }
0669: } catch (Exception ex) {
0670: Tools.ihmExceptionView(ex);
0671: }
0672: }
0673: });
0674:
0675: JPanel xlsChoixImportTestPanel = new JPanel();
0676: xlsChoixImportTestPanel.setLayout(new FlowLayout(
0677: FlowLayout.LEFT));
0678: xlsChoixImportTestPanel.add(choixImport);
0679:
0680: JPanel xlsChoixSelectTestPanel = new JPanel();
0681: xlsChoixSelectTestPanel.setLayout(new FlowLayout(
0682: FlowLayout.LEFT));
0683: xlsChoixSelectTestPanel.add(importTest);
0684:
0685: JPanel xlsChoixSelectExigencePanel = new JPanel();
0686: xlsChoixSelectExigencePanel.setLayout(new FlowLayout(
0687: FlowLayout.LEFT));
0688: xlsChoixSelectExigencePanel.add(importExigence);
0689:
0690: JPanel xlsChoixSelectParametrePanel = new JPanel();
0691: xlsChoixSelectParametrePanel.setLayout(new FlowLayout(
0692: FlowLayout.LEFT));
0693: xlsChoixSelectParametrePanel.add(importParametre);
0694:
0695: JPanel xlsChoixSelectEnvironnementPanel = new JPanel();
0696: xlsChoixSelectEnvironnementPanel.setLayout(new FlowLayout(
0697: FlowLayout.LEFT));
0698: xlsChoixSelectEnvironnementPanel.add(importEnvironnement);
0699:
0700: JPanel xlsChoixSelectPanel = new JPanel();
0701: xlsChoixSelectPanel.setLayout(new BoxLayout(
0702: xlsChoixSelectPanel, BoxLayout.Y_AXIS));
0703: xlsChoixSelectPanel.add(xlsChoixImportTestPanel);
0704: xlsChoixSelectPanel.add(xlsChoixSelectTestPanel);
0705: if (TestPresencePlugin.testDeLaPresenceDuPluginRequirement()) {
0706: xlsChoixSelectPanel.add(xlsChoixSelectExigencePanel);
0707: } else {
0708: selectionImportExigence = false;
0709: }
0710: xlsChoixSelectPanel.add(xlsChoixSelectParametrePanel);
0711: xlsChoixSelectPanel.add(xlsChoixSelectEnvironnementPanel);
0712:
0713: JPanel xlsChoixTestEtCampagne = new JPanel();
0714: xlsChoixTestEtCampagne.setLayout(new BoxLayout(
0715: xlsChoixTestEtCampagne, BoxLayout.X_AXIS));
0716: xlsChoixTestEtCampagne.setBorder(BorderFactory
0717: .createTitledBorder(""));
0718: xlsChoixTestEtCampagne.add(xlsChoixSelectPanel);
0719: xlsChoixTestEtCampagne.add(gestionChoixCampagne);
0720:
0721: JPanel xlsButtons = new JPanel();
0722: xlsButtons.add(xlsValider);
0723: xlsButtons.add(xlsAnnuler);
0724:
0725: // Gestion de la progressbar
0726: xlsProgress = new JProgressBar();
0727: JPanel xlsProgression = new JPanel(new FlowLayout(
0728: FlowLayout.CENTER));
0729: xlsProgression.add(xlsProgress);
0730:
0731: JPanel xlsPage = new JPanel();
0732: xlsPage.setLayout(new BoxLayout(xlsPage, BoxLayout.Y_AXIS));
0733: xlsPage.add(Box.createVerticalStrut(10));
0734: xlsPage.add(xlsSauvPanel);
0735: xlsPage.add(Box.createVerticalStrut(10));
0736: xlsPage.add(xlsChoixTestEtCampagne);
0737: xlsPage.add(Box.createVerticalStrut(10));
0738: xlsPage.add(xlsProgression);
0739: xlsPage.add(xlsButtons);
0740:
0741: JTabbedPane onglets = new JTabbedPane();
0742: onglets.addTab(Language.getInstance().getText("Principal"),
0743: xlsPage);
0744: onglets.addTab(Language.getInstance().getText("Options"),
0745: optionsPanel);
0746:
0747: Container xlsContentPaneFrame = this .getContentPane();
0748: xlsContentPaneFrame.add(onglets, BorderLayout.CENTER);
0749: this .setLocation(400, 100);
0750: this .setTitle(Language.getInstance().getText(
0751: "Import_des_exigences"));
0752: this .pack();
0753: this .setVisible(true);
0754:
0755: }
0756:
0757: /**
0758: * parse XML document from the "path"
0759: *
0760: * @param path
0761: * Xml directory
0762: * @return un document DOM4J
0763: * @throws Exception
0764: * Exception
0765: */
0766: public Document xmlParser(String path) throws Exception {
0767: SAXReader reader = new SAXReader(false);
0768: Document doc = reader.read(new FileInputStream(new File(path)));
0769: return doc;
0770: }
0771:
0772: /**
0773: * launch all process to import data from a XLS spreadsheet to SaloméTMF
0774: */
0775: public void importXLS() {
0776: boolean erreurImportFichier = false;
0777: String fichiersNonImportes = null;
0778: String saveFileName = xlsSauvTF.getText().trim();
0779: String xmlTempFile;
0780: String creationCampagne = null;
0781: if (CampagneUneParFamille.isSelected()) {
0782: creationCampagne = Language.getInstance().getText(
0783: "Campagne_Par_Famille");
0784: } else if (CampagneUneParExigence.isSelected()) {
0785: creationCampagne = Language.getInstance().getText(
0786: "Campagne_Par_Exigence");
0787: } else if (CampagneUneParProjet.isSelected()) {
0788: creationCampagne = Language.getInstance().getText(
0789: "Campagne_Par_Projet");
0790: } else if (CampagneImport.isSelected()) {
0791: creationCampagne = Language.getInstance().getText(
0792: "Importer_Campagnes");
0793: } else {
0794: creationCampagne = Language.getInstance().getText(
0795: "Pas_De_Campagne");
0796: }
0797: ok = true;
0798:
0799: if (xlsSauvTF.getText().equals("")) {
0800:
0801: JOptionPane.showMessageDialog(ImportXLSDialog.this ,
0802: Language.getInstance().getText(
0803: "Vous_devez_entrez_un_nom_de_fichier"),
0804: Language.getInstance().getText("Erreur_!"),
0805: JOptionPane.ERROR_MESSAGE);
0806: ok = false;
0807:
0808: } else {
0809:
0810: try {
0811: FromExcelToXml Transformation = new FromExcelToXml(
0812: saveFileName, selectionImportExigence,
0813: selectionImportTest, selectionImportParametre,
0814: selectionImportEnvironnement, creationCampagne,
0815: selectionExecutionCampagnes);
0816: xmlTempFile = Transformation.getXMLFileName();
0817: erreurImportFichier = Transformation
0818: .getErreurImportFichier();
0819: fichiersNonImportes = Transformation
0820: .getFichiersNonImportes();
0821: exigenceNonTrouvePourTest = Transformation
0822: .getExigenceNonTrouvePourTest();
0823: isErreurTraitementImport = Transformation
0824: .getIsErreurTraitementImport();
0825: System.out
0826: .println("Recuperation Retour Nom Fichier Temporaire XML : "
0827: + xmlTempFile);
0828: String xmlFile = xmlTempFile;
0829: if (xmlFile == null || xmlFile.equals("")) {
0830: JOptionPane
0831: .showMessageDialog(
0832: ImportXLSDialog.this ,
0833: Language
0834: .getInstance()
0835: .getText(
0836: "Problème_lors_de_l'import_des_données_du_document_XML"),
0837: Language.getInstance().getText(
0838: "Erreur_!"),
0839: JOptionPane.ERROR_MESSAGE);
0840: CampagneneRienFaire.setEnabled(true);
0841: CampagneUneParFamille.setEnabled(true);
0842: CampagneUneParExigence.setEnabled(true);
0843: CampagneUneParProjet.setEnabled(true);
0844: CampagneImport.setEnabled(true);
0845: suppr.setEnabled(true);
0846: keepOriginal.setEnabled(true);
0847: keepOriginalAndImport.setEnabled(true);
0848: keepOriginalAndUpdate.setEnabled(true);
0849: updateOriginal.setEnabled(true);
0850: eraseOriginalAndImport.setEnabled(true);
0851: xlsProgress.setIndeterminate(false);
0852: xlsSauvButton.setEnabled(true);
0853: xlsValider.setEnabled(true);
0854: xlsAnnuler.setEnabled(true);
0855: importTest.setEnabled(true);
0856: importExigence.setEnabled(true);
0857: importParametre.setEnabled(true);
0858: importEnvironnement.setEnabled(true);
0859: importExecutionCampagnes.setEnabled(true);
0860: xlsSauvTF.setEnabled(true);
0861:
0862: ok = false;
0863:
0864: if (erreurImportFichier == true) {
0865: File file = new File(xmlFile);
0866: file.delete();
0867: }
0868:
0869: //Sert à supprimer le répertoire attachements lors de l'import
0870: //File fileAttachements = new File(Transformation.getXmlDir() + fs + Language.getInstance().getText("Attachements"));
0871: //if (fileAttachements.exists()) {
0872: // deleteDirectory(fileAttachements);
0873: //}
0874:
0875: } else {
0876: try {
0877: String dirXml = xmlFile.substring(0, xmlFile
0878: .lastIndexOf(fs));
0879: if (xlsSauvTF.getText().equals("")) {
0880: JOptionPane
0881: .showMessageDialog(
0882: ImportXLSDialog.this ,
0883: Language
0884: .getInstance()
0885: .getText(
0886: "Vous_devez_entrez_un_nom_de_fichier_pour_le_document_généré"),
0887: Language
0888: .getInstance()
0889: .getText("Erreur_!"),
0890: JOptionPane.ERROR_MESSAGE);
0891: CampagneneRienFaire.setEnabled(true);
0892: CampagneUneParFamille.setEnabled(true);
0893: CampagneUneParExigence.setEnabled(true);
0894: CampagneUneParProjet.setEnabled(true);
0895: CampagneImport.setEnabled(true);
0896: suppr.setEnabled(true);
0897: keepOriginal.setEnabled(true);
0898: keepOriginalAndImport.setEnabled(true);
0899: keepOriginalAndUpdate.setEnabled(true);
0900: updateOriginal.setEnabled(true);
0901: eraseOriginalAndImport.setEnabled(true);
0902: xlsProgress.setIndeterminate(false);
0903: xlsSauvButton.setEnabled(true);
0904: xlsValider.setEnabled(true);
0905: xlsAnnuler.setEnabled(true);
0906: importTest.setEnabled(true);
0907: importExigence.setEnabled(true);
0908: importParametre.setEnabled(true);
0909: importEnvironnement.setEnabled(true);
0910: importExecutionCampagnes.setEnabled(true);
0911: xlsSauvTF.setEnabled(true);
0912:
0913: } else {
0914:
0915: File file = new File(xmlFile);
0916:
0917: if (isErreurTraitementImport == false) {
0918: try {
0919:
0920: SAXReader reader = new SAXReader();
0921: Document doc = reader
0922: .read(new FileInputStream(
0923: file));
0924: // Façon Salomé V3
0925:
0926: try {
0927: traitement = new ImportXML2(
0928: ImportXLSDialog.this ,
0929: doc,
0930: familySelectionList,
0931: suiteSelectionList,
0932: testSelectionList,
0933: null, pIhm);
0934:
0935: } catch (Exception e) {
0936: e.printStackTrace();
0937: xlsErrorMessage += Language
0938: .getInstance()
0939: .getText(
0940: "Problème_lors_de_l'import_des_données_du_document_XML");
0941: showErrorMessage();
0942: traitement.setAnnule(true);
0943: }
0944: traitement.setDirXml(dirXml);
0945: traitement.setInitSelection(false);
0946: traitement.setImportCampaign(true);
0947: traitement.importInProject();
0948:
0949: } catch (Exception ex) {
0950:
0951: xlsErreurTraitement = true;
0952: ex.printStackTrace();
0953: JOptionPane
0954: .showMessageDialog(
0955: ImportXLSDialog.this ,
0956: Language
0957: .getInstance()
0958: .getText(
0959: "Problème_lors_de_l'import_des_données_du_document_XML"),
0960: Language
0961: .getInstance()
0962: .getText(
0963: "Erreur_!"),
0964: JOptionPane.ERROR_MESSAGE);
0965: traitement.setAnnule(true);
0966: CampagneneRienFaire
0967: .setEnabled(true);
0968: CampagneUneParFamille
0969: .setEnabled(true);
0970: CampagneUneParExigence
0971: .setEnabled(true);
0972: CampagneUneParProjet
0973: .setEnabled(true);
0974: CampagneImport.setEnabled(true);
0975: xlsProgress.setIndeterminate(false);
0976: suppr.setEnabled(true);
0977: keepOriginal.setEnabled(true);
0978: keepOriginalAndImport
0979: .setEnabled(true);
0980: keepOriginalAndUpdate
0981: .setEnabled(true);
0982: updateOriginal.setEnabled(true);
0983: eraseOriginalAndImport
0984: .setEnabled(true);
0985: xlsSauvButton.setEnabled(true);
0986: xlsValider.setEnabled(true);
0987: xlsAnnuler.setEnabled(true);
0988: importTest.setEnabled(true);
0989: importExigence.setEnabled(true);
0990: importParametre.setEnabled(true);
0991: importEnvironnement
0992: .setEnabled(true);
0993: importExecutionCampagnes
0994: .setEnabled(true);
0995: xlsSauvTF.setEnabled(true);
0996:
0997: }
0998: }
0999: // Supprime fichier temporaire XML à la fin du programme
1000: file.delete();
1001:
1002: // supprime le repertoire temporaire des Pieces
1003: // jointes uploades :
1004: /* File fileAttachements = new File(Transformation.getXmlDir() + fs + Language.getInstance().getText("Attachements"));
1005: if (fileAttachements.exists()) {
1006: deleteDirectory(fileAttachements);
1007: }
1008: */
1009: if (isErreurTraitementImport == true) {
1010: xlsErreurTraitement = true;
1011: erreurImportFichier = false;
1012: ok = false;
1013: ImportXLSDialog.this .dispose();
1014: //suprime le fichier XML
1015: file = new File(xmlFile);
1016: if (file.exists()) {
1017: file.delete();
1018: }
1019: }
1020: if (!traitement.isAnnule()) {
1021:
1022: if (xlsErreurTraitement == true) {
1023:
1024: CampagneneRienFaire
1025: .setEnabled(true);
1026: CampagneUneParFamille
1027: .setEnabled(true);
1028: CampagneUneParExigence
1029: .setEnabled(true);
1030: CampagneUneParProjet
1031: .setEnabled(true);
1032: CampagneImport.setEnabled(true);
1033: xlsProgress.setIndeterminate(false);
1034: suppr.setEnabled(true);
1035: keepOriginal.setEnabled(true);
1036: keepOriginalAndImport
1037: .setEnabled(true);
1038: keepOriginalAndUpdate
1039: .setEnabled(true);
1040: updateOriginal.setEnabled(true);
1041: eraseOriginalAndImport
1042: .setEnabled(true);
1043: xlsSauvButton.setEnabled(true);
1044: xlsValider.setEnabled(true);
1045: xlsAnnuler.setEnabled(true);
1046: importTest.setEnabled(true);
1047: importExigence.setEnabled(true);
1048: importParametre.setEnabled(true);
1049: importEnvironnement
1050: .setEnabled(true);
1051: importExecutionCampagnes
1052: .setEnabled(true);
1053: xlsSauvTF.setEnabled(true);
1054:
1055: JOptionPane
1056: .showMessageDialog(
1057: ImportXLSDialog.this ,
1058: Language
1059: .getInstance()
1060: .getText(
1061: "Problème_lors_de_l'import_des_données_du_document_XML"),
1062: Language
1063: .getInstance()
1064: .getText(
1065: "Erreur_!"),
1066: JOptionPane.ERROR_MESSAGE);
1067: ok = false;
1068: ImportXLSDialog.this .dispose();
1069: }
1070: }
1071:
1072: }
1073: } catch (Exception ex) {
1074:
1075: Tools.ihmExceptionView(ex);
1076: ex.printStackTrace();
1077: }
1078: }
1079: //suprime le fichier XML
1080: File file = new File(xmlFile);
1081: if (file.exists()) {
1082: file.delete();
1083: }
1084: } catch (Exception ex) {
1085:
1086: ex.printStackTrace();
1087: }
1088: }
1089:
1090: if (erreurImportFichier == true) {
1091: JOptionPane
1092: .showMessageDialog(
1093: ImportXLSDialog.this ,
1094: Language
1095: .getInstance()
1096: .getText(
1097: "Problème_lors_de_l'import_des_données_du_document_XML")
1098: + "\n "
1099: + Language.getInstance().getText(
1100: "malformed_File")
1101: + "\n "
1102: + fichiersNonImportes, Language
1103: .getInstance().getText("Erreur_!"),
1104: JOptionPane.ERROR_MESSAGE);
1105: }
1106: if (exigenceNonTrouvePourTest.length() > 0
1107: && selectionImportExigence == true) {
1108: JOptionPane
1109: .showMessageDialog(
1110: ImportXLSDialog.this ,
1111: Language
1112: .getInstance()
1113: .getText(
1114: "Problème_lors_de_l'import_des_données_du_document_XML")
1115: + "\n "
1116: + Language.getInstance().getText(
1117: "requirements_dont_exist")
1118: + "\n " + exigenceNonTrouvePourTest,
1119: Language.getInstance().getText("Erreur_!"),
1120: JOptionPane.ERROR_MESSAGE);
1121: }
1122:
1123: if (ok && !xlsAnnule) {
1124: CampagneneRienFaire.setEnabled(true);
1125: CampagneUneParFamille.setEnabled(true);
1126: CampagneUneParExigence.setEnabled(true);
1127: CampagneUneParProjet.setEnabled(true);
1128: CampagneImport.setEnabled(true);
1129: xlsProgress.setIndeterminate(false);
1130: suppr.setEnabled(true);
1131: keepOriginal.setEnabled(true);
1132: keepOriginalAndImport.setEnabled(true);
1133: keepOriginalAndUpdate.setEnabled(true);
1134: updateOriginal.setEnabled(true);
1135: eraseOriginalAndImport.setEnabled(true);
1136: xlsSauvButton.setEnabled(true);
1137: xlsValider.setEnabled(true);
1138: xlsAnnuler.setEnabled(true);
1139: importTest.setEnabled(true);
1140: importExigence.setEnabled(true);
1141: importParametre.setEnabled(true);
1142: importEnvironnement.setEnabled(true);
1143: importExecutionCampagnes.setEnabled(true);
1144: xlsSauvTF.setEnabled(true);
1145:
1146: JOptionPane
1147: .showMessageDialog(
1148: ImportXLSDialog.this ,
1149: Language
1150: .getInstance()
1151: .getText(
1152: "L'import_des_exigences_s'est_terminé_avec_succès"),
1153: Language.getInstance().getText(
1154: "Information..."),
1155: JOptionPane.INFORMATION_MESSAGE);
1156: ImportXLSDialog.this .dispose();
1157: }
1158:
1159: }
1160:
1161: /**
1162: * Return true if there is an error during import
1163: *
1164: * @param erreur
1165: * boolean
1166: */
1167: public void setXlsErreurTraitement(boolean erreur) {
1168: ok = erreur;
1169: }
1170:
1171: /**
1172: * Delete a directory tree (files and folders)
1173: *
1174: * @param path
1175: * Directory tree to delete
1176: * @return true if there is no error during delete
1177: */
1178: static public boolean deleteDirectory(File path) {
1179: boolean resultat = true;
1180:
1181: if (path.exists()) {
1182: File[] files = path.listFiles();
1183: for (int i = 0; i < files.length; i++) {
1184: if (files[i].isDirectory()) {
1185: resultat &= deleteDirectory(files[i]);
1186: } else {
1187: resultat &= files[i].delete();
1188: }
1189: }
1190: }
1191: resultat &= path.delete();
1192: return (resultat);
1193: }
1194:
1195: /**
1196: * @return Returns the supprElement.
1197: */
1198: public boolean isSupprElement() {
1199: return suppr.isSelected();
1200: }
1201:
1202: /**
1203: * Show error meesage
1204: */
1205: public void showErrorMessage() {
1206: JOptionPane.showMessageDialog(ImportXLSDialog.this ,
1207: xlsErrorMessage, Language.getInstance().getText(
1208: "Erreur_!"), JOptionPane.ERROR_MESSAGE);
1209: ImportXLSDialog.this .dispose();
1210: }
1211:
1212: /**
1213: * Returns the suiteList.
1214: *
1215: * @return Returns the suiteList.
1216: */
1217: public ArrayList getSuiteSelectionList() {
1218: return suiteSelectionList;
1219: }
1220:
1221: /**
1222: * Set the suiteList.
1223: *
1224: * @param suiteSelectionList
1225: * Set the suiteList.
1226: */
1227: public void setSuiteSelectionList(ArrayList suiteSelectionList) {
1228: this .suiteSelectionList = suiteSelectionList;
1229: }
1230:
1231: /**
1232: * Returns the familyList.
1233: *
1234: * @return Returns the familyList.
1235: */
1236: public ArrayList getFamilySelectionList() {
1237: return familySelectionList;
1238: }
1239:
1240: /**
1241: * Set the familyList.
1242: *
1243: * @param familySelectionList
1244: * Set the familyList.
1245: */
1246: public void setFamilySelectionList(ArrayList familySelectionList) {
1247: this .familySelectionList = familySelectionList;
1248: }
1249:
1250: /**
1251: * Returns the testList.
1252: *
1253: * @return Returns the testList.
1254: */
1255: public ArrayList getTestSelectionList() {
1256: return testSelectionList;
1257: }
1258:
1259: /**
1260: * The testList to set.
1261: *
1262: * @param testSelectionList
1263: * The testList to set.
1264: */
1265: public void setTestSelectionList(ArrayList testSelectionList) {
1266: this .testSelectionList = testSelectionList;
1267: }
1268:
1269: /**
1270: * Returns the chosenRoot
1271: *
1272: * @return Returns the chosenRoot.
1273: */
1274: public DefaultMutableTreeNode getChosenRoot() {
1275: return chosenRoot;
1276: }
1277:
1278: /**
1279: * The chosenRoot to set.
1280: *
1281: * @param chosenRoot
1282: * The chosenRoot to set.
1283: */
1284: public void setChosenRoot(DefaultMutableTreeNode chosenRoot) {
1285: this .chosenRoot = chosenRoot;
1286: }
1287:
1288: /**
1289: * Returns the errorMessage.
1290: *
1291: * @return Returns the errorMessage.
1292: */
1293: public String getErrorMessage() {
1294: return xlsErrorMessage;
1295: }
1296:
1297: /**
1298: * The errorMessage to set.
1299: *
1300: * @param errorMessage
1301: * The errorMessage to set.
1302: */
1303: public void setErrorMessage(String errorMessage) {
1304: this .xlsErrorMessage = errorMessage;
1305: }
1306:
1307: public boolean isKeepOriginalOption() {
1308: return keepOriginal.isSelected();
1309: }
1310:
1311: public boolean isKeepOriginalAndImportOption() {
1312: return keepOriginalAndImport.isSelected();
1313: }
1314:
1315: public boolean isKeepOriginalAndUpdateOption() {
1316: return keepOriginalAndUpdate.isSelected();
1317: }
1318:
1319: public boolean isUpdateOriginalOption() {
1320: return updateOriginal.isSelected();
1321: }
1322:
1323: public boolean isEraseOriginalAndImport() {
1324: return eraseOriginalAndImport.isSelected();
1325: }
1326:
1327: }
|