[SEMINAR REPORT]

MOUSE PROGRAMMING IN C/C++

BACHELOR OF ENGINEERING
IN
COMPUTER SCIENCE & ENGINEERING

DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

Chandigarh University, Gharuan

Submitted By:
Navpreet Singh
12BCS1176

Submitted to:
Er. Jasneet kaur

CONTENTS
BASIC TERMINOLOGY
Interrupt
Interrupt Service Routine
Device Driver
Int86 function in c
Union regs
Generic values for the mouse programming
Steps for implementation
MOUSE programs
Conclusion

BASIC TERMINOLOGY
INTERRUPT:Interrupt is a signal to the processor of computer informing some event needs a immediate
attention. An interrupt alerts the processor to a high-priority condition requiring the interruption
of the current code the processor is executing. The processor responds by suspending its current
activities, saving its state, and executing a function called an interrupt handler (or an interrupt
service routine, ISR) to deal with the event. This interruption is temporary, and, after the interrupt
handler finishes, the processor resumes normal activities. There are two types of interrupts:
hardware interrupts and software interrupts.

Hardware interrupts are used by devices to communicate that they require attention from the
operating system. Internally, hardware interrupts are implemented using electronic alerting signals
that are sent to the processor from an external device, which is either a part of the computer itself,
such as a disk controller, or an external peripheral. For example, pressing a key on the keyboard
or moving the mouse triggers hardware interrupts that cause the processor to read the keystroke or
mouse position. Unlike the software type (described below), hardware interrupts are asynchronous
and can occur in the middle of instruction execution, requiring additional care in programming.
The act of initiating a hardware interrupt is referred to as an interrupt request (IRQ).

A software interrupt is caused either by an exceptional condition in the processor itself, or a

special instruction in the instruction set which causes an interrupt when it is executed. The former
is often called a trap or exception and is used for errors or events occurring during program
execution that are exceptional enough that they cannot be handled within the program itself. For
example, if the processor's arithmetic logic unit is commanded to divide a number by zero, this
impossible demand will cause a divide-by-zero exception, perhaps causing the computer to
abandon the calculation or display an error message. Software interrupt instructions function
similarly to subroutine calls and are used for a variety of purposes, such as to request services from
low-level system software such as device drivers. For example, computers often use software
interrupt instructions to communicate with the disk controller to request data be read or written to
the disk.
Each interrupt has its own interrupt handler. The number of hardware interrupts is limited by the
number of interrupt request (IRQ) lines to the processor, but there may be hundreds of different
software interrupts. Interrupts are a commonly used technique for computer multitasking,
especially in real-time computing. Such a system is said to be interrupt-driven

INTERRUPT SERVICE ROUTINE:In computer systems programming, an interrupt handler, also known as an interrupt service routine
or ISR, is a callback function in microcontroller firmware, an operating system or a device driver,
whose execution is triggered by the reception of an interrupt. In general, interrupts and their
handlers are used to handle high-priority conditions that require the interruption of the current code
the processor is executing.
Interrupt handlers have a multitude of functions, which vary based on the reason the interrupt was
generated and the speed at which the interrupt handler completes its task. For example, pressing a
key on a computer keyboard, or moving the mouse, triggers interrupts that call interrupt handlers
which read the key, or the mouse's position, and copy the associated information into the
computer's memory.
An interrupt handler is a low-level counterpart of event handlers. These handlers are initiated by
either hardware interrupts or interrupt instructions in software, and are used for servicing hardware
devices and transitions between protected modes of operation such as system calls.
In several operating systemsLinux, Unix, Mac OS X, Microsoft Windows, z/OS, and some other
operating systems used in the pastinterrupt handlers are divided into two parts: the First-Level
Interrupt Handler (FLIH) and the Second-Level Interrupt Handlers (SLIH). FLIHs are also known
as hard interrupt handlers or fast interrupt handlers, and SLIHs are also known as slow/soft
interrupt handlers, Deferred Procedure Call.
A FLIH implements at minimum platform-specific interrupt handling similar to interrupt routines.
In response to an interrupt, there is a context switch, and the code for the interrupt is loaded and
executed. The job of a FLIH is to quickly service the interrupt, or to record platform-specific

critical information which is only available at the time of the interrupt, and schedule the execution
of a SLIH for further long-lived interrupt handling.
FLIHs cause jitter in process execution. FLIHs also mask interrupts. Reducing the jitter is most
important for real-time operating systems, since they must maintain a guarantee that execution of
specific code will complete within an agreed amount of time. To reduce jitter and to reduce the
potential for losing data from masked interrupts, programmers attempt to minimize the execution
time of a FLIH, moving as much as possible to the SLIH. With the speed of modern computers,
FLIHs may implement all device and platform-dependent handling, and use a SLIH for further
platform-independent long-lived handling.
FLIHs which service hardware typically mask their associated interrupt (or keep it masked as the
case may be) until they complete their execution. An (unusual) FLIH which unmasks its associated
interrupt before it completes is called a reentrant interrupt handler. Reentrant interrupt handlers
might cause a stack overflow from multiple preemptions by the same interrupt vector, and so they
are usually avoided. In a priority interrupt system, the FLIH also (briefly) masks other interrupts
of equal or lesser priority.
A SLIH completes long interrupt processing tasks similarly to a process. SLIHs either have a
dedicated kernel thread for each handler, or are executed by a pool of kernel worker threads. These
threads sit on a run queue in the operating system until processor time is available for them to
perform processing for the interrupt. SLIHs may have a long-lived execution time, and thus are
typically scheduled similarly to threads and processes.
In Linux, FLIHs are called upper half, and SLIHs are called lower half or bottom half. This is
different from naming used in other Unix-like systems, where both are a part of bottom half.
DEVICE DRIVER:In computing, a device driver (commonly referred to as a driver) is a computer program that
operates or controls a particular type of device that is attached to a computer. A driver provides a
software interface to hardware devices, enabling operating systems and other computer programs
to access hardware functions without needing to know precise details of the hardware being used.

A driver typically communicates with the device through the computer bus or communications
subsystem to which the hardware connects. When a calling program invokes a routine in the driver,
the driver issues commands to the device. Once the device sends data back to the driver, the driver
may invoke routines in the original calling program. Drivers are hardware-dependent and
operating-system-specific. They usually provide the interrupt handling required for any necessary
asynchronous time-dependent hardware interface.
Device drivers simplify programming by acting as translator between a hardware device and the
applications or operating systems that use it. Programmers can write the higher-level application
code independently of whatever specific hardware the end-user is using.
For example, a high-level application for interacting with a serial port may simply have two
functions for "send data" and "receive data". At a lower level, a device driver implementing these
functions would communicate to the particular serial port controller installed on a user's computer.
The commands needed to control a 16550 UART are much different from the commands needed
to control an FTDI serial port converter, but each hardware-specific device driver abstracts these
details into the same (or similar) software interface.
Device drivers, particularly on modern Microsoft Windows platforms, can run in kernel-mode
(Ring 0 on x86 CPUs) or in user-mode (Ring 3 on x86 CPUs). The primary benefit of running a
driver in user mode is improved stability, since a poorly written user mode device driver cannot
crash the system by overwriting kernel memory. On the other hand, user/kernel-mode transitions
usually impose a considerable performance overhead, thereby prohibiting user-mode drivers for
low latency and high throughput requirements.
Kernel space can be accessed by user module only through the use of system calls. End user
programs like the UNIX shell or other GUI-based applications are part of the user space. These
applications interact with hardware through kernel supported functions.
INT86() FUNCTION :INT 86 Int86() is a C function that allows to call interrupts in the program. prototype in dos.h
Usage is int86 (int intr num, union REGS *inregs, union REGS *outregs) In and out register must
be type of REGS. REGS is a built in UNION declaration in C. It is defined in the header file
<DOS.h>
This function takes 3 arguments as shown.

Interrupt number.
UNION REGS type input_reg variable for inputting into CPU registers.
UNION REGS type output_reg variable for outputting from the CPU registers.

First argument, I have already explained above i.e. Interrupt number. Second and third arguments
are nothing but UNION REGS type of variable, which are used to pass information to and from
int86() function. Before executing the interrupt, int86() function copies register values from
input_reg argument to CPU registers, and after execution of the interrupt, int86() function copies

the current CPU register value to the output_reg variable. Thats why we are using UNION REGS
variable.
union REGS
{
struct WORDREGS x;
struct BYTEREGS h;
};
These two structures contain some 1-byte long and 2-byte long variables which indirectly represent
CPU's registers. Now we need to perform some tasks related to mouse programming as, displaying
mouse pointer on the screen, working with mouse clicks and much more. To perform these tasks,
we have to execute mouse interrupt every time for every single operation with its own input.
The Functions are listed below - Here AX, BX, CX and DX are members of Union REGS and
more or less integers. We can access different mouse functions by placing the different values in
AX register.

UNION REGS:Union REGS {

Struct WORDREGS x;
Struct ByteREGS h;
}

Struct WORDREGS{
Unsigned int ax,bx,cx,dx,si,di,cflags,flags;
}

Struct ByteReg {
Unsigned char ah,al,bh,bl,ch,cl,dh,dl;
}

GENERIC VALUES FOR THE MOUSE PROGRAMMING

STEPS FOR IMPLEMENTATION

1. Include all the necessary header files.
2. Declare two objects of type REGS
EXAMPLE: union REGS IN ,OUT;
IN:- for the input
OUT:- for the output
3. Initialize the values of input register.
4. Call the function int86 as following:
int86(51,&in,&out);
5. Check the output register if it returning some values.

MOUSE PROGRAMS
1. C program to check the mouse availability

Source code:
#include <dos.h>
union REGS in, out;
void detect_mouse ()
{
in.x.ax = 0;
int86 (0X33,&in,&out);
//invoke interrupt
if (out.x.ax == 0)
printf ("\nMouse Failed To Initialize");
else
printf ("\nMouse was Succesfully Initialized");
}
int main ()
{
detect_mouse ();
getch ();
return 0;
}

Explaination : In the above program, we have used a user defined function, named detectmouse().
Which detects the mouse in our system.If mouse driver is not loaded, it returns 0 in ax register. All
return values are accessed using 'out', that's why we have out.x.ax==0 in if statement.

2. C program to show the mouse pointer on the screen

Source code:
#include <dos.h>
union REGS in, out;
void showmouse_text ()
{
in.x.ax = 1;
int86 (0X33,&in,&out);
}
int main ()
{
detect_mouse ();
showmouse_text ();
getch ();
return 0;
}

Explaination: First we have checked for mouse status by setting ax=1. After completing this
interrupt, we again set ax=1 to show mouse pointer. Then we have to call again int86() function
with new input value. So to perform different tasks(hide pointer, restrict mouse etc.) we have to
call int86() function every time with new value of ax register.

3. c program to detect mouse clicks

Source code:#include <dos.h>

#include <graphics.h>
union REGS in, out;
void detect ()
{
int button;
while (!kbhit () )
{
in.x.ax = 3;
int86 (0X33,&in,&out);
button=out.x.bx&7
switch(button)
{
case 1:
print(left button pressed\n);
break;
case 2:
print(right button pressed\n);
break;

case 4:
print(middle button pressed\n);
break;
case 3:
print(left and right button pressed\n);
break;
case 5:
print(left and middle button pressed\n);
break;
case 6:
print(right and middle button pressed\n);
break;
case 7:
print(all the three buttons pressed\n);
break;
default:
print(No button pressed\n);
}
delay (200); // Otherwise due to quick computer response 100s
of words will get print
}
}
int main ()
{
detect_mouse ();
showmouse_text ();
detect ();
hide_mouse ();
getch ();
return 0;
}

4. c program to get current position of mouse pointer on the screen.

#include<graphics.h>
#include<conio.h>
#include<stdio.h>
#include<dos.h>
int initmouse();
void showmouseptr();
void hidemouseptr();
void getmousepos(int*,int*,int*);
union REGS i, o;
main()
{
int gd = DETECT, gm, status, button, x, y, tempx, tempy;
char array[50];
initgraph(&gd,&gm,"C:\\TC\\BGI");
settextstyle(DEFAULT_FONT,0,2);

status = initmouse();
if ( status == 0 )
printf("Mouse support not available.\n");
else
{
showmouseptr();
getmousepos(&button,&x,&y);
tempx = x;
tempy = y;
while(!kbhit())
{
getmousepos(&button,&x,&y);
if( x == tempx && y == tempy )
{}
else
{
cleardevice();
sprintf(array,"X = %d, Y = %d",x,y);
outtext(array);
tempx = x;
tempy = y;
}
}
}
getch();
return 0;
}
int initmouse()
{
i.x.ax = 0;
int86(0X33,&i,&o);
return ( o.x.ax );
}
void showmouseptr()
{
i.x.ax = 1;
int86(0X33,&i,&o);
}
void getmousepos(int *button, int *x, int *y)
{
i.x.ax = 3;
int86(0X33,&i,&o);
*button = o.x.bx;
*x = o.x.cx;
*y = o.x.dx; }

5. c program to hide mouse pointer

Source code:
#include<graphics.h>
#include<conio.h>
#include<dos.h>
int initmouse();
void showmouseptr();
void hidemouseptr();
union REGS i, o;
main()
{
int status, count = 1, gd = DETECT, gm;
initgraph(&gd,&gm,"C:\\TC\\BGI");
status = initmouse();
if ( status == 0 )
printf("Mouse support not available.\n");
else
{
showmouseptr();
while(count<=10)
{
getch();
count++;
if(count%2==0)
hidemouseptr();
else
showmouseptr();
}
}
getch();
return 0;
}
int initmouse()
{
i.x.ax = 0;

int86(0X33,&i,&o);
return ( o.x.ax );
}
void showmouseptr()
{
i.x.ax = 1;
int86(0X33,&i,&o);
}
void hidemouseptr()
{
i.x.ax = 2;
// to hide mouse
int86(0X33,&i,&o);
}
6. c program to restrict mouse pointer
Source code:
#include<dos.h>
#include<graphics.h>
#include<conio.h>
int initmouse();
void showmouseptr();
void hidemouseptr();
void restrictmouseptr(int, int, int, int);
union REGS i, o;
main()
{
int status, gd = DETECT, gm;
initgraph(&gd,&gm,"C:\\TC\\BGI");
settextstyle(DEFAULT_FONT,0,2);
status = initmouse();
if ( status == 0 )
outtext("Mouse support not available.\n");
else
{
showmouseptr();
rectangle(120,70,520,410);

restrictmouseptr(120,70,520,410);
}
getch();
return 0;
}
int initmouse()
{
i.x.ax = 0;
int86(0X33,&i,&o);
return ( o.x.ax );
}
void showmouseptr()
{
i.x.ax = 1;
int86(0X33,&i,&o);
}
void restrictmouseptr(int x1, int y1, int x2, int y2)
{
i.x.ax = 7;
i.x.cx = x1;
i.x.dx = x2;
int86(0X33,&i,&o);
i.x.ax = 8;
i.x.cx = y1;
i.x.dx = y2;
int86(0X33,&i,&o);
}
7. c program to restrict mouse pointer in a circle
Source code:
#include<graphics.h>
#include<conio.h>
#include<dos.h>
#include<stdlib.h>
#include<math.h>
union REGS i, o;
int initmouse()

{
i.x.ax = 0;
int86(0X33, &i, &o);
return ( o.x.ax );
}
void showmouseptr()
{
i.x.ax = 1;
int86(0X33, &i, &o);
}
void hidemopuseptr()
{
i.x.ax = 2;
int86(0X33,&i,&o);
}
void getmousepos(int *x, int *y)
{
i.x.ax = 3;
int86(0X33, &i, &o);
*x = o.x.cx;
*y = o.x.dx;
}
void movemouseptr(int x, int y)
{
i.x.ax = 4;
i.x.cx = x;
i.x.dx = y;
int86(0X33, &i, &o);
}
main()
{
int gd = DETECT, gm, midx, midy, radius, x, y, tempx, tempy;
radius = 100;
initgraph(&gd, &gm, "C:\\TC\\BGI");
if(!initmouse())
{
closegraph();

exit(1);
}
midx = getmaxx()/2;
midy = getmaxy()/2;
showmouseptr();
movemouseptr(midx, midy);
circle(midx, midy, radius);
x = tempx = midx;
y = tempy = midy;
while(!kbhit())
{
getmousepos(&x, &y);
if((pow(x-midx,2)+pow(y-midy,2)-pow(radius,2))>0)
{
movemouseptr(tempx, tempy);
x = tempx;
y = tempy;
}
tempx = x;
tempy = y;
}
closegraph();
return 0;
}
8. c program to show mouse pointer on to the screen in text mode
Source code:
#include<dos.h>
#include<conio.h>
int initmouse();
void showmouseptr();
union REGS i, o;
main()
{

int status;
status = initmouse();
if ( status == 0 )
printf("Mouse support not available.\n");
else
showmouseptr();
getch();
return 0;
}
int initmouse()
{
i.x.ax = 0;
int86(0X33,&i,&o);
return ( o.x.ax );
}
void showmouseptr()
{
i.x.ax = 1;
int86(0X33,&i,&o);
}

CONCLUSION
Mouse programming has lots of applications like gaming, GUI , Graphics ,
animations etc.
Mouse programming is a topic which every C programmer from beginner to
professional needs to have in his tool box to have a cutting edge .