article

TINIFile And You - Using INI Files in Delphi

Email
Submitted on: 1/1/2015 9:28:00 AM
By: bleh (from psc cd)  
Level: Beginner
User Rating: By 23 Users
Compatibility: Delphi 5, Delphi 4
Views: 15318
 
     Learn the magic of the TINIFile object.

 
				
TINIFile And You - Using INI Files in Delphi

This article is just a simple explanation of how to implement the TINIFile object into your Delphi application. Thankfully, the wonderful people at Borland have created this object for us, so we don't have to actually write out the API to do so (such as in VB). If you already understand what an INI File is and how it works, you can skip directly to Part 2. Otherwise, I suggest you read Part 1 first

Part 1: Understanding INI Files

INI Files are nothing more than text files that are used by many programs to store application and operating system values, such as a programs window position, colors, or virtually any other settings. INI Files were rather abundant in Windows 3.1, and to alleviate this growing problem, Microsoft decided that with Windows 95, it would implement a database they so lovingly called the registry (there is a good tutorial on here for the Windows Registry in Delphi, so I won't bother getting into it here). Despite this fact, INI Files are still very much in use within the Windows operating system. A good example is the win.ini file, which can be found in C:\Windows\win.ini. We are going to take a look at this file to help us understand more about it. So to help us out more, open up the file C:\Windows\win.ini in Notepad.

NOTE: It's probably NOT a good idea to change any of the settings in this file, as you can screw up your windows settings if you do. Your best and safest bet is to copy the win.ini file to another location, and open it up from there. Don't blame me if you dink around with this file and something goes wrong on your machine. You've been warned.

An INI File consists of three main part. The Section, the Key, and the Value. If you browse through the win.ini file, you will see that it is split up into "Sections". Each Section is defined by brackets. Beneath each Section is a list of "Keys", and their respective "Values". Here is an example and explanation of some Keys and Values from the Desktop Section of my win.ini file.

[Desktop]
Wallpaper=(None)
TileWallpaper=0
WallpaperStyle=2
Pattern=(None)

In this example, our Section is called "Desktop". Beneath this, we have the Keys "Wallpaper", "TileWallpaper", "WallpaperStyle", and "Pattern". Their respective Values are "(None)", "0", "2", and "(None)". Your values are probably different than mine, but the Keys should be the same. Every time Windows loads, the Operating System checks this file, and creates your Desktop settings based on the values within this Section.

I can't really think of anything else to write to explain this any better, so I am going to just jump ahead to using the TINIFile object within your Delphi project.

Part 2: TINIFile Object - Borland Loves You

Like many programmers, I once too struggled with the unholy carnage that was using the Windows API in Visual Basic. Then one day, I heard about Delphi. After messing around with a copy of it at a friends house, I found that all the things that were absolutely annoying and tedious about Visual Basic could be done about 100 times faster and more efficiently in Delphi. I had seen the light at the end of the tunnel, and it was being tended by the good people at Borland. They took the lame task of dealing with INI Files and put it all into one, easy to use object.

The first thing we are going to do to enable the ability to read and write to INI Files in our project is to put the word "INIFiles" into the Uses section of our main unit. Example:

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

Let's go ahead and put a text box and two buttons onto our form. Name the text box "txtValue". Name the Buttons "btnRead" and "btnWrite", and set their Captions to "Read INI" and "Write INI" respectively. Create an "onClick" event for your btnWrite button, and insert the following code.

TForm1.btnWriteClick(Sender: TObject);
var
    myINI : TINIFile;
begin
    myINI := TINIFile.Create(ExtractFilePath(Application.EXEName) + 'myinifile.ini');
    myINI.WriteString('Settings', 'Text Box', txtValue.Text);
    myINI.Free;
end;

The first thing this code does is assign myINI as a TINIFile object. The .Create() is telling us that "Hey, everything within these parentheses is the path to our INI File." I have used "ExtractFilePath(Application.EXEName) + 'myinifile.ini'". This is telling us that our INI File will be located in the application's directory. Feel free to change this path if you wish. If the file doesn't exist, don't worry. Delphi will automatically create the INI File once we call our next bit of code.

The second thing this code does, is to write out a Value to a specific Key within a certain Section. The Section we are writing to here is 'Settings', although realistically, it could be called anything you want. The second parameter is telling Delphi that we want to write out a Key called 'Text Box'. Again, this can be anything you want it to be. Finally, the last parameter is our Value for the Key 'Text Box', in the Section 'Settings'. In this example, it will write out whatever is contained within txtValue.Text.

Now that we have successfully written to a INI File, let's read it back in. Create an "onClick" even for your btnRead button and insert the following code. :

TForm1.btnReadClick(Sender: TObject);
var
    myINI : TINIFile;
begin
    myINI := TINIFile.Create(ExtractFilePath(Application.EXEName) + 'myinifile.ini');
    txtValue.Text := myINI.ReadString('Settings', 'Text Box', 'Default');
    myINI.Free;
end;

Basically, the first line of code does the same thing as the btnReadClick event. If the file doesn't exist, don't worry. The next line of code is a bit different than the WriteString procedure, however. Like the WriteString procedure, it is going to look for the Section 'Settings', and the Key 'Text Box'. However, our third parameter is different. This parameter is what will be returned if the Key 'Text Box' or Section 'Settings' doesn't exist. It will also return this if there is no INI File to begin with. So if the Key exists, whatever is contained within it will be placed into the txtValue. If it doesn't, then the word 'Default' will be put there.

Part 3: Other Types Of Procedures and Functions..

In addition to reading and writing strings to/from INI Files, we can also read/write Integers, using "ReadInteger()" and "WriteInteger()" respectively. There are also a slew of other procedures and functions that we can use.

  • DeleteKey
  • EraseSection
  • ReadBinaryStream
  • ReadBool
  • ReadDate
  • ReadDateTime
  • ReadFloat
  • ReadSection
  • ReadSections
  • ReadBinaryStream
  • ReadSectionValues
  • ReadTime
  • SectionExists
  • WriteBinaryStream
  • WriteBool
  • WriteDate
  • WriteDateTime
  • WriteFloat
  • WriteTime
  • UpdateFile
  • ValueExists

Hopefully this will help you along your way with using INI Files. If you want an indepth description of what each function, procedure, method, or event does, check the Delphi Help files.


Other 1 submission(s) by this author

 


Report Bad Submission
Use this form to tell us if this entry should be deleted (i.e contains no code, is a virus, etc.).
This submission should be removed because:

Your Vote

What do you think of this article (in the Beginner category)?
(The article with your highest vote will win this month's coding contest!)
Excellent  Good  Average  Below Average  Poor (See voting log ...)
 

Other User Comments


 There are no comments on this submission.
 

Add Your Feedback
Your feedback will be posted below and an email sent to the author. Please remember that the author was kind enough to share this with you, so any criticisms must be stated politely, or they will be deleted. (For feedback not related to this particular article, please click here instead.)
 

To post feedback, first please login.