Volian/SourceCode
8
0
Fork 0
Code Issues Pull Requests 1 Projects Releases Wiki Activity

Commit for development environment setup

Browse Source
This commit is contained in:
Chris Glavan
2023-06-19 16:12:33 -04:00
parent be72063a3c
commit bbce2ad0a6
2209 changed files with 1171775 additions and 625 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
PROMS/csla20cs-2.1.4-070223/csla20cs/OLDcsla20cs/Csla/Windows/BindingSourceRefresh.cs Normal file
View File

@@ -0,0 +1,95 @@
using System;
using System.ComponentModel;
using System.Collections.Generic;
using System.Windows.Forms;
// code from Bill McCarthy
// http://msmvps.com/bill/archive/2005/10/05/69012.aspx
// used with permission
namespace Csla.Windows
{
/// <summary>
/// Windows Forms extender control that resolves the
/// data refresh issue with data bound detail controls
/// as discussed in Chapter 5.
/// </summary>
[DesignerCategory("")]
[ProvideProperty("ReadValuesOnChange", typeof(BindingSource))]
public class BindingSourceRefresh : Component, IExtenderProvider
{
private Dictionary<BindingSource, bool> _sources = new Dictionary<BindingSource, bool>();
/// <summary>
/// Creates an instance of the object.
/// </summary>
/// <param name="container">Container of the control.</param>
public BindingSourceRefresh(IContainer container)
{
container.Add(this);
}
/// <summary>
/// Gets a value indicating whether the extender control
/// can extend the specified control.
/// </summary>
/// <param name="extendee">The control to be extended.</param>
/// <remarks>
/// This control only extends <see cref="BindingSource"/> controls.
/// </remarks>
public bool CanExtend(object extendee)
{
if (extendee is BindingSource)
return true;
return false;
}
/// <summary>
/// Gets the value of the custom ReadValuesOnChange extender
/// property added to extended controls.
/// </summary>
/// <param name="source">Control being extended.</param>
public bool GetReadValuesOnChange(BindingSource source)
{
if (_sources.ContainsKey(source))
return _sources[source];
return false;
}
/// <summary>
/// Sets the value of the custom ReadValuesOnChange extender
/// property added to extended controls.
/// </summary>
/// <param name="source">Control being extended.</param>
/// <param name="value">New value of property.</param>
/// <remarks></remarks>
public void SetReadValuesOnChange(
BindingSource source, bool value)
{
if (_sources.ContainsKey(source))
_sources[source] = value;
else
_sources.Add(source, value);
if (value)
{
// hook
source.BindingComplete +=
new BindingCompleteEventHandler(Source_BindingComplete);
}
else
{
// unhook
source.BindingComplete -=
new BindingCompleteEventHandler(Source_BindingComplete);
}
}
private void Source_BindingComplete(
object sender, BindingCompleteEventArgs e)
{
e.Binding.ReadValue();
}
}
}

222
PROMS/csla20cs-2.1.4-070223/csla20cs/OLDcsla20cs/Csla/Windows/ReadWriteAuthorization.cs Normal file
View File

@@ -0,0 +1,222 @@
using System;
using System.ComponentModel;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Reflection;
namespace Csla.Windows
{
/// <summary>
/// Windows Forms extender control that automatically
/// enables and disables detail form controls based
/// on the authorization settings from a CSLA .NET
/// business object.
/// </summary>
[DesignerCategory("")]
[ProvideProperty("ApplyAuthorization", typeof(Control))]
public class ReadWriteAuthorization : Component, IExtenderProvider
{
private Dictionary<Control, bool> _sources =
new Dictionary<Control, bool>();
/// <summary>
/// Creates an instance of the object.
/// </summary>
/// <param name="container">The container of the control.</param>
public ReadWriteAuthorization(IContainer container)
{ container.Add(this); }
/// <summary>
/// Gets a value indicating whether the extender control
/// can extend the specified control.
/// </summary>
/// <param name="extendee">The control to be extended.</param>
/// <remarks>
/// Any control implementing either a ReadOnly property or
/// Enabled property can be extended.
/// </remarks>
public bool CanExtend(object extendee)
{
if (IsPropertyImplemented(extendee, "ReadOnly")
|| IsPropertyImplemented(extendee, "Enabled"))
return true;
else
return false;
}
/// <summary>
/// Gets the custom ApplyAuthorization extender
/// property added to extended controls.
/// </summary>
/// <param name="source">Control being extended.</param>
public bool GetApplyAuthorization(Control source)
{
if (_sources.ContainsKey(source))
return _sources[source];
else
return false;
}
/// <summary>
/// Sets the custom ApplyAuthorization extender
/// property added to extended controls.
/// </summary>
/// <param name="source">Control being extended.</param>
/// <param name="value">New value of property.</param>
public void SetApplyAuthorization(Control source, bool value)
{
if (_sources.ContainsKey(source))
_sources[source] = value;
else
_sources.Add(source, value);
}
/// <summary>
/// Causes the ReadWriteAuthorization control
/// to apply authorization rules from the business
/// object to all extended controls on the form.
/// </summary>
/// <remarks>
/// Call this method to refresh the display of detail
/// controls on the form any time the authorization
/// rules may have changed. Examples include: after
/// a user logs in or out, and after an object has
/// been updated, inserted, deleted or retrieved
/// from the database.
/// </remarks>
public void ResetControlAuthorization()
{
foreach (KeyValuePair<Control, bool> item in _sources)
{
if (item.Value)
{
// apply authorization rules
ApplyAuthorizationRules(item.Key);
}
}
}
private void ApplyAuthorizationRules(Control control)
{
foreach (Binding binding in control.DataBindings)
{
// get the BindingSource if appropriate
if (binding.DataSource is BindingSource)
{
BindingSource bs =
(BindingSource)binding.DataSource;
// get the BusinessObject if appropriate
Csla.Security.IAuthorizeReadWrite ds =
bs.Current as Csla.Security.IAuthorizeReadWrite;
if (ds != null)
{
// get the object property name
string propertyName =
binding.BindingMemberInfo.BindingField;
ApplyReadRules(
control, binding,
ds.CanReadProperty(propertyName));
ApplyWriteRules(
control, binding,
ds.CanWriteProperty(propertyName));
}
}
}
}
private void ApplyReadRules(
Control ctl, Binding binding,
bool canRead)
{
// enable/disable reading of the value
if (canRead)
{
bool couldRead = ctl.Enabled;
ctl.Enabled = true;
binding.Format -=
new ConvertEventHandler(ReturnEmpty);
if (!couldRead) binding.ReadValue();
}
else
{
ctl.Enabled = false;
binding.Format +=
new ConvertEventHandler(ReturnEmpty);
// clear the value displayed by the control
PropertyInfo propertyInfo =
ctl.GetType().GetProperty(binding.PropertyName,
BindingFlags.FlattenHierarchy |
BindingFlags.Instance |
BindingFlags.Public);
if (propertyInfo != null)
{
propertyInfo.SetValue(ctl,
GetEmptyValue(
Utilities.GetPropertyType(
propertyInfo.PropertyType)),
new object[] { });
}
}
}
private void ApplyWriteRules(
Control ctl, Binding binding,
bool canWrite)
{
if (ctl is Label) return;
// enable/disable writing of the value
PropertyInfo propertyInfo =
ctl.GetType().GetProperty("ReadOnly",
BindingFlags.FlattenHierarchy |
BindingFlags.Instance |
BindingFlags.Public);
if (propertyInfo != null)
{
bool couldWrite =
(!(bool)propertyInfo.GetValue(
ctl, new object[] { }));
propertyInfo.SetValue(
ctl, !canWrite, new object[] { });
if ((!couldWrite) && (canWrite))
binding.ReadValue();
}
else
{
bool couldWrite = ctl.Enabled;
ctl.Enabled = canWrite;
if ((!couldWrite) && (canWrite))
binding.ReadValue();
}
}
private void ReturnEmpty(
object sender, ConvertEventArgs e)
{
e.Value = GetEmptyValue(e.DesiredType);
}
private object GetEmptyValue(Type desiredType)
{
object result = null;
if (desiredType.IsValueType)
result = Activator.CreateInstance(desiredType);
return result;
}
private static bool IsPropertyImplemented(
object obj, string propertyName)
{
if (obj.GetType().GetProperty(propertyName,
BindingFlags.FlattenHierarchy |
BindingFlags.Instance |
BindingFlags.Public) != null)
return true;
else
return false;
}
}
}