Some Paradigms

1.1.1 Procedural

This is focusing on grouping organizations and/or code by similar operations or by the operations that can be done on them.

1.1.2 Functional

Functional programming is so called because a program consists entirely of functions. The program itself is written as a function which receives the program's input as its argument and delivers the program's output as its result. Typically the main function is defined in terms of other functions, which in turn are defined in terms of still more functions, until at the bottom level the functions are language primitives. These functions are much like ordinary mathematical functions.

Functional programs contain no assignment statements, so variables, once given a value, never change. Functions can be described intentionally by a rule describing the association, or extensionally as a set of associated pairs (argument, result) which are called the graph of the function. Functional programming also provides greater abstraction for solution. One such a feature is polymorphism which allows general definition of functions which could be applied to objects of any type. To achieve such a behavior we use type variables which stand for any type. Further higher order functions provide facility to treat functions as a data objects and use them like other data objects. It means that function (higher order function) can manipulate and create other functions. Another important feature of the functional programming is that evaluation of arguments could be delayed but done at most once. This technique is called lazy evaluation. Postponing sometimes can lead to such a situation that postponed value could be found as not necessary to evaluate, even when argument is undefined. If such a function can return a defined result we call it non-strict, else if returns undefined is called strict.

1.1.3 Logic

The basic constructs of logic programming, terms and statements are inherited from logic. There are three basic statements: facts, rules and queries. There is a single data structure: the logical term.

In a logic programming language the logical relationship between various entities are declared. The programmer writes a database of facts and rules. The user supplies a queries (goals) which the system tries to prove. This involves matching the current goal against each fact or the left hand side of each rule using unification. If the goal matches a fact, the goal succeeds; if it matches a rule then the process recurses, taking each sub-goal on the right hand side of the rule as the current goal. If all sub-goals succeed then the rule succeeds.

Logic programming languages tend to be declarative programming languages, as opposed to the more traditional imperative programming languages. In a declarative language, you concentrate on the relationships between the parts of the problem, rather than on the exact sequence of steps required to solve the problem. An example of a well-known declarative languages are SQL, Prolog.

1.1.4 Structural

Two mathematicians, Corrado Bohm and Guiseppe Jacopini proved that any computer program can be written with the three structures : sequences, decisions and loops. This discovery led to the method of modern programming known as structured programming. Structured programming can be seen as a subset or sub discipline of Procedural programming one of the major paradigms (and probably the most popular one) for Programming computers. It is possible to do structured programming in almost any procedural programming languages.

Edsger Dijkstra a professor of computer science at the Technological University at Eindhoven proposes that GOTO statements be abolished from all high-level languages such as BASIC. Modern programming languages such as Visual Basic do away with the need for GOTO statements.

A computer program is said to be structured if it has a modular design and uses only the three types of logical structures, sequences, decisions and loops.

Sequences: Statements are executed one after another.

Decisions: One of two blocks of program code is executed based on a test for some condition.

Loops (Iteration): One or more statements are executed repeatedly as long as a specified condition is true.

One major shortcoming of earlier programming languages was their reliance on the GoTo statement. This statement was used to branch (that is jump) from one line of the program to another. It was common for a program to be composed on a convoluted tangle of branching that produced confusing code sometimes referred to as spaghetti code.

The logic of a structured program can be pictured using a flowchart that flows smoothly fro the top to the bottom without unstructured branching (GoTos). Here is an example of a flowchart showing the structure with and without the GoTo statement:

Advantages of Structured Programming

The goal of structured programming is to create correct programs that are easy to write, understand and change.

Earlier Analysis and Design

As programs got more complex, programmers realized that there might be a better way to write programs than getting a problem statement and sitting down and writing code. In other words, a little abstract planning might help. Along these lines, some abstract modeling techniques were developed. Earlier methods included flowcharts and functional specifications, functional decomposition. Later techniques involved:

The later techniques arose from the structured programming languages, and became used in structured analysis and design. The intention of the models was to create extra levels of abstraction between the real-world problem/system and the computer implementation of the system. They served as a bridge between the real world situation, and the computer code. The problem was mapped into a verbal problem statement, and then into a requirements analysis model, which was far removed from the machine implementation. The analysis model was then mapped into a design model, which was one step closer to the machine implementation (the code). Finally, code was written from the design model. However, these earlier abstract models all ran on one premise -- there is data, and there are functions that process the data. The first models attempted only to model the functionality of the real-world systems. Later, entity relationship diagrams were added -- these modeled the data, or the static nature of the system. However, the functionality models and the data models were distinct and separate entities.

1.1.4 Object-oriented

In object-oriented programming programmers define not only the data type of a data structure, but also the types of operations (functions) that can be applied to the data structure. In this way, the data structure becomes an object that includes both data and functions. In addition, programmers can create relationships between one object and another. For example, objects can inherit characteristics from other objects. Objects and object interactions are the basic elements of design.

One of the principal advantages of object-oriented programming techniques over imperative programming techniques is that they enable programmers to create modules that do not need to be changed when a new type of object is added. A programmer can simply create a new object that inherits many of its features from existing objects. This makes object-oriented programs easier to modify.

The advantages of object-oriented programming do not evidence themselves when you are writing a single function for a particular purpose. Instead, the advantages arise when you are designing a large system that will do similar , but not identical, things to a variety of data objects. By specifying classes of data objects for which identical effects will occur, you can define a single generic function that embraces the similarities across object types, but permits individual implementations or methods for each defined class. As an example of languages that implements object paradigm are Smalltalk, Delphi and Java.

OO The Object Oriented Paradigm

Is it possible to make a computer think the way people naturally think, rather than in terms of data and instructions that process data? The base machine will probably always think in terms of data and instructions that process data. However, are there high-level languages that can add another layer of abstraction on top of the machine, so that the high level languages can be written in code that mirrors the way people think? Yes, of course -- these are the OO languages! Some OO languages are better at hiding the basic premise of the machine. Smalltalk is probably the best, while C++ is probably the worst .

Abstraction

Software objects mirror the human mind's tendency to abstract out details. Software objects hide the internal details of an object behind the walls of an interface. The "user" or "client" of an object does not have to worry about the inner details of the object, only the abstract principles of the object, as defined by the interface.

1.2. The Windows Environment

Windows is a Graphical User Interface (GUI). It uses graphics to organize the user’s workspace. User’s choose items and execute programs by pointing and clicking with a mouse. The program that run from within Windows also have a Graphical User Interface (GUI); for example, MS-Excel and MS-Word. Moreover these programs can run only within Windows. This is because Windows provides these programs with a number of built in functions and data which are not available in other environments. The functions that are provided by windows include functions with the functionality to draw text in different sizes and styles using font data. Windows provides a broad range of graphical functions for drawing lines and geometric shapes and changing color. Windows program make use of these built in functions and do not have to be coded to perform these tasks.

These system defined functions that an application can call are provided by an interface known as the Application Program Interface (API) Every Windows environment has its unique API. For example, the API that Windows 95 supports (also called the Win32 interface) is a 32-bit API. All the functions supported by the API can work with 32 bits of information at any given time. Writing programs for the Windows environment using the API functions is referred to as SDK programming where SDK stands for Software Development Kit.

1.3

A History of Windows

Windows promised an easy-to-use graphical interface, device-independent graphics and multitasking support. The development was delayed several times, however, and the Windows 1.0 hit the store shelves in November 1985. The selection of applications was sparse, however, and Windows sales were modest.

Windows 1.0 package, included

MS-DOS Executive, Calendar, Cardfile, Notepad, Terminal, Calculator, Clock, Reversi, Control Panel, PIF (Program Information File) Editor, Print Spooler, Clipboard, RAMDrive, Windows Write, Windows Paint.

On November 10, 1983, Microsoft announced Microsoft Windows, an extension of the MS-DOS operating system that would provide a graphical operating environment for PC users. Microsoft called Windows 1.0 a new software environment for developing and running applications that use bitmap displays and mouse pointing devices. With Windows, the graphical user interface (GUI) era at Microsoft had begun.

The release of Windows XP in 2001 marked a major milestone in the Windows desktop operating system family, by bringing together the two previously separate lines of Windows desktop operating systems.

With the upcoming release of Windows .NET Server, Microsoft will complete a cycle of server operating system upgrades it began nearly a decade ago in 1993, with the release of the first version of Microsoft Windows NT Server. To understand the progression of Windows server operating systems you have to look back earlier than 1993, however, to the even longer line of Windows desktop operating systems stretching back to the early 1980s.

To explain the many advances since Windows 1.0, the following pages summarize milestones in the development of Windows desktop operating systems at Microsoft.

Many longtime PC users trace Windows to the 1990 release of Windows 3.0, the first widely popular version of Windows and the first version of Windows many PC users ever tried. But Microsoft actually released the first version of Windows six years earlier, in 1985. To understand the roots of today's Windows operating systems, we must journey back nearly 20 years.

The Windows 1.0 product box showed the new tiled windows and graphical user interface in the operating system

1985: Windows 1.0

The first version of Windows was a milestone product because it allowed PC users to switch from the MS-DOS® method of typing commands at the C prompt (C:\) to using a mouse to point and click their way through functions, such as starting applications, in the operating system.

Windows 1.0 also allowed users to switch between several programs—without requiring them to quit and restart individual applications. The product included a set of desktop applications, including the MS-DOS file management program, a calendar, card file, notepad, calculator, clock, and telecommunications programs, which helped users manage day-to-day activities.

Even before the Windows 1.0 graphical user interface, there was this pre-Windows 1.0 Interface Manager

1987: Windows 2.0

With the second version of Windows, Microsoft took advantage of the improved processing speed of the Intel 286 processor, expanded memory, and inter-application communication capabilities using Dynamic Data Exchange (DDE). Windows 2.0 featured support for the VGA graphics standard, and also allowed users to overlap windows, control screen layout, and use keyboard combinations to move rapidly through Windows operations.

Many developers started writing their first Window-based applications for Windows 2.x. Following the release of Windows 2.0 was Windows/386 2.03, which took advantage of the protected mode and extended memory capabilities of the Intel 386 processor.

Subsequent Windows releases continued to improve the speed, reliability, and usability of the PC, and improved the interface design and capabilities.

1990: Windows 3.0

Microsoft's first mainstream computing platform offered 32-bit performance, advanced graphics, and full support of the more powerful Intel 386 processor. A new wave of 386 PCs helped drive the popularity of Windows 3.0, which offered a wide range of new features and capabilities, including:

• Program Manager, File Manager, and Print Manager
• A completely rewritten application development environment with modular virtual device drivers (VxDs), native support for applications running in extended memory, and fully pre-emptive MS-DOS multitasking
• An improved set of Windows icons

The popularity of Windows 3.0 blossomed with the release of a completely new Windows software development kit (SDK), which helped software developers focus more on writing applications and less on writing device drivers. Widespread acceptance among third-party hardware and software developers helped fuel the success of Windows 3.0.

Windows 3.0 featured a new File Manager

1993: Windows for Workgroups 3.11

A superset of Windows 3.1, Windows for Workgroups 3.11 added peer-to-peer workgroup and domain networking support. For the first time, Windows PCs were natively network-aware and became an integral part of the emerging client/server computing evolution.

Windows for Workgroups was used in local area networks (LANs) and on stand-alone PCs and laptop computers. It added features of special interest to corporate users, such as centralized configuration and security, significantly improved support for Novell NetWare networks, and remote access service (RAS). Windows for Workgroups also offered the performance benefits of Microsoft's new 32-bit file system.

1993: Windows NT 3.1

The release to manufacturing of Microsoft Windows NT® on July 27, 1993, marked an important milestone for Microsoft. It completed a project Microsoft began in the late 1980s to build an advanced new operating system from scratch. "Windows NT represents nothing less than a fundamental change in the way that companies can address their business computing requirements.

Windows NT was the first Windows operating system to combine support for high-end client/server business applications with the industry's leading personal productivity applications. The operating system broke new ground in security, operating system power, performance, desktop scalability, and reliability with a range of key new features. These included a pre-emptive multitasking scheduler for Windows-based applications, integrated networking, domain server security, OS/2 and POSIX subsystems, support for multiple processor architectures, and the NTFS file system.

Windows NT 3.1 contained overlapping windows and other features similar to Windows 3.1

The new operating system began with version 3.1 in order to maintain consistency with Windows 3.1, which at the time was a well-established operating system for both home and business users.

Windows NT was geared toward business users and was initially available in both a desktop (workstation) version and a server version called Windows NT Advanced Server. The desktop version was well received by developers because of its security, stability, and rich Microsoft Win32® application programming interface (API)—a combination that made it easier to support powerful programs.

Windows NT was a strategic platform that could integrate client/server applications with existing Windows-based desktop applications, or function as a technical workstation to run high-end engineering or scientific applications.

1993: Windows NT Workstation 3.5

Windows NT Workstation 3.5 supported the OpenGL graphics standard, which helped power high-end applications for software development, engineering, financial analysis, scientific, and business-critical tasks.

The Windows NT Workstation 3.5 release provided the highest degree of protection yet for critical business applications and data. The product also offered 32-bit performance improvements, better application support, including support for NetWare file and print servers, and improved productivity features, such as the capability to give files 255-character names.

1995: Windows 95

Windows 95 was the successor to Microsoft's three existing general-purpose desktop operating systems—Windows 3.1, Windows for Workgroups, and MS-DOS. Windows 95 included an integrated 32-bit TCP/IP stack for built-in Internet support, dial-up networking, and new Plug and Play capabilities that made it easy for users to install hardware and software.

The 32-bit operating system also offered enhanced multimedia capabilities, more powerful features for mobile computing, and integrated networking. In order to keep memory requirements to a minimum, it did not include support for such features as system-level security or Unicode, which came later.

1996: Windows NT Workstation 4.0

This upgrade to Microsoft's business desktop operating system brought increased ease of use and simplified management, higher network throughput, and a complete set of tools for developing and managing intranets.

Windows NT Workstation 4.0 included the popular Windows 95 user interface and improved networking support, providing secure, easy access to the Internet and corporate intranets.

In October 1998, Microsoft announced that Windows NT would no longer carry the initials  NT," and that the next major version of the operating system would be called Windows 2000.

1998: Windows 98

Windows 98 was the upgrade to Windows 95. Described as an operating system that "Works Better, Plays Better," Windows 98 was the first version of Windows designed specifically for consumers.

Windows 98 enabled users to find PC- or Internet-based information easily, it opened and closed applications more quickly, and it included support for reading DVD discs and connecting to universal serial bus (USB) devices.

1999: Windows 98 Second Edition

Microsoft Windows 98 SE, as it was often abbreviated, was an incremental update to Windows 98. It offered consumers a variety of new and enhanced hardware compatibility and Internet-related features.

Windows 98 SE delivered an improved online experience with Internet Explorer 5 browser software and Microsoft Windows NetMeeting® version 3.0 conferencing software. It also included Microsoft DirectX® API 6.1, which delivered a variety of Windows multimedia improvements, and offered home networking capabilities through Internet connection sharing (ICS). Windows 98 SE was also Microsoft's first consumer operating system capable of using device drivers that also worked with the Windows NT business operating system.

2000: Windows Millennium Edition (Windows Me)

Windows Me offered consumers numerous music, video, and home networking enhancements and reliability improvements.

System Restore let users roll back their PC software configuration to a date or time before a problem occurred. Windows Movie Maker provided users with the tools to digitally edit, save, and share home videos. Microsoft Windows Media™ Player 7 technologies allowed users to easily find, organize, and play digital media.

Windows Me was the last Microsoft operating system to be based on the Windows 95 kernel. Microsoft announced that all future operating system products would be based on the Windows NT and Windows 2000 kernel.

2000: Windows 2000 Professional

Figure 1

Windows 2000 Professional was the upgrade to Windows NT Workstation 4.0, but it was more than just that. Windows 2000 Professional was designed to replace Windows 95, Windows 98, and Windows NT Workstation 4.0 on all business desktops and laptops. Built on top of the proven Windows NT Workstation 4.0 code base, Windows 2000 added major improvements in reliability, ease of use, Internet compatibility, and support for mobile computing.

Windows 2000 Professional also made hardware installation much easier than it was with Windows NT Workstation 4.0 by adding support for a wide variety of new Plug and Play hardware, including advanced networking and wireless products, USB devices, IEEE 1394 devices, and infrared devices.

2001: Windows XP

Windows XP is a unifying leap forward for desktop operating systems. With the release of Windows XP Home Edition and Windows XP Professional in October 2001, Microsoft succeeded in merging its two Windows operating system lines for consumers and businesses, uniting them around the Windows NT and Windows 2000 code base.

With Windows XP, consumers and home users now have performance, stability, and security that business users benefited from in Windows 2000.

Windows XP also includes the broad base of application and hardware compatibility of Windows 98 and Windows Me, while adding new tech-support technology, a fresh user interface, and many other improvements that make it easier to use for a broad range of tasks.

Windows XP is available in two main versions, Windows XP Professional and Windows XP Home Edition, as well as a 64-bit edition, Windows XP 64-Bit Edition, for power users with workstations that use the Intel Itanium 64-bit processor.

2001: Windows XP Professional

Windows XP Professional benefits from the long track record of Microsoft Windows NT technology: superior operating system performance, including preemptive multitasking, fault tolerance, and system memory protection.

Windows XP Professional also offers a redesigned interface and includes features for business and advanced home computing, including Remote Desktop, encrypting file system, system restore and advanced networking features. It also offers numerous key enhancements such as wireless 802.1x networking support, Windows Messenger, Remote Assistance, and the System Restore feature.

2001:WindowsXPHomeEdition

Windows XP Home Edition offers a clean, simplified visual design that makes frequently accessed features more accessible. The product offers many enhancements aimed at home users such as the Network Setup Wizard, Microsoft Windows Media™ Player, Windows Movie Maker, and enhanced digital photo capabilities.

1.4 Windows Programming Model

Programs written for traditional operating environments use a procedural programming model in which programs execute from top to bottom in an orderly fashion. The path taken from start to finish may vary with each invocation of the program depending on the input it receives or the conditions under which it is run, but the path remains fairly predictable. In a C program, execution begins with the first line in the function named main and ends when main returns. In between, main might call other functions and these functions might call even more functions, but ultimately it is the program—not the operating system—that determines what gets called and when.

Windows programs operate differently. They use the event-driven programming model illustrated in Figure 1.4, in which applications respond to events by processing messages sent by the operating system. An event could be a keystroke, a mouse click, or a command for a window to repaint itself, among other things. The entry point for a Windows program is a function named WinMain, but most of the action takes place in a function known as the window procedure. Figure 1.4 Windows Programming Model

The window procedure processes messages sent to the window. WinMain creates that window and then enters a message loop, alternately retrieving messages and dispatching them to the window procedure. Messages wait in a message queue until they are retrieved. A typical Windows application performs the bulk of its processing in response to the messages it receives, and in between messages, it does little except wait for the next message to arrive.

 The message loop ends when a WM_QUIT message is retrieved from the message queue, signaling that it's time for the application to end. This message usually appears because the user selected Exit from the File menu, clicked the close button (the small button with an X in the window's upper right corner), or selected Close from the window's system menu. When the message loop ends, WinMain returns and the application terminates.

1.5 Dynamic Link Library (DLL)

Dynamic Link Library (DLL) is a collection of software routines programmed in a language such as C or Pascal, which has been packaged especially for use from another program. For example, a C programmer might write a routine that accesses a laser disc player. By compiling this as a DLL, it might be usable by an author of a Windows Help hyper book, without them having to know anything about the programming. In windows programming DLL plays an important part. Windows provides function calls to implement its user interface and display text and graphics on the video display. These functions are implemented in DLL. These are files with extension .DLL or .EXE.

The original idea for the DLL system was that there would be a central repository of code. Here are the advantages:

• Applications would link to this code library, thus saving greatly on duplication of effort and storage space.
• Applications that used the DLL system would behave exactly the same as all other applications that used it.
• If a problem arose, or a new feature was desired, it could be written once and all would benefit. In this sense, the DLL system is a weak version of the object-programming paradigm.

Naturally enough, along with these advantages came some responsibilities. An application should only place a DLL in the central repository if:

• The DLL was newer and/or better than the ones already there.
• The DLL was uniquely named, i.e. did not conflict with a DLL for another purpose with the same name.
• If the DLL replaced another with the same name, then the code in the DLL would be exhaustively tested, so that on replacement, other applications could use it in the same way as its predecessor.

In time, all these rules have been broken, even by Microsoft itself, the originator of the idea.

• On several occasions Microsoft has created and distributed DLL files that instantaneously broke every Windows application in the world.
• Regularly, end users will install an application that has a DLL with the same name as a "system" DLL, thus mysteriously bringing down the system until an expert can sort it out.
• Over time, the "synchronization" problem becomes more severe. In this scenario, a DLL is replaced that brings it into conflict with other DLLs it must work with.
• The service pack problem is becoming severe. In this scenario, Microsoft releases a service pack that updates all key system DLLs. All the elements of the service pack must simultaneously be present in their most recent form or the system will crash. Then the user installs an application that blithely replaces one or more of the DLLs from the service pack. Result – system failure, even on Windows NT 4.0, which, notwithstanding its reputation for stability and resilience, will fail utterly and completely.

This is an example of a collision between an idea and reality, a key element in the human drama. The idea was sound, but it failed to take into account the imperfections in the human character, in particular those imperfections that influence the creation and operation of computer programs. The reality is that Microsoft and any number of software vendors regularly risk the stability and security of the end user's machine by writing DLL code as though it were normal programming. It isn't. To write a DLL, you must imagine the effect of your changes and additions on every computer program that uses it. This is obviously impossible. The solution to these problems is to go back to the system that preceded the DLL system. Every application should place as many DLL files as possible in its own directory (some DLL files are part of Windows itself, these must be accessed in common). No application should assume that it can copy DLLs into the system directory or that its newer version of a system DLL is safe to copy solely because it is newer. Many applications (including Microsoft's own) have rendered systems unstable or unusable through this reasoning.

Win32s DLL Libraries

The Win32s DLL Libraries are an add-on set of programs that expand the MS Windows 3.1 and MS Windows for Workgroups 3.11 systems so that they can run programs that follow the Win32s standard from MicroSoft. By allowing them to run Win32s compliant programs, programers can write programs to follow that standard and have it run, hopefully, on MS Windows 3.1, MS Windows for Workgroups 3.11, MS Windows 95 and MS Windows NT.

MS DOS and MS Windows 3.1/MS Windows for Workgroups 3.11 run 16-bit coded programs. The limit to 16-bit allows them to run on older computers with no significant changes. MS Windows 95 and MS Windows NT run 32-bit coded programs and do not need DOS at all. The 32-bit code needs at least a 386 IBM Compatible computer to run because the code is 32-bits instead of 16-bits it can:

In the course of writing and distributing Windows applications, the majority of customer problems were related to DLLs. If you create a program that assumed that standard Windows system DLLs would be present, those DLLs would not be present or would not be current, and the application would fail. If I took it upon myself to follow the DLL guidelines and copy DLLs into the system directory after ascertaining that my DLL was newer than the current one, other applications would fail. To avoid this problem it is better to include in the application all required DLLs in the program directory.

1.6 API (Application Programming Interface)

A set of routines, protocols, and tools for building software applications. A good API makes it easier to develop a program by providing all the building blocks. A programmer puts the blocks together.

API (Application Programming Interface) is a set of commands, which interfaces the programs with the processors. The most commonly used set of external procedures are those that make up Microsoft Windows itself. The Windows API contains thousands of functions, structures, and constants that you can declare and use in your projects. Those functions are written in the C language, however, so they must be declared before you can use them. The declarations for DLL procedures can become fairly complex. Specifically to C# it is more complex than VB. You can use API viewer tool to get API function declaration but you have to keep in mind the type of parameter which is different in C#.

Most of the advanced languages support API programming. The Microsoft Foundation Class Library (MFC) framework encapsulates a large portion of the Win32 (API). ODBC API Functions are useful for performing fast operations on database. With API your application can request lower-level services to perform on computer's operating system. As API supports thousands of functionality from simple Message Box to Encryption or Remote computing, developers should know how to implement API in their program.

API\’s has many types depending on OS, processor and functionality.

OS specific API:

Each operating system has common set of API's and some special

e.g.

Windows NT supports MS-DOS, Win16, Win32, POSIX (Portable Operating System Interface), OS/2 console API and Windows 95 supports MS-DOS, Win16 and Win32 APIs.

Win16 & Win32 API:

Win16 is an API created for 16-bit processor and relies on 16 bit values. It has platform independent nature.

e.g. you can tie Win16 programs to MS-DOS feature like TSR programs.

Win32 is an API created for 32-bit processor and relies on 32 bit values. It is portable to any operating system, wide range of processors and platform independent nature. Win32 API’s has ‘32’ prefix after the library name e.g. KERNEL32, USER32 etc…

All APIs are implemented using 3 Libraries.

KERNEL

It is the library named KERNEL32.DLL, which supports capabilities that are associated with OS such as

e.g. The GlobalMemoryStatus function obtains information about the system's current usage of both physical and virtual memory

USER

This is the library named "USER32.DLL" in Win32. This allows managing the entire user interfaces such as :

e.g. The DrawIcon function draws an icon or cursor into the specified device context.

GDI (Graphical Device Interface)

This is the library named "GDI32.dll" in Win32. It is Graphic output library. Using GDI Windows draws windows, menus and dialog boxes.

e.g. The CreateBitmap function creates a bitmap with the specified width, height, and color format (color planes and bits-per-pixel).

1.7 The Programming Environment

The Microsoft Visual C++ package includes more than the C compiler and other files and tools necessary to compile and link windows programs. It also includes the Visual C++ Developer Studio an environment in which you can edit your source code, create resources such as icons and dialog boxes and edit, compile, run and debug your programs. The msdn portion of the Microsoft URL stands for Microsoft Developer Network which is a program that provides developers with the frequently updated CD-ROMs containing much of what they need to be on the cutting edge of windows development.

1.7.1 Graphical User Interface Concepts

Since the invention of Graphical User Interface (GUI) is in 1972 from that we have seen a good number of attempts to define and build the perfect GUI. GUI consists of number of elements such as:

GUIs offer a standard look and feel to application thus reducing development and learning time. A GUI is an environment that can work with graphic objects and it allows event-based interaction with program for e.g., clicking on mouse buttons, entering data through a text field (like for the calculator tool). Each event triggers the execution of event handler function to take appropriate action. Microsoft Windows a typical example has the following components.

A GUI enforces consistency by restricting developers they must support features for the program to run under the GUI. In addition one benefit of GUI is that the user can learn a second application faster because he or she is familiar with the environment. Note that the benefit comes with succeeding applications. Consistency and familiarity help produce shorter learning curves. Users generally prefer the interface style they know, whether it be Macintosh or Microsoft Windows. The consistency offered by a GUI trades on the users familiarity with the environment.

Drawing and CAD programs are the best suited to GUI. Since, by their nature they manipulate objects lines and curves, fill closed areas with color. For database programs, such manipulation is not as useful. However they can use GUIs effectively to:

The last point is particularly important. Database applications often must transfer data to and from spreadsheets, word processors, desktop publishing programs, business or presentation graphics programs, statistics programs or project management software. GUIs generally have data exchange features, such as Microsoft windows dynamic data exchange (DDE) to handle such transfers.

A final benefit of GUI is that it lets you see the final product before you print it. What You See Is What You Get (WYSIWYG) is a feature essential to desktop publishing and drawing applications and useful in database applications (so you can inspect reports to see that all data fits on the page).

However there are drawbacks associated with using GUI. The cost includes the expense of graphics cards, pointing device (such as mouse) and extra memory. Because GUIs run in graphics mode, screen refresh is usually slower as well. If speed is important, a GUIs consistency may not be sufficient compensation.

1.8 Event Driven Programming

While your program was looking for a particular kind of input, be it a mouse click or a key press, it wasn’t doing any other work. If at a particular place in your program you were looking for a mouse click and a key was pressed, generally the key press was ignored (at least at that instant). While this approach to programming is functional in many situations, it does not work very well when there are multiple possible sources of input whose arrival time you cannot predict and where it is unacceptable to ignore any of the inputs. As an example consider the case of a VCR.

On a typical VCR there are a number of buttons, sensor inputs for tape in and the end of the tape as well as commands that can be received from the remote control. The program for the embedded computer controlling the VCR must be able to respond to any of those inputs at any time and in any sequence. For example, while running fast forward, you can stop, play, change channels, and program the VCR to record or any number of other actions. The program cannot move to only looking for the channel select buttons while you are programming, or it would miss the end of tape sensor for the rewinding tape.

Clearly, what we need is a program structure that will allow us to respond to a multitude of possible inputs, any of which may arrive at unpredictable times and in an unpredictable sequence. While this problem is very common in embedded systems, like the VCR, it is also very common in modern desktop computers. Think about using a word processor. While you are typing, the program is accepting your keys and entering the characters into your document. You can also click with the mouse at any place on the screen. If the mouse pointer is at another place in your document, the point of insertion moves. If it is in the menu bar, a menu will drop down. If it is over a formatting button, it may change the format of the next character entered. Your word processor, or most other programs running under Windows, MacOS, X-Windows or any other modern Graphical User Interface(GUI), must also be capable of dealing with the same kind of variable input that the VCR must handle. All of these operating systems, and many embedded applications, have adopted a common program structure to deal with the need to respond to many asynchronous (not time sequence) inputs. This program structure is generally called event driven programming.

Under the event driven programming model, the program structure is divided into two rough groups, Events and Services. An event represents the occurrence of something interesting. A service is what you do in response to the event. While events most often originate from the outside your program, such a mouse click, events can also generated by other parts of the program. The program executes by constantly checking for possible events and, when an event is detected, executing the associated service.

In order for this approach to work, the events must checked continuously and often. This implies that the services must execute quickly, so that the program can get back to checking for events. In order to meet this requirement, the service can not to go into a state where it is waiting for some long or indeterminate time. The most common example of this would be a while loop where the condition for termination was not under program control, for example; a switch closure. This kind of program structure, an indefinite loop is referred to as ‘Blocking ‘ code. In order for the even t driven programming model to work, you must only write ‘Non-Blocking’ code. So how to deal with the need to wait for the switch close? You make the switch closure an event. Then, rather than waiting in a loop for the switch to close, you program a service that does the right thing when the switch closes and let all of the event checkers run while you are waiting for the switch to close. In this way, you could also react to another event while you were waiting for the switch to close.

Event Checkers

An event, by its nature, represents a discrete point in time. At one instant, the event has not occurred , at the next it has. In the case of a switch, the opening or closing of the switch represents an event. The switch being open or closed does not represent an event. The event is marked by the transition from open to closed.

1.9 Header Files

Windows programs begin with a processor directive at the top such as :

#include <windows.h>

WINDOWS.H is a master file that includes other Windows header files, some of which also include other header files. The most important and most basic of these header files are:

These header files define all the Windows data types, function calls, data structures and constant identifiers. They are important part of Windows documentation.

1.10 Program Entry Point

In windows program the entry point is WinMain similar to the main function in C program. The WinMain function appears like this:

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR szCmdLine,

int nCmdShow)

It is declared in WINBASE.H like so (line breaks and all) :

int

WINAPI

WinMain(

HINSTANCE hInstance,

HINSTANCE hPrevInstance,

LPSTR lpCmdLine,

int nShowCmd

);

This declaration uses a system called “Hungarian notation” through which the variable name is indicated with a short prefix that indicates the variables data type. This notation will be discussed later. The first parameter to WinMain is an “instance handle”. In windows programming a handle is simply a number that an application uses to identify something. In this case the handle uniquely identifies the program. It is required as an argument to some other windows function calls. In early versions of windows when you run the same program concurrently more than once, multiple instances of that program will be created. A program can determine if other instances of itself are running by checking the hPrevInstance parameter. In 32 bit versions this concept has been abandoned.

The second parameter to WinMain is always NULL (defined 0). The third parameter to WinMain is command line used to run the program. The fourth parameter to WinMain indicates how the program should be initially displayed either normally or maximized to fill the window or minimized to be displayed in the task list bar.

1.11 Compile, Link and Run Windows program

When you are ready to compile your program named samplewinprg, you can select Build samplewinprg.exe from the Build menu or press F7, or select the Build icon from the Build toolbar. The appearance of this icon is shown in the Build menu. If the Build toolbar is not currently displayed you can choose Customize from the tools menu and select the Toolbars tab. Pick Build or Build MiniBar. Alternatively you can execute samplewinprg.exe from the Build menu by pressing Ctrl+F5 or click the Execute program icon. From the Build toolbar. A message will be displayed asking if you want to build the program.

During compilation the compiler generates an .OBJ(object) file from the C source code file. During the ling stage the linker combines the .OBJ file with .LIB(library) files to create the .EXE(executable) file. You can see a list of these library files by selecting settings from the Project tab and clicking the Link tab. In particular you’ll notice KERNEL32.LIB, USER32.LIB, and GDI32.LIB. These are “import libraries” for the three major Windows subsystems. They contain the dynamic-ling library names and reference information that is bound in to the .EXE file. Windows uses this information to resolve calls from the program to function in the KERNEL32.DLL, USER32.DLL and GDI32.DLL dynamic link libraries. In Visual C++ Developer Studio, you can compile and link the program in different configurations. By default these are called Debug and Release.

1.12 MessageBox Function

The MessageBox function is designed to display short messages. The window that a MessageBox displays is considered to be a dialog box. The first argument to MessageBox is normally a window handle. The second argument is the text string that appears in the body of the message box and the third argument is the text string that appears in the caption bar of the message box. The fourth parameter can be any of the combination of constants beginning with the prefix MB_ that are defined in the WINUSER.H. The list of buttons that can appear in dialog box are:

MB_OK

MB_OKCANCEL

MB_ABORTRETRYIGNORE

MB_YESNO

MB_YESNOCANCEL

MB_RETRYCANCEL

The appearance of the icon in the message box can be any one of the following:

MB_ICANHAND

MB_ICONEXCLAMATION

MB_ICONASTERISK

1.13 Data Types

Windows programming has a reputation for its variety of data types, it uses all C data types and also introduces a few data types of its own. The sample windows application illustrated in this chapter uses a few of the Windows data types.

The following code displays a message as displayed in figure 2.10(a)

# include <windows.h>

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,PSTR szCmdLine,

int nCmdShow)

{int i;

MessageBox(0,"Application executing","Application",MB_OK);

return(0);

}

Figure 2.10(a) Sample Output

In this program, the MessageBox function returns the value 1, but it is more proper to say that it returns IDOK, which is defined in WINUSER.h as equaling 1.Each running copy of a program is called an instance. To refer to a particular instance of a program, a handle is required. A handle is an unsigned integer that Windows uses internally to keep track of objects in memory. For example, every window on the screen has a unique window handle. Handles are also used to keep a track of running applications, allocated memory blocks and a host of other objects.

A handle is simply a number assigned by the system to a particular entity. It serves to identify the entity, whether it is an instance, a window, a control or a block of memory. All objects in windows are referred to by handles. Handles are a replacement of pointers. There are a number of related data types for describing different kinds of handles. All these data types begin with the letter H. Thus, HWND is the data type for a window handle, and HPEN is the handle to PEN. In the program shown above, hInstance is the handle that identifies the current instance of the application and hPrevInstance contains the hInstance value for the last copy of application.

Internally the Kernel of windows maintains tables that allow windows to convert handles to physical memory addresses. A handle is a pointer to a memory location. The reason for this complexity is that windows moves objects (memory blocks, programs and so on) in memory to make room for others. If windows moves and object in memory, the handle table is updated. The handle used by the program does not need to change since it always gets correctly translated to the right physical memory addresses by the windows kernel, no matter where the object is moved in memory. Figure 2.10(b) displays a representation of handles in the memory.

Program Windows Kernel Memory

HandleHandle TablePhysical Address

Figure 2.10(b) Handles in the Memory

If a pointer was used to refer to an object in memory, the pointer will be invalid when the object is moved by windows as a part of its memory management. Thus pointers can be dereferenced whereas handles will continue to be valid since the handle to pointer table will be updated automatically by windows whenever it moves an object in memory.

In the above program, LPSTR is another new windows data type that is used; it is used to store a Long Pointer to a String same as the char data type of C. The MessageBox function of the Win32 API displays a message on the screen, with the specified title and message text, the message displayed will show an OK button also, which will dismiss the MessageBox as specified by the MB_OK parameter.

1.14 Hungarian Naming Convention

The names of the variables used in a window program follow a naming convention called Hungarian notation, in honor of its inventor Charles Simonyi. The idea is to precede variable names with key letters that describe the type of data the variable represents and follow a verb-noun combination. The Table 1.14 represents the Hungarian notations.

Table 1.14 Variable Name Codes in Hungarian Notation

1.15 Windows String Functions

2.2 Device Context

Returns an integer that identifies the device-context of window if it has one, or nil otherwise. A device-context is a construct used in the Windows API to specify a set of parameters that are used when drawing on a window. A common graphics application does not normally need to deal with a window's device-context directly, but if you need to pass the window to a WINAPI function that calls for the window's device-context (or hDC), then you should pass the integer returned by this function for that argument. Every non-control window in common graphics (and every lisp-widget window) is automatically assigned a device-context, which it keeps until it is closed. Controls supplied by the OS (all controls except lisp-widgets), on the other hand, are not automatically given device-contexts in lisp since it is normally only the OS rather than lisp that draws on the control. If you do want to draw directly on a non-lisp control, then you must give the window of the control a device-context while drawing on it.

2.3 The WM_PAINT message

The WM_PAINT message is a request to repaint the window. Every application is responsible for redrawing its window(s). This means that the application will have to keep track of the current state, so that it knows that to draw. In most cases, the WM_PAINT message will be triggerd from the outside. However, it is also possible to trigger WM_PAINT from inside the application. With the Invalidate() function, you can tell that the contents of a window are no longer valid so that it will need to be redrawn. With the InvalidateRect() function, you can specify that only part of the window content is invalid, so that only that part will be redrawn. In this way, you can prevent the flickering of the screen when redrawing. Because paint message have very low priority, you might want to send an immediate redraw request. You can do this with the UpdateWindow() function.

2.4 Getting a Device Context Handle

There are two methods in getting a Device Context handle. The first method is by processing WM_PAINT messages. Two functions involved in this process are BeginPaint and EndPaint. These functions require the handle to window, which is passed to the window procedure as an argument and the address of a structure variable of type PAINTSTRUCT which has to be defined within the window procedure like so:

PAINTSTRUCT ps; // where ps is the paint structure variable

While processing a WM_PAINT message the window procedure first calls the function BeginPaint which causes the background of the invalid region to be erased and prepare the window for painting. This function fills the fields of the paint structure. The value returned by BeginPaint is a device context handle. This value can be stored in a variable commonly named as hdc, which has to be defined in window procedure like so:

HDC hdc; // handle to DC

HDC is a data type defined as a 32 bit integer. After the definition of HDC the program can use functions like TextOut. The call to EndPaint releases the device context handle. The processing of WM_PAINT message looks like this:

case WM_PAINT:

hdc = BeginPaint(hwnd,&ps);

[ GDI functions]

EndPaint (hwnd,&ps);

return 0;