public void RefreshColumnsWidgets()
        {
            foreach (var label in columnsLabels)
            {
                tableColumns.Remove(label);
            }
            foreach (var combo in columnsTypeCombos)
            {
                tableColumns.Remove(combo);
            }
            tableColumns.NRows = (uint)ViewModel.ImportModel.MaxSourceColumns;
            columnsLabels.Clear();
            columnsTypeCombos.Clear();
            uint nRow = 0;

            foreach (var column in ViewModel.ImportModel.DisplayColumns)
            {
                var label = new yLabel();
                label.Xalign = 1;
                label.Binding
                .AddBinding(column, nameof(IDataColumn.Title), w => w.LabelProp)
                .InitializeFromSource();
                columnsLabels.Add(label);
                tableColumns
                .Attach(label, 0, 1, nRow, nRow + 1,
                        AttachOptions.Shrink, AttachOptions.Shrink, 0, 0);
                var combo = new yEnumComboBox();
                combo.ItemsEnum = ViewModel.ImportModel.DataTypeEnum;
                combo.Binding
                .AddBinding(column, nameof(IDataColumn.DataType), w => w.SelectedItem)
                .InitializeFromSource();
                columnsTypeCombos.Add(combo);
                tableColumns
                .Attach(combo, 1, 2, nRow, nRow + 1,
                        AttachOptions.Shrink, AttachOptions.Shrink, 0, 0);
                nRow++;
            }
            tableColumns.ShowAll();
        }
Esempio n. 2
0
        private void Configure()
        {
            notebook1.Binding
            .AddBinding(ViewModel, vm => vm.CurrentPage, w => w.CurrentPage)
            .InitializeFromSource();
            notebook1.SwitchPage += (o, args) =>
            {
                if (args.PageNum == 1)
                {
                    radioFixedPrices.Active = true;
                }
            };
            notebook1.ShowTabs  = false;
            buttonSave.Clicked += (sender, args) =>
            {
                deliverypointresponsiblepersonsview1.RemoveEmpty();
                ViewModel.Save(true);
            };
            buttonSave.Binding
            .AddFuncBinding(ViewModel, vm => !vm.IsInProcess && vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();
            buttonCancel.Clicked += (sender, args) => ViewModel.Close(false, CloseSource.Cancel);
            buttonCancel.Binding
            .AddFuncBinding(ViewModel, vm => !vm.IsInProcess, w => w.Sensitive)
            .InitializeFromSource();
            buttonInsertFromBuffer.Clicked  += (s, a) => ViewModel.SetCoordinatesFromBuffer(_clipboard.WaitForText());
            buttonInsertFromBuffer.Sensitive = ViewModel.CanEdit;
            buttonApplyLimitsToAllDeliveryPointsOfCounterparty.Clicked +=
                (s, a) => ViewModel.ApplyOrderSumLimitsToAllDeliveryPointsOfClient();
            buttonApplyLimitsToAllDeliveryPointsOfCounterparty.Sensitive = ViewModel.CanEdit;
            radioInformation.Toggled += RadioInformationOnToggled;
            radioFixedPrices.Toggled += RadioFixedPricesOnToggled;

            ybuttonOpenOnMap.Binding
            .AddBinding(ViewModel.Entity, e => e.CoordinatesExist, w => w.Visible)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();

            ybuttonOpenOnMap.Clicked += (s, a) => ViewModel.OpenOnMapCommand.Execute();

            #region Address entries

            entryCity.CitiesDataLoader     = ViewModel.CitiesDataLoader;
            entryStreet.StreetsDataLoader  = ViewModel.StreetsDataLoader;
            entryBuilding.HousesDataLoader = ViewModel.HousesDataLoader;
            entryCity.CitySelected        += EntryCityOnCitySelected;
            entryStreet.StreetSelected    += EntryStreetOnStreetSelected;
            entryStreet.FocusOutEvent     += EntryStreetOnFocusOutEvent;
            entryBuilding.FocusOutEvent   += EntryBuildingOnFocusOutEvent;
            entryCity.Binding.AddSource(ViewModel.Entity)
            .AddBinding(e => e.City, w => w.CityName)
            .AddBinding(e => e.CityFiasGuid, w => w.FiasGuid)
            .AddBinding(e => e.LocalityType, w => w.CityTypeName)
            .AddBinding(e => e.LocalityTypeShort, w => w.CityTypeNameShort)
            .AddSource(ViewModel)
            .AddBinding(vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();

            entryCity.FireCityChange();

            entryStreet.Binding.AddSource(ViewModel.Entity)
            .AddBinding(e => e.Street, w => w.StreetName)
            .AddBinding(e => e.StreetDistrict, w => w.StreetDistrict)
            .AddBinding(e => e.StreetType, w => w.StreetTypeName)
            .AddBinding(e => e.StreetTypeShort, w => w.StreetTypeNameShort)
            .AddBinding(e => e.StreetFiasGuid, w => w.FiasGuid)
            .AddSource(ViewModel)
            .AddBinding(vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();

            entryStreet.FireStreetChange();

            entryBuilding.Binding.AddSource(ViewModel.Entity)
            .AddBinding(e => e.BuildingFiasGuid, w => w.FiasGuid)
            .AddBinding(e => e.Building, w => w.BuildingName)
            .AddSource(ViewModel)
            .AddBinding(vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();

            ViewModel.CityBeforeChange     = entryCity.CityName;
            ViewModel.StreetBeforeChange   = entryStreet.StreetName;
            ViewModel.BuildingBeforeChange = entryBuilding.BuildingName;

            #endregion

            phonesview1.ViewModel = ViewModel.PhonesViewModel;

            ySpecCmbCategory.ItemsList = ViewModel.DeliveryPointCategories;
            ySpecCmbCategory.Binding
            .AddBinding(ViewModel.Entity, e => e.Category, w => w.SelectedItem)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();

            ycheckHaveResidue.Binding.AddSource(ViewModel.Entity)
            .AddFuncBinding(e => e.HaveResidue.HasValue, w => w.Visible)
            .AddFuncBinding(e => e.HaveResidue.HasValue && e.HaveResidue.Value, w => w.Active)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();

            comboRoomType.ItemsEnum = typeof(RoomType);
            comboRoomType.Binding
            .AddBinding(ViewModel.Entity, e => e.RoomType, w => w.SelectedItem)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();

            yenumEntranceType.ItemsEnum = typeof(EntranceType);
            yenumEntranceType.Binding
            .AddBinding(ViewModel.Entity, e => e.EntranceType, w => w.SelectedItem)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();

            entryDefaultDeliverySchedule.SetEntityAutocompleteSelectorFactory(ViewModel.DeliveryScheduleSelectorFactory);
            entryDefaultDeliverySchedule.Binding
            .AddBinding(ViewModel.Entity, e => e.DeliverySchedule, w => w.Subject)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();

            checkIsActive.Binding
            .AddBinding(ViewModel.Entity, e => e.IsActive, w => w.Active)
            .AddSource(ViewModel)
            .AddFuncBinding(vm => vm.CanArchiveDeliveryPoint, w => w.Sensitive)
            .InitializeFromSource();

            textComment.Binding
            .AddBinding(ViewModel.Entity, e => e.Comment, w => w.Buffer.Text)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();
            labelCompiledAddress.Binding
            .AddBinding(ViewModel.Entity, e => e.CompiledAddress, w => w.LabelProp)
            .InitializeFromSource();
            entryRoom.Binding
            .AddBinding(ViewModel.Entity, e => e.Room, w => w.Text)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();
            entryFloor.Binding
            .AddBinding(ViewModel.Entity, e => e.Floor, w => w.Text)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();
            entryEntrance.Binding
            .AddBinding(ViewModel.Entity, e => e.Entrance, w => w.Text)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();
            spinMinutesToUnload.Binding
            .AddBinding(ViewModel.Entity, e => e.MinutesToUnload, w => w.ValueAsInt)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();

            hboxOrganisation.Binding
            .AddFuncBinding(ViewModel.Entity, e => e.Counterparty != null && e.Counterparty.PersonType == PersonType.natural, w => w.Visible)
            .InitializeFromSource();
            ylabelOrganisation.Binding
            .AddFuncBinding(ViewModel.Entity, e => e.Counterparty != null && e.Counterparty.PersonType == PersonType.natural, w => w.Visible)
            .InitializeFromSource();
            yentryOrganisation.Binding
            .AddBinding(ViewModel.Entity, e => e.Organization, w => w.Text)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();
            yentryKPP.Binding
            .AddBinding(ViewModel.Entity, e => e.KPP, w => w.Text)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();

            entryDefaultWater.SetEntityAutocompleteSelectorFactory(ViewModel.NomenclatureSelectorFactory.GetDefaultWaterSelectorFactory());
            entryDefaultWater.Binding
            .AddBinding(ViewModel.Entity, e => e.DefaultWaterNomenclature, w => w.Subject)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();

            #region Оставлено для корректного отображения старых заказов

            yentryAddress1c.Binding.AddSource(ViewModel.Entity)
            .AddBinding(e => e.Address1c, w => w.Text)
            .AddBinding(e => e.Address1c, w => w.TooltipText)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();
            labelAddress1c.Visible = yentryAddress1c.Visible = !string.IsNullOrWhiteSpace(ViewModel.Entity.Address1c);
            yentryCode1c.Binding
            .AddBinding(ViewModel.Entity, e => e.Code1c, w => w.Text)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();
            codeLabel.Visible = hboxCode.Visible = !string.IsNullOrWhiteSpace(ViewModel.Entity.Code1c);

            #endregion

            spinBottlesReserv.Binding
            .AddBinding(ViewModel.Entity, e => e.BottleReserv, w => w.ValueAsInt)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();
            ychkAlwaysFreeDelivery.Binding
            .AddBinding(ViewModel.Entity, e => e.AlwaysFreeDelivery, w => w.Active)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();
            ychkAlwaysFreeDelivery.Visible = ViewModel.CanSetFreeDelivery;
            lblCounterparty.LabelProp      = ViewModel.Entity.Counterparty.FullName;
            lblId.LabelProp = ViewModel.Entity.Id.ToString();

            ylabelFoundOnOsm.Binding.AddFuncBinding(ViewModel.Entity,
                                                    e => e.CoordinatesExist
                                        ? string.Format("<span foreground='{1}'>{0}</span>", e.CoordinatesText, e.FoundOnOsm ? "green" : "blue")
                                        : "<span foreground='red'>Не найден на карте.</span>",
                                                    w => w.LabelProp).InitializeFromSource();
            ylabelChangedUser.Binding.AddFuncBinding(ViewModel,
                                                     vm => vm.CoordsWasChanged
                                        ? $"Изменено: {vm.CoordsLastChangeUserName}"
                                        : "Никем не изменялись",
                                                     w => w.LabelProp).InitializeFromSource();
            ycheckOsmFixed.Binding
            .AddBinding(ViewModel.Entity, e => e.IsFixedInOsm, w => w.Active)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();
            ycheckOsmFixed.Visible = ViewModel.CurrentUserIsAdmin;

            chkAddCertificatesAlways.Binding
            .AddBinding(ViewModel.Entity, e => e.AddCertificatesAlways, w => w.Active)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();

            entryLunchTimeFrom.Binding
            .AddBinding(ViewModel.Entity, e => e.LunchTimeFrom, w => w.Time)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();
            entryLunchTimeTo.Binding
            .AddBinding(ViewModel.Entity, e => e.LunchTimeTo, w => w.Time)
            .AddBinding(ViewModel, vm => vm.CanEdit, w => w.Sensitive)
            .InitializeFromSource();

            //make actions menu
            var menu           = new Menu();
            var openClientItem = new MenuItem("Открыть контрагента");
            openClientItem.Activated += (s, a) => ViewModel.OpenCounterpartyCommand.Execute();
            menu.Add(openClientItem);
            menuActions.Menu = menu;
            menu.ShowAll();

            //Configure map
            _mapWidget = new GMapControl
            {
                MapProvider  = GMapProviders.GoogleMap,
                Position     = new PointLatLng(59.93900, 30.31646),
                MinZoom      = 0,
                MaxZoom      = 24,
                Zoom         = 9,
                WidthRequest = 500,
                HasFrame     = true
            };
            _mapWidget.Overlays.Add(_addressOverlay);
            _mapWidget.ButtonPressEvent   += MapWidgetOnButtonPressEvent;
            _mapWidget.ButtonReleaseEvent += MapWidgetOnButtonReleaseEvent;
            _mapWidget.MotionNotifyEvent  += MapWidgetOnMotionNotifyEvent;
            _mapWidget.Sensitive           = ViewModel.CanEdit;

            _vboxMap                        = new VBox();
            _comboMapType                   = new yEnumComboBox();
            _comboMapType.ItemsEnum         = typeof(MapProviders);
            _comboMapType.SelectedItem      = MapProviders.GoogleMap;
            _comboMapType.EnumItemSelected += (sender, args) =>
            {
                _mapWidget.MapProvider = MapProvidersHelper.GetPovider((MapProviders)args.SelectedItem);
            };
            _vboxMap.Add(_comboMapType);
            _vboxMap.SetChildPacking(_comboMapType, false, false, 0, PackType.Start);
            _vboxMap.Add(_mapWidget);
            _vboxMap.ShowAll();

            sidePanelMap.Panel         = _vboxMap;
            sidePanelMap.IsHided       = false;
            ViewModel.PropertyChanged += ViewModelOnPropertyChanged;
            UpdateAddressOnMap();

            if (ViewModel.DeliveryPoint.Counterparty.IsForRetail)
            {
                ySpinLimitMin.ValueAsInt = int.MinValue;
                ySpinLimitMax.ValueAsInt = int.MaxValue;

                ySpinLimitMin.Sensitive = ViewModel.CanEditOrderLimits;
                ySpinLimitMax.Sensitive = ViewModel.CanEditOrderLimits;

                ySpinLimitMin.Binding.AddBinding(ViewModel.Entity, e => e.MinimalOrderSumLimit, w => w.ValueAsInt).InitializeFromSource();
                ySpinLimitMax.Binding.AddBinding(ViewModel.Entity, e => e.MaximalOrderSumLimit, w => w.ValueAsInt).InitializeFromSource();

                //FIXME этот виджет следовало бы переписать на VM + V
                deliverypointresponsiblepersonsview1.UoW                = ViewModel.UoW;
                deliverypointresponsiblepersonsview1.DeliveryPoint      = ViewModel.DeliveryPoint;
                deliverypointresponsiblepersonsview1.ResponsiblePersons = ViewModel.ResponsiblePersons;
                deliverypointresponsiblepersonsview1.Sensitive          = ViewModel.CanEdit;
            }
            else
            {
                labelLimit.Visible = false;
                hboxLimits.Visible = false;
                deliverypointresponsiblepersonsview1.Visible = false;
                labelResponsiblePersons.Visible = false;
            }
        }