示例#1
0
        public void InitView(P4ScmProvider _scm, IList <string> files, IList <object> fields)
        {
            listItemMap = new Dictionary <string, P4ObjectTreeListViewItem>();

            IList <P4.FileSpec> fs = P4.FileSpec.LocalSpecList(files.ToArray());

            Files  = _scm.GetFileMetaData(fs, null);
            Fields = fields;

            foreach (P4.FileMetaData file in Files)
            {
                P4FileTreeListViewItem it = new P4FileTreeListViewItem(null, file, (IList <object>)Fields);
                listItemMap.Add(file.DepotPath.Path, it);
                this.Items.Add(it);
            }
        }
示例#2
0
        public P4ChangeTreeListViewItem(TreeListViewItem parentItem, P4.Changelist changeData,
                                        P4ScmProvider scm, IList <object> fields)
            : base()
        {
            ParentItem = parentItem;
            Fields     = fields;
            NodeType   = nodeType.Pending;           // default
            Scm        = scm;
            Tag        = changeData;

            Ours = (changeData.ClientId == Scm.Connection.Workspace);

            if (Ours)
            {
                P4.Options opts = new P4.Options();

                if (changeData.Id > 0)
                {
                    opts["-e"] = changeData.Id.ToString();
                }
                else
                {
                    opts["-e"] = "default";
                    NodeType.Set(nodeType.Default);
                }
                opts["-Ru"] = null;
                opts["-m"]  = "1";
                P4.FileSpec        fs  = new P4.FileSpec(new P4.ClientPath(@"//" + Scm.Connection.Workspace + @"/..."), null);
                List <P4.FileSpec> lfs = new List <P4.FileSpec>();
                lfs.Add(fs);
                IList <P4.FileMetaData> unresolved = Scm.GetFileMetaData(lfs, opts);

                if ((unresolved != null) && (unresolved.Count > 0))
                {
                    NeedsResolve = true;
                }
            }

            _changeData = changeData;             // don't call InitSubitems() or SelectImagesFromMetaData() yet

            if (changeData.Id > 0)
            {
                _reviewData = Scm.Connection.Swarm.IsChangelistAttachedToReview(changeData.Id);
            }
            InitSubitems();
            SelectImagesFromMetaData();
        }
示例#3
0
        public static void ChangeFileType(P4ScmProvider scm, IList <string> paths)
        {
            FileAttributesDlg dlg = new FileAttributesDlg(scm);

            int changelistId = 0;

            IList <string> CheckedinFiles  = new List <string>();
            IList <string> CheckedoutFiles = new List <string>();

            IList <P4.FileMetaData> fmd = scm.GetFileMetaData(paths, null);

            P4.FileType ft = null;
            if (fmd != null)
            {
                foreach (P4.FileMetaData md in fmd)
                {
                    if (ft == null)
                    {
                        ft = md.Type;
                        if (md.Change > 0)
                        {
                            changelistId = md.Change;
                        }
                    }
                    else
                    {
                        // only keep the base type if all the same
                        if (ft.BaseType != md.Type.BaseType)
                        {
                            ft.BaseType = P4.BaseFileType.Unspecified;
                        }
                        // only keep fags that are the same
                        ft.Modifiers &= md.Type.Modifiers;
                        if (changelistId != md.Change)
                        {
                            changelistId = 0;
                        }
                    }
                    if (md.Action == P4.FileAction.None)
                    {
                        CheckedinFiles.Add(md.LocalPath.Path);
                    }
                    else
                    {
                        CheckedoutFiles.Add(md.LocalPath.Path);
                    }
                }
            }

            dlg.FileType           = ft;
            dlg.TargetChangelistId = changelistId;

            if (dlg.ShowDialog() == DialogResult.Cancel)
            {
                return;
            }
            int targetChangelist = dlg.TargetChangelistId;

            P4.Options options = null;

            if (targetChangelist < 0)
            {
                // if selected, create a new numbered changelist with the files.

                P4.Changelist change = scm.Connection.Repository.NewChangelist();
                change.Description = "<P4VS Change FileType>";
                change.ClientId    = scm.Connection.Repository.Connection.Client.Name;
                change.OwnerName   = scm.Connection.Repository.Connection.UserName;
                change.Files       = null;           // new List<P4.FileMetaData>();

                P4.Changelist newChange = scm.Connection.Repository.CreateChangelist(change);

                targetChangelist = newChange.Id;
            }

            if (CheckedoutFiles.Count > 0)
            {
                options = new P4.ReopenCmdOptions(targetChangelist, dlg.FileType);
                if ((options.ContainsKey("-t")) && (string.IsNullOrEmpty(options["-t"]) == false))
                {
                    scm.ReopenFiles(P4.FileSpec.LocalSpecList(CheckedoutFiles), options);
                }
            }

            if (CheckedinFiles.Count > 0)
            {
                options = new P4.EditCmdOptions(P4.EditFilesCmdFlags.None, targetChangelist, dlg.FileType);

                if ((options.ContainsKey("-t")) && (string.IsNullOrEmpty(options["-t"]) == false))
                {
                    scm.EditFiles(P4.FileSpec.LocalSpecList(CheckedinFiles), options);
                }
            }
            scm.BroadcastChangelistUpdate(null, new P4ScmProvider.ChangelistUpdateArgs(targetChangelist,
                                                                                       P4ScmProvider.ChangelistUpdateArgs.UpdateType.Edit));
        }
示例#4
0
        /// <summary>
        /// Expand the directory by filling in the list of child directories
        /// and file within the directory.
        /// </summary>
        /// <returns>false if an error prevented completion</returns>
        public bool Expand(bool filtered)
        {
            if (String.IsNullOrEmpty(depotPath))
            {
                return(false);
            }

            if (_scm.ServerVersion >= Versions.V12_1)
            {
                if (!String.IsNullOrEmpty(depotPath))
                {
                    IList <string>       subdirs  = new List <string>();
                    IList <FileMetaData> fileList = new List <FileMetaData>();

                    Options options = new Options();
                    options["-Ol"] = null;
                    options["-D"]  = null;
                    options["-F"]  = "^headAction=delete & ^headAction=move/delete";
                    options["-T"]  = "depotFile, dir";

                    if (filtered)
                    {
                        options         = new Options();
                        options["-Ol"]  = null;
                        options["-Dlc"] = null;
                        options["-Rc"]  = null;
                        options["-F"]   = "^headAction=delete & ^headAction=move/delete";
                        options["-T"]   = "depotFile, dir";
                    }

                    IList <FileMetaData> fmd = _scm.GetFileMetaData(options, DepotPath + "/*");

                    foreach (FileMetaData f in fmd)
                    {
                        if (f.DepotPath != null)
                        {
                            fileList.Add(f);
                        }
                        if (f.Directory != null)
                        {
                            subdirs.Add(f.Directory);
                        }
                    }

                    if ((subdirs != null) && (subdirs.Count > 0))
                    {
                        subdirectories = P4DirectoryMap.FromDirsOutput(_scm, Workspace, this, subdirs);
                        foreach (P4Directory dir in subdirectories.Values)
                        {
                            dir.InDepot = true;
                        }
                    }

                    if (fileList != null)
                    {
                        files = P4FileMap.FromFstatOutput(fileList);

                        // if the directory contains files from the depot, we can use
                        // the local path of one of those files to determine the local
                        // path for this directory
                        if ((String.IsNullOrEmpty(localPath)) && (files != null) && (files.Count > 0))
                        {
                            foreach (FileMetaData f in files.Values)
                            {
                                if ((f.LocalPath != null) && !String.IsNullOrEmpty(f.LocalPath.Path))
                                {
                                    localPath = f.LocalPath.GetDirectoryName();
                                    break;
                                }
                            }
                        }
                    }
                }
            }

            else
            {
                // old tree builder using dirs and fstat
                //*****************************************************************************************
                // if we have the depot path, get a list of the subdirectories from the depot
                if (!String.IsNullOrEmpty(depotPath))
                {
                    IList <string> subdirs = _scm.GetDepotDirs(null, String.Format("{0}/*", depotPath));
                    if ((subdirs != null) && (subdirs.Count > 0))
                    {
                        subdirectories = P4DirectoryMap.FromDirsOutput(_scm, Workspace, this, subdirs);
                        foreach (P4Directory dir in subdirectories.Values)
                        {
                            dir.InDepot = true;
                        }
                    }

                    IList <FileMetaData> fileList = _scm.GetFileMetaData(null, String.Format("{0}/*", depotPath));
                    // get a list of the files in the directory

                    if (fileList != null)
                    {
                        files = P4FileMap.FromFstatOutput(fileList);

                        // if the directory contains files from the depot, we can use
                        // the local path of one of those files to determine the local
                        // path for this directory
                        if ((String.IsNullOrEmpty(localPath)) && (files != null) && (files.Count > 0))
                        {
                            foreach (FileMetaData f in files.Values)
                            {
                                if ((f.LocalPath != null) && !String.IsNullOrEmpty(f.LocalPath.Path))
                                {
                                    localPath = f.LocalPath.GetDirectoryName();
                                    break;
                                }
                            }
                        }
                    }
                }
                //*****************************************************************************************
            }



            // if we have a workspace and a local path, match the files and
            // subdirectories in the depot with the files in the file system
            if ((!String.IsNullOrEmpty(localPath)) && (Workspace != null))
            {
                DirectoryInfo[] directoryList = null;
                FileInfo[]      fileList      = null;
                try
                {
                    DirectoryInfo di = new DirectoryInfo(localPath);

                    directoryList = di.GetDirectories();
                    fileList      = di.GetFiles();
                }
                catch
                {
                    //LogFile.LogException( "Initializing Directory from Workspace", ex );
                }

                // get the subdirectories listed in the file and match them up
                // with the one in the list from the depot
                if ((directoryList != null) && (directoryList.Length > 0))
                {
                    foreach (DirectoryInfo di in directoryList)
                    {
                        string itemName = di.Name;
                        if (subdirectories.ContainsKey(itemName))
                        {
                            subdirectories[itemName].InWorkspace = true;
                        }
                        else
                        {
                            P4Directory subDir = new P4Directory(_scm, Workspace, itemName, null, di.FullName, parentDirectory);
                            subDir.InDepot           = false;
                            subDir.InWorkspace       = true;
                            subdirectories[itemName] = subDir;
                        }
                    }
                }

                // get the files listed in the subdirectory and match them up
                // with the one in the list from the depot
                if ((fileList != null) && (fileList.Length > 0))
                {
                    foreach (FileInfo fi in fileList)
                    {
                        string itemName = fi.Name;
                        if (files != null && files.ContainsKey(itemName) == false)
                        {
                            FileMetaData file = new FileMetaData();
                            file.LocalPath  = new LocalPath(fi.FullName);
                            file.DepotPath  = null;
                            file.FileSize   = fi.Length;
                            files[itemName] = file;
                        }
                    }
                }
            }
            return(true);
        }
示例#5
0
        //private P4.Label _labelToAdd = null;

        public static List <P4.FileSpec> Show(IList <string> paths, string specifier, string value, P4ScmProvider scm)
        {
            List <P4.FileSpec> files = new List <P4.FileSpec>();

            DiffDlg dlg = null;

            try
            {
                dlg = new DiffDlg(paths, specifier, value, scm);
            }
            catch
            {
                return(null);
            }
            if (dlg.ShowDialog() != DialogResult.Cancel)
            {
                if (dlg.DialogResult == DialogResult.OK)
                {
                    // get the strings to diff
                    string path1 = dlg.path1TB.Text;
                    string path2 = dlg.path2TB.Text;

                    // create the 2 filespecs
                    P4.FileSpec spec1 = new P4.FileSpec();
                    P4.FileSpec spec2 = new P4.FileSpec();
                    if (path1.StartsWith("//"))
                    {
                        spec1.DepotPath = new P4.DepotPath(path1);
                    }
                    else
                    {
                        spec1.LocalPath = new P4.LocalPath(path1);
                    }
                    if (path2.StartsWith("//"))
                    {
                        spec2.DepotPath = new P4.DepotPath(path2);
                    }
                    else
                    {
                        spec2.LocalPath = new P4.LocalPath(path2);
                    }

                    // build spec one
                    if (dlg.specifier1stRB.Checked == true)
                    {
                        // #revision
                        if (dlg.specifier1stCB.SelectedIndex == 0)
                        {
                            if (dlg.path1ValueTB.Text == string.Empty)
                            {
                                spec1.Version = null;
                            }
                            else
                            {
                                try
                                {
                                    int rev1 = Convert.ToInt32(dlg.path1ValueTB.Text);
                                    spec1.Version = new P4.Revision(rev1);
                                }
                                catch (Exception)
                                {
                                    MessageBox.Show(string.Format(Resources.DiffDlg_InvalidRevisionSpecifier, dlg.path1ValueTB.Text),
                                                    Resources.PerforceSCM, MessageBoxButtons.OK);
                                    Show(paths, specifier, value, scm);
                                    return(files);
                                }
                            }
                        }

                        // @workspace
                        if (dlg.specifier1stCB.SelectedIndex == 4)
                        {
                            if (dlg.path1ValueTB.Text == string.Empty)
                            {
                                spec1.Version = null;
                            }
                            else
                            {
                                string ws1 = dlg.path1ValueTB.Text;
                                spec1.Version = new P4.ClientNameVersion(ws1);
                            }
                        }

                        // @date/time
                        if (dlg.specifier1stCB.SelectedIndex == 2)
                        {
                            DateTime dt1 = dlg.path1dateTimePicker.Value;
                            spec1.Version = new P4.DateTimeVersion(dt1);
                        }

                        // @changelist
                        if (dlg.specifier1stCB.SelectedIndex == 1)
                        {
                            if (dlg.path1ValueTB.Text == string.Empty)
                            {
                                spec1.Version = null;
                            }
                            else
                            {
                                try
                                {
                                    int cl1 = Convert.ToInt32(dlg.path1ValueTB.Text);
                                    spec1.Version = new P4.ChangelistIdVersion(cl1);
                                }
                                catch (Exception)
                                {
                                    MessageBox.Show(string.Format(Resources.DiffDlg_InvalidChangelistSpecifier, dlg.path1ValueTB.Text),
                                                    Resources.PerforceSCM, MessageBoxButtons.OK);
                                    Show(paths, specifier, value, scm);
                                    return(files);
                                }
                            }
                        }

                        // @label
                        if (dlg.specifier1stCB.SelectedIndex == 3)
                        {
                            if (dlg.path1ValueTB.Text == string.Empty)
                            {
                                spec1.Version = null;
                            }
                            else
                            {
                                string lb1 = dlg.path1ValueTB.Text;
                                spec1.Version = new P4.LabelNameVersion(lb1);
                            }
                        }
                    }

                    if (dlg.workspace1stRB.Checked == true)
                    {
                        // if diffing with local path, get that from the file metadata
                        // and null out the spec's depot path
                        if (spec1.DepotPath != null)
                        {
                            P4.FileMetaData fmd = scm.GetFileMetaData(spec1.DepotPath.Path);
                            if (fmd != null)
                            {
                                spec1.LocalPath = fmd.LocalPath;
                                spec1.DepotPath = null;
                            }
                        }
                    }

                    if (dlg.latest1stRB.Checked == true)
                    {
                        spec1.Version = new P4.HeadRevision();
                    }

                    if (dlg.have1stRB.Checked == true)
                    {
                        spec1.Version = new P4.HaveRevision();
                    }

                    // build spec 2
                    if (dlg.specifier2ndRB.Checked == true)
                    {
                        // #revision
                        if (dlg.specifier2ndCB.SelectedIndex == 0)
                        {
                            if (dlg.path2ValueTB.Text == string.Empty)
                            {
                                spec2.Version = null;
                            }
                            else
                            {
                                try
                                {
                                    int rev2 = Convert.ToInt32(dlg.path2ValueTB.Text);
                                    spec2.Version = new P4.Revision(rev2);
                                }
                                catch (Exception)
                                {
                                    MessageBox.Show(string.Format(Resources.DiffDlg_InvalidRevisionSpecifier, dlg.path1ValueTB.Text),
                                                    Resources.PerforceSCM, MessageBoxButtons.OK);
                                    Show(paths, specifier, value, scm);
                                    return(files);
                                }
                            }
                        }

                        // @workspace
                        if (dlg.specifier2ndCB.SelectedIndex == 4)
                        {
                            if (dlg.path2ValueTB.Text == string.Empty)
                            {
                                spec2.Version = null;
                            }
                            else
                            {
                                string ws2 = dlg.path2ValueTB.Text;
                                spec2.Version = new P4.ClientNameVersion(ws2);
                            }
                        }

                        // @date/time
                        if (dlg.specifier2ndCB.SelectedIndex == 2)
                        {
                            DateTime dt2 = dlg.path2dateTimePicker.Value;
                            spec2.Version = new P4.DateTimeVersion(dt2);
                        }

                        // @changelist
                        if (dlg.specifier2ndCB.SelectedIndex == 1)
                        {
                            if (dlg.path2ValueTB.Text == string.Empty)
                            {
                                spec2.Version = null;
                            }
                            else
                            {
                                try
                                {
                                    int cl2 = Convert.ToInt32(dlg.path2ValueTB.Text);
                                    spec2.Version = new P4.ChangelistIdVersion(cl2);
                                }
                                catch (Exception)
                                {
                                    MessageBox.Show(string.Format(Resources.DiffDlg_InvalidChangelistSpecifier, dlg.path1ValueTB.Text),
                                                    Resources.PerforceSCM, MessageBoxButtons.OK);
                                    Show(paths, specifier, value, scm);
                                    return(files);
                                }
                            }
                        }

                        // @label
                        if (dlg.specifier2ndCB.SelectedIndex == 3)
                        {
                            if (dlg.path2ValueTB.Text == string.Empty)
                            {
                                spec2.Version = null;
                            }
                            else
                            {
                                string lb2 = dlg.path2ValueTB.Text;
                                spec2.Version = new P4.LabelNameVersion(lb2);
                            }
                        }
                    }

                    if (dlg.workspace2ndRB.Checked == true)
                    {
                        // if diffing with local path, get that from the file metadata
                        // and null out the spec's depot path
                        if (spec2.DepotPath != null)
                        {
                            P4.FileMetaData fmd = scm.GetFileMetaData(spec2.DepotPath.Path);
                            if (fmd != null)
                            {
                                spec2.LocalPath = fmd.LocalPath;
                                spec2.DepotPath = null;
                            }
                        }
                    }

                    if (dlg.latest2ndRB.Checked == true)
                    {
                        spec2.Version = new P4.HeadRevision();
                    }

                    if (dlg.have2ndRB.Checked == true)
                    {
                        spec2.Version = new P4.HaveRevision();
                    }


                    files.Add(spec1);
                    files.Add(spec2);

                    IList <P4.FileMetaData> checkForValid = scm.GetFileMetaData(files, null);

                    if (checkForValid == null || (checkForValid != null && checkForValid.Count < 2))
                    {
                        if (scm.Connection.Repository.Connection.LastResults.ErrorList != null)
                        {
                            P4.P4ClientErrorList invalid = scm.Connection.Repository.Connection.LastResults.ErrorList;
                            string message = string.Empty;
                            foreach (P4ClientError error in invalid)
                            {
                                message = message + error.ErrorMessage;
                            }
                            MessageBox.Show(message);

                            Show(paths, specifier, value, scm);
                            return(files);
                        }
                    }

                    if (files != null)
                    {
                        scm.Diff2Files(files);
                    }
                    return(files);
                }
            }
            return(null);
        }
示例#6
0
        public DiffDlg(IList <string> paths, string specifier, string value, P4ScmProvider scm)
        {
            PreferenceKey = "DiffDlg";

            _scm   = scm;
            _paths = paths;

            InitializeComponent();
            this.Icon = Images.icon_p4vs_16px;

            if (components == null)
            {
                components = new System.ComponentModel.Container();
            }
            //
            // imageList1
            //
            imageList1 = new System.Windows.Forms.ImageList(components);
            this.imageList1.TransparentColor = System.Drawing.Color.Transparent;
            this.imageList1.Images.Add("revision_icon_base.png", Images.revision_icon_base);
            this.imageList1.Images.Add("submitted_change_icon.png", Images.submitted_change_icon);
            this.imageList1.Images.Add("datetime.png", Images.datetime);
            this.imageList1.Images.Add("labels_icon.png", Images.labels_icon);
            this.imageList1.Images.Add("clients_icon.png", Images.clients_icon);
            this.imageList1.Images.Add("portrait.png", Images.portrait);
            this.imageList1.Images.Add("client_folder.png", Images.client_folder);
            this.imageList1.Images.Add("depot_folder.png", Images.depot_folder);

            latest1stRBFmt = latest1stRB.Text;
            have1stRBFmt   = have1stRB.Text;
            latest2ndRBFmt = latest2ndRB.Text;
            have2ndRBFmt   = have2ndRB.Text;

            // dialog called from workspace tool window
            if (specifier == "workspace")
            {
            }

            // dialog called from solution explorer or VS menu
            if (specifier == "revision" ||
                specifier == "explorer")
            {
                int latest = 0;
                int have   = 0;

                // set up top path
                path1TB.Text = paths[0];
                P4.FileMetaData file1 = scm.GetFileMetaData(paths[0]);
                if (file1 != null)
                {
                    latest                       = file1.HeadRev;
                    have                         = file1.HaveRev;
                    latest1stRB.Text             = string.Format(latest1stRBFmt, latest);
                    have1stRB.Text               = string.Format(have1stRBFmt, have);
                    specifier1stCB.SelectedIndex = 0;
                    latest1stRB.Checked          = true;
                    specifier1stCB.SelectedIndex = 0;
                    if ((string.IsNullOrEmpty(path1ValueTB.Text) == true ||
                         string.IsNullOrEmpty(path1ValueTB.Text) == true) &&
                        (specifier1stRB.Checked == true))
                    {
                        diffBtn.Enabled = false;
                    }
                    else
                    {
                        diffBtn.Enabled = true;
                    }

                    // set up bottom path
                    path2TB.Text                 = paths[0];
                    latest2ndRB.Text             = string.Format(latest2ndRBFmt, latest);
                    have2ndRB.Text               = string.Format(have2ndRBFmt, have);
                    specifier2ndCB.SelectedIndex = 0;
                    have2ndRB.Checked            = true;
                    if ((string.IsNullOrEmpty(path2ValueTB.Text) == true ||
                         string.IsNullOrEmpty(path2ValueTB.Text) == true) &&
                        (specifier2ndRB.Checked == true))
                    {
                        diffBtn.Enabled = false;
                    }
                    else
                    {
                        diffBtn.Enabled = true;
                    }
                }
                else
                {
                    string msg = string.Format(Resources.DiffDlg_MissingFileError, paths[0]);
                    MessageBox.Show(msg, Resources.P4VS, MessageBoxButtons.OK, MessageBoxIcon.Error);
                    throw new ArgumentException(msg);
                }
            }
            // dialog called from history
            if (specifier == "history")
            {
                int latest = 0;
                int have   = 0;

                // set up top path
                path1TB.Text = paths[0];
                P4.FileMetaData file1 = scm.GetFileMetaData(paths[0]);
                if (file1 != null)
                {
                    latest                       = file1.HeadRev;
                    have                         = file1.HaveRev;
                    latest1stRB.Text             = string.Format(latest1stRBFmt, latest);
                    have1stRB.Text               = string.Format(have1stRBFmt, have);
                    specifier1stCB.SelectedIndex = 0;
                    if (value == "local")
                    {
                        workspace1stRB.Checked = true;
                    }
                    else
                    {
                        specifier1stRB.Checked = true;
                        path1ValueTB.Text      = value;
                    }
                    specifier1stCB.SelectedIndex = 0;
                    if ((string.IsNullOrEmpty(path1ValueTB.Text) == true ||
                         string.IsNullOrEmpty(path1ValueTB.Text) == true) &&
                        (specifier1stRB.Checked == true))
                    {
                        diffBtn.Enabled = false;
                    }
                    else
                    {
                        diffBtn.Enabled = true;
                    }

                    // set up bottom path
                    path2TB.Text                 = paths[0];
                    latest2ndRB.Text             = string.Format(latest2ndRBFmt, latest);
                    have2ndRB.Text               = string.Format(have2ndRBFmt, have);
                    specifier2ndCB.SelectedIndex = 0;
                    specifier2ndRB.Checked       = true;
                    if ((string.IsNullOrEmpty(path2ValueTB.Text) == true ||
                         string.IsNullOrEmpty(path2ValueTB.Text) == true) &&
                        (specifier2ndRB.Checked == true))
                    {
                        diffBtn.Enabled = false;
                    }
                    else
                    {
                        diffBtn.Enabled = true;
                    }
                }
                else
                {
                    string msg = string.Format(Resources.DiffDlg_MissingFileError, paths[0]);
                    MessageBox.Show(msg, Resources.P4VS, MessageBoxButtons.OK, MessageBoxIcon.Error);
                    throw new ArgumentException(msg);
                }
            }

            // dialog called from submitted changelists tool window
            if (specifier == "changelist")
            {
                // set up top path
                path1TB.Text = string.Empty;
                specifier1stCB.SelectedIndex = 1;
                specifier1stRB.Checked       = true;
                path1ValueTB.Text            = value;
                diffBtn.Enabled = false;

                // set up bottom path
                path2TB.Text = string.Empty;
                specifier2ndCB.SelectedIndex = 0;
                specifier2ndRB.Checked       = true;
                diffBtn.Enabled = false;
            }

            // dialog called from labels tool window
            if (specifier == "label")
            {
            }
        }
示例#7
0
		public static void ShelveFiles(IList<string> files, P4ScmProvider Scm, bool ShowUi)
		{
			Dictionary<int, IDictionary<string, P4.FileMetaData>> changeLists =
                new Dictionary<int, IDictionary<string, P4.FileMetaData>>();

		    bool shelvedFiles = false;

			for (int idx = 0; idx < files.Count; idx++)
			{
				int changeListId = -1;

				if (files[idx] != null && (files[idx].EndsWith("...") || files[idx].EndsWith("*")))
				{
					List<P4.FileSpec> fileSpecs = new List<P4.FileSpec>();
					fileSpecs.Add(P4.FileSpec.DepotSpec(files[idx]));
                    IList<P4.File> opened = Scm.Connection.Repository.GetOpenedFiles(fileSpecs, null);
					IList<P4.FileSpec> openedSpecs = new List<P4.FileSpec>();
					foreach (P4.File f in opened)
					{
						if ((f != null) && (f.DepotPath != null))
						{
							openedSpecs.Add(P4.FileSpec.ClientSpec(f.ClientPath.Path));
						}
					}
					IList<P4.FileMetaData> metadata = Scm.ListFileMetaData(null, openedSpecs);
					foreach (P4.FileMetaData f in metadata)
					{
                        if (f != null)
                        {
                            changeListId = f.Change;

                            if (changeLists.ContainsKey(changeListId) == false)
                            {
                                changeLists.Add(changeListId, new Dictionary<string, P4.FileMetaData>());
                            }
                            if (changeLists[changeListId].ContainsKey(f.LocalPath.Path) == false)
                            {
                                changeLists[changeListId].Add(f.LocalPath.Path, f);
                            }
                            if (f.MovedFile != null)
                            {
                                P4.FileMetaData movedFmd = Scm.GetFileMetaData(f.MovedFile.Path);
                                if ((movedFmd != null) && (movedFmd.LocalPath != null) &&
                                    (changeLists[changeListId].ContainsKey(movedFmd.LocalPath.Path) == false))
                                {
                                    changeLists[changeListId].Add(movedFmd.LocalPath.Path, movedFmd);
                                }
                            }
                        }
					}

					continue;
				}
				P4.FileMetaData fmd = null;

				fmd = Scm.Fetch(files[idx]);
				if (fmd == null)
				{
					continue;
				}
				SourceControlStatus status = Scm.GetFileStatus(files[idx]);
				if (status == SourceControlStatus.scsCheckedIn)
				{
					continue;
				}

				changeListId = fmd.Change;

                // describe cl here and see if it is shelved
                if (changeListId > 0)
                {
                    Options opts = new Options();
                    opts["-S"] = null;
                    Changelist isChangeShelved = Scm.GetChangelist(changeListId, opts);

                    if (isChangeShelved.Shelved)
                    {
                        shelvedFiles = true;
                    }
                }

				if (changeLists.ContainsKey(changeListId) == false)
				{
					changeLists.Add(changeListId, new Dictionary<string, P4.FileMetaData>());
				}
				if (changeLists[changeListId].ContainsKey(fmd.LocalPath.Path) == false)
				{
					changeLists[changeListId].Add(fmd.LocalPath.Path, fmd);
				}
				if (fmd.MovedFile != null)
				{
					P4.FileMetaData movedFmd = Scm.GetFileMetaData(fmd.MovedFile.Path);
					if ((movedFmd != null) && (movedFmd.LocalPath != null) &&
						(changeLists[changeListId].ContainsKey(movedFmd.LocalPath.Path) == false))
					{
						changeLists[changeListId].Add(movedFmd.LocalPath.Path, movedFmd);
					}
				}
			}
			bool dlgShown = false;
			foreach (int changeListId in changeLists.Keys)
			{
				ShelveFileDlg dlg = new ShelveFileDlg(Scm);

                if (!(shelvedFiles))
                {
                    dlg.ClearChangelistTB.Checked = false;
                    dlg.ClearChangelistTB.Enabled = false;
                }
				dlg.ChangelistId = changeListId;
				dlg.SelectedFileList = changeLists[changeListId].Values.ToList();
                
				if (dlg.SelectedFileList.Count <= 0)
				{
					continue;
				}
				dlgShown = true;

				DialogResult res = DialogResult.OK;

                dlg.Description = Resources.ShelveFileDlg_FilesShelvedFromDefaultChangelist;
				if (changeListId > 0)
				{
					dlg.Description = string.Format(
						Resources.ShelveFileDlg_FilesShelvedFromNumberedChangelist, changeListId);
				}
				if (ShowUi)
				{
					res = dlg.ShowDialog();
				}
				if (res == DialogResult.Cancel)
				{
					return;
				}
				// If requested delete the existing shelved flags
				if ((changeListId > 0) && (dlg.ReplaceExistingShelvedFiles))
				{
					if (Scm.ShelveFiles(changeListId, null, P4.ShelveFilesCmdFlags.Delete, true, null) == false)
					{
						return;
					}
				}
				P4.ShelveFilesCmdFlags flags = P4.ShelveFilesCmdFlags.Force;
				if (dlg.DontShelveUnchangedFiles)
				{
					flags |= ShelveFilesCmdFlags.LeaveUnchanged;
				}
				// Shelve the files
				if (Scm.ShelveFiles(changeListId, dlg.Description, flags, dlg.SelectedFileList) == false)
				{
					return;
				}

				// If requested, revert the files after shelving

				if (dlg.RevertAfterShelving)
				{
					IList<string> selection = dlg.GetSelectedFiles();
					string[] selected = selection.ToArray();
					Scm.RevertFiles(false, true, null, selected);
				}
				Scm.BroadcastChangelistUpdate(null, new P4ScmProvider.ChangelistUpdateArgs(changeListId, P4ScmProvider.ChangelistUpdateArgs.UpdateType.ContentUpdate));
			}
			if (dlgShown == false)
			{
				MessageBox.Show(Resources.ShelveFileDlg_NoShelveableFilesWarning, Resources.PerforceSCM, MessageBoxButtons.OK, MessageBoxIcon.Error);
			}
		}
示例#8
0
		public static void ShelveFiles(IList<P4.FileMetaData> files, P4.Changelist changelist, P4ScmProvider ScmProvider, bool ShowUi)
		{
			ShelveFileDlg dlg = new ShelveFileDlg(ScmProvider);
            bool shelvedFiles = changelist.Shelved;

			dlg.ChangelistId = changelist.Id;
			if ((files != null) && (files.Count > 0))
			{
			    List<P4.FileMetaData> linkedFiles = new List<P4.FileMetaData>();
				foreach (P4.FileMetaData fmd in files)
				{
					if (fmd.MovedFile != null)
					{
						P4.FileMetaData movedFmd = ScmProvider.GetFileMetaData(fmd.MovedFile.Path);
						linkedFiles.Add(movedFmd);
					}
                   
				}
                foreach (P4.FileMetaData fmd in linkedFiles)
                {

                    files.Add(fmd);
                }
			    dlg.SelectedFileList = files;

                
			}
			if (dlg.SelectedFileList.Count <= 0)
			{
				dlg.SelectAllCB.Checked = true;
			}

            if (!(shelvedFiles))
            {
                dlg.ClearChangelistTB.Checked = false;
                dlg.ClearChangelistTB.Enabled = false;
            }
			DialogResult res = DialogResult.OK;

			dlg.Description = Resources.ShelveFileDlg_FilesShelvedFromDefaultChangelist;
			if (changelist.Id > 0)
			{
				dlg.Description = string.Format(
					Resources.ShelveFileDlg_FilesShelvedFromNumberedChangelist, changelist.Id);
			}
			if (ShowUi)
			{
				res = dlg.ShowDialog();
			}
			if (res == DialogResult.Cancel)
			{
				return;
			}
			// If requested delete the existing shelved flags
			if ((changelist.Id > 0) && (dlg.ReplaceExistingShelvedFiles))
			{
				if (ScmProvider.ShelveFiles(changelist.Id, null, P4.ShelveFilesCmdFlags.Delete, true, null) == false)
				{
					return;
				}
			}
			P4.ShelveFilesCmdFlags flags = P4.ShelveFilesCmdFlags.Force;
			if (dlg.DontShelveUnchangedFiles)
			{
				flags |= ShelveFilesCmdFlags.LeaveUnchanged;
			}
			// Shelve the files
			if (ScmProvider.ShelveFiles(changelist.Id, dlg.Description, flags, dlg.SelectedFileList) == false)
			{
				return;
			}

			// If requested, revert the files after shelving

			if (dlg.RevertAfterShelving)
			{
				ScmProvider.RevertFiles(false, true, null, dlg.GetSelectedFiles().ToArray());
			}
			ScmProvider.BroadcastChangelistUpdate(null, new P4ScmProvider.ChangelistUpdateArgs(changelist.Id, P4ScmProvider.ChangelistUpdateArgs.UpdateType.ContentUpdate));
		}
示例#9
0
        public GetRevisionDlg(IList <P4.FileSpec> files, string specifier, string value, P4ScmProvider scm, bool isSolutionIncluded)
        {
            PreferenceKey = "GetRevisionDlg";

            _scm   = scm;
            _files = files;
            _isSolutionIncluded = isSolutionIncluded;

            InitializeComponent();

            this.Icon = Images.icon_p4vs_16px;
            // adding a header with header style set to none so that this
            // behaves as a single column list.
            ColumnHeader h = new ColumnHeader();

            h.Width = -2;
            filesListView.Columns.Add(h);
            IList <P4.FileMetaData> mdl = new List <P4.FileMetaData>();

            if (files != null)
            {
                foreach (FileSpec fs in files)
                {
                    // if LocalPath is null, it is likely that this was
                    // launched from somewhere only providing depot paths
                    // in that case, assume all LocalPaths for files will
                    // be null and break.
                    if (fs.LocalPath == null)
                    {
                        break;
                    }
                    if (fs.LocalPath.Path.EndsWith("..."))
                    {
                        mdl.Add(fs);
                    }
                    else
                    {
                        FileMetaData fmd = _scm.GetCachedFile(fs.LocalPath.Path);
                        if (fmd == null)
                        {
                            fmd = _scm.UpdateFileInCache(fs.LocalPath.Path, true);
                        }
                        // if it is still null, it is likely not in Perforce
                        if (fmd != null)
                        {
                            mdl.Add(fmd);
                        }
                    }
                }
                if (mdl.Count == 0)
                {
                    mdl = scm.GetFileMetaData(files, null);
                }
            }
            IList <object> fields = new List <object>();

            fields.Add(P4FileTreeListViewItem.SubItemFlag.DepotFullPath);

            if ((mdl != null) && (mdl.Count > 0))
            {
                foreach (P4.FileMetaData file in mdl)
                {
                    P4FileTreeListViewItem item = new P4FileTreeListViewItem(null, file, fields);
                    P4FileTreeListViewItem dupe = (P4FileTreeListViewItem)filesListView.FindItemWithText(item.Text);
                    if (dupe != item)
                    {
                        item.Tag      = file;
                        item.FileData = file;

                        filesListView.Items.Add(item);
                    }
                }
            }

            // dialog called from workspace tool window
            if (specifier == "workspace")
            {
                specifierCB.SelectedIndex = 4;
                specifierRB.Checked       = true;
                if (value != null)
                {
                    ValueTB.Text = value;
                }
            }

            // dialog called from solution explorer or VS menu
            if (specifier == "revision" ||
                specifier == "explorer")
            {
                specifierCB.SelectedIndex = 0;
                getLatestRB.Checked       = true;
            }

            // dialog called from submitted changelists tool window
            if (specifier == "changelist")
            {
                specifierCB.SelectedIndex  = 1;
                specifierRB.Checked        = true;
                changelistFilesChk.Enabled = true;
                if (value != null)
                {
                    ValueTB.Text = value;
                }
            }

            // dialog called from labels tool window
            if (specifier == "label")
            {
                specifierCB.SelectedIndex = 3;
                specifierRB.Checked       = true;
                removeChk.Enabled         = true;
                if (value != null)
                {
                    ValueTB.Text = value;
                }
            }
        }