/// <summary> /// Update the User based on an EntityRow. /// </summary> /// <param name="entityRow">The row to update from.</param> public override void Update(EntityRow entityRow) { UserRow userRow = DataModel.User.UserKey.Find(entityRow.EntityId); base.Update(entityRow); if (userRow != null) { if (!this.Modified && entityRow.EntityId == this.EntityId) { this.IdentityName = userRow.IdentityName; this.isRemoved = userRow.IsRemoved; this.groups.Clear(); foreach (GroupUsersRow groupRow in userRow.GetGroupUsersRows()) { this.groups.Add(Entity.New(groupRow.GroupRow.RightsHolderRow.EntityRow) as Group); } // The information kept in AD takes a really long time to come back, so we'll grab it in another thread. ThreadPoolHelper.QueueUserWorkItem(data => this.LoadAdInformation(data as String), this.IdentityName); } this.rowVersion = userRow.RowVersion; } }
/// <summary> /// Handle the apply command. /// </summary> /// <param name="sender">The apply button.</param> /// <param name="eventArgs">The event arguments.</param> private void OnApply(object sender, EventArgs eventArgs) { ThreadPoolHelper.QueueUserWorkItem( data => this.Apply(data as Blotter), this.Entity.Clone()); }
/// <summary> /// Create a new user accounts window. /// </summary> public WindowUserAccounts() { InitializeComponent(); this.Loaded += this.OnLoaded; this.Unloaded += this.OnUnloaded; ThreadPoolHelper.QueueUserWorkItem(data => this.CheckAdminStatus()); }
private void reportMatch_SelectionChanged(object sender, EventArgs e) { ReportCell reportCell = ViewerDebtBlotter.reportMatch.FocusedCell; if (reportCell != null) { ThreadPoolHelper.QueueUserWorkItem(InitializeMatchReport, reportCell); } }
/// <summary> /// Updates the data in the report. /// </summary> public override void Refresh() { if (this.reportGrid != null) { this.reportGrid.UpdateBodyCanvasCursor(true); } ThreadPoolHelper.QueueUserWorkItem(RefreshThread); }
/// <summary> /// Handles the end of merging data into the client side data model. /// </summary> /// <param name="sender">The object that originated the event.</param> /// <param name="eventArgs">The unused event arguments.</param> private void OnEndMerge(object sender, EventArgs eventArgs) { // The content of the report is regenerated in a worker thread when the data related to this report has changed. When // the content is regenerated, it will be sent to the foreground to be presented in the report. if (this.isDataChanged) { ThreadPoolHelper.QueueUserWorkItem(RefreshThread, false); this.isDataChanged = false; } }
/// <summary> /// Handle the Entity changing. /// </summary> protected override void OnEntityChanged() { base.OnEntityChanged(); ThreadPoolHelper.QueueUserWorkItem(delegate(object data) { lock (DataModel.SyncRoot) this.entityId = (Guid)data; }, this.Entity.EntityId); }
private void OnOkay(object sender, EventArgs eventArgs) { String name = this.OrganizationName; Guid typeId = this.OrganizationType; ThreadPoolHelper.QueueUserWorkItem( data => this.Create(name, typeId)); this.Close(); }
/// <summary> /// ctor /// </summary> /// <param name="serverAdmin"></param> /// <param name="clientProxy"></param> /// <param name="scriptFilePath">script file to load (path to file on the server)</param> /// <param name="asyncTicket">ticket string to pass back to caller though callback so caller can match message to the original request</param> /// <param name="streamConents">should the contents of the file be streamed back to the client</param> public LoadSciptFileMethodImpl(ServerAdmin serverAdmin, ClientProxy clientProxy, string scriptFilePath, string asyncTicket, bool streamConents) { this.streamConents = streamConents; this.clientProxy = clientProxy; this.serverAdmin = serverAdmin; this.scriptFilePath = scriptFilePath.Trim().ToLowerInvariant(); this.asyncTicket = asyncTicket; //start the thread to do the work ThreadPoolHelper.QueueUserWorkItem(new System.Threading.WaitCallback(this.LoadScriptFileProc)); }
/// <summary> /// Create a new debt rule list. /// </summary> public DebtRuleList(Guid blotterId) { this.blotterId = blotterId; DataModel.EntityTree.RowChanged += this.OnTreeChanged; ThreadPoolHelper.QueueUserWorkItem(delegate(object data) { this.blotterList = this.GetBlotterList(); this.InitializeList(); }); }
/// <summary> /// Handle the parent folder changing. /// </summary> /// <param name="sender">The unlink folder window.</param> /// <param name="eventArgs">The event arguments.</param> private static void OnParentFolderChanged(DependencyObject sender, DependencyPropertyChangedEventArgs eventArgs) { WindowUnlinkFolder chooser = sender as WindowUnlinkFolder; if (chooser.ParentFolder != null) { ThreadPoolHelper.QueueUserWorkItem(data => chooser.InitializeFolders((Guid)data), chooser.ParentFolder.EntityId); } else { chooser.Folders = null; } }
/// <summary> /// Handle the Group changing. /// </summary> /// <param name="eventArgs">The event arguments.</param> private void OnGroupChanged(DependencyPropertyChangedEventArgs eventArgs) { ThreadPoolHelper.QueueUserWorkItem(delegate(object guid) { lock (DataModel.SyncRoot) this.groupId = (Guid)guid; }, this.Group.GroupId); this.users.ItemsSource = new UserList() { FilterMethod = u => (u as User).Groups.Any(g => g.GroupId == this.groupId) }; }
/// <summary> /// Refreshes the data in the report in a worker thread. /// </summary> /// <param name="state">The unused thread start parameters.</param> private void RefreshThread(object state) { bool requestGC = true.Equals(state); // Once the module is compiled and loaded into memory, an instance of the specified viewer is created. The // IDocumentView is all that is needed to communicate with the loaded view. Note that an array of delegates is passed // into the newly compiled and loaded View that allow the View to communicate back to the host Viewer. // Note that SetContent method will dispatch the thread hence it was not done here. lock (DataModel.SyncRoot) this.SetContent(this.CreditCardHeaderSelector(this.guid), requestGC); ThreadPoolHelper.QueueUserWorkItem(RefreshThreadCompleted); }
/// <summary> /// Handle the Okay event. /// </summary> /// <param name="sender">The cancel button.</param> /// <param name="eventArgs">The event arguments.</param> protected override void OnOkay(object sender, ExecutedRoutedEventArgs eventArgs) { if (this.Folder != null) { Entity parent = this.ParentFolder.Clone() as Entity; Entity child = this.Folder.Clone() as Entity; ThreadPoolHelper.QueueUserWorkItem(data => this.Commit(parent, child)); this.DialogResult = true; } else { this.DialogResult = false; } this.Close(); }
/// <summary> /// Change data contexts when the entity changes. /// </summary> protected override void OnEntityChanged() { Guid entityId = this.Entity.EntityId; Guid?debtRuleId = (this.Entity as DebtClass).DebtRuleId; base.OnEntityChanged(); ThreadPoolHelper.QueueUserWorkItem(delegate(object data) { lock (DataModel.SyncRoot) { this.entityId = entityId; this.debtRuleId = debtRuleId; } }); }
/// <summary> /// Create a new properties dialog box. /// </summary> public WindowBlotterProperties() : base() { this.BuildPaymentScheduleTab(); this.CommandBindings.Add(new CommandBinding(WindowBlotterProperties.EditCommissionSchedule, this.OnEditCommissionSchedule, this.CanEditCommissionSchedule)); ThreadPoolHelper.QueueUserWorkItem(data => this.InitializeUser()); this.Loaded += delegate(object sender, RoutedEventArgs eventArgs) { DataModel.Blotter.RowChanging += this.FilterRow; }; this.Unloaded += delegate(object sender, RoutedEventArgs eventArgs) { DataModel.Blotter.RowChanging -= this.FilterRow; }; }
/// <summary> /// Handle the Entity changing. /// </summary> protected override void OnEntityChanged() { base.OnEntityChanged(); (this.Entity as User).Groups.CollectionChanged += delegate(object sender, NotifyCollectionChangedEventArgs eventArgs) { if (!this.Populating) { this.CanApply = true; } }; ThreadPoolHelper.QueueUserWorkItem(delegate(object data) { lock (DataModel.SyncRoot) this.entityId = (Guid)data; }, this.Entity.EntityId); }
/// <summary> /// Load up the user-specific information. /// </summary> protected override void FinishLoad() { UserRow userRow = DataModel.User.UserKey.Find(this.EntityId); base.FinishLoad(); this.isRemoved = userRow.IsRemoved; this.identityName = userRow.IdentityName; this.rowVersion = userRow.RowVersion; if (this.groups == null) { this.groups = new ObservableCollection <Group>(); this.groups.CollectionChanged += this.OnGroupsChanged; } foreach (GroupUsersRow groupRow in userRow.GetGroupUsersRows()) { this.groups.Add(Entity.New(groupRow.GroupRow.RightsHolderRow.EntityRow) as Group); } // The information kept in AD takes a really long time to come back, so we'll grab it in another thread. ThreadPoolHelper.QueueUserWorkItem(data => this.LoadAdInformation(data as String), this.IdentityName); }
/// <summary> /// Create a new link folder window. /// </summary> public WindowLinkFolder() : base() { ThreadPoolHelper.QueueUserWorkItem(data => this.InitializeFolders()); }
/// <summary> /// Create a new RightsHolderListBox. /// </summary> public RightsHolderListBox() { ThreadPoolHelper.QueueUserWorkItem(data => this.DetermineMultiTenant()); }
/// <summary> /// Initializes the components found in the dynamic XAML source. /// </summary> public void LoadSource() { ThreadPoolHelper.QueueUserWorkItem(LoadSource); }
private void OnLoad(object sender, EventArgs eventArgs) { ThreadPoolHelper.QueueUserWorkItem(this.LoadTypes); }
/// <summary> /// Build new settlement template control. /// </summary> public EditSettlementTemplateControl() { InitializeComponent(); ThreadPoolHelper.QueueUserWorkItem(data => this.InitializeUser()); }
/// <summary> /// Create a new link folder window. /// </summary> public WindowMove() : base() { this.Title = Properties.Resources.MoveTitle; ThreadPoolHelper.QueueUserWorkItem(data => this.InitializeFolders()); }
/// <summary> /// Updates the data in the report. /// </summary> public override void Refresh() { ThreadPoolHelper.QueueUserWorkItem(RefreshThread, true); }
private void btnThreadPool_Click(object sender, EventArgs e) { ThreadPoolHelper.QueueUserWorkItem(new ThreadPoolHelper.WaitCallbackNew(UpdateText)); ThreadPoolHelper.WaitAny(); }