Sto cercando un design per la mia applicazione, qui ci sono i giocatori (classi) coinvolti.
struct Transform {
// Uses a matrix to transform the position.
// Also acts acts as the state of a Dialog.
Position transform(Position p);
//other methods.
};
struct Dialog {
// There are multiple dialog for the user to transform the output.
Transform& t;
void ChangeTranformation(){t.rotate(360);}
}
struct Algorithm {
//gives us a position based on an implementation. For example this can return points on a circle or line.
Transform& t;
Position m_p;
Dialog& d;
Position GetCurrentPosition(){ return t.transform(m_p);}
//other methods.
}
Proprietà di cui ho bisogno:
- Ogni algoritmo ha una finestra di dialogo e ogni finestra di dialogo può avere molti algoritmi ad essa associati.
- Quando l'utente seleziona un algoritmo viene visualizzata una finestra di dialogo associata a quell'algoritmo.
- Se l'utente seleziona un algoritmo diverso, quindi seleziona nuovamente lo stato viene ripristinato nella finestra di dialogo.
Fondamentalmente voglio un buon modello di progettazione per mantenere lo stato del dialogo dato che molti algoritmi lo usano e possono essere commutati avanti e indietro. Qualcuno ha qualche suggerimento?
Ecco un caso d'uso:
Dialog1 ha una sola casella di modifica per controllare il raggio.
Algorithm1 genera punti su un cerchio unitario.
Algorithm2 è lo stesso di Algorithm1.
L'utente ha selezionato Algorithm1 e inserito 2 nella casella di modifica. Questo genererà punti su un cerchio di raggio 2.
L'utente seleziona Algorithm2 e inserisce 10 nella casella di modifica di Dialog1 . Questo genererà punti su un cerchio di raggio 10.
Infine Algorithm1 è nuovamente selezionato. La casella di modifica di Dialog1 dovrebbe mostrare 2 e i punti su un cerchio di raggio 2 dovrebbero essere generati.