private void LoadSettings() { this.DisplayOptions = XMLUTILS.LoadDisplayOptionsSettings(); this.SetVolume(); this.SetProgress(); this.SetDiskIcon(); }
/// <summary> /// Write out the target link information /// </summary> /// <param name="target">The target for which to write link information</param> /// <param name="options">The link display options</param> /// <param name="writer">The write to which the information is written</param> public void WriteTarget(Target target, DisplayOptions options, XmlWriter writer) { if(target == null) throw new ArgumentNullException("target"); if(writer == null) throw new ArgumentNullException("writer"); NamespaceTarget space = target as NamespaceTarget; if(space != null) { WriteNamespaceTarget(space, writer); return; } TypeTarget type = target as TypeTarget; if(type != null) { WriteTypeTarget(type, options, writer); return; } MemberTarget member = target as MemberTarget; if(member != null) { WriteMemberTarget(member, options, writer); return; } if(target.Id.StartsWith("R:", StringComparison.OrdinalIgnoreCase)) { WriteInvalid(new InvalidReference(target.Id), writer); return; } throw new InvalidOperationException("Unknown target type"); }
private void WriteConstructor(ConstructorTarget constructor, DisplayOptions options, XmlWriter writer) { WriteType(constructor.ContainingType, options & ~DisplayOptions.ShowContainer, writer); if((options & DisplayOptions.ShowParameters) > 0) WriteMethodParameters(constructor.Parameters, writer); }
/// <summary> /// Write out a type target /// </summary> /// <param name="type">The type target information</param> /// <param name="options">The link display options</param> /// <param name="showOuterType">True to show the outer type, false if not</param> /// <param name="writer">The write to which the information is written</param> private void WriteTypeTarget(TypeTarget type, DisplayOptions options, bool showOuterType, XmlWriter writer) { // write namespace, if containers are requested if((options & DisplayOptions.ShowContainer) > 0) { WriteNamespace(type.ContainingNamespace, writer); WriteSeparator(writer); } // write outer type, if one exists if(showOuterType && (type.ContainingType != null)) { WriteSimpleType(type.ContainingType, DisplayOptions.Default, writer); WriteSeparator(writer); } // write the type name writer.WriteString(type.Name); // write if template parameters, if they exist and we are requested if((options & DisplayOptions.ShowTemplates) > 0) { WriteTemplateParameters(type.Templates, writer); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the SimpleRootSiteDataProviderVc class /// </summary> /// <param name="options"></param> /// ------------------------------------------------------------------------------------ public SimpleRootSiteDataProviderVc(DisplayOptions options) { m_displayOptions = options; }
public string GetDisplayString(DisplayOptions option) { switch (option) { case DisplayOptions.Message: if (!object.ReferenceEquals(this.lastUpdatedMessage, this.ValidationResult.Message)) { this.displayMessage = this.ValidationResult.Message.Replace("\n", " ").Replace("\r", ""); this.lastUpdatedMessage = this.ValidationResult.Message; } return(this.displayMessage); case DisplayOptions.Path: { var path = this.ProfileResult.Path; if (string.IsNullOrEmpty(path) && this.ProfileResult.Source is UnityEngine.Object) { var uObj = this.ProfileResult.Source as UnityEngine.Object; if (AssetDatabase.Contains(uObj.GetInstanceID())) { path = AssetDatabase.GetAssetPath(uObj.GetInstanceID()); } } return(path); } case DisplayOptions.PropertyPath: { return(this.ValidationResult.Path); } case DisplayOptions.Validator: return(this.ValidationResult.Setup.Validator == null ? "None" : this.ValidationResult.Setup.Validator.GetType().GetNiceName()); case DisplayOptions.Object: return(this.ProfileResult.Name); case DisplayOptions.Scene: return(this.SceneName); case DisplayOptions.Category: switch (this.ValidationResult.ResultType) { case ValidationResultType.Error: return("Error"); case ValidationResultType.Warning: return("Warning"); case ValidationResultType.Valid: case ValidationResultType.IgnoreResult: default: return(""); } default: return(""); } }
internal static void WriteSimpleMemberReference(SimpleMemberReference member, DisplayOptions options, XmlWriter writer, LinkTextResolver resolver) { string cer = member.Id; string typeCer, memberName, arguments; DecomposeMemberIdentifier(cer, out typeCer, out memberName, out arguments); if ((options & DisplayOptions.ShowContainer) > 0) { SimpleTypeReference type = CreateSimpleTypeReference(typeCer); WriteSimpleTypeReference(type, options & ~DisplayOptions.ShowContainer, writer); writer.WriteString("."); } // Change this so that we deal with EII names correctly, too writer.WriteString(memberName); if ((options & DisplayOptions.ShowParameters) > 0) { if (String.IsNullOrEmpty(arguments)) { Parameter[] parameters = new Parameter[0]; resolver.WriteMethodParameters(parameters, writer); } else { IList <string> parameterTypeCers = SeparateTypes(arguments); Parameter[] parameters = new Parameter[parameterTypeCers.Count]; for (int i = 0; i < parameterTypeCers.Count; i++) { TypeReference parameterType = CreateTypeReference(parameterTypeCers[i]); if (parameterType == null) { parameterType = new NamedTemplateTypeReference("UAT"); } parameters[i] = new Parameter(String.Empty, parameterType); } resolver.WriteMethodParameters(parameters, writer); } } }
private void WriteSimpleMember(SimpleMemberReference member, DisplayOptions options, XmlWriter writer) { WriteSimpleMember(member, options, writer, null); }
public DisplayOptionsViewModel(DisplayOptions displayOptions) : this() { DisplayOptions = displayOptions; }
/// <summary> /// Write out a simple type reference /// </summary> /// <param name="simple">The simple type reference information</param> /// <param name="options">The link display options</param> /// <param name="writer">The write to which the information is written</param> public void WriteSimpleType(SimpleTypeReference simple, DisplayOptions options, XmlWriter writer) { WriteSimpleType(simple, options, true, writer); }
/// <summary> /// Initializes a new instance of the <see cref="RootSiteDataProvider_MultiStringViewVc"/> class. /// </summary> /// <param name="sda"></param> /// <param name="options">The options.</param> /// <param name="wsOrder">a list of writing systems in the order the strings should show in the view</param> public RootSiteDataProvider_MultiStringViewVc(ISilDataAccess sda, DisplayOptions options, IList <int> wsOrder) : base(options, wsOrder) { }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the SimpleRootSiteDataProviderVc class /// </summary> /// <param name="options"></param> /// <param name="sda"></param> /// ------------------------------------------------------------------------------------ public RootSiteDataProviderVc(DisplayOptions options, ISilDataAccess sda) : base(options) { // DataAccess = sda; }
public void Start() { do { Console.WriteLine("\tEDIT CATEGORY\n"); Console.WriteLine("(1) Display all Categories"); Console.WriteLine("(2) Display a specific Category and its related Products"); Console.WriteLine("(3) Search for a specific category to edit (By the Category Name)"); Console.WriteLine("(4) Search for a specific category to edit (By the Category ID)"); Console.WriteLine("(5) Search for a specific category to edit (By the Category Description)"); Console.WriteLine("Press ESC to go back"); ConsoleKeyInfo keypress = Console.ReadKey(); Console.WriteLine(); NLogger logging = new NLogger(); DisplayOptions disOp = new DisplayOptions(); //Display all categories if (keypress.Key == ConsoleKey.D1 || keypress.Key == ConsoleKey.NumPad1) { disOp.DisplayAllCategories(); } //Display specific category and products else if (keypress.Key == ConsoleKey.D2 || keypress.Key == ConsoleKey.NumPad2) { NorthwindContext db = new NorthwindContext(); Console.WriteLine("Which category are you looking for (Name)?"); var results = db.SearchCategory(Console.ReadLine(), true); if (results.Count() == 0) { logging.Log("WARN", "No results found. Try Again."); } else { disOp.DisplayCategoryAndProducts(results.FirstOrDefault()); } } //Edit by Name else if (keypress.Key == ConsoleKey.D3 || keypress.Key == ConsoleKey.NumPad3) { NorthwindContext db = new NorthwindContext(); Console.WriteLine("What is the name of the category that you are looking for?"); string toFind = Console.ReadLine(); var results = db.SearchCategory(toFind, true); if (results.Count() == 0) { //logging.Log("WARN", "No results found. Try Again."); } else if (results.Count() == 1) { disOp.DisplayCategories(results); Console.WriteLine("Is this the correct Product?"); Console.WriteLine("If yes, Press Y. If No, Press N."); do { ConsoleKeyInfo keypress2 = Console.ReadKey(); Console.WriteLine(); if (keypress2.Key == ConsoleKey.Y) { EditCategory(results[0]); break; } else if (keypress2.Key == ConsoleKey.N) { break; } else { logging.Log("ERROR", "A valid key was not pressed. Please press (Y)es or (N)o."); } } while (true); } else { int row = 0; foreach (var category in results) { Console.WriteLine("Row: {0}", row++); disOp.DisplayCategory(category); Console.WriteLine(""); } Console.WriteLine("Which Category would you like to edit?"); Console.Write("Enter the Row number: \t"); string choice = Console.ReadLine(); int vInput = IntValidation(choice); EditCategory(results[vInput - 1]); } } //Edit by ID else if (keypress.Key == ConsoleKey.D4 || keypress.Key == ConsoleKey.NumPad4) { NorthwindContext db = new NorthwindContext(); Console.WriteLine("What is the ID of the category that you are looking for?"); int toFind = IntValidation(Console.ReadLine()); var results = db.SearchCategory(toFind); if (results.Count() == 0) { } else if (results.Count() == 1) { disOp.DisplayCategories(results); Console.WriteLine("Is this the correct Product?"); Console.WriteLine("If yes, Press Y. If No, Press N."); do { ConsoleKeyInfo keypress2 = Console.ReadKey(); Console.WriteLine(); if (keypress2.Key == ConsoleKey.Y) { EditCategory(results[0]); break; } else if (keypress2.Key == ConsoleKey.N) { break; } else { logging.Log("ERROR", "A valid key was not pressed. Please press (Y)es or (N)o."); } } while (true); } //Should never get used because ID is unique. If it does, something is terribly wrong with the database. else { int row = 0; foreach (var category in results) { Console.WriteLine("Row: {0}", row++); disOp.DisplayCategory(category); Console.WriteLine(""); } Console.WriteLine("Which Category would you like to edit?"); Console.Write("Enter the Row number: \t"); string choice = Console.ReadLine(); int vInput = IntValidation(choice); EditCategory(results[vInput - 1]); } } //Edit by description else if (keypress.Key == ConsoleKey.D5 || keypress.Key == ConsoleKey.NumPad5) { NorthwindContext db = new NorthwindContext(); Console.WriteLine("What is the Description of the category that you are looking for?"); string toFind = Console.ReadLine(); var results = db.SearchCategory(toFind, false); if (results.Count() == 0) { //logging.Log("WARN", "No results found. Try Again."); } else if (results.Count() == 1) { disOp.DisplayCategories(results); Console.WriteLine("Is this the correct Product?"); Console.WriteLine("If yes, Press Y. If No, Press N."); do { ConsoleKeyInfo keypress2 = Console.ReadKey(); Console.WriteLine(); if (keypress2.Key == ConsoleKey.Y) { EditCategory(results[0]); break; } else if (keypress2.Key == ConsoleKey.N) { break; } else { logging.Log("ERROR", "A valid key was not pressed. Please press (Y)es or (N)o."); } } while (true); } //Should never get used because ID is unique. If it does, something is terribly wrong with the database. else { int row = 0; foreach (var category in results) { Console.WriteLine("Row: {0}", row++); disOp.DisplayCategory(category); Console.WriteLine(""); } Console.WriteLine("Which Category would you like to edit?"); Console.Write("Enter the Row number: \t"); string choice = Console.ReadLine(); int vInput = IntValidation(choice); EditCategory(results[vInput - 1]); } } else if (keypress.Key == ConsoleKey.Escape) { break; } else { logging.Log("WARN", "Please press a valid option. Try again."); } } while (true); }
/// <summary> /// Main segmentation loop. Loops through the entire set of pixels to /// detect skin-like pixels. Then Removes noise and enhances the skin /// pixels using skinblobs and gets the contourPointss of the skin. Finally /// calculating the convex hull. /// Also changes colors of pixels in the texture for debug / visualisation /// purposes. /// </summary> /// <param name="texture"> Contains all the pixels of the image. </param> /// <param name="threshold"> /// Contains the color threshold to be considered a skin candidate. /// </param> /// <returns> Edited texture. </returns> public Color[] SegmentColors(WebCamTexture texture, float threshold, DisplayOptions OPTIONS) { // Get an array of pixels from the texture. var pixels = texture.GetPixels(); // First Loop : Segment and identify skin blobs. skinObjects = new List <SkinBlob>(); largestSkinObject = new SkinBlob(new Vector2()); int close = 0; for (var i = 0; i < pixels.Length; i++) { // Identify skin coloured pixels and add them to an object. // Threshold for skin color lowers if the pixel is close to a definite skin pixel. if (PixelThreshold(pixels[i], threshold) || (close > 0 && PixelThreshold(pixels[i], threshold / 2))) { CheckSkinObjects(Utility.IndexToPoint(texture.width, i)); close = closeThreshold; // Display options - Sets initital segmentation pixels to white if (OPTIONS.SHOW_SEGMENTATION_FIRST) { pixels[i] = Color.white; } } else { close--; // Display options - Sets other pixels to black if (OPTIONS.SHOW_SEGMENTATION_FIRST) { pixels[i] = Color.black; } } } // Second Loop : focus on largest skin blob, removing noise. Get contour list. // Contour list creates candidates for the convex hull. var contourPoints = new List <Vector2>(); // Linewidth dictates the longest uninterrupted line of skin pixels. var lineWidth = 0; var thisPixel = 0; // 0 black / 1 white. var lastPixel = 0; // 0 black / 1 white. for (var i = 0; i < pixels.Length; i++) { var pixelCoords = Utility.IndexToPoint(texture.width, i); // If within the skin objects min max boundries. // Also within an even more lenient threshold. if (pixelCoords.y < largestSkinObject.GetMaxPoint().y&& pixelCoords.y > largestSkinObject.GetMinPoint().y&& pixelCoords.x < largestSkinObject.GetMaxPoint().x&& pixelCoords.x > largestSkinObject.GetMinPoint().x&& PixelThreshold(pixels[i], threshold / 3)) { lineWidth++; thisPixel = 1; // Skin pixel // Calculates 'center of mass'. largestSkinObject.AddToMean(pixelCoords); // Display Options - Show pixels after second segmentaiton. if (OPTIONS.SHOW_SEGMENTATION_SECOND) { pixels[i] = Color.grey; } } else { // Send linewidth to the skin object and reset linewidth as // black pixel has been reached. largestSkinObject.TestWidth(lineWidth); lineWidth = 0; thisPixel = 0; // Black pixel. // Display Options - Show pixels after second segmentaiton. if (OPTIONS.SHOW_SEGMENTATION_SECOND) { pixels[i] = Color.black; } } // Get a "good enough" contour point list for convex hull calculations. // Checks if the previous pixel was classed differently, then if true, // adds the current pixel to a list of contour points. if (thisPixel != lastPixel) { contourPoints.Add(pixelCoords); } lastPixel = thisPixel; } // Calculate convex hull using contour points. var hullPoints = ConvexHull.GetConvexHull(contourPoints); fingertipPoints = GetFingertips(hullPoints); // Display Options - Set contour pixels to green if (OPTIONS.SHOW_CONTOUR) { contourPoints.ForEach(point => { pixels[Utility.PointToIndex(texture.width, point)] = Color.green; }); } // Return array of edited pixels for display. return(pixels); }
public void Start() { do { Console.WriteLine("\n\tDELETE PRODUCT\n"); Console.WriteLine("Delete which product?\n"); Console.WriteLine("(1) Find by ID"); Console.WriteLine("(2) Find by Name"); Console.WriteLine("(ESC) Return to Products menu"); var keypress = Console.ReadKey(); Console.WriteLine(""); NorthwindContext db = new NorthwindContext(); DisplayOptions disOp = new DisplayOptions(); List <Product> results = null; if (keypress.Key == ConsoleKey.D1 || keypress.Key == ConsoleKey.NumPad1) { Console.WriteLine("Please enter the ID of the product that you are searching for."); int search = IntValidation(Console.ReadLine()); results = db.SearchProducts(search); } else if (keypress.Key == ConsoleKey.D2 || keypress.Key == ConsoleKey.NumPad2) { Console.WriteLine("Please enter the Name of the product that you are searching for."); string search = Console.ReadLine(); results = db.SearchProducts(search); } else if (keypress.Key == ConsoleKey.Escape) { break; } else { NLogger logging = new NLogger(); logging.Log("ERROR", "A valid key was not pressed. Please press (Y)es or (N)o."); } if (results == null) { } else if (results.Count() == 0) { } else if (results.Count() == 1) { //disOp.DisplayProducts_Long(results); this.Delete(results[0]); } else { disOp.DisplayProducts_Short(results); Console.WriteLine("Which Product?"); Console.Write("Enter the Row number: \t"); string choice = Console.ReadLine(); int vInput = IntValidation(choice); this.Delete(results[vInput - 1]); } } while (true); }
private void WriteMemberTarget(MemberTarget target, DisplayOptions options, XmlWriter writer, Dictionary<IndexedTemplateTypeReference, TypeReference> dictionary) { if(target == null) throw new ArgumentNullException("target"); if(writer == null) throw new ArgumentNullException("writer"); MethodTarget method = target as MethodTarget; if((options & DisplayOptions.ShowContainer) > 0) { WriteType(target.ContainingType, options & ~DisplayOptions.ShowContainer, writer); if(method != null && method.IsConversionOperator) writer.WriteString(" "); else WriteSeparator(writer); } // special logic for writing methods if(method != null) { WriteMethod(method, options, writer, dictionary); return; } // special logic for writing properties PropertyTarget property = target as PropertyTarget; if(property != null) { WriteProperty(property, options, writer); return; } // special logic for writing constructors ConstructorTarget constructor = target as ConstructorTarget; if(constructor != null) { WriteConstructor(constructor, options, writer); return; } // special logic for writing events EventTarget trigger = target as EventTarget; if(trigger != null) { WriteEvent(trigger, writer); return; } // by default, just write name writer.WriteString(target.Name); }
private void WriteSpecialization(Specialization specialization, DisplayOptions options, XmlWriter writer) { // write the type itself (without outer types, because those will be written be other calls to this routine) WriteSimpleType(specialization.TemplateType, (options & ~DisplayOptions.ShowTemplates), false, writer); // then write the template arguments WriteTemplateArguments(specialization.Arguments, writer); }
/// <summary> /// Write out a type reference /// </summary> /// <param name="type">The type reference information</param> /// <param name="options">The link display options</param> /// <param name="writer">The write to which the information is written</param> public void WriteType(TypeReference type, DisplayOptions options, XmlWriter writer) { WriteType(type, options, writer, null); }
private void WriteTemplateType(TemplateTypeReference template, DisplayOptions options, XmlWriter writer, Dictionary<IndexedTemplateTypeReference, TypeReference> dictionary) { // if we have the name, just write it NamedTemplateTypeReference namedTemplate = template as NamedTemplateTypeReference; if(namedTemplate != null) { writer.WriteString(namedTemplate.Name); return; } IndexedTemplateTypeReference indexedTemplate = template as IndexedTemplateTypeReference; if(indexedTemplate != null) { if(dictionary != null && dictionary.ContainsKey(indexedTemplate)) WriteType(dictionary[indexedTemplate], options, writer); else writer.WriteString(GetTemplateName(indexedTemplate.TemplateId, indexedTemplate.Index)); return; } TypeTemplateTypeReference typeTemplate = template as TypeTemplateTypeReference; if(typeTemplate != null) { TypeReference value = null; if(dictionary != null) { IndexedTemplateTypeReference key = new IndexedTemplateTypeReference(typeTemplate.TemplateType.Id, typeTemplate.Position); if(dictionary.ContainsKey(key)) value = dictionary[key]; } if(value == null) writer.WriteString(GetTypeTemplateName(typeTemplate.TemplateType, typeTemplate.Position)); else WriteType(value, options, writer); return; } throw new InvalidOperationException("Unknown template type"); }
public ItemComparer(DisplayOptions option, bool ascending) { this.Option = option; this.Ascending = ascending; }
public async Task <IEnumerable <Models.Task> > GetAllTasksForTeamAsync(int teamId, DisplayOptions options) { var allTasks = await _taskRepository.GetAllAsync(); var allTasksForTean = allTasks.Where(x => x.TeamId == teamId); if (options.SortDirection == SortDirection.Ascending) { return(allTasksForTean.OrderBy(x => x.Name)); } else { return(allTasksForTean.OrderByDescending(x => x.Name)); } }
private void WritePointerType(PointerTypeReference pointer, DisplayOptions options, XmlWriter writer, Dictionary<IndexedTemplateTypeReference, TypeReference> dictionary) { WriteType(pointer.PointedToType, options, writer, dictionary); writer.WriteString("*"); }
private void DrawColumnHeaders() { Rect columnsRect = GUILayoutUtility.GetRect(0, this.Tree.Config.DefaultMenuStyle.Height, GUILayoutOptions.ExpandWidth(true)); EditorGUI.DrawRect(columnsRect, SirenixGUIStyles.DarkEditorBackground); //SirenixGUIStyles.Temporary.Draw(columnsRect, GUIContent.none, 0); int columnIndex = 0; float currentX = columnsRect.xMin; for (int i = 0; i < AllDisplayOptions.Length; i++) { DisplayOptions option = AllDisplayOptions[i]; if ((this.Display & option) == option) { float width = this.columns[columnIndex].ColWidth; Rect rect = new Rect(currentX, columnsRect.yMin + 3, width - 0.5f, columnsRect.height); rect.xMax = Math.Min(rect.xMax, columnsRect.xMax); if (rect.width <= 0) { break; } string labelText = option == DisplayOptions.Category ? "" : option.ToString(); if (GUI.Button(rect, GUIHelper.TempContent(labelText), SirenixGUIStyles.BoldLabel)) { if (this.SortBy == option) { this.SortAscending = !this.SortAscending; } else { this.SortBy = option; this.SortAscending = false; } this.shouldSort = true; } Rect iconRect = rect.AlignRight(rect.height).Padding(3).SubY(3); EditorIcon icon; if (this.SortBy != option) { icon = EditorIcons.TriangleRight; GUIHelper.PushColor(GUI.color * 0.7f); } else { icon = this.SortAscending ? EditorIcons.TriangleUp : EditorIcons.TriangleDown; } icon.Draw(iconRect); if (this.SortBy != option) { GUIHelper.PopColor(); } currentX += width; columnIndex++; } } SirenixEditorGUI.DrawHorizontalLineSeperator(columnsRect.xMin, columnsRect.yMax, columnsRect.width, 0.5f); }
/// <summary> /// Write out a member reference /// </summary> /// <param name="member">The member reference information</param> /// <param name="options">The link display options</param> /// <param name="writer">The write to which the information is written</param> public void WriteMember(MemberReference member, DisplayOptions options, XmlWriter writer) { if(member == null) throw new ArgumentNullException("member"); if(writer == null) throw new ArgumentNullException("writer"); SimpleMemberReference simple = member as SimpleMemberReference; if(simple != null) { WriteSimpleMember(simple, options, writer); return; } SpecializedMemberReference special = member as SpecializedMemberReference; if(special != null) { WriteSpecializedMember(special, options, writer); return; } SpecializedMemberWithParametersReference ugly = member as SpecializedMemberWithParametersReference; if(ugly != null) { WriteSpecializedMemberWithParameters(ugly, options, writer); return; } throw new InvalidOperationException("Unknown member reference type"); }
public ValidationInfoMenuItem(OdinMenuTree tree, ValidationResult validationResult, ValidationProfileResult profileResult, ResizableColumn[] columns, DisplayOptions displayOptions, int originalItemIndex) : base(tree, "", validationResult) { this.ValidationResult = validationResult; this.ProfileResult = profileResult; this.Columns = columns; this.DisplayOptions = displayOptions; this.OriginalItemIndex = originalItemIndex; if (this.ProfileResult.SourceRecoveryData is SceneValidationProfile.SceneAddress) { SceneValidationProfile.SceneAddress address = (SceneValidationProfile.SceneAddress) this.ProfileResult.SourceRecoveryData; SceneAsset sceneAsset = AssetDatabase.LoadAssetAtPath <SceneAsset>(address.ScenePath); this.SceneName = sceneAsset != null ? sceneAsset.name : ""; } else { this.SceneName = ""; } this.SearchString = string.Join(" ", AllDisplayOptions.Select(x => this.GetDisplayString(x)).ToArray()); }
private void WriteMethod(MethodTarget target, DisplayOptions options, XmlWriter writer, Dictionary<IndexedTemplateTypeReference, TypeReference> dictionary) { WriteProcedureName(target, writer); if((options & DisplayOptions.ShowTemplates) > 0) { // if this is a generic method, write any template params or args if(target.TemplateArgs != null && target.TemplateArgs.Count > 0) WriteTemplateArguments(target.TemplateArgs, writer); } if((options & DisplayOptions.ShowParameters) > 0) { if(target.IsConversionOperator) WriteConversionOperatorParameters(target.Parameters, target.ReturnType, writer, dictionary); else WriteMethodParameters(target.Parameters, writer, dictionary); } }
public override void DrawMenuItem(int indentLevel) { base.DrawMenuItem(indentLevel); if (!this.MenuItemIsBeingRendered || Event.current.type != EventType.Repaint) { return; } Rect totalRect = this.Rect; int columnIndex = 0; float currentX = totalRect.xMin; for (int i = 0; i < AllDisplayOptions.Length; i++) { DisplayOptions option = AllDisplayOptions[i]; if ((this.DisplayOptions & option) == option) { float width = this.Columns[columnIndex].ColWidth; Rect rect = new Rect(currentX, totalRect.yMin, width, totalRect.height); if (option == DisplayOptions.Category) { rect = rect.AlignCenter(16, 16); switch (this.ValidationResult.ResultType) { case ValidationResultType.Valid: GUIHelper.PushColor(Color.green); GUI.DrawTexture(rect, EditorIcons.Checkmark.Highlighted, ScaleMode.ScaleToFit); GUIHelper.PopColor(); break; case ValidationResultType.Error: GUI.DrawTexture(rect, EditorIcons.UnityErrorIcon, ScaleMode.ScaleToFit); break; case ValidationResultType.Warning: GUI.DrawTexture(rect, EditorIcons.UnityWarningIcon, ScaleMode.ScaleToFit); break; default: break; } } else { rect.y = this.LabelRect.y; rect.yMax = this.LabelRect.yMax; rect.x += 5; rect.width -= 10; GUIStyle labelStyle = this.IsSelected ? this.Style.SelectedLabelStyle : this.Style.DefaultLabelStyle; GUI.Label(rect, GUIHelper.TempContent(this.GetDisplayString(option)), labelStyle); } currentX += width; columnIndex++; } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the SimpleRootSiteDataProviderVc class /// </summary> /// <param name="options"></param> /// ------------------------------------------------------------------------------------ public SimpleRootSiteDataProvider_MultiStringViewVc(DisplayOptions options) { m_displayOptions = options; }
public void ResetSortingSettings() { this.SortBy = DisplayOptions.None; this.SortAscending = false; }
private void WriteProperty(PropertyTarget target, DisplayOptions options, XmlWriter writer) { WriteProcedureName(target, writer); if((options & DisplayOptions.ShowParameters) > 0) { IList<Parameter> parameters = target.Parameters; if(parameters.Count > 0) { writer.WriteStartElement("span"); writer.WriteAttributeString("class", "languageSpecificText"); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "cs"); writer.WriteString("["); writer.WriteEndElement(); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "vb"); writer.WriteString("("); writer.WriteEndElement(); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "cpp"); writer.WriteString("["); writer.WriteEndElement(); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "nu"); writer.WriteString("("); writer.WriteEndElement(); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "fs"); writer.WriteString(" "); writer.WriteEndElement(); writer.WriteEndElement(); // show parameters // we need to deal with type template substitutions! for(int i = 0; i < parameters.Count; i++) { if(i > 0) writer.WriteString(", "); WriteType(parameters[i].ParameterType, DisplayOptions.Default, writer); } writer.WriteStartElement("span"); writer.WriteAttributeString("class", "languageSpecificText"); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "cs"); writer.WriteString("]"); writer.WriteEndElement(); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "vb"); writer.WriteString(")"); writer.WriteEndElement(); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "cpp"); writer.WriteString("]"); writer.WriteEndElement(); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "nu"); writer.WriteString(")"); writer.WriteEndElement(); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "fs"); writer.WriteString(" "); writer.WriteEndElement(); writer.WriteEndElement(); } } }
public async Task <IActionResult> AllSprints(int teamId, DisplayOptions options) { List <Sprint> sprints; if (await _accessCheckService.OwnerOrMemberAsync(teamId)) { sprints = (List <Sprint>) await _manageSprintsService.GetAllSprintsAsync(teamId, options); } else { return(View("ErrorGetAllSprints")); } List <TeamMember> teamMembers = await GetAllTeamMembersAsync(teamId, new DisplayOptions { }); var sprintViewModel = new SprintAndTeamViewModel { Sprints = new List <SprintViewModel>() }; if (await _accessCheckService.IsOwnerAsync(teamId)) { sprintViewModel.IsOwner = true; } else { sprintViewModel.IsOwner = false; } sprints.OrderBy(s => s.Status).ToList().ForEach(t => sprintViewModel.Sprints.Add(new SprintViewModel() { Id = t.Id, DaysInSprint = t.DaysInSprint, Status = t.Status, Name = t.Name, StoryPointInHours = t.StoryPointInHours, TeamId = t.TeamId } )); if (sprintViewModel.Sprints.Count > 1 && sprintViewModel.Sprints[1].Status == PossibleStatuses.ActiveStatus) { var swapElem = sprintViewModel.Sprints[0]; sprintViewModel.Sprints[0] = sprintViewModel.Sprints[1]; sprintViewModel.Sprints[1] = swapElem; } var team = await _manageSprintsService.GetTeam(teamId); sprintViewModel.Team = new TeamViewModel() { Id = team.Id, Owner = team.Owner, TeamName = team.TeamName, TeamMembers = new List <TeamMemberViewModel>() }; teamMembers.ForEach(t => sprintViewModel.Team.TeamMembers.Add(new TeamMemberViewModel() { Member = t.Member, MemberId = t.MemberId })); return(View(sprintViewModel)); }
private void WriteSpecializedMemberWithParameters(SpecializedMemberWithParametersReference ugly, DisplayOptions options, XmlWriter writer) { if((options & DisplayOptions.ShowContainer) > 0) { WriteSpecializedType(ugly.SpecializedType, options & ~DisplayOptions.ShowContainer, writer); WriteSeparator(writer); } writer.WriteString(ugly.MemberName); if((options & DisplayOptions.ShowParameters) > 0) { writer.WriteString("("); IList<TypeReference> parameterTypes = ugly.ParameterTypes; for(int i = 0; i < parameterTypes.Count; i++) { if(i > 0) writer.WriteString(", "); WriteType(parameterTypes[i], DisplayOptions.Default, writer); } writer.WriteString(")"); } }
public static void Display(DisplayOptions options) { _currentOptions = options; AlertExternMethods.UnityDisplayAlertDialog(options.title, options.message, options.positiveButtonTitle, options.negativeButtonTitle, options.neutralButtonTitle); }
/// <summary> /// Write out a member target /// </summary> /// <param name="target">The member target information</param> /// <param name="options">The link display options</param> /// <param name="writer">The write to which the information is written</param> public void WriteMemberTarget(MemberTarget target, DisplayOptions options, XmlWriter writer) { WriteMemberTarget(target, options, writer, null); }
/// <inheritdoc /> public async Task <CloudFlareResult <IReadOnlyList <Membership> > > GetAsync(MembershipFilter filter = null, DisplayOptions displayOptions = null, CancellationToken cancellationToken = default) { var builder = new ParameterBuilderHelper(); builder .InsertValue(Filtering.Status, filter?.Status) .InsertValue(Filtering.AccountName, filter?.AccountName) .InsertValue(Filtering.Order, filter?.MembershipOrder) .InsertValue(Filtering.Page, displayOptions?.Page) .InsertValue(Filtering.PerPage, displayOptions?.PerPage) .InsertValue(Filtering.Direction, displayOptions?.Order); var requestUri = $"{MembershipEndpoints.Base}"; if (builder.ParameterCollection.HasKeys()) { requestUri = $"{requestUri}/?{builder.ParameterCollection}"; } return(await Connection.GetAsync <IReadOnlyList <Membership> >(requestUri, cancellationToken).ConfigureAwait(false)); }
/// <summary> /// Write out a reference /// </summary> /// <param name="reference">The reference information</param> /// <param name="options">The link display options</param> /// <param name="writer">The write to which the information is written</param> public void WriteReference(Reference reference, DisplayOptions options, XmlWriter writer) { if(reference == null) throw new ArgumentNullException("reference"); if(writer == null) throw new ArgumentNullException("writer"); NamespaceReference space = reference as NamespaceReference; if(space != null) { WriteNamespace(space, writer); return; } TypeReference type = reference as TypeReference; if(type != null) { WriteType(type, options, writer); return; } MemberReference member = reference as MemberReference; if(member != null) { WriteMember(member, options, writer); return; } ExtensionMethodReference extMethod = reference as ExtensionMethodReference; if(extMethod != null) { WriteExtensionMethod(extMethod, options, writer); return; } InvalidReference invalid = reference as InvalidReference; if(invalid != null) { WriteInvalid(invalid, writer); return; } throw new InvalidOperationException("Unknown target type"); }
public static void SetDisplayOption(Image obj, DisplayOptions value) { obj.SetValue(DisplayOptionProperty, value); }
/// <summary> /// Write out a type reference /// </summary> /// <param name="type">The type reference information</param> /// <param name="options">The link display options</param> /// <param name="writer">The write to which the information is written</param> /// <param name="dictionary">The template type dictionary</param> private void WriteType(TypeReference type, DisplayOptions options, XmlWriter writer, Dictionary<IndexedTemplateTypeReference, TypeReference> dictionary) { if(type == null) throw new ArgumentNullException("type"); if(writer == null) throw new ArgumentNullException("writer"); SimpleTypeReference simple = type as SimpleTypeReference; if(simple != null) { WriteSimpleType(simple, options, writer); return; } SpecializedTypeReference specialized = type as SpecializedTypeReference; if(specialized != null) { WriteSpecializedType(specialized, options, writer); return; } ArrayTypeReference array = type as ArrayTypeReference; if(array != null) { WriteArrayType(array, options, writer, dictionary); return; } ReferenceTypeReference reference = type as ReferenceTypeReference; if(reference != null) { WriteReferenceType(reference, options, writer, dictionary); return; } PointerTypeReference pointer = type as PointerTypeReference; if(pointer != null) { WritePointerType(pointer, options, writer, dictionary); return; } TemplateTypeReference template = type as TemplateTypeReference; if(template != null) { WriteTemplateType(template, options, writer, dictionary); return; } throw new InvalidOperationException("Unknown type reference type"); }
public PreviewControllerHelper(IContentLoader contentLoader, TemplateResolver templateResolver, DisplayOptions displayOptions, HttpContextBase httpContext) { _contentLoader = contentLoader; _templateResolver = templateResolver; _displayOptions = displayOptions; _httpContext = httpContext; }
private void WriteSimpleType(SimpleTypeReference simple, DisplayOptions options, bool showOuterType, XmlWriter writer) { TypeTarget type = targets[simple.Id] as TypeTarget; if(type != null) { WriteTypeTarget(type, options, showOuterType, writer); } else { TextReferenceUtilities.WriteSimpleTypeReference(simple, options, writer); } }
/// <summary> /// Changes resolution of all elements in the game - just calls ResolutionChanged method of all elements in the game. /// </summary> /// <param name="newResolution">Value of resolution after change.</param> public static void ResolutionChanged(Vector2 newResolution) { DisplayOptions.ActualiseResolution(newResolution); MenuScreenManager.ResolutionChanged(); }
private void WriteSpecializedType(SpecializedTypeReference special, DisplayOptions options, XmlWriter writer) { IList<Specialization> specializations = special.Specializations; for(int i = 0; i < specializations.Count; i++) if(i == 0) WriteSpecialization(specializations[0], options, writer); else { WriteSeparator(writer); WriteSpecialization(specializations[i], options & ~DisplayOptions.ShowContainer, writer); } }
public void Start() { do { Console.WriteLine("\n\tDISPLAY CATEGORIES\n"); Console.WriteLine("(1) Display all Categories"); Console.WriteLine("(2) Display a Category with all related products"); Console.WriteLine("Press ESC to go back"); var keypress = Console.ReadKey(); Console.WriteLine(""); DisplayOptions disOp = new DisplayOptions(); //Display all categories if (keypress.Key == ConsoleKey.D1 || keypress.Key == ConsoleKey.NumPad1) { disOp.DisplayAllCategories(); } else if (keypress.Key == ConsoleKey.D2 || keypress.Key == ConsoleKey.NumPad2) { Console.WriteLine("What Category are you looking for? \n"); Console.WriteLine("(1) Search by ID"); Console.WriteLine("(2) Search by Name"); Console.WriteLine("(3) Search by Description"); var keypress2 = Console.ReadKey(); Console.WriteLine(""); Category choice = null; List <Category> results = null; if (keypress2.Key == ConsoleKey.D1 || keypress2.Key == ConsoleKey.NumPad1) { Console.WriteLine("What is the ID of the Category you want to display?"); int toFind = IntValidation(Console.ReadLine()); results = db.SearchCategory(toFind).ToList(); } else if (keypress2.Key == ConsoleKey.D2 || keypress2.Key == ConsoleKey.NumPad2) { Console.WriteLine("What is the Name of the Category you want to display?"); string toFind = Console.ReadLine(); results = db.SearchCategory(toFind, true).ToList(); } else if (keypress2.Key == ConsoleKey.D3 || keypress2.Key == ConsoleKey.NumPad3) { Console.WriteLine("What is the Description of the Category you want to display?"); string toFind = Console.ReadLine(); results = db.SearchCategory(toFind, false).ToList(); } else { logging.Log("WARN", "Please press a valid option. Try again."); } if (results == null) { } else if (results.Count == 0) { } else if (results.Count == 1) { disOp.DisplayCategory(results[0]); choice = results[0]; } else { int row = 0; foreach (var category in results) { Console.WriteLine("Row: {0}", row++); disOp.DisplayCategory(category); Console.WriteLine(""); } Console.WriteLine("Which Category would you like to display?"); Console.Write("Enter the Row number: \t"); string rowChoice = Console.ReadLine(); int vInput = IntValidation(rowChoice); choice = results[vInput - 1]; } if (results.Count > 0) { Console.WriteLine("(1) Display all Products"); Console.WriteLine("(2) Display only active Products"); Console.WriteLine("(3) Display only discontinued Products"); var keypress3 = Console.ReadKey(); Console.WriteLine(""); if (choice == null) { } else if (keypress3.Key == ConsoleKey.D1 || keypress3.Key == ConsoleKey.NumPad1) { disOp.DisplayCategoryAndProducts(choice); } else if (keypress3.Key == ConsoleKey.D2 || keypress3.Key == ConsoleKey.NumPad2) { disOp.DisplayCategoryAndActiveProducts(choice); } else if (keypress3.Key == ConsoleKey.D3 || keypress3.Key == ConsoleKey.NumPad3) { disOp.DisplayCategoryAndDiscontinuedProducts(choice); } else { logging.Log("WARN", "Please press a valid option. Try again."); } } } else if (keypress.Key == ConsoleKey.Escape) { break; } else { logging.Log("WARN", "Please press a valid option. Try again."); } } while (true); }
private void WriteArrayType(ArrayTypeReference reference, DisplayOptions options, XmlWriter writer, Dictionary<IndexedTemplateTypeReference, TypeReference> dictionary) { writer.WriteStartElement("span"); writer.WriteAttributeString("class", "languageSpecificText"); // C++ array notation (left) writer.WriteStartElement("span"); writer.WriteAttributeString("class", "cpp"); writer.WriteString("array<"); writer.WriteEndElement(); writer.WriteEndElement(); // end of <span class="languageSpecificText"> element // the underlying type WriteType(reference.ElementType, options, writer, dictionary); // C++ array notation (right) writer.WriteStartElement("span"); writer.WriteAttributeString("class", "languageSpecificText"); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "cpp"); if(reference.Rank > 1) writer.WriteString("," + reference.Rank.ToString(CultureInfo.InvariantCulture)); writer.WriteString(">"); writer.WriteEndElement(); // C# array notation writer.WriteStartElement("span"); writer.WriteAttributeString("class", "cs"); writer.WriteString("["); for(int i = 1; i < reference.Rank; i++) writer.WriteString(","); writer.WriteString("]"); writer.WriteEndElement(); // VB array notation writer.WriteStartElement("span"); writer.WriteAttributeString("class", "vb"); writer.WriteString("("); for(int i = 1; i < reference.Rank; i++) writer.WriteString(","); writer.WriteString(")"); writer.WriteEndElement(); // neutral array notation writer.WriteStartElement("span"); writer.WriteAttributeString("class", "nu"); writer.WriteString("["); for(int i = 1; i < reference.Rank; i++) writer.WriteString(","); writer.WriteString("]"); writer.WriteEndElement(); // F# array notation writer.WriteStartElement("span"); writer.WriteAttributeString("class", "fs"); writer.WriteString("["); for(int i = 1; i < reference.Rank; i++) writer.WriteString(","); writer.WriteString("]"); writer.WriteEndElement(); writer.WriteEndElement(); // end of <span class="languageSpecificText"> element }
public PreviewController(IContentLoader contentLoader, TemplateResolver templateResolver, DisplayOptions displayOptions) { _contentLoader = contentLoader; _templateResolver = templateResolver; _displayOptions = displayOptions; }
private void WriteReferenceType(ReferenceTypeReference reference, DisplayOptions options, XmlWriter writer, Dictionary<IndexedTemplateTypeReference, TypeReference> dictionary) { WriteType(reference.ReferredToType, options, writer, dictionary); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "languageSpecificText"); // add % in C++ writer.WriteStartElement("span"); writer.WriteAttributeString("class", "cpp"); writer.WriteString("%"); writer.WriteEndElement(); writer.WriteEndElement(); }
/// <inheritdoc /> public override void Apply(XmlDocument document, string key) { Target target = null, keyTarget; string msdnUrl = null; foreach (XPathNavigator linkNode in document.CreateNavigator().Select(referenceLinkExpression).ToArray()) { // Extract link information ReferenceLinkInfo link = new ReferenceLinkInfo(linkNode); // Determine target, link type, and display options string targetId = link.Target; DisplayOptions options = link.DisplayOptions; ReferenceLinkType type = ReferenceLinkType.None; if (String.IsNullOrWhiteSpace(targetId)) { this.WriteMessage(key, MessageLevel.Warn, "The target attribute is missing or has no " + "value. You have most likely omitted a cref attribute or left it blank on an XML " + "comments element such as see, seealso, or exception."); continue; } bool targetFound = targets.TryGetValue(targetId, out target, out type); // If not found and it starts with "System." or "Microsoft." we'll go with the assumption that // it's part of a Microsoft class library that is not part of the core framework but does have // documentation available on MSDN. Worst case it doesn't and we get an unresolved link warning // instead of an unknown reference target warning. if (!targetFound && ((targetId.Length > 9 && targetId.Substring(2).StartsWith("System.", StringComparison.Ordinal)) || (targetId.Length > 12 && targetId.Substring(2).StartsWith( "Microsoft.", StringComparison.Ordinal)))) { // Use the same link type as a core framework class targetFound = targets.TryGetValue("T:System.Object", out target, out type); // We don't have a target in this case so links to overloads pages won't work. Also note // that the link text will be generated from the ID which shouldn't make much of a difference // in most cases. If either case is an issue, the Additional Reference Links SHFB plug-in // can be used to generate valid link target data. target = null; } if (!targetFound) { // If not being rendered as a link, don't report a warning if (link.RenderAsLink && targetId != key) { base.WriteMessage(key, MessageLevel.Warn, "Unknown reference link target '{0}'.", targetId); } // !EFW - Turn off the Show Parameters option for unresolved elements except methods. If // not, it outputs an empty "()" after the member name which looks odd. if (targetId[0] != 'M') { options &= ~DisplayOptions.ShowParameters; } } else { // If overload is preferred and found, change targetId and make link options hide parameters if (link.PreferOverload && target != null) { bool isConversionOperator = false; MethodTarget method = target as MethodTarget; if (method != null) { isConversionOperator = method.IsConversionOperator; } MemberTarget member = target as MemberTarget; // If conversion operator is found, always link to individual topic if (member != null && !String.IsNullOrEmpty(member.OverloadId) && !isConversionOperator) { Target overloadTarget = targets[member.OverloadId]; if (overloadTarget != null) { target = overloadTarget; targetId = overloadTarget.Id; } } // If individual conversion operator is found, always display parameters if (isConversionOperator && member != null && !String.IsNullOrEmpty(member.OverloadId)) { options = options | DisplayOptions.ShowParameters; } else { options = options & ~DisplayOptions.ShowParameters; } } // If link type is Local or Index, determine which if (type == ReferenceLinkType.LocalOrIndex) { if (targets.TryGetValue(key, out keyTarget) && target != null && target.Container == keyTarget.Container) { type = ReferenceLinkType.Local; } else { type = ReferenceLinkType.Index; } } } // Suppress the link if so requested. Links to this page are not live. if (!link.RenderAsLink) { type = ReferenceLinkType.None; } else if (targetId == key) { type = ReferenceLinkType.Self; } else if (target != null && targets.TryGetValue(key, out keyTarget) && target.File == keyTarget.File) { type = ReferenceLinkType.Self; } // !EFW - Redirect enumeration fields to the containing enumerated type so that we // get a valid link target. Enum fields don't have a topic to themselves. if (type != ReferenceLinkType.None && type != ReferenceLinkType.Self && type != ReferenceLinkType.Local && targetId.StartsWith("F:", StringComparison.OrdinalIgnoreCase)) { MemberTarget member = target as MemberTarget; if (member != null) { SimpleTypeReference typeRef = member.ContainingType as SimpleTypeReference; if (typeRef != null && targets[typeRef.Id] is EnumerationTarget) { targetId = typeRef.Id; } } } // Get MSDN endpoint if needed if (type == ReferenceLinkType.Msdn) { if (msdnResolver != null && !msdnResolver.IsDisabled) { msdnUrl = msdnResolver.GetMsdnUrl(targetId); if (String.IsNullOrEmpty(msdnUrl)) { // If the web service failed, report the reason if (msdnResolver.IsDisabled) { base.WriteMessage(key, MessageLevel.Warn, "MSDN web service failed. No " + "further look ups will be performed for this build.\r\nReason: {0}", msdnResolver.DisabledReason); } else { base.WriteMessage(key, MessageLevel.Warn, "MSDN URL not found for target '{0}'.", targetId); } type = ReferenceLinkType.None; } } else { type = ReferenceLinkType.None; } } // Write opening link tag and target info XmlWriter writer = linkNode.InsertAfter(); switch (type) { case ReferenceLinkType.None: writer.WriteStartElement("span"); // If the link was intentionally suppressed, write it out as an identifier (i.e. links // in the syntax section). if (link.RenderAsLink) { writer.WriteAttributeString("class", "nolink"); } else { writer.WriteAttributeString("class", "identifier"); } break; case ReferenceLinkType.Self: writer.WriteStartElement("span"); writer.WriteAttributeString("class", "selflink"); break; case ReferenceLinkType.Local: // Format link with prefix and/or postfix string href = String.Format(CultureInfo.InvariantCulture, hrefFormat, target.File); // Make link relative, if we have a baseUrl if (baseUrl != null) { href = href.GetRelativePath(document.EvalXPathExpr(baseUrl, "key", key)); } writer.WriteStartElement("a"); writer.WriteAttributeString("href", href); break; case ReferenceLinkType.Index: writer.WriteStartElement("MSHelp", "link", "http://msdn.microsoft.com/mshelp"); writer.WriteAttributeString("keywords", targetId); writer.WriteAttributeString("tabindex", "0"); break; case ReferenceLinkType.Msdn: writer.WriteStartElement("a"); writer.WriteAttributeString("href", msdnUrl); writer.WriteAttributeString("target", linkTarget); break; case ReferenceLinkType.Id: writer.WriteStartElement("a"); writer.WriteAttributeString("href", ("ms-xhelp:///?Id=" + targetId).Replace("#", "%23")); break; } // Write the link text if (String.IsNullOrEmpty(link.DisplayTarget)) { if (link.Contents == null) { if (target != null) { resolver.WriteTarget(target, options, writer); } else { Reference reference = TextReferenceUtilities.CreateReference(targetId); if (reference is InvalidReference) { base.WriteMessage(key, MessageLevel.Warn, "Invalid reference link target '{0}'.", targetId); } resolver.WriteReference(reference, options, writer); } } else { do { link.Contents.WriteSubtree(writer); } while(link.Contents.MoveToNext()); } } else { if (link.DisplayTarget.Equals("content", StringComparison.OrdinalIgnoreCase) && link.Contents != null) { // Use the contents as an XML representation of the display target Reference reference = XmlTargetDictionaryUtilities.CreateReference(link.Contents); resolver.WriteReference(reference, options, writer); } if (link.DisplayTarget.Equals("format", StringComparison.OrdinalIgnoreCase) && link.Contents != null) { // Use the contents as a format string for the display target string format = link.Contents.OuterXml; string input = null; using (StringWriter textStore = new StringWriter(CultureInfo.InvariantCulture)) { XmlWriterSettings settings = new XmlWriterSettings(); settings.ConformanceLevel = ConformanceLevel.Fragment; using (XmlWriter xmlStore = XmlWriter.Create(textStore, settings)) { if (target != null) { resolver.WriteTarget(target, options, xmlStore); } else { Reference reference = TextReferenceUtilities.CreateReference(targetId); resolver.WriteReference(reference, options, xmlStore); } } input = textStore.ToString(); } string output = String.Format(CultureInfo.InvariantCulture, format, input); XmlDocumentFragment fragment = document.CreateDocumentFragment(); fragment.InnerXml = output; fragment.WriteTo(writer); } else if (link.DisplayTarget.Equals("extension", StringComparison.OrdinalIgnoreCase) && link.Contents != null) { Reference extMethodReference = XmlTargetDictionaryUtilities.CreateExtensionMethodReference(link.Contents); resolver.WriteReference(extMethodReference, options, writer); } else { // Use the display target value as a CER for the display target TextReferenceUtilities.SetGenericContext(key); Reference reference = TextReferenceUtilities.CreateReference(link.DisplayTarget); resolver.WriteReference(reference, options, writer); } } // Write the closing link tag writer.WriteEndElement(); writer.Close(); // Delete the original tag linkNode.DeleteSelf(); } }
/// <summary> /// Write out an extension method reference /// </summary> /// <param name="extMethod">The extension method reference information</param> /// <param name="options">The link display options</param> /// <param name="writer">The write to which the information is written</param> public void WriteExtensionMethod(ExtensionMethodReference extMethod, DisplayOptions options, XmlWriter writer) { if(extMethod == null) throw new ArgumentNullException("extMethod"); if(writer == null) throw new ArgumentNullException("writer"); // write the unqualified method name writer.WriteString(extMethod.Name); // if this is a generic method, write any template params or args if(extMethod.TemplateArgs != null && extMethod.TemplateArgs.Count > 0) WriteTemplateArguments(extMethod.TemplateArgs, writer); // write parameters if((options & DisplayOptions.ShowParameters) > 0) WriteMethodParameters(extMethod.Parameters, writer); }
BrExLayout IPlasticAPI.GetBranchExplorerLayout(WorkspaceInfo wkInfo, RepositorySpec repSpec, FilterCollection filters, DisplayOptions options, out BrExTree explorerTree) { throw new NotImplementedException(); }
private void WriteSpecializedMember(SpecializedMemberReference member, DisplayOptions options, XmlWriter writer) { if((options & DisplayOptions.ShowContainer) > 0) { WriteType(member.SpecializedType, options & ~DisplayOptions.ShowContainer, writer); WriteSeparator(writer); } WriteSimpleMember(member.TemplateMember, options & ~DisplayOptions.ShowContainer, writer, member.SpecializedType.SpecializationDictionary); }
BrExLayout IPlasticAPI.GetBranchExplorerLayout(WorkspaceInfo wkInfo, RepositoryExplainMergeData explainMergeData, DisplayOptions displayOptions, out BrExTree explorerTree) { throw new NotImplementedException(); }
private void WriteSimpleMember(SimpleMemberReference member, DisplayOptions options, XmlWriter writer, Dictionary<IndexedTemplateTypeReference, TypeReference> dictionary) { MemberTarget target = targets[member.Id] as MemberTarget; if(target != null) WriteMemberTarget(target, options, writer, dictionary); else TextReferenceUtilities.WriteSimpleMemberReference(member, options, writer, this); }
BrExLayout IPlasticAPI.GetBranchExplorerLayout(RepositorySpec repSpec, BrExTree explorerTree, DisplayOptions options) { throw new NotImplementedException(); }
private ImageSource GetBitmapSource(LoadImageRequest loadTask, DisplayOptions loadType) { Image image = loadTask.Image; string source = loadTask.Source; ImageSource imageSource = null; if (!string.IsNullOrWhiteSpace(source)) { Stream imageStream = null; SourceType sourceType = SourceType.LocalDisk; image.Dispatcher.Invoke(new ThreadStart(delegate { sourceType = Loader.GetSourceType(image); })); try { if (loadTask.Stream == null) { ILoader loader = LoaderFactory.CreateLoader(sourceType); imageStream = loader.Load(source); loadTask.Stream = imageStream; } else { imageStream = new MemoryStream(); loadTask.Stream.Position = 0; loadTask.Stream.CopyTo(imageStream); imageStream.Position = 0; } } catch (Exception) { } if (imageStream != null) { try { if (loadType == DisplayOptions.Preview) { BitmapFrame bitmapFrame = BitmapFrame.Create(imageStream); imageSource = bitmapFrame.Thumbnail; if (imageSource == null) // Preview it is not embedded into the file { // we'll make a thumbnail image then ... (too bad as the pre-created one is FAST!) TransformedBitmap thumbnail = new TransformedBitmap(); thumbnail.BeginInit(); thumbnail.Source = bitmapFrame as BitmapSource; // we'll make a reasonable sized thumnbail with a height of 240 int pixelH = bitmapFrame.PixelHeight; int pixelW = bitmapFrame.PixelWidth; int decodeH = 240; int decodeW = (bitmapFrame.PixelWidth * decodeH) / pixelH; double scaleX = decodeW / (double)pixelW; double scaleY = decodeH / (double)pixelH; TransformGroup transformGroup = new TransformGroup(); transformGroup.Children.Add(new ScaleTransform(scaleX, scaleY)); thumbnail.Transform = transformGroup; thumbnail.EndInit(); // this will disconnect the stream from the image completely ... WriteableBitmap writable = new WriteableBitmap(thumbnail); writable.Freeze(); imageSource = writable; } } else if (loadType == DisplayOptions.FullResolution) { BitmapImage bitmapImage = new BitmapImage(); bitmapImage.BeginInit(); bitmapImage.StreamSource = imageStream; bitmapImage.EndInit(); imageSource = bitmapImage; } } catch (Exception) { } } if (imageSource == null) { image.Dispatcher.BeginInvoke(new ThreadStart(delegate { Loader.SetErrorDetected(image, true); })); } else { imageSource.Freeze(); image.Dispatcher.BeginInvoke(new ThreadStart(delegate { Loader.SetErrorDetected(image, false); })); } } else { image.Dispatcher.BeginInvoke(new ThreadStart(delegate { Loader.SetErrorDetected(image, false); })); } return imageSource; }
private void WriteProperty(PropertyTarget target, DisplayOptions options, XmlWriter writer) { WriteProcedureName(target, writer); if ((options & DisplayOptions.ShowParameters) > 0) { IList <Parameter> parameters = target.Parameters; if (parameters.Count > 0) { writer.WriteStartElement("span"); writer.WriteAttributeString("class", "languageSpecificText"); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "cs"); writer.WriteString("["); writer.WriteEndElement(); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "vb"); writer.WriteString("("); writer.WriteEndElement(); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "cpp"); writer.WriteString("["); writer.WriteEndElement(); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "nu"); writer.WriteString("("); writer.WriteEndElement(); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "fs"); writer.WriteString(" "); writer.WriteEndElement(); writer.WriteEndElement(); // show parameters // we need to deal with type template substitutions! for (int i = 0; i < parameters.Count; i++) { if (i > 0) { writer.WriteString(", "); } WriteType(parameters[i].ParameterType, DisplayOptions.Default, writer); } writer.WriteStartElement("span"); writer.WriteAttributeString("class", "languageSpecificText"); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "cs"); writer.WriteString("]"); writer.WriteEndElement(); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "vb"); writer.WriteString(")"); writer.WriteEndElement(); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "cpp"); writer.WriteString("]"); writer.WriteEndElement(); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "nu"); writer.WriteString(")"); writer.WriteEndElement(); writer.WriteStartElement("span"); writer.WriteAttributeString("class", "fs"); writer.WriteString(" "); writer.WriteEndElement(); writer.WriteEndElement(); } } }
protected void ShowForm(DisplayOptions options) { Visible = true; ReadOnlyView = options.ReadOnlyView; if (!IsHandleCreated) { // making a selection should help us get a handle created, if it's not already try { RootBox.MakeSimpleSel(true, true, false, true); } catch (COMException) { // We ignore failures since the text window may be empty, in which case making a // selection is impossible. } } else { CallLayout(); } AutoScrollPosition = new Point(0, 0); }
/// <summary> /// Initializes a new instance of the <see cref="SimpleRootSiteDataProvider_MultiStringViewVc"/> class. /// </summary> /// <param name="options">The options.</param> /// <param name="wsOrder">a list of writing systems in the order the strings should show in the view</param> public SimpleRootSiteDataProvider_MultiStringViewVc(DisplayOptions options, IList<int> wsOrder) : this(options) { WsOrder = wsOrder; }
public string GenerateLink(LinkType type, int clientId, IEnumerable <int> groupIds, string redirectUri, DisplayOptions display, GroupPermissions scope, string state) { var sb = new StringBuilder($"https://oauth.vk.com/authorize?client_id={clientId}"); var uri = string.IsNullOrWhiteSpace(redirectUri) ? "https://oauth.vk.com/blank.html" : redirectUri; sb.Append($"&group_ids={string.Join(",", groupIds)}"); sb.Append($"&scope={scope:D}"); sb.Append($"&response_type={type.ToString().ToLower()}"); sb.Append($"&v={RequestSettings.ApiVersion}"); sb.Append($"&redirect_uri={uri}"); if (display != DisplayOptions.Default) { sb.Append($"&display={display.ToString().ToLower()}"); } if (!string.IsNullOrWhiteSpace(state)) { sb.Append($"&state={state}"); } return(sb.ToString()); }