risolto - widget text con righe protette e righe modificabili

[maresama]

python 2.7 -
Un lungo testo (con frasi evidenziate da colori (tag)) è gestito con text
nb: visualizzazione protetta da modifiche (disabled)
Ora si vorrebbero inserire delle righe con domande e con la possibilità di scrivere la risposta
(lasciando lo spazio necessario).
In pratica su tali righe, premendo un tasto del mouse, si dovrebbe poter scrivere ma solo nell'apposito
spazio riservato
In pratica tipo questionario molto commentato.

Ad esempio:
testo..xxxxxx. riga protetta
xxxxxxxxxxxxxx id.
xxxxxxxxxxxxxx id.
titolo di studio?: (qui si dovrebbe poter scrivere direttamente la risposta)
xxxxxxxxxxxx riga protetta
xxxxxxxxxxxx id.
Città prescelta?: (qui si dovrebbe poter scrivere)
xxxxxxxxxxxx.... riga protetta
xxxxxxxxxxxx.... id.

Ho scartato l'idea di usare tkSimpleDialog.askstring() perchè poco gradevole e poco pratico
non scrivendo direttamente sul testo
C'è qualche soluzione?

Non ho capito se c'è una possibilità di proteggere solo una parte delle righe
lasciando la possibilità di scrivere sulle altre (sapendo il numero di tali righe).
(disabled e normal agiscono su tutto)

[nuzzopippo]

Riferisci proprio ad un singolo widget "Text"?

È complicato ma ci si potrebbe riuscire a patto di avere chiarissimo e stabile l'intero contenuto del documento ed intercettare qualsiasi tasto premuto prima che venga rilasciato, valutandone la posizione, per i colori è semplice. se Ti serve un esempio guarda qui.

... Quello che mi chiedo è : non puoi fare in modo più semplice? E poi, perché utilizzi ancora python 2.7? È fuori supporto da un anno, comincia anche a diventare difficile da usare per le differenze sintattiche e di comportamento.

[maresama]

Il fatto di usare python 2.7 è che stiamo parlando di un programma già esistente
Per quanto riguarda i colori nessun problema. E' già con frasi colorate, sottolineate e con font diversi.
Per quanto riguarda il discorso del testo avevo già il dubbio che sarebbe stata una cosa difficile,
Ora stavo pensando ad una soluzione diversa ma anche questa mi sembra impossibile:
Premesse:
1 quando premo il tasto del mouse so esattamente in che riga di testo sono, posso leggere la riga e sapere cosa fare
2 Supponiamo che riesca a fare un widget di immissione di una riga senza la mascherina attorno (in un nuovo post che ora farò spero di risolvere il problema (riesco a fare l'input senza il contorno giocando sulla trasparenza ma non funziona. Ci riesco in un altro modo ma però non riesco ad immettere il dato.... insomma devo ancora risolverlo)
3 se riesco a risolvere e trovo il sistema per sapere esattamente la posizione della riga in variazione, potrei sovrapporre i due (quindi la scrittura in realtà sarebbe separata (nb: in effetti oggi è già così ma si vuol cambiare!) e il dato immesso poi riportato sul testo
Il tutto comunque m sembra ancora di difficile realizzazione per portare la riga di immissione esattamente sul testo credo sia possibile ma non so cosa succederà chiamando la funzione della immissione in una call chiamata dal mouse.
Io sono però ostinato e prima di arrendermi tento di trovare una soluzione.....
Ti ringrazio comunque per i consigli. E da te sono veramente preziosi!

[nuzzopippo]

Ci ho pensato un po' su ... in certe circostanze "potrebbe" non essere difficile, supponiamo di avere il template di un modulo da compilate così fatto

Codice: Seleziona tutto

testo..xxxxxx.
xxxxxxxxxxxxxx id.
xxxxxxxxxxxxxx id.
titolo di studio?: 
xxxxxxxxxxxx
xxxxxxxxxxxx id.
Città prescelta?: 
xxxxxxxxxxxx....
xxxxxxxxxxxx.... id.

contenuto nel file "template" e che le righe da compilare terminino tutte con ": " (due punti + spazio

potremmo definirci una matrice di righe e colonne che determino da quale riga e da quale colonna sia possibile inserire del testo, Ho realizzato, in python3, purtroppo "python" neanche si avvia nel mio ubuntu, un semplice esempio che permette di inserire del testo solo nelle righe abilitate e dopo il testo descrittivo, non permette di inserire testo altrove e ritorni a capo da nessuna parte, permette l'uso dei tasti di navigazione. Il file "template" con il contenuto sopra deve stare nella stessa directory, ho omesso di "colorare" casalle dato che lo sai fare.

codice:

Codice: Seleziona tutto

import tkinter as tk

def get_module(f_name):
    with open(f_name) as f:
        rows = f.read().splitlines()
    enabled = []
    for i in range(len(rows)):
        if rows[i].endswith(': '):
            coords = i+1, len(rows[i]) - 1
            enabled.append(coords)
    return rows, enabled

class TextModule(tk.Tk):
    def __init__(self):
        super().__init__()
        self.module, self.enabled = get_module('template')
        self.t_box = tk.Text(self)
        self.t_box.grid(row=0, column=0, sticky='nsew')
        self.grid_rowconfigure(0, weight=1)
        self.grid_columnconfigure(0, weight=1)
        self.t_box.bind('<KeyPress>', self._on_key)
        self._make_module()

    def _on_key(self, evt):
        key_s = evt.keysym
        if key_s in ['Left', 'Right', 'Down', 'Next',
                     'Prior', 'End', 'Home']:
            return
        if key_s == 'Return':
            return 'break'
        row, col = self.t_box.index(tk.INSERT).split('.')
        if int(row) not in [x[0] for x in self.enabled]:
            return 'break'
        for item in self.enabled:
            if item[0] == int(row):
                if item[1] > int(col):
                    return 'break'
                break

    def _make_module(self):
        for r in self.module:
            self.t_box.insert('end', r + '\n')
            


if __name__ == '__main__':
    app = TextModule()
    app.mainloop()

Spero Ti sia utile, comunque fai sapere

Ciao

[Edit] Eliminati un paio di "print" di degub che avevo lasciato

[maresama]

La mia alternativa è fallita perchè non si riesce ad eliminare la cornice contemporaneamente alla entry (mi sarebbe servito anche per un altro problema,,,)
Invece la tua soluzione mi sembra valida:
devo vedere come adattarla al programma in esame (non usa classi) e se ho ben capito, tu suggerisci di inibire lo spostamento dalla riga in variazione (in effetti terminano già con : e comunque soro righe riconoscibili)
In pratica dove ho la chiamata per la variazione, dovrei controllare l'input carattere x carattere (get di 1 solo carattere?) e quindi bloccare gli spostamenti di riga. Ho capito bene?
Devo chiarirmi le idee (chiedo scusa ma a 86 anni le idee sono molto rallentate !) ma mi sembra la strada giusta.
Devo anche capire bene il tuo esempio ed adattarlo (senza le classi) ma mi sembra comunque che non ci siano differenze fra python 2,7 e 3 in questo problema....

[nuzzopippo]

Nell'esempio ho, di fatto, inibito l'inserimento di nuove righe interrompendo l'evento in presenza della pressione del tasto "Return", ciò perché sfalserebbe gli eventuali riferimenti a righe permesse successive ... tieni presente che NON ho fatto la stessa cosa con il return del tastierino numerico, ma il riposizionamento del punto di inserimento dovrebbe comunque annullare la digitazione, non ho verificato però.
L'inserimento di una nuova riga potrebbe anche essere gestito, incrementando i valori di riga successivi in self.enabled ed inserendo nuove righe editabili ma ciò complicherebbe la logica di gestione, penso convenga lasciare una tale limitazione.

Riguardo al non utilizzo delle classi ... beh, potresti lasciare la matrice delle righe/colonne abilitate quale variabile globale e gestirla dichiarandola tale nelle funzioni di inizializzazione e di gestione del callback però ... gestire una GUI senza la programmazione ad oggetti rende le cose molto più complesse, certo, se si ha la bicicletta bisogna pedalare ma si è su di ua strada "ciottolosa"

[Edit] l'avevo saltato

In pratica dove ho la chiamata per la variazione, dovrei controllare l'input carattere x carattere (get di 1 solo carattere?) e quindi bloccare gli spostamenti di riga. Ho capito bene?

Si, più o meno la logica è quella, si intercetta ogni pressione della tastiera rilevando il punto di inserimento e si valuta cosa fare in base alla situazione.
io ho considerato i tasti di navigazione, lasciandoli sempre validi, prudenzialmente ho definito sempre NON valido il tasto di return, ma probabilmente è non necessario, non ho esaminato a fondo la questione del riposizionamento del punto di inserimento, se entra in gioco prima o dopo il completamento dell'evento, per altro interrompo sempre l'evento di pressione tasto se si è posizionati su di una riga od anche colonna non abilitata lasciando inalterato l'evento altrimenti.

[maresama]

Innanzitutto grazie per i tuoi interventi
La tua soluzione mi ha fatto venire in mente un programma di diversi anni fa e l'ho ripescato: if effetti fa proprio il controllo carattere per carattere
Li il problema era di non accettare in digitazione certi caratteri ma in pratica la cosa è analoga.
Ora sto rivedendo il tutto; fra quello che riesco a capire di quanto avevo fatto più la tua soluzione, dovrei riuscire a venirne a capo.
Almeno spero.....

[maresama]

Sto seguendo questa strada, semplice a mio avviso ma in parte da verificare:
nella callback con get controllo se la riga è di quelle modificabili (questo è già nella vecchia versione)
Se OK:

Codice: Seleziona tutto

            Tfix.config(state=NORMAL)
            Tfix.bind('<KeyPress>', Clic)
 
        def Clic( event):
            key = event.keysym
            print key
            if key in ['Up','Down', 'Next','Prior', 'End', 'Home']:  Tfix.config(state=DISABLED); return ''
            Tfix.config(state=NORMAL)
            return key

In pratica se scrivo sulla riga va tutto bene
se invece cambio riga disattivo la scrittura, Occorre poi rientrare nella call per proseguire
Devo ancora vedere come bloccare se cambio riga spostandomi con il mouse (se cambio riga non si accorge e finisco per scrivere su altra riga) e per evitare da cancellare la parte iniziale della riga....
Inoltre devo vedere come disattivare Tfix.bind('<KeyPress>', Clic che potrebbe dare qualche problema
Cosa ne dici? Ci vedi qualcosa da correggere ?

[nuzzopippo]

Non credo che sia una buona strada quella che hai intrapreso.

Prova a lavorare direttamente sull'evento nella funzione di callback (in Tuo "Clic") all'evento "<KeyPress>" dovrebbe far seguito un evento "<KeyRelease>" che completa l'azione determinata dal tasto premuto, se nel callback effetti un "Return 'break'" interrompi il processamento del callback e l'azione non si verifica, sfruttare questo effetto è più semplice che giostare con uno stato attivato/disattivato di un controllo ... poi, hai il problema di stabilire "quando" il controllo deve essere attivo o meno, da disattivato non so se riposizioni il punto di inserimento, mi sembra di difficile gestione nel Tuo modo.

[maresama]

Non credo i aver capito bene : pensi che dovrei non agire sul 'Disabled' per evitare la scrittura?
Io avevo scelto questa soluzione perchè mi permetteva di bloccare la scrittura nella riga sbagliata muovendo il mouse (bind B1-motion non sempre interviene e non ho capito perchè).
Mi rendo conto che spiegare le cose è molto difficile....
Come ho fatto io quando entro in modifica memorizzo il numero riga, quando entro nella call.back verifico subito su quale riga sono. Se giusta tutto ok, Se non corrisponde esco prima ancora che si digiti il carattere che poi comunque va nella riga e non so come toglierlo...
Non ho capito il return break' da fare nella call-back (vado sempre peggio....), Come dovrei fare?

Come ho fatto resiste a tutte le prove eseguite, ma certamente non è una prova esaustiva, Se mi trovo qualche nuovo problema rivedrò tutto dal principio cercando di utilizzare quanto mi hai suggerito.

Come penso avrai capito io sono molto attirato dal cercare di risolvere i problemi più strani, e a volte mentre tento di risolverne uno me ne trovo altri che mi propongo di risolvere, anche se al momento non mi servono le soluzioni.
In questo caso, ad esempio, la domanda: esiste la possibilità di annullare una chiamata ad una callback?
Un' altra è nata dal fatto che dovevo poter annullare l'immissione dell'ultimo carattere scritto (problema del mouse spostato: mi son detto: ma è possibile dare da terminate Control-z per annullare quanto fatto. Sicuramnte è una scemenza ma la vita è fatta di curiosità... (nati non foste per viver.......)

Scusami se sono troppo noioso.... forse stare sempre chiusi in casa (per la mia età è vitale) ci trasforma... e naturalmente in peggio!

[nuzzopippo]

Non credo i aver capito bene : pensi che dovrei non agire sul 'Disabled' per evitare la scrittura?

La programmazione è bella perché da mille possibilità, penso solo che sia una strada più tortuosa e difficile da percorrere.

Io avevo scelto questa soluzione perchè mi permetteva di bloccare la scrittura nella riga sbagliata muovendo il mouse (bind B1-motion non sempre interviene e non ho capito perchè).

Difficile arguirlo, in gioco entrano anche i tempi di elaborazione ed il movimento del mouse, pensa a quanti eventi si accavallano mentre lo muovi : spostamento, focus su widget diversi, su righe e colonne diverse, su caratteri diversi ... mica facile avere risposte "chiare"

Mi rendo conto che spiegare le cose è molto difficile....
Come ho fatto io quando entro in modifica memorizzo il numero riga, quando entro nella call.back verifico subito su quale riga sono. Se giusta tutto ok, Se non corrisponde esco prima ancora che si digiti il carattere che poi comunque va nella riga e non so come toglierlo...
Non ho capito il return break' da fare nella call-back (vado sempre peggio....), Come dovrei fare?

Si, spiegare è difficile, principalmente se non è che poi si abbiano le idee chiare (la docs è tutta in inglese ed io ho fatto francese ) ... a soldoni, cercherò di spiegare cosa credo di aver capito ma prendimi con le molle.
Quando si preme un tasto sulla tastiera si scatenano tutta una serie di eventi concatenati che vengono elaborati in successione, in soldoni possiamo dire che tali eventi si avviano premendo il tasto e si concludono appena dopo che il tasto viene rilasciato, interpretando il codice del tasto e ponendo in essere i comportamenti previsti per quel particolare tasto, nel caso di una test-box spostando il cursore se è un tasto di navigazione, eseguendo una qualche funzione od anche assegnando "a qualcosa" un certo "valore" associato al tasto (il carattere, p.e.).
Definendo una funzione di callback si inserisce del codice da processare nel normale flusso della catena di eventi determinata dalla pressione del tasto, il momento in cui verrà preso in considerazione sarà determinato dalla scelta effettuata per il binding, più o meno "<KeyPressed>" non appena viene premuto, "<KeyReleased>" un istante prima degli eventi previsti per il rilascio, "<Key>" alla fase terminale di gestione.
Ogni funzione python ritorna sempre e comunque un valore che viene processato, o rilasciato con il "return" o, comunque, "None" (che poi corrisponde al return senza parametri. Quando la funzione ritorna il valore "break" il normale flusso di eventi successivo al momento scelto per il callback non viene processato, quindi se esso è nella fase iniziale non avviene l'effetto che avrebbe dovuto realizzarsi con il tasto premuto, p.e. assegnazione del valore nel punto di inserimento della Text-box ... è questo particolare che ho sfruttato nell'esempio che Ti ho proposto, esistono anche altre modalità, tipo annullare il valore del tasto, per impedire che un carattere "vada nella riga", comunque se la funzione di callback esce con i valori di default (None) la catena di eventi continua normalmente ed il valore del tasto viene assegnato, è questo il perché il carattere "comunque va nella riga" : il valore del tasto premuto rimane valido ed il flusso di eventi viene elaborato.

Come ho fatto resiste a tutte le prove eseguite, ma certamente non è una prova esaustiva, Se mi trovo qualche nuovo problema rivedrò tutto dal principio cercando di utilizzare quanto mi hai suggerito.

Non posso dire di "aver chiaro" ciò che hai fatto ma se a Te va bene mi sembra OK, come è stato detto, tutte le strade portano a Roma

Come penso avrai capito io sono molto attirato dal cercare di risolvere i problemi più strani ...

... qualcosa del genere l'avevo intuita, in effetti i post più particolari cui ricordo di aver risposto sono i Tuoi ... ottima cosa, la mente curiosa

...In questo caso, ad esempio, la domanda: esiste la possibilità di annullare una chiamata ad una callback?
Un' altra è nata dal fatto che dovevo poter annullare l'immissione dell'ultimo carattere scritto (problema del mouse spostato: mi son detto: ma è possibile dare da terminate Control-z per annullare quanto fatto. Sicuramnte è una scemenza ma la vita è fatta di curiosità... (nati non foste per viver.......)

Non comprendo cosa Tu effettivamente intenda con "annullare una chiamata ad una callback, ho il dubbio Tu intendo lo "unbind" del widget ma il sospetto di averti già risposto prima ... poi NO, da terminare puoi killare l'applicazione ma non puoi intervenire all'interno del mainloop di tkinter: è un thread bloccante, niente al di fuori di esso può intervenire (beh ... quasi niente) se vuoi delle funzioni di "undo" e "redo" te le devi implementare Tu.

... e niente scuse, credo Tu stia interloquendo con una delle personalità più noiose che la storia dell'umanità ricordi è un piacere se mi riesce di esserTi utile.
Ciao

[maresama]

Non sei noioso, sei SPECIALE!
Grazie delle spiegazioni
In effetti ora va tutto bene, ma dopo aver scoperto che 'return' non viene restituito come evento.
Lo restituisce solo aggiungendo: Tfix.bind("<KeyRelease>", lambda event: Clic(event.keysym))
Poi ho scoperto che comunque anche disattivando text, il return viene comunque eseguito e crea una nuova riga (una sola perchè poi è disattivato...'
ho risolto con text,delet della riga creata quindi viene creata ma subito eliminata.
Ho provato ad usare break ma se metto return break da errore, se return 'break' non cambia nulla e crea sempre la riga.
Ho visto che tu l'hai usato in tutte e due i modi. Non è per caso una diversità tra python 2,7 e 3?
Infine per sapere uk numero riga e la colonna del momento io usavo .index(CURRENT), invece devo usare .index(INSERT) perchè da la riga giusta ma la colonna errata.
Non so come ringraziarti per la tua gentilezza e pazienza.
E' una gran fortuna avere nel forum persone come te.

[nuzzopippo]

Mi lusinga la Tua opinione, @maresama, ma la ritengo eccessiva, so di avere ancora TROPPO da imparare

In effetti ora va tutto bene, ma dopo aver scoperto che 'return' non viene restituito come evento.

Mi sa che hai un po' di confusione circa l'istruzione return, essa causa l'immediata uscita da una funzione, senza processarla per intero, con restituzione di alcune espressioni oppure None.
Gli eventi sono una cosa, il valore restituito da una funzione è un'altra, come ho accennato nel precedente post, l'handler degli eventi è un qualcosa di articolato e piuttosto complesso, il 'break' restituito (ove occorreva) nell'esempio serviva a segnalare al gestore degli eventi di tkinter l'intenzione di interrompere il processo di pressione del tasto (quindi di non fare nulla)

... non credo ci siano differenze comportamentali di return tra la versione 2.x e la 3.x.
La differenza nell'uso di return da me effettuata è determinata da precise ragioni, ove il return era dato "puro" volevo che il gestore degli eventi di tkinter processasse normalmente e per intero l'evento, sino alla fine, dove, invece, il return restituiva "break" stavo indicato al gestore degli eventi di tkinter di interrompere il processo degli eventi di tastiera e non fare nulla ... se provi il mio esempio vedrai che i tasti cursore (frecce, pgsu pggiù, home ed end) funzionano in qualunque punto, gli altri no, solo dove io lo permetto (righe e colonne "libere")

Lo restituisce solo aggiungendo: Tfix.bind("<KeyRelease>", lambda event: Clic(event.keysym))

Questa istruzione mi lascia un po' perplesso, non ho idea che effetto fa passare ad un callback solo una parte dell'evento, io l'avrei scritta così

Codice: Seleziona tutto

Tfix.bind("<KeyRelease>",  Clic)

ed eventualmente estratto le proprietà dell'evento al suo interno

... comunque, se hai risolto penso che vada bene in ogni caso, c'è sempre tempo per comprendere e migliorare

[maresama]

In effetti io non ho provato il tuo programma.
Dopo aver cambiato tkinter con Tkinter avevo provato ma mi ha dato questo errore
Traceback (most recent call last):
File "9prova2.py", line 24433, in <module>
app = TextModule()
File "9prova2.py", line 24401, in __init__
super().__init__()
TypeError: super() takes at least 1 argument (0 given)
Ma io nel frattempo ero interessato a capire quello che il programma faceva.
Quindi ho subito provato ad adattare la parte di Clic da te scritta nella mia prova
Con un print di event ho scoperto che gli eventi 'Down', 'Up' ecc venivano intercettati ma no 'Return'
In effetti per avere anche 'Retun' occorre aggiungere bind("<KeyRelease>"
ma comunque dopo che l'operazione di scrittura è stata fatta e non prima di farla
Per il break a parte quello per terminare il ciclo for, mi aspettavo di trovare una interrogazione del risultato della funzione.
Non avendo trovato nessun 'if ... 'break' non ho approfondito su come funzionava
Ciao

[nuzzopippo]

Dopo aver cambiato tkinter con Tkinter avevo provato ma mi ha dato questo errore ...

uhmm ... NON so se sia l'unica cosa che non andrebbe con il 2.7 ma cambia il super in questo modo:

Codice: Seleziona tutto

super(TestModule, self).__init__()

e dovrebbe andare, riguardo al "Return", intercetta il tasto invio della tastiera principale, se per caso utilizzi lo invio del tastierino numerico, il keysim è "KP_Enter", che nell'esempio non viene gestito.

... L'esempio, come detto, è stato sviluppato con python 3, dovrebbe essere lanciato con quello (non lo hai sulla Tua macchina?) comunque prova con quanto sopra e fai sapere, purtroppo non posso testarlo con la version 2.x

[maresama]

Io non volevo assillarti con il mio problema che tra l'altro con i tuoi suggerimenti è stato risolto.
Probabilmente c'è qualche comportamento diverso tra le prove con Python 2,7 e 3.
Con la tua modifica mi ha dato un altro errore ma non merita approfondire visto che comunque per me serve quella per la 2.7
Probabilmente è diverso anche il comportamento verso il 'return' visto che a te funzionava.
Per quanto riguarda la mia opinione non è affatto eccessiva!
Torno a ringraziarti ma non sperare che non ti chieda più qualche altro suggerimento!
Naturalmente per qualche problema sfizioso!
Non c'è mai motivo per fermarsi se non si è obbligati (*)
Ciao.

* pensa che ora sto trafficando per fare un libro (poesie e racconti... non programmazione!). Con relativi problemi tipografici, copertina ecc. E qui non ho nessun amico come te per risolvere i problemi!