System.Collections.Generic.Dictionary.ContainsKey(eNkMAIDCapability)

Here are the examples of the csharp api System.Collections.Generic.Dictionary.ContainsKey(eNkMAIDCapability) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

6 Examples 7

19 Source : NikonSDKCamera.cs
with GNU General Public License v3.0
from vtorkalo

public void Init(NikonDevice cam)
        {

            Logger.WriteTraceMessage("Initializing Nikon camera '" + cam.Name + "'");
            _camera = cam;
            _camera.ImageReady += Camera_ImageReady;
            _camera.CaptureComplete += _camera_CaptureComplete;


            //Set to shoot in RAW
            Logger.WriteTraceMessage("Setting compression to RAW");
            var compression = _camera.GetEnum(eNkMAIDCapability.kNkMAIDCapability_CompressionLevel);
            for (int i = 0; i < compression.Length; i++)
            {
                var val = compression.GetEnumValueByIndex(i);
                if (val.ToString() == "RAW")
                {
                    compression.Index = i;
                    _camera.SetEnum(eNkMAIDCapability.kNkMAIDCapability_CompressionLevel, compression);
                    break;
                }
            }

            //Ensure camera is in Manual mode
            /*var exposureMode = _camera.GetEnum(eNkMAIDCapability.kNkMAIDCapability_ExposureMode);
            if (exposureMode.Index != (int)eNkMAIDExposureMode.kNkMAIDExposureMode_Manual)
            {
                Logger.WriteTraceMessage("Camera not set to Manual mode. Switching now.");
                exposureMode.Index = (int)eNkMAIDExposureMode.kNkMAIDExposureMode_Manual;
                _camera.SetEnum(eNkMAIDCapability.kNkMAIDCapability_ExposureMode, exposureMode);
            }*/
            //Changed to function
            SetCameraToManual();

            GetIsoList();
            GetShutterSpeeds();
            GetCapabilities();


            /* Setting SaveMedia when supported, to save images via SDRAM and not to the internal memory card */
            if (Capabilities.ContainsKey(eNkMAIDCapability.kNkMAIDCapability_SaveMedia) && Capabilities[eNkMAIDCapability.kNkMAIDCapability_SaveMedia].CanSet())
            {
                _camera.SetUnsigned(eNkMAIDCapability.kNkMAIDCapability_SaveMedia, (uint)eNkMAIDSaveMedia.kNkMAIDSaveMedia_SDRAM);
            }
            else
            {
                Logger.WriteTraceMessage("Setting SaveMedia Capability not available. This has to be set manually or is not supported by this model.");
            }
        }

19 Source : NikonSDKCamera.cs
with GNU General Public License v3.0
from vtorkalo

private void SetCameraToManual()
        {
            Logger.WriteTraceMessage("Set camera to manual exposure");
            if (Capabilities.ContainsKey(eNkMAIDCapability.kNkMAIDCapability_ExposureMode) && Capabilities[eNkMAIDCapability.kNkMAIDCapability_ExposureMode].CanSet())
            {
                var exposureMode = _camera.GetEnum(eNkMAIDCapability.kNkMAIDCapability_ExposureMode);
                var foundManual = false;
                for (int i = 0; i < exposureMode.Length; i++)
                {
                    if ((uint)exposureMode[i] == (uint)eNkMAIDExposureMode.kNkMAIDExposureMode_Manual)
                    {
                        exposureMode.Index = i;
                        foundManual = true;
                        _camera.SetEnum(eNkMAIDCapability.kNkMAIDCapability_ExposureMode, exposureMode);
                        break;
                    }
                }

                if (!foundManual)
                {
                    throw new NikonException("Failed to find the 'Manual' exposure mode");
                }
            }
            else
            {
                Logger.WriteTraceMessage("Cannot set to manual mode. Skipping...");
            }
        }

19 Source : NikonSDKCamera.cs
with GNU General Public License v3.0
from vtorkalo

private void SetCameraISO(int index)
        {
            if (Capabilities.ContainsKey(eNkMAIDCapability.kNkMAIDCapability_Sensitivity) && Capabilities[eNkMAIDCapability.kNkMAIDCapability_Sensitivity].CanSet())
            {
                Logger.WriteTraceMessage("Setting ISO to index: " + index);
                var ISOCOntrolList = _camera.GetEnum(eNkMAIDCapability.kNkMAIDCapability_Sensitivity);
                ISOCOntrolList.Index = index;
                _camera.SetEnum(eNkMAIDCapability.kNkMAIDCapability_Sensitivity, ISOCOntrolList);
            }
            else
            {
                Logger.WriteTraceMessage("Cannot set camera ISO. Skipping...");
            }
        }

19 Source : NikonSDKCamera.cs
with GNU General Public License v3.0
from vtorkalo

private void SetCameraShutterSpeed(int index)
        {
            if (Capabilities.ContainsKey(eNkMAIDCapability.kNkMAIDCapability_ShutterSpeed) && Capabilities[eNkMAIDCapability.kNkMAIDCapability_ShutterSpeed].CanSet())
            {
                Logger.WriteTraceMessage("Setting shutter speed to index: " + index);
                var shutterspeed = _camera.GetEnum(eNkMAIDCapability.kNkMAIDCapability_ShutterSpeed);
                _prevShutterSpeed = shutterspeed.Index;
                shutterspeed.Index = index;
                _camera.SetEnum(eNkMAIDCapability.kNkMAIDCapability_ShutterSpeed, shutterspeed);
            }
            else
            {
                Logger.WriteTraceMessage("Cannot set camera shutter speed. Skipping...");
            }
        }

19 Source : Nikon.cs
with GNU General Public License v3.0
from vtorkalo

public bool SupportsCapability(eNkMAIDCapability capability)
        {
            bool supported = false;

            lock (_caps)
            {
                supported = _caps.ContainsKey(capability);
            }

            return supported;
        }

19 Source : NikonNative.cs
with GNU General Public License v3.0
from vtorkalo

void SetSupportedCallbacks()
        {
            // Get supported caps and add them to a dictionary
            Dictionary<eNkMAIDCapability, NkMAIDCapInfo> caps = new Dictionary<eNkMAIDCapability, NkMAIDCapInfo>();
            NkMAIDCapInfo[] capsArray = GetCapInfo();
            foreach (NkMAIDCapInfo c in capsArray)
            {
                caps.Add(c.ulID, c);
            }

            // Callback capabilities
            eNkMAIDCapability[] procCaps = new eNkMAIDCapability[]
            {
                eNkMAIDCapability.kNkMAIDCapability_ProgressProc,
                eNkMAIDCapability.kNkMAIDCapability_EventProc,
                eNkMAIDCapability.kNkMAIDCapability_UIRequestProc,
                eNkMAIDCapability.kNkMAIDCapability_DataProc
            };

            // Corresponding callback functions
            Delegate[] procDelegates = new Delegate[]
            {
                _progressProc,
                _eventProc,
                _uiRequestProc,
                _dataProc
            };

            Debug.replacedert(procCaps.Length == procDelegates.Length);

            // Set supported callbacks
            for (int i = 0; i < procCaps.Length; i++)
            {
                eNkMAIDCapability cap = procCaps[i];

                if (caps.ContainsKey(cap) &&
                    caps[cap].CanSet())
                {
                    NkMAIDCallback callback = new NkMAIDCallback();
                    callback.pProc = Marshal.GetFunctionPointerForDelegate(procDelegates[i]);

                    SetCallback(cap, callback);
                }
            }
        }