Beispiel #1
0
        public override void ReadDeviceProperties(uint prop)
        {
            //lock (Locker)
            //{
            try
            {
                HaveLiveView = true;
                switch (prop)
                {
                case CONST_PROP_Fnumber:
                    //FNumber.SetValue(_stillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue, CONST_PROP_Fnumber));
                    ReInitFNumber(false);
                    break;

                case CONST_PROP_MovieFnumber:
                    //FNumber.SetValue(_stillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue, CONST_PROP_Fnumber));
                    ReInitFNumber(false);
                    break;

                case CONST_PROP_ExposureIndex:
                    NormalIsoNumber.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
                                                                              CONST_PROP_ExposureIndex), false);
                    break;

                //case CONST_PROP_ExposureIndexEx:
                //    NormalIsoNumber.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
                //                                                        CONST_PROP_ExposureIndexEx), false);
                //    break;
                case CONST_PROP_MovieExposureIndex:
                    MovieFNumber.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
                                                                           CONST_PROP_MovieExposureIndex), false);
                    break;

                //case CONST_PROP_ExposureTime:
                //    NormalShutterSpeed.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
                //                                                           CONST_PROP_ExposureTime), false);
                //    break;
                case CONST_PROP_ShutterSpeed:
                    NormalShutterSpeed.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
                                                                                 CONST_PROP_ShutterSpeed), false);
                    break;

                case CONST_PROP_MovieShutterSpeed:
                    MovieShutterSpeed.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
                                                                                CONST_PROP_MovieShutterSpeed), false);
                    break;

                case CONST_PROP_WhiteBalance:
                    WhiteBalance.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
                                                                           CONST_PROP_WhiteBalance), false);
                    break;

                case CONST_PROP_ExposureProgramMode:
                    Mode.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
                                                                   CONST_PROP_ExposureProgramMode), true);
                    break;

                case CONST_PROP_ExposureBiasCompensation:
                    NormalExposureCompensation.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
                                                                                         CONST_PROP_ExposureBiasCompensation),
                                                        false);
                    break;

                case CONST_PROP_MovieExposureBiasCompensation:
                    MovieExposureCompensation.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
                                                                                        CONST_PROP_MovieExposureBiasCompensation),
                                                       false);
                    break;

                case CONST_PROP_CompressionSetting:
                    CompressionSetting.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
                                                                                 CONST_PROP_CompressionSetting),
                                                false);
                    break;

                case CONST_PROP_ExposureMeteringMode:
                    ExposureMeteringMode.SetValue(StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
                                                                                   CONST_PROP_ExposureMeteringMode),
                                                  false);
                    break;

                case CONST_PROP_AFModeSelect:
                    NormalFocusMode.SetValue(
                        StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue, CONST_PROP_AFModeSelect),
                        false);
                    NormalFocusMode.IsEnabled = NormalFocusMode.NumericValue != 3;
                    break;

                case CONST_PROP_AfModeAtLiveView:
                    LiveViewFocusMode.SetValue(
                        StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue, CONST_PROP_AfModeAtLiveView),
                        false);
                    LiveViewFocusMode.IsEnabled = LiveViewFocusMode.NumericValue != 3;
                    break;

                case CONST_PROP_BatteryLevel:
                {
                    var data = StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue, CONST_PROP_BatteryLevel);
                    if (data.Data != null && data.Data.Length > 0)
                    {
                        Battery = data.Data[0];
                    }
                }
                break;

                case CONST_PROP_ExposureIndicateStatus:
                {
                    var data =
                        StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
                                                         CONST_PROP_ExposureIndicateStatus);
                    if (data.Data != null && data.Data.Length > 0)
                    {
                        sbyte i =
                            unchecked (
                                (sbyte)data.Data[0]);
                        ExposureStatus = Convert.ToInt32(i);
                    }
                }
                break;

                case CONST_PROP_LiveViewStatus:
                {
                    MTPDataResponse response = ExecuteReadDataEx(CONST_CMD_GetDevicePropValue, CONST_PROP_LiveViewStatus);
                    if (response.Data != null && response.Data.Length > 0)
                    {
                        LiveViewOn = response.Data[0] == 1;
                    }
                    else
                    {
                        LiveViewOn = false;
                    }
                    break;
                }

                case CONST_PROP_LiveViewSelector:
                {
                    MTPDataResponse response = ExecuteReadDataEx(CONST_CMD_GetDevicePropValue, CONST_PROP_LiveViewSelector);
                    if (response.Data != null && response.Data.Length > 0)
                    {
                        LiveViewMovieOn = response.Data[0] == 1;
                    }
                    else
                    {
                        LiveViewMovieOn = false;
                    }
                    break;
                }

                default:
                    // imrovements from: http://digicamcontrol.com/forum/testingbug-reports/buglet-nikonbasecs
                    foreach (PropertyValue <long> advancedProperty in AdvancedProperties.Where(advancedProperty => advancedProperty.Code == prop))
                    {
                        if (advancedProperty.Name == "Image Size")
                        {
                            var val = StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
                                                                       advancedProperty.Code);
                            if (val.Data != null && val.Data.Length > 0)
                            {
                                advancedProperty.SetValue(
                                    Encoding.Unicode.GetString(val.Data, 1, 20), false);
                            }
                        }
                        else
                        {
                            advancedProperty.SetValue(
                                StillImageDevice.ExecuteReadData(CONST_CMD_GetDevicePropValue,
                                                                 advancedProperty.Code), false);
                        }
                    }
                    break;
                }
            }
            catch (Exception ex)
            {
                Log.Error("ReadDeviceProperties error", ex);
            }
            //}
        }
        public override bool Init(DeviceDescriptor deviceDescriptor)
        {
            IsBusy = false;
            //the device not connected
            try
            {
                ConnectToWiaDevice(deviceDescriptor);
            }
            catch (Exception exception)
            {
                Log.Error("Unable to connect camera using wia driver", exception);
                return(false);
            }
            DeviceManager = new DeviceManager();
            DeviceManager.RegisterEvent(Conts.wiaEventItemCreated, deviceDescriptor.WiaId);
            DeviceManager.OnEvent += DeviceManager_OnEvent;

            try
            {
                Device       = deviceDescriptor.WiaDevice;
                DeviceName   = Device.Properties["Description"].get_Value();
                Manufacturer = Device.Properties["Manufacturer"].get_Value();
                SerialNumber = StaticHelper.GetSerial(Device.Properties["PnP ID String"].get_Value());
            }
            catch (Exception ex)
            {
                Log.Debug("Init error", ex);
            }
            IsConnected = true;
            try
            {
                try
                {
                    Property apertureProperty = Device.Properties[Conts.CONST_PROP_F_Number];
                    if (apertureProperty != null)
                    {
                        foreach (var subTypeValue in apertureProperty.SubTypeValues)
                        {
                            double d = (int)subTypeValue;
                            string s = (d / 100).ToString("0.0");
                            FNumber.AddValues(s, (int)d);
                            FNumber.ReloadValues();
                            if ((int)subTypeValue == (int)apertureProperty.get_Value())
                            {
                                FNumber.SetValue((int)d);
                            }
                        }
                    }
                }
                catch (COMException)
                {
                    FNumber.IsEnabled = false;
                }

                try
                {
                    Property isoProperty = Device.Properties[Conts.CONST_PROP_ISO_Number];
                    if (isoProperty != null)
                    {
                        foreach (var subTypeValue in isoProperty.SubTypeValues)
                        {
                            IsoNumber.AddValues(subTypeValue.ToString(), (int)subTypeValue);
                            IsoNumber.ReloadValues();
                            if ((int)subTypeValue == (int)isoProperty.get_Value())
                            {
                                IsoNumber.SetValue((int)subTypeValue);
                            }
                        }
                    }
                }
                catch (COMException)
                {
                    IsoNumber.IsEnabled = false;
                }

                try
                {
                    Property shutterProperty = Device.Properties[Conts.CONST_PROP_Exposure_Time];
                    if (shutterProperty != null)
                    {
                        foreach (int subTypeValue in shutterProperty.SubTypeValues)
                        {
                            if (ShutterTable.ContainsKey((int)subTypeValue))
                            {
                                ShutterSpeed.AddValues(ShutterTable[(int)subTypeValue], (int)subTypeValue);
                            }
                        }
                        ShutterSpeed.ReloadValues();
                        ShutterSpeed.SetValue(shutterProperty.get_Value());
                    }
                }
                catch (COMException)
                {
                    ShutterSpeed.IsEnabled = false;
                }

                try
                {
                    Property wbProperty = Device.Properties[Conts.CONST_PROP_WhiteBalance];
                    if (wbProperty != null)
                    {
                        foreach (var subTypeValue in wbProperty.SubTypeValues)
                        {
                            if (WbTable.ContainsKey((int)subTypeValue))
                            {
                                WhiteBalance.AddValues(WbTable[(int)subTypeValue], (int)subTypeValue);
                            }
                        }
                        WhiteBalance.ReloadValues();
                        WhiteBalance.SetValue(wbProperty.get_Value());
                    }
                }
                catch (COMException)
                {
                    WhiteBalance.IsEnabled = false;
                }

                try
                {
                    Property modeProperty = Device.Properties[Conts.CONST_PROP_ExposureMode];
                    if (modeProperty != null)
                    {
                        foreach (var subTypeValue in modeProperty.SubTypeValues)
                        {
                            if (ExposureModeTable.ContainsKey((int)subTypeValue))
                            {
                                Mode.AddValues(ExposureModeTable[(int)subTypeValue], Convert.ToUInt32(subTypeValue));
                            }
                        }
                        Mode.ReloadValues();
                        Mode.SetValue(Convert.ToUInt32(modeProperty.get_Value()));
                    }
                    Mode.IsEnabled = false;
                }
                catch (COMException)
                {
                    Mode.IsEnabled = false;
                }

                try
                {
                    Property ecProperty = Device.Properties[Conts.CONST_PROP_ExposureCompensation];
                    if (ecProperty != null)
                    {
                        foreach (var subTypeValue in ecProperty.SubTypeValues)
                        {
                            decimal d = (int)subTypeValue;
                            string  s = decimal.Round(d / 1000, 1).ToString();
                            if (d > 0)
                            {
                                s = "+" + s;
                            }
                            ExposureCompensation.AddValues(s, (int)subTypeValue);
                        }
                        ExposureCompensation.ReloadValues();
                        ExposureCompensation.SetValue(ecProperty.get_Value());
                    }
                }
                catch (COMException)
                {
                    ExposureCompensation.IsEnabled = false;
                }

                try
                {
                    Property csProperty = Device.Properties[Conts.CONST_PROP_CompressionSetting];
                    if (csProperty != null)
                    {
                        foreach (var subTypeValue in csProperty.SubTypeValues)
                        {
                            if (CSTable.ContainsKey((int)subTypeValue))
                            {
                                CompressionSetting.AddValues(CSTable[(int)subTypeValue], (int)subTypeValue);
                            }
                        }
                        CompressionSetting.ReloadValues();
                        CompressionSetting.SetValue(csProperty.get_Value());
                    }
                }
                catch (COMException)
                {
                    CompressionSetting.IsEnabled = false;
                }

                try
                {
                    Property emmProperty = Device.Properties[Conts.CONST_PROP_ExposureMeteringMode];
                    if (emmProperty != null)
                    {
                        foreach (var subTypeValue in emmProperty.SubTypeValues)
                        {
                            if (EMMTable.ContainsKey((int)subTypeValue))
                            {
                                ExposureMeteringMode.AddValues(EMMTable[(int)subTypeValue], (int)subTypeValue);
                            }
                        }
                        ExposureMeteringMode.ReloadValues();
                        ExposureMeteringMode.SetValue(emmProperty.get_Value());
                    }
                }
                catch (COMException)
                {
                    CompressionSetting.IsEnabled = false;
                }

                try
                {
                    Property fmProperty = Device.Properties[Conts.CONST_PROP_FocusMode];
                    if (fmProperty != null)
                    {
                        foreach (int subTypeValue in fmProperty.SubTypeValues)
                        {
                            uint subval = Convert.ToUInt16(subTypeValue);
                            if (FMTable.ContainsKey(subval))
                            {
                                FocusMode.AddValues(FMTable[subval], subval);
                            }
                        }
                        FocusMode.ReloadValues();
                        FocusMode.SetValue(Convert.ToUInt16((int)fmProperty.get_Value()));
                    }
                }
                catch (COMException)
                {
                    FocusMode.IsEnabled = false;
                }

                try
                {
                    Battery = Device.Properties[Conts.CONST_PROP_BatteryStatus].get_Value();
                }
                catch (COMException)
                {
                    Battery = 0;
                }
                IsConnected = true;
            }
            catch (Exception exception)
            {
                Log.Error(exception);
                IsConnected = false;
            }
            HaveLiveView = true;
            //Capabilities.Add(CapabilityEnum.LiveView);
            return(true);
        }
Beispiel #3
0
        private void SetValues(string data)
        {
            List <string> values = new List <string>();
            dynamic       a      = JsonConvert.DeserializeObject(data);

            foreach (string o in a.options)
            {
                values.Add(o);
            }
            string param = (string)a.param;

            switch (param)
            {
            case "photo_quality":
                CompressionSetting.Clear();
                for (int i = 0; i < values.Count; i++)
                {
                    CompressionSetting.AddValues(values[i], i);
                }
                CompressionSetting.IsEnabled = a.permission == "settable";
                CompressionSetting.ReloadValues();
                CompressionSetting.Value = GetValue(param);
                break;

            case "meter_mode":
                ExposureMeteringMode.Clear();
                for (int i = 0; i < values.Count; i++)
                {
                    ExposureMeteringMode.AddValues(values[i], i);
                }
                ExposureMeteringMode.ReloadValues();
                ExposureMeteringMode.IsEnabled = a.permission == "settable";
                ExposureMeteringMode.Value     = GetValue(param);
                break;

            default:
                foreach (var property in Properties)
                {
                    if (property.Tag == param)
                    {
                        property.Clear();
                        for (int i = 0; i < values.Count; i++)
                        {
                            property.AddValues(values[i], i);
                        }
                        property.IsEnabled = a.permission == "settable";
                        property.ReloadValues();
                        property.Value = GetValue(param);
                    }
                }
                foreach (var property in AdvancedProperties)
                {
                    if (property.Tag == param)
                    {
                        property.Clear();
                        for (int i = 0; i < values.Count; i++)
                        {
                            property.AddValues(values[i], i);
                        }
                        property.IsEnabled = a.permission == "settable";
                        property.ReloadValues();
                        property.Value = GetValue(param);
                    }
                }
                break;
            }
        }