public CommentNode(int col, int line, string value, CommentType type) { this.col = col; this.line = line; Value = value; Type = type; }
//主线程中在窗口打印日志信息 private void LogCommentM(CommentType commentType, string comment) { string mark = null; ItemType itemType = ItemType.Error; if (commentType == CommentType.Info) { mark = "消息"; itemType = ItemType.Info; } else if (commentType == CommentType.Warn) { mark = "警告"; itemType = ItemType.Warn; } else if (commentType == CommentType.Error) { mark = "错误"; itemType = ItemType.Error; } string message = String.Format("{0} [{1}] {2}", DateTime.Now.ToString(), mark, comment); SListBoxItem item = new SListBoxItem(message, itemType); //添加滚动效果,在添加记录前,先计算滚动条是否在底部,从而决定添加后是否自动滚动 bool scoll = false; if (logsBox.TopIndex == logsBox.Items.Count - (int)(logsBox.Height / logsBox.ItemHeight)) scoll = true; //添加记录 logsBox.Items.Add(item); //滚动到底部 if (scoll) logsBox.TopIndex = logsBox.Items.Count - (int)(logsBox.Height / logsBox.ItemHeight); }
public override CommentCollection GetLastestCommentsForSomeone(int targetUserID, CommentType type, int top) { using (SqlQuery query = new SqlQuery()) { string getTargetNameSql = null; switch (type) { case CommentType.Blog: getTargetNameSql = "(SELECT [Subject] FROM [bx_BlogArticles] WHERE [ArticleID]=TargetID) AS [TargetName] "; break; case CommentType.Photo: getTargetNameSql = "(SELECT [Name] FROM [bx_Photos] WHERE [PhotoID]=TargetID) AS [TargetName] "; break; default: getTargetNameSql = string.Empty; break; } query.CommandText = "SELECT TOP (@TopCount) *, " + getTargetNameSql + " FROM bx_Comments WHERE [TargetUserID]=@TargetUserID AND [Type]=@Type ORDER BY [CommentID] DESC"; query.CommandType = CommandType.Text; query.CreateParameter<int>("@TargetUserID", targetUserID, SqlDbType.Int); query.CreateParameter<CommentType>("@Type", type, SqlDbType.TinyInt); query.CreateTopParameter("@TopCount", top); using (XSqlDataReader reader = query.ExecuteReader()) { return new CommentCollection(reader); } } }
// used for comment tracking public void StartComment(CommentType commentType, bool commentStartsLine, Location startPosition) { this.currentCommentType = commentType; this.startPosition = startPosition; this.sb.Length = 0; this.commentStartsLine = commentStartsLine; }
public Comment(CommentType commentType, string comment, bool commentStartsLine, Location startPosition, Location endPosition) : base(startPosition, endPosition) { this.CommentType = commentType; this.CommentText = comment; CommentStartsLine = commentStartsLine; }
public async Task<List<Comment>> GetComments(string id, CommentType commentType) { var uri = "/" + id + "?commentType=" + commentType; List<Comment> comments = new List<Comment>(); var recievedContent = ""; try { var response = await httpClient.GetAsync(new Uri(App.serverUri + "message/comment" + uri)); if (response.IsSuccessStatusCode) { recievedContent = await response.Content.ReadAsStringAsync(); comments = JsonConvert.DeserializeObject<List<Comment>>(recievedContent); } else { await App.coreView.displayAlertMessage("Connection Error", "Trouble Connecting To Server", "OK"); } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(@" ERROR {0}", ex.Message); Comment comm = JsonConvert.DeserializeObject<Comment>(recievedContent); comments.Add(comm); } return comments; }
private int GetObjectID(CommentType type, string WebID) { if (type == CommentType.Wall) { Member m = Member.GetMemberViaWebMemberID(WebID); return m.MemberID; } else if (type == CommentType.Video) { Video v = Video.GetVideoByWebVideoIDWithJoin(WebID); return v.VideoID; } else if (type == CommentType.AskAFriend) { AskAFriend aaf = AskAFriend.GetAskAFriendByWebAskAFriendID(WebID); return aaf.AskAFriendID; } else if (type == CommentType.Blog) { BlogEntry blog = BlogEntry.GetBlogEntryByWebBlogEntryID(WebID); return blog.BlogEntryID; } else if (type == CommentType.Photo) { Photo photo = Photo.GetPhotoByWebPhotoIDWithJoin(WebID); return photo.PhotoID; } else if (type == CommentType.PhotoGallery) { PhotoCollection photoColl = PhotoCollection.GetPhotoCollectionByWebPhotoCollectionID(WebID); return photoColl.PhotoCollectionID; } return -1; }
public Comment(Nemerle.Compiler.Comment comment, CommentType type, int textPosition) { Position = comment.Position; Length = comment.Length; IsDocument = comment.IsDocument; IsMultiline = comment.IsMultiline; Type = type; TextPosition = textPosition; }
/// <summary> /// Creates a new comment instance from an XML element. /// </summary> /// <param name="xml">The XML element.</param> public CrawlerComment(XElement xml) { this.type = (CommentType)int.Parse(xml.Attribute("type").Value, CultureInfo.InvariantCulture); this.guid = Guid.Parse(xml.Attribute("guid").Value); this.time = DateTime.Parse(xml.Attribute("time").Value, CultureInfo.InvariantCulture); this.user = xml.Attribute("user").Value; this.item = xml.Attribute("item").Value; this.text = xml.Value; this.xml = xml; }
/// <summary> /// Initializes a new instance of the Comment class. /// </summary> /// <param name="document">The parent document.</param> /// <param name="text">The line text.</param> /// <param name="commentType">The type of the comment.</param> internal Comment(CsDocument document, string text, CommentType commentType) : base(document, (int)commentType) { Param.AssertNotNull(document, "document"); Param.AssertNotNull(text, "text"); Param.Ignore(commentType); this.Text = text; CsLanguageService.Debug.Assert(System.Enum.IsDefined(typeof(CommentType), this.CommentType), "The type is invalid."); }
/// <summary> /// Returns the height of the given comment. /// </summary> public static int GetCommentHeight(string comment, CommentType commentType) { int minHeight = 38; if (commentType == CommentType.None) minHeight = 17; GUIStyle style = "HelpBox"; return Math.Max( (int)style.CalcHeight(new GUIContent(comment), Screen.width), minHeight); }
/// <summary> /// 显示Comment /// </summary> /// <param name="type"></param> /// <param name="message"></param> /// <param name="arg"></param> public static void Comment(CommentType type, string message, params object[] arg) { if (LogEvent != null) { if (arg.Length == 0) LogEvent(type, message); else LogEvent(type, String.Format(message, arg)); } }
public Comment(String memberID, String commentToID, String content,CommentType type) { this.MemberID = memberID; this.Creater = new BiZ.Creater.Creater(memberID); this.CommentToID = commentToID; this.Content = content; this.CreatedTime = DateTime.Now; this.UpdateTime = DateTime.Now; this.CommentType = type; this.DeleteFlag = Comm.DeletedFlag.No; }
public static int GetResourseType(CommentType type) { switch (type) { case CommentType.AlbumComment: return 1; case CommentType.PhotoComment: default: return 2; } }
public static Int32 GetCloserOfPositionOfComment(String Code, Int32 SearchOffset, CommentType Type) { switch (Type) { case CommentType.SingleLine: return Code.IndexOf(CloserOfSingleLineComment, SearchOffset); case CommentType.MultiLine: return Code.IndexOf(CloserOfMultiLineComment, SearchOffset); default: return IndexNotFound; } }
private async Task RequestShortComments() { if (_currCommentType == CommentType.Long) { _currCommentType = CommentType.Short; } var shortComment = await DataRequester.RequestShortComment(CurrentStoryId, _currCommentType == CommentType.Long ? null : LastCommentId); if (shortComment == null) return; CommentList.Last().AddRange(shortComment.comments); }
protected XElement FormatComments(Step step, CommentType type) { XElement comment = new XElement(this.xmlns + "span", new XAttribute("class", "comment")); foreach (var stepComment in step.Comments.Where(o => o.Type == type)) { comment.Add(stepComment.Text.Trim()); comment.Add(new XElement(this.xmlns + "br")); } comment.LastNode.Remove(); return comment; }
/// <summary> /// Comments list /// </summary> /// <param name="commentType">Comment type</param> /// <param name="take">Items to take</param> /// <param name="skip">Items to skip</param> /// <param name="filter">Filter expression</param> /// <param name="order">Sort order</param> /// <returns>List of comments</returns> public IEnumerable<CommentItem> GetComments(CommentType commentType = CommentType.All, int take = 10, int skip = 0, string filter = "", string order = "") { if (!Security.IsAuthorizedTo(BlogEngine.Core.Rights.ViewPublicComments)) throw new System.UnauthorizedAccessException(); if (string.IsNullOrEmpty(filter)) filter = "1==1"; if (string.IsNullOrEmpty(order)) order = "DateCreated desc"; var items = new List<Comment>(); var query = items.AsQueryable().Where(filter); var comments = new List<CommentItem>(); var all = Security.IsAuthorizedTo(BlogEngine.Core.Rights.EditOtherUsersPosts); foreach (var p in Post.Posts) { if (all || p.Author.ToLower() == Security.CurrentUser.Identity.Name.ToLower()) { switch (commentType) { case CommentType.Pending: items.AddRange(p.NotApprovedComments); break; case CommentType.Pingback: items.AddRange(p.Pingbacks); break; case CommentType.Spam: items.AddRange(p.SpamComments); break; case CommentType.Approved: items.AddRange(p.ApprovedComments); break; default: items.AddRange(p.Comments); break; } } } // if take passed in as 0, return all if (take == 0) take = items.Count; var itemList = query.OrderBy(order).Skip(skip).Take(take).ToList(); foreach (var item in itemList) { comments.Add(CreateJsonCommentFromComment(item, itemList)); } return comments; }
public bool CheckPossibilityOfChangingComment(string userId, int commentId, CommentType type) { switch (type) { case CommentType.AlbumComment: var albumComment = _unitOfWork.AlbumComments.Get(commentId); return albumComment != null && albumComment.TargetAlbum.UserId == userId; case CommentType.PhotoComment: default: var photoComment = _unitOfWork.PhotoComments.Get(commentId); return photoComment != null && photoComment.TargetPhoto.AuthorId == userId; } }
public HttpResponseMessage PostComment(CommentType c) { Log.InfoFormat("POST api/comments/{0}/ EventId={1} Content={2}", c.id, c.id, c.content); var comment = c.content; var userId = User.Identity.GetUserName().ToLong(); // Pulling this from the IPrincipal. It is actually the user id var profile = _profilesService.GetProfile(userId); var ev = _eventService.GetEvent(c.id); _eventService.AddShoutoutToEvent(profile, ev, c.content); Log.InfoFormat("Posted comment to event. EventId={0} ", c.id); return Request.CreateResponse(HttpStatusCode.OK); }
public void SaveComment(int elementid, int? parentid, string comment, CommentType commenttype, int userid) { DB.Comments.InsertOnSubmit( new Comment() { UserId = userid, ParentId = parentid, ItemId = elementid, Date = DateTime.Now, CommentType = commenttype, CommentText = comment } ); DB.SubmitChanges(); }
/// <summary> /// Creates a comment instance. /// </summary> /// <param name="type">The type.</param> /// <param name="time">The time.</param> /// <param name="user">The user.</param> /// <param name="item">The item.</param> /// <param name="text">The text.</param> public CrawlerComment(CommentType type, DateTime time, string user, string item, string text) { this.type = type; this.guid = Guid.NewGuid(); this.time = time; this.user = user; this.item = item; this.text = text; this.xml = new XElement("comment", new XAttribute("type", ((int)this.type).ToString(CultureInfo.InvariantCulture)), new XAttribute("guid", this.guid), new XAttribute("time", this.time.ToString(CultureInfo.InvariantCulture)), new XAttribute("item", this.item), new XAttribute("user", this.user), text); }
public static Comment[] GetCommentByObjectIDWithJoin(Int32 objectID, CommentType commentType) { var db = DatabaseFactory.CreateDatabase(); var dbCommand = db.GetStoredProcCommand("HG_GetCommentByObjectIDWithJoin"); db.AddInParameter(dbCommand, "ObjectID", DbType.Int32, objectID); db.AddInParameter(dbCommand, "CommentType", DbType.Int32, (Int32)commentType); List<Comment> comments = null; using (var dr = db.ExecuteReader(dbCommand)) { comments = Comment.PopulateObject(dr); dr.Close(); } return comments.ToArray(); }
public override void Parse(MemoryStream ms, ParseState state) { /* eat comment marker */ byte commentType = (byte) ms.ReadByte(); if (commentType == 36) { Type = CommentType.SLASH_STAR; } else if (commentType == 78) { //TODO: make a global string writer to use instead of each element making its own string builder Type = CommentType.SLASH_STAR_SAME_LINE; } else if (commentType == 85) { Type = CommentType.ANGLE_STAR; } else if (commentType == 109) { Type = CommentType.SLASH_PLUS; } if (Type == CommentType.SLASH_PLUS) { ms.Seek(-1, SeekOrigin.Current); PureStringElement commentText = new PureStringElement(); commentText.Parse(ms, state); this.Value = "/+ " + commentText.Value + " +/"; } else { byte[] bShort = new byte[2]; bShort[0] = (byte)ms.ReadByte(); bShort[1] = (byte)ms.ReadByte(); int commentLength = BitConverter.ToInt16(bShort, 0); byte[] commentData = new byte[commentLength]; ms.Read(commentData, 0, commentLength); string s = Encoding.Unicode.GetString(commentData); s = s.Replace("\r\n", "\n"); // CRLF to LF s = s.Replace("\n", "\r\n"); // LF to CRLF this.Value = s; } }
internal static char GetCommentChar (CommentType type) { switch (type) { case CommentType.Extracted: return '.'; case CommentType.Reference: return ':'; case CommentType.Flag: return ','; case CommentType.PreviousContext: return '|'; case CommentType.ObsoleteMessage: return '~'; case CommentType.Translator: return ' '; default: throw new Exception ("Invalid CommentType"); } }
public async Task<Comment> PostAsync(CommentType commentType, int id, string text, int inReplyTo = 0) { var postData = new Dictionary<string, string>(); postData.Add("id", id); postData.Add("text", text); postData.Add("type", commentType); if (inReplyTo != 0) postData.Add("in_reply_to", inReplyTo); var options = "?" + postData.ToQueryString(); var response = await Post<RootComment>(PostUrl + options, null); ValidateResponse(response); return response.Comment; }
public static Int32[] GetCommentIDs(Int32 objectID, Int32 lastCommentID, CommentType commentType) { var db = DatabaseFactory.CreateDatabase(); var dbCommand = db.GetStoredProcCommand("HG_GetCommentIDs"); db.AddInParameter(dbCommand, "objectID", DbType.Int32, objectID); db.AddInParameter(dbCommand, "lastCommentID", DbType.Int32, lastCommentID); db.AddInParameter(dbCommand, "commentType", DbType.Int32, (Int32)commentType); var commentIDs = new List<Int32>(); // Populate the datareader using (var dr = db.ExecuteReader(dbCommand)) { while (dr.Read()) commentIDs.Add(Convert.ToInt32(dr["CommentID"])); dr.Close(); } return commentIDs.ToArray(); }
public async Task<IList<Comment>> GetAsync(CommentType commentType, int id, int numberOfCommentByPage, int sinceId = 0) { var postData = new Dictionary<string, string>(); postData.Add("id", id); postData.Add("nbpp", numberOfCommentByPage); postData.Add("order", "desc"); postData.Add("type", commentType); if (sinceId != 0) postData.Add("since_id", sinceId); var options = "?" + postData.ToQueryString(); var response = await Get<CommentList>(GetUrl + options); ValidateResponse(response); return response.Comments; }
public bool TrackComment(string s, int index) { switch (_current) { case CommentType.None: if (_definition.IsSingleLineCommentsSupported() && StartsWith(s, index, _definition.SINGLE_LINE)) _current = CommentType.SingleLine; else if (_definition.IsMultiLineCommentsSupported() && StartsWith(s, index, _definition.MULTI_LINE_START)) _current = CommentType.MultiLine; break; case CommentType.MultiLine: if (EndsWith(s, index, _definition.MULTI_LINE_END)) { _current = CommentType.None; return true; } break; } return _current != CommentType.None; }
public Collection<Post> GetAllPosts(int categoryId, DateTime startDate, DateTime endDate, CommentType ctype, int numberOfPosts) { //// int numberOfPosts = 10; Collection<Post> posts = new Collection<Post>(); using (SqlConnection connection = this.GetConnection()) { connection.Open(); SqlCommand sc = new SqlCommand(); sc.CommandText = "GetAllPosts"; sc.Parameters.AddWithValue("NumberOfPosts", numberOfPosts); sc.Parameters.AddWithValue("CategoryId", categoryId); sc.Parameters.AddWithValue("DateFrom", startDate); sc.Parameters.AddWithValue("DateTo", endDate); if (ctype != CommentType.All) { sc.Parameters.AddWithValue("@ApprovedCommentsOnly", ctype == CommentType.Approved ? 1 : 0); } else { sc.Parameters.AddWithValue("@ApprovedCommentsOnly", DBNull.Value); } sc.CommandType = CommandType.StoredProcedure; sc.Connection = connection; using (SqlDataReader reader = sc.ExecuteReader()) { posts = SqlDataMap.CreatePostsFromReader(reader); } } return posts; }
public InspectorCommentAttribute(CommentType type, string tooltip) { }
public abstract void WriteComment(CommentType commentType, string content);
public override void WriteComment(CommentType commentType, string content) { decoratedWriter.WriteComment(commentType, content); }
public Comment(CommentType commentType, TextLocation startLocation, TextLocation endLocation) { this.CommentType = commentType; this.startLocation = startLocation; this.endLocation = endLocation; }
/* Function: ScoreUsingInterpretation * A function used by <ScoreInterpretation()> to determine the C and S fields of the score for the passed interpretation * using only the using statements. Only those fields and the trailing 1 will be set in the returned score. If the interpretation * doesn't match using the using statements, it will return zero. */ private long ScoreUsingInterpretation(Topic topic, Link link, SymbolString interpretation) { // --C----- -------- -------- -SSSSSSS SSS----- -------- -------- -------1 // C - Whether the topic and link's capitalization match if it matters to the language. // S - How high on the scope list the symbol match is. IList <UsingString> usingStrings = link.Context.GetUsingStatements(); if (usingStrings == null || usingStrings.Count == 0) { return(0); } Language topicLanguage = EngineInstance.Languages.FromID(topic.LanguageID); CommentType commentType = EngineInstance.CommentTypes.FromID(topic.CommentTypeID); // Values of C: // Natural Docs links: // 1 - Topic is documentation, case matches // 1 - Topic is documentation, case differs // 1 - Topic is file, case matches // 1 - Topic is file, case differs // 1 - Topic is code, topic language is case sensitive, case matches // 0 - Topic is code, topic language is case sensitive, case differs // 1 - Topic is code, topic language is case insensitive, case matches // 1 - Topic is code, topic language is case insensitive, case differs // Type/Class Parent links: // Assuming they're the same language... // X - Topic is documentation, case matches // X - Topic is documentation, case differs // X - Topic is file, case matches // X - Topic is file, case differs // 1 - Topic is code, language is case sensitive, case matches // X - Topic is code, language is case sensitive, case differs // 1 - Topic is code, language is case insensitive, case matches // 1 - Topic is code, language is case insensitive, case differs bool caseFlagged; bool caseRequired; if (link.Type == LinkType.NaturalDocs) { caseRequired = false; caseFlagged = (commentType.Flags.Code && topicLanguage.CaseSensitive); } else { if (commentType.Flags.Code == false) { return(0); } caseRequired = topicLanguage.CaseSensitive; caseFlagged = false; } // Find the scope list index to start at, since the actual scopes come before the using statements. // Scope list: // 0 - A.B.C.Link // 1 - A.B.Link // 2 - A.Link // 3 - Link // 4 - Link + first using statement // So if there's a scope, the starting index is the number of separators in the scope + 2. Otherwise it's one. // Scope list: // 0 - Link // 1 - Link + first using statement int scopeListIndex; if (link.Context.ScopeIsGlobal) { scopeListIndex = 1; } else { int scopeIndex, scopeLength; link.Context.GetRawTextScope(out scopeIndex, out scopeLength); scopeListIndex = link.Context.RawText.Count(SymbolString.SeparatorChar, scopeIndex, scopeLength) + 2; } // Go through each using statement looking for the best score. long bestScore = 0; foreach (var usingString in usingStrings) { SymbolString newInterpretation; bool newInterpretationPossible; if (usingString.Type == UsingString.UsingType.AddPrefix) { newInterpretation = usingString.PrefixToAdd + interpretation; newInterpretationPossible = true; } else if (usingString.Type == UsingString.UsingType.ReplacePrefix) { SymbolString prefixToRemove = usingString.PrefixToRemove; string prefixToRemoveString = prefixToRemove.ToString(); string interpretationString = interpretation.ToString(); if (interpretationString.Length > prefixToRemoveString.Length && interpretation.StartsWith(prefixToRemove, !caseRequired)) { newInterpretation = usingString.PrefixToAdd + SymbolString.FromExportedString(interpretationString.Substring(prefixToRemoveString.Length + 1)); newInterpretationPossible = true; } else { newInterpretation = new SymbolString(); // to make the compiler shut up newInterpretationPossible = false; } } else { throw new NotImplementedException(); } if (newInterpretationPossible && string.Compare(newInterpretation, topic.Symbol, !caseRequired) == 0) { // --C----- -------- -------- -SSSSSSS SSS----- -------- -------- -------1 // Our baseline. long score = 0x0000000000000001; // --C----- -------- -------- -SSSSSSS SSS----- -------- -------- -------= // Encode the scope index. We want lower indexes to have a higher score. if (scopeListIndex > 1023) { scopeListIndex = 1023; } long scopeListBits = 1023 - scopeListIndex; scopeListBits <<= 29; score |= scopeListBits; // --C----- -------- -------- -======= ===----- -------- -------- -------= // Determine C. If C is set we can quit early because it would be impossible for a later using statement to // generate a higher score. if (!caseFlagged || string.Compare(newInterpretation, topic.Symbol, false) == 0) { score |= 0x2000000000000000; bestScore = score; break; } else { if (score > bestScore) { bestScore = score; } } } scopeListIndex++; } return(bestScore); }
/// <summary> /// List of comments based on type for a single page. /// </summary> /// <param name="commentType"> /// The comment type. /// </param> /// <param name="page"> /// The current page. /// </param> /// <returns> /// A list of JSON comments. /// </returns> public static List <JsonComment> GetComments(CommentType commentType, int page) { return(GetComments(commentType, BlogSettings.Instance.CommentsPerPage, page)); }
/// <summary> /// List of comments based on type for a single page. /// </summary> /// <param name="commentType"> /// The comment type. /// </param> /// <param name="pageSize"> /// The number of comments per page. /// </param> /// <param name="page"> /// The current page. /// </param> /// <returns> /// A list of JSON comments. /// </returns> public static List <JsonComment> GetComments(CommentType commentType, int pageSize, int page) { var cntTo = page * pageSize; var cntFrom = cntTo - pageSize; var cnt = 0; var allComments = new List <Comment>(); var pageComments = new List <JsonComment>(); foreach (var p in Post.Posts) { switch (commentType) { case CommentType.Pending: allComments.AddRange(p.NotApprovedComments); break; case CommentType.Pingback: allComments.AddRange(p.Pingbacks); break; case CommentType.Spam: allComments.AddRange(p.SpamComments); break; default: allComments.AddRange(p.ApprovedComments); break; } } allComments.Sort((x, y) => DateTime.Compare(y.DateCreated, x.DateCreated)); // TODO: find a way to better handle deleting last comment on the last page // below is not working properly; after moving to the next page and deleting // another comment there, things get nasty if (allComments.Count > 0 && allComments.Count == cntFrom && page > 1) { // removed last comment(s) on the page // need to shift one page back //var context = System.Web.HttpContext.Current; //if (context.Request.Cookies["CommentPagerCurrentPage"] != null) // context.Request.Cookies["CommentPagerCurrentPage"].Value = (page - 1).ToString(); //return GetComments(commentType, page - 1); } foreach (var c in allComments) { cnt++; if (cnt <= cntFrom || cnt > cntTo) { continue; } pageComments.Add(CreateJsonCommentFromComment(c)); } currentPage = page; commCnt = cnt; return(pageComments); }
/* Function: ScoreScopeInterpretation * A function used by <ScoreInterpretation()> to determine the C and S fields of the score for the passed interpretation * using only the scope. Only those fields and the trailing 1 will be set in the returned score. If the interpretation doesn't * match using the scope, it will return zero. */ private long ScoreScopeInterpretation(Topic topic, Link link, SymbolString interpretation) { // --C----- -------- -------- -SSSSSSS SSS----- -------- -------- -------1 // C - Whether the topic and link's capitalization match if it matters to the language. // S - How high on the scope list the symbol match is. Language topicLanguage = EngineInstance.Languages.FromID(topic.LanguageID); CommentType commentType = EngineInstance.CommentTypes.FromID(topic.CommentTypeID); // Values of C: // Natural Docs links: // 1 - Topic is documentation, case matches // 1 - Topic is documentation, case differs // 1 - Topic is file, case matches // 1 - Topic is file, case differs // 1 - Topic is code, topic language is case sensitive, case matches // 0 - Topic is code, topic language is case sensitive, case differs // 1 - Topic is code, topic language is case insensitive, case matches // 1 - Topic is code, topic language is case insensitive, case differs // Type/Class Parent links: // Assuming they're the same language... // X - Topic is documentation, case matches // X - Topic is documentation, case differs // X - Topic is file, case matches // X - Topic is file, case differs // 1 - Topic is code, language is case sensitive, case matches // X - Topic is code, language is case sensitive, case differs // 1 - Topic is code, language is case insensitive, case matches // 1 - Topic is code, language is case insensitive, case differs bool caseFlagged; bool caseRequired; if (link.Type == LinkType.NaturalDocs) { caseRequired = false; caseFlagged = (commentType.Flags.Code && topicLanguage.CaseSensitive); } else { if (commentType.Flags.Code == false) { return(0); } caseRequired = topicLanguage.CaseSensitive; caseFlagged = false; } // --C----- -------- -------- -SSSSSSS SSS----- -------- -------- -------1 // Our baseline. long score = 0x0000000000000001; int scopeListIndex; // If we match as a global symbol... if (string.Compare(topic.Symbol, interpretation, !caseRequired) == 0) { if (link.Context.ScopeIsGlobal) { scopeListIndex = 0; } else { // Conceptually, we had to walk down the entire hierachy to get to global: // Scope A.B.C = A.B.C.Name, A.B.Name, A.Name, Name = Index 3 // so the scope list index is the number of dividers in the scope plus one. int linkScopeIndex, linkScopeLength; link.Context.GetRawTextScope(out linkScopeIndex, out linkScopeLength); int dividers = link.Context.RawText.Count(SymbolString.SeparatorChar, linkScopeIndex, linkScopeLength); scopeListIndex = dividers + 1; } // --C----- -------- -------- -SSSSSSS SSS----- -------- -------- -------= // Apply C if (!caseFlagged || string.Compare(topic.Symbol, interpretation, false) == 0) { score |= 0x2000000000000000; } } // If the topic ends with the interepretation, such as "A.B.C.Name" and "Name"... else if (topic.Symbol.EndsWith(interpretation, !caseRequired)) { string topicSymbolString = topic.Symbol.ToString(); int topicScopeIndex = 0; int topicScopeLength = topicSymbolString.Length - interpretation.ToString().Length - 1; // See if the link's scope can completely encompass the remaining scope: // Topic A.B.C.Name + Link Name + Link Scope A.B.C = yes // Topic A.B.C.Name + Link Name + Link Scope A.B = no // Topic A.B.C.Name + Link Name + Link Scope A.B.C.D = yes, it can walk up the hierarchy // Topic A.B.C.Name + Link Name + Link Scope A.B.CC = no, can't split a word // Topic A.B.C.Name + Link Name + Link Scope X.Y.Z = no string linkContextString = link.Context.RawText; int linkScopeIndex, linkScopeLength; link.Context.GetRawTextScope(out linkScopeIndex, out linkScopeLength); // If the remaining topic scope is a substring or equal to the link scope... if (topicScopeLength <= linkScopeLength && string.Compare(linkContextString, linkScopeIndex, topicSymbolString, topicScopeIndex, topicScopeLength, !caseRequired) == 0) { if (topicScopeLength == linkScopeLength) { // If it's an exact match, this is considered the first entry on our conceptual scope list. scopeListIndex = 0; } else // topicScopeLength < linkScopeLength { // If the scope was a substring, the next character needs to be a separator so we don't split a word. if (linkContextString[topicScopeLength] != SymbolString.SeparatorChar) { return(0); } // The scope list index is the number of separators we trimmed off: // Link scope: A.B.C.D // Remaining topic scope: A.B // Scope list: // 0 - A.B.C.D // 1 - A.B.C // 2 - A.B // 3 - A // 4 - global scopeListIndex = linkContextString.Count(SymbolString.SeparatorChar, linkScopeIndex + topicScopeLength, linkScopeLength - topicScopeLength); } // --C----- -------- -------- -SSSSSSS SSS----- -------- -------- -------= // Apply C if (!caseFlagged || (topicSymbolString.EndsWith(interpretation) == true && string.Compare(linkContextString, linkScopeIndex, topicSymbolString, topicScopeIndex, topicScopeLength, false) == 0)) { score |= 0x2000000000000000; } } else { return(0); } } else { return(0); } // --=----- -------- -------- -SSSSSSS SSS----- -------- -------- -------= // Encode the scope index. We want lower indexes to have a higher score. if (scopeListIndex > 1023) { scopeListIndex = 1023; } long scopeListBits = 1023 - scopeListIndex; scopeListBits <<= 29; score |= scopeListBits; return(score); }
public static string GetCommentGroupName(CommentType type, string count) { return(count + GetString("CommentItem") + (type == CommentType.Long ? GetString("LongComment") : GetString("ShortComment"))); }
public static void TypeLabel(CommentType value) { GUIUtils.ColoredLabel(value.ToString(), GetTypeColor(value)); }
/// <summary> /// Создает экземляр класса <name>DisciplineChoiceApplication</name> /// </summary> /// <param name="electivesBlock">Элективный блок</param> /// <param name="discipline">Дисциплина</param> /// <param name="student">Студент</param> /// <param name="priority">Приоритет, присвоенный дисциплине</param> /// <param name="status">Статус заявления</param> public DisciplineChoiceApplication(ElectivesBlock electivesBlock, Discipline discipline, Student student, int priority, Status status, CommentType comment) { ElectivesBlock = electivesBlock; Discipline = discipline; Student = student; Priority = priority; Status = status; Comment = comment; }
public Comment(string content, CommentType type = CommentType.SingleLine) { this.CommentType = type; this.Content = content; }