protected void SaveChoices(
IDeviceSpecificDesigner designer,
String deviceSpecificID,
ICollection choices
) {
DeviceSpecific deviceSpecific;
if (!designer.GetDeviceSpecific(deviceSpecificID, out deviceSpecific))
{
return;
}
if(choices.Count == 0)
{
designer.SetDeviceSpecific(deviceSpecificID, null);
return;
}
if (deviceSpecific == null)
{
deviceSpecific = new DeviceSpecific();
}
else
{
deviceSpecific.Choices.Clear();
}
foreach (ChoiceTreeNode node in choices)
{
node.CommitChanges();
DeviceSpecificChoice choice = node.Choice.RuntimeChoice;
deviceSpecific.Choices.Add(choice);
}
designer.SetDeviceSpecific(deviceSpecificID, deviceSpecific);
}
/////////////////////////////////////////////////////////////////////////
// CONTROL OVERRIDES
/////////////////////////////////////////////////////////////////////////
protected override void AddParsedSubObject(Object obj)
{
if (obj is DeviceSpecific)
{
if (DeviceSpecific == null)
{
DeviceSpecific = (DeviceSpecific)obj;
}
else
{
throw new Exception(
SR.GetString(SR.MobileControl_NoMultipleDeviceSpecifics));
}
}
else
{
base.AddParsedSubObject(obj);
}
}
void IDeviceSpecificDesigner.SetDeviceSpecific(String deviceSpecificParentID, DeviceSpecific ds)
{
Debug.Assert(_defaultDeviceSpecificIdentifier == deviceSpecificParentID);
if (_mobileControl != null)
{
if (null != ds)
{
ds.SetOwner(_mobileControl);
}
_mobileControl.DeviceSpecific = ds;
}
else if (_control != null && ds == null)
{
Debug.Assert(_control is DeviceSpecific);
// Clear the choices if it is a DeviceSpecific control.
((DeviceSpecific)_control).Choices.Clear();
}
if (null != CurrentChoice)
{
if (null == ds)
{
CurrentChoice = null;
}
else
{
// This makes sure that the CurrentChoice value is set to null if
// it was deleted during the deviceSpecific object editing
if (CurrentChoice.Filter.Length == 0)
{
TemplateDeviceFilter = SR.GetString(SR.DeviceFilter_DefaultChoice);
}
else
{
TemplateDeviceFilter = DesignerUtility.ChoiceToUniqueIdentifier(CurrentChoice);
}
}
}
}
bool IDeviceSpecificDesigner.GetDeviceSpecific(String deviceSpecificParentID, out DeviceSpecific ds)
{
Debug.Assert(deviceSpecificParentID == _currentDeviceSpecificID);
ds = null;
if (_cbChoices.Items.Count > 0)
{
ds = new DeviceSpecific();
foreach (ChoiceTreeNode choiceNode in _cbChoices.Items)
{
DeviceSpecificChoice choice = choiceNode.Choice.RuntimeChoice;
ds.Choices.Add(choice);
}
}
return true;
}
private void LoadChoices(DeviceSpecific deviceSpecific)
{
if(deviceSpecific != null)
{
foreach(DeviceSpecificChoice runtimeChoice in deviceSpecific.Choices)
{
debug_CheckChoicesForDuplicate(runtimeChoice);
ChoiceTreeNode newChoiceNode = new ChoiceTreeNode(
null,
runtimeChoice,
_designer
);
newChoiceNode.IncludeArgument = true;
_cbChoices.Items.Add(newChoiceNode);
}
}
UpdateUI();
}
bool IDeviceSpecificDesigner.GetDeviceSpecific(String deviceSpecificParentID, out DeviceSpecific ds)
{
Debug.Assert(_defaultDeviceSpecificIdentifier == deviceSpecificParentID);
ds = ((MobileControl) _mobileControl).DeviceSpecific;
return true;
}
/////////////////////////////////////////////////////////////////////////
// CONTROL OVERRIDES
/////////////////////////////////////////////////////////////////////////
/// <include file='doc\MobileControl.uex' path='docs/doc[@for="MobileControl.AddParsedSubObject"]/*' />
protected override void AddParsedSubObject(Object obj)
{
if (obj is DeviceSpecific)
{
if (DeviceSpecific == null)
{
DeviceSpecific = (DeviceSpecific)obj;
}
else
{
throw new Exception(
SR.GetString(SR.MobileControl_NoMultipleDeviceSpecifics));
}
}
else
{
base.AddParsedSubObject(obj);
}
}
bool IDeviceSpecificDesigner.GetDeviceSpecific(String deviceSpecificParentID, out DeviceSpecific ds)
{
return _dsd.GetDeviceSpecific(deviceSpecificParentID, out ds);
}
public override void Initialize(IComponent component)
{
Debug.Assert(component is System.Web.UI.MobileControls.DeviceSpecific,
"DeviceSpecificControlDesigner.Initialize - Invalid DeviceSpecific Control");
_ds = (System.Web.UI.MobileControls.DeviceSpecific) component;
base.Initialize(component);
_isDuplicate = false;
}
/// <include file='doc\MobileControl.uex' path='docs/doc[@for="MobileControl.RemovedControl"]/*' />
protected override void RemovedControl(Control control) {
MobileControl ctl = control as MobileControl;
if (ctl != null) {
ctl.InvalidateParentStyles();
}
// Remove the cached _deviceSpecific.
DeviceSpecific deviceSpecific = control as DeviceSpecific;
if (deviceSpecific != null) {
_deviceSpecific.SetOwner(null);
_deviceSpecific = null;
}
_cachedInnerText = null;
base.RemovedControl(control);
}
internal DeviceSpecificChoiceCollection(DeviceSpecific owner)
{
_owner = owner;
}
void IDeviceSpecificDesigner.SetDeviceSpecific(String deviceSpecificParentID, DeviceSpecific ds)
{
Style style = (Style) _styleSheet[deviceSpecificParentID];
Debug.Assert(null != style, "style is null in IDeviceSpecificDesigner.SetDeviceSpecific");
if (null != ds)
{
ds.SetOwner((MobileControl) _styleSheet);
}
style.DeviceSpecific = ds;
if (CurrentChoice != null && 0 == String.Compare(CurrentStyle.Name, deviceSpecificParentID, StringComparison.OrdinalIgnoreCase))
{
if (ds == null)
{
CurrentChoice = null;
}
else
{
// This makes sure that the CurrentChoice value is set to null is
// it was deleted during the deviceSpecific object editing
if (CurrentChoice.Filter.Length == 0)
{
TemplateDeviceFilter = SR.GetString(SR.DeviceFilter_DefaultChoice);
}
else
{
TemplateDeviceFilter = DesignerUtility.ChoiceToUniqueIdentifier(CurrentChoice);
}
}
}
}
bool IDeviceSpecificDesigner.GetDeviceSpecific(String deviceSpecificParentID, out DeviceSpecific ds)
{
Style style = (Style) _styleSheet[deviceSpecificParentID];
if (null == style)
{
ds = null;
return false;
}
else
{
ds = style.DeviceSpecific;
return true;
}
}
private DeviceSpecificChoice GetChoiceFromIdentifier(String choiceIdentifier, DeviceSpecific ds)
{
if (null == ds)
{
return null;
}
Debug.Assert(ds.Choices != null);
foreach (DeviceSpecificChoice choice in ds.Choices)
{
if (DesignerUtility.ChoiceToUniqueIdentifier(choice).Equals(choiceIdentifier) ||
(choice.Filter.Length == 0 &&
choiceIdentifier.Equals(SR.GetString(SR.DeviceFilter_DefaultChoice))))
{
return choice;
}
}
return null;
}
internal static DeviceSpecificChoice FindChoiceInDeviceSpecific(string activeDeviceFilter, DeviceSpecific ds)
{
if (ds != null)
{
string filterFromActiveDeviceFilter = GetFilterFromActiveDeviceFilter(activeDeviceFilter);
string argumentFromActiveDeviceFilter = GetArgumentFromActiveDeviceFilter(activeDeviceFilter);
foreach (DeviceSpecificChoice choice in ds.get_Choices())
{
if ((string.Compare(choice.get_Filter(), filterFromActiveDeviceFilter, true) == 0) && (string.Compare(choice.get_Argument(), argumentFromActiveDeviceFilter, true) == 0))
{
return choice;
}
}
}
return null;
}
void IRefreshableDeviceSpecificEditor.Refresh(String deviceSpecificID, DeviceSpecific ds)
{
_ds = ds;
FillChoicesComboBox();
FillSchemasComboBox();
SetSchemaValue();
UpdateControlEnabling();
}
internal static object GetDeviceSpecificOwner(DeviceSpecific deviceSpecific)
{
return typeof(DeviceSpecific).InvokeMember("_owner", BindingFlags.GetField | BindingFlags.NonPublic | BindingFlags.Instance, null, deviceSpecific, null);
}
void IDeviceSpecificDesigner.SetDeviceSpecific(String deviceSpecificParentID, DeviceSpecific ds)
{
_ds = ds;
_dsd.SetDeviceSpecific(deviceSpecificParentID, ds);
}
internal static void SetDeviceSpecificOwner(DeviceSpecific deviceSpecific, MobileControl control)
{
typeof(DeviceSpecific).InvokeMember("SetOwner", BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, deviceSpecific, new object[] { control });
}
void IDeviceSpecificDesigner.SetDeviceSpecific(String deviceSpecificParentID, DeviceSpecific ds)
{
Debug.Assert(_defaultDeviceSpecificIdentifier == deviceSpecificParentID);
if (null != ds)
{
ds.SetOwner((MobileControl) _mobileControl);
}
_mobileControl.DeviceSpecific = ds;
}
private void LoadChoices(DeviceSpecific deviceSpecific)
{
_appliedFiltersList.TvList.Nodes.Clear();
if(deviceSpecific != null)
{
foreach(DeviceSpecificChoice runtimeChoice in deviceSpecific.Choices)
{
LoadChoice(runtimeChoice);
}
}
EnsureDefaultFilterAvailableXorApplied();
}
internal DeviceSpecificChoiceCollection(DeviceSpecific owner)
{
_owner = owner;
}
void IRefreshableDeviceSpecificEditor.Refresh(
String deviceSpecificID,
DeviceSpecific deviceSpecific
) {
if (_currentDeviceSpecificID != null)
{
CacheCurrentState();
}
if(!RestoreState(deviceSpecificID))
{
// If we could not restore the state, we have not edited
// this DeviceSpecific yet and need to load choices.
LoadChoices(deviceSpecific);
}
UpdateUI();
}
void IRefreshableDeviceSpecificEditor.Refresh(
String deviceSpecificID,
DeviceSpecific deviceSpecific
) {
if (_currentDeviceSpecificID != null)
{
CacheCurrentState();
}
_cbChoices.Items.Clear();
if (!RestoreState(deviceSpecificID))
{
LoadChoices(deviceSpecific);
if(!ValidateLoadedChoices())
{
_designer.RefreshHeader(
MobileControlDesigner.MergingContextProperties
);
}
}
UpdateUI();
}
bool IDeviceSpecificDesigner.GetDeviceSpecific(String deviceSpecificParentID, out DeviceSpecific ds)
{
Debug.Assert(_defaultDeviceSpecificIdentifier == deviceSpecificParentID);
ds = CurrentDeviceSpecific;
return true;
}
void IDeviceSpecificDesigner.SetDeviceSpecific(String deviceSpecificParentID, DeviceSpecific ds)
{
Debug.Assert(_currentDeviceSpecificID != null);
_cbChoices.Items.Clear();
LoadChoices(ds);
UpdateUI();
}
public override void Initialize(IComponent component)
{
base.Initialize(component);
this._deviceSpecific = (DeviceSpecific) component;
IDesignerHost service = (IDesignerHost) this.GetService(typeof(IDesignerHost));
if (service != null)
{
service.LoadComplete += new EventHandler(this.OnLoadComplete);
}
this._deviceSpecificSelectionProvider = (IDeviceSpecificSelectionProvider) this.GetService(typeof(IDeviceSpecificSelectionProvider));
if (this._deviceSpecificSelectionProvider != null)
{
foreach (DeviceSpecificChoice choice in this._deviceSpecific.get_Choices())
{
string filterName = Utils.CreateUniqueChoiceName(choice);
if (!this._deviceSpecificSelectionProvider.FilterExists(filterName))
{
this._deviceSpecificSelectionProvider.AddFilter(filterName);
}
}
}
}
