//
// Rect
//
internal void SetRect(eNkMAIDCapability capability, NkMAIDRect rectangle)
{
CapSet(
capability,
eNkMAIDDataType.kNkMAIDDataType_RectPtr,
new IntPtr(&rectangle));
}
//
// CapSet
//
internal void CapSet(eNkMAIDCapability capability, eNkMAIDDataType type, IntPtr data)
{
CapSet(
capability,
type,
data.ToInt32());
}
//
// Enum
//
internal void SetEnum(eNkMAIDCapability capability, NkMAIDEnum enumeration)
{
CapSet(
capability,
eNkMAIDDataType.kNkMAIDDataType_EnumPtr,
new IntPtr(&enumeration));
}
internal void SetUnsigned(eNkMAIDCapability capability, uint value)
{
CapSet(
capability,
eNkMAIDDataType.kNkMAIDDataType_Unsigned,
new IntPtr((int)value));
}
internal void SetBoolean(eNkMAIDCapability capability, bool value)
{
CapSet(
capability,
eNkMAIDDataType.kNkMAIDDataType_Boolean,
new IntPtr(value ? 1 : 0));
}
internal void SetCallback(eNkMAIDCapability capability, NkMAIDCallback callback)
{
CapSet(
capability,
eNkMAIDDataType.kNkMAIDDataType_CallbackPtr,
new IntPtr(&callback));
}
internal void SetFloat(eNkMAIDCapability capability, double value)
{
CapSet(
capability,
eNkMAIDDataType.kNkMAIDDataType_FloatPtr,
new IntPtr(&value));
}
internal void GetArrayGeneric(eNkMAIDCapability capability, IntPtr destination)
{
CapGetArray(
capability,
eNkMAIDDataType.kNkMAIDDataType_GenericPtr,
destination);
}
internal void SetGeneric(eNkMAIDCapability capability, IntPtr source)
{
CapSet(
capability,
eNkMAIDDataType.kNkMAIDDataType_GenericPtr,
source);
}
//
// Array
//
internal void SetArray(eNkMAIDCapability capability, NkMAIDArray array)
{
CapSet(
capability,
eNkMAIDDataType.kNkMAIDDataType_ArrayPtr,
new IntPtr(&array));
}
//
// Size
//
internal void SetSize(eNkMAIDCapability capability, NkMAIDSize size)
{
CapSet(
capability,
eNkMAIDDataType.kNkMAIDDataType_SizePtr,
new IntPtr(&size));
}
internal void SetInteger(eNkMAIDCapability capability, int value)
{
CapSet(
capability,
eNkMAIDDataType.kNkMAIDDataType_Integer,
new IntPtr(value));
}
internal void SetRange(eNkMAIDCapability capability, NkMAIDRange value)
{
CapSet(
capability,
eNkMAIDDataType.kNkMAIDDataType_RangePtr,
new IntPtr(&value));
}
internal void SetPoint(eNkMAIDCapability capability, NkMAIDPoint value)
{
CapSet(
capability,
eNkMAIDDataType.kNkMAIDDataType_PointPtr,
new IntPtr(&value));
}
public NkMAIDCapInfo GetCapabilityInfo(eNkMAIDCapability cap)
{
lock (_caps)
{
return(_caps[cap]);
}
}
void OnCapabilityValueChanged(NikonDevice sender, eNkMAIDCapability capability)
{
if (_capabilityValueChanged != null)
{
_capabilityValueChanged(sender, capability);
}
}
//
// CapStart
//
internal void CapStart(eNkMAIDCapability cap, eNkMAIDDataType dataType, IntPtr data)
{
CallEntryPointAsync(
eNkMAIDCommand.kNkMAIDCommand_CapStart,
(uint)cap,
dataType,
data);
}
internal void CapSet(eNkMAIDCapability capability, eNkMAIDDataType type, Int32 data)
{
CallEntryPointAsync(
eNkMAIDCommand.kNkMAIDCommand_CapSet,
(uint)capability,
type,
data);
}
void GetPreviewAndFireEvent(eNkMAIDCapability previewCapabilty, PreviewReadyDelegate d)
{
NikonArrayWithData previewArray = Object.GetArrayWithData(previewCapabilty);
NikonPreview preview = new NikonPreview(previewArray.buffer);
Scheduler.Callback(d, this, preview);
}
//
// CapGetDefault
//
internal void CapGetDefault(eNkMAIDCapability capability, eNkMAIDDataType type, IntPtr data)
{
CallEntryPointAsync(
eNkMAIDCommand.kNkMAIDCommand_CapGetDefault,
(uint)capability,
type,
data);
}
//
// CapGetArray
//
internal void CapGetArray(eNkMAIDCapability capability, eNkMAIDDataType type, IntPtr data)
{
CallEntryPointAsync(
eNkMAIDCommand.kNkMAIDCommand_CapGetArray,
(uint)capability,
type,
data.ToInt32());
}
public bool SupportsCapability(eNkMAIDCapability capability)
{
bool supported = false;
lock (_caps) {
supported = _caps.ContainsKey(capability);
}
return(supported);
}
//
// DateTime
//
internal DateTime GetDateTime(eNkMAIDCapability capability)
{
NkMAIDDateTime result = new NkMAIDDateTime();
CapGet(
capability,
eNkMAIDDataType.kNkMAIDDataType_DateTimePtr,
new IntPtr(&result));
return(result.GetDateTime());
}
//
// Callback
//
internal NkMAIDCallback GetCallback(eNkMAIDCapability capability)
{
NkMAIDCallback callback = new NkMAIDCallback();
CapGet(
capability,
eNkMAIDDataType.kNkMAIDDataType_CallbackPtr,
new IntPtr(&callback));
return(callback);
}
internal int GetDefaultInteger(eNkMAIDCapability capability)
{
int result;
CapGetDefault(
capability,
eNkMAIDDataType.kNkMAIDDataType_IntegerPtr,
new IntPtr(&result));
return(result);
}
internal bool GetDefaultBoolean(eNkMAIDCapability capability)
{
bool result;
CapGetDefault(
capability,
eNkMAIDDataType.kNkMAIDDataType_BooleanPtr,
new IntPtr(&result));
return(result);
}
internal NkMAIDRange GetDefaultRange(eNkMAIDCapability capability)
{
NkMAIDRange result = new NkMAIDRange();
CapGetDefault(
capability,
eNkMAIDDataType.kNkMAIDDataType_RangePtr,
new IntPtr(&result));
return(result);
}
internal double GetDefaultFloat(eNkMAIDCapability capability)
{
double result;
CapGetDefault(
capability,
eNkMAIDDataType.kNkMAIDDataType_FloatPtr,
new IntPtr(&result));
return(result);
}
internal NkMAIDPoint GetDefaultPoint(eNkMAIDCapability capability)
{
NkMAIDPoint result = new NkMAIDPoint();
CapGetDefault(
capability,
eNkMAIDDataType.kNkMAIDDataType_PointPtr,
new IntPtr(&result));
return(result);
}
internal uint GetDefaultUnsigned(eNkMAIDCapability capability)
{
uint result;
CapGetDefault(
capability,
eNkMAIDDataType.kNkMAIDDataType_UnsignedPtr,
new IntPtr(&result));
return(result);
}
public void GetGeneric(eNkMAIDCapability cap, IntPtr destination)
{
_scheduler.Invoke(() => { _object.GetGeneric(cap, destination); });
}
public NkMAIDPoint GetPoint(eNkMAIDCapability cap)
{
return (NkMAIDPoint)Get(cap);
}
public void SetRange(eNkMAIDCapability cap, NikonRange value)
{
Set(cap, value);
}
public void Start(eNkMAIDCapability cap, eNkMAIDDataType dataType, Int32 data)
{
_scheduler.Invoke(new StartCapabilityDelegate(_object.CapStart), cap, dataType, data);
}
public void Start(eNkMAIDCapability cap)
{
Start(cap, eNkMAIDDataType.kNkMAIDDataType_Null, 0);
}
public void SetFloat(eNkMAIDCapability cap, double value)
{
Set(cap, value);
}
public void SetString(eNkMAIDCapability cap, string value)
{
Set(cap, value);
}
public void SetSize(eNkMAIDCapability cap, NkMAIDSize value)
{
Set(cap, value);
}
public void SetRect(eNkMAIDCapability cap, NkMAIDRect value)
{
Set(cap, value);
}
public bool SupportsCapability(eNkMAIDCapability capability)
{
bool supported = false;
lock (_caps)
{
supported = _caps.ContainsKey(capability);
}
return supported;
}
public void SetInteger(eNkMAIDCapability cap, int value)
{
Set(cap, value);
}
internal eNkMAIDCapType GetCapabilityType(eNkMAIDCapability cap)
{
NkMAIDCapInfo info;
bool found = false;
lock (_caps)
{
found = _caps.TryGetValue(cap, out info);
}
if (!found)
{
throw new NikonException("Capability (" + cap.ToString() + ") is not supported");
}
return info.ulType;
}
public void Set(eNkMAIDCapability cap, object value)
{
switch (GetCapabilityType(cap))
{
case eNkMAIDCapType.kNkMAIDCapType_String:
_scheduler.Invoke(new SetStringDelegate(_object.SetString), cap, value);
break;
case eNkMAIDCapType.kNkMAIDCapType_Unsigned:
_scheduler.Invoke(new SetUnsignedDelegate(_object.SetUnsigned), cap, value);
break;
case eNkMAIDCapType.kNkMAIDCapType_Integer:
_scheduler.Invoke(new SetIntegerDelegate(_object.SetInteger), cap, value);
break;
case eNkMAIDCapType.kNkMAIDCapType_Boolean:
_scheduler.Invoke(new SetBooleanDelegate(_object.SetBoolean), cap, value);
break;
case eNkMAIDCapType.kNkMAIDCapType_Float:
_scheduler.Invoke(new SetFloatDelegate(_object.SetFloat), cap, value);
break;
case eNkMAIDCapType.kNkMAIDCapType_Enum:
_scheduler.Invoke(new SetEnumDelegate(_object.SetEnum), cap, (value as NikonEnum).Enum);
break;
case eNkMAIDCapType.kNkMAIDCapType_Array:
_scheduler.Invoke(new SetArrayDelegate(_object.SetArray), cap, (value as NikonArray).Array);
break;
case eNkMAIDCapType.kNkMAIDCapType_Range:
_scheduler.Invoke(new SetRangeDelegate(_object.SetRange), cap, (value as NikonRange).Range);
break;
case eNkMAIDCapType.kNkMAIDCapType_DateTime:
_scheduler.Invoke(new SetDateTimeDelegate(_object.SetDateTime), cap, value);
break;
case eNkMAIDCapType.kNkMAIDCapType_Point:
_scheduler.Invoke(new SetPointDelegate(_object.SetPoint), cap, value);
break;
case eNkMAIDCapType.kNkMAIDCapType_Rect:
_scheduler.Invoke(new SetUnsignedDelegate(_object.SetUnsigned), cap, value);
break;
case eNkMAIDCapType.kNkMAIDCapType_Size:
_scheduler.Invoke(new SetUnsignedDelegate(_object.SetUnsigned), cap, value);
break;
}
}
public string GetString(eNkMAIDCapability cap)
{
return Get(cap) as string;
}
public uint GetUnsigned(eNkMAIDCapability cap)
{
return (uint)Get(cap);
}
public NkMAIDRect GetRect(eNkMAIDCapability cap)
{
return (NkMAIDRect)Get(cap);
}
void device_CapabilityValueChanged(NikonDevice sender, eNkMAIDCapability capability)
{
if (_cap.ulID == capability)
{
OnPropertyChanged("CapValue");
switch (_cap.ulType)
{
case eNkMAIDCapType.kNkMAIDCapType_Enum:
OnPropertyChanged("EnumSelectedIndex");
break;
case eNkMAIDCapType.kNkMAIDCapType_Range:
OnPropertyChanged("RangeValue");
break;
}
}
}
public void SetPoint(eNkMAIDCapability cap, NkMAIDPoint value)
{
Set(cap, value);
}
public NkMAIDSize GetSize(eNkMAIDCapability cap)
{
return (NkMAIDSize)Get(cap);
}
void device_CapabilityChanged(NikonDevice sender, eNkMAIDCapability capability)
{
RefreshCaps();
}
public NikonRange GetRange(eNkMAIDCapability cap)
{
return Get(cap) as NikonRange;
}
public void SetEnum(eNkMAIDCapability cap, NikonEnum value)
{
Set(cap, value);
}
public int GetInteger(eNkMAIDCapability cap)
{
return (int)Get(cap);
}
public void SetDateTime(eNkMAIDCapability cap, DateTime value)
{
Set(cap, value);
}
public double GetFloat(eNkMAIDCapability cap)
{
return (double)Get(cap);
}
public void SetBoolean(eNkMAIDCapability cap, bool value)
{
Set(cap, value);
}
public NikonEnum GetEnum(eNkMAIDCapability cap)
{
return Get(cap) as NikonEnum;
}
public void SetArray(eNkMAIDCapability cap, NikonArray value)
{
Set(cap, value);
}
public void SetGeneric(eNkMAIDCapability cap, IntPtr source)
{
_scheduler.Invoke(() => { _object.SetGeneric(cap, source); });
}
public void SetUnsigned(eNkMAIDCapability cap, uint value)
{
Set(cap, value);
}
