public static void Main() { // The path to the documents directory. string dataDir = Path.GetFullPath("../../../Data/"); //create bookmarks Bookmarks bookmarks = new Bookmarks(); Bookmark childBookmark1 = new Bookmark(); childBookmark1.PageNumber = 1; childBookmark1.Title = "First Child"; Bookmark childBookmark2 = new Bookmark(); childBookmark2.PageNumber = 2; childBookmark2.Title = "Second Child"; bookmarks.Add(childBookmark1); bookmarks.Add(childBookmark2); Bookmark bookmark = new Bookmark(); bookmark.Action = "GoTo"; bookmark.PageNumber = 1; bookmark.Title = "Parent"; bookmark.ChildItems = bookmarks; //create PdfBookmarkEditor class PdfBookmarkEditor bookmarkEditor = new PdfBookmarkEditor(); //bind PDF document bookmarkEditor.BindPdf(dataDir+ "input.pdf"); //create bookmarks bookmarkEditor.CreateBookmarks(bookmark); //save updated document bookmarkEditor.Save(dataDir+ "output.pdf"); }
protected override void OnCancelTimer(Bookmark bookmark) { lock (this.ThisLock) { this.RegisteredTimers.RemoveTimer(bookmark); } }
public static void AddBookmark(string username, string title, string url, string[] tags, string notes) { //Console.WriteLine("{0} {1} {2} {3} {4}", username, title, url, string.Join(", ", tags), notes); BookmarksEntities context = new BookmarksEntities(); Bookmark newBookmark = new Bookmark(); newBookmark.User = CreateOrLoadUser(context, username); newBookmark.Title = title; newBookmark.URL = url; newBookmark.Notes = notes; foreach (var tagName in tags) { Tag tag = CreateOrLoadTag(context, tagName); newBookmark.Tags.Add(tag); } //dopulnitelnite tagotve------------------------ //string[] titleTags = Regex.Split(title, @"\W+"); string[] titleTags = Regex.Split(title, @"[,'!\. ;?-]+"); foreach (var titleTagName in titleTags) { Tag titleTag = CreateOrLoadTag(context, titleTagName); newBookmark.Tags.Add(titleTag); } //dopulnitelnite tagotve----------------------- context.Bookmarks.Add(newBookmark); context.SaveChanges(); }
public static void AddBookmarks(string username, string title, string url, string[] tags, string notes) { var dbCon = new BookmarksEntities(); using (dbCon) { var bookmark = new Bookmark(); bookmark.Notes = notes; bookmark.URL = url; bookmark.Title = title; bookmark.User = CreateOrLoadUser(dbCon, username); foreach (var tagName in tags) { var tag = CreateOrLoadTag(dbCon, tagName); bookmark.Tags.Add(tag); } var titleTags = Regex.Split(title, @"[ ,-\.;!?]+"); foreach (var titleTag in titleTags) { var tag = CreateOrLoadTag(dbCon, titleTag); bookmark.Tags.Add(tag); } dbCon.Bookmarks.Add(bookmark); dbCon.SaveChanges(); } }
public static void Run() { // ExStart:AddChildBookmark // The path to the documents directory. string dataDir = RunExamples.GetDataDir_AsposePdfFacades_Bookmarks(); // Create bookmarks Aspose.Pdf.Facades.Bookmarks bookmarks = new Aspose.Pdf.Facades.Bookmarks(); Bookmark childBookmark1 = new Bookmark(); childBookmark1.PageNumber = 1; childBookmark1.Title = "First Child"; Bookmark childBookmark2 = new Bookmark(); childBookmark2.PageNumber = 2; childBookmark2.Title = "Second Child"; bookmarks.Add(childBookmark1); bookmarks.Add(childBookmark2); Bookmark bookmark = new Bookmark(); bookmark.Action = "GoTo"; bookmark.PageNumber = 1; bookmark.Title = "Parent"; bookmark.ChildItems = bookmarks; // Create PdfBookmarkEditor class PdfBookmarkEditor bookmarkEditor = new PdfBookmarkEditor(); // Bind PDF document bookmarkEditor.BindPdf(dataDir+ "AddChildBookmark.pdf"); // Create bookmarks bookmarkEditor.CreateBookmarks(bookmark); // Save updated document bookmarkEditor.Save(dataDir+ "AddChildBookmark_out.pdf"); // ExEnd:AddChildBookmark }
// Constructor public ExprNodeAssignment(Bookmark bookmark, ExprNode lhs, ExprNode rhs, Token op) : base(bookmark) { Lhs = lhs; Rhs = rhs; Op = op; }
private void Continue(NativeActivityContext context, Bookmark bookmark, object obj) { var args = (object[])obj; var userID = (int)args[0]; UserID.Set(context, userID); var result = 0; var id = ID.Get(context); var item = ProjectProcessService.GetById(id); ProjectProcessService.LoadReference(item, i => i.Owner); var appraisalResult = ProjectProcessService.GetAppraisalResult(item); var userCount = UserService.Count(); if (appraisalResult.Item1 + appraisalResult.Item2 < userCount * 0.8)//投票人数未达到所有人的 80% { result = 0; } else { if (appraisalResult.Item1 > appraisalResult.Item2 * 2)//同意的人数大于不同意人数的两倍 { result = 1; InboxService.Create(UserRoleEnum.全员, item.ID, RedirectType.项目流程查看, InboxService.APPRAISAL_FINISH_PROCESS_PROJECT, item.ID.ToString(), appraisalResult.Item1.ToString(), appraisalResult.Item2.ToString(), "通过", item.Owner.NickName); InboxService.Create(UserRoleEnum.运营组成员, item.ID, RedirectType.项目流程处理, InboxService.DESIGN_PROCESS_PROJECT, item.ID.ToString(), item.Owner.NickName); } else { result = -1; InboxService.Create(UserRoleEnum.全员, item.ID, RedirectType.项目流程查看, InboxService.APPRAISAL_FINISH_PROCESS_PROJECT, item.ID.ToString(), appraisalResult.Item1.ToString(), appraisalResult.Item2.ToString(), "不通过", item.Owner.NickName); } } Rusult.Set(context, result); }
// This ctor is only used by subclasses which make their own determination about no persist or not protected BookmarkWorkItem(BookmarkCallbackWrapper callbackWrapper, Bookmark bookmark, object value) : base(callbackWrapper.ActivityInstance) { this.callbackWrapper = callbackWrapper; this.bookmark = bookmark; this.state = value; }
/// <summary> /// Copies content of the bookmark and adds it to the end of the specified node. /// The destination node can be in a different document. /// </summary> /// <param name="importer">Maintains the import context </param> /// <param name="srcBookmark">The input bookmark</param> /// <param name="dstNode">Must be a node that can contain paragraphs (such as a Story).</param> private static void AppendBookmarkedText(NodeImporter importer, Bookmark srcBookmark, CompositeNode dstNode) { // This is the paragraph that contains the beginning of the bookmark. Paragraph startPara = (Paragraph)srcBookmark.BookmarkStart.ParentNode; // This is the paragraph that contains the end of the bookmark. Paragraph endPara = (Paragraph)srcBookmark.BookmarkEnd.ParentNode; if ((startPara == null) || (endPara == null)) throw new InvalidOperationException("Parent of the bookmark start or end is not a paragraph, cannot handle this scenario yet."); // Limit ourselves to a reasonably simple scenario. if (startPara.ParentNode != endPara.ParentNode) throw new InvalidOperationException("Start and end paragraphs have different parents, cannot handle this scenario yet."); // We want to copy all paragraphs from the start paragraph up to (and including) the end paragraph, // therefore the node at which we stop is one after the end paragraph. Node endNode = endPara.NextSibling; // This is the loop to go through all paragraph-level nodes in the bookmark. for (Node curNode = startPara; curNode != endNode; curNode = curNode.NextSibling) { // This creates a copy of the current node and imports it (makes it valid) in the context // of the destination document. Importing means adjusting styles and list identifiers correctly. Node newNode = importer.ImportNode(curNode, true); // Now we simply append the new node to the destination. dstNode.AppendChild(newNode); } }
private void OnBookmarkCallback(NativeActivityContext context, Bookmark bookmark) { var log = context.Resolve<ILoggerFactory>() != null ? context.Resolve<ILoggerFactory>().Create(typeof(SubProcess)) : null; var parser = context.Resolve<IScriptParser>(); var extension = context.GetExtension<DataFieldExtension>(); //完成规则解析 if (this.Result != null && parser != null && this.FinishRule != null && this.FinishRule.Count > 0) { foreach (var i in this.FinishRule) if (parser.EvaluateRule(i.Value, extension)) { this.Result.Set(context, i.Key); if (log != null) log.InfoFormat("SubProcess节点完成规则“{0}”测试通过,将进入节点“{1}”", i.Value, i.Key); break; } } //所有逻辑完成才可删除,若上述逻辑失败则将此书签用于错误恢复 context.RemoveBookmark(bookmark); }
public void Add(string title, string url, string description, string snapshotBase64String, IEnumerable<Tag> tags, Website website, string userId) { var bookmark = new Bookmark { Description = description, UserId = userId, Title = title, Url = url, SnapshotBase64String = snapshotBase64String }; //check for existing website var existingWebsite = websiteService.GetWebsiteByName(website.Name, userId).FirstOrDefault(); if (existingWebsite != null) { bookmark.WebSite = existingWebsite; } else { var websiteToAdd = new Website { Name = website.Name, FaviconBase64String = website.FaviconBase64String }; bookmark.WebSite = website; } AddTags(bookmark, tags, userId); this.bookmarks.Add(bookmark); this.bookmarks.SaveChanges(); }
public static Bookmark CreateBookmark(int bookmarkId, int userId, int ordinal) { Bookmark bookmark = new Bookmark(); bookmark.BookmarkId = bookmarkId; bookmark.UserId = userId; bookmark.Ordinal = ordinal; return bookmark; }
void Continue(NativeActivityContext context, Bookmark bookmark, object obj) { var eventArgs = obj as WorkflowNotificationEventArgs; if (eventArgs.NotificationType != WorkflowNotificationObserver.CONTENTCHANGEDNOTIFICATIONTYPE) return; InstanceManager.ReleaseWait(notificationId.Get(context)); }
private bool MatchProgram(Bookmark bookmark, FuzzyMatcher matcher) { if ((bookmark.Score = matcher.Evaluate(bookmark.Name).Score) > 0) return true; if ((bookmark.Score = matcher.Evaluate(bookmark.PinyinName).Score) > 0) return true; if ((bookmark.Score = matcher.Evaluate(bookmark.Url).Score / 10) > 0) return true; return false; }
// Add another variable declaration public void AddDeclaration(Bookmark bookmark, string Name, ast.Expression InitialValue) { var v = new Variable(); v.Bookmark = bookmark; v.Name = Name; v.InitialValue = InitialValue; Variables.Add(v); }
/// <summary> /// 添加子流程启动信息 /// </summary> /// <param name="context"></param> /// <param name="referredBookmark"></param> /// <param name="activityName"></param> /// <param name="flowNodeIndex"></param> public void AddSubProcess(NativeActivityContext context, Bookmark referredBookmark, string activityName, int flowNodeIndex) { this._instances.Add(new SubProcessActivityInstance(context.WorkflowInstanceId , flowNodeIndex , context.ActivityInstanceId , activityName , referredBookmark.Name)); }
private void Initialize() { // Create new map with a base map Map myMap = new Map(Basemap.CreateImageryWithLabels()); // Set the map view, map property to the base map MyMapView.Map = myMap; // Create a set of predefined bookmarks; each one follows the pattern of: // ~ Initialize a viewpoint pointing to a latitude longitude // ~ Create a new bookmark // ~ Give the bookmark a name // ~ Assign the viewpoint // ~ Add the bookmark to bookmark collection of the map // ~ Add the bookmark to the UI combo box for the user to choose from // Bookmark-1 Viewpoint myViewpoint1 = new Viewpoint(27.3805833, 33.6321389, 6000); Bookmark myBookmark1 = new Bookmark(); myBookmark1.Name = "Mysterious Desert Pattern"; myBookmark1.Viewpoint = myViewpoint1; MyMapView.Map.Bookmarks.Add(myBookmark1); bookmarkChooser.Items.Add(myBookmark1); // Bookmark-2 Viewpoint myViewpoint2 = new Viewpoint(37.401573, -116.867808, 6000); Bookmark myBookmark2 = new Bookmark(); myBookmark2.Name = "Strange Symbol"; myBookmark2.Viewpoint = myViewpoint2; MyMapView.Map.Bookmarks.Add(myBookmark2); bookmarkChooser.Items.Add(myBookmark2); // Bookmark-3 Viewpoint myViewpoint3 = new Viewpoint(-33.867886, -63.985, 40000); Bookmark myBookmark3 = new Bookmark(); myBookmark3.Name = "Guitar-Shaped Forest"; myBookmark3.Viewpoint = myViewpoint3; MyMapView.Map.Bookmarks.Add(myBookmark3); bookmarkChooser.Items.Add(myBookmark3); // Bookmark-4 Viewpoint myViewpoint4 = new Viewpoint(44.525049, -110.83819, 6000); Bookmark myBookmark4 = new Bookmark(); myBookmark4.Name = "Grand Prismatic Spring"; myBookmark4.Viewpoint = myViewpoint4; MyMapView.Map.Bookmarks.Add(myBookmark4); bookmarkChooser.Items.Add(myBookmark4); // Set the initial combo box selection to the lat bookmark added bookmarkChooser.SelectedItem = MyMapView.Map.Bookmarks.Last(); // Zoom to the last bookmark myMap.InitialViewpoint = myMap.Bookmarks.Last().Viewpoint; // Hide the controls for adding an additional bookmark BorderAddBookmark.Visibility = Visibility.Collapsed; }
public void AddBookmarkToMenu(Bookmark seq) { MenuItem mi = new MenuItem(); mi.Header = seq.Name; mi.Name = seq.ID; mi.Command = ExecuteBookmarkCommand; mi.CommandParameter = seq; Core.ApplicationData.Instance.MainWindow.gccombmmnu.Items.Add(mi); }
private void OnBookmarkCallback(NativeActivityContext context, Bookmark bookmark, object value) { //HACK:【重要】子流程节点书签回调逻辑较复杂,容易出错,需要对异常进行处理以便在该回调级别重试而避免整个节点的重试 this.ExecuteAndDealWithError(() => this.OnBookmarkCallback(context, bookmark) , context //复用原书签 , bookmark); }
/// <summary> /// Gets a specific article from a bookmark based on its href. /// </summary> /// <param name="bookmark">The bookmark that has the article to be returned.</param> /// <returns>The full article as a string. This is useful for immediately saving it.</returns> public async Task<Article> GetArticle(Bookmark bookmark) { var request = new RestRequest(bookmark.ArticleHref.Replace("/api/rest/v1", "")); var content = await ReadabilityClient.MakeRequestAsync(request).ConfigureAwait(false); var js = new StringReader(content); var jr = new JsonTextReader(js); var serializer = new JsonSerializer(); return serializer.Deserialize<Article>(jr); }
/// <summary> /// Used to resume bookmark outside workflow. /// </summary> /// <param name="bookmark">The value of Bookmark to be resumed</param> public void ResumeBookmark(Bookmark bookmark) { // This method is necessary due to CSDMain 223257. IAsyncResult asyncResult = this.instance.BeginResumeBookmark(bookmark, null, Fx.ThunkCallback(new AsyncCallback(StateMachineExtension.OnResumeBookmarkCompleted)), this.instance); if (asyncResult.CompletedSynchronously) { this.instance.EndResumeBookmark(asyncResult); } }
internal void Initialize(FolderWatcherExtension extension, Bookmark bookmark, string folder, string pattern, bool subfolders, string subscriberDisplayName) { if (this.IsInitialized) { throw new InvalidOperationException(String.Format( Properties.Resources.SubscriptionHandleAlreadyInitialized, subscriberDisplayName)); } this.Id = extension.Subscribe(bookmark, folder, pattern, subfolders); }
public BookmarkWorkItem(ActivityExecutor executor, bool isExternal, BookmarkCallbackWrapper callbackWrapper, Bookmark bookmark, object value) : this(callbackWrapper, bookmark, value) { if (isExternal) { executor.EnterNoPersist(); this.ExitNoPersistRequired = true; } }
protected override void OnRegisterTimer(TimeSpan timeout, Bookmark bookmark) { if (timeout < TimeSpan.MaxValue) { lock (this.ThisLock) { this.RegisteredTimers.AddTimer(timeout, bookmark); } } }
/// <summary> /// Zooms to the selected bookmark /// </summary> /// <param name="bmk">A bookmark</param> /// <returns>Task returning the bookmark</returns> public static async Task ZoomToSelectedBmk(Bookmark bmk) { if (bmk == null) return; if (MapView.Active != null) return; await MapView.Active.ZoomToAsync(bmk); //zoom to map }
internal void OnNotificationCallback(NativeActivityContext context, Bookmark bookmark, Object value) { var notification = (NotificationFailure) value; NotificationDescriptor.Set(context, notification.NotificationDescriptor); // Exit the no persist zone var handle = _noPersistHandle.Get(context); handle.Exit(context); }
public ActivityExecutionWorkItem CreateWorkItem(ActivityExecutor executor, bool isExternal, Bookmark bookmark, object value) { if (this.IsCallbackNull) { return executor.CreateEmptyWorkItem(this.ActivityInstance); } else { return new BookmarkWorkItem(executor, isExternal, this, bookmark, value); } }
public Bookmark CreateBookmark(string name, BookmarkCallback callback, System.Activities.ActivityInstance owningInstance, BookmarkOptions options) { Bookmark key = new Bookmark(name); if ((this.bookmarks != null) && this.bookmarks.ContainsKey(key)) { throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.BookmarkAlreadyExists(name))); } this.AddBookmark(key, callback, owningInstance, options); this.UpdateAllExclusiveHandles(key, owningInstance); return key; }
private void btnCreateOrEdit_Click(object sender, EventArgs e) { if (bookmark == null) bookmark = new Bookmark(); bookmark.Description = tbDescription.Text; bookmark.FileNames = tbFileNames.Text; bookmark.SearchPattern = tbSearchFor.Text; bookmark.ReplacePattern = tbReplaceWith.Text; DialogResult = DialogResult.OK; Close(); }
public ActionResult View(Bookmark bookmark) { if (bookmark == null) { return this.HttpNotFound(); } var bookmarkView = Mapper.Map<BookmarkDetailsViewModel>(bookmark); return this.View(bookmarkView); }
// Constructor public StatementReturnThrow(Bookmark bookmark, Token op) : base(bookmark) { Op = op; }
// Constructor public ExprNodeParens(Bookmark bookmark, ExprNode inner) : base(bookmark) { Inner = inner; }
public BookmarkResumptionResult TryGenerateWorkItem(ActivityExecutor executor, ref Bookmark bookmark, BookmarkScope scope, object value, ActivityInstance isolationInstance, bool nonScopedBookmarksExist, out ActivityExecutionWorkItem workItem) { Fx.Assert(scope != null, "We should never have a null sub instance."); BookmarkManager manager = null; workItem = null; BookmarkScope lookupScope = scope; if (scope.IsDefault) { lookupScope = this.defaultScope; } // We don't really care about the return value since we'll // use null to know we should check uninitialized sub instances this.bookmarkManagers.TryGetValue(lookupScope, out manager); if (manager == null) { Fx.Assert(lookupScope != null, "The sub instance should not be default if we are here."); BookmarkResumptionResult finalResult = BookmarkResumptionResult.NotFound; // Check the uninitialized sub instances for a matching bookmark if (this.uninitializedScopes != null) { for (int i = 0; i < this.uninitializedScopes.Count; i++) { BookmarkScope uninitializedScope = this.uninitializedScopes[i]; Fx.Assert(this.bookmarkManagers.ContainsKey(uninitializedScope), "We must always have the uninitialized sub instances."); Bookmark internalBookmark; BookmarkCallbackWrapper callbackWrapper; BookmarkResumptionResult resumptionResult; if (!this.bookmarkManagers[uninitializedScope].TryGetBookmarkFromInternalList(bookmark, out internalBookmark, out callbackWrapper)) { resumptionResult = BookmarkResumptionResult.NotFound; } else if (IsExclusiveScopeUnstable(internalBookmark)) { resumptionResult = BookmarkResumptionResult.NotReady; } else { resumptionResult = this.bookmarkManagers[uninitializedScope].TryGenerateWorkItem(executor, true, ref bookmark, value, isolationInstance, out workItem); } if (resumptionResult == BookmarkResumptionResult.Success) { // We are using InitializeBookmarkScopeWithoutKeyAssociation because we know this is a new uninitialized scope and // the key we would associate is already associated. And if we did the association here, the subsequent call to // FlushBookmarkScopeKeys would try to flush it out, but it won't have the transaction correct so will hang waiting for // the transaction that has the PersistenceContext locked to complete. But it won't complete successfully until // we finish processing here. InitializeBookmarkScopeWithoutKeyAssociation(uninitializedScope, scope.Id); // We've found what we were looking for return(BookmarkResumptionResult.Success); } else if (resumptionResult == BookmarkResumptionResult.NotReady) { // This uninitialized sub-instance has a matching bookmark but // it can't currently be resumed. We won't return BookmarkNotFound // because of this. finalResult = BookmarkResumptionResult.NotReady; } else { if (finalResult == BookmarkResumptionResult.NotFound) { // If we still are planning on returning failure then // we'll incur the cost of seeing if this scope is // stable or not. if (!IsStable(uninitializedScope, nonScopedBookmarksExist)) { // There exists an uninitialized scope which is unstable. // At the very least this means we'll return NotReady since // this uninitialized scope might eventually contain this // bookmark. finalResult = BookmarkResumptionResult.NotReady; } } } } } return(finalResult); } else { Bookmark bookmarkFromList; BookmarkCallbackWrapper callbackWrapper; BookmarkResumptionResult resumptionResult; if (!manager.TryGetBookmarkFromInternalList(bookmark, out bookmarkFromList, out callbackWrapper)) { resumptionResult = BookmarkResumptionResult.NotFound; } else { if (IsExclusiveScopeUnstable(bookmarkFromList)) { resumptionResult = BookmarkResumptionResult.NotReady; } else { resumptionResult = manager.TryGenerateWorkItem(executor, true, ref bookmark, value, isolationInstance, out workItem); } } if (resumptionResult == BookmarkResumptionResult.NotFound) { if (!IsStable(lookupScope, nonScopedBookmarksExist)) { resumptionResult = BookmarkResumptionResult.NotReady; } } return(resumptionResult); } }
// Constructor public StatementTryCatchFinally(Bookmark bookmark) : base(bookmark) { }
protected static string CreateReminderName(Bookmark bookmark) => WorkflowNamespace.ReminderPrefixForBookmarks + bookmark.ToString();
protected override void BookmarkResumptionCallback(NativeActivityContext context, Bookmark bookmark, object value) { try { base.BookmarkResumptionCallback(context, bookmark, value); } catch (Exception e) { if (ContinueOnError.Get(context)) { Trace.TraceError(e.ToString()); } else { throw; } } }
public void RemoveBookmark(Bookmark bookmark) { Bookmarks.Remove(bookmark); }
private void AddBookmark(Bookmark bookmark) { Bookmarks.Add(bookmark); }
// Return true/false if the notebook already has this bookmark public bool HasBookmark(Bookmark bookmark) => Bookmarks.Contains(bookmark);
public TimerData(Bookmark timerBookmark, DateTime expirationTime) { this.Bookmark = timerBookmark; this.ExpirationTime = expirationTime; }
public void OnResumeBookmark(NativeActivityContext context, Bookmark bookmark, object obj) { // When the Bookmark is resumed, assign its value to // the Result argument. Result.Set(context, (string)obj); }
public bool TryGetValue(Bookmark bookmark, out TimerData timerData) { return(_dictionary.TryGetValue(bookmark, out timerData)); }
public void UnregisterReminder(Bookmark bookmark) { UnregisterReminder(CreateReminderName(bookmark)); }
public void Refresh() { if (Instance != null) { if (_InstanceUpMenuItem == null) { _InstanceUpMenuItem = new ToolStripMenuItem(Instance.Machines.Length > 1 ? "Up All" : "Up", Resources.up, UpAllMachines_Click); MenuItem.DropDownItems.Add(_InstanceUpMenuItem); } if (_SSHMenuItem == null) { _SSHMenuItem = new ToolStripMenuItem("SSH", Resources.ssh, SSHInstance_Click); MenuItem.DropDownItems.Add(_SSHMenuItem); } if (_InstanceReloadMenuItem == null) { _InstanceReloadMenuItem = new ToolStripMenuItem(Instance.Machines.Length > 1 ? "Reload All" : "Reload", Resources.reload, ReloadAllMachines_Click); MenuItem.DropDownItems.Add(_InstanceReloadMenuItem); } if (_InstanceSuspendMenuItem == null) { _InstanceSuspendMenuItem = new ToolStripMenuItem(Instance.Machines.Length > 1 ? "Suspend All" : "Suspend", Resources.suspend, SuspendAllMachines_Click); MenuItem.DropDownItems.Add(_InstanceSuspendMenuItem); } if (_InstanceHaltMenuItem == null) { _InstanceHaltMenuItem = new ToolStripMenuItem(Instance.Machines.Length > 1 ? "Halt All" : "Halt", Resources.halt, HaltAllMachines_Click); MenuItem.DropDownItems.Add(_InstanceHaltMenuItem); } if (_InstanceDestroyMenuItem == null) { _InstanceDestroyMenuItem = new ToolStripMenuItem(Instance.Machines.Length > 1 ? "Destroy All" : "Destroy", Resources.destroy, DestroyAllMachines_Click); MenuItem.DropDownItems.Add(_InstanceDestroyMenuItem); } if (_InstanceProvisionMenuItem == null) { _InstanceProvisionMenuItem = new ToolStripMenuItem(Instance.Machines.Length > 1 ? "Provision All" : "Provision", Resources.provision, ProvisionAllMachines_Click); MenuItem.DropDownItems.Add(_InstanceProvisionMenuItem); } if (_InstanceRsyncMenuItem == null) { _InstanceRsyncMenuItem = new ToolStripMenuItem(Instance.Machines.Length > 1 ? "Rsync All" : "Rsync", Resources.rsync, RsyncAllMachines_Click); MenuItem.DropDownItems.Add(_InstanceRsyncMenuItem); } if (_InstanceRsyncAutoMenuItem == null) { _InstanceRsyncAutoMenuItem = new ToolStripMenuItem("Rsync-Auto", Resources.rsyncauto, RsyncAutoInstance_Click); MenuItem.DropDownItems.Add(_InstanceRsyncAutoMenuItem); } if (_ActionSeparator == null) { _ActionSeparator = new ToolStripSeparator(); MenuItem.DropDownItems.Add(_ActionSeparator); } if (_OpenInExplorerMenuItem == null) { _OpenInExplorerMenuItem = Util.MakeBlankToolstripMenuItem("Open In Explorer", OpenInExplorerMenuItem_Click); MenuItem.DropDownItems.Add(_OpenInExplorerMenuItem); } if (_OpenInTerminalMenuItem == null) { _OpenInTerminalMenuItem = Util.MakeBlankToolstripMenuItem("Open In Terminal", OpenInTerminalMenuItem_Click); MenuItem.DropDownItems.Add(_OpenInTerminalMenuItem); } if (_ChooseProviderMenuItem == null) { _ChooseProviderMenuItem = new ToolStripMenuItem(String.Format("Provider: {0}", Instance.ProviderIdentifier ?? "Unknown")); VagrantManager.Instance.GetProviderIdentifiers().ToList().ForEach(identifier => { ToolStripMenuItem menuItem = Util.MakeBlankToolstripMenuItem(identifier, UpdateProviderIdentifier_Click); menuItem.Tag = identifier; _ChooseProviderMenuItem.DropDownItems.Add(menuItem); }); MenuItem.DropDownItems.Add(_ChooseProviderMenuItem); } else { _ChooseProviderMenuItem.Text = String.Format("Provider: {0}", Instance.ProviderIdentifier ?? "Unknown"); } if (_RemoveBookmarkMenuItem == null) { _RemoveBookmarkMenuItem = Util.MakeBlankToolstripMenuItem("Remove from bookmarks", RemoveBookmarkMenuItem_Click); MenuItem.DropDownItems.Add(_RemoveBookmarkMenuItem); } if (_AddBookmarkMenuItem == null) { _AddBookmarkMenuItem = Util.MakeBlankToolstripMenuItem("Add to bookmarks", AddBookmarkMenuItem_Click); MenuItem.DropDownItems.Add(_AddBookmarkMenuItem); } if (Instance.HasVagrantFile()) { int runningCount = Instance.GetRunningMachineCount(); int SuspendedCount = Instance.GetMachineCountWithState(VagrantMachineState.SavedState); if (runningCount == 0 && SuspendedCount == 0) { MenuItem.Image = Resources.status_icon_off; } else if (runningCount == this.Instance.Machines.Length) { MenuItem.Image = Resources.status_icon_on; } else { MenuItem.Image = Resources.status_icon_suspended; } if (runningCount < Instance.Machines.Count()) { _InstanceUpMenuItem.Visible = true; _SSHMenuItem.Visible = false; _InstanceReloadMenuItem.Visible = false; _InstanceSuspendMenuItem.Visible = false; _InstanceHaltMenuItem.Visible = false; _InstanceProvisionMenuItem.Visible = false; _InstanceRsyncMenuItem.Visible = false; _InstanceRsyncAutoMenuItem.Visible = false; } if (runningCount > 0) { _InstanceUpMenuItem.Visible = false; _SSHMenuItem.Visible = true; _InstanceReloadMenuItem.Visible = true; _InstanceSuspendMenuItem.Visible = true; _InstanceHaltMenuItem.Visible = true; _InstanceProvisionMenuItem.Visible = true; _InstanceRsyncMenuItem.Visible = true; _InstanceRsyncAutoMenuItem.Visible = true; } // hide terminal based actions if more than one instance if (Instance.Machines.Count() > 1) { _SSHMenuItem.Visible = false; _InstanceRsyncAutoMenuItem.Visible = false; } if (BookmarkManager.Instance.GetBookmarkWithPath(Instance.Path) != null) { _RemoveBookmarkMenuItem.Visible = true; _AddBookmarkMenuItem.Visible = false; } else { _AddBookmarkMenuItem.Visible = true; _RemoveBookmarkMenuItem.Visible = false; } } else { MenuItem.DropDownItems.Clear(); } Bookmark bookmark = BookmarkManager.Instance.GetBookmarkWithPath(Instance.Path); if (bookmark != null) { MenuItem.Text = "[B] " + bookmark.DisplayName; } else { string title; if (Properties.Settings.Default.UsePathAsInstanceDisplayName) { title = Instance.Path; } else { title = Instance.DisplayName; } if (Instance.Machines.Count() > 0 && Properties.Settings.Default.IncludeMachineNamesInMenu) { title = String.Format("{0} ({1})", title, String.Join(", ", Instance.Machines.Select(machine => machine.Name).ToArray())); } MenuItem.Text = title; } if (_MachineSeparator == null) { _MachineSeparator = new ToolStripSeparator(); MenuItem.DropDownItems.Add(_MachineSeparator); } _MachineMenuItems.ForEach(machineItem => { MenuItem.DropDownItems.Remove(machineItem); }); _MachineMenuItems.Clear(); if (Instance.Machines.Count() > 1) { _MachineSeparator.Visible = true; Array.ForEach(Instance.Machines, machine => { ToolStripMenuItem machineItem = new ToolStripMenuItem(machine.Name); ToolStripMenuItem machineUpMenuItem = new ToolStripMenuItem("Up", Resources.up, UpMachine_Click) { Tag = machine }; ToolStripMenuItem machineSSHMenuItem = new ToolStripMenuItem("SSH", Resources.ssh, SSHMachine_Click) { Tag = machine }; ToolStripMenuItem machineReloadMenuItem = new ToolStripMenuItem("Reload", Resources.reload, ReloadMachine_Click) { Tag = machine }; ToolStripMenuItem machineSuspendMenuItem = new ToolStripMenuItem("Suspend", Resources.suspend, SuspendMachine_Click) { Tag = machine }; ToolStripMenuItem machineHaltMenuItem = new ToolStripMenuItem("Halt", Resources.halt, HaltMachine_Click) { Tag = machine }; ToolStripMenuItem machineDestroyMenuItem = new ToolStripMenuItem("Destroy", Resources.destroy, DestroyMachine_Click) { Tag = machine }; ToolStripMenuItem machineProvisionMenuItem = new ToolStripMenuItem("Provision", Resources.provision, ProvisionMachine_Click) { Tag = machine }; ToolStripMenuItem machineRsyncMenuItem = new ToolStripMenuItem("Rsync", Resources.rsync, RsyncMachine_Click) { Tag = machine }; ToolStripMenuItem machineRsyncAutoMenuItem = new ToolStripMenuItem("Rsync-Auto", Resources.rsyncauto, RsyncAutoMachine_Click) { Tag = machine }; machineItem.DropDownItems.AddRange(new ToolStripMenuItem[] { machineUpMenuItem, machineSSHMenuItem, machineReloadMenuItem, machineSuspendMenuItem, machineHaltMenuItem, machineDestroyMenuItem, machineProvisionMenuItem, machineRsyncMenuItem, machineRsyncAutoMenuItem }); _MachineMenuItems.Add(machineItem); MenuItem.DropDownItems.Insert(MenuItem.DropDownItems.IndexOf(_MachineSeparator) + _MachineMenuItems.Count, machineItem); machineItem.Image = machine.State == VagrantMachineState.RunningState ? Resources.status_icon_on : machine.State == VagrantMachineState.SavedState ? Resources.status_icon_suspended : Resources.status_icon_off; if (machine.State == VagrantMachineState.RunningState) { machineUpMenuItem.Visible = false; machineSSHMenuItem.Visible = true; machineReloadMenuItem.Visible = true; machineSuspendMenuItem.Visible = true; machineHaltMenuItem.Visible = true; machineProvisionMenuItem.Visible = true; machineRsyncMenuItem.Visible = true; machineRsyncAutoMenuItem.Visible = true; } else { machineUpMenuItem.Visible = true; machineSSHMenuItem.Visible = false; machineReloadMenuItem.Visible = false; machineSuspendMenuItem.Visible = false; machineHaltMenuItem.Visible = false; machineProvisionMenuItem.Visible = false; machineRsyncMenuItem.Visible = false; machineRsyncAutoMenuItem.Visible = false; } }); } else { _MachineSeparator.Visible = false; } } else { MenuItem.DropDownItems.Clear(); } }
// Constructor public CatchClause(Bookmark bookmark) : base(bookmark) { }
public void ResumeBookmark(Bookmark bookmark, object value) { this.instance.EndResumeBookmark( this.instance.BeginResumeBookmark(bookmark, value, null, null)); }
public Task <IConnection> AcquireAsync(AccessMode mode, string database, string impersonatedUser, Bookmark bookmark) { return(Task.FromResult(Connection)); }
public ActionResult Create(Bookmark bookmark) { bookmark.DateCreated = DateTime.UtcNow; _bookmarkService.Add(bookmark); return(RedirectToAction("Index")); }
// Constructor public StatementReturnThrow(Bookmark bookmark, Token op, Expression value) : base(bookmark) { Op = op; Value = value; }
void OnBookmarkCallback(NativeActivityContext context, Bookmark bookmark, object obj) { // keep bookmark, we want to support being triggerede multiple times, so bookmark needs to be keep incase workflow is restarted // context.RemoveBookmark(bookmark.Name); }
public void OnResumeBookmark(NativeActivityContext context, Bookmark bookmark, object obj) { NextWorkFlow.Set(context, nextWorkFlow); context.RemoveAllBookmarks(); }
public ReminderInfo(Bookmark bookmark, ReminderState reminderState, DateTime dueTime) { Bookmark = bookmark; DueTime = dueTime; ReminderState = reminderState; }
static void Main(string[] args) { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Console.WriteLine("Milestone SDK Bookmarks demo (XProtect Corporate only)"); Console.WriteLine("Creates 2 new bookmarks and retrieves them using "); Console.WriteLine(" 1) BookmarkSearchTime "); Console.WriteLine(" 2) BookmarkSearchFromBookmark"); Console.WriteLine(" 3) BookmarkGet"); Console.WriteLine(""); // Initialize the SDK - must be done in stand alone VideoOS.Platform.SDK.Environment.Initialize(); VideoOS.Platform.SDK.UI.Environment.Initialize(); // Initialize ActiveX references, e.g. usage of ImageViewerActiveX etc #region Connect to the server VideoOS.Platform.SDK.UI.LoginDialog.DialogLoginForm loginForm = new VideoOS.Platform.SDK.UI.LoginDialog.DialogLoginForm(SetLoginResult, IntegrationId, IntegrationName, Version, ManufacturerName); Application.Run(loginForm); // Show and complete the form and login to server if (!Connected) { Console.WriteLine("Failed to connect or login"); Console.ReadKey(); return; } if (EnvironmentManager.Instance.MasterSite.ServerId.ServerType == ServerId.EnterpriseServerType) { Console.WriteLine("Bookmark is not supported on this product."); Console.ReadKey(); return; } #endregion #region Select a camera Item _selectItem1 = null; VideoOS.Platform.UI.ItemPickerForm form = new VideoOS.Platform.UI.ItemPickerForm(); form.KindFilter = Kind.Camera; form.AutoAccept = true; form.Init(Configuration.Instance.GetItems()); if (form.ShowDialog() == DialogResult.OK) { _selectItem1 = form.SelectedItem; } if (_selectItem1 == null) { Console.WriteLine("Failed to pick a camera"); Console.ReadKey(); return; } if (_selectItem1.FQID.ServerId.ServerType == ServerId.EnterpriseServerType) { Console.WriteLine("Bookmark is not supported on this product."); Console.ReadKey(); return; } FQID cameraFqid = _selectItem1.FQID; #endregion DateTime timeNow = DateTime.Now; // get cameras for each recording server // now-5:10min: BookmarkSearchTime start // now-5:00min: (beginTime) | BookmarkGet // now-4:59min: start recording 1 | // now-4:55min: start bookmark 1 | // now-4:45min: end bookmark 1 | // | BookmarkSearchFromBookmark // now-2:00min: | | // now-1:59min: start recording 2 | | // now-1:55min: start bookmark 2 (trigger time) | | // now-1:45min: end bookmark 2 | | // now v V Guid[] mediaDeviceTypes = new Guid[3]; mediaDeviceTypes[0] = Kind.Camera; mediaDeviceTypes[1] = Kind.Microphone; mediaDeviceTypes[2] = Kind.Speaker; #region get bookmark reference Console.WriteLine("Asking for a new Bookmark Reference:"); BookmarkReference bookmarkReference = BookmarkService.Instance.BookmarkGetNewReference(cameraFqid, true); Console.WriteLine(".... Received:" + bookmarkReference.Reference); #endregion #region create first bookmark Console.WriteLine("Creating the first bookmark"); DateTime timeBegin = timeNow.AddMinutes(-5); StringBuilder bookmarkref = new StringBuilder(); StringBuilder bookmarkHeader = new StringBuilder(); StringBuilder bookmarkDesc = new StringBuilder(); bookmarkref.AppendFormat("Mybookmark-{0}", timeBegin.ToLongTimeString()); bookmarkHeader.AppendFormat("AutoBookmark-{0}", timeBegin.ToLongTimeString()); bookmarkDesc.AppendFormat("AutoBookmark-{0} set for a duration of {1} seconds", timeBegin.ToLongTimeString(), (timeBegin.AddSeconds(10) - timeBegin.AddSeconds(1)).Seconds); Bookmark bookmark1 = null; try { bookmark1 = BookmarkService.Instance.BookmarkCreate( cameraFqid, timeBegin.AddSeconds(1), timeBegin.AddSeconds(5), timeBegin.AddSeconds(10), bookmarkref.ToString(), bookmarkHeader.ToString(), bookmarkDesc.ToString()); Console.WriteLine("Created bookmark 1 = " + bookmark1.BookmarkFQID.ToString()); } catch (Exception ex) { Console.WriteLine("BookmarkCreate 1 failed: " + ex.Message); Console.WriteLine("Press any Key"); Console.ReadKey(); } #endregion Console.WriteLine(""); Console.WriteLine("Waiting 20sec ...."); Console.WriteLine(""); System.Threading.Thread.Sleep(20000); #region Create a second bookmark Console.WriteLine("Creating a second bookmark - 2 minutes after the first bookmark"); DateTime timeBegin2 = timeBegin.AddMinutes(2); bookmarkHeader.Length = 0; bookmarkDesc.Length = 0; StringBuilder bookmarkref2 = new StringBuilder(); bookmarkref2.AppendFormat("Mybookmark-{0}", timeBegin2.ToLongTimeString()); bookmarkHeader.AppendFormat("AutoBookmark-{0}", timeBegin2.ToLongTimeString()); bookmarkDesc.AppendFormat("AutoBookmark-{0} set for a duration of {1} seconds", timeBegin2.ToLongTimeString(), (timeBegin2.AddSeconds(10) - timeBegin2.AddSeconds(1)).Seconds); Bookmark bookmark2 = null; try { bookmark2 = BookmarkService.Instance.BookmarkCreate( cameraFqid, timeBegin2.AddSeconds(1), timeBegin2.AddSeconds(5), timeBegin2.AddSeconds(10), bookmarkref2.ToString(), bookmarkHeader.ToString(), bookmarkDesc.ToString()); Console.WriteLine("Created bookmark 2 " + bookmark2.BookmarkFQID.ToString()); } catch (Exception ex) { Console.WriteLine("BookmarkCreate 2 failed: " + ex.Message); Console.WriteLine("Press any Key"); Console.ReadKey(); } Console.WriteLine("-> trigger time = {0}", bookmark2.TimeTrigged); Console.WriteLine(""); #endregion #region BookmarkSearchTime // Get max 10 the bookmarks created after the specified time Console.WriteLine(""); Console.WriteLine("Looking for bookmarks using BookmarkSearchTime (finding the 2 newly created)"); Bookmark[] bookmarkList = BookmarkService.Instance.BookmarkSearchTime( cameraFqid.ServerId, bookmark1.TimeBegin.AddSeconds(-10), 1800000000, 10, mediaDeviceTypes, null, null, null); if (bookmarkList.Length > 0) { Console.WriteLine("-> Found {0} bookmark(s)", bookmarkList.Length); int counter = 1; foreach (Bookmark bookmark in bookmarkList) { Console.WriteLine("{0}:", counter); Item camera = Configuration.Instance.GetItem(bookmark.BookmarkFQID.ParentId, Kind.Camera); FQID parent = bookmark.BookmarkFQID.GetParent(); Item camera2 = Configuration.Instance.GetItem(parent); Console.WriteLine(" Id ={0} ", bookmark.BookmarkFQID.ToString()); Console.WriteLine(" Name={0} ", bookmark.Header); Console.WriteLine(" Desc={0} ", bookmark.Description); Console.WriteLine(" user={0} ", bookmark.User); Console.WriteLine(" Device={0} Start={1} Stop={2} ", bookmark.GetDeviceItem().FQID.ObjectId, bookmark.TimeBegin, bookmark.TimeEnd); counter++; } } else { Console.WriteLine("sorry no bookmarks found"); } Console.WriteLine(""); #endregion #region BookmarkSearchFromBookmark // Get the next (max 10) bookmarks after the first Console.WriteLine("Looking for bookmarks using BookmarSearchFromBookmark (finding the last of the 2 newly created)"); Bookmark[] bookmarkListsFromBookmark = BookmarkService.Instance.BookmarkSearchFromBookmark( bookmark1.BookmarkFQID, 1800000000, 10, mediaDeviceTypes, null, null, null); if (bookmarkListsFromBookmark.Length > 0) { Console.WriteLine("-> Found {0} bookmark(s)", bookmarkListsFromBookmark.Length); int counter = 1; foreach (Bookmark bookmark in bookmarkListsFromBookmark) { Console.WriteLine("{0}:", counter); Console.WriteLine(" Id ={0} ", bookmark.BookmarkFQID.ToString()); Console.WriteLine(" Name={0} ", bookmark.Header); Console.WriteLine(" Desc={0} ", bookmark.Description); Console.WriteLine(" user={0} ", bookmark.User); Console.WriteLine(" Device={0} Start={1} Stop={2} ", bookmark.GetDeviceItem().FQID.ObjectId, bookmark.TimeBegin, bookmark.TimeEnd); counter++; } } else { Console.WriteLine("sorry no bookmarks found"); } Console.WriteLine(""); #endregion #region SearchTimeAsync Console.WriteLine("Looking for bookmarks using bookmarkSearchTimeAsync (finding the last of the 2 newly created)"); _hasBeenCalledBack = false; BookmarkService.Instance.BookmarkSearchTimeAsync( cameraFqid.ServerId, bookmark2.TimeBegin.AddSeconds(-10), 1800000000, 10, mediaDeviceTypes, null, null, null, MyAsyncCallbackHandler, null); while (!_hasBeenCalledBack) { //Do something usefull while waiting System.Threading.Thread.Sleep(100); } #endregion #region SearchBookmarkAsync Console.WriteLine("Looking for bookmarks using BookmarkSearchFromBookmarkAsync (finding the last of the 2 newly created)"); _hasBeenCalledBack = false; BookmarkService.Instance.BookmarkSearchFromBookmarkAsync( bookmark1.BookmarkFQID, 1800000000, 10, mediaDeviceTypes, null, null, null, MyAsyncCallbackHandler, null); while (!_hasBeenCalledBack) { //Do something usefull while waiting System.Threading.Thread.Sleep(100); } #endregion #region BookmarkGet // Get first created bookmark Console.WriteLine("Looking for the first bookmarks using BookmarkGet (finding the first of the 2 newly created)"); Bookmark newbookmarkFetched = BookmarkService.Instance.BookmarkGet(bookmark1.BookmarkFQID); if (newbookmarkFetched != null) { Console.WriteLine("-> A bookmarks is found"); Console.WriteLine(" Id ={0} ", newbookmarkFetched.BookmarkFQID.ToString()); Console.WriteLine(" Name={0} ", newbookmarkFetched.Header); Console.WriteLine(" Desc={0} ", newbookmarkFetched.Description); Console.WriteLine(" user={0} ", newbookmarkFetched.User); Console.WriteLine(" Device={0} Start={1} Stop={2} ", newbookmarkFetched.GetDeviceItem().FQID.ObjectId, newbookmarkFetched.TimeBegin, newbookmarkFetched.TimeEnd); } else { Console.WriteLine("Sorry no bookmarks found"); } Console.WriteLine(""); #endregion #region Update Bookmark1 Console.WriteLine("Updating the bookmark just fetched using BookmarkUpdate"); newbookmarkFetched.Description = "Now I have updated the description of this bookmark"; Bookmark newbookmark1 = BookmarkService.Instance.BookmarkUpdate(newbookmarkFetched); if (newbookmarkFetched != null) { Console.WriteLine("-> Result ="); Console.WriteLine(" Id ={0} ", newbookmarkFetched.BookmarkFQID.ToString()); Console.WriteLine(" Name={0} ", newbookmarkFetched.Header); Console.WriteLine(" Desc={0} ", newbookmarkFetched.Description); Console.WriteLine(" user={0} ", newbookmarkFetched.User); Console.WriteLine(" Device={0} Start={1} Stop={2} ", newbookmarkFetched.GetDeviceItem().FQID.ObjectId, newbookmarkFetched.TimeBegin, newbookmarkFetched.TimeEnd); } else { Console.WriteLine("Sorry. Failed to update the bookmark"); } Console.WriteLine(""); #endregion #region Deleting bookmarks Console.WriteLine("Deleting 2 newly created bookmarks"); BookmarkService.Instance.BookmarkDelete(bookmark1.BookmarkFQID); Console.WriteLine(" -> first deleted"); BookmarkService.Instance.BookmarkDelete(bookmark2); Console.WriteLine(" -> second deleted"); #endregion Console.WriteLine(""); Console.WriteLine("Press any key"); Console.ReadKey(); }
public ReminderInfo(Bookmark bookmark, ReminderState reminderState) : this(bookmark, reminderState, default(DateTime)) { }
public ActionResult Edit(Bookmark bookmark) { _bookmarkService.Add(bookmark); return(RedirectToAction("Index")); }
private void AddToListView(Bookmark[] bookmarks) { int limit = bookmarks.Length > bookmarksCount ? bookmarksCount : bookmarks.Length; for (int i = 0; i < limit; i++) { try { Bookmark bookmark = bookmarks[i]; BookmarkDescription bookmarkDescription = Helper.ParseBookmarkDescription(bookmark.Description); /* * string[] row = new string[] * { * (i+1).ToString(), * bookmark.TimeBegin.ToLocalTime().ToString(), * bookmark.TimeEnd.ToLocalTime().ToString (), * bookmark.Header, * bookmark.Description, * bookmarkDescription.PlateNumber, * bookmarkDescription.Make, * bookmarkDescription.Timestamp.ToString(), * bookmarkDescription.BestRegion * }; */ string[] row = new string[] { (i + 1).ToString(), bookmark.TimeBegin.ToLocalTime().ToString(), bookmark.TimeEnd.ToLocalTime().ToString(), bookmarkDescription.PlateNumber, bookmarkDescription.Make, bookmarkDescription.BodyType, bookmarkDescription.Color, bookmarkDescription.BestRegion }; ListViewItem listViewItem = new ListViewItem(row) { Tag = bookmark.BookmarkFQID }; lsvBookmarks.Items.Add(listViewItem); if (OpenALPRBackgroundPlugin.Stop) { break; } } catch (Exception ex) { Logger.Log.Error(null, ex); } } string plus = bookmarks.Length > bookmarksCount ? "+" : string.Empty; btnNext.Enabled = bookmarks.Length > bookmarksCount; lblMessage.Text = $"Total Bookmarks found: {limit.ToString()}{plus}"; }
public ViewResult Details(string id) { Bookmark model = _bookmarkService.GetById(id); return(View(model)); }
public bool ContainsKey(Bookmark bookmark) { return(_dictionary.ContainsKey(bookmark)); }
protected internal abstract IAsyncResult OnBeginResumeBookmark(Bookmark bookmark, object value, TimeSpan timeout, AsyncCallback callback, object state);
public ActionResult Create() { var model = new Bookmark(); return(View(model)); }