Newsgroup: it.comp.lang.visual-basic
Titolo: Cancellare un'Item col tasto destro

Allora, dopo aver guardato i sorgenti dell'SC e di qualche altro sito non
riuscendo a trovare niente, pongo questa domanda: in una listbox vorrei
cancellare un'item cliccando col tasto destro e scegliendo Cancella dal menu
a scelta rapida. Fino a qua non ho problemi, ma come faccio a rimuoverlo se
non so su che Item ho cliccato? (listbox non seleziona col tasto destro)
Ho provato a simulare un clic col sinistro per selezionare l'item e poi far
andare il popupmenu, sia con sendmessage che con mouse_event, ma non riesco
a selezionare. Come si fa? Grazie

> st_985:

Considera l'evento:
    Private Sub List1_MouseUp( _
      Button As Integer _
    , Shift As Integer _
    , X As Single, Y As Single _
    )
--
Ciao.
Maurizio
--------
?SPQR(C)
 X

|
| Considera l'evento:
|
|     Private Sub List1_MouseUp( _
|       Button As Integer _
|     , Shift As Integer _
|     , X As Single, Y As Single _
|     )
|
Ho provato già con MouseDown, che mi dà gli stessi parametri,ma il problema
è sapere la riga in base al valore di y:
Private Sub List1_MouseUp( Button As Integer, Shift As Integer , X _
As Single, Y As Single )
    If Button = 2 Then
        listbox1.listindex="questo è il mio problema!"    'misurare il
numero di
'twips per riga mi sembra
'bruttino, che ne dite?
        popupmenu mnuPop
    end If
EndSub

 EndSub
Option Explicit
Private Sub List1_MouseUp( _
  Button As Integer _
, Shift As Integer _
, X As Single, Y As Single _
)
  Dim lngIndex As Long
  With List1
    Let lngIndex = .TopIndex + (Y \ TextHeight("A"))
  End With
  With Label1
    Let .Caption = List1.List(lngIndex)
    Call .Refresh
  End With
End Sub
Ovviamente supponendo che il Font del Form sia lo stesso del
ListBox...


 ListBox...
e se cosě non fosse?
Io ho risolto lo stesso problema con una chiamata ad una piccola API:
LBItemFromPt. Ecco la dichiarazione:
Declare Function LBItemFromPt Lib "comctl32" (ByVal hLB As Long, ByVal
xPoint As Long, ByVal yPoint As Long, ByVal bAutoScroll As Long) As Long
Questa restituisce l'indice dell'elemento che corrisponde ad un determinato
pixel.
Ovviamente xPoint e yPoint sono in pixel/schermo e li si puň ottenere con la
GetCursorPos:
Declare Function GetCursorPos Lib "user32" (lpPoint As POINTAPI) As Long
Spero che questa soluzione vi possa essere utile e che concordiate con me
sul fatto che sia un pochino piů "elegante".
Ciao.
--
Princi, 
princ...@programmer.net
--------------------------------------------------------------------------
"Tutti sanno che una cosa č impossibile da realizzare,
finché arriva uno sprovveduto che non lo sa e la inventa." A.E.

 Spero che questa soluzione vi possa essere utile e che
concordiate con me sul fatto che sia un pochino piů
"elegante".
Discorso difficile quello sull'eleganza. Soprattutto se ci
metti funzioni API di mezzo. Che sono quanto di meno elegante
ci sia nel mondo Visual Basic. A me sembran piuttosto toppe su
un bell'abito.


 un bell'abito.
Ovviamente su questo non siamo d'accordo, altrimenti non avrei risposto.
A parte che paragonare VB ad un bell'abito mi sembra esagerato (semmai è un
completo da lavoro), VB internamente non fa altro che chiamare le API di
Windows. Non vedo motivo di vergognarsi di fare qualche cosa che VB stesso
fa regolarmente ad ogni istruzione.
Le API sono utili in tutti i casi in cui costano meno fatica che fare lo
stesso lavoro con VB. In realtà sarebbero da chiamare anche nel caso in cui
costassero lo stesso lavoro, dato che comunque sono + veloci del codice VB
equivalente e quindi la procedura ne guadagna.
Senza contare che il codice in questione non è sicuro che sia compatibile
con le versioni successive di VB. Se infatti in VB7 implementassero la
possibilità di inserire delle immagini nei listbox, oppure di avere font
diversi per ogni item, la chiamata alla API sarebbe ancora corretta, mentre
il tuo codice no.
In questo caso mi pare proprio che l'eleganza delle API sia maggiore, ma
sono pronto al contraddittorio.
Ciao
*Roby*

 In questo caso mi pare proprio che l'eleganza delle API sia
maggiore, ma sono pronto al contraddittorio.
Vuala'. Io non me la sento di affermare ne' una cosa ne'
l'altra ne' l'altra ancora... tanto per uscire dal dualismo
d'apertura. Quando si parla di "bello", e ancor piu` di
"eleganza", io a volte mi ritiro, perche' la filosofia,
l'estetica, la sociopsicologia non sono mestier mio ne' pane
per i miei denti; a volte, se sono in vena, mi lancio in
qualche arzigolo da bar o da salotto, a seconda della suddetta
vena, e magari me la cavo con una battuta. Oggi tocca alla
battuta:
Al buio le lucciole sono piu` eleganti delle api.


 Al buio le lucciole sono piu` eleganti delle api.
Il buio della coscienza produce mostri. (Shakespeare?)
Ciao
*Roby*

| Non troppo tempo fa ho avuto modo su questo ng di dire la mia
| in proposito. Non vorrei tediare i pochi scaricanti. Se vuoi,
| in e-mail.
Me lo ricordo, era un altro thread lanciato da me, sul Goto e let, bè adesso
so almeno chi è Orwell
|
| > Altro che mucca pazza; è l'inaridimento cerebrale da eccesso
| di programmazione.
| > (Beh, visto che Pal è in ferie, qualcun altro deve pur farli
| questi discorsi)
|
| Adda torna' Baffone!..
|
| > > Discorso difficile quello sull'eleganza. Soprattutto se ci
| metti funzioni API di mezzo. Che sono quanto di meno elegante
| ci sia nel mondo Visual Basic. A me sembran piuttosto
| toppe su un bell'abito.
| > Ovviamente su questo non siamo d'accordo, altrimenti non
| avrei risposto.
| > A parte che paragonare VB ad un bell'abito mi sembra
| esagerato (semmai è un completo da lavoro),
|
| Visto il nostro mestiere... il completo da lavoro potrebbe
| essere piu` elegante di quello della domenica:)
Sinceramente, pur ringraziando Maurizio per la risposta, credo che
l'"eleganza"
maggiore l'abbia il codice di Princi. Infatti secondo me l'"eleganza" non è
altro (almeno se ne parliamo a proposito di un linguaggio di programmazione
o normale) che la capacità di svolgere quella determinata funzione (non
intendo funzione in termini informatici) con il modo più diretto (e su
questo sarebbe da dare ragiona Maurizio), ma soprattutto con la maggiore
duttilità (e qua mi dispiace ma il tuo codice ha qualche pecca).

A-ah beccato... si copia dai libri!
Seriamente, io non ho molta cultura sui libri di VB, ma scommetto quanto
volete che esiste un libro con un titolo del genere: "VB6 e l'utilità delle
API";
come su questo NG anche gli autori avranno pareri contradditori.
In quanto a chiamare API al posto delle istruzioni standard di VB, qua mi
trovo perplesso: mi va benissimo usare API quando la soluzione usando solo
VB non esiste o ha delle limitazioni, come in questo caso, ma se si esagera
usando API per inserire un'item o eliminarlo da una listbox allora penso
diminuisca anche la chiarezza del codice, sarà perchè le API mi fanno un po'
paura (le uniche che uso chiaramente sono Sleep e GetTickCount...:o))
|
| > Senza contare che il codice in questione non è sicuro che
| sia compatibile con le versioni successive di VB. Se infatti
| in VB7 implementassero la possibilità di inserire delle
| immagini nei listbox, oppure di avere font diversi per ogni
| item, la chiamata alla API sarebbe ancora corretta, mentre il
| tuo codice no.
|
| Questa tua e` un'ipotesi. E` un fatto, invece, che il "mio"
| codice, se l'avessi scritto in VB3, funzionerebbe ancora in
| VB4/16, VB4/32, VB5 e VB6, mentre l'altro avrei dovuto
| riscriverlo per VB4/32. ;-)
Non mi ci metto neanche, passiamo ad altro...
| > In questo caso mi pare proprio che l'eleganza delle API sia
| maggiore, ma sono pronto al contraddittorio.
|
| Vuala'. Io non me la sento di affermare ne' una cosa ne'
| l'altra ne' l'altra ancora... tanto per uscire dal dualismo
| d'apertura. Quando si parla di "bello", e ancor piu` di
| "eleganza", io a volte mi ritiro, perche' la filosofia,
| l'estetica, la sociopsicologia non sono mestier mio ne' pane
| per i miei denti; a volte, se sono in vena, mi lancio in
| qualche arzigolo da bar o da salotto, a seconda della suddetta
| vena, e magari me la cavo con una battuta. Oggi tocca alla
| battuta:
|
| Al buio le lucciole sono piu` eleganti delle api.
|
E con questa finisce il contradditorio...


 un bell'abito.
Bè, ne hai di ammirazione (cieca) per il VB se lo definisci un bell'abito
;-))
Programmare per Windows senza voler utilizzare le API è come correre un Gran
Premio senza voler cambiare le marce.
[quoto da un mio recente post]
...gli oggetti e i metodi del VB richiamano le API ma non sempre richiamano
quelle migliori! Se usi le API giuste al momento giusto puoi ottenere del
codice molto più semplice e compatto di quello che otterresti con i semplici
strumenti di VB. In VB "classico" si possono fare veramente tante cose (se
lo si conosce a fondo) ma a volte una chiamata alle API può dare la
soluzione giusta in un colpo solo e sostituire le inutili contorsioni di
programmazione insite nel VB.
[fine]
Il discorso sull'eleganza e sul "bel codice" sarà sempre un argomento
delicato e molto soggettivo.
Avendo lavorato come programmatore professionista cerco sempre di guardare
qualsiasi soluzione sia sotto l'aspetto puramente etico-estetico che sotto
il più immediato profilo della praticità. Una soluzione può essere più
"elegante" quando sfrutta appieno i meccanismi funzionali di un problema e
lo risolve dal suo interno senza disturbare logiche paralele od esterne.
Credo che qualunque "buon programmatore" sia affascinato da questo tipo di
soluzioni e trovi motivo di orgoglio quando riesce ad implementarle.
Spesso però (con esclusione degli hobbisti) è il tempo (=soldi) che la fa da
padrone e la praticità e velocità di realizzazione sono componenti per nulla
trascurabili: una soluzione (qualitativamente bella - o brutta - o qualunque
via di mezzo) deve fare i conti con il tempo di implementazione che è stato
necessario spendere.
Come avrai capito non sono certo un fanatico del "bel codice" a tutti i
costi, ma preferisco tenere divise le caratteristiche di eleganza da quelle
di praticità. Le singole valutazioni andranno poi pesate e concorrerano al
giudizio finale che uno può avere.
Per questo ti dico che se una soluzione è "bruttina" rimarrà sempre
"bruttina", anche se il quel determinato contesto risulta essere la
"migliore" soluzione possibile.
Aspetto il dibattito. Ciao.
--
Princi, 
princ...@programmer.net
--------------------------------------------------------------------------
"Tutti sanno che una cosa è impossibile da realizzare,


| > Al buio le lucciole sono piu` eleganti delle api.
| Il buio della coscienza produce mostri. (Shakespeare?)
Attenti a non scambiare lucciole per lanterne...
Comunque non credo che se continuaste il dialogo sul NG dareste fastidio a
qualcuno, non mi sembra troppo OT, anzi e mi piacerebbe vedere chi vince...
Ciao e grazie a tutti e due!

 anzi e mi piacerebbe vedere chi vince...
Non vorrei che diventasse una competizione, si tratta solo di chiacchiere da
bar tra programmatori.
Se non si vince e non si perde,  a cambiare idea non si fa brutta figura.
8-)
Ciao
*Roby*

 In quanto a chiamare API al posto delle istruzioni standard
di VB, qua mi trovo perplesso: mi va benissimo usare API
quando la soluzione usando solo VB non esiste o ha delle
limitazioni, come in questo caso, ma se si esagera usando API
per inserire un'item o eliminarlo da una listbox allora penso
diminuisca anche la chiarezza del codice, sarà perchè le API
mi fanno un po' paura (le uniche che uso chiaramente sono
Sleep e GetTickCount...:o)) [...]
Vedi un altro mio post nel thread.


 Bè, ne hai di ammirazione (cieca) per il VB se lo definisci
un bell'abito ;-))
In effetti la parola "bello" relativa ad "abito" mi era
sfuggita nella foga del discorso. Non intendevo qualificare VB
ma accentuare il contrasto abito/abito con toppe.
Riservo la mia ammirazione cieca per cose di tutt'altro
genere, mentre nelle cose di informatica ha sempre ammirazioni
con gli occhi il piu` possibile aperti... 8-)) E VB l'ammiro,
perche' no, per quello che ha di ammirabile: ritengo che le
sue virtu` siano piu` sociologiche che tecniche.

"Bello", "brutto" e "elegante" sono termini che usiamo
impropriamente a proposito del codice. Ritengo sia legittimo
usarli, invece, parlando degli effetti dell'esecuzione di tale
codice: l'applicazione.
Fatta questa premessa continuo anche io, come penso tutti, ad
usare tali termini a proposito del codice. Nella nostra
"comunita`" assumono un senso particolare e sarebbe ormai
difficile prescinderne. A condizione che si sia consapevoli
della specificita` dell'uso.
A parte quel "quid", quella particolare "vibrazione" che ha, e
che procura a chi e` in grado di coglierla, un codice "bello"
o "elegante", sconfinando nella poesia, anche aiutato
dall'analogia grafica delle righe a bandiera, ritengo che,
generalmente, la "bellezza" di esso codice sia relativa e non
assoluta.
Una parola chiave e` "compromesso". Un'altra e` "limite",
"finitezza". E in questo senso solo riesco a ragionare.
Mi sembra ovvio e scontato che c'e` un limite all'uso delle
chiamate all'API in VB oltre il quale ci si deve interrogare
sul perche' si sia scelto VB per lo sviluppo. Questo limite e`
oggettivo e soggettivo insieme.
Tralasciando per comodita` di discorso le altre possibilita`,
c'e` chi arriva a VB dal C, chi da altri dialetti BASIC e chi
dal "buio informatico":
"Al buio le lucciole sono piu` eleganti delle api."
dicevo... E forse adesso il senso e` piu` chiaro ;-)
Probabilmente anche dopo n anni i listati di questi tre
soggetti saranno riconoscibili.
Insomma. Non c'e` una ricetta. Come non credo sia possibile
scrivere un "Thinking in Visual Basic" (e mi auguro nessuno
l'abbia gia` fatto) perche' questo "nostro" linguaggio non ha
una *sua* anima ma e` piuttosto un contenitore ed una risposta
a numerose istanze.


 Propongo di spostare l'oggetto della questione da "le API
sono belle ed eleganti" a "Le API sono funzionali". Così
abbiamo ancora qualche margine di manovra.
Non essere ansioso. Ci stiamo arrivando. ;-)))


 Non essere ansioso. Ci stiamo arrivando. ;-)))
Ok, ma ti do tempo ancora solo pochi messaggi. 8-)
Ciao
*Roby*

 a numerose istanze.
E bravo Maurizio! A questo nessuno credo possa avere (o non avere?) la
coscienza di obbiettare.
Ed io lo interpreto proprio così! (Non ti facevo tanto filosofo ;-) )
Ciao.
--
Princi, 
princ...@programmer.net


 Il buio della coscienza produce mostri. (Shakespeare?)
forse
il sonno della ragione genera mostri
(una specie di esergo dei disastri della guerra di goya) ?

 Ok, ma ti do tempo ancora solo pochi messaggi. 8-)
(-: Ho meditato a lungo :-) ... soprattutto sulla parola
"funzionale". Facendo la media delle accezioni, ebbene si`,
usare in Visual Basic chiamate alle funzioni dell'API e`
funzionale.


 funzionale.
Bravo Maurizio,
adesso anche tu fai parte della grande famiglia dei programmatori VB
"sporchi" e "cattivi" :-)))
(si potrà dire una cosa così superficiale, per nulla ragionata e nella quale
non credo nemmeno un pochino, in risposta ad un mentore che ha riflettuto
ben 16 - dico sedici - giorni prima di rispondere? me ne sono già pentito ma
invio ugualmente!)
Ciao.
--
Princi, 
princ...@programmer.net
--------------------------------------------------------------------------
