topic Re: VB.Net Restricting TextBox to Positive Long or Double in ArcObjects SDK Questions

VB.Net Restricting TextBox to Positive Long or Double

RichardFairhurst — Sat, 11 Dec 2021 19:00:09 GMT

I have been searching the internet for ideas on how to restrict a VB.Net System.Windows.Forms.TextBox control to only accept positive Long or positive Double numeric values. I think I have come up with a good control set up, primarily based on this post on msdn. The code within the KeyPress and Leave events below is generic and can be pasted into any Textbox KeyPress and Leave events to produce the behaviors described below. I am posting this in case it helps others and also to see if anyone has a more elegant way of doing this.

For this example, the behavior criteria of my Long Textbox are as follows:

1. When the user finishes editing in the Textbox the value of the Textbox must be a Long interger that is positive and greater than or equal to 1 (in this example the Textbox represents an annual average daily trip count which cannot be negative and which is used as a divisor in an equation, so at least 1 annual average daily trip must occur on the road for a valid analysis).

2. From the keyboard the user must only be able to type numbers.

3. The user may paste text into the Textbox. This introduces the possibility for insertion of negative numbers, floating values, and invalid entries which must be resolved in the following ways:
a. If a negative number is pasted into the Textbox, it must be reset to its absolute value.
b. If a floating number is pasted into the Textbox, it must be rounded to a whole interger.
c. If the user pastes invalid text into the Textbox and does not correct an invalid entry prior to leaving the Textbox, the user will be permitted to exit the textbox, but the invalid value will be replaced by the minimum default value (in this case 1).

4. If a user attempts to leave the Textbox with a blank entry or an entry of 0, the user is permitted to leave but the textbox will be completed using the minimum default value (in this case 1).

5. Numbers must always be corrected to a conventional format when the user leaves the Textbox. In other words, a user may enter a value of 023 into the Textbox, but when he exits the Textbox it must appear as 23.

Here is the code that implements this behavior. The Textbox in this specific example is named txtAADT; however, the code written within the KeyPress and Leave Subs is generic and can be pasted into these two events for any other Textbox to implement the same behavior.

Imports System.Math

  Private Sub txtAADT_KeyPress(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyPressEventArgs) Handles txtAADT.KeyPress
    # If the keystroke is not a numeric digit, the keystroke will be disregarded.  Code works for any Textbox KeyPress event.
    If Not (Char.IsDigit(e.KeyChar) Or Char.IsControl(e.KeyChar)) Then
      e.Handled = True
    End If
  End Sub

  Private Sub txtAADT_Leave(ByVal sender As Object, ByVal e As System.EventArgs) Handles txtAADT.Leave
    # User has completed their entry and is leaving the Textbox.

    # Create a Textbox variable to make the code below generic so that it can be pasted into any Textbox Leave event
    Dim tbx As System.Windows.Forms.TextBox = sender

    Dim value As Double
    If Not Double.TryParse(tbx.Text, value) Then
      # The user did not correct an invalid entry so replace it with 1
      tbx.Text = 1
    ElseIf value < -1 Then
      # The user pasted a negative value, so make sure it is rounded and take its absolute value
      tbx.Text = Abs(CLng(value))
    ElseIf value < 1 Then
      # The user has entered 0 or pasted in a value between -1 and 1, so replace with minimum value of 1
      tbx.Text = 1
    ElseIf value = vbNull Then
      # The user has blanked out the Textbox, so fill in the Textbox with the minimum value of 1
      tbx.Text = 1
    Else
      # The user has entered a valid postive number, so make sure it is rounded and appears as a conventional number
      tbx.Text = CLng(value)
    End If
  End Sub

The positive Double Textbox has similar requirements to the positive Long Textbox, but it allows an optional single decimal point to be inserted to create non-integer values. (The code is not designed at this time to respond to local Cultural settings for the decimal character, so that would be a nice enhancement if anyone cares to suggest the code required to do that.) The following additional or different behaviors are implement with the positive Double Textbox:

1. When the user finishes editing in the Textbox the value of the Textbox must be a Double value that is positive and greater than or equal to 0 (in this example the Textbox represents a Distance of offset from an intersection which cannot be negative, but which may be 0 where no offset is desired).

2. From the keyboard the user must only be able to type numbers and at most one decimal character.

3. The user may paste text into the Textbox. This introduces the possibility for insertion of negative numbers and invalid entries which must be resolved in the following ways:
a. If a negative number is pasted into the Textbox, it must be reset to its absolute value.
b. If the user pastes invalid text into the Textbox and does not correct an invalid entry prior to leaving the Textbox, the user will be permitted to exit the textbox, but the invalid value will be replaced by the minimum default value (in this case 0).

4. If a user attempts to leave the Textbox with a blank entry, the user is permitted to leave but the textbox will be completed using the minimum default value (in this case 0).

5 A maximum of 4 fractional digits are permitted. Any fractional digits beyond that must be rounded. (This is due to the maximum resolution of the data)

6. Numbers must always be corrected to a conventional format when the user leaves the Textbox. In other words, a user may enter a value of 023.123456 into the Textbox, but when he exits the Textbox it must appear as 23.1235.

Here is the code for the positive Double Textbox. The Textbox in this specific example is named txtDistance1; however, the code written within the KeyPress and Leave Subs is generic and can be pasted into these two events for any other Textbox to implement the same behavior.

Imports System.Math

  Private Sub txtDistance1_KeyPress(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyPressEventArgs) Handles txtDistance1.KeyPress
    # Create a Textbox variable so that the code within this KeyPress event is generic for all positive Double Textboxes.
    Dim tbx As System.Windows.Forms.TextBox = sender
    If Not (Char.IsDigit(e.KeyChar) Or Char.IsControl(e.KeyChar) Or (e.KeyChar = "." And tbx.Text.IndexOf(".") < 0) Or (e.KeyChar = "." And tbx.Text.IndexOf(".") >= 0 And tbx.SelectionLength > 0 And tbx.SelectionStart <= tbx.Text.IndexOf(".") And tbx.SelectionStart + tbx.SelectionLength > tbx.Text.IndexOf("."))) Then
    # Explanation: Prevent the keystroke if it is not a numeric digit, a non-printable character such as a Backspace, or a decimal point where no decimal point exists in the Textbox or where the existing decimal point is contained in a text selection that will be overwritten by the new decimal point.
      e.Handled = True
    End If
  End Sub

  Private Sub txtDistance1_Leave(ByVal sender As Object, ByVal e As System.EventArgs) Handles txtDistance1.Leave
    # User has completed their entry and is leaving the Textbox

    # Create a Textbox variable so that the code below is generic and can be pasted into any Textbox Leave event
    Dim tbx As System.Windows.Forms.TextBox = sender
    Dim value As Double
    If Not Double.TryParse(tbx.Text, value) Then
      # Textbox value is invalid, so replace it with the minimum default value (in this case 0)
      tbx.Text = 0
    ElseIf value = vbNull Then
      # The user has blanked out the Textbox, so fill in the Textbox with the minimum value of 0
      tbx.Text = 0
    ElseIf value >= 0 Then
      # value is positive so round to 4 decimal places and correct to conventional format
      tbx.Text = Round(value, 4)
    Else
      # value is negative so round to 4 decimal places, apply the absolute value and correct to conventional format
      tbx.Text = Abs(Round(value, 4))
    End If
  End Sub

Again, I hope this helps.

Re: VB.Net Restricting TextBox to Positive Long or Double

LeoDonahue — Wed, 29 Aug 2012 02:13:42 GMT

What if the user pastes in a hex or unicode escape sequence for a number? Something like 0x0039 or 9 (hilarious, the unicode I pasted in here was converted to the numeric value of 9, which is what I tried pasting in as unicode...)
http://msdn.microsoft.com/en-us/library/aa664669(v=vs.71).aspx

Also, rather than trap for correct input and settle for defaults, you can test the values of the text boxes for numeric and prompt the user for correct input.

Your code is only checking for "leave" events, which you hope the user enters a value and leaves that text box. What if the user enters junk into a text box and doesn't do anything to trigger the leave event before they submit?

Did you find this example? http://msdn.microsoft.com/en-us/library/ms229644(v=vs.80).aspx#Y0

Re: VB.Net Restricting TextBox to Positive Long or Double

RichardFairhurst — Wed, 29 Aug 2012 02:55:43 GMT

What if the user pastes in a hex or unicode escape sequence for a number? Something like 0x0039 or 9
http://msdn.microsoft.com/en-us/library/aa664669(v=vs.71).aspx

Also, rather than trap for correct input and settle for defaults, you can test the values of the text boxes for numeric and prompt the user for correct input.

Your code is only checking for "leave" events, which you hope the user enters a value and leaves that text box. What if the user enters junk into a text box and doesn't do anything to trigger the leave event before they submit?

Did you find this example? http://msdn.microsoft.com/en-us/library/ms229644(v=vs.80).aspx#Y0

I hate the approach of locking a user into a field. I won't do it for myself or them. I don't ever want a prompt. So that is not the way I will design my interface. The pasting example may be a worry to programmers that work in the public shpere, but I only work for in house Engineers, who don't even know that hex codes or escape codes exist. So far I have been unable to submit anything without leaving the dialog except by closing the dialog without posting, which I want to allow. Anyway, I have my preferences and if they don't work for others, that is fine. This is working the way I described and the way I want.

Anyway, I did not see the help you pointed to and it probably does help to make improvements over my code. I searched for 3 hours on msdn and never hit on the search terms that brought that back. Search systems are a failure more and more everywhere (especially microsoft's).

Edit:

Something seems to be missing from the example. I got it to compile and it allows the keystrokes it says it will. However, I cannot use an InputPanel in an Add-In form and there is no obvious indentification of where to implement the IntValue or DecimalValue to correct the user's input. It lets the user put in multiple decimal points and negative signs, which I have prevented. With the keyboard a user cannot enter junk in my Textbox or an invalid base 10 number, but a user can in this example. Only pasting creates junk in my Textbox, which is a rare occurance for my particular users. Based on the entries I can type in I would expect errors to arise from the IntValue and DecimalValue properties if I did access them. Again, I understand that for programmers in the public sphere more possibilities need to be handled, but they simply are not worth an hour of my time for my users.

Edit 2:

I see the potential of the leave event not being fired. Triggering that code in the Submit method is one of the options. If you know of a better event that must fire before a user can execute a command button I would like to know about it. It seems you are suggesting to validate it in the command button itself, which I can do to clean up junk. There is no right way to do this (which is the key reason I love the Python script tool interface. This stuff is built in with one click and it just works without me coding anything. Unfortunately the script tool is slow to load and execute when too much code gets added, which is why I am fighting my frustrations and building it in VB.Net.)

Re: VB.Net Restricting TextBox to Positive Long or Double

LeoDonahue — Wed, 29 Aug 2012 03:10:12 GMT

I wasn't thinking about locking a user into a text box before they can move on, rather, a label next to the text box indicating the value entered is invalid.

What happens if your user enters more than one decimal point? Such as: .........

Yes, searches only help if you have the right keywords. I googled: msdn restrict textbox to numbers. First link.

Re: VB.Net Restricting TextBox to Positive Long or Double

RichardFairhurst — Wed, 29 Aug 2012 04:59:07 GMT

I wasn't thinking about locking a user into a text box before they can move on, rather, a label next to the text box indicating the value entered is invalid.

What happens if your user enters more than one decimal point? Such as: .........

Yes, searches only help if you have the right keywords. I googled: msdn restrict textbox to numbers. First link.

Run my code. Entering more than 1 decimal point in the Double Textbox is impossible with the keyboard. The only way to cause this problem is with pasting (which is not the data entry method users of my form will normally use).

If the user insisted on pasting in such a value the code would replace it with the default value if a user insists on exiting the textbox before correcting that entry. A more likely problem would be that they meant to paste over a decimal and instead pasted before or after it and thereby entered two decimal points without realizing it. When they left the Textbox such an entry would be replaced by the default value. I see the point of using a label to notify them about such replacements, but I generally would not let faulty input go uncorrected hoping the user would go back and correct it before pressing the execute button.

The alternative would be to disable the execute button until all entries were valid and use labels to highlight errors. I assume that is the approach you are recommending. I thought I had seen some kind of Validator class that could add error symbols and messages directly to controls (rather than having to generate my own labels all over the form), but I may be misremembering and mixing languages and interfaces. I will try searching for it (wish me luck).

Speaking of funky searches, I had that problem with the Python website too. I was trying to find a Python based method for closing a Windows program. Nowhere was the word "close" associated with that action and I never got any hits in my search. Later another user pointed out that the Python term you need to use for closing a Window was "Kill". But if you search "python kill" you get a lot of articles about deaths in the Amazon and not much on the python language. Sigh.

Re: VB.Net Restricting TextBox to Positive Long or Double

KenBuja — Sat, 11 Dec 2021 19:00:11 GMT

Here's a subroutine I found that I usually put in my text box KeyPress functions when I want to restrict what's being typed in. This doesn't account for hex values, but I doubt that the users would even know what they are.

   Friend Function ValidateKey(ByVal Key As Integer, ByVal KeyMask As String) As Boolean

        'I wrote this simple general-purpose key-validating function. You might find
        'it useful. just call it like this in your keypress event:

        '    If Not ValidateKey(Asc(e.KeyChar), "mask") Then e.Handled = True

        '"mask" contains pairs of characters. The function checks that your keypress
        'falls between the ascii range of each pair. For instance if you want to
        'allow only lowercase letters just use "az". If you want only numbers and
        'decimal points use "09.." Include as many pairs as you like.
        'PURPOSE: check that a keystroke was allowed by key mask. return true/false

        'declare variable

        Dim intCharCheck As Integer = 0

        Try
            'assume invalid
            ValidateKey = False

            Do Until intCharCheck = KeyMask.Length Or ValidateKey = True

                'check if keypress falls between pair of characters in KeyMask
                If Key >= Asc(KeyMask.Chars(intCharCheck)) And Key <= Asc(KeyMask.Chars(intCharCheck + 1)) Then ValidateKey = True

                'advance to next pair in KeyMask
                intCharCheck += 2

            Loop

            'allow backspace and Enter
            If Key = System.Windows.Forms.Keys.Back Then ValidateKey = True
        Catch ex As Exception
            System.Windows.Forms.MessageBox.Show(ex.ToString, "Utilities: ValidateKey")
        End Try

    End Function

When using this with numbers, I have additional checks to make sure there's not more than one decimal place or negative sign, in addition. Here's an example for a group of textboxes that can be decimal degree or degree minutes seconds or just numbers.

    Private Sub Numeric_KeyPress(sender As Object, e As System.Windows.Forms.KeyPressEventArgs) Handles txtLatD.KeyPress, txtLatM.KeyPress, txtLatS.KeyPress, txtLonD.KeyPress, txtLonM.KeyPress, txtLonS.KeyPress, txtLatDD.KeyPress, txtLonDD.KeyPress, txtDistance.KeyPress

        Dim Mask As String

        Select Case sender.name
            Case "txtLatD", "txtLonD"
                Mask = "09--"
            Case "txtLatDD", "txtLonDD"
                Mask = "09--.."
            Case Else
                Mask = "09.."
        End Select

        If Not ValidateKey(Asc(e.KeyChar), Mask) Then e.Handled = True
        If Asc(e.KeyChar) = 46 Then 'test for existing decimal point
            If InStr(sender.text, ".") > 0 Then e.Handled = True
        End If
        If Asc(e.KeyChar) = 45 Then 'test for exisiting negative sign
            If InStr(sender.text, "-") > 0 Then e.Handled = True
            If sender.selectionstart > 0 Then e.Handled = True 'Can't have a negative sign other than in the first position
        End If

    End Sub

Re: VB.Net Restricting TextBox to Positive Long or Double

LeoDonahue — Wed, 29 Aug 2012 13:12:43 GMT

The alternative would be to disable the execute button until all entries were valid and use labels to highlight errors. I assume that is the approach you are recommending.

I was thinking of something more straightforward, as in when the user clicks the execute button, a boolean method would first check the validity of the input as a group and set caption messages next to the invalid input. Once the boolean method returns true, continue on with the execute logic. Execute would be three methods. The boolean validity check of the execute click action, the validity check itself, and the exectue. Then you wouldn't have all of those keypress and leave events firing around. Imagine if you had to debug this code and had to switch between the form and the code to trace your way through those events.

I will try searching for it (wish me luck)

lol.

Re: VB.Net Restricting TextBox to Positive Long or Double

LeoDonahue — Wed, 29 Aug 2012 13:20:32 GMT

The validity check method could be as simple as the way this text changed method works.

http://msdn.microsoft.com/en-us/library/system.windows.forms.control.textchanged.aspx

Did you also look at the Masked Text Box?
http://msdn.microsoft.com/en-us/library/system.windows.forms.maskedtextbox.mask.aspx

Re: VB.Net Restricting TextBox to Positive Long or Double

RichardFairhurst — Wed, 29 Aug 2012 14:02:37 GMT

Imagine if you had to debug this code and had to switch between the form and the code to trace your way through those events.

lol.

The code I wrote does have such a problem in that the code is fully self contained to operate within a single method that has an obvious connection to the behavior of the Textbox. And even if it did cause a problem it is not that much code or difficult to interprete with the commenting I have added.

Tracing your suggested code involving multiple boolean variables accessed across the entire form is much more likely to miss a code path, because I have to set and trap these flags all over the form, keeping track between methods that fire in orders that I have no control over or clear understanding of. It is easy to set the flag to a condition indicating one or more conditions fails to pass the test for execution, but nearly impossible to set the flag to indicate that widely dispersed operations all combine to allow final form execution without a centeralize check method that queries every relavant part of the form. Attempting to write such a centralize check is much more likely to result in impossible code traces of branching if then else statements and in debug nightmares that isolating each part of the form to play its part in ensuring valid input.

Were I to use your suggested set of boolean variables I would be sure that they affected the enabled status of the execute button, so that I could eliminate the user's ability to proceed on that path until the variables are set correctly for execution and visually see on the form what the boolean variable state was for any given set of user actions to assist me in debugging the ever expanding code paths. But I have gone down that road before and have always regretted it when I want to make additions or modifications to the forms behaviors. Every new option affecting the boolean variables seems to result in an exponential growth of code paths and unexpected combinations of conditions that I have to spend a lot of time tracing out.

I still am not convinced that using default values to replace obvious garbage that can only be generated through rare user actions is a bad idea.

Have you actually run my code to see for yourself how it works? I have been running the code you have referenced.

Re: VB.Net Restricting TextBox to Positive Long or Double

KenBuja — Wed, 29 Aug 2012 14:03:54 GMT

The problem with putting it into the TextChanged subroutine is that the user can put in invalid characters into the text box, whereas the KeyPress validation won't put those invalid characters there to begin with. Using the code from the MS example, you can still see something like this

[ATTACH=CONFIG]17327[/ATTACH]

It looks like the Masked Textbox requires more user interaction with decimal numbers, requiring them to position the cursor at the correct location to put in a number that has fewer numbers than the maximum number.

Re: VB.Net Restricting TextBox to Positive Long or Double

LeoDonahue — Wed, 29 Aug 2012 14:15:32 GMT

I'm not doing a good job of being clear. Let me try again.

While trying to limit what a user can enter into an input control is fine, you should also validate that input before you use it.

Example: Esri's map scale tool. You can type letters in there, but when you hit enter, you'll get a message indicating that what you typed is junk.

[ATTACH=CONFIG]17329[/ATTACH]

Re: VB.Net Restricting TextBox to Positive Long or Double

RichardFairhurst — Wed, 29 Aug 2012 14:27:46 GMT

The problem with putting it into the TextChanged subroutine is that the user can put in invalid characters into the text box, whereas the KeyPress validation won't put those invalid characters there to begin with. Using the code from the MS example, you can still see something like this

[ATTACH=CONFIG]17327[/ATTACH]

It looks like the Masked Textbox requires more user interaction with decimal numbers, requiring them to position the cursor at the correct location to put in a number that has fewer numbers than the maximum number.

I concur on both statements. The Keypress operation does the best job of ensuring keyboard actions cannot result in unwanted characters and can even restrict certain characters to a certain number of occurrances (as my code has shown) or even to specific positions (were I to use a negative sign I could write a KeyPress routine that ensured the negative sign only occurred once at the beginning of the number and that any attemp to type numbers to the left of it would result in the numbers being placed after the negative sign, without requiring the user to move their cursor to that position).

Restricting cursor movements within the textbox to specific locations that match a mask are unacceptable to me. Text entry needs to be like normal typing, with all standard editing operations, such as select and overwrite abilities, allowed using intelligent character ordering through the keyboard keypress operation.

Pasting is the sole path to entering garbage in the Textbox and I have no problem discouraging that practice and penalizing a user for careless use of that data entry method if they do not care to conform to the form's business rules.

When Federal and State Transportation Agencies, State Engineering and Surveying Licensing Boards, and my Department's policy formally adopt standards to accomdate document submissions and field data recordings using hex values and escape codes I will revise my Textbox to accomodate such numbers. But until then, such entries will be treated as the junk that they are.

Re: VB.Net Restricting TextBox to Positive Long or Double

RichardFairhurst — Wed, 29 Aug 2012 14:55:44 GMT

I'm not doing a good job of being clear. Let me try again.

While trying to limit what a user can enter into an input control is fine, you should also validate that input before you use it.

Example: Esri's map scale tool. You can type letters in there, but when you hit enter, you'll get a message indicating that what you typed is junk.

[ATTACH=CONFIG]17329[/ATTACH]

I concur with this practice of the warning (not the typing of invalid characters from the keyboard), provided that the invalid data would be immediately replaced by valid data and that the warning would only serve to notify the user that:

"You typed - 12.345.678 - which not a valid Base 10 Double Number. Your invalid entry has been replaced by the default value of 1."

This warning (which is better than a generalized failure notice) would allow the user to recover from their error by recopying their failed entry and pasting it back into the form at which point they could make appropriate corrections according the form's requirements (i.e. 12345.678).

I feel certain that the keyboard for my Textbox is bulletproof (and can be made that way for alternative requirements through the KeyPress method), but I definitely would like to have a more foolproof set of behaviors for the responding to the paste option. While in my particular case I do not want thousands separators in the Textbox on my form, I would prefer to add a subroutine that would accept pasted numbers with thousands separators as valid numbers and that would reformat them as numbers without thousands separators.

The key to solving this appears to be to find the events that always fire when the paste occurs and when the user is done entering their text by whatever method (perhaps Losing Focus). I could really use a flowchart outlining the order of more events than just KeyDown, KeyPress, and KeyUp to understand my options. I will continue looking into the options.

Re: VB.Net Restricting TextBox to Positive Long or Double

LeoDonahue — Wed, 29 Aug 2012 15:12:03 GMT

I don't want to be known for beating a dead horse, but I don't see where you are testing the validity of an integer value.

What if user enters this: 9,223,372,036,854,775,808 (which is larger than the maximum integer size by one) into your integer checking leave event?

Re: VB.Net Restricting TextBox to Positive Long or Double

RichardFairhurst — Wed, 29 Aug 2012 15:38:33 GMT

I don't want to be known for beating a dead horse, but I don't see where you are testing the validity of an integer value.

What if user enters this: 9,223,372,036,854,775,808 (which is larger than the maximum integer size by one) into your integer checking leave event?

Using the keyboard this number could only be entered as: 9223372036854775808 according to my intentional disallowance of the thousands separator. Assuming the Leave event triggered this value would be replaced by 1 as an invalid value, since it would not parse to a valid Long value, but that is not a problem, because it is far beyond the valid maximum number my form can use. The maximum number for my form's Long value is well below the one you have suggested, being at most 7 digits long for any real world AADT. The Leave event already has tests for numbers that are too small (anything below 1 for the Long field example), and adding additional tests for the total number of characters entered for a Long value would be an easy test to add to restrict the number to a valid maximum range. Exceeding the maximum number would be corrected by replacing the input with the maximum value allowed instead of the minimum value. I would definitely have other tests specific to my application that would also ensure that the distances entered actually kept the event on my real roads, none of which is anywhere near this long in any standard units of measure I use. Testing for character length of the Double value on each side of the decimal place would also be an easy test to add for the Double Textbox, and thank you for alerting me to this ommision.

Regardless of where I put it, the code I have used in the Leave event is the minimum validation code I need to have executed, whether it occurs there or in an execute button or whereever. So I just need to find the best place to put it to make it fire. My desire is to have it tested as soon as possible upon a user finishing with his entry, which in most cases should be long before the user gets to the point of trying to execute the form if they are filling it in normally (12 completed fields are required for execution in my case). At this stage I would be inclined to keep the Leave event in my code (with the addition of a maximum value validation) and just add a double check routine to be executed just prior to form execution to ensure that the user did not find a way around triggering the Leave event.

Re: VB.Net Restricting TextBox to Positive Long or Double

RichardFairhurst — Wed, 29 Aug 2012 16:12:43 GMT

Here's a subroutine I found that I usually put in my text box KeyPress functions when I want to restrict what's being typed in. This doesn't account for hex values, but I doubt that the users would even know what they are...

When using this with numbers, I have additional checks to make sure there's not more than one decimal place or negative sign, in addition. Here's an example for a group of textboxes that can be decimal degree or degree minutes seconds or just numbers...

It took me a while to understand how the mask worked, but the second example of the decimal degrees or degrees minutes seconds helped me figure it out. I assume you have other checks that would deal with minutes and seconds being between 0 and 59 that you did not publish, or did I miss something?

You also designed this with multiple textboxes for the Degrees Minutes Seconds input. Do you have any idea how it would be written to work as a single Textbox. Say that the user set a checkbox to specify the format mask they were entering so that one Textbox could accept a variety of formats depending on user preference at the time of data entry and that internal code would convert it to match the format specifications of a database field. (I realize the check box could expose different sets of Textbox fields to handle and preparse each format, which would be a safer design, but I am trying to explore the limits of what a Textbox can do in this discussion thread).

Re: VB.Net Restricting TextBox to Positive Long or Double

RichardFairhurst — Wed, 29 Aug 2012 17:57:51 GMT

Your code is only checking for "leave" events, which you hope the user enters a value and leaves that text box. What if the user enters junk into a text box and doesn't do anything to trigger the leave event before they submit?

I have not encountered any case where I have been able to execute a button that submits the form's data for execution without first triggering the Leave event of the Textbox (whether or not I changed anything in the Textbox), so unless you can show me a way to submit without triggering the Leave event I don't think your second comment applies. Therefore I have every reason to believe that the KeyPress and Leave events are all that is required to ensure that a valid entry will be in the Textbox when the user has finished with that field and wants to submit their results for execution.

So at this point I plan on amending my original code to add a check in the Leave event for the allowable maximum value and to provide a notification prior to execution of the form to the user to let him know when his entry was rejected, what the invalid value was that he entered, and that the value was replaced with a default minimum or maximum value so that he is aware of his error and can optionally correct it before proceeding with execution. I also plan to revise the code to use globalization methods that will use the decimal character that conforms to a users local cultural settings for the benefit of programmers working in other cultures that would want to use my code (although that code may need to have its behavior verified by a programmer in another culture before putting it in use). Finally, I plan on determining the local setting for the thousands separator and parsing it out of an entry that was pasted into the textbox so that it will be treated as a valid number and accepted in the field (subject to the other checks).

Re: VB.Net Restricting TextBox to Positive Long or Double

KenBuja — Sat, 11 Dec 2021 19:00:14 GMT

It took me a while to understand how the mask worked, but the second example of the decimal degrees or degrees minutes seconds helped me figure it out. I assume you have other checks that would deal with minutes and seconds being between 0 and 59 that you did not publish, or did I miss something?

You also designed this with multiple textboxes for the Degrees Minutes Seconds input. Do you have any idea how it would be written to work as a single Textbox. Say that the user set a checkbox to specify the format mask they were entering so that one Textbox could accept a variety of formats depending on user preference at the time of data entry and that internal code would convert it to match the format specifications of a database field. (I realize the check box could expose different sets of Textbox fields to handle and preparse each format, which would be a safer design, but I am trying to explore the limits of what a Textbox can do in this discussion thread).

In my case, I was using a radio button to allow the user to enter positions by decimal degree or DMS by making one set of text boxes visible and the other invisible.

You could do this by using something like

If chkInteger.Checked Then  
    Mask = "09--"
Else
    Mask = "09--.."
End If

You'd have to incorporate validation in the checkbox in case the user selects that check box after typing in a value.

Re: VB.Net Restricting TextBox to Positive Long or Double

LeoDonahue — Wed, 29 Aug 2012 19:13:47 GMT

I have not encountered any case where I have been able to execute a button that submits the form's data for execution without first triggering the Leave event of the Textbox (whether or not I changed anything in the Textbox), so unless you can show me a way to submit without triggering the Leave event I don't think your second comment applies.

You would be able to submit a form button without the leave event triggering if your button has a hot key assigned to it, such as the Text property of your button reads: &Submit

That would submit your form with no values, assuming you have a hot key assigned to your button, which you probably don't. But also means that if you wanted one, you would be forced to validate your input for all text boxes in the event the form is submitted without any values.

Re: VB.Net Restricting TextBox to Positive Long or Double

RichardFairhurst — Wed, 29 Aug 2012 23:37:13 GMT

You would be able to submit a form button without the leave event triggering if your button has a hot key assigned to it, such as the Text property of your button reads: &Submit

That would submit your form with no values, assuming you have a hot key assigned to your button, which you probably don't. But also means that if you wanted one, you would be forced to validate your input for all text boxes in the event the form is submitted without any values.

Given that validating the input data is the primary function of my form I would not assign a hot key to let the user submit the form without firing the Leave event. If I did, you are correct that I would have to find another location (the submit button) to do the validation. Is there a way to detect that a hot key was used? If so the additional validation would only need to occur if the hot key was triggered. Probably the best compromise would be to create separate Subs of Functions that placed the validation contents currently within the Leave event outside of that event. That way the method could be called from both the Leave event and the Submit button. Then the validation would always occur with whichever event fired earliest, which is my preference.