Scribd
Upload
55 views

Event-Based Programming: Roger Crawfis

This document discusses event-based programming and how it differs from procedural programming. In event-based programming: - The system waits for user input events which trigger program methods. This allows a program to wait for and respond to multiple input sources simultaneously. - When an input event occurs, like a mouse click, it is added to an event queue by the operating system. The program removes events from this queue and processes them, with each event type triggering the appropriate response method. - The main program loop continuously removes events from the queue and calls the processing method. This replaces sequential execution with an event-driven model where the flow is determined by user input events.

Uploaded by

Ion Sirbu
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
55 views

Event-Based Programming: Roger Crawfis

This document discusses event-based programming and how it differs from procedural programming. In event-based programming: - The system waits for user input events which trigger program methods. This allows a program to wait for and respond to multiple input sources simultaneously. - When an input event occurs, like a mouse click, it is added to an event queue by the operating system. The program removes events from this queue and processes them, with each event type triggering the appropriate response method. - The main program loop continuously removes events from the queue and calls the processing method. This replaces sequential execution with an event-driven model where the flow is determined by user input events.

Uploaded by

Ion Sirbu
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 21

Event-based Programming

Roger Crawfis

Window-based
programming
Most modern desktop systems are
window-based.
WhatlocationdoIusetosetthispixel?
Non-window based environment

Window based environment

Event-based Programming
Window-based GUIs are typically
comprised of many independent
processes.
These processes sit and wait for the
user to do something, to which it can
respond.
Moreover, a simple application may
be waiting for any of a number of
things.

Event-based Programming
Sample main programs:
C# / managed C++
static void Main()
{
Application.Run( new Form1());
}

C++ (MFC Document/View architecture)


There isnt one!!

GLUT
void main(int argc, char** argv)
{
myInit();
glutMainLoop();
}

Programming forms
statement
statement
statement
--------------statement

Procedural programming

code is executed in sequential order.

Event-driven programming

code is executed upon activation of events.

Do
method 1
then
method 3

method 1
method 2
method 3
--------------method n

Do
method 2
then
method 1
then
method 3

1
2
3
n

Procedural programming
Up to now, our control flow model has been
pretty straight-forward.
Execution starts at main() and executes
statement sequentially branching with if,for,and
while statement, and occasional method calls.
When we need user input we call read() on the
console stream which waits (blocks) until the
user types something, then returns.
One problem with this model is: How do we wait
for and respond to input from more than one
source (eg keyboard and mouse). If we block
on either waiting for input, we may miss input
from the other.

Event-driven programming
the system waits for user input
events, and these events trigger
program methods
Event-based programming
addresses the two problems:
How to wait on multiple input sources
(input events)
How to decide what to do on each
type of input event

General form of eventdriven programming


The operating system and window
system process input events from
devices (mouse movement, mouse
clicks, key presses etc)
The window system decides which
window, and hence which frame and
program, each input event belongs to.

General form of event-driven


programming
A data structure describing the event is
produced and placed on an event queue.
Events are added to one end of the
queue by the window system. Events are
removed from the queue and processed
by the program. These event data
structures hold information including:
Which of the program's windows this event
belongs to.
The type of event (mouse click, key press,
etc.)
Any event-specific data (mouse position, key
code, etc.)

Event loop
main(){
...set up application data structures...
...set up GUI....
// enter event loop
while(true){

Event e = get_event();

process_event(e); // event dispatch routine } }


the event loop is usually hidden from
programmer, he/she provides just a
process_event() method

AWT Applications - Frame


Frame is a container for components

Optional
Menu

Three
containers in
Frame with
Border Layout

UI-components
inside
containers each
with own layout

Frame with
normal window
controls

Understanding the GUI


UI-containers
have list of
UI-components

Each UI-component
{label}
{Frame}
components

{textfield}

{button}

is a class
with paint method
& lists of
Event listeners

Understanding .NET UI
Components
Overview
Replacement for VB Forms and MFC

Fully integrated with the .NET framework


Web Service aware
Data (ADO.NET and XML) aware
Secure code and Licensing

A framework for building Windows application


No touch deployment
No registration, Versionable, Smart caching

A RAD environment in Visual Studio .NET


Windows Form Designer, Property Browser

Overview (cont)
Rich set of controls

Standard controls - Label, Button, TextBox, etc.


Common controls - ProgressBar, StatusBar, etc.
Data aware controls - ListBox, DataGrid, etc.
Common dialogs

ActiveX Interoperability
Can host ActiveX controls / author ActiveX controls

Printing Support
Visual inheritance
Create a form based on another form by using
inheritance

Advanced layout
Anchoring and docking

Basic Terms
Component
Timer, DB Connection

Control (User Control)


Windows Forms
Menu
Button
etc

Web Forms
ASP.NET specific

Using VS.NET
Adding Components and Controls
Just drag component from the toolbox

Editing properties
Edit directly in the properties editor

Registering for events


Also in the properties editor

What actually happens?


Data members for components
For example, after placing timer:
public class FunnyButton :
System.Windows.Forms.Button
{
private System.Windows.Forms.Timer
timer1;

What actually happens?


Attributes for the properties
For example, after changing Text
property:
private void InitializeComponent()
{

this.Text = "ADO Example";

What actually happens?


Delegates for events
Special type event in .NET (special delegate)
private void InitializeComponent()
{

this->MouseEnter += new
System.EventHandler(this.UserControl1_MouseEnter)
;

private void UserControl1_MouseEnter(object sender,


System.EventArgs e) {}

Names everyone should


know
Properties
Name data member name
Text text shown by control (was
Caption)
ForeColor current text color
Dock docking to the parent
Enabled active or not

Events
Click mouse click on the control
SizeChanged - resize

InitializeComponent()
method
This method is created by VS.NET
Code generated there represents all the
changes done in the design view
Note: if you remove event handler or
data member added by VS.NET
manually, do not forget to clean the code
that uses it from InitializeComponent().
Doing this from the design view is easier!

You might also like