public TestContenItemControl(UIContentItem contentItem)
 {
     m_contentItem = contentItem;
     m_contentItem.StateChanged += new UIObjectStateChangedDelegate(m_contentItem_StateChanged);
     m_clientActionControl = m_contentItem.ClientActionControl;
     m_clientActionControl.ApplyToAllClicked += new EventHandler<EventArgs>(ctrl_ApplyToAllClicked);
     m_clientActionControl.ActionProperties = m_contentItem.ActionPropertySet;
 }
Esempio n. 2
0
		/// <summary>
		/// Returns whether the content item and all its children are to be processed transparently
		/// </summary>
		/// <param name="name"></param>
		/// <returns></returns>
		private static bool ProcessTransparently(UIContentItem parent)
		{
			if (parent == null || !parent.Transparent)
			{
				return false;
			}
			foreach (UIContentItem child in parent.ChildContentItems.Values)
			{
				if (!ProcessTransparently(child))
				{
					return false;
				}
			}
			return true;
		} 
        /// <summary>
        /// Doctors the "ApplyToAll" ActionProperty value.
        /// </summary>
        /// <param name="contentItem"></param>
        /// <param name="applyToAll"></param>
        private static void SetApplyToAll(UIContentItem contentItem, bool applyToAll)
        {
			if (contentItem == null)
			{
				throw new ArgumentNullException("contentItem");
			}
			IActionProperty applyToAllProperty = contentItem.GetClientActionProperty(PropertyNames.ApplyToAll);
			if (applyToAllProperty != null)
			{
				applyToAllProperty.Value = applyToAll;
			}
        }
        /// <summary>
		/// For each of the given UIContentItem and its children, adds a SummaryContentControl row
		/// to the list, or updates the row to Completed state if it's already there
        /// </summary>
        /// <param name="action"></param>
        /// <param name="parent"></param>
		private void IterateContentItems(UIAction action, UIContentItem item)
        {
			if (item.ContainsPolicyViolation())
			{
				SummaryContentControl control = m_summaryContentControlList.Find(c => c.ContentId == item.Id);
				if (control == null && item.ContentType == ContentTypeEnum.Email.ToString())
				{
					// This could be the item for the email subject/body itself (not an attachment).
					// Look for a placeholder item added earlier (when we didn't have the Id available).
					control = m_summaryContentControlList.Find(c => c.TitleText == item.Name);
				}
				if (control == null)
				{
					// The control wasn't created before scanning: add it now
					control = AddNewContentControl(item.Id, item.DisplayName, item.ContentType, true);
				}

				// Either the control was just created, or it was a placeholder
				// created during dynamic-discovery scanning.
				// Make sure it has the outcome of the scan for each action type
				string actionType = Dialogs.Utilities.MapActionToActionType(action);
				if (!control.ContentItems.ContainsKey(actionType))
				{
					control.ContentItems.Add(actionType, item);
				}

				string parentActionType = Dialogs.Utilities.MapActionToActionType(item.Action);
				if (!control.ContentItems.ContainsKey(parentActionType))
				{
					control.ContentItems.Add(parentActionType, item);
				}

				bool execute = true;
				{
					IActionProperty actionProperty;
					item.ActionPropertySet.TryGetValue(PropertyNames.Execute, out actionProperty);
					ActionPropertyFacade executeProperty = actionProperty as ActionPropertyFacade;
					if (executeProperty != null)
					{
						execute = Convert.ToBoolean(executeProperty.Value, CultureInfo.InvariantCulture);
					}
				}

				foreach (UIPolicy policy in item.Policies.Values)
				{
					if (!policy.Triggered)
					{
						continue;
					}
					control.AddPolicy(policy.Name);
					control.AddRisk(policy.HighestRating);
					control.AddAction(actionType, execute);

					if (!control.SelectionContexts.ContainsKey(actionType))
					{
						control.SelectionContexts.Add(actionType, true);
					}
					control.ScanCompleted = true;
				}
			}

			foreach (UIContentItem child in item.ChildContentItems.Values)
            {
				IterateContentItems(action, child);
            }
        }
		protected bool HandleApplyToAllClick(UIContentItem parent)
		{
			Control[] controls = parent.ClientActionControl.Controls.Find("cbApplyToAll", true);
			if (controls.Length > 0)
			{
				CheckBox checkBox = null;
				int i = 0;
				while (checkBox == null)
				{
					checkBox = controls[i++] as CheckBox;
				}
				if (checkBox != null)
				{
					checkBox.Checked = true;
					return true;
				}
			}

			foreach (UIContentItem contentItem in parent.ChildContentItems.Values)
			{
				if (HandleApplyToAllClick(contentItem))
					return true;
			}
			return false;
		}
        public SelectedContentItemsChangedArgs(UIContentItem[] selectedContentItems, bool allSelected)
        {
            m_allSelected = allSelected;
			m_selectContentItems = (selectedContentItems ?? new UIContentItem[0]);
        }
        public MockTransparentContentItemControl(UIContentItem contentItem)
            : base(contentItem)
        {
			ContentItem.ActionPropertySet[PropertyNames.Transparent].Value = bool.TrueString;
        }
Esempio n. 8
0
		/// <summary>
		/// Returns whether the content item or any of its children contain the specified content type
		/// </summary>
		/// <remarks>
		/// The comparison of the content type is not case-sensitive.
		/// Only leaf (non-container) nodes are tested.
		/// </remarks>
		/// <returns></returns>
		private static bool ContainsContentType(UIContentItem parent, string contentType)
		{
			if (parent == null)
			{
				return false;
			}
			if (!parent.Container &&
				string.Compare(parent.ContentType, contentType, StringComparison.InvariantCultureIgnoreCase) == 0)
			{
				return true;
			}
			foreach (UIContentItem child in parent.ChildContentItems.Values)
			{
				if (ContainsContentType(child, contentType))
				{
					return true;
				}
			}
			return false;
		}
Esempio n. 9
0
		/// <summary>|
		/// We need this to handle the recursive parenting.
		/// </summary>
		/// <param name="response">The <see cref="Workshare.PolicyContent.Response"/></param>
		/// <param name="uiAction">The <see cref="UIAction"/> object for the content item</param>
		/// <param name="action">The <see cref="Workshare.PolicyContent.Action"/> object for the content item</param>
		/// <param name="contentItem"></param>
		/// <returns></returns>
		private static UIContentItem HandleParentContentItems(Response response, UIAction uiAction, PolicyContent.Action action, ContentItem contentItem)
		{
			UIContentItem parent = uiAction.GetContentItemById(contentItem.ParentId);
			if (parent == null)
			{
				CustomProperty parentIndex = Array.Find(contentItem.Properties, p => p.Name == "ParentIndex");
				int index = (parentIndex == null ? -1 : Int32.Parse(parentIndex.Value));
				if (index > -1)
				{
					parent = new UIContentItem(response.Contents[index], action, true);
				}
				if (parent != null)
				{
					if (parent.ParentId == null)
					{
						uiAction.ContentItems[parent.Id] = parent;
					}
					else
					{
						UIContentItem grandparent = HandleParentContentItems(response, uiAction, action, parent.ContentItem);
						grandparent.ChildContentItems[parent.Id] = parent;
					}
				}
			}
			return parent;
		}
Esempio n. 10
0
		/// <summary>
		/// Returns the UIContentItem in the given tree that has the specified name
		/// </summary>
		/// <param name="contentItem">The root of the tree to search</param>
		/// <param name="name">The name to look for</param>
		/// <returns>The matching UIContentItem if found, otherwise null</returns>
		public static UIContentItem GetContentItemByName(UIContentItem contentItem, string name)
		{
			if (contentItem == null)
			{
				return null;
			}
			if (contentItem.Name == name)
			{
				return contentItem;
			}
			foreach (UIContentItem child in contentItem.ChildContentItems.Values)
			{
				UIContentItem result = GetContentItemByName(child, name);
				if (result != null)
				{
					return result;
				}
			}
			return null;
		}
Esempio n. 11
0
		/// <summary>
		/// Returns the UIContentItem in the given tree that has the specified id
		/// </summary>
		/// <param name="contentItem">The root of the tree to search</param>
		/// <param name="id">The id to look for</param>
		/// <returns>The matching UIContentItem if found, otherwise null</returns>
		public static UIContentItem GetContentItemById(UIContentItem contentItem, string id)
		{
			if (contentItem == null)
			{
				return null;
			}
			if (contentItem.Id == id)
			{
				return contentItem;
			}
			foreach (UIContentItem child in contentItem.ChildContentItems.Values)
			{
				UIContentItem result = GetContentItemById(child, id);
				if (result != null)
				{
					return result;
				}
			}
			return null;
		}
 public ExecuteActionPropertyChangedArgs(UIContentItem contentItem, bool execute)
 {
     m_contenItem = contentItem;
     m_execute = execute;
 }
Esempio n. 13
0
		protected void HandleContentItems(UIAction action, UIContentItem parent)
		{
			bool allowExecuteOverride = parent.AllowOverride(PropertyNames.Execute);
			
			bool isContainerContentItem = parent.IsContainerContentItem();

			MockContenItemControl ctrl = m_transparent ? new MockTransparentContentItemControl(parent) : 
				new MockContenItemControl(parent);
			ctrl.ApplyToAll += new ApplyToAllDelegate(action.HandleApplyToAll);
			m_controls.Add(ctrl);
		   
			foreach (UIContentItem child in parent.ChildContentItems.Values)
			{
				HandleContentItems(action, child);
			}
		}
Esempio n. 14
0
		protected static void SetExecute(UIContentItem parent, bool value)
		{
			parent.Execute = value;
			foreach (UIContentItem child in parent.ChildContentItems.Values)
			{
				SetExecute(child, value);
			}

		}
Esempio n. 15
0
		/// <summary>
		/// Returns whether the content item or any of its children require an application controller
		/// </summary>
		/// <param name="name"></param>
		/// <returns></returns>
		private static bool RequiresApplicationController(UIContentItem parent)
		{
			if (parent == null)
			{
				return false;
			}
			if (parent.RequiresApplicationController)
			{
				return true;
			}
			foreach (UIContentItem child in parent.ChildContentItems.Values)
			{
				if (RequiresApplicationController(child))
				{
					return true;
				}
			}
			return false;
		}
Esempio n. 16
0
		/// <summary>
		/// Prepares a <see cref="Workshare.Policy.ClientManager.ObjectModel.UIResponse"/> object based on the supplied <see cref="Response"/>
		/// </summary>
		/// <param name="request">A <see cref="Workshare.PolicyContent.Request"/> the request that the content scanner recieved when it generate the response</param>
		/// <param name="response">A <see cref="Workshare.PolicyContent.Response"/> object to parse</param>
		/// <returns>A fully populated <see cref="Workshare.Policy.ClientManager.ObjectModel.UIResponse"/> object</returns>
		public static UIResponse UIResponseFromResponse(Request request, Response response)
		{
			if (response == null)
			{
				throw new ArgumentNullException("response");
			}

			UIResponse uiResponse = new UIResponse(request, response);
			uiResponse.Initialize();

			ResolvedAction[] resolvedActions = response.ResolvedActions ?? new ResolvedAction[0];

			#region The loops
			foreach (ResolvedAction resolvedAction in resolvedActions)
			{
				foreach (ContentItem contentItem in resolvedAction.Contents)
				{
					foreach (PolicySet policySet in contentItem.PolicySets)
					{
						foreach (Workshare.PolicyContent.Policy policy in policySet.Policies)
						{
							if (!policy.Triggered)
								continue;
							foreach (Workshare.PolicyContent.Action action in policy.Actions)
							{
								#region Is Action valid
								if (action.Type != resolvedAction.Action.Type)
								{
									continue;
								}
								if (!Array.Exists(action.Properties, c => c.Name == "ExceptionAction"))
								{
									continue;
								}
								#endregion

								#region Create UIAction
								UIAction uiAction;
								uiResponse.Actions.TryGetValue(action.Type, out uiAction);
								if (uiAction == null)
								{
									uiAction = new UIAction(resolvedAction);
									uiResponse.Actions[action.Type] = uiAction;
								}
								#endregion

								#region Create UIContent & add to UIAction
								// First try and find the parent.
								UIContentItem uiParentContentItem = HandleParentContentItems(response, uiAction, action, contentItem);
								UIContentItem uiContentItem = null;
								if (uiParentContentItem == null)
								{
									uiContentItem = uiAction.GetContentItemById(contentItem.Id);
									if (uiContentItem == null)
									{
										uiContentItem = new UIContentItem(contentItem, action);
									}
									uiAction.ContentItems[uiContentItem.Name] = uiContentItem;
								}
								else
								{
									uiContentItem = UIContentItem.GetContentItemById(uiParentContentItem, contentItem.Id);
									if (uiContentItem == null)
									{
										uiContentItem = new UIContentItem(contentItem, action);
									}
									uiParentContentItem.ChildContentItems[uiContentItem.Id] = uiContentItem;
								}
								uiContentItem.Container = false;
								
								#endregion

								#region Create UIPolicy & add to UIContentItem
								UIPolicy uiPolicy;
								uiContentItem.Policies.TryGetValue(policy.Name, out uiPolicy);
								if (uiPolicy == null)
								{
									uiPolicy = new UIPolicy(policySet, policy);
									uiContentItem.Policies[policy.Name] = uiPolicy;
								}

								uiPolicy.Actions.Add(uiAction);
								#endregion

								#region Is this UIAction a blocking action?
								if (uiAction.IsBlockingAction() && !uiResponse.BlockingActions.Contains(uiAction))
								{
									uiResponse.BlockingActions.Add(uiAction);
								}
								#endregion
							}
						
						}
					}
				}
			}
			#endregion

			try
			{
				// The initialization will call Initialize on all contained objects.
				uiResponse.Initialize();
			}
			catch 
			{
				uiResponse = null;
			}

			return uiResponse;
		}
Esempio n. 17
0
		/// <summary>
		/// Returns whether the content item or any of its children contain policy violations
		/// </summary>
		/// <returns></returns>
		private static bool ContainsViolations(UIContentItem parent)
		{
			if (parent == null)
			{
				return false;
			}
			if (parent.ContainsPolicyViolation())
			{
				return true;
			}
			foreach (UIContentItem child in parent.ChildContentItems.Values)
			{
				if (ContainsViolations(child))
				{
					return true;
				}
			}
			return false;
		}
		private void IterateContentItems(UIAction action, UIContentItem parent)
		{

			switch (Dialogs.Utilities.MapActionToActionType(action))
			{
			case "CLEAN":
				RemoveCommentsEnabled = true;
				RemoveTrackChangesEnabled = true;
				SkipOfficeCleaningEnabled = true;
				break;
			case "PDFCLEAN":
				SkipPdfCleaningEnabled = true;
				break;
			case "PDF":
				PDFOptionsEnabled = true;
				break;
			}

			foreach (UIPolicy policy in parent.Policies.Values)
			{
				if (!policy.Triggered)
				{
					continue;
				}
				if (!policy.Actions.Exists(item => item.Name == action.Name))
				{
					continue;
				}
				SortedList<string, List<UICondition>> conditions;
				m_triggeredPolicies.TryGetValue(parent.Id, out conditions);
				if (conditions == null)
				{
					conditions = new SortedList<string, List<UICondition>>();
					m_triggeredPolicies[parent.Id] = conditions;
				}
				if (conditions.ContainsKey(policy.Name))
				{
					continue;
				}

				List<UICondition> expressions = new List<UICondition>();
				foreach (UICondition condition in policy.Conditions.Values)
				{
					UIExpression expression = condition as UIExpression;
					if (expression != null)
					{
						expressions.Add(expression);
					}
				}
				conditions[policy.Name] = expressions;

				if (m_totalRiskRating < policy.HighestRating)
				{
					m_totalRiskRating = policy.HighestRating;
				}
			}

			foreach (UIContentItem contentItem in parent.ChildContentItems.Values)
			{
				IterateContentItems(action, contentItem);
			}
		}
Esempio n. 19
0
		/// <summary>
		/// For all content items in the given tree that are of the same ContentType as the master,
		/// copies the values of all properties defined in both items (except EXECUTE)
		/// from the master item to the item in the tree
		/// </summary>
		/// <param name="parent"></param>
		/// <param name="master"></param>
		private void ApplyToAll(UIContentItem parent, UIContentItem master)
		{
			if (parent == null || master == null)
			{
				return;
			}
			if (parent != master && parent.ContentType == master.ContentType)
			{
				foreach (var masterProp in master.ActionPropertySet)
				{
					if (masterProp.Key == PropertyNames.Execute)
					{
						continue;
					}
					Workshare.Policy.Action.IActionProperty prop;
					if (parent.ActionPropertySet.TryGetValue(masterProp.Key, out prop))
					{
						prop.Value = masterProp.Value;
					}
				}
				parent.OnStateChanged(new UIObjectStateChangedArgs(parent));
			}
			foreach (UIContentItem child in parent.ChildContentItems.Values)
			{
				ApplyToAll(child, master);
			}
		}
		private void ConfigureOfficeCleanOptions(UIContentItem contentItem, ref TriState tsWord, ref TriState tsExcel, ref TriState tsPpt, ref TriState tsDefault, ref bool firstClean)
		{
			IActionProperty executeProperty = contentItem.GetClientActionProperty(PropertyNames.Execute);
			if (executeProperty == null)
			{
				return;
			}

			bool execute = Convert.ToBoolean(executeProperty.Value, CultureInfo.InvariantCulture);

			// Remove Comments
			IActionProperty removeCommentsProperty = contentItem.GetClientActionProperty(PropertyNames.Comments);
			bool removeComments = (removeCommentsProperty != null && Convert.ToBoolean(removeCommentsProperty.Value, CultureInfo.InvariantCulture));
			SetCheckBoxCheckState(removeCommentsCheckBox, removeComments, firstClean);

			// Remove Track changes
			IActionProperty removeTrackChangesProperty = contentItem.GetClientActionProperty(PropertyNames.TrackChanges);
			bool removeTrackChanges = (!skipOfficeCleaningCheckBox.Checked
				&& removeTrackChangesProperty != null
				&& Convert.ToBoolean(removeTrackChangesProperty.Value, CultureInfo.InvariantCulture));
			SetCheckBoxCheckState(removeTrackChangesCheckBox, removeTrackChanges, firstClean);

			// Skip cleaning
			MasterSkipCleaningEnabled = SkipOfficeCleaningEnabled = executeProperty.Override;
			SetCheckBoxCheckState(skipOfficeCleaningCheckBox, !execute, firstClean);

			RemoveCommentsEnabled = (execute && !skipOfficeCleaningCheckBox.Checked
				&& removeCommentsProperty != null && removeCommentsProperty.Override && removeCommentsProperty.Visible);

			ContentTypeEnum contentType = ContentTypeEnum.Unknown;
			if (!string.IsNullOrEmpty(contentItem.ContentType))
			{
				try
				{
					contentType = (ContentTypeEnum) Enum.Parse(typeof(ContentTypeEnum), contentItem.ContentType);
				}
				catch { }
			}
			FindRemoveTrackChangesState(contentType, removeTrackChangesProperty, execute, ref tsWord, ref tsExcel, ref tsPpt, ref tsDefault);

			firstClean = false;
			officeHiddenDataOptionsLinkLabel.Enabled = true;
		}
 public SelectedContentItemsChangedArgs(UIContentItem[] selectedContentItems)
     : this(selectedContentItems, false)
 {
 }
		private void ConfigurePdfCleanOptions(UIContentItem contentItem, ref bool firstClean)
		{
			IActionProperty executeProperty = contentItem.GetClientActionProperty(PropertyNames.Execute);
			if (executeProperty == null)
			{
				return;
			}

			bool execute = Convert.ToBoolean(executeProperty.Value, CultureInfo.InvariantCulture);

			// Skip cleaning
			MasterSkipCleaningEnabled = SkipPdfCleaningEnabled = executeProperty.Override;
			
			SetCheckBoxCheckState(skipPdfCleaningCheckBox, !execute, firstClean);

			firstClean = false;
			pdfHiddenDataOptionsLinkLabel.Enabled = true;
		}
Esempio n. 23
0
 public ApplyToAllArgs(UIContentItem contentItem)
 {
     m_contentItem = contentItem;
 }
        public void AddClientActionControl(UIContentItem contentItem)
        {
            m_contentItems.Add(contentItem);
            IActionPropertySet propertySet = contentItem.ActionPropertySet;
            ClientActionControl clientActionControl = contentItem.ClientActionControl;
            m_containsApplyToAll = true; 
            // Doctor the action property set to make the "ApplyToAll" property invisible.
            try
            {
				IActionProperty prop;
				propertySet.TryGetValue("ApplyToAll", out prop);
				ActionPropertyFacade applyToAllProperty = (ActionPropertyFacade) prop;
				if (applyToAllProperty == null)
                {
                    m_containsApplyToAll = false;
                    m_selectAllState = true;
                    m_selectAllOverride = true;
                }
                else 
                {
                    applyToAllProperty.Visible = false;
                    m_selectAllOverride = false;
					if ((applyToAllProperty.Override == false) && ((bool)applyToAllProperty.Value))
					{
						m_selectAllState = true;
						m_selectAllOverride = true;
                }
            }
			}
            catch (InvalidCastException ice)
            {
				Logger.LogError("Invalid cast: UIContentItem.PropertySet[\"ApplyToAll\"] not ActionPropertyFacade");
				Logger.LogError(ice);
            }


            // Build the APPLYTOALL ClientActionControl
            if (m_applyToAllClientActionControl == null)
            {
                // HACK: Stops us creating the UIContentItem.ClientActionControl ....
                m_applyToAllClientActionControl = m_containsApplyToAll
                                                      ? contentItem.Action.Action2.ClientActionControl
                                                      : clientActionControl;
                m_applyToAllClientActionControl.Size = new Size(350, m_applyToAllClientActionControl.Height);
                m_applyToAllClientActionControl.Dock = DockStyle.Top;
                clientActionControlContainerPanel.Controls.Add(m_applyToAllClientActionControl);
                m_applyToAllClientActionControl.ApplyToAllClicked += clientActionControl_ApplyToAllClicked;
                m_applyToAllClientActionControl.Visible = false;
                m_controls.Add(m_applyToAllClientActionControl);
            }

            if (m_containsApplyToAll)
            {
                if (m_applyToAllActionPropertySet == null)
                {
                    m_applyToAllActionPropertySet = new ActionPropertySet();
                }
                MergePropertySets(propertySet, m_applyToAllActionPropertySet, m_contentItems.Count == 0);
            }
            else
            {
                m_applyToAllActionPropertySet = propertySet;
            }
			
			// Now we have the final propertySet we can assign it.
			clientActionControl.ActionProperties = propertySet;

            // Build the APPLYTOALL Execute Checkbox
            if (m_applyToAllExecuteCheckBox == null)
            {
                m_applyToAllExecuteCheckBox = new CheckBox();
                m_applyToAllExecuteCheckBox.Text = Properties.Resources.APPLY_ACTION_TEXT;
                m_applyToAllExecuteCheckBox.Dock = DockStyle.Left;
                m_applyToAllExecuteCheckBox.AutoSize = true;
                m_applyToAllExecuteCheckBox.Name = "APPLYTOALL";
                m_applyToAllExecuteCheckBox.Visible = executePanel.Controls.Count == 0;
                m_applyToAllExecuteCheckBox.CheckedChanged += executeCheckBox_CheckedChanged;
                // Hook up the execute
                executePanel.Controls.Add(m_applyToAllExecuteCheckBox);
				IActionProperty executeProperty;
				m_applyToAllActionPropertySet.TryGetValue(PropertyNames.Execute, out executeProperty);
                if (executeProperty != null)
                {
                    ExecutePropertyController.Hook(executeProperty, m_applyToAllExecuteCheckBox, "CheckedChanged", "Checked");
                }

                m_applyToAllClientActionControl.Tag = m_applyToAllExecuteCheckBox;
                m_applyToAllExecuteCheckBox.Tag = m_applyToAllClientActionControl;
            }

            if (!m_containsApplyToAll)
                return;
            
            // Check to see if the client action control instance already exists as some of the actions
            // have implemented a singleton for the ClientActionControl. This has consequences when attempting
            // sync of ActionProperty's.
			if (m_controls.Contains(clientActionControl))
			{
				m_singleton = true;
			}
            CheckBox executeCheckBox = new CheckBox();
            executeCheckBox.Text = Properties.Resources.APPLY_ACTION_TEXT;
            executeCheckBox.Dock = DockStyle.Left;
            executeCheckBox.AutoSize = true;
            executeCheckBox.Name = contentItem.Id;
            executeCheckBox.Visible = executePanel.Controls.Count == 0;
            executeCheckBox.CheckedChanged += executeCheckBox_CheckedChanged;
            
            // Hook up the execute
            executePanel.Controls.Add(executeCheckBox);
			IActionProperty execProperty;
			propertySet.TryGetValue(PropertyNames.Execute, out execProperty);
            if (execProperty != null)
            {
                ExecutePropertyController.Hook(execProperty, executeCheckBox, "CheckedChanged", "Checked");
            }

            
            // Add client action control to the checkbox TAG
            executeCheckBox.Tag = clientActionControl;

            if (m_singleton)
                return;
            clientActionControl.Name = contentItem.Id;
            clientActionControl.Tag = executeCheckBox;
            clientActionControl.Size = new Size(350, clientActionControl.Height);
            clientActionControl.Dock = DockStyle.Top;
            clientActionControlContainerPanel.Controls.Add(clientActionControl);
            m_controls.Add(clientActionControl);
            clientActionControl.Visible = false;
            // We're only doing this here to ensure the control has a stab at setup before the initial display.  
            // For some ClientActionControl implementations this does not work as the Visible property for controls
            // is linked to Parent.Visisble and makes the control !Visible regardless of any assignment.
            
        }