public ScannerListControl(ScannerSettings settings)
{
Settings = settings;
settings.SettingsUpdated += OnSettingsUpdated;
InitializeComponent();
lblName.Text = Settings.Name;
}
public async Task DetectScanner(string message)
{
try
{
_logger.LogInformation(message);
var scanners = SystemDevices.GetScannerDevices();
_firstScanner = scanners.FirstOrDefault();
if (_firstScanner == null)
{
await _hubClient.CallScannerIsNotConnectedError();
return;
}
_logger.LogInformation($"{_firstScanner}");
await _hubClient.CallGetScannerSettings(_firstScanner);
}
catch (COMException ex)
{
var friendlyErrorMessage = ex.GetComErrorMessage(); // How to show a better error message to users
_logger.LogError(ex, friendlyErrorMessage);
await _hubClient.CallGetErrors(friendlyErrorMessage);
}
catch (Exception ex)
{
_logger.LogError(ex, "DetectScanner error.");
await _hubClient.CallGetErrors(ex.Message);
}
}
public ZXingParser(ScannerSettings settings)
{
Scanner = new BarcodeReader();
Scanner.AutoRotate = settings.ParserAutoRotate;
Scanner.TryInverted = settings.ParserTryInverted;
Scanner.Options.TryHarder = settings.ParserTryHarder;
}
public ScannerSettings GetScannerSettings()
{
Log("Get scanner settings");
var getSettings = new GetSettings(GetTwainScannerSettings);
var settings = _windowsMessageLoop.Invoke <SourceSettings>(getSettings);
Dictionary <int, string> supportedScanSources = null;
if (settings.HasADF && settings.HasFlatbed)
{
supportedScanSources = new Dictionary <int, string>
{
{ (int)ScanFeed.Flatbad, EnumExtensions.GetDescription(ScanFeed.Flatbad) },
{ (int)ScanFeed.Feeder, EnumExtensions.GetDescription(ScanFeed.Feeder) }
};
if (settings.HasDuplex)
{
supportedScanSources.Add((int)ScanFeed.Duplex, EnumExtensions.GetDescription(ScanFeed.Duplex));
}
}
var scannerSettings = new ScannerSettings(Index, Name, settings.FlatbedResolutions, settings.FeederResolutions, TwainPixelTypeExtensions.GetSelectListDictionary(settings.PixelTypes), settings.PhysicalHeight, settings.PhysicalWidth, supportedScanSources);
Log("Get scanner settings success");
return(scannerSettings);
}
public void AddScanner(ScannerSettings settings)
{
ScannerManager.Scanners.Add(settings);
ScannerListControl control = new ScannerListControl(settings);
ScannerList.Add(settings, control);
Scanners.Children.Add(control);
}
public ScannerSettingsViewModel(ScannerSettings settings)
{
Settings = settings.Clone();
tempSettings = settings.Clone();
OnDisappearingCommand = new AsyncCommand(OnDisappearing);
DefaultSettingsCommand = new AsyncCommand(MakeDefaultSettings);
ApplySettingsCommand = new AsyncCommand(ApplySettings);
}
public void NearStandartFormat()
{
var scannerSettings = new ScannerSettings(0, "test", null, null, null, 11.69f, 8.27f);
scannerSettings = new ScannerSettings(0, "test", null, null, null, 11.73f, 8.31f);
scannerSettings = new ScannerSettings(0, "test", null, null, null, 11.66f, 8.23f);
scannerSettings = new ScannerSettings(0, "test", null, null, null, 13, 10.23f);
scannerSettings = new ScannerSettings(0, "test", null, null, null, 40, 50);
scannerSettings = new ScannerSettings(0, "test", null, null, null, 10.23f, 13);
}
public UnityWebcam(ScannerSettings settings)
{
// Create Webcam Texture
Webcam = new WebCamTexture(settings.WebcamDefaultDeviceName);
Webcam.requestedWidth = settings.WebcamRequestedWidth;
Webcam.requestedHeight = settings.WebcamRequestedHeight;
Webcam.filterMode = settings.WebcamFilterMode;
// Get size
Width = 0;
Height = 0;
}
public Scanner(ScannerSettings settings, IParser parser, IWebcam webcam)
{
Status = ScannerStatus.Initialize;
// Default Properties
Settings = (settings == null) ? new ScannerSettings() : settings;
Parser = (parser == null) ? new ZXingParser(Settings) : parser;
Camera = (webcam == null) ? new UnityWebcam(Settings) : webcam;
// Check Device Authorization
if (!Application.HasUserAuthorization(UserAuthorization.WebCam))
{
throw new Exception("This Webcam Library can't work without the webcam authorization");
}
}
public MainViewModel(IEV3Brick brick, ILogger log, PrinterSettings printSettings, ScannerSettings scannerSettings, SystemSettings systemSettings)
{
_log = log;
_printSettings = printSettings;
_sysSettings = systemSettings;
_scannerSettings = scannerSettings;
// default values
ServerAddress = "10.0.1.1:13000";
_brick = brick;
_brick.OnLog += Brick_OnLog;
_brick.OnConnect += Brick_OnConnect;
}
public void ThrowIfDeviceInstanceExists(
[Frozen] ImagingDeviceConfig deviceConfig,
[Frozen] ScannerSettings settings,
[Frozen, CollectionSize(1)] IEnumerable <ScannerSettings> _,
[Greedy] ScanningDevices sut)
{
var existingInstance = new ScanningDevice(settings, deviceConfig);
sut.Invoking(x => x.AddDevice(existingInstance))
.Should().Throw <ArgumentException>();
sut.Devices.Should()
.HaveCount(1)
.And.OnlyHaveUniqueItems()
.And.Contain(i => i.DeviceID == existingInstance.DeviceID);
}
private void ScannersLauncher(ScannerSettings scannerSettings, PopupNotifierSettings popupNotifierSettings, ApplicationMode applicationMode)
{
try
{
scanners.ForEach(scanner => Task.Factory.StartNew(() =>
{
scanner.ApplySettings(scannerSettings, popupNotifierSettings);
scanner.StartStopWorker(applicationMode == ApplicationMode.Scanning);
}));
}
catch (Exception)
{
// write exception into the log.
}
}
public ScannerViewModel(IEV3Brick brick, ILogger log, ScannerSettings settings) :
base(brick)
{
_log = log;
// see: https://github.com/teichgraf/WriteableBitmapEx
_bmp = BitmapFactory.New(PrinterSettings.PageWidth, PrinterSettings.PageHeight);
_timer = new DispatcherTimer();
_timer.Interval = TimeSpan.FromSeconds(1);
_timer.Tick += _timer_Tick;
_timer.Start();
_brick = brick;
_settings = settings;
_brick.OnData += _brick_OnData;
}
public static ScannerSettings Build()
{
ScannerSettings settings = new ScannerSettings();
try
{
settings.ParserTryHarder = ParamatersManager.Instance.ParserTryHarder;
settings.ScannerDecodeInterval = ParamatersManager.Instance.DecodeInterval;
settings.ScannerDelayFrameMin = ParamatersManager.Instance.DelayFrameMin;
settings.WebcamDefaultDeviceName = ParamatersManager.Instance.DeviceName;
settings.WebcamFilterMode = (FilterMode)ParamatersManager.Instance.WebcamFilterMode;
if (ParamatersManager.Instance.Resolution != null)
{
settings.WebcamRequestedHeight = ParamatersManager.Instance.Resolution.Value.height;
settings.WebcamRequestedWidth = ParamatersManager.Instance.Resolution.Value.width;
}
if (ParamatersManager.Instance.RequestedFPS != null)
{
settings.WebcamRequestedFPS = ParamatersManager.Instance.RequestedFPS;
}
if (ParamatersManager.Instance.WebcamAutoFocusPoint != null)
{
settings.WebcamAutoFocusPoint = ParamatersManager.Instance.WebcamAutoFocusPoint;
}
// Others params
QualitySettings.SetQualityLevel(ParamatersManager.Instance.QualitySettingsLevel);
QualitySettings.vSyncCount = ParamatersManager.Instance.VSyncCount;
if (ParamatersManager.Instance.TargetFrameRate != null)
{
Application.targetFrameRate = ParamatersManager.Instance.TargetFrameRate.Value;
}
}
catch (Exception ex)
{
Debug.LogErrorFormat("ScannerSettingsBuilder : Exception = {0}", ex.Message);
}
Debug.Log("Scanner Settings Applied!");
return(settings);
}
public ScannerSettings GetScannerSettings()
{
if (_source == null)
{
throw new Exception("Не выбран источник данных для сканера.");
}
var settings = new ScannerSettings(
Index,
Name,
GetAllowableResolutions(),
//todo:
GetAllowableResolutions(),
GetAllowablePixelTypes(),
GetMaxHeight(),
GetMaxWidth());
return(settings);
}
public void TestSettings()
{
var settings = new ScannerSettings("Webcam Name")
{
ScannerBackgroundThread = false,
ScannerDelayFrameMin = 2,
ParserAutoRotate = false,
ParserTryInverted = false,
ParserTryHarder = true,
WebcamRequestedWidth = 256,
WebcamRequestedHeight = 512,
WebcamFilterMode = FilterMode.Bilinear
};
var scanner = new Scanner(settings);
Assert.AreSame(scanner.Settings, settings);
}
private void StartScanning_Click(object sender, EventArgs e)
{
scanResultsGridView.Refresh();
// global popup settings (should be UI setted)
PopupNotifierSettings popupSettings = new PopupNotifierSettings
{
Size = 15
};
// global scanner settings (UI setted)
ScannerSettings scannerSettings = new ScannerSettings
{
AllowScannChange = changedBox.Checked,
AllowScannCreate = createdBox.Checked,
AllowScannDelete = deletedBox.Checked,
AllowScannRenamed = renamedBox.Checked
};
// App running settings
if (applicationMode == ApplicationMode.Stopped)
{
applicationMode = ApplicationMode.Scanning;
startScanning.Text = "Stop";
changedBox.Enabled = false;
createdBox.Enabled = false;
deletedBox.Enabled = false;
renamedBox.Enabled = false;
}
else
{
applicationMode = ApplicationMode.Stopped;
startScanning.Text = "Start";
changedBox.Enabled = true;
createdBox.Enabled = true;
deletedBox.Enabled = true;
renamedBox.Enabled = true;
}
ScannersLauncher(scannerSettings, popupSettings, applicationMode);
}
public void AddNewDevicesToCollection(
[Frozen] Mock <ISystemImagingDevices <ScannerSettings> > systemDevices,
[Frozen, CollectionSize(4)] IEnumerable <ScannerSettings> scannerSettings,
ScannerSettings newScannerSettings)
{
systemDevices
.Setup(mock => mock.GetDeviceSettings())
.Returns(scannerSettings);
var sut = new ScanningDevices(null, systemDevices.Object);
var initalDevices = sut.Devices;
// Add an extra scanner to the collection
scannerSettings = scannerSettings.Append(newScannerSettings);
var scannerProperties = new List <IDictionary <string, object> >();
foreach (var deviceID in sut.Devices.Select(d => d.DeviceID).Append(newScannerSettings.Id))
{
scannerProperties.Add(new Dictionary <string, object>()
{
{ "Unique Device ID", deviceID }
});
}
systemDevices
.Setup(mock => mock.GetDeviceProperties())
.Returns(scannerProperties);
systemDevices
.Setup(mock => mock.GetDeviceSettings())
.Returns(scannerSettings);
sut.RefreshDevices();
sut.Devices
.Should().HaveCount(5)
.And.Contain(initalDevices);
sut.Devices
.Any(d => d.DeviceID == newScannerSettings.Id)
.Should().BeTrue();
}
private IEnumerator Start()
{
// Create a basic scanner
yield return(Application.RequestUserAuthorization(UserAuthorization.WebCam));
if (!Application.HasUserAuthorization(UserAuthorization.WebCam))
{
throw new Exception("This Webcam library can't work without the webcam authorization");
}
ScannerSettings scannerSettings = new ScannerSettings();
scannerSettings.WebcamRequestedWidth = Screen.width;
scannerSettings.WebcamRequestedHeight = Screen.height;
var image = UIEngine.Get <UICamera> ().CameraImage;
image.rectTransform.sizeDelta = new Vector2(Screen.width, Screen.height);
BarcodeScanner = new Scanner(scannerSettings);
BarcodeScanner.Camera.Play();
// Display the camera texture through a RawImage
BarcodeScanner.OnReady += (sender, arg) => {
Log("BarcodeScanner.OnReady");
// Set Orientation & Texture
image.transform.localEulerAngles = BarcodeScanner.Camera.GetEulerAngles();
image.transform.localScale = BarcodeScanner.Camera.GetScale();
image.texture = BarcodeScanner.Camera.Texture;
image.color = Color.white;
// Keep Image Aspect Ratio
var rect = image.GetComponent <RectTransform> ();
var newHeight = rect.sizeDelta.x * BarcodeScanner.Camera.Height / BarcodeScanner.Camera.Width;
rect.sizeDelta = new Vector2(rect.sizeDelta.x, newHeight);
RestartTime = Time.realtimeSinceStartup;
};
}
public UnityWebcam(ScannerSettings settings)
{
string frontCam = null;
var webCamDevices = WebCamTexture.devices;
foreach (var camDevice in webCamDevices)
{
if (camDevice.isFrontFacing)
{
frontCam = camDevice.name;
break;
}
}
// Create Webcam Texture
//Webcam = new WebCamTexture(settings.WebcamDefaultDeviceName);
Webcam = new WebCamTexture(frontCam);
Webcam.requestedWidth = settings.WebcamRequestedWidth;
Webcam.requestedHeight = settings.WebcamRequestedHeight;
Webcam.filterMode = settings.WebcamFilterMode;
// Get size
Width = 0;
Height = 0;
}
public Scanner(ScannerSettings settings) : this(settings, null, null)
{
}
public void EqualSettingsHash([Frozen] ScannerSettings settings, ScanningDevice sut)
{
var result = sut.GetHashCode();
result.Should().Be(settings.Id.GetHashCode());
}
public void RemoveScanner(ScannerSettings settings)
{
RemoveScanner(settings, ScannerList[settings]);
}
public void BeEquivalentToClone([Frozen] ScannerSettings _, ScanningDevice sut, ScanningDevice clone) => sut.Equals(clone).Should().BeTrue();
/// <summary>
/// Constructor
/// </summary>
public PaperScanner()
{
Settings = new ScannerSettings(() => dirty_ = true);
}
public void RemoveScanner(ScannerSettings settings, ScannerListControl control)
{
ScannerManager.Scanners.Remove(settings);
Scanners.Children.Remove(control);
}
public ScannerSettings GetScannerSettings()
{
Log("Get scanner settings");
if (_deviceId == null)
{
throw new Exception("Не выбран источник данных для сканера.");
}
// connect to scanner
var device = ConnectToDevice();
var source = device.Items[1];
var supportedScanFeeds = GetSupportedDocumentHandlingCaps(device);
List <float> flatbedResolutions = null;
List <float> feederResolutions = null;
if (supportedScanFeeds == null || supportedScanFeeds.Count == 0 || !IsDocumentHandlingSelectSupported(device))
{
flatbedResolutions = GetAllowableResolutions(source);
}
else
{
if (supportedScanFeeds.ContainsKey((int)ScanFeed.Flatbad))
{
Debug("Getting resolutions for Flatbad");
try
{
SetProperty(device.Properties, WiaProperty.DocumentHandlingSelect, WIA_DPS_DOCUMENT_HANDLING_SELECT.Flatbad);
}
catch (Exception e)
{
Debug("Can't set DocumentHandlingSelect to Flatbad, " + e);
}
flatbedResolutions = GetAllowableResolutions(source);
}
if (supportedScanFeeds.ContainsKey((int)ScanFeed.Feeder))
{
Debug("Getting resolutions for Feeder");
try
{
SetProperty(device.Properties, WiaProperty.DocumentHandlingSelect, WIA_DPS_DOCUMENT_HANDLING_SELECT.Feeder);
}
catch (Exception e)
{
Debug("Can't set DocumentHandlingSelect to Feeder, " + e);
}
feederResolutions = GetAllowableResolutions(source);
}
}
var settings = new ScannerSettings(
_sourceIndex,
_name,
flatbedResolutions,
feederResolutions,
GetAllowablePixelTypes(),
GetMaxHeight(device),
GetMaxWidth(device),
supportedScanFeeds);
Log("Get scanner settings success");
return(settings);
}
public Task GetScannerSettings(ScannerSettings scannerSettings)
{
return(Clients.All.SendAsync("OnScannerSettingsReceived", scannerSettings));
}
public Task CallGetScannerSettings(ScannerSettings firstScanner)
{
return(_hubConnection.InvokeAsync(GetScannerSettings, firstScanner));
}
public ScannerParametersQueryResult Execute(object markerAsync)
{
_logger.Info("======================================= GET PARAMS QUERY ========================================");
_logger.Info("Scanner index: " + _sourceIndex);
ScannerSettings searchSetting = null;
List <ISource> sources = null;
if (Monitor.TryEnter(markerAsync))
{
_logger.Debug("Enter to monitor");
try
{
var sourcesCount = _scannerManager.SourceCount;
if (sourcesCount > 0)
{
//если выбранный источник существует, выбираем его; если нет - выбираем первый
int sourceIndex;
if (!_sourceIndex.HasValue || (_sourceIndex.Value > sourcesCount - 1))
{
sourceIndex = 0;
}
else
{
sourceIndex = _sourceIndex.Value;
}
if (_cacheSettings.NeedUpdateNow(DateTime.UtcNow))
{
_logger.Debug("Update cache");
_cacheSettings.Update(_scannerManager);
}
try
{
searchSetting = GetScannerSettings(sourceIndex);
}
catch (Exception e)
{
_logger.Error("Can't obtain scanner settings: " + e);
}
sources = _scannerManager.GetSources();
}
}
catch (Exception e)
{
return(new ScannerParametersQueryResult(string.Format("Ошибка при получении информации об источниках: {0}", e)));
}
finally
{
Monitor.Exit(markerAsync);
}
}
else
{
return(new ScannerParametersQueryResult(string.Format("Не удалось получить информацию об источниках: сканер занят")));
}
_logger.Info("Scan settings: " + (searchSetting == null? "": searchSetting.Serialize()));
return(new ScannerParametersQueryResult(sources, searchSetting, _sourceIndex));
}
