public ActionResult Create()
{
EnumVM viewModel = new EnumVM();
viewModel = poulateDropDownList(viewModel);
return(View(viewModel));
}
public GenericParamVM(GenericParamOptions options, ModuleDef ownerModule, Language language, TypeDef ownerType, MethodDef ownerMethod)
{
this.ownerModule = ownerModule;
this.origOptions = options;
this.number = new UInt16VM(a => { OnPropertyChanged("FullName"); HasErrorUpdated(); });
this.typeDefOrRefAndCAsVM = new TypeDefOrRefAndCAsVM <GenericParamConstraint>("Edit Generic Parameter Constraint", "Create Generic Parameter Constraint", ownerModule, language, ownerType, ownerMethod);
this.customAttributesVM = new CustomAttributesVM(ownerModule, language);
this.gpVarianceVM = new EnumListVM(EnumVM.Create(typeof(GPVariance)));
var typeSigCreatorOptions = new TypeSigCreatorOptions(ownerModule, language)
{
IsLocal = false,
CanAddGenericTypeVar = true,
CanAddGenericMethodVar = false,
OwnerType = ownerType,
OwnerMethod = ownerMethod,
};
if (ownerType != null && ownerType.GenericParameters.Count == 0)
{
typeSigCreatorOptions.CanAddGenericTypeVar = false;
}
if (ownerMethod != null && ownerMethod.GenericParameters.Count > 0)
{
typeSigCreatorOptions.CanAddGenericMethodVar = true;
}
this.typeSigCreator = new TypeSigCreatorVM(typeSigCreatorOptions);
Reinitialize();
}
public object Convert(object value, System.Type targetType, object parameter, CultureInfo culture)
{
int imAccess = (int)value;
EnumVM enumvm = (EnumVM)parameter;
return(enumvm.Values.Where(o => (o.ID & imAccess) == o.ID));
}
public GenericParamVM(GenericParamOptions options, ModuleDef ownerModule, IDecompilerManager decompilerManager, TypeDef ownerType, MethodDef ownerMethod)
{
this.ownerModule = ownerModule;
this.origOptions = options;
this.Number = new UInt16VM(a => { OnPropertyChanged(nameof(FullName)); HasErrorUpdated(); });
this.TypeDefOrRefAndCAsVM = new TypeDefOrRefAndCAsVM <GenericParamConstraint>(dnSpy_AsmEditor_Resources.EditGenericParameterConstraint, dnSpy_AsmEditor_Resources.CreateGenericParameterConstraint, ownerModule, decompilerManager, ownerType, ownerMethod);
this.CustomAttributesVM = new CustomAttributesVM(ownerModule, decompilerManager);
this.GPVarianceVM = new EnumListVM(EnumVM.Create(typeof(GPVariance)));
var typeSigCreatorOptions = new TypeSigCreatorOptions(ownerModule, decompilerManager)
{
IsLocal = false,
CanAddGenericTypeVar = true,
CanAddGenericMethodVar = false,
OwnerType = ownerType,
OwnerMethod = ownerMethod,
};
if (ownerType != null && ownerType.GenericParameters.Count == 0)
{
typeSigCreatorOptions.CanAddGenericTypeVar = false;
}
if (ownerMethod != null && ownerMethod.GenericParameters.Count > 0)
{
typeSigCreatorOptions.CanAddGenericMethodVar = true;
}
this.TypeSigCreator = new TypeSigCreatorVM(typeSigCreatorOptions);
Reinitialize();
}
public void B()
{
var enumBM = new EnumBM <TestEnum>();
enumBM.Metadata.DataProvider.Data = TestEnum.A;
Assert.IsNotNull(enumBM.Settings);
Assert.IsTrue(enumBM.Settings.IncludeValuesSpecified);
Assert.IsNotNull(enumBM.Settings.IncludeValues);
var enumVM = new EnumVM <TestEnum> {
Metadata = new BusinessValueMetadata <TestEnum>()
};
((BusinessValueDataProvider <TestEnum>)enumVM.Metadata.DataProvider).BusinessValue = enumBM;
Assert.That(enumVM.DisplayValueProvider, Is.TypeOf <EnumDisplayValueProvider>());
Assert.AreEqual(TestEnum.A, enumVM.Value);
Assert.AreEqual("A", enumVM.DisplayValueProvider.String);
Assert.AreEqual("A", enumVM.EditValueProvider.String);
Assert.IsNotNull(enumVM.ValueSourceProvider);
Assert.IsNotNull(enumVM.ValueSourceProvider.SourceList);
var validValues = enumVM.ValueSourceProvider.SourceList.Cast <EnumMemberVM <TestEnum> >().ToList();
Assert.AreEqual(3, validValues.Count);
enumVM.Value = TestEnum.B;
Assert.AreEqual(TestEnum.B, enumBM.Value);
enumVM.EditValueProvider.String = "C";
Assert.IsFalse(enumVM.ErrorProvider.HasError);
Assert.AreEqual(TestEnum.C, enumBM.Value);
}
[Test, Ignore("TODO")] //TODO
public void BusinessValueDataProvider_BusinessValue_is_not_initialized()
{
var enumVM = new EnumVM <TestEnum> {
Metadata = new BusinessValueMetadata <TestEnum>()
};
//Throws.TypeOf<InvalidOperationException>();
//Assert.AreEqual(enumVM.Value,null);
}
public CANamedArgumentVM(ModuleDef ownerModule, CANamedArgument namedArg, TypeSigCreatorOptions options)
{
this.ownerModule = ownerModule;
this.originalNamedArg = namedArg.Clone();
this.constantTypeEnumListVM = new EnumListVM(ConstantTypeVM.CreateEnumArray(validTypes), (a, b) => OnConstantTypeChanged());
this.namedArgTypeEnumListVM = new EnumListVM(EnumVM.Create(typeof(NamedArgType)), (a, b) => OnNamedArgTypeChanged());
InitializeFrom(namedArg, options);
this.modified = false;
}
public void UseWidthDefaultMetadata()
{
var vm = new EnumVM <TestEnum>();
vm.EditValueProvider.String = "B";
Assert.AreEqual(TestEnum.B, vm.Value);
vm.EditValueProvider.String = "D";
Assert.IsTrue(vm.ErrorProvider.HasError);
}
public void BusinessValueDataProvider_BusinessValue_Settings_IncludeValues_changed_while_value_is_selected()
{
var enumBM = new EnumBM <TestEnum>();
var enumVM = new EnumVM <TestEnum> {
Metadata = new BusinessValueMetadata <TestEnum>()
};
((BusinessValueDataProvider <TestEnum>)enumVM.Metadata.DataProvider).BusinessValue = enumBM;
//A selected and A removed from IncludeValues should result in ErrorProvider.HasError=true
((ObservableCollection <TestEnum>)enumBM.Metadata.Settings.IncludeValues).RemoveAt(0); // C removed
Assert.AreEqual(2, enumVM.ValueSourceProvider.SourceList.Count());
Assert.IsTrue(enumVM.ErrorProvider.HasError);
}
public ActionResult Edit(int id)
{
EnumVM viewModel = new EnumVM();
CRUDOperation dataOperations = new CRUDOperation();
tbl_EnumCategory tblItem = dataOperations.GetEnumCategoryById(id);
viewModel.EnumCategoryID = id;
viewModel.EnumCategoryCode = tblItem.Code;
viewModel.EnumCategoryName = tblItem.Name;
viewModel.EnumCategoryDesc = tblItem.Description;
return(View(viewModel));
}
public ActionResult Edit(int id)
{
EnumVM viewModel = new EnumVM();
viewModel = poulateDropDownList(viewModel);
CRUDOperation dataOperations = new CRUDOperation();
tbl_EnumValue tblItem = dataOperations.GetEnumValueById(id);
viewModel.EnumValueID = id;
viewModel.EnumCategoryID = tblItem.EnumCategoryID == null?0:(Int64)tblItem.EnumCategoryID;
viewModel.EnumValueCode = tblItem.Code;
viewModel.EnumValueName = tblItem.Name;
viewModel.EnumValueDesc = tblItem.Description;
return(View(viewModel));
}
public ActionResult Edit(EnumVM viewModel)
{
try
{
var UserProfile = (UserProfileSessionData)this.Session["UserProfile"];
if (UserProfile != null)
{
if (ModelState.IsValid)
{
tbl_EnumValue item = new tbl_EnumValue()
{
ID = viewModel.EnumValueID,
EnumCategoryID = viewModel.EnumCategoryID,
Code = viewModel.EnumValueCode,
Name = viewModel.EnumValueName,
Description = viewModel.EnumValueDesc,
UpdateDate = DateTime.Now,
UpdateUser = UserProfile.UserId
};
CRUDOperation dataOperations = new CRUDOperation();
tbl_EnumValue dbItem = dataOperations.UpdateEnumValue(item);
if (dbItem != null)
{
TempData["success"] = "Ok";
TempData["message"] = "Məlumatlar uğurla dəyişdirildi";
return(RedirectToAction("Index"));
}
else
{
TempData["success"] = "notOk";
TempData["message"] = "Məlumatlar dəyişdirilərkən xəta baş verdi";
return(RedirectToAction("Index"));
}
}
}
throw new ApplicationException("Invalid model");
}
catch (ApplicationException ex)
{
viewModel = poulateDropDownList(viewModel);
return(View(viewModel));
}
}
public ActionResult Create(EnumVM viewModel)
{
try
{
var UserProfile = (UserProfileSessionData)this.Session["UserProfile"];
if (UserProfile != null)
{
tbl_EnumValue item = new tbl_EnumValue()
{
EnumCategoryID = viewModel.EnumCategoryID,
Code = viewModel.EnumValueCode,
Name = viewModel.EnumValueName,
Description = viewModel.EnumValueDesc,
InsertDate = DateTime.Now,
InsertUser = UserProfile.UserId
};
CRUDOperation dataOperations = new CRUDOperation();
tbl_EnumValue dbItem = dataOperations.AddEnumValue(item);
if (dbItem != null)
{
TempData["success"] = "Ok";
TempData["message"] = "Məlumatlar uğurla əlavə olundu";
return(RedirectToAction("Index"));
}
else
{
TempData["success"] = "notOk";
TempData["message"] = "Məlumatlar əlavə olunarkən xəta baş verdi";
return(RedirectToAction("Index"));
}
}
}
catch (ApplicationException ex)
{
viewModel = poulateDropDownList(viewModel);
return(View(viewModel));
}
throw new ApplicationException("Invalid model");
}
public void BusinessValueDataProvider_BusinessValue_Settings_IncludeValues_changed()
{
var enumBM = new EnumBM <TestEnum>();
var enumVM = new EnumVM <TestEnum> {
Metadata = new BusinessValueMetadata <TestEnum>()
};
((BusinessValueDataProvider <TestEnum>)enumVM.Metadata.DataProvider).BusinessValue = enumBM;
((ObservableCollection <TestEnum>)enumBM.Metadata.Settings.IncludeValues).RemoveAt(1); // B removed
Assert.AreEqual(2, enumVM.ValueSourceProvider.SourceList.Count());
enumVM.EditValueProvider.String = "B";
Assert.IsTrue(enumVM.ErrorProvider.HasError);
Assert.IsNotNull(enumVM.ErrorProvider.ErrorMessage);
Assert.AreNotEqual("", enumVM.ErrorProvider.ErrorMessage);
Assert.AreEqual(TestEnum.A, enumVM.Value);
enumVM.EditValueProvider.String = "C";
Assert.IsFalse(enumVM.ErrorProvider.HasError);
Assert.IsNull(enumVM.ErrorProvider.ErrorMessage);
Assert.AreEqual(TestEnum.C, enumVM.Value);
}
public ActionResult Index(int?page, string vl, string prm = null)
{
EnumRepository repository = new EnumRepository();
try
{
Search search = new Search();
search = SetValue(page, vl, prm);
int pageSize = 15;
int pageNumber = (page ?? 1);
EnumVM viewModel = new EnumVM();
viewModel.Search = search;
viewModel.Search.pageSize = pageSize;
viewModel.Search.pageNumber = pageNumber;
viewModel.REnumCategoryList = repository.SW_GetEnumCategories(viewModel.Search);
viewModel.ListCount = repository.SW_GetEnumCategoriesCount(viewModel.Search);
int[] pc = new int[viewModel.ListCount];
viewModel.Paging = pc.ToPagedList(pageNumber, pageSize);
return(Request.IsAjaxRequest()
? (ActionResult)PartialView("PartialIndex", viewModel)
: View(viewModel));
}
catch (Exception ex)
{
return(View("Error", new HandleErrorInfo(ex, "Error", "Error")));
}
}
private EnumVM poulateDropDownList(EnumVM viewModel)
{
viewModel.EnumCategoryList = EnumService.GetEnumCategoryList();
return(viewModel);
}
public AppSettingsPageImpl(IBackgroundImageSettingsService backgroundImageSettingsService, IPickFilename pickFilename, IPickDirectory pickDirectory, ImageSettingsInfo[] settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (settings.Length == 0)
{
throw new ArgumentException();
}
Debug.Assert(settings.All(a => a.Lazy.Value.UserVisible));
this.backgroundImageSettingsService = backgroundImageSettingsService ?? throw new ArgumentNullException(nameof(backgroundImageSettingsService));
this.pickFilename = pickFilename ?? throw new ArgumentNullException(nameof(pickFilename));
this.pickDirectory = pickDirectory ?? throw new ArgumentNullException(nameof(pickDirectory));
Settings = new ObservableCollection <Settings>(settings.OrderBy(a => a.Lazy.Value.UIOrder).Select(a => new Settings(a)));
stretchVM = new EnumListVM(EnumVM.Create(false, typeof(Stretch)), (a, b) => currentItem.RawSettings.Stretch = (Stretch)stretchVM.SelectedItem);
stretchDirectionVM = new EnumListVM(stretchDirectionList, (a, b) => currentItem.RawSettings.StretchDirection = (StretchDirection)stretchDirectionVM.SelectedItem);
imagePlacementVM = new EnumListVM(imagePlacementList, (a, b) => currentItem.RawSettings.ImagePlacement = (ImagePlacement)imagePlacementVM.SelectedItem);
opacityVM = new DoubleVM(a => { if (!opacityVM.HasError)
{
currentItem.RawSettings.Opacity = FilterOpacity(opacityVM.Value);
}
});
horizontalOffsetVM = new DoubleVM(a => { if (!horizontalOffsetVM.HasError)
{
currentItem.RawSettings.HorizontalOffset = FilterOffset(horizontalOffsetVM.Value);
}
});
verticalOffsetVM = new DoubleVM(a => { if (!verticalOffsetVM.HasError)
{
currentItem.RawSettings.VerticalOffset = FilterOffset(verticalOffsetVM.Value);
}
});
leftMarginWidthPercentVM = new DoubleVM(a => { if (!leftMarginWidthPercentVM.HasError)
{
currentItem.RawSettings.LeftMarginWidthPercent = FilterMarginPercent(leftMarginWidthPercentVM.Value);
}
});
rightMarginWidthPercentVM = new DoubleVM(a => { if (!rightMarginWidthPercentVM.HasError)
{
currentItem.RawSettings.RightMarginWidthPercent = FilterMarginPercent(rightMarginWidthPercentVM.Value);
}
});
topMarginHeightPercentVM = new DoubleVM(a => { if (!topMarginHeightPercentVM.HasError)
{
currentItem.RawSettings.TopMarginHeightPercent = FilterMarginPercent(topMarginHeightPercentVM.Value);
}
});
bottomMarginHeightPercentVM = new DoubleVM(a => { if (!bottomMarginHeightPercentVM.HasError)
{
currentItem.RawSettings.BottomMarginHeightPercent = FilterMarginPercent(bottomMarginHeightPercentVM.Value);
}
});
maxHeightVM = new DoubleVM(a => { if (!maxHeightVM.HasError)
{
currentItem.RawSettings.MaxHeight = FilterLength(maxHeightVM.Value);
}
});
maxWidthVM = new DoubleVM(a => { if (!maxWidthVM.HasError)
{
currentItem.RawSettings.MaxWidth = FilterLength(maxWidthVM.Value);
}
});
zoomVM = new DoubleVM(a => { if (!zoomVM.HasError)
{
currentItem.RawSettings.Zoom = FilterZoom(zoomVM.Value);
}
});
intervalVM = new DefaultConverterVM <TimeSpan>(a => { if (!intervalVM.HasError)
{
currentItem.RawSettings.Interval = intervalVM.Value;
}
});
CurrentItem = Settings.FirstOrDefault(a => a.Id == backgroundImageSettingsService.LastSelectedId) ?? Settings[0];
}
public ActionResult Create()
{
EnumVM viewModel = new EnumVM();
return(View(viewModel));
}
