Como Criar um Extra para a QrCode Docker, CorelDraw Addon Parte 4

Notificando o progresso para a Interface principal e notificando o fim do processo

Publicado:04/05/2022 Modificado:04/05/2022

Começando o Extra

Adicionando idiomas ao Extra

Persistindo as configurações

Nossa Interface principal possui uma "Progress Bar" que podemos modificar seu valor em nossos Extra, para este fim temos que disparar o evento "ProgressChange", como nossa classe base do Core possui uma implementação de "OnProgressChange" iremos utiliza-lá.

Vamos abrir nosso projeto Teste, para conseguir manter nossa UI livre enquanto ocorre o processamento precisamos criar um nova "Thread", nossa UI vai continuar rodando em sua "Thread" e nosso processamento do desenho rodará em outra.

Vamos adicionar a diretiva "using System.Threading;", crie um variavel do tipo Thread, vamos criar uma instancia de Thread em nosso método "Draw", para se criar uma instância dessa classe precisamos passar um objeto do tipo "delegate", já temos uma classe pronta que fornece um objecto com o formato necessário do "delegate", a classe "ThreadStart", então vamos criar uma instância dessa classe e passar para nossa classe "Thread", porém precisamos fornecer um método "void" para esse "delegate", podemos criar uma função com nosso processamento ou podemos colocar nosso código do processamente dentro de uma expressão "lambda", vamos utilizar o segundo caso.

 drawThread = new Thread(new ThreadStart(() =>    {  Aqui vem nosso processamento         }                

            }));
            drawThread.IsBackground = true; definimos que nossa "Thread" vai rodar em plano de fundo
            drawThread.Start(); iniciamos nossa "Thread"

Precisamos também fazer um pequeno calculo matematico simples, pois nossa "Progress Bar" tem como valor inicial 0 e final de 100, como não sabemos que valores serão utilizados pelo nosso usuário precisaremos realizar este calculo.Vamos pegar o valor final e subtrair pelo inicial, precisamos agora verificar se o valor é diferente de 0, se caso for 0 retornaremos e não executamos nada, mas caso contrário pegamos o valor total da nossa "Progress Bar", no caso 100 e dividimos pelo resultado do calculo anterior, com isso temos a porcentagem de cada ciclo de nosso processamento.

double count = End - start;
            if (count == 0)
                return;
            else
                count = 100 / count;

Em cada ciclo de nosso processamento iremos disparar o evento "ProgressChange" informando o valor.

OnProgressChange((int)(count * i));

O valor informado será o produto de nossa porcentagem com nossa posição do ciclo fazendo uma conversão para um número inteiro.

Ao final do "loop" vamos informar a nossa Interface principal que o processo acabou, assim ela vai ocultar a "Progress Bar", para isso vamos dispara o evento "FinishJob", esse evento recebe um objeto de notificação , mas neste caso não passaremos nada, então usaremos "null".

OnFinishJob(null);

Com isso nosso código do Core está assim.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using br.corp.bonus630.PluginLoader;
using Corel.Interop.VGCore;

namespace TestExtra
{
    public class TestExtraCore : PluginCoreBase<TestExtraCore>, IPluginDrawer
    {
        private Thread drawThread;
        public const string PluginDisplayName = "Test Extra";
        public override string GetPluginDisplayName { get { return PluginDisplayName; } }

        public List<object[]> DataSource { get; set; }
        public double Size { get; set; }
        public Application App { get; set; }
        public ICodeGenerator CodeGenerator { get; set; }
        private int start;

        public int Start
        {
            get { return start; }
            set { start = value; OnNotifyPropertyChanged("Start"); }
        }
        private int end;

        public int End
        {
            get { return end; }
            set { end = value; OnNotifyPropertyChanged("End"); }
        }
        public override void SaveConfig()
        {
            Properties.Settings.Default.Start = Start;
            Properties.Settings.Default.End = End;
            Properties.Settings.Default.Save();
            base.SaveConfig();
        }
        public override void LoadConfig()
        {
            Start = Properties.Settings.Default.Start;
            End = Properties.Settings.Default.End;
            base.LoadConfig();
        }
        public override void DeleteConfig()
        {
            Properties.Settings.Default.Reset();
        }

        public void Draw()
        {
            double count = End - start;
            if (count == 0)
                return;
            else
                count = 100 / count;

            drawThread = new Thread(new ThreadStart(() =>
            {

                for (int i = Start; i <= End; i++)
                {
                    App.Optimization = true;
                    Shape code = CodeGenerator.CreateVetorLocal2(App.ActiveLayer, i.ToString(), Size);
                    code.SetPosition(code.PositionX + (Size * i), code.PositionY);
                    OnProgressChange((int)(count * i));
                    App.Optimization = false;
                    App.Refresh();
                }

                OnFinishJob(null);
            }));
            drawThread.IsBackground = true;
            drawThread.Start();
        }
    }
}

Vamos deixar as considerações finais para o próximo artigo