public static void Initiate()
{
if (!initiated)
{
logging = new LoggingSection("Services");
CommandHandler = new CommandHandler();
Scanners = new Scanners();
OCRProvider = new ConcurrentResourceProvider <TesseractEngine>();
TesseractEngine[] tesseractEngine = new TesseractEngine[Environment.ProcessorCount];
for (int i = 0; i < tesseractEngine.Length; i++)
{
tesseractEngine[i] = new TesseractEngine(@"./Tesseract/tessdata", "deu");
}
OCRProvider.Setup(tesseractEngine);
servicesToBeDisposed = new List <IDisposable>()
{
CommandHandler,
OCRProvider
};
initiated = true;
logging.Info("Services initiation complete");
}
}
public static void Options()
{
// Cria o arquivo se ele não existir
if (!Directories.Options.Exists)
{
Clean.Options();
}
else
{
// Create a Timer file
BinaryReader Arquivo = new BinaryReader(File.OpenRead(Directories.Options.FullName));
// Load the Data
Lists.Options.Jogo_Name = Arquivo.ReadString();
Lists.Options.SalvarUsuário = Arquivo.ReadBoolean();
Lists.Options.Sons = Arquivo.ReadBoolean();
Lists.Options.Músicas = Arquivo.ReadBoolean();
Lists.Options.User = Arquivo.ReadString();
// Download the file
Arquivo.Dispose();
}
// Adds the Data to the cache
Markers.Locate("Sons").State = Lists.Options.Sons;
Markers.Locate("Músicas").State = Lists.Options.Músicas;
Markers.Locate("SalvarUsuário").State = Lists.Options.SalvarUsuário;
if (Lists.Options.SalvarUsuário)
{
Scanners.Locate("Conectar_Usuário").Text = Lists.Options.User;
}
}
public static void Jogo_Chat()
{
// Define a bisiblidade da caixa
Panels.Locate("Chat").Geral.Visible = Scanners.Foco == Scanners.LocateIndex("Chat");
// Renderiza as caixas
Panel("Chat");
Scanner("Chat");
// Renderiza as mensagens
if (Tools.Lines_Visible)
{
for (byte i = Tools.Line; i <= Tools.Lines_Visíveis + Tools.Line; i++)
{
if (Tools.Chat.Count > i)
{
Desenhar(Tools.Chat[i].Text, 16, 461 + 11 * (i - Tools.Line), Tools.Chat[i].Cor);
}
}
}
// Dica de como Open o chat
if (!Panels.Locate("Chat").Geral.Visible)
{
Desenhar("Aperte [Enter] para Open o chat.", Scanners.Locate("Chat").Geral.Position.X + 5, Scanners.Locate("Chat").Geral.Position.Y + 3, SFML.Graphics.Color.White);
}
else
{
Button("Chat_Up");
Button("Chat_Down");
}
}
public void Should_exclude_bound_parameters()
{
Expression <Func <int, int, int> > expr = (x, y) => x + y;
var parameters = Scanners.FindUnboundParameters(expr);
Assert.Empty(parameters);
}
private void btnScan_Click(object sender, EventArgs e)
{
frmListOfScanner frmListOfScanner = new frmListOfScanner(scanner => { scanner.RefId = scanners.RefId; });
var frm = frmListOfScanner.ShowDialogResult();
scanners = frm.scanners;
this.pctScanImage.Image = scanners.ScanImage;
}
public static void Connect_Ready()
{
// Saves the user name
Lists.Options.User = Scanners.Locate("Conectar_Usuário").Text;
Write.Options();
// Connect with Jogo
Jogo.SetLocation(Jogo.Situations.Connect);
}
public static void Connect()
{
NetOutgoingMessage Data = Network.Device.CreateMessage();
// Envia os Data
Data.Write((byte)Packages.Connect);
Data.Write(Scanners.Locate("Conectar_Usuário").Text);
Data.Write(Scanners.Locate("Connect_Senha").Text);
Package(Data);
}
public static void Register()
{
NetOutgoingMessage Data = Network.Device.CreateMessage();
// Envia os Data
Data.Write((byte)Packages.Register);
Data.Write(Scanners.Locate("Register_User").Text);
Data.Write(Scanners.Locate("Register_Senha").Text);
Package(Data);
}
public static void CreateCharacter()
{
NetOutgoingMessage Data = Network.Device.CreateMessage();
// Envia os Data
Data.Write((byte)Packages.CreateCharacter);
Data.Write(Scanners.Locate("CreateCharacter_Name").Text);
Data.Write(Jogo.CreateCharacter_Classe);
Data.Write(Markers.Locate("GenreMasculino").State);
Package(Data);
}
public static void Register_Ready()
{
// Regras de segurança
if (Scanners.Locate("Register_Senha").Text != Scanners.Locate("Register_RepetirSenha").Text)
{
MessageBox.Show("The passwords you entered are not the same.");
return;
}
// Registra o Player, se estiver All certo
Jogo.SetLocation(Jogo.Situations.Register);
}
// IICDeviceBrowserDelegate Interface
public void DidAddDevice(ICDeviceBrowser browser, ICDevice device, bool moreComing)
{
Console.WriteLine($"{nameof (DidAddDevice)}: {device}");
if (device.Type.HasFlag(ICDeviceType.Scanner))
{
WillChangeValue("Scanners");
Scanners.Add(device);
DidChangeValue("Scanners");
device.Delegate = this;
}
}
private static void CreateCharacter(NetIncomingMessage Data)
{
// Reseta os valores
Scanners.Locate("CreateCharacter_Name").Text = string.Empty;
Markers.Locate("GenreMasculino").State = true;
Markers.Locate("GenreFeminino").State = false;
Jogo.CreateCharacter_Classe = 1;
// Abre o Panel de criação de Character
Panels.Menu_Close();
Panels.Locate("CreateCharacter").Geral.Visible = true;
}
private static void Entrar(NetIncomingMessage Data)
{
// Reseta os valores
Tools.Chat = new System.Collections.Generic.List <Tools.Chat_Structure>();
Scanners.Locate("Chat").Text = string.Empty;
Panels.Locate("Chat").Geral.Visible = false;
Tools.Line = 0;
// Abre o Jogo
Audio.Música.Stop();
Tools.CurrentWindow = Tools.Windows.Jogo;
}
private void Window_KeyDown(object sender, KeyEventArgs e)
{
// Define se um Button está sendo HoldKey
switch (e.KeyCode)
{
case Keys.Up: Jogo.HoldKey_Above = true; break;
case Keys.Down: Jogo.HoldKey_Below = true; break;
case Keys.Left: Jogo.HoldKey_Left = true; break;
case Keys.Right: Jogo.HoldKey_Right = true; break;
case Keys.ShiftKey: Jogo.HoldKey_Shift = true; break;
case Keys.ControlKey: Jogo.HoldKey_Control = true; break;
case Keys.Enter: Scanners.Chat_Digitar(); break;
}
// Em Jogo
if (Tools.CurrentWindow == Tools.Windows.Jogo)
{
if (!Panels.Locate("Chat").Geral.Visible)
{
switch (e.KeyCode)
{
case Keys.Space: Player.CollectItem(); break;
case Keys.D1: Sending.Hotbar_Use(1); break;
case Keys.D2: Sending.Hotbar_Use(2); break;
case Keys.D3: Sending.Hotbar_Use(3); break;
case Keys.D4: Sending.Hotbar_Use(4); break;
case Keys.D5: Sending.Hotbar_Use(5); break;
case Keys.D6: Sending.Hotbar_Use(6); break;
case Keys.D7: Sending.Hotbar_Use(7); break;
case Keys.D8: Sending.Hotbar_Use(8); break;
case Keys.D9: Sending.Hotbar_Use(9); break;
case Keys.D0: Sending.Hotbar_Use(0); break;
}
}
}
}
private async Task ListScanners()
{
Scanners.Clear();
var result = Service.GetAllScanners();
foreach (var item in result)
{
Scanners.Add(item);
}
await Task.CompletedTask;
}
public void Should_include_unbound_parameters()
{
var param1 = Expression.Parameter(typeof(int));
var expr = Expression.Lambda(
Expression.Add(
left: Expression.Parameter(typeof(int), "unbound"),
right: param1),
param1);
var parameters = Scanners.FindUnboundParameters(expr);
Assert.Single(parameters, p => p.Name == "unbound");
}
/// <summary>
/// 新規にパーサーを作成します。
/// </summary>
private Grammar CreateParser(AngleMode angleMode)
{
var sDelim = Scanners.IsWhitespaces().Many_();
var OPs = Terms.GetOperatorsInstance(
"+", "-", "**", "*", "/", "%", "(", ")", ",", "#");
var lToken = OPs.Lexer | Lexers.LexDecimal() | Lexers.LexWord();
var lexeme = Lexers.Lexeme(sDelim, lToken).FollowedBy(Parsers.Eof());
var pNumber = Terms.OnDecimal((from, len, s) => double.Parse(s));
var pWord = Terms.OnWord((from, len, s) => s);
Terms.FromSimpleToken <string, string>((from, len, s) => s);
var pPlus = GetOperator(OPs, "+", new Binary((a, b) => (a + b)));
var pMinus = GetOperator(OPs, "-", new Binary((a, b) => (a - b)));
var pMul = GetOperator(OPs, "*", new Binary((a, b) => (a * b)));
var pDiv = GetOperator(OPs, "/", new Binary((a, b) => (a / b)));
var pMod = GetOperator(OPs, "%", new Binary((a, b) => (a % b)));
var pPow = GetOperator(OPs, "**", new Binary((a, b) => Math.Pow(a, b)));
var pNone = GetOperator(OPs, "+", new Unary(n => n));
var pNeg = GetOperator(OPs, "-", new Unary(n => - n));
var opTable = new OperatorTable <double>()
.Infixl(pPlus, 10)
.Infixl(pMinus, 10)
.Infixl(pMul, 20)
.Infixl(pDiv, 20)
.Infixl(pMod, 20)
.Infixr(pPow, 30)
.Prefix(pNone, 40)
.Prefix(pNeg, 40);
var pLParen = OPs.GetParser("(");
var pRParen = OPs.GetParser(")");
var pComma = OPs.GetParser(new string[] { ",", "#" });
var lazyExpr = new Grammar[1];
var pLazyExpr = Parsers.Lazy <double>(() => lazyExpr[0]);
var pArg
= pLazyExpr.SepEndBy(pComma).Between(pLParen, pRParen)
| pLParen.Seq(pRParen).Seq(Parsers.Return(new double[0]));
var pTerm
= pLazyExpr.Between(pLParen, pRParen)
| pWord.And(pArg.Optional(), new Map <string, double[], double>(CalcFunc))
| pNumber;
var pExpr = Expressions.BuildExpressionParser(pTerm, opTable);
lazyExpr[0] = pExpr;
return(Parsers.ParseTokens(lexeme, pExpr.FollowedBy(Parsers.Eof()), "calculator"));
}
static ScannerData GetScannerComponent(Module[] modules)
{
var scanners = new Improbable.Collections.Map <int, ScannerStat>();
for (int i = 0; i < modules.Length; i++)
{
if (modules[i].Type == ModuleType.Scanner)
{
scanners[i] = Scanners.Craft(modules[i].Properties.BackingArray);
}
}
return(new ScannerData(scanners));
}
private void _scannersListPreview_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
{
try
{
_twain32?.Dispose();
_twain32 = new Twain32
{
ShowUI = true,
IsTwain2Enable = true
};
_twain32.OpenDSM();
_twain32.SourceIndex = Scanners.IndexOf(SelectedScanner);
_twain32.OpenDataSource();
_twain32.EndXfer += _twain32_EndXfer;
_twain32.AcquireCompleted += _twain32_AcquireCompleted;
_twain32.AcquireError += _twain32_AcquireError;
_twain32.MemXferEvent += _twain32_MemXferEvent;
_twain32.Acquire();
if (_scannedImage != null)
{
SaveImage();
}
Environment.ExitCode = (int)ExitCodes.ExitCode.SUCCESS;
CustomMessageBox.Show($"Save photo: {Path.GetFileName(_filePath)}\n{_destinationPath}", "Succes", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Information);
}
catch (Exception ex)
{
var messagebox = CustomMessageBox.Show(ex.Message, "Scanner Error!", System.Windows.Forms.MessageBoxButtons.YesNo, System.Windows.Forms.MessageBoxIcon.Error);
if (messagebox == System.Windows.Forms.DialogResult.Yes)
{
Environment.ExitCode = (int)ExitCodes.ExitCode.ERROR_DEVICE_UNREACHABLE;
}
}
finally
{
_twain32?.CloseDSM();
_twain32?.CloseDataSource();
_twain32.Dispose();
GC.Collect();
GC.WaitForPendingFinalizers();
this.Close();
}
}
private async Task ListScanners()
{
Scanners.Clear();
var client = new DeviceClient();
var result = client.GetAllScanners();
foreach (var item in result)
{
Scanners.Add(item);
}
await Task.CompletedTask;
}
internal static ValueTask <Validation <string, Func <CancellationToken, TResult> > > CompileQuery <TSourceDescription, TResult>(
Expression expression,
Verifier verify,
Authorizer <TSourceDescription> authorize,
IReadOnlyDictionary <string, TSourceDescription> bindings,
Func <Expression, Expression> boxingRewriter) where TSourceDescription : IQueryableSourceDescription =>
from verified in verify(expression).ToValueTask()
let unboundParameters = Scanners.FindUnboundParameters(expression)
from methodBindings in BindMethods(unboundParameters, bindings).ToValueTask()
from authorized in authorize(methodBindings.Values)
let lambdaBindings = BindLambdas(methodBindings)
let syntheticParameters = new[] { Expression.Parameter(typeof(CancellationToken)) }
from invocationBindings in BindInvocations(lambdaBindings, syntheticParameters).ToValueTask()
let boundQuery = BindingRewriter.Rewrite(expression, invocationBindings)
let boxedQuery = boxingRewriter(boundQuery)
select Expression.Lambda <Func <CancellationToken, TResult> >(boxedQuery, syntheticParameters).Compile();
public DocScanDocumentViewModel(IScannerService scannerService)
{
this.scannerService = scannerService;
FetchScanners();
BackHomeCommand = new DelegateCommand(NavigateBack);
ScanCommand = new DelegateCommand(Scan);
PreviewCommand = new DelegateCommand(Preview);
ManageCommand = new DelegateCommand(ManageImage);
SelectedScanner = Scanners.FirstOrDefault();
ResolutionsList = new ObservableCollection <Resolution>(Resolutions.List);
Resolution = Resolutions.R300;
}
private void SbtEventScannerAppearedHandler(SbtScannerInfo scanner)
{
if (Scanners.Count(m => m.ScannerName == scanner.ScannerName) == 0)
{
Scanners.Add(new ZebraScanner(scanner));
ScannersChanged?.Invoke();
}
if (_activeScannerName != null)
{
if (scanner.ScannerName == _activeScannerName)
{
connectedScanner = scanner;
apiInstance.SbtEstablishCommunicationSession(scanner.ScannerID);
apiInstance.SbtEnableAutomaticSessionReestablishment(true, scanner.ScannerID);
}
}
}
public Wizard()
{
Controls.Add(typeof(Start));
Controls.Add(typeof(Scan));
Controls.Add(typeof(Results));
Scanners.Add(new ApplicationInfo());
Scanners.Add(new ApplicationPaths());
Scanners.Add(new ApplicationSettings());
Scanners.Add(new ActivexComObjects());
Scanners.Add(new SharedDLLs());
Scanners.Add(new SystemDrivers());
Scanners.Add(new WindowsFonts());
Scanners.Add(new WindowsHelpFiles());
Scanners.Add(new RecentDocs());
Scanners.Add(new WindowsSounds());
Scanners.Add(new StartupFiles());
}
public static void Scanner(string Name)
{
byte Index = Scanners.LocateIndex(Name);
// List a ordem de renderização da ferramenta
Tools.Listr(Tools.Types.Scanner, Index);
// Não desenha a ferramenta se ela não for Visible
if (!Scanners.List[Index].Geral.CheckHabilitation())
{
return;
}
// Desenha a ferramenta
Renderizar_Caixa(Tex_Scanner, 3, Scanners.List[Index].Geral.Position, new Size(Scanners.List[Index].Width, MySize(Tex_Scanner).Height));
// Desenha o Text do Scanner
Scanner_Text(Index);
}
/// <summary>
/// Configures the scanners.
/// </summary>
/// <returns>The scanners.</returns>
protected override void ConfigureScanners()
{
Scanners.Discard(ReadMultilineComment).If(IsMultilineComment);
Scanners.Discard(ReadComment).If(IsComment);
Scanners.Scan(ReadIdentifier).If(IsIdentifier);
Scanners.Scan(ReadString).If(IsString);
Scanners.Scan(ReadNumber).If(IsNumber);
Scanners.Scan(ReadOperator).If(IsOperator);
Scanners.Scan('(').As(LoreToken.OpenParen);
Scanners.Scan(')').As(LoreToken.CloseParen);
Scanners.Scan('{').As(LoreToken.OpenBrace);
Scanners.Scan('}').As(LoreToken.CloseBrace);
Scanners.Scan('[').As(LoreToken.OpenBracket);
Scanners.Scan(']').As(LoreToken.CloseBracket);
Scanners.Scan(',').As(LoreToken.Comma);
Scanners.Scan(':').As(LoreToken.Colon);
Scanners.Scan(';').As(LoreToken.Semicolon);
Scanners.Scan('.').As(LoreToken.MemberAccess);
}
private static void Scanner()
{
// Contagem para a renderização da referência do último Text
if (Scanner_Contagem < Environment.TickCount)
{
Scanner_Contagem = Environment.TickCount + 500;
Scanners.Sinal = !Scanners.Sinal;
// Se necessário foca o Scanner de novo
Scanners.Focalizar();
}
// Chat
if (Tools.Lines_Visible && !Panels.Locate("Chat").Geral.Visible)
{
if (Chat_Contagem < Environment.TickCount)
Tools.Lines_Visible = false;
}
else
Chat_Contagem = Chat_Contagem = Environment.TickCount + 10000;
}
/// <summary>
/// Inner parse method
/// </summary>
/// <param name="scanner">scanner</param>
/// <returns>the match</returns>
protected override ParserMatch ParseMain(Scanners.IScanner scanner)
{
ParserMatch m = FirstParser.TryAccept(scanner);
if (!m.Success)
{
return m;
}
// doing difference
ParserMatch d = SecondParser.TryAccept(scanner);
if (d.Success)
{
if (d.Length >= m.Length)
{
return ParserMatch.CreateFailureMatch(scanner, m.Offset, 0);
}
}
// ok
FirstParser.Parse(scanner);
return m;
}
private void LoadParametes()
{
try
{
_twain32 = new Twain32
{
ShowUI = true,
IsTwain2Enable = true
};
_twain32.OpenDSM();
#region GetScanners
for (int i = 0; i < _twain32.SourcesCount; i++)
{
_scanners.Add(_twain32.GetSourceProductName(i));
}
#endregion GetScanners
if (Scanners.Count > 0)
{
SelectedScanner = Scanners.FirstOrDefault();
}
}
catch (Exception ex)
{
var messagebox = CustomMessageBox.Show(ex.Message, "Error!", System.Windows.Forms.MessageBoxButtons.YesNo, System.Windows.Forms.MessageBoxIcon.Error);
if (messagebox == System.Windows.Forms.DialogResult.Yes)
{
_twain32?.CloseDSM();
_twain32?.CloseDataSource();
_twain32.Dispose();
Environment.ExitCode = (int)ExitCodes.ExitCode.ERROR_DEVICE_UNREACHABLE;
this.Close();
}
}
}
internal void ParseModelChild(SectionModel model)
{
if (model.Root.Children[0].Children.Count <= 0)
{
throw new ArgumentException("model must contain children", nameof(model));
}
foreach (var child in model.Root.Children[0].Children)
{
foreach (var scanner in Scanners.Where(scanner => child.SectionName == scanner.ScannerName))
{
if (child.IsChecked.HasValue && child.IsChecked.Value)
{
scanner.BitmapImg = child.BitmapImage;
scanner.IsEnabled = true;
Scan.EnabledScanners.Add(scanner);
}
else
{
scanner.IsEnabled = false;
}
}
}
}
/// <summary>
/// Query on Wolfram Alpha using the specified
/// </summary>
/// <param name="query">The query you would like to search for on Wolfram Alpha</param>
/// <returns>The results of the query</returns>
public QueryResult Query(string query)
{
//http://api.wolframalpha.com/v2/query?input=xx&appid=xxxxx
RestRequest request = CreateRequest("query", query);
//Output
if (Formats.HasElements())
{
request.AddParameter("format", string.Join(",", Formats));
}
if (OutputUnit != Unit.NotSet)
{
request.AddParameter("units", OutputUnit.ToString().ToLower());
}
if (Assumptions.HasElements())
{
foreach (string assumption in Assumptions)
{
request.AddParameter("assumption", assumption);
}
}
//Filtering
if (IncludePodIDs.HasElements())
{
foreach (string include in IncludePodIDs)
{
request.AddParameter("includepodid", include);
}
}
if (ExcludePodIDs.HasElements())
{
foreach (string exclude in ExcludePodIDs)
{
request.AddParameter("excludepodid", exclude);
}
}
if (PodTitles.HasElements())
{
foreach (string podTitle in PodTitles)
{
request.AddParameter("podtitle", podTitle);
}
}
if (PodIndex.HasElements())
{
request.AddParameter("podindex", string.Join(",", PodIndex));
}
if (Scanners.HasElements())
{
request.AddParameter("scanner", string.Join(",", Scanners));
}
//Timeout
if (ParseTimeout >= Epsilon)
{
request.AddParameter("parsetimeout", ParseTimeout.ToString(_culture));
}
if (ScanTimeout >= Epsilon)
{
request.AddParameter("scantimeout", ScanTimeout.ToString(_culture));
}
if (PodTimeout >= Epsilon)
{
request.AddParameter("podtimeout", PodTimeout.ToString(_culture));
}
if (FormatTimeout >= Epsilon)
{
request.AddParameter("formattimeout", FormatTimeout.ToString(_culture));
}
//Async
if (UseAsync)
{
request.AddParameter("async", UseAsync.ToString().ToLower());
}
//Location
if (IpAddress != null)
{
request.AddParameter("ip", IpAddress.ToString());
}
if (!string.IsNullOrEmpty(Location))
{
request.AddParameter("location", Location);
}
if (GPSLocation != null)
{
request.AddParameter("latlong", GPSLocation.ToString());
}
//Size
if (Width >= 1f)
{
request.AddParameter("width", Width);
}
if (MaxWidth >= 1f)
{
request.AddParameter("maxwidth", MaxWidth);
}
if (PlotWidth >= 1f)
{
request.AddParameter("plotwidth", PlotWidth);
}
if (Magnification >= 0.1f)
{
request.AddParameter("mag", Magnification.ToString(_culture));
}
//Misc
if (!string.IsNullOrEmpty(Signature))
{
request.AddParameter("sig", Signature);
}
if (ReInterpret.HasValue)
{
request.AddParameter("reinterpret", ReInterpret.ToString().ToLower());
}
if (IgnoreCase.HasValue)
{
request.AddParameter("ignorecase", IgnoreCase.ToString().ToLower());
}
if (EnableTranslate.HasValue)
{
request.AddParameter("translation", EnableTranslate.ToString().ToLower());
}
QueryResult results = GetResponse <QueryResult>(request);
return(results);
}
