public void Init(GroupFilterVM gf, GroupFilterSortingCriteria gfsc)
		{
			groupFilter = gf;
			groupFilterSortingCriteria = gfsc;

			try
			{
				cboSortType.Items.Clear();
				foreach (string stype in GroupFilterHelper.GetAllSortTypes())
				{
					if (gf != null)
					{
						bool alreadyExists = false;
						foreach (GroupFilterSortingCriteria gfsc_old in gf.SortCriteriaList)
						{
							if (GroupFilterHelper.GetTextForEnum_Sorting(gfsc_old.SortType) == stype)
							{
								alreadyExists = true;
								break;
							}
						}

						if (!alreadyExists) cboSortType.Items.Add(stype);
					}
				}
				if (cboSortType.Items.Count > 0)
					cboSortType.SelectedIndex = 0;



				cboDirection.Items.Clear();
				cboDirection.Items.Add(GroupFilterHelper.GetTextForEnum_SortDirection(GroupFilterSortDirection.Asc));
				cboDirection.Items.Add(GroupFilterHelper.GetTextForEnum_SortDirection(GroupFilterSortDirection.Desc));
				cboDirection.SelectedIndex = 0;

			}
			catch (Exception ex)
			{
				Utils.ShowErrorMessage(ex);
			}

		}
Example #2
0
        private void CommandBinding_Cancel(object sender, ExecutedRoutedEventArgs e)
        {
            object obj = e.Parameter;
            if (obj == null) return;

            try
            {
                if (obj.GetType() == typeof(AnimeGroupVM))
                {
                    AnimeGroupVM grp = (AnimeGroupVM)obj;
                    grp.IsReadOnly = true;
                    grp.IsBeingEdited = false;

                    // copy all editable properties
                    if (grp.AnimeGroupID.HasValue) // an existing group
                    {
                        grp.GroupName = groupBeforeChanges.GroupName;
                        grp.IsFave = groupBeforeChanges.IsFave;

                        //grp.AnimeGroupParentID = groupBeforeChanges.AnimeGroupParentID;
                        grp.Description = groupBeforeChanges.Description;
                        grp.SortName = groupBeforeChanges.SortName;

                        MainListHelperVM.Instance.ViewGroups.Refresh();
                        EnableDisableGroupControls(true);
                        //MainListHelperVM.Instance.LastAnimeGroupID = grp.AnimeGroupID.Value;
                        HighlightMainListItem();
                    }
                    else
                    {
                        HighlightMainListItem();
                        SetDetailBinding(null);
                    }

                }

                if (obj.GetType() == typeof(GroupFilterVM))
                {
                    GroupFilterVM gf = (GroupFilterVM)obj;
                    gf.IsLocked = true;
                    gf.IsBeingEdited = false;

                    // copy all editable properties
                    if (gf.GroupFilterID.HasValue && gf.GroupFilterID.Value!=0) // an existing group filter
                    {
                        gf.FilterName = groupFilterBeforeChanges.FilterName;
                        gf.ApplyToSeries = groupFilterBeforeChanges.ApplyToSeries;
                        gf.BaseCondition = groupFilterBeforeChanges.BaseCondition;
                        gf.FilterConditions.Clear();
                        gf.SortCriteriaList.Clear();

                        foreach (GroupFilterConditionVM gfc_old in groupFilterBeforeChanges.FilterConditions)
                        {
                            GroupFilterConditionVM gfc = new GroupFilterConditionVM();
                            gfc.ConditionOperator = gfc_old.ConditionOperator;
                            gfc.ConditionParameter = gfc_old.ConditionParameter;
                            gfc.ConditionType = gfc_old.ConditionType;
                            gfc.GroupFilterConditionID = gfc_old.GroupFilterConditionID;
                            gfc.GroupFilterID = gfc_old.GroupFilterID;
                            gf.FilterConditions.Add(gfc);
                        }

                        foreach (GroupFilterSortingCriteria gfsc_old in groupFilterBeforeChanges.SortCriteriaList)
                        {
                            GroupFilterSortingCriteria gfsc = new GroupFilterSortingCriteria();
                            gfsc.GroupFilterID = gfsc_old.GroupFilterID;
                            gfsc.SortDirection = gfsc_old.SortDirection;
                            gfsc.SortType = gfsc_old.SortType;
                            gf.SortCriteriaList.Add(gfsc);
                        }

                        //MainListHelperVM.Instance.LastGroupFilterID = gf.GroupFilterID.Value;
                    }
                    else
                    {
                        SetDetailBinding(null);
                    }
                    EnableDisableGroupControls(true);
                    HighlightMainListItem();
                }

                if (obj.GetType() == typeof(AnimeSeriesVM))
                {

                }
            }
            catch (Exception ex)
            {
                Utils.ShowErrorMessage(ex);
            }
        }
Example #3
0
        /// <summary>
        /// Moves group sorting up and down
        /// </summary>
        /// <param name="gfsc"></param>
        /// <param name="direction">1 = up, 2 = down</param>
        private void GroupFilterSortMoveUpDown(GroupFilterSortingCriteria gfsc, int direction)
        {
            // find the sorting condition
            foreach (GroupFilterVM gf in MainListHelperVM.Instance.AllGroupFiltersDictionary.Values)
            {
                if (!gf.AllowEditing) continue; // all filter
                if (gf.GroupFilterID == gfsc.GroupFilterID)
                {
                    int pos = -1;
                    for (int i = 0; i < gf.SortCriteriaList.Count; i++)
                    {
                        if (gfsc.SortType == gf.SortCriteriaList[i].SortType)
                        {
                            pos = i;
                            break;
                        }
                    }

                    if (direction == 1) // up
                    {
                        if (pos > 0)
                        {
                            gf.SortCriteriaList.Move(pos, pos - 1);
                            groupFilterVM = gf;
                            MainListHelperVM.Instance.ViewGroupsForms.Filter = GroupFilter_GroupSearch;
                            MainListHelperVM.Instance.SetGroupFilterSortingOnForms(gf);
                        }
                    }
                    else
                    {
                        if (pos + 1 < gf.SortCriteriaList.Count)
                        {
                            gf.SortCriteriaList.Move(pos, pos + 1);
                            groupFilterVM = gf;
                            MainListHelperVM.Instance.ViewGroupsForms.Filter = GroupFilter_GroupSearch;
                            MainListHelperVM.Instance.SetGroupFilterSortingOnForms(gf);
                        }
                    }
                }
            }
        }
Example #4
0
        private void CommandBinding_NewFilterSorting(object sender, ExecutedRoutedEventArgs e)
        {
            try
            {
                object obj = e.Parameter;
                if (obj == null) return;

                GroupFilterVM gf = (GroupFilterVM)obj;
                GroupFilterSortingCriteria gfsc = new GroupFilterSortingCriteria();

                GroupFilterSortingForm frm = new GroupFilterSortingForm();
                frm.Owner = this;
                frm.Init(gf, gfsc);
                bool? result = frm.ShowDialog();
                if (result.HasValue && result.Value == true)
                {
                    gf.SortCriteriaList.Add(gfsc);

                    groupFilterVM = gf;
                    MainListHelperVM.Instance.ViewGroupsForms.Filter = GroupFilter_GroupSearch;
                    MainListHelperVM.Instance.SetGroupFilterSortingOnForms(gf);
                }
            }
            catch (Exception ex)
            {
                Utils.ShowErrorMessage(ex);
            }
        }
Example #5
0
        private void CommandBinding_Edit(object sender, ExecutedRoutedEventArgs e)
        {
            //object obj = lbGroupsSeries.SelectedItem;
            object obj = e.Parameter;
            if (obj == null) return;

            try
            {
                if (obj.GetType() == typeof(AnimeGroupVM))
                {
                    AnimeGroupVM grp = (AnimeGroupVM)obj;

                    if (grp.AnimeGroupID.HasValue)
                    {
                        groupBeforeChanges = new AnimeGroupVM();
                        Cloner.Clone(grp, groupBeforeChanges);
                    }

                    grp.IsReadOnly = false;
                    grp.IsBeingEdited = true;

                }

                if (obj.GetType() == typeof(GroupFilterVM))
                {
                    GroupFilterVM gf = (GroupFilterVM)obj;

                    if (gf.GroupFilterID.HasValue && gf.GroupFilterID.Value!=0)
                    {
                        groupFilterBeforeChanges = new GroupFilterVM();
                        groupFilterBeforeChanges.FilterName = gf.FilterName;
                        groupFilterBeforeChanges.BaseCondition = gf.BaseCondition;
                        groupFilterBeforeChanges.ApplyToSeries = gf.ApplyToSeries;
                        groupFilterBeforeChanges.FilterConditions = new ObservableCollection<GroupFilterConditionVM>();
                        groupFilterBeforeChanges.SortCriteriaList = new ObservableCollection<GroupFilterSortingCriteria>();

                        foreach (GroupFilterConditionVM gfc_cur in gf.FilterConditions)
                        {
                            GroupFilterConditionVM gfc = new GroupFilterConditionVM();
                            gfc.ConditionOperator = gfc_cur.ConditionOperator;
                            gfc.ConditionParameter = gfc_cur.ConditionParameter;
                            gfc.ConditionType = gfc_cur.ConditionType;
                            gfc.GroupFilterConditionID = gfc_cur.GroupFilterConditionID;
                            gfc.GroupFilterID = gfc_cur.GroupFilterID;
                            groupFilterBeforeChanges.FilterConditions.Add(gfc);
                        }

                        foreach (GroupFilterSortingCriteria gfcs_cur in gf.SortCriteriaList)
                        {
                            GroupFilterSortingCriteria gfsc = new GroupFilterSortingCriteria();
                            gfsc.GroupFilterID = gfcs_cur.GroupFilterID;
                            gfsc.SortDirection = gfcs_cur.SortDirection;
                            gfsc.SortType = gfcs_cur.SortType;
                            groupFilterBeforeChanges.SortCriteriaList.Add(gfsc);
                        }
                        //Cloner.Clone(gf, groupFilterBeforeChanges);
                    }

                    gf.IsLocked = false;
                    gf.IsBeingEdited = true;

                    groupFilterVM = gf;
                    MainListHelperVM.Instance.ViewGroupsForms.Filter = GroupFilter_GroupSearch;
                    MainListHelperVM.Instance.SetGroupFilterSortingOnForms(gf);
                }

                if (obj.GetType() == typeof(AnimeSeriesVM))
                {

                }
            }
            catch (Exception ex)
            {
                Utils.ShowErrorMessage(ex);
            }

            EnableDisableGroupControls(false);
        }