Hello,
What darren notes is one way to handle events, which can be very useful. Basically, the LabVIEW programming object which "handles" recognizing events and executing event code is the Event Structure. You have two options for registering events:
1. static
2. dynamic
Static registration is done at edit time, when you right click on the event structure edit and add event cases. Dynamic registration involves programming, where you can register and unregister events programmatically. This API also allows you to define User Events, which basically provide a mechanism for you to fire your own custom events, with the option to pass custom data along with the event. In the static case, relevant event data is available in the left data node inside the event structure; the data available in the static case varies by event type.
The final distinction I'll make about events has to do with whether the event is fired and processed on the front panel before OR after the code in the corresponding event case fires. The terminology used to distinguish those event "flavors" is Notify and Filter events. Notify events are the case where the event happens, front panel activity is registered, and then code executes. For example, suppose you register for a button click event... then when your program is running, and you click the button, it's value will change (it's a boolean so it would go from false to true) and then the code would execute. The Filter events are the case where the event is triggered (say by a button click again) but the value does NOT change first. Instead, the code inside the corresponding event case executes, and you have the option to dispose of the event (for filter events there is a right hand side datanode as well). If you choose to dispose of the event, the event is discarded and the button will not change value. If you do not dispose of the event, the button will then indeed change value as a result of processing the button click event.
Ok, I think if you read the above few paragraphs carefully, and play around with the event structure (and event api for registering dynamically, and creating and firing user events - see the All Functions -> Application Control -> Events palette) you'll have a pretty good idea of how to start programming using events in LabVIEW.
Best Regards,
JLS
PS - the callback mechanism is something not entirely foreign to LabVIEW. First, functions in general are just subVIs, and putting those inside the event structure is basically like "calling your callback function" when the event occurs. Actually, to handle ActiveX events, you CAN register a "callback VI" which will execute when an ActiveX event occurs. See the All Functions -> Communication -> ActiveX palette for the ActiveX API, which includes a function "Register Event Callback" where you can indeed provide a reference to a VI, which will cause that VI to execute when the corresponding ActiveX event occurs.