Mi enfoque. El núcleo es el motor. - página 7

Nuevo comentario
 
La mejor manera de organizar las propiedades, los objetos y los elementos es crear una tabla.

El núcleo de los elementos es la mesa.

Hemos creado un modelo de proto-núcleo, diseñado para almacenar los parámetros iniciales del objeto de un elemento particular.

A continuación, tenemos que crear un Kernel principal y escribir en él tantos elementos como necesitemos.

A continuación, estableceremos nuevos valores a cada elemento dentro del núcleo principal.

Después crearemos elementos.

Luego trabajaremos con ellos en diferentes eventos.


 

Declarar el núcleo principal:

int G_CORE[All_objects][All_properties];

Cada fila del núcleo ocupará un objeto.

Tenemos que determinar cuántos objetos totales habrá en el núcleo. Para ello, tenemos que calcular el número de Elementos que queremos crear y el número de Objetos de cada Elemento.

Digamos que tenemos 10 botones. Entonces: 10 elementos * 3 objetos = 30 objetos. Así que hay 30 filas.

#define  All_objects     30
#define  All_properties  10

Hemos aumentado el número de propiedades en el núcleo principal, porque además de los parámetros básicos necesitamos los nombres de los Elementos y Objetos, la unión entre ellos y algunas otras propiedades.


Volvemos a declarar las propiedades de los 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
//-------------------

La propiedad TEXT contendrá una referencia a otro array que contendrá los textos de los botones.

La propiedad ELEMENTO es necesaria para enlazar objetos del mismo elemento dentro del núcleo (para evitar confusiones sobre qué objeto pertenece a qué elemento). En esta propiedad estableceremos el número de secuencia del elemento.

 
Реter Konow: /Este es el aspecto que tendrían las llamadas a las propiedades de los elementos:

Es muy fácil confundir base, texto e icono. En la descripción queda claro qué hay dentro de tal o cual índice. En la programación real, hay que tenerlo todo en la cabeza. Sé que Peter es un titán de la memoria con una capacidad de olvido muy reducida. Pero me temo que no hay muchos titanes así. Ya se me olvida dónde y qué poner al día siguiente.

¿No sería mejor tener más o menos lo siguiente (yo lo haría):

Declarar las estructuras elementales que necesitamos.

struct SPosition
{
uint m_uiX;
uint m_uiY;
};

struct SElementSize
{
uint m_uiXSize;
uint m_uiYSize;
};

Ahora podemos obtener las interfaces de base, texto e icono del objeto común:

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

Y cualquiera de estas tres interfaces - establece la propiedad apropiada. Bueno, por ejemplo, el texto:

ptText.SetPosition(SPosition& rpPos);

Llenamos la estructura de posición (X e Y), llamamos a la interfaz de texto desde el núcleo, y desde esta interfaz llamamos a la función de ajuste de posición con nuestra estructura. Cada una de estas interfaces tiene también una función para ajustar el tamaño y el color. Tiene sentido heredarlos de una interfaz común puramente virtual, donde todas las funciones se ponen a cero.

Aquí, es mucho más difícil mezclar las cosas. Porque en un momento dado, sólo tienes acceso a lo que necesitas para hacer tu trabajo. Y para otra cosa, todavía tienes que llamarla, y si no se te permite hacerlo, ni siquiera puedes llamar a esta interfaz "prohibida", protegiéndote así de los errores.

 

Y así, vamos a cambiar primero el número de propiedades del núcleo prototipo, eran las mismas que en el núcleo principal. A continuación vamos a realizar un ciclo de construcción 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;    
  }


Después de este ciclo, el núcleo G_CORE se llenará de prototipos de 10 botones. A continuación, nuestra tarea es dar a los elementos nombres únicos y vincular los objetos a sus elementos, dando a cada elemento un índice único.

 
Реter Konow:

Y así, primero vamos a cambiar el número de propiedades del núcleo prototipo, eran las mismas que en el núcleo principal. Entonces hagamos un bucle para construir G_CORE.

Puedes verlo perfectamente en este código.

Ya he olvidado qué significa a1 y qué significa a2.

Pero es la mitad del problema: si me he olvidado, tendré que mirar arriba. Pero puedo estar seguro de que no se me ha olvidado, y todavía puedo mezclar los elementos. Y entonces es bueno, si sale bien. De lo contrario, no es un hecho, y el error puede ocurrir mucho más tarde, y afectará, por la ley de la mala suerte, en el lugar más vulnerable, y en el momento más inoportuno.

El enfoque de Pedro es el de un titán de la memorización, lo que también es bastante normal. Pero, ¿cuántos participantes son esos titanes?

 

Mientras tanto, incluso algunos una pequeña empresa abrió el código de su cojo GUI :-)

realmente están dando la vuelta a la tortilla... ¡¡¡tienen miedo de la competencia!!!

bromas, bromas, pero cualquiera que esté interesado puede ver cómo se construye la interfaz gráfica de Windows desde dentro:

WPF es un marco de trabajo de interfaz de usuario de .NET Core para crear aplicaciones de escritorio de Windows: https://github.com/dotnet/wpf

Windows Forms es un marco de trabajo de interfaz de usuario de .NET Core para crear aplicaciones de escritorio de Windows: https://github.com/dotnet/winforms

Versiones retrocompatibles de las características de la interfaz de usuario de Windows, incluidos los controles UWP XAML y los estilos y materiales Fluent: https://github.com/Microsoft/microsoft-ui-xaml


 
Maxim Kuznetsov:

Mientras tanto, incluso algunos una pequeña empresa ha abierto el código de su cursi interfaz gráfica de usuario :-

La interfaz gráfica de usuario no es el problema aquí. Mi enfoque puede extrapolarse y aplicarse a cualquier propósito. Incluyendo la IA.

A continuación, te mostraré cómo se puede hacer.

 
George, por favor, déjame continuar. Sé que prefieres la OOP y que te sientes más cómodo así. Pero, sus decisiones se calculan en base a las credenciales de un programador. Ahora estoy buscando un enfoque, a través del cual se puede lograr el máximo desarrollo. La comodidad es lo segundo.
 
Реter Konow:

Tenemos que determinar cuántos objetos habrá en el núcleo. Para ello, tenemos que calcular el número de Elementos que queremos crear y el número de Objetos de cada Elemento.

#define  All_objects     30
#define  All_properties  10

Pregunta del público:

Supongamos que creamos una tabla de operaciones del Asesor Experto en comercio. Cada fila - una transacción con la entrada, el precio de salida, el volumen, etc. ¿Cómo saber de antemano, antes de compilar, el número de operaciones que realizará el Asesor Experto para determinar correctamente el número de filas de la tabla?

 
Vasiliy Sokolov:

Pregunta del público:

Supongamos que creamos una tabla de operaciones de un Asesor Experto en comercio. Cada fila es una operación con el precio de entrada, de salida, el volumen, etc. ¿Cómo puedo saber de antemano, antes de la compilación, el número de operaciones que realizará el Asesor Experto, para determinar correctamente el número de filas de la tabla?

Añade un número al array usando ArrayResize en cada operación, y registra las propiedades de la operación en él.

Al mismo tiempo, las propiedades se distribuirán por adelantado entre las celdas.

Después, se ordenarán todos los datos.

1234567891011121314...184
Nuevo comentario
Razón de la queja: