Fare un progetto in crowdsourcing su Canvas - pagina 14
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
ElementSet, dove dovete specificare (1) proprietà e valore o (2) proprietà, modificatore e valore.
Sì, è universale in termini di accesso alle proprietà di controllo.
Generalmente PropGet/Set è un buon meccanismo per gestire le classi template quando l'interfaccia ereditata è inizialmente sconosciuta.
Ma voglio riportare la discussione alla mia domanda originale - come posso fare un "inizio rapido" per un programmatore sullo schema dei colori dei controlli?
Ed è possibile implementare non un funzionale (SetBgColor o SetProp(Enum_Color, ), ecc.), ma una classe di attributi più universale.
In modo che tutti i controllori accedano a una classe universale di attributi e il codificatore possa facilmente capire quale colore è usato da quale controllore.
Ma tutto questo è il mio ragionamento sul mio schema. Non escludo che cambierà ancora molto quando inizierò la transizione. Quindi tutto quello che ho scritto sopra potrebbe non essere più rilevante per l'argomento in discussione qui. )
In linea di principio sono d'accordo, sarà chiaro quali colori ha e cosa può essere cambiato.
c'è una domanda allora - Theme implica una ridondanza di parametri inutilizzati?
Sì, è ridondante, per tutte le varianti. Ma allora è conveniente creare un nuovo tema ridipingendo e cambiando i valori in quello precedente. Proprio come i temi in Windows.
P.S.
E sono scettico sui cambiamenti di massa di alcuni valori da parte del codificatore diversi da quelli utilizzati nel tema attuale. Mi ricorda un progetto Delphi in cui la prima cosa che si cerca di fare è dipingere l'interfaccia con i propri colori che poi non cambia quando si cambia il tema del sistema.
E perché macchiare gli stili di design da qualche parte? Eredita una classe di tema da uno dei temi esistenti e ridisegna solo i valori che devono essere cambiati.
c'è questa tecnologia CSS
1) conosciuto e ben documentato
2) familiare e versatile
3) tag==controlli in linea di principio, il che lo rende adatto al nostro compito
Provatelo, dovrebbe funzionare come previsto.
c'è una tecnologia CSS
Poi vai direttamente a LESS / SCSS (SASS)
Poi vai direttamente a LESS / SCSS (SASS)
ugh, Lass è probabilmente buono, ma non abbiamo bisogno della sua funzionalità. non stiamo facendo un interprete.
Prendiamo puramente il principio di costruire e ridefinire gli stili in cascata^selettiva^punto - come fanno loro.
E assicurati di includere un'opzione di design reattivo per diverse risoluzioni. Vedere Media Queries in CSS
E alcune parti possono essere di dimensioni fisse, mentre altre possono allungarsi il più possibile.
Cari membri del forum, non ho alcun desiderio di demotivare nessuno, ma a mio parere, la tecnologia in discussione è così complessa che non può essere implementata da sforzi congiunti e dispersivi. Non possiamo combinare questi sforzi in modo efficace perché tutti noi differiamo nei livelli di comprensione, professionalità e approcci... Siamo anche separati da distanze e persino da paesi.
La mia conclusione è che questa tecnologia può essere implementata da un singolo sviluppatore che ci ha lavorato a lungo e duramente. Forse più di un anno. Ma è improbabile che questa persona faccia crowdsourcing di questa tecnologia perché ci ha messo troppo impegno, troppa anima, e si è semplicemente esaurito con questo lavoro... È il suo progetto e ha il diritto di non distribuirlo liberamente. (Forse all'inizio, ma non sempre).
Credo che questa tecnologia sia già stata implementata in MQL.
P.S. Anche se, anche se lo è - perché non provare a implementarlo di nuovo? ))
Perché potrebbe essere utile:
1. l'interfaccia della bitmap è veloce. Così veloce che è praticamente indistinguibile dall'interfaccia del sistema. Per esempio, ho implementato elementi traslucidi con gradienti, eanche quando si muovono, sono resi in modo fluido senza alcun ritardo visibile, tenendo conto della miscelazione dei colori e del calcolo del canale alfa su altri oggetti con gradienti traslucidi.
2. L'interfaccia è scalabile. Potete rendere l'applicazione più complessa e non rallenterà a causa della cancellazione e della creazione di un gran numero di oggetti del grafico. I costi di ridisegno sono minimi, si tratta solo di sostituire un'immagine, in millesimi di secondo.
3. Potete creare controlli già pronti e fornire la possibilità di crearne di nuovi, perché potete fornire il vostro pool di eventi, per esempio:
OnMouseDown - ha premuto la LKM
OnMouseUp - premuto il pulsante del mouse
OnMouseHoverOn - passaggio del cursore del mouse su un oggetto
OnMouseHoverOut - sposta il cursore del mouse dall'oggetto
OnMouseClick - preme e clicca entro i confini dell'oggetto
OnMouseDblClick - doppio clic del mouse entro i limiti dell'oggetto
OnDragStart - evento che si verifica una volta all'inizio del movimento con il tasto sinistro del mouse premuto
OnDragMove - evento generato durante il movimento con il tasto sinistro del mouse
OnDragEnd - evento generato dopo lo spostamento con LKM
OnPut - l'oggetto è castato in un altro oggetto
OnGet - l'oggetto viene scaricato in un altro oggetto
OnFocus - l'oggetto è stato messo a fuoco
OnBlur - l'oggetto perde il focus
OnResize - l'oggetto ha cambiato dimensione
OnParentResize - l'oggetto padre ha cambiato dimensione
OnKeyPress - un tasto premuto
OnChange - valore di un campo cambiato
ecc.
Stai esagerando un po' nel seguito:
La velocità con cui viene disegnata una bitmap dipende dalle sue dimensioni. Se si ridisegna l'intera bitmap che rappresenta la finestra quando si ridisegna la parte, la risposta sarà lenta (verificata). La soluzione ovvia è quella di far ridipingere solo l'area della bitmap.
Tuttavia, per ridisegnare solo una parte della bitmap che rappresenta una finestra, è necessario memorizzare la maschera digitale della bitmap in memoria (in un array). Successivamente, è necessario navigare all'interno di questa maschera, e trovare il modello desiderato al suo interno. Tuttavia, tenete conto che ci possono essere molte finestre. Ora valutate la quantità di memoria necessaria per memorizzare le maschere di tutte le finestre. Si potrebbe inventare un sistema di priorità per scegliere quali finestre ricordare e quali "dimenticare", e quando. Tuttavia, non è una cosa facile da fare.
Dovete capire che ridisegnare è riscrivere valori in un array, e se dovete riscrivere 1000000 valori (numero approssimativo di pixel nell'immagine della finestra e nella bitmap), non saranno "millesimi di secondi", ma secondi. Pertanto, si dovrebbe disegnare una finestra completamente solo una volta, salvarla in memoria e poi, agli eventi, ridisegnare ogni oggetto separatamente. Allora la velocità sarà molto alta.
Apparentemente, avete implementato solo oggetti separati, ma provate a creare una finestra e ad implementare lì l'interattività dei suoi elementi. Capirete cosa intendo.
Per quanto riguarda gli eventi che hai citato, la loro implementazione nel programma non è legata alla tecnologia dei controlli di disegno e dovrebbe essere presente in qualsiasi interfaccia.
...
Apparentemente hai implementato solo oggetti individuali, ma prova a creare una finestra e implementa lì l'interattività dei tuoi elementi, vedrai cosa intendo.
...
Lei sta leggermente esagerando quanto segue:
La velocità di disegno della bitmap dipende dalle sue dimensioni. Se ridipingete l'intera bitmap che rappresenta una finestra, la risposta sarà lenta (l'ho provato). La soluzione ovvia è quella di avere solo la zona della parte da riverniciare.
Tuttavia, per ridisegnare solo una parte di un disegno bitmap che rappresenta una finestra, è necessario avere una maschera digitale di quella bitmap memorizzata (in un array). Poi, dovete navigare all'interno di questa maschera e trovare la parte che volete. Tuttavia, tenete conto che ci possono essere molte finestre. Ora valutate la quantità di memoria necessaria per memorizzare le maschere di tutte le finestre. Si potrebbe inventare un sistema di priorità per scegliere quali finestre ricordare e quali "dimenticare", e quando. Tuttavia, questo non è un compito facile.
Dovete capire che ridisegnare è riscrivere valori in un array, e se volete riscrivere 1000000 valori (numero approssimativo di pixel nell'immagine della finestra e nella bitmap), saranno secondi, non "millesimi di secondo". Pertanto, si dovrebbe disegnare una finestra completamente solo una volta, salvarla in memoria e poi, agli eventi, ridisegnare ogni oggetto separatamente. Allora la velocità sarà molto alta.
Probabilmente avete implementato solo oggetti singoli, ma provate a creare una finestra e ad implementare lì l'interattività dei vostri elementi e capirete di cosa sto parlando.
Per quanto riguarda gli eventi che hai citato, la loro implementazione nel programma non è legata alla tecnologia dei controlli di disegno e deve essere presente in qualsiasi interfaccia.
Voglio fare una piccola precisazione:
Prima creiamo una maschera digitale della finestra con tutti i suoi elementi. Poi creiamo una bitmap con ResourceCreate(). Otteniamo la nostra finestra sul grafico.
Poi spostiamo il mouse sull'interfaccia di questa finestra e catturiamo, per esempio, l'evento di puntamento (_Object_Pointed).
Descriverò due approcci di implementazione dell'interattività degli oggetti - uno cattivo, l'altro migliore:
1. Se la maschera digitale della nostra finestra non è stata salvata nell'array dopo la sua creazione, allora per cambiare qualsiasi dettaglio del disegno di quella finestra, dobbiamo ricrearla completamente. Cioè, bisogna ridigitalizzare. Questo di per sé richiede tempo perché è necessario inizializzare l'array con i valori dei colori dei pixel di tutti i modelli di finestre per passarlo a ResourceCreate(). Più grande è la finestra e più dettagli contiene, più tempo ci vorrà (da 250 millisecondi a 2 secondi circa). E così, su ogni evento di ogni elemento. Questa opzione è troppo difettosa.
2. Se una maschera numerica è stata memorizzata in un array, abbiamo solo bisogno di reinizializzare quei valori che si riferiscono a una parte specifica di quella finestra. Troviamo quella parte nell'array e riscriviamo i suoi valori. Poi, - inviamo l'array a ResourceCreate() e otteniamo immediatamente il risultato.
Questa è in realtà l'intera tecnologia. Quasi))