Esempio n. 1
0
        private void menuAddFeature_Click(object sender, EventArgs e)
        {
            SetupFeature feature = new SetupFeature();

            currentProject.projectFeatures.Add(feature);
            SynchFeatures(true);
        }
Esempio n. 2
0
        private void addDirectoryMenu_Click(object sender, EventArgs e)
        {
            SetupFeature feature = null;

            try
            {
                feature = (SetupFeature)featuresTree.SelectedNode.Tag;
            }
            catch (NullReferenceException)
            {
                return;
            }

            // Open file-dialog
            FolderBrowserDialog dlg = new FolderBrowserDialog();

            dlg.Description  = "Select a directory to add";
            dlg.SelectedPath = LastSelectedFolder;
            if (dlg.ShowDialog() == DialogResult.OK)
            {
                LastSelectedFolder = dlg.SelectedPath;
                string file = dlg.SelectedPath;
                if ((File.GetAttributes(file) & FileAttributes.Directory) == FileAttributes.Directory)
                {
                    string my_file = currentProject.projectProperties.UseRelativePaths
                        ? Shell.GetRelativePath(file) : file;
                    feature.directories.Add(new SetupDirectory(my_file));
                }

                ReloadDirectories();
            }
        }
Esempio n. 3
0
        private void MenuAddShortcut_Click(object sender, EventArgs e)
        {
            if (featuresTree.SelectedNode != null)
            {
                SetupFeature  current  = (SetupFeature)featuresTree.SelectedNode.Tag;
                SetupShortcut shortcut = new SetupShortcut();
                shortcut.srcPath = "[APPLICATIONFOLDER]";
                if ((null != current.configurableDirectory) && ("" != current.configurableDirectory))
                {
                    shortcut.srcPath = "[" + current.configurableDirectory + "]";
                }
                shortcut.dstPath     = "[APPLICATIONFOLDER]\\New Shortcut";
                shortcut.description = "Some Description";

                current.shortcuts.Add(shortcut);
                ReloadShortcuts();

                // Set the new one as selected
                foreach (ListViewItem item in shortcutList.Items)
                {
                    if (item.Tag.Equals(shortcut))
                    {
                        item.Selected = true;
                        break;
                    }
                }
            }
        }
Esempio n. 4
0
        private void addFilesMenu_Click(object sender, EventArgs e)
        {
            SetupFeature feature = null;

            try
            {
                feature = (SetupFeature)featuresTree.SelectedNode.Tag;
            }
            catch (NullReferenceException)
            {
                return;
            }

            // Open file-dialog
            OpenFileDialog dlg = new OpenFileDialog();

            dlg.Multiselect      = true;
            dlg.RestoreDirectory = true;
            if (dlg.ShowDialog() == DialogResult.OK)
            {
                // Add the target-files

                string[] files = dlg.FileNames;
                foreach (string file in files)
                {
                    string my_file = currentProject.projectProperties.UseRelativePaths
                        ? Shell.GetRelativePath(file) : file;
                    SetupFile sf = feature.AddFile(my_file);
                }

                // Reload the file-list
                ReloadFileList();
            }
        }
Esempio n. 5
0
        private void fileList_DragDrop(object sender, DragEventArgs e)
        {
            // Find the selcted feature

            SetupFeature feature = null;

            try
            {
                feature = (SetupFeature)featuresTree.SelectedNode.Tag;
            }
            catch (NullReferenceException)
            {
                return;
            }

            string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
            foreach (string file in files)
            {
                string my_file = currentProject.projectProperties.UseRelativePaths
                    ? Shell.GetRelativePath(file) : file;
                SetupFile sf = feature.AddFile(my_file);
            }

            // Reload the file-list
            ReloadFileList();
        }
Esempio n. 6
0
 private void featureName_TextChanged(object sender, EventArgs e)
 {
     if (featuresTree.SelectedNode != null)
     {
         SetupFeature current = (SetupFeature)featuresTree.SelectedNode.Tag;
         featuresTree.SelectedNode.Text = featureName.Text;
     }
 }
Esempio n. 7
0
 private void menuAddChildFeature_Click(object sender, EventArgs e)
 {
     if (featuresTree.SelectedNode != null)
     {
         SetupFeature current = (SetupFeature)featuresTree.SelectedNode.Tag;
         SetupFeature feature = new SetupFeature();
         current.childFeatures.Add(feature);
     }
     SynchFeatures(true);
 }
Esempio n. 8
0
 private void MenuDeleteDirectory_Click(object sender, EventArgs e)
 {
     if ((null != featureDirectoryList.SelectedItems) && (featureDirectoryList.SelectedItems.Count == 1))
     {
         if (featuresTree.SelectedNode != null)
         {
             SetupFeature current = (SetupFeature)featuresTree.SelectedNode.Tag;
             current.directories.Remove((SetupDirectory)featureDirectoryList.SelectedItems[0].Tag);
             ReloadDirectories();
         }
     }
 }
Esempio n. 9
0
        private void MenuDeleteShortcut_Click(object sender, EventArgs e)
        {
            if (featuresTree.SelectedNode != null)
            {
                SetupFeature current = (SetupFeature)featuresTree.SelectedNode.Tag;

                foreach (ListViewItem item in shortcutList.SelectedItems)
                {
                    current.shortcuts.Remove((SetupShortcut)item.Tag);
                }
            }
            ReloadShortcuts();
        }
Esempio n. 10
0
        private void menuDeleteFeature_Click(object sender, EventArgs e)
        {
            if (featuresTree.SelectedNode != null)
            {
                SetupFeature current = (SetupFeature)featuresTree.SelectedNode.Tag;
                if (featuresTree.SelectedNode.Parent == null)
                {
                    currentProject.projectFeatures.Remove(current);
                }
                else
                {
                    SetupFeature parent = (SetupFeature)featuresTree.SelectedNode.Parent.Tag;
                    parent.childFeatures.Remove(current);
                }

                SynchFeatures(true);
            }
        }
Esempio n. 11
0
        private void featureDirectoryList_DragDrop(object sender, DragEventArgs e)
        {
            if (featuresTree.SelectedNode != null)
            {
                SetupFeature current = (SetupFeature)featuresTree.SelectedNode.Tag;
                string[]     files   = (string[])e.Data.GetData(DataFormats.FileDrop);
                foreach (string file in files)
                {
                    if ((File.GetAttributes(file) & FileAttributes.Directory) == FileAttributes.Directory)
                    {
                        string my_file = currentProject.projectProperties.UseRelativePaths
                    ? Shell.GetRelativePath(file) : file;
                        current.directories.Add(new SetupDirectory(my_file));
                    }
                }

                ReloadDirectories();
            }
        }
Esempio n. 12
0
        private void featuresTree_AfterSelect(object sender, TreeViewEventArgs e)
        {
            checkPartOfDefaultInstall.DataBindings.Clear();
            checkPartOfMinimalInstall.DataBindings.Clear();
            featureName.DataBindings.Clear();
            featureDescription.DataBindings.Clear();
            featureDefaultInstall.DataBindings.Clear();
            featurePathPropertyName.DataBindings.Clear();
            featurePathDefaultPath.DataBindings.Clear();
            featureId.DataBindings.Clear();
            shortcutProperties.SelectedObject    = null;
            directoryProperties.SelectedObject   = null;
            currentFileProperties.SelectedObject = null;
            featurePropertiesGrid.SelectedObject = null;

            if (e.Node != null)
            {
                SetupFeature feature = (SetupFeature)e.Node.Tag;

                checkPartOfDefaultInstall.DataBindings.Add("Checked", feature,
                                                           "enableInDefaultInstall");
                checkPartOfMinimalInstall.DataBindings.Add("Checked", feature,
                                                           "enableInMinimalInstall");
                featureName.DataBindings.Add("Text", feature,
                                             "featureName");
                featureDescription.DataBindings.Add("Text", feature,
                                                    "featureDescription");
                featureDefaultInstall.DataBindings.Add("SelectedIndex", feature,
                                                       "defaultInstallMode");
                featurePathPropertyName.DataBindings.Add("Text", feature,
                                                         "configurableDirectory");
                featurePathDefaultPath.DataBindings.Add("Text", feature,
                                                        "configurableDirectoryDefaultPath");
                featureId.DataBindings.Add("Text", feature, "featureId");
                featurePropertiesGrid.SelectedObject = feature;
            }

            ReloadFileList();
            ReloadDirectories();
            ReloadShortcuts();
        }
Esempio n. 13
0
        private void ReloadShortcuts()
        {
            shortcutList.Items.Clear();

            if (featuresTree.SelectedNode != null)
            {
                SetupFeature current = (SetupFeature)featuresTree.SelectedNode.Tag;

                if ((null != current) && (null != current.shortcuts))
                {
                    foreach (SetupShortcut shortcut in current.shortcuts)
                    {
                        ListViewItem i = new ListViewItem(Path.GetFileName(shortcut.dstPath));
                        i.SubItems.Add(Path.GetDirectoryName(shortcut.dstPath));
                        i.SubItems.Add(shortcut.srcPath);
                        i.Tag = shortcut;

                        shortcutList.Items.Add(i);
                    }
                }
            }
        }
Esempio n. 14
0
        private void ReloadFileList()
        {
            fileList.Items.Clear();

            SetupFeature feature = null;

            try
            {
                feature = (SetupFeature)featuresTree.SelectedNode.Tag;
            }
            catch (NullReferenceException)
            {
                return;
            }

            foreach (SetupComponent cmp in feature.components)
            {
                foreach (SetupFile file in cmp.componentFiles)
                {
                    ListViewItem item = new ListViewItem(file.dstName);
                    item.SubItems.Add(cmp.targetDirectory);
                    item.SubItems.Add(file.srcName);
                    item.SubItems.Add(file.srcDirectory);

                    FileBinding bind = new FileBinding();
                    bind.mComponent   = cmp;
                    bind.mFeature     = feature;
                    bind.mListViewItm = item;
                    item.Tag          = bind;

                    if (cmp.GetFirstFileId() == currentProject.mainTargetApp)
                    {
                        item.ImageIndex = 1; // Main target
                    }

                    fileList.Items.Add(item);
                }
            }
        }
Esempio n. 15
0
        private void ReloadDirectories()
        {
            featureDirectoryList.Items.Clear();
            directoryProperties.SelectedObject = null;

            if (featuresTree.SelectedNode != null)
            {
                SetupFeature current = (SetupFeature)featuresTree.SelectedNode.Tag;

                foreach (SetupDirectory dir in current.directories)
                {
                    ListViewItem item = new ListViewItem(dir.dstPath);
                    item.SubItems.Add(dir.srcPath);
                    item.Tag = dir;

                    featureDirectoryList.Items.Add(item);
                }

                if (featureDirectoryList.Items.Count > 0)
                {
                    featureDirectoryList.Items[0].Selected = true;
                }
            }
        }
Esempio n. 16
0
 private void menuAddChildFeature_Click(object sender, EventArgs e)
 {
     if (featuresTree.SelectedNode != null)
     {
         SetupFeature current = (SetupFeature)featuresTree.SelectedNode.Tag;
         SetupFeature feature = new SetupFeature();
         current.childFeatures.Add(feature);
     }
     SynchFeatures(true);
 }
Esempio n. 17
0
        private XmlElement GenerateComponent(SetupComponent component, SetupFeature feature, XmlElement feature_node)
        {
            // Make the reference from Feature
            XmlElement component_ref = doc.CreateElement("ComponentRef");
            component_ref.SetAttribute("Id", component.componentId);
            feature_node.AppendChild(component_ref);

            // Make the actual component and file
            XmlElement component_node = doc.CreateElement("Component");
            component_node.SetAttribute("Id", component.componentId);
            component_node.SetAttribute("Guid", component.componentGuid);

            if (component.addToCreateFolder)
            {
                XmlElement node = doc.CreateElement("CreateFolder");
                component_node.AppendChild(node);
            }

            // Link the component to the appropriate directory
            string target_dir_name = component.targetDirectory; // Not accessible from the UI. We use the file.dstPath in stead.

            // Now, lets see if the file overrides the default target. We only have one file
            // for each component (unless the older i sscanned, in wich case the dstPath in the
            // file is guaranteed to be empty
            if ((component.componentFiles.Count == 1)
                && ("" != component.componentFiles[0].dstPath))
            {
                target_dir_name = component.componentFiles[0].dstPath;
            }

            if ((null == target_dir_name) || ("" == target_dir_name))
            {
                target_dir_name = GetDefaultDir(feature);
                if ((null == target_dir_name) || ("" == target_dir_name))
                    target_dir_name = "[APPLICATIONFOLDER]";
                else
                    target_dir_name = "[" + target_dir_name + "]";

            }

            TargetDir target_dir = GetDirectoryNode(target_dir_name, null);
            target_dir.mXmlNode.AppendChild(component_node);

            // Path
            if ((null != component.pathEntry) && ("" != component.pathEntry))
            {
                XmlElement path_node = doc.CreateElement("Environment");
                path_node.SetAttribute("Id", GetUniqueId());
                path_node.SetAttribute("Name", "PATH");
                path_node.SetAttribute("Action", "set");
                path_node.SetAttribute("System", "yes");
                path_node.SetAttribute("Part", "last");
                path_node.SetAttribute("Value", component.pathEntry);
                component_node.AppendChild(path_node);
            }

            foreach (SetupFile file in component.componentFiles)
            {

                XmlElement file_node = doc.CreateElement("File");
                file_node.SetAttribute("Id", file.fileId);
                string src_path = Path.Combine(file.srcDirectory, file.srcName);
                file_node.SetAttribute("Source", src_path);
                if (!isMergeModle)
                    file_node.SetAttribute("DiskId", GetMedia(src_path).ToString());

                SetNameAttribute(file_node, file.dstName);

                if (file.ExecuteOnInstall)
                {
                    AddExecuteOnInstall(file);
                }

                /* TODO: Create a dedicated component for user-shortcuts (for each file)
                 * to avoid the "ICE57: Component 'IDC5A7B8F2554B02E5FC9D5ED7E684B285'
                 * has both per-user and per-machine data with a per-machine KeyPath."
                 * warning.
                 */

                //if (file.shortcutInProgramFilesMenu)
                //    file_node.AppendChild(AddShortcut(file, my_program_menu, "pf"));

                //if (file.shortcutInQuickLaunch)
                //    file_node.AppendChild(AddShortcut(file, quicklaunch, "ql"));

                //if (file.shortcutOnDesktop)
                //    file_node.AppendChild(AddShortcut(file, desktop, "dt"));

                if (file.shortcutInProgramFilesMenu)
                    AddShortcut(file, feature_node, my_program_menu, target_dir.mXmlNode);

                if (file.shortcutInQuickLaunch)
                    AddShortcut(file, feature_node, quicklaunch, target_dir.mXmlNode);

                if (file.shortcutOnDesktop)
                    AddShortcut(file, feature_node, desktop, target_dir.mXmlNode);

                if (file.shortcutInStartupFolder)
                    AddShortcut(file, feature_node, my_start_menu, target_dir.mXmlNode);

                if (file.isTrueTypeFont)
                {
                    file_node.SetAttribute("TrueType", "yes");
                    //if ((file.dstPath == null) || (file.dstPath == ""))
                }

                if (file.isComModule)
                {
                    XmlElement typelib = doc.CreateElement("TypeLib");
                    typelib.SetAttribute("Id", file.typelibGuid);
                    typelib.SetAttribute("Language", "0");
                    typelib.SetAttribute("Advertise", "yes"); // Just to avoid manual version mess
                    file_node.AppendChild(typelib);
                    if ((file.typelibGuid == null) || (file.typelibGuid == ""))
                    {
                        throw new ApplicationException(
                            "The COM/Typelib file \"" + file.srcName + "\" is missing a GUID. This must be specifield.");
                    }
                }

                if (file.service.isService)
                {
                    XmlElement svc = doc.CreateElement("ServiceInstall");
                    component_node.AppendChild(svc);

                    svc.SetAttribute("Id", file.service.id);
                    if ("" != file.service.userAccount)
                        svc.SetAttribute("Account", file.service.userAccount);
                    if ("" != file.service.userPassword)
                        svc.SetAttribute("Password", file.service.userPassword);
                    if ("" != file.service.cmdLineArguments)
                        svc.SetAttribute("Arguments", file.service.cmdLineArguments);
                    if ("" != file.service.description)
                        svc.SetAttribute("Description", file.service.description);
                    svc.SetAttribute("ErrorControl", file.service.errorControl.ToString());
                    svc.SetAttribute("Interactive", file.service.interactive ? "yes" : "no");
                    if ("" != file.service.loadOrderGroup)
                        svc.SetAttribute("LoadOrderGroup", file.service.loadOrderGroup);
                    svc.SetAttribute("Name", file.service.serviceName);
                    svc.SetAttribute("Start", file.service.startMode.ToString());
                    svc.SetAttribute("Type", "ownProcess");
                    svc.SetAttribute("Vital", file.service.vital ? "yes" : "no");

                    XmlElement svc_ctl = doc.CreateElement("ServiceControl");
                    component_node.AppendChild(svc_ctl);

                    svc_ctl.SetAttribute("Id", file.service.id);
                    svc_ctl.SetAttribute("Name", file.service.serviceName);
                    svc_ctl.SetAttribute("Remove", file.service.Remove.ToString());
                    if (file.service.StartWhenInstalled)
                        svc_ctl.SetAttribute("Start", "install");
                }

                foreach (FileExtension ext in file.fileExtensions)
                {
                    XmlElement prog_id_node = doc.CreateElement("ProgId");
                    prog_id_node.SetAttribute("Id", ext.Id);
                    prog_id_node.SetAttribute("Description", ext.Description);
                    prog_id_node.SetAttribute("Icon", file.fileId);
                    prog_id_node.SetAttribute("IconIndex", ext.IconIndex.ToString());
                    component_node.AppendChild(prog_id_node);

                    XmlElement ext_node = doc.CreateElement("Extension");
                    ext_node.SetAttribute("Id", ext.Extension);
                    ext_node.SetAttribute("ContentType", ext.MimeType);
                    prog_id_node.AppendChild(ext_node);

                    XmlElement verb_node = doc.CreateElement("Verb");
                    verb_node.SetAttribute("Id", "Open");
                    verb_node.SetAttribute("Command", "Open");
                    verb_node.SetAttribute("TargetFile", file.fileId);
                    verb_node.SetAttribute("Argument", "\"%1\""); // BUG 1944386 FIXED

                    ext_node.AppendChild(verb_node);
                }

                component_node.AppendChild(file_node);
            }

            return component_node;
        }
Esempio n. 18
0
        private void GenerateFeature(SetupFeature feature, XmlElement parent)
        {
            if (feature.excludeFromBuild)
                return;

            XmlElement node = doc.CreateElement("Feature");

            if (null == parent)
            {
                // Root
                if (!isMergeModle)
                    product.AppendChild(node);
                features_root = node;
            }
            else
            {
                parent.AppendChild(node);
            }

            node.SetAttribute("Id", feature.featureId);
            node.SetAttribute("Title", feature.featureName);
            node.SetAttribute("Level", feature.installLevel.ToString());
            node.SetAttribute("Description", feature.featureDescription);
            string install_mode = null;
            switch ((SetupFeature.InstallModeE)feature.defaultInstallMode)
            {
                case SetupFeature.InstallModeE.INSTALL_LOCALLY:
                    install_mode = "local";
                    break;
                case SetupFeature.InstallModeE.RUN_FROM_SOURCE:
                    install_mode = "source";
                    break;
                case SetupFeature.InstallModeE.SAME_AS_PARENT_FEATURE:
                    install_mode = "followParent";
                    break;
            }

            // Handle configurable directories for the feature
            // Add the dir for this node.
            if ((null != feature.configurableDirectory)
                && ("" != feature.configurableDirectory)
                && ("APPLICATIONFOLDER" != feature.configurableDirectory))
            {
                GetDirectoryNode(feature.configurableDirectoryDefaultPath,
                    feature.configurableDirectory);
            }

            // Generate the components (and files) for the directories
            List<SetupComponent> dir_components = new List<SetupComponent>();
            foreach (SetupDirectory dir in feature.directories)
            {
                // Make the Directory-node if it don't exist
                GetDirectoryNode(dir.dstPath, dir.dirId);

                // Make components under the dir
                dir.MakeComponents(dir_components, dir.srcPath, dir.dstPath);

                if (dir.addToPath)
                {
                    dir.pathComponent.pathEntry = "[" + GetDirectoryNode(dir.dstPath, null).mXmlNode.GetAttribute("Id") + "]";
                    dir_components.Add(dir.pathComponent);
                }
                else
                    dir.pathComponent.pathEntry = null;

                // Visual Studio Integration
                if (dir.ideMicrosoftVisualStudio2003)
                    MakeVcIntegration("Microsoft Visual Studio 2003", dir, feature, node);
                if (dir.ideMicrosoftVisualStudio2005)
                    MakeVcIntegration("Microsoft Visual Studio 2005", dir, feature, node);
            }

            if (install_mode != null)
                node.SetAttribute("InstallDefault", install_mode);

            if ((feature.configurableDirectory != null) && ("" != feature.configurableDirectory))
                node.SetAttribute("ConfigurableDirectory", feature.configurableDirectory);

            foreach (SetupComponent component in feature.components)
                GenerateComponent(component, feature, node);

            foreach (SetupComponent component in dir_components)
                GenerateComponent(component, feature, node);

            {
                //XmlElement my_component = GenerateComponent(feature.component, node);

                // Add shortcuts
                foreach (SetupShortcut shortcut in feature.shortcuts)
                {
                    AddShortcut(shortcut, feature, null, null);

                    if (shortcut.showOnDesktop)
                        AddShortcut(shortcut, feature, desktop.GetAttribute("Id"), "dt");
                    if (shortcut.showOnProgramMenu)
                        AddShortcut(shortcut, feature, my_program_menu.GetAttribute("Id"), "pf");
                    if (shortcut.showOnQuickLaunchBar)
                        AddShortcut(shortcut, feature, quicklaunch.GetAttribute("Id"), "ql");
                }
            }

            GenerateFeature(feature.childFeatures, node);
            return;
        }
Esempio n. 19
0
        private string GetDefaultDir(SetupFeature feature)
        {
            if ((null != feature.configurableDirectory) && ("" != feature.configurableDirectory))
                return feature.configurableDirectory;

            // try parent
            SetupFeature parent = GetParentFeature(feature, null, projectFeatures);
            if (null != parent)
                return GetDefaultDir(parent);

            return null; // No luck
        }
Esempio n. 20
0
        // Find the parent node of feature.
        // Since we have no "parent" property, we have to start a recursive scan from
        // the projects feature-list
        private SetupFeature GetParentFeature(SetupFeature feature, SetupFeature parent, List<SetupFeature> parentList)
        {
            // Scan down
            foreach (SetupFeature child in parentList)
            {
                if (child.featureId == feature.featureId)
                    return parent;

                SetupFeature probe = GetParentFeature(feature, child, child.childFeatures);
                if (null != probe)
                    return probe;
            }

            return null;
        }
Esempio n. 21
0
 private void menuAddFeature_Click(object sender, EventArgs e)
 {
     SetupFeature feature = new SetupFeature();
     currentProject.projectFeatures.Add(feature);
     SynchFeatures(true);
 }
Esempio n. 22
0
        private void MakeVcIntegration(string ideName, SetupDirectory dir, SetupFeature feature, XmlElement featureNode)
        {
            string ide_version = "";
            string feature_option = "";
            switch (ideName)
            {
                case "Microsoft Visual Studio 2003":
                    ide_version = "7.1";
                    feature_option = projectProperties.VS2003Integration;
                    break;
                case "Microsoft Visual Studio 2005":
                    ide_version = "8.0";
                    feature_option = projectProperties.VS2005Integration;
                    break;
            }

            // Must modify C:\Documents and Settings\jgaa\Local Settings\Application Data\Microsoft\VisualStudio\7.1\VCComponents.dat
            #if DEBUG
            XmlElement bin = GetBinDll(Path.Combine(Path.Combine(Shell.warSetupResPath, "CustomActions"), "WarSetupPluginD.dll"));
            #else
            XmlElement bin = GetBinDll(Path.Combine(Path.Combine(Shell.warSetupResPath, "CustomActions"), "WarSetupPlugin.dll"));
            #endif

            string ini_path = @"[LocalAppDataFolder]Microsoft\VisualStudio\" + ide_version + @"\VCComponents.dat";

            SetPropertyValue("VCCOMPONENTSFILEPATH", ini_path);

            string prop_key = MakeVcFileCond(ini_path, null);

            SetPropertyValue("VC_VERSION", ideName);

            string feature_cond_install = "";
            if ((null != feature_option) && ("" != feature_option))
            {
                // make a rule that only activates the integration i fa feature with Id feature_option is enabled
                feature_cond_install = " AND (&" + feature_option + "=3) ";
                //feature_cond_uninstall = " OR (&feature_option=2) ";
            }

            // TODO: Add CustomAction to abort installation if the feature is enabled and
            // the VCComponents.dat file is missing.
            {
                XmlElement abort = doc.CreateElement("CustomAction");
                abort.SetAttribute("Id", GetUniqueId().ToUpper());
                abort.SetAttribute("Error", "The required file " + ini_path
                    + " is missing. "
                    + ideName + " must be installed, and you must have entered the "
                    + "Tools/Options menu and selected Projects/C++ Directories "
                    + "at least once (That's when this file is created).");
                product.AppendChild(abort);

                AddExecuteSequence(abort.GetAttribute("Id"), "(NOT " + prop_key
                    + ") AND (&" + featureNode.GetAttribute("Id") + "=3)"
                    + feature_cond_install);
            }

            if (dir.ideExecutables)
                MakeVcIntegrationPath(bin, "VCCOMPONENTSFILEEXECDIR", dir.dstPath, featureNode, prop_key, feature_option);

            if (dir.ideHeaderFiles)
                MakeVcIntegrationPath(bin, "VCCOMPONENTSFILEHEADERDIR", dir.dstPath, featureNode, prop_key, feature_option);

            if (dir.ideLibrary)
                MakeVcIntegrationPath(bin, "VCCOMPONENTSFILELIBDIR", dir.dstPath, featureNode, prop_key, feature_option);
        }
Esempio n. 23
0
        public void InitializeDefaults()
        {
            SetupFeature features = new WarSetup.SetupFeature();
            features.featureName = "";
            features.featureDescription = "The complete package";
            features.configurableDirectory = "APPLICATIONFOLDER";
            features.configurableDirectoryDefaultPath = "[ProjectName]";
            features.defaultInstallMode = (int)SetupFeature.InstallModeE.INSTALL_LOCALLY;

            {
                SetupFeature program_feature = new SetupFeature();
                program_feature.featureName = "Program";
                program_feature.featureDescription = "The Main Executable";
                program_feature.featureId = "PROGRAM";
                program_feature.defaultInstallMode = (int)SetupFeature.InstallModeE.INSTALL_LOCALLY;
                features.childFeatures.Add(program_feature);
            }

            {
                SetupFeature program_feature = new SetupFeature();
                program_feature.featureName = "Documentation";
                program_feature.featureDescription = "The documentation";
                program_feature.featureId = "DOCUMENTATION";
                program_feature.defaultInstallMode = (int)SetupFeature.InstallModeE.INSTALL_LOCALLY;
                features.childFeatures.Add(program_feature);
            }

            _projectFeatures.Add(features);
            projectProperties.AddAllUiCulture();
        }
Esempio n. 24
0
        private XmlElement AddShortcut(SetupShortcut shortcut, SetupFeature feature, string directoryId, string shortcutType)
        {
            XmlElement sc_node = doc.CreateElement("Shortcut");

            if (null == shortcutType)
            {
                sc_node.SetAttribute("Id", shortcut.shortcutId);
            }
            else
            {
                sc_node.SetAttribute("Id", shortcutType + "_" + shortcut.shortcutId);
            }

            if ((null != shortcut.commandArguments) && ("" != shortcut.commandArguments))
                sc_node.SetAttribute("Arguments", shortcut.commandArguments);

            sc_node.SetAttribute("Description", shortcut.description);

            if (null == directoryId)
            {
                sc_node.SetAttribute("Directory", GetDirectoryNode(
                    Path.GetDirectoryName(shortcut.dstPath), null).mXmlNode.GetAttribute("Id"));
            }
            else
            {
                sc_node.SetAttribute("Directory", directoryId);
            }

            sc_node.SetAttribute("Name", Path.GetFileName(shortcut.dstPath));

            if ((null != shortcut.workingDir) && ("" != shortcut.workingDir))
            {
                TargetDir dir = GetDirectoryNode(shortcut.workingDir, null);
                string id = dir.mXmlNode.GetAttribute("Id");
                sc_node.SetAttribute("WorkingDirectory", id);
            }

            XmlElement target_dir = GetDirectoryNode(Path.GetDirectoryName(shortcut.srcPath), null).mXmlNode;
            XmlElement target_node = null;
            string target_name = Path.GetFileName(shortcut.srcPath);

            // Scan the target-dir for a directory with the target-name
            foreach (XmlNode xml_node in target_dir.ChildNodes)
            {
                if ((xml_node.NodeType == XmlNodeType.Element)
                    && (xml_node.Name == "Directory"))
                {
                    XmlElement subdir = (XmlElement)xml_node;
                    string name = subdir.GetAttribute("Name");
                    if (name == target_name)
                    {
                        target_node = subdir;
                        break;
                    }
                }
            }

            // Scan the dir for a file with the target_name
            if (null == target_node)
            {
                foreach (XmlNode xml_node in target_dir.GetElementsByTagName("File"))
                {
                    XmlElement file = (XmlElement)xml_node;
                    string name = file.GetAttribute("Name");
                    if (name == target_name)
                    {
                        target_node = file;
                        break;
                    }
                }
            }

            if (null == target_node)
            {
                throw new ApplicationException(
                    "The shortcut \"" + shortcut.dstPath + "\" in feature \"" +
                    feature.featureName + "\" does not resolve.\r\n" +
                    "I cannot find any file or directory on the target system " +
                    "with the path \"" + shortcut.srcPath + "\".");

            }

            //sc_node.SetAttribute("Target", "[" + target_node.GetAttribute("Id") + "]");
            target_node.AppendChild(sc_node);

            return sc_node;
        }