Eto Children of radiobuttonlist

sto utilizzando un codice per gestire i radiobuttonlist in RCommon/Eto

items_to_disable = ["Mild steel", "4140"]

for rb in self.radiobuttonlist.Children:
    if isinstance(rb, Eto.Forms.RadioButton):
        if rb.Text in items_to_disable:
            rb.Enabled = False

preciso che per ciò che mi serve ho già modificato il tutto ed è funzionante
ma questa parte linkata non comprendo al 100% il suo funzionamento

il ciclo va a prendere tutti gli elementi Children da radiobuttonlist
poi usa isinstance e questa parte mi sfugge l’utilizzo
(in pratica cosa fa compara rb con Eto.Forms.RadioButton?)

stavo tentando “senza il ciclo” di disabilitare un solo elemento radiobuttonlist tramite indici ecc ma nulla. . .

debbo passare obbligatoriamente per isinstance tramite il ciclo?

Scusa Salvio, si puo’ vedere qualcosa di piu’ dello script, se possibile ?
( Non conosco Eto … ho trovato la documentazione della API.
Sarebbe interessante capirci qualcosa di piu’ … Forse vedendo lo script …
O forse no, non so. :blush: :smile:)

sempre a disposizione mr. Emilio :wink:

il file postato nel link da Clement, dove spiega anche qualcosa sul funzionamento
quello che ha spiegato l’ho compreso, infatti l’avevo riscontrato nell’esecuzione
ma ciò che non riesco a fare (se possibile) saltare il ciclo e le due condizioni

avevo provato con gl’indici ma non so se sia corretta come strada
ps c’é quel isinstance che secondo me è la chiave di tutto
ma non so come fuziona è la prima volta che lo vedo.

isinstance verifica il tipo di un valore.
https://www.andreaminini.com/python/funzione-isinstance-python

Grazie per il link.
Provo a capirci qualcosa. :slight_smile:

Questo non lo so …
Ma ho provato a capire come funziona adesso.

Aggiungendo un print al ciclo, possiamo vedere quali sono i vari Children

        for rb in self.radiobuttonlist.Children:
            print( 'Child => ' + str( rb ) )
            if isinstance(rb, Eto.Forms.RadioButton):
                if rb.Text in items_to_disable:
                    rb.Enabled = False

L’output e’ questo:

Child => Eto.Forms.DynamicLayout
Child => Eto.Forms.RadioButton
Child => Eto.Forms.RadioButton
Child => Eto.Forms.RadioButton

Si vede che tra i Children e’ compreso anche un DynamicLayout.
Per quello Clement ha aggiunto la verifica tramite isinstance:
per lavorare solo sui Button.

esatto la prova col print l’avevo fatta anch’io

e anche qui mi confermi la mia prima ipotesi quindi :+1:

questo ero fuori strada, nel senso, credevo che isinstance facesse parte di RCommon
e quindi ero andato a controllare in quella guida, non credevo che facesse parte di Python

per questo poi successivamente avevo ipotizzare che oltre a comparare, avesse anche un’altra funzione.

ricapitolando a questo punto, il ciclo è semplice:
si va a prendere tutti gli elementi Children in radiobuttonlist
poi usa isinstance per prendere solo determinati elementi
ed in fine con Text filtra i valori dalla lista per disabilitarli.

quindi non vedo il perché non sono riuscito ad escludere il ciclo

ps avevo anche provato ad mettere rb.Enabled = False dopo il for escludendo i due if
i radiobuttonlist vengono tutti disabilitati come nell’esempio del codice, ma credo che
in questo caso venga disabilitato tutto radiobuttonlist e non ogni singola opzione.

mah non vorrei che centrasse l’istanza della parola self. . .

edit:

oppure l’arcano si nasconde in Children

questo è quello che mi restituisce il print di radiobuttonlist.Children:

<Eto.Forms.Container+<get_Children>d__10 object at 0x000000000000002C [Eto.Forms.Container+<get_Children>d__10]>

e questo invece è il print di radiobuttonlist.Properties

Dictionary[object, object]({'Control.MouseDown.Instance' : True, 'Control.MouseUp.Instance' : True, <object object at 0x000000000000002D> : <Eto.Forms.DynamicLayout object at 0x000000000000002E [Eto.Forms.DynamicLayout]>, <object object at 0x000000000000002F> : <System.EventHandler`1[[System.EventArgs, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] object at 0x0000000000000030 [System.EventHandler`1[System.EventArgs]]>})

ri-edit:
in Eto.Forms c’é proprio una classe Container che ha la proprietà Children dove spiega questo:

Gets an enumeration of all contained child controls, including controls within child containers

Get: Children(self: Container) → IEnumerable[Control]

RhinoCommon e’ una libreria di classi ( in C# credo ci sia poca scelta … :wink: )
Non ci sono funzioni ‘libere’. Ci sono solo metodi appartenenti a qualche classe.
Se prima del nome della funzione (isinstance) non c’e’ almeno un nome e un punto, non puo’ appartenere a RhinoCommon.
Inoltre tutti i nomi di RhinoCommon iniziano con una maiuscola.

( Poi un ‘vecchio’ pythonista come te dovrebbe proprio conoscerla isinstance:wink: )

Scusa, perche’ vorresti escluderlo ?.
A me quanto fatto da Clement (che tra parentesi e’ molto in gamba) sembra un’ottima soluzione.
Come dicevo, non sono esperto di Eto, ma dando un’occhiata alla documentazione non ho trovato nessun modo per fare quella operazione escludendo il ciclo.
Ripeto: secondo me, se Clement ha fatto cosi’, vuol dire che e’ il modo migliore … o l’unico. :wink:

Per forza, visto che lo script funziona … :wink: :smile:

in effetti sul fatto della libreria è vero, mi sarò fatto trascinare da una similitudine nella guida

immagine

“vecchio pythonista” nel senso che mi farò vecchio prima di capirci qualcosa di buono. . . ahahaha
lo sai che è giusto da quando ho iniziato a giocare con RCommon (inizio anno), che sto utilizzando
i metodi e un pochino le classi, prima usavo Py come VBS in modo per così dire procedurale
e come VBS i miei script in Py alla fine si basavano sulle semplici fubzioni tra cicli e if ecc

per il resto per carità, mi va bene anche che il metodo migliore o anche l’unico sia quello esposto,
anche se fosse così, volevo capire del perché, nel senso, con che tipo di oggetto sto avendo a che fare,
come posso gestirlo, e quali mezzi ho a disposizione per interagire con quest’oggetto?

ps e secondo me, questo dipende dal fatto che essendo all’inizio in questo tipo di programmazione,
ancora debbo comprendere bene il funzionamento delle Classi e come si intreccia il tutto.
infatti per ora riesco a trovare le soluzioni tra la guida (che per lo meno sto riuscendo a sfogliare)
e qualche esempio che scovo in rete, ma purtroppo ancora non so il funzionamento che c’é dietro.

come dire, es: mi interessava sapere che ciò che volevo fare, gestire quell’oggetto con gl’indici
come delle liste, in quel caso essendo che si trattava di altr’oggetto non lo si può gestire come una lista
perché non ha gl’indici ma ha altre proprietà/metodi ecc ma chissà col tempo poi lo capirò :wink:

Se vuoi dire che vorresti capire perche’ la RadioButtonList funziona cosi’ …
Non so se sia una cosa semplice.
E lo stesso discorso vale per le altre classi di RhinoCommon e di Eto.
Non e’ detto che ci sia una logica particolare dietro.
Io piu’ che del perche’ mi interesserei del come.
Come utilizzare queste classi, ma senza cercare chissa’ quale filosofia dietro ai metodi.
E’ il modo che ha scelto McNeel per fare queste operazioni.
Va bene cosi’.

E in effetti RadioButtonList ha dei metodi che usano gli indici, ad esempio SelectedIndex che ci da’ l’indice del Button selezionato, almeno credo …
Ma poi non trovo nessun modo di utilizzarlo quell’indice … Va be’, non importa.
Forse sono io che non capisco certi metodi, o forse certe cose sono ancora in via di sviluppo.
Fa lo stesso. Utilizziamo quello che c’e’, e che sappiamo come utilizzare, anche se questo richiede un ciclo. :grinning:

semplice non credo o per lo meno, non lo è perché viene usato una metodo inusuale (se si conoscesce)

della logica che li ha portati ad impostarlo in questo modo non’é che mi interessa
ma di come è strutturato quello si, poi del perché avranno avuto i loro buoni motivi
(oppure come spesso mi capita, per eseguire due azioni simili, uso metodi diversi giusto per imparare)

si di sicuro usa gl’indici, ma come ho già detto ieri, e da poco me ne sono maggiormente convinto,
che l’indice se lo va a prendere tramite il nome che gli si va ad impostare in fase di creazione

in pratica il ciclo si va a prendere tutti gli elementi Children del radiobuttonlist
poi il secondo passaggio, verifica se fa parte della classe RadioButton
(essendo che come primo elemento ha anche un DynamicLayout)
escludendo il DynamicLayout si va a prendere il Text di ogni elemento
che corrisponde ai nomi dati con DataStore che facendo parte di un dizionario
credo che venga usato come parola Key si va a recuperare il valore Indice
preso l’indice il gioco è fatto, si va ad impostare la proprietà Enable = False

ci sto girando in torno da un bel po di tempo ma non riesco a trovare il modo corretto
a meno che non sia proprio fattibile oppure come hai detto (cosa che ho notato anch’io)
il problema è che il tutto è ancora in fase di sviluppo e quindi ci sono molti punti vuoti

che testaccia dura che mi ritrovo :rage:

edit:
infatti ad avallare la mia tesi c’é la Property Items del radiobuttonlist

che ha come Type una ListItemCollection

che a sua volta ha un costruttore ListItemCollection Constructor (IEnumerable)

quindi dovrebbe usare gli Enum che già abbiamo avuto modo di parlarne tempo fa
il quale non mi erano chiare alcune cose, e ovviamente si vede che nemmeno adesso lo sono
:sweat_smile: :sweat_smile:

Premesso che per ora non ci ho capito molto, soprattutto i vari Bindings

Quale dizionario ?
Non lo vedo …

Se parli del testo, verifica solo che sia incluso nella lista items_to_disable

Anche qui non vedo nessun indice.

Se trova il testo tra quelli elencati, setta Enable come False per quel Control

Il fatto che un costruttore usi una enumeration vuol dire solo che puoi costruire uno di quegli oggetti tramite una enumeration di IListItem.
Non ci da’ altre informazioni su ListItemCollection

E gli unici metodi presenti servono ad aggiungere degli item tramite delle stringhe.
Non vedo traccia di Enum.

… E per finire coi soliti brontolii … :smile:

Indagare per capire come e’ strutturato va benissimo, credo sia la cosa giusta da fare. :grinning:

… Ma inventarsi delle cose che nello script non ci sono (dizionario, indice, enum …) secondo me non serve a niente, se non a farti perdere tempo …

Poi ovviamente forse tu ti trovi bene cosi’ e riesci a capire, allora fai bene … non so … :confused: :smile:

condivido in pieno, anch’io non ho idea di cosa sono e a cosa servono e non solo per gli Bindings

comunque ho riproposto la domanda all’altro forum, vediamo se qualcuno risponde. . .

items_to_disable = ["Mild steel", "4140"]

for rb in self.radiobuttonlist.Children:
    if isinstance(rb, Eto.Forms.RadioButton):
        if rb.Text in items_to_disable:
            rb.Enabled = False

una cosa che non capisco proprio, e come mai se rb è associata agli elementi self.radiobuttonlist.Children ed essendo che Children da come vedo è una proprietà della classe radiobuttonlist quando nel codice vediamo rb.Text e rb.Enabled se non erro sono sempre due proprietà che si vanno ad accodare a Children

(mi scuso per le cose non corrette che ci sono)

Non capisco cosa vuoi dire … e quindi quale sia il problema. :blush:

Posso solo dire velocemente cosa capisco io …

Children e’ una proprieta’ di Container, che viene quindi ereditata da RadioButtonList
Questa proprieta’ restituisce una IEnumerable<Control> cioe’ una enumerazione di oggetti Control.
In questo caso, come spiegato da Clement, gli oggetti sono in realta’ dei RadioButton, classe che discende da Control.
Il loop cicla su questi oggetti, usando la variabile rb. Quindi rb e’ un RadioButton

Text e’ una proprieta’ di TextControl, da cui discende RadioButton

Enabled e’ una proprieta’ di Control, da cui di nuovo discende RadioButton

… OOP in piena azione ! :grinning:

:wink: :smile:

eeeeh essendo un bel po complicato, lo sto imparando piano piano
insieme a RCommon e Eto che a dirla tutta nemmeno loro sono semplici :exploding_head: :exploding_head:

1 Mi Piace

Ho visto. :grinning:

… E ci ho messo un’ora a capire come funziona … :roll_eyes:
Eh, la vecchiaia ( come alibi va sempre bene … :smile:)

1 Mi Piace

mi fa piacere Emilio che ci sei riuscito a capire qualcosa,
(se e quando vuoi, lo sai sono sempre pronto ad ascoltare)
io non ero in grado nemmeno di avviare un evento in init ahahahah

eeee io chissà, posso utilizzare qualche altra scusante. . . :wink:

Niente di particolare.
Non capivo a cosa si riferiva quell’ IndexOf.
Bisogna farci un po’ l’abitudine a Eto … :wink:
( Forse piu’ alla OOP … :confused: :confused: :wink: )

Tu dimmi qual’e’ il dubbio e proviamo a ragionarci.

Direi piu’ “settare un event handler” … o una cosa simile.

Poi, fatta salva l’elegante e robusta soluzione di Clement,
perche’ non hai semplicemente chiamato DisableRadioButtonListItems dopo il costruttore ?
… O dopo ShowModal, nal caso prima dia errore … :slight_smile:

EDIT

Credo che in questo caso i parametri sender ed e andrebbero eliminati in quanto non lo richiami piu’ da un pulsante.

è stata la prima cosa che ho fatto, ma in entrambi i casi, o non ha nessun effetto, oppure torna un errore.

Emilio secondo me, da quello che sto vedendo, per quanto mi riguarda,
per capirci qualcosina si dovrebbe iniziare come coi bambini, da un disegnino

un bel disegno che tracci i collegamenti tra istanze parametri e quant’altro
cosa crea, cosa richiamano ecc dopo aver capito bene tutto questo
allora forse si potrebbe iniziare a ragionarci sopra ahahahah

ps lo dissi che le cose le imparo visivamente (il mio grande fardello)
prima le debbo fare, poi dopo che ho memorizzato tutti i passaggi
e quindi le riesco a ripercorrere passo passo nella mia mente
allora posso fare i ragionamenti, oppure quando leggo quei
argomenti riesco a fare i collegamenti necessari ecc ecc
altrimenti tutte le letture vanno a vuoto non rimane nulla

Hai ragione. Ho detto una cavolata. :confused:
Non so perche’, ma e’ cosi’.
Sembra che sia prima che dopo ShowModal il dialogo non sia accessibile.
E dopo posso capire, perche’ essendo modale (pessima cosa secondo me :smile:), lo script dovrebbe bloccarsi fin quando il dialogo non si chiude.
Ma prima non so perche’ … devono esserci dei meccanismi per cui il dialogo non e’ ancora completo, o raggiungibile … o che ne so.
Sto imparando da te Salvio … faccio ipotesi completamente a caso …
:wink: :smile:

Brutte bestie le interfacce grafiche, almeno alcune … :confused: :wink:

Non c’e’ niente di male o di strano.
Ad esempio moltissimi preferiscono i programmi ‘grafici’ di GH agli script tradizionali.
E’ questione di preferenze personali. :slight_smile:

Possiamo anche provare a fare degli schemini.
Pero’ bisogna decidere cosa schematizzare.
Concentrarsi su una cosa per volta, su un problema o un aspetto o una operazione particolare.
Gia’ capire a cosa servono i vari parametri di un singolo metodo a volte non e’ semplice (per un insulso scriptomane come il sottoscritto … ). :smile:
Se cerchi uno schema per tutta RhinoCommon o per tutta Eto … io mi ritiro in buon ordine. :wink: :smile: