I’d like to show you how to create an Enum for Days of the Week and demonstrate the use of that by creating a custom segmented button control.

Open Xojo and create a new Desktop Project.  Insert a module and give it a name – I called mine Enumerations.

Next, add an enumeration.

Call this Enum DaysOfWeek and make it a binary enum.

Next, fill in the Declarations.

Next, I’m going to add a bunch of Constants to the module, one for each day of the week.  This will allow me to localise the control later.

Now I’ll add a convenience method called ToString that will extend the DaysOfWeek Enum.

The code in this method is:

Var SelectedDays() As String

Var d As DaysOfWeek

d = DaysOfWeek.Sunday
If Value.Contains(d) Then
  SelectedDays.Add(Day1)
End If

d = DaysOfWeek.Monday
If Value.Contains(d) Then
  SelectedDays.Add(Day2)
End If

d = DaysOfWeek.Tuesday
If Value.Contains(d) Then
  SelectedDays.Add(Day3)
End If

d = DaysOfWeek.Wednesday
If Value.Contains(d) Then
  SelectedDays.Add(Day4)
End If

d = DaysOfWeek.Thursday
If Value.Contains(d) Then
  SelectedDays.Add(Day5)
End If

d = DaysOfWeek.Friday
If Value.Contains(d) Then
  SelectedDays.Add(Day6)
End If

d = DaysOfWeek.Saturday
If Value.Contains(d) Then
  SelectedDays.Add(Day7)
End If

Return String.FromArray(SelectedDays, ", ")

You can see from this code that it is possible to include multiple days in this Enum.  The return string might be “Sunday, Monday, Friday” for example.

Create the DaysOfWeek Control by dragging a segmented button from the library to the navigator and naming it DaysOfWeekControl.

Then use the Inspector Behaviour option to customise the control.

Change the default width to 500 and the selection style to 1 for multiple

Unfortunately, we can’t edit the segments here as the control is a textfield, not a textarea and the edit button is missing.  But we can edit the source file (you need a license capable of saving the project in text format).  Save and close the project, and open the DaysOfWeekControl.xojo_code file in Notepad, search for “One” which will find the initial value of the control.

You can see each segment is separated with “\r” which the IDE translates to <CR>.  Replace “One\rTwo” with “#Day1\r#Day2\r#Day3\r#Day4\r#Day5\r#Day6\r#Day7” which will tell the compiler to use the localised Day constants created earlier. Save the code file and reopen the project.

Now we can continue customising the control first adding a computed property Value As DaysOfWeek. In the Get method add this code:

Var Result As DaysOfWeek = 0 ' The default value is set to create an instance of Result
For i As Integer = 0 To 6 ' Each Segment in the control
  If me.SegmentAt(i).Selected Then
    Var d As DaysOfWeek = 2 ^ i ' Converts the index (i) to the binary number that matches the value of the enum
    Result = Result Or d ' Adds the selected day to the enum
  End If
Next i

Return Result

You’ll notice the first line sets the value of Result to 0, this is important as otherwise the variable will be Nil – remember this is being rendered as a class by the compiler.

In the Set Method place this code:

For i As Integer = 0 To 6 ' Index of each segment
  Var d As DaysOfWeek = 2 ^ i ' Convert the index (i) to binary
  me.SegmentAt(i).Selected = value.Contains(d) ' Set the selected state of the button
Next i

RaiseEvent ValueChanged(value)

This will show the button as pressed or not depending on whether the day is included on the value.  Now add an event definition.

Which will raise when a button is pressed, which means we need to handle the pressed event of the control.

Sub Pressed(segmentIndex as integer) Handles Pressed
  #Pragma Unused segmentIndex

  RaiseEvent ValueChanged(Value)
 End Sub

Time to use the control. We want to place a copy of the control onto Window1; we can either drag the control from the Navigator or select it from the Library (it will show in the Project Controls section). I’m also going to add a label to the Window under the DaysofWeek control, name it SelectedDaysLabel and make it the same width as the control (500). This will be where we will show the result of the days selected.

Next, handle the ValueChanged event on the control:

Sub ValueChanged(Value As DaysOfWeek) Handles ValueChanged
  SelectedDaysLabel.Text = Value.ToString
End Sub

When we run the project and select some days, we’ll see something similar to the following.

Now to show the power of the binary enum I’m going to add another declaration to the Enumeration “WeekDays” with a value of 62

62 is the total of the values for Monday through Friday. Once we have this, we can add a button to the window and set its “Pressed” event handler to:

Sub Pressed() Handles Pressed
  DaysOfWeekControl1.Value = DaysOfWeek.Weekdays
End Sub

Pressing the button will result in:

Taking this further we can add the enum value to the DateTime class by adding another Extension method to the module as below.

Public Function DayOfWeekEnum(Extends Value As DateTime) As DaysOfWeek  

  Var Result As DaysOfWeek = 2 ^ (Value.DayOfWeek - 1)
  Return Result

End Function

We need to subtract 1 from the DayOfWeek property of the passed DateTime object as the days are 1 based not 0 as in the control. To demonstrate how this works I’m going to add a multiline label to the window called SelectedDatesLabel and set that to show which dates over the next week have been selected by updating the ValueChanged handler as below:

Sub ValueChanged(Value As DaysOfWeek) Handles ValueChanged

SelectedDaysLabel.Text = Value.ToString

SelectedDatesLabel.Text = ""

For i As Integer = 1 To 7 ' From tomorrow for a week
 Var dt As DateTime = DateTime.Now.AddInterval(0, 0, i)
 If Value.Contains(dt.DayOfWeekEnum) Then
  SelectedDatesLabel.Text = SelectedDatesLabel.Text + _
  dt.ToString(DateTime.FormatStyles.Short, DateTime.FormatStyles.None) _
  + EndOfLine
    End If
  Next i

End Sub

That’s it folks, hope you enjoyed this tutorial.

Wayne Golding has been a Xojo developer since 2005 and is a Xojo MVP. He operates the IT Company Axis Direct Ltd which primarily develops applications using Xojo that integrate with Xero www.xero.com. Wayne’s hobby is robotics where he uses Xojo to build applications for his Raspberry Pi, often implementing IoT for remote control.

In addition, we’ve added a new Binary option which allows you to automatically create sets that aren’t mutually exclusive. That is, the values of the elements are automatically powers of two and can have binary operations applied to them:

This new feature comes with the requirement that they be placed inside a Module because they’re rendered into your project as a Class. The reason for this is that these classes automatically have some helper methods on them to make working with the binary data easier.

• An Operator_Convert which takes an Integer:
  Var x as MyEnum = 3 // MyEnum.George, MyEnum.John
  
• …as well as one that returns an integer:
  Var y as Integer = MyEnum.George // y = 2
  
• Automatic conversion to and from Integer:
  Var x as Integer = MyEnum.Ringo // x = 4
  
• Binary operations And, Or and Xor:
  Var x as MyEnum = MyEnum.Paul Or MyEnum.Mary // x has a value of 40
  
• Equality operations so you can compare the internal value of one instance to another:
  Var x as MyEnum = MyEnum.Paul
Var y as MyEnum = MyEnum.Ringo
If x = y Then
  
• Contains helper method:
  If x.Contains(MyEnum.Peter) Then
  
• A Read-Only Value property so you can see the internal value in the debugger

Just like regular Enumerations, the editor also allows you to explicitly specify the value of an element:

This is so instead of having to write:
Var x as MyEnum = MyEnum.George Or MyEnum.John Or MyEnum.Ringo Or MyEnum.Paul

You can simply write:
Var x as MyEnum = MyEnum.TheBeatles

We hope that you’ll enjoy this feature as much as we do!

Keyboard
The Tab key steps to the next enumeration line. Tabbing off the last enumeration lands on the blank ‘+’ line. Unfortunately pressing Return does not open the enumeration line editor (hmm, Feature Request!). Tabbing off the blank ‘+’ lands on the enumeration editor ‘Name’ field.

Shift-Tab steps to the previous enumeration line. Tabbing off the first enumeration line lands on the enumeration declaration in the Navigator.

Reordering
Existing enumerations can be reordered. Using the mouse, grab the line to be moved, drag it to the desired location in the enumeration list and release. Do not try grabbing the ‘-‘ symbol!

Assignments
A value can be assigned to an enumeration label. After the label type ‘=’ and an integer value. For example: ‘foo = 123’. Spaces around the assignment symbol (‘=’) are optional.

Note: ‘foo =’ will generate a syntax error.

Non-sequential values
Values assigned to enumeration labels do not have to be sequential. For example:

Note: Same value assignments are legal, so ‘one’ and ‘two’ could be assigned the same value, e.g. 3.

Non-ordered values
Values assigned to enumeration labels do have to be ordered. For example:

Assigned and unassigned enumerations
If assigned and unassigned enumerations are intermixed, the unassigned enumeration will be assigned the last assigned value + 1. For example:

one = 16
two
three = -2
four
five = 3
six

will render as:

one = 16
two = 17
three = -2
four = -1
five = 3
six = 4

Comments
Enumeration lines can contain comments. For example:

one = 16  //This is a comment

Any of the valid Xojo comment symbols are allowed, I just prefer ‘//’.

Base type
The default base type for an enumeration is Integer. It can be any integer type. For example: int32
One of my favourites is uint8. But you need to be aware of a couple of things. In the following example, the enumeration is ‘Foos’ and the base type is uint8:

one =-2
two
three
four
five = 17
six

will render as:

one = 254 //value wrapped around the base type range
two = 255
three = 0
four = 1
five = 17
six = 18//Incremented from the previous value

If converting the enumeration to an integer the same base type bit-width must be used.
For example: thisValue as int32 = uint8(Foos.two)

or: thisValue as int32 = int8(Foos.two)

I try to stick to using the same enumeration base type. It avoids confusion caused by type range wrap-around.

Enumeration value references
An enumeration value can be assigned an enumeration label from another enumeration declaration. For example, given one enumeration is declared as ‘Foos’ and there is another enumeration declared as ‘Things’. In the following example ‘Things’ is attached to a module or class called ‘Those’.

Those.Things(integer):
thing1 = 1
thing2 = -2

one = 1
two = Foos.four
three = Those.Things.thing2
four = Foos.three

one = 1
two = 254 //Clever compiler 
three = 254 //Remember base type wrap-around
four = 254

Note: The compiler will catch recursive declarations!

Constant references are also allowed. For example:

THING = 127

one = THING

one = 127

Current limitations
a) Non-integer base types are not allowed, e.g. String or Double

b)  Enumeration values cannot be expressions, e.g. 2+3 is not allowed Hint: Another secret, some fields in the IDE do allow simple expressions.

c)  The maximum number of enumeration elements is uint64[Max]. If that is a limitation, then your code probably has other problems!

d)  An enumeration argument is not rigorously checked against its declaration when passed as a function or method parameter. For example:

Foos(int32)
one = 1
two = 2

sub Test(value as Foos)
  dim thisValue as int32 = int32(value)
end sub

Test(Foos(5))

Would result in ‘thisValue’ having the value 5. Interestingly the Debugger will show the value ‘5’ in red, so something can detect invalid values.

e)  The enumeration editor font is not affected by the Options/Preferences,Code Editor, Font selection.

I hope there were at a least of couple of things in here you did not know before. I’m not sure if any of this makes the Enumeration Editor any easier to use, but it might make it a little more fun. Enjoy!