.Net

AcceptButton e Textbox Multiline

Francesco Geri — Mon, 22 Feb 2010 10:27:24 GMT

Se si ha progetta una Windows Form con pulsante OK e Annulla è sempre bene impostare le proprietà AcceptButton sul pulsante OK e CancelButton sul pulsante Annulla.
In questo modo l'utente può premere Invio per l'OK ed Esc per l'annulla.
Se però nella Form dovete inserire una TextBox Multiline allora c'è un problema: se la textbox ha il focus e premete invio invece che ottenere una nuova linea nella textbox otterrete il click sul pulsante di OK, ovvero vince l'AcceptButton.
Per ottenere il comportamento desiderato, ovvero che se premo Reutn mentre sto digitando nella textbox voglio la nuova linea, mentre se sono sugli altri controlli voglio la pressione di OK, allora basta impostare la proprità AcceptReturn a True per la textbox.

UpdatePanel e focus delle Textbox

Francesco Geri — Fri, 12 Dec 2008 14:30:11 GMT

Inserendo una Textbox in un UpdatePanel (AJAX) può succedere (o succede sempre?) che la textbox perda il focus, o non lo possa prendere affatto.

Un modo per ovviare alla cosa è di registrare uno script che imposti il focus con un piccolo ritardo rispetto alla load:

   1: Dim script As String = "setTimeout(""$('" & MyTextBox.ClientID & "').focus(); "", 100);"

   2: ScriptManager.RegisterStartupScript(updSearch, GetType(String), "set_focus_script", script, True)

Come verificare se un punto è visibile nello schermo

Francesco Geri — Thu, 04 Dec 2008 00:23:28 GMT

Il post mostra un semplice tip per vedere se un punto è visibile nello schermo (anche in presenza di più schermi).

La grafica dell'esempio è "mozzafiato":

Il codice è invece il seguente:

   1: Public Class Form1

2:

   3:     Private Sub Button1_Click(ByVal sender As System.Object, _

   4:                 ByVal e As System.EventArgs) Handles Button1.Click

   5:         Me.TxtEsito.Text = "..."

   6:         Dim p As Point

   7:         Try

   8:             Me.Cursor = Cursors.WaitCursor

   9:             Threading.Thread.Sleep(120)

  10:             p = New Point(Me.TxtX.Text, Me.TxtY.Text)

  11:             Dim s As Screen = Screen.FromPoint(p)

  12:             If s Is Nothing Then

  13:                 Me.TxtEsito.Text = "non nello schermo"

  14:             Else

  15:                 Me.TxtEsito.Text = "Schermo '" & s.DeviceName & "'"

  16:                 ' Verifica se il punto è contenuto

  17:                 If s.WorkingArea.Contains(p) Then

  18:                     Me.TxtEsito.Text &= ": il punto è contenuto!"

  19:                 Else

  20:                     Me.TxtEsito.Text &= ": il punto NON è contenuto!"

  21:                 End If

  22:             End If

  23:         Catch ex As Exception

  24:             Me.TxtEsito.Text = ex.Message

  25:         Finally

  26:             Me.Cursor = Cursors.Default

  27:         End Try

  28:     End Sub

29:

30:

  31: End Class

In pratica è sufficiente determinare lo schermo che "dovrebbe" mostrare il punto che ci interessa:

Dim s As Screen = Screen.FromPoint(p)

Ho scritto "dovrebbe" in quanto, se nessuno schermo contiene quel punto allora il metodo restituisce lo schermo più "vicino" al punto.

A questo punto, per essere sicuri che il punto sia contenuto nell'area visibile dello schermo, basta eseguire la seguente chiamata:

If s.WorkingArea.Contains(p) Then

Mouse Wheel in un Panel con Controlli non Focusable (2)

Francesco Geri — Fri, 24 Oct 2008 00:57:44 GMT

Riprendo un mio precedente post su come ottenere lo scroll con il mouse wheel su un controllo che non possa avere il focus.

La soluzione suggerita aveva dei problemi, ed in particolare non gestiva bene il caso in cui il controllo si trovasse all'interno di una form di tipo mdichild, da cui si poteva aprire una form modale.... Ok, non vado avanti nei particolari, ma dico semplicemente che aveva dei problemi.

Per cui qui suggerisco un'altra soluzione, che mi sembra funzionare correttamente e che ho trovato googlando a partire dalla prima.

   1: Public Class MyForm

   2:   Inherits System.Windows.Forms.Form

   3:   Implements IClassWithLanguage, IMessageFilter

4:

   5:   Public Function PreFilterMessage(ByRef m As Message) As Boolean Implements IMessageFilter.PreFilterMessage

   6:     Try

   7:         If (m.Msg = &H20A) Then

   8:             ' WM_MOUSEWHEEL, find the control at screen position m.LParam

   9:             Dim pos As Point = New Point(m.LParam.ToInt32() And &HFFFF, m.LParam.ToInt32() >> 16)

  10:             Dim hWnd As IntPtr = WindowFromPoint(pos)

  11:             If (hWnd <> IntPtr.Zero AndAlso hWnd <> m.HWnd AndAlso Not Control.FromHandle(hWnd) Is Nothing) Then

  12:                 SendMessage(hWnd, m.Msg, m.WParam, m.LParam)

  13:                 Return True

  14:             End If

  15:         End If

  16:         Return False

  17:     Catch ex As Exception

  18:         ' Trascura l'eccezione

  19:     End Try

  20:   End Function

21:

  22:   ' P/Invoke declarations

  23:   <DllImport("user32.dll")> _

  24:   Private Shared Function WindowFromPoint(ByVal pt As Point) As Int32

  25:   End Function

  26:   <DllImport("User32.dll")> _

  27:   Private Shared Function SendMessage(ByVal hWnd As Integer, ByVal Msg As Integer, ByVal wParam As Integer, ByVal lParam As Integer) As Int32

  28:   End Function

Personalizzare il template dei commenti in Visual Studio (per VB.NET)

Francesco Geri — Sun, 19 Oct 2008 17:04:01 GMT

Come tutti sanno in Visual Studio 2005 si può creare la documentazione automatica del proprio codice semplicemente scrivendo i commenti con il triplice apice (''').

Di default, se si scrivono i tre apici davanti ad un metodo o a quello che volete, automaticamente Visual Studio completa con qualcosa del tipo:

   1: ''' <summary>

   2: '''

   3: ''' </summary>

   4: ''' <remarks></remarks>

Io non faccio molto uso di del tag remarks, per cui mi da un po' noia il fatto che ci sia.

Beh, ovviamente, si può personalizzare il template dei commenti e decidere, ad esempio, di non autogenerae il tag remarks o qualunque altra cosa.

Per otterene la personalizzazione bisogna individuare la cartella \Documents and Settings\<user-name>\Application Data\Microsoft\VisualStudio\8.0 (o l'analoga in Vista \Users\<user-name>\AppData\Roaming\Microsoft\VisualStudio\8.0), creare un file di nome VBXMLDoc.xml con il template che desiderate.

Quello di default, che quindi ciascuno può modificare a piacere, è il seguente:

   1: <?xml version="1.0" encoding="utf-8" ?>

   2: <XMLDocCommentSchema>

3:

   4:     <CodeElement type="Module">

   5:         <Template>

   6:             <summary/>

   7:             <remarks/>

   8:         </Template>

   9:         <CompletionList>

  10:             <include file="" path=""/>

  11:             <permission cref=""/>

  12:             <remarks/>

  13:             <summary/>

  14:         </CompletionList>

  15:     </CodeElement>

16:

  17:     <CodeElement type="Class">

  18:         <Template>

  19:             <summary/>

  20:             <remarks/>

  21:         </Template>

  22:         <CompletionList>

  23:             <include file="" path=""/>

  24:             <permission cref=""/>

  25:             <remarks/>

  26:             <summary/>

  27:         </CompletionList>

  28:     </CodeElement>

29:

  30:     <CodeElement type="Structure">

  31:         <Template>

  32:             <summary/>

  33:             <remarks/>

  34:         </Template>

  35:         <CompletionList>

  36:             <include file="" path=""/>

  37:             <permission cref=""/>

  38:             <remarks/>

  39:             <summary/>

  40:         </CompletionList>

  41:     </CodeElement>

42:

  43:     <CodeElement type="Interface">

  44:         <Template>

  45:             <summary/>

  46:             <remarks/>

  47:         </Template>

  48:         <CompletionList>

  49:             <include file="" path=""/>

  50:             <permission cref=""/>

  51:             <remarks/>

  52:             <summary/>

  53:         </CompletionList>

  54:     </CodeElement>

55:

  56:     <CodeElement type="Enum">

  57:         <Template>

  58:             <summary/>

  59:             <remarks/>

  60:         </Template>

  61:         <CompletionList>

  62:             <include file="" path=""/>

  63:             <permission cref=""/>

  64:             <remarks/>

  65:             <summary/>

  66:         </CompletionList>

  67:     </CodeElement>

68:

  69:     <CodeElement type="Property">

  70:         <Template>

  71:             <summary/>

  72:             <param/>

  73:             <value/>

  74:             <remarks/>

  75:         </Template>

  76:         <CompletionList>

  77:             <exception cref=""/>

  78:             <include file="" path=""/>

  79:             <param name=""/>

  80:             <permission cref=""/>

  81:             <remarks/>

  82:             <summary/>

  83:             <value/>

  84:          </CompletionList>

  85:     </CodeElement>

86:

  87:     <CodeElement type="Sub">

  88:         <Template>

  89:             <summary/>

  90:             <param/>

  91:             <remarks/>

  92:         </Template>

  93:         <CompletionList>

  94:             <exception cref=""/>

  95:             <include file="" path=""/>

  96:             <param name=""/>

  97:             <permission cref=""/>

  98:             <remarks/>

  99:             <summary/>

 100:         </CompletionList>

 101:     </CodeElement>

 102:

 103:     <CodeElement type="Function">

 104:         <Template>

 105:             <summary/>

 106:             <param/>

 107:             <returns/>

 108:         </Template>

 109:         <CompletionList>

 110:             <exception cref=""/>

 111:             <include file="" path=""/>

 112:             <param name=""/>

 113:             <permission cref=""/>

 114:             <remarks/>

 115:             <returns/>

 116:             <summary/>

 117:         </CompletionList>

 118:     </CodeElement>

 119:

 120:     <CodeElement type="Operator">

 121:         <Template>

 122:             <summary/>

 123:             <param/>

 124:             <returns/>

 125:             <remarks/>

 126:         </Template>

 127:         <CompletionList>

 128:             <exception cref=""/>

 129:             <include file="" path=""/>

 130:             <param name=""/>

 131:             <permission cref=""/>

 132:             <remarks/>

 133:             <returns/>

 134:             <summary/>

 135:         </CompletionList>

 136:     </CodeElement>

 137:

 138:     <CodeElement type="Declare">

 139:         <Template>

 140:             <summary/>

 141:             <param/>

 142:             <returns/>

 143:             <remarks/>

 144:         </Template>

 145:         <CompletionList>

 146:             <exception cref=""/>

 147:             <include file="" path=""/>

 148:             <param name=""/>

 149:             <permission cref=""/>

 150:             <remarks/>

 151:             <returns/>

 152:             <summary/>

 153:         </CompletionList>

 154:     </CodeElement>

 155:

 156:     <CodeElement type="Field">

 157:         <Template>

 158:             <summary/>

 159:             <remarks/>

 160:         </Template>

 161:         <CompletionList>

 162:             <include file="" path=""/>

 163:             <permission cref=""/>

 164:             <remarks/>

 165:             <summary/>

 166:         </CompletionList>

 167:     </CodeElement>

 168:

 169:     <CodeElement type="Delegate">

 170:         <Template>

 171:             <summary/>

 172:             <param/>

 173:             <returns/>

 174:             <remarks/>

 175:         </Template>

 176:         <CompletionList>

 177:             <include file="" path=""/>

 178:             <param name=""/>

 179:             <permission cref=""/>

 180:             <remarks/>

 181:             <returns/>

 182:             <summary/>

 183:         </CompletionList>

 184:     </CodeElement>

 185:

 186:     <CodeElement type="Event">

 187:         <Template>

 188:             <summary/>

 189:             <param/>

 190:             <remarks/>

 191:         </Template>

 192:         <CompletionList>

 193:             <include file="" path=""/>

 194:             <param name=""/>

 195:             <permission cref=""/>

 196:             <remarks/>

 197:             <summary/>

 198:         </CompletionList>

 199:     </CodeElement>

 200:

 201:     <ChildCompletionList>

 202:         <c/>

 203:         <code/>

 204:         <example/>

 205:         <list type="">

 206:             <listheader>

 207:                 <term/>

 208:                 <description/>

 209:             </listheader>

 210:         </list>

 211:         <para/>

 212:         <paramref name=""/>

 213:         <see cref=""/>

 214:         <seealso cref=""/>

 215:     </ChildCompletionList>

 216:

 217: </XMLDocCommentSchema>

[Vedi fonte]

Errore LoaderLock was detected in Visual Studio 2005

Francesco Geri — Wed, 24 Sep 2008 20:40:54 GMT

Ho un progetto in Visual Studio 2005 che fa uso di una DLL esterna che, in DEBUG, mi genera il seguente errore:

LoaderLock was detected
Message: DLL 'C:\Windows\assembly\GAC\dllEsterna\4.0.22.1__80d669b8b606a2da\dllEsterna.dll' is attempting managed execution inside OS Loader lock. Do not attempt to run managed code inside a DllMain or image initialization function since doing so can cause the application to hang.

L'errore interrompe il debug e mi costringe a fare un po' di click di "OK" o "Continua" prima di poter andare avanti.

La cosa non è piacevole e rallenta il debug.

Per evitare il problema (non risolverlo... per quello dovrei sentire il produtto della dllEsterna) si può fare come segue:

Da Visual Studio andare sul menu "Debug", poi "Exceptions" per aprire la finestra seguente:
Espandere "Managed Debugging Assistants"
Individuare la voce (checkbox) "LoaderLock" che sarà spuntato e togliere la spunta!

Mouse Wheel in un Panel con Controlli non Focusable

Francesco Geri — Sun, 14 Sep 2008 20:20:41 GMT

Se si ha un pannello con "Autoscroll=True" lo si può sfruttare per fare lo scroll con la rotella del mouse.

Tuttavia se il pannello contiene solo controlli non Focusable (...che non possono avere il Focus) allora l'autoscroll al mousewhell non funziona.

Per questo segnalo un interessante post in cui si spiega come risolvere il problema.

Disegnare con GDI+: gestire lo zoom

Francesco Geri — Wed, 10 Sep 2008 22:23:33 GMT

Riprendo un mio post precedente in cui disegnavo un rettangolo con gli angoli arrotondati per aggiungere un paio di cosette.
....

Stranezze delle ComboBox: impostare il ToUpper di un suo elemento

Francesco Geri — Sun, 07 Sep 2008 19:48:38 GMT

Oggi mi sono imbattuto in quella che a me pare una stranezza.

Ho una windows form con una ComboBox in stile DropDownList, definita ad esempio nel modo seguente:

    1 Me.ComboBox1.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList
    2 Me.ComboBox1.FormattingEnabled = True
    3 Me.ComboBox1.Items.AddRange(New Object() {"valore 1", "valore 2", "valore 3"})
    4 Me.ComboBox1.Location = New System.Drawing.Point(43, 34)
    5 Me.ComboBox1.Name = "ComboBox1"
    6 Me.ComboBox1.Size = New System.Drawing.Size(149, 21)
    7 Me.ComboBox1.TabIndex = 0

Vorrei modificare un suo item, impostando l'uppercase del valore. Il problema è che se si assegna a ComboBox1.Items(index) un valore che differisce da quello corrente solo per il case dei caratteri allora l'operazione non ha effetti (se non quello di generare un evento di SelectedIndexChanged)...

Per provare aggiungo un pulsante nella mia form:

E scrivo il seguente codice (senza l'istruzione alla riga 7 non funzionerebbe!):

1 Public Class Form1

    2 
    3   Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
    4     If Me.ComboBox1.SelectedIndex < 0 Then Return
    5     Dim v As String = Me.ComboBox1.Items(Me.ComboBox1.SelectedIndex)
    6     ' Aggiunge un carattere fittizio per forzare la modifica
    7     Me.ComboBox1.Items(Me.ComboBox1.SelectedIndex) = "~" & v.ToUpper
    8     ' Esegue la modifica desiderata
    9     Me.ComboBox1.Items(Me.ComboBox1.SelectedIndex) = v.ToUpper
   10   End Sub
   11 
   12 End Class

Disegnare un rettangolo con angoli arrotondati in VB.NET (GDI+)

Francesco Geri — Tue, 02 Sep 2008 17:48:59 GMT

Di seguito una funzione che consente di disegnare un rettangolo con angoli arrotondati, sfruttando la GDI+ in VB.NET.

    1 ''' <summary>
    2 ''' Disegna un rettangolo con i bordi arrotondati
    3 ''' </summary>
    4 ''' <param name="g">Oggetto Graphics per il disegno</param>
    5 ''' <param name="pen">Oggetto <see cref="Pen"></see> con cui
    6 ''' disegnare il rettangolo</param>
    7 ''' <param name="roundedRectangle">Rettangolo da disegnare</param>
    8 ''' <param name="cornerSize">Dimensioni dell'angolo arrotondato</param>
    9 Public Shared Sub DrawRoundedRectangle(ByVal g As Graphics, ByVal pen As Pen, _
   10 ByVal roundedRectangle As Rectangle, ByVal cornerSize As Size)
   11   Dim points(7) As Point
   12   Dim rX As Single = roundedRectangle.Location.X
   13   Dim rY As Single = roundedRectangle.Location.Y
   14   Dim rW As Single = roundedRectangle.Width
   15   Dim rH As Single = roundedRectangle.Height
   16   Dim cW As Single = cornerSize.Width
   17   Dim cH As Single = cornerSize.Height
   18 
   19   ' Prepara i punti per le linee
   20   points(0) = New Point(rX + cW / 2, rY)
   21   points(1) = New Point(rX + rW - cW / 2, rY)
   22   points(2) = New Point(rX + rW, rY + cH / 2)
   23   points(3) = New Point(rX + rW, rY + rH - cH / 2)
   24   points(4) = New Point(rX + rW - cW / 2, rY + rH)
   25   points(5) = New Point(rX + cW / 2, rY + rH)
   26   points(6) = New Point(rX, rY + rH - cH / 2)
   27   points(7) = New Point(rX, rY + cH / 2)
   28 
   29   Dim rectPath As New GraphicsPath()
   30   rectPath.StartFigure()
   31   rectPath.AddLine(points(0), points(1))
   32   rectPath.AddArc(rX + rW - cW, rY, cW, cH, CType(270, Single), CType(90, Single))
   33   rectPath.AddLine(points(2), points(3))
   34   rectPath.AddArc(rX + rW - cW, rY + rH - cH, cW, cH, CType(0, Single), CType(90, Single))
   35   rectPath.AddLine(points(4), points(5))
   36   rectPath.AddArc(rX, rY + rH - cH, cW, cH, CType(90, Single), CType(90, Single))
   37   rectPath.AddLine(points(6), points(7))
   38   rectPath.AddArc(rX, rY, cW, cH, CType(180, Single), CType(90, Single))
   39   rectPath.CloseFigure()
   40 
   41   g.DrawPath(pen, rectPath)
   42 
   43 End Sub

... e questo è un esempio di cosa si ottiene: