Vani scompartimento non visualizzati nel diagramma DSL

Question

OK, quindi le cose sono progredite significativamente con il mio DSL da quando ho chiesto a questa domanda qualche giorno fa.

Non appena ho riformattato il mio codice, posterò la mia risposta a quello, ma per ora, sto riscontrando un altro problema.

Sto generando dinamicamente sotto-diagrammi da un modello creato da DSL, salvando quei diagrammi come immagini e quindi generando un documento di Word con quelle immagini incorporate. Fin qui tutto bene.

Ma dove le mie forme hanno scomparti (per esempio, Operazioni su un contratto di servizio - puoi ancora indovinare di cosa si tratta?), viene visualizzata l'intestazione del compartimento ma nessuno degli elementi .

Se esamino il mio oggetto forma, ha un singolo figlio nidificato - un ElementListCompartment che a sua volta ha un numero di elementi che mi aspetto di essere visualizzati. La proprietà ElementListCompartment.IsExpanded è impostata su true (e l'intestazione del compartimento ha una piccola icona "comprimi") ma dove, oh dove sono i miei oggetti?

La forma è stata aggiunta al diagramma usando

parentShape.FixupChildShapes(modelElement);

Quindi, qualcuno può guidarmi sulla mia strada allegra?

Answer 1

Di recente ho riscontrato un problema correlato e sono riuscito a farlo funzionare, quindi ecco la storia.

L'attività che stavo implementando era caricare e visualizzare un modello di dominio e un diagramma associato generato dal pacchetto DSL di ActiveWriter.

Ecco come ho implementato la funzionalità richiesta (tutti i metodi seguenti appartengono alla classe Form1 che ho creato per giocare):

private Store LoadStore()
{
    var store = new Store();
    store.LoadDomainModels(typeof(CoreDesignSurfaceDomainModel), typeof(ActiveWriterDomainModel));
    return store;
}

private void LoadDiagram(Store store)
{
    using (var tx = store.TransactionManager.BeginTransaction("tx", true))
    {
        var validator = new ValidationController();
        var deserializer = ActiveWriterSerializationHelper.Instance;
        deserializer.LoadModelAndDiagram(store,
            @"..\..\ActiveWriter1.actiw", @"..\..\ActiveWriter1.actiw.diagram", null, validator);
        tx.Commit();
    }
}

private DiagramView CreateDiagramView()
{
    var store = LoadStore();
    LoadDiagram(store);

    using (var tx = store.TransactionManager.BeginTransaction("tx2", true))
    {
        var dir = store.DefaultPartition.ElementDirectory;
        var diag = dir.FindElements<ActiveRecordMapping>().SingleOrDefault();
        var view = new DiagramView(){Diagram = diag};
        diag.Associate(view);
        tx.Commit();

        view.Dock = DockStyle.Fill;
        return view;
    }
}

protected override void OnLoad(EventArgs e)
{
    var view = CreateDiagramView();
    this.Controls.Add(view);
}

Questa roba ha funzionato principalmente con precisione: ha caricato correttamente il diagramma dai file creati con Visual Studio, ha disegnato il diagramma all'interno del mio modulo personalizzato di Windows, ha supportato lo scorrimento della tela e mi ha persino permesso di trascinare forme qui. Tuttavia, una cosa mi infastidiva: gli scomparti erano vuoti e avevano un nome predefinito, vale a dire "scompartimento".

Google non ha aiutato affatto, quindi ho dovuto scavare da solo. Non è stato molto facile, ma con l'aiuto di Reflector e dopo aver trascorso un paio d'ore sono riuscito a far funzionare questo scenario come previsto!

Il problema era il seguente. Con mia sorpresa, le librerie DSL non disegnano correttamente determinati elementi del diagramma immediatamente dopo che sono stati aggiunti al diagramma. A volte, vengono disegnati solo tronchi di determinate forme (come mostrato nella prima immagine). Pertanto, a volte è necessario chiedere manualmente alla libreria di ridisegnare le forme del diagramma.

Questa funzionalità può essere implementata con le cosiddette " regole " che in realtà sono gestori di eventi che vengono attivati ??da determinati eventi del diagramma. Fondamentalmente, ciò che dobbiamo fare è collegare un determinato gestore a un evento del diagramma con aggiunta di elementi e garantire l'inizializzazione della forma.

Fortunatamente non abbiamo nemmeno bisogno di scrivere alcun codice poiché DSL Designer genera automaticamente sia le regole di correzione che un metodo di utilità che allega quelle regole al diagramma (vedi le EnableDiagramRules di seguito). Tutto quello che dobbiamo fare è chiamare questo metodo subito dopo la creazione del negozio (prima di caricare il modello e il diagramma).

private Store LoadStore()
{
    var store = new Store();
    store.LoadDomainModels(typeof(CoreDesignSurfaceDomainModel), typeof(ActiveWriterDomainModel));
    ActiveWriterDomainModel.EnableDiagramRules(store);
    return store;
}

/// <summary>
/// Enables rules in this domain model related to diagram fixup for the given store.
/// If diagram data will be loaded into the store, this method should be called first to ensure
/// that the diagram behaves properly.
/// </summary>
public static void EnableDiagramRules(DslModeling::Store store)
{
    if(store == null) throw new global::System.ArgumentNullException("store");

    DslModeling::RuleManager ruleManager = store.RuleManager;
    ruleManager.EnableRule(typeof(global::Altinoren.ActiveWriter.FixUpDiagram));
    ruleManager.EnableRule(typeof(global::Altinoren.ActiveWriter.ConnectorRolePlayerChanged));
    ruleManager.EnableRule(typeof(global::Altinoren.ActiveWriter.CompartmentItemAddRule));
    ruleManager.EnableRule(typeof(global::Altinoren.ActiveWriter.CompartmentItemDeleteRule));
    ruleManager.EnableRule(typeof(global::Altinoren.ActiveWriter.CompartmentItemRolePlayerChangeRule));
    ruleManager.EnableRule(typeof(global::Altinoren.ActiveWriter.CompartmentItemRolePlayerPositionChangeRule));
    ruleManager.EnableRule(typeof(global::Altinoren.ActiveWriter.CompartmentItemChangeRule));
}

Il codice sopra funziona come segue:

1. Dopo l'aggiunta di un nuovo elemento al diagramma (ad es. durante la deserializzazione del diagramma) la regola "FixUpDiagram" viene attivato.

2. La regola chiama quindi Diagram.FixUpDiagram (parentElement, childElement) , dove childElement indica un elemento che viene aggiunto e parentElement sta per il suo genitore logico (determinato usando una logica condizionale complicata, quindi non ho provato a riprodurlo da solo).

3. Giù per la traccia dello stack Il metodo FixUpDiagram chiama i metodi GuaranteCompartments di tutte le forme di classe nel diagramma.

4. Il metodo GuaranteCompartments ridisegna i compartimenti della classe trasformando lo stub "[-] Compartimento " grafico in "Proprietà" in piena regola. forma come mostrato nell'immagine collegata sopra.

P.S. Steve, ho notato che hai chiamato il fixup ma non ha ancora funzionato. Bene, non sono un professionista in DSL SDK (ho appena iniziato a usarlo un paio di giorni fa), quindi non posso spiegare perché potresti avere problemi.

Forse hai chiamato il fixup con argomenti sbagliati. O forse Diagram.FixupDiagram (parent, newChild) fa qualcosa di diverso rispetto a parent.FixupChildShapes (newChild). Tuttavia, ecco la mia variante che funziona. Spero che questo aiuti anche.

Answer 2

Forse la mia risposta è un po 'troppo tardi, ma hai confermato utilizzando DSL Explorer che i tuoi scomparti hanno degli elementi?