Source Code - Koreng

Other Preprocessor Commands

2009-01-14T09:00:00.000-08:00

The C Preprocessor

Recall that preprocessing is the first step in the C program compilation stage -- this feature is unique to C compilers. The preprocessor more or less provides its own language which can be a very powerful tool to the programmer. Recall that all preprocessor directives or commands begin with a #.
Use of the preprocessor is advantageous since it makes:

programs easier to develop,
easier to read,
easier to modify
C code more transportable between different machine architectures.

The preprocessor also lets us customise the language. For example to replace { ... } block statements delimiters by PASCAL like begin ... end we can do:

#define begin { #define end }

During compilation all occurrences of begin and end get replaced by corresponding { or } and so the subsequent C compilation stage does not know any difference!!!.
Lets look at #define in more detail

#define

Use this to define constants or any macro substitution. Use as follows:


    #define   
 
For Example
 
   #define FALSE  0
   #define TRUE  !FALSE

We can also define small ``functions'' using #define. For example max. of two variables:
   #define max(A,B) ( (A) > (B) ? (A):(B))
? is the ternary operator in C.
Note: that this does not define a proper function max.
All it means that wherever we place max(C,D) the text gets replaced by the appropriate definition. [ = any variable names - not necessarily C and D]
So if in our C code we typed something like:
   x = max(q+r,s+t);
after preprocessing, if we were able to look at the code it would appear like this:
   x = ( (q+r) > (r+s) ? (q+r) : (s+t));
Other examples of #define could be:
#define Deg_to_Rad(X) (X*M_PI/180.0) /* converts degrees to radians, M_PI is the value of pi and is defined in math.h library */ #define LEFT_SHIFT_8 <<8
NOTE: The last macro LEFT_SHIFT_8 is only valid so long as replacement context is valid i.e. x = y LEFT_SHIFT_8.

#undef

This commands undefined a macro. A macro must be undefined before being redefined to a different value.

#include

This directive includes a file into code.

It has two possible forms:

#include or #include ``file''

tells the compiler to look where system include files are held. Usually UNIX systems store files in usrinclude directory.
``file'' looks for a file in the current directory (where program was run from)
Included files usually contain C prototypes and declarations from header files and not (algorithmic) C code (SEE next Chapter for reasons)

#if -- Conditional inclusion

#if evaluates a constant integer expression. You always need a #endif to delimit end of statement.

We can have else etc. as well by using #else and #elif -- else if.

Another common use of #if is with:

#ifdef: -- if defined and
#ifndef: -- if not defined

These are useful for checking if macros are set -- perhaps from different program modules and header files.

For example, to set integer size for a portable C program between TurboC (on MSDOS) and Unix (or other) Operating systems. Recall that TurboC uses 16 bits/integer and UNIX 32 bits/integer.

Assume that if TurboC is running a macro TURBOC will be defined. So we just need to check for this:

#ifdef TURBOC #define INT_SIZE 16 #else #define INT_SIZE 32 #endif

As another example if running program on MSDOS machine we want to include file msdos.h otherwise a default.h file. A macro SYSTEM is set (by OS) to type of system so check for this:
#if SYSTEM == MSDOS #include #else #include ``default.h'' #endif

Preprocessor Compiler Control

You can use the cc compiler to control what values are set or defined from the command line. This gives some flexibility in setting customised values and has some other useful functions. The -D compiler option is used. For example:
   cc -DLINELENGTH=80 prog.c -o prog
has the same effect as:
   #define LINELENGTH 80
Note that any #define or #undef within the program (prog.c above) override command line settings.
You can also set a symbol without a value, for example:
   cc -DDEBUG prog.c -o prog
Here the value is assumed to be 1.
The setting of such flags is useful, especially for debugging. You can put commands like:

#ifdef DEBUG
     print("Debugging: Program Version 1\");
#else
     print("Program Version 1 (Production)\");
#endif

Also since preprocessor command can be written anywhere in a C program you can filter out variables etc for printing etc. when debugging:

x = y *3;

#ifdef DEBUG
     print("Debugging: Variables (x,y) = \",x,y);
#endif

The -E command line is worth mentioning just for academic reasons. It is not that practical a command. The -E command will force the compiler to stop after the preprocessing stage and output the current state of your program. Apart from being debugging aid for preprocessor commands and also as a useful initial learning tool (try this option out with some of the examples above) it is not that commonly used.

There are few other preprocessor directives available:

#error

text of error message -- generates an appropriate compiler error message. e.g #ifdef OS_MSDOS #include #elifdef OS_UNIX #include ``default.h'' #else #error Wrong OS!! #endif

# line

number "string" -- informs the preprocessor that the number is the next number of line of input. "string" is optional and names the next line of input. This is most often used with programs that translate other languages to C. For example, error messages produced by the C compiler can reference the file name and line numbers of the original source files instead of the intermediate C (translated) source files.

Exercises

Exercise 12529
Define a preprocessor macro swap(t, x, y) that will swap two arguments x and y of a given type t.

Exercise 12531
Define a preprocessor macro to select:

the least significant bit from an unsigned char
the nth (assuming least significant is 0) bit from an unsigned char.

Low Level Operators and Bit Fields

2009-01-14T08:59:00.000-08:00

We have seen how pointers give us control over low level memory operations. Many programs (e.g. systems type applications) must actually operate at a low level where individual bytes must be operated on.
NOTE: The combination of pointers and bit-level operators makes C useful for many low level applications and can almost replace assembly code. (Only about 10 % of UNIX is assembly code the rest is C!!.)

Bitwise Operators

The bitwise operators of C a summarised in the following table:

**Table:** Bitwise operators
&	AND
	OR
	XOR
	One's Compliment


<<	Left shift
>>	Right Shift

DO NOT confuse & with &&: & is bitwise AND, && logical AND. Similarly for and .

is a unary operator -- it only operates on one argument to right of the operator.

The shift operators perform appropriate shift by operator on the right to the operator on the left. The right operator must be positive. The vacated bits are filled with zero (i.e. There is NO wrap around).
For example: x << 2 shifts the bits in x by 2 places to the left.

So:

if x = 00000010 (binary) or 2 (decimal)

then:

or 0 (decimal)

Also: if x = 00000010 (binary) or 2 (decimal)

or 8 (decimal)

Therefore a shift left is equivalent to a multiplication by 2.

Similarly a shift right is equal to division by 2

NOTE: Shifting is much faster than actual multiplication (*) or division (/) by 2. So if you want fast multiplications or division by 2 use shifts.

To illustrate many points of bitwise operators let us write a function, Bitcount, that counts bits set to 1 in an 8 bit number (unsigned char) passed as an argument to the function.

int bitcount(unsigned char x) { int count; for (count=0; x != 0; x>>=1); if ( x & 01) count++; return count; }

This function illustrates many C program points:

for loop not used for simple counting operation
x x = x >> 1
for loop will repeatedly shift right x until x becomes 0
use expression evaluation of x & 01 to control if
x & 01 masks of 1st bit of x if this is 1 then count++

Bit Fields

Bit Fields allow the packing of data in a structure. This is especially useful when memory or data storage is at a premium. Typical examples:

Packing several objects into a machine word. e.g. 1 bit flags can be compacted -- Symbol tables in compilers.
Reading external file formats -- non-standard file formats could be read in. E.g. 9 bit integers.

C lets us do this in a structure definition by putting :bit length after the variable. i.e.

struct packed_struct { unsigned int f1:1; unsigned int f2:1; unsigned int f3:1; unsigned int f4:1; unsigned int type:4; unsigned int funny_int:9; } pack;

Here the packed_struct contains 6 members: Four 1 bit flags f1..f3, a 4 bit type and a 9 bit funny_int.
C automatically packs the above bit fields as compactly as possible, provided that the maximum length of the field is less than or equal to the integer word length of the computer. If this is not the case then some compilers may allow memory overlap for the fields whilst other would store the next field in the next word (see comments on bit fiels portability below).
Access members as usual via:
pack.type = 7;
NOTE:

Only n lower bits will be assigned to an n bit number. So type cannot take values larger than 15 (4 bits long).
Bit fields are always converted to integer type for computation.
You are allowed to mix ``normal'' types with bit fields.
The unsigned definition is important - ensures that no bits are used as a flag.

Bit Fields: Practical Example

Frequently device controllers (e.g. disk drives) and the operating system need to communicate at a low level. Device controllers contain several registers which may be packed together in one integer (Figure 12.1).

Fig. 12.1 Example Disk Controller Register We could define this register easily with bit fields:

struct DISK_REGISTER  {
     unsigned ready:1;
     unsigned error_occured:1;
     unsigned disk_spinning:1;
     unsigned write_protect:1;
     unsigned head_loaded:1;
     unsigned error_code:8;
     unsigned track:9;
     unsigned sector:5;
     unsigned command:5;
};

To access values stored at a particular memory address, DISK_REGISTER_MEMORY we can assign a pointer of the above structure to access the memory via:

struct DISK_REGISTER *disk_reg = (struct DISK_REGISTER *) DISK_REGISTER_MEMORY;

The disk driver code to access this is now relatively straightforward:

/* Define sector and track to start read */

disk_reg->sector = new_sector;
disk_reg->track = new_track;
disk_reg->command = READ;

/* wait until operation done, ready will be true */

while ( ! disk_reg->ready ) ;

/* check for errors */

if (disk_reg->error_occured)
  { /* interrogate disk_reg->error_code for error type */
    switch (disk_reg->error_code)
    ......
  }

A note of caution: Portability

Bit fields are a convenient way to express many difficult operations. However, bit fields do suffer from a lack of portability between platforms:

integers may be signed or unsigned
Many compilers limit the maximum number of bits in the bit field to the size of an integer which may be either 16-bit or 32-bit varieties.
Some bit field members are stored left to right others are stored right to left in memory.
If bit fields too large, next bit field may be stored consecutively in memory (overlapping the boundary between memory locations) or in the next word of memory.

If portability of code is a premium you can use bit shifting and masking to achieve the same results but not as easy to express or read. For example:

unsigned int  *disk_reg = (unsigned int *) DISK_REGISTER_MEMORY;

/* see if disk error occured */

disk_error_occured = (disk_reg & 0x40000000) >> 31;

Exercises

Exercise 12507
Write a function that prints out an 8-bit (unsigned char) number in binary format.

Exercise 12514
Write a function setbits(x,p,n,y) that returns x with the n bits that begin at position p set to the rightmost n bits of an unsigned char variable y (leaving other bits unchanged).
E.g. if x = 10101010 (170 decimal) and y = 10100111 (167 decimal) and n = 3 and p = 6 say then you need to strip off 3 bits of y (111) and put them in x at position 10xxx010 to get answer 10111010.
Your answer should print out the result in binary form (see Exercise 12.1 although input can be in decimal form.
Your output should be like this:

x = 10101010 (binary)
   y = 10100111 (binary)
   setbits n = 3, p = 6 gives x = 10111010 (binary)

Exercise 12515
Write a function that inverts the bits of an unsigned char x and stores answer in y.
Your answer should print out the result in binary form (see Exercise 12.1 although input can be in decimal form.
Your output should be like this:

x = 10101010 (binary)
   x inverted = 01010101 (binary)

Exercise 12516
Write a function that rotates (NOT shifts) to the right by n bit positions the bits of an unsigned char x.ie no bits are lost in this process.
Your answer should print out the result in binary form (see Exercise 12.1 although input can be in decimal form.
Your output should be like this:

x = 10100111 (binary)
   x rotated by 3 = 11110100 (binary)

Note: All the functions developed should be as concise as possible

Advanced Pointer Topics

2009-01-14T08:58:00.002-08:00

We have introduced many applications and techniques that use pointers. We have introduced some advanced pointer issues already. This chapter brings together some topics we have briefly mentioned and others to complete our study C pointers.
In this chapter we will:

Examine pointers to pointers in more detail.
See how pointers are used in command line input in C.
Study pointers to functions

Pointers to Pointers

We introduced the concept of a pointer to a pointer previously. You can have a pointer to a pointer of any type.
Consider the following:

char ch;  /* a character */
char *pch; /* a pointer to a character */
char **ppch; /* a pointer to a pointer to a character */

We can visualise this in Figure 11.1. Here we can see that **ppch refers to memory address of *pch which refers to the memory address of the variable ch. But what does this mean in practice?

Fig. 11.1 Pointers to pointers Recall that char * refers to a (NULL terminated string. So one common and convenient notion is to declare a pointer to a pointer to a string (Figure 11.2)

Fig. 11.2 Pointer to String Taking this one stage further we can have several strings being pointed to by the pointer (Figure 11.3)

Fig. 11.3 Pointer to Several Strings We can refer to individual strings by ppch[0], ppch[1], ..... Thus this is identical to declaring char *ppch[].
One common occurrence of this type is in C command line argument input which we now consider.

Command line input

C lets read arguments from the command line which can then be used in our programs.

We can type arguments after the program name when we run the program.

We have seen this with the compiler for example

c89 -o prog prog.c

c89 is the program, -o prog prog.c the arguments.

In order to be able to use such arguments in our code we must define them as follows:

main(int argc, char **argv)

So our main function now has its own arguments. These are the only arguments main accepts.

argc is the number of arguments typed -- including the program name.
argv is an array of strings holding each command line argument -- including the program name in the first array element.

A simple program example:

#include main (int argc, char **argv)     { /* program to print arguments from command line */ int i; printf(``argc = %dnn'',argc); for (i=0;i printf(``argv[%d]: %sn'', i, argv[i]); }

Assume it is compiled to run it as args.

So if we type:

   args f1 ``f2'' f3 4 stop!
The output would be:
   argc = 6 argv[0] = args argv[1] = f1 argv[2] = f2 argv[3] = f3 argv[4] = 4 argv[5] = stop!


NOTE:  argv[0] is program name.
    argc counts program name
    Embedded `` '' are ignored.
   Blank spaces delimit end of arguments.
   Put blanks in `` '' if needed.

Pointers to a Function

Pointer to a function are perhaps on of the more confusing uses of pointers in C. Pointers to functions are not as common as other pointer uses. However, one common use is in a passing pointers to a function as a parameter in a function call. (Yes this is getting confusing, hold on to your hats for a moment).
This is especially useful when alternative functions maybe used to perform similar tasks on data. You can pass the data and the function to be used to some control function for instance. As we will see shortly the C standard library provided some basic sorting ( qsort) and searching (bsearch) functions for free. You can easily embed your own functions.
To declare a pointer to a function do:

int (*pf) ();

This simply declares a pointer *pf to function that returns and int. No actual function is pointed to yet.
If we have a function int f() then we may simply (!!) write:

pf = &f;

For compiler prototyping to fully work it is better to have full function prototypes for the function and the pointer to a function:

int f(int);
int (*pf) (int) = &f;

Now f() returns an int and takes one int as a parameter.
You can do things like:

ans = f(5);
ans = pf(5);

which are equivalent.
The qsort standard library function is very useful function that is designed to sort an array by a key value of any type into ascending order, as long as the elements of the array are of fixed type.
qsort is prototyped in (stdlib.h):

void qsort(void *base, size_t num_elements, size_t element_size,
   int (*compare)(void const *, void  const *));

The argument base points to the array to be sorted, num_elements indicates how long the array is, element_size is the size in bytes of each array element and the final argument compare is a pointer to a function.
qsort calls the compare function which is user defined to compare the data when sorting. Note that qsort maintains it's data type independence by giving the comparison responsibility to the user. The compare function must return certain (integer) values according to the comparison result:

less than zero: : if first value is less than the second value
zero: : if first value is equal to the second value
greater than zero: : if first value is greater than the second value

Some quite complicated data structures can be sorted in this manner. For example, to sort the following structure by integer key:

typedef struct {
        int   key;
        struct other_data;
} Record;

We can write a compare function, record_compare:

int record\_compare(void const *a, void  const *a)
  {  return ( ((Record *)a)->key - ((Record *)b)->key );
  }

Assuming that we have an array of array_length Records suitably filled with date we can call qsort like this:

qsort( array, arraylength, sizeof(Record), record_compare);

Further examples of standard library and system calls that use pointers to functions may be found in Chapters 15.4 and 19.1.

Exercises

Exercise 12476
Write a program last that prints the last n lines of its text input. By default n should be 5, but your program should allow an optional argument so that

last -n

prints out the last n lines, where n is any integer. Your program should make the best use of available storage. (Input of text could be by reading a file specified from the command or reading a file from standard input)

Exercise 12477
Write a program that sorts a list of integers in ascending order. However if a -r flag is present on the command line your program should sort the list in descending order. (You may use any sorting routine you wish)
Exercise 12478
Write a program that reads the following structure and sorts the data by keyword using qsort

typedef struct {
        char   keyword[10];
        int    other_data;
} Record;

Exercise 12479
An insertion sort is performed by adding values to an array one by one. The first value is simply stored at the beginning of the array. Each subsequent value is added by finding its ordered position in the array, moving data as needed to accommodate the value and inserting the value in this position.
Write a function called insort that performs this task and behaves in the same manner as qsort, i.e it can sort an array by a key value of any type and it has similar prototyping.

Dynamic Memory Allocation and Dynamic Structures

2009-01-14T08:58:00.001-08:00

Dynamic allocation is a pretty unique feature to C (amongst high level languages). It enables us to create data types and structures of any size and length to suit our programs need within the program.

We will look at two common applications of this:

dynamic arrays
dynamic data structure e.g. linked lists

Malloc, Sizeof, and Free

The Function malloc is most commonly used to attempt to ``grab'' a continuous portion of memory. It is defined by:

void *malloc(size_t number_of_bytes)

That is to say it returns a pointer of type void * that is the start in memory of the reserved portion of size number_of_bytes. If memory cannot be allocated a NULL pointer is returned.
Since a void * is returned the C standard states that this pointer can be converted to any type. The size_t argument type is defined in stdlib.h and is an unsigned type.
So:

char *cp; cp = malloc(100);

attempts to get 100 bytes and assigns the start address to cp.
Also it is usual to use the sizeof() function to specify the number of bytes:


    int *ip;
   ip = (int *) malloc(100*sizeof(int));

Some C compilers may require to cast the type of conversion. The (int *) means coercion to an integer pointer. Coercion to the correct pointer type is very important to ensure pointer arithmetic is performed correctly. I personally use it as a means of ensuring that I am totally correct in my coding and use cast all the time.
It is good practice to use sizeof() even if you know the actual size you want -- it makes for device independent (portable) code.
sizeof can be used to find the size of any data type, variable or structure. Simply supply one of these as an argument to the function.
SO:
   int i; struct COORD {float x,y,z}; typedef struct COORD PT; sizeof(int), sizeof(i), sizeof(struct COORD) and sizeof(PT) are all ACCEPTABLE
In the above we can use the link between pointers and arrays to treat the reserved memory like an array. i.e we can do things like:
   ip[0] = 100;
or
   for(i=0;i<100;++i) scanf("%d",ip++);

When you have finished using a portion of memory you should always free() it. This allows the memory freed to be aavailable again, possibly for further malloc() calls
The function free() takes a pointer as an argument and frees the memory to which the pointer refers.

Calloc and Realloc

There are two additional memory allocation functions, Calloc() and Realloc(). Their prototypes are given below:

void *calloc(size_t num_elements, size_t element_size};

void *realloc( void *ptr, size_t new_size);

Malloc does not initialise memory (to zero) in any way. If you wish to initialise memory then use calloc. Calloc there is slightly more computationally expensive but, occasionally, more convenient than malloc. Also note the different syntax between calloc and malloc in that calloc takes the number of desired elements, num_elements, and element_size, element_size, as two individual arguments.
Thus to assign 100 integer elements that are all initially zero you would do:
int *ip; ip = (int *) calloc(100, sizeof(int));
Realloc is a function which attempts to change the size of a previous allocated block of memory. The new size can be larger or smaller. If the block is made larger then the old contents remain unchanged and memory is added to the end of the block. If the size is made smaller then the remaining contents are unchanged.
If the original block size cannot be resized then realloc will attempt to assign a new block of memory and will copy the old block contents. Note a new pointer (of different value) will consequently be returned. You must use this new value. If new memory cannot be reallocated then realloc returns NULL.
Thus to change the size of memory allocated to the *ip pointer above to an array block of 50 integers instead of 100, simply do:
ip = (int *) calloc( ip, 50);

Linked Lists

Let us now return to our linked list example:
  typedef struct { int value; ELEMENT *next; } ELEMENT;

We can now try to grow the list dynamically:

  link = (ELEMENT *) malloc(sizeof(ELEMENT));
This will allocate memory for a new link.
If we want to deassign memory from a pointer use the free() function:
  free(link)
See Example programs (queue.c) below and try exercises for further practice.

Full Program: `queue.c`

A queue is basically a special case of a linked list where one data element joins the list at the left end and leaves in a ordered fashion at the other end.
The full listing for queue.c is as follows:

/*            */
/* queue.c            */
/* Demo of dynamic data structures in C                      */

#include 

#define FALSE 0
#define NULL 0

typedef struct {
    int     dataitem;
    struct listelement *link;
}               listelement;

void Menu (int *choice);
listelement * AddItem (listelement * listpointer, int data);
listelement * RemoveItem (listelement * listpointer);
void PrintQueue (listelement * listpointer);
void ClearQueue (listelement * listpointer);

main () {
    listelement listmember, *listpointer;
    int     data,
            choice;

    listpointer = NULL;
    do {
 Menu (&choice);
 switch (choice) {
     case 1: 
  printf ("Enter data item value to add  ");
  scanf ("%d", &data);
  listpointer = AddItem (listpointer, data);
  break;
     case 2: 
  if (listpointer == NULL)
      printf ("Queue empty!\n");
  else
      listpointer = RemoveItem (listpointer);
  break;
     case 3: 
  PrintQueue (listpointer);
  break;

     case 4: 
  break;

     default: 
  printf ("Invalid menu choice - try again\n");
  break;
 }
    } while (choice != 4);
    ClearQueue (listpointer);
}    /* main */

void Menu (int *choice) {

    char    local;

    printf ("\nEnter\t1 to add item,\n\t2 to remove item\n\
\t3 to print queue\n\t4 to quit\n");
    do {
 local = getchar ();
 if ((isdigit (local) == FALSE) && (local != '\n')) {
     printf ("\nyou must enter an integer.\n");
     printf ("Enter 1 to add, 2 to remove, 3 to print, 4 to quit\n");
 }
    } while (isdigit ((unsigned char) local) == FALSE);
    *choice = (int) local - '0';
}

listelement * AddItem (listelement * listpointer, int data) {

    listelement * lp = listpointer;

    if (listpointer != NULL) {
 while (listpointer -> link != NULL)
     listpointer = listpointer -> link;
 listpointer -> link = (struct listelement  *) malloc (sizeof (listelement));
 listpointer = listpointer -> link;
 listpointer -> link = NULL;
 listpointer -> dataitem = data;
 return lp;
    }
    else {
 listpointer = (struct listelement  *) malloc (sizeof (listelement));
 listpointer -> link = NULL;
 listpointer -> dataitem = data;
 return listpointer;
    }
}

listelement * RemoveItem (listelement * listpointer) {

    listelement * tempp;
    printf ("Element removed is %d\n", listpointer -> dataitem);
    tempp = listpointer -> link;
    free (listpointer);
    return tempp;
}

void PrintQueue (listelement * listpointer) {

    if (listpointer == NULL)
 printf ("queue is empty!\n");
    else
 while (listpointer != NULL) {
     printf ("%d\t", listpointer -> dataitem);
     listpointer = listpointer -> link;
 }
    printf ("\n");
}

void ClearQueue (listelement * listpointer) {

    while (listpointer != NULL) {
 listpointer = RemoveItem (listpointer);
    }
}

Exercises

Exercise 12456
Write a program that reads a number that says how many integer numbers are to be stored in an array, creates an array to fit the exact size of the data and then reads in that many numbers into the array.
Exercise 12457
Write a program to implement the linked list as described in the notes above.
Exercise 12458
Write a program to sort a sequence of numbers using a binary tree (Using Pointers). A binary tree is a tree structure with only two (possible) branches from each node (Fig. 10.1). Each branch then represents a false or true decision. To sort numbers simply assign the left branch to take numbers less than the node number and the right branch any other number (greater than or equal to). To obtain a sorted list simply search the tree in a depth first fashion.

Fig. 10.1 Example of a binary tree sort Your program should: Create a binary tree structure. Create routines for loading the tree appropriately. Read in integer numbers terminated by a zero. Sort numbers into numeric ascending order. Print out the resulting ordered values, printing ten numbers per line as far as possible.
Typical output should be

The sorted values are:
     2  4  6  6  7  9 10 11 11 11
    15 16 17 18 20 20 21 21 23 24
    27 28 29 30

Pointers

2009-01-14T08:57:00.001-08:00

Pointer are a fundamental part of C. If you cannot use pointers properly then you have basically lost all the power and flexibility that C allows. The secret to C is in its use of pointers. C uses pointers a lot. Why?:

It is the only way to express some computations.
It produces compact and efficient code.
It provides a very powerful tool.

C uses pointers explicitly with:

Arrays,
Structures,
Functions.

NOTE: Pointers are perhaps the most difficult part of C to understand. C's implementation is slightly different DIFFERENT from other languages.

What is a Pointer?

A pointer is a variable which contains the address in memory of another variable. We can have a pointer to any variable type.
The unary or monadic operator & gives the ``address of a variable''.
The indirection or dereference operator * gives the ``contents of an object pointed to by a pointer''.
To declare a pointer to a variable do:
int *pointer;
NOTE: We must associate a pointer to a particular type: You can't assign the address of a short int to a long int, for instance.
Consider the effect of the following code:


   int x = 1, y = 2;
   int *ip;
 
   ip = &x;
 

y = *ip;
 

x = ip;
 

   *ip = 3;

It is worth considering what is going on at the machine level in memory to fully understand how pointer work. Consider Fig. 9.1. Assume for the sake of this discussion that variable x resides at memory location 100, y at 200 and ip at 1000. Note A pointer is a variable and thus its values need to be stored somewhere. It is the nature of the pointers value that is new.

Fig. 9.1 Pointer, Variables and Memory Now the assignments x = 1 and y = 2 obviously load these values into the variables. ip is declared to be a pointer to an integer and is assigned to the address of x (&x). So ip gets loaded with the value 100.
Next y gets assigned to the contents of ip. In this example ip currently points to memory location 100 -- the location of x. So y gets assigned to the values of x -- which is 1.
We have already seen that C is not too fussy about assigning values of different type. Thus it is perfectly legal (although not all that common) to assign the current value of ip to x. The value of ip at this instant is 100.
Finally we can assign a value to the contents of a pointer (*ip).
IMPORTANT: When a pointer is declared it does not point anywhere. You must set it to point somewhere before you use it.
So ...
int *ip; *ip = 100;
will generate an error (program crash!!).
The correct use is:


   int *ip;
   int x;
 
   ip = &x;
   *ip = 100;

We can do integer arithmetic on a pointer:


   float *flp, *flq;
 
   *flp = *flp + 10;
 
   ++*flp;
 
   (*flp)++;
 
   flq = flp;

NOTE: A pointer to any variable type is an address in memory -- which is an integer address. A pointer is definitely NOT an integer.
The reason we associate a pointer to a data type is so that it knows how many bytes the data is stored in. When we increment a pointer we increase the pointer by one ``block'' memory.
So for a character pointer ++ch_ptr adds 1 byte to the address.
For an integer or float ++ip or ++flp adds 4 bytes to the address.
Consider a float variable (fl) and a pointer to a float (flp) as shown in Fig. 9.2.

Fig. 9.2 Pointer Arithmetic Assume that flp points to fl then if we increment the pointer ( ++flp) it moves to the position shown 4 bytes on. If on the other hand we added 2 to the pointer then it moves 2 float positions i.e 8 bytes as shown in the Figure.

Pointer and Functions

Let us now examine the close relationship between pointers and C's other major parts. We will start with functions.
When C passes arguments to functions it passes them by value.
There are many cases when we may want to alter a passed argument in the function and receive the new value back once to function has finished. Other languages do this (e.g. var parameters in PASCAL). C uses pointers explicitly to do this. Other languages mask the fact that pointers also underpin the implementation of this.
The best way to study this is to look at an example where we must be able to receive changed parameters.
Let us try and write a function to swap variables around?
The usual function call:

    swap(a, b)   WON'T WORK.

Pointers provide the solution: Pass the address of the variables to the functions and access address of function.

Thus our function call in our program would look like this:

    swap(&a, &b)

The Code to swap is fairly straightforward:
    void swap(int *px, int *py)    { int temp; temp = *px; /* contents of pointer */ *px = *py; *py = temp; }
We can return pointer from functions. A common example is when passing back structures. e.g.:


typedef struct {float x,y,z;} COORD;
 
   main()
 
    {  COORD p1, *coord_fn();
      /* declare fn to return ptr of
       COORD type */ 
 
       ....
       p1 = *coord_fn(...);
     /* assign contents of address returned */
       ....
     }


   COORD *coord_fn(...)
 
    {  COORD p;
 
       .....
       p = ....;
       /* assign structure values */ 
 
       return &p;
       /* return address of p */
     }

Here we return a pointer whose contents are immediately unwrapped into a variable. We must do this straight away as the variable we pointed to was local to a function that has now finished. This means that the address space is free and can be overwritten. It will not have been overwritten straight after the function ha squit though so this is perfectly safe.

Pointers and Arrays

Pointers and arrays are very closely linked in C.

Hint: think of array elements arranged in consecutive memory locations.

Consider the following:
   int a[10], x; int *pa; pa = &a[0]; /* pa pointer to address of a[0] */ x = *pa; /* x = contents of pa (a[0] in this case) */

Fig. 9.3 Arrays and Pointers
To get somewhere in the array (Fig. 9.3) using a pointer we could do:

   pa + i a[i]
WARNING: There is no bound checking of arrays and pointers so you can easily go beyond array memory and overwrite other things.
C however is much more subtle in its link between arrays and pointers.
For example we can just type
   pa = a;
instead of
   pa = &a[0]
and
   a[i] can be written as *(a + i). i.e. &a[i] a + i.
We also express pointer addressing like this:
   pa[i] *(pa + i).
However pointers and arrays are different:

A pointer is a variable. We can do pa = a and pa++.
An Array is not a variable. a = pa and a++ ARE ILLEGAL.

This stuff is very important. Make sure you understand it. We will see a lot more of this.
We can now understand how arrays are passed to functions.
When an array is passed to a function what is actually passed is its initial elements location in memory.
So:
   strlen(s) strlen(&s[0])
This is why we declare the function:
     int strlen(char s[]);
An equivalent declaration is : int strlen(char *s); since char s[] char *s.
strlen() is a standard library function (Chapter 18) that returns the length of a string. Let's look at how we may write a function:
   int strlen(char *s)    { char *p = s; while (*p != `);    p++; return p-s;    }
Now lets write a function to copy a string to another string. strcpy() is a standard library function that does this.
   void strcpy(char *s, char *t)    { while ( (*s++ = *t++) != `);}
This uses pointers and assignment by value.
Very Neat!!
NOTE: Uses of Null statements with while.

Arrays of Pointers

We can have arrays of pointers since pointers are variables.

Example use:

Sort lines of text of different length.

NOTE: Text can't be moved or compared in a single operation.

Arrays of Pointers are a data representation that will cope efficiently and conveniently with variable length text lines.

How can we do this?:

Store lines end-to-end in one big char array (Fig. 9.4). n will delimit lines.
Store pointers in a different array where each pointer points to 1st char of each new line.
Compare two lines using strcmp() standard library function.
If 2 lines are out of order -- swap pointer in pointer array (not text).

Fig. 9.4 Arrays of Pointers (String Sorting Example)
This eliminates:

complicated storage management.
high overheads of moving lines.

Multidimensional arrays and pointers

We should think of multidimensional arrays in a different way in C:

A 2D array is really a 1D array, each of whose elements is itself an array

Hence

  a[n][m] notation.

Array elements are stored row by row.

When we pass a 2D array to a function we must specify the number of columns -- the number of rows is irrelevant.

The reason for this is pointers again. C needs to know how many columns in order that it can jump from row to row in memory.

Considerint a[5][35] to be passed in a function:

We can do:

   f(int a[][35]) {.....}

or even:

   f(int (*a)[35]) {.....}

We need parenthesis (*a) since [] have a higher precedence than *

So:

   int (*a)[35]; declares a pointer to an array of 35 ints.

   int *a[35]; declares an array of 35 pointers to ints.

Now lets look at the (subtle) difference between pointers and arrays. Strings are a common application of this.

Consider:
   char *name[10];
   char Aname[10][20];

We can legally do name[3][4] and Aname[3][4] in C.
However

Aname is a true 200 element 2D char array.
access elements via
20*row + col + base_address
in memory.
name has 10 pointer elements.

NOTE: If each pointer in name is set to point to a 20 element array then and only then will 200 chars be set aside (+ 10 elements).

The advantage of the latter is that each pointer can point to arrays be of different length.

Consider:


   char *name[] = { ``no month'', ``jan'',
    ``feb'', ... };
   char Aname[][15] = { ``no month'', ``jan'',
    ``feb'', ... };

Fig. 2D Arrays and Arrays of Pointers

Static Initialisation of Pointer Arrays

Initialisation of arrays of pointers is an ideal application for an internal static array.
some_fn() { static char *months = { ``no month'', ``jan'', ``feb'', ...}; }
static reserves a private permanent bit of memory.

Pointers and Structures

These are fairly straight forward and are easily defined. Consider the following:


   struct COORD {float x,y,z;} pt;
   struct COORD *pt_ptr;
 

pt_ptr = &pt; /* assigns pointer to pt */

the operator lets us access a member of the structure pointed to by a pointer.i.e.:
pt_ptrx = 1.0;
pt_ptry = pt_ptry - 3.0;

Example: Linked Lists


  typedef struct {  int value;
       ELEMENT *next;
     } ELEMENT; 
 

ELEMENT n1, n2;
 

n1.next = &n2;

Fig. Linking Two Nodes NOTE: We can only declare next as a pointer to ELEMENT. We cannot have a element of the variable type as this would set up a recursive definition which is NOT ALLOWED. We are allowed to set a pointer reference since 4 bytes are set aside for any pointer.
The above code links a node n1 to n2 (Fig. 9.6) we will look at this matter further in the next Chapter.

Common Pointer Pitfalls

Here we will highlight two common mistakes made with pointers.

Not assigning a pointer to memory address before using it

int *x; *x = 100; we need a physical location say: int y; x = &y; *x = 100;
This may be hard to spot. NO COMPILER ERROR. Also x could some random address at initialisation.

Illegal indirection

Suppose we have a function malloc() which tries to allocate memory dynamically (at run time) and returns a pointer to block of memory requested if successful or a NULL pointer
otherwise.

  char *malloc() -- a standard library function (see later).

Let us have a pointer: char *p;

Consider:

  *p = (char *) malloc(100);    /* request 100 bytes of memory */

  *p = `y';

There is mistake above. What is it?

No * in
   *p = (char *) malloc(100);

Malloc returns a pointer. Also p does not point to any address.

The correct code should be:

   p = (char *) malloc(100);

If code rectified one problem is if no memory is available and p is NULL. Therefore we can't do:
   *p = `y';.

A good C program would check for this:
  p = (char *) malloc(100); if ( p == NULL)   { printf(``Error: Out of Memory n''); exit(1); } *p = `y';

Exercise

Exercise 12453
Write a C program to read through an array of any type using pointers. Write a C program to scan through this array to find a particular value.
Exercise 12454
Write a program to find the number of times that a given word(i.e. a short string) occurs in a sentence (i.e. a long string!).
Read data from standard input. The first line is a single word, which is followed by general text on the second line. Read both up to a newline character, and insert a terminating null before processing.
Typical output should be:

The word is "the".
        The sentence is "the cat sat on the mat".
       The word occurs 2 times.

Exercise 12455
Write a program that takes three variable (a, b, b) in as separate parameters and rotates the values stored so that value a goes to be, b, to c and c to a.

Further Data Types

2009-01-14T08:56:00.001-08:00

This Chapter discusses how more advanced data types and structures can be created and used in a C program.

Structures

Structures in C are similar to records in Pascal. For example:
  struct gun { char name[50]; int magazinesize; float calibre; }; struct gun arnies;
defines a new structure gun and makes arnies an instance of it.
NOTE: that gun is a tag for the structure that serves as shorthand for future declarations. We now only need to say struct gun and the body of the structure is implied as we do to make the arnies variable. The tag is optional.
Variables can also be declared between the } and ; of a struct declaration, i.e.:
  struct gun { char name[50]; int magazinesize; float calibre; } arnies;
struct's can be pre-initialised at declaration:
  struct gun arnies={"Uzi",30,7};

which gives arnie a 7mm. Uzi with 30 rounds of ammunition.
To access a member (or field) of a struct, C provides the . operator. For example, to give arnie more rounds of ammunition:
   arnies.magazineSize=100;

Defining New Data Types

typedef can also be used with structures. The following creates a new type agun which is of type struct gun and can be initialised as usual:
  typedef struct gun { char name[50]; int magazinesize; float calibre; } agun; agun arnies={"Uzi",30,7};
Here gun still acts as a tag to the struct and is optional. Indeed since we have defined a new data type it is not really of much use,
agun is the new data type. arnies is a variable of type agun which is a structure.
C also allows arrays of structures:
  typedef struct gun { char name[50]; int magazinesize; float calibre; } agun; agun arniesguns[1000];
This gives arniesguns a 1000 guns. This may be used in the following way:
          arniesguns[50].calibre=100;
gives Arnie's gun number 50 a calibre of 100mm, and:


          itscalibre=arniesguns[0].calibre;

assigns the calibre of Arnie's first gun to itscalibre.

Unions

A union is a variable which may hold (at different times) objects of different sizes and types. C uses the union statement to create unions, for example:
          union number { short shortnumber; long longnumber; double floatnumber; } anumber
defines a union called number and an instance of it called anumber. number is a union tag and acts in the same way as a tag for a structure.
Members can be accessed in the following way:
          printf("%ldn",anumber.longnumber);
This clearly displays the value of longnumber.
When the C compiler is allocating memory for unions it will always reserve enough room for the largest member (in the above example this is 8 bytes for the double).
In order that the program can keep track of the type of union variable being used at a given time it is common to have a structure (with union embedded in it) and a variable which flags the union type:
An example is:
  typedef struct { int maxpassengers; } jet; typedef struct { int liftcapacity; } helicopter; typedef struct { int maxpayload; } cargoplane; typedef union { jet jetu; helicopter helicopteru; cargoplane cargoplaneu; } aircraft; typedef struct { aircrafttype kind; int speed; aircraft description; } an_aircraft;
This example defines a base union aircraft which may either be jet, helicopter, or cargoplane.
In the an_aircraft structure there is a kind member which indicates which structure is being held at the time.

Coercion or Type-Casting

C is one of the few languages to allow coercion, that is forcing one variable of one type to be another type. C allows this using the cast operator (). So:

int integernumber; float floatnumber=9.87; integernumber=(int)floatnumber;

assigns 9 (the fractional part is thrown away) to integernumber.

And:


  int integernumber=10;
   float floatnumber;
 
     floatnumber=(float)integernumber;

assigns 10.0 to floatnumber.
Coercion can be used with any of the simple data types including char, so:
int integernumber; char letter='A'; integernumber=(int)letter;
assigns 65 (the ASCII code for `A') to integernumber.
Some typecasting is done automatically -- this is mainly with integer compatibility.
A good rule to follow is: If in doubt cast.
Another use is the make sure division behaves as requested: If we have two integers internumber and anotherint and we want the answer to be a float then :


e.g.
 floatnumber =
   (float) internumber / (float) anotherint;

ensures floating point division.

Enumerated Types

Enumerated types contain a list of constants that can be addressed in integer values.

We can declare types and variables as follows.

enum days {mon, tues, ..., sun} week;
enum days week1, week2;

NOTE: As with arrays first enumerated name has index value 0. So mon has value 0, tues 1, and so on.

week1 and week2 are variables.

We can define other values:


  enum escapes { bell = `a',
   backspace = `b',  tab = `t',
   newline = `n', vtab = `v',
   return = `r'};

We can also override the 0 start value:

enum months {jan = 1, feb, mar, ......, dec};

Here it is implied that feb = 2 etc.

Static Variables

A static variable is local to particular function. However, it is only initialised once (on the first call to function).
Also the value of the variable on leaving the function remains intact. On the next call to the function the the static variable has the same value as on leaving.
To define a static variable simply prefix the variable declaration with the static keyword. For example:


  void stat(); /* prototype fn */ 
 
   main()
    { int i;
 
     for (i=0;i<5;++i)
       stat();
    }
 

stat()
    {  int auto_var = 0;
     static int static_var = 0;
 
     printf( ``auto = %d, static = %d n'',
       auto_var, static_var);
     ++auto_var;
     ++static_var;
    }

Output is:


  auto_var = 0, static_var= 0
  auto_var = 0, static_var = 1
  auto_var = 0, static_var = 2
  auto_var = 0, static_var = 3
  auto_var = 0, static_var = 4

Clearly the auto_var variable is created each time. The static_var is created once and remembers its value.

Exercises

Exercise 12386
Write program using enumerated types which when given today's date will print out tomorrow's date in the for 31st January, for example.
Exercise 12387
Write a simple database program that will store a persons details such as age, date of birth, address etc.

Functions

2009-01-14T08:54:00.000-08:00

C provides functions which are again similar most languages. One difference is that C regards main() as function. Also unlike some languages, such as Pascal, C does not have procedures -- it uses functions to service both requirements.
Let us remind ourselves of the form of a function:
returntype fn_name(₁, parameterdef₂,) { localvariables functioncode }
Let us look at an example to find the average of two integers:


  float findaverage(float a, float b)
    { float average;
 
>     average=(a+b)/2;
       return(average);
    }
 
We would call the function as follows:
 
   main()
    {    float a=5,b=15,result;
 
       result=findaverage(a,b);
       printf("average=%fn",result);
    }

Note: The return statement passes the result back to the main program.

`void` functions

The void function provide a way of emulating PASCAL type procedures.
If you do not want to return a value you must use the return type void and miss out the return statement:


  void squares()
    { int loop;
 
       for (loop=1;loop<10;loop++);
         printf("%dn",loop*loop);
    }
 
   main() 
 
    {    squares();
    }

NOTE: We must have () even for no parameters unlike some languages.

Functions and Arrays

Single dimensional arrays can be passed to functions as follows:-
float findaverage(int size,float list[]) { int i; float sum=0.0; for (i=0;i sum+=list[i]; return(sum/size); }
Here the declaration float list[] tells C that list is an array of float. Note we do not specify the dimension of the array when it is a parameter of a function.
Multi-dimensional arrays can be passed to functions as follows:


  void printtable(int xsize,int ysize,
       float table[][5])
 
    { int x,y;
 
       for (x=0;x
         { for (y=0;y
           printf("t%f",table[x][y]);
         printf("n");
      }
    }

Here float table[][5] tells C that table is an array of dimension N5 of float. Note we must specify the second (and subsequent) dimension of the array BUT not the first dimension.

Function Prototyping

Before you use a function C must have knowledge about the type it returns and the parameter types the function expects.
The ANSI standard of C introduced a new (better) way of doing this than previous versions of C. (Note: All new versions of C now adhere to the ANSI standard.)
The importance of prototyping is twofold.

It makes for more structured and therefore easier to read code.
It allows the C compiler to check the syntax of function calls.

How this is done depends on the scope of the function (See Chapter 34). Basically if a functions has been defined before it is used (called) then you are ok to merely use the function.
If NOT then you must declare the function. The declaration simply states the type the function returns and the type of parameters used by the function.
It is usual (and therefore good) practice to prototype all functions at the start of the program, although this is not strictly necessary.
To declare a function prototype simply state the type the function returns, the function name and in brackets list the type of parameters in the order they appear in the function definition.

e.g.

int strlen(char []);

This states that a function called strlen returns an integer value and accepts a single string as a parameter.
NOTE: Functions can be prototyped and variables defined on the same line of code. This used to be more popular in pre-ANSI C days since functions are usually prototyped separately at the start of the program. This is still perfectly legal though: order they appear in the function definition.

e.g.

int length, strlen(char []);

Here length is a variable, strlen the function as before.

Exercises

Exercise 12346
Write a function ``replace'' which takes a pointer to a string as a parameter, which replaces all spaces in that string by minus signs, and delivers the number of spaces it replaced.
Thus

char *cat = "The cat sat";
        n = replace( cat );

should set

cat to "The-cat-sat"

and

n to 2.

Exercise 12347
Write a program which will read in the source of a C program from its standard input, and print out all the starred items in the following statistics for the program (all as integers). (Note the comment on tab characters at the end of this specification.)
Print out the following values:

Lines:
  *  The total number of lines
  *  The total number of blank lines
        (Any lines consisting entirely of white space should be
        considered as blank lines.)
     The percentage of blank lines (100 * blank_lines / lines)

  Characters:
  *  The total number of characters after tab expansion
  *  The total number of spaces after tab expansion
  *  The total number of leading spaces after tab expansion
      (These are the spaces at the start of a line, before any visible
        character; ignore them if there are no visible characters.)
    The average number of
      characters per line
      characters per line ignoring leading spaces
      leading spaces per line
      spaces per line ignoring leading spaces

  Comments:
  *  The total number of comments in the program
  *  The total number of characters in the comments in the program
       excluding the "/*" and "*/" thenselves
    The percentage of number of comments to total lines
    The percentage of characters in comments to characters

  Identifiers:
    We are concerned with all the occurrences of "identifiers" in the
      program where each part of the text starting with a letter,
      and continuing with letter, digits and underscores is considered
      to be an identifier, provided that it is not
          in a comment,
          or in a string,
          or within primes.
        Note that
            "abc\"def"
        the internal escaped quote does not close the string.
        Also, the representation of the escape character is
            '\\'
 and of prime is
            '\''
      Do not attempt to exclude the fixed words of the language,
      treat them as identifiers. Print
  *  The total number of identifier occurrences.
  *  The total number of characters in them.
    The average identifier length.

  Indenting:
  *  The total number of times either of the following occurs:
      a line containing a "}" is more indented than the preceding line
      a line is preceded by a line containing a "{" and is less
        indented than it.
      The "{" and "}" must be ignored if in a comment or string or
        primes, or if the other line involved is entirely comment.
    A single count of the sum of both types of error is required.

NOTE: All tab characters ('') on input should be interpreted as multiple spaces using the rule:

"move to the next modulo 8 column"
  where the first column is numbered column 0.
 col before tab | col after tab
        ---------------+--------------
                0      |      8
                1      |      8
                7      |      8
                8      |     16
                9      |     16
               15      |     16
               16      |     24

To read input a character at a time the skeleton has code incorporated to read a line at a time for you using

char ch;
        ch = getchar();

Which will deliver each character exactly as read. The "getline" function then puts the line just read in the global array of characters "linec", null terminated, and delivers the length of the line, or a negative value if end of data has been encountered. You can then look at the characters just read with (for example)

switch( linec[0] ) {
        case ' ': /* space ..... */
                break;
        case '\t': /* tab character .... */
                break;
        case '\n': /* newline ... */
                break;
        ....
        } /* end switch */

End of data is indicated by scanf NOT delivering the value 1.

Your output should be in the following style:

Total lines                     126
        Total blank lines               3
        Total characters                3897
        Total spaces                    1844
        Total leading spaces            1180
        Total comments                  7
        Total chars in comments         234
        Total number of identifiers     132
        Total length of identifiers     606
        Total indenting errors          2

You may gather that the above program (together with the unstarred items) forms the basis of part of your marking system! Do the easy bits first, and leave it at that if some aspects worry you. Come back to me if you think my solution (or the specification) is wrong! That is quite possible! Exercise 12348
It's rates of pay again!
Loop performing the following operation in your program:

Read two integers, representing a rate of pay (pence per hour) and a number of hours. Print out the total pay, with hours up to 40 being paid at basic rate, from 40 to 60 at rate-and-a-half, above 60 at double-rate. Print the pay as pounds to two decimal places.

Terminate the loop when a zero rate is encountered. At the end of the loop, print out the total pay.
The code for computing the pay from the rate and hours is to be written as a function.
The recommended output format is something like:

Pay at 200 pence/hr for 38 hours is 76.00 pounds
        Pay at 220 pence/hr for 48 hours is 114.40 pounds
        Pay at 240 pence/hr for 68 hours is 206.40 pounds
        Pay at 260 pence/hr for 48 hours is 135.20 pounds
        Pay at 280 pence/hr for 68 hours is 240.80 pounds
        Pay at 300 pence/hr for 48 hours is 156.00 pounds
        Total pay is 928.80 pounds

The ``program features'' checks that explicit values such as 40 and 60 appear only once, as a #define or initialised variable value. This represents good programming practice.

Arrays and Strings

2009-01-14T08:53:00.000-08:00

In principle arrays in C are similar to those found in other languages. As we shall shortly see arrays are defined slightly differently and there are many subtle differences due the close link between array and pointers. We will look more closely at the link between pointer and arrays later in Chapter 9.

Single and Multi-dimensional Arrays

Let us first look at how we define arrays in C: int listofnumbers[50];
BEWARE: In C Array subscripts start at 0 and end one less than the array size. For example, in the above case valid subscripts range from 0 to 49. This is a BIG difference between C and other languages and does require a bit of practice to get in the right frame of mind.
Elements can be accessed in the following ways:-


  thirdnumber=listofnumbers[2];
   listofnumbers[5]=100;

Multi-dimensional arrays can be defined as follows:


  int tableofnumbers[50][50];

for two dimensions.
For further dimensions simply add more [ ]:


  int bigD[50][50][40][30]......[50];

Elements can be accessed in the following ways:


  anumber=tableofnumbers[2][3];
   tableofnumbers[25][16]=100;

Strings

In C Strings are defined as arrays of characters. For example, the following defines a string of 50 characters:
char name[50]; C has no string handling facilities built in and so the following are all illegal:


  char firstname[50],lastname[50],fullname[100];
 
   firstname= "Arnold"; /* Illegal */
   lastname= "Schwarznegger"; /* Illegal */
   fullname= "Mr"+firstname
     +lastname; /* Illegal */

However, there is a special library of string handling routines which we will come across later.
To print a string we use printf with a special %s control character:
printf(``%s'',name);
NOTE: We just need to give the name of the string.
In order to allow variable length strings the 0 character is used to indicate the end of a string.
So we if we have a string, char NAME[50]; and we store the ``DAVE'' in it its contents will look like:

Exercises

Exercise 12335
Write a C program to read through an array of any type. Write a C program to scan through this array to find a particular value.
Exercise 12336
Read ordinary text a character at a time from the program's standard input, and print it with each line reversed from left to right. Read until you encounter end-of-data (see below).
You may wish to test the program by typing

prog5rev | prog5rev

to see if an exact copy of the original input is recreated. To read characters to end of data, use a loop such as either

char ch;
        while( ch = getchar(), ch >= 0 ) /* ch < 0 indicates end-of-data */

char ch;
        while( scanf( "%c", &ch ) == 1 ) /* one character read */

Exercise 12337
Write a program to read English text to end-of-data (type control-D to indicate end of data at a terminal, see below for detecting it), and print a count of word lengths, i.e. the total number of words of length 1 which occurred, the number of length 2, and so on.
Define a word to be a sequence of alphabetic characters. You should allow for word lengths up to 25 letters.
Typical output should be like this:

length 1 : 10 occurrences
      length 2 : 19 occurrences
      length 3 : 127 occurrences
      length 4 : 0 occurrences
      length 5 : 18 occurrences
      ....

To read characters to end of data see above question.

Looping and Iteration

2009-01-14T08:52:00.002-08:00

This chapter will look at C's mechanisms for controlling looping and iteration. Even though some of these mechanisms may look familiar and indeed will operate in standard fashion most of the time. NOTE: some non-standard features are available.

The `for` statement

The C for statement has the following form:


  for  (expression₁; ₂; expression₃)
     statement;
     or {block of statements}

expression₁ initialises; expression₂ is the terminate test; expression₃ is the modifier (which may be more than just simple increment);

NOTE: C basically treats for statements as while type loops

For example: int x; main() { for (x=3;x>0;x-) { printf("x=%dn",x); } }
...outputs:


  x=3
  x=2
  x=1

...to the screen
All the following are legal for statements in C. The practical application of such statements is not important here, we are just trying to illustrate peculiar features of C for that may be useful:-
for (x=0;((x>3) && (x<9)); x++) for (x=0,y=4;((x>3) && (y<9)); x++,y+=2) for (x=0,y=4,z=4000;z; z/=10)
The second example shows that multiple expressions can be separated a ,.
In the third example the loop will continue to iterate until z becomes 0;

The `while` statement

The while statement is similar to those used in other languages although more can be done with the expression statement -- a standard feature of C.
The while has the form:


  while (expression)
     statement

For example: int x=3; main() { while (x>0) { printf("x=%dn",x); x-; } }
...outputs:


  x=3
  x=2
  x=1

...to the screen.
Because the while loop can accept expressions, not just conditions, the following are all legal:-
while (x-); while (x=x+1); while (x+=5);
Using this type of expression, only when the result of x-, x=x+1, or x+=5, evaluates to 0 will the while condition fail and the loop be exited.
We can go further still and perform complete operations within the while expression:
while (i++ < 10); while ( (ch = getchar()) != `q') putchar(ch);
The first example counts i up to 10.
The second example uses C standard library functions (See Chapter 18) getchar() - reads a character from the keyboard - and putchar() - writes a given char to screen. The while loop will proceed to read from the keyboard and echo characters to the screen until a 'q' character is read. NOTE: This type of operation is used a lot in C and not just with character reading!! (See Exercises).

The `do-while` statement

C's do-while statement has the form:


  do 
     statement;
     while (expression);

It is similar to PASCAL's repeat ... until except do while expression is true.

For example:
int x=3; main() { do { printf("x=%dn",x-); } while (x>0); }
..outputs:-


  x=3
   x=2
   x=1

NOTE: The postfix x- operator which uses the current value of x while printing and then decrements x.

`break` and `continue`

C provides two commands to control how we loop:

break -- exit form loop or switch.
continue -- skip 1 iteration of loop.

Consider the following example where we read in integer values and process them according to the following conditions. If the value we have read is negative, we wish to print an error message and abandon the loop. If the value read is great than 100, we wish to ignore it and continue to the next value in the data. If the value is zero, we wish to terminate the loop.


   while (scanf( ``%d'', &value ) == 1 && value != 0) { 
 
     if (value < 0) {
       printf(``Illegal valuen'');
       break;
       /* Abandon the loop */
     }
 
     if (value > 100) {
       printf(``Invalid valuen'');
       continue;
       /* Skip to start loop again */
     }
 
     /* Process the value read */
       /* guaranteed between 1 and 100 */
           ....;
 
     ....;
   } /* end while value != 0 */

Exercises

Exercise 12327
Write a program to read in 10 numbers and compute the average, maximum and minimum values.
Exercise 12328
Write a program to read in numbers until the number -999 is encountered. The sum of all number read until this point should be printed out.
Exercise 12329
Write a program which will read an integer value for a base, then read a positive integer written to that base and print its value.
Read the second integer a character at a time; skip over any leading non-valid (i.e. not a digit between zero and ``base-1'') characters, then read valid characters until an invalid one is encountered.

Input       Output
        ==========     ======
        10    1234      1234
         8      77        63   (the value of 77 in base 8, octal)
         2    1111        15   (the value of 1111 in base 2, binary)

The base will be less than or equal to 10. Exercise 12330
Read in three values representing respectively
a capital sum (integer number of pence),
a rate of interest in percent (float),
and a number of years (integer).
Compute the values of the capital sum with compound interest added over the given period of years. Each year's interest is calculated as
interest = capital * interest_rate / 100;
and is added to the capital sum by
capital += interest;
Print out money values as pounds (pence / 100.0) accurate to two decimal places.
Print out a floating value for the value with compound interest for each year up to the end of the period.
Print output year by year in a form such as:

Original sum 30000.00 at  12.5 percent for 20 years

Year Interest  Sum
----+-------+--------
  1  3750.00 33750.00
  2  4218.75 37968.75
  3  4746.09 42714.84
  4  5339.35 48054.19
  5  6006.77 54060.96
  6  6757.62 60818.58
  7  7602.32 68420.90
  8  8552.61 76973.51
  9  9621.68 86595.19
 10 10824.39 97419.58

Exercise 12331
Read a positive integer value, and compute the following sequence: If the number is even, halve it; if it's odd, multiply by 3 and add 1. Repeat this process until the value is 1, printing out each value. Finally print out how many of these operations you performed.
Typical output might be:

Inital value is 9
 Next value is  28
 Next value is  14
 Next value is   7
 Next value is  22
 Next value is  11
 Next value is  34
 Next value is  17
 Next value is  52
 Next value is  26
 Next value is  13
 Next value is  40
 Next value is  20
 Next value is  10
 Next value is   5
 Next value is  16
 Next value is   8
 Next value is   4
 Next value is   2
 Final value 1, number of steps 19

If the input value is less than 1, print a message containing the word

Error

and perform an

exit( 0 );

Exercise 12332
Write a program to count the vowels and letters in free text given as standard input. Read text a character at a time until you encounter end-of-data.
Then print out the number of occurrences of each of the vowels a, e, i, o and u in the text, the total number of letters, and each of the vowels as an integer percentage of the letter total.
Suggested output format is:

Numbers of characters:
        a   3 ; e   2 ; i   0 ; o   1 ; u   0 ; rest  17
        Percentages of total:
        a  13%; e   8%; i   0%; o   4%; u   0%; rest  73%

Read characters to end of data using a construct such as

char ch;
        while(
            ( ch = getchar() ) >= 0
        ) {
            /* ch is the next character */    ....
        }

to read characters one at a time using getchar() until a negative value is returned. Exercise 12333
Read a file of English text, and print it out one word per line, all punctuation and non-alpha characters being omitted.
For end-of-data, the program loop should read until "getchar" delivers a value <= 0. When typing input, end the data by typing the end-of-file character, usually control-D. When reading from a file, "getchar" will deliver a negative value when it encounters the end of the file.
Typical output might be

Read
a
file
of
English
text
and
print
it
out
one

etc.

Conditionals

2009-01-14T08:52:00.001-08:00

This Chapter deals with the various methods that C can control the flow of logic in a program. Apart from slight syntactic variation they are similar to other languages.
As we have seen following logical operations exist in C:

==, !=, , &&.

One other operator is the unitary - it takes only one argument - not !.

These operators are used in conjunction with the following statements.

The `if` statement

The if statement has the same function as other languages. It has three basic forms:


  if  (expression)
     statement

...or:


  if  (expression)
     statement₁
   else
     statement₂

...or:


  if  (expression)
     statement₁
   else if (expression)
     statement₂
   else
     statement₃

For example:-
int x,y,w; main() { if (x>0) { z=w; ........ } else { z=y; ........ } }

The `?` operator

The ? (ternary condition) operator is a more efficient form for expressing simple if statements. It has the following form:


  expression₁ ? expression₂:  expression₃

It simply states:

if expression₁ then expression₂ else expression₃

For example to assign the maximum of a and b to z:
z = (a>b) ? a : b;
which is the same as:


  if (a>b)
     z = a;
   else
     z=b;

The `switch` statement

The C switch is similar to Pascal's case statement and it allows multiple choice of a selection of items at one level of a conditional where it is a far neater way of writing multiple if statements:


  switch (expression) {
     case item₁:
       statement₁;
       break;
     case item₂:
       statement₂;
       break;
                   case item_n:
       statement_n;
       break;
     default:
       statement;
       break;
    }

In each case the value of item_i must be a constant, variables are not allowed.
The break is needed if you want to terminate the switch after execution of one choice. Otherwise the next case would get evaluated. Note: This is unlike most other languages.
We can also have null statements by just including a ; or let the switch statement fall through by omitting any statements (see e.g. below).
The default case is optional and catches any other cases.

For example:-
switch (letter) { case `A': case `E': case `I': case `O': case `U': numberofvowels++; break; case ` ': numberofspaces++; break; default: numberofconstants++; break; }
In the above example if the value of letter is `A', `E', `I', `O' or `U' then numberofvowels is incremented.
If the value of letter is ` ' then numberofspaces is incremented.
If none of these is true then the default condition is executed, that is numberofconstants is incremented.

Exercises

Exercise 12304
Write a program to read two characters, and print their value when interpreted as a 2-digit hexadecimal number. Accept upper case letters for values from 10 to 15.

Exercise 12305
Read an integer value. Assume it is the number of a month of the year; print out the name of that month.

Exercise 12306
Given as input three integers representing a date as day, month, year, print out the number day, month and year for the following day's date.
Typical input: 28 2 1992 Typical output: Date following 28:02:1992 is 29:02:1992

Exercise 12307
Write a program which reads two integer values. If the first is less than the second, print the message up. If the second is less than the first, print the message down If the numbers are equal, print the message equal If there is an error reading the data, print a message containing the word Error and perform exit( 0 );

C/C++ Program Compilation

2009-01-14T08:41:00.000-08:00

C/C++ Program Compilation

In this chapter we begin by outlining the basic processes you need to go through in order to compile your C (or C++) programs. We then proceed to formally describe the C compilation model and also how C supports additional libraries.

Creating, Compiling and Running Your Program

The stages of developing your C program are as follows. (See Appendix and exercises for more info.)

Creating the program

Create a file containing the complete program, such as the above example. You can use any ordinary editor with which you are familiar to create the file. One such editor is textedit available on most UNIX systems.
The filename must by convention end ``.c'' (full stop, lower case c), e.g. myprog.c or progtest.c. The contents must obey C syntax. For example, they might be as in the above example, starting with the line /* Sample .... (or a blank line preceding it) and ending with the line } /* end of program */ (or a blank line following it).

Compilation

There are many C compilers around. The cc being the default Sun compiler. The GNU C compiler gcc is popular and available for many platforms. PC users may also be familiar with the Borland bcc compiler.
There are also equivalent C++ compilers which are usually denoted by CC (note upper case CC. For example Sun provides CC and GNU GCC. The GNU compiler is also denoted by g++
Other (less common) C/C++ compilers exist. All the above compilers operate in essentially the same manner and share many common command line options. Below and in Appendix we list and give example uses many of the common compiler options. However, the best source of each compiler is through the online manual pages of your system: e.g. man cc.
For the sake of compactness in the basic discussions of compiler operation we will simply refer to the cc compiler -- other compilers can simply be substituted in place of cc unless otherwise stated.
To Compile your program simply invoke the command cc. The command must be followed by the name of the (C) program you wish to compile. A number of compiler options can be specified also. We will not concern ourselves with many of these options yet, some useful and often essential options are introduced below -- See Appendix or online manual help for further details.
Thus, the basic compilation command is:
cc program.c
where program.c is the name of the file.
If there are obvious errors in your program (such as mistypings, misspelling one of the key words or omitting a semi-colon), the compiler will detect and report them.
There may, of course, still be logical errors that the compiler cannot detect. You may be telling the computer to do the wrong operations.
When the compiler has successfully digested your program, the compiled version, or executable, is left in a file called a.out or if the compiler option -o is used : the file listed after the -o.
It is more convenient to use a -o and filename in the compilation as in
cc -o program program.c
which puts the compiled program into the file program (or any file you name following the "-o" argument) instead of putting it in the file a.out .

Running the program

The next stage is to actually run your executable program. To run an executable in UNIX, you simply type the name of the file containing it, in this case program (or a.out)
This executes your program, printing any results to the screen. At this stage there may be run-time errors, such as division by zero, or it may become evident that the program has produced incorrect output.
If so, you must return to edit your program source, and recompile it, and run it again.

The C Compilation Model

We will briefly highlight key features of the C Compilation model (Fig. 2.1) here.

Fig. 2.1 The C Compilation Model

The Preprocessor

We will study this part of the compilation process in greater detail later (Chapter 13. However we need some basic information for some C programs.
The Preprocessor accepts source code as input and is responsible for

removing comments
interpreting special preprocessor directives denoted by #.

For example

#include -- includes contents of a named file. Files usually called header files. e.g
- #include -- standard library maths file.
- #include -- standard library I/O file
#define -- defines a symbolic name or constant. Macro substitution.
- #define MAX_ARRAY_SIZE 100

C Compiler

The C compiler translates source to assembly code. The source code is received from the preprocessor.

Assembler

The assembler creates object code. On a UNIX system you may see files with a .o suffix (.OBJ on MSDOS) to indicate object code files.

Link Editor

If a source file references library functions or functions defined in other source files the link editor combines these functions (with main()) to create an executable file. External Variable references resolved here also. More on this later (Chapter 34).

Some Useful Compiler Options

Now that we have a basic understanding of the compilation model we can now introduce some useful and sometimes essential common compiler options. Again see the online man pages and Appendix for further information and additional options.

-c: Suppress the linking process and produce a .o file for each source file listed. Several can be subsequently linked by the cc command, for example: cc file1.o file2.o ...... -o executable
-llibrary: Link with object libraries. This option must follow the source file arguments. The object libraries are archived and can be standard, third party or user created libraries (We discuss this topic briefly below and also in detail later (Chapter 34). Probably the most commonly used library is the math library ( math.h). You must link in this library explicitly if you wish to use the maths functions (note do note forget to #include header file), for example: cc calc.c -o calc -lm Many other libraries are linked in this fashion (see below)
-Ldirectory: Add directory to the list of directories containing object-library routines. The linker always looks for standard and other system libraries in /lib and /usr/lib. If you want to link in libraries that you have created or installed yourself (unless you have certain privileges and get the libraries installed in /usr/lib) you will have to specify where you files are stored, for example: cc prog.c -L/home/myname/mylibs mylib.a
-Ipathname: Add pathname to the list of directories in which to search for #include files with relative filenames (not beginning with slash /). BY default, The preprocessor first searches for #include files in the directory containing source file, then in directories named with -I options (if any), and finally, in /usr/include. So to include header files stored in /home/myname/myheaders you would do: cc prog.c -I/home/myname/myheaders Note: System library header files are stored in a special place (/usr/include) and are not affected by the -I option. System header files and user header files are included in a slightly different manner (see Chapters 13 and 34)
-g: invoke debugging option. This instructs the compiler to produce additional symbol table information that is used by a variety of debugging utilities.
-D: define symbols either as identifiers (-Didentifer) or as values (-Dsymbol=value) in a similar fashion as the #define preprocessor command. For more details on the use of this argument see Chapter 13.

For further information on general compiler options and the GNU compiler refer to Appendix .

Using Libraries

C is an extremely small language. Many of the functions of other languages are not included in C. e.g. No built in I/O, string handling or maths functions.
What use is C then?
C provides functionality through a rich set function libraries.
As a result most C implementations include standard libraries of functions for many facilities ( I/O etc.). For many practical purposes these may be regarded as being part of C. But they may vary from machine to machine. (cf Borland C for a PC to UNIX C).
A programmer can also develop his or her own function libraries and also include special purpose third party libraries (e.g. NAG, PHIGS).
All libraries (except standard I/O) need to be explicitly linked in with the -l and, possibly, -L compiler options described above.

UNIX Library Functions

The UNIX system provides a large number of C functions as libraries. Some of these implement frequently used operations, while others are very specialised in their application.
Do Not Reinvent Wheels: It is wise for programmers to check whether a library function is available to perform a task before writing their own version. This will reduce program development time. The library functions have been tested, so they are more likely to be correct than any function which the programmer might write. This will save time when debugging the program.
Later chapters deal with all important standard library issues and other common system libraries.

Finding Information about Library Functions

The UNIX manual has an entry for all available functions. Function documentation is stored in section 3 of the manual, and there are many other useful system calls in section 2. If you already know the name of the function you want, you can read the page by typing (to find about sqrt):
man 3 sqrt
If you don't know the name of the function, a full list is included in the introductory page for section 3 of the manual. To read this, type
man 3 intro
There are approximately 700 functions described here. This number tends to increase with each upgrade of the system.
On any manual page, the SYNOPSIS section will include information on the use of the function. For example:

#include 

  char *ctime(time_t *clock)

This means that you must have

#include

in your file before you call ctime. And that function ctime takes a pointer to type time_t as an argument, and returns a string (char *). time_t will probably be defined in the same manual page.
The DESCRIPTION section will then give a short description of what the function does. For example:

ctime() converts a long integer, pointed to by clock,  to  a
  26-character  string  of the form produced by asctime().

Lint -- A C program verifier

You will soon discover (if you have not already) that the C compiler is pretty vague in many aspects of checking program correctness, particularly in type checking. Careful use of prototyping of functions can assist modern C compilers in this task. However, There is still no guarantee that once you have successfully compiled your program that it will run correctly.
The UNIX utility lint can assist in checking for a multitude of programming errors. Check out the online manual pages (man lint) for complete details of lint. It is well worth the effort as it can help save many hours debugging your C code.
To run lint simply enter the command:
lint myprog.c.
Lint is particularly good at checking type checking of variable and function assignments, efficiency, unused variables and function identifiers, unreachable code and possibly memory leaks. There are many useful options to help control lint (see man lint).

Exercises

Exercise 12171
Enter, compile and run the following program:

main()

 { int i;

    printf("\t Number \t\t Square of Number\n\n");

    for (i=0; i<=25;++i)
            printf("\t %d \t\t\t %d \n",i,i*i);

 }

Exercise 12172
The following program uses the math library. Enter compile and run it correctly.

#include 

 main()

 { int i;

    printf("\t Number \t\t Square Root of Number\n\n");

    for (i=0; i<=360; ++i)
            printf("\t %d \t\t\t %d \n",i, sqrt((double) i));

 }

Exercise 12173
Look in /lib and /usr/lib and see what libraries are available.

Use the man command to get details of library functions
Explore the libraries to see what each contains by running the command ar t libfile.

Exercise 12174
Look in /usr/include and see what header files are available.

Use the more or cat commands to view these text files
Explore the header files to see what each contains, note the include, define, type definitions and function prototypes declared in them

Exercise 12175
Suppose you have a C program whose main function is in main.c and has other functions in the files input.c and output.c:

What command(s) would you use on your system to compile and link this program?
How would you modify the above commands to link a library called process1 stored in the standard system library directory?
How would you modify the above commands to link a library called process2 stored in your home directory?
Some header files need to be read and have been found to located in a header subdirectory of your home directory and also in the current working directory. How would you modify the compiler commands to account for this?

Exercise 12176
Suppose you have a C program composed of several separate files, and they include one another as shown below:

**Figure 1.5:** Sample Icon from Xterm Application
File	Include Files
`main.c`	`stdio.h, process1.h`
`input.c`	`stdio.h, list.h`
`output.c`	`stdio.h`
`process1.c`	`stdio.h, process1.h`
`process2.c`	`stdio.h, list.h`

Which files have to recompiled after you make changes to process1.c?
Which files have to recompiled after you make changes to process1.h?
Which files have to recompiled after you make changes to list.h?

The Common Desktop Environment

2009-01-14T08:37:00.000-08:00

The Common Desktop Environment

In order to use Solaris and most other Unix Systems you will need to be familiar with the Common Desktop Environment (CDE). Before embarking on learning C with briefly introduce the main features of the CDE.
Most major Unix vendors now provide the CDE as standard. Consequently, most users of the X Window system will now be exposed to the CDE. Indeed, continuing trends in the development of Motif and CDE will probably lead to a convergence of these technologies in the near future. This section highlights the key features of the CDE from a Users perspective.
Upon login, the user is presented with the CDE Desktop (Fig. 1.1). The desktop includes a front panel (Fig. 1.2) , multiple virtual workspaces, and window management. CDE supports the running of applications from a file manager, from an application manager and from the front panel. Each of the subcomponents of the desktop are described below.

Fig. 1.1 Sample CDE Desktop

The front panel

The front panel (Fig. 1.2) contains a set of icons and popup menus (more like roll-up menus) that appear at the bottom of the screen, by default (Fig. 1.1). The front panel contains the most regularly used applications and tools for managing the workspace. Users can drag-and-drop application icons from the file manager or application manager to the popups for addition of the application(s) to the associated menu. The user can also manipulate the default actions and icons for the popups. The front panel can be locked so that users can't change it. A user can configure several virtual workspaces -- each with different backgrounds and colors if desired. Each workspace can have any number of applications running in it. An application can be set to appear in one, more than one, or all workspaces simultaneously.

Fig. 1.2 Clients, Servers and Xlib

The file manager

CDE includes a standard file manager. The functionality is similar to that of the Microsoft Windows, Macintosh, or Sun Open Look file manager. Users can directly manipulate icons associated with UNIX files, drag-and-drop them, and launch associated applications.

The application manager

The user interaction with the application manager is similar to the file manager except that is is intended to be a list of executable modules available to a particular user. The user launches the application manager from an icon in the front panel. Users are notified when a new application is available on a server by additions (or deletions) to the list of icons in the application manager window. Programs and icons can be installed and pushed out to other workstations as an integral part of the installation process. The list of workstations that new software is installed on is configurable. The application manager comes preconfigured to include several utilities and programs.

The session manager

The session manager is responsible for the start up and shut down of a user session. In the CDE, applications that are made CDE aware are warned via an X Event when the X session is closing down. The application responds by returning a string that can be used by the session manager at the user's next login to restart the application. CDE can remember two sessions per user. One is the current session, where a snapshot of the currently running applications is saved. These applications can be automatically restarted at the user's next login. The other is the default login, which is analogous to starting an X session in the Motif window manager. The user can choose which of the two sessions to use at the next login.

Other CDE desktop tools

CDE 1.0 includes a set of applications that enable users to become productive immediately. Many of these are available directly from the front panel, others from the desktop or personal application managers. Common and productive desktop tools include:

Mail Tool: -- Used to compose, view, and manage electronic mail through a GUI. Allows the inclusion of attachments and communications with other applications through the messaging system.
Calendar Manager: -- Used to manage, schedule, and view appointments, create calendars, and interact with the Mail Tool.
Editor: -- A text editor with common functionality including data transfer with other applications via the clipboard, drag and drop, and primary and quick transfer.
Terminal Emulator: -- An xterm terminal emulator.
Calculator: -- A standard calculator with scientific, financial, and logical modes.
Print Manager: -- A graphical print job manager for the scheduling and management of print jobs on any available printer.
Help System: -- A context-sensitive graphical help system based on Standard Generalized Markup Language (SGML).
Style Manager: -- A graphical interface that allows a user to interactively set their preferences, such as colors, backdrops, and fonts, for a session.
Icon Editor: -- This application is a fairly full featured graphical icon (pixmap) editor.

Application development tools

CDE includes two components for application development. The first is a shell command language interpreter that has built-in commands for most X Window system and CDE functions. The interpreter is based on ksh93 (The Korn Shell), and should provide anyone familiar with shell scripts the ability to develop X, Motif, and CDE applications.
To support interactive user interface development, developers can use the Motif Application Builder. This is a GUI front end for building Motif applications that generates C source code. The source code is then compiled and linked with the X and Motif libraries to produce the executable binary.

Application integration

CDE provides a number of tools to ease integration. The overall model of the CDE session is intended to allow a straightforward integration for virtually all types of applications. Motif and other X toolkit applications usually require little integration.
The task of integrating in-house and third party applications into a desktop, often the most difficult aspect of a desktop installation, is simplified by CDE. The power and advantage of CDE functionality can be realized in most cases without recompiling applications.
For example, Open Look applications can be integrated through the use of scripts that perform front-end execution of the application and scripts that perform pre- and post-session processing.
After the initial task of integrating applications so that they fit within session management, further integration can be done to increase their overall common look-and-feel with the rest of the desktop and to take advantage of the full range of CDE functionality. Tools that ease this aspect of integration include an Icon Editor used to create colour and monochrome icons. Images can be copied from the desktop into an icon, or they can be drawn freehand.
The Action Creation Utility is used to create action entries in the action database. Actions allow applications to be launched using desktop icons, and they ease administration by removing an application's specific details from the user interface.
The Application Gather and Application Integrate routines are used to control and format the application manager. They simplify installations so that applications can be accessible from virtually anywhere on the network.

Windows and the Window Manager

From a user's perspective, one of the first distinguishing features of Motif's look and feel is the window frame (Fig. 1.3). Every application window is contained inside such a frame. The following items appear in the window frame:

Fig. 1.3 The Motif Window Frame

Title Bar

-- This identifies the window by a text string. The string is usually the name of the application program. However, an application's resource controls the label (Chapter ).

Window Menu

-- Every window under the control of mwm has a window menu. The application has a certain amount of control over items that can be placed in the menu. The Motif Style Guide insists that certain commands are always available in this menu and that they can be accessed from either mouse or keyboard selection. Keyboard selections are called mnemonics and allow routine actions (that may involve several mouse actions) to be called from the keyboard. The action from the keyboard usually involves pressing two keys at the same time: the Meta key and another key. The default window menu items and mnemonics are listed below and illustrated in Fig. 1.4: Fig. 1.4 The Window Menu

Restore (Meta+F5) -- Restore window to previous size after iconification (see below).
Move (Meta+F7) -- Allows the window to be repositioned with a drag of the mouse.
Size (Meta+F8) -- Allows the size of the window to be changed by dragging on the corners of the window.
Minimize (Meta+F9) -- Iconify the window.
Maximize (Meta+F10) -- Make the window the size of the root window, usually the whole of the display size.
Lower (Meta+F3) -- Move the window to the bottom of the window stack. Windows may be tiled on top of each other (see below). The front window being the top of the stack.
Close (Meta+F4) -- Quit the program. Some simple applications (Chapter ) provide no internal means of termination. The Close option being the only means to achieve this.

Minimize Button

-- another way to iconify a window .

Maximize Button

-- another way to make a window the size of the root window .

The window manager must also be able to manage multiple windows from multiple client applications. There are a few important issues that need to be resolved. When running several applications together, several windows may be displayed on the screen. As a result, the display may appear cluttered and hard to navigate. The window manager provides two mechanisms to help deal with such problems:

Active Window

-- Only one window can receive input at any time. If you are selecting a graphical object with a mouse, then it is relatively easy for the window manager to detect this and schedule appropriate actions related to the chosen object. It is not so easy when you enter data or make selections directly from the keyboard. To resolve this only one window at a time is allowed keyboard focus. This window is called the active window. The selection of the active window will depend on the system configuration which the user typically has control over. There are two common methods for selecting the active window:

Focus follows pointer: -- The active window is the window is the window underneath mouse pointer.
Click-to-type: -- The active window is selected, by clicking on an area of the window, and remains active until another window is selected no matter where the mouse points.

When a window is made active its appearance will change slightly:

Its outline frame will become shaded.
The cursor will change appearance when placed in the window.
The window may jump, or be raised to the top of the window stack.

The exact appearance of the above may vary from system to system and may be controlled by the user by setting environment settings in the window manager.

Window tiling

-- Windows may be stacked on top of each other. The window manager tries to maintain a three-dimensional look and feel . Apart from the fact that buttons, dialog boxes appear to be elevated from the screen, windows are shaded and framed in a three-dimensional fashion. The top window (or currently active window) will have slightly different appearance for instance. The window menu has a few options for controlling the tiling of a window. Also a window can be brought to the top of the stack, or raised by clicking a part of its frame.

Iconification

-- If a window is currently active and not required for input or displaying output then it may be iconified or minimised thus reducing the screen clutter. An icon (Fig. 1.5) is a small graphical symbol that represents the window (or application). It occupies a significantly less amount of screen area. Icons are usually arranged around the perimeter (typically bottom or left side) of the screen. The application will still be running and occupying computer memory. The window related to the icon may be reverted to by either double clicking on the icon, or selecting Restore or Maximise from the icon's window menu.

**Figure 1.5:** Sample Icon from Xterm Application

The Root Menu

The Root Menu is the main menu of the window manager. The root menu typically is used to control the whole display, for example starting up new windows and quitting the desktop. To display the Root menu:

Move the mouse pointer to the Root Window.
Hold down the left mouse button.

The default Root Menu has the following The root menu can be customised to start up common applications for example. The root menu for the mwm (Fig. 1.6) and dtwm (Fig. 1.7) have slightly different appearance but have broadly similar actions, which are summarised below:

Fig. 1.6 The mwm Root Menu
Fig. 1.7 The CDE dtwm Root Menu

Program: (dtwm) -- A sub-menu is displayed that allows a variety of programs to be called from the desktop, for example to create a new window. The list of available programs can be customised from the desktop.
New Window: (mwm) -- Create a new window which is usually an Xterm window.
Shuffle Up: -- Move the bottom of the window stack to the top.
Shuffle Down: -- Move the top of the window stack to the bottom.
Refresh: -- Refresh the current screen display.
Restart: -- Restart the Workspace.
Logout: (dtwm) -- Quit the Window Manager.

Exercises

Exercise 12158
Exercise~\ref{ex.cde1}

Add an application to the application manager
Exercise 12159
Practice opening, closing and moving windows around the screen and to/from the background/foreground. Get used to using the mouse and its buttons for such tasks.
Exercise 12160
Figure out the function of each of the three mouse buttons. Pay particular attention to the different functions the buttons in different windows (applications) and also when the mouse is pointing to the background.

Exercise 12161
Find out how to resize windows etc. and practice this.
Exercise 12162
Fire up the texteditor of your choice (You may use dtpad (basic but functional), textedit application (SOLARIS basic editor), emacs/Xemacs, or vi) and practice editing text files. Create any files you wish for now. Figure out basic options like cut and paste of text around the file, saving and loading files, searching for strings in the text and replacing strings.
Particularly pay attention in getting used to using the Key Strokes and / or mouse to perform the above tasks.
Exercise 12163
Use Unix Commands to

1.: Copy a file (created by text editor or other means) to another file called spare.
2.: Rename your original file to b called new.
3.: Delete the file spare.
4.: Display your original file on the terminal.
5.: Print your file out.

Exercise 12164
Familiarise yourself with other UNIX functions by creating various files of text etc. and trying out the various functions listed in handouts.

How to use the keyboard as input for games - Delphi

2008-12-31T18:44:00.000-08:00

Using the following code to let the player move in a game works. However, it doesn't really work the way we want. The problem is that when the player, for example, holds down the left arrow key and then fires, then the left movement will stop because another key than left is sent to the FormKeyDown() procedure. This will result in a nearly unplayable game in most cases.

procedure TForm1.FormKeyDown(Sender: TObject;
  var Key: Word; Shift: TShiftState);
begin
  case Key of
    vk_left  : Dec(x);
    vk_right : Inc(x);
    vk_up    : Dec(y);
    vk_down  : Inc(x);
    vk_space : BulletFired;  // call to another procedure
  end;
end;

What we need is to detect key presses without interrupting already present keys which are down. The solution for this is to keep a state of each key. This is done with the following global variables.

var
  movingUp    : boolean;
  movingDown  : boolean;
  movingRight : boolean;
  movingLeft  : boolean;

Now, instead of triggering the result directly (i.e. increasing/decreasing x/y position) we use the FormKeyDown() and FormKeyUp() procedures to toggle the state of each key. In this way, multiple keys may be down at once (for example the user may move up and right (diagonally) the same time as he presses fire).

FormKeyDown sets respectively state to True. Because someone can't move both up AND down at the same time the "opposite" key has to be set to False.

procedure TForm1.FormKeyDown(Sender: TObject;
  var Key: Word; Shift: TShiftState);
begin
  case Key of
    vk_left:
      begin
        movingLeft  := True;
        movingRight := False;
      end;
    vk_right:
      begin
        movingLeft  := False;
        movingRight := True;
      end;
    vk_up:
      begin
        movingUp   := True;
        movingDown := False;
      end;
    vk_down:
      begin
        movingUp   := False;
        movingDown := True;
      end;
    vk_space: BulletFired;
  end;
end;

When a key is released the state is set to False in the FormKeyUp procedure.

procedure TForm1.FormKeyUp(Sender: TObject;
  var Key: Word; Shift: TShiftState);
begin
  case Key of
    vk_left  : movingLeft  := False;
    vk_right : movingRight := False;
    vk_up    : movingUp    := False;
    vk_down  : movingDown  := False;
    end;
end;

The actual moving of the player is then performed from the game loop (Application.OnIdle for example) depending on each state. This is also the place to check to see if the player doesn't move out of bounds or collide into anything else.

procedure TForm1.MovePlayer;
  if movingUp    then Dec(y);
  if movingDown  then Inc(y);
  if movingLeft  then Dec(x);
  if movingRight then Inc(x);
end;

This article was an example of how it may be done. I've tried to make it as general as possible so it shouldn't be a problem to apply this to a project, no matter if it's a jump'n run, racing or a shoot'em up game.

(more than one year later...)

As commented below, there is also another approach of doing this by using GetKeyState. The reason for the above, quite lenghty, solution is basically that I didn't know of GetKeyState when I wrote it more than one year ago. Therefore I do this little rewrite and add the GetKeyState solution.

Simply get rid of all the code above, and just replace the MovePlayer procedure with this code:

procedure TMainForm.MovePlayer;
begin
  if (GetKeyState(VK_UP) and $80) = $80 then
    Dec(y);

  if (GetKeyState(VK_DOWN) and $80) = $80 then
    Inc(y);

  if (GetKeyState(VK_LEFT) and $80) = $80 then
    Dec(x);

  if (GetKeyState(VK_RIGHT) and $80) = $80 then
    Inc(x);
end;

How to send keystrokes to another application (a better one) -Delphi

2008-12-31T18:41:00.000-08:00

Found another unit which has exactly the same functionality as the SendKeys method of VB. The Code was written by Ken Henderson, email:khen@compuserve.com.

Begin of listing
======================================================================

(*
SendKeys routine for 32-bit Delphi.

Written by Ken Henderson

Copyright (c) 1995 Ken Henderson email:khen@compuserve.com

This unit includes two routines that simulate popular Visual Basic
routines: Sendkeys and AppActivate. SendKeys takes a PChar
as its first parameter and a boolean as its second, like so:

SendKeys('KeyString', Wait);

where KeyString is a string of key names and modifiers that you want
to send to the current input focus and Wait is a boolean variable or value
that indicates whether SendKeys should wait for each key message to be
processed before proceeding. See the table below for more information.

AppActivate also takes a PChar as its only parameter, like so:

AppActivate('WindowName');

where WindowName is the name of the window that you want to make the
current input focus.

SendKeys supports the Visual Basic SendKeys syntax, as documented below.

Supported modifiers:

+ = Shift
^ = Control
% = Alt

Surround sequences of characters or key names with parentheses in order to
modify them as a group. For example, '+abc' shifts only 'a', while '+(abc)' shifts
all three characters.

Supported special characters

~ = Enter
( = Begin modifier group (see above)
) = End modifier group (see above)
{ = Begin key name text (see below)
} = End key name text (see below)

Supported characters:

Any character that can be typed is supported. Surround the modifier keys
listed above with braces in order to send as normal text.

Supported key names (surround these with braces):

BKSP, BS, BACKSPACE
BREAK
CAPSLOCK
CLEAR
DEL
DELETE
DOWN
END
ENTER
ESC
ESCAPE
F1
F2
F3
F4
F5
F6
F7
F8
F9
F10
F11
F12
F13
F14
F15
F16
HELP
HOME
INS
LEFT
NUMLOCK
PGDN
PGUP
PRTSC
RIGHT
SCROLLLOCK
TAB
UP

Follow the keyname with a space and a number to send the specified key a
given number of times (e.g., {left 6}).
*)

unit sndkey32;

interface

Uses SysUtils, Windows, Messages;

Function SendKeys(SendKeysString : PChar; Wait : Boolean) : Boolean;
function AppActivate(WindowName : PChar) : boolean;

{Buffer for working with PChar's}

const
  WorkBufLen = 40;
var
  WorkBuf : array[0..WorkBufLen] of Char;

implementation
type
  THKeys = array[0..pred(MaxLongInt)] of byte;
var
  AllocationSize : integer;

(*
Converts a string of characters and key names to keyboard events and
passes them to Windows.

Example syntax:

SendKeys('abc123{left}{left}{left}def{end}456{left 6}ghi{end}789', True);

*)

Function SendKeys(SendKeysString : PChar; Wait : Boolean) : Boolean;
type
  WBytes = array[0..pred(SizeOf(Word))] of Byte;

  TSendKey = record
    Name : ShortString;
    VKey : Byte;
  end;

const

{Array of keys that SendKeys recognizes.

  If you add to this list, you must be sure to keep it sorted alphabetically
  by Name because a binary search routine is used to scan it.}

  MaxSendKeyRecs = 41;
  SendKeyRecs : array[1..MaxSendKeyRecs] of TSendKey =
  (
   (Name:'BKSP'; VKey:VK_BACK),
   (Name:'BS'; VKey:VK_BACK),
   (Name:'BACKSPACE'; VKey:VK_BACK),
   (Name:'BREAK'; VKey:VK_CANCEL),
   (Name:'CAPSLOCK'; VKey:VK_CAPITAL),
   (Name:'CLEAR'; VKey:VK_CLEAR),
   (Name:'DEL'; VKey:VK_DELETE),
   (Name:'DELETE'; VKey:VK_DELETE),
   (Name:'DOWN'; VKey:VK_DOWN),
   (Name:'END'; VKey:VK_END),
   (Name:'ENTER'; VKey:VK_RETURN),
   (Name:'ESC'; VKey:VK_ESCAPE),
   (Name:'ESCAPE'; VKey:VK_ESCAPE),
   (Name:'F1'; VKey:VK_F1),
   (Name:'F10'; VKey:VK_F10),
   (Name:'F11'; VKey:VK_F11),
   (Name:'F12'; VKey:VK_F12),
   (Name:'F13'; VKey:VK_F13),
   (Name:'F14'; VKey:VK_F14),
   (Name:'F15'; VKey:VK_F15),
   (Name:'F16'; VKey:VK_F16),
   (Name:'F2'; VKey:VK_F2),
   (Name:'F3'; VKey:VK_F3),
   (Name:'F4'; VKey:VK_F4),
   (Name:'F5'; VKey:VK_F5),
   (Name:'F6'; VKey:VK_F6),
   (Name:'F7'; VKey:VK_F7),
   (Name:'F8'; VKey:VK_F8),
   (Name:'F9'; VKey:VK_F9),
   (Name:'HELP'; VKey:VK_HELP),
   (Name:'HOME'; VKey:VK_HOME),
   (Name:'INS'; VKey:VK_INSERT),
   (Name:'LEFT'; VKey:VK_LEFT),
   (Name:'NUMLOCK'; VKey:VK_NUMLOCK),
   (Name:'PGDN'; VKey:VK_NEXT),
   (Name:'PGUP'; VKey:VK_PRIOR),
   (Name:'PRTSC'; VKey:VK_PRINT),
   (Name:'RIGHT'; VKey:VK_RIGHT),
   (Name:'SCROLLLOCK'; VKey:VK_SCROLL),
   (Name:'TAB'; VKey:VK_TAB),
   (Name:'UP'; VKey:VK_UP)
  );
{Extra VK constants missing from Delphi's Windows API interface}
  VK_NULL=0;
  VK_SemiColon=186;
  VK_Equal=187;
  VK_Comma=188;
  VK_Minus=189;
  VK_Period=190;
  VK_Slash=191;
  VK_BackQuote=192;
  VK_LeftBracket=219;
  VK_BackSlash=220;
  VK_RightBracket=221;
  VK_Quote=222;
  VK_Last=VK_Quote;

  ExtendedVKeys : set of byte =
  [VK_Up,
   VK_Down,
   VK_Left,
   VK_Right,
   VK_Home,
   VK_End,
   VK_Prior, {PgUp}
   VK_Next, {PgDn}
   VK_Insert,
   VK_Delete];

const
  INVALIDKEY = $FFFF;
  VKKEYSCANSHIFTON = $01;
  VKKEYSCANCTRLON = $02;
  VKKEYSCANALTON = $04;
  UNITNAME = 'SendKeys';
var
  UsingParens, ShiftDown, ControlDown, AltDown, FoundClose : Boolean;
  PosSpace : Byte;
  I, L : Integer;
  NumTimes, MKey : Word;
  KeyString : String[20];

procedure DisplayMessage(Message : PChar);
begin
  MessageBox(0,Message,UNITNAME,0);
end;

function BitSet(BitTable, BitMask : Byte) : Boolean;
begin
  Result:=ByteBool(BitTable and BitMask);
end;

procedure SetBit(var BitTable : Byte; BitMask : Byte);
begin
  BitTable:=BitTable or Bitmask;
end;

Procedure KeyboardEvent(VKey, ScanCode : Byte; Flags : Longint);
var
  KeyboardMsg : TMsg;
begin
  keybd_event(VKey, ScanCode, Flags,0);
  If (Wait) then While (PeekMessage(KeyboardMsg,0,WM_KEYFIRST, WM_KEYLAST, PM_REMOVE)) do begin
    TranslateMessage(KeyboardMsg);
    DispatchMessage(KeyboardMsg);
  end;
end;

Procedure SendKeyDown(VKey: Byte; NumTimes : Word; GenUpMsg : Boolean);
var
  Cnt : Word;
  ScanCode : Byte;
  NumState : Boolean;
  KeyBoardState : TKeyboardState;
begin
  If (VKey=VK_NUMLOCK) then begin
    NumState:=ByteBool(GetKeyState(VK_NUMLOCK) and 1);
    GetKeyBoardState(KeyBoardState);
    If NumState then KeyBoardState[VK_NUMLOCK]:=(KeyBoardState[VK_NUMLOCK] and not 1)
    else KeyBoardState[VK_NUMLOCK]:=(KeyBoardState[VK_NUMLOCK] or 1);
    SetKeyBoardState(KeyBoardState);
    exit;
  end;

  ScanCode:=Lo(MapVirtualKey(VKey,0));
  For Cnt:=1 to NumTimes do
    If (VKey in ExtendedVKeys)then begin
      KeyboardEvent(VKey, ScanCode, KEYEVENTF_EXTENDEDKEY);
      If (GenUpMsg) then
        KeyboardEvent(VKey, ScanCode, KEYEVENTF_EXTENDEDKEY or KEYEVENTF_KEYUP)
    end else begin
      KeyboardEvent(VKey, ScanCode, 0);
      If (GenUpMsg) then KeyboardEvent(VKey, ScanCode, KEYEVENTF_KEYUP);
    end;
end;

Procedure SendKeyUp(VKey: Byte);
var
  ScanCode : Byte;
begin
  ScanCode:=Lo(MapVirtualKey(VKey,0));
  If (VKey in ExtendedVKeys)then
    KeyboardEvent(VKey, ScanCode, KEYEVENTF_EXTENDEDKEY and KEYEVENTF_KEYUP)
  else KeyboardEvent(VKey, ScanCode, KEYEVENTF_KEYUP);
end;

Procedure SendKey(MKey: Word; NumTimes : Word; GenDownMsg : Boolean);
begin
  If (BitSet(Hi(MKey),VKKEYSCANSHIFTON)) then SendKeyDown(VK_SHIFT,1,False);
  If (BitSet(Hi(MKey),VKKEYSCANCTRLON)) then SendKeyDown(VK_CONTROL,1,False);
  If (BitSet(Hi(MKey),VKKEYSCANALTON)) then SendKeyDown(VK_MENU,1,False);
  SendKeyDown(Lo(MKey), NumTimes, GenDownMsg);
  If (BitSet(Hi(MKey),VKKEYSCANSHIFTON)) then SendKeyUp(VK_SHIFT);
  If (BitSet(Hi(MKey),VKKEYSCANCTRLON)) then SendKeyUp(VK_CONTROL);
  If (BitSet(Hi(MKey),VKKEYSCANALTON)) then SendKeyUp(VK_MENU);
end;

{Implements a simple binary search to locate special key name strings}
Function StringToVKey(KeyString : ShortString) : Word;
var
  Found, Collided : Boolean;
  Bottom, Top, Middle : Byte;
begin
  Result:=INVALIDKEY;
  Bottom:=1;
  Top:=MaxSendKeyRecs;
  Found:=false;
  Middle:=(Bottom+Top) div 2;
  Repeat
    Collided:=((Bottom=Middle) or (Top=Middle));
    If (KeyString=SendKeyRecs[Middle].Name) then begin
       Found:=True;
       Result:=SendKeyRecs[Middle].VKey;
    end else begin
       If (KeyString>SendKeyRecs[Middle].Name) then Bottom:=Middle
       else Top:=Middle;
       Middle:=(Succ(Bottom+Top)) div 2;
    end;
  Until (Found or Collided);
  If (Result=INVALIDKEY) then DisplayMessage('Invalid Key Name');
end;

procedure PopUpShiftKeys;
begin
  If (not UsingParens) then begin
    If ShiftDown then SendKeyUp(VK_SHIFT);
    If ControlDown then SendKeyUp(VK_CONTROL);
    If AltDown then SendKeyUp(VK_MENU);
    ShiftDown:=false;
    ControlDown:=false;
    AltDown:=false;
  end;
end;

begin
  AllocationSize:=MaxInt;
  Result:=false;
  UsingParens:=false;
  ShiftDown:=false;
  ControlDown:=false;
  AltDown:=false;
  I:=0;
  L:=StrLen(SendKeysString);
  If (L>AllocationSize) then L:=AllocationSize;
  If (L=0) then Exit;

  While (I
    case SendKeysString[I] of
    '(' : begin
            UsingParens:=True;
            Inc(I);
          end;
    ')' : begin
            UsingParens:=False;
            PopUpShiftKeys;
            Inc(I);
          end;
    '%' : begin
             AltDown:=True;
             SendKeyDown(VK_MENU,1,False);
             Inc(I);
          end;
    '+' : begin
             ShiftDown:=True;
             SendKeyDown(VK_SHIFT,1,False);
             Inc(I);
           end;
    '^' : begin
             ControlDown:=True;
             SendKeyDown(VK_CONTROL,1,False);
             Inc(I);
           end;
    '{' : begin
            NumTimes:=1;
            If (SendKeysString[Succ(I)]='{') then begin
              MKey:=VK_LEFTBRACKET;
              SetBit(Wbytes(MKey)[1],VKKEYSCANSHIFTON);
              SendKey(MKey,1,True);
              PopUpShiftKeys;
              Inc(I,3);
              Continue;
            end;
            KeyString:='';
            FoundClose:=False;
            While (I<=L) do begin
              Inc(I);
              If (SendKeysString[I]='}') then begin
                FoundClose:=True;
                Inc(I);
                Break;
              end;
              KeyString:=KeyString+Upcase(SendKeysString[I]);
            end;
            If (Not FoundClose) then begin
               DisplayMessage('No Close');
               Exit;
            end;
            If (SendKeysString[I]='}') then begin
              MKey:=VK_RIGHTBRACKET;
              SetBit(Wbytes(MKey)[1],VKKEYSCANSHIFTON);
              SendKey(MKey,1,True);
              PopUpShiftKeys;
              Inc(I);
              Continue;
            end;
            PosSpace:=Pos(' ',KeyString);
            If (PosSpace<>0) then begin
               NumTimes:=StrToInt(Copy(KeyString,Succ(PosSpace),Length(KeyString)-PosSpace));
               KeyString:=Copy(KeyString,1,Pred(PosSpace));
            end;
            If (Length(KeyString)=1) then MKey:=vkKeyScan(KeyString[1])
            else MKey:=StringToVKey(KeyString);
            If (MKey<>INVALIDKEY) then begin
              SendKey(MKey,NumTimes,True);
              PopUpShiftKeys;
              Continue;
            end;
          end;
    '~' : begin
            SendKeyDown(VK_RETURN,1,True);
            PopUpShiftKeys;
            Inc(I);
          end;
    else begin
             MKey:=vkKeyScan(SendKeysString[I]);
             If (MKey<>INVALIDKEY) then begin
               SendKey(MKey,1,True);
               PopUpShiftKeys;
             end else DisplayMessage('Invalid KeyName');
             Inc(I);
          end;
    end;
  end;
  Result:=true;
  PopUpShiftKeys;
end;

{AppActivate

This is used to set the current input focus to a given window using its
name. This is especially useful for ensuring a window is active before
sending it input messages using the SendKeys function. You can specify
a window's name in its entirety, or only portion of it, beginning from
the left.

}

var
  WindowHandle : HWND;

function EnumWindowsProc(WHandle: HWND; lParam: LPARAM): BOOL; export; stdcall;
const
  MAX_WINDOW_NAME_LEN = 80;
var
  WindowName : array[0..MAX_WINDOW_NAME_LEN] of char;
begin
  {Can't test GetWindowText's return value since some windows don't have a title}
  GetWindowText(WHandle,WindowName,MAX_WINDOW_NAME_LEN);
  Result := (StrLIComp(WindowName,PChar(lParam), StrLen(PChar(lParam))) <> 0);
  If (not Result) then WindowHandle:=WHandle;
end;

function AppActivate(WindowName : PChar) : boolean;
begin
  try
    Result:=true;
    WindowHandle:=FindWindow(nil,WindowName);
    If (WindowHandle=0) then EnumWindows(@EnumWindowsProc,Intege (PChar(WindowName)));
    If (WindowHandle<>0) then begin
      SendMessage(WindowHandle, WM_SYSCOMMAND, SC_HOTKEY, WindowHandle);
      SendMessage(WindowHandle, WM_SYSCOMMAND, SC_RESTORE, WindowHandle);
    end else Result:=false;
  except
    on Exception do Result:=false;
  end;
end;

end.

======================================================================
End of listing

Try creating a new unit and paste the code above in it. The comments in the unit explain how to use it. In Holland we would say: "Beter goed gejat dan slecht verzonnen"

Adding Application or Ports to the Windows Firewall - Delphi

2008-12-31T18:40:00.000-08:00

//Don't forget to add ActiveX and ComObj in your uses statement.

Const
  NET_FW_PROFILE_DOMAIN = 0;
  NET_FW_PROFILE_STANDARD = 1;
  NET_FW_IP_VERSION_ANY = 2;
  NET_FW_IP_PROTOCOL_UDP = 17;
  NET_FW_IP_PROTOCOL_TCP = 6;
  NET_FW_SCOPE_ALL = 0;
  NET_FW_SCOPE_LOCAL_SUBNET = 1;

procedure addPortToFirewall(EntryName:string;PortNumber:Cardinal);
var
  fwMgr,port:OleVariant;
  profile:OleVariant;
begin
  fwMgr := CreateOLEObject('HNetCfg.FwMgr');
  profile := fwMgr.LocalPolicy.CurrentProfile;
  port := CreateOLEObject('HNetCfg.FWOpenPort');
  port.Name := EntryName;
  port.Protocol := NET_FW_IP_PROTOCOL_TCP;
  port.Port := PortNumber;
  port.Scope := NET_FW_SCOPE_ALL;
  port.Enabled := true;
  profile.GloballyOpenPorts.Add(port);
end;

procedure addApplicationToFirewall(EntryName:string;ApplicationPathAndExe:string);
var
  fwMgr,app,port:OleVariant;
  profile:OleVariant;
begin
  fwMgr := CreateOLEObject('HNetCfg.FwMgr');
  profile := fwMgr.LocalPolicy.CurrentProfile;
  app := CreateOLEObject('HNetCfg.FwAuthorizedApplication');
  app.ProcessImageFileName := ApplicationPathAndExe;
  app.Name := EntryName;
  app.Scope := NET_FW_SCOPE_ALL;
  app.IpVersion := NET_FW_IP_VERSION_ANY;
  app.Enabled :=true;
  profile.AuthorizedApplications.Add(app);
end;

//more things you can see at this Address: http://msdn2.microsoft.com/en-us/library/aa366415.aspx

NOTE: If you application doesn't initialize any activex objects you will also need to call CoInitialize(nil); before using the firewall functions and CoUninitialize; at the end.

How to detect a program that Not Responding? - Delphi

2008-12-31T18:39:00.000-08:00

function IsHung(theWindow: Hwnd; timeOut: LongInt): Boolean;
var
  dwResult: DWord;
begin
  Result:= SendMessageTimeOut(theWindow, WM_NULL, 0, 0 ,
    SMTO_ABORTIFHUNG or SMTO_BLOCK, timeOut, dwResult) <> 0;
end;

you can use FindWindow() function to get Handle of Window.
timOut is in Miliseconds.

Execute screensaver, then force execute your application at the same time

2008-12-31T18:31:00.000-08:00

function KillScreenSaverWndProc(hwndx: HWND; lParamx: LPARAM): boolean;
begin
   PostMessage(hwndx, WM_CLOSE, 0, 0);
   Result := true;
end;

:

var
   osversioninfo: TOSVersionInfo;
   hssWnd: HWND;
   hDeskWnd: HDESK;
begin
   osversioninfo.dwOSVersionInfoSize := sizeof(osversioninfo);

   GetVersionEx(osversioninfo);

   case osversioninfo.dwPlatformId of
       VER_PLATFORM_WIN32_WINDOWS:
       begin
           hssWnd := FindWindow('WindowsScreenSaverClass', nil);

           if hwwWnd <> 0 then
PostMessage(hsswnd, WM_CLOSE, 0, 0);
       end;

       VER_PLATFORM_WIN32_NT:
       begin
           hDeskWnd := OpenDesktop(
               'Screen-saver',
               0,
               false,
               DESKTOP_READOBJECTS or DESKTOP_WRITEOBJECTS
           );

           if hDeskWnd <> 0 then
           begin
               EnumDesktopWindows(hDeskWnd, TFNWndEnumProc(@KillScreenSaverWndProc), 0);
               CloseDesktop(hDeskWnd);
           end
       end;
   end;
end;

Send characters to another control (in any application)

2008-12-31T18:25:00.000-08:00

There are several methods to send keystrokes or characters to a WinControl. The SetKeyboardState requires the control to have the focus but can send more (esp. special) keys.
The use of WM_CHAR message enables you to send characters even to a hidden control unless you have found out the handle of it (there are a couple of ways to find out a controls handle).
Once you've got it, you can send messages to it.

I'm using this method for a little tool to "type" certain frequently used phrases while posting to newsgroups.

I hardcoded the handle of the edit control of my favorite newsreader and now I have a small and handy tool to type messages faster than ever.

// === code starts here ===

procedure SendMsg(const h: HWND; const s: string);
var
  i: integer;
begin
  if h = 0 then
    Exit;
  if Length(s) = 0 then
    Exit;
  for i:= 1 to Length(s) do
  begin
    if Ord(s[i]) in [9, 13, 32..254] then
      SendMessage(h, WM_CHAR, Ord(s[i]), 0);
  end;
end;

// === code ends here ===

How to find out if CAPS LOCK is on? b - Delphi

2008-12-31T18:21:00.000-08:00

function IsCapsLockOn : Boolean;
begin
Result := 0 <> (GetKeyState(VK_CAPITAL) and $01);
end;

Changing the screen resolution - Delphi

2008-12-31T18:17:00.000-08:00

To change the screen resolution you can use the following function
which is a wrapper for the Windows API ChangeDisplaySettings. The
function takes the desired width and height as parameters and returns
the return value of ChangeDisplaySettings (see the documentation for
more datails).

  function SetScreenResolution(Width, Height: integer): Longint;
  var
    DeviceMode: TDeviceMode;
  begin
    with DeviceMode do begin
      dmSize := SizeOf(TDeviceMode);
      dmPelsWidth := Width;
      dmPelsHeight := Height;
      dmFields := DM_PELSWIDTH or DM_PELSHEIGHT;
    end;
    Result := ChangeDisplaySettings(DeviceMode, CDS_UPDATEREGISTRY);
  end;

You can use ChangeDisplaySettings to change other properties of the
display like the color depth and the display frequency.

Sample call
-----------

In the following example first we get the current screen resolution
before setting it to 800x600, and then we restore it calling
SetScreenResolution again.

  var
    OldWidth, OldHeight: integer;

  procedure TForm1.Button1Click(Sender: TObject);
  begin
    OldWidth := GetSystemMetrics(SM_CXSCREEN);
    OldHeight := GetSystemMetrics(SM_CYSCREEN);
    SetScreenResolution(800, 600);
  end;

  procedure TForm1.Button2Click(Sender: TObject);
  begin
    SetScreenResolution(OldWidth, OldHeight);
  end;

Show Windows properties window - Delphi

2008-12-31T18:16:00.000-08:00

This function uses Shell API

The function:

function VisaEgenskaper(hWndOwner: HWND; const FileName: string): Boolean;
var Info: TShellExecuteInfo;
begin
  { Fill in the SHELLEXECUTEINFO structure }
  with Info do
  begin
    cbSize := SizeOf(Info);
    fMask := SEE_MASK_NOCLOSEPROCESS or
             SEE_MASK_INVOKEIDLIST or
             SEE_MASK_FLAG_NO_UI;
    wnd  := hWndOwner;
    lpVerb := 'properties';
    lpFile := pChar(FileName);
    lpParameters := nil;
    lpDirectory := nil;
    nShow := 0;
    hInstApp := 0;
    lpIDList := nil;
  end;

  { Call Windows to display the properties dialog. }
  Result := ShellExecuteEx(@Info);
end;

Call the function with this line:

VisaEgenskaper(Application.Handle, 'C:\Thomas.txt');

Accessing the Windows Registry - Delphi

2008-12-31T18:15:00.001-08:00

What is the Registry?
---------------------

It is where Windows stores many of its configuration options and also allows applications to access this data as well as save their own data. If you want to take a look at the registry, just execute the REGEDIT.EXE application located in the Windows directory. Be careful not to change anything or you could end up ruining your installation! Now, the data in the registry is stored in a tree structure. There are many roots (many trees):

  HKEY_CLASSES_ROOT
  HKEY_CURRENT_USER
  HKEY_LOCAL_MACHINE
  HKEY_USERS
  HKEY_PERFORMANCE_DATA
  HKEY_CURRENT_CONFIG
  HKEY_DYN_DATA

Each root can have values and keys. The values are data stored under item names (right panel of RegEdit). Keys can have values and other keys, forming a tree structure (left panel of RegEdit).

For example, the tree HKEY_CURRENT_USER has many keys, like AppEvents, Control Panel, Identities, Network, Software, etc. Each key may have sub-keys. For example, Control Panel has some sub-keys, like Accessibility, Appearance, Colors, Cursors, Desktop, International, etc. All keys have at least one value (the first value in the right panel of RegEdit), which is the default value (the name of the value is the empty string), not necessarily set. A key may have more values. For example, let's see the key Control Panel\Colors under HKEY_CURRENT_USER. Appart from the default value, it has values like ActiveBorder, ActiveTitle, AppWorkspace, Background, etc. In turn, each "value" has a "data" (the actual value, sort to speak). For example, the data of the value ActiveTitle would be "0 0 128" (may be different if you are not using the standard Windows colors).

TRegistry
---------

Before getting into GetRegistryData and SetRegistryData, let's see how we would accomplish the same tasks the hard way, using TRegistry.

The TRegistry class is declared in the Registry unit, so you will have to add this unit to the Uses clause of the unit or program where you want to use it. To access a value in the registry, first you should create an object of this class, assign the root to its RootKey property (the values are defined in the Windows unit) and then try to open a key with the OpenKey function method, which will return True if successful. Then you can read (with the ReadXxxx functions) or write (with the WriteXxxx procedures) the values of the open key and, after that, you should close the key with CloseKey. When you are done with the registry, you should free the registry object you created. Let's see an example of how to obtain the name of the processor in our computer:

  procedure TForm1.Button1Click(Sender: TObject);
  var
    Reg: TRegistry;
  begin
    Reg := TRegistry.Create;
    Reg.RootKey := HKEY_LOCAL_MACHINE;
    if Reg.OpenKey('\Hardware\Description\System'
        + '\CentralProcessor\0', False) then begin
      ShowMessage(Reg.ReadString('Identifier'));
      Reg.CloseKey;
    end; // if
    Reg.Free;
  end;

You can see another example in the article Determining the associated application. Of course, there are many more things you can do with the registry, like creating and deleting keys and values...

The TRegistryIniFile class makes it simpler for applications to write and read their configuration information to and from the registry, while TRegistry operates at a lower level.

GetRegistryData
---------------

To simplify reading a data value from the registry you can use the following function that can read any data type from the registry and returns it as a variant (string or integer). The function performs exception handling.

  uses Registry;

  function GetRegistryData(RootKey: HKEY; Key,
                           Value: string): variant;
  var
    Reg: TRegistry;
    RegDataType: TRegDataType;
    DataSize, Len: integer;
    s: string;
  label cantread;
  begin
    Reg := nil;
    try
      Reg := TRegistry.Create(KEY_QUERY_VALUE);
      Reg.RootKey := RootKey;
      if Reg.OpenKeyReadOnly(Key) then begin
        try
          RegDataType := Reg.GetDataType(Value);
          if (RegDataType = rdString) or
             (RegDataType = rdExpandString) then
            Result := Reg.ReadString(Value)
          else if RegDataType = rdInteger then
            Result := Reg.ReadInteger(Value)
          else if RegDataType = rdBinary then begin
            DataSize := Reg.GetDataSize(Value);
            if DataSize = -1 then
              raise Exception.Create(SysErrorMessage(ERROR_CANTREAD));
            SetLength(s, DataSize);
            Len := Reg.ReadBinaryData(Value, PChar(s)^, DataSize);
            if Len <> DataSize then
              raise Exception.Create(SysErrorMessage(ERROR_CANTREAD));
            Result := s;
          end else
            raise Exception.Create(SysErrorMessage(ERROR_CANTREAD));
        except
          s := ''; // Deallocates memory if allocated
          Reg.CloseKey;
          raise;
        end;
        Reg.CloseKey;
      end else
        raise Exception.Create(SysErrorMessage(GetLastError));
    except
      Reg.Free;
      raise;
    end;
    Reg.Free;
  end;

Sample Call:

  ShowMessage(GetRegistryData(HKEY_LOCAL_MACHINE,
    '\Hardware\Description\System\CentralProcessor\0', 'Identifier'));

SetRegistryData
---------------

To simplify writing a data value to the registry you can use the following procedure that can write any data type to the registry. The procedure performs exception handling.

  uses Registry;

  procedure SetRegistryData(RootKey: HKEY; Key, Value: string;
    RegDataType: TRegDataType; Data: variant);
  var
    Reg: TRegistry;
    s: string;
  begin
    Reg := nil;
    try
      Reg := TRegistry.Create(KEY_WRITE);
      Reg.RootKey := RootKey;
      if Reg.OpenKey(Key, True) then begin
        try
          if RegDataType = rdUnknown then
            RegDataType := Reg.GetDataType(Value);
          if RegDataType = rdString then
            Reg.WriteString(Value, Data)
          else if RegDataType = rdExpandString then
            Reg.WriteExpandString(Value, Data)
          else if RegDataType = rdInteger then
            Reg.WriteInteger(Value, Data)
          else if RegDataType = rdBinary then begin
            s := Data;
            Reg.WriteBinaryData(Value, PChar(s)^, Length(s));
          end else
            raise Exception.Create(SysErrorMessage(ERROR_CANTWRITE));
        except
          Reg.CloseKey;
          raise;
        end;
        Reg.CloseKey;
      end else
        raise Exception.Create(SysErrorMessage(GetLastError));
    except
      Reg.Free;
      raise;
    end;
    Reg.Free;
  end;

Sample Call:

  SetRegistryData(HKEY_LOCAL_MACHINE,
    '\Software\Microsoft\Windows\CurrentVersion',
    'RegisteredOrganization', rdString, 'Latium Software');

logged in as administator - Delphi

2008-12-31T18:14:00.000-08:00

const
  SECURITY_NT_AUTHORITY: TSIDIdentifierAuthority =
    (Value: (0, 0, 0, 0, 0, 5));
  SECURITY_BUILTIN_DOMAIN_RID = $00000020;
  DOMAIN_ALIAS_RID_ADMINS     = $00000220;

function IsAdmin: Boolean;
var
  hAccessToken: THandle;
  ptgGroups: PTokenGroups;
  dwInfoBufferSize: DWORD;
  psidAdministrators: PSID;
  x: Integer;
  bSuccess: BOOL;
begin
  Result := False;
  bSuccess := OpenThreadToken(GetCurrentThread, TOKEN_QUERY, True,
    hAccessToken);
  if not bSuccess then
  begin
    if GetLastError = ERROR_NO_TOKEN then
    bSuccess := OpenProcessToken(GetCurrentProcess, TOKEN_QUERY,
      hAccessToken);
  end;
  if bSuccess then
  begin
    GetMem(ptgGroups, 1024);
    bSuccess := GetTokenInformation(hAccessToken, TokenGroups,
      ptgGroups, 1024, dwInfoBufferSize);
    CloseHandle(hAccessToken);
    if bSuccess then
    begin
      AllocateAndInitializeSid(SECURITY_NT_AUTHORITY, 2,
        SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS,
        0, 0, 0, 0, 0, 0, psidAdministrators);
      {$R-}
      for x := 0 to ptgGroups.GroupCount - 1 do
        if EqualSid(psidAdministrators, ptgGroups.Groups[x].Sid) then
        begin
          Result := True;
          Break;
        end;
      {$R+}
      FreeSid(psidAdministrators);
    end;
    FreeMem(ptgGroups);
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  if isAdmin then
  begin
    ShowMessage('Logged in as Administrator');
  end;
end;

How to set the current screensaver - Delphi

2008-12-31T18:13:00.000-08:00

The following code sets up your desired screensave then shows it. For actual use this code needs to be changed to suite your needs i.e. remove ShowMessage dialogs, change name of screensaver, change timeout value and remove actual testing section.

Tested under Windows XP but should work with earlier versions of Windows

program SetupDefaultScrnSaver;

uses
  Windows, SysUtils, Forms, Dialogs, Registry;

const
  { from Windows.pas }
  SPI_SETSCREENSAVEACTIVE = 17;
  SPIF_SENDWININICHANGE = 2;
  SPI_SETSCREENSAVETIMEOUT = 15;
  { from Messages.pas }
  WM_SYSCOMMAND       = $0112;

  { From Project JEDI JCL library
    http://www.delphi-jedi.org/Jedi:CODELIBJCL:22798 }
  function GetWindowsSysFolder: string;
    procedure StrResetLength(var S: AnsiString);
    begin
      SetLength(S, StrLen(PChar(S)));
    end;
  var
    Required: Cardinal;
  begin
    Result := '';
    Required := GetSystemDirectory(nil, 0);
    if Required <> 0 then
    begin
      SetLength(Result, Required);
      GetSystemDirectory(PChar(Result), Required);
      StrResetLength(Result) ;
    end;
  end;

  function SetScreenSave(const Name: string; Const TimeOut: Integer = 30):Boolean;
  const
    SixtySeconds = 60 ;
  var
    Reg:TRegistry ;
  begin
    if not FileExists(Name) then
    begin
      ShowMessage('ScreenSaver "' + Name + '" not located') ;
      exit ;
    end ;

    Reg := TRegistry.Create ;
    Reg.RootKey := HKEY_CURRENT_USER ;
    try
      with Reg do
      begin
        if OpenKey('Control Panel\Desktop',False) then
        begin
          WriteString('SCRNSAVE.EXE', Name) ;
          WriteString('ScreenSaverIsSecure','1') ;
          CloseKey ;
        end else
        begin
          Result := False ;
          exit ;
        end ;
      end ;
    finally
      Reg.Free ;
    end ;

    SystemParametersInfo(SPI_SETSCREENSAVEACTIVE,1,nil,SPIF_SENDWININICHANGE);
    SystemParametersInfo(SPI_SETSCREENSAVETIMEOUT,SixtySeconds * TimeOut,
      nil,SPIF_SENDWININICHANGE);
    Result := True ;
  end;

begin
  { -=CHANGE THE SCREENSAVER NAME TO ONE YOU WANT THE USER TO HAVE=- }
  if SetScreenSave(GetWindowsSysFolder + '\ss3dfo.scr') then  begin
    ShowMessage('Screensaver set, press OK to test (remember grace period)') ;
    PostMessage(GetDesktopWindow, WM_SYSCOMMAND, SC_SCREENSAVE, 0);
  end ;
end.

Making an application run automatically when Windows starts

2008-12-31T18:12:00.000-08:00

One way is placing a direct access to the application in the Startup folder of Windows Start Menu. Alternatively, you can add a value under the appropriate key in the Windows Registry, as shown below:

  procedure TForm1.Button1Click(Sender: TObject);
  begin
    SetRegistryData(HKEY_LOCAL_MACHINE,
      'Software\Microsoft\Windows\CurrentVersion\Run',
      Application.Title, rdString, Application.ExeName);
  end;

NOTE: SetRegistryData has been featured in the article "Accessing the       Windows Registry": http://www.delphi3000.com/articles/article_1575.asp

Instead of Application.Title you can write a string with a unique name for the application, and instead of Application.ExeName you can write the full path name of the application (as well as its command-line parameters if they are needed)

Hiding caption bars - Delphi

2008-12-31T18:05:00.002-08:00

//--------------------------------------------------------------------------- 
// Author   : Digital Survivor [Esteban Rodríguez Nieto | José Plano] 
// Email    : plmad666@gmail.com | jose.plano@gmail.com 
// Web site : www.ds-studioscom.ar 
//--------------------------------------------------------------------------- 

We can use this example in the onCreate event: 

Procedure TForm1.FormCreate (Sender : TObject); 

Begin 

     SetWindowLong (Handle, GWL_STYLE, GetWindowLong (Handle, GWL_STYLE) AND NOT WS_CAPTION); 
     ClientHeight := Height; 

End; 

//--------------------------------------------------------------------------- 

Detecting CPU type - Delphi

2008-12-31T18:05:00.001-08:00

//---------------------------------------------------------------------------
// Author   : Digital Survivor [Esteban Rodríguez Nieto | José Plano]
// Email    : plmad666@gmail.com | jose.plano@gmail.com
// Web site : www.ds-studios.com.ar
//---------------------------------------------------------------------------

{ Note: This code seems not to work in all machines. It's seems also not to work with all kinds of CPUs, but try it. It works for me... }

Unit CPUid;

Interface

Type

    TCpuType = (cpu8086, cpu286, cpu386, cpu486, cpuPentium);

Function CpuType : TCpuType;
Function CpuTypeString : String;

Implementation

Uses

    SysUtils;

Function CpuType : TCpuType; ASSEMBLER;

Asm

   // 8086 CPU check

   push ds
   pushf
   pop bx
   mov ax, 0fffh
   and ax, bx
   push ax
   popf
   pushf
   pop ax
   and ax, 0f000h
   cmp ax, 0f000h
   mov ax, cpu8086
   je @@End_CpuType

   // 80286 CPU check

   or bx, 0f000h
   push bx
   popf
   pushf
   pop ax
   and ax, 0f000h
   mov ax, cpu286
   jz @@End_CpuType

   // 386 CPU check

   db 66h
   pushf
   db 66h
   pop ax
   db 66h
   mov cx, ax
   db 66h
   xor ax, 0h
   dw 0004h
   db 66h
   push ax
   db 66h
   popf
   db 66h
   pushf
   db 66h
   pop ax
   db 66h
   xor ax, cx
   mov ax, cpu386
   je @@End_CpuType

   // 486 CPU check

   db 66h
   pushf
   db 66h
   pop ax
   db 66h
   mov cx, ax
   db 66h
   xor ax, 0h
   dw 0020h
   db 66h
   push ax
   db 66h
   popf
   db 66h
   pushf
   db 66h
   pop ax
   db 66h
   xor ax, cx
   mov ax, cpu486
   je @@End_CpuType

   // Pentium CPU check

   db 66h
   mov ax, 1
   dw 0
   db 66h
   db 0Fh
   db 0a2h
   db 66h
   and ax, 0F00H
   dw 0
   db 66h
   shr ax, 8
   sub ax, 1

   @@End_CpuType:

   pop ds

End;

Function CpuTypeString : String;

Var

  Kind : TCpuType;

Begin

     Kind := CpuType;

     Case Kind Of

          cpu8086 : Result := '8086';
          cpu286 : Result := '286';
          cpu386 : Result := '386';
          cpu486 : Result := '486';
          cpuPentium : Result := 'Pentium';

          Else Result := Format ('P%d', [Ord (kind)]);

     End;

End;

End.

Changing hard drive's icon under Windows XP - Delphi

2008-12-31T18:04:00.001-08:00

This article shows that how can changing a driver icon in MyComputer under
  WinXP. This modification is so different than Win9x and not easy.
  As you know that you have so many articles that just change some settings
  in the registry in D3K database, but the following registry codes are
  undocumanted and you don't see it normally in XP Registry.
  if you can want to change your hard driver icon then insert the following
  code into Button1's OnClick event. I hope this be usefull for someone.

  add Registry in USES clause

  procedure TForm1.Button1Click(Sender: TObject);
  var Reg: TRegistry;
  begin
     Reg := TRegistry.Create;
     try
        with Reg do
        begin
          RootKey := HKEY_LOCAL_MACHINE;
          OpenKey
  ('Software\Microsoft\Windows\CurrentVersion\Explorer\DriveIcons\', True);
  { True, because if a subkey named DriveIcons and/or DefaultIcon
    does not exist, windows automatically creates it }

          OpenKey('C\DefaultIcon\', True); // as default first drive C
          // we are choosing empty field as default value
          WriteString('', 'C:\YourIcons\Sample1.ico');
          { and icon file path  or if dll file then
            e.g  'c:\YourIcons\Icons.dll, 2' }
          CloseKey;
        end;
     finally
         Reg.Free;
     end;

     // if 2nd hard drive is present..

     Reg := TRegistry.Create;
     try
        with Reg do
        begin
          RootKey := HKEY_LOCAL_MACHINE;
          OpenKey
  ('Software\Microsoft\Windows\CurrentVersion\Explorer\DriveIcons\', True);
          OpenKey('D\DefaultIcon\', True);
          WriteString('', 'C:\YourIcons\Sample2.ico');
          CloseKey;
        end;
     finally
        Reg.Free;
     end;
  end;

  in the same way, you can write these techniques for another drivers.
  Now, hard drive's icon have been changed. Press F5 on the keyboard
  or reboot for the changes to take effect.

Changing attributes of files - Delphi

2008-12-31T18:03:00.000-08:00

To read a file's attributes, pass the filename to the FileGetAttr function, which returns the file attributes of a file.For example, add a TButton  and TLabel components to the form and write the following code to the OnClick event of button.

var
attr:Integer;
s:string;
begin
attr:=FileGetAttr('c:\Autoexec.bat');
if(attr and faHidden)<>0 then s:='Hidden';
if(attr and faReadOnly)<>0 then s:=s+'Read-Only';
if(attr and faSysFile)<>0 then s:=s+'System';
if(attr and faArchive)<>0 then s:=s+'Archive';
Label1.Caption:=s;
---------------------------
To set a file's attributes, pass the name of the file and the attributes you want to the FileSetAttr function.Each attribute has a mnemonic name defined in the SysUtils unit. For example, to set a file's system attribute, you would do the following:

Attributes := Attributes or faSystem;

You can also set or clear several attributes at once. For example, the clear both the read-only file and hidden attributes:

Attributes := Attributes and not (faReadOnly or faHidden);
---------------------------
Furthermore,To change file's attribute, you can use the following return values.The routine can be simplified.

     +----------------------------------+
     | Return Value | Attribute of File |
     +----------------------------------+
     |   128        |   Normal          |
     |   1          |   Read Only       |
     |   2          |   Hidden          |
     |   4          |   System          |
     |   32         |   Archive         |
     +--------------+-------------------+
Sample call: We use a code like the following:

FileSetAttr('C:\Autoexec.bat',2);{Hidden}
FileSetAttr('C:\Autoexec.bat',3);{Hidden and Read-Only.
                                   FileGetAttr returns 3 value}

Get the next day of the month

2008-12-31T18:02:00.000-08:00

NOTE: You need do add the unit "DateUtils" to the uses clause (where DayOfTheWeek is declared).

//----------------------------------------------------------------
type
  TWeeks    = (wFirst, wSecond, wThird, wFourth, wLast);
  TWeekDays = (wdMonday, wdTuesday, wdWednesday, wdThursday,
               wdFriday, wdSaturday, wdSunday);

//Examples:
//ShowMessage(DateTimeToStr(GetDayOfMonth(Now, wLast, wdTuesday)));
//ShowMessage(DateTimeToStr(GetDayOfMonth(Now, wFirst, wdSunday)));

function DaysPerMonth(AYear, AMonth: Integer): Integer;
const
  DaysInMonth: array[1..12] of Integer =
    (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
begin
  Result := DaysInMonth[AMonth];
  if (AMonth = 2) and IsLeapYear(AYear) then Inc(Result); { leap-year Feb is special }
end;

function GetDayOfMonth(DT: TDateTime; Weeks: TWeeks; WeekDays: TWeekDays): TDateTime;
var
  aDateTime: TDateTime;
  aDayOfWeek, bDayOfWeek: Word;
  AYear, AMonth, ADay: Word;
begin
  DecodeDate(DT, AYear, AMonth, ADay);
  aDateTime := EncodeDate(AYear, AMonth, 1); //Returns the 1st day of the month
  //-DayOfTheWeek-
  //1 - Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, 7 - Sunday
  aDayOfWeek := DayOfTheWeek(aDateTime);
  //-WeekDays-
  //0 - Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, 6 - Sunday
  bDayOfWeek := Ord(WeekDays) +1;

  if aDayOfWeek <= bDayOfWeek //The day we want is still yet to come
    then ADay := (bDayOfWeek - aDayOfWeek)
    else ADay := 7 - (aDayOfWeek - bDayOfWeek);

  //-Weeks-
  //0 - first, 1 - second, 2 - third, 3 - fourth, 4 - last
  ADay := ADay + Ord(Weeks) * 7;
   if Ord(Weeks) = 4 then
    if (ADay+1 > DaysPerMonth(AYear, AMonth))
    or ( (ADay+1 <= DaysPerMonth(AYear, AMonth))
    and (bDayOfWeek <> DayOfTheWeek(EncodeDate(AYear, AMonth, ADay+1))) )
      then ADay := ADay - 7;
   Result := aDateTime + ADay;
end;
//----------------------------------------------------------------

I'm sure there are better ways to deal with this problem so please let me know if you happen to know any.

Make A System-Wide Shorcut Key !! - Delphi

2008-12-31T18:00:00.001-08:00

Try This Code...........

type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  protected
    procedure hotykey(var msg:TMessage); message WM_HOTKEY;
  end;

var
  Form1: TForm1;
  id,id2:Integer;

implementation

{$R *.DFM}

procedure TForm1.hotykey(var msg:TMessage);
begin
  if (msg.LParamLo=MOD_CONTROL) and (msg.LParamHi=81) then
  begin
    ShowMessage('Ctrl + Q wurde gedrückt !');
  end;

  if (msg.LParamLo=MOD_CONTROL) and (msg.LParamHi=82) then
  begin
    ShowMessage('Ctrl + R wurde gedrückt !');
  end;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  id:=GlobalAddAtom('hotkey');
  RegisterHotKey(handle,id,mod_control,81);

  id2:=GlobalAddAtom('hotkey2');
  RegisterHotKey(handle,id2,mod_control,82);
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  UnRegisterHotKey(handle,id);
  UnRegisterHotKey(handle,id2);
end;

Preventing the user from closing a form - Delphi

2008-12-31T17:56:00.002-08:00

To prevent the user from closing a form you need to disable the close
button in the title bar of a form and at the same time disable the
"Close" menu item in the form's system menu. This is done by calling
the EnableMenuItem API function (see the example below). Nonetheless,
the user can still close the form using the Alt+F4 key combination,
so we have to set the KeyPreview form property to True and write an
event handler for the OnKeyDown event to cancel out this hot key:

  procedure TForm1.FormCreate(Sender: TObject);
  var
    hSysMenu: HMENU;
  begin
    hSysMenu := GetSystemMenu(Self.Handle, False);
    if hSysMenu <> 0 then begin
      EnableMenuItem(hSysMenu, SC_CLOSE,
        MF_BYCOMMAND Or MF_GRAYED);
      DrawMenuBar(Self.Handle);
    end;
    KeyPreview := True;
  end;

  procedure TForm1.FormKeyDown(Sender: TObject;
    var Key: Word; Shift: TShiftState);
  begin
    if (Key = VK_F4) and (ssAlt in Shift) then
      Key := 0;
  end;

Display forms full screen

2008-12-31T17:56:00.001-08:00

Covering the entire screen with a form is relatively easy to accomplish as shown below.
Component Download: ../article/2863/KG_FullScreen.zip
procedure TfrmMainForm.FormCreate(Sender: TObject);
begin
  { Position form }
  Top := 0 ;
  Left := 0 ;

  { Go full screen }
  WindowState  := wsmaximized;
  ClientWidth  := Screen.Width ;
  ClientHeight := Screen.Height;
  Refresh;
end;

If this is a typical form it will have borders which you might consider removing by setting BorderStyle property to bsNone as shown below.

procedure TfrmMainForm.FormCreate(Sender: TObject);
begin
  { Position form }
  Top := 0 ;
  Left := 0 ;

  { Go full screen }
  BorderStyle := bsNone ;
  WindowState  := wsmaximized;
  ClientWidth  := Screen.Width ;
  ClientHeight := Screen.Height;
  Refresh;
end;

Sometimes the code shown above will go full screen but still display the Windows TaskBar, if this happens we can force the form on top using either SetForeGroundWindow or SetActiveWindow. From my testing it is best to use both if the problem persist.

procedure TfrmMainForm.FormCreate(Sender: TObject);
begin
  { Position form }
  Top := 0 ;
  Left := 0 ;

  { Go full screen }
  BorderStyle := bsNone ;
  WindowState  := wsmaximized;
  ClientWidth  := Screen.Width ;
  ClientHeight := Screen.Height;
  Refresh;
  SetForegroundWindow(Handle) ;
  SetActiveWindow(Application.Handle) ;
end;

Other  considerations (see attachment for code to address these items)
If the form is already in maximized window state the above code will not work.
Controlling the system menu commands as per above needs to be considered
Ghost items in the TaskBar after terminating your application.

Delphi makes it simple to cover the display screen but what if you need to duplicate the functionality in another programming language such as Microsoft Visual Basic? Well in this case you might want to learn the API methods (again see attachment).

Rotate an image by 90º

2008-12-31T17:54:00.002-08:00

You have to create two images first. I'm sure anyone could convert this code to use just on image by using a TBitmap.

Procedure TurnImage(Src, Dst: TImage);
var x,y: integer;
begin
  Dst.Width:= Src.Height; Dst.Height:= Src.Width;
  For x:= 0 to Src.Width-1 do begin
    For y:= 0 to Src.Height-1 do begin
      Dst.Canvas.Pixels[(Src.Height-1)-y,x]:= Src.Canvas.Pixels[x,y];
    end;
  end;
end;

Inserting a .bmp file into your .exe

2008-12-31T17:54:00.001-08:00

This is helpful if you do not want to have a bitmap file in the directory of the program you distribute.  

One problem with inserting a bitmap file into your .exe is that it makes your programs .exe larger, so it is a good idea if your 
program uses small bitmap files.  
The Delphi example below will work on any version of Delphi above Delphi 2.  

First open an editor like Notepad.exe, for this example we will use a bitmap file called Picture.bmp  
and this is the bitmap file we will insert into our programs .exe  
(Make sure that there is a picture in your folder/directory named Picture.bmp.  
If you do not have a picture already called Picture.bmp you can rename a different bitmap file so that it is called Picture.bmp) 

Type these words into the text file:  

ThePicture Bitmap "Picture.bmp"  

Then save the text file as:  

mybmp.rc  

We will use BRCC32.exe that comes with Delphi and it should be in Delphi's Bin directory, to compile the file.  
In order to use BRCC32.exe you have to use a DOS window, using DOS is not hard at all.  
To run a DOS window, go to your TaskBar, click Start|Programs|MS-DOS Prompt  
Whenever you use DOS all you have to do to get back to Windows (Your desktop) is type the word Exit, then press the Enter 
key.  

You should have your bitmap files and your .rc file in the same folder/directory.  

So we will type this sentence in the DOS window:  
C:\Delphi 3\Bin\Brcc32.exe C:\Delphi 3\bin\bmps\MyBmp.rc  
The above paths may have to be changed to the place where you have Delphi installed and to the folder/directory where you 
have saved your files for this example.  

If this does not work or you get an error, you may not have Delphi in your computers path.  
A way around this is for you to copy the BRCC32.exe and RW32CORE.DLL into your folder/directory that you are using, 
then try again.  
(The above files, BRCC32.exe and RW32CORE.DLL, may be different for different versions of  Delphi)  

Use Explorer or another File Manager and have a look in your directory, you should find that you have an extra file called 
mybmp.RES.  

Start Delphi, then start a new project (Application).  

Look for {$R *.DFM} in Unit1 and add {$R MYBMP.RES} next to it.  

Add a TImage component to your form and make its AutoSize property True.  
Next drop a Button onto your Form, double-click on the Button and add this code:  

Image1.Picture.Bitmap.LoadFromResourceName(hInstance, 'ThePicture');  

Note we use 'ThePicture' to call the bitmap file.  
Run the program and then click on the Button, you should see the image that you put into the resource file.  
If you have to save the project before you can run it, save in in the same folder/directory where you have the resource (*.RES) 
file.  

Your complete unit should look like this:  

unit Unit1;  

interface  

uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,  
  StdCtrls, ExtCtrls;  

type  
  TForm1 = class(TForm)  
    Button1: TButton;  
    Image1: TImage;  
    procedure Button1Click(Sender: TObject);  
  private  
    { Private declarations }  
  public  
    { Public declarations }  
  end;  

var  
  Form1: TForm1;  

implementation  

{$R *.DFM} {$R MYBMP.RES}  

procedure TForm1.Button1Click(Sender: TObject);  
begin  
  Image1.Picture.Bitmap.LoadFromResourceName(hInstance, 'THEPICTURE');  
end;  

end. 

Screencapture with animated gif support!

2008-12-31T17:52:00.000-08:00

In may last year i promised to create a component which could
take screenshots and save them in a gif image, and here it
FINALLY is. :)

This component can be used in ANY kind of application, royalty
free with only 1 demand: credits!

==============================================================

Description:

This component can create screenshots of the screen (or
portions of the screen).

You can set a region of what you want to "photograph" by
calling the function

=> TtspScreenCapture.SetRegion(ARegion: TCaptureRegion)

After setting the region you must specify a capture mode.
there are 4 capturemodes:

- cmStillBitmap
- cmStillJPEG
- cmStillGIF
- cmMotionGIF

Now you can take a still image by calling the function

=> TtspScreenCapture.GetStillImage: TCaptureResult;

According to the chosen capture mode you can access the
screenshot in the proper TGraphic object:

=>   TCaptureResult = record
VBitmap: TBitmap;
     VJPEG: TJPEGImage;
     VGIFImage: TGIFImage;
      end;

With these objects you can save the images to wherever you want
them.

Motion gifs require a little different approach.

First you must set the capture mode to cmMotionGIF.
Accordingly you must set the interval in which a screenshot
should be taken by setting the property

=> TtspScreenCapture.MotionGifInterval: integer

This property is in milliseconds. (1 second = 1000 millisecond)

Everything is now ready for capturing.

To activate the capturing set the property

=> TtspScreenCapture.Active: boolean;

to true.

while capturing you can read the current GIFImage by calling the
function

=> TtspScreenCapture.GetMotionGif: TGIFImage;

To stop capturing set the Active property back to false.

The final Gif image is again accesible by calling the function
GetMotionGIF.

======================================================================

Benchmark:

The component also contains a function benchmark. this is a very simple
function which calculates how much frames can be captured in 10 seconds.

the result value is in captured frames per second (rounded).

=======================================================================

well, this wraps it up for now.

Good luck with using this component in your application!

Nevertheless i have 1 more thing to tell you:

1. DON'T forget to credit me in your application. You got this for free
   so it would be quite fair to do this simple thing.

========================================================================

Have fun,

Christiaan ten Klooster
webmaster@tsp2000.tmfweb.nl
www.tsp2000.tmfweb.nl

check, if a directory is empty - Delphi

2008-12-31T17:51:00.000-08:00

// Diese Funktion gibt true zurück, falls Directory ein leeres Verzeichnis ist.
// This function returns true if Directory is an empty directory.

function DirectoryIsEmpty(Directory: string): Boolean;
var
  SR: TSearchRec;
  i: Integer;
begin
  Result := False;
  FindFirst(IncludeTrailingPathDelimiter(Directory) + '*', faAnyFile, SR);
  for i := 1 to 2 do
    if (SR.Name = '.') or (SR.Name = '..') then
      Result := FindNext(SR) <> 0;
  FindClose(SR);
end;

// Beispiel:
// Example:

procedure TForm1.Button1Click(Sender: TObject);
begin
  if DirectoryIsEmpty('C:\test') then
    Label1.Caption := 'empty'
  else
    Label1.Caption := 'not empty';
end;

Show Windows properties window - Delphi

2008-12-31T05:18:00.001-08:00

This function uses Shell API

The function:

function VisaEgenskaper(hWndOwner: HWND; const FileName: string): Boolean;
var Info: TShellExecuteInfo;
begin
{ Fill in the SHELLEXECUTEINFO structure }
with Info do
begin
cbSize := SizeOf(Info);
fMask := SEE_MASK_NOCLOSEPROCESS or
SEE_MASK_INVOKEIDLIST or
SEE_MASK_FLAG_NO_UI;
wnd := hWndOwner;
lpVerb := 'properties';
lpFile := pChar(FileName);
lpParameters := nil;
lpDirectory := nil;
nShow := 0;
hInstApp := 0;
lpIDList := nil;
end;

{ Call Windows to display the properties dialog. }
Result := ShellExecuteEx(@Info);
end;

Call the function with this line:

VisaEgenskaper(Application.Handle, 'C:\Thomas.txt');

Send a file to windows recycle bin - Delphi

2008-12-31T05:17:00.001-08:00

Don't forget to add ShellAPI in your uses-group.

This is the function that does all the work:

function RecycleFile(sFileName: string): Boolean;
var
FOS: TSHFileOpStruct;
begin
FillChar(FOS, SizeOf(FOS), 0);
with FOS do
begin
wFunc := FO_DELETE; { Functions as FO_COPY also works.
pFrom := PChar(sFileName + #0);
pTo := { Only for FO_COPY }
fFlags := FOF_ALLOWUNDO; { Since we wan't to send the file the file to recycle bin }
end;
// Send the file
Result := (SHFileOperation(FOS) = 0);
end;

Call the function by using this line:
RecycleFile('E:\Test.exe');

Searching for a directory

2008-12-31T05:14:00.000-08:00

Getting the icon of an application, library or document

2008-12-31T05:13:00.000-08:00

ExtractAssociatedIcon
---------------------

To get the icon of an application or document we can use this API
function (declared in the ShellAPI unit):

  function ExtractAssociatedIcon(hInst: HINST; lpIconPath: PChar;
                                 var lpiIcon: Word): HICON; stdcall;

* hInst: The application handle. This value is contained in the
  predefined variable HInstance.

* lpIconPath: A pointer to a character buffer that should contain a
  null terminated string with the full path name of the application,
  library (DLL) or document. If it is a document, the function will
  place there the full pathname of the associated application from
  where the icon was extracted, so we should allocate a buffer large
  enough.

* lpiIcon: The icon index (the first icon in the file has an index of
  0). If lpIconPath specifies a document, then lpiIcon is set by the
  function (that's why it is passed by reference) to the index
  position of the actual icon taken from the associated executable
  (defined in the file association).

Return value:
If the function fails, it returns 0. If it succeeds, it returns an
icon handle, which is an integer value Windows uses to identify the
allocated resource. It is not necessary to call the API DestroyIcon
to release the icon since it'll be deallocated automatically when the
application finishes, although you can do it if you want.

Sample call
-----------
Now, what do we do with the icon handle? Normally what we want is an
icon, namely and instance of the TIcon class. All we have to do is
create a TIcon object and assign this handle to its Handle property.
If later we assign the Handle property to another value, the previous
icon will be automatically be released. The same happens if the TIcon
object is freed. Here is an example that changes the icon of the form:

  procedure TForm1.Button1Click(Sender: TObject);
  var
    IconIndex: word;
    Buffer: array[0..2048] of char;
    IconHandle: HIcon;
  begin
    StrCopy(@Buffer, 'C:\Windows\Help\Windows.hlp');
    IconIndex := 0;
    IconHandle := ExtractAssociatedIcon(HInstance, Buffer, IconIndex);
    if IconHandle <> 0 then
      Icon.Handle := IconHandle;
  end;


GetAssociatedIcon
-----------------

Unfortunately, ExtractAssociatedIcon fails if the file does not exists
on disk, so we defined a procedure that gets the icon of a file
whether it exists or not, and can also get the small icon (ideal for
a TListView that can be shown in vsIcon or vsReport view styles). The
procedure receives three parameters: the filename and two pointers to
HICON (integer) variables: one for the large icon (32x32) and another
one for the small icon (16x16). Any of them can be nil if you don't
need one of these icons. The icons "returned" by the procedure must be
freed with the DestroyIcon API. This will be done automatically if you
assign the icon handle (HICON) to the Handle property of a TIcon object
(the icon will be released when this object gets freed or a new value
is assigned to it).

  uses
    Registry, ShellAPI;

  type
    PHICON = ^HICON;

  procedure GetAssociatedIcon(FileName: TFilename;
      PLargeIcon, PSmallIcon: PHICON);
  // Gets the icons of a given file
  var
    IconIndex: word;  // Position of the icon in the file
    FileExt, FileType: string;
    Reg: TRegistry;
    p: integer;
    p1, p2: pchar;
  label
    noassoc;
  begin
    IconIndex := 0;
    // Get the extension of the file
    FileExt := UpperCase(ExtractFileExt(FileName));
    if ((FileExt <> '.EXE') and (FileExt <> '.ICO')) or
        not FileExists(FileName) then begin
      // If the file is an EXE or ICO and it exists, then
      // we will extract the icon from this file. Otherwise
      // here we will try to find the associated icon in the
      // Windows Registry...
      Reg := nil;
      try
        Reg := TRegistry.Create(KEY_QUERY_VALUE);
        Reg.RootKey := HKEY_CLASSES_ROOT;
        if FileExt = '.EXE' then FileExt := '.COM';
        if Reg.OpenKeyReadOnly(FileExt) then
          try
            FileType := Reg.ReadString('');
          finally
            Reg.CloseKey;
          end;
        if (FileType <> '') and Reg.OpenKeyReadOnly(
            FileType + '\DefaultIcon') then
          try
            FileName := Reg.ReadString('');
          finally
            Reg.CloseKey;
          end;
      finally
        Reg.Free;
      end;

      // If we couldn't find the association, we will
      // try to get the default icons
      if FileName = '' then goto noassoc;

      // Get the filename and icon index from the
      // association (of form '"filaname",index')
      p1 := PChar(FileName);
      p2 := StrRScan(p1, ',');
      if p2 <> nil then begin
        p := p2 - p1 + 1; // Position of the comma
        IconIndex := StrToInt(Copy(FileName, p + 1,
          Length(FileName) - p));
        SetLength(FileName, p - 1);
      end;
    end;
    // Attempt to get the icon
    if ExtractIconEx(pchar(FileName), IconIndex,
        PLargeIcon^, PSmallIcon^, 1) <> 1 then
    begin
  noassoc:
      // The operation failed or the file had no associated
      // icon. Try to get the default icons from SHELL32.DLL

      try // to get the location of SHELL32.DLL
        FileName := IncludeTrailingBackslash(GetSystemDir)
          + 'SHELL32.DLL';
      except
        FileName := 'C:\WINDOWS\SYSTEM\SHELL32.DLL';
      end;
      // Determine the default icon for the file extension
      if      (FileExt = '.DOC') then IconIndex := 1
      else if (FileExt = '.EXE')
           or (FileExt = '.COM') then IconIndex := 2
      else if (FileExt = '.HLP') then IconIndex := 23
      else if (FileExt = '.INI')
           or (FileExt = '.INF') then IconIndex := 63
      else if (FileExt = '.TXT') then IconIndex := 64
      else if (FileExt = '.BAT') then IconIndex := 65
      else if (FileExt = '.DLL')
           or (FileExt = '.SYS')
           or (FileExt = '.VBX')
           or (FileExt = '.OCX')
           or (FileExt = '.VXD') then IconIndex := 66
      else if (FileExt = '.FON') then IconIndex := 67
      else if (FileExt = '.TTF') then IconIndex := 68
      else if (FileExt = '.FOT') then IconIndex := 69
      else IconIndex := 0;
      // Attempt to get the icon.
      if ExtractIconEx(pchar(FileName), IconIndex,
          PLargeIcon^, PSmallIcon^, 1) <> 1 then
      begin
        // Failed to get the icon. Just "return" zeroes.
        if PLargeIcon <> nil then PLargeIcon^ := 0;
        if PSmallIcon <> nil then PSmallIcon^ := 0;
      end;
    end;
  end;

Sample call
-----------
This example will change the icon of your form:

  procedure TForm1.Button1Click(Sender: TObject);
  var
    SmallIcon: HICON;
  begin
    GetAssociatedIcon('file.doc', nil, @SmallIcon);
    if SmallIcon <> 0 then
      Icon.Handle := SmallIcon;
  end;

Minimize All Windows on Desktop - Delphi

2008-12-31T05:10:00.002-08:00

To minimize all the windows on the Desktop manually, you need to right-click the taskbar and select "Minimize All Windows" (Win 98) ; another solution requires a click to the "Show Desktop" icon in the "Quick Launch" area of the taskbar (Windows 2000 or Windows XP).

Finally you can press the Windows logo key and the M key simultaneously. Unfortunately, you can't programmatically send this key combination to the Windows shell or any other application.

You can use the Shell API Application object, take a look on the code:

uses ShlObj;

procedure Shell_MinimizeAll;
var
Shell : OleVariant;
begin
Shell := CreateOleObject('Shell.Application');
Shell.MinimizeAll;
end;

Determining if there is a disk/diskette/CD in a removable-disk drive - Delphi

2008-12-31T05:10:00.001-08:00

The trick is done by calling the API GetDiskFreeSpace and returning
its return value as a boolean. The following function takes the drive
letter as a parameter (for example 'A', 'D', etc.) and returns True
if there is a disk in the drive, or False if not.

var
DrivePath: array [0..3] of char = 'A:\';

function IsDiskIn(drive: char): boolean;
var
d1, d2, d3, d4: longword;
begin
DrivePath[0] := drive;
Result := GetDiskFreeSpace(DrivePath, d1, d2, d3, d4);
end;

In the implementation we use an initialized null-terminated string
(DrivePath) that contains the root directory of drive A: and we
substitute the drive letter with the one passed as parameter before
calling GetDiskFreeSpace.

Sample call
-----------

procedure TForm1.Button1Click(Sender: TObject);
begin
if not IsDiskIn('A') then
ShowMessage('Drive A: Not Ready');
end;

Starting an application as an icon in the system tray - Delphi

2008-12-31T05:09:00.002-08:00

Placing an icon the system tray
-------------------------------

NOTE: You can download the full source code of this article from
http://www.latiumsoftware.com/download/d00035.zip

The system tray is the area at the right of the task bar where "background" applications can place their icons. To place an icon in the tray you have to call the Shell_NotifyIcon API declared in the ShellAPI unit, passing it the constant NIM_ADD (to tell it to add an icon) and the address of a TNotifyIconData record with the icon information that includes the handle of the icon to show, the text to show as tool tip when the mouse is over the icon, the handle of the window that will receive the messages of the icon and the message type the icon will send to this window.

uses
..., ShellAPI;

const
WM_ICONTRAY = WM_USER + 1; // User-defined message

type
...

var
...
NotifyIconData : TNotifyIconData;

implementation

procedure TForm1.FormCreate(Sender: TObject);
begin
with NotifyIconData do begin
hIcon := Icon.Handle;
StrPCopy(szTip, Application.Title);
Wnd := Handle;
uCallbackMessage := WM_ICONTRAY;
uID := 1;
uFlags := NIF_MESSAGE + NIF_ICON + NIF_TIP;
cbSize := sizeof(TNotifyIconData);
end;
Shell_NotifyIcon(NIM_ADD, @NotifyIconData);
end;

Handling icon messages
----------------------

Form1 will receive WM_ICONTRAY messages from the icon. To capture and handle these messages we have to declare a new method in our form. For example:

type
TForm1 = class(TForm)
...
private
{ Private declarations }
...
procedure Icontray(var Msg: TMessage); message WM_ICONTRAY;
public
{ Public declarations }
...
end;

In the implementation of this method we can for example display a popup menu when the user right-clicks on the icon. Assuming you have created a popup menu named PopupMenu1, the following code will do the trick:

procedure TForm1.Icontray(var Msg: TMessage);
var
CursorPos : TPoint;
begin
if Msg.lParam = WM_RBUTTONDOWN then begin
GetCursorPos(CursorPos);
SetForegroundWindow(Handle); // suggested by Berend Radstaat
PopupMenu1.Popup(CursorPos.x, CursorPos.y);
PostMessage(Handle, WM_NULL, 0, 0); // suggested by Berend Radstaat
end else
inherited;
end;

Thanks to Berend Radstaat for the additions to this article.

Showing and hiding the form
---------------------------

Normally you will include a menu item in the popup menu to show the form, so all you have to do is write an event handler to call the Show method of the form and optionally remove the icon from the system tray:

procedure TForm1.mnuShowClick(Sender: TObject);
begin
Show;
// Shell_NotifyIcon(NIM_DELETE, @NotifyIconData);
end;

When the user closes the form, you can for example hide it instead of closing it and optionally show the icon again in the system tray if you have removed it when you made the form visible. For example:

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
Action := caNone;
Hide;
// Shell_NotifyIcon(NIM_ADD, @NotifyIconData);
end;

Finishing the application
-------------------------

You can have a menu item in the popup menu to exit the application. In this case you have to write an event handler for its click event to remove the icon and finish the application:

procedure TForm1.mnuExitClick(Sender: TObject);
begin
Shell_NotifyIcon(NIM_DELETE, @NotifyIconData);
Application.ProcessMessages;
Application.Terminate;
end;

How to start the "Control Panel"

2008-12-31T05:09:00.001-08:00

In fact it is realy simple
see the following...

procedure TForm1.Buton1Click(Sender : TObject);
begin
ShellExecute(Handle,'Open','control',nil,nil,SW_SHOWNORMAL);
end;

there are a lot of things you can do with this code
just replace the string 'control' with a
normal command line (c:\)

NOTE you must add "ShellApi" to the uses clause!

Windows Search Engine - Delphi

2008-12-31T05:07:00.001-08:00

The Shell supports several search utilities that allow users to locate namespace objects such as files or printers. You can create a custom search engine and make it available to users by implementing and registering a search handler.

Users have two ways to select a search engine. The first way is from the Start menu. With systems earlier than Microsoft Windows 2000, selecting the Find command on the Start menu displays a submenu of the available search engines. With Windows 2000 and later, the Start menu's Find command is renamed Search.
Users can also launch a search from Windows Explorer. On systems earlier than Windows 2000, they click the Find command on the Tools menu to display essentially the same menu as the one associated with the Start menu. However, Windows Explorer for Windows 2000 handles search engines in a very different way. Instead of handling search engines as a submenu of the Tools menu, there is now a Search button on the toolbar. Clicking this button opens the Explorer bar's Search pane

The following example shows how to implement Shell Search Handler using Borland Delphi. As any Shell Extension it must be implemented as in-process Component Object Model (COM) object. It must be assigned a globally unique identifier (GUID) and registered using regsvr32.exe

library SearchHandler;

uses
ComServ,
HandlerM in 'HandlerM.pas';

{$R *.RES}

exports
DllGetClassObject,
DllCanUnloadNow,
DllRegisterServer,
DllUnregisterServer;

begin
end.

{*****************************************************************************
Name : TSearchEngine
Author : Perevoznyk Serhiy
Description : Shell Search Handler
*****************************************************************************}

unit HandlerM;

interface

uses
Windows, ActiveX, ComObj, ShlObj, Dialogs;

type
TSearchEngine = class(TComObject, IShellExtInit, IContextMenu)
protected
{ IShellExtInit }
function IShellExtInit.Initialize = SEIInitialize; // Avoid compiler warning
function SEIInitialize(pidlFolder: PItemIDList; lpdobj: IDataObject;
hKeyProgID: HKEY): HResult; stdcall;
{ IContextMenu }
function QueryContextMenu(Menu: HMENU; indexMenu, idCmdFirst, idCmdLast,
uFlags: UINT): HResult; stdcall;
function InvokeCommand(var lpici: TCMInvokeCommandInfo): HResult; stdcall;
function GetCommandString(idCmd, uType: UINT; pwReserved: PUINT;
pszName: LPSTR; cchMax: UINT): HResult; stdcall;
end;

const
Class_SearchEngine: TGUID = '{B8091A44-1F5E-4EFE-8F26-194ACBDE4465}';

implementation

uses ComServ, SysUtils, ShellApi, Registry;

function TSearchEngine.SEIInitialize(pidlFolder: PItemIDList; lpdobj: IDataObject;
hKeyProgID: HKEY): HResult;
begin
Result := NOERROR;
end;

function TSearchEngine.QueryContextMenu(Menu: HMENU; indexMenu, idCmdFirst,
idCmdLast, uFlags: UINT): HResult;
begin
Result := 0;
end;

function TSearchEngine.InvokeCommand(var lpici: TCMInvokeCommandInfo): HResult;
begin
//enter your code here
ShowMessage('Executed');
Result := NOERROR;
end;

function TSearchEngine.GetCommandString(idCmd, uType: UINT; pwReserved: PUINT;
pszName: LPSTR; cchMax: UINT): HRESULT;
begin
if (idCmd = 0) then
begin
if (uType = GCS_HELPTEXT) then
// return help string for menu item
StrCopy(pszName, 'Find document');
Result := NOERROR;
end
else
Result := E_INVALIDARG;
end;

type
TSearchEngineFactory = class(TComObjectFactory)
public
procedure UpdateRegistry(Register: Boolean); override;
end;

procedure CreateKey(const Key, ValueName, Value: string);
var
Handle: HKey;
Status, Disposition: Integer;
begin
Status := RegCreateKeyEx(HKEY_LOCAL_MACHINE, PChar(Key), 0, '',
REG_OPTION_NON_VOLATILE, KEY_READ or KEY_WRITE, nil, Handle,
@Disposition);
if Status = 0 then
begin
RegSetValueEx(Handle, PChar(ValueName), 0, REG_SZ,
PChar(Value), Length(Value) + 1);
RegCloseKey(Handle);
end;
end;

procedure DeleteKey(const Key: string);
begin
RegDeleteKey(HKEY_LOCAL_MACHINE, PChar(Key));
end;

procedure TSearchEngineFactory.UpdateRegistry(Register: Boolean);
var
ClassID: string;
FileName: array [0..MAX_PATH] of Char;
begin
if Register then
begin
inherited UpdateRegistry(Register);
ClassID := GUIDToString(Class_SearchEngine);
GetModuleFileName(HInstance, FileName, SizeOf(FileName));
CreateKey('Software\Microsoft\Windows\CurrentVersion\Explorer\FindExtensions\Static\SearchHandler', '', ClassID);
CreateKey('Software\Microsoft\Windows\CurrentVersion\Explorer\FindExtensions\Static\SearchHandler\0', '', 'Using Delphi...');
CreateKey('Software\Microsoft\Windows\CurrentVersion\Explorer\FindExtensions\Static\SearchHandler\0\DefaultIcon', '', FileName + ',0');
end
else
begin
DeleteKey('Software\Microsoft\Windows\CurrentVersion\Explorer\FindExtensions\Static\SearchHandler\0\DefaultIcon');
DeleteKey('Software\Microsoft\Windows\CurrentVersion\Explorer\FindExtensions\Static\SearchHandler\0');
DeleteKey('Software\Microsoft\Windows\CurrentVersion\Explorer\FindExtensions\Static\SearchHandler');
inherited UpdateRegistry(Register);
end;
end;

initialization
TSearchEngineFactory.Create(ComServer, TSearchEngine, Class_SearchEngine,
'', 'Delphi Search Engine Example', ciMultiInstance,
tmApartment);
end.

Multi-files properties dialog? - Delphi

2008-12-31T05:04:00.000-08:00

{ Copyright Kingron 2005 }
{ For Windows 2000 or Higher, Shell32.dll version 5.0 or later }

uses ActiveX, ShlObj, ComObj;

function SHMultiFileProperties(pDataObj: IDataObject; Flag: DWORD): HRESULT;
stdcall; external 'shell32.dll';

function GetFileListDataObject(Files: TStrings): IDataObject;
type
PArrayOfPItemIDList = ^TArrayOfPItemIDList;
TArrayOfPItemIDList = array[0..0] of PItemIDList;
var
Malloc: IMalloc;
Root: IShellFolder;
p: PArrayOfPItemIDList;
chEaten, dwAttributes: ULONG;
i, FileCount: Integer;
begin
Result := nil;
FileCount := Files.Count;
if FileCount = 0 then Exit;

OleCheck(SHGetMalloc(Malloc));
OleCheck(SHGetDesktopFolder(Root));
p := AllocMem(SizeOf(PItemIDList) * FileCount);
try
for i := 0 to FileCount - 1 do
try
if not (DirectoryExists(Files[i]) or FileExists(Files[i])) then Continue;
OleCheck(Root.ParseDisplayName(GetActiveWindow,
nil,
PWideChar(WideString(Files[i])),
chEaten,
p^[i],
dwAttributes));
except
end;
OleCheck(Root.GetUIObjectOf(GetActiveWindow,
FileCount,
p^[0],
IDataObject,
nil,
Pointer(Result)));
finally
for i := 0 to FileCount - 1 do
begin
if p^[i] <> nil then Malloc.Free(p^[i]);
end;
FreeMem(p);
end;
end;

procedure ShowFileProperties(Files: TStrings; aWnd: HWND);
type
PArrayOfPItemIDList = ^TArrayOfPItemIDList;
TArrayOfPItemIDList = array[0..0] of PItemIDList;
var
Data: IDataObject;
begin
if Files.Count = 0 then Exit;
Data := GetFileListDataObject(Files);
SHMultiFileProperties(Data, 0);
end;

// Example:
// Beispiel:

procedure TForm1.Button1Click(Sender: TObject);
begin
if OpenDialog1.Execute then
Memo1.Lines.AddStrings(OpenDialog1.Files);
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
ShowFileProperties(Memo1.Lines, 0);
end;

Transparent Desktop Icon - Delphi

2008-12-31T05:00:00.000-08:00

Below is code to a quick unit I threw together to allow my Desktop icons to be transparent:

unit Desktop;

interface

uses Windows, CommCtrl, Graphics;

function FindDesktopWindow: HWND;
function IsDesktopTransparent: Boolean;
procedure SetDesktopIconColor(Foreground, Background: TColor; Trans: Boolean);
procedure SetDefaultIconColors;

implementation

function FindDesktopWindow: HWND;
var
Window: HWND;
begin
Window := FindWindow('Progman','Program Manager');
Window := FindWindowEx(Window,0,'SHELLDLL_DefView','');
Window := FindWindowEx(Window,0,'SysListView32','');
Result := Window;
end;

function IsDesktopTransparent: Boolean;
var
BkColor: COLORREF;
begin
BkColor := ListView_GetTextBkColor(FindDesktopWindow);
if BkColor <> $FFFFFFFF then
Result := False
else
Result := True;
end;

procedure SetDesktopIconColor(Foreground, Background: TColor; Trans: Boolean);
var
Window: HWND;
begin
Window := FindDesktopWindow;
if Trans = True then
ListView_SetTextBkColor(Window,$FFFFFFFF)
else
ListView_SetTextBkColor(Window,Background);
ListView_SetTextColor(Window, Foreground);
ListView_RedrawItems(Window,0,ListView_GetItemCount(Window) - 1);
UpdateWindow(Window);
end;

procedure SetDefaultIconColors;
var
Kind: Integer;
Color: TColor;
begin
Kind := COLOR_DESKTOP;
Color := GetSysColor(COLOR_DESKTOP);
SetSysColors(0,Kind,Color);
end;

end.

Theme application- Make a different style!

2008-12-31T04:57:00.000-08:00

Introduction

Dear.
Don't worry about your application style.
I'll tell you how to make your application deference. You can design them to the XP themes. How? Follow me.

1) Create a new windows application project with C#.NET or VB.NET
2) In your project constructor write this code:

/* C# Application */
public WindowsApplication1()
{
InitializeComponent();

////////////////////////////////////////////
///////////////// Add It /////////////////

System.Windows.Forms.Application.EnableVisualStyles();

////////////////////////////////////////////
////////////////////////////////////////////

}

static void Main()
{
Application.EnableVisualStyles();
Application.DoEvents();Application.Run(new MainForm());
}

/* VB Application */
Public Sub New()
MyBase.New()
InitializeComponent()

''''''''''''''''''''''''''''''''''''''''''''''''''''
'''''''''''''''''''''' Add It '''''''''''''''

System.Windows.Forms.Application.EnableVisualStyles()

''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''
End Sub

3) Now, design your from with some of standard components.
For example put a TextBox, a Button and a CheckBox.

4) For your text box, do nothing. But for your button, set the FlatStyle property to the System.You must do that for the Checkbox and the radio button but do nothing for Combo Box, Progress and etc.

5) Run your project. Wow. See a deference style.

6) Good luck.

How to make XP Style Buttons in your VB.Net

2008-12-31T04:52:00.000-08:00

Author: DevASP
Download Source Code : 364_XP_STYLE_BUTTONS.zip

Create a New Project in VB.Net. Drag ten Button controls from tool box . Now write code on Form Load Event and Buttons Click events

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

Button1.Text = "Click Me"

Button2.Text = "Click Me"

Button3.Text = "Click Me"

Button4.Text = "Click Me"

Button5.Text = "Click Me"

Button6.Text = "Click Me"

Button7.Text = "Click Me"

Button8.Text = "Click Me"

Button9.Text = "Click Me"

End Sub

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

Button1.FlatStyle = FlatStyle.System

End Sub

Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click

Button3.FlatStyle = FlatStyle.System

End Sub

Private Sub Button9_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button9.Click

Button9.FlatStyle = FlatStyle.System

End Sub

Private Sub Button8_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button8.Click

Button8.FlatStyle = FlatStyle.System

End Sub

Private Sub Button6_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button6.Click

Button6.FlatStyle = FlatStyle.System

End Sub

Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click

Button2.FlatStyle = FlatStyle.System

End Sub

Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button4.Click

Button4.FlatStyle = FlatStyle.System

End Sub

Private Sub Button7_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button7.Click

Button7.FlatStyle = FlatStyle.System

End Sub

Private Sub Button5_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button5.Click

Button5.FlatStyle = FlatStyle.System

End Sub

Private Sub Button10_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button10.Click

Button1.FlatStyle = FlatStyle.Standard

Button2.FlatStyle = FlatStyle.Standard

Button3.FlatStyle = FlatStyle.Standard

Button4.FlatStyle = FlatStyle.Standard

Button5.FlatStyle = FlatStyle.Standard

Button6.FlatStyle = FlatStyle.Standard

Button7.FlatStyle = FlatStyle.Standard

Button8.FlatStyle = FlatStyle.Standard

Button9.FlatStyle = FlatStyle.Standard

End Sub