FórumSeções

Minha abordagem. O núcleo é o motor. - página 7

Novo comentário
A melhor maneira de organizar propriedades, objetos e elementos é criar uma mesa.

O núcleo dos elementos é a tabela.

Criamos um modelo proto-kernel, projetado para armazenar os parâmetros iniciais do objeto de um elemento em particular.

Em seguida, temos de criar um Kernel principal e escrever nele tantos elementos quantos forem necessários.

Então, estabeleceremos novos valores para cada elemento dentro do núcleo principal.

Depois disso, vamos criar elementos.

Em seguida, trabalharemos com eles em diferentes eventos.


Declare o núcleo principal:

int G_CORE[All_objects][All_properties];

Cada fileira do Núcleo ocupará um Objeto.

Temos que determinar quantos objetos totais estarão no núcleo. Para isso, temos que calcular o número de Itens que queremos criar e o número de Objetos em cada Item.

Digamos que temos 10 botões. Assim: 10 elementos * 3 objetos = 30 objetos. Portanto, há 30 fileiras.

#define  All_objects     30
#define  All_properties  10

Aumentamos o número de propriedades no núcleo principal, pois além dos parâmetros básicos precisamos dos nomes dos Elementos e Objetos, ligações entre eles e algumas outras propriedades.


Nós redeclaramos as propriedades dos objetos:

#define  NAME        0
#define  TYPE        1
#define  ELEMENT     2

#define  X           3
#define  X_SIZE      4
#define  Y           5
#define  Y_SIZE      6
#define  BG_COLOR    7
#define  TEXT_COLOR  7
#define  TEXT        8
#define  CORNER      9
#define  STATE       10
//-------------------

A propriedade TEXT conterá uma referência a outra matriz que conterá textos de botões.

A propriedade ELEMENT é necessária para ligar objetos do mesmo elemento dentro do núcleo (para evitar confusão sobre qual objeto pertence a qual elemento). Nesta propriedade, definiremos o número seqüencial do elemento.

Реter Konow: // Isto é o que se parece com as propriedades dos elementos:

É muito fácil confundir base, texto e ícone. Está claro na descrição o que está dentro deste ou daquele índice. Na programação real, você tem que manter tudo isso na sua cabeça. Eu sei que Peter é um titã da memória com uma capacidade nitidamente prejudicada de esquecer. Mas temo que não haja muitos titãs assim. Já estou esquecendo onde e o que colocar no dia seguinte.

Não seria melhor ter aproximadamente o seguinte (eu o faria):

Declarar as estruturas elementares que precisamos.

struct SPosition
{
uint m_uiX;
uint m_uiY;
};

struct SElementSize
{
uint m_uiXSize;
uint m_uiYSize;
};

Agora podemos obter a base, o texto e as interfaces de ícones a partir do objeto comum:

CBaseI* pbBase = core.GetBase();
CTextI* ptText = core.GetText();
CIconI* pbIcon = core.GetIcon();

E qualquer uma destas três interfaces - define a propriedade relevante. Bem, por exemplo, texto:

ptText.SetPosition(SPosition& rpPos);

Preenchemos a estrutura de posição (X e Y), chamamos a interface de texto a partir do núcleo, e a partir desta interface chamamos a função de configuração de posição com nossa estrutura. Cada uma dessas interfaces também tem uma função de ajuste de tamanho e cor. Faz sentido herdá-los de uma interface comum puramente virtual, onde todas as funções são zeradas.

Aqui, é muito mais difícil misturar as coisas. Porque, a qualquer momento, você só tem acesso ao que precisa para fazer seu trabalho. E para outra coisa, você tem que chamá-la, e se você não tem permissão para fazer isso, então com um projeto de sistema adequado você não pode nem mesmo chamar essa interface de "proibida", protegendo-se assim de erros.

E assim, vamos primeiro mudar o número de propriedades do protótipo de kernel, elas eram as mesmas que no kernel principal. Em seguida, vamos fazer um ciclo de construção de G_CORE.

int P_CORE[3][10] = {
//Основание кнопки.-----------------------------
//
//NAME     TYPE   ELEMENT     X    Y     X_SIZE  Y_SIZE       COLOR 
//----------------------------------------------
{ 100001,  base,  button,    100, 100,    200,    50,    C'245,245,245'},
//---------------------------------------------- 
//Текст кнопки.---------------------------------
//
//NAME    TYPE   ELEMENT   X    Y     X_SIZE  Y_SIZE       COLOR 
//----------------------------------------------
{100002,  text,  button,  120, 120,     0,      0,       C'245,0,0'},
//---------------------------------------------- 
//Иконка кнопки.-------------------------------- 
//
//NAME    TYPE     ELEMENT   X    Y     X_SIZE  Y_SIZE       COLOR 
{100003,  icon,    button,  140, 140,     16,     16,           0},
//---------------------------------------------- 
};
//Далее, строим G_CORE:
//--------------------------------------
int q = 0;
//--------------
for(int a1 = 0; a1 < All_objects; a1++)
  {
   for(int a2 = 0; a2 < All_properties; a2++)
    {
     G_CORE[a1][a2] = P_CORE[q][a2];
    }
     q++;
     if(q == 3)q = 0;    
  }


Após este ciclo, o núcleo G_CORE será preenchido com protótipos de 10 botões. Em seguida, nossa tarefa é dar aos Elementos nomes únicos e ligar os Objetos a seus Elementos, dando a cada Elemento um índice único.

Реter Konow:

E assim, primeiro vamos mudar o número de propriedades do protótipo de kernel, elas eram as mesmas que no kernel principal. Então vamos fazer um loop para construir G_CORE.

Você pode vê-lo perfeitamente a partir deste código.

Eu já esqueci o que significa a1 e o que significa a2.

Mas é a metade do problema - se esqueci, terei que olhar acima. Mas posso ter certeza de que não esqueci, e ainda posso misturar os elementos. E então é bom, se acontecer de imediato. Caso contrário, não é um fato, e o erro pode ocorrer muito mais tarde, e afetará, pela lei da má sorte, no lugar mais vulnerável, e no momento mais inoportuno.

A abordagem de Peter é a de um titã de memorização, o que também é bastante normal. Mas quantos participantes são tais titãs?

Enquanto isso, mesmo alguns uma pequena empresa abriu o código de sua GUI coxo :-)

eles estão realmente dando a volta por cima...eles estão com medo da concorrência!!!

piadas, piadas, mas qualquer pessoa interessada pode ver como o Windows GUI é construído a partir de dentro:

WPF é uma estrutura .NET Core UI para a construção de aplicações desktop Windows: https://github.com/dotnet/wpf

Windows Forms é uma estrutura .NET Core UI para a construção de aplicações desktop Windows: https://github.com/dotnet/winforms

Versões retrocompatíveis dos recursos do Windows UI, incluindo controles UWP XAML, e estilos e materiais fluentes: https://github.com/Microsoft/microsoft-ui-xaml


Maxim Kuznetsov:

Enquanto isso, mesmo alguns uma pequena empresa abriu o código de sua GUI queijosa :-

A GUI não é a questão aqui. Minha abordagem pode ser extrapolada e aplicada a qualquer propósito. Incluindo IA.

A seguir, mostrarei como isso pode ser feito.

George, por favor, deixe-me continuar. Eu sei que você prefere OOP e está mais à vontade dessa maneira. Mas, suas decisões são calculadas com base nas credenciais de um programador. Agora estou procurando uma abordagem, através da qual se possa alcançar o máximo desenvolvimento. A comodidade vem em segundo lugar.
Реter Konow:

Temos que determinar quantos objetos estarão no núcleo. Para isso, temos que calcular o número de Itens que queremos criar e o número de Objetos em cada Item.

#define  All_objects     30
#define  All_properties  10

Pergunta da audiência:

Vamos supor que criemos uma tabela de acordos do Expert Advisor comercial. Cada linha - uma transação com o preço de entrada, saída, volume, etc. Como saber antecipadamente, antes de compilarmos, o número de negócios que o Expert Advisor realizará para determinar corretamente o número de filas na tabela?

Vasiliy Sokolov:

Pergunta da audiência:

Suponha que criemos uma tabela de negociações de um Expert Advisor comercial. Cada fila é uma negociação com o preço de entrada, saída, volume, etc. Como posso saber antecipadamente, antes da compilação, o número de negócios que o Consultor Especialista realizará, a fim de determinar corretamente o número de linhas na tabela?

Adicione um número à matriz usando o ArrayResize em cada transação, e registre as propriedades do negócio nela.

Ao mesmo tempo, as propriedades serão distribuídas antecipadamente entre as células.

Em seguida, todos os dados serão encomendados.

1234567891011121314...184
Novo comentário