public XamlBindingDefinition(Control target, PerspexProperty targetProperty, PropertyPath sourcePropertyPath, BindingMode bindingMode)
{
this.target = target;
this.targetProperty = targetProperty;
this.sourcePropertyPath = sourcePropertyPath;
this.bindingMode = bindingMode;
}
public ParameterKey(PropertyPath propertyPath, bool rightKey)
{
DebugCheck.NotNull(propertyPath);
_propertyPath = propertyPath;
_rightKey = rightKey;
}
public ColumnPropertyDescriptor(DisplayColumn displayColumn, string name, PropertyPath propertyPath, PivotKey pivotKey)
: base(name, displayColumn.GetAttributes(pivotKey).ToArray())
{
DisplayColumn = displayColumn;
PropertyPath = propertyPath;
PivotKey = pivotKey;
}
public static object GetValue(ComponentPath path, PropertyPath prop, bool resolveDataContext = true)
{
if (resolveDataContext && path.Component is DataContext)
return (path.Component as DataContext).GetValue(prop);
else
return prop.GetValue(path.Component, null);
}
private NotNullConditionConfiguration(EntityMappingConfiguration owner, NotNullConditionConfiguration source)
{
Contract.Requires(source != null);
Contract.Requires(owner != null);
_entityMappingConfiguration = owner;
PropertyPath = source.PropertyPath;
}
private NotNullConditionConfiguration(EntityMappingConfiguration owner, NotNullConditionConfiguration source)
{
DebugCheck.NotNull(source);
DebugCheck.NotNull(owner);
_entityMappingConfiguration = owner;
PropertyPath = source.PropertyPath;
}
internal NotNullConditionConfiguration(
EntityMappingConfiguration entityMapConfiguration, PropertyPath propertyPath)
{
DebugCheck.NotNull(entityMapConfiguration);
DebugCheck.NotNull(propertyPath);
_entityMappingConfiguration = entityMapConfiguration;
PropertyPath = propertyPath;
}
internal NotNullConditionConfiguration(
EntityMappingConfiguration entityMapConfiguration, PropertyPath propertyPath)
{
Contract.Requires(entityMapConfiguration != null);
Contract.Requires(propertyPath != null);
_entityMappingConfiguration = entityMapConfiguration;
PropertyPath = propertyPath;
}
public ManyToManyCustomizer(IModelExplicitDeclarationsHolder explicitDeclarationsHolder, PropertyPath propertyPath, ICustomizersHolder customizersHolder)
{
if (explicitDeclarationsHolder == null)
{
throw new ArgumentNullException("explicitDeclarationsHolder");
}
explicitDeclarationsHolder.AddAsManyToManyRelation(propertyPath.LocalMember);
this.propertyPath = propertyPath;
this.customizersHolder = customizersHolder;
}
private void GoToSearchResult(PropertyPath propertyPath)
{
if (null == _searcher || !Equals(_searcher.SearchState, GetSearchState()))
{
return;
}
if (null == propertyPath)
{
return;
}
AvailableFieldsTree.SelectColumn(propertyPath);
}
private void EnsureViewRoundTrips(ViewInfo viewInfo)
{
IEnumerable<PropertyPath> emptyPropertyPaths = new PropertyPath[0];
ValidateViewInfo(viewInfo);
var transformer = new DocumentViewTransformer();
var viewInfoDocument = transformer.MakeIntoDocumentView(viewInfo, ref emptyPropertyPaths);
Assert.AreEqual(typeof(SkylineDocument), viewInfoDocument.ParentColumn.PropertyType);
ValidateViewInfo(viewInfoDocument);
var viewInfoRoundTrip = transformer.ConvertFromDocumentView(viewInfoDocument, ref emptyPropertyPaths);
Assert.AreEqual(viewInfo.ParentColumn.PropertyType, viewInfoRoundTrip.ParentColumn.PropertyType);
Assert.AreEqual(viewInfo.GetViewSpec(), viewInfoRoundTrip.GetViewSpec());
}
void btnEditVideo_Click(object sender, EventArgs e)
{
if (txtVideo.Text.Length > 0) {
try {
PropertyPath pp = new PropertyPath(txtVideo.Text);
FilePropertyValue fpv = WAFContext.Session.GetProperty<FilePropertyValue>(pp);
WAFContext.StartWorkflowMethod(new WAF.Engine.Workflow.Methods.WMEditContent(pp.ContentKey, true));
} catch (Exception err) {
WAFContext.Session.Notify(err);
}
}
}
public void PropertyPath_ToString_return_correct_value()
{
var propertyPath = new PropertyPath(
new List<PropertyInfo>
{
new MockPropertyInfo(typeof(int), "P1"),
new MockPropertyInfo(typeof(int), "P2"),
new MockPropertyInfo(typeof(int), "P3")
});
Assert.Equal("P1.P2.P3", propertyPath.ToString());
}
public DataContextChangeSynchronizer(PerspexObject target, PerspexProperty targetProperty,
PropertyPath sourcePropertyPath, object source, ITypeConverterProvider typeConverterProvider)
{
Guard.ThrowIfNull(target, nameof(target));
Guard.ThrowIfNull(targetProperty, nameof(targetProperty));
Guard.ThrowIfNull(sourcePropertyPath, nameof(sourcePropertyPath));
Guard.ThrowIfNull(source, nameof(source));
Guard.ThrowIfNull(typeConverterProvider, nameof(typeConverterProvider));
this.bindingEndpoint = new TargetBindingEndpoint(target, targetProperty);
this.sourceEndpoint = new ObservablePropertyBranch(source, sourcePropertyPath);
this.targetPropertyTypeConverter = typeConverterProvider.GetTypeConverter(targetProperty.PropertyType);
}
public PropertyChangedNotifier(DependencyObject propertySource, PropertyPath property, Action<DependencyObject, object> propertyChangedAction)
{
if (null == propertySource) throw new ArgumentNullException("propertySource");
if (null == property) throw new ArgumentNullException("property");
if (null == propertyChangedAction) throw new ArgumentNullException("propertyChangedAction");
this.propertyChangedAction = propertyChangedAction;
this.propertySource = new WeakReference(propertySource);
Binding binding = new Binding();
binding.Path = property;
binding.Mode = BindingMode.OneWay;
binding.Source = propertySource;
BindingOperations.SetBinding(this, ValueProperty, binding);
}
protected void Page_Load(object sender, EventArgs e)
{
btnSelectVideo.Click += new EventHandler(btnSelectVideo_Click);
chkUseOrgFile.CheckedChanged += new EventHandler(chkUseOrgFile_CheckedChanged);
btnEditVideo.Click += new EventHandler(btnEditVideo_Click);
txtWidth.Attributes.Add("onchange", "updateHeight();");
txtHeight.Attributes.Add("onchange", "updateWidth();");
txtWidth.Attributes.Add("onkeyup", "updateHeight();");
txtHeight.Attributes.Add("onkeyup", "updateWidth();");
// txtQuality.Attributes.Add("disabled", "disabled");
ddlQuality.Attributes.Add("onchange", "qualityChanged();");
ddlFormat.Attributes.Add("onchange", "formatChanged();");
NameValueCollection nvc = WebDialogueContext.GetDialogueParameter<NameValueCollection>("Parameters");
if (!IsPostBack) {
txtHeight.Text = Utils.GetIntegerOnly(nvc["y"], 240).ToString();
txtWidth.Text = Utils.GetIntegerOnly(nvc["x"], 320).ToString();
chkAutoplay.Checked = (nvc["autoplay"] + "") == "1";
PropertyPath pp = new PropertyPath(nvc["VideoFile"]);
FilePropertyValue fpv = WAFContext.Session.GetProperty<FilePropertyValue>(pp);
chkUseOrgFile.Checked = nvc["use_org_file"] == "1";
chkUseOrgFile.Visible = fpv.FileExtension.ToLower() == ".flv" || fpv.FileExtension.ToLower() == ".mp4";
ddlQuality.Enabled = !(chkUseOrgFile.Visible && chkUseOrgFile.Checked);
if (fpv.VideoHeight > 0 && fpv.VideoWidth > 0) {
ListItem it = new ListItem();
it.Value = ((double)fpv.VideoWidth / (double)fpv.VideoHeight).ToString("0.0000000000000").Replace(",", ".");
it.Text = "Original ratio " + ((double)fpv.VideoWidth / (double)fpv.VideoHeight).ToString("0.00").Replace(",", ".") + " (" + fpv.VideoWidth + "x" + fpv.VideoHeight + ")";
ddlFormat.Items.Insert(0, it);
}
findbestFormat();
txtQuality.Text = Utils.GetIntegerOnly(nvc["bitrate"], 500).ToString();
txtVideo.Text = nvc["VideoFile"] + "";
findbestQuality();
updateVideoFile();
}
MainButton buttonOk = new MainButton();
buttonOk.Text = Local.Text("Web.WAF.Dialogues.Editor.EditVideoButtonOk");
//b.Text = "Ok";
Controls.Add(buttonOk);
WebDialogueContext.AddDialogueButton(buttonOk);
buttonOk.Click += new EventHandler(buttonOk_Click);
}
public ObservableExpression(object baseValue, PropertyPath propertyPath)
{
observableValue = new ObservableValue();
observableValue.ValueChanged += (sender, e) => ValueChanged.Raise(this, e);
if (propertyPath.IsEmpty)
{
observableValue.Value = baseValue;
ValueType = baseValue != null ? baseValue.GetType() : null;
}
else
{
propertyPathElement = propertyPath.Elements.Last();
baseObserver = new ObservableExpression(baseValue, propertyPath.GetBasePropertyPath());
baseObserver.ValueChanged += (sender, e) => SetDelegateObserverBaseValue();
SetDelegateObserverBaseValue();
}
}
public static PropertyPath FigureBinding(ComponentPath path, PropertyChangedEventHandler handler, bool resolveDataContext)
{
Type type;
if (resolveDataContext && path.Component is DataContext)
type = (path.Component as DataContext).Type;
else
type = path.Component.GetType();
var prop = new PropertyPath(path.Property, type, true);
if (handler != null)
{
if (resolveDataContext && path.Component is DataContext)
(path.Component as DataContext).AddDependentProperty(prop, handler);
else
prop.AddHandler(path.Component, handler);
}
return prop;
}
private void AddFilter(DataboundGridForm databoundGridForm, PropertyPath propertyPath,
IFilterOperation filterOperation, string filterOperand)
{
var viewEditor = ShowDialog<ViewEditor>(databoundGridForm.NavBar.CustomizeView);
RunUI(() =>
{
viewEditor.ViewName = "Custom View";
viewEditor.TabControl.SelectTab(1);
Assert.IsTrue(viewEditor.FilterTab.TrySelectColumn(propertyPath));
int iFilter = viewEditor.ViewInfo.Filters.Count;
viewEditor.FilterTab.AddSelectedColumn();
viewEditor.FilterTab.SetFilterOperation(iFilter, filterOperation);
if (null != filterOperand)
{
viewEditor.FilterTab.SetFilterOperand(iFilter, filterOperand);
}
});
OkDialog(viewEditor, viewEditor.OkDialog);
WaitForConditionUI(() => databoundGridForm.IsComplete);
}
protected virtual void OnActivatePropertyPath(PropertyPath propertyPath)
{
}
public void ActivatePropertyPath(PropertyPath propertyPath)
{
if (null != PropertyPathActivated)
{
PropertyPathActivated(this, new PropertyPathEventArgs(propertyPath));
}
}
public OneToManyCustomizer(PropertyPath propertyPath, ICustomizersHolder customizersHolder)
{
this.propertyPath = propertyPath;
this.customizersHolder = customizersHolder;
}
public void AddCustomizer(PropertyPath member, Action <ICollectionPropertiesMapper> propertyCustomizer)
{
AddCustomizer(collectionCustomizers, member, propertyCustomizer);
}
public void AddCustomizer(PropertyPath member, Action <IDynamicComponentAttributesMapper> propertyCustomizer)
{
AddCustomizer(dynamicComponentCustomizers, member, propertyCustomizer);
}
public void InvokeCustomizers(PropertyPath member, IAnyMapper mapper)
{
InvokeCustomizers(anyCustomizers, member, mapper);
}
/// <summary>
/// Initializes a new <see cref="CommandBindingExtension"/> instance.
/// </summary>
/// <param name="commandPath">The command to which the event is to be bound.</param>
/// <param name="passEventArgumentsToCommand">Determines whether the arguments of the event to which the command gets bound should be passed to the command as a parameter.</param>
public CommandBindingExtension(PropertyPath commandPath, bool passEventArgumentsToCommand)
{
this.CommandPath = commandPath;
this.PassEventArgumentsToCommand = passEventArgumentsToCommand;
}
public void InvokeCustomizers(PropertyPath member, IMapKeyMapper mapper)
{
InvokeCustomizers(mapKeyElementCustomizers, member, mapper);
}
public void InvokeCustomizers(PropertyPath member, IOneToManyMapper mapper)
{
InvokeCustomizers(collectionRelationOneToManyCustomizers, member, mapper);
}
public void InvokeCustomizers(PropertyPath member, IElementMapper mapper)
{
InvokeCustomizers(collectionRelationElementCustomizers, member, mapper);
}
public void InvokeCustomizers(PropertyPath member, IDynamicComponentAttributesMapper mapper)
{
InvokeCustomizers(dynamicComponentCustomizers, member, mapper);
}
public void InvokeCustomizers(PropertyPath member, IComponentAsIdAttributesMapper mapper)
{
InvokeCustomizers(componentAsIdPropertyCustomizers, member, mapper);
}
public void InvokeCustomizers(PropertyPath member, IIdBagPropertiesMapper mapper)
{
InvokeCustomizers(collectionCustomizers, member, mapper);
InvokeCustomizers(idBagCustomizers, member, mapper);
}
public void InvokeCustomizers(PropertyPath member, IListPropertiesMapper mapper)
{
InvokeCustomizers(collectionCustomizers, member, mapper);
InvokeCustomizers(listCustomizers, member, mapper);
}
=> Binding = new Binding()
{
Source = this,
Path = new PropertyPath(nameof(Value))
};
public void AddCustomizer(PropertyPath member, Action <IAnyMapper> propertyCustomizer)
{
AddCustomizer(anyCustomizers, member, propertyCustomizer);
}
public TextBlockDataContextListener(PropertyPath path, ResolveMode resolveMode, bool appendColon)
: base(path, resolveMode)
{
_appendColon = appendColon;
}
private string MakeUniqueName(HashSet<string> columnNames, PropertyPath propertyPath)
{
return MakeUniqueName(columnNames, "COLUMN_" + propertyPath); // Not L10N
}
public void Parameter(
PropertyPath propertyPath,
string parameterName,
string originalValueParameterName = null)
{
DebugCheck.NotNull(propertyPath);
DebugCheck.NotEmpty(parameterName);
_parameterNames[propertyPath]
= Tuple.Create(parameterName, originalValueParameterName);
}
public void AddCustomizer(PropertyPath member, Action <IElementMapper> collectionRelationElementCustomizer)
{
AddCustomizer(collectionRelationElementCustomizers, member, collectionRelationElementCustomizer);
}
public void AddCustomizer(PropertyPath member, Action <IMapKeyMapper> mapKeyElementCustomizer)
{
AddCustomizer(mapKeyElementCustomizers, member, mapKeyElementCustomizer);
}
public void AddCustomizer(PropertyPath member, Action <IComponentAsIdAttributesMapper> propertyCustomizer)
{
AddCustomizer(componentAsIdPropertyCustomizers, member, propertyCustomizer);
}
/// <summary>
/// Tests using the "Remove Precursor Peaks" button.
/// This test removes peaks from the "614" precursor of the "SIV..." peptide.
/// It removes peaks from the replicates "S_1" and "S_3".
/// </summary>
private void TestRemovePrecursorPeaks()
{
RunUI(() => SkylineWindow.OpenFile(TestFilesDir.GetTestPath("RowActionsTest.sky")));
RunUI(() => SkylineWindow.ShowDocumentGrid(true));
var documentGrid = FindOpenForm <DocumentGridForm>();
RunUI(() => documentGrid.DataboundGridControl.ChooseView(new ViewName(PersistedViews.MainGroup.Id,
"TransitionAreas")));
WaitForConditionUI(() => documentGrid.IsComplete);
var peptideDocNode = SkylineWindow.Document.Peptides.Skip(1).First();
StringAssert.StartsWith(peptideDocNode.Peptide.Sequence, "SIV");
Assert.AreEqual(2, peptideDocNode.TransitionGroupCount);
foreach (var precursor in peptideDocNode.TransitionGroups)
{
Assert.AreEqual(3, precursor.Results.Count);
for (int iReplicate = 0; iReplicate < 3; iReplicate++)
{
Assert.AreEqual(1, precursor.Results[iReplicate].Count);
var precursorChromInfo = precursor.Results[iReplicate].First();
Assert.IsNotNull(precursorChromInfo.Area);
}
}
RunUI(() =>
{
var colPeptide = documentGrid.FindColumn(PropertyPath.Parse("Precursor.Peptide"));
Assert.IsNotNull(colPeptide);
var colPrecursorMz = documentGrid.FindColumn(PropertyPath.Parse("Precursor.Mz"));
Assert.IsNotNull(colPrecursorMz);
var colReplicate = documentGrid.FindColumn(PropertyPath.Parse("Results!*.Value.PrecursorResult.PeptideResult.ResultFile.Replicate"));
Assert.IsNotNull(colReplicate);
for (int iRow = 0; iRow < documentGrid.RowCount; iRow++)
{
var row = documentGrid.DataGridView.Rows[iRow];
var peptide = (Skyline.Model.Databinding.Entities.Peptide)row.Cells[colPeptide.Index].Value;
var precursorMz = (double)row.Cells[colPrecursorMz.Index].Value;
var replicate = (Replicate)row.Cells[colReplicate.Index].Value;
if (peptide.Sequence.StartsWith("SIV") && Math.Abs(precursorMz - 614) < 1 &&
(replicate.Name == "S_1" || replicate.Name == "S_3"))
{
row.Selected = true;
}
}
});
var menuItem = GetDropDownItems(documentGrid.NavBar.ActionsButton)
.FirstOrDefault(item => item.Text == RemovePeaksAction.Precursors.MenuItemText);
Assert.IsNotNull(menuItem);
var confirmDialog = ShowDialog <AlertDlg>(menuItem.PerformClick);
string expectedMessage = string.Format(
Resources.RemovePrecursors_GetConfirmRemoveMessage_Are_you_sure_you_want_to_remove_these__0__peaks_from_one_precursor_,
2);
Assert.AreEqual(expectedMessage, confirmDialog.Message);
OkDialog(confirmDialog, confirmDialog.ClickOk);
peptideDocNode = SkylineWindow.Document.Peptides.Skip(1).First();
Assert.AreEqual(2, peptideDocNode.TransitionGroupCount);
for (int iPrecursor = 0; iPrecursor < 2; iPrecursor++)
{
var precursor = (TransitionGroupDocNode)peptideDocNode.Children[iPrecursor];
Assert.AreEqual(3, precursor.Results.Count);
for (int iReplicate = 0; iReplicate < 3; iReplicate++)
{
Assert.AreEqual(1, precursor.Results[iReplicate].Count);
var precursorChromInfo = precursor.Results[iReplicate].First();
bool shouldHaveValue = iPrecursor == 0 || iReplicate == 1;
Assert.AreEqual(shouldHaveValue, precursorChromInfo.Area.HasValue);
}
}
var alertDlg = ShowDialog <AlertDlg>(SkylineWindow.NewDocument);
OkDialog(alertDlg, alertDlg.ClickNo);
}
public void AddCustomizer(PropertyPath member, Action <IIdBagPropertiesMapper> propertyCustomizer)
{
AddCustomizer(idBagCustomizers, member, propertyCustomizer);
}
private static PropertyPath ClonePropertyPath(PropertyPath path)
{
return(new PropertyPath(path.Path, path.PathParameters));
}
public void AddCustomizer(PropertyPath member, Action <IMapPropertiesMapper> propertyCustomizer)
{
AddCustomizer(mapCustomizers, member, propertyCustomizer);
}
private ColumnSpec ConvertReportColumn(ReportColumn reportColumn)
{
var identifierPath = PropertyPath.Root;
var databindingTableAttribute = GetDatabindingTableAttribute(reportColumn);
var component = reportColumn.Table;
string oldCaption = null;
foreach (string part in reportColumn.Column.Parts)
{
PropertyPath propertyPath;
if (part.StartsWith(AnnotationDef.ANNOTATION_PREFIX))
{
string annotationName = AnnotationDef.GetColumnDisplayName(part);
if (component == typeof(DbProteinResult))
{
propertyPath = PropertyPath.Root.Property("Replicate").Property(AnnotationDef.ANNOTATION_PREFIX + annotationName); // Not L10N
}
else
{
propertyPath = PropertyPath.Root.Property(AnnotationDef.ANNOTATION_PREFIX + annotationName);
}
oldCaption = annotationName;
component = typeof(string);
}
else if (RatioPropertyAccessor.IsRatioOrRdotpProperty(part))
{
propertyPath = null;
if (component == typeof(DbPeptideResult))
{
const string prefixPeptideRatio = "ratio_Ratio"; // Not L10N
string labelName, standardName;
if (part.StartsWith(prefixPeptideRatio))
{
if (TryParseLabelNames(part.Substring(prefixPeptideRatio.Length), out labelName, out standardName))
{
propertyPath = PropertyPath.Root.Property(RatioPropertyDescriptor.MakePropertyName(
RatioPropertyDescriptor.RATIO_PREFIX, labelName, standardName));
}
}
const string prefixPeptideRdotp = "rdotp_DotProduct"; // Not L10N
if (part.StartsWith(prefixPeptideRdotp))
{
if (TryParseLabelNames(part.Substring(prefixPeptideRdotp.Length), out labelName, out standardName))
{
propertyPath = PropertyPath.Root.Property(RatioPropertyDescriptor.MakePropertyName(
RatioPropertyDescriptor.RDOTP_PREFIX, labelName, standardName));
}
}
}
else if (component == typeof(DbPrecursorResult))
{
const string prefixPrecursorRatio = "ratio_TotalAreaRatioTo"; // Not L10N
const string prefixPrecursorRdotp = "rdotp_DotProductTo"; // Not L10N
if (part.StartsWith(prefixPrecursorRatio))
{
propertyPath = PropertyPath.Root.Property(
RatioPropertyDescriptor.MakePropertyName(RatioPropertyDescriptor.RATIO_PREFIX, part.Substring(prefixPrecursorRatio.Length)));
}
else if (part.StartsWith(prefixPrecursorRdotp))
{
propertyPath = PropertyPath.Root.Property(
RatioPropertyDescriptor.MakePropertyName(RatioPropertyDescriptor.RDOTP_PREFIX,
part.Substring(prefixPrecursorRdotp.Length)));
}
}
else if (component == typeof(DbTransitionResult))
{
const string prefixTransitionRatio = "ratio_AreaRatioTo"; // Not L10N
if (part.StartsWith(prefixTransitionRatio))
{
propertyPath = PropertyPath.Root.Property(
RatioPropertyDescriptor.MakePropertyName(RatioPropertyDescriptor.RATIO_PREFIX,
part.Substring(prefixTransitionRatio.Length)));
}
}
component = typeof(double);
oldCaption = null;
if (null == propertyPath)
{
Trace.TraceWarning("Unable to parse ratio property {0}", part); // Not L10N
propertyPath = PropertyPath.Root.Property(part);
}
}
// else if (component == typeof (DbProteinResult) && part == "ResultFile")
// {
// propertyPath = PropertyPath.Parse("Results!*.Value");
// }
else
{
PropertyInfo property = component.GetProperty(part);
if (null == property)
{
Trace.TraceWarning("Could not find property {0}", part); // Not L10N
continue;
}
propertyPath = PropertyPath.Root.Property(part);
foreach (DatabindingColumnAttribute databindingColumn in
property.GetCustomAttributes(typeof(DatabindingColumnAttribute), true))
{
if (null != databindingColumn.Name)
{
propertyPath = PropertyPath.Parse(databindingColumn.Name);
break;
}
}
oldCaption = property.Name;
foreach (QueryColumn attr in property.GetCustomAttributes(typeof(QueryColumn), true))
{
oldCaption = attr.FullName ?? oldCaption;
}
component = property.PropertyType;
}
identifierPath = identifierPath.Concat(propertyPath);
}
var columnDescriptor = GetColumnDescriptor(databindingTableAttribute, identifierPath);
if (null == columnDescriptor)
{
return(new ColumnSpec(identifierPath));
}
var columnSpec = new ColumnSpec(columnDescriptor.PropertyPath);
var newCaption = DataSchema.GetColumnCaption(columnDescriptor).InvariantCaption;
if (oldCaption != newCaption)
{
columnSpec = columnSpec.SetCaption(oldCaption);
}
return(columnSpec);
}
protected void ActivatePropertyPath(PropertyPath propertyPath)
{
IEnumerable<PropertyPath> activatedPaths = new[] {propertyPath};
if (UseTransformedView && ViewEditor.ViewTransformer != null)
{
activatedPaths = ViewEditor.ViewTransformer.TransformView(ViewInfo, activatedPaths).Value;
}
ViewEditor.ActivatePropertyPath(activatedPaths.First());
}
private ColumnDescriptor GetColumnDescriptor(DatabindingTableAttribute databindingTable, PropertyPath identifierPath)
{
identifierPath = PropertyPath.Parse(databindingTable.Property).Concat(identifierPath);
var viewSpec = new ViewSpec().SetColumns(new[] { new ColumnSpec(identifierPath) });
var viewInfo = new ViewInfo(DataSchema, databindingTable.RootTable, viewSpec);
return(viewInfo.DisplayColumns.First().ColumnDescriptor);
}
private ColumnDescriptor GetColumnDescriptor(PropertyPath idPath)
{
ColumnDescriptor columnDescriptor;
if (_columnDescriptors.TryGetValue(idPath, out columnDescriptor))
{
return columnDescriptor;
}
var parent = GetColumnDescriptor(idPath.Parent);
if (parent == null)
{
return null;
}
if (idPath.Name != null)
{
columnDescriptor = parent.ResolveChild(idPath.Name);
}
else
{
columnDescriptor = parent.GetCollectionColumn();
if (columnDescriptor == null)
{
return null;
}
}
_columnDescriptors.Add(idPath, columnDescriptor);
return columnDescriptor;
}
void ApplyManyToOneConvention(IModelInspector mi, PropertyPath type, IManyToOneMapper map)
{
map.Column(type.LocalMember.Name + "_id");
}
public void AddCustomizer(PropertyPath member, Action <IListPropertiesMapper> propertyCustomizer)
{
AddCustomizer(listCustomizers, member, propertyCustomizer);
}
private void DoStudy7Test()
{
// Preparing a Document to Accept the Study 7 Transition List, p. 18
RunUI(() => SkylineWindow.NewDocument());
var peptideSettingsUI1 = ShowDialog <PeptideSettingsUI>(SkylineWindow.ShowPeptideSettingsUI);
if (IsCoverShotMode)
{
var modHeavyK = new StaticMod(HEAVY_K, "K", ModTerminus.C, false, null, LabelAtoms.C13 | LabelAtoms.N15, // Not L10N
RelativeRT.Matching, null, null, null);
AddHeavyMod(modHeavyK, peptideSettingsUI1, "Edit Isotope Modification form", 6);
}
var mod13Cr = new StaticMod("Label:13C(6) (C-term R)", "R", ModTerminus.C, false, null, LabelAtoms.C13,
RelativeRT.Matching, null, null, null);
AddHeavyMod(mod13Cr, peptideSettingsUI1, "Edit Isotope Modification form", 18);
RunUI(() =>
{
peptideSettingsUI1.PickedHeavyMods = new[] { "Label:13C(6) (C-term R)", HEAVY_K };
peptideSettingsUI1.PickedLibraries = new string[0];
peptideSettingsUI1.SelectedBackgroundProteome = Resources.SettingsList_ELEMENT_NONE_None;
peptideSettingsUI1.OkDialog();
});
// Pasting a Transition List into the Document, p. 19.
string clipboardSaveText = string.Empty;
RunUI(() =>
{
var filePath = GetTestPath(@"Study 7\Study7 transition list.xls");
SetExcelFileClipboardText(filePath, "Simple", 6, false);
clipboardSaveText = ClipboardEx.GetText();
});
// We expect this to fail due to instrument settings rather than format issues eg "The product m/z 1519.78 is out of range for the instrument settings, in the peptide sequence YEVQGEVFTKPQLWP. Check the Instrument tab in the Transition Settings."
{
var transitionSelectdgl = ShowDialog <ImportTransitionListColumnSelectDlg>(SkylineWindow.Paste);
var messageDlg = ShowDialog <ImportTransitionListErrorDlg>(transitionSelectdgl.AcceptButton.PerformClick);
AssertEx.AreComparableStrings(TextUtil.SpaceSeparate(Resources.MassListRowReader_CalcTransitionExplanations_The_product_m_z__0__is_out_of_range_for_the_instrument_settings__in_the_peptide_sequence__1_,
Resources.MassListRowReader_CalcPrecursorExplanations_Check_the_Instrument_tab_in_the_Transition_Settings),
messageDlg.ErrorList[0].ErrorMessage,
2);
RunUI(() => messageDlg.Size = new Size(838, 192));
PauseForScreenShot <ImportTransitionListErrorDlg>("Error message form (expected)", 19);
OkDialog(messageDlg, messageDlg.CancelButton.PerformClick); // Acknowledge the error but decline to proceed with import
RunUI(() => transitionSelectdgl.DialogResult = DialogResult.Cancel); // Cancel the import
// Restore the clipboard text after pausing
ClipboardEx.SetText(clipboardSaveText);
}
RunDlg <TransitionSettingsUI>(() => SkylineWindow.ShowTransitionSettingsUI(TransitionSettingsUI.TABS.Instrument), transitionSettingsUI =>
{
transitionSettingsUI.InstrumentMaxMz = 1800;
transitionSettingsUI.OkDialog();
});
PasteTransitionListSkipColumnSelect();
RunUI(SkylineWindow.CollapsePeptides);
PauseForScreenShot("Targets tree (selected from main window)", 20);
// Adjusting Modifications Manually, p. 19.
AdjustModifications("AGLCQTFVYGGCR", true, 'V', 747.348);
PauseForScreenShot("Target tree clipped from main window", 22);
AdjustModifications("IVGGWECEK", true, 'V', 541.763);
AdjustModifications("YEVQGEVFTKPQLWP", false, 'L', 913.974);
RunUI(() => SkylineWindow.SaveDocument(GetTestPath(@"Study 7\Study7.sky")));
// Importing Data from a Multiple Sample WIFF file, p. 23.
var importResultsDlg1 = ShowDialog <ImportResultsDlg>(SkylineWindow.ImportResults);
var openDataSourceDialog1 = ShowDialog <OpenDataSourceDialog>(() => importResultsDlg1.NamedPathSets =
importResultsDlg1.GetDataSourcePathsFile(null));
RunUI(() =>
{
openDataSourceDialog1.CurrentDirectory = new MsDataFilePath(GetTestPath("Study 7"));
openDataSourceDialog1.SelectAllFileType(UseRawFilesOrFullData ? ".wiff" : ".mzML"); // Force true wiff for FullData
});
if (UseRawFilesOrFullData)
{
var importResultsSamplesDlg = ShowDialog <ImportResultsSamplesDlg>(openDataSourceDialog1.Open);
PauseForScreenShot <ImportResultsSamplesDlg>("Choose Samples form", 24);
RunUI(() =>
{
if (IsFullData)
{
importResultsSamplesDlg.CheckAll(true);
importResultsSamplesDlg.ExcludeSample(0); // Blank
importResultsSamplesDlg.ExcludeSample(25); // QC
importResultsSamplesDlg.ExcludeSample(26);
importResultsSamplesDlg.ExcludeSample(27);
importResultsSamplesDlg.ExcludeSample(28);
importResultsSamplesDlg.ExcludeSample(45); // A2
importResultsSamplesDlg.ExcludeSample(46);
importResultsSamplesDlg.ExcludeSample(47);
importResultsSamplesDlg.ExcludeSample(48);
importResultsSamplesDlg.ExcludeSample(49); // gradientwash
importResultsSamplesDlg.ExcludeSample(50);
importResultsSamplesDlg.ExcludeSample(51);
importResultsSamplesDlg.ExcludeSample(52);
importResultsSamplesDlg.ExcludeSample(53); // A3
importResultsSamplesDlg.ExcludeSample(54);
importResultsSamplesDlg.ExcludeSample(55);
importResultsSamplesDlg.ExcludeSample(56);
}
else
{
importResultsSamplesDlg.CheckAll(false);
importResultsSamplesDlg.IncludeSample(1);
importResultsSamplesDlg.IncludeSample(2);
importResultsSamplesDlg.IncludeSample(11);
importResultsSamplesDlg.IncludeSample(12);
}
});
OkDialog(importResultsSamplesDlg, importResultsSamplesDlg.OkDialog);
}
else
{
RunUI(openDataSourceDialog1.Open);
}
{
var importResultsNameDlg = ShowDialog <ImportResultsNameDlg>(importResultsDlg1.OkDialog);
PauseForScreenShot <ImportResultsNameDlg>("Import Results Common prefix form", 25);
OkDialog(importResultsNameDlg, importResultsNameDlg.YesDialog);
}
WaitForCondition(() =>
SkylineWindow.Document.Settings.HasResults && SkylineWindow.Document.Settings.MeasuredResults.IsLoaded);
RestoreViewOnScreen(26);
// Inspecting and Adjusting Peak Integration, p. 24.
RunUI(() =>
{
SkylineWindow.ShowPeakAreaReplicateComparison();
SkylineWindow.ShowGraphRetentionTime(true);
SkylineWindow.Size = new Size(1029, 659);
});
if (!IsPauseForScreenShots && !IsFullData)
{
TestApplyToAll();
}
PauseForScreenShot <GraphSummary.RTGraphView>("Main window with peaks and retention times showing", 26);
CheckReportCompatibility.CheckAll(SkylineWindow.Document);
RunUI(SkylineWindow.EditDelete);
FindNode("IVGGWECEK"); // Not L10N
TransitionGroupTreeNode selNodeGroup = null;
RunUI(() =>
{
selNodeGroup = (TransitionGroupTreeNode)SkylineWindow.SequenceTree.SelectedNode.Nodes[1];
Assert.AreEqual(selNodeGroup.StateImageIndex, (int)SequenceTree.StateImageId.peak_blank);
});
RunDlg <TransitionSettingsUI>(SkylineWindow.ShowTransitionSettingsUI, transitionSettingsUI =>
{
transitionSettingsUI.MZMatchTolerance = 0.065;
transitionSettingsUI.OkDialog();
});
RunUI(() =>
{
Assert.AreEqual((int)SequenceTree.StateImageId.peak, selNodeGroup.StateImageIndex);
SkylineWindow.ToggleIntegrateAll();
});
RunUI(() =>
{
foreach (PeptideDocNode nodePep in SkylineWindow.Document.Molecules)
{
string sequence = nodePep.Peptide.Sequence;
int imageIndex = PeptideTreeNode.GetPeakImageIndex(nodePep, SkylineWindow.SequenceTree);
if ((sequence != null) && (sequence.StartsWith("YLA") || sequence.StartsWith("YEV"))) // Not L10N
{
Assert.AreEqual((int)SequenceTree.StateImageId.keep, imageIndex,
string.Format("Expected keep icon for the peptide {0}, found {1}", sequence, imageIndex));
}
else if (sequence != null)
{
Assert.AreEqual((int)SequenceTree.StateImageId.peak, imageIndex,
string.Format("Expected peak icon for the peptide {0}, found {1}", sequence, imageIndex));
}
else // Custom Ion
{
Assert.AreEqual((int)SequenceTree.StateImageId.peak_blank, imageIndex,
string.Format("Expected peak_blank icon for the custom ion {0}, found {1}", nodePep.ModifiedTarget, imageIndex));
}
}
});
PauseForScreenShot("Main window", 27);
// Data Inspection with Peak Areas View, p. 29.
RestoreViewOnScreen(28);
FindNode("SSDLVALSGGHTFGK"); // Not L10N
RunUI(NormalizeGraphToHeavy);
PauseForScreenShot <GraphSummary.AreaGraphView>("Peak Areas graph metafile", 29);
FindNode((564.7746).ToString(LocalizationHelper.CurrentCulture) + "++"); // ESDTSYVSLK - Not L10N
PauseForScreenShot <GraphSummary.AreaGraphView>("Peak Areas graph metafile", 30);
RunUI(SkylineWindow.ExpandPeptides);
string hgflprLight = (363.7059).ToString(LocalizationHelper.CurrentCulture) + "++"; // HGFLPR - Not L10N
FindNode(hgflprLight);
PauseForScreenShot <GraphSummary.AreaGraphView>("Peak Areas graph metafile", 31);
RunUI(() => SkylineWindow.NormalizeAreaGraphTo(NormalizeOption.TOTAL));
PauseForScreenShot <GraphSummary.AreaGraphView>("Peak Areas graph normalized metafile", 32);
RunUI(() =>
{
SkylineWindow.ShowGraphPeakArea(false);
SkylineWindow.ActivateReplicate("E_03");
SkylineWindow.Size = new Size(757, 655);
});
PauseForScreenShot <GraphChromatogram>("Chromatogram graph metafile with interference", 32);
RunUI(() => SkylineWindow.ShowGraphPeakArea(true));
RunUI(() =>
{
SkylineWindow.ShowPeakAreaPeptideGraph();
SkylineWindow.ShowTotalTransitions();
SkylineWindow.ShowCVValues(true);
SkylineWindow.ShowPeptideOrder(SummaryPeptideOrder.document);
});
PauseForScreenShot <GraphSummary.AreaGraphView>("Peak Areas Peptide Comparison graph metafile", 33);
float[] concentrations = { 0f, 60, 175, 513, 1500, 2760, 4980, 9060, 16500, 30000 };
var documentGrid = ShowDialog <DocumentGridForm>(() => SkylineWindow.ShowDocumentGrid(true));
var pathConcentration = PropertyPath.Parse("AnalyteConcentration");
var pathSampleType = PropertyPath.Parse("SampleType");
RunUI(() => documentGrid.ChooseView(Resources.SkylineViewContext_GetDocumentGridRowSources_Replicates));
WaitForConditionUI(() => documentGrid.RowCount == (IsFullData ? concentrations.Length * 4 : 4) &&
documentGrid.FindColumn(pathConcentration) != null &&
documentGrid.FindColumn(pathSampleType) != null); // Let it initialize
RunUI(() =>
{
// Parent is a DocPane and Parent.Parent is the floating window
documentGrid.Parent.Parent.Size = new Size(585, 325);
var documentGridView = documentGrid.DataGridView;
var colConcentration = documentGrid.FindColumn(pathConcentration);
var colStandardType = documentGrid.FindColumn(pathSampleType);
if (IsFullData)
{
for (int i = 0; i < concentrations.Length; i++)
{
for (int j = i * 4; j < (i + 1) * 4; j++)
{
double?concentration = concentrations[i];
SetCellValue(documentGridView, j, colConcentration.Index, concentration);
SetCellValue(documentGridView, j, colStandardType.Index,
concentration == 0 ? SampleType.BLANK : SampleType.STANDARD);
}
}
}
else
{
SetCellValue(documentGridView, 0, colConcentration.Index, 0.0);
SetCellValue(documentGridView, 0, colStandardType.Index, SampleType.BLANK);
SetCellValue(documentGridView, 1, colConcentration.Index, 0.0);
SetCellValue(documentGridView, 1, colStandardType.Index, SampleType.BLANK);
SetCellValue(documentGridView, 2, colConcentration.Index, 175.0);
SetCellValue(documentGridView, 2, colStandardType.Index, SampleType.STANDARD);
SetCellValue(documentGridView, 3, colConcentration.Index, 175.0);
SetCellValue(documentGridView, 3, colStandardType.Index, SampleType.STANDARD);
}
});
WaitForGraphs();
PauseForScreenShot <DocumentGridForm>("Document grid filled (scrolled to the end)", 35);
RunUI(() => documentGrid.Close());
FindNode("SSDLVALSGGHTFGK"); // Not L10N
RunUI(() =>
{
SkylineWindow.ShowPeakAreaReplicateComparison();
var settings = SkylineWindow.DocumentUI.Settings;
var valConcentration = ReplicateValue.GetAllReplicateValues(settings).Skip(1).First();
SkylineWindow.GroupByReplicateValue(valConcentration);
NormalizeGraphToHeavy();
});
PauseForScreenShot <GraphSummary.AreaGraphView>("Peak Areas graph with CVs metafile", 36);
RunUI(() => SkylineWindow.ShowCVValues(false));
RunUI(() => SkylineWindow.SaveDocument());
PauseForScreenShot <GraphSummary.AreaGraphView>("Peak Areas graph grouped by concentration metafile", 37);
PauseForAuditLog();
// Further Exploration, p. 33.
RunUI(() =>
{
SkylineWindow.OpenFile(GetTestPath(@"Study 7\Study II\Study 7ii (site 52).sky")); // Not L10N
SkylineWindow.ShowPeakAreaPeptideGraph();
SkylineWindow.ShowCVValues(true);
});
WaitForCondition(() => SkylineWindow.Document.Settings.MeasuredResults.IsLoaded);
RestoreViewOnScreen(38);
PauseForScreenShot <GraphSummary.AreaGraphView>("Peak Areas peptide comparison graph metafile", 38);
FindNode("LSEPAELTDAVK");
RunUI(() =>
{
SkylineWindow.ShowGraphPeakArea(false);
SkylineWindow.Width = 920;
SkylineWindow.ShowRTReplicateGraph();
});
PauseForScreenShot <GraphSummary.RTGraphView>("Retention Times replicate graph metafile", 38);
FindNode("INDISHTQSVSAK");
RunUI(SkylineWindow.ShowPeakAreaReplicateComparison);
PauseForScreenShot <GraphSummary.AreaGraphView>("Peak Areas normalized to heave graph metafile", 39);
if (IsCoverShotMode)
{
RunUI(() =>
{
Settings.Default.ChromatogramFontSize = 14;
Settings.Default.AreaFontSize = 14;
SkylineWindow.ChangeTextSize(TreeViewMS.LRG_TEXT_FACTOR);
SkylineWindow.AutoZoomBestPeak();
});
RestoreCoverViewOnScreen();
RunUI(() => SkylineWindow.SequenceTree.SelectedNode = SkylineWindow.SelectedNode.Parent);
WaitForGraphs();
RunUI(() => SkylineWindow.SequenceTree.SelectedNode = SkylineWindow.SelectedNode.Nodes[0]);
RunUI(SkylineWindow.FocusDocument);
TakeCoverShot();
return;
}
RunUI(() => SkylineWindow.NormalizeAreaGraphTo(NormalizeOption.NONE));
WaitForGraphs();
PauseForScreenShot <GraphSummary.AreaGraphView>("Peak Areas no normalization graph metafile", 40);
FindNode(hgflprLight);
RunUI(() =>
{
SkylineWindow.ShowAllTransitions();
NormalizeGraphToHeavy();
});
WaitForGraphs();
PauseForScreenShot <GraphSummary.AreaGraphView>("Area Ratio to Heavy graph showing interference metafile", 41);
RunUI(() => SkylineWindow.ShowGraphPeakArea(false));
RunUI(() => SkylineWindow.ActivateReplicate("E_ 03"));
WaitForGraphs();
PauseForScreenShot <GraphChromatogram>("Chromatogram graph metafile showing slight interference", 41);
}
/// <summary>
/// Initializes a new <see cref="CommandBindingExtension"/> instance. The event arguments are not passed to the command.
/// </summary>
/// <param name="commandPath">The command to which the event is to be bound.</param>
public CommandBindingExtension(PropertyPath commandPath)
: this(commandPath, false) { }
public TemplateBinding(PropertyPath path = default(PropertyPath), IValueConverter converter = null, object converterParameter = null)
: base(path, converter, converterParameter)
{
RelativeSource = RelativeSource.TemplatedParent;
}
public HashSet<PivotKey> GetPivotKeys(PropertyPath pivotColumnId, IEnumerable<RowItem> rowItems)
{
var pivotKeys = new HashSet<PivotKey>();
foreach (var row in rowItems)
{
pivotKeys.UnionWith(row.PivotKeys);
}
pivotKeys.RemoveWhere(pivotKey => !pivotKey.Contains(pivotColumnId));
return pivotKeys;
}
public void AddCustomizer(PropertyPath member, Action <IManyToAnyMapper> collectionRelationManyToAnyCustomizer)
{
AddCustomizer(collectionRelationManyToAnyCustomizers, member, collectionRelationManyToAnyCustomizer);
}
public static void VisitAtPath <TContainer, TVisitor>(ref TContainer container, PropertyPath path, TVisitor visitor, ref ChangeTracker changeTracker)
where TVisitor : IPropertyVisitor
{
Actions.VisitAtPath(ref container, path, 0, visitor, ref changeTracker);
}
public void InvokeCustomizers(PropertyPath member, IOneToOneMapper mapper)
{
InvokeCustomizers(oneToOneCustomizers, member, mapper);
}
public void Result(PropertyPath propertyPath, string columnName)
{
DebugCheck.NotNull(propertyPath);
DebugCheck.NotEmpty(columnName);
_resultBindings[propertyPath.Single()] = columnName;
}
public static bool TryVisitAtPath <TContainer, TVisitor>(ref TContainer container, PropertyPath path, TVisitor visitor, ref ChangeTracker changeTracker)
where TVisitor : IPropertyVisitor
{
return(Actions.TryVisitAtPath(ref container, path, 0, visitor, ref changeTracker));
}
