public static void MarkLocalAssetBlessed(MOG_Filename assetFilename, string blessedTimestamp) { // Walk through all of our workspaces foreach (MOG_ControllerSyncData workspace in mWorkspaces.Values) { // Check if this is the current workspace? or // Check if this workspace is active? if (workspace == MOG_ControllerProject.GetCurrentSyncDataController() || workspace.IsAlwaysActive()) { // Build the expected path to this asset in our local workspace MOG_Filename workspaceAsset = MOG_Filename.GetLocalUpdatedTrayFilename(workspace.GetSyncDirectory(), assetFilename); // Open the local asset MOG_ControllerAsset localAsset = MOG_ControllerAsset.OpenAsset(workspaceAsset); if (localAsset != null) { // Stamp this locally update asset with the newly blessed revision timestamp localAsset.GetProperties().BlessedTime = blessedTimestamp; // Change the state of this asset to blessed MOG_ControllerInbox.UpdateInboxView(localAsset, MOG_AssetStatusType.Blessed); localAsset.Close(); } } } }
/// <summary> /// Make sure this asset is MOG Compliant /// </summary> private bool CheckName(string filename) { MOG_Filename assetName; try { assetName = new MOG_Filename(filename); } catch { throw new Exception("Unable to convert filename, '" + filename + "' to a valid MOG Filename."); } // No asset is valid if it has the '[' character // Original string == "[]'`,$^:?*<>/\\%#!|=" // glk: Kier and I changed this so that ONLY Windows, MOG-Specific, and INI chars are filtered if (assetName.GetAssetLabel().Split(ImportFilter_String.ToCharArray()).Length > 1) { throw new Exception("Non-valid character in import file: \n\n\t " + ImportFilter_String); } // Make sure the asset name is valid if (assetName.GetFilenameType() == MOG_FILENAME_TYPE.MOG_FILENAME_Unknown && MOG_ControllerProject.ValidateAssetFilename(assetName) == false) { return(false); } else { return(true); } }
/// <summary> /// Add group or object to the database /// </summary> private bool AddGroupToDatabase(string addCandidate, MOG_Filename packageAsset) { // Are we platform generic? bool success = true; if (packageAsset.GetAssetPlatform() == "All") { string packageVersion = MOG_DBAssetAPI.GetAssetVersion(packageAsset); if (packageVersion.Length > 0) { success = MOG_DBPackageAPI.AddPackageGroupName(packageAsset, packageVersion, addCandidate, MOG_ControllerProject.GetUser().GetUserName()); } } // We are platform generic, loop through all platforms then ArrayList platforms = MOG_ControllerProject.GetProject().GetPlatforms(); for (int p = 0; p < platforms.Count && success; p++) { MOG_Platform platform = (MOG_Platform)platforms[p]; // Set this package to be platform specific for this platform name packageAsset = MOG_Filename.CreateAssetName(packageAsset.GetAssetClassification(), platform.mPlatformName, packageAsset.GetAssetLabel()); string packageVersion = MOG_DBAssetAPI.GetAssetVersion(packageAsset); if (packageVersion.Length > 0) { // Add to the database success &= MOG_DBPackageAPI.AddPackageGroupName(packageAsset, packageVersion, addCandidate, MOG_ControllerProject.GetUser().GetUserName()); } } return success; }
/// <summary> /// Walk up the parents of a node looking for a parent with a valid MOG_Filename /// in the tag as well as the isPackage() bool set to true /// </summary> private TreeNode FindPackage(TreeNode node) { try { MOG_Filename assetName = new MOG_Filename(((MOG_ControlsLibrary.Controls.Mog_BaseTag)node.Tag).FullFilename); MOG_Properties props = new MOG_Properties(assetName); if (assetName != null && props.IsPackage) { return(node); } else { if (node.Parent != null) { return(FindPackage(node.Parent)); } else { return(null); } } } catch { if (node.Parent != null) { return(FindPackage(node.Parent)); } else { return(null); } } }
/// <summary> /// Keeps user from renaming multiple asset labels. /// </summary> private void RenameNewLabelTextBox_TextChanged(object sender, System.EventArgs e) { try { // Check for invalid characters in the new name if (MOG_ControllerSystem.InvalidMOGCharactersCheck(RenameNewLabelTextBox.Text, true)) { RenameNewLabelTextBox.Text = MOG_ControllerSystem.ReplaceInvalidCharacters(RenameNewLabelTextBox.Text); } // For Rename Label, we only need to worry about one asset... if (mFullFilename != null) { MOG_Filename currentFilename = new MOG_Filename(this.mFullFilename); string targetName = GetTargetName(currentFilename, RenameNewClassNameTextBox.Text, RenameNewPlatformComboBox.Text, RenameNewLabelTextBox.Text); ChangeAssetFilenameInListView(targetName); // Update the imported files column if (RenameFiles.Checked && bInitialized) { ChangeAssetImportnameInListView(RenameNewLabelTextBox.Text); } } } // Eat any errors we get catch (Exception ex) { MOG_Prompt.PromptMessage("Error With Value", ex.Message, ex.StackTrace, MOG_ALERT_LEVEL.ALERT); } }
private void PackageManagementForm_Closing(object sender, System.ComponentModel.CancelEventArgs e) { guiUserPrefs.SaveDynamic_LayoutPrefs(guiUserPrefs.PackageManagementForm_Text, this); // Check if we were modyifying assets? if (ModifyingAssets) { // Itterate through all the assets and mark them as being modified foreach (ListViewItem item in AssetList.Items) { MOG_Filename assetFilename = item.Tag as MOG_Filename; if (assetFilename != null) { // Open up this asset so we can remove the package relationships MOG_ControllerAsset asset = MOG_ControllerAsset.OpenAsset(assetFilename); if (asset != null) { if (asset.GetProperties().NativeDataType) { MOG_ControllerInbox.UpdateInboxView(asset, MOG_AssetStatusType.Processed); } else { MOG_ControllerInbox.UpdateInboxView(asset, MOG_AssetStatusType.Modified); } asset.Close(); } } } } }
private ArrayList GetRequiredAssets(string classification) { ArrayList requiredAssetList = new ArrayList(); // Break up classification into its parts string[] classificationParts = MOG_Filename.SplitClassificationString(classification); // Scan our list of required assets looking for any immediate children that should be included? foreach (DictionaryEntry requiredAsset in mRequiredAssets) { MOG_Filename requiredAssetFilename = new MOG_Filename(requiredAsset.Key.ToString()); string requiredClassification = requiredAssetFilename.GetAssetClassification(); // Check if classification is a parent for requiredClassification? if (MOG_Filename.IsParentClassificationString(requiredClassification, classification)) { // Break up classification into its parts string[] requiredClassificationParts = MOG_Filename.SplitClassificationString(requiredClassification); // Make sure there is an immediate child classification we can extract? if (requiredClassificationParts.Length == classificationParts.Length) { requiredAssetList.Add(requiredAssetFilename); } } } return(requiredAssetList); }
private void AttachValidatedTagToNewObjectOrGroup(TreeNode package, TreeNode newNode, PackageNodeTypes nodeType) { // If this thing is a Group or Object, we need to do this algorithm string fullFilename = null; MOG_Filename assetFile = null; int imageIndex = 0; switch (nodeType) { case PackageNodeTypes.Group: imageIndex = MogUtil_AssetIcons.GetClassIconIndex(PackageGroup_ImageText); break; case PackageNodeTypes.Object: imageIndex = MogUtil_AssetIcons.GetClassIconIndex(PackageObject_ImageText); break; default: MOG_Report.ReportSilent("Got Unexpected PackageNodeTypes", "Unexpected PackageNodeTypes enum given for MOG_ControlsLibrary.Controls", Environment.StackTrace); break; } string groupPath = newNode.FullPath.Substring(package.FullPath.Length).Trim(PathSeparator.ToCharArray()).Replace(PathSeparator, "/"); fullFilename = package.FullPath + "/" + groupPath; assetFile = new MOG_Filename(((Mog_BaseTag)package.Tag).FullFilename); // Now that we've got our initial information, add our tag newNode.Tag = new Mog_BaseTag(newNode, assetFile.GetEncodedFilename(), this.FocusForAssetNodes, true); ((Mog_BaseTag)newNode.Tag).PackageNodeType = nodeType; ((Mog_BaseTag)newNode.Tag).PackageFullName = fullFilename; SetImageIndices(newNode, imageIndex); }
/// <summary> /// Used to get an Asset node with a good node.Tag for this TreeView or any inheriting classes. /// </summary> private TreeNode CreateAssetNode(MOG_Filename asset, System.Drawing.Color foreColor, bool useFullFilename) { string assetName = asset.GetAssetFullName(); MOG_Filename assetFullFilename; // If we found revisions, go ahead and select the first one as the full filename for our tag... assetFullFilename = MOG_ControllerRepository.GetAssetBlessedPath(asset); TreeNode assetNode = new TreeNode(asset.GetAssetName()); if (useFullFilename) { assetNode.Text = asset.GetAssetFullName(); } assetNode.Tag = new Mog_BaseTag(assetNode, assetFullFilename.GetEncodedFilename(), RepositoryFocusLevel.Repository, true); // If we are Archive_Color, remain displayed as such if (foreColor == Archive_Color) { assetNode.ForeColor = Archive_Color; } assetNode.Nodes.Add(new TreeNode(Blank_Node_Text)); assetNode.Name = asset.GetAssetFullName(); SetImageIndices(assetNode, GetAssetImageIndex(((Mog_BaseTag)assetNode.Tag).FullFilename)); return(assetNode); }
private void CheckPackages(HybridDictionary packages, bool markAsInherited) { // Add our packages to our mogPackagesSet and expand the tree to that node foreach (DictionaryEntry entry in packages) { string package = entry.Key as string; int count = (int)entry.Value; // Generate a MOG_Filename and concat our path from it MOG_Filename packageFile = new MOG_Filename(package); string assetName = packageFile.GetAssetName(); string assetFullName = packageFile.GetAssetClassification() + assetName; // Make sure we have this Package selected (if possible) TreeNode node = FindPackageNode(assetFullName); if (node == null) { node = AddPackageNode(assetFullName); } if (node != null) { if (count < AssetList.Items.Count) { node.ForeColor = Color.Gray; } if (markAsInherited) { node.NodeFont = new Font(node.TreeView.Font, FontStyle.Italic); } node.Checked = true; } } }
public bool ToolNewerCheck(MOG_Filename mogAsset, string version, MOG_Project pProject, ref string failedString) { MOG_Time assetTime = new MOG_Time(version); MOG_Time correctAssetTime = new MOG_Time(); DirectoryInfo [] dirs = DosUtils.DirectoryGetList(MOG_ControllerRepository.GetAssetBlessedPath(mogAsset).GetEncodedFilename(), "*.*"); if (dirs != null) { foreach (DirectoryInfo dir in dirs) { string checkVersion = dir.Name.Substring(dir.Name.LastIndexOf(".") + 1); MOG_Time dirTime = new MOG_Time(checkVersion); // Is this asset equal or newer than this dir version? if (assetTime.Compare(dirTime) < 0) { failedString = "Out of date," + failedString; return(false); } } } return(true); }
private void CreateLateResolverItem(MOG_DBPackageCommandInfo packageCommand) { MOG_Filename assetName = new MOG_Filename(packageCommand.mAssetName); if (assetName.GetFilenameType() == MOG_FILENAME_TYPE.MOG_FILENAME_Asset) { ListViewItem item = new ListViewItem(); // "NAME, CLASSIFICATION, DATE, TARGET PACKAGE, OWNER, FULLNAME, COMMANDID, LABEL, VERSION" item.Text = assetName.GetAssetLabel(); item.SubItems.Add(assetName.GetAssetClassification()); // Class item.SubItems.Add(MogUtils_StringVersion.VersionToString(packageCommand.mAssetVersion)); item.SubItems.Add(packageCommand.mPackageName); item.SubItems.Add((packageCommand.mBlessedBy.Length != 0) ? packageCommand.mBlessedBy : packageCommand.mCreatedBy); item.SubItems.Add(packageCommand.mAssetName); item.SubItems.Add(packageCommand.mID.ToString()); item.SubItems.Add(packageCommand.mLabel); item.SubItems.Add(packageCommand.mAssetVersion); item.ImageIndex = MogUtil_AssetIcons.GetAssetIconIndex(packageCommand.mAssetName, null, false); mainForm.ConnectionManagerLateResolversListView.Items.Add(item); } }
protected TreeNode CreateSyncTargetTreeNode(MOG_DBSyncTargetInfo info, string platform) { bool ableToGetSourceFileAssetLinks = false; string currentVersionStamp = info.mVersion; MOG_Filename tempFilename = MOG_Filename.CreateAssetName(info.mAssetClassification, info.mAssetPlatform, info.mAssetLabel); MOG_Filename assetRealFile = MOG_ControllerRepository.GetAssetBlessedVersionPath(tempFilename, currentVersionStamp); // Create node with FocusLevel that does not plug into the BaseLeafTreeView TreeNode node = new TreeNode(info.FilenameOnly, new TreeNode[] { new TreeNode(Blank_Node_Text) }); Mog_BaseTag tag = new Mog_BaseTag(node, assetRealFile.GetEncodedFilename(), RepositoryFocusLevel.Classification, true); node.Name = tempFilename.GetAssetFullName(); tag.AttachedSyncTargetInfo = info; node.Tag = tag; string gamedataFilePath; if (ableToGetSourceFileAssetLinks) { gamedataFilePath = assetRealFile.GetEncodedFilename() + "\\Files.Imported\\" + info.mSyncTargetFile; } else { gamedataFilePath = assetRealFile.GetEncodedFilename() + "\\Files.Imported\\" + info.FilenameOnly; } //This is either a file or an asset SetImageIndices(node, base.GetAssetFileImageIndex(gamedataFilePath)); return(node); }
private ListViewItem AddItemToListView(MOG_Filename mogAsset, MOG_Properties pProperties, string fullPath) { ListViewItem item = new ListViewItem(); foreach (ColumnHeader column in ListListView.Columns) { item.SubItems.Add(""); } SetSubColumnText(item, "Name", mogAsset.GetAssetLabel()); SetSubColumnText(item, "MOG Classification", mogAsset.GetAssetClassification()); SetSubColumnText(item, "Platform", mogAsset.GetAssetPlatform()); SetSubColumnText(item, "Version", mogAsset.GetVersionTimeStampString("")); if (pProperties != null) { SetSubColumnText(item, "Size", guiAssetController.FormatSize(pProperties.Size)); SetSubColumnText(item, "Package", GetPackages(pProperties)); SetSubColumnText(item, "Creator", pProperties.Creator); SetSubColumnText(item, "Last Bless", pProperties.Owner); SetSubColumnText(item, "Computer", pProperties.SourceMachine); SetSubColumnText(item, "GamePath", pProperties.SyncTargetPath); SetSubColumnText(item, "Last Comment", pProperties.LastComment); } SetSubColumnText(item, "Fullname", fullPath); // Icon item.ImageIndex = MogUtil_AssetIcons.GetAssetIconIndex(mogAsset.GetOriginalFilename(), pProperties, false); return(ListListView.Items.Add(item)); }
/// <summary> /// Utility method to make sure we have a valid Package name (which should have an extension) /// </summary> private bool ValidatePackageExtension(NodeLabelEditEventArgs e, MOG_Filename packageName) { // Make sure packages have extensions, if not make strong warning if (packageName.GetExtension().Length == 0) { string message = "This package does not have an extension!\r\n" + "Most engines require extensions on packages.\r\n\r\n" + "(Click 'Ignore' to continue without adding an extension)"; switch (MOG_Prompt.PromptResponse("Create new package", message, MOGPromptButtons.AbortRetryIgnore)) { case MOGPromptResult.Retry: e.CancelEdit = true; e.Node.TreeView.LabelEdit = true; e.Node.BeginEdit(); return false; case MOGPromptResult.Abort: e.Node.Remove(); e.CancelEdit = true; return false; } } // We finished the block. Return true. return true; }
private void FindAndUpdateNodeLockStatus(string nodeKey, MOG_Filename assetName, MogControl_BaseTreeView tree) { // Attempt to find this node in our tree TreeNode[] foundNodes = tree.Nodes.Find(nodeKey, true); if (foundNodes != null && foundNodes.Length > 0) { foreach (TreeNode node in foundNodes) { Mog_BaseTag tag = node.Tag as Mog_BaseTag; if (tag != null) { // Is this a sync target node if (tag.AttachedSyncTargetInfo != null) { // Update this assets status string assetRepositoryName = tag.FullFilename + "\\Files.Imported\\" + tag.AttachedSyncTargetInfo.FilenameOnly; node.ImageIndex = MogUtil_AssetIcons.GetBinaryLockedOrUnlockedIcon(assetName.GetAssetFullName(), assetRepositoryName); node.SelectedImageIndex = node.ImageIndex; } else { // Update this assets status node.ImageIndex = MogUtil_AssetIcons.GetAssetIconIndex(assetName.GetAssetFullName()); node.SelectedImageIndex = node.ImageIndex; } } } } }
static public bool RepackageAssetInWorkspaces(MOG_Filename assetFilename, BackgroundWorker worker) { bool bFailed = false; // Walk through all of our workspaces foreach (MOG_ControllerSyncData workspace in mWorkspaces.Values) { // Check if this is the current workspace? or // Check if this workspace is active? if (workspace == MOG_ControllerProject.GetCurrentSyncDataController() || workspace.IsAlwaysActive()) { // Proceed to add the asset to this workspace MOG_Filename workspaceAsset = MOG_Filename.GetLocalUpdatedTrayFilename(workspace.GetSyncDirectory(), assetFilename); if (!workspace.RepackageAssetInLocalWorkspace(workspaceAsset)) { bFailed = true; } } } if (!bFailed) { return(true); } return(false); }
private bool SetParentForecolors(MOG_Filename filename, TreeNode node, int numberOfRevisions) { node.ForeColor = Color.Red; if (node.Text.EndsWith(filename.GetAssetLabel(), StringComparison.CurrentCultureIgnoreCase)) { // We also need to remove the "Current <DATE>" node if (node.Nodes != null && node.Nodes.Count > 0 && node.Nodes[0].Text.StartsWith("Current", StringComparison.CurrentCultureIgnoreCase)) { node.Nodes[0].Remove(); } return(true); } else if (numberOfRevisions == 1) { if (node.Parent != null) { if (SetParentForecolors(filename, node.Parent, numberOfRevisions)) { return(true); } } } return(false); }
/// <summary> /// Returns true if asset has been blessed. /// </summary> /// <param name="asset"></param> /// <returns></returns> private bool CheckIfAssetHasBeenBlessed(MOG_Filename asset) { // Create MOG_Filename for this asset string assetVersion = MOG.DATABASE.MOG_DBAssetAPI.GetAssetVersion(asset); return(assetVersion != null && assetVersion.Length > 0); }
/// <summary> /// Shows Assets based on MOG_Property(s) assigned to PropertyList /// </summary> private void ExpandPropertyTreeDown(TreeNode node) { BeginUpdate(); List <string> classificationsToAdd = GetSubClassifications(node); List <string> assetsToAdd = GetAssets(node); // Sort our classifications alphabetically classificationsToAdd.Sort(); // Foreach classification, add it foreach (string classification in classificationsToAdd) { TreeNode classificationNode = new TreeNode(classification); // Assign the default node checked state classificationNode.Checked = node.Checked; classificationNode.Tag = new Mog_BaseTag(classificationNode, classification, RepositoryFocusLevel.Classification, false); ((Mog_BaseTag)classificationNode.Tag).PackageNodeType = PackageNodeTypes.Class; node.Nodes.Add(classificationNode); classificationNode.Name = classificationNode.FullPath; SetImageIndices(classificationNode, GetClassificationImageIndex(classificationNode.FullPath)); classificationNode.Nodes.Add(new TreeNode(Blank_Node_Text)); } // Use the System.IComparable interface for `string` to sort our list assetsToAdd.Sort(); // Foreach Asset, add it foreach (string assetFilename in assetsToAdd) { MOG_Filename assetFile = new MOG_Filename(assetFilename); assetFile = MOG_ControllerProject.GetAssetCurrentBlessedPath(assetFile); TreeNode assetNode; // If we are expandingAssets or expandingPackageGroups, we need to be able to expand down if (ExpandAssets || ExpandPackageGroups) { assetNode = new TreeNode(assetFile.GetAssetName(), new TreeNode[] { new TreeNode(Blank_Node_Text) }); } // Else, do not expand down. Showing the Asset is all we need to do else { assetNode = new TreeNode(assetFile.GetAssetName()); } assetNode.Tag = new Mog_BaseTag(assetNode, assetFile.GetEncodedFilename(), FocusForAssetNodes, true); ((Mog_BaseTag)assetNode.Tag).PackageNodeType = PackageNodeTypes.Asset; ((Mog_BaseTag)assetNode.Tag).PackageFullName = assetFile.GetAssetFullName(); node.Nodes.Add(assetNode); assetNode.Name = assetFile.GetAssetFullName(); SetImageIndices(assetNode, GetAssetFileImageIndex(assetFile.GetEncodedFilename())); } EndUpdate(); }
private bool ShowEntireClassificationContents(string classification) { bool bShowEntireTree = true; // Check if we have any properties associated with this tree? if (MogPropertyList.Count > 0) { // Check if we have no mRequiredClassifications? if (mRequiredClassifications.Count > 0) { int bestMatchingRequiredClassificationLength = 0; // Check if this classification is a child of a required classification? foreach (DictionaryEntry requiredClassification in mRequiredClassifications) { // Is this classification a child of this required classification? if (MOG_Filename.IsParentClassificationString(classification, requiredClassification.Key.ToString())) { // Check if this requiredClassification is a better match? if (requiredClassification.Key.ToString().Length > bestMatchingRequiredClassificationLength) { // Start tracking this as our best match thus far bestMatchingRequiredClassificationLength = requiredClassification.Key.ToString().Length; } } } // Check if we think we found a best match? if (bestMatchingRequiredClassificationLength != 0) { // Check if this classification is a child of a an excluded classification? foreach (DictionaryEntry excludedClassification in mExludedClassifications) { // Is this classification a child of this excluded classification? if (MOG_Filename.IsParentClassificationString(classification, excludedClassification.Key.ToString())) { // Check if this trumps our best match? if (excludedClassification.Key.ToString().Length > bestMatchingRequiredClassificationLength) { // Looks like the nays take it bestMatchingRequiredClassificationLength = 0; break; } } } } // Check if we still have a best possitive match? if (bestMatchingRequiredClassificationLength == 0) { bShowEntireTree = false; } } } return(bShowEntireTree); }
/// <summary> /// Utility method for the Package portion of AfterLabelEdit() (above) /// </summary> private ArrayList GetValidTargetSyncPath(NodeLabelEditEventArgs e, MOG_Filename packageName) { // Get the gameDataPath for this new package GameDataPathForm getPath = new GameDataPathForm(packageName.GetAssetPlatform(), packageName.GetAssetName()); ArrayList targetSyncPath = null; // This dialog should be pushed to topmost when it doesn't have a parent or else it can ger lost behind other apps. // You would think this is simple but for some reason MOG has really struggled with these dialogs being kept on top... // We have tried it all and finally ended up with this...toggling the TopMost mode seems to be working 100% of the time. getPath.TopMost = true; getPath.TopMost = false; getPath.TopMost = true; // Show the dialog if (DialogResult.Cancel != getPath.ShowDialog()) { targetSyncPath = getPath.MOGPropertyArray; // Get a value for our relative gamedata path string relativePath = null; if (targetSyncPath.Count > 0) { relativePath = ((MOG_Property)targetSyncPath[0]).mPropertyValue; } // If we found our relativePath... if (relativePath != null) { // Go ahead and add an initial backslash, if necessary... if (relativePath.Length > 0 && relativePath[0] != '\\') { relativePath = "\\" + relativePath; } // Find all our assets with this gamedata path ArrayList assets = MOG_DBAssetAPI.GetAllAssetsBySyncLocation(relativePath, packageName.GetAssetPlatform()); // If we found assets... if (assets != null && assets.Count > 0) { // Check and see if any of the assets we found match the package we want to add... foreach (MOG_Filename asset in assets) { // If we already have the package name we want to add, warn user and quit... if (asset.GetAssetName().ToLower() == packageName.GetAssetName().ToLower()) { MessageBox.Show(this, "Package name, " + packageName.GetAssetName() + ", already exists in location, '" + relativePath.Substring(1) + "'!", "Package Already Exists!", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); e.Node.EndEdit(true); e.Node.Remove(); return null; } } } } } // Finished our method, so return true return targetSyncPath; }
private void MessageAttachOpenFileDialog_FileOk(object sender, System.ComponentModel.CancelEventArgs e) { foreach (string file in MessageAttachOpenFileDialog.FileNames) { MOG_Filename filename = new MOG_Filename(file); mMessage.AttachmentAdd(filename); MessageAttachTextBox.Text = String.Concat(MessageAttachTextBox.Text, "\r\n", file); } }
/// <summary> SetAssetIcon /// Searches through mAssetTypes to find the matching key with /// that of the filename. Then returns the index /// </summary> /// <param name="filename"></param> /// <returns>index of icon in the mAssetTypeImages list</returns> static public int GetClassIconIndex(String filename) { // Construct a filename MOG_Filename file = null; try { file = new MOG_Filename(filename); } catch (Exception e) { e.ToString(); return(0); } string classification; switch (file.GetFilenameType()) { case MOG_FILENAME_TYPE.MOG_FILENAME_Asset: classification = file.GetAssetClassification(); break; case MOG_FILENAME_TYPE.MOG_FILENAME_Group: classification = "group"; break; default: classification = filename; break; } // Get the index of the key in the types array int x = 0; foreach (string classType in mAssetTypes) { if (string.Compare(classType, classification, true) == 0) { break; } else { x++; } } // If the asset was not found, return for first icon in the list if (x >= mAssetTypes.Count) { return(0); } // Return the index of the icon return(x); } // end ()
/// <summary> /// Add a new mog asset to the listView items array /// </summary> /// <param name="mogAsset"></param> /// <param name="version"></param> /// <param name="pProperties"></param> /// <param name="failedString"></param> /// <returns></returns> public ListViewItem ItemAdd(MOG_Filename mogAsset, MOG_Properties pProperties, string failedString) { //MOG_Time assetTime = new MOG_Time(version); ListViewItem item = AddItemToListView(mogAsset, pProperties, ToString(mogAsset, pProperties, mogAsset.GetVersionTimeStamp()).GetEncodedFilename()); //item.SubItems[FindColumn("Failed Check")].Text = failedString; // Failed string return(item); }
/// <summary> /// Add a new asset to this listView /// </summary> public ListViewItem CreateListViewItem(ListView thisListView, MOG_Filename add, string status, MOG_Properties properties) { // Update the ListViewItem ListViewItem item = guiAssetManager.NewListViewItem(add, status, properties); // Add the item to the list view thisListView.Items.Add(item); return(item); }
public bool ToolExistsCheck(MOG_Filename mogAsset, string version, MOG_Project pProject, ref string failedString) { if (!Directory.Exists(MOG_ControllerRepository.GetAssetBlessedVersionPath(mogAsset, version).GetEncodedFilename())) { failedString = "Doesn't exist," + failedString; return(false); } return(true); }
/// Build a node within the confirm treeView of assets to confirm /// </summary> /// <param name="filename"></param> /// <param name="fullFilename"></param> private void BuildMogFilenameNode(MOG_Filename filename, string fullFilename, string label) { TreeNode node = MogUtil_ClassificationTrees.CreateAndExpandTreeNodeFullPath(ConfirmTreeView, null, this.LabelTreeDelimiter, label); if (node != null) { node.Tag = fullFilename; node.Checked = true; } }
/// <summary> /// Makes the selected assets the current version in the current branch /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void MakeCurrentMenuItem_Click(object sender, System.EventArgs e) { try { ArrayList selectedItems = ControlGetSelectedItems(); ArrayList assetFilenames = new ArrayList(); // Scan the list and prepare it for delivery to the DLL string message = ""; foreach (guiAssetTreeTag tag in selectedItems) { if (tag.Execute) { MOG_Filename filename = new MOG_Filename(tag.FullFilename); if (filename.GetFilenameType() == MOG_FILENAME_TYPE.MOG_FILENAME_Asset) { assetFilenames.Add(filename); } message = message + filename.GetAssetFullName() + "\n"; } } // Check if this request effects more than 1 asset?? if (selectedItems.Count > 1) { if (MOG_Prompt.PromptResponse("Are you sure you want to make all of these assets the current versions?", message, MOGPromptButtons.OKCancel) != MOGPromptResult.OK) { return; } } // Stamp all the specified assets if (MOG_ControllerProject.MakeAssetCurrentVersion(assetFilenames, "Made current by " + MOG_ControllerProject.GetUserName_DefaultAdmin())) { // Check if this request effects more than 1 asset?? if (selectedItems.Count > 1) { // Inform the user this may take a while MOG_Prompt.PromptResponse("Completed", "This change requires Slave processing.\n" + "The project will not reflect these changes until all slaves have finished processing the generated commands.\n" + "The progress of this task can be monitored in the Connections Tab."); } } else { MOG_Prompt.PromptMessage("Make Current Failed", "The system was unable to fully complete the task!", Environment.StackTrace); } } catch (Exception ex) { MOG_Report.ReportMessage("MakeCurrent Exception", ex.Message, ex.StackTrace, MOG.PROMPT.MOG_ALERT_LEVEL.CRITICAL); } }
/// <summary> SetAssetIcon /// Searches through mAssetTypes to find the matching key with /// that of the filename. Then returns the index /// </summary> /// <param name="filename"></param> /// <returns>index of icon in the mAssetTypeImages list</returns> static public int GetClassIconIndex(string filename, MOG_Properties properties) { // Construct a filename MOG_Filename file = null; try { file = new MOG_Filename(filename); } catch (Exception e) { e.ToString(); return(0); } string classification; switch (file.GetFilenameType()) { case MOG_FILENAME_TYPE.MOG_FILENAME_Asset: classification = file.GetAssetClassification(); break; case MOG_FILENAME_TYPE.MOG_FILENAME_Group: classification = "group"; break; default: classification = filename; break; } try { TstDictionaryEntry node = mAssetTypes.Find(classification); if (node != null && node.IsKey) { return((int)node.Value); } else { if (properties == null) { // If we didn't get anything, we need to load this icon into our array properties = new MOG_Properties(classification); } return(MogUtil_AssetIcons.LoadIcon(properties.ClassIcon, classification)); } } catch { return(0); } } // end ()