Erstellen einer Grafikbibliothek von Grund auf - Seite 3

Neuer Kommentar
 
Maxim Kuznetsov:

Kurz zum Thema Technik:

Wenn man ein "A" durch eine Neuentwicklung verbessern will, muss man seine kritischen Schwachstellen aufzeigen. Führen Sie sie einfach auf und erklären Sie, warum sie im Prozess der evolutionären Entwicklung von A unlösbar sind.

Andererseits verbietet es aber auch niemand. Wenn Sie gerne Code schreiben, schreiben Sie ihn. Schreiben Sie "A" um, aber auf Ihre eigene Art und Weise, aber es wird neu sein

Max, hallo!

Nun, ich habe bereits wiederholt die "Mängel" beschrieben, die ich aus meiner Sicht in der Standardbibliothek und in Anatolys Bibliothek sehe.

Beide Bibliotheken haben meiner Meinung nach einen entscheidenden Nachteil: Die Schnittstelle ist auf diskreten Diagrammobjekten aufgebaut, d.h. je mehr Steuerelemente in der Schnittstelle, desto mehr isolierte Objekte im Diagramm selbst. Auf der einen Seite scheint dies kein Problem zu sein, aber auf der anderen Seite ist es ein Problem mit Drag-and-Drop-Dialogen, da nicht ein einzelnes "Formular mit Elementen"-Objekt gezogen und fallen gelassen wird, sondern viele verschiedene Elemente. Und das verbraucht zusätzliche Ressourcen.

Die Bibliothek von Anatoly ist sehr schick, aber sie ist kompliziert in ihrer Zusammensetzung und schwer in das Hauptprogramm zu integrieren. Und die Standardbibliothek ist bei den Steuerelementen selbst begrenzt, obwohl die ursprüngliche Architektur meiner Meinung nach sehr gut ist.

In der Tat wäre die beste Lösung, was Petr Konov versucht zu tun: GUI GUI Builder mit GUI-Code-Generierung, aber mit erweiterten Event-Modell, so dass bei der Integration mit dem Hauptprogramm, würden Sie nicht brauchen, um in großen GUI-Code (so etwas wie MVVM-Analogie), und natürlich mit Objekten, die Benutzer könnten auf ihre eigenen zu erweitern.

 
Алексей Барбашин:

Max, hallo!

Nun, ich habe bereits mehrfach die "Mängel" beschrieben, die ich aus meiner Sicht in der Standardbibliothek und in der Bibliothek von Anatoly sehe.

Beide Bibliotheken haben meiner Meinung nach einen entscheidenden Nachteil: Die Schnittstelle ist auf diskreten Diagrammobjekten aufgebaut, d.h. je mehr Steuerelemente in der Schnittstelle, desto mehr isolierte Objekte im Diagramm selbst. Auf der einen Seite scheint dies kein Problem zu sein, aber auf der anderen Seite ist es ein Problem mit Drag-and-Drop-Dialogen, da nicht ein einzelnes "Formular mit Elementen"-Objekt gezogen und fallen gelassen wird, sondern viele verschiedene Elemente. Und das verbraucht zusätzliche Ressourcen.

Die Bibliothek von Anatoly ist sehr schick, aber sie ist komplex in ihrer Zusammensetzung und schwer in das Hauptprogramm zu integrieren. Und die Standardbibliothek ist bei den Steuerelementen selbst begrenzt, obwohl die ursprüngliche Architektur meiner Meinung nach sehr gut ist.

Eigentlich wäre die beste Lösung das, was Petr Konov versucht: ein GUI-GUI-Builder mit GUI-Code-Generierung, aber mit einem erweiterten Ereignismodell, so dass man bei der Integration in das Hauptprogramm nicht in riesigen GUI-Code gehen muss, und natürlich mit Objekten, die Benutzer selbst erweitern können.

das Zitat sollte von unten nach oben gelesen werden. Der untere Teil (das, was unterstrichen ist) ist wichtiger. Das ist der entscheidende Punkt.

Bei all der modernen Entwicklung der Human Interfaces ist es eher überraschend, dass Koordinatenansichten und Formularelemente im Vordergrund stehen.
Gleichzeitig benutzt jeder Browser mit Rest/Ajax, weiß was MVC ist, denkt aber nicht an die Schnittstelle zwischen dem Expert Advisor und seiner GUI.

Wenn das Modell beschrieben ist und es ein Protokoll für die Arbeit mit ihm gibt, kann die grafische Benutzeroberfläche beliebig sein und ist nicht vom Expert Advisor abhängig. Es ist eine böse, böse, böse Sache, Fenster in den Expert Advisor einzubauen. Der Hauptzweck von Expert Advisors ist der Handel, alles andere sollte aus dem Hauptcode herausgenommen werden und optional sein.

 
Maxim Kuznetsov:

das Zitat muss von unten nach oben richtig gelesen werden. Der untere Teil (das, was unterstrichen ist) ist wichtiger. Sie ist das Entscheidende.

Bei all der modernen Entwicklung des Human Interface ist es recht überraschend, dass Koordinatendarstellungen und Formelemente im Vordergrund stehen.
Gleichzeitig benutzt jeder Browser mit Rest/Ajax, weiß was MVC ist, denkt aber nicht an die Schnittstelle zwischen dem Expert Advisor und seiner GUI.

Wenn das Modell beschrieben ist und es ein Protokoll für die Arbeit mit ihm gibt, kann die grafische Benutzeroberfläche beliebig sein und ist nicht von Expert Advisor abhängig. Dies ist eine Art von Übel, wenn Sie ein Feld in den Expert Advisor setzen. Der Hauptzweck von Expert Advisors ist der Handel, alles andere sollte aus dem Hauptcode herausgenommen werden und optional sein.

Ich denke, wir sollten davon ausgehen, dass die Entwickler anfangs nicht daran gedacht haben, dass Schnittstellenfunktionen benötigt werden könnten. Wenn Sie sich erinnern, gab es in den frühen Tagen nicht einmal OOP in mql, sein Hauptzweck war nur, Indikatoren zu schreiben, und alles war dafür ausgelegt.

Und jetzt sehen wir, dass mql bereits mit Sockets und Datenbanken gearbeitet hat, sogar auf der Core-Ebene... Aber die Mechanismen der Interaktion zwischen dem Benutzer und dem Programm werden beiseite gelassen.

Die Entwickler selbst haben vor fast zehn Jahren erklärt, dass die Entwicklung von Schnittstellen ist ein sehr wichtiger Mechanismus der Interaktion zwischen dem Benutzer und der Anwendung und haben eine Standard-Bibliothek für diesen Fall entwickelt, aber nur seine Anwendbarkeit auf die Aufgaben nicht gezeigt haben und in der Tat auch heute noch viele Programmierer sind nicht bewusst, seine Existenz.

Wir werden versuchen, die Lücken zu schließen. Auch wenn die anderen Teilnehmer sie nicht brauchen, werden sie doch eine gewisse Erfahrung sammeln.

 
Alexandr Andreev:

Ich begann mit Ihrer Bibliothek, ich danke Ihnen dafür, dann habe ich es ein bisschen gezwickt, dann einige mehr, dann einige mehr)))) änderte alles einschließlich umgeschrieben Zeile Funktionen, auch breite Zeile Funktion aus Kanvas Quelle, entfernt gefälschte Funktionen, setzen Stub auf Ereignis. noch nicht ganz weg von W-Struktur, obwohl es nicht mehr viel zu. Ich habe die Berechnung der Balken auf der linken und rechten Seite durch binäre Suche unter anderen Elementen und auch hinzugefügt binäre Suche selbst mit der Fähigkeit, größer oder kleiner Wert wählen. Auch hinzugefügt Fähigkeit, von Arrays jeglicher Art (Zeitreihen/gemeinsam) erstellen und kam zu dem Schluss, dass ich ändern sollte construct))))))

Cool.

Ja, die Bibliotheken sollten entweder universell für unerfahrene Programmierer oder eng fokussiert für Fortgeschrittene sein.

Ich selbst habe mehrere Versionen meines eigenen iCanvas für unterschiedliche Zwecke.

Deshalb habe ich begonnen, eine Liste von Absichten und Zielen zu formulieren oder zumindest die Richtung anzugeben. Und setzen Sie diese Liste in den ersten Beitrag, solange sie zur Bearbeitung verfügbar ist.

  
//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(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 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);} 
   #undef  ME
   #undef  TD1
   #undef  TD2
   #undef  GET 
   #undef  SET
   };
   
class CSizeD : public CCoordBaseD
   {
   public:
   CSizeD(){};
   };
   
class CCoordD : public CCoordBaseD
   {
   public:
   CCoordD(){};
   };

class CTX {public:CTX(){}}; 
class CTY {public:CTY(){}};
class CTZ {public:CTZ(){}};
TEMPL(T)
class CCoordA : public T
   {
   public:
   CCoordA() {};
   CSizeD size;
   CCoordD ar; 
   void operator <<(CSizeD &a)   {return ;}
   void operator <<(CCoordD &a)  {return ;}
   };
   
class CCoord
   {  
   public: 
   CCoordA<CTX> X;
   CCoordA<CTY> Y; 
   CCoord ()                              {} 
   bool MouseOn(CMouse &mouse)//px
      {
      //return X.ar.Result()<=mouse.X && X.ar.Result()+X.size.Result()>=mouse.X && GetY()<=mouse.Y && GetY()+GetH()>=mouse.Y;
      return false;
      }
   };  
 

Wie auch immer, entweder mache ich etwas falsch oder die Klassendeklaration (leer) Vorlagen wollen nicht funktionieren. Das macht den Code nicht besonders praktisch.

Ich denke darüber nach, die

 
So ein schöner Code wäre eine gute Idee, ihn zu einer Ausstellung mitzunehmen. Wozu es dient, wie und was es löst, ist unbekannt, aber es ist sehr schön...
 
Leute, da ihr mich gelehrt habt, lasst mich euch lehren.

Sie sollten in erster Linie verstehen, wie GUI-Mechanismen funktionieren, und dann anfangen, Code zu schreiben. Sie sollten die Struktur und das Verhalten der Elemente sowie ihre Reaktionen in verschiedenen Situationen kennen. Stellen Sie sie zunächst als Vorlagen dar, und erstellen Sie dann Instanzen auf einer vorbereiteten technischen Basis, einschließlich Ereignismodell, Zustandsbehandler, Phänomene, Koordinaten, Bindungen und Zeichnungen. Am Ende haben Sie eine rohe Grafikbibliothek auf der Leinwand. Von einer Auszeichnungssprache wird sie weit entfernt sein. Ganz zu schweigen von einem Redakteur. Aber, nur zu.

Wenn Sie glauben, dass Sie einfach etwas Vorgefertigtes nehmen und es auf ein höheres Niveau heben können, dann haben Sie nie etwas Ernsthaftes entwickelt.
 
Реter Konow:
Leute, da ihr mich gelehrt habt, lasst mich euch lehren.

Sie sollten in erster Linie verstehen, wie GUI-Mechanismen funktionieren, und dann anfangen, Code zu schreiben. Sie sollten die Struktur und das Verhalten der Elemente sowie ihre Reaktionen in verschiedenen Situationen kennen. Stellen Sie sie zunächst als Vorlagen dar, und erstellen Sie dann Instanzen auf einer vorbereiteten technischen Basis, einschließlich Ereignismodell, Zustandsbehandler, Phänomene, Koordinaten, Bindungen und Zeichnungen. Am Ende haben Sie eine rohe Grafikbibliothek auf der Leinwand. Von einer Auszeichnungssprache wird sie weit entfernt sein. Ganz zu schweigen von einem Redakteur. Aber, nur zu.

Wenn Sie glauben, dass Sie einfach etwas Vorgefertigtes nehmen und es aufpeppen können, dann haben Sie noch nie etwas Ernsthaftes entwickelt.

Warten Sie mit dem Urteil - es ist nicht einmal mehr als die Grundlagen. Und die Tatsache, dass ich die GUI fertigstellen werde, ist unwahrscheinlich - das habe ich ja schon am Anfang gesagt. Wie für große Projekte - ich sage so in Ihrem Code Zeilen sind nicht genug, um mit großen Projekten konkurrieren.....


Die Frage ist nun, warum der Trick nicht funktioniert.

class CB; 
class CC;

class CBx{public: CBx(){};};
class CBy{public: CBy(){};};
TEMPL(T) 
class CA : public T
   {
   public:
   CA(){}
   CB<T> *b;
   CC<T> *c;
   };
    
TEMPL(T) 
class CB : public CA<T>
   {
   public:
   CB(){}
   };
    
TEMPL(T) 
class CC : public CA<T>
   {
   public:
   CC(){}
   }; 

CB<CBy> cc;
 
Alexandr Andreev:

...

Die Frage ist nun, warum dieser Trick nicht funktioniert.

Wer weiß, warum es nicht funktioniert...

Zuerst sollte das Bibliotheksschema erstellt werden, und dann sollten die Codes geschrieben werden. So wird es normalerweise gemacht.
12345678910...15
Neuer Kommentar