Criar uma biblioteca gráfica a partir do zero - página 4

Novo comentário
 
Реter Konow:
Quem sabe por que não funciona...

O esquema da biblioteca deve ser elaborado primeiro, e depois os códigos devem ser escritos. Esta é geralmente a maneira de fazer isso.

trabalha em C++

O que o faz pensar que o esquema não foi elaborado, havia algum pré-requisito para isso???
 
Alexandr Andreev:

trabalha em C++

O que o faz pensar que não existe um esquema, havia algum pré-requisito para isso?
Onde está? Não o vejo há três páginas.
 
Реter Konow:
Onde está? Não o vejo há três páginas.

Eu estava pensando em fazer uma base de uso que seria reduzida ao estilo de código mínimo New_Window<<<Window_Upper.Size; New_Window<<<Window_Upper.Position; New_Window.Size<<<0.5 (o tamanho se torna automaticamente metade do acima); ...

E esta classe já leva em conta a relação desde a posição da pequena cruz até a janela mais alta (base).

Parece que não vai correr bem... isso acontece.
 
Alexandr Andreev:

Eu estava pensando em fazer uma base de uso que seria reduzida ao estilo de código mínimo New_Window<<<Window_Upper.Size; New_Window<<<Window_Upper.Position; New_Window.Size<<<0.5 (o tamanho se torna automaticamente metade do acima); ...

E esta classe já leva em conta a relação desde a posição da pequena cruz até a janela mais alta.

Ehhh, heh, heh.... "o que nos custa construir uma casa, vamos desenhá-la, vamos viver"...

Eu mesmo tenho a mesma abordagem. Somente eu pago por isso com anos de trabalho duro.
 
Алексей Барбашин:

...

Bem, eu já descrevi muitas vezes as "falhas" que do meu ponto de vista vejo na biblioteca padrão e na biblioteca do Anatoly.

Ambas as bibliotecas têm, em minha opinião, uma desvantagem significativa: interface é construída sobre objetos gráficos discretos,ou seja, quanto mais controles na interface, mais objetos isolados no próprio gráfico. Por um lado, não é um problema em si, mas por outro lado é um problema ao arrastar e soltar diálogos, pois não um único objeto "forma com elementos" é arrastado e solto, mas muitos elementos diferentes. E isto consome recursos adicionais.

A biblioteca de Anatoly é muito chique, mas é complicada em sua composição e difícil de ser integrada ao programa principal. E a biblioteca padrão é limitada nos próprios controles, embora a arquitetura original seja muito boa, na minha opinião.

Na verdade, a melhor solução seria o que Petr Konov tenta fazer: construtor de GUI GUI com geração de código GUI, mas com modelo de evento estendido, de modo que ao integrar com o programa principal, você não teria que cavar em enorme código GUI (algo como o analógico MVVM), e, claro, com objetos que os usuários poderiam estender por conta própria.

Naturalmente, esta é uma visão muito simplificada sobre o problema das bibliotecas gráficas. Não se trata de arrastar e soltar formulários e a falta de manuseio de kanvas, o que limita as possibilidades e a funcionalidade da GUI. O resultado final é que os objetos MTtêm poucas propriedades, e os manipuladores de bibliotecas não estão suficientemente desenvolvidos para gerenciar os elementos desenhados e para suportar todas as suas diversas capacidades. A complexidade dos objetos MT e a funcionalidade de controle das bibliotecas não atingem o nível mínimo exigido pelo kanvas.

Levar estas bibliotecas e reescrevê-las para kanvas significa elevá-las a um nível fundamentalmente novo, que a priori não pode ser fácil e simples.


ZS. Anatoly iniciou o caminho para kanvas em sua biblioteca e foi o primeiro a criar mesas desenhadas em MKL. No entanto, o método de construí-las é imperfeito, devido ao fato de que as células são elementos semi-independentes e há dificuldades em abordar cada um deles individualmente.

Lembro-me de quanto custou a transição Anatoly e quanto tempo ela levou.

 

É mais ou menos assim

#define  TEMPLATE(T) template<typename T>
#define  TEMPLATE2(T1,T2) template<typename T1, typename T2>

#define  TEMPL(T) TEMPLATE(T)
#define  TEMPL1(T) TEMPLATE(T)
#define  TEMPL2(T,T1) TEMPLATE2(T,T1)
//whats TD (template define)? because TT is busy
//почемуто этот код в шаблонах на мкл не хочет компилироваться поэтому через дефайн - это Плохо надо бы через шаблоны как то придумать.... привет метаквотам
#define  TD1 int
#define  TD2 double 
#define  EMPY -1 
#define  GET this.operator>> 
#define  SET this.operator<< 
class CCoordD; 
class CSizeD;
class CCoordBaseD //полностью внутрений класс
   {
   private:
   #define  ME CCoordBaseD 
   TEMPL1(T)
   bool Chek(T *a)                  {return CheckPointer(a)!=POINTER_INVALID;}
   TEMPL1(T)
   bool Chek(T a)                   {return a!=(T)EMPY;}
   TD1 Error()                      {Print(__FUNCTION__," ",__LINE__," POINTER_INVALID size"); int a[]; a[0]=0; return (TD1)EMPY;};//wtf??? =P CRASH Error
   TD1 GetA()                       {return c.GetA()+ar;}
   TD1 GetP()                       {return c.Result() + size.GetP()*(TD1)pr;}
   public:
   ME()                                   {Init();} 
   ME(TD1 a)                              {Init(a);} 
   ME(TD1 a,CCoordD &b)                   {Init(a,b);} 
   ME(TD1 a,CCoordD &b,CSizeD &x)         {Init(a,b,x);} 
   ME(TD2 a,CSizeD &b)                    {Init(a,b);} 
   ME(TD2 a,CCoordD &b,CSizeD &x)         {Init(a,b,x);} 
   CCoordD *c;//one coord
   CSizeD *size;//size 
   TD1 ar;
   TD2 pr;//percent проценты
   void Init()                            {ar=(TD1)EMPY; pr=(TD2)EMPY; }  
   TD1 Result()                           {return Chek(ar)?Chek(c)?GetA():ar:Chek(pr)?Chek(size)?GetP():Error():(TD1)EMPY;}
   ME *GetMe()                            {return &this;}
   ME *GetCoorBase()                      {return c;}
   ME *GetSizeBase()                      {return size;} 
   CCoordD *GetCoor()                     {return c;}
   CSizeD *GetSize()                      {return size;} 
   void Init(TD1 a)                       {Init(); SET(a);}
   void Init(TD1 a,CCoordD &b)            {Init(); SET(a); SET(b);}
   void Init(TD1 a,CCoordD &b,CSizeD &x)  {Init(); SET(a); SET(b); SET(x);}
   void Init(TD1 a,CSizeD &b,CCoordD &x)  {Init(); SET(a); SET(b); SET(x);}
 //  void Init(TD2 p)                     {Init(); pr=p_;}
   void Init(TD2 a,CSizeD &b)             {Init(); SET(a); SET(b);}
   void Init(TD2 a,CCoordD &b,CSizeD &x)  {Init(); SET(a); SET(b); SET(x);}
   void Init(TD2 a,CSizeD &b,CCoordD &x)  {Init(); SET(a); SET(b); SET(x);}
   void operator >> (TD1 a)               {a=ar;} 
   void operator >> (TD2 a)               {a=pr;}  
   void operator >> (CCoordD &a)          {a=GetPointer(c);}  
   void operator >> (CSizeD &s)           {s=GetPointer(size);}  
   void operator << (TD1 a)               {ar=a;} 
   void operator << (TD2 a)               {pr=a;}  
   void operator << (CCoordD &a)          {c=GetPointer(a);}  
   void operator << (CSizeD &s)           {size=GetPointer(s);}  
   void operator << (ME &a)               {a>>c; a>>ar; a>>pr; a>>size;}  
   void operator = (CCoordD &a)           {SET(a);}
   void operator = (CSizeD &a)            {SET(a);}
   void operator = (ME &a)                {SET(a);} 
   TD1 operator ~ ()                      {return Result();} 
   #undef  ME
   #undef  GET 
   #undef  SET
   };
   
class CSizeD : public CCoordBaseD
   {
   public:
   CSizeD(){};
   };
   
class CCoordD : public CCoordBaseD
   {
   public:
   CCoordD(){};
   };

class CCoord;

class CTX {public:CTX(){}}; 
class CTY {public:CTY(){}};
class CTZ {public:CTZ(){}};
TEMPL(T)
class CCoordA : public T
   {
   public:
   CCoordD ar; 
   CSizeD size;
   CCoordA()                                                {}; 
   CCoordA(TD1 a1,TD1 a2=(TD1)0)                            {Init(a1,a2);} 
   CCoordA(TD1 a1,CCoordD &c1, CSizeD &c2,TD1 a2)           {Init(a1,c1,c2,a2);}  
   CCoordA(TD1 a1,CCoordD &c1, CSizeD &c2,TD2 a2=(TD2)1)    {Init(a1,c1,c2,a2);}  
   CCoordA(TD2 a1,CCoordD &c1, CSizeD &c2,TD1 a2)           {Init(a1,c1,c2,a2);}  
   CCoordA(TD2 a1,CCoordD &c1, CSizeD &c2,TD2 a2=(TD2)1)    {Init(a1,c1,c2,a2);}   
   void Init()                                              {} 
   void Init(TD1 a1,TD1 a2=(TD1)0)                          {ar.Init(a1);        size.Init(a2);} 
   void Init(TD1 a1,CCoordD &c1, CSizeD &c2,TD1 a2)         {ar.Init(a1,c1,c2);  size.Init(a2,c1,c2);}  
   void Init(TD1 a1,CCoordD &c1, CSizeD &c2,TD2 a2=(TD2)1)  {ar.Init(a1,c1,c2);  size.Init(a2,c1,c2);}  
   void Init(TD2 a1,CCoordD &c1, CSizeD &c2,TD1 a2)         {ar.Init(a1,c1,c2);  size.Init(a2,c1,c2);}  
   void Init(TD2 a1,CCoordD &c1, CSizeD &c2,TD2 a2=(TD2)1)  {ar.Init(a1,c1,c2);  size.Init(a2,c1,c2);}  
   void operator <<(CSizeD &a)   {return ;}
   void operator <<(CCoordD &a)  {return ;} 
   bool Chek(int px)             {return (px-=(int)~ar) < 0 && px<(int)~size;}                   
   };
   
class CCoord
   {  
   public: 
   CCoordA<CTX> X;
   CCoordA<CTY> Y; 
   CCoord ()                              {} 
   void operator >> (CCoordA<CTX> &a)     {a=GetPointer(X);}
   void operator >> (CCoordA<CTY> &a)     {a=GetPointer(Y);}
   void operator << (CCoord &a)           {a>>X; a>>Y;}
   bool MouseOn(CMouse &mouse)//px
      {
      return X.Chek(mouse.X) && Y.Chek(mouse.Y);
      }
   };  
CCoord Pro1; 

void Func()
   {
   TD1 bi;//buf int
   TD1 bd;//buf double
   CCoord general;//создали класс координат некого объекта - к примеру окна дженерал
   general.X.Init((int)0,(int)1000); //установили размер
   general.Y.Init((int)0,(int)1000); 
   
   CCoord next;//создали класс координат следующего окна
   next<<general;//сделали его зависимым от главного окна
   next.X.ar<<(double)0.25;//старт по оси Х 25%, если значение типа дабл автоматически считается процент
   next.X.size<<(double)0.5;//размер окна равен 50% от главного.
   }
   #undef  TD1
   #undef  TD2
 

Esse é o fim da classe de coordenadas. Eu nem sei o que vem a seguir.

Mas acho que deveríamos acrescentar posicionamento.

No estilo do próximo, em, esquerda, topo. cent.....

 
Alexandr Andreev:

É mais ou menos assim.


#define  TEMPLATE(T) template<typename T>
#define  TEMPLATE2(T1,T2) template<typename T1, typename T2>

#define  TEMPL(T) TEMPLATE(T)
#define  TEMPL1(T) TEMPLATE(T)
#define  TEMPL2(T,T1) TEMPLATE2(T,T1)

Você também esqueceu isto:

#define  TE(T) TEMPL(T)
#define  TE1(T) TEMPL1(T)
#define  TE2(T,T1) TEMPL2(T,T1)
 
Alexandr Andreev:

É mais ou menos assim.

#define  TD1 int
#define  TD2 double

E é isso que está faltando:

#define  TD3 bool
#define  TD4
 void
 
Aliaksandr Hryshyn:

E é isto que está faltando:

Eu queria usar modelos, mas eles não compilam, o exemplo simplificado na página anterior

E não é certo que será exatamente intrigante e não algum enumero, e então você não quer consertar o código

E por que precisamos de um bool lá?

Idealmente, deveria ser assim

enum EPX{}//px
enum EPR{}//процент
#define  TD1 EPX
#define  TD2 EPR

E nenhum TD3 (na verdade a classe inteira é escrita para dois valores). Por que eu chamei a TD também escrito no código

1234567891011...15
Novo comentário