HQEd callbacks

Wymagania

W ramach projektu należy stworzyć edytor callback-ów w edytorze HQEd.
Oto lista rzeczy, wymagań które należy uwzględnić podczas implementacji.

  • Rozmieszczenie callbacków w plikach:
    • W HQEd-zie powinna być zdefiniowana nazwa pliku będącego biblioteką callback-ów.
      • Format pliku bazuje na składni XML-owej.
      • Dbamy o to aby był to poprawnie uformowany XML.
      • Panowie proponujecie jakiś format opisu, który powinien zawierać min.:
        • identyfikator callback-a
        • nazwę callback-a
        • typ callback-a (input, output)
        • rodzaj atrybutu (simple, generalizaed)
        • Definicję callback-a
    • W plikach modelu (HML) umieszczamy tylko te definicje callback-ów, które są wykorzystane w danym modelu.
      • W tagach definiujących atrybuty, dodajemy atrybut o nazwie np. clb, którego wartość określa id callback-a.
      • Treść callback-a jest zapisywana w elemencie będącym bezpośrednim potomkiem elementu <hml>.
  • Należy stworzyć osobny pojemnik, w którym będą przechowywane definicje wszystkich callbacków.
    • Klasa pojemnika powinna mieć nazwę rozpoczynającą się od h np. hCallbackContainer.
    • Powinna dostarczać odpowiedniego interfejsu (zestawu metod) do:
      • Dodawania,
      • Usuwania,
      • Wyszukiwania callbacków na podstawie ich id.
    • Klasa powinna posiadać metodę toProlog, która będzie tworzyła definicję callback-ów w formacie zgodnym z HMR.
  • Należy stworzyć osobne okno edytora, który będzie umożliwiał:
    • Podświetlania składni.
    • Wyświetlanie podpowiedzi podczas pisania.
    • Definiowanie właściwości callback-a: nazwa, typ, rodzaj dziedziny.
  • W oknie definiowania atrybutu należy:
    • Stworzyć pole wyboru odpowiedniego callback-a (lista callback-ów pasujących do aktualnie edytowanego atrybutu).
    • Stworzyć przycisk umożliwiający dodanie nowej definicji poprzez otwarcie edytora.
  • Wczytywanie modelu i biblioteki callback-ów:
    • Klasa pojemnika callback-ów powinna posiadać metodę wczytywania danych z formatu XML (proszę używać standardowych klas Qt).
    • Należy obsłużyć sytuację dublujących się identyfikatorów: ustalić które mają większy priorytet czy te z pliku HML (proponuję to rozwiązanie), czy może te z biblioteki.
    • Należy zmienić definicję klasy XTT_Attribute w której należy dodać pole typu QString przechowujące identyfikator callback-a związanego z danym atrybutem.
  • Zapisywanie, export modelu.
    • Klasa pojemnika callback-ów powinna posiadać metodę zapisywania danych w formatcie XML (proszę używać standardowych klas Qt).
    • Należy zmienić metodę tworzącą plik HMR (toProlog) w klasie XTT_Attribute tak aby w przypadku powiązania atrybutu z jakimś callback-iem dodawała odpowiednią informację.
    • Należy w pliku xs_xtt.cpp w funkcji generateProlog() dodać instrukcję wywołującą generowanie HMR dla biblioteki callback-ów.

Uwagi 24.06.2011

Projekt

  • Nazwy metod powinny rozpoczynać się małą literą - XTT_CallbackContainer.
  • Komentarze w postaci linii rozdzielających - plik nagłówkowy.
  • Stworzyć analogiczne komentarze nagłówkowe plików.
  • Usunąć elementy GUI z metody XTT_CallbackContainer::in_XML:
    QFile file(libFile);
    if (!file.open(QFile::WriteOnly | QFile::Text))
    {
         QMessageBox::warning(MainWin, QObject::tr("HQEd"),
              QObject::tr("Can not open Callback Library file:\n%1.")
              .arg(file.errorString()));
    }
    QXmlStreamWriter xmlWriter(&file);
    allToXML(&xmlWriter);
  • Usunąć elementy GUI z metody void XTT_CallbackContainer::loadFormLibrary():
    QFile file(libFile);
    if (!file.open(QFile::ReadOnly | QFile::Text))
    {
         QMessageBox::warning(MainWin, QObject::tr("HQEd"),
              QObject::tr("Cannot read Callback Library file:\n%1.")
              .arg(file.errorString()));
    }
    QTextStream in(&file);
     
    #ifndef QT_NO_CURSOR
         QApplication::setOverrideCursor(Qt::WaitCursor);
    #endif
         QString temp = in.readAll();
    #ifndef QT_NO_CURSOR
         QApplication::restoreOverrideCursor();
    #endif
    else if (xml.hasError())
         QMessageBox::about(MainWin, QObject::tr("Error!"),QObject::tr("This is not a valid XML file."));
  • Metoda XTT_CallbackContainer::in_XML powinna coś zwracać, jako opis błędu wykorzystać
  • QString &__msg
  • Brak destruktora klasy: XTT_CallbackContainer
  • Nierozwiązane konflikty identyfikatorów: zmiana ID callback-a nie powoduje zmiany ID callback-a w atrybucie.
  • Podczas wczytywania atrybutów nie jest weryfikowane istnienie callback-a o podanym ID.
  • Nieuzupełniona funkcja
    vas_out_HML_2_0(QIODevice* __device, bool __formating, int __parts)

    w części

    #if QT_VERSION < 0x040300
    ...
    #endif
  • Należy bezwzględnie uwzględnić flagi części plików:
    //if((__parts & VAS_XML_MODEL_PARTS_XTT_CLBS) != 0)
        CallbackContainer->usedToXML(outxml);
  • Tworzenie obiektu kontenera:
    • Oddzielić od kodu tworzenia okien
    • Wczytywanie biblioteki: w konstruktorze MainWindow
  • Poprawić layout okna managera callback-ów
  • Umożliwić zmianę rozmiaru okna.
  • Zlikwidować przycisk minimalizacji okna.
  • Okno managera powinno być modalne.
  • W managerze atrybutów dodać kolumnę informująca o przypisanym callback-u.
  • Plik biblioteki powinien być umieszczony w folderze conf. Do pobrania ścieżki do folderu konfiguracyjnego użyć metody
    QString Settings_ui::configurationPath(void)
  • AttributeEditor: niedziałający filtr callback-ów - nie pojawia się żadna opcja do wyboru.

Uwagi 04.07.2011

  • Poprawić layout okna managera callback-ów:
    • Kontrolki typu QRadioButton, QCheckBox nie zmieniają położenia wraz ze zmiana rozmiaru okna.
    • Label Definition: wiersz nie powinien zmieniać wysokości.
  • Poprawić layout okna managera atrybutów:
    • Po wybraniu atrybutu do którego nie ma przypisanego callback-a tuż po tym jak był wybrany atrybut z callback-iem, rozmiar pola callback information nie zmniejsza się i pozostaje zbędnie powiększony.
  • Zapis do HML:
    • :!: Brak elementu zamykającego tag <callbacks>
    • nie dodajemy argumentu clb do elementu attr jeżeli do danego atrybutu nie ma przypisanego callback-a.
    • :!: void XTT_CallbackContainer::allToXML(QXmlStreamWriter* xmlWriter)
      Koniecznie należy usunąć:
      • xmlWriter->writeEndDocument();
      • xmlWriter->writeStartDocument();
      • to jest pobierane z opcji:
        xmlWriter->setAutoFormatting(true);
  • Wczytywanie HML:
    • Prosta walidacja danych:
      • Czy dane ID już nie istnieje itp.
      • Obsługa błędów generowanych przez XTT_CallbackContainer::in_XML w pliku vasXML w funkcji vas_in_HML_2_0.
  • Generowanie HMR:
    • Brak przypisania callback-a do atrybutu.
  • Usunąć elementy GUI z metody void XTT_CallbackContainer::loadFormLibrary():
    #ifndef QT_NO_CURSOR
         QApplication::setOverrideCursor(Qt::WaitCursor);
    #endif
         QString temp = in.readAll();
    #ifndef QT_NO_CURSOR
         QApplication::restoreOverrideCursor();
    #endif

Uwagi 05.07.2011 - future work

  • Wczytywanie HML:
    • Prosta walidacja danych:
      • Czy dane ID już nie istnieje itp.
      • Niewłaściwa obsługa komunikatów w XTT_CallbackContainer::in_XML:
        __msg += "\nCan not open the Library File.";

        vs.

        __msg += "\n" + hqed::createErrorString("", "", "Undefined state id. The state will not be read." + hqed::createDOMlocalization(DOMstate), 0, 1);
  • Poprawić layout okna managera callback-ów:
    • Kontrolki typu QRadioButton, QCheckBox nie zmieniają położenia wraz ze zmiana rozmiaru okna.
    • Label Definition: wiersz nie powinien zmieniać wysokości.
  • Poprawić layout okna managera atrybutów:
    • Po wybraniu atrybutu do którego nie ma przypisanego callback-a tuż po tym jak był wybrany atrybut z callback-iem, rozmiar pola callback information nie zmniejsza się i pozostaje zbędnie powiększony.
  • Dodać przycisk managera callback-ów w menu w głównym oknie.

Raport

1 Cel projektu

Celem projektu była implementacja edytora callback-ów w narzędziu HQEd. Edytor miał zostać zaimplementowany w języku C++ przy pomocy biblioteki Qt4. Lista wymagań które należało uwzględnić podczas implementacji:

  • Rozmieszczenie callback-ów w plikach:
    • W HQEd powinna być zdefiniowana nazwa pliku będącego biblioteką callback-ów.
    • Format pliku bazuje na składni XML-owej.
    • Tam gdzie to konieczne należy używać bloków <![CDATA[ … ]]>
    • Format opisu callback-a powinien zawierać.:
      • identyfikator callback-a
      • nazwę callback-a
      • typ callback-a (input, output)
      • rodzaj atrybutu (simple, generalizaed)
      • definicję callback-a
    • W plikach modelu (HML) należy umieszczać te definicje callback-ów, które są wykorzystane w danym modelu.
      • W tagach definiujących atrybuty, należy dodać atrybut o nazwie np. clb, którego wartość określa id callback-a.
      • Treść callback-a powinna być zapisywana w elemencie będącym bezpośrednim potomkiem elementu <hml>.
    • Należy stworzyć osobną klasę pojemnika, w którym będą przechowywane definicje wszystkich callback-ów.
      • Klasa powinna dostarczać odpowiedniego interfejsu (zestawu metod) do:
        • Dodawania,
        • Usuwania,
        • Wyszukiwania callback-ów na podstawie ich id.
      • Klasa powinna posiadać metodę toProlog, która będzie tworzyła definicję callback-ów w formacie zgodnym z HMR.
    • Należy stworzyć osobne okno edytora, który będzie umożliwiał:
      • Podświetlania składni.
      • Definiowanie właściwości callback-a: nazwa, typ, rodzaj dziedziny.
    • W oknie definiowania atrybutu należy:
      • Stworzyć pole wyboru odpowiedniego callback-a (lista callback-ów pasujących do aktualnie edytowanego atrybutu).
      • Stworzyć przycisk umożliwiający dodanie nowej definicji poprzez otwarcie edytora.
    • Wczytywanie modelu i biblioteki callback-ów:
      • Klasa pojemnika callback-ów powinna posiadać metodę wczytywania danych z formatu XML (proszę używać standardowych klas Qt).
      • Należy obsłużyć sytuację dublujących się identyfikatorów: ustalić które mają większy priorytet czy te z pliku HML (proponuję to rozwiązanie), czy może te z biblioteki.
      • Należy zmienić definicję klasy XTT_Attribute w której należy dodać pole typu QString przechowujące identyfikator callback-a związanego z danym atrybutem.
    • Zapisywanie, export modelu.
      • Klasa pojemnika callback-ów powinna posiadać metodę zapisywania danych w formatcie XML (należy używać standardowych klas Qt).
      • Należy zmienić metodę tworzącą plik HMR (toProlog) w klasie XTT_Attribute tak aby w przypadku powiązania atrybutu z jakimś callback-iem dodawała odpowiednią informację.
      • Należy w pliku xs_xtt.cpp w funkcji generateProlog() dodać instrukcję wywołującą generowanie HMR dla biblioteki callback-ów.

2 Co zostało wykonane

  • Stworzono klasę XTT_Callback przechowującą dane o callbacku – id, nazwę, typ, rodzaj dziedziny, definicję.
  • Stworzono bibliotekę Callbacków umieszczoną w zdefiniowany w programie pliku. Format zapisu callbacków w bibliotece bazuje na składni XML-owej. W bibliotece znajdują się definicje znanych callbacków.
  • Format opisu callback-a zawiera:
    • identyfikator callback-a
    • nazwę callback-a
    • typ callback-a (input, output)
    • rodzaj atrybutu (simple, generalizaed)
    • definicję callback-a
  • Stworzono osobny pojemnik, w którym są przechowywane definicje wszystkich callback-ów. Klasa pojemnika posiada nazwę XTT_CallbackContainer. Klasa umożliwia:
    • dodawanie callback-ów
    • usuwanie
    • edycję
    • wyszukiwanie callback-ów po ich ID
    • eksport callback-ów do biblioteki
    • eksport definicji callback-ów w języku Prolog
  • Okno menadżera callback-ów umożliwiające zarządzaniem zbiorem callback-ów, posiadające podświetlanie składni, możliwość definiwania własności callback-a: typ, nazwa, rodzaj dziedziny.
  • Wczytywanie modelu i biblioteki callback-ów
    • Klasa pojemnika callback-ów posiada metodę wczytywania danych z pliku modelu z formatu XML
    • Do pliku modelu zapisywane są definicje wszystkich używanych callbacków w formacie XML.

3 Dodane pliki

3.1 XTT_Callback

  • klasa XTT_Callback – obiekt tej klasy przechowuje pojedynczy callback.
    • zmienne:
      • bool libsave – określa czy callback ma być zapisany do biblioteki callback-ów.
      • bool used – określa, czy callback jest używany w modelu – zmienna jest używana przy zapisywaniu pliku modelu i w zależności od jej wartości callback jest zapisywany w tym pliku bądź nie.
      • QString ID – zmienna przechowuje identyfikator callback-a.
      • QString name – zmienna przechowuje nazwe callback-a.
      • QString type – przechowuje typ callback-a (in/out/inout).
      • QString att – rodzaj dziedziny callback-a (simple/general).
      • QString def – definicja callback-a w języku prolog.
    • Funkcje
      • void setID(QString newID) – funkcja ustawia nowy identyfikator dla callback-a. Parametr: nowy identyfikator.
      • void setName(QString newName) – ustawia nową nazwę dla callback-a. Parametr: nowa nazwa.
      • void setType(QString newType) – ustawia nowy typ callback-a. Parametr: nowy typ.
      • void setAtt(QString newAtt) – ustawia nową dziedzinę atrybutów. Parametr: dziedzina atrybutów.
      • void setDef(QString newDef) – ustawia nową definicje callback-a. Parametr: nowa definicja.
      • void setSave(bool save) – ustawia zmienną savelib, informującą czy callback ma być zapisany do biblioteki. Parametr: nowa wartość zmiennej libsave.
      • void setUsage(bool clbu) – ustawia wartość zmiennej, informującej o tym, czy callback jest używany w modelu. Parametr: nowa wartość zmiennej usage.
      • void toXML(QXmlStreamWriter* xmlWriter) – funkcja zapisująca callback do pliku w formacie XML. Parametr: wskaźnik do obiektu QXmlStreamWriter, który posłuży do zapisania treści callback-a.
      • QString getID() – funkcja zwraca identyfikator callback-a.
      • QString getName() – funkcja zwraca nazwę callback-a.
      • QString getType() – funkcja zwraca typ callback-a.
      • QString getAtt() – funkcja zwraca dziedzinę atrybutów callback-a.
      • QString getDef() – funkcja zwraca definicje callback-a.
      • QString toProlog() – funkcja zwraca definicję callback-a w jezyku Prolog.
      • bool getSave() – funkcja zwraca wartość zmiennej libsave.
      • bool getUsage()– funkcja zwraca wartość zmiennej usage.
      • QString callbackInfo(bool _html) – funkcja zwraca informacje o callback-u. Parametr zmienna typu bool, informująca czy w informacji zwrotnej maja znajdować się tagi HTML.


Zapis treści callback-a do pliku w formacie XML przy pomocy obiektu QXmlStreamWriter:

void XTT_Callback::toXML(QXmlStreamWriter* xmlWriter)
{
     xmlWriter->writeStartElement("clb");
     xmlWriter->writeTextElement("id", getID());
     xmlWriter->writeTextElement("name", getName());
     xmlWriter->writeTextElement("type", getType());
     xmlWriter->writeTextElement("att", getAtt());
     xmlWriter->writeStartElement("def");
     xmlWriter->writeCDATA(getDef());
     xmlWriter->writeEndElement();
     xmlWriter->writeEndElement();
}

3.2 XTT_CallbackContainer

  • Klasa XTT_CallbackContainer – klasa jest pojemnikiem dla callback-ów: wczytanych z pliku biblioteki i pliku wczytanego modelu, dostarcza prostego interfejsu pozwalającego m.in. na dodawanie, edycję, usuwanie i zapisywanie callback-ów.
    • Zmienne
      • QString libFile – zmienna przechowująca nazwę pliku, będącego biblioteką callbacków (clblib.xml).
      • QString idprefix – przedrostek identyfikatorów callbacków (clb_), wykorzystywany do generowania nowych identyfikatorów.
      • QList<XTT_Callback> *clbcks – obiekt typu QList, przechowujący obiekty typu XTT_callback.
      • extern XTT_CallbackContainer *CallbackContainer – wskaźnik do obiektu XTT_CallbackContainer, dostępny we wszystkich plikach, w których dołączony jest plik XTT_CallbackContainer.h
    • Funkcje
      • void add(XTT_Callback clb) – funkcja dodaje nowy callback do kontenera. Parametr: nowy callback – obiekt typu XTT_callback.
      • void del(int IDNo) – funkcja usuwa callback z kontenera o podanym indeksie. Parametr: indeks callback-a do usunięcia.
      • bool exist(QString eID) – funkcja zwraca wartość typu bool informującą czy w kontenerze istnieje callback o podanym identyfikatorze. Parametr: szukany identyfikator.
      • int size() – funkcja zwraca liczę callbacków w kontenerze.
      • void clear() – funkcja usuwa wszystkie callbacki z kontenera.
      • bool libsave(int i) – funkcja informuje, czy callback o podanym identyfikatorze będzie zapisany do biblioteki. Parametr: identyfikator callback-a.
      • void setUsed(QString id, bool use) – funkcja ustawia wartość zmiennej used dla callback-a o podanym identyfikatorze. Parametry: identyfikator callback-a, nowa wartość zmiennej used.
      • void allToXML(QXmlStreamWriter* xmlWriter) – funkcja zapisuje wszystkie callback-i, których zmienna libsave ma wartość true do biblioteki callback-ów w formacie XML. Parametr: wskaźnik do obiektu QXmlStreamWriter, który posłuży do zapisania treści callbacków.
      • QString getPrologName(int index) – funkcja zwraca nazwę callback-a zawartą w jego definicji w języku Prolog. Nazwa ta wykorzystywana jest przy generacji kodu HMR do skojarzenia callback z zawierającym go atrybutem. Parametr: identyfikator callback-a.
      • XTT_Callback* get(int i) – funkcja zwraca adres do obiektu typu XTT_Callback zapisanego w kontenerze pod podanym indeksem. Parametry: Indeks callback-a.
      • int getByID(QString IDsearch) – funkcja zwraca indeks pod którym zapisano w kontenerze callback o podanym identyfikatorze. Parametr: identyfikator callback-a.
      • QString generateID() – funkcja generuje nowy identyfikator callback-a.
      • QString toProlog() – funkcja zwraca definicje wszystkich używanych w modelu callback-ów w języku Prolog.
      • void usedToXML(QXmlStreamWriter* xmlWriter) – zapisuje wszystkie używane w modelu callbacki w formacie XML. Funkcja wykorzystywana jest do zapisywania treści callbacków do plików modelu, w których są używane. Parametr: wskaźnik do obiektu QXmlStreamWriter, który posłuży do zapisania treści callbacków.
      • int in_XML(QDomElement& _root, QString& _msg) – funkcja odczytuje treści callback-ów z format XML i zapisuje. Wykorzystywana jest do odczytywania callback-ów z otwieranych w programie plików z modelami, w których znajdują się definicje używanych callback-ów. W przypadku, gdy w kontenerze istnieje już callback o danym ID, zmieniane jest ID callback-a w kontenerze, a callback wczytywany jest z pliku z niezmienny ID. Parametry: adres do obiektu QDomElement, z którego będą odczytywane treści callback-ów, adres do zmiennej przechowującej informacje o błędach odczytu. Funkcja zwraca kod błędu:
        • 0 – brak błędu
        • -1 – błąd zapisu callback-ów do biblioteki – nie można otworzyć pliku.
        • -2 – brak callback-ów w pliku modelu.
      • int loadFormLibrary() – funkcja wczytuje do kontenera treści callback-ów zapisanych w bibliotece. Funkcja zwraca kod błędu:
        • 0 – brak błędu
        • -1 – nie można otworzyć pliku biblioteki.
        • -2 – niepoprawny format pliku biblioteki.

Odczyt treści callback-ów przy użyciu obiektu QDomElement:

int XTT_CallbackContainer::in_XML(QDomElement &_root, QString &__msg)
{
     QString elementName = "callbacks";
     QDomElement DOMclbs = __root.firstChildElement(elementName);
     if(DOMclbs.isNull())
     {
         __msg += "\nNo callbacks to read.";
          return -2;
     }
     XTT_Callback *newclb;
     QDomElement DOMclb = DOMclbs.firstChildElement("clb");
     while(!DOMclb.isNull())
     {
          newclb = new XTT_Callback;
          QString cid = DOMclb.firstChildElement("id").text();
          newclb->setID(cid);
          QString cname = DOMclb.firstChildElement("name").text();
          newclb->setName(cname);
          QString ctype = DOMclb.firstChildElement("type").text();
          newclb->setType(ctype);
          QString catt = DOMclb.firstChildElement("att").text();
          newclb->setAtt(catt);
          QString cdef = DOMclb.firstChildElement("def").text();
          newclb->setDef(cdef);
          if(!exist(cid))
          {
               add(*newclb);
          }
          else
          {
               int index = getByID(cid);
               QString name = get(index)->getName();
               if(cname == name)
               {
                    del(index);
                    newclb->setSave(true);
                    add(*newclb);
               }
               else
               {
                    newclb->setID(generateID());
                    add(*newclb);
               }
          }
          DOMclb = DOMclb.nextSiblingElement("clb");
     }
     QFile file(libFile);
     if (!file.open(QFile::WriteOnly | QFile::Text))
     {
         __msg += "\nCan not open the Library File.";
         return -1;
     }
     QXmlStreamWriter xmlWriter(&file);
     allToXML(&xmlWriter);
     file.close();
     return 0;
}

3.3 Callback Manager

  • Klasa CallbackManager – okno służące do zarządzania callback-ami. Wyświetla atrybuty i treść callback-ów znajdujących się w kontenerze, ich tworzenie, edytowanie i usuwanie. Dostarcza narzędzia podświetlania składni języka Prolog w oknie wprowadzania definicji callback-a.

Rys.1. Okno managera callback-ów

  • Zmienne:
    • HSyntaxHighlighter *highlighter – wskaźnik do obiektu HSyntaxHighlighter wykorzystywany do podświetlania składni języka Prolog.
    • QString MODE – zmienna przechowująca aktualny tryb pracy (NORMAL, EDIT, NEW).
    • QString libFile – nazwa pliku biblioteki callback-ów.
    • bool changed – informuje o zmianie danych dowolnego callback-a w kontenerze.
  • Funkcje:
    • void layoutForm() – funkcja wczytuje wydgety i układa je w oknie, wyrównując do siatki.
    • void loadCombo() – wczytuje identyfikatory wszystkich callback-ów zapisanych w kontenerze do Combo Boxa.
    • void ChangeContent(QString id) – wczytuje i wyświetla dane callback-a o podanym identyfikatorze.
    • void NewCallback() – funkcja czyści pola z danymi i umożliwia wprowadzenie nowych wartości dla nowego callback-a. Identyfikator nowego callback-a jest automatycznie generowany.
    • void ApplyChanges() – funkcja zapisuje dane callback-a wprowadzone w oknie do kontenera. W zależności od trybu pracy działanie funkcji jest różne.
    • void Save() – funkcja zapisuje dane callback-a do kontenera.
    • void SaveToLibrary() – funkcja zapisuje callback-i do biblioteki, korzystając z funkcji allToXML(QXmlStreamWriter* xmlWriter) z obiektu XTT_CallbackContainer.
  • Sloty:
    • void ComboChanged(QString id) – uruchamiany po otrzymaniu sygnału z ComboBox o zmianie aktualnego identyfikatora. Parametr: nowy identyfikator callback-a zmieniony w ComboBox.
    • void ApplyClicked() – uruchamiany po naciśnięciu przycisku Apply wywołuje funkcję ApplyChanges().
    • void okClicked() – uruchamiany po naciśnięciu przycisku OK. Wywołuje funkcję. W zależności od trybu pracy (NEW, NORMAL) odpowiednio zapisuje zmiany edycyjne callbacka, bądź zamyka okno i wybiera callback o identyfikatorze wybranym w ComboBox
    • void NewClicked() – uruchamiany po naciśnięciu przycisku New, wywołuje funkcję NewCallback().
    • void cancelClick() – uruchamiany po naciśnięciu przycisku Cancel w zależności od trybu pracy (NORMAL, NEW/EDIT) odpowiednio zamyka okno, bądź anuluje tworzenie/edycję callback-a.
    • void deleteClick() – uruchamiany po naciśnięciu przycisku Delete. Usuwa wybrany callback.
    • void editClick()– uruchamiany po naciśnięciu przycisku Edit. Umożliwia edycję wybranego callback-a, zmienia tryb pracy na EDIT.
  • Sygnały
    • okClick(QString) – Emitowany w przypadku zamknięcia okna przyciskiem OK. Parametr: identyfikator wybranego callback-a.
    • cancelClicked() – Emitowany po zamknięciu okna, za pomocą przycisku Cancel.

4 Modyfikowane pliki

4.1 XTT_Attribute

  • Dodane:
    • Zmienne:
      • QString fAttrClbId – identyfikator callback-a przypisanego do atrybutu
    • Funkcje:
      • QString CallbackId(void) – zwraca identyfikator callback-a przypisanego do atrybutu.
      • void setCallbackId(QString _new_clbid) – ustawia identyfikator callback-a przypisanego do atrybutu.
  • Modyfikowane:
    • Funkcje:
      • QStringList* XTT_Attribute::out_HML_2_0(int /*_mode*/) – dodano zapis identyfikatora callback-a.
      • void XTT_Attribute::out_HML_2_0(QXmlStreamWriter* _xmldoc, int /*_mode*/) – j.w.
      • int XTT_Attribute::in_HML_2_0(QDomElement& _root, QString& _msg) – dodano odczyt identyfikatora callback-a.

4.2 AttributeEditor

Dodano grupę Attribute callback umożliwiającą przypisanie callback-a do atrybutu, otworzenie okna managera callback-ów, podgląd definicji callback-a.

Rys.2. Dodana grupa w oknie AttributeEditor.

  • Dodano
    • Zmienne:
      • QString fSelectedClb – przechowuje identyfikator aktualnie wybranego callback-a.
    • Funkcje:
      • void LoadCombo() – wczytuje identyfikatory wszystkich callback-ów do ComboBox.
    • Sloty:
      • void clbManager(void) – wywoływany po naciśnięciu przycisku Callback Manager, wyświetla okno menadżera callback-ów
      • void clbComboChaned(QString clbID) – jest wywoływany po zmianie zawartości ComboBoxa z identyfikatorami callback-ów. Zmienia informacje o wybranym callbacku. Parametr: aktualny identyfikator callback-a.
      • void ClbManagerOk(QString id) – wywoływany po otrzymaniu sygnału OkClicked z okna menadżera callbacków. Odświeża ComboBox z identyfikatorami callback-ów i wybiera callback o identyfikatorze przekazanym w parametrze. Parametr: identyfikator callback-a.
      • void ClbManagerCancel()– wywoływany po otrzymaniu sygnału CancelClicked z okna menadżera callbacków. Odświeża ComboBox z identyfikatorami callback-ów.
      • void selectAttributeCurrentCallback() – wywoływany po zmianie atrybutu, zmienia wybrany callback w ComboBox, na ten używany przez atrybut.
  • Modyfikacje:
    • Funkcje:
      • void AttrEditor::SelectedAttributeChanged(int GroupIndex, int AttrIndex) – dodano wywołanie funkcji selectAttributeCurrentCallback()
      • bool AttrEditor::applyChanges(void) – dodano ustawienie identyfikatora używanego callback-a w atrybucie.

4.3 vasXML

  • Dodano:
    • Flaga: #define VAS_XML_MODEL_PARTS_XTT_CLBS
  • Modyfikowano:
    • int vas_in_HML_2_0(QDomElement& _root, QString& _msg, int _parts) – dodano wczytywanie callback-ów z pliku modelu.
    • int vas_out_HML_2_0(QIODevice* _device, bool _formating, int _parts) – dodano zapis callback-ów w formacie XML do pliku modelu.
pl/dydaktyka/miw/2011/tematy/hqedcbed.txt · ostatnio zmienione: 2017/07/17 08:08 (edycja zewnętrzna)
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0