Home | News | Projects | Releases
Bugs | RFE | Repositories | Help
Import Kiriwrite 0.0.2 into the private repository.
authorkirinji <kirinji@b7d4c41f-bb2b-0410-be1d-d0fb2b8774c1>
Thu, 15 Mar 2007 18:20:16 +0000 (18:20 +0000)
committerkirinji <kirinji@b7d4c41f-bb2b-0410-be1d-d0fb2b8774c1>
Thu, 15 Mar 2007 18:20:16 +0000 (18:20 +0000)
COPYING [new file with mode: 0644]
INSTALL [new file with mode: 0644]
README [new file with mode: 0644]
cgi-files/Modules/Output/HTML4T.pm [new file with mode: 0644]
cgi-files/kiriwrite.cgi [new file with mode: 0755]
cgi-files/kiriwrite.xml [new file with mode: 0644]
cgi-files/lang/en-uk.xml [new file with mode: 0644]
cgi-files/page.html [new file with mode: 0644]
misc/dbspecs/kiriwrite_database.sqlite [new file with mode: 0644]
misc/dbspecs/kiriwrite_filters.sqlite [new file with mode: 0644]
misc/dbspecs/kiriwrite_template.sqlite [new file with mode: 0644]

diff --git a/COPYING b/COPYING
new file mode 100644 (file)
index 0000000..5b6e7c6
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,340 @@
+                   GNU GENERAL PUBLIC LICENSE
+                      Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                           Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+\f
+                   GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+\f
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+\f
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+\f
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                           NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                    END OF TERMS AND CONDITIONS
+\f
+           How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff --git a/INSTALL b/INSTALL
new file mode 100644 (file)
index 0000000..8d1c8b6
--- /dev/null
+++ b/INSTALL
@@ -0,0 +1 @@
diff --git a/README b/README
new file mode 100644 (file)
index 0000000..8d1c8b6
--- /dev/null
+++ b/README
@@ -0,0 +1 @@
diff --git a/cgi-files/Modules/Output/HTML4T.pm b/cgi-files/Modules/Output/HTML4T.pm
new file mode 100644 (file)
index 0000000..8d1c8b6
--- /dev/null
@@ -0,0 +1 @@
diff --git a/cgi-files/kiriwrite.cgi b/cgi-files/kiriwrite.cgi
new file mode 100755 (executable)
index 0000000..2b061b6
--- /dev/null
@@ -0,0 +1,11927 @@
+#!/usr/bin/perl -Tw
+
+#################################################################################
+# Kiriwrite (kiriwrite.cgi)                                                    #
+# Main program script                                                          #
+#                                                                              #
+# Version: 0.0.2                                                               #
+#                                                                              #
+# Copyright (C) 2005-2007 Steve Brokenshire <sbrokenshire@xestia.co.uk>                #
+#                                                                              #
+# This program is free software; you can redistribute it and/or modify it under #
+# the terms of the GNU General Public License as published by the Free         #
+# Software Foundation; as version 2 of the License.                            #
+#                                                                              #
+# This program is distributed in the hope that it will be useful, but WITHOUT  #
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS        #
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.#
+#                                                                              #
+# You should have received a copy of the GNU General Public License along with #
+# this program; if not, write to the Free Software Foundation, Inc., 51        #
+# Franklin St, Fifth Floor, Boston, MA 02110-1301 USA                          #
+#################################################################################
+
+use strict;                            # Throw errors if there's something wrong.
+use warnings;                          # Write warnings to the HTTP Server Log file.
+
+use utf8;
+use CGI qw(:standard);                 
+use CGI::Carp('fatalsToBrowser');      # Output errors to the browser.
+
+# Declare global variables for Kiriwrite settings and languages.
+
+our($kiriwrite_config, %kiriwrite_config, $kiriwrite_lang, %kiriwrite_lang, $kiriwrite_version, %kiriwrite_version);
+
+# Setup the version information for Kiriwrite.
+
+%kiriwrite_version = (
+       "major"         => 0,
+       "minor"         => 0,
+       "revision"      => 2
+);
+
+#################################################################################
+# Begin listing the functions needed.                                          #
+#################################################################################
+
+#sub AUTOLOAD{
+#################################################################################
+# AUTOLOAD: Catch-all for subroutines that do not exist.                       #
+#################################################################################
+
+       # A subroutine given does not exist so return an error.
+
+#      kiriwrite_error("internalerror");
+
+#}
+
+sub kiriwrite_page_add{
+#################################################################################
+# kiriwrite_page_add: Adds a page to a database                                        #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_page_add(database, pagefilename, title, description, section,      #
+#                      template, settings, info, confirm);                     #
+#                                                                              #
+# database     Specifies the database name.                                    #
+# pagefilename Specifies the page filename.                                    #
+# title                Specifies the page title to be used.                            #
+# description  Specifies the short description of the page.                    #
+# section      Specifies the section assigned to the page.                     #
+# template     Specifies the template to use.                                  #
+# settings     Specifies the settings to be used on the page.                  #
+# data         Specifies the data which consists the page.                     #
+# confirm      Confirms action to add an page.                                 #
+#################################################################################
+
+       # Fetch the required variables that have been passed to the subroutine.
+
+       my ($pagedatabase, $pagefilename, $pagetitle, $pagedescription, $pagesection, $pagetemplate, $pagesettings, $pagefiledata, $confirm) = @_;
+       
+       # Load the required Perl modules.
+
+       use DBI;
+       
+       # Check if the action to add a new page has been confirmed (or not).
+       
+       my $pagedata = "";
+       
+       if (!$confirm){
+       
+               $confirm = 0;
+
+       }
+
+       kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
+
+       # Check if the database filename is valid and return an error if
+       # it isn't.
+
+       my $pagedatabase_filename_check = kiriwrite_variablecheck($pagedatabase, "filename", 0, 1);
+
+       if ($pagedatabase_filename_check eq 1){
+
+               # The database filename is blank, so return an error.
+
+               kiriwrite_error("blankdatabasepageadd");
+
+       } elsif ($pagedatabase_filename_check eq 2){
+
+               # The database filename is invalid, so return an error.
+
+               kiriwrite_error("databasefilenameinvalid");
+
+       }
+
+       # Check the length the database name and return an error if it's
+       # too long.
+
+       my $pagedatabase_length_check   = kiriwrite_variablecheck($pagedatabase, "maxlength", 64, 1);
+
+       if ($pagedatabase_length_check eq 1){
+
+               # The database name is too long, so return an error.
+
+               kiriwrite_error("databasefilenametoolong");
+
+       }
+       
+       if ($confirm eq "1"){
+
+               # Check all the variables to see if they UTF8 valid.
+
+               kiriwrite_variablecheck($pagefilename, "utf8", 0, 0);
+               kiriwrite_variablecheck($pagetitle, "utf8", 0, 0);
+               kiriwrite_variablecheck($pagedescription, "utf8", 0, 0);
+               kiriwrite_variablecheck($pagesection, "utf8", 0, 0);
+               kiriwrite_variablecheck($pagedatabase, "utf8", 0, 0);
+               kiriwrite_variablecheck($pagesettings, "utf8", 0, 0);
+               kiriwrite_variablecheck($pagetemplate, "utf8", 0, 0);
+               kiriwrite_variablecheck($pagefiledata, "utf8", 0, 0);
+
+               # Convert the values into proper UTF8 values.
+
+               $pagefilename           = kiriwrite_utf8convert($pagefilename);
+               $pagetitle              = kiriwrite_utf8convert($pagetitle);
+               $pagedescription        = kiriwrite_utf8convert($pagedescription);
+               $pagesection            = kiriwrite_utf8convert($pagesection);
+               $pagedatabase           = kiriwrite_utf8convert($pagedatabase);
+               $pagesettings           = kiriwrite_utf8convert($pagesettings);
+               $pagetemplate           = kiriwrite_utf8convert($pagetemplate);
+               $pagefiledata           = kiriwrite_utf8convert($pagefiledata);
+
+               # Check all the variables (except for the page data, filename and settings 
+               # will be checked more specifically later if needed) that were passed to 
+               # the subroutine.
+       
+               my $pagefilename_maxlength_check                = kiriwrite_variablecheck($pagefilename, "maxlength", 256, 1);
+               my $pagetitle_maxlength_check                   = kiriwrite_variablecheck($pagetitle, "maxlength", 512, 1);
+               my $pagedescription_maxlength_check             = kiriwrite_variablecheck($pagedescription, "maxlength", 512, 1);
+               my $pagesection_maxlength_check                 = kiriwrite_variablecheck($pagesection, "maxlength", 256, 1);
+               my $pagedatabase_maxlength_check                = kiriwrite_variablecheck($pagedatabase, "maxlength", 64, 1);
+               my $pagesettings_maxlength_check                = kiriwrite_variablecheck($pagesettings, "maxlength", 1, 1);
+               my $pagetemplate_maxlength_check                = kiriwrite_variablecheck($pagetemplate, "maxlength", 64, 1);
+
+               # Check if an value returned is something else other than 0.
+
+               if ($pagefilename_maxlength_check eq 1){
+
+                       # The page filename given is too long, so return an error.
+
+                       kiriwrite_error("pagefilenametoolong");
+
+               }
+
+               if ($pagetitle_maxlength_check eq 1){
+
+                       # The page title given is too long, so return an error.
+
+                       kiriwrite_error("pagetitletoolong");
+
+               }
+
+               if ($pagedescription_maxlength_check eq 1){
+
+                       # The page description given is too long, so return an error.
+
+                       kiriwrite_error("pagedescriptiontoolong");
+
+               }
+
+               if ($pagesection_maxlength_check eq 1){
+
+                       # The page section given is too long, so return an error.
+
+                       kiriwrite_error("pagesectiontoolong");
+
+               }
+
+               if ($pagedatabase_maxlength_check eq 1){
+
+                       # The page database given is too long, so return an error.
+
+                       kiriwrite_error("pagedatabasefilenametoolong");
+
+               }
+
+               if ($pagesettings_maxlength_check eq 1){
+
+                       # The page settings given is too long, so return an error.
+
+                       kiriwrite_error("pagesettingstoolong");
+
+               }
+
+               if ($pagetemplate_maxlength_check eq 1){
+
+                       # The page template given is too long, so return an error.
+
+                       kiriwrite_error("pagetemplatefilenametoolong");
+
+               }
+
+               # The action to create a new page has been confirmed, so add the page to the
+               # selected database.
+               
+               if (!$pagefilename){
+                       kiriwrite_error("pagefilenameblank");           
+               }
+
+               # Check the page filename and page settings.
+
+               my $pagefilename_filename_check = kiriwrite_variablecheck($pagefilename, "page_filename", 0, 1);
+               my $pagesettings_setting_check  = kiriwrite_variablecheck($pagesettings, "pagesetting", 0, 1);
+               my $pagetemplate_filename_check = 0;
+               
+               if ($pagetemplate ne "!none"){
+
+                       # A template is being used so check the filename of the
+                       # template.
+
+                       $pagetemplate_filename_check    = kiriwrite_variablecheck($pagetemplate, "page_filename", 0, 1);
+
+               }
+
+               if ($pagefilename_filename_check eq 1){
+
+                       # The page filename given is invalid, so return an error.
+
+                       kiriwrite_error("pagefilenameinvalid");
+
+               }
+
+               if ($pagesettings_setting_check eq 1){
+
+                       # The page settings given is invalid, so return an error.
+
+                       kiriwrite_error("pagesettingsinvalid");
+
+               }
+
+               if ($pagetemplate_filename_check eq 1){
+
+                       # The template filename given is invalid, so return an error
+
+                       kiriwrite_error("templatefilenameinvalid");
+
+               }
+
+               # Check the permissions of the page database.
+
+               my $pagedatabase_exists         = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $pagedatabase . '.db');
+               my $pagedatabase_permissions    = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $pagedatabase . '.db', 1, 1, 0);
+
+               if ($pagedatabase_exists eq 1){
+
+                       # The page database does not exist, so return an error.
+
+                       kiriwrite_error("databasefilemissing");
+
+               }
+
+               if ($pagedatabase_permissions eq 1){
+
+                       # The page database permissions are invalid, so return
+                       # an error.
+
+                       kiriwrite_error("databaseinvalidpermissions");
+
+               }
+               
+               # Load the SQLite database.
+
+               my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $pagedatabase . '.db');
+               
+               # Check if the filename used already exists and return
+               # an error if it is.
+
+               my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $pagefilename . '\' LIMIT 1') or kiriwrite_error("databasefileinvalid");
+               $string_handle->execute();
+
+               my @database_page;
+               my $page_exists = 0;
+
+               while (@database_page = $string_handle->fetchrow_array()){
+
+                       # The page exists so set the page exists value to 1.
+
+                       $page_exists = 1;
+
+               }
+
+               if ($page_exists eq 1){
+
+                       # The page exists so return an error.
+
+                       kiriwrite_error("pagefilenameexists");
+
+               }
+
+               # Get the database name.
+
+               $string_handle          = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1');
+               $string_handle->execute();
+
+               my @database_info       = $string_handle->fetchrow_array();
+               
+               my $database_name       = $database_info[0];
+
+               # Convert the values so they don't cause the SQL query
+               # to break.
+
+               my $filename_sql                = kiriwrite_convert($pagefilename, "kiriwrite");
+               my $pagename_sql                = kiriwrite_convert($pagetitle, "kiriwrite");
+               my $pagedescription_sql         = kiriwrite_convert($pagedescription, "kiriwrite");
+               my $pagesection_sql             = kiriwrite_convert($pagesection, "kiriwrite");
+               my $pagetemplate_sql            = kiriwrite_convert($pagetemplate, "kiriwrite");
+               my $pagesettings_sql            = kiriwrite_convert($pagesettings, "kiriwrite");
+               my $pagefiledata_sql            = kiriwrite_convert($pagefiledata, "kiriwrite");
+
+               # Create the last modified date.
+
+               my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
+
+               my $pagelastmodified = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
+
+               # Add the page to the database.
+
+               $string_handle          = $database_handle->prepare('INSERT INTO kiriwrite_database_pages VALUES(
+                       \'' . $filename_sql . '\',
+                       \'' . $pagename_sql . '\',
+                       \'' . $pagedescription_sql . '\',
+                       \'' . $pagesection_sql . '\',
+                       \'' . $pagetemplate_sql . '\',
+                       \'' . $pagefiledata_sql . '\',
+                       \'' . $pagesettings_sql . '\',
+                       \'' . $pagelastmodified . '\'
+               )');
+               $string_handle->execute();
+
+               # Convert certain variables so that display properly.
+
+               my $pagetitle_display           = kiriwrite_convert($pagetitle, "normal_display");
+               my $database_name_display       = kiriwrite_convert($database_name, "normal_display");
+
+               $pagedata = "<h2>Add Page</h2>";
+               $pagedata = $pagedata . "The page called '" . $pagetitle_display . "' was added to the '" . $database_name_display .  "' database successfully.<br><br>";
+               $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $pagedatabase . "\">Return to the page list for the '" . $database_name . "' database.</a>";
+               
+               return $pagedata;
+               
+       } elsif ($confirm eq 0) {
+
+               # The action to create a new page has not been confirmed, so print out a form
+               # for adding a page to a database.
+               
+               # Check if the page database and template database exists and has valid permissions 
+               # set and return an error if they don't.
+
+               my $database_page_exists                = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $pagedatabase . '.db');
+               my $database_page_permissions           = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $pagedatabase . '.db', 1, 1, 0);
+               my $database_template_exists            = kiriwrite_fileexists("templates.db");
+               my $database_template_permissions       = kiriwrite_filepermissions("templates.db", 1, 0, 0);
+
+               my $template_data = "";
+               
+               my $database_handle;
+               my $string_handle;
+
+               my $template_warningmessage;
+               my $template_warning = 0;
+
+               my @database_template;
+               my @database_page;
+
+               if ($database_page_exists eq 1){
+
+                       # The page database does not exists so return an 
+                       # error.
+
+                       kiriwrite_error("databasemissingfile");
+
+               }
+
+               if ($database_page_permissions eq 1){
+
+                       # The page database permissions are invalid so
+                       # return an error.
+
+                       kiriwrite_error("databaseinvalidpermissions");
+
+               }
+
+               if ($database_template_exists eq 1){
+
+                       # The template database does not exist so
+                       # write a message to say that the template
+                       # database is missing, none assumed.
+
+                       $template_warningmessage = "Template database does not exist. No template will be used.";
+                       $template_warning = 1;
+
+               }
+
+               if ($database_template_permissions eq 1 && $database_template_exists ne 1){
+
+                       # The template permissions are invalid so
+                       # write a message saying that the template
+                       # database has invalid permissions set,
+                       # none assumed.
+
+                       $template_warningmessage = "Template database has invalid permissions set. No template will be used.";
+                       $template_warning = 1;
+
+               }
+
+               # Check if the template_warning value is set to 1 and
+               # if it isn't then load the template database.
+
+               if ($template_warning eq 0){
+
+                       # The template_warning value is not set to 1, so
+                       # load the template database.
+
+                       my $page_filename       = "";
+                       my $page_name           = "";
+                       my $template_count      = 0;
+
+                       # Load the SQLite database.
+
+                       $database_handle        = DBI->connect("dbi:SQLite:dbname=templates.db");
+                       $string_handle  = $database_handle->prepare("SELECT * FROM kiriwrite_templates ORDER BY templatename asc") or kiriwrite_error("templatedatabaseinvalidformat");
+                       $string_handle->execute();
+
+                       $template_data = "<select name=\"pagetemplate\">";
+
+                       # Process each template, getting the filename and template
+                       # name and put them into the list of templates available.
+
+                       while (@database_template = $string_handle->fetchrow_array()){
+
+                               $page_filename  = $database_template[0];
+                               $page_name      = $database_template[1];
+
+                               $page_filename  = kiriwrite_convert($page_filename, "normal_display");
+                               $page_name      = kiriwrite_convert($page_name, "normal_display");
+
+                               $template_data = $template_data . "<option value=\"" . $page_filename . "\">" . $page_name . " (" . $page_filename . ")</option>";
+                               $template_count++
+
+                       }
+
+                       $template_data = $template_data . "<option value=\"!none\">Don't use a template</option>";
+                       $template_data = $template_data . "</select>";
+
+                       if ($template_count eq 0){
+
+                               # There are no templates in the template database
+                               # so write a message saying that no templates
+                               # are in the template database.
+
+                               $template_warningmessage = "There are no templates in the template database. No template will be used.";
+                               $template_warning = 1;
+
+                       }
+
+               }
+
+               # Load the page database and get the page database
+               # name.
+
+               $database_handle        = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $pagedatabase . '.db');
+               $string_handle          = $database_handle->prepare("SELECT * FROM kiriwrite_database_info limit 1") or kiriwrite_error("databasefileinvalid");
+               $string_handle->execute();
+
+               @database_page          = $string_handle->fetchrow_array();
+
+               my $database_name       = $database_page[0];
+
+               $database_name          = kiriwrite_convert($database_name, "normal_display");
+               $pagedatabase           = kiriwrite_convert($pagedatabase, "normal_display");
+
+               $pagedata = $pagedata . "<h2>Add Page</h2>";
+               $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"page\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"add\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"database\" value=\"" . $pagedatabase . "\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
+               $pagedata = $pagedata . "<table cellpadding=\"5\" cellspacing=\"0\">";
+               $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Database</td><td class=\"tablecell2\">" . $database_name . "</td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Name</td><td class=\"tablecell2\"><input type=\"input\" name=\"pagename\" value=\"\" maxlength=\"512\" size=\"64\"></td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Description</td><td class=\"tablecell2\"><input type=\"input\" name=\"pagedescription\" value=\"\" maxlength=\"512\" size=\"64\"></td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Section</td><td class=\"tablecell2\"><input type=\"input\" name=\"pagesection\" value=\"\" maxlength=\"256\" size=\"64\"></td></tr>";
+
+               if ($template_warning eq 1){
+
+                       $pagedata = $pagedata . "<tr><td class=\"tablecell1\"><input type=\"hidden\" name=\"pagetemplate\" value=\"!none\">Page Template</td><td class=\"tablecell2\">" . $template_warningmessage . "</td></tr>";
+                       $pagedata = $pagedata . "";
+
+               } else {
+
+                       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Template</td><td class=\"tablecell2\">" . $template_data . "</td></tr>";
+
+               }
+
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Filename</td><td class=\"tablecell2\"><input type=\"input\" name=\"pagefilename\" value=\"\" maxlength=\"256\" size=\"64\"></td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Content</td><td class=\"tablecell2\"><textarea cols=\"50\" rows=\"10\" name=\"pagecontent\" wrap=\"off\"></textarea><br><br>";
+               $pagedata = $pagedata . "<div class=\"datalist\"><b>Kiriwrite tags</b><br><br>&lt;kiriwrite:autosection&gt; - Automatic page section name. (Will be blank if page section name is blank).<br>
+               &lt;kiriwrite:autotitle&gt; - Automatic title and section name based on page setting.<br>
+               &lt;kiriwrite:pagedata&gt; - Page Content<br>
+               &lt;kiriwrite:pagetitle&gt; - Page Title based on page setting.<br>
+               &lt;kiriwrite:pagename&gt; - Page Name<br>
+               &lt;kiriwrite:pagedescription&gt; - Page Description<br>
+               &lt;kiriwrite:pagesection&gt; - Page Section<br></div>";
+               $pagedata = $pagedata . "</td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Settings</td><td class=\"tablecell2\"><input type=\"radio\" name=\"pagesettings\" value=\"1\" checked=checked> Use page name and section name.<br><input type=\"radio\" name=\"pagesettings\" value=\"2\"> Use the page name only.<br><input type=\"radio\" name=\"pagesettings\" value=\"3\"> Use the section name only. <br><input type=\"radio\" name=\"pagesettings\" value=\"0\"> Don't use page name or section name.<br></td></tr>";
+               $pagedata = $pagedata . "</table>";
+               $pagedata = $pagedata . "<br><input type=\"submit\" value=\"Add Page\"> | <input type=\"reset\" value=\"Clear inputted data\"> | <a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $pagedatabase . "\">Return to the page list.</a>";
+               $pagedata = $pagedata . "</form>";
+       
+               return $pagedata;
+               
+       } else {
+       
+               # The confirm value is something else than '1' or '0' so
+               # return an error.
+               
+               kiriwrite_error("invalidvalue");
+       
+       }
+       
+
+
+}
+
+sub kiriwrite_page_delete{
+#################################################################################
+# kiriwrite_page_delete: Deletes a (single) page from a database.              #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_page_delete(database, page, [confirm]);                            #
+#                                                                              #
+# database     Specifies the database to delete from.                          #
+# page         Specifies the page to delete.                                   #
+# confirm      Confirms the action to delete the page.                         #
+#################################################################################
+
+       my ($database, $page, $confirm) = @_;
+
+       # Load the required Perl modules.
+
+       use DBI;
+
+       my $pagedata;
+       
+       # Check if the database filename is valid and return an error if
+       # it isn't.
+
+       my $pagedatabase_filename_check = kiriwrite_variablecheck($database, "filename", 0, 1);
+
+       if ($pagedatabase_filename_check eq 1){
+
+               # The database filename is blank, so return an error.
+
+               kiriwrite_error("blankdatabasepageadd");
+
+       } elsif ($pagedatabase_filename_check eq 2){
+
+               # The database filename is invalid, so return an error.
+
+               kiriwrite_error("databasefilenameinvalid");
+
+       }
+
+       # Check the length the database name and return an error if it's
+       # too long.
+
+       my $pagedatabase_length_check   = kiriwrite_variablecheck($database, "maxlength", 64, 1);
+
+       if ($pagedatabase_length_check eq 1){
+
+               # The database name is too long, so return an error.
+
+               kiriwrite_error("databasefilenametoolong");
+
+       }
+
+       # Check if the page name is specified is blank and return an error if
+       # it is.
+
+       if (!$page){
+
+               # The page name is blank, so return an error.
+
+               kiriwrite_error("blankfilename");
+
+       }
+       
+       # If the confirm value is blank, then set the confirm value to 0.
+
+       if (!$confirm){
+               
+               $confirm = 0;
+               
+       }
+       
+       if ($confirm eq 1){
+
+               # The action to delete the selected page from the database
+               # has been confirmed.
+
+               # Check that the database exists and has the correct permissions
+               # set.
+
+               my $database_check_exists       = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+               my $database_check_permissions  = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db', 1, 1, 0);
+
+               # Check the results and return an error if needed.
+
+               if ($database_check_exists eq 1){
+
+                       # The database file does not exist, so return an error.
+
+                       kiriwrite_error("databasemissingfile");
+
+               }
+
+               if ($database_check_permissions eq 1){
+
+                       # The database file has invalid permissions set, so
+                       # return an error.
+
+                       kiriwrite_error("databaseinvalidpermissions");
+
+               }
+
+               # Load the SQLite database and get information about the
+               # database.
+
+               my $database_handle             = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+               my $string_handle               = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("databasefileinvalid") or kiriwrite_error("databasefileinvalid");
+               $string_handle->execute();
+
+               my @database_info;
+               my $database_name;
+               @database_info = $string_handle->fetchrow_array();
+               $database_name = $database_info[0];
+
+               my $pagefilename_sql            = kiriwrite_convert($page, "kiriwrite");
+
+               # Check if the filename exists and return an error if it
+               # isn't.
+
+               $string_handle                  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $pagefilename_sql . '\' LIMIT 1');
+               $string_handle->execute();
+
+               my @database_page;
+               my $page_found = 0;
+
+               while (@database_page = $string_handle->fetchrow_array()){
+
+                       $page_found = 1;
+
+               }
+
+               # Check if the page wasn't found and return an error if it
+               # didn't.
+
+               if ($page_found eq 0){
+
+                       # Page wasn't found in the database so return
+                       # an error.
+
+                       kiriwrite_error("pagefilenamedoesnotexist");
+
+               }
+
+               # Get information about the page (mainly the name).
+
+               $string_handle                  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $pagefilename_sql . '\' LIMIT 1');
+               $string_handle->execute();
+
+               my $page_name;
+               @database_page  = $string_handle->fetchrow_array();
+               $page_name      = $database_page[1];
+
+               # Delete the page from the database.
+
+               $string_handle                  = $database_handle->prepare('DELETE FROM kiriwrite_database_pages WHERE filename = \'' . $pagefilename_sql . '\'');
+               $string_handle->execute();
+
+               # Convert the values before writing them.
+
+               my $database_out        = kiriwrite_convert($database, "normal_display");
+               my $database_name_out   = kiriwrite_convert($database_name, "normal_display");
+               my $page_name_out       = kiriwrite_convert($page_name, "normal_display");
+
+               # Write out a message saying that the selected page from
+               # the database has been deleted.
+
+               $pagedata = "<h2>Page Deleted</h2>";
+               $pagedata = $pagedata . "The page named '" . $page_name_out . "' was deleted from the '" . $database_name_out . "' database. <br><br>";
+               $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_out . "\">Return to the '" . $database_name_out . "' database.</a>";
+
+               return $pagedata;
+
+       } elsif ($confirm eq 0){
+
+               # Check that the database exists and has the correct permissions
+               # set.
+
+               my $database_check_exists       = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+               my $database_check_permissions  = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db', 1, 1, 0);
+
+               # Check the results and return an error if needed.
+
+               if ($database_check_exists eq 1){
+
+                       # The database file does not exist, so return an error.
+
+                       kiriwrite_error("databasemissingfile");
+
+               }
+
+               if ($database_check_permissions eq 1){
+
+                       # The database file has invalid permissions set, so
+                       # return an error.
+
+                       kiriwrite_error("databaseinvalidpermissions");
+
+               }
+
+               # Load the SQLite database and get information about the
+               # database.
+
+               my $database_handle             = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+               my $string_handle               = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("databasefileinvalid") or kiriwrite_error("databasefileinvalid");
+               $string_handle->execute();
+
+               my @database_info;
+               my $database_name;
+               @database_info = $string_handle->fetchrow_array();
+               $database_name = $database_info[0];
+
+               my $pagefilename_sql            = kiriwrite_convert($page, "kiriwrite");
+
+               # Check if the filename exists and return an error if it
+               # isn't.
+
+               $string_handle                  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $pagefilename_sql . '\' LIMIT 1');
+               $string_handle->execute();
+
+               my $page_found = 0;
+
+               my @database_page;
+
+               while (@database_page = $string_handle->fetchrow_array()){
+
+                       $page_found = 1;
+
+               }
+
+               # Check if the page wasn't found and return an error if it
+               # didn't.
+
+               if ($page_found eq 0){
+
+                       # Page wasn't found in the database so return
+                       # an error.
+
+                       kiriwrite_error("pagefilenamedoesnotexist");
+
+               }
+
+               # Get information about the page (mainly the name).
+
+               $string_handle                  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $pagefilename_sql . '\' LIMIT 1');
+               $string_handle->execute();
+
+               my $page_name;
+               @database_page  = $string_handle->fetchrow_array();
+               $page_name      = $database_page[1];
+
+               # Convert the values so that they can be displayed properly.
+
+               my $page_name_out       = kiriwrite_convert($page_name, "normal_display");
+               my $database_out        = kiriwrite_convert($database, "normal_display");
+               my $database_name_out   = kiriwrite_convert($database_name, "normal_display");
+               my $page_out            = kiriwrite_convert($page, "normal_display");
+
+               # Write a message asking the user to confirm the deletion of the
+               # page.
+
+               $pagedata = "<form>";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"page\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"delete\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"database\" value=\"" . $database_out . "\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"page\" value=\"" . $page_out . "\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";;
+               $pagedata = $pagedata . "<h2>Delete page '" . $page_name_out . "'</h2>";
+               $pagedata = $pagedata . "Are you sure you want to delete '" . $page_name_out . "' from the '" . $database_name_out . "' database?<br><br>";
+               $pagedata = $pagedata . "<input type=\"submit\" value=\"Yes, delete the page\"> | <a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_out  . "\">No, return to the '" . $database_name_out . "' database.</a>";
+               $pagedata = $pagedata . "</form>";
+               
+
+               return $pagedata;               
+
+       } else {
+       
+               # Another page deletion type was specified, so return an error.
+               
+               kiriwrite_error("invalidoption");
+       
+       }
+
+}
+
+sub kiriwrite_page_edit{
+#################################################################################
+# kiriwrite_page_edit: Edits a page from a database.                           #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_page_edit(database, filename, newname, newfilename, newdescription, #
+#                      newsection, newtemplate,  newsettings, newpagecontent   #
+#                      confirm);                                               #
+#                                                                              #
+# database      Specifies the database to edit from.                           #
+# filename      Specifies the filename to use.                                 #
+# newfilename   Specifies the new page filename to use.                        #
+# newname       Specifies the new page name to use.                            #
+# newdescription Specifies the new description for the page.                   #
+# newsection    Specifies the new section name to use.                         #
+# newtemplate   Specifies the new template filename to use.                    #
+# newsettings   Specifies the new page settings to use.                        #
+# newpagecontent Specifies the new page content to use.                                #
+# confirm       Confirms the action to edit the page.                          #
+#################################################################################
+
+       # Get the values that have been passed to the subroutine.
+
+       my ($database, $pagefilename, $pagenewfilename, $pagenewtitle, $pagenewdescription, $pagenewsection, $pagenewtemplate, $pagenewsettings, $pagenewcontent, $confirm) = @_;
+
+       # Load the required Perl modules.
+       
+       use DBI;
+       
+       my $pagedata = "";
+               
+       # Check if the confirm value is blank and if it is, then set it to '0'.
+       
+       if (!$confirm){
+       
+               $confirm = 0;
+       
+       }
+
+       # Check if the confirm value is more than one character long and if it
+       # is then return an error.
+
+       kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
+       
+       # Check if the database filename is valid and return an error if
+       # it isn't.
+
+       my $pagedatabase_filename_check = kiriwrite_variablecheck($database, "filename", 0, 1);
+
+       if ($pagedatabase_filename_check eq 1){
+
+               # The database filename is blank, so return an error.
+
+               kiriwrite_error("blankdatabasepageadd");
+
+       } elsif ($pagedatabase_filename_check eq 2){
+
+               # The database filename is invalid, so return an error.
+
+               kiriwrite_error("databasefilenameinvalid");
+
+       }
+       
+       # Check the length the database name and return an error if it's
+       # too long.
+
+       my $pagedatabase_length_check   = kiriwrite_variablecheck($database, "maxlength", 64, 1);
+
+       if ($pagedatabase_length_check eq 1){
+
+               # The database name is too long, so return an error.
+
+               kiriwrite_error("databasefilenametoolong");
+
+       }
+
+       # Check if the page identification number is blank (which it shouldn't
+       # be) and if it is, then return an error.
+       
+       if (!$pagefilename){
+       
+               kiriwrite_error("blankfilename");
+       
+       }
+       
+       # Check if the confirm value is '1' and if it is, edit the specified
+       # page in the database.
+       
+       if ($confirm eq 1){
+               
+               # Check if the new page filename is blank.
+
+               if (!$pagenewfilename){
+
+                       # The page filename is blank so return an error.
+
+                       kiriwrite_error("pagefilenameblank");
+
+               }
+
+               # The action to edit a page has been confirmed so check the
+               # variables recieved are UTF8 compiliant before converting.
+
+               kiriwrite_variablecheck($database, "utf8", 0, 0);
+               kiriwrite_variablecheck($pagefilename, "utf8", 0, 0);
+               kiriwrite_variablecheck($pagenewfilename, "utf8", 0, 0);
+               kiriwrite_variablecheck($pagenewtitle, "utf8", 0, 0);
+               kiriwrite_variablecheck($pagenewdescription, "utf8", 0, 0);
+               kiriwrite_variablecheck($pagenewsection, "utf8", 0, 0);
+               kiriwrite_variablecheck($pagenewsettings, "utf8", 0, 0);
+               kiriwrite_variablecheck($pagenewtemplate, "utf8", 0, 0);
+               kiriwrite_variablecheck($pagenewcontent, "utf8", 0, 0);
+
+               # Convert the variables into proper UTF8 variables.
+
+               $database               = kiriwrite_utf8convert($database);
+               $pagefilename           = kiriwrite_utf8convert($pagefilename);
+               $pagenewfilename        = kiriwrite_utf8convert($pagenewfilename);
+               $pagenewtitle           = kiriwrite_utf8convert($pagenewtitle);
+               $pagenewdescription     = kiriwrite_utf8convert($pagenewdescription);
+               $pagenewsection         = kiriwrite_utf8convert($pagenewsection);
+               $pagenewsettings        = kiriwrite_utf8convert($pagenewsettings);
+               $pagenewtemplate        = kiriwrite_utf8convert($pagenewtemplate);
+               $pagenewcontent         = kiriwrite_utf8convert($pagenewcontent);
+
+               # Check the lengths of the variables.
+
+               my $pagenewfilename_maxlength_check     = kiriwrite_variablecheck($pagenewfilename, "maxlength", 256, 1);
+               my $pagenewtitle_maxlength_check        = kiriwrite_variablecheck($pagenewtitle, "maxlength", 256, 1);
+               my $pagenewdescription_maxlength_check  = kiriwrite_variablecheck($pagenewdescription, "maxlength", 512, 1);
+               my $pagenewsection_maxlength_check      = kiriwrite_variablecheck($pagenewsection, "maxlength", 256, 1);
+               my $pagenewsettings_maxlength_check     = kiriwrite_variablecheck($pagenewsettings, "maxlength", 1, 1);
+               my $pagenewtemplate_maxlength_check     = kiriwrite_variablecheck($pagenewtemplate, "maxlength", 64, 1);
+
+               # Check each result to see if the length of the variable
+               # is valid and return an error if it isn't.
+
+               if ($pagenewfilename_maxlength_check eq 1){
+
+                       # The new page filename given is too long, so return an error.
+
+                       kiriwrite_error("pagefilenametoolong");
+
+               }
+
+               if ($pagenewtitle_maxlength_check eq 1){
+
+                       # The new page title given is too long, so return an error.
+
+                       kiriwrite_error("pagetitletoolong");
+
+               }
+
+               if ($pagenewdescription_maxlength_check eq 1){
+
+                       # The new page description given is too long, so return an error.
+
+                       kiriwrite_error("pagedescriptiontoolong");
+
+               }
+
+               if ($pagenewsection_maxlength_check eq 1){
+
+                       # The new page section given is too long, so return an error.
+
+                       kiriwrite_error("pagesectiontoolong");
+
+               }
+
+               if ($pagenewsettings_maxlength_check eq 1){
+
+                       # The new page settings given is too long, so return an error.
+
+                       kiriwrite_error("pagesettingstoolong");
+
+               }
+
+               if ($pagenewtemplate_maxlength_check eq 1){
+
+                       # The new page template given is too long, so return an error.
+
+                       kiriwrite_error("pagetemplatefilenametoolong");
+
+               }
+
+               # Check if the new page filename and new page settings
+               # are valid.
+
+               my $pagenewfilename_filename_check      = kiriwrite_variablecheck($pagenewfilename, "page_filename", 0, 1);
+               my $pagenewsettings_settings_check      = kiriwrite_variablecheck($pagenewsettings, "pagesetting", 0, 1);
+               my $pagetemplate_filename_check = 0;
+               
+               if ($pagenewtemplate ne "!none"){
+
+                       # A template is being used so check the filename of the
+                       # template.
+
+                       $pagetemplate_filename_check    = kiriwrite_variablecheck($pagenewtemplate, "page_filename", 0, 1);
+
+               }
+
+               # Check each result to see if the variables have passed
+               # their tests and return an error if they haven't.
+
+               if ($pagenewfilename_filename_check eq 1){
+
+                       # The new page filename is invalid, so return an error.
+
+                       kiriwrite_error("pagefilenameinvalid");
+
+               }
+
+               if ($pagenewsettings_settings_check eq 1){
+
+                       # The new page settings is invalid, so return an error.
+
+                       kiriwrite_error("pagesettingsinvalid");
+
+               }
+
+               if ($pagetemplate_filename_check eq 1){
+
+                       # The template filename given is invalid, so return an error
+
+                       kiriwrite_error("templatefilenameinvalid");
+
+               }
+
+               # Check if the page database exists and the permissions set for
+               # it are valid.
+
+               my $database_exists             = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+               my $database_permissions        = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db', 1, 1, 0);
+
+               if ($database_exists eq 1){
+
+                       # The database does not exist, so return an error.
+
+                       kiriwrite_error("databasemissingfile");
+
+               }
+               
+               if ($database_permissions eq 1){
+
+                       # The database permissions are invalid, so return
+                       # an error.
+
+                       kiriwrite_error("databaseinvalidpermissions");
+
+               }
+
+               # Load the SQLite database.
+
+               my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+               
+               # Check if the page exists in the page database and return
+               # an error if it doesn't.
+
+               my $pagefilename_sql    = kiriwrite_convert($pagefilename, "kiriwrite");
+
+               my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $pagefilename . '\' LIMIT 1') or kiriwrite_error("databasefileinvalid");
+               $string_handle->execute();
+
+               my $page_exists = 0;
+               my @database_pages;
+
+               # Check if a result has returned (meaning that the
+               # page with that filename exists.
+
+               while(@database_pages = $string_handle->fetchrow_array()){
+
+                       # The page exists so set the value to 1.
+
+                       $page_exists = 1;
+
+               }
+
+               if ($page_exists eq 0){
+
+                       # The page does not exist, so return an error.
+
+                       kiriwrite_error("pagefilenamedoesnotexist");
+
+               }
+
+               # Get the current date and time.
+
+               my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
+
+               my $pagelastmodified = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
+
+               # Prepare for the page's values to be changed.
+
+               $pagefilename_sql               = kiriwrite_convert($pagefilename, "kiriwrite");
+               my $pagenewfilename_sql         = kiriwrite_convert($pagenewfilename, "kiriwrite");
+               my $pagenewtitle_sql            = kiriwrite_convert($pagenewtitle, "kiriwrite");
+               my $pagenewdescription_sql      = kiriwrite_convert($pagenewdescription, "kiriwrite");
+               my $pagenewsection_sql          = kiriwrite_convert($pagenewsection, "kiriwrite");
+               my $pagenewtemplate_sql         = kiriwrite_convert($pagenewtemplate, "kiriwrite");
+               my $pagenewsettings_sql         = kiriwrite_convert($pagenewsettings, "kiriwrite");
+               my $pagenewcontent_sql          = kiriwrite_convert($pagenewcontent, "kiriwrite");
+               my $pagelastmodified_sql        = kiriwrite_convert($pagelastmodified, "kiriwrite");
+
+               # Edit the page in the database.
+
+               $string_handle  = $database_handle->prepare('UPDATE kiriwrite_database_pages SET filename = \'' . $pagenewfilename_sql . '\', pagename = \'' . $pagenewtitle_sql . '\', pagedescription = \'' . $pagenewdescription_sql . '\', pagesection = \'' . $pagenewsection_sql . '\', pagetemplate = \'' . $pagenewtemplate_sql . '\', pagedata = \'' . $pagenewcontent_sql . '\', pagesettings = \'' . $pagenewsettings_sql . '\', lastmodified = \'' . $pagelastmodified_sql . '\' WHERE filename = \'' . $pagefilename_sql . '\'');
+               $string_handle->execute();
+
+               # Get the database name.
+
+               $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1');
+               $string_handle->execute();
+
+               my @database_info;
+               my $database_name;
+
+               @database_info  = $string_handle->fetchrow_array();
+               $database_name  = $database_info[0];
+
+               # Convert certain values so that they can be displayed
+               # properly.
+
+               my $pagenewtitle_out            = kiriwrite_convert($pagenewtitle, "normal_display");
+               my $database_out                = kiriwrite_convert($database, "normal_display");
+               my $database_name_out           = kiriwrite_convert($database_name, "normal_display");
+
+               # Write out the message to say that the page has been
+               # edited.
+
+               $pagedata = "<h2>Page Edited</h2>";
+               $pagedata = $pagedata . "The page '" . $pagenewtitle_out . "' has been edited.<br><br>";
+               $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_out . "\">Return to the page list for the '" . $database_name_out . "' database</a>";
+
+               return $pagedata;
+       
+       } elsif ($confirm eq 0) {
+       
+               # Check if the database exists and that the permissions
+               # for the database are valid.
+
+               my $database_file_exists        = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+               my $database_file_permissions   = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+
+               if ($database_file_exists eq 1){
+
+                       # The database with the filename given does
+                       # not exist, so return an error.
+
+                       kiriwrite_error("databasemissingfile");
+
+               }
+
+               if ($database_file_permissions eq 1){
+
+                       # The file permissions of the database given
+                       # are invalid so return an error.
+
+                       kiriwrite_error("databaseinvalidpermissions");
+
+               }
+
+               # Load the SQLite database and check if the file exists.
+
+               my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+               my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $pagefilename . '\' LIMIT 1') or kiriwrite_error("databasefileinvalid");
+               $string_handle->execute();
+
+               my $page_count = 0;
+               my @database_pages;
+               my @database_info;
+               my @database_templates;
+               my $template_data;
+               my $template_filename;
+               my $template_name;
+               my $template_found = 0;
+
+               while (@database_pages = $string_handle->fetchrow_array()){
+
+                       $page_count = 1;
+
+               }
+
+               if ($page_count eq 0){
+
+                       # The page does not exist in the template database, so
+                       # return an error.
+
+                       kiriwrite_error("pagefilenamedoesnotexist");
+
+               }
+
+               # Get the database name.
+
+               $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("databasefileinvalid");
+               $string_handle->execute();
+               @database_info  = $string_handle->fetchrow_array();
+
+               my $database_name = $database_info[0];
+
+               $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $pagefilename . '\' LIMIT 1');
+               $string_handle->execute();
+               @database_pages = $string_handle->fetchrow_array();
+
+               # Get the variables and convert them so that they can be displayed
+               # properly.
+
+               my $data_filename               = kiriwrite_convert($database_pages[0], "normal_display");
+               my $data_name                   = kiriwrite_convert($database_pages[1], "normal_display");
+               my $data_description            = kiriwrite_convert($database_pages[2], "normal_display");
+               my $data_section                = kiriwrite_convert($database_pages[3], "normal_display");
+               my $data_template               = kiriwrite_convert($database_pages[4], "normal_display");
+               my $data_content                = kiriwrite_convert($database_pages[5], "normal_display");
+               my $data_settings               = kiriwrite_convert($database_pages[6], "normal_display");
+               my $data_lastmodified           = kiriwrite_convert(kiriwrite_convert($database_pages[7], "date"), "normal_display");
+
+               # Get the template list and select the template that is being used by
+               # the page, check the permissions and if the template database exists.
+
+               my $template_warning;
+
+               my $template_file_exists        = kiriwrite_fileexists("templates.db");
+               my $template_file_permissions   = kiriwrite_filepermissions("templates.db", 1, 0, 0);
+
+               if ($template_file_exists eq 1){
+
+                       # The template database does not exist, so write a warning messsage.
+
+                       $template_warning = "The template database does not exist. Existing template settings for page kept.";
+
+               }
+
+               if ($template_file_permissions eq 1 && $template_file_exists ne 1){
+
+                       # The template database has invalid permissions set, so write a warning message.
+
+                       $template_warning = "The template database has invalid permissions set. Existing template settings for page kept.";
+
+               }
+
+               # Get the list of templates.
+
+               if (!$template_warning){
+
+                       # Load the templates database and get the templates.
+
+                       $database_handle        = DBI->connect("dbi:SQLite:templates.db");
+
+                       $string_handle          = $database_handle->prepare('SELECT * FROM kiriwrite_templates') or $template_warning = "The template database is in an invalid format. Existing template settings kept.";
+                       
+                       if (!$template_warning){
+
+                               $string_handle->execute();
+
+                               $template_data = "<select name=\"pagetemplate\">";
+
+                               while (@database_templates = $string_handle->fetchrow_array()){
+
+                                       # Get the filename and name of the database.
+
+                                       $template_filename      = $database_templates[0];
+                                       $template_name          = $database_templates[1];
+
+                                       # Convert the values so that they can be displayed in the list.
+
+                                       $template_filename      = kiriwrite_convert($template_filename, "normal_display");
+                                       $template_name          = kiriwrite_convert($template_name, "normal_display");
+
+                                       # Append the template filename and name and make it the selected
+                                       # template if that is the template the page is using.
+
+                                       if ($data_template eq $template_filename && !$template_found){
+
+                                               $template_data = $template_data .  "<option value=\"" . $template_filename . "\" selected>" . $template_name . " (" . $template_filename .")</option>";
+                                               $template_found = 1;
+
+                                       } else {
+
+                                               $template_data = $template_data .  "<option value=\"" . $template_filename . "\">" . $template_name . " (" . $template_filename .")</option>";
+
+                                       }
+
+                               }
+
+                       }
+
+                       # Add the option to not use a template at all. Check if the
+                       # template filename is set to not use a template.
+
+                       if ($data_template eq "!none"){
+
+                               # The template filename is set to use no template
+                               # at all.
+
+                               $template_data = $template_data . "<option value=\"!none\" selected>Don't use a template</option>";
+
+                       } else {
+
+                               # The template filename is not set to use no
+                               # template at all.
+
+                               $template_data = $template_data . "<option value=\"!none\">Don't use a template</option>";
+
+                       }
+
+                       # Check if the template filename was found
+                       # in the template database and use the
+                       # current template name if not.
+
+                       if ($template_found eq 0 && $data_template ne "!none"){
+
+                               # The template with the filename given was not found.
+
+                               $template_data = $template_data . "<option class=\"warningoption\" value=\"" . $data_template . "\" selected>Keep current template filename (" . $data_template . ")</option>";
+
+                       }
+                       $template_data = $template_data . "</select>";
+
+               }
+
+               # Begin writing out the form for editing the selected page.
+
+               $pagedata = "<h2>Editing Page '" . $data_name . "'</h2>";
+               $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"page\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"edit\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"database\" value=\"" . $database . "\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"page\" value=\"" . $pagefilename . "\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
+               $pagedata = $pagedata . "<table cellspacing=\"0\" cellpadding=\"5\">";
+               $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Database</td><td class=\"tablecell2\">" . $database_name . "</td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Name</td><td class=\"tablecell2\"><input type=\"text\" name=\"pagename\" maxlength=\"256\" size=\"64\"  value=\"" . $data_name ."\"></td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Description</td><td class=\"tablecell2\"><input type=\"text\" name=\"pagedescription\" maxlength=\"512\" size=\"64\" value=\"" . $data_description . "\"=</td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Section</td><td class=\"tablecell2\"><input type=\"text\" name=\"pagesection\" maxlength=\"256\" size=\"64\" value=\"" . $data_section . "\"></td></tr>";
+
+               if ($template_warning){
+
+                       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Template</td><td class=\"tablecell2\"><input type=\"hidden\" name=\"pagetemplate\" value=\"" . $data_template . "\"><b>" . $data_template . "</b><br>" . $template_warning . "</td></tr>";
+
+               } else {
+
+                       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Template</td><td class=\"tablecell2\">" . $template_data . "</td></tr>";
+
+               }
+
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Filename</td><td class=\"tablecell2\"><input type=\"text\" name=\"pagefilename\" value=\"" . $data_filename . "\" maxlength=\"256\" size=\"64\"></td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Content</td><td class=\"tablecell2\"><textarea name=\"pagecontent\" rows=\"10\" cols=\"50\" wrap=\"off\">" . $data_content . "</textarea><br><br>";
+               $pagedata = $pagedata . "<div class=\"datalist\"><b>Kiriwrite tags</b><br><br>&lt;kiriwrite:autosection&gt; - Automatic page section name. (Will be blank if page section name is blank).<br>
+               &lt;kiriwrite:autotitle&gt; - Automatic title and section name based on page setting.<br>
+               &lt;kiriwrite:pagedata&gt; - Page Content<br>
+               &lt;kiriwrite:pagetitle&gt; - Page Title based on page setting.<br>
+               &lt;kiriwrite:pagename&gt; - Page Name<br>
+               &lt;kiriwrite:pagedescription&gt; - Page Description<br>
+               &lt;kiriwrite:pagesection&gt; - Page Section<br></div>";
+               $pagedata = $pagedata . "</td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Settings</td><td class=\"tablecell2\">";
+
+               # Check the page settings value and set the currently selected
+               # option to what the settings value is set to.
+
+               if ($data_settings eq 1){
+
+                       # The selected option is to use the page name and
+                       # section name so make sure it is selected.
+
+                       $pagedata = $pagedata . "<input type=\"radio\" name=\"pagesettings\" value=\"1\" checked> Use page name and section name.<br>";
+
+               } else {
+
+                       # The setting is not the one being checked for
+                       # so write the option out as normal.
+
+                       $pagedata = $pagedata . "<input type=\"radio\" name=\"pagesettings\" value=\"1\"> Use page name and section name.<br>";
+
+               }
+
+               if ($data_settings eq 2){
+
+                       # The selected option is to use the page name
+                       # only so make sure it is selected.
+
+                       $pagedata = $pagedata . "<input type=\"radio\" name=\"pagesettings\" value=\"2\" checked> Use the page name only.<br>";
+
+               } else {
+
+                       # The setting is not the one being checked for
+                       # so write the option out as normal.
+
+                       $pagedata = $pagedata . "<input type=\"radio\" name=\"pagesettings\" value=\"2\"> Use the page name only.<br>";
+
+               }
+
+               if ($data_settings eq 3){
+
+                       # The selected option is to use the section name
+                       # only so make sure it is selected.
+
+                       $pagedata = $pagedata . "<input type=\"radio\" name=\"pagesettings\" value=\"3\" checked> Use the section name only. <br>";
+
+               } else {
+
+                       # The setting is not the one being checked for
+                       # so write the option out as normal.
+
+                       $pagedata = $pagedata . "<input type=\"radio\" name=\"pagesettings\" value=\"3\"> Use the section name only. <br>";
+
+               }
+
+               if ($data_settings eq 0){
+
+                       # The selected option is to not use the page name
+                       # or the section name.
+
+                       $pagedata = $pagedata . "<input type=\"radio\" name=\"pagesettings\" value=\"0\" checked> Don't use page name or section name.<br></td></tr>";
+
+               } else {
+
+                       # The setting is not the one being checked for
+                       # so write the option out as normal.
+
+                       $pagedata = $pagedata . "<input type=\"radio\" name=\"pagesettings\" value=\"0\"> Don't use page name or section name.<br></td></tr>";
+
+               }
+
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Last Modified</td><td class=\"tablecell2\">" . $data_lastmodified  . "</td></tr>";
+               $pagedata = $pagedata . "</table>";
+               $pagedata = $pagedata . "<br><input type=\"submit\" value=\"Edit Page\"> | <input type=\"reset\" value=\"Reset page values\"> | <a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database . "\">Return to the page list for '" . $database_name . "'</a>";
+               $pagedata = $pagedata . "</form>";
+
+               return $pagedata;
+
+       } else {
+       
+               # The confirm value is a value other than '0' and '1' so
+               # return an error.
+               
+               kiriwrite_error("invalidvalue");
+       
+       }
+
+}
+
+sub kiriwrite_page_multidelete{
+#################################################################################
+# kiriwrite_page_multidelete: Delete mulitple pages from the database.         #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_page_multidelete(database, confirm, filelist);                     #
+#                                                                              #
+# database     Specifies the database to delete multiple pages from.           #
+# confirm      Confirms the action to delete the selected pages from the       #
+#              database.                                                       #
+# filelist     The list of files to delete from the selected database.         #
+#################################################################################
+
+       # Get the information passed to the subroutine.
+
+       my ($database, $confirm, @filelist) = @_;
+
+       # Load the needed Perl modules.
+
+       use DBI;
+
+       # Define a variable for later on.
+
+       my $pagedata;
+
+       # Check if the database name is blank and return an error if
+       # it is.
+
+       if (!$database){
+
+               # The database name is blank so return an error.
+
+               kiriwrite_error("databasenameblank");
+
+       }
+
+       # Check if the page database exists and the permissions set for
+       # it are valid.
+
+       my $database_exists             = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+       my $database_permissions        = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db', 1, 1, 0);
+       
+       if ($database_exists eq 1){
+
+               # The database does not exist, so return an error.
+
+               kiriwrite_error("databasemissingfile");
+
+       }
+               
+       if ($database_permissions eq 1){
+
+               # The database permissions are invalid, so return
+               # an error.
+
+               kiriwrite_error("databaseinvalidpermissions");
+
+       }
+
+       # Check if the file list array has any values and return
+       # an error if it doesn't.
+
+       if (!@filelist){
+
+               # The page list really is blank so return
+               # an error.
+
+               kiriwrite_error("nopagesselected");
+       }
+
+       # Check if the database filename is valid and return an error if
+       # it isn't.
+
+       my $pagedatabase_filename_check = kiriwrite_variablecheck($database, "filename", 0, 1);
+
+       if ($pagedatabase_filename_check eq 1){
+
+               # The database filename is blank, so return an error.
+
+               kiriwrite_error("blankdatabasepageadd");
+
+       } elsif ($pagedatabase_filename_check eq 2){
+
+               # The database filename is invalid, so return an error.
+
+               kiriwrite_error("databasefilenameinvalid");
+
+       }
+       
+       # Check the length the database name and return an error if it's
+       # too long.
+
+       my $pagedatabase_length_check   = kiriwrite_variablecheck($database, "maxlength", 64, 1);
+
+       if ($pagedatabase_length_check eq 1){
+
+               # The database name is too long, so return an error.
+
+               kiriwrite_error("databasefilenametoolong");
+
+       }
+
+       # Check if the confirm value is blank and if it is, then
+       # set it to 0.
+
+       if (!$confirm){
+
+               # The confirm value is blank so set the confirm value
+               # to 0.
+
+               $confirm = 0;
+
+       }
+
+       if ($confirm eq 1){
+
+               # The action to delete multiple pages from the database has
+               # been confirmed.
+
+               # Load the SQLite Database and get info about the database.
+
+               my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+               my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("databasefileinvalid");
+               $string_handle->execute();
+
+               my @database_info       = $string_handle->fetchrow_array();
+               my $database_name       = $database_info[0];
+
+               # Define some variables for later.
+
+               my @database_page;
+               my $filelist_filename;
+               my $deleted_list;
+               my $page_name;
+               my $page_found = 0;
+
+               $deleted_list = "";
+
+               foreach $filelist_filename (@filelist){
+
+                       # Check if the page exists and skip to the next
+                       # file if it doesn't exist.
+
+                       $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $filelist_filename . '\' LIMIT 1');
+                       $string_handle->execute();
+
+                       while (@database_page = $string_handle->fetchrow_array()){
+                               $page_found = 1;
+                       }
+
+                       if ($page_found eq 0){
+
+                               next;
+
+                       }
+
+                       # Get the page name.
+
+                       $string_handle->execute();
+                       @database_page  = $string_handle->fetchrow_array();
+                       $page_name      = $database_page[1];
+
+                       # Delete the page.
+
+                       $string_handle  = $database_handle->prepare('DELETE FROM kiriwrite_database_pages WHERE filename = \'' . $filelist_filename  . '\'');
+                       $string_handle->execute();
+
+                       # Append the page name and page filename to the list
+                       # of deleted pages.
+
+                       $deleted_list   = $deleted_list . kiriwrite_convert($page_name, "normal_display") . " (" . $filelist_filename . ")" . "<br>";
+                       $page_found = 0;
+
+               }
+
+               $string_handle  = $database_handle->prepare('VACUUM');
+               $string_handle->execute();
+
+               my $database_out        = kiriwrite_convert($database, "normal_display");
+               my $database_name_out   = kiriwrite_convert($database_name, "normal_display");
+
+               $pagedata = "<h2>Selected pages deleted</h2>";
+               $pagedata = $pagedata . "The following pages were deleted from the '" . $database_name_out . "' database:<br><br>";
+               $pagedata = $pagedata . "<div class=\"datalist\">";
+               $pagedata = $pagedata . $deleted_list;
+               $pagedata = $pagedata . "</div><br>";
+               $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_out . "\">Return to the page list for the '" . $database_name_out . "' database.</a>";
+
+               return $pagedata;
+
+       } elsif ($confirm eq 0){
+
+               # The action to delete multiple pages from the database has
+               # not been confirmed, so write a form asking the user to confirm
+               # the deletion of those pages.
+
+               # Load the SQLite Database and get info about the database.
+
+               my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+               my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("databasefileinvalid");
+               $string_handle->execute();
+
+               my @database_info       = $string_handle->fetchrow_array();
+               my $database_name       = $database_info[0];
+
+               # Define some variables for later.
+
+               my @page_info;
+               my @pagenames;
+               my @filenames;
+               my $pagename;
+               my $filelist_filename;
+               my $filelist_filename_sql;
+               my $database_name_out;
+               my $pagenameslist;
+               my $pagenameslist_out;
+               my $pageseek = 0;
+               my $pagefound = 0;
+
+               # Process each filename given.
+
+               foreach $filelist_filename (@filelist){
+
+                       $filelist_filename_sql  = kiriwrite_convert($filelist_filename, "kiriwrite");
+                       $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $filelist_filename . '\' LIMIT 1') or kiriwrite_error("databasefileinvalid");
+
+                       $string_handle->execute();
+
+                       # Check if the filename given exists and if it
+                       # doesn't then skip this filename and go onto
+                       # the next filename.
+
+                       while (@page_info = $string_handle->fetchrow_array()){
+
+                               $pagefound = 1;
+
+                       }
+                       
+                       if ($pagefound eq 0){
+
+                               next;
+
+                       }
+
+                       # Get the data again.
+
+                       $string_handle->execute();
+                       @page_info      = $string_handle->fetchrow_array();
+
+                       # Add the page name and file name to their seperate
+                       # arrays.
+
+                       $pagenames[$pageseek]   = $page_info[1];
+                       $filenames[$pageseek]   = $page_info[0];
+
+                       # Increment the page seek counter and reset the
+                       # page found value.
+
+                       $pageseek++;
+                       $pagefound = 0;
+
+               }
+
+               $pageseek = 0;
+
+               $pagenameslist = "";
+
+               foreach $pagename (@pagenames){
+
+                       if (!$pagename){
+
+                               $pagenameslist = $pagenameslist . "<i>No page name</i> (" . $filenames[$pageseek] . ")<br>";                            
+
+                       } else {
+
+                               $pagenameslist = $pagenameslist . kiriwrite_convert($pagename, "normal_display") . " (" . kiriwrite_convert($filenames[$pageseek], "normal_display") . ")<br>";
+
+                       }
+
+                       $pageseek++;
+
+               }
+
+               # Check if any files were selected and return
+               # an error if there wasn't.
+
+               if ($pageseek eq 0){
+
+                       # No pages were selected so return an error.
+
+                       kiriwrite_error("nopagesselected");
+
+               }
+
+               # Convert the values so that they display properly.
+
+               $database_name_out      = kiriwrite_convert($database_name, "normal_display");
+               my $database_out                = kiriwrite_convert($database, "normal_display");
+
+               # Write the form for displaying pages.
+
+               $pagedata = "<h2>Delete multiple pages</h2>";
+               $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"page\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"multidelete\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"database\" value=\"" . $database_out . "\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"count\" value=\"" . $pageseek . "\">";
+
+               $pageseek = 1;
+
+               foreach $filelist_filename (@filenames){
+
+                       $pagedata = $pagedata . "<input type=\"hidden\" name=\"name[" . $pageseek . "]\" value=\"on\">";
+                       $pagedata = $pagedata . "<input type=\"hidden\" name=\"id[" . $pageseek . "]\" value=\"" . $filenames[$pageseek - 1] . "\">";
+
+                       $pageseek++;
+
+               }
+
+               
+
+               $pagedata = $pagedata . "Are you sure you want to delete the selected pages below from the '" . $database_name_out . "' database?<br><br>";
+               $pagedata = $pagedata . "<div class=\"datalist\">" . $pagenameslist . "</div><br>";
+               $pagedata = $pagedata . "<input type=\"submit\" value=\"Yes, delete selected\"> | <a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_out . "\">No, return to the list for '" . $database_name_out . "' database.</a>";
+               $pagedata = $pagedata . "</form>";
+
+               return $pagedata;
+
+       } else {
+
+               # A confirm value other than 0 or 1 is given, so
+               # return an error.
+
+               kiriwrite_error("invaildvalue");
+
+       }
+
+}
+
+sub kiriwrite_page_multimove{
+#################################################################################
+# kiriwrite_page_multimove: Move several pages from one database to another    #
+# database.                                                                    #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_page_multimove(database, newdatabase, confirm, filelist);          #
+#                                                                              #
+# database     Specifies the database to move the selected pages from.         #
+# newdatabase  Specifies the database to move the selected pages to.           #
+# confirm      Confirms the action to move the pages from one database to      #
+#              another.                                                        #
+# filelist     Specifies the list of pages to move.                            #
+#################################################################################
+
+       # Get the values that were passed to the subroutine.
+
+       my ($database, $newdatabase, $confirm, @filelist) = @_;
+
+       # Load the required Perl modules.
+
+       use DBI;
+
+       # Define a variable for later.
+
+       my $pagedata = "";
+
+       # Check if the file list is blank and return an error
+       # if it is.
+
+       if (!@filelist){
+
+               # The file list really is blank so return
+               # an error.
+
+               kiriwrite_error("nopagesselected");
+
+       }
+
+       # Check if the file permissions on the original database
+       # are valid and return an error if they aren't.
+
+       my $database_exists             = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+       my $database_permissions        = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db', 1, 1, 0);
+
+       if ($database_exists eq 1){
+
+               # The database does not exist, so return an error.
+
+               kiriwrite_error("oldmovedatabasedoesnotexist");
+
+       }
+               
+       if ($database_permissions eq 1){
+
+               # The database permissions are invalid, so return
+               # an error.
+
+               kiriwrite_error("oldmovedatabasefileinvalidpermissions");
+
+       }
+
+       # Check if the confirm value is blank and if it is then
+       # set the confirm value to 0.
+
+       if (!$confirm){
+
+               $confirm = 0;
+
+       }
+
+       if ($confirm eq 1){
+
+               # The action to move several pages from one database
+               # to another has been confirmed.
+
+               # Check if the database that the pages are moving from 
+               # is the same as the database the pages are moving to.
+               # Return an error if it is.
+
+               if ($database eq $newdatabase){
+
+                       # The database that the pages are moving from
+                       # and the database the pages are moving to
+                       # is the same, so return an error.
+
+                       kiriwrite_error("databasemovesame");
+
+               }
+
+               # Check that the new database exists and the permissions
+               # for the new database are valid. 
+
+               $database_exists                = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $newdatabase . '.db');
+               $database_permissions           = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $newdatabase . '.db', 1, 1, 0);              
+
+               if ($database_exists eq 1){
+
+                       # The database does not exist, so return an error.
+
+                       kiriwrite_error("newmovedatabasedoesnotexist");
+
+               }
+               
+               if ($database_permissions eq 1){
+
+                       # The database permissions are invalid, so return
+                       # an error.
+
+                       kiriwrite_error("newmovedatabasefileinvalidpermissions");
+
+               }
+
+               # Define some values for later.
+
+               my @olddatabase_info;
+               my @olddatabase_page;
+               my @newdatabase_info;
+               my @newdatabase_page;
+
+               my $filename;
+               my $filename_sql;
+               my $filename_out;
+
+               my $olddatabase_database_handle;
+               my $olddatabase_string_handle;
+               my $olddatabase_name;
+               my $olddatabase_name_out;
+               my $olddatabase_out;
+               my $newdatabase_database_handle;
+               my $newdatabase_string_handle;
+               my $newdatabase_name;
+               my $newdatabase_name_out;
+               my $newdatabase_out;
+
+               my $warninglist = "";
+               my $movedlist = "";
+
+               my $page_filename;
+               my $page_filename_sql;
+               my $page_filename_out;
+               my $page_name;
+               my $page_name_sql;
+               my $page_name_out;
+               my $page_description;
+               my $page_description_sql;
+               my $page_section;
+               my $page_section_sql;
+               my $page_template;
+               my $page_template_sql;
+               my $page_data;
+               my $page_data_sql;
+               my $page_settings;
+               my $page_settings_sql;
+               my $page_lastmodified;
+               my $page_lastmodified_sql;
+
+               my $page_found = 0;
+
+               # Check if the database filename is valid and return an error if
+               # it isn't.
+
+               my $newpagedatabase_filename_check = kiriwrite_variablecheck($newdatabase, "filename", 0, 1);
+
+               if ($newpagedatabase_filename_check eq 1){
+
+                       # The database filename is blank, so return an error.
+
+                       kiriwrite_error("blankdatabasepageadd");
+
+               } elsif ($newpagedatabase_filename_check eq 2){
+
+                       # The database filename is invalid, so return an error.
+
+                       kiriwrite_error("databasefilenameinvalid");
+
+               }
+
+               # Load the old and new SQLite databases.
+
+               $olddatabase_database_handle    = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+               $newdatabase_database_handle    = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $newdatabase . '.db');
+
+               # Get the database information from both databases.
+
+               $olddatabase_string_handle      = $olddatabase_database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("oldmovedatabasefileinvalid");
+               $newdatabase_string_handle      = $newdatabase_database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("newmovedatabasefileinvalid");
+               $olddatabase_string_handle->execute();
+               $newdatabase_string_handle->execute();
+
+               @olddatabase_info       = $olddatabase_string_handle->fetchrow_array();
+               @newdatabase_info       = $newdatabase_string_handle->fetchrow_array();
+
+               $olddatabase_name       = $olddatabase_info[0];
+               $newdatabase_name       = $newdatabase_info[0];
+
+               # Convert the database names so that they can be displayed
+               # properly.
+
+               $olddatabase_name_out   = kiriwrite_convert($olddatabase_name, "normal_display");
+               $newdatabase_name_out   = kiriwrite_convert($newdatabase_name, "normal_display");
+               $olddatabase_out        = kiriwrite_convert($database, "normal_display");
+               $newdatabase_out        = kiriwrite_convert($newdatabase, "normal_display");
+
+               # Get each file in the old database, get the file values,
+               # put them into the new database and delete the pages
+               # from the old database.
+
+               foreach $filename (@filelist){
+
+                       # Check if the filename exists in the old database. 
+                       # If the filename does not exist then write
+                       # a warning and process the next file.
+
+                       $filename_sql                   = kiriwrite_convert($filename, "kiriwrite");
+                       $filename_out                   = kiriwrite_convert($filename, "normal_display");
+                       $olddatabase_string_handle      = $olddatabase_database_handle->prepare('SELECT * FROM kiriwrite_database_pages where filename = \'' . $filename_sql . '\' LIMIT 1');
+                       $olddatabase_string_handle->execute();
+
+                       $page_found = 0;
+
+                       while (@olddatabase_page = $olddatabase_string_handle->fetchrow_array()){
+
+                               # The page in the old database does exist so 
+                               # set the value to 1.
+
+                               $page_found = 1;
+
+                       }
+
+                       # See if the page was found and write a warning if it
+                       # wasn't.
+
+                       if ($page_found eq 0){
+
+                               # The page was not found. Write a warning and
+                               # process the next page.
+
+                               $filename_out   = kiriwrite_convert($filename, "normal_display");
+                               $warninglist    = $warninglist . "The page with the filename '" . $filename_out . "' could not be found in the '" . $olddatabase_name_out . "' database. Page skipped.<br>";
+                               next;
+
+                       }
+
+                       # Check if the filename exists in the new database.
+                       # If the filename does exist then write
+                       # a warning and process the next file.
+
+                       $newdatabase_string_handle      = $newdatabase_database_handle->prepare('SELECT * FROM kiriwrite_database_pages where filename = \'' . $filename_sql . '\' LIMIT 1');
+                       $newdatabase_string_handle->execute();
+
+                       $page_found = 0;
+
+                       while (@newdatabase_page = $newdatabase_string_handle->fetchrow_array()){
+
+                               # The page in the old database does exist so 
+                               # set the value to 1.
+
+                               $page_found = 1;
+
+                       }
+
+                       # See if the page was found and write a warning if it
+                       # wasn't.
+
+                       if ($page_found eq 1){
+
+                               # The page was not found. Write a warning and
+                               # process the next page.
+
+                               $filename_out   = kiriwrite_convert($filename, "normal_display");
+                               $warninglist    = $warninglist . "The page with the filename '" . $filename_out . "' already exists in '" . $olddatabase_name_out . "' database. Page skipped.<br>";
+                               next;
+
+                       }
+
+
+                       # Get the information about the page.
+
+                       $olddatabase_string_handle->execute();
+                       @olddatabase_page       = $olddatabase_string_handle->fetchrow_array();
+                       $page_filename          = $olddatabase_page[0];
+                       $page_name              = $olddatabase_page[1];
+                       $page_description       = $olddatabase_page[2];
+                       $page_section           = $olddatabase_page[3];
+                       $page_template          = $olddatabase_page[4];
+                       $page_data              = $olddatabase_page[5];
+                       $page_settings          = $olddatabase_page[6];
+                       $page_lastmodified      = $olddatabase_page[7];
+
+                       # Convert the values so that they can be processed
+                       # properly.
+
+                       $page_filename_sql      = kiriwrite_convert($page_filename, "kiriwrite");
+                       $page_name_sql          = kiriwrite_convert($page_name, "kiriwrite");
+                       $page_description_sql   = kiriwrite_convert($page_description, "kiriwrite");
+                       $page_section_sql       = kiriwrite_convert($page_section, "kiriwrite");
+                       $page_template_sql      = kiriwrite_convert($page_template, "kiriwrite");
+                       $page_data_sql          = kiriwrite_convert($page_data, "kiriwrite");
+                       $page_settings_sql      = kiriwrite_convert($page_settings, "kiriwrite");
+                       $page_lastmodified_sql  = kiriwrite_convert($page_lastmodified, "kiriwrite");
+
+                       $page_filename_out      = kiriwrite_convert($page_filename, "normal_display");
+                       $page_name_out          = kiriwrite_convert($page_name, "normal_display");
+
+                       # Add the page to the new database.
+
+                       $newdatabase_string_handle      = $newdatabase_database_handle->prepare('INSERT INTO kiriwrite_database_pages VALUES(
+                               \'' . $page_filename_sql . '\',
+                               \'' . $page_name_sql . '\',
+                               \'' . $page_description_sql . '\',
+                               \'' . $page_section_sql . '\',
+                               \'' . $page_template_sql . '\',
+                               \'' . $page_data_sql . '\',
+                               \'' . $page_settings_sql . '\',
+                               \'' . $page_lastmodified_sql . '\'
+                       )');
+                       $newdatabase_string_handle->execute();
+
+                       # Delete the page from the old database.
+
+                       $olddatabase_string_handle      = $olddatabase_database_handle->prepare('DELETE FROM kiriwrite_database_pages WHERE filename = \'' . $filename_sql . '\'');
+                       $olddatabase_string_handle->execute();
+
+                       # Append the moved page (filename and name) to the list of
+                       # moved pages.
+
+                       if (!$page_name_out){
+
+                               $page_name_out = "<i>No Name</i>";
+
+                       }
+
+                       $movedlist = $movedlist . $page_name_out . " (" . $filename_out . ")" . "<br>";
+
+               }
+
+               # Write out a message saying that the pages were moved (if any)
+               # to the new database (and any warnings given).
+
+               $pagedata = $pagedata . "<h2>Move multiple pages</h2>";
+
+               if ($movedlist){
+               
+               $pagedata = $pagedata . "The following pages from the '" . $olddatabase_name_out . "' database were moved to the '" . $newdatabase_name_out . "' database:<br><br>";
+               $pagedata = $pagedata . "<div class=\"datalist\">";
+               $pagedata = $pagedata . $movedlist;
+               $pagedata = $pagedata . "</div><br><br>";
+               
+               } else {
+
+                       $pagedata = $pagedata . "No pages were moved from the '" . $olddatabase_name_out  . "' database to the '" . $newdatabase_name_out . "' database.<br><br>";
+
+               }
+
+               if ($warninglist){
+
+                       $pagedata = $pagedata . "The following errors/warnings have occured while moving the pages:<br><br>";
+                       $pagedata = $pagedata . "<div class=\"datalist\">";
+                       $pagedata = $pagedata . $warninglist;
+                       $pagedata = $pagedata . "</div><br><br>";
+
+               }
+
+               $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $olddatabase_out . "\">Return to the page list for the '" . $olddatabase_name_out . "' database.</a> | <a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $newdatabase_out . "\">View the page list for the '" . $newdatabase_name_out . "' database.</a>";
+
+               return $pagedata;
+
+       } elsif ($confirm eq 0) {
+
+               # The action to move several pages from one database
+               # to another has not been confirmed so write a form.
+
+               # Load the SQLite database and get the needed
+               # information about the database.
+
+               my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+               my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("databasefileinvalid");
+               $string_handle->execute();
+
+               my @database_info       = $string_handle->fetchrow_array();
+               my $database_name       = $database_info[0];
+
+               # Define some values for later.
+
+               my $database_info;
+               my @page_info;
+               my @pagenames;
+               my @filenames;
+               my $data_file;
+               my $data_file_length;
+               my $database_list;
+               my $database_filename;
+               my $filename;
+               my $filename_out;
+               my $filelist_filename_sql;
+               my $filelist_filename;
+               my $pagelist_formdata;
+               my $newdatabase_filename;
+               my $newdatabase_filename_out;
+               my $newdatabase_name;
+               my $newdatabase_name_out;
+               my $pagelist;
+               my $pagename;
+               my $pageseek    = 0;
+               my $dbseek      = 0;
+               my $pagefound   = 0;
+
+               # Process each filename given.
+
+               foreach $filelist_filename (@filelist){
+
+                       $filelist_filename_sql  = kiriwrite_convert($filelist_filename, "kiriwrite");
+                       $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $filelist_filename . '\' LIMIT 1') or kiriwrite_error("databasefileinvalid");
+
+                       $string_handle->execute();
+
+                       # Check if the filename given exists and if it
+                       # doesn't then skip this filename and go onto
+                       # the next filename.
+
+                       while (@page_info = $string_handle->fetchrow_array()){
+
+                               $pagefound = 1;
+
+                       }
+                       
+                       if ($pagefound eq 0){
+
+                               next;
+
+                       }
+
+                       # Get the data again.
+
+                       $string_handle->execute();
+                       @page_info      = $string_handle->fetchrow_array();
+
+                       # Add the page name and file name to their seperate
+                       # arrays.
+
+                       $pagenames[$pageseek]   = $page_info[1];
+                       $filenames[$pageseek]   = $page_info[0];
+
+                       # Increment the page seek counter and reset the
+                       # page found value.
+
+                       $pageseek++;
+                       $pagefound = 0;
+
+               }
+
+               # Check if any pages exust and return an error if
+               # there wasn't.
+
+               if ($pageseek eq 0){
+
+                       # None of the selected pages exist, so return
+                       # an error.
+
+                       kiriwrite_error("nopagesselected");
+
+               }
+
+               # Create the page list of files to move.
+
+               $pageseek               = 1;
+               $pagelist               = "";
+               $pagelist_formdata      = "";
+
+               foreach $filename (@filenames){
+
+
+
+                       $pagename       = $pagenames[$pageseek - 1];
+
+                       # Check if the page name is blank and if it is then say
+                       # no name.
+
+                       if (!$pagename){
+
+                               # The page name is blank.
+
+                               $pagelist       = $pagelist . "<i>No Name</i>" . " (" . $filename . ")<br>";
+
+                       } else {
+
+                               # Append the page name and filename to the page list. 
+
+                               $pagelist       = $pagelist . kiriwrite_convert($pagename, "normal_display") . " (" . $filename . ")<br>";
+
+                       }
+
+                       # Append the form data to the page list form data.
+
+                       $filename_out           = kiriwrite_convert($filename, "normal_display");
+
+                       $pagelist_formdata      = $pagelist_formdata . "<input type=\"hidden\" name=\"name[" . $pageseek . "]\" value=\"on\">";
+                       $pagelist_formdata      = $pagelist_formdata . "<input type=\"hidden\" name=\"id[" . $pageseek . "]\" value=\"" . $filename . "\">";
+
+                       $pageseek++;
+
+               }
+
+               # Get the database filenames and names.
+
+               # Check the directory to make sure the permissions are settings are valid
+               # and return an error if the permission settings are invalid.
+
+               my $data_directory_permissions = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"}, 1, 0);
+
+               if ($data_directory_permissions eq 1){
+
+                       # The data directory has invalid permissions set, so return an error.
+
+                       kiriwrite_error("datadirectoryinvalidpermissions");
+
+               }
+
+               # Open the directory and get the list of all files ending with .xml and
+               # put them into the data_directory array.
+
+               opendir(DATADIR, $kiriwrite_config{"directory_data_db"});
+               my @data_directory = grep /m*\.db/, readdir(DATADIR);
+               closedir(DATADIR);
+
+               # Process each database to get the database name.
+
+               $database_list = "<select name=\"newdatabase\">";
+
+               foreach $data_file (@data_directory){
+
+                       # Get the length of the filename.
+
+                       $data_file_length       = length($data_file);
+                       
+                       # Remove the last three characters from the filename.
+
+                       $data_file              = substr($data_file, 0, $data_file_length - 3);
+
+                       # Check if the permissions are valid before trying
+                       # to load the database.
+
+                       $database_filename      = $kiriwrite_config{"directory_data_db"} . '/' . $data_file . '.db';
+                       $database_permissions   = kiriwrite_filepermissions($database_filename, 1, 0, 0);
+
+                       if ($database_permissions eq 1){
+
+                               # If the database has invalid permissions set then
+                               # process the next database.
+
+                               next;
+
+                       }
+
+                       # Load the SQLite database.
+               
+                       $database_handle = DBI->connect("dbi:SQLite:dbname=" . $database_filename);
+
+                       # Query the SQLite database or return an error (meaning that the database is in
+                       # a invalid format), if it can't then process the next database.
+
+                       $string_handle = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or next;
+
+                       $string_handle->execute();
+                       @database_info = $string_handle->fetchrow_array();
+
+                       # Get the values from the query.
+
+                       $newdatabase_name       = $database_info[0];
+
+                       # Convert the values so that they can be displayed
+                       # properly.
+
+                       $newdatabase_filename_out       = kiriwrite_convert($data_file, "normal_display");
+                       $newdatabase_name_out           = kiriwrite_convert($newdatabase_name, "normal_display");
+
+                       # Append the database filename and name to the list of databases
+                       # to move the pages to.
+
+                       $database_list = $database_list . "<option value=\"" . $newdatabase_filename_out . "\">" . $newdatabase_name_out . "</option>";
+
+               }
+
+               $database_list = $database_list . "</select>";
+
+               # Convert some values so that they display properly.
+
+               my $database_name_out   = kiriwrite_convert($database_name, "normal_display");
+               my $database_out        = kiriwrite_convert($database, "normal_display");
+
+               # Write out the form.
+
+               $pagedata = "<h2>Move selected pages</h2>";
+               $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"page\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"multimove\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"database\" value=\"" . $database_out . "\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"count\" value=\"" . ($pageseek - 1) . "\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
+               $pagedata = $pagedata . $pagelist_formdata;
+               $pagedata = $pagedata . "Which database do you want to move the following pages from the '" . $database_name_out . "' database to?<br><br>";
+               $pagedata = $pagedata . "<div class=\"datalist\">";
+               $pagedata = $pagedata . $pagelist;
+               $pagedata = $pagedata . "</div><br>";
+               $pagedata = $pagedata . "Move pages to: " . $database_list . "<br><br>";
+               $pagedata = $pagedata . "<input type=\"submit\" value=\"Move pages to the selected database.\"> | <a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_out . "\">Return to the page list for the '" . $database_name_out . "' database.</a>";
+               $pagedata = $pagedata . "</form>";
+
+               return $pagedata;
+
+       } else {
+
+               # The confirm value is other than 0 or 1, so return
+               # an error.
+
+               kiriwrite_error("invalidvariable");
+
+       }
+
+
+}
+
+
+sub kiriwrite_page_multicopy{
+#################################################################################
+# kiriwrite_page_multicopy: Copy several pages from one database to another    #
+# database.                                                                    #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_page_multicopy(database, newdatabase, confirm, filelist);          #
+#                                                                              #
+# database     Specifies the database to copy the selected pages from.         #
+# newdatabase  Specifies the database to copy the selected page to.            #
+# confirm      Confirms the action to copy the pages.                          #
+# filelist     A list of filenames to copy in an array.                        #
+#################################################################################
+
+       # Get the values that were passed to the subroutine.
+
+       my ($database, $newdatabase, $confirm, @filelist) = @_;
+
+       # Load the required Perl modules.
+
+       use DBI;
+
+       # Define a variable for later.
+
+       my $pagedata = "";
+
+       # Check if the file list is blank and return an error
+       # if it is.
+
+       if (!@filelist){
+
+               # The file list really is blank so return
+               # an error.
+
+               kiriwrite_error("nopagesselected");
+
+       }
+
+       # Check if the file permissions on the original database
+       # are valid and return an error if they aren't.
+
+       my $database_exists             = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+       my $database_permissions        = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db', 1, 0);
+
+       if ($database_exists eq 1){
+
+               # The database does not exist, so return an error.
+
+               kiriwrite_error("oldcopydatabasedoesnotexist");
+
+       }
+               
+       if ($database_permissions eq 1){
+
+               # The database permissions are invalid, so return
+               # an error.
+
+               kiriwrite_error("oldcopydatabasefilenameinvalidpermissions");
+
+       }
+
+       # Check if the confirm value is blank and if it is then
+       # set the confirm value to 0.
+
+       if (!$confirm){
+
+               $confirm = 0;
+
+       }
+
+       # Check if the database filename is valid and return an error if
+       # it isn't.
+
+       my $pagedatabase_filename_check = kiriwrite_variablecheck($database, "filename", 0, 1);
+
+       if ($pagedatabase_filename_check eq 1){
+
+               # The database filename is blank, so return an error.
+
+               kiriwrite_error("blankdatabasepageadd");
+
+       } elsif ($pagedatabase_filename_check eq 2){
+
+               # The database filename is invalid, so return an error.
+
+               kiriwrite_error("databasefilenameinvalid");
+
+       }
+
+       if ($confirm eq 1){
+
+               # The action to copy several pages from one database
+               # to another has been confirmed.
+
+               # Check if the database that the pages are copied from 
+               # is the same as the database the pages are copied to.
+               # Return an error if it is.
+
+               if ($database eq $newdatabase){
+
+                       # The database that the pages are being copied from
+                       # and the database that the pages are copied to
+                       # is the same, so return an error.
+
+                       kiriwrite_error("databasecopysame");
+
+               }
+
+               # Check that the new database exists and the permissions
+               # for the new database are valid. 
+
+               $database_exists                = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $newdatabase . '.db');
+               $database_permissions           = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $newdatabase . '.db', 1, 1, 0);              
+
+               if ($database_exists eq 1){
+
+                       # The database does not exist, so return an error.
+
+                       kiriwrite_error("newcopydatabasedoesnotexist");
+
+               }
+               
+               if ($database_permissions eq 1){
+
+                       # The database permissions are invalid, so return
+                       # an error.
+
+                       kiriwrite_error("newcopydatabasefileinvalidpermissions");
+
+               }
+
+               # Define some values for later.
+
+               my @olddatabase_info;
+               my @olddatabase_page;
+               my @newdatabase_info;
+               my @newdatabase_page;
+
+               my $filename;
+               my $filename_sql;
+               my $filename_out;
+
+               my $olddatabase_database_handle;
+               my $olddatabase_string_handle;
+               my $olddatabase_name;
+               my $olddatabase_name_out;
+               my $olddatabase_out;
+               my $newdatabase_database_handle;
+               my $newdatabase_string_handle;
+               my $newdatabase_name;
+               my $newdatabase_name_out;
+               my $newdatabase_out;
+
+               my $warninglist = "";
+               my $copiedlist = "";
+
+               my $page_filename;
+               my $page_filename_sql;
+               my $page_filename_out;
+               my $page_name;
+               my $page_name_sql;
+               my $page_name_out;
+               my $page_description;
+               my $page_description_sql;
+               my $page_section;
+               my $page_section_sql;
+               my $page_template;
+               my $page_template_sql;
+               my $page_data;
+               my $page_data_sql;
+               my $page_settings;
+               my $page_settings_sql;
+               my $page_lastmodified;
+               my $page_lastmodified_sql;
+
+               my $page_found = 0;
+
+               # Check if the database filename is valid and return an error if
+               # it isn't.
+
+               my $newpagedatabase_filename_check = kiriwrite_variablecheck($newdatabase, "filename", 0, 1);
+
+               if ($newpagedatabase_filename_check eq 1){
+
+                       # The database filename is blank, so return an error.
+
+                       kiriwrite_error("blankdatabasepageadd");
+
+               } elsif ($newpagedatabase_filename_check eq 2){
+
+                       # The database filename is invalid, so return an error.
+
+                       kiriwrite_error("databasefilenameinvalid");
+
+               }
+
+               # Load the old and new SQLite databases.
+
+               $olddatabase_database_handle    = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+               $newdatabase_database_handle    = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $newdatabase . '.db');
+
+               # Get the database information from both databases.
+
+               $olddatabase_string_handle      = $olddatabase_database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("oldcopydatabasefileinvalid");
+               $newdatabase_string_handle      = $newdatabase_database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("newcopydatabasefileinvalid");
+               $olddatabase_string_handle->execute();
+               $newdatabase_string_handle->execute();
+
+               @olddatabase_info       = $olddatabase_string_handle->fetchrow_array();
+               @newdatabase_info       = $newdatabase_string_handle->fetchrow_array();
+
+               $olddatabase_name       = $olddatabase_info[0];
+               $newdatabase_name       = $newdatabase_info[0];
+
+               # Convert the database names so that they can be displayed
+               # properly.
+
+               $olddatabase_name_out   = kiriwrite_convert($olddatabase_name, "normal_display");
+               $newdatabase_name_out   = kiriwrite_convert($newdatabase_name, "normal_display");
+               $olddatabase_out        = kiriwrite_convert($database, "normal_display");
+               $newdatabase_out        = kiriwrite_convert($newdatabase, "normal_display");
+
+               # Get each file in the old database, get the file values,
+               # put them into the new database.
+
+               foreach $filename (@filelist){
+
+                       # Check if the filename exists in the old database. 
+                       # If the filename does not exist then write
+                       # a warning and process the next file.
+
+                       $filename_sql                   = kiriwrite_convert($filename, "kiriwrite");
+                       $filename_out                   = kiriwrite_convert($filename, "normal_display");
+                       $olddatabase_string_handle      = $olddatabase_database_handle->prepare('SELECT * FROM kiriwrite_database_pages where filename = \'' . $filename_sql . '\' LIMIT 1');
+                       $olddatabase_string_handle->execute();
+
+                       $page_found = 0;
+
+                       while (@olddatabase_page = $olddatabase_string_handle->fetchrow_array()){
+
+                               # The page in the old database does exist so 
+                               # set the value to 1.
+
+                               $page_found = 1;
+
+                       }
+
+                       # See if the page was found and write a warning if it
+                       # wasn't.
+
+                       if ($page_found eq 0){
+
+                               # The page was not found. Write a warning and
+                               # process the next page.
+
+                               $filename_out   = kiriwrite_convert($filename, "normal_display");
+                               $warninglist    = $warninglist . "The page with the filename '" . $filename_out . "' could not be found in the '" . $olddatabase_name_out . "' database. Page skipped.<br>";
+                               next;
+
+                       }
+
+                       # Check if the filename exists in the new database.
+                       # If the filename does exist then write
+                       # a warning and process the next file.
+
+                       $newdatabase_string_handle      = $newdatabase_database_handle->prepare('SELECT * FROM kiriwrite_database_pages where filename = \'' . $filename_sql . '\' LIMIT 1');
+                       $newdatabase_string_handle->execute();
+
+                       $page_found = 0;
+
+                       while (@newdatabase_page = $newdatabase_string_handle->fetchrow_array()){
+
+                               # The page in the old database does exist so 
+                               # set the value to 1.
+
+                               $page_found = 1;
+
+                       }
+
+                       # See if the page was found and write a warning if it
+                       # wasn't.
+
+                       if ($page_found eq 1){
+
+                               # The page was not found. Write a warning and
+                               # process the next page.
+
+                               $filename_out   = kiriwrite_convert($filename, "normal_display");
+                               $warninglist    = $warninglist . "The page with the filename '" . $filename_out . "' already exists in '" . $newdatabase_name_out . "' database. Page skipped.<br>";
+                               next;
+
+                       }
+
+
+                       # Get the information about the page.
+
+                       $olddatabase_string_handle->execute();
+                       @olddatabase_page       = $olddatabase_string_handle->fetchrow_array();
+                       $page_filename          = $olddatabase_page[0];
+                       $page_name              = $olddatabase_page[1];
+                       $page_description       = $olddatabase_page[2];
+                       $page_section           = $olddatabase_page[3];
+                       $page_template          = $olddatabase_page[4];
+                       $page_data              = $olddatabase_page[5];
+                       $page_settings          = $olddatabase_page[6];
+                       $page_lastmodified      = $olddatabase_page[7];
+
+                       # Convert the values so that they can be processed
+                       # properly.
+
+                       $page_filename_sql      = kiriwrite_convert($page_filename, "kiriwrite");
+                       $page_name_sql          = kiriwrite_convert($page_name, "kiriwrite");
+                       $page_description_sql   = kiriwrite_convert($page_description, "kiriwrite");
+                       $page_section_sql       = kiriwrite_convert($page_section, "kiriwrite");
+                       $page_template_sql      = kiriwrite_convert($page_template, "kiriwrite");
+                       $page_data_sql          = kiriwrite_convert($page_data, "kiriwrite");
+                       $page_settings_sql      = kiriwrite_convert($page_settings, "kiriwrite");
+                       $page_lastmodified_sql  = kiriwrite_convert($page_lastmodified, "kiriwrite");
+
+                       $page_filename_out      = kiriwrite_convert($page_filename, "normal_display");
+                       $page_name_out          = kiriwrite_convert($page_name, "normal_display");
+
+                       # Add the page to the new database.
+
+                       $newdatabase_string_handle      = $newdatabase_database_handle->prepare('INSERT INTO kiriwrite_database_pages VALUES(
+                               \'' . $page_filename_sql . '\',
+                               \'' . $page_name_sql . '\',
+                               \'' . $page_description_sql . '\',
+                               \'' . $page_section_sql . '\',
+                               \'' . $page_template_sql . '\',
+                               \'' . $page_data_sql . '\',
+                               \'' . $page_settings_sql . '\',
+                               \'' . $page_lastmodified_sql . '\'
+                       )');
+                       $newdatabase_string_handle->execute();
+
+                       # Append the copied page (filename and name) to the list of
+                       # copied pages.
+
+                       if (!$page_name_out){
+
+                               $page_name_out = "<i>No page name</i>";
+
+                       }
+
+                       $copiedlist = $copiedlist . $page_name_out . " (" . $filename_out . ")" . "<br>";
+
+               }
+
+               # Write out a message saying that the pages were moved (if any)
+               # to the new database (and any warnings given).
+
+               $pagedata = $pagedata . "<h2>Copy multiple pages</h2>";
+
+               if ($copiedlist){
+               
+               $pagedata = $pagedata . "The following pages from the '" . $olddatabase_name_out . "' database were copied to the '" . $newdatabase_name_out . "' database:<br><br>";
+               $pagedata = $pagedata . "<div class=\"datalist\">";
+               $pagedata = $pagedata . $copiedlist;
+               $pagedata = $pagedata . "</div><br><br>";
+               
+               } else {
+
+                       $pagedata = $pagedata . "No pages were copied from the '" . $olddatabase_name_out  . "' database to the '" . $newdatabase_name_out . "' database.<br><br>";
+
+               }
+
+               if ($warninglist){
+
+                       $pagedata = $pagedata . "The following errors/warnings have occured while copying the pages:<br><br>";
+                       $pagedata = $pagedata . "<div class=\"datalist\">";
+                       $pagedata = $pagedata . $warninglist;
+                       $pagedata = $pagedata . "</div><br><br>";
+
+               }
+
+               $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $olddatabase_out . "\">Return to the page list for the '" . $olddatabase_name_out . "' database.</a> | <a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $newdatabase_out . "\">View the page list for the '" . $newdatabase_name_out . "' database.</a>";
+
+               return $pagedata;
+
+       } elsif ($confirm eq 0) {
+
+               # The action to copy several pages from one database
+               # to another has not been confirmed so write a form.
+
+               # Load the SQLite database and get the needed
+               # information about the database.
+
+               my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+               my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("databasefileinvalid");
+               $string_handle->execute();
+
+               my @database_info       = $string_handle->fetchrow_array();
+               my $database_name       = $database_info[0];
+
+               # Define some values for later.
+
+               my $database_info;
+               my @page_info;
+               my @pagenames;
+               my @filenames;
+               my $data_file;
+               my $data_file_length;
+               my $database_list;
+               my $database_filename;
+               my $filename;
+               my $filename_out;
+               my $filelist_filename_sql;
+               my $filelist_filename;
+               my $pagelist_formdata;
+               my $newdatabase_filename;
+               my $newdatabase_filename_out;
+               my $newdatabase_name;
+               my $newdatabase_name_out;
+               my $pagelist;
+               my $pagename;
+               my $pageseek    = 0;
+               my $dbseek      = 0;
+               my $pagefound   = 0;
+
+               # Process each filename given.
+
+               foreach $filelist_filename (@filelist){
+
+                       $filelist_filename_sql  = kiriwrite_convert($filelist_filename, "kiriwrite");
+                       $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $filelist_filename . '\' LIMIT 1') or kiriwrite_error("databasefileinvalid");
+
+                       $string_handle->execute();
+
+                       # Check if the filename given exists and if it
+                       # doesn't then skip this filename and go onto
+                       # the next filename.
+
+                       while (@page_info = $string_handle->fetchrow_array()){
+
+                               $pagefound = 1;
+
+                       }
+                       
+                       if ($pagefound eq 0){
+
+                               next;
+
+                       }
+
+                       # Get the data again.
+
+                       $string_handle->execute();
+                       @page_info      = $string_handle->fetchrow_array();
+
+                       # Add the page name and file name to their seperate
+                       # arrays.
+
+                       $pagenames[$pageseek]   = $page_info[1];
+                       $filenames[$pageseek]   = $page_info[0];
+
+                       # Increment the page seek counter and reset the
+                       # page found value.
+
+                       $pageseek++;
+                       $pagefound = 0;
+
+               }
+
+               # Check if any pages exust and return an error if
+               # there wasn't.
+
+               if ($pageseek eq 0){
+
+                       # None of the selected pages exist, so return
+                       # an error.
+
+                       kiriwrite_error("nopagesselected");
+
+               }
+
+               # Create the page list of files to move.
+
+               $pageseek               = 1;
+               $pagelist               = "";
+               $pagelist_formdata      = "";
+
+               foreach $filename (@filenames){
+
+                       $pagename       = $pagenames[$pageseek - 1];
+
+                       # Check if the 
+
+                       if (!$pagename){
+
+                               # Write a message saying that there is no page name.
+
+                               $pagelist       = $pagelist . "<i>No Name</i>" . " (" . $filename . ")<br>";
+
+                       } else {
+
+                               # Append the page name and filename to the page list.                           
+
+                               $pagelist       = $pagelist . $pagename . " (" . $filename . ")<br>";
+
+                       }
+
+
+
+                       # Append the form data to the page list form data.
+
+                       $filename_out           = kiriwrite_convert($filename, "normal_display");
+
+                       $pagelist_formdata      = $pagelist_formdata . "<input type=\"hidden\" name=\"name[" . $pageseek . "]\" value=\"on\">";
+                       $pagelist_formdata      = $pagelist_formdata . "<input type=\"hidden\" name=\"id[" . $pageseek . "]\" value=\"" . $filename . "\">";
+
+                       $pageseek++;
+
+               }
+
+               # Get the database filenames and names.
+
+               # Check the directory to make sure the permissions are settings are valid
+               # and return an error if the permission settings are invalid.
+
+               my $data_directory_permissions = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"}, 1, 0);
+
+               if ($data_directory_permissions eq 1){
+
+                       # The data directory has invalid permissions set, so return an error.
+
+                       kiriwrite_error("datadirectoryinvalidpermissions");
+
+               }
+
+               # Open the directory and get the list of all files ending with .xml and
+               # put them into the data_directory array.
+
+               opendir(DATADIR, $kiriwrite_config{"directory_data_db"});
+               my @data_directory = grep /m*\.db/, readdir(DATADIR);
+               closedir(DATADIR);
+
+               # Process each database to get the database name.
+
+               $database_list = "<select name=\"newdatabase\">";
+
+               foreach $data_file (@data_directory){
+
+                       # Get the length of the filename.
+
+                       $data_file_length       = length($data_file);
+                       
+                       # Remove the last three characters from the filename.
+
+                       $data_file              = substr($data_file, 0, $data_file_length - 3);
+
+                       # Check if the permissions are valid before trying
+                       # to load the database.
+
+                       $database_filename      = $kiriwrite_config{"directory_data_db"} . '/' . $data_file . '.db';
+                       $database_permissions   = kiriwrite_filepermissions($database_filename, 1, 0, 0);
+
+                       if ($database_permissions eq 1){
+
+                               # If the database has invalid permissions set then
+                               # process the next database.
+
+                               next;
+
+                       }
+
+                       # Load the SQLite database.
+               
+                       $database_handle = DBI->connect("dbi:SQLite:dbname=" . $database_filename);
+
+                       # Query the SQLite database or return an error (meaning that the database is in
+                       # a invalid format), if it can't then process the next database.
+
+                       $string_handle = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or next;
+
+                       $string_handle->execute();
+                       @database_info = $string_handle->fetchrow_array();
+
+                       # Get the values from the query.
+
+                       $newdatabase_name       = $database_info[0];
+
+                       # Convert the values so that they can be displayed
+                       # properly.
+
+                       $newdatabase_filename_out       = kiriwrite_convert($data_file, "normal_display");
+                       $newdatabase_name_out           = kiriwrite_convert($newdatabase_name, "normal_display");
+
+                       # Append the database filename and name to the list of databases
+                       # to move the pages to.
+
+                       $database_list = $database_list . "<option value=\"" . $newdatabase_filename_out . "\">" . $newdatabase_name_out . "</option>";
+
+               }
+
+               $database_list = $database_list . "</select>";
+
+               # Convert some values so that they display properly.
+
+               my $database_name_out   = kiriwrite_convert($database_name, "normal_display");
+               my $database_out        = kiriwrite_convert($database, "normal_display");
+
+               # Write out the form.
+
+               $pagedata = "<h2>Copy selected pages</h2>";
+               $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"page\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"multicopy\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"database\" value=\"" . $database_out . "\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"count\" value=\"" . ($pageseek - 1) . "\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
+               $pagedata = $pagedata . $pagelist_formdata;
+               $pagedata = $pagedata . "Which database do you want to copy the following pages from the '" . $database_name_out . "' database to?<br><br>";
+               $pagedata = $pagedata . "<div class=\"datalist\">";
+               $pagedata = $pagedata . $pagelist;
+               $pagedata = $pagedata . "</div><br>";
+               $pagedata = $pagedata . "Copy pages to: " . $database_list . "<br><br>";
+               $pagedata = $pagedata . "<input type=\"submit\" value=\"Copy pages to the selected database.\"> | <a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_out . "\">Return to the page list for the '" . $database_name_out . "' database.</a>";
+               $pagedata = $pagedata . "</form>";
+
+               return $pagedata;
+
+       } else {
+
+               # The confirm value is other than 0 or 1, so return
+               # an error.
+
+               kiriwrite_error("invalidvariable");
+
+       }       
+
+}
+
+sub kiriwrite_page_multiedit{
+#################################################################################
+# kiriwrite_page_multiedit: Edit several pages from a database.                        #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_page_multiedit(database, newsection, altersection, newtemplate,    #
+#                              altertemplate, newsettings, altersettings       #
+#                              confirm, filelist);                             #
+#                                                                              #
+# database     Specifies the database to edit the pages from.                  #
+# newsection   Specifies the new section name to use on the selected pages.    #
+# altersection Specifies if the section name should be altered.                #
+# newtemplate  Specifies the new template filename to use on the selected      #
+#              pages.                                                          #
+# altertemplate        Specifies if the template filename should be altered.           #
+# newsettings  Specifies the new settings to use on the selected pages.        #
+# altersettings        Specifies if the settings should be altered.                    #
+# confirm      Confirms the action to edit the selected pages.                 #
+# filelist     The list of file names to edit.                                 #
+#################################################################################
+
+       # Get the values that were passed to the subroutine.
+
+       my ($database, $newsection, $altersection, $newtemplate, $altertemplate, $newsettings, $altersettings, $confirm, @filelist) = @_;
+
+       # Load the required Perl modules.
+
+       use DBI;
+
+       # Define a variable for later.
+
+       my $pagedata = "";
+
+       # Check if the file list is blank and return an error
+       # if it is.
+
+       if (!@filelist){
+
+               # The file list really is blank so return
+               # an error.
+
+               kiriwrite_error("nopagesselected");
+
+       }
+
+       # Check if the file permissions on the original database
+       # are valid and return an error if they aren't.
+
+       my $database_exists             = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+       my $database_permissions        = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db', 1, 1, 0);
+
+       if ($database_exists eq 1){
+
+               # The database does not exist, so return an error.
+
+               kiriwrite_error("databasemissingfile");
+
+       }
+               
+       if ($database_permissions eq 1){
+
+               # The database permissions are invalid, so return
+               # an error.
+
+               kiriwrite_error("databaseinvalidpermissions");
+
+       }
+
+       # Check if certain values are undefined and define them if
+       # they are.
+
+       if (!$altersection){
+
+               # The alter section value is blank, so set it to
+               # off.
+
+               $altersection   = "off";
+
+       }
+
+       if (!$altertemplate){
+
+               # The alter template value is blank, so set it to
+               # off.
+
+               $altertemplate  = "off";
+
+       }
+
+       if (!$altersettings){
+
+               # The alter settings value is blank, so set it to
+               # off.
+
+               $altersettings  = "off";
+
+       }
+
+       # Check if the database filename is valid and return an error if
+       # it isn't.
+
+       my $pagedatabase_filename_check = kiriwrite_variablecheck($database, "filename", 0, 1);
+
+       if ($pagedatabase_filename_check eq 1){
+
+               # The database filename is blank, so return an error.
+
+               kiriwrite_error("blankdatabasepageadd");
+
+       } elsif ($pagedatabase_filename_check eq 2){
+
+               # The database filename is invalid, so return an error.
+
+               kiriwrite_error("databasefilenameinvalid");
+
+       }
+
+       # Check if the confirm value is blank and if it is then
+       # set the confirm value to 0.
+
+       if (!$confirm){
+
+               $confirm = 0;
+
+       }
+
+       if ($confirm eq 1){
+
+               # The action to edit the template has been confirmed so
+               # edit the selected pages.
+
+               # Check the values recieved at UTF8 compliant before
+               # converting.
+
+               kiriwrite_variablecheck($newsection, "utf8", 0, 0);
+               kiriwrite_variablecheck($newtemplate, "utf8", 0, 0);
+               kiriwrite_variablecheck($newsettings, "utf8", 0, 0);
+
+               # Convert the values into proper UTF8 values.
+
+               $newsection     = kiriwrite_utf8convert($newsection);
+               $newtemplate    = kiriwrite_utf8convert($newtemplate);
+               $newsettings    = kiriwrite_utf8convert($newsettings);
+
+               # Check the length of the variables.
+
+               kiriwrite_variablecheck($altersection, "maxlength", 3, 0);
+               kiriwrite_variablecheck($altertemplate, "maxlength", 3, 0);
+               kiriwrite_variablecheck($altersettings, "maxlength", 3, 0);
+               my $newsection_maxlength_check  = kiriwrite_variablecheck($newsection, "maxlength", 256, 1);
+               my $newtemplate_maxlength_check = kiriwrite_variablecheck($newtemplate, "maxlength", 256, 1);
+               my $newtemplate_filename_check  = kiriwrite_variablecheck($newtemplate, "filename", 0, 1);
+               my $newsettings_maxlength_check = kiriwrite_variablecheck($newsettings, "maxlength", 1, 1);
+               my $newsettings_settings_check  = kiriwrite_variablecheck($newsettings, "pagesetting", 0, 1);
+
+               # Check the values and return an error if needed.
+
+               if ($newsection_maxlength_check eq 1 && $altersection eq "on"){
+
+                       # The new section name is too long, so return an
+                       # error.
+
+                       kiriwrite_error("pagesectiontoolong");
+
+               }
+
+               if ($newtemplate_maxlength_check eq 1 && $altertemplate eq "on"){
+
+                       # The new template name is too long, so return an
+                       # error.
+
+                       kiriwrite_error("templatefilenametoolong");                     
+
+               }
+
+               # Check if the template filename is set to !skip or !none
+               # and skip this check if it is.
+
+               if ($newtemplate eq "!skip" || $newtemplate eq "!none"){
+
+                       # Skip this check as the template filename is 
+                       # !skip or !none.
+
+               } else {
+                       if ($newtemplate_filename_check eq 1 && $altertemplate eq "on" || $newtemplate_filename_check eq 2 && $altertemplate eq "on"){
+
+                               # The new template filename is invalid, so return
+                               # an error.
+
+                               kiriwrite_error("templatefilenameinvalid");
+
+                       }
+               }
+
+               if ($newsettings_maxlength_check eq 1 && $altertemplate eq "on"){
+
+                       # The new settings value is too long, so return
+                       # an error.
+
+                       kiriwrite_error("pagesettingstoolong");
+
+               }
+
+               if ($newsettings_settings_check eq 1 && $altertemplate eq "on"){
+
+                       # The new settings value is invalid, so return
+                       # an error.
+
+                       kiriwrite_error("pagesettingsinvalid");
+
+               }
+
+               # Load the SQLite Database and get info about the database.
+
+               my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+               my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("databasefileinvalid");
+               $string_handle->execute();
+
+               # Get the database name.
+
+               my @database_info       = $string_handle->fetchrow_array();
+               my $database_name       = $database_info[0];
+               my $database_name_out   = kiriwrite_convert($database_name, "normal_display");
+               my $database_out        = kiriwrite_convert($database, "normal_display");
+
+               # Define some values for later.
+
+               my @database_page;
+               my $edited_list = "";
+               my $filename;
+               my $filename_sql;
+               my $filename_out;
+               my $sqlquery_options = "";
+               my @sqlquery_list;
+               my $sqlquery_option;
+               my $page_name;
+               my $page_name_out;
+               my $newsection_sql;
+               my $newtemplate_sql;
+               my $newsettings_sql;
+               my $pagefound = 0;
+               my $pageedited = 0;
+               my $sqlquery_seek = 0;
+               my $warninglist;
+
+               # Get the date and time information.
+
+               my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
+
+               my $pagelastmodified = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
+
+
+               # Check if the template filename is !skip and
+               # set the alter template value to off if it
+               # is.
+
+               if ($newtemplate eq "!skip"){
+
+                       $altertemplate = "off";
+
+               }
+
+               # Check if all values are not selected and return
+               # an error if they are.
+
+               if ($altersection ne "on" && $altertemplate ne "on" && $altersettings ne "on"){
+
+                       # All values are not selected so return 
+                       # an error.
+
+                       kiriwrite_error("noeditvaluesselected");
+
+               }
+
+               # Check if each value is meant to be changed on
+               # the selected files. Start with the section
+               # name.
+
+               if ($altersection eq "on"){
+
+                       # Convert the value so that it will work
+                       # when SQL query is made.
+
+                       $newsection_sql = kiriwrite_convert($newsection, "kiriwrite");
+
+                       # The section name should be altered so
+                       # prepare the a part of the SQL query.
+                       # Check if this is the first part of
+                       # the SQL query.
+
+                       if ($sqlquery_seek eq 0){
+
+                               # This is the first part of the SQL query.
+
+                               $sqlquery_list[$sqlquery_seek] = "pagesection = \'" . $newsection_sql . "\'";
+                               $sqlquery_seek++;
+
+                       } else {
+
+                               # This isn't the first part of the SQL query.
+
+                               $sqlquery_list[$sqlquery_seek] = ", pagesection = \'" . $newsection_sql . "\'";
+                               $sqlquery_seek++;
+
+                       }
+
+               }
+
+               # Check if the template name should be changed.
+
+               if ($altertemplate eq "on"){
+
+                       # Convert the value so that it will work
+                       # when SQL query is made.
+
+                       $newtemplate_sql        = kiriwrite_convert($newtemplate, "kiriwrite");
+
+                       # The section name should be altered so
+                       # prepare the a part of the SQL query.
+                       # Check if this is the first part of
+                       # the SQL query.
+
+                       if ($sqlquery_seek eq 0){
+
+                               # This is the first part of the SQL query.
+
+                               $sqlquery_list[$sqlquery_seek] = "pagetemplate = \'" . $newtemplate_sql . "\'";
+                               $sqlquery_seek++;
+
+                       } else {
+
+                               # This isn't the first part of the SQL query.
+
+                               $sqlquery_list[$sqlquery_seek] = ", pagetemplate = \'" . $newtemplate_sql . "\'";
+                               $sqlquery_seek++;
+
+                       }
+
+               }
+
+               # Check if the page settings should be changed.
+
+               if ($altersettings eq "on"){
+
+                       # Convert the value so that it will work
+                       # when SQL query is made.
+
+                       $newsettings_sql        = kiriwrite_convert($newsettings, "kiriwrite");
+
+                       # The section name should be altered so
+                       # prepare the a part of the SQL query.
+                       # Check if this is the first part of
+                       # the SQL query.
+
+                       if ($sqlquery_seek eq 0){
+
+                               # This is the first part of the SQL query.
+
+                               $sqlquery_list[$sqlquery_seek] = "pagesettings = \'" . $newsettings_sql . "\'";
+                               $sqlquery_seek++;
+
+                       } else {
+
+                               # This isn't the first part of the SQL query.
+
+                               $sqlquery_list[$sqlquery_seek] = ", pagesettings = \'" . $newsettings_sql . "\'";
+                               $sqlquery_seek++;
+
+                       }
+
+               }
+
+               # Add a new modification date.
+
+               $sqlquery_list[$sqlquery_seek] = ", lastmodified = \'" . $pagelastmodified . "\'";
+
+               # Create the line for the needed SQL query.
+
+               foreach $sqlquery_option (@sqlquery_list){
+
+                       # Add the line to the needed SQL query.
+
+                       $sqlquery_options = $sqlquery_options . $sqlquery_option;
+
+               }
+
+               # Edit each filename.
+
+               foreach $filename (@filelist){
+
+                       # Check if the page filename exists in the
+                       # database.
+
+                       $filename_sql   = kiriwrite_convert($filename, "kiriwrite");
+                       $filename_out   = kiriwrite_convert($filename, "normal_display");
+                       $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $filename_sql . '\'') or kiriwrite_error("databasefileinvalid");
+                       $string_handle->execute();
+
+                       # Check if the filename given exists and if it
+                       # doesn't then skip this filename and go onto
+                       # the next filename.
+
+                       while (@database_page = $string_handle->fetchrow_array()){
+
+                               $pagefound = 1;
+
+                       }
+                       
+                       if ($pagefound eq 0){
+
+                               # The page was not find in the database so
+                               # add a warning saying it could not be
+                               # found in the database and process the
+                               # next file.
+
+                               
+                               $warninglist = $warninglist . "The page \'" . $filename_out . "\'could not be found." . "<br>";
+                               next;
+
+                       }
+
+                       # Get the page name.
+
+                       $string_handle->execute();
+                       @database_page  = $string_handle->fetchrow_array();
+                       $page_name      = $database_page[1];
+                       $page_name_out  = kiriwrite_convert($page_name, "normal_display");
+
+                       # Alter the values of the page using the values recieved.
+
+                       $string_handle  = $database_handle->prepare('UPDATE kiriwrite_database_pages SET ' . $sqlquery_options . ' WHERE filename = \'' . $filename_sql . '\'');
+                       $string_handle->execute();
+
+                       # Add the page to the list of edited pages. Check if
+                       # the page name is blank.
+
+                       if (!$page_name_out){
+
+                               # The page name is blank so write no name.
+
+                               $edited_list    = $edited_list . "The page (" . $filename_out . ") was edited." . "<br>";
+
+                       } else {
+
+                               # Add the page to the list of edited pages.
+
+                               $edited_list    = $edited_list . "The page called '" . $page_name_out . "' (" . $filename_out . ") was edited." . "<br>";
+
+                       }
+
+                       # Increment the counter of edited pages.
+
+                       $pageedited++;
+
+               }
+
+               $pagedata       = $pagedata . "<h2>Edit selected pages</h2>";
+
+               # Check if the counter of edited pages is 0 and if it is
+               # then write a message saying that no pages were edited
+               # else write a message listing all of the pages edited.
+
+               if ($pageedited eq 0){
+
+                       $pagedata       = $pagedata . "No pages were edited in the '" . $database_name_out . "' database. <br><br>";
+
+               } else {
+
+                       # Write out the message saying that the selected pages
+                       # were edited.
+
+                       $pagedata       = $pagedata . "The selected pages in the '" . $database_name_out . "' database have been edited:<br><br>";
+                       $pagedata       = $pagedata . "<div class=\"datalist\">";
+                       $pagedata       = $pagedata . $edited_list;
+                       $pagedata       = $pagedata . "</div><br>";
+
+               }
+
+               # Check if any warnings have occured and write a message
+               # if any warnings did occur.
+
+               if ($warninglist){
+
+                       # One or several warnings have occured so 
+                       # write a message.
+
+                       $pagedata       = $pagedata . "The following errors/warnings occured while editing the selected pages:<br><br>";
+                       $pagedata       = $pagedata . "<div class=\"datalist\">";
+                       $pagedata       = $pagedata . $warninglist;
+                       $pagedata       = $pagedata . "</div><br>";
+
+               }
+
+               # Write a link going back to the page list for
+               # the selected database.
+
+               $pagedata       = $pagedata . "<a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_out . "\">Return to the page list for the '" . $database_name_out . "' database.</a>";
+
+               return $pagedata;
+
+       } elsif ($confirm eq 0){
+
+               # The action to edit the template has not been confirmed
+               # so write a form out instead.
+
+               # Load the SQLite Database and get info about the database.
+
+               my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+               my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("databasefileinvalid");
+               $string_handle->execute();
+
+               # Get the database name.
+
+               my @database_info       = $string_handle->fetchrow_array();
+               my $database_name       = $database_info[0];
+               my $database_name_out   = kiriwrite_convert($database_name, "normal_display");
+               my $database_out        = kiriwrite_convert($database, "normal_display");
+
+               # Define some variables for later.
+
+               my @database_page;
+               my @database_templates;
+               my @filenames;
+               my @page_info;
+               my @pagenames;
+               my $filelist_filename;
+               my $filelist_filename_sql;
+               my $filelist_filename_out;
+               my $filename;
+               my $pagefound;
+               my $pagelist = "";
+               my $pagelistformdata = "";
+               my $pageseek = 0;
+               my $page_name;
+               my $page_filename;
+               my $template_data;
+               my $template_filename;
+               my $template_name;
+               my $template_warning;
+
+               # Get the information about each page that is going
+               # to be edited.
+
+               foreach $filelist_filename (@filelist){
+
+                       $filelist_filename_sql  = kiriwrite_convert($filelist_filename, "kiriwrite");
+                       $filelist_filename_out  = kiriwrite_convert($filelist_filename, "normal_display");
+
+                       $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $filelist_filename . '\' LIMIT 1') or kiriwrite_error("databasefileinvalid");
+
+                       $string_handle->execute();
+
+                       # Check if the filename given exists and if it
+                       # doesn't then skip this filename and go onto
+                       # the next filename.
+
+                       while (@page_info = $string_handle->fetchrow_array()){
+
+                               $pagefound = 1;
+
+                       }
+                       
+                       if ($pagefound eq 0){
+
+                               next;
+
+                       }
+
+                       # Get the data again.
+
+                       $string_handle->execute();
+                       @page_info      = $string_handle->fetchrow_array();
+
+                       # Add the page name and file name to their seperate
+                       # arrays.
+
+                       $pagenames[$pageseek]   = $page_info[1];
+                       $filenames[$pageseek]   = $page_info[0];
+
+                       # Add the form data for the page filename.
+
+                       # BLEARGH
+
+                       $pagelistformdata       = $pagelistformdata . "<input type=\"hidden\" name=\"name[" . ($pageseek + 1) . "]\" value=\"on\">";
+                       $pagelistformdata       = $pagelistformdata . "<input type=\"hidden\" name=\"id[" . ($pageseek + 1) . "]\" value=\"" . $filelist_filename_out . "\">";
+
+                       # Increment the page seek counter and reset the
+                       # page found value.
+
+                       $pageseek++;
+                       $pagefound = 0;
+
+               }
+
+               # Check if any pages were found in the database and return
+               # an error if not.
+
+               if ($pageseek eq 0){
+
+                       # No pages were found so return an error.
+
+                       kiriwrite_error("nopagesselected");
+
+               }
+
+               # Get the template list and select the template that is being used by
+               # the page, check the permissions and if the template database exists.
+
+               my $template_file_exists        = kiriwrite_fileexists("templates.db");
+               my $template_file_permissions   = kiriwrite_filepermissions("templates.db", 1, 0, 0);
+
+               if ($template_file_exists eq 1){
+
+                       # The template database does not exist, so write a warning messsage.
+
+                       $template_warning = "The template database does not exist. Existing template settings for selected pages kept.";
+
+               }
+
+               if ($template_file_permissions eq 1 && $template_file_exists ne 1){
+
+                       # The template database has invalid permissions set, so write a warning message.
+
+                       $template_warning = "The template database has invalid permissions set. Existing template settings for selected pages kept.";
+
+               }
+
+               # Get the list of templates.
+
+               if (!$template_warning){
+
+                       # Load the templates database and get the templates.
+
+                       $database_handle        = DBI->connect("dbi:SQLite:templates.db");
+                       $string_handle          = $database_handle->prepare('SELECT * FROM kiriwrite_templates') or $template_warning = "The template database is in an invalid format. Existing template settings for selected pages kept.";
+                       
+                       if (!$template_warning){
+
+                               $string_handle->execute();
+
+                               $template_data = "<select name=\"newtemplate\">";
+
+                               while (@database_templates = $string_handle->fetchrow_array()){
+
+                                       # Get the filename and name of the database.
+
+                                       $template_filename      = $database_templates[0];
+                                       $template_name          = $database_templates[1];
+
+                                       # Convert the values so that they can be displayed in the list.
+
+                                       $template_filename      = kiriwrite_convert($template_filename, "normal_display");
+                                       $template_name          = kiriwrite_convert($template_name, "normal_display");
+
+                                       # Add the template to the list of templates.
+
+                                       $template_data = $template_data .  "<option value=\"" . $template_filename . "\">" . $template_name . " (" . $template_filename .")</option>";
+
+                               }
+
+                       # Add the option to not use a template at all.
+
+                       $template_data = $template_data . "<option value=\"!none\" selected>Don't use a template</option>";
+                       $template_data = $template_data . "</select>";
+
+                       }
+
+               }
+
+               # Process the list of selected pages.
+
+               $pageseek = 1;
+               foreach $filename (@filenames){
+
+                       # Process each filename.
+
+                       $page_name      = $pagenames[$pageseek - 1];
+                       $page_filename  = $filenames[$pageseek - 1];
+
+                       # Check if the page name is blank.
+
+                       if (!$page_name){
+
+                               # Write a message saying there's no page name.
+
+                               $pagelist       = $pagelist . "<i>No Name</i>" . " (" . $page_filename . ")" . "<br>"
+
+                       } else {
+
+                               # Append the page to the list of pages to edit.
+
+                               $pagelist       = $pagelist . $page_name . " (" . $page_filename . ")" . "<br>";
+
+                       }
+
+                       $pageseek++;
+
+               }
+
+               # Write a form for editing the selected pages.
+
+               $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"page\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"multiedit\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"database\" value=\"" . $database_out . "\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"count\" value=\"" . ($pageseek - 1) . "\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
+               $pagedata = $pagedata . "<h2>Edit selected pages</h2>";
+               $pagedata = $pagedata . "The following pages from the '" . $database_name_out . "' database will be altered:<br><br>";
+               $pagedata = $pagedata . "<div class=\"datalist\">";
+               $pagedata = $pagedata . $pagelist;
+               $pagedata = $pagedata . "</div><br>";
+               $pagedata = $pagedata . $pagelistformdata;
+               $pagedata = $pagedata . "Using the values below (click on the checkbox for each value to be edited on the selected pages):<br><br>";
+               $pagedata = $pagedata . "<table cellpadding=\"5\" cellspacing=\"0\">";
+               $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Alter</td><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\"><input type=\"checkbox\" name=\"altersection\"></td><td class=\"tablecell1\">Page Section</td><td class=\"tablecell1\"><input type=\"text\" name=\"newsection\" size=\"64\" maxlength=\"256\"></td></tr>";
+               
+               # Check if a warning for template database has been written
+               # and return the warning message if it has else write the
+               # list of templates.
+
+               if ($template_warning){
+
+                       # There is a message in the template warning variable
+
+                       $pagedata = $pagedata . "<tr><td class=\"tablecell2\"><input type=\"checkbox\" name=\"altertemplate\"></td><td class=\"tablecell2\">Page Template</td><td class=\"tablecell2\"><input type=\"hidden\" name=\"newtemplate\" value=\"!skip\">" . $template_warning . "</td></tr>";
+
+               } else {
+               
+                       $pagedata = $pagedata . "<tr><td class=\"tablecell2\"><input type=\"checkbox\" name=\"altertemplate\"></td><td class=\"tablecell2\">Page Template</td><td class=\"tablecell2\">" . $template_data . "</td></tr>";
+
+               }
+
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\"><input type=\"checkbox\" name=\"altersettings\"></td><td class=\"tablecell1\">Page Settings</td><td class=\"tablecell1\"><input type=\"radio\" name=\"newsettings\" value=\"1\"> Use page name and section name.<br><input type=\"radio\" name=\"newsettings\" value=\"2\"> Use the page name only.<br><input type=\"radio\" name=\"newsettings\" value=\"3\"> Use the section name only.<br><input type=\"radio\" name=\"newsettings\" value=\"0\" checked> Don't use page name or section name.<br></td></tr>";
+               $pagedata = $pagedata . "</table><br>";
+               $pagedata = $pagedata . "<input type=\"submit\" value=\"Edit selected pages\"> | <a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_out . "\">Return to the page list for the '" . $database_name_out . "' database.</a>";
+               $pagedata = $pagedata . "</form>";
+
+               return $pagedata;
+
+       } else {
+
+               # The confirm value is something else other than
+               # 1 or 0, so return an error.
+
+               kiriwrite_error("invalidvariable");
+
+       }
+
+}
+
+sub kiriwrite_page_list{
+#################################################################################
+# kiriwrite_page_list: Lists pages from an database.                           #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_page_list([database]);                                             #
+#                                                                              #
+# database     Specifies the database to retrieve the pages from.              #
+#################################################################################
+
+       # Get the database file name from what was passed to the subroutine.
+
+       my ($database_file) = @_;
+               
+       # Load the required Perl modules.
+       
+       my $xsl = XML::Simple->new();
+       use DBI;
+       
+       # Check if the database_file variable is empty, if it is then print out a
+       # select box asking the user to select a database from the list.
+       
+       if (!$database_file) {
+       
+               # Define the variables required for this section.
+       
+               my $pagedata            = "";
+               my $dblistdata          = "";
+               my $data_file           = "";
+               my $data_file_length    = 0;
+               my $data_file_friendly  = "";
+               my $database_handle     = "";
+               my $string_handle       = "";
+               my $database_name       = "";
+               my $file_permissions    = "";
+               my @database_info;
+               my @data_directory;
+                                               
+               # Open the data directory and get all of the databases.
+               
+               opendir(DATADIR, $kiriwrite_config{"directory_data_db"});
+               @data_directory = grep /m*\.db/, readdir(DATADIR);
+               closedir(DATADIR);
+               
+               # Get the information about each database (the short name and friendly name).
+                               
+               foreach $data_file (@data_directory){
+                       
+                       # Give the filename a friendly name.
+
+                       $data_file_length       = length($data_file);
+                       $data_file_friendly     = substr($data_file, 0, $data_file_length - 3);
+
+                       # Check if the permissions for the database are valid.
+
+                       $file_permissions       = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' .$data_file, 1, 0);
+                       
+                       if ($file_permissions ne 0){
+
+                               # The permissions for the database are invalid
+                               # so process the next database.
+
+                               next;
+
+                       }
+
+                       # Load the SQLite database.
+
+                       $database_handle        = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $data_file);
+                       $string_handle          = $database_handle->prepare("SELECT * FROM kiriwrite_database_info LIMIT 1") or next;
+                       $string_handle->execute();
+                       @database_info          = $string_handle->fetchrow_array();
+
+                       # Get the database name from the results.
+
+                       $database_name          = $database_info[0];
+                       $database_name          = kiriwrite_convert($database_name, "normal_display");
+
+                       # Append the database to the list of databases available.
+                       
+                       $dblistdata = $dblistdata . "<option value=\"" . $data_file_friendly . "\">" . $database_name . "</option>";
+
+               }               
+               
+               # Write the page data.
+               
+               $pagedata = "<h2>View Pages</h2>\r\n";
+               $pagedata = $pagedata . "No database selected. Please select a database from the drop-down list below and then press the \'View\' button to view the pages in the selected database.<br><br>";
+               
+               $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">\r\n";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"page\">\r\n";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"view\">\r\n";
+               $pagedata = $pagedata . "<select name=\"database\">";
+               $pagedata = $pagedata . $dblistdata;
+               $pagedata = $pagedata . "</select>&nbsp;|&nbsp;";
+               $pagedata = $pagedata . "<input type=\"submit\" value=\"View\">";
+               $pagedata = $pagedata . "</form>&nbsp;<br>";
+               
+               return $pagedata;
+       
+       } else {
+               
+               my @database_pages;
+               my @database_info;
+               my $tabledata           = "";
+               my $pagedata            = "";
+               my $pagemultioptions    = "";
+               my $database_handle     = "";
+               my $string_handle       = "";
+               my $db_friendlyname     = "";
+               my $tablestyle          = "";
+
+               my $page_filename       = "";
+               my $page_name           = "";
+               my $page_description    = "";
+               my $page_modified       = "";
+
+               my $tablestyletype      = 0;
+               my $page_count          = 0;
+               my $db_file_notblank    = 0;
+               
+               # The database_file variable is not blank, so print out a list of pages from
+               # the selected database.
+               
+               # Preform a variable check on the database filename to make sure that it is
+               # valid before using it.
+               
+               kiriwrite_variablecheck($database_file, "filename", "", 0);
+               kiriwrite_variablecheck($database_file, "maxlength", 64, 0);
+       
+               # Check if the specified database file exists,
+               # if it does exist then continue otherwise return an error saying the database
+               # could not be found.
+               
+               if (-e $kiriwrite_config{"directory_data_db"} . '/' . $database_file . '.db'){
+               
+                       # Check that the permissions for the database file are valid.
+
+                       my $database_db_permissions     = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database_file . '.db', 1, 0, 0);
+
+                       if ($database_db_permissions eq 1){
+
+                               kiriwrite_error("databaseinvalidpermissions");
+
+                       }
+
+                       # Load the SQLite database.
+
+                       $database_handle        = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database_file . '.db');
+                       
+                       # Get the database name.
+
+                       $string_handle          = $database_handle->prepare("SELECT * FROM kiriwrite_database_info LIMIT 1") or kiriwrite_error("databasenameinvalid");
+                       $string_handle->execute();
+
+                       @database_info = $string_handle->fetchrow_array();
+
+                       $db_friendlyname = $database_info[0];
+
+                       $string_handle          = $database_handle->prepare("SELECT * FROM kiriwrite_database_pages") or kiriwrite_error("databasenameinvalid");
+                       $string_handle->execute();
+
+                       # Write the table header into the tabledata string.
+
+                       $tabledata = "<table cellpadding=\"5\" cellspacing=\"0\">\r\n<tr>\r\n\t<td class=\"tablecellheader\"></td>\r\n\t<td class=\"tablecellheader\">Page Location</td>\r\n\t<td class=\"tablecellheader\">Page Name</td>\r\n\t<td class=\"tablecellheader\">Page Description</td>\r\n\t<td class=\"tablecellheader\">Last Modified</td>\r\n\t<td class=\"tablecellheader\">Options</td>\r\n</tr>";
+
+                       # Write the results out as a list and append it to the
+                       # tabledata string.
+
+                       while (@database_pages = $string_handle->fetchrow()){
+
+                               $page_filename          = kiriwrite_convert($database_pages[0], "normal_display");
+                               $page_name              = kiriwrite_convert($database_pages[1], "normal_display");
+                               $page_description       = kiriwrite_convert($database_pages[2], "normal_display");
+                               $page_modified          = kiriwrite_convert($database_pages[7], "date");
+                               $page_modified          = kiriwrite_convert($page_modified, "normal_display");
+
+                               if ($database_pages[0]){
+                                       $page_count++;
+                               } else {
+                                       next;
+                               }
+
+                               if ($tablestyletype eq 0){
+
+                                       $tablestyle = "tablecell1";
+                                       $tablestyletype = 1;
+
+                               } else {
+
+                                       $tablestyle = "tablecell2";
+                                       $tablestyletype = 0;
+
+                               }
+
+                               # Check if the page name and description names
+                               # are blank and if they are write a message saying that
+                               # field contains no data.
+
+                               if ($page_name eq ""){
+
+                                       $page_name = "<i>No Name</i>";
+
+                               }
+
+                               if ($page_description eq ""){
+
+                                       $page_description = "<i>No Description</i>";
+
+                               }
+
+                               if ($page_modified eq ""){
+
+                                       $page_modified = "<i>No Date</i>";
+
+                               }
+
+                               $tabledata = $tabledata . "<tr><td class=\"" . $tablestyle . "\"><input type=\"hidden\" name=\"id[" . $page_count . "]\" value=\"" . $database_pages[0] . "\"><input type=\"checkbox\" name=\"name[" . $page_count . "]\"></td><td class=\"" . $tablestyle . "\">" . $page_filename ."</td><td class=\"" . $tablestyle . "\">" . $page_name . "</td><td class=\"" . $tablestyle . "\">" . $page_description . "</td><td class=\"" . $tablestyle . "\">" . $page_modified . "</td><td class=\"" . $tablestyle . "\"><a href=\"kiriwrite.cgi?mode=page&action=edit&database=" . $database_file . "&page=" . $page_filename ."\">Edit</a> <a href=\"kiriwrite.cgi?mode=page&action=delete&database=" . $database_file . "&page=" . $page_filename . "\">Delete</td></tr>";
+                               
+
+
+                       }
+
+                       # Check if the page count is more than
+                       
+                       if ($page_count > 0){
+                               $db_file_notblank = 1;
+                       }
+
+                       # Append the closing table part into the tabledata string.
+
+                       $tabledata = $tabledata . "</table>";
+                       
+               } else {
+                       # Either the database file, the database configuration file or both are missing
+                       # so return an error saying that certain files are missing.
+                       
+                       kiriwrite_error("databasemissingfile");
+               }
+               
+               # Check if the database really was not blank and if it was, write a message saying that
+               # no pages existed in the database else write the list of pages in the database.
+
+               $db_friendlyname = kiriwrite_convert($db_friendlyname, "normal_display");
+
+               if ($db_file_notblank eq 0){
+
+                       $pagedata = "<h2>Page list for '" . $db_friendlyname . "'</h2>";
+                       $pagedata = $pagedata . "<div class=\"errorbox\">No pages exist in this database. To create a page for this database, click on Add Page link at the top of the page.</div>";
+
+               } else {
+
+                       $pagemultioptions = "<input type=\"reset\" value=\"Select None\"> | <button name=\"action\" value=\"multidelete\">Delete Selected</button> | <button name=\"action\" value=\"multimove\">Move Selected</button> | <button name=\"action\" name=\"action\" value=\"multicopy\">Copy Selected</button> | <button name=\"action\" value=\"multiedit\">Edit Selected</button>";
+
+                       $pagedata = "<h2>Page list for '" . $db_friendlyname . "'</h2>";
+                       $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">\r\n";
+                       $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"page\">\r\n";             
+                       $pagedata = $pagedata . "<input type=\"hidden\" name=\"count\" value=\"" . $page_count . "\">\r\n";
+                       $pagedata = $pagedata . "<input type=\"hidden\" name=\"type\" value=\"multiple\">\r\n";
+                       $pagedata = $pagedata . "<input type=\"hidden\" name=\"database\" value=\"" . $database_file . "\">\r\n";
+                       $pagedata = $pagedata . $pagemultioptions . "<p>\r\n";
+                       $pagedata = $pagedata . $tabledata;
+                       $pagedata = $pagedata . "<br>" . $pagemultioptions . "<p>\r\n";
+                       $pagedata = $pagedata . "</form>";
+
+               }
+               
+               return $pagedata;
+               
+       }
+
+}
+
+sub kiriwrite_page_multipleselect{
+#################################################################################
+# kiriwrite_page_multipleselect: Gets the multiple page selections from a      #
+# database and processes them into a single which can be used in the           #
+# kiriwrite_page_delete.                                                       #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_page_multipleselect();                                             #
+#################################################################################
+
+       # Load the required perl modules for this subroutine.
+
+       my $query = new CGI;
+       
+       # Setup some variables that will be used later on.
+       
+       my $page_select_seek = 1;
+       my $page_current_value = "";
+       my $selectionlist = "";
+               
+       # Get the required variables from the HTTP query.
+       
+       my $page_count = $query->param('count');
+       
+       do {
+               
+               # Get the current value of the selected page's checkbox.
+               
+               $page_current_value = $query->param('name[' . $page_select_seek . ']');
+
+               # If page_current_value is undefinied or blank, set page_current_value
+               # to off.
+               
+               if (!$page_current_value){
+                               
+                       $page_current_value = "off";
+               
+               }
+                               
+               # Check if the page_current_value is set to 'on' if it is append the
+               # current page seek value to the selection list.
+
+               if ($page_current_value eq "on"){
+               
+                       # Append the current seek value to the selection list.
+                       
+                       $selectionlist = $selectionlist . $page_select_seek . "|";
+               
+               }
+       
+               # Increment the page selection seeking counter. 
+       
+               $page_select_seek++;
+       
+       } until ($page_select_seek eq $page_count);
+       
+       return $selectionlist;
+
+}
+
+sub kiriwrite_template_add{
+#################################################################################
+# kiriwrite_template_add: Add a template to the template folder                        #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_template_add(filename, name, description, layout, confirm);                #
+#                                                                              #
+# filename     The filename of the new template.                               #
+# name         The name of the template.                                       #
+# description  The description of the template.                                #
+# layout       The layout of the new template.                                 #
+# confirm      Confirm the action of creating a new template.                  #
+#################################################################################
+
+       # Get the variables that were passed to the subroutine.
+       
+       my ($templatefilename, $templatename, $templatedescription, $templatelayout, $confirm) = @_;
+       
+       # Load the needed Perl Modules
+
+       use DBI;
+
+       # Check if the confirm value is blank and if it is then set confirm to 0.
+
+       if (!$confirm){
+
+               # The confirm value is blank, so set the value of confirm to 0.
+
+               $confirm = 0;
+
+       }
+
+       if ($confirm eq 1){
+               
+               # Check (validate) each of the values.
+       
+               kiriwrite_variablecheck($templatename, "utf8", 0, 0);
+               kiriwrite_variablecheck($templatedescription, "utf8", 0, 0);
+               kiriwrite_variablecheck($templatelayout, "utf8", 0, 0);
+
+               # Convert the values into proper UTF8 strings that can be used.
+
+               $templatename           = kiriwrite_utf8convert($templatename);
+               $templatedescription    = kiriwrite_utf8convert($templatedescription);
+               $templatelayout         = kiriwrite_utf8convert($templatelayout);
+
+               # Check the length of the converted UTF8 strings.
+
+               my $templatefilename_length_check       = kiriwrite_variablecheck($templatefilename, "maxlength", 64, 1);
+               my $templatename_length_check           = kiriwrite_variablecheck($templatename, "maxlength", 512, 1);
+               my $templatedescription_length_check    = kiriwrite_variablecheck($templatedescription, "maxlength", 512, 1);
+               kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
+
+               if ($templatefilename_length_check eq 1){
+                       
+                       # The template filename length is too long, so return an error.
+
+                       kiriwrite_error("templatefilenametoolong");
+
+               }
+
+               if ($templatename_length_check eq 1){
+
+                       # The template name length is too long, so return an error.
+
+                       kiriwrite_error("templatenametoolong");
+
+               }
+
+
+               if ($templatedescription_length_check eq 1){
+
+                       # The template description length is too long, so return an error.
+
+                       kiriwrite_error("templatedescriptiontoolong");
+
+               }
+
+               # Check if the filename specified is a valid filename.
+
+               kiriwrite_variablecheck($templatefilename, "filename", "", 0);
+
+               # Check if the template database file permissions are valid and
+               # return an error if they aren't.
+
+               my $template_database_permissions = kiriwrite_filepermissions("templates.db", 1, 1, 1);
+
+               if ($template_database_permissions eq 1){
+
+                       # Template database has invalid permissions set, so return
+                       # an error.
+
+                       kiriwrite_error("templatedatabasefileinvalidpermissions");
+               }
+
+               # Check if the template database exists and if it doesn't then
+               # create the database and populate it.
+
+               my $template_database_exists = kiriwrite_fileexists("templates.db");
+               my $database_handle;
+               my $string_handle;              
+
+               if ($template_database_exists eq 1){
+
+                       # The template database does not exist, so try to create a database.
+
+                       # Check if the directory has valid permissions to create files (and
+                       # thus be able create a template database).
+
+                       my $directory_permissions = kiriwrite_filepermissions(".", 1, 1, 0);
+
+                       if ($directory_permissions eq 1){
+
+                               # The template database cannot be created because of invalid directory
+                               # permissions so return an error.
+
+                               kiriwrite_error("templatedatabasefilenotcreated");
+                       }
+
+                       # Create the SQLite database for the templates and populate it.
+
+                       $database_handle        = DBI->connect("dbi:SQLite:dbname=templates.db");
+                       $string_handle          = $database_handle->prepare('CREATE TABLE kiriwrite_templates(
+                               filename varchar(64) primary key,
+                               templatename varchar(512),
+                               templatedescription varchar(512),
+                               templatelayout text,
+                               datemodified datetime
+                       )') or die(kiriwrite_error("templatedatabaseinvalidformat")); 
+                       $string_handle->execute();
+
+               }
+
+               # Check if the template filename is already used and if it is then
+               # return an error.
+
+               $database_handle        = DBI->connect("dbi:SQLite:dbname=templates.db");
+               $string_handle          = $database_handle->prepare('select * from kiriwrite_templates where filename = \'' . $templatefilename . '\' limit 1') or die(kiriwrite_error("templatedatabaseinvalidformat"));
+               $string_handle->execute();
+
+               my @database_template_check     = $string_handle->fetchrow_array();
+               my $template_checkname          = $database_template_check[0];
+
+               if ($template_checkname){
+
+                       # A template already exists with the filename given, so return an error.
+
+                       kiriwrite_error("templatefilenameexists");
+               }
+
+               # Get the current date.
+
+               my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
+
+               my $templatedate = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
+
+               # Convert the values that are going to be added for storing in the database.
+
+               $templatename           = kiriwrite_convert($templatename, "kiriwrite");
+               $templatedescription    = kiriwrite_convert($templatedescription, "kiriwrite");
+               $templatelayout         = kiriwrite_convert($templatelayout, "kiriwrite");
+
+               # Add the template to the template database.
+
+               $string_handle          = $database_handle->prepare('INSERT INTO kiriwrite_templates values(
+                               \'' . $templatefilename . '\',
+                               \'' . $templatename . '\',
+                               \'' . $templatedescription . '\',
+                               \'' . $templatelayout . '\',
+                               \'' . $templatedate . '\'
+               )');
+               $string_handle->execute();
+                                       
+               # Print out the confirmation message.
+
+               my $pagedata = "<h2>Template Added</h2>";
+               $pagedata = $pagedata . "The template called '" . $templatename ."' was sucessfully created.<br><br>";
+               $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=template\">Return to the templates list</a>";
+               return $pagedata;
+       
+       } else {
+               # No confirmation was made, so print out a form for adding a template.  
+                       
+               my $pagedata = "<h2>Add Template</h2>";
+               $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"post\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"template\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"add\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
+               $pagedata = $pagedata . "<table cellpadding=\"5\" cellspacing=\"0\">";
+               $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Name:</td><td class=\"tablecell2\"><input type=\"text\" name=\"templatename\" maxlength=\"512\" size=\"64\"></td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Description:</td><td class=\"tablecell2\"><input type=\"text\" name=\"templatedescription\" maxlength=\"512\" size=\"64\"></td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Filename:</td><td class=\"tablecell2\"><input type=\"text\" name=\"templatefilename\" maxlength=\"64\" size=\"32\"></td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Template Layout:</td><td class=\"tablecell2\"><textarea name=\"templatelayout\" rows=\"15\" cols=\"50\" wrap=off></textarea></td></tr>";
+               $pagedata = $pagedata . "</table><br>";
+               $pagedata = $pagedata . "<input type=\"submit\" value=\"Create New Template\"> | <input type=\"reset\" value=\"Clear Settings\">";
+               $pagedata = $pagedata . "</form>";
+               
+               return $pagedata;
+               
+       }
+       
+       
+}
+
+sub kiriwrite_template_edit{
+#################################################################################
+# kiriwrite_template_edit: Edit a template from the template folder.           #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_template_edit(filename, [newfilename], [newname], [newdescription], #
+#                              [templatelayout], [confirm]);                   #
+#                                                                              #
+# filename             The current filename of the template to edit.           #
+# newfilename          The new filename of the template to edit.               #
+# newname              The new name of the template being edited.              #
+# newdescription       The new description of the template being edited.       #
+# templatelayout       The modified/altered template layout.                   #
+# confirm              Confirms the action to edit a template and its          #
+#                      settings.                                               #
+#################################################################################
+
+       # Get all the variables that have been passed to the subroutine.
+
+       my ($templatefilename, $templatenewfilename, $templatenewname, $templatenewdescription, $templatelayout, $confirm) = @_;
+
+       # Load the Perl modules required for this subroutine.
+       
+       use DBI;
+               
+       # Define the pagedata variable for later on.
+       
+       my $pagedata = "";
+       
+       # Check if the confirm variable is blank, if it is then
+       # set confirm to '0'
+       
+       if (!$confirm){
+       
+               # confirm is uninitalised/blank, so set the value of confirm
+               # to '0'
+               
+               $confirm = 0;
+       
+       }
+
+       # Check if the template filename is blank and if it is, then return
+       # an error.
+
+       if (!$templatefilename){
+
+               kiriwrite_error("templatefilenameblank");
+
+       }
+       
+       if ($confirm eq 1){
+
+               # Check certain strings to see if they UTF8 compiliant.
+       
+               kiriwrite_variablecheck($templatenewname, "utf8", 0, 0);
+               kiriwrite_variablecheck($templatenewdescription, "utf8", 0, 0);
+               kiriwrite_variablecheck($templatelayout, "utf8", 0, 0);
+
+               # Convert the values into proper UTF8 strings.
+
+               $templatenewname        = kiriwrite_utf8convert($templatenewname);
+               $templatenewdescription = kiriwrite_utf8convert($templatenewdescription);
+               $templatelayout         = kiriwrite_utf8convert($templatelayout);
+
+               # Check if the filenames recieved are valid filenames.
+
+               kiriwrite_variablecheck($templatenewfilename, "maxlength", 64, 0);
+               kiriwrite_variablecheck($templatenewdescription, "maxlength", 512, 0);
+               kiriwrite_variablecheck($templatenewname, "maxlength", 512, 0);
+               kiriwrite_variablecheck($templatefilename, "maxlength", 64, 0);
+               kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
+
+               kiriwrite_variablecheck($templatefilename, "filename", "", 0);
+               kiriwrite_variablecheck($templatenewfilename, "filename", "", 0);
+
+               # Check that the template database file exists and the permissions 
+               # of the template database are valid.
+
+               my $template_database_exists            = kiriwrite_fileexists("templates.db");
+               my $template_database_permissions       = kiriwrite_filepermissions("templates.db", 1, 1, 0);
+
+               if ($template_database_exists eq 1){
+
+                       # the template database does not exist so return an error.
+
+                       kiriwrite_error("templatedatabasemissing");
+
+               }
+
+               if ($template_database_permissions eq 1){
+               
+                       # The template database permissions are set incorrectly so
+                       # return an error.
+
+                       kiriwrite_error("templatedatabaseinvalidpermissions");
+
+               }
+
+               # Get the date.
+
+               my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
+
+               my $templatenewdate = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
+
+               # Convert the values so that they don't break when entering them into the SQL query.
+
+               $templatenewname        = kiriwrite_convert($templatenewname, "kiriwrite");
+               $templatenewdescription = kiriwrite_convert($templatenewdescription, "kiriwrite");
+               $templatelayout         = kiriwrite_convert($templatelayout, "kiriwrite");
+
+               # Load the SQLite database.
+
+               my $database_handle     = DBI->connect("dbi:SQLite:dbname=templates.db");
+               my $string_handle       = $database_handle->prepare('UPDATE kiriwrite_templates SET
+                       filename                = \'' . $templatenewfilename . '\',
+                       templatename            = \'' . $templatenewname . '\',
+                       templatedescription     = \'' . $templatenewdescription . '\',
+                       templatelayout          = \'' . $templatelayout . '\',
+                       datemodified            = \'' . $templatenewdate . '\'
+                       WHERE filename          = \'' . $templatefilename . '\'
+               ') or die(kiriwrite_error("templatedatabaseinvalidformat"));
+               $string_handle->execute();
+
+               # Convert the following values so that display 
+
+               $templatenewname        = kiriwrite_convert($templatenewname, "normal_display");
+
+               # Append a link so that the user can return to the templates list.
+               
+               $pagedata = $pagedata . "<h2>Edit Template</h2>";
+               $pagedata = $pagedata . "The selected template called '" . $templatenewname . "' was edited.<p>";
+               $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=template\">Return to the templates list.</a>";
+               
+       } else {
+       
+               # Load the SQLite database. 
+
+               my $templatefilename_sql        = kiriwrite_convert($templatefilename, "kiriwrite");
+
+               my $database_handle     = DBI->connect("dbi:SQLite:dbname=templates.db");
+               my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_templates where filename = \'' . $templatefilename_sql . '\' limit 1') or die(kiriwrite_error("templatedatabaseinvalidformat"));
+               $string_handle->execute();
+
+               # Check if there is a result from the SQL query made (meaning
+               # that the template exists).
+
+               my $template_found = 0;
+               my @database_template;
+
+               while (@database_template = $string_handle->fetchrow_array()){
+
+                       # The template has been found, so set the template
+                       # found value to 1 so it doesn't return an error.
+
+                       $template_found = 1;
+
+               }
+
+               if ($template_found eq 0){
+
+                       # The template was not found (doesn't exist) so
+                       # return an error.
+
+                       kiriwrite_error("templatedoesnotexist");
+
+               }
+
+               # Execute the query and get the information again.
+
+               $string_handle->execute();
+               @database_template      = $string_handle->fetchrow_array();
+
+               # Get the values from the query results.
+
+               my $template_filename           = $database_template[0];
+               my $template_name               = $database_template[1];
+               my $template_description        = $database_template[2];
+               my $template_layout             = $database_template[3];
+               my $template_modified           = $database_template[4];
+
+               # Convert the values that are going to be displayed.
+
+               $template_filename      = kiriwrite_convert($template_filename, "normal_display");
+               $template_name          = kiriwrite_convert($template_name, "normal_display");
+               $template_description   = kiriwrite_convert($template_description, "normal_display");
+               $template_layout        = kiriwrite_convert($template_layout, "normal_display");
+                               
+               # Write out the form for editing an template with the current template 
+               # settings put into the correct place.
+                       
+               $pagedata = $pagedata . "<h2>Edit Template</h2>";
+               $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"template\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"edit\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"template\" value=\"" . $template_filename . "\">";
+               $pagedata = $pagedata . "<table cellspacing=\"0\" cellpadding=\"5\">";
+               $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Name:</td><td class=\"tablecell2\"><input type=\"text\" name=\"newname\" value=\"" . $template_name . "\" maxlength=\"512\" size=\"64\"></td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Description:</td><td class=\"tablecell2\"><input type=\"text\" name=\"newdescription\" value=\"" . $template_description . "\" maxlength=\"512\" size=\"64\"></td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Filename:</td><td class=\"tablecell2\"><input type=\"text\" name=\"newfilename\" maxlength=\"64\" size=\"32\" value=\"" . $template_filename . "\"></td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Template Layout:</td><td class=\"tablecell2\"><textarea rows=\"15\" cols=\"50\" name=\"newlayout\" wrap=off>" . $template_layout . "</textarea></td></tr>";
+               $pagedata = $pagedata . "</table><br>";
+               $pagedata = $pagedata . "<input type=\"submit\" value=\"Update template settings\"> | <input type=\"reset\" value=\"Restore current settings\"> | <a href=\"kiriwrite.cgi?mode=template\">Return to the templates list.</a>";
+               $pagedata = $pagedata . "</form>";      
+       
+       }
+
+       return $pagedata;
+       
+}
+
+sub kiriwrite_template_delete{
+#################################################################################
+# kiriwrite_template_delete: Delete a template from the template folder.       #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_template_delete(filename, confirm);                                        #
+#                                                                              #
+# filename     Specifies the filename of the database to delete.               #
+# confirm      Confirms the action to delete a template.                       #
+#################################################################################
+
+       # Get the parameters that were passed to the subroutine.
+       
+       my ($template_filename, $template_confirm) = @_;
+       
+       if (!$template_confirm){
+               $template_confirm = 0;
+       }
+
+       # Load the required Perl modules
+       use DBI;
+       
+       # Check the length of the variables.
+       kiriwrite_variablecheck($template_filename, "maxlength", 64, 0);
+       kiriwrite_variablecheck($template_confirm, "maxlength", 1, 0);
+       
+       # Check if the template_name string is blank and if it is then
+       # return an error (as the template_name string should not be
+       # blank.
+       
+       if (!$template_filename){
+       
+               # The template_filename string really is blank, 
+               # so return an error saying that an empty
+               # filename was passed (to the subroutine).
+       
+               kiriwrite_error("templatefilenameblank");
+               
+       }
+       
+       # Check if the template_confirm string is blank and if it is, write
+       # out a form asking the user to confirm the deletion.
+       
+       if ($template_confirm eq 1){
+
+               # The action to delete the template from the template database has
+               # been confirmed so delete the template.
+
+               # Check if the template database exists and the file permissions
+               # are valid and return an error if they aren't.
+
+               my $template_database_exists            = kiriwrite_fileexists("templates.db");
+               my $template_database_permissions       = kiriwrite_filepermissions("templates.db", 1, 1, 0);
+
+               if ($template_database_exists eq 1){
+
+                       # the template database does not exist so return an error.
+
+                       kiriwrite_error("templatedatabasemissing");
+
+               }
+
+               if ($template_database_permissions eq 1){
+               
+                       # The template database permissions are set incorrectly so
+                       # return an error.
+
+                       kiriwrite_error("templatedatabaseinvalidpermissions");
+
+               }
+
+               # Load thw SQLite database.
+
+               my $database_handle     = DBI->connect("dbi:SQLite:dbname=templates.db");
+
+               # Get the template name.
+
+               my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_templates WHERE filename = \'' . $template_filename . '\' LIMIT 1') or die(kiriwrite_error("templatedatabaseinvalidformat"));
+               $string_handle->execute();
+
+               my @database_template_page      = $string_handle->fetchrow_array();
+               my $database_template_name      = $database_template_page[1];
+
+               $database_template_name         = kiriwrite_convert($database_template_name, "normal_display");
+
+               # Delete the selected template.
+
+               $string_handle  = $database_handle->prepare('DELETE FROM kiriwrite_templates WHERE filename = \'' . $template_filename . '\'');
+               $string_handle->execute();
+               
+               my $pagedata = "<h2>Template Deleted</h2>";
+               $pagedata = $pagedata . "The selected template called '" . $database_template_name . "' was deleted.";
+               $pagedata = $pagedata . "<br><br><a href=\"kiriwrite.cgi?mode=template\">Return to the templates list</a>";
+
+               return $pagedata;
+       
+       } elsif ($template_confirm eq 0) {
+       
+               # The template confirm value is 0 (previously blank and then set to 0), so
+               # write out a form asking the user to confirm the deletion of the template.
+               
+               # Check the templte database file exists and the permissions for the
+               # template database are valid.
+
+               my $template_database_exists            = kiriwrite_fileexists("templates.db");
+               my $template_database_permissions       = kiriwrite_filepermissions("templates.db", 1, 1, 0);
+
+               if ($template_database_exists eq 1){
+
+                       # The template database does not exist so return an error.
+
+                       kiriwrite_error("templatedatabasemissing");
+
+               }
+               
+               if ($template_database_permissions eq 1){
+
+                       # The template database has invalid permissions set so return
+                       # an error.
+
+                       kiriwrite_error("templatedatabaseinvalidpermissions");
+
+               }
+
+               # Load the SQLite database.
+
+               my $database_handle     = DBI->connect("dbi:SQLite:dbname=templates.db");
+               my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_templates WHERE filename = \'' . $template_filename . '\' LIMIT 1');
+               $string_handle->execute();
+
+               # Check if a result had returned and return an error if no result
+               # was returned.
+
+               my @template_data;
+               my $template_found = 0;
+
+               while(@template_data = $string_handle->fetchrow_array()){
+                       
+                       # A template has been found so increment the counter.
+
+                       $template_found++;
+               }
+
+               if ($template_found eq 0){
+
+                       # The template does not exist, so return an error.
+                       kiriwrite_error("templatedoesnotexist");
+
+               }
+
+               # Get the template file information.
+
+               $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_templates WHERE filename = \'' . $template_filename . '\' LIMIT 1');
+               $string_handle->execute();
+               @template_data = $string_handle->fetchrow_array();
+
+               my $template_data_filename      = $template_data[0];
+               my $template_data_name          = $template_data[1];
+
+               # Check if the template name is blank and if it is 
+
+               # Convert the strings so that display properly.
+
+               $template_data_name     = kiriwrite_convert($template_data_name, "normal_display");
+               $template_data_name     = kiriwrite_convert($template_data_name, "normal_display");
+
+               # Write out the confirmation form.
+                       
+               my $pagedata = "<h2>Template Deletion</h2>";
+               $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"template\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"template\" value=\"" . $template_filename ."\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"delete\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
+               $pagedata = $pagedata . "Are you sure you want to delete the template called '" . $template_data_name . "' (" . $template_data_filename . ")?<br><br>";
+               $pagedata = $pagedata . "<input type=\"submit\" name=\"submit\" value=\"Yes, delete the template\"> | <a href=\"kiriwrite.cgi?mode=template\">No, return to the template list.</a>";
+                               
+               $pagedata = $pagedata . "</form>";
+               
+               return $pagedata;
+       
+       } else {
+
+                       kiriwrite_error("invalidvariable");
+
+       }
+
+}
+
+sub kiriwrite_template_list{
+#################################################################################
+# kiriwrite_template_list: List the templates in the template folder.          #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_template_list();                                                   #
+#################################################################################
+
+       # Load the module required for processing the XML configuration files.
+       
+       use DBI;
+
+       # Define certain values for later.
+
+       my @database_template;
+       
+       my $database_handle;
+       my $string_handle;
+       
+       my $template_filename           = "";
+       my $template_name               = "";
+       my $template_description        = "";
+       my $template_data               = "";
+
+       my $template_count = 0;
+
+       my $template_style = 0;
+       my $template_stylename = "";
+       
+       my $pagedata = "";
+       my $templatedata = "";
+
+       # Check if the template database exists and the permissions for it are
+       # valid if the template database doesn't exist then write a message
+       # saying it will be created when a template is added.
+
+       my $template_database_permissions = kiriwrite_filepermissions("templates.db", 1, 0, 1);
+       my $template_database_exists      = kiriwrite_fileexists("templates.db");
+
+       if ($template_database_permissions eq 1){
+
+               # The templates directory has invalid permissions so an
+               # error will be returned.
+
+               kiriwrite_error("templatedatabaseinvalidpermissions");
+
+       }
+
+       if ($template_database_exists eq 1){
+
+               $pagedata = "<h2>View Templates</h2>";
+               $pagedata = $pagedata .  "<div class=\"errorbox\">The template database doesn't exist and will be created when a template is added.</div>";
+
+               return $pagedata;
+
+       }
+       
+       # Place the table cell headings into the templatedata string.
+
+       $templatedata = "<table cellspacing=\"0\" cellpadding=\"5\"><tr><td class=\"tablecellheader\">Template Filename</td><td class=\"tablecellheader\">Template Name</td><td class=\"tablecellheader\">Template Description</td><td class=\"tablecellheader\">Options</td></tr>";
+
+       # Check if the database exists first before loading it.
+
+       if ($template_database_exists eq 1){
+
+       } else {
+
+               # Load the SQLite database.
+
+               $database_handle        = DBI->connect("dbi:SQLite:dbname=templates.db");
+               $string_handle          = $database_handle->prepare("SELECT * FROM kiriwrite_templates ORDER BY filename ASC") or die(kiriwrite_error("templatedatabaseinvalidformat"));
+               $string_handle->execute();
+
+               # Process each template.
+
+               while (@database_template = $string_handle->fetchrow_array()){
+
+                       # Get certain values from the array.
+
+                       $template_filename      = $database_template[0];
+                       $template_name          = $database_template[1];
+                       $template_description   = $database_template[2];
+                       $template_data          = $database_template[3];
+
+                       # Convert the data into information that can be displayed.
+
+                       $template_filename      = kiriwrite_convert($template_filename, "normal_display");
+                       $template_name          = kiriwrite_convert($template_name, "normal_display");
+                       $template_description   = kiriwrite_convert($template_description, "normal_display");
+                       $template_data          = kiriwrite_convert($template_data, "normal_display");
+
+                       # Check what style the row of table cells should be.
+
+                       if ($template_style eq 0){
+
+                               $template_stylename = "tablecell1";
+                               $template_style = 1;
+
+                       } else {
+
+                               $template_stylename = "tablecell2";
+                               $template_style = 0;
+
+                       }
+
+                       # Check if the template name and descriptions are blank and if
+                       # they are then insert a message saying that there's no name
+                       # or no description.
+
+                       if (!$template_name){
+                               $template_name = "<i>No Name</i>";
+                       }
+
+                       if (!$template_description){
+                               $template_description = "<i>No Description</i>";
+                       }
+
+                       # Check if there is no template data and if there isn't write
+                       # a blank template message.
+
+                       if (!$template_data){
+                               $template_filename = $template_filename . " <i>[Blank Template]</i>";
+                       }
+
+                       # Append the table row to the templatedata string.
+
+                       $templatedata = $templatedata . "<tr><td class=\"" . $template_stylename  . "\">" . $template_filename . "</td><td class=\"" . $template_stylename  . "\">" . $template_name . "</td><td class=\"" . $template_stylename  . "\">" . $template_description . "</td><td class=\"" . $template_stylename  . "\"><a href=\"kiriwrite.cgi?mode=template&action=edit&template=" . $template_filename . "\">Edit</a> <a href=\"kiriwrite.cgi?mode=template&action=delete&template=" . $template_filename . "\">Delete</a></td></tr>";
+
+                       # Increment the template counter.
+
+                       $template_count++;
+
+               }
+
+       }
+       
+       $templatedata = $templatedata . "</table>";
+
+       # Check if any templates are in the database and if there isn't
+       # then write a message saying that there are no templates in the
+       # database.
+
+       if ($template_count eq 0){
+               $templatedata = "<div class=\"errorbox\">There are no templates in the template database. To add a template click on the Add Template link.</div>";
+       }
+
+       # Process the templatedata into pagedata.
+
+       $pagedata = "<h2>View Templates</h2>";
+       $pagedata = $pagedata . $templatedata;
+       
+       return $pagedata;
+       
+}
+
+sub kiriwrite_database_add{
+#################################################################################
+# kiriwrite_database_add: Creates a new database.                              #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_database_add(filename, name, description, [confirm]);              #
+#                                                                              #
+# filename     Specifies the filename for the database.                        #
+# name         Specifies a (friendly) name for the database.                   #
+# description  Specifies a description for the database.                       #
+# confirm      Confirms the action to create a database.                       #
+#################################################################################
+
+       # Get the variables passed from the subroutine.
+       
+       my ($database_filename, $database_name, $database_description, $database_notes, $database_categories, $database_confirm) = @_;
+
+       # Load the perl modules for this subroutine.
+
+       use DBI;
+
+       # Check if the confirm value is blank and if it is then
+       # set the confirm value to 0.
+
+       if (!$database_confirm){
+
+               # The confirm value was blank so set the value to 0.
+
+               $database_confirm = 0;
+
+       }
+       
+       
+       if ($database_confirm eq 1){
+
+               # The action to create a new database is confirmed.
+                       
+               # Validate the database name and database descriptions.
+
+               my $database_name_check_utf8            = kiriwrite_variablecheck($database_name, "utf8", 0, 0);
+               my $database_description_check_utf8     = kiriwrite_variablecheck($database_description, "utf8", 0, 0);
+               my $database_notes_check_utf8           = kiriwrite_variablecheck($database_notes, "utf8", 0, 0);
+               my $database_categories_check_utf8      = kiriwrite_variablecheck($database_categories, "utf8", 0, 0);
+
+               # Convert the UTF8 strings before checking the length of the strings.
+
+               $database_name                  = kiriwrite_utf8convert($database_name);
+               $database_description           = kiriwrite_utf8convert($database_description);
+               $database_notes                 = kiriwrite_utf8convert($database_notes);
+               $database_categories            = kiriwrite_utf8convert($database_categories);
+
+               my $database_name_check_blank           = kiriwrite_variablecheck($database_name, "blank", 0, 1);               
+               my $database_name_check_length          = kiriwrite_variablecheck($database_name, "maxlength", 256, 1);
+               my $database_description_check_length   = kiriwrite_variablecheck($database_description, "maxlength", 512, 1);
+               my $database_filename_check_length      = kiriwrite_variablecheck($database_filename, "maxlength", 64, 1);
+               my $database_categories_check_length    = kiriwrite_variablecheck($database_categories, "maxlength", 512, 1);
+
+               # Check if values returned contains any values that would
+               # result in a specific error message being returned.
+
+               if ($database_name_check_length eq 1){
+
+                       # The length of the database name is too long, so return an error.
+                       kiriwrite_error("databasenametoolong");
+
+               }
+
+               if ($database_description_check_length eq 1){
+
+                       # The database description length is too long, so return an error.
+                       kiriwrite_error("databasedescriptiontoolong");
+
+               }
+
+               if ($database_name_check_blank eq 1){
+
+                       # The database name is blank, so return an error.
+                       kiriwrite_error("databasenameblank");
+
+               }
+
+               if ($database_filename_check_length eq 1){
+
+                       # The database filename is to long, so return an error.
+                       kiriwrite_error("databasefilenametoolong");
+
+               }
+
+               if ($database_categories_check_length eq 1){
+
+                       # The database categories is too long, so return an error.
+                       kiriwrite_error("databasecategoriestoolong");
+
+               }
+
+               # Check if the database filename is blank and if it is then
+               # generate a filename.
+                       
+               if ($database_filename eq ""){
+                       
+                       # Filename is blank so generate a file name from
+                       # the database name.
+                               
+                       $database_filename = kiriwrite_processfilename($database_name);
+                               
+                       # Check to make sure that the database filename really
+                       # is valid.
+                               
+                       kiriwrite_variablecheck($database_filename, "filename", "", 0);
+                       kiriwrite_variablecheck($database_filename, "maxlength", 64, 0);
+                               
+                       # Check if the database and database configuration file does
+                       # not already exist.
+                               
+                       if (-e $kiriwrite_config{"directory_data_db"} . '/' . $database_filename . '.db'){
+                                       
+                               # A filename exists, so abort the script telling the user that those files exist.
+                               kiriwrite_error("fileexists");
+                                       
+                       }                               
+                       
+               } else {
+                       
+                       # Filename is not blank, so check if the filenames are already
+                       # being used and if the actual filename itself is valid.
+                       
+                       # Check the filename to make sure the database and the database configuration file does not already exist.
+                       
+                       if (-e $kiriwrite_config{"directory_data_db"} . '/' . $database_filename . '.db' ){
+                               
+                               # A filename exists, so abort the script telling the user that those files exist.
+                                       
+                               kiriwrite_error("fileexists");
+                                       
+                               
+                       }
+                               
+                       # Check to make sure the database filename itself really is 
+                       # valid.
+                               
+                       kiriwrite_variablecheck($database_filename, "filename", "", 0);
+                       kiriwrite_variablecheck($database_filename, "maxlength", 64, 0);
+                               
+               }
+
+               # Convert certain data so that the SQL query doesn't break.
+
+               my $database_name_final = $database_name;
+               $database_name          = kiriwrite_convert($database_name, "kiriwrite");
+               $database_description   = kiriwrite_convert($database_description, "kiriwrite");
+               $database_categories    = kiriwrite_convert($database_categories, "kiriwrite");
+                       
+               # Populate the database with the infomration and page tables.
+
+               my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database_filename . ".db");
+               my $string_handle       = $database_handle->prepare('CREATE TABLE kiriwrite_database_info(
+                       name varchar(256) primary key, 
+                       description varchar(512), 
+                       notes text, 
+                       categories varchar(512), 
+                       kiriwrite_version_major int(4), 
+                       kiriwrite_version_minor int(4), 
+                       kiriwrite_version_revision int(4)
+               )');
+               $string_handle->execute();
+
+               $string_handle  = $database_handle->prepare('CREATE TABLE kiriwrite_database_pages(
+                       filename varchar(256) primary key, 
+                       pagename varchar(512), 
+                       pagedescription varchar(512), 
+                       pagesection varchar(256),
+                       pagetemplate varchar(64),
+                       pagedata text,
+                       pagesettings int(1),
+                       lastmodified datetime
+               )');
+               $string_handle->execute();
+
+               # Add an entry to the kiriwrite_database_info table.
+
+               $string_handle = $database_handle->prepare('INSERT INTO kiriwrite_database_info values(
+                       \'' . $database_name . '\',
+                       \'' . $database_description . '\',
+                       \'' . $database_notes . '\',
+                       \'' . $database_categories . '\',
+                       \'' . $kiriwrite_version{"major"} . '\',
+                       \'' . $kiriwrite_version{"minor"} . '\',
+                       \'' . $kiriwrite_version{"revision"} . '\'
+               )');
+               $string_handle->execute();
+               
+               $database_name_final = kiriwrite_convert($database_name_final, "normal_display");
+       
+               my $pagedata    = "<h2>Add Database</h2>";
+               $pagedata       = $pagedata . "Database '" . $database_name_final  . "' has been created.<br><br>\r\n";
+               $pagedata       = $pagedata . "<a href=\"kiriwrite.cgi?mode=db\">Return to database list</a>";
+                       
+               return $pagedata;
+                               
+       }
+               
+       # There is confirm value is not 1, so write a form for creating a database to
+       # store pages in.
+                       
+       my $pagedata    = "<h2>Add Database</h2>\r\n";
+               
+       $pagedata       = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
+       $pagedata       = $pagedata . "\t\t\t<table cellpadding=\"5\" cellspacing=\"0\">\r\n";
+       $pagedata       = $pagedata . "\t\t<input type=\"hidden\" name=\"mode\" value=\"db\">\r\n";
+       $pagedata       = $pagedata . "\t\t<input type=\"hidden\" name=\"action\" value=\"new\">\r\n";
+       $pagedata       = $pagedata . "\t\t<input type=\"hidden\" name=\"confirm\" value=\"1\">\r\n";
+       $pagedata       = $pagedata . "<tr><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
+       $pagedata       = $pagedata . "<tr><td class=\"tablecell1\">Database name</td><td class=\"tablecell2\"><input type=\"text\" size=\"64\" maxlength=\"256\" name=\"databasename\"></td></tr>";
+       $pagedata       = $pagedata . "<tr><td class=\"tablecell1\">Database description</td><td class=\"tablecell2\"><input type=\"text\" size=\"64\" maxlength=\"512\" name=\"databasedescription\"></td></tr>";
+       $pagedata       = $pagedata . "<tr><td class=\"tablecell1\">Database notes</td><td class=\"tablecell2\"><textarea name=\"databasenotes\" wrap=\"off\" cols=\"50\" rows=\"10\"></textarea></td></tr>";
+       $pagedata       = $pagedata . "<tr><td class=\"tablecell1\">Database categories</td><td class=\"tablecell2\"><input type=\"text\" size=\"64\" maxlength=\"512\" name=\"databasecategories\"></td></tr>";
+       $pagedata       = $pagedata . "<tr><td class=\"tablecell1\">Database filename</td><td class=\"tablecell2\"><input type=\"text\" size=\"32\" maxlength=\"64\" name=\"databasefilename\"><br />
+               <ul>
+                       <li>Leave the filename blank to automatically generate a filename.</li>
+                       <li>Don't include .db as it will be appended automatically.</li>
+                       <li>The filename cannot be any more than 64 characters long.</li>
+                       <li>The filename should only contain letters and numbers, no spaces.</li>
+               </ul>           
+       </td></tr>";
+       $pagedata       = $pagedata . "\t\t\t</table>\r\n";
+       $pagedata       = $pagedata . "\t\t\t<br />\r\n";
+       $pagedata       = $pagedata . "\t\t\t<input type=\"submit\" value=\"Add Database\"> | <input type=\"reset\" value=\"Clear values\">";
+       $pagedata       = $pagedata . "\t\t</form>\r\n";
+               
+       # Exit the subroutine taking the data in the pagadata variable with it.
+               
+       return $pagedata;
+
+}
+
+sub kiriwrite_database_edit{
+#################################################################################
+# kiriwrite_database_edit: Edits an database.                                  #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_database_edit(filename, name, description, newfilename, newname,   #
+#                              newdescription, notes, categories, [confirm]);  #
+#                                                                              #
+# filename             Specifies the filename of the database.                 #
+# name                 Specifies the name of the database.                     #
+# description          Specifies the description of the database.              #
+# newfilename          Specifies the new filename of the database.             #
+# newname              Specifies the new name of the database.                 #
+# newdescription       Specifies the new description of the database.          #
+# notes                        Specifies the new notes of the database.                #
+# categories           Specifies the new categories of the database.           #
+# confirm              Confirms the action to edit a database.                 #
+#################################################################################
+
+       # First, get all the variables passed to the subroutine.
+
+       my ($database_shortname, $database_name, $database_description, $database_newfilename, $database_newname, $database_newdescription, $database_notes, $database_categories, $database_confirm) = @_;
+
+       # Load the needed Perl modules.
+       
+       use DBI;
+       
+       # Check if the database confirm value is blank and if it is
+       # set the confirm value to 0.
+
+       if (!$database_confirm){
+
+               $database_confirm = 0;
+
+       }
+
+       # Check if the confirm variable has a value in it, if it has, check again to make sure it really is the correct value (Perl moans
+       # if $database_confirm was used directly).
+
+       if ($database_confirm eq 1){
+
+               # Check if the database exists before trying to edit it.
+
+               my $database_exists     = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database_shortname . '.db');
+
+               if ($database_exists eq 1){
+
+                       # The database does not exist so return an error.
+       
+                       kiriwrite_error("databasemissingfile");
+
+               }
+               
+               # Check if the new data passes the validation tests below. First, check the length of the variables.
+
+               my $database_name_check_utf8            = kiriwrite_variablecheck($database_newname, "utf8", 0, 0);
+               my $database_description_check_utf8     = kiriwrite_variablecheck($database_newdescription, "utf8", 0, 0);
+               my $database_notes_check_utf8           = kiriwrite_variablecheck($database_notes, "utf8", 0, 0);
+               my $database_categories_check_utf8      = kiriwrite_variablecheck($database_categories, "utf8", 0, 0);
+
+               # Convert the UTF8 strings to make sure their length is accurate.
+
+               $database_newname               = kiriwrite_utf8convert($database_newname);
+               $database_newdescription        = kiriwrite_utf8convert($database_newdescription);
+               $database_notes                 = kiriwrite_utf8convert($database_notes);
+               $database_categories            = kiriwrite_utf8convert($database_categories);
+
+               # Check if the database filename given is valid and return an error
+               # if it isn't.
+
+               kiriwrite_variablecheck($database_shortname, "filename", "", 0);
+
+               # Preform the following tests.
+               
+               my $database_filename_check_length      = kiriwrite_variablecheck($database_newfilename, "maxlength", 64, 1);
+               my $database_filename_letnum            = kiriwrite_variablecheck($database_newfilename, "filename", 0, 0);
+               my $database_name_check_length          = kiriwrite_variablecheck($database_newname, "maxlength", 256, 1);
+               my $database_description_check_length   = kiriwrite_variablecheck($database_newdescription, "maxlength", 512, 1);
+               my $database_categories_check_length    = kiriwrite_variablecheck($database_categories, "maxlength", 512, 1);
+               my $database_name_check_blank           = kiriwrite_variablecheck($database_newname, "blank", 0, 1);
+
+               # Check if the data is valid and return a specific error if it doesn't.
+
+               if ($database_name_check_length eq 1){
+
+                       # The length of the database name is too long, so return an error.
+                       kiriwrite_error("databasenametoolong");
+
+               }
+
+               if ($database_description_check_length eq 1){
+
+                       # The database description length is too long, so return an error.
+                       kiriwrite_error("databasedescriptiontoolong");
+
+               }
+
+               if ($database_name_check_blank eq 1){
+
+                       # The database name is blank, so return an error.
+                       kiriwrite_error("databasenameblank");
+
+               }
+
+               if ($database_filename_check_length eq 1){
+
+                       # The database filename is too long, so return an error.
+                       kiriwrite_error("databasefilenametoolong");
+
+               }
+
+               if ($database_categories_check_length eq 1){
+
+                       # The database categories is too long, so return an error.
+                       kiriwrite_error("databasecategoriestoolong");
+
+               }
+
+               # Check the permissions of the database file to see if it is valid
+               # and return an error if it isn't.
+
+               my $database_file_permissions = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database_shortname . '.db', 1, 1, 1);
+
+               if ($database_file_permissions eq 1){
+
+                       # The database file itself has invalid permissions.
+
+                       kiriwrite_error("databaseinvalidpermissions");
+
+               }
+
+               # Check if the old and new filenames have changed, if they have then rename the database file.
+                       
+               my $pagedata;
+                       
+               $pagedata = "<h2>Edit Database</h2>";
+               
+               if ($database_shortname ne $database_newfilename){
+
+                       # Old name does not match with the new filename, so rename the database file.
+                       
+                       # Check if a database with the same shortname already exists, if it does then return with an error.
+                               
+                       if (-e $kiriwrite_config{"directory_data_db"} . '/' . $database_newfilename . '.db'){
+                               kiriwrite_error("databasealreadyexists");
+                       }
+
+                       # Change the database filename.
+               
+                       rename($kiriwrite_config{"directory_data_db"} . '/' . $database_shortname . '.db', $kiriwrite_config{"directory_data_db"} . '/' . $database_newfilename . '.db');
+                       unlink($kiriwrite_config{"directory_data_db"} . '/' . $database_shortname . '.db');
+
+                       # Set the filename to the new filename.
+
+                       $database_shortname = $database_newfilename;
+
+               }
+                       
+               # Load the SQLite database.
+
+               my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database_shortname . ".db");
+
+               # Convert the UTF8 strings so that they can be properly updated.
+
+               $database_name                  = kiriwrite_utf8convert($database_name);
+               $database_description           = kiriwrite_utf8convert($database_description);
+
+               # Convert the strings that are going to put into the database so that
+               # the database query doesn't break.
+
+               $database_name                  = kiriwrite_convert($database_name, "kiriwrite");                               
+               $database_newname               = kiriwrite_convert($database_newname, "kiriwrite");
+               $database_description           = kiriwrite_convert($database_description, "kiriwrite");        
+               $database_newdescription        = kiriwrite_convert($database_newdescription, "kiriwrite");
+                       
+               my $string_handle       = $database_handle->prepare('UPDATE kiriwrite_database_info SET name = \'' . $database_newname . '\', description = \'' . $database_newdescription . '\', notes = \'' . $database_notes . '\', categories = \'' . $database_categories . '\' WHERE name = \'' . $database_name . '\' AND description = \'' . $database_description . '\'') or kiriwrite_error("databasefileinvalid");
+               $string_handle->execute();
+
+               # Convert a string so that it can be displayed properly.
+
+               $database_newname = kiriwrite_convert($database_newname, "normal_display");
+
+               # Write out a message saying that the database has been updated.
+
+               $pagedata = $pagedata . "Database '" . $database_newname . "' updated.<br>";
+               $pagedata = $pagedata . "<br>\r\n<a href=\"kiriwrite.cgi?mode=db\">Return to database list.</a>";
+                       
+               return $pagedata;
+               
+       } else {
+
+               # Check if the database filename given is valid and return an error
+               # if it isn't.
+
+               kiriwrite_variablecheck($database_shortname, "filenameindir", "", 0);
+
+               # Check if the database exists before trying to edit it.
+
+               my $database_exists     = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database_shortname . '.db');
+
+               if ($database_exists eq 1){
+
+                       # The database does not exist so return an error.
+       
+                       kiriwrite_error("databasemissingfile");
+
+               }
+
+
+               # Check the permissions of the database file to see if it is valid
+               # and return an error if it isn't.
+
+               my $database_file_permissions = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database_shortname . '.db', 1, 0, 1);
+
+               if ($database_file_permissions eq 1){
+
+                       # The database file itself has invalid permissions.
+
+                       kiriwrite_error("databaseinvalidpermissions");
+
+               }
+
+               # Load the SQLite database.
+
+               my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database_shortname . ".db");
+               my $string_handle       = $database_handle->prepare("SELECT * FROM kiriwrite_database_info LIMIT 1") or kiriwrite_error("databasefileinvalid");
+               $string_handle->execute();
+               my @database_info               = $string_handle->fetchrow_array();
+
+               # Get the values needed from the kiriwrite_database_info table.
+
+               my $database_oldname            = $database_info[0];
+               my $database_olddescription     = $database_info[1];
+               my $database_notes              = $database_info[2];
+               my $database_categories         = $database_info[3];
+
+               # Convert the values in the kieiwrite format into the format that can be understood
+               # with a web browser.
+
+               $database_oldname               = kiriwrite_convert($database_oldname, "normal_display");
+               $database_olddescription        = kiriwrite_convert($database_olddescription, "normal_display");
+               $database_notes                 = kiriwrite_convert($database_notes, "normal_display");
+               $database_categories            = kiriwrite_convert($database_categories, "normal_display");
+
+               # Print out the form for editing a database's settings.
+                               
+               my $pagedata = "<h2>Edit Database '" . $database_oldname . "'</h2>";
+               $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">\r\n";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"db\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"edit\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"database\" value=\"" . $database_shortname . "\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"yes\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"olddatabasename\" value=\"" . $database_oldname . "\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"olddatabasedescription\" value=\"" . $database_olddescription . "\">";
+               $pagedata = $pagedata . "<table cellspacing=\"0\" cellpadding=\"5\">\r\n";
+               $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Database name</td><td class=\"tablecell2\"><input type=\"text\" name=\"databasename\" value=\"" . $database_oldname . "\" maxlength=\"256\" size=\"64\"></td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Database description</td><td class=\"tablecell2\"><input name=\"databasedescription\" maxlength=\"512\" size=\"64\" value=\"" . $database_olddescription . "\"></td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Database notes</td><td class=\"tablecell2\"><textarea name=\"databasenotes\" cols=\"50\" rows=\"10\" wrap=\"off\">" . $database_notes . "</textarea></td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Database categories</td><td class=\"tablecell2\"><input name=\"databasecategories\"  value=\"" . $database_categories . "\"  size=\"64\" maxlength=\"512\"></td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Database filename</td><td class=\"tablecell2\"><input name=\"databasefilename\" maxlength=\"64\" size=\"64\" value=\"" . $database_shortname . "\"></td></tr>";           
+               $pagedata = $pagedata . "</table><p />";
+               
+               $pagedata = $pagedata . "<input type=\"submit\" value=\"Edit settings\" /> | <input type=\"reset\" value=\"Reset settings\" />";
+               $pagedata = $pagedata . "</form>";
+               return $pagedata;
+       
+       }
+       
+       # The interpreter should not be here. So return an error saying invalid variable.
+       
+       kiriwrite_error("invalidvariable");
+
+}
+
+sub kiriwrite_database_delete{
+#################################################################################
+# kiriwrite_database_delete: Deletes an database.                              #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_database_delete(filename, [confirm]);                              #
+#                                                                              #
+# filename     Specifies the filename for the database to be deleted.          #
+# confirm      Confirms the action to delete a database.                       #
+#################################################################################
+
+       my ($database_filename, $database_confirm) = @_;
+       
+       # Load the CGI module and the XML::Simple module for this subroutine.
+       
+       use DBI;
+       
+       # Check if the confirm value is blank and if it is then set the
+       # confirm value to 0.
+
+       if (!$database_confirm){
+
+               $database_confirm = 0;
+
+       }
+
+       # Check if the database exists before trying to edit it.
+
+       my $database_exists     = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database_filename . '.db');
+
+       if ($database_exists eq 1){
+
+               # The database does not exist so return an error.
+       
+               kiriwrite_error("databasemissingfile");
+
+       }
+
+       # Check if the database filename given is valid and return an error
+       # if it isn't.
+
+       kiriwrite_variablecheck($database_filename, "filename", "", 0);
+
+       # Check if the request to delete a database has been confirmed. If it has, 
+       # then delete the database itself.
+       
+       if ($database_confirm eq 1){
+               # There is a value in the confirm variable of the HTTP query.
+               
+               # Before deleting, check the permissions of the database file.
+                       
+               my $deleted_database_file_permissions                   = 0;
+                       
+               my $pagedata = "";
+
+               $deleted_database_file_permissions = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database_filename . '.db', 1, 1, 1);
+
+               if ($deleted_database_file_permissions eq 1){
+
+                       # The database file itself has invalid permissions.
+
+                       kiriwrite_error("databaseinvalidpermissions");
+
+               }
+               
+               # Load the SQLite database to get the database name.
+
+               my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database_filename . '.db');
+               my $string_handle       = $database_handle->prepare("SELECT * FROM kiriwrite_database_info LIMIT 1");
+               $string_handle->execute;
+               my @database_info       = $string_handle->fetchrow_array();
+
+               my $database_name = $database_info[0];
+               $database_name = kiriwrite_convert($database_name, "normal_display");
+
+               # Untaint the database filename given.
+
+               ($database_filename) = $database_filename =~ /^([a-zA-Z0-9.]+)$/;
+
+               # Delete the database file.
+
+               unlink($kiriwrite_config{"directory_data_db"} . '/' . $database_filename . '.db');
+       
+               # Write a message saying that the database has been deleted.
+               
+               $pagedata = "<h2>Database Deleted</h2>";
+               $pagedata = $pagedata . "Database '" . $database_name . "' was deleted.<br />\r\n";
+
+               $pagedata = $pagedata . "<br><a href=\"kiriwrite.cgi?mode=db\">Return to database list.</a>"; 
+                       
+               return $pagedata;
+               
+       }
+       
+       # The action has not been confirmed, so write out a form asking the 
+       # user to confirm.
+       
+       # Check the permissions of the database file to see if they are valid
+       # and return an error if it isn't.
+
+       my $delete_database_file_permissions = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database_filename . '.db', 1, 1, 1);
+
+       if ($delete_database_file_permissions eq 1){
+
+               # The database file itself has invalid permissions.
+
+               kiriwrite_error("databaseinvalidpermissions");
+
+       }
+
+       # Load the SQLite database to get the database name.
+       
+       my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database_filename . '.db');
+       my $string_handle       = $database_handle->prepare("SELECT * FROM kiriwrite_database_info LIMIT 1");
+       $string_handle->execute;
+       my @database_info       = $string_handle->fetchrow_array();
+
+       # Convert the database name so that it can be displayed properly.
+
+       my $database_name = $database_info[0];
+       $database_filename      = kiriwrite_convert($database_filename, "normal_display");
+       $database_name          = kiriwrite_convert($database_name, "normal_display");
+       
+       # Write out the form to ask the user to confirm the deletion of the 
+       # selected database.
+       
+       my $pagedata = "<h2>Database Deletion</h2>";
+       $pagedata = $pagedata . "\t\tAre you sure you want to delete '". $database_name . "'\?<br><br>";
+       $pagedata = $pagedata . "\t\t<form action=\"kiriwrite.cgi\" method=\"POST\">\r\n";
+       $pagedata = $pagedata . "\t\t<input type=\"hidden\" name=\"mode\" value=\"db\">";
+       $pagedata = $pagedata . "\t\t<input type=\"hidden\" name=\"action\" value=\"delete\">";
+       $pagedata = $pagedata . "\t\t<input type=\"hidden\" name=\"database\" value=\"" . $database_filename . "\">";
+       $pagedata = $pagedata . "\t\t<input type=\"hidden\" name=\"confirm\" value=\"1\">";
+       $pagedata = $pagedata . "\t\t<input type=\"submit\" value=\"Delete Database\"> | <a href=\"kiriwrite.cgi?mode=db\">Return to database list.</a>";
+       $pagedata = $pagedata . "\t\t</form>\r\n";
+               
+       return $pagedata;
+
+}
+
+sub kiriwrite_database_list{
+#################################################################################
+# kiriwrite_database_list: Lists the databases available.                      #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_database_list();                                                   #
+#################################################################################
+
+       # Load the following Perl modules.
+       use DBI;
+
+       # Check the directory to make sure the permissions are settings are valid
+       # and return an error if the permission settings are invalid.
+
+       my $data_directory_permissions = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"}, 1, 0);
+
+       if ($data_directory_permissions eq 1){
+
+               # The data directory has invalid permissions set, so return an error.
+
+               kiriwrite_error("datadirectoryinvalidpermissions");
+
+       }
+
+       # Open the directory and get the list of all files ending with .xml and
+       # put them into the data_directory array.
+
+       opendir(DATADIR, $kiriwrite_config{"directory_data_db"});
+       my @data_directory = grep /m*\.db/, readdir(DATADIR);
+       closedir(DATADIR);
+       
+       # Declare the following variables that are going to be used before using 
+       # the foreach function.
+       
+       my $pagedata = "";
+       my $database_count = 0;
+       my $database_handle = "";
+       my $database_filename = "";
+       my $database_filename_friendly = "";
+       my $database_filename_length = 0;
+       my $database_permissions = "";
+       my $data_file = "";
+       my $string_handle = "";
+       my @database_info;
+       my $table_style = 0;
+       my $table_style_name = "";
+       my $permissions_warning = 0;
+       my $permissions_list = "";
+       my $invalid_warning = 0;
+       my $invalid_list = "";
+       
+       # Begin creating the table for the list of databases.
+       
+       $pagedata = "<h2>Database List</h2>\r\n";
+       
+       $pagedata = $pagedata . "<table cellpadding=\"5\" cellspacing=\"0\"><tr><td class=\"tablecellheader\">Database Name</td><td class=\"tablecellheader\">Database Description</td><td class=\"tablecellheader\">Options</td></tr>\r\n";
+       
+       foreach $data_file (@data_directory){
+               # Check the database file permissions before opening it.
+
+               $database_filename = $kiriwrite_config{"directory_data_db"} . '/' . $data_file;
+               $database_permissions = kiriwrite_filepermissions($database_filename, 1, 0, 0);
+
+               if ($database_permissions eq 1){
+                       $permissions_warning = 1;
+                       $permissions_list = $permissions_list . $data_file . "<br>\r\n";
+                       next;
+               }
+
+               # Load the SQLite database.
+               
+               $database_handle = DBI->connect("dbi:SQLite:dbname=" . $database_filename);
+
+               # Query the SQLite database or return an error (meaning that the database is in
+               # a invalid format).
+
+               $string_handle = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or (
+                       $invalid_list = $invalid_list . $data_file . "<br>\r\n",
+                       $invalid_warning = 1,
+                       next
+               );
+
+               $string_handle->execute();
+               @database_info = $string_handle->fetchrow_array();
+               
+               # Check the style to be used with.
+
+               if ($table_style eq 0){
+
+                       # Use the first style and set the style value
+                       # to use the next style, the next time the
+                       # if statement is checked.
+
+                       $table_style_name = "tablecell1";
+                       $table_style = 1;
+               } else {
+
+                       # Use the second style and set the style
+                       # value to use the first style, the next
+                       # time if statement is checked.
+
+                       $table_style_name = "tablecell2";
+                       $table_style = 0;
+               }
+
+               $database_info[0] = kiriwrite_convert($database_info[0], "normal_display");
+               $database_info[1] = kiriwrite_convert($database_info[1], "normal_display");
+
+               # Create a friendly name for the database.
+
+               $database_filename_length = length($data_file);
+               $database_filename_friendly = substr($data_file, 0, $database_filename_length - 3);
+
+               # Append the database information to the table.
+
+               $pagedata = $pagedata . "<tr><td class=\"" . $table_style_name . "\"><a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_filename_friendly . "\">" . $database_info[0] . "</a></td><td class=\"" . $table_style_name . "\">" . $database_info[1] . "</td><td class=\"" . $table_style_name . "\"><a href=\"kiriwrite.cgi?mode=db&action=edit&&database=" . $database_filename_friendly . "\">Edit</a> <a href=\"kiriwrite.cgi?mode=db&action=delete&database=" . $database_filename_friendly . "\">Delete</a> <a href=\"kiriwrite.cgi?mode=compile&action=compile&type=single&database=" . $database_filename_friendly . "\">Compile</a></td></tr>\r\n";
+
+               $database_count++;
+               
+       }
+       
+       $pagedata = $pagedata . "</table>\r\n<br />";
+
+       # Check if there are no valid databases are if there is no
+       # valid databases then write a message saying that no
+       # valid databases are available.
+
+       if ($database_count eq 0){
+
+               # 
+
+               $pagedata = "<h2>Database List</h2><p>";
+               $pagedata = $pagedata . "<div class=\"errorbox\">There are no databases that can be used. To create a database click on the Add Database link.</div><p>";
+
+       }
+
+       # Check if any databases with problems have appeared and if they
+       # have, print out a message saying which databases have problems.
+
+       if ($permissions_warning eq 1){
+
+               $pagedata = $pagedata . "<h4>Databases with invalid permissions</h4>";
+               $pagedata = $pagedata . "The following databases have invalid permissions set:<br><br>";
+               $pagedata = $pagedata . $permissions_list;
+
+       }
+       
+       if ($invalid_warning eq 1){
+
+               $pagedata = $pagedata . "<h4>Databases with invalid formats</h4>";
+               $pagedata = $pagedata . "The following databases are in a invalid format:<br><br>";
+               $pagedata = $pagedata . $invalid_list;
+
+       }
+
+       return $pagedata;       # Return to the main part of the script with the processed information.
+
+}
+
+
+sub kiriwrite_filter_list{
+#################################################################################
+# kiriwrite_filter_list: Lists the filters that will be used when compiling a  #
+# webpage.                                                                     #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_filter_list();                                                     #
+#################################################################################
+       
+       # Load the needed Perl modules.
+
+       use DBI;
+
+       # Check if the filters database exists and the
+       # permissions for the filters database are
+       # valid.
+
+       my $database_exists             = kiriwrite_fileexists("filters.db");
+       my $database_permissions        = kiriwrite_filepermissions("filters.db", 1, 0, 0);
+       my $filtersdb_notexist = 0;
+
+       if ($database_exists eq 1){
+
+               # The filters database does not exist so
+               # set the value for the filters database
+               # not existing to 1.
+
+               $filtersdb_notexist = 1;                
+
+       } 
+
+       if ($database_permissions eq 1 && $database_exists ne 1){
+
+               # The filters database has invalid
+               # permissions set, so return an error.
+
+               kiriwrite_error("filtersdbpermissions");
+
+       }
+
+       # Define some variables required for processing the filters list.
+
+       my @database_filters;
+       my $database_handle;
+       my $string_handle;
+       my $pagedata = "";
+       my $filterdata = "";
+       my $filterswarning = "";
+       my $filter_id;
+       my $filter_id_out;
+       my $filter_find;
+       my $filter_find_out;
+       my $filter_replace;
+       my $filter_replace_out;
+       my $filter_count = 0;
+       my $filter_priority;
+       my $filter_priority_out;
+       my $filter_style = 0;
+       my $filter_find_blank = 0;
+       my $filter_style_name = "";
+
+       $pagedata = $pagedata . "<h2>View Filters</h2>";
+
+       # If the filters database exists then get the list of filters,
+       # otherwise write a message saying that the filters database
+       # does not exist and will be created when a filter is added.
+
+       if ($filtersdb_notexist eq 0){
+
+               # Get the SQLite database and get the filters ordered
+               # by priority.
+
+               $database_handle        = DBI->connect("dbi:SQLite:dbname=filters.db");
+               $string_handle          = $database_handle->prepare('SELECT * FROM kiriwrite_filters ORDER BY priority ASC') or kiriwrite_error("filtersdbinvalidformat");
+               $string_handle->execute();
+
+               $filterdata = $filterdata . "<table cellspacing=\"0\" cellpadding=\"5\">";
+               $filterdata = $filterdata . "<tr><td class=\"tablecellheader\">Priority</td><td class=\"tablecellheader\">Find Setting</td><td class=\"tablecellheader\">Replace Setting</td><td class=\"tablecellheader\">Options</td></tr>";
+
+               while (@database_filters = $string_handle->fetchrow_array()){
+
+                       # Get the values from the from the array.
+
+                       $filter_id              = $database_filters[0];
+                       $filter_priority        = $database_filters[1];
+                       $filter_find            = $database_filters[2];
+                       $filter_replace         = $database_filters[3];
+
+                       # Convert the values into values that can be displayed.
+
+                       $filter_id_out          = kiriwrite_convert($filter_id, "normal_display");
+                       $filter_priority_out    = kiriwrite_convert($filter_priority, "normal_display");
+                       $filter_find_out        = kiriwrite_convert($filter_find, "normal_display");
+                       $filter_replace_out     = kiriwrite_convert($filter_replace, "normal_display");
+
+                       # Check which style should be used.
+
+                       if ($filter_style eq 0){
+
+                               $filter_style_name = "tablecell1";
+                               $filter_style = 1;
+
+                       } else {
+
+                               $filter_style_name = "tablecell2";
+                               $filter_style = 0;
+
+                       }
+
+                       # Check if the replace filter is blank and if it is
+                       # then say no replace setting is given.
+
+                       if (!$filter_replace){
+
+                               # No replace filter is specified, so write a message
+                               # saying that there is no replace filter.
+
+                               $filter_replace_out = "<i>Replace filter is blank.</i>";
+
+                       }
+
+                       # Check if the find filter is blank.
+
+                       if (!$filter_find && $filter_find_blank eq 0){
+
+                               # No find filter is specified, So write a message saying
+                               # that one of your find filters is blank and needs to be 
+                               # fixed.
+
+                               $filterdata = "<b>Warning</b>: One (or more) of your filters has a blank find filter and needs to be fixed.<br><br>" . $filterdata;
+
+                       }
+
+                       # Add the filter to the list of filters in the database.
+
+                       $filterdata     = $filterdata . "<tr><td class=\"" . $filter_style_name . "\">" . $filter_priority_out . "</td><td class=\"" . $filter_style_name . "\">" . $filter_find_out . "</td><td class=\"" . $filter_style_name . "\">" . $filter_replace_out . "</td><td class=\"" . $filter_style_name . "\"><a href=\"\"><a href=\"kiriwrite.cgi?mode=filter&action=edit&filter=" . $filter_id_out . "\">Edit</a></a> <a href=\"kiriwrite.cgi?mode=filter&action=delete&filter=" . $filter_id_out . "\">Delete</a></td></tr>";
+
+                       $filter_count++;
+
+               }
+
+               $filterdata = $filterdata . "</table>";
+
+               # Check if there are filters in the filters database and
+               # write a message if there isn't.
+
+               if ($filter_count eq 0){
+
+                       # There are no filters in the filters database.
+
+                       $filterswarning = "There are no filters available in the filters database. To add a filter, click on the Add Filter link.";
+
+               }
+
+       }
+
+       # Check if the database wasn't found and if it
+       # wasn't then write a message saying that the
+       # database will be created when a filter is
+       # added.
+
+       if ($filtersdb_notexist eq 1){
+
+               # The filters database doesn't exist so write
+               # a message.
+
+               $filterswarning = "The filters database does not exist and will be created when a filter is added.";
+
+
+       }
+
+       # Check if there is a warning message and if
+       # there is then write that warning message
+       # else write the list of filters.
+
+       if ($filterswarning){
+
+               $pagedata = $pagedata . "<div class=\"errorbox\">";
+               $pagedata = $pagedata . $filterswarning;
+               $pagedata = $pagedata . "</div>";
+
+       } else {
+
+               # The filters database exists so write out the
+               # list of filters.
+
+               $pagedata = $pagedata . $filterdata;
+
+       }
+
+       return $pagedata;
+
+}
+
+sub kiriwrite_filter_add{
+#################################################################################
+# kiriwrite_filter_add: Adds a filter to the filter list.                      #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_filter_add(filterfind, filterreplace, filterpriority,              #
+#                      filternotes, [confirm]);                                #
+#                                                                              #
+# filterfind           Specifies the new word(s) to find.                      #
+# filterreplace                Specifies the new word(s) to replace.                   #
+# filterpriority       Specifies the new priority to use.                      #
+# filternotes          Specifies the new notes to use.                         #
+# confirm              Confirms the action to add a filter.                    #
+#################################################################################
+
+       # Get the values that have been passed to the subroutine.
+       
+       my ($filter_new_find, $filter_new_replace, $filter_new_priority, $filter_new_notes, $confirm) = @_;
+
+       # Load the needed Perl modules.
+
+       use DBI;
+
+       # Check the confirm value to make sure it is no more than
+       # one character long.
+       
+       kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
+       
+       # Define the page data value for later.
+
+       my $pagedata = "";
+       
+       if (!$confirm){
+       
+               # The confirm value is undefined, so set the
+               # value of the confirm integer to '0'.
+       
+               $confirm = 0;
+               
+       }
+       
+       if ($confirm eq 1){
+       
+               # The confirm integer is '1', so add the word
+               # to the filter list.
+       
+               # First, check the variables recieved are UTF8
+               # copliant.
+
+               kiriwrite_variablecheck($filter_new_find, "utf8", 0, 0);
+               kiriwrite_variablecheck($filter_new_replace, "utf8", 0, 0);
+               kiriwrite_variablecheck($filter_new_priority, "utf8", 0, 0);
+
+               # Convert the UTF8 values so that the length can
+               # checked properly.
+
+               $filter_new_find        = kiriwrite_utf8convert($filter_new_find);
+               $filter_new_replace     = kiriwrite_utf8convert($filter_new_replace);
+               $filter_new_priority    = kiriwrite_utf8convert($filter_new_priority);
+
+               # Check if the find filter is blank and return an error
+               # if it is.
+
+               if (!$filter_new_find){
+
+                       # The find filter given is blank so return an
+                       # error.
+
+                       kiriwrite_error("blankfindfilter");
+
+               }
+
+               if (!$filter_new_priority){
+
+                       # The filter priority is blank so set it
+                       # to 1.
+
+                       $filter_new_priority = 1;
+
+               }
+
+               # Check the length and contents of the values given
+               # to make sure they are valid.
+               
+               my $filterfind_maxlength_check          = kiriwrite_variablecheck($filter_new_find, "maxlength", 1024, 1);
+               my $filterreplace_maxlength_check       = kiriwrite_variablecheck($filter_new_replace, "maxlength", 1024, 1);
+               my $filterpriority_maxlength_check      = kiriwrite_variablecheck($filter_new_priority, "maxlength", 5, 1);
+               my $filterpriority_numbers_check        = kiriwrite_variablecheck($filter_new_priority, "numbers", 0, 1);
+
+               # Check if the result of the tests to see if they
+               # are valid.
+
+               if ($filterfind_maxlength_check eq 1){
+
+                       # The find filter is too long, so return
+                       # an error.
+
+                       kiriwrite_error("findfiltertoolong");
+
+               }
+
+               if ($filterreplace_maxlength_check eq 1){
+
+                       # The replace filter is too long, so
+                       # return an error.
+
+                       kiriwrite_error("replacefiltertoolong");
+
+               }
+
+               if ($filterpriority_maxlength_check eq 1){
+
+                       # The length of the filter priority
+                       # given is too long, so return an
+                       # error.
+
+                       kiriwrite_error("filterprioritytoolong");
+
+               }
+
+               if ($filterpriority_numbers_check eq 1){
+
+                       # The priority of the filter given
+                       # contains characters other than
+                       # numbers.
+
+                       kiriwrite_error("filterpriorityinvalidchars");
+
+               }
+
+               # Check if the filter priority is less than 1
+               # and more than 10000 and return an error
+               # if it is.
+
+               if ($filter_new_priority < 1 || $filter_new_priority > 50000){
+
+                       # The filter priority is less than 1 and
+                       # more than 10000, so return an error.
+
+                       kiriwrite_error("filterpriorityinvalid");
+
+               }
+               
+               # Define some variables for later on.
+
+               my @database_filters;
+               my @database_check;
+
+               my $database_handle;
+               my $string_handle;
+               my $chk_database_handle;
+               my $chk_string_handle;
+
+               my $filters_exist;
+               my $filters_permissions;
+               my $filters_count       = 0;
+               my $blankid_found       = 0;
+               my $current_id          = 0;
+               my $next_id             = 0;
+               my $filter_exists       = 0;
+
+               my $first_filter        = 0;
+
+               my $new_id;
+
+               # Check if the filters database exists, has valid
+               # permission settings and if it doesn't create 
+               # the database first.
+
+               $filters_exist = kiriwrite_fileexists("filters.db");
+               
+               if ($filters_exist eq 0){
+               
+                       # The filters database does exist, so don't
+                       # bother trying to create another one.
+
+                       $filters_permissions = kiriwrite_filepermissions("filters.db", 1, 1, 1);
+                       
+                       if ($filters_permissions eq 1){
+
+                               # The filters database has invalid permissions so
+                               # return an error.
+
+                               kiriwrite_error("filtersdbpermissions");                                
+
+                       }
+
+                       # Load the SQLite database.
+
+                       $database_handle        = DBI->connect("dbi:SQLite:dbname=filters.db");
+               
+               } else {
+               
+                       # The filters database does not exist, so create
+                       # the filters database.
+                       
+                       # Check if the filters database can really be
+                       # created.
+
+                       my $directory_permissions = kiriwrite_filepermissions(".", 1, 1, 0);
+
+                       if ($directory_permissions eq 1){
+
+                               # The filters database cannot be created because of invalid directory
+                               # permissions so return an error.
+
+                               kiriwrite_error("filtersdatabasefilenotcreated");
+                       }
+
+                       # Create the filters database.
+
+                       $database_handle        = DBI->connect("dbi:SQLite:dbname=filters.db");
+                       $string_handle          = $database_handle->prepare('create table kiriwrite_filters(
+                                       id int(7) primary key,
+                                       priority int(5),
+                                       findsetting varchar(1024),
+                                       replacesetting varchar(1024),
+                                       notes text
+                               );
+                       ');
+                       $string_handle->execute();
+               
+               }
+
+               $chk_database_handle    = DBI->connect("dbi:SQLite:dbname=filters.db");
+
+               # Find the lowest identification number available.
+
+               $string_handle          = $database_handle->prepare('SELECT * FROM kiriwrite_filters ORDER BY id ASC') or kiriwrite_error("filtersdbinvalidformat");;
+               $string_handle->execute();
+
+               # Process each filter to find a blank identification
+               # number.
+
+               while(@database_filters = $string_handle->fetchrow_array()){
+
+                       # Check the next filter identification number to see
+                       # if it exists and use that identification number if
+                       # it doesn't exist.
+
+                       $current_id             = $database_filters[0];
+                       $next_id                = $current_id + 1;
+                       $chk_string_handle      = $chk_database_handle->prepare('SELECT * FROM kiriwrite_filters WHERE id = \'' . $next_id . '\' LIMIT 1');
+                       $chk_string_handle->execute();
+
+                       while(@database_check = $chk_string_handle->fetchrow_array()){
+
+                               $filter_exists = 1;
+
+
+                       }
+
+                       if ($filter_exists eq 0 && $blankid_found eq 0){
+
+                               $new_id         = $next_id;
+                               $blankid_found  = 1;
+
+                       }
+
+                       # Check if this is the first filter and the current
+                       # identification number is more than 1 and if it
+                       # is then set the new identification number to 1.
+
+                       if ($first_filter eq 0 && $current_id > 1 && $blankid_found eq 0){
+
+                               # The first filter has an identification
+                               # number more than 1, so set the new
+                               # identification number to 1.
+
+                               $new_id         = 1;
+                               $blankid_found  = 1;
+                               $first_filter   = 1;
+
+
+                       }
+
+                       # Set the next identification number as the
+                       # current identification number add one and
+                       # increment the filters count.
+
+                       $first_filter = 1;
+                       $filters_count++;
+                       $filter_exists = 0;
+
+               }
+
+               # Check if there are any filters in the database
+               # and if not set the identification number to 1.
+
+               if ($filters_count eq 0){
+
+                       # No filters were really in the filters
+                       # database.
+
+                       $new_id = 1;
+
+               }
+
+               # Convert the values so that they can be processed
+               # properly.
+
+               my $filter_new_id_sql           = kiriwrite_convert($new_id, "kiriwrite");
+               my $filter_new_priority_sql     = kiriwrite_convert($filter_new_priority, "kiriwrite");
+               my $filter_new_find_sql         = kiriwrite_convert($filter_new_find, "kiriwrite");
+               my $filter_new_replace_sql      = kiriwrite_convert($filter_new_replace, "kiriwrite");
+               my $filter_new_notes_sql        = kiriwrite_convert($filter_new_notes, "kiriwrite");
+
+               # Add the new filter to the filters database.
+
+               $string_handle  = $database_handle->prepare('INSERT INTO kiriwrite_filters VALUES(
+                       \'' . $filter_new_id_sql . '\',
+                       \'' . $filter_new_priority_sql . '\',
+                       \'' . $filter_new_find_sql . '\',
+                       \'' . $filter_new_replace_sql . '\',
+                       \'' . $filter_new_notes_sql . '\'
+               )');
+               $string_handle->execute();
+
+               # Write out a message saying that the filter was added to the
+               # filters database.
+               
+               $pagedata = $pagedata . "<h2>Filter Added</h2>";
+               $pagedata = $pagedata . "The filter was added sucessfully to the filters list.<br><br>";
+               $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=filter\">Return to the filters list.</a>";
+                               
+               return $pagedata;
+               
+       } elsif ($confirm ne 0) {
+       
+               # The confirm integer is another value (which
+               # it shouldn't be) so return an error.
+               
+               kiriwrite_error("invalidvalue");
+       
+       }
+       
+       # The confirm integer was blank so print out a form
+       # for adding a new filter.
+       
+       $pagedata = "<h2>Add Filter</h2>";
+       $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
+       $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"filter\">";
+       $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"add\">";
+       $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
+       $pagedata = $pagedata . "<table cellspacing=0 cellpadding=5>";
+       $pagedata = $pagedata . "<Tr><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Find...</td><td class=\"tablecell2\"><input type=\"input\" name=\"findword\" size=\"64\" maxlength=\"1024\"></td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Replace with...</td><td class=\"tablecell2\"><input type=\"input\" name=\"replaceword\" size=\"64\" maxlength=\"1024\"></td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Filter Priority</td><td class=\"tablecell2\"><input type=\"input\" name=\"priority\" size=\"5\" maxlength=\"5\"><br><ul><li>If no filter priority is specified, the filter priority will be set to 1.</li></ul></td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Filter Notes</td><td class=\"tablecell2\"><textarea name=\"notes\" cols=\"50\" rows=\"10\"></textarea></td></tr>";
+       $pagedata = $pagedata . "</table>";
+       $pagedata = $pagedata . "<br>";
+       $pagedata = $pagedata . "<input type=\"submit\" value=\"Add Filter\"> | <input type=\"reset\" value=\"Clear values\">";
+       $pagedata = $pagedata . "</form>";
+       
+       return $pagedata;
+
+}
+
+sub kiriwrite_filter_edit{
+#################################################################################
+# kiriwrite_filter_edit: Edits a filter from the filter list.                  #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_filter_edit(filternumber, newfilterfind, newfilterreplace,         #
+#                      newfilterpriority, newfilternotes, confirm);            #
+#                                                                              #
+# filterid             Specifies the filter number (line number) in the        #
+#                      filters database.                                       #
+# newfilterfind                Specifies the new word to find.                         #
+# newfilterreplace     Specifies the new word to replace.                      #
+# newfilterpriority    Specifies the new filter priority.                      #
+# newfilternotes       Specifies the new filter notes.                         #
+# confirm              Confirms the action to edit a filter.                   #
+#################################################################################
+
+       # Get the values that have been passed to the subroutine.
+       
+       my ($filter_id, $filter_new_find, $filter_new_replace, $filter_new_priority, $filter_new_notes, $confirm) = @_; 
+
+       # Load the needed Perl modules.
+
+       use DBI;
+
+       # Check the confirm value to make sure it is no more than
+       # one character long.
+
+       kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
+
+       # Define the page data value for later.
+
+       my $pagedata = "";
+
+       # Check if the confirm value is blank and if it is
+       # srt the confirm value to 0.
+
+       if (!$confirm){
+
+               # The confirm value does not have any value
+               # set so set it to 0.
+
+               $confirm = 0;
+
+       }
+
+       # Check if the filter identification number is blank,
+       # contains characters other than numbers and is more
+       # than seven characters long.
+
+       if (!$filter_id){
+
+               # The filter identification number is blank,
+               # so return an error.
+
+               kiriwrite_error("filteridblank");
+
+       }
+
+       my $filter_id_numbers_check     = kiriwrite_variablecheck($filter_id, "numbers", 0, 1);
+
+       if ($filter_id_numbers_check eq 1){
+
+               # The filter identification number contains
+               # characters other than numbers, so return
+               # an error.
+
+               kiriwrite_error("filteridinvalid");
+
+       }
+
+       my $filter_id_maxlength_check   = kiriwrite_variablecheck($filter_id, "maxlength", 7, 1);
+
+       if ($filter_id_maxlength_check eq 1){
+
+               # The filter identification number given
+               # is more than seven characters long, so
+               # return an error.
+
+               kiriwrite_error("filteridtoolong");
+
+       }
+
+       # Check if the filters database exists and the
+       # permissions for it are valid.
+
+       my $filters_exists      = kiriwrite_fileexists("filters.db");
+
+       if ($filters_exists eq 1){
+
+               # The filters database does not exist, so
+               # return an error.
+
+               kiriwrite_error("filtersdbmissing");
+
+       }
+
+       my $filters_permissions = kiriwrite_filepermissions("filters.db", 1, 0);
+
+       if ($filters_permissions eq 1){
+
+               # The filters database has invalid permissions
+               # set, so return an error.
+
+               kiriwrite_error("filtersdbpermissions");
+
+       }
+
+       # Define some variables for later.
+
+       my $database_handle;
+       my $string_handle;
+       my $filter_id_sql       = kiriwrite_convert($filter_id, "kiriwrite");
+       my $filter_id_out       = kiriwrite_convert($filter_id, "normal_display");
+       my $filter_priority;
+       my $filter_priority_sql;
+       my $filter_priority_out;
+       my $filter_find;
+       my $filter_find_sql;
+       my $filter_find_out;
+       my $filter_replace;
+       my $filter_replace_sql;
+       my $filter_replace_out;
+       my $filter_notes;
+       my $filter_notes_sql;
+       my $filter_notes_out;
+
+       # Check if the action to edit a filter has been
+       # confirmed.
+
+       # Load the SQLite database.
+
+       $database_handle        = DBI->connect("dbi:SQLite:dbname=filters.db");
+
+       if ($confirm eq 1){
+
+               # The action to edit a filter has been confirmed so
+               # edit the selected filter.
+
+               # Check if changes to the database can be written to.
+
+               $filters_permissions    = kiriwrite_filepermissions("filters.db", 1, 1);
+
+               if ($filters_permissions eq 1){
+
+                       # The filters database has invalid permissions
+                       # set, so return an error.
+
+                       kiriwrite_error("filtersdbpermissions");
+
+               }
+
+               # Define some variables for later.
+
+               my @database_filter;
+               my $filter_exists = 0;
+
+               # Check if the filter exists.
+
+               $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_filters WHERE id = \'' . $filter_id_sql . '\' LIMIT 1') or kiriwrite_error("filtersdbinvalidformat");
+               $string_handle->execute();
+
+               while (@database_filter = $string_handle->fetchrow_array()){
+
+                       # The filter exists.
+
+                       $filter_exists = 1;
+
+               }
+
+               # Check if the filter really doesn't exist.
+
+               if ($filter_exists eq 0){
+
+                       # The filter really does not exist so
+                       # return an error.
+
+                       kiriwrite_error("filterdoesnotexist");
+
+               }
+
+               # First, check the variables recieved are UTF8
+               # copliant.
+
+               kiriwrite_variablecheck($filter_new_find, "utf8", 0, 0);
+               kiriwrite_variablecheck($filter_new_replace, "utf8", 0, 0);
+               kiriwrite_variablecheck($filter_new_priority, "utf8", 0, 0);
+               kiriwrite_variablecheck($filter_new_notes, "utf8", 0, 0);
+
+               # Convert the UTF8 values so that the length can
+               # checked properly.
+
+               $filter_find            = kiriwrite_utf8convert($filter_new_find);
+               $filter_replace         = kiriwrite_utf8convert($filter_new_replace);
+               $filter_priority        = kiriwrite_utf8convert($filter_new_priority);
+               $filter_notes           = kiriwrite_utf8convert($filter_new_notes);
+
+               # Check if the find filter is blank and return an error
+               # if it is.
+
+               if (!$filter_new_find){
+
+                       # The find filter given is blank so return an
+                       # error.
+
+                       kiriwrite_error("blankfindfilter");
+
+               }
+
+               if (!$filter_new_priority){
+
+                       # The filter priority is blank so set it
+                       # to 1.
+
+                       $filter_new_priority = 1;
+
+               }
+
+               # Check the length and contents of the values given
+               # to make sure they are valid.
+               
+               my $filterfind_maxlength_check          = kiriwrite_variablecheck($filter_new_find, "maxlength", 1024, 1);
+               my $filterreplace_maxlength_check       = kiriwrite_variablecheck($filter_new_replace, "maxlength", 1024, 1);
+               my $filterpriority_maxlength_check      = kiriwrite_variablecheck($filter_new_priority, "maxlength", 5, 1);
+               my $filterpriority_numbers_check        = kiriwrite_variablecheck($filter_new_priority, "numbers", 0, 1);
+
+               # Check if the result of the tests to see if they
+               # are valid.
+
+               if ($filterfind_maxlength_check eq 1){
+
+                       # The find filter is too long, so return
+                       # an error.
+
+                       kiriwrite_error("findfiltertoolong");
+
+               }
+
+               if ($filterreplace_maxlength_check eq 1){
+
+                       # The replace filter is too long, so
+                       # return an error.
+
+                       kiriwrite_error("replacefiltertoolong");
+
+               }
+
+               if ($filterpriority_maxlength_check eq 1){
+
+                       # The length of the filter priority
+                       # given is too long, so return an
+                       # error.
+
+                       kiriwrite_error("filterprioritytoolong");
+
+               }
+
+               if ($filterpriority_numbers_check eq 1){
+
+                       # The priority of the filter given
+                       # contains characters other than
+                       # numbers.
+
+                       kiriwrite_error("filterpriorityinvalidchars");
+
+               }
+
+               # Check if the filter priority is less than 1
+               # and more than 10000 and return an error
+               # if it is.
+
+               if ($filter_new_priority < 1 || $filter_new_priority > 50000){
+
+                       # The filter priority is less than 1 and
+                       # more than 10000, so return an error.
+
+                       kiriwrite_error("filterpriorityinvalid");
+
+               }
+
+               # Convert the new information about the filter given
+               # so that it can be added to the SQL query properly.
+
+               $filter_find_sql        = kiriwrite_convert($filter_find, "kiriwrite");
+               $filter_replace_sql     = kiriwrite_convert($filter_replace, "kiriwrite");
+               $filter_priority_sql    = kiriwrite_convert($filter_priority, "kiriwrite");
+               $filter_notes_sql       = kiriwrite_convert($filter_notes, "kiriwrite");
+
+               # Edit the filter using the information provided.
+
+               $string_handle = $database_handle->prepare('UPDATE kiriwrite_filters SET priority = \'' . $filter_priority_sql . '\', findsetting = \'' . $filter_find_sql . '\', replacesetting = \'' . $filter_replace_sql . '\', notes = \'' . $filter_notes_sql . '\' WHERE id = \'' . $filter_id_sql . '\'');
+               $string_handle->execute();
+
+               # Write a message saying that the filter was edited.
+
+               $pagedata = $pagedata . "<h2>Filter edited</h2>";
+               $pagedata = $pagedata . "The selected filter was edited.<br><br>";
+               $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=filter\">Return to the list of filters.</a>";
+
+               return $pagedata;
+
+       } elsif ($confirm eq 0){
+
+               # The action to edit a filter has not been confirmed
+               # so write a form for editing the filter with.
+
+               # Define some variables for later.
+
+               my @database_filter;
+               my $filter_exists = 0;
+
+               # Check if the filter exists.
+
+               $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_filters WHERE id = \'' . $filter_id_sql . '\' LIMIT 1') or kiriwrite_error("filtersdbinvalidformat");
+               $string_handle->execute();
+
+               while (@database_filter = $string_handle->fetchrow_array()){
+
+                       # The filter exists.
+
+                       $filter_exists = 1;
+
+               }
+
+               # Check if the filter really doesn't exist.
+
+               if ($filter_exists eq 0){
+
+                       # The filter really does not exist so
+                       # return an error.
+
+                       kiriwrite_error("filterdoesnotexist");
+
+               }
+
+               # Get the filter information.
+
+               $string_handle->execute();
+
+               @database_filter = $string_handle->fetchrow_array();
+               
+               # Get the required information.
+
+               $filter_priority        = $database_filter[1];
+               $filter_find            = $database_filter[2];
+               $filter_replace         = $database_filter[3];
+               $filter_notes           = $database_filter[4];
+
+               $filter_priority_out    = kiriwrite_convert($filter_priority, "normal_display");
+               $filter_find_out        = kiriwrite_convert($filter_find, "normal_display");
+               $filter_replace_out     = kiriwrite_convert($filter_replace, "normal_display");
+               $filter_notes_out       = kiriwrite_convert($filter_notes, "normal_display");
+               
+               # Write out the form.
+
+               $pagedata = $pagedata . "<h2>Edit Filter</h2>";
+               $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"filter\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"edit\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"filter\" value=\"" . $filter_id_out . "\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
+               $pagedata = $pagedata . "<table cellpadding=\"5\" cellspacing=\"0\">";
+               $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Find...</td><td class=\"tablecell2\"><input type=\"text\" name=\"filterfind\" size=\"64\" maxlength=\"1024\" value=\"" . $filter_find_out . "\"></td><tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Replace With...</td><td class=\"tablecell2\"><input type=\"text\" name=\"filterreplace\" size=\"64\" maxlength=\"1024\" value=\"" . $filter_replace_out . "\"></td><tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Filter Priority</td><td class=\"tablecell2\"><input type=\"text\" name=\"priority\" size=\"5\" maxlength=\"5\" value=\"" . $filter_priority_out . "\"><ul><li>If no filter priority is specified, the filter priority will be set to 1.</li></ul></td><tr>";
+               $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Filter Notes</td><td class=\"tablecell2\"><textarea name=\"notes\" rows=\"10\" cols=\"50\">" . $filter_notes_out . "</textarea></td><tr>";
+               $pagedata = $pagedata . "</table><br>";
+               $pagedata = $pagedata . "<input type=\"submit\" value=\"Edit filter\"> | <input type=\"reset\" value=\"Restore filter settings\"> | <a href=\"kiriwrite.cgi?mode=filter\">Return to the filter database.</a>";
+               $pagedata = $pagedata . "</form>";
+
+               return $pagedata; 
+
+       } else {
+
+               # A confirm value other than 0 or 1 has been
+               # specified, so return an error.
+
+               kiriwrite_error("invalidvalue");
+
+       }
+
+}
+
+sub kiriwrite_filter_delete{
+#################################################################################
+# kiriwrite_filter_delete: Deletes a filter from the filter list.              #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_filter_delete(number, confirm);                                    #
+#                                                                              #
+# number       Specifies the filter line number to delete.                     #
+# confirm      Confirms the deletion of the selected filter.                   #
+#################################################################################
+
+       # Get the values that were passed to this subroutine.
+       
+       my ($filter_id, $confirm) = @_;
+       
+       # Load the needed Perl modules.
+
+       use DBI;
+
+       # Check the confirm value to make sure it is no more than
+       # one character long.
+
+       kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
+
+       # Define the page data value for later.
+
+       my $pagedata = "";
+
+       # Check if the confirm value is blank and if it is
+       # srt the confirm value to 0.
+
+       if (!$confirm){
+
+               # The confirm value does not have any value
+               # set so set it to 0.
+
+               $confirm = 0;
+
+       }
+
+       # Check if the filter identification number is blank,
+       # contains characters other than numbers and is more
+       # than seven characters long.
+
+       if (!$filter_id){
+
+               # The filter identification number is blank,
+               # so return an error.
+
+               kiriwrite_error("filteridblank");
+
+       }
+
+       my $filter_id_numbers_check     = kiriwrite_variablecheck($filter_id, "numbers", 0, 1);
+
+       if ($filter_id_numbers_check eq 1){
+
+               # The filter identification number contains
+               # characters other than numbers, so return
+               # an error.
+
+               kiriwrite_error("filteridinvalid");
+
+       }
+
+       my $filter_id_maxlength_check   = kiriwrite_variablecheck($filter_id, "maxlength", 7, 1);
+
+       if ($filter_id_maxlength_check eq 1){
+
+               # The filter identification number given
+               # is more than seven characters long, so
+               # return an error.
+
+               kiriwrite_error("filteridtoolong");
+
+       }
+
+       # Check if the filters database exists and the
+       # permissions for it are valid.
+
+       my $filters_exists      = kiriwrite_fileexists("filters.db");
+
+       if ($filters_exists eq 1){
+
+               # The filters database does not exist, so
+               # return an error.
+
+               kiriwrite_error("filtersdbmissing");
+
+       }
+
+       my $filters_permissions = kiriwrite_filepermissions("filters.db", 1, 0);
+
+       if ($filters_permissions eq 1){
+
+               # The filters database has invalid permissions
+               # set, so return an error.
+
+               kiriwrite_error("filtersdbpermissions");
+
+       }
+       
+       # Define some values for later.
+
+       my @database_filter;
+       my $filterid_sql        = kiriwrite_convert($filter_id, "kiriwrite");
+       my $filterid_out        = kiriwrite_convert($filter_id, "normal_display");
+       my $database_handle;
+       my $string_handle;
+       my $filter_exists = 0;
+
+       # Load the SQLite database.
+
+       $database_handle        = DBI->connect("dbi:SQLite:dbname=filters.db");
+
+       # Check if the confirm integer has a value of '1'.
+       
+       if ($confirm eq 1){
+               
+               # The action to delete a filter has been confirmed.
+
+               # Check the permissions of the filters database is
+               # valid (for writing).
+
+               $filters_permissions    = kiriwrite_filepermissions("filters.db", 1, 1);
+
+               if ($filters_permissions eq 1){
+
+                       # The filters database has invalid permissions
+                       # set, so return an error.
+
+                       kiriwrite_error("filtersdbpermissions");
+
+               }
+
+               # Check if the filter exists.
+
+               $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_filters WHERE id = \'' . $filterid_sql . '\' LIMIT 1') or kiriwrite_error("filtersdbinvalidformat");
+               $string_handle->execute();
+
+               while (@database_filter = $string_handle->fetchrow_array()){
+
+                       # The filter exists.
+
+                       $filter_exists = 1;
+
+               }
+
+               # Check if the filter really doesn't exist.
+
+               if ($filter_exists eq 0){
+
+                       # The filter really does not exist so
+                       # return an error.
+
+                       kiriwrite_error("filterdoesnotexist");
+
+               }
+
+               # Delete the filter from the filters database.
+
+               $string_handle  = $database_handle->prepare('DELETE FROM kiriwrite_filters where id = \'' . $filterid_sql . '\'') or kiriwrite_error("filtersdbinvalidformat");         
+               $string_handle->execute();
+
+               # Write a message saying that the filter was deleted
+               # from the filters database.
+
+               $pagedata = $pagedata . "<h2>Delete Filter</h2>";
+               $pagedata = $pagedata . "The selected filter was deleted from the filters database.<br><br>";
+               $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=filter\">Return to the filters database.</a>";
+
+       } elsif ($confirm eq 0) {
+       
+               # The action to delete a filter has not been confirmed so write
+               # a form asking for the user to confirm the deletion of the
+               # filter.
+
+               # Check if the filter exists.
+
+               $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_filters WHERE id = \'' . $filterid_sql . '\' LIMIT 1') or kiriwrite_error("filtersdbinvalidformat");
+               $string_handle->execute();
+
+               while (@database_filter = $string_handle->fetchrow_array()){
+
+                       # The filter exists.
+
+                       $filter_exists = 1;
+
+               }
+
+               # Check if the filter really doesn't exist.
+
+               if ($filter_exists eq 0){
+
+                       # The filter really does not exist so
+                       # return an error.
+
+                       kiriwrite_error("filterdoesnotexist");
+
+               }
+
+               # The confirm integer is '0', so continue write out
+               # a form asking the user to confirm the deletion
+               # pf the filter.
+               
+               $pagedata = $pagedata . "<h2>Confirm deletion</h2>";
+               $pagedata = $pagedata . "Are you sure you want to delete the selected filter?<br><br>";
+               $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"filter\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"delete\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"filter\" value=\"" . $filterid_out . "\">";
+               $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
+               $pagedata = $pagedata . "<input type=\"submit\" value=\"Yes, delete the selected filter\"> | <a href=\"kiriwrite.cgi?mode=filter\">No, return to the filters list.</a>";
+               $pagedata = $pagedata . "</form>";
+       
+       } else {
+       
+               kiriwrite_error("invalidvalue");
+       
+       }
+
+       return $pagedata;
+
+}
+
+sub kiriwrite_compile_makepages{
+#################################################################################
+# kiriwrite_compile_makepages: Compile the selected pages and place them in the #
+# specified output directory.                                                  #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_compile_makepages(type, selectedlist, confirm);                    #
+#                                                                              #
+# type         Specifies if single or multiple databases are to be compiled.   #
+# confirm      Specifies if the action to compile the databases should really  #
+#              be done.                                                        #
+# selectedlist Specifies the databases to compile from as an array.            #
+#################################################################################
+
+       # Get the values that have been passed to the subroutine.
+       
+       my ($type, $confirm, @selectedlist) = @_;
+
+       # Check if the confirm value is more than one
+       # character long.
+
+       kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
+
+       # Check if the confirm value is blank and if it
+       # is then set the confirm value to 0.
+
+       if (!$confirm){
+
+               # The confirm value is blank, so set the
+               # confirm value to 0.
+
+               $confirm = 0;
+
+       }       
+
+       # Check if there are any databases selected
+       # and return an error if there isn't.
+
+       if (!@selectedlist){
+
+               # There are no databases in the array
+               # so return an error.
+
+               kiriwrite_error("nodatabaseselected");
+
+       }
+
+       # Check if the type given is no more than
+       # 7 characters long.
+
+       my $type_maxlength_check = kiriwrite_variablecheck($type, "maxlength", 8, 1);
+
+       if ($type_maxlength_check eq 1){
+
+               # The type length given is too long so
+               # return an error.
+
+               kiriwrite_error("variabletoolong");
+
+       }
+
+       # Define the following values for later.
+
+       my $pagedata = "";
+
+       # Check if the action to compile the databases
+       # has been confirmed.
+
+       if ($confirm eq 1){
+
+               # The action to compile the datavases has
+               # been confirmed.
+
+               # Define some variables for later.
+
+               my %templatefiles;
+               my @databaseinfo;
+               my @databasepages;
+               my @filterslist;
+               my @findfilter;
+               my @replacefilter;
+               my @templateslist;
+               my @pagedirectories;
+               my $messages                    = "";
+               my $warning_count               = 0;
+               my $error_count                 = 0;
+               my $pages_count                 = 0;
+               my $filters_count               = 0;
+               my $filters_find_blank_warning  = 0;
+               my $database_handle;
+               my $string_handle;
+               my $filter_find;
+               my $filter_replace;
+               my $database;
+               my $database_out;
+               my $database_name;
+               my $database_name_out;
+               my $page_filename;
+               my $page_filename_out;
+               my $page_filename_check;
+               my $page_filename_char          = "";
+               my $page_filename_directory;
+               my $page_filename_length        = 0;
+               my $page_filename_seek          = 0;
+               my $page_filename_dircount      = 0;
+               my $page_directory_name;
+               my $page_directory_path;
+               my $page_name;
+               my $page_name_out;
+               my $page_description;
+               my $page_section;
+               my $page_template;
+               my $page_template_out;
+               my $page_content;
+               my $page_settings;
+               my $page_lastmodified;
+               my $page_title;
+               my $page_final;
+               my $page_autosection;
+               my $page_autotitle;
+               my $database_filename_check     = 0;
+               my $database_maxlength_check    = 0;            
+               my $output_exists               = 0;
+               my $output_permissions          = 0;
+               my $filters_exists              = 0;
+               my $filters_permissions         = 0;
+               my $filters_skip                = 0;
+               my $templates_exists            = 0;
+               my $templates_permissions       = 0;
+               my $templates_skip              = 0;
+               my $database_exists             = 0;
+               my $database_permissions        = 0;
+               my $information_prefix          = "[Information] ";
+               my $error_prefix                = "[Error] ";
+               my $warning_prefix              = "[Warning] ";
+
+               # Check if the output directory exists and has
+               # valid permissions set.
+
+               $output_exists          = kiriwrite_fileexists($kiriwrite_config{'directory_data_output'});
+
+               if ($output_exists ne 0){
+
+                       # The output directory does not exist so
+                       # return an error.
+
+                       kiriwrite_error("outputdirectorymissing");
+
+               }
+
+               $output_permissions     = kiriwrite_filepermissions($kiriwrite_config{'directory_data_output'}, 1, 1);
+
+               if ($output_permissions ne 0){
+
+                       # The output directory has invalid
+                       # permissions set so return an error.
+
+                       kiriwrite_error("outputdirectoryinvalidpermissions");
+
+               }
+
+               # Check if the filters database exists and has valid
+               # permissions set.
+
+               $filters_exists         = kiriwrite_fileexists("filters.db");
+
+               if ($filters_exists ne 0){
+
+                       # The filters database does not exist
+                       # so write a warning.
+
+                       $messages = $messages . $warning_prefix . "The filters database does not exist. No filters will be used." . "<br>";
+                       $filters_skip = 1;
+                       $warning_count++;
+
+               }
+
+               $filters_permissions    = kiriwrite_filepermissions("filters.db", 1, 0);
+               
+               if ($filters_permissions ne 0 && $filters_exists eq 0){
+
+                       # The filters database has invalid
+                       # permissions set so write a warning.
+
+                       $messages = $messages . $warning_prefix . "The filters database has invalid permissions set. No filters will be used." . "<br>";
+                       $filters_skip = 1;
+                       $warning_count++;
+
+               }
+
+               # Load the filters database (if the filters skip
+               # value isn't set to 1).
+
+               if ($filters_skip eq 0){
+
+                       # Load the filters database.
+
+                       $database_handle = DBI->connect("dbi:SQLite:dbname=filters.db");
+                       $string_handle = $database_handle->prepare('SELECT * FROM kiriwrite_filters ORDER BY priority ASC') or $messages = $messages . $error_prefix . "The filters database is in an invalid format. No filters will be used." . "<br>", $error_count++, $filters_skip = 1;
+
+                       # Check if the filters skip value is set to 0
+                       # before executing the query.
+
+                       if ($filters_skip eq 0){
+
+                               # Get the filters.
+
+                               $string_handle->execute();
+                               while (@filterslist = $string_handle->fetchrow_array()){
+
+                                       # Check if the find filter is blank and
+                                       # if it is then write a warning message.
+
+                                       if (!$filterslist[2]){
+
+                                               if ($filters_find_blank_warning ne 1){
+
+                                                       $messages = $messages . $warning_prefix . "One (or more) of the find filters from the filters database is blank." . "<br>";
+                                                       $filters_find_blank_warning = 1;
+                                               }
+                                               next;
+
+                                       } else {
+
+                                               # Add each find and replace filter.
+
+                                               $findfilter[$filters_count]     = $filterslist[2];
+                                               $replacefilter[$filters_count]  = $filterslist[3];
+
+                                       }
+
+                                       $filters_count++;
+
+                               }
+                               $messages = $messages . $information_prefix . "The filters database has been loaded." . "<br>";
+
+                       }
+
+               }
+
+               # Check if the templates database exists and has
+               # valid permissions set.
+
+               $templates_exists       = kiriwrite_fileexists("templates.db");
+
+               if ($templates_exists ne 0){
+
+                       # The template database does not exist
+                       # so write a warning.
+
+                       $messages = $messages . $warning_prefix . "The templates database does not exist. Pages will be compiled without templates being used." . "<br>";
+                       $templates_skip = 1;
+                       $warning_count++;
+
+               }
+
+               $templates_permissions  = kiriwrite_filepermissions("templates.db", 1, 0);
+
+               if ($templates_permissions ne 0 && $templates_exists eq 0){
+
+                       # The template database has invalid
+                       # permissions set so write a warning.
+
+                       $messages = $messages . $warning_prefix . "The templates database has invalid permissions set. Pages will be compiled without templates being used." . "<br>";
+                       $templates_skip = 1;
+                       $warning_count++;
+
+               }
+
+               # Load the templates database (if the template
+               # skip value isn't set to 1).
+
+               if ($templates_skip eq 0){
+
+                       # Load the templates database.
+
+                       $database_handle = DBI->connect('dbi:SQLite:dbname=templates.db');
+                       $string_handle = $database_handle->prepare('SELECT * FROM kiriwrite_templates') or $messages = $messages . $error_prefix . "The templates database is in an invalid format. Pages will be compiled without templates being used." . "<br>", $error_count++, $templates_skip = 1;
+
+                       # Check if the templates skip value is set to
+                       # 0 before executing the query.
+
+                       if ($templates_skip eq 0){
+
+                               # Get the templates and place them into the
+                               # template files hash.
+
+                               $string_handle->execute();
+                               while(@templateslist = $string_handle->fetchrow_array()){
+
+                                       # Place each template file into the hash.
+
+                                       $templatefiles{$templateslist[0]}{template}     = $templateslist[3];
+                                       $templatefiles{$templateslist[0]}{valid}        = 1;
+
+                               }
+                               $messages = $messages . $information_prefix . "The templates database has been loaded." . "<br>";
+
+                       }
+
+               }
+
+               # Process each database.
+
+               foreach $database (@selectedlist){
+
+                       # Check if the database filename and length
+                       # are valid.
+
+                       $messages = $messages . "<hr>";
+
+                       $database_out   = kiriwrite_convert($database, "normal_display");
+                       $database_filename_check        = kiriwrite_variablecheck($database, "page_filename", "", 1);
+                       $database_maxlength_check       = kiriwrite_variablecheck($database, "maxlength", 64, 1);
+
+                       if ($database_filename_check ne 0){
+
+                               # The database filename is invalid, so process
+                               # the next database.
+
+                               $messages       = $messages . $error_prefix . "The database filename '" . $database_out . ".db' is invalid. Skipping this database..." . "<br>";
+                               $error_count++;
+                               next;
+
+                       }
+
+                       if ($database_maxlength_check ne 0){
+
+                               # The database file is too long, so process the
+                               # next database.
+
+                               $messages       = $messages . $error_prefix . "The database with the filename '" . $database_out . ".db' is too long. Skipping this database..." . "<br>";
+                               $error_count++;
+                               next;
+
+                       }
+
+                       # Check if the database exists and has valid
+                       # permissions set.
+
+                       $database_exists        = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+                       
+                       if ($database_exists ne 0){
+
+                               # The database does not exist so process
+                               # the next database.
+
+                               $messages       = $messages . $error_prefix . "The database with the filename '" . $database_out . ".db' does not exist. Skipping this database..." . "<br>";
+                               $error_count++;
+                               next;
+
+                       }
+                       
+                       $database_permissions   = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db', 1, 0);
+
+                       if ($database_permissions ne 0){
+
+                               # The permissions for the database are invalid
+                               # so process the next database.
+
+                               $messages       = $messages . $error_prefix . "The database with the filename '" . $database_out . ".db' has invalid permissions set. Skipping this database..." . "<br>";
+                               $error_count++;
+                               next;
+
+                       }
+
+                       # Load the SQLite database.
+
+                       $database_handle = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
+
+                       # Get the database name.
+
+                       $string_handle = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or $messages = $messages . $error_prefix . "The database with the filename '" . $database_out . ".db' is in an invalid format. Skipping this database..." . "<br>", next;
+                       $string_handle->execute();
+                       @databaseinfo = $string_handle->fetchrow_array();
+                       $database_name = $databaseinfo[0];
+                       $database_name_out = kiriwrite_convert($database_name, "normal_display");
+                       $messages = $messages . $information_prefix . "Compiling pages in the '" . $database_name_out . "' database..." . "<br>";
+
+                       # Get the pages in the database.
+
+                       $string_handle = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages') or $messages = $messages . $error_prefix . "The database with the filename '" . $database_out . ".db' is in an invalid format. Skipping this database..." . "<br>", next;
+                       $string_handle->execute();
+
+                       while(@databasepages = $string_handle->fetchrow_array()){
+
+                               # Convert the values so that they can be
+                               # used in the messages list.
+
+                               $page_filename          = $databasepages[0];
+                               $page_name              = $databasepages[1];
+                               $page_description       = $databasepages[2];
+                               $page_section           = $databasepages[3];
+                               $page_template          = $databasepages[4];
+                               $page_content           = $databasepages[5];
+                               $page_settings          = $databasepages[6];
+                               $page_lastmodified      = $databasepages[7];
+
+                               $page_filename_out      = kiriwrite_convert($page_filename, "normal_display");
+                               $page_name_out          = kiriwrite_convert($page_name, "normal_display");
+                               $page_template_out      = kiriwrite_convert($page_template, "normal_display");
+
+                               # Check if the filename is valid.
+
+                               $page_filename_check = kiriwrite_variablecheck($page_filename, "page_filename");
+
+                               if ($page_filename_check ne 0){
+
+                                       # The file name is not valid so write a
+                                       # error and process the next page.
+
+                                       $messages = $messages . $error_prefix . "The page '" . $page_name_out . "' has an invalid filename. Page skipped." . "<br>";
+                                       next;
+
+                               }
+
+                               # Check if the template with the filename does not exist
+                               # in the template files hash and write a message and
+                               # process the next page.
+                               
+                               if (!$templatefiles{$page_template}{valid} && $page_template ne "!none" && $templates_skip eq 0){
+
+                                       $messages = $messages . $error_prefix . "The template with the filename '" . $page_template_out . "' for '" . $page_name_out . "' (" . $page_filename_out . ") does not exist." . "<br>";
+                                       $error_count++;
+                                       next;
+
+                                       $page_final = $page_content;
+
+                               } elsif ($page_template eq "!none"){
+
+                                       $page_final = $page_content;
+
+                               } else {
+
+                                       $page_final = $templatefiles{$page_template}{template};
+                                       $page_final =~ s/<kiriwrite:pagecontent>/$page_content/g;
+
+                               }
+
+                               # Create the combined page title (if needed).
+
+                               if ($page_settings eq 0){
+
+                                       # Don't use page name or section name.
+
+                                       $page_final =~ s/<kiriwrite:pagetitle>//g;
+
+                               } elsif ($page_settings eq 1){
+
+                                       # Use the page name and section name.
+
+                                       $page_autotitle = "(" . $page_section . " - " . $page_name . ")";
+                                       $page_title = $page_section . " - " . $page_name;
+                                       $page_final =~ s/<kiriwrite:pagetitle>/$page_title/g;
+
+                               } elsif ($page_settings eq 2){
+
+                                       # Use the page name only.
+
+                                       $page_autotitle = "(" . $page_name . ")";
+                                       $page_final =~ s/<kiriwrite:pagetitle>/$page_name/g;
+
+                               } elsif ($page_settings eq 3){
+
+                                       # Use the section name only.
+
+                                       if ($page_section){
+                                               $page_autotitle = "(" . $page_section . ")";
+                                       }
+                                       $page_final =~ s/<kiriwrite:pagetitle>/$page_section/g;
+
+                               }
+
+                               # Check if the section name is not blank and
+                               # place brackets inbetween if it is.
+
+                               if ($page_section){
+
+                                       $page_autosection = "(" . $page_section . ")";
+
+                               }
+
+                               # Replace each <kiriwrite> value with the apporiate page
+                               # values.
+
+                               $page_final =~ s/<kiriwrite:pagename>/$page_name/g;
+                               $page_final =~ s/<kiriwrite:pagedescription>/$page_description/g;
+                               $page_final =~ s/<kiriwrite:pagesection>/$page_section/g;
+                               $page_final =~ s/<kiriwrite:autosection>/$page_autosection/g;
+                               $page_final =~ s/<kiriwrite:autotitle>/$page_autotitle/g;
+
+                               # Process the filters on the page data.
+
+                               if ($filters_skip eq 0){
+
+                                       $filters_count = 0;
+
+                                       foreach $filter_find (@findfilter){
+
+                                               # Get the replace filter and process each
+                                               # filter on the page.
+
+                                               $filter_replace = $replacefilter[$filters_count];
+                                               $page_final =~ s/$filter_find/$filter_replace/g;
+                                               $filters_count++;
+
+                                       }
+
+                               }
+
+                               # Process the page filename and check what directories
+                               # need to be created.
+
+                               $page_filename_length = int(length($page_filename));
+
+                               do {
+
+                                       $page_filename_char = substr($page_filename, $page_filename_seek, 1);
+                                       
+                                       # Check if a forward slash appears and add it to
+                                       # the list of directories array.
+
+                                       if ($page_filename_char eq '/'){
+
+                                               # Append the directory name to the list of
+                                               # directories array.
+
+                                               $pagedirectories[$page_filename_dircount] = $page_filename_directory;
+                                               $page_filename_directory        = "";
+                                               $page_filename_char             = "";
+                                               $page_filename_dircount++;
+
+                                       } else {
+
+                                               # Append the character to the directory/filename.
+
+                                               $page_filename_directory = $page_filename_directory . $page_filename_char;
+
+                                       }
+
+                                       $page_filename_seek++;
+
+                               } until ($page_filename_length eq $page_filename_seek);
+
+                               foreach $page_directory_name (@pagedirectories){
+
+                                       # Check if the directory exists and create 
+                                       # the directory if it doesn't exist.
+                               
+                                       $page_directory_path = $page_directory_path . '/' . $page_directory_name;
+
+                                       mkdir($kiriwrite_config{"directory_data_output"} . '/' . $page_directory_path);
+
+                               }
+
+                               # Write the file to the output directory.
+
+                               open(PAGE, "> " . $kiriwrite_config{"directory_data_output"} . '/' . $page_filename);
+                               print PAGE $page_final;
+                               close(PAGE);
+
+                               # Write a message saying the page has been compiled.
+
+                               $messages = $messages . $information_prefix . "'" . $page_name_out . "' (" . $page_filename_out . ") was compiled." . "<br>";
+                               $pages_count++;
+
+                               # Reset certain values.
+
+                               $page_autotitle = "";
+                               $page_autosection = "";
+                               $page_filename_seek = 0;
+                               $page_filename_dircount = 0;
+                               
+                               $page_filename_directory = "";
+                               $page_directory_path = "";
+                               $page_directory_name = "";
+                               @pagedirectories = ();
+
+                       }
+
+                       # Write a message saying that the database has
+                       # been processed.
+
+                       $messages = $messages . $information_prefix . "Finished compiling pages in the '" . $database_name_out . "' database..." . "<br>";
+
+               }
+
+               $messages = $messages . "<hr>";
+               $messages = $messages . $pages_count . " pages compiled, " . $error_count . " errors, " . $warning_count . " warnings.";
+               $pagedata = $pagedata . "<h2>Compile databases</h2>";
+               $pagedata = $pagedata . "<div class=\"datalist\">";
+               $pagedata = $pagedata . $messages;
+               $pagedata = $pagedata . "</div>";
+
+               return $pagedata;
+
+       } elsif ($confirm eq 0){
+
+               # The action to compile the databases has
+               # not been confirmed so check what type
+               # is being used.
+
+               if ($type eq "single"){
+
+                       # The type is a single database selected so
+                       # process that database.
+
+                       # Define some variables for later.
+
+                       my $database_handle;
+                       my $string_handle;
+                       my @database_info;
+                       my $database_filename_check;
+                       my $database_maxlength_check;
+                       my $databasefilename;
+                       my $databasefilename_out;
+                       my $database_name;
+                       my $database_name_out;
+
+                       # Check that the database name and length are
+                       # valid and return an error if they aren't.
+
+                       $databasefilename = $selectedlist[0];
+                       $databasefilename_out = kiriwrite_convert($databasefilename, "normal_display");
+                       $database_filename_check        = kiriwrite_variablecheck($databasefilename, "filename", "", 1);
+                       $database_maxlength_check       = kiriwrite_variablecheck($databasefilename, "maxlength", 64, 1);
+
+                       if ($database_filename_check ne 0){
+
+                               # The database filename is invalid, so
+                               # return an error.
+
+                               kiriwrite_error("databasefilenameinvalid");
+
+                       }
+
+                       if ($database_maxlength_check ne 0){
+
+                               # The database filename is too long, so
+                               # return an error.
+
+                               kiriwrite_error("databasefilenametoolong");
+
+                       }
+
+                       # Check if the database exists and has valid permissions
+                       # set and skip them if they don't.
+
+                       my $database_exists             = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $databasefilename . '.db');
+                       my $database_permissions        = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $databasefilename . '.db', 1, 0);
+
+                       if ($database_exists ne 0){
+
+                               # The database filename does not exist, so
+                               # return an error.
+
+                               kiriwrite_error("databasemissingfile");
+
+                       }
+
+                       if ($database_permissions ne 0){
+
+                               # The database permissions are invalid, so
+                               # return an error.
+
+                               kiriwrite_error("databaseinvalidpermissions");
+
+                       }
+
+                       # Load the SQLite database.
+
+                       $database_handle        = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $databasefilename . '.db');
+                       
+                       # Get the database name.
+
+                       $string_handle          = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1');
+                       $string_handle->execute();
+                       @database_info = $string_handle->fetchrow_array();
+                       $database_name          = $database_info[0];
+                       $database_name_out      = kiriwrite_convert($database_name, "normal_display");
+
+                       # Write out a form asking the user to confirm if the
+                       # user wants to compile the selected database.
+
+                       $pagedata = $pagedata . "<h2>Compile database</h2>";
+                       $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
+                       $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"compile\">";
+                       $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"compile\">";
+                       $pagedata = $pagedata . "<input type=\"hidden\" name=\"type\" value=\"multiple\">";
+                       $pagedata = $pagedata . "<input type=\"hidden\" name=\"id[1]\" value=\"" . $databasefilename_out . "\">";
+                       $pagedata = $pagedata . "<input type=\"hidden\" name=\"name[1]\" value=\"on\">";
+                       $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
+                       $pagedata = $pagedata . "Are you sure you want to compile the '" . $database_name_out . "' database?<br><br>";
+                       $pagedata = $pagedata . "<input type=\"submit\" value=\"Compile database\"> | <a href=\"kiriwrite.cgi?mode=compile\">Return to the list of databases for compiling.</a>";
+                       $pagedata = $pagedata . "</form>";
+                       
+                       return $pagedata;
+
+               } elsif ($type eq "multiple"){
+
+                       # The type is multiple databases selected
+                       # so process each database.
+
+                       # Define some variables for later.
+
+                       my $database_handle;
+                       my $databasename;
+                       my $databasename_out;
+                       my @database_info;
+                       my $database_filename_check;
+                       my $database_maxlength_check;
+                       my $database_exists;
+                       my $database_permissions;
+                       my $database_count = 0;
+                       my $string_handle;
+                       my $database_info_name;
+                       my $database_info_name_out;
+                       my $databaselist = "";
+
+                       foreach $databasename (@selectedlist){
+
+                               # Check if the database is in the database
+                               # directory and skip it if it isn't.
+
+                               $database_filename_check        = kiriwrite_variablecheck($databasename, "filename", "", 1);
+                               $database_maxlength_check       = kiriwrite_variablecheck($databasename, "maxlength", 64, 1);
+
+                               if ($database_filename_check ne 0 || $database_maxlength_check ne 0){
+
+                                       # The database filename given is invalid or
+                                       # the database filename given is too long
+                                       # so process the next database.
+
+                                       next;
+
+                               }
+
+                               # Check if the database exists and has valid permissions
+                               # set and skip them if they don't.
+
+                               $database_exists        = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $databasename . '.db');
+                               $database_permissions   = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $databasename . '.db', 1, 0);
+
+                               if ($database_exists ne 0 || $database_permissions ne 0){
+
+                                       # The database does not exist or the permissions
+                                       # for the database are invalid so process the
+                                       # next database.
+
+                                       next;
+
+                               }
+
+                               # Get the database name.
+
+                               $database_handle = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $databasename . '.db');
+                               $string_handle = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or next;
+                               $string_handle->execute();
+
+                               # Increment the amount of databases to compile.
+
+                               $database_count++;
+
+                               # Get the database name, convert it so that it can
+                               # be displayed properly and add it to the list of
+                               # databases to be compiled.
+
+                               @database_info = $string_handle->fetchrow_array();
+                               $database_info_name = $database_info[0];
+                               $database_info_name_out = kiriwrite_convert($database_info_name, "normal_display");
+                               $databasename_out = kiriwrite_convert($databasename, "normal_display");
+
+                               $databaselist = $databaselist . "<input type=\"hidden\" name=\"id[" . $database_count . "]\" value=\"" . $databasename_out . "\"><input type=\"hidden\" name=\"name[" . $database_count . "]\" value=\"on\">" . $database_info_name_out . "<br>";
+
+                       }
+
+                       # Check if any databases are available to be compiled.
+
+                       if ($database_count eq 0){
+
+                               # No databases are available to be compiled.
+
+                               kiriwrite_error("nodatabaseselected");
+
+                       }
+
+                       # Write out the form for compiling the database.
+
+                       $pagedata = $pagedata . "<h2>Compile selected databases</h2>";
+                       $pagedata = $pagedata . "Do you want to compile the following databases?<br><br>";
+                       $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
+                       $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"compile\">";
+                       $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"compile\">";
+                       $pagedata = $pagedata . "<input type=\"hidden\" name=\"type\" value=\"multiple\">";
+                       $pagedata = $pagedata . "<input type=\"hidden\" name=\"count\" value=\"" . $database_count . "\">";
+                       $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
+                       $pagedata = $pagedata . "<div class=\"datalist\">";
+                       $pagedata = $pagedata . $databaselist;
+                       $pagedata = $pagedata . "</div><br>";
+                       $pagedata = $pagedata . "<input type=\"submit\" value=\"Compile selected databases\"> | <a href=\"kiriwrite.cgi?mode=compile\">Return to the database list.</a>";
+                       $pagedata = $pagedata . "</form>";
+
+                       return $pagedata; 
+
+               } else {
+
+                       # The type is something else other than
+                       # single or multiple, so return an error.
+
+                       kiriwrite_error("invalidvariable");
+
+               }
+
+       } else {
+
+               # The confirm value is neither 0 or 1, so
+               # return an error.
+
+               kiriwrite_error("invalidvariable");
+
+       }
+
+}
+
+sub kiriwrite_compile_all{
+#################################################################################
+# kiriwrite_compile_all: Compile all of the databases in the database          #
+# directory.                                                                   #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_compile_all();                                                     #
+#################################################################################
+
+       # Get the list of databases to compile.
+
+       opendir(DATABASE, $kiriwrite_config{"directory_data_db"});
+       my @database_list = grep /m*\.db/, readdir(DATABASE);
+       closedir(DATABASE);
+
+       # Define some variables for later.
+
+       my $databaseformdata;
+       my $database_name               = "";
+       my $database_name_filename_check;
+       my $database_name_length        = 0;
+       my $database_name_final_length  = 0;
+       my $database_name_final         = "";
+       my $database_count              = 1;
+       
+       foreach $database_name (@database_list){
+
+               # Check if the database filename is valid before
+               # using the database.
+
+               $database_name_filename_check   = kiriwrite_variablecheck($database_name, "filename", 0, 1);
+
+               if ($database_name_filename_check ne 0){
+
+                       # The database filename is invalid so process
+                       # the next database.
+
+                       next;
+
+               }
+
+               # Get the database name without the extension.
+
+               $database_name_length           = length($database_name);
+               $database_name_final_length     = $database_name_length - 3;
+               $database_name_final            = substr($database_name, 0, $database_name_final_length);
+
+               # Process the final database name into form values.
+
+               $databaseformdata = $databaseformdata . "<input type=\"hidden\" name=\"id[" . $database_count . "]\" value=\"" . $database_name_final . "\">";
+               $databaseformdata = $databaseformdata . "<input type=\"hidden\" name=\"name[" . $database_count . "]\" value=\"on\">";
+
+               $database_count++;
+
+       }
+
+       # Check the list of databases to compile to see if it is blank,
+       # if it is then return an error.
+
+       if ($database_count eq 0){
+
+               # The list of database is blank so return an error.
+
+               kiriwrite_error("nodatabasesavailable");
+
+       }
+
+       # Write out a form for confirming the action to compile all of the databases.
+
+       my $pagedata = "<h2>Compile all databases</h2>";
+       $pagedata = $pagedata . "Do you want to compile all of the databases in the database directory?<br><br>";
+       $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
+       $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"compile\">";
+       $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"compile\">";
+       $pagedata = $pagedata . "<input type=\"hidden\" name=\"type\" value=\"multiple\">";
+       $pagedata = $pagedata . "<input type=\"hidden\" name=\"count\" value=\"" . $database_count . "\">";
+       $pagedata = $pagedata . $databaseformdata;
+       $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
+       $pagedata = $pagedata . "<input type=\"submit\" value=\"Compile all databases\"> | <a href=\"kiriwrite.cgi?mode=compile\">Return to the compile database list.</a>";
+       $pagedata = $pagedata . "</form>";
+
+       return $pagedata;
+
+}
+
+sub kiriwrite_selectedlist{
+#################################################################################
+# kiriwrite_page_selectedlist: Get the list of selected pages to use.          #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_page_selectedlist();                                               #
+#################################################################################
+
+       # Load the required Perl modules.
+       
+       my $query = new CGI;
+       
+       my $count       = $query->param('count');
+       
+       # Check if the list of files has a value and if not set it 0.
+
+       if (!$count){
+
+               $count = 0;
+
+       }
+
+       # Define some values for later.
+
+       my @filename_list; 
+       my @selected_list;
+       my @final_list;
+
+       my $filename;
+       my $selected;
+       
+       my $final_count = 0;
+       my $seek = 0;
+
+       # Get the list of filenames.
+
+       do {
+
+               # Get the values from id[]
+
+               $seek++;
+
+               $filename               = $query->param('id[' . $seek . ']');
+               $filename_list[$seek]   = $filename;
+
+       } until ($seek eq $count || $count eq 0);
+
+       # Get the list of selected filenames.
+
+       $seek = 0;
+
+       do {
+
+               # Get the values from name[]
+
+               $seek++;
+
+               $selected       = $query->param('name[' . $seek . ']');
+
+               if (!$selected){
+
+                       $selected = 'off';
+
+               }
+
+               $selected_list[$seek]   = $selected;
+
+       } until ($seek eq $count || $count eq 0);
+
+       # Create a final list of filenames to be used for
+       # processing.
+
+       $seek = 0;
+
+       do {
+
+               # Check if the selected value is on and include
+               # the filename in the final list.
+
+               $seek++;
+
+               $selected       = $selected_list[$seek];
+
+               if ($selected eq "on"){
+
+                       $filename       = $filename_list[$seek];
+                       $final_list[$final_count] = $filename;
+                       $final_count++;
+
+               }
+
+       } until ($seek eq $count || $count eq 0);
+
+       return @final_list;
+
+}
+
+sub kiriwrite_compile_list{
+#################################################################################
+# kiriwrite_compile_list: Shows a list of databases that can be compiled.      #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_compile_list();                                                    #
+#################################################################################
+
+       # Load the required Perl modules.
+       
+       use DBI;
+
+       # Check the directory to make sure the permissions are settings are valid
+       # and return an error if the permission settings are invalid.
+
+       my $data_directory_permissions = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"}, 1, 0);
+
+       if ($data_directory_permissions eq 1){
+
+               # The data directory has invalid permissions set, so return an error.
+
+               kiriwrite_error("datadirectoryinvalidpermissions");
+
+       }
+
+       # Open the directory and get the list of all files ending with .xml and
+       # put them into the data_directory array.
+
+       opendir(DATADIR, $kiriwrite_config{"directory_data_db"});
+       my @data_directory = grep /m*\.db/, readdir(DATADIR);
+       closedir(DATADIR);
+
+       # Declare the following variables that are going to be used before using 
+       # the foreach function.
+       
+       my $pagedata = "";
+       my $database_count = 0;
+       my $database_handle = "";
+       my $database_filename = "";
+       my $database_filename_friendly = "";
+       my $database_filename_length = 0;
+       my $database_permissions = "";
+       my $database_name_out = "";
+       my $database_description_out = "";
+       my $data_file = "";
+       my $string_handle = "";
+       my @database_info;
+       my $table_style = 0;
+       my $table_style_name = "";
+       my $tabledata = "";
+       my $permissions_warning = 0;
+       my $permissions_list = "";
+       my $select_menu = "";
+       my $invalid_warning = 0;
+       my $invalid_list = "";
+       
+       # Begin creating the table for the list of databases.
+       
+       $pagedata = "<h2>Compile Pages</h2>\r\n";
+       $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
+       $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"compile\">";
+       $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"compile\">";
+       $pagedata = $pagedata . "<input type=\"hidden\" name=\"type\" value=\"multiple\">";
+
+       $select_menu = "<input type=\"reset\" value=\"Select None\"> | <input type=\"submit\" value=\"Compile selected\">";
+
+       foreach $data_file (@data_directory){
+               # Check the database file permissions before opening it.
+
+               $database_filename = $kiriwrite_config{"directory_data_db"} . '/' . $data_file;
+               $database_permissions = kiriwrite_filepermissions($database_filename, 1, 0, 0);
+
+               if ($database_permissions eq 1){
+                       $permissions_warning = 1;
+                       $permissions_list = $permissions_list . $data_file . "<br>\r\n";
+                       next;
+               }
+
+               # Load the SQLite database.
+               
+               $database_handle = DBI->connect("dbi:SQLite:dbname=" . $database_filename);
+
+               # Query the SQLite database or return an error (meaning that the database is in
+               # a invalid format).
+
+               $string_handle = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or (
+                       $invalid_list = $invalid_list . $data_file . "<br>\r\n",
+                       $invalid_warning = 1,
+                       next
+               );
+
+               $string_handle->execute();
+               @database_info = $string_handle->fetchrow_array();
+               
+               # Check the style to be used with.
+
+               if ($table_style eq 0){
+
+                       # Use the first style and set the style value
+                       # to use the next style, the next time the
+                       # if statement is checked.
+
+                       $table_style_name = "tablecell1";
+                       $table_style = 1;
+               } else {
+
+                       # Use the second style and set the style
+                       # value to use the first style, the next
+                       # time if statement is checked.
+
+                       $table_style_name = "tablecell2";
+                       $table_style = 0;
+               }
+
+               $database_name_out              = kiriwrite_convert($database_info[0], "normal_display");
+               $database_description_out       = kiriwrite_convert($database_info[1], "normal_display");
+
+               # Create a friendly name for the database.
+
+               $database_filename_length = length($data_file);
+               $database_filename_friendly = substr($data_file, 0, $database_filename_length - 3);
+
+               $database_count++;
+
+               # Append the database information to the table.
+
+               $tabledata = $tabledata . "<tr><td class=\"" . $table_style_name . "\"><input type=\"hidden\" name=\"id[" . $database_count . "]\" value=\"" . $database_filename_friendly . "\"><input type=\"checkbox\" name=\"name[" . $database_count . "]\"></td><td class=\"" . $table_style_name . "\"><a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_filename_friendly . "\">" . $database_name_out . "</a></td><td class=\"" . $table_style_name . "\">" . $database_description_out . "</td><td class=\"" . $table_style_name . "\"><a href=\"kiriwrite.cgi?mode=compile&action=compile&type=single&database=" . $database_filename_friendly . "\">Compile</a></td></tr>\r\n";
+               
+       }
+
+       $pagedata = $pagedata . "<input type=\"hidden\" name=\"count\" value=\"" . $database_count . "\">";
+
+       $pagedata = $pagedata . $select_menu . "<br><br>";
+
+       $pagedata = $pagedata . "<table cellpadding=\"5\" cellspacing=\"0\"><tr><td class=\"tablecellheader\"></td><td class=\"tablecellheader\">Database Name</td><td class=\"tablecellheader\">Database Description</td><td class=\"tablecellheader\">Options</td></tr>\r\n";
+
+       $pagedata = $pagedata . $tabledata;
+       
+       $pagedata = $pagedata . "</table>\r\n<br />";
+
+       $pagedata = $pagedata . $select_menu;
+       $pagedata = $pagedata . "</form>";
+
+       # Check if there are no valid databases are if there is no
+       # valid databases then write a message saying that no
+       # valid databases are available.
+
+       if ($database_count eq 0){
+
+               # 
+
+               $pagedata = "<h2>Database List</h2><p>";
+               $pagedata = $pagedata . "<div class=\"errorbox\">There are no databases that can be used for compiling.</div><p>";
+
+       }
+
+       # Check if any databases with problems have appeared and if they
+       # have, print out a message saying which databases have problems.
+
+       if ($permissions_warning eq 1){
+
+               $pagedata = $pagedata . "<h4>Databases with invalid permissions</h4>";
+               $pagedata = $pagedata . "The following databases have invalid permissions set:<br><br>";
+               $pagedata = $pagedata . $permissions_list;
+
+       }
+       
+       if ($invalid_warning eq 1){
+
+               $pagedata = $pagedata . "<h4>Databases with invalid formats</h4>";
+               $pagedata = $pagedata . "The following databases are in a invalid format:<br><br>";
+               $pagedata = $pagedata . $invalid_list;
+
+       }
+
+       return $pagedata;
+
+}
+
+sub kiriwrite_compile_clean{
+#################################################################################
+# kiriwrite_compile_clean: Deletes the contents of the output directory.       #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_compile_clean(confirm);                                            #
+#                                                                              #
+# confirm      Confirms the deletion of files from the output directory.       #
+#################################################################################
+
+       # Get the values passed to the subroutine.
+       
+       my ($confirm) = @_;
+
+       # Define some variables for later.
+
+       my $file_permissions;
+       my $output_directory_exists;
+       my $output_directory_permissions;
+       my $warning_message;
+       my $pagedata = "";
+
+       # Check if the output directory exists.
+
+       $output_directory_exists         = kiriwrite_fileexists($kiriwrite_config{"directory_data_output"});            
+
+       if ($output_directory_exists eq 1){
+
+               # The output directory does not exist so return
+               # an error.
+
+               kiriwrite_error("outputdirectorymissing");
+
+       }
+
+       # Check if the output directory has invalid
+       # permissions set.
+
+       $output_directory_permissions   = kiriwrite_filepermissions($kiriwrite_config{"directory_data_output"});
+
+       if ($output_directory_permissions eq 1){
+
+               # The output directory has invalid permissions
+               # set, so return an error.
+
+               kiriwrite_error("outputdirectoryinvalidpermissions");
+
+       }
+       
+       if ($confirm) {
+       
+               if ($confirm eq 1){
+       
+                       # The action to clean the output directory has been
+                       # confirmed.
+                       
+                       # Remove the list of files and directories from the
+                       # output directory.
+
+                       $file_permissions = kiriwrite_compile_clean_helper($kiriwrite_config{"directory_data_output"}, 1);
+
+                       if ($file_permissions eq 1){
+
+                               # One of the files or directories has invalid
+                               # permissions set so write a warning message.
+
+                       }
+
+                       $pagedata = "<h2>Clean Output Directory</h2>";
+
+                       if ($file_permissions eq 1){
+
+                               $pagedata = $pagedata . "Some of the contents of the directory were removed. However, not all of the files in the output directory were deleted due to invalid permissions.<br><br>";
+
+                       } else {
+
+                               $pagedata = $pagedata . "The contents of the output directory have been removed.<br><br>";
+
+                       }
+
+                       $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=compile\">Return to the compile databases list.</a>";
+                       
+                       return $pagedata;
+               
+               } else {
+               
+                       # A value other than 1 is set for the confirm value
+                       # (which it shouldn't be) so return an error.
+                       
+                       kiriwrite_error("invalidvariable");
+               
+               }
+       
+       }
+       
+       # Print out a form for cleaning the output directory.
+       
+       $pagedata = "<h2>Clean Output Directory</h2>";
+       $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
+       $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"compile\">";
+       $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"clean\">";
+       $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
+       $pagedata = $pagedata . "Are you sure you want to clean the output directory?<br><br>";
+       $pagedata = $pagedata . "<input type=\"submit\" value=\"Yes, clean output directory\"> | <a href=\"kiriwrite.cgi?mode=compile\">Return to compile list.</a>";
+       $pagedata = $pagedata . "</form>";
+       
+       return $pagedata;
+
+}
+
+sub kiriwrite_compile_clean_helper{
+#################################################################################
+# kiriwrite_compile_clean_helper: Helper for cleaning out the output directory.        #
+# This command sometimes is called recursively (when a directory is found).    #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_compile_clean_helper(directory, removedirectory, [permissions]);   #
+#                                                                              #
+# directory            Specifies the directory to remove files (and            #
+#                      sub-directories) from.                                  #
+# keepdirectory                Keeps the directory itself after all files have been    #
+#                      removed.                                                #
+# permissions          Used recursively for error checking.                    #
+#################################################################################
+
+       # Get the values passed to the subroutine.
+       
+       my ($directory, $directory_keep, $permissions) = @_;    
+       
+       # Check if the directory_keep is only one charater long.
+       
+       my $directory_file = "";
+       my @directory_list;
+       my $file_permissions = 0;
+       my $debug = 0;
+
+       # Check if the file permissions value is blank.
+
+       if (!$permissions){
+
+               # The file permissions value is blank.
+
+               $permissions = 0;
+
+       }
+       
+       # Open the directory specified, read the contents of
+       # the directory and then close the directory.
+       
+       opendir(DIRECTORY, $directory);
+       @directory_list = readdir(DIRECTORY);
+       closedir(DIRECTORY);
+       
+       # Remove each file and directory.
+       
+       foreach $directory_file (@directory_list){
+       
+               # Check if the filename is '.' or '..' and if it
+               # is skip those files.
+               
+               if ($directory_file eq "." || $directory_file eq ".."){
+                       
+                       # The filename is '.' or '..' so skip processing
+                       # these files.
+               
+               } else {
+
+                       # Check if the permissions on the file or directory has
+                       # valid permissions set.
+
+                       $file_permissions = kiriwrite_filepermissions($directory . '/' . $directory_file, 1, 1);
+
+                       if ($file_permissions eq 1){
+
+                               # The file or directory has invalid permissions set.
+
+                               $permissions = 1;
+                               next;
+
+                       }
+
+                       # Check if the filename is a directory.
+               
+                       if (-d $directory . '/' . $directory_file){
+               
+                               # The filename is a directory so send the directory name
+                               # and this subroutine again (recursively).
+
+                               kiriwrite_compile_clean_helper($directory . '/' . $directory_file, 0, $permissions);
+               
+                       } else {
+                       
+                               # The file is not a directory but an actual file so
+                               # remove as normal (in terms of the Perl language).
+
+                               ($directory) = $directory =~ m/^([a-zA-Z0-9\/.]+)$/ig;
+                               ($directory_file) = $directory_file =~ m/^([a-zA-Z0-9.]+)$/ig;
+
+                               unlink($directory . '/' . $directory_file);
+                       
+                       }
+       
+               }
+                       
+       }
+       
+       # Check if the directory should be kept.
+       
+       if ($directory_keep eq 1){
+       
+               # The directory_keep value is set as 1 so the directory
+               # specified should be kept.
+       
+       } elsif ($directory_keep eq 0) {
+       
+               # The directory_keep value is set as 0 so remove the
+               # directory specified.
+               
+               ($directory) = $directory =~ m/^([a-zA-Z0-9\/.]+)$/ig;
+               rmdir($directory);
+       
+       } else {
+       
+               # A value other than 0 or 1 was specified so return
+               # an error,
+
+               kiriwrite_error('invalidvalue');
+       
+       }
+
+       return $permissions;
+
+}
+
+sub kiriwrite_settings_view{
+#################################################################################
+# kiriwrite_options_view: Writes out the list of options and variables.                #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_settings_view();                                                   #
+#################################################################################
+
+       # Get the settings.
+
+       my $settings_directory_db       = $kiriwrite_config{"directory_data_db"};
+       my $settings_directory_output   = $kiriwrite_config{"directory_data_output"};
+       my $settings_noncgi_images      = $kiriwrite_config{"directory_noncgi_images"};
+       my $settings_system_datetime    = $kiriwrite_config{"system_datetime"};
+       my $settings_system_language    = $kiriwrite_config{"system_language"};
+       my $settings_system_output      = $kiriwrite_config{"system_output"};
+
+       # CONTINUE: Write out convert things.
+
+       my $settings_directory_db_out           = kiriwrite_convert($settings_directory_db, "normal_display");
+       my $settings_directory_output_out       = kiriwrite_convert($settings_directory_output, "normal_display");
+       my $settings_noncgi_images_out          = kiriwrite_convert($settings_noncgi_images, "normal_display");
+       my $settings_system_datetime_out        = kiriwrite_convert($settings_system_datetime, "normal_display");
+       my $settings_system_language_out        = kiriwrite_convert($settings_system_language, "normal_display");
+       my $settings_system_output_out          = kiriwrite_convert($settings_system_output, "normal_display");
+
+       my $pagedata = "<h2>View Settings</h2>";
+       
+       $pagedata = $pagedata . "The current settings being used are the following:";
+       
+       $pagedata = $pagedata . "<br><br><table cellpadding=\"5\" cellspacing=\"0\">";
+       $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
+       
+       $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Directories</td><td class=\"tablecellheader\"></td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Database Directory</td><td class=\"tablecell2\">" . $settings_directory_db_out . "</td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Output Directory</td><td class=\"tablecell2\">" . $settings_directory_output_out . "</td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Images (URI path)</td><td class=\"tablecell2\">" . $settings_noncgi_images_out . "</td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Date</td><td class=\"tablecellheader\"></td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Date format</td><td class=\"tablecell2\">" . $settings_system_datetime_out . "</td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Language</td><td class=\"tablecellheader\"></td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">System Language</td><td class=\"tablecell2\">" . $settings_system_language_out . "</td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Output</td><td class=\"tablecellheader\"></td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Output System</td><td class=\"tablecell2\">" . $settings_system_output_out . "</td></tr>";
+       $pagedata = $pagedata . "</table><br>";
+       
+       $pagedata = $pagedata . "To alter the current settings, select the Edit Settings option at the top of the page.";
+
+       return $pagedata;
+
+}
+
+sub kiriwrite_settings_edit{
+#################################################################################
+# kiriwrite_options_edit: Edits the options.                                   #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_options_edit(dbdirectory, outputdirectory, imagesuri,              #
+#                      languagesystem, outputsystem, confirm);                 #
+#                                                                              #
+# dbdirectory          Specifies the new database directory to use.            #
+# outputdirectory      Specifies the new output directory to use.              #
+# imagesuri            Specifies the new URI path for images.                  #
+# datetimeformat       Specifies the new date and time format.                 #
+# languagesystem       Specifies the new language to use for Kiriwrite.        #
+# outputsystem         Specifies the new output system to use for Kiriwrite.   #
+# confirm              Confirms the action to edit the settings.               #
+#################################################################################
+
+       # Get the values that have been passed to the subroutine.
+       
+       my ($settings_dbdirectory, $settings_outputdirectory, $settings_imagesuri, $settings_datetimeformat, $settings_languagesystem, $settings_outputsystem, $confirm) = @_;
+       
+       # Load the required Perl modules.
+       
+       my $xsl = XML::Simple->new();
+
+       if (!$confirm){
+       
+               # If the confirm value is blank, then set the confirm
+               # value to 0.
+       
+               $confirm = 0;
+       
+       }
+       
+       if ($confirm eq "1"){
+       
+               # The action to edit the settings has been confirmed.
+               # Start by checking each variable about to be placed
+               # in the settings file is valid.
+               
+               # Deinfe some variables for later.
+
+               my @kiriwrite_new_settings;
+
+               # Check the length of the directory names.
+               
+               kiriwrite_variablecheck($settings_dbdirectory, "maxlength", 64, 0);
+               kiriwrite_variablecheck($settings_outputdirectory, "maxlength", 64, 0);
+               kiriwrite_variablecheck($settings_imagesuri, "maxlength", 512, 0);
+               kiriwrite_variablecheck($settings_datetimeformat, "maxlength", 32, 0);
+                               
+               kiriwrite_variablecheck($settings_languagesystem, "language_filename", "", 0);
+               kiriwrite_variablecheck($settings_outputsystem, "outputmodule", 0, 1);
+
+               # Check if the directory names only contain letters and numbers and
+               # return a specific error if they don't.
+
+               my $kiriwrite_dbdirectory_check         = kiriwrite_variablecheck($settings_dbdirectory, "directory", 0, 1);
+               my $kiriwrite_outputdirectory_check     = kiriwrite_variablecheck($settings_outputdirectory, "directory", 0, 1);
+               kiriwrite_variablecheck($settings_datetimeformat, "datetime", 0, 0);
+               
+               if ($kiriwrite_dbdirectory_check eq 1){
+
+                       # The database directory name is blank, so return
+                       # an error.
+
+                       kiriwrite_error("dbdirectoryblank");
+
+               } elsif ($kiriwrite_dbdirectory_check eq 2){
+
+                       # The database directory name is invalid, so return
+                       # an error.
+
+                       kiriwrite_error("dbdirectoryinvalid");
+
+               }
+
+               if ($kiriwrite_outputdirectory_check eq 1){
+
+                       # The output directory name is blank, so return
+                       # an error.
+
+                       kiriwrite_error("outputdirectoryblank");
+
+               } elsif ($kiriwrite_outputdirectory_check eq 2){
+
+                       # The output directory name is invalid, so return
+                       # an error.
+
+                       kiriwrite_error("outputdirectoryinvalid");
+
+               }
+
+               # Place the settings into the array.
+
+               $kiriwrite_new_settings[0] = $settings_dbdirectory;
+               $kiriwrite_new_settings[1] = $settings_outputdirectory;
+               $kiriwrite_new_settings[2] = $settings_imagesuri;
+               $kiriwrite_new_settings[3] = $settings_datetimeformat;
+               $kiriwrite_new_settings[4] = $settings_languagesystem;
+               $kiriwrite_new_settings[5] = $settings_outputsystem;
+
+               # Write the new settings to the XML file.
+               
+               kiriwrite_output_xml("kiriwrite.xml", "config", @kiriwrite_new_settings);
+               
+               # Write a confirmation message.
+               
+               my $pagedata = "<h2>Edit Settings</h2>";
+               $pagedata = $pagedata . "The page settings have been changed and will take effect on the next page load of Kiriwrite.<br><br>";
+               $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=settings\">Return to the list of settings.</a>"; 
+               
+               return $pagedata;
+       
+       }
+       
+       # Get the list of languages available.
+       
+       my @language_directory          = "";
+       my $language_filename           = "";
+       my $language_file_xml           = "";
+       my $language_file_systemname    = "";
+       my $language_file_localname     = "";
+       my $language_file_localname_out = "";
+       my $language_file_seek          = 0;
+       my $language_flie_dot           = 0;
+       my $language_file_length        = 0;
+       my $language_file_char          = "";
+       my $language_file_friendly      = "";
+       my $language_selectlist         = "";
+       
+       opendir(LANGUAGEDIR, "lang");
+       @language_directory = grep /m*\.xml/, readdir(LANGUAGEDIR);
+       closedir(LANGUAGEDIR);
+       
+       # Process each language by loading the XML configuration file
+       # used for each language and then get the System name and 
+       # the local name of the language.
+       
+       $language_selectlist = "<select name=\"language\">";
+       
+       foreach $language_filename (@language_directory){
+       
+               # Load the language file currently selected.
+       
+               $language_file_xml = $xsl->XMLin("lang" . '/' . $language_filename, SuppressEmpty => 1);
+               
+               # Get the system name and the local name of the language.
+               
+               $language_file_localname = $language_file_xml -> {about} -> {name};
+               
+               # Check if either the system name or the local name of the language
+               # is blank and if it is, then don't add the language to the list.
+               
+               if ($language_file_localname eq ""){
+                       
+                       # The system name or the local name is blank so don't add
+                       # the language to the list.
+                                                               
+               } else {
+               
+                       # Get the 'friendly' name of the language file name (basically
+                       # remove the .xml part from the filename.
+               
+                       $language_file_length = length($language_filename);
+                       
+                       do {
+                       
+                               # Get a character from the language filename and currently
+                               # set by the seek counter.
+                               
+                               $language_file_char = substr($language_filename, $language_file_seek, 1);
+                               
+                               # Check if the character is a dot and if it is then set the
+                               # last dot value to the seek counter value.
+                               
+                               if ($language_file_char eq "."){
+                               
+                                       # Current chatacter is a dot so set the last dot value 
+                                       # to what is currently the seek counter.
+                                       
+                                       $language_flie_dot = $language_file_seek;
+                               
+                               } else {
+                               
+                                       # Current character is not a dot, so do nothing.
+                               
+                               }
+                       
+                               # Increment the seek counter.
+                       
+                               $language_file_seek++;
+                       
+                       } until ($language_file_seek eq $language_file_length);
+                       
+                       # Reset the seek counter.
+                       
+                       $language_file_seek = 0;
+                       
+                       # Process the file name again and this time process the file
+                       # name until it reaches the last dot found.
+                       
+                       do {
+                       
+                               # Get the character the seek counter is currently set at.
+                       
+                               $language_file_char = substr($language_filename, $language_file_seek, 1);
+
+                               # Append the character to the friendly file name.
+                               
+                               $language_file_friendly = $language_file_friendly . $language_file_char;
+                               
+                               # Increment the seek counter.
+                                                       
+                               $language_file_seek++;
+                       
+                       } until ($language_file_seek eq $language_flie_dot);
+                       
+                       # Append the language to the available languages list.
+                       
+                       $language_file_localname_out = kiriwrite_convert($language_file_localname, "normal_display");
+                       $language_selectlist = $language_selectlist . "<option value=\"" . $language_file_friendly . "\">" . $language_file_localname_out . "</option>";
+               
+                       # Reset certain counters and values before continuing.
+                       
+                       $language_file_seek     = 0;
+                       $language_flie_dot      = 0;
+                       $language_file_length   = 0;
+                       $language_file_char     = "";
+                       $language_file_friendly = "";
+                       
+               }
+               
+       }       
+       
+       $language_selectlist = $language_selectlist . "</select>";
+       
+       # Get the list of output systems available.
+       
+       my @outputsys_directory         = "";
+       my $outputsys_file              = "";
+       my $outputsys_char              = "";
+       my $outputsys_dot               = 0;
+       my $outputsys_firstdot          = 0;
+       my $outputsys_firstdotfound     = "";
+       my $outputsys_seek              = 0;
+       my $outputsys_length            = 0;
+       my $outputsys_friendly          = "";
+       my $outputsys_selectlist        = "";
+       my $outputsys_config            = $kiriwrite_config{"system_output"};
+       
+       # Open and get the list of output systems (perl modules) by filtering
+       # out the 
+       
+       opendir(OUTPUTSYSTEMDIR, "Modules/Output");
+       @outputsys_directory = grep /m*\.pm/, readdir(OUTPUTSYSTEMDIR);
+       closedir(OUTPUTSYSTEMDIR);
+               
+       $outputsys_selectlist = "<select name=\"outputsys\">";  
+       
+       # Process each output system and add them to the list of available
+       # output systems.
+       
+       foreach $outputsys_file (@outputsys_directory){
+               
+               # Get the length of the output system (perl module) filename.   
+
+               $outputsys_length = length($outputsys_file);
+               
+               # Get the friendly name of the Perl module (by getting rid of the
+               # .pm part of the filename).
+                               
+               do {
+               
+                       $outputsys_char = substr($outputsys_file, $outputsys_seek, 1);
+                       
+                       # Check if the current character is a dot and if it is then
+                       # set the last dot found number to the current seek number.
+                       
+                       if ($outputsys_char eq "."){
+                       
+                               # Put the seek value as the last dot found number.
+                       
+                               $outputsys_dot = $outputsys_seek;
+                       
+                       }
+                       
+                       # Increment the seek counter.
+                       
+                       $outputsys_seek++;
+               
+               } until ($outputsys_seek eq $outputsys_length);
+               
+               # Reset the seek counter as it is going to be used again.
+               
+               $outputsys_seek = 0;
+               
+               # Get the friendly name of the Perl module by the processing the file
+               # name to the last dot the previous 'do' tried to find.
+               
+               do {
+                       
+                       # Get the character the seek counter is currently set at.
+               
+                       $outputsys_char = substr($outputsys_file, $outputsys_seek, 1);
+                       
+                       # Append the character to the friendly name of the output system.
+                       
+                       $outputsys_friendly = $outputsys_friendly . $outputsys_char;
+                       
+                       # Increment the seek counter.
+                       
+                       $outputsys_seek++;
+               
+               } until ($outputsys_seek eq $outputsys_dot);
+               
+               # Append the option to tbe list of available output systems.
+
+               # Check if the current friendly output module name matches with the
+               # output module name used in the configuration file.
+
+               if ($outputsys_friendly eq $outputsys_config){
+               
+                       # The output module friendly name matches with the output
+                       # module name used in the configuration file.
+
+                       $outputsys_selectlist = $outputsys_selectlist . "<option value=\"" . $outputsys_friendly . "\" selected>" . $outputsys_friendly . "</option>";
+
+               } else {
+
+                       # The output module friendly name does not match with the
+                       # output module name used in the configuration file.
+
+                       $outputsys_selectlist = $outputsys_selectlist . "<option value=\"" . $outputsys_friendly . "\">" . $outputsys_friendly . "</option>";
+
+               }
+               
+               # Reset the following values.
+               
+               $outputsys_seek         = 0;
+               $outputsys_length       = 0;
+               $outputsys_char         = "";
+               $outputsys_friendly     = "";
+               
+               
+       }
+       
+       $outputsys_selectlist = $outputsys_selectlist . "</select>";    
+       
+       # Get the directory settings.
+       
+       my $directory_settings_database                 = $kiriwrite_config{"directory_data_db"};
+       my $directory_settings_output                   = $kiriwrite_config{"directory_data_output"};
+       my $directory_settings_imagesuri                = $kiriwrite_config{"directory_noncgi_images"};
+       my $datetime_setting                            = $kiriwrite_config{"system_datetime"};
+
+       my $directory_settings_database_out             = kiriwrite_convert($directory_settings_database, "normal_display");
+       my $directory_settings_output_out               = kiriwrite_convert($directory_settings_output, "normal_display");
+       my $directory_settings_imagesuri_out            = kiriwrite_convert($directory_settings_imagesuri, "normal_display");
+       my $datetime_setting_out                        = kiriwrite_convert($datetime_setting, "normal_display");
+       
+       # Print out a form for editing the settings.
+
+       my $pagedata = "<h2>Edit Settings</h2>";
+       $pagedata = $pagedata . "<b>Warning:</b> Settings that have changed take effect after clicking on the 'Change Settings' button and viewing the confirmation message.<br><br>";
+       
+       $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
+       $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"settings\">";
+       $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"edit\">";
+       $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
+       $pagedata = $pagedata . "<table cellpadding=\"5\" cellspacing=\"0\">";
+       $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Directories</td><td class=\"tablecellheader\"></td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Database Directory</td><td class=\"tablecell2\"><input type=\"text\" name=\"databasedir\" value=\"" . $directory_settings_database_out . "\" size=\"32\" maxlength=\"64\"></td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Output Directory</td><td class=\"tablecell2\"><input type=\"text\" name=\"outputdir\" value=\"" . $directory_settings_output_out . "\" size=\"32\" maxlength=\"64\"></td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Images (URI path)</td><td class=\"tablecell2\"><input type=\"text\" name=\"imagesuripath\" value=\"" . $directory_settings_imagesuri_out . "\" size=\"32\" maxlength=\"64\"></td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Date</td><td class=\"tablecellheader\"></td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Date format</td><td class=\"tablecell2\"><input type=\"text\" name=\"datetime\" value=\"" . $datetime_setting_out . "\" size=\"32\" maxlength=\"32\"><br><br>";
+       $pagedata = $pagedata . "<div class=\"datalist\">D - Show single digit day if day value is less than 10.<br>
+       DD - Show double digit day if day value is less than 10.<br>
+       M - Show single digit month if month value is less than 10.<br>
+       MM - Show double digit month if month value is less than 10.<br>
+       Y - Show double digit year value.<br>
+       YY - Show four digit year value.<br><br>
+       h - Show single digit hour if hour value is less than 10.<br>
+       hh - Show double digit hour if hour value is less than 10.<br>
+       m - Show single digit minute if minute value is less than 10.<br>
+       mm - Show double digit minute if minute value is less than 10.<br>
+       s - Show single digit second if second value is less than 10.<br>
+       ss - Show double digit second if second value is less than 10.<br><br>
+       Other Characters: / - ( ) :
+       </div>";
+       $pagedata = $pagedata . "</td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Languages</td><td class=\"tablecellheader\"></td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">System Language</td><td class=\"tablecell2\">" . $language_selectlist . "</td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Output</td><td class=\"tablecellheader\"></td></tr>";
+       $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Output System</td><td class=\"tablecell2\">" . $outputsys_selectlist . "</td></tr>";
+       $pagedata = $pagedata . "</table><br>";
+       $pagedata = $pagedata . "<input type=\"submit\" value=\"Change Settings\"> | <input type=\"reset\" value=\"Revert Settings\">";
+       $pagedata = $pagedata . "</form>";
+       
+       return $pagedata;
+
+}
+
+sub kiriwrite_settings_load{
+#################################################################################
+# kiriwrite_settings_load: Load the configuration settings into the global     #
+# variables.                                                                   #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_settings_load();                                                   #
+#################################################################################
+
+       # Load the required Perl modules.
+
+       use XML::Simple;
+       my $xsl = XML::Simple->new();   
+
+       # Check if the Kiriwrite configuration file exists before using it and
+       # return a critical error if it doesn't exist.
+
+       my $kiriwrite_conf_exist = kiriwrite_fileexists("kiriwrite.xml");
+       
+       if ($kiriwrite_conf_exist eq 1){
+
+               # The configuration really does not exist so return an critical error.
+
+               kiriwrite_critical("configfilemissing");
+
+       }
+
+       # Check if the Kiriwrite configuration file has valid permission settings
+       # before using it and return a critical error if it doesn't have the
+       # valid permission settings.
+
+       my $kiriwrite_conf_permissions = kiriwrite_filepermissions("kiriwrite.xml", 1, 0);
+
+       if ($kiriwrite_conf_permissions eq 1){
+
+               # The permission settings for the Kiriwrite configuration file are
+               # invalid, so return an critical error.
+
+               kiriwrite_critical("configfileinvalidpermissions");
+
+       }
+
+       # Converts the XML file into meaningful data for later on in this subroutine.
+       
+       my $kiriwrite_conf_file = 'kiriwrite.xml';
+       my $kiriwrite_conf_data = $xsl->XMLin($kiriwrite_conf_file, SuppressEmpty => 1);        
+
+       # Go and fetch the settings and place them into a hash (that is global).
+       
+       %kiriwrite_config = (
+       
+               "directory_data_db"             => $kiriwrite_conf_data->{settings}->{directories}->{database},
+               "directory_data_output"         => $kiriwrite_conf_data->{settings}->{directories}->{output},
+               "directory_noncgi_images"       => $kiriwrite_conf_data->{settings}->{directories}->{images},
+               
+               "system_language"               => $kiriwrite_conf_data->{settings}->{language}->{type},
+               "system_output"                 => $kiriwrite_conf_data->{settings}->{system}->{output},
+               "system_datetime"               => $kiriwrite_conf_data->{settings}->{system}->{datetime}
+               
+       );      
+       
+       # Do a validation check on all of the variables that were loaded into the global configuration hash.
+       
+       kiriwrite_variablecheck($kiriwrite_config{"directory_data_db"}, "maxlength", 64, 0);
+       kiriwrite_variablecheck($kiriwrite_config{"directory_data_output"}, "maxlength", 64, 0);
+       kiriwrite_variablecheck($kiriwrite_config{"directory_noncgi_images"}, "maxlength", 512, 0);
+       kiriwrite_variablecheck($kiriwrite_config{"directory_data_template"}, "maxlength", 64, 0);
+       
+       kiriwrite_variablecheck($kiriwrite_config{"system_language"}, "language_filename", "", 0);
+       kiriwrite_variablecheck($kiriwrite_config{"system_output"}, "outputmodule", 0, 0);
+
+       # Check if the output system module does exist before loading it and return an critical error
+       # if the output system module does not exist.
+
+       my $kiriwrite_config_systemoutput_fileexists = kiriwrite_fileexists("Modules/Output/" . $kiriwrite_config{"system_output"} . ".pm");
+
+       if ($kiriwrite_config_systemoutput_fileexists eq 1){
+
+               # Output system module does not exist so return an critical error.
+               
+               kiriwrite_critical("outputsystemmissing");
+
+       }
+
+       # Check if the output system module does have the valid permission settings and return an
+       # critical error if the output system module contains invalid permission settings.
+
+       my $kiriwrite_config_systemoutput_permissions = kiriwrite_filepermissions("Modules/Output/" . $kiriwrite_config{"system_output"} . ".pm", 1, 0);
+
+       if ($kiriwrite_config_systemoutput_permissions eq 1){
+
+               # Output system contains invalid permissions so return an critical error.
+
+               kiriwrite_critical("outputsysteminvalidpermissions");
+
+       }
+
+       return;
+       
+}
+
+sub kiriwrite_variablecheck{
+#################################################################################
+# kiriwrite_variablecheck: Checks the variables for any invalid characters.    #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #                       
+# kiriwrite_variablecheck(variablename, type, length, noerror);                        #
+#                                                                              #
+# variablename Specifies the variable to be checked.                           #
+# type         Specifies what type the variable is.                            #
+# option       Specifies the maximum/minimum length of the variable            #
+#              (if minlength/maxlength is used) or if the filename should be   #
+#              checked to see if it is blank.                                  #
+# noerror      Specifies if Kiriwrite should return an error or not on         #
+#              certain values.                                                 #
+#################################################################################
+
+       # Get the values that were passed to the subroutine.
+
+       my ($variable_data, $variable_type, $variable_option, $variable_noerror) = @_;
+       
+       if ($variable_type eq "numbers"){
+               
+               # Check for numbers and return an error if there is anything else than numebrs.
+                               
+               my $variable_data_validated = $variable_data;   # Copy the variable_data to variable_data_validated.
+               $variable_data_validated =~ tr/0-9//d;          # Take away all of the numbers and from the variable. 
+                                                               # If it only contains numbers then it should be blank.
+
+               if ($variable_data_validated eq ""){
+                       # The validated variable is blank. So continue to the end of this section where the return function should be.
+               } else {
+                       # The variable is not blank, so check if the no error value is set
+                       # to 1 or not.
+                       
+                       if ($variable_noerror eq 1){
+                       
+                               # The validated variable is not blank and the noerror
+                               # value is set to 1. So return an value of 1.
+                               # (meaning that the data is invalid).
+                               
+                               return 1;
+                       
+                       } elsif ($variable_noerror eq 0) {
+                       
+                               # The validated variable is not blank and the noerror
+                               # value is set to 0.
+                       
+                               kiriwrite_error("invalidvariable");
+                               
+                       } else {
+                       
+                               # The variable noerror value is something else
+                               # pther than 1 or 0. So return an error.
+                       
+                               kiriwrite_error("invalidvariable");
+                       
+                       }
+                       
+               }
+               
+               return 0;               
+       
+       } elsif ($variable_type eq "lettersnumbers"){
+
+               # Check for letters and numbers and return an error if there is anything else other
+               # than letters and numbers.
+
+               my $variable_data_validated = $variable_data;   # Copy the variable_data to variable_data_validated
+               $variable_data_validated =~ tr/a-zA-Z0-9.//d;
+               $variable_data_validated =~ s/\s//g;
+
+               if ($variable_data_validated eq ""){
+                       # The validated variable is blank. So continue to the end of this section where the return function should be.
+               } else {
+                       # The variable is not blank, so check if the no error value is set
+                       # to 1 or not.
+
+                       if ($variable_noerror eq 1){
+                       
+                               # The validated variable is not blank and the noerror
+                               # value is set to 1. So return an value of 1.
+                               # (meaning that the data is invalid).
+                               
+                               return 1;
+                       
+                       } elsif ($variable_noerror eq 0) {
+                       
+                               # The validated variable is not blank and the noerror
+                               # value is set to 0.
+                       
+                               kiriwrite_error("invalidvariable");
+                               
+                       } else {
+                       
+                               # The variable noerror value is something else
+                               # pther than 1 or 0. So return an error.
+                       
+                               kiriwrite_error("invalidvariable");
+                       
+                       }
+
+               }
+
+               return 0;
+
+       } elsif ($variable_type eq "maxlength"){
+               # Check for the length of the variable, return an error if it is longer than the length specified.
+               
+               # Check if the variable_data string is blank, if it is then set the variable_data_length
+               # to '0'.
+               
+               my $variable_data_length = 0;           
+               
+               if (!$variable_data){
+               
+                       # Set variable_data_length to '0'.
+                       $variable_data_length = 0;
+               
+               } else {
+               
+                       # Get the length of the variable recieved.
+                       $variable_data_length = length($variable_data); 
+                       
+               }
+
+
+
+               if ($variable_data_length > $variable_option){
+
+                       # The variable length is longer than it should be so check if
+                       # the no error value is set 1.
+                       
+                       if ($variable_noerror eq 1){
+                       
+                               # The no error value is set to 1, so return an
+                               # value of 1 (meaning tha the variable is
+                               # too long to be used).
+                       
+                               return 1;       
+                       
+                       } elsif ($variable_noerror eq 0){
+                       
+                               # The no error value is set to 0, so return
+                               # an error.
+                       
+                               kiriwrite_error("variabletoolong");
+                       
+                       } else {
+                       
+                               # The no error value is something else other
+                               # than 0 or 1, so return an error.
+                       
+                               kiriwrite_error("variabletoolong");
+                       
+                       }
+                       
+               } else {
+               
+                       # The variable length is exactly or shorter than specified, so continue to end of this section where
+                       # the return function should be.
+                       
+               }
+
+               return 0;
+               
+       } elsif ($variable_type eq "blank"){
+               # Check if the variable is blank and if it is blank, then return an error.
+
+               if (!$variable_data){
+
+                       # The variable data really is blank, so check what
+                       # the no error value is set.
+
+                       if ($variable_noerror eq 1){
+
+                               # The no error value is set to 1, so return
+                               # a value of 1 (saying that the variable was
+                               # blank).
+
+                               return 1;
+
+                       } elsif ($variable_noerror eq 0){
+
+                               # The no error value is set to 0, so return
+                               # an error.
+
+                               kiriwrite_error("blankvariable");
+
+                       } else {
+
+                               # The no error value is something else other
+                               # than 0 or 1, so return an error.
+
+                               kiriwrite_error("invalidvariable");
+
+                       }
+
+               }
+
+               return 0;
+
+       } elsif ($variable_type eq "filename"){
+               # Check for letters and numbers, if anything else than letters and numbers is there (including spaces) return
+               # an error.
+               
+               # Check if the filename passed is blank, if it is then return with an error.
+               
+               if ($variable_data eq ""){
+               
+                       # The filename specified is blank, so check what the
+                       # noerror value is set.
+               
+                       if ($variable_noerror eq 1){
+                       
+                               # The no error value is set to 1 so return
+                               # a value of 1 (meaning that the filename
+                               # was blank).
+                       
+                               return 1;
+                       
+                       } elsif ($variable_noerror eq 0){
+                       
+                               # The no error value is set to 1 so return
+                               # an error.
+                       
+                               kiriwrite_error("blankfilename");
+                       
+                       } else {
+                       
+                               # The no error value is something else other
+                               # than 0 or 1, so return an error.
+                       
+                               kiriwrite_error("invalidvariable");
+                       
+                       }
+                       
+               } else {
+               
+               
+               }
+               
+               my $variable_data_validated = $variable_data;
+               $variable_data_validated =~ tr/a-zA-Z0-9\.//d;
+               
+               # Check if the validated data variable is blank, if it is 
+               # then continue to the end of this section where the return 
+               # function should be, otherwise return an error.
+               
+               if ($variable_data_validated eq ""){
+                       
+                       # The validated data variable is blank, meaning that 
+                       # it only contained letters and numbers.
+                       
+               } else {
+                       
+                       # The validated data variable is not blank, meaning 
+                       # that it contains something else, so return an error
+                       # (or a value).
+                       
+                       if ($variable_noerror eq 1){
+                       
+                               # The no error value is set to 1 so return
+                               # an value of 2. (meaning that the filename
+                               # is invalid).
+                               
+
+                               return 2;
+                       
+                       } elsif ($variable_noerror eq 0){
+                       
+                               # The no error value is set to 0 so return
+                               # an error.
+                               
+                               kiriwrite_error("invalidfilename");
+                       
+                       } else {
+                       
+                               # The no error value is something else other
+                               # than 0 or 1 so return an error.
+                               
+                               kiriwrite_error("invalidvariable");
+                       
+                       }
+                       
+               }
+               
+               return 0;
+       
+       } elsif ($variable_type eq "filenameindir"){
+               # Check if the filename is in the directory and return an
+               # error if it isn't.
+
+               if ($variable_data eq ""){
+               
+                       # The filename specified is blank, so check what the
+                       # noerror value is set.
+               
+                       if ($variable_noerror eq 1){
+                       
+                               # The no error value is set to 1 so return
+                               # a value of 1 (meaning that the filename
+                               # was blank).
+                       
+                               return 1;
+                       
+                       } elsif ($variable_noerror eq 0){
+                       
+                               # The no error value is set to 1 so return
+                               # an error.
+                       
+                               kiriwrite_error("blankfilename");
+                       
+                       } else {
+                       
+                               # The no error value is something else other
+                               # than 0 or 1, so return an error.
+                       
+                               kiriwrite_error("invalidvariable");
+                       
+                       }
+                       
+               } else {
+               
+               
+               }
+
+               # Set the following variables for later on.
+               
+               my $variable_data_length = 0;
+               my $variable_data_char = "";
+               my $variable_data_validated = "";
+               my $variable_data_seek = 0;
+               my $variable_data_directory = "";
+               my $variable_data_directorycurrent = "";
+               my $variable_data_firstlevel = 1;
+
+               # Get the length of the variable recieved.
+
+               $variable_data_length = length($variable_data);
+
+               # Check if the database filename contains the directory command
+               # for up a directory level and if it is, return an error
+               # or return with a number.
+               
+               do {
+                       
+                       # Get a character from the filename passed to this subroutine.
+               
+                       $variable_data_char = substr($variable_data, $variable_data_seek, 1);
+                       
+                       # Check if the current character is the forward slash character.
+                       
+                       if ($variable_data_char eq "/"){
+                       
+                               # Check if the current directory is blank (and on the first level), or if the
+                               # current directory contains two dots or one dot, if it does return an error.
+                       
+                               if ($variable_data_directorycurrent eq "" && $variable_data_firstlevel eq 1 || $variable_data_directorycurrent eq ".." || $variable_data_directorycurrent eq "."){
+                                       
+                                       # Check if the noerror value is set to 1, if it is return an
+                                       # number, else return an proper error.
+                                       
+                                       if ($variable_noerror eq 1){
+                                       
+                                               # Page filename contains invalid characters and
+                                               # the no error value is set to 1 so return a 
+                                               # value of 2 (meaning that the page filename
+                                               # is invalid).
+                                       
+                                               return 2;
+                                               
+                                       } elsif ($variable_noerror eq 0) {
+                                       
+                                               # Page filename contains invalid characters and
+                                               # the no error value is set to 0 so return an
+                                               # error.
+                                       
+                                               kiriwrite_error("invalidfilename");
+                                               
+                                       } else {
+                                       
+                                               # The no error value is something else other
+                                               # than 0 or 1 so return an error.
+                                       
+                                               kiriwrite_error("invalidvariable");
+                                               
+                                       }
+                                       
+                               }
+                               
+                               # Append the forward slash, clear the current directory name and set
+                               # the first directory level value to 0.
+                               
+                               $variable_data_directory = $variable_data_directory . $variable_data_char;
+                               $variable_data_directorycurrent = "";
+                               $variable_data_firstlevel = 0;
+                       
+                       } else {
+                       
+                               # Append the current character to the directory name and to the current
+                               # directory name.
+                       
+                               $variable_data_directory = $variable_data_directory . $variable_data_char;
+                               $variable_data_directorycurrent = $variable_data_directorycurrent . $variable_data_char;
+                                               
+                       }
+                       
+                       # Increment the seek counter.
+                       
+                       $variable_data_seek++;
+                                       
+               } until ($variable_data_seek eq $variable_data_length);
+
+               return 0;       
+
+       } elsif ($variable_type eq "datetime"){
+               # Check if the date and time setting format is valid.
+
+               if ($variable_data eq ""){
+
+                       if ($variable_noerror eq 1){
+                       
+                               # The no error value is set to 1 so return
+                               # a value of 1 (meaning that the date and
+                               # time format was blank).
+                       
+                               return 1;
+                       
+                       } elsif ($variable_noerror eq 0){
+                       
+                               # The no error value is set to 1 so return
+                               # an error.
+                       
+                               kiriwrite_error("blankdatetimeformat");
+                       
+                       } else {
+                       
+                               # The no error value is something else other
+                               # than 0 or 1, so return an error.
+                       
+                               kiriwrite_error("invalidvariable");
+                       
+                       }
+
+               }
+
+               my $variable_data_validated = $variable_data;
+               $variable_data_validated =~ tr|dDmMyYhms/():[ ]||d;
+
+               if ($variable_data_validated eq ""){
+
+                       # The date and time format is valid. So
+                       # skip this bit.
+
+               } else {
+
+                       # The validated data variable is not blank, meaning 
+                       # that it contains something else, so return an error
+                       # (or a value).
+                       
+                       if ($variable_noerror eq 1){
+                       
+                               # The no error value is set to 1 so return
+                               # an value of 2. (meaning that the date and
+                               # time format was invalid).
+                               
+                               return 2;
+                       
+                       } elsif ($variable_noerror eq 0){
+                       
+                               # The no error value is set to 0 so return
+                               # an error.
+                               
+                               kiriwrite_error("invaliddatetimeformat");
+                       
+                       } else {
+                       
+                               # The no error value is something else other
+                               # than 0 or 1 so return an error.
+                               
+                               kiriwrite_error("invalidvariable");
+                       
+                       }
+
+               }
+
+               return 0;
+
+       } elsif ($variable_type eq "directory"){
+               # Check if the directory only contains letters and numbers and
+               # return an error if anything else appears.
+
+               my $variable_data_validated = $variable_data;
+               $variable_data_validated =~ tr/a-zA-Z0-9//d;
+
+               if ($variable_data eq ""){
+
+                       if ($variable_noerror eq 1){
+                       
+                               # The no error value is set to 1 so return
+                               # a value of 1 (meaning that the directory
+                               # name was blank).
+                       
+                               return 1;
+                       
+                       } elsif ($variable_noerror eq 0){
+                       
+                               # The no error value is set to 1 so return
+                               # an error.
+                       
+                               kiriwrite_error("blankdirectory");
+                       
+                       } else {
+                       
+                               # The no error value is something else other
+                               # than 0 or 1, so return an error.
+                       
+                               kiriwrite_error("invalidvariable");
+                       
+                       }
+
+               }
+
+               if ($variable_data_validated eq ""){
+
+                       # The validated data variable is blank, meaning that
+                       # it only contains letters and numbers.
+
+               } else {
+
+                       # The validated data variable is not blank, meaning 
+                       # that it contains something else, so return an error
+                       # (or a value).
+                       
+                       if ($variable_noerror eq 1){
+                       
+                               # The no error value is set to 1 so return
+                               # an value of 2. (meaning that the directory
+                               # name is invalid).
+                               
+                               return 2;
+                       
+                       } elsif ($variable_noerror eq 0){
+                       
+                               # The no error value is set to 0 so return
+                               # an error.
+                               
+                               kiriwrite_error("invaliddirectory");
+                       
+                       } else {
+                       
+                               # The no error value is something else other
+                               # than 0 or 1 so return an error.
+                               
+                               kiriwrite_error("invalidvariable");
+                       
+                       }
+
+               }
+
+               return 0;
+
+       } elsif ($variable_type eq "language_filename"){
+       
+               # The variable type is a language filename type.
+               # Check if the language file name is blank and 
+               # if it is then return an error (or value).
+               
+               if ($variable_data eq ""){
+               
+                       # The language filename is blank so check the
+                       # no error value and return an error (or value).
+               
+                       if ($variable_noerror eq 1){
+                               
+                               # Language filename is blank and the no error value
+                               # is set as 1, so return a value of 1 (saying that
+                               # the language filename is blank).
+                               
+                               return 1;
+                       
+                       } elsif ($variable_noerror eq 0) {
+                       
+                               # Language filename is blank and the no error value
+                               # is not set as 1, so return an error.
+                               
+                               kiriwrite_error("emptylanguagefilename");
+                       
+                       } else {
+                       
+                               # The noerror value is something else other
+                               # than 0 or 1 so return an error.
+                               
+                               kiriwrite_error("invalidvariable");
+                       
+                       }
+               
+               }
+               
+               # Set the following variables for later on.
+               
+               my $variable_data_length = 0;
+               my $variable_data_char = "";
+               my $variable_data_seek = 0;
+               
+               # Get the length of the language file name.
+               
+               $variable_data_length = length($variable_data);
+               
+               do {
+               
+                       # Get a character from the language filename passed to this 
+                       # subroutine and the character the seek counter value is set
+                       # to.
+               
+                       $variable_data_char = substr($variable_data, $variable_data_seek, 1);
+                       
+                       # Check if the language filename contains a forward slash or a dot, 
+                       # if the selected character is a forward slash then return an error
+                       # (or value).
+                       
+                       if ($variable_data_char eq "/" || $variable_data_char eq "."){
+                       
+                               # The language filename contains a forward slash or
+                               # a dot so depending on the no error value, return
+                               # an error or a value.
+                       
+                               if ($variable_noerror eq 1){
+                                       
+                                       # Language filename contains a forward slash or a dot
+                                       # and the no error value has been set to 1, so return 
+                                       # an value of 2 (saying that the language file name is 
+                                       # invalid).
+                                       
+                                       return 2;
+                               
+                               } elsif ($variable_noerror eq 0) {
+                               
+                                       # Language filename contains a forward slash and the no
+                                       # error value has not been set to 1, so return an error.
+                               
+                                       kiriwrite_error("invalidlanguagefilename");
+                                       
+                               } else {
+                               
+                                       # The noerror value is something else other than
+                                       # 1 or 0 so return an error.
+                                       
+                                       kiriwrite_error("invalidvariable");
+                               
+                               }
+                       
+                       }
+                       
+                       # Increment the seek counter.
+
+                       $variable_data_seek++;
+               
+               } until ($variable_data_seek eq $variable_data_length);
+               
+               return 0;
+                                       
+       } elsif ($variable_type eq "pagesetting"){
+
+               # The variable type is a page setting, so check if the page
+               # setting has one of the valid options.
+
+               if ($variable_data eq 0 || $variable_data eq 1 || $variable_data eq 2 || $variable_data eq 3){
+
+                       # The variable is one of the options above, so continue
+                       # to the end of this section.   
+
+               } else {
+
+                       # The variable is not one of the options above, so check
+                       # and see if a error or a value should be returned.
+
+                       if ($variable_noerror eq 1){
+                       
+                               # The page setting is invalid and the no error
+                               # value is set 1, so return a value of 1
+                               # (saying that the page setting value is
+                               # invalid).
+                               
+                               return 1;
+                               
+                       } elsif ($variable_noerror eq 0) {
+                               
+                               # Page setting is invalid and the no error value
+                               # is not 1, so return an error.
+                       
+                               kiriwrite_error("invalidvariable");
+                               
+                       } else {
+                       
+                               # The no error value is something else other
+                               # than 0 or 1 so return an error.
+                       
+                               kiriwrite_error("invalidvariable");
+                       
+                       }
+
+               }
+
+               return 0;
+
+       } elsif ($variable_type eq "page_filename"){
+        
+               # The variable type is a page filename type. Check
+               # if the data is empty and if it is then return an
+               # error (or value).
+       
+               if ($variable_data eq ""){
+               
+                       # The filename is blank so check the no error
+                       # value and depending on it return an value
+                       # or an error.
+               
+                       if ($variable_noerror eq 1){
+                       
+                               # Page filename is blank and the no error value
+                               # is set as 1, so return a value of 1 (saying
+                               # the filename is blank).
+                               
+                               return 1;
+                               
+                       } elsif ($variable_noerror eq 0) {
+                               
+                               # Page filename is blank and the no error value
+                               # is not 1, so return an error.
+                       
+                               kiriwrite_error("emptypagefilename");
+                               
+                       } else {
+                       
+                               # The no error value is something else other
+                               # than 0 or 1 so return an error.
+                       
+                               kiriwrite_error("invalidvariable");
+                       
+                       }
+               }
+               
+               # Set the following variables for later on.
+               
+               my $variable_data_length = 0;
+               my $variable_data_char = "";
+               my $variable_data_validated = "";
+               my $variable_data_seek = 0;
+               my $variable_data_directory = "";
+               my $variable_data_directorycurrent = "";
+               my $variable_data_firstlevel = 1;
+               
+               # Get the length of the filename.
+               
+               $variable_data_length = length($variable_data);
+               
+               # Check that only valid characters should be appearing in
+               # the filename.
+
+               $variable_data_validated = $variable_data;
+               $variable_data_validated =~ tr|a-zA-Z0-9\.\/||d;
+
+               if ($variable_data_validated ne ""){
+
+                       # The validated variable is not blank, meaning the
+                       # variable contains invalid characters, so return
+                       # an error.
+
+                       kiriwrite_error("invalidfilename");
+
+               }
+
+               # Check if the page filename contains the directory command
+               # for up a directory level and if it is, return an error
+               # or return with a number.
+               
+               do {
+                       
+                       # Get a character from the filename passed to this subroutine.
+               
+                       $variable_data_char = substr($variable_data, $variable_data_seek, 1);
+                       
+                       # Check if the current character is the forward slash character.
+                       
+                       if ($variable_data_char eq "/"){
+                       
+                               # Check if the current directory is blank (and on the first level), or if the
+                               # current directory contains two dots or one dot, if it does return an error.
+                       
+                               if ($variable_data_directorycurrent eq "" && $variable_data_firstlevel eq 1 || $variable_data_directorycurrent eq ".." || $variable_data_directorycurrent eq "."){
+                                       
+                                       # Check if the noerror value is set to 1, if it is return an
+                                       # number, else return an proper error.
+                                       
+                                       if ($variable_noerror eq 1){
+                                       
+                                               # Page filename contains invalid characters and
+                                               # the no error value is set to 1 so return a 
+                                               # value of 2 (meaning that the page filename
+                                               # is invalid).
+                                       
+                                               return 2;
+                                               
+                                       } elsif ($variable_noerror eq 0) {
+                                       
+                                               # Page filename contains invalid characters and
+                                               # the no error value is set to 0 so return an
+                                               # error.
+                                       
+                                               kiriwrite_error("invalidfilename");
+                                               
+                                       } else {
+                                       
+                                               # The no error value is something else other
+                                               # than 0 or 1 so return an error.
+                                       
+                                               kiriwrite_error("invalidvariable");
+                                               
+                                       }
+                                       
+                               }
+                               
+                               # Append the forward slash, clear the current directory name and set
+                               # the first directory level value to 0.
+                               
+                               $variable_data_directory = $variable_data_directory . $variable_data_char;
+                               $variable_data_directorycurrent = "";
+                               $variable_data_firstlevel = 0;
+                       
+                       } else {
+                       
+                               # Append the current character to the directory name and to the current
+                               # directory name.
+                       
+                               $variable_data_directory = $variable_data_directory . $variable_data_char;
+                               $variable_data_directorycurrent = $variable_data_directorycurrent . $variable_data_char;
+                                               
+                       }
+                       
+                       # Increment the seek counter.
+                       
+                       $variable_data_seek++;
+                                       
+               } until ($variable_data_seek eq $variable_data_length);
+               
+               return 0;
+       
+       } elsif ($variable_type eq "outputmodule"){
+               
+               # The variable type is a output module filename.
+
+               # Check if the variable_data is blank and if it is
+               # return an error.
+
+               if ($variable_data eq ""){
+
+                       # The output module is blank so check if an error
+                       # value should be returned or a number should be
+                       # returned.
+
+               } else {
+
+               }
+
+               my $variable_data_validated = $variable_data;
+               $variable_data_validated =~ tr/a-zA-Z0-9//d;
+
+               if ($variable_data_validated eq ""){
+
+               } else {
+
+                       kiriwrite_error("outputmoduleinvalid");
+
+               }
+
+               return 0;
+
+       } elsif ($variable_type eq "utf8"){
+
+               # The variable type is a UTF8 string.
+
+               # Check if the string is a valid UTF8 string.
+
+               if ($variable_data =~ m/^(
+                       [\x09\x0A\x0D\x20-\x7E]              # ASCII
+                       | [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
+                       |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
+                       | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
+                       |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
+                       |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
+                       | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
+                       |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
+               )*$/x){
+
+                       # The UTF-8 string is valid.
+
+               } else {
+
+                       # The UTF-8 string is not valid, check if the no error
+                       # value is set to 1 and return an error if it isn't.
+
+                       if ($variable_noerror eq 1){
+
+                               # The no error value has been set to 1, so return
+                               # a value of 1 (meaning that the UTF-8 string is
+                               # invalid).
+
+                               return 1; 
+
+                       } elsif ($variable_noerror eq 0) {
+
+                               # The no error value has been set to 0, so return
+                               # an error.
+
+                               kiriwrite_error("invalidutf8");
+                       
+                       } else {
+
+                               # The no error value is something else other than 0
+                               # or 1, so return an error.
+
+                               kiriwrite_error("invalidoption");
+
+                       }
+
+               }
+
+               return 0;
+
+       } else {
+               # Another type than the valid ones above has been specified so return an error specifying an invalid option.
+               kiriwrite_error("invalidoption");
+       }
+
+}
+
+sub kiriwrite_convert{
+#################################################################################
+# kiriwrite_convert: Converts certain characters.                              #
+#                                                                              #
+# Usage;                                                                       #
+#                                                                              #
+# kiriwrite_convert(data, type);                                               #
+#                                                                              #
+# data         Specifies the data to be used with                              #
+# type         The type of conversion to make (convert from or to kiriwrite    #
+#              values.                                                         #
+#################################################################################
+
+       # Get the data that was passed to the subroutine.
+       my ($data, $type) = @_;
+
+       if ($type eq "kiriwrite"){
+
+               # Convert to into the Kiriwrite format.
+
+               $data =~ s/'/''/g;
+               $data =~ s/\b//g;
+
+       } elsif ($type eq "normal_display"){
+
+               # Convert into a viewable format.
+
+               $data =~ s/&/&amp;/g;
+               $data =~ s/\"/&quot;/g;
+               $data =~ s/'/'/g;
+               $data =~ s/>/&gt;/g;
+               $data =~ s/</&lt;/g;
+               $data =~ s/\0//g;
+               $data =~ s/\b//g;
+
+       } elsif ($type eq "normal_out"){
+
+               # Convert into the original format.
+
+               $data =~ s/\0//g;
+               $data =~ s/\b//g;
+
+       } elsif ($type eq "date"){
+
+               # Convert the date given into the proper date.
+
+               # Create the following varialbes to be used later.
+
+               my $date;
+               my $time;
+               my $day;
+               my $day_full;
+               my $month;
+               my $month_check;
+               my $month_full;
+               my $year;
+               my $year_short;
+               my $hour;
+               my $hour_full;
+               my $minute;
+               my $minute_full;
+               my $second;
+               my $second_full;
+               my $seek = 0;
+               my $timelength;
+               my $datelength;
+               my $daylength;
+               my $secondlength;
+               my $startchar = 0;
+               my $char;
+               my $length;
+               my $count = 0;
+
+               # Split the date and time.
+
+               $length = length($data);
+
+               if ($length > 0){
+
+                       do {
+
+                               # Get the character and check if it is a space.
+
+                               $char = substr($data, $seek, 1);
+
+                               if ($char eq ' '){
+
+                                       # The character is a space, so get the date and time.
+
+                                       $date           = substr($data, 0, $seek);
+                                       $timelength     = $length - $seek - 1;
+                                       $time           = substr($data, $seek + 1, $timelength);
+
+                               }
+
+                               $seek++;
+
+                       } until ($seek eq $length);
+
+                       # Get the year, month and date.
+
+                       $length = length($date);
+                       $seek = 0;
+
+                       do {
+
+                               # Get the character and check if it is a dash.
+
+                               $char = substr($date, $seek, 1);
+
+                               if ($char eq '-'){
+
+                                       # The character is a dash, so get the year, month or day.
+
+                                       $datelength = $seek - $startchar;
+
+                                       if ($count eq 0){
+
+                                               # Get the year from the date.
+
+                                               $year           = substr($date, 0, $datelength) + 1900;
+                                               $startchar      = $seek;
+                                               $count = 1;
+
+                                               # Get the last two characters to get the short year
+                                               # version.
+
+                                               $year_short     = substr($year, 2, 2);
+
+                                       } elsif ($count eq 1){
+
+                                               # Get the month and day from the date.
+
+                                               $month  = substr($date, $startchar + 1, $datelength - 1) + 1;
+
+                                               # Check if the month is less then 10, if it is
+                                               # add a zero to the value.
+
+                                               if ($month < 10){
+
+                                                       $month_full = '0' . $month;
+
+                                               } else {
+
+                                                       $month_full = $month;
+
+                                               }
+
+                                               $startchar      = $seek;
+                                               $count = 2;
+
+                                               $daylength      = $length - $seek + 1;
+                                               $day            = substr($date, $startchar + 1, $daylength);
+
+                                               # Check if the day is less than 10, if it is
+                                               # add a zero to the value.
+
+                                               if ($day < 10){
+
+                                                       $day_full       = '0' . $day;
+
+                                               } else {
+
+                                                       $day_full       = $day;
+
+                                               }
+
+                                       }
+
+                               }
+
+                               $seek++;
+
+                       } until ($seek eq $length);
+
+                       # Get the length of the time value and reset certain
+                       # values to 0.
+
+                       $length = length($time);
+                       $seek = 0;
+                       $count = 0;
+                       $startchar = 0;
+
+                       do {
+
+                               # Get the character and check if it is a colon.
+
+                               $char = substr($time, $seek, 1);
+
+                               if ($char eq ':'){
+
+                                       # The character is a colon, so get the hour, minute and day.
+
+                                       $timelength = $seek - $startchar;
+
+                                       if ($count eq 0){
+
+                                               # Get the hour from the time.
+
+                                               $hour = substr($time, 0, $timelength);
+                                               $count = 1;
+                                               $startchar = $seek;
+
+                                               # If the hour is less than ten then add a
+                                               # zero.
+
+                                               if ($hour < 10){
+
+                                                       $hour_full = '0' . $hour;
+
+                                               } else {
+
+                                                       $hour_full = $hour;
+
+                                               }
+
+                                       } elsif ($count eq 1){
+
+                                               # Get the minute and second from the time.
+
+                                               $minute = substr($time, $startchar + 1, $timelength - 1);
+                                               $count = 2;
+                                               
+                                               # If the minute is less than ten then add a
+                                               # zero.
+
+                                               if ($minute < 10){
+
+                                                       $minute_full = '0' . $minute;
+
+                                               } else {
+
+                                                       $minute_full = $minute;
+
+                                               }
+
+                                               $startchar = $seek;
+
+                                               $secondlength = $length - $seek + 1;
+                                               $second = substr($time, $startchar + 1, $secondlength);
+                                               
+                                               # If the second is less than ten then add a
+                                               # zero.
+
+                                               if ($second < 10){
+
+                                                       $second_full = '0' . $second;
+
+                                               } else {
+
+                                                       $second_full = $second;
+
+                                               }
+
+                                       }
+
+                               }
+
+                               $seek++;
+
+                       } until ($seek eq $length);
+
+                       # Get the setting for displaying the date and time.
+
+                       $data = $kiriwrite_config{"system_datetime"};
+
+                       # Process the setting for displaying the date and time
+                       # using regular expressions
+
+                       $data =~ s/DD/$day_full/g;
+                       $data =~ s/D/$day/g;
+                       $data =~ s/MM/$month_full/g;
+                       $data =~ s/M/$month/g;
+                       $data =~ s/YY/$year/g;
+                       $data =~ s/Y/$year_short/g;
+
+                       $data =~ s/hh/$hour_full/g;
+                       $data =~ s/h/$hour/g;
+                       $data =~ s/mm/$minute_full/g;
+                       $data =~ s/m/$minute/g;
+                       $data =~ s/ss/$second_full/g;
+                       $data =~ s/s/$second/g;
+
+               }
+
+       } else {
+               kiriwrite_error("invalidoption");
+       }
+
+       return $data;
+
+}
+
+sub kiriwrite_output_header{
+#################################################################################
+# kiriwrite_output_header: Outputs the header to the browser/stdout/console.   #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_output_header(mimetype);                                           #
+#                                                                              #
+# mimetype     Specifies the mime type of the header.                          #
+#################################################################################
+
+       # Print a header saying that the page expires immediately since the
+       # date is set in the past.
+
+       #print "Expires: Sunday, 01-Jan-06 00:00:00 GMT\n";
+       #print "Content-Type: text/html; charset=utf-8\n";
+       #print header();
+       print header(-Expires=>'Sunday, 01-Jan-06 00:00:00 GMT', -charset=>'utf-8');    
+       return;
+}
+
+sub kiriwrite_processfilename{
+#################################################################################
+# kiriwrite_processfilename: Processes a name and turns it into a filename that #
+# can be used by Kiriwrite.                                                    #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_processfilename(text);                                             #
+#                                                                              #
+# text         Specifies the text to be used in the process for creating a new #
+#              filename.                                                       #
+#################################################################################
+
+       # Get the values that have been passed to the subroutine.
+       
+       my ($process_text) = @_;
+       
+       # Define some variables that will be used later on.
+       
+       my $processed_stageone  = "";
+       my $processed_stagetwo  = "";
+       my $processed_length    = "";
+       my $processed_char      = "";
+       my $processed_seek      = 0;
+       my $processed_filename  = "";
+       
+       # Set the first stage value of the processed filename to the
+       # process filename and then filter it out to only contain
+       # numbers and letters (no spaces) and then convert the
+       # capitals to small letters.
+       
+       $processed_stageone = $process_text;
+       $processed_stageone =~ tr#a-zA-Z0-9##cd;
+       $processed_stageone =~ tr/A-Z/a-z/;
+       
+       # Now set the second stage value of the processed filename
+       # to the first stage value of the processed filename and
+       # then limit the filename down to 64 characters.
+       
+       $processed_stagetwo = $processed_stageone;
+       $processed_length = length($processed_stagetwo);
+       
+       # Process the second stage filename into the final 
+       # filename and do so until the seek counter is 64
+       # or reaches the length of the second stage filename.
+       
+       do {
+       
+               # Get the character that is the seek counter
+               # is set at.
+       
+               $processed_char = substr($processed_stagetwo, $processed_seek, 1);
+               
+               # Append to the final processed filename.
+               
+               $processed_filename = $processed_filename . $processed_char;
+               
+               # Increment the seek counter.
+               
+               $processed_seek++;
+       
+       } until ($processed_seek eq 64 || $processed_seek eq $processed_length);
+               
+       return $processed_filename;
+
+}
+
+sub kiriwrite_error{
+#################################################################################
+# kiriwrite_error: Prints out an error message.                                        #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_error(errortype);                                                  #
+#                                                                              #
+# errortype    Specifies the type of error that occured.                       #
+#################################################################################
+
+       # Get the error type from the subroutine.
+
+       my ($error_type) = @_;
+       
+       # Load the list of error messages.
+
+       my ($kiriwrite_error, %kiriwrite_error);
+
+       %kiriwrite_error = (
+               # Catch all error message.
+               "generic"                               => "An error has occured but not an error that is known to Kiriwrite.",
+
+               # Standard error messages.
+               "blankfilename"                         => "The filename specified was blank.",
+               "blankvariable"                         => "A blank variable was specified.",
+               "fileexists"                            => "A filename specified already exists.",
+               "internalerror"                         => "An internal error has occured within Kiriwrite.",
+               "invalidoption"                         => "An invalid option was given.",
+               "invalidaction"                         => "An invalid action was specified.",
+               "invalidfilename"                       => "The filename given contains invalid characters.",
+               "invalidmode"                           => "An invalid mode was specified.",
+               "invalidutf8"                           => "A UTF-8 string is invalid.",
+               "invalidvariable"                       => "An variable with invalid data has been found.",
+               "variabletoolong"                       => "A variable given is too long.",
+
+               # Specific error messages.
+               "blankcompiletype"                      => "The compile type specified is blank",
+               "blankdatabasepageadd"                  => "No database was specified when trying to add a page.",
+               "blankdirectory"                        => "The directory name specified was blank.",
+               "blankfindfilter"                       => "The find filter was blank.",
+               "blankdatetimeformat"                   => "The date and time format given is blank.",
+               "databasecategoriestoolong"             => "The database categories list is too long.",
+               "databasecopysame"                      => "The database that the pages are being copied to is the same database that the pages are copied from.",
+               "datadirectoryinvalidpermissions"       => "The database directory has invalid permission settings.",
+               "databasedescriptiontoolong"            => "The database description is too long.",
+               "databasefilenameinvalid"               => "The database filename is invalid.",
+               "databasefilenametoolong"               => "The database filename is too long.",
+               "databasefileinvalid"                   => "The database file is in an invalid format.",
+               "databaseinvalidpermissions"            => "The database has invalid permission settings.",
+               "databasenameinvalid"                   => "The database name contains invalid characters.",
+               "databasenametoolong"                   => "The database name is too long.",
+               "databasenameblank"                     => "The database name is blank.",
+               "databasemissingfile"                   => "The database file is missing.",
+               "databasemovemissingfile"               => "The database that the pages are moving to is missing.",
+               "databasemovesame"                      => "The database that the pages are being moved to is the same database that the pages are moving from.",
+               "dbdirectoryblank"                      => "The database directory name given was blank.",
+               "dbdirectoryinvalid"                    => "The database directory name given was invalid.",
+               "filtersdatabasefilenotcreated"         => "The filters database was not created because of the invalid permissions set for directory where Kiriwrite is being run from.",
+               "filtersdbinvalidformat"                => "The filters database is an invalid format.",
+               "filtersdbpermissions"                  => "The filters database has invalid permission settings.",
+               "filtersdbmissing"                      => "The filters database is missing.",
+               "filteridblank"                         => "The filter identification number given is blank.",
+               "filterdoesnotexist"                    => "The filter with the identification number given does not exist.",
+               "filteridinvalid"                       => "The filter identification number given is invalid.",
+               "filteridtoolong"                       => "The filter identification number given is too long.",
+               "findfiltertoolong"                     => "The find filter given is too long.",
+               "filterpriorityinvalid"                 => "The filter priority number given is invalid.",
+               "filterpriorityinvalidchars"            => "The filter priority given contains invalid characters.",
+               "filterprioritytoolong"                 => "The filter priority given is too long.",
+               "invalidcompiletype"                    => "The compile type given is invalid.",
+               "invalidpagenumber"                     => "The page number specified is invalid.",
+               "nopagesselected"                       => "No pages were selected.",
+               "invaliddirectory"                      => "The directory name specified was invalid.",
+               "invaliddatetimeformat"                 => "The date and time format given is invalid.",
+               "invalidlanguagefilename"               => "An invalid language filename was given.",
+               "newcopydatabasedoesnotexist"           => "The database that the selected pages are being copied to does not exist.",
+               "newcopydatabasefileinvalidpermissions" => "The database that the selected pages are being copied has invalid permissions set.",
+               "newcopydatabasefileinvalid"            => "The database that the selected pages are being copied to is in an invalid format.",
+               "newmovedatabasedoesnotexist"           => "The database that the selected pages are moving to does not exist.",
+               "newmovedatabasefileinvalidpermissions" => "The database that the selected pages are moving to has invalid permissions set.",
+               "newmovedatabasefileinvalid"            => "The database that the selected pages are moving to is in an invalid format.",
+               "nodatabasesavailable"                  => "No databases are available for compiling.",
+               "nodatabaseselected"                    => "No databases were selected for compiling.",
+               "noeditvaluesselected"                  => "No values will be changed on the selected pages as no values for changing were selected.",
+               "oldcopydatabasedoesnotexist"           => "The database that the selected pages are being copied to does not exist.",
+               "oldcopydatabasefileinvalidpermissions" => "The database that the selected pages are being copied to has invalid permissions set.",
+               "oldcopydatabasefileinvalid"            => "The database that the selected pages are being copied to is in an invalid format.",
+               "oldmovedatabasedoesnotexist"           => "The database that the selected pages are moving from does not exist.",
+               "oldmovedatabasefileinvalidpermissions" => "The database that the selected pages are moving from has invalid permissions set.",
+               "oldmovedatabasefileinvalid"            => "The database that the selected pages are moving from is in an invalid format.",
+               "outputdirectoryblank"                  => "The output directory name given was blank.",
+               "outputdirectoryinvalid"                => "The output directory name given was invalid.",
+               "outputdirectorymissing"                => "The output directory is missing",
+               "outputdirectoryinvalidpermissions"     => "The output directory has invalid permissions set.",
+               "outputmoduleblank"                     => "The output module name given is blank.",
+               "outputmoduleinvalid"                   => "The output module name given is invalid.",
+               "pagefilenamedoesnotexist"              => "The page with the filename given does not exist.",
+               "pagefilenameexists"                    => "The page filename given already exists",
+               "pagefilenameinvalid"                   => "The page filename given is invalid.",
+               "pagefilenametoolong"                   => "The page filename given is too long.",
+               "pagefilenameblank"                     => "The page filename given is blank.",
+               "pagetitletoolong"                      => "The page title given is too long.",
+               "pagedescriptiontoolong"                => "The page description given is too long.",
+               "pagesectiontoolong"                    => "The page section given is too long.",
+               "pagedatabasefilenametoolong"           => "The page database filename given is too long.",
+               "pagesettingstoolong"                   => "The page settings given is too long.",
+               "pagesettingsinvalid"                   => "The page settings given are invalid.",
+               "pagetemplatefilenametoolong"           => "The page template filename given was too long.",
+               "replacefiltertoolong"                  => "The replace filter given is too long",
+               "templatenameblank"                     => "The template name given is blank.",
+               "templatefilenameexists"                => "A template with the given filename already exists.",
+               "templatefilenameinvalid"               => "The template filename given is invalid.",
+               "templatedatabaseinvalidpermissions"    => "The template database has invalid permissions.",
+               "templatedatabaseinvalidformat"         => "The template database is in a invalid format.",
+               "templatedirectoryblank"                => "The template directory name given was blank.",
+               "templatedirectoryinvalid"              => "The template directory name given was invalid.",
+               "templatedatabasefilenotcreated"        => "The template database was not created because of the invalid permissions set for the directory where Kiriwrite is being run from.",
+               "templatefilenametoolong"               => "The template filename given is too long",
+               "templatenametoolong"                   => "The template name given is too long",
+               "templatedescriptiontoolong"            => "The template description given is too long",
+               "templatedatabasemissing"               => "The template database is missing.",
+               "templatedoesnotexist"                  => "The template filename given does not exist in the templates database.",
+               "templatefilenameblank"                 => "The template filename given was blank.",
+       );
+
+       # Check if the specified error is blank and if it is
+       # use the generic error messsage.
+
+       if (!$kiriwrite_error{$error_type}){
+               $error_type = "generic";
+       }
+
+       my $pagedata = "<div class=\"errorbox\"><font class=\"errorheader\">Error!</font><br /><font class=\"errortext\">" . $kiriwrite_error{$error_type} . "</font></div>";
+       
+       kiriwrite_output_header;
+       kiriwrite_output_page("Error!", $pagedata, "none");
+               
+       exit;
+
+}
+
+sub kiriwrite_get_templates{
+#################################################################################
+# kiriwrite_get_templates: Get the list of templates available (and valid) from #
+# the template directory.                                                      #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_get_templates();                                                   #
+#################################################################################
+
+       # Open the template folder and get the list of database configuration files.
+
+       opendir(TEMPLATEDIR, $kiriwrite_config{"directory_data_template"});
+       my @templatedir = grep /m*\.xml/, readdir(TEMPLATEDIR);
+       closedir(TEMPLATEDIR);
+
+       # Get the actual filename of the template by removing the .xml part from
+       # the filename.
+
+       my $templatedir_filename                = "";
+       my $templatedir_filename_originallength = "";
+       my $templatedir_filename_char           = "";
+       my $templatedir_filename_processed      = "";
+       my $templatedir_filename_seek           = 0;
+       my $templatedir_filename_length         = 0;
+       my $templatedir_filename_finallength    = 0;
+       my @templatelist_processed;
+       my $templatedir_processed_filename      = "";
+       my @templatelist_final;
+       my $templatelist_final_count            = 0;
+
+       foreach $templatedir_filename (@templatedir){
+
+               # Get the length of the original filename.
+
+               $templatedir_filename_length            = length($templatedir_filename);
+               $templatedir_filename_finallength       = $templatedir_filename_length - 4;
+
+               # Get the filename minus the last four characters and put the processed 
+               # filename into the array of processed filenames.
+
+               $templatedir_filename_processed         = substr($templatedir_filename, 0, $templatedir_filename_finallength);
+
+               $templatelist_processed[$templatedir_filename_seek] = $templatedir_filename_processed;
+
+               # Increment the counter.
+
+               $templatedir_filename_seek++;
+
+               # Clear certain variables before using them again.
+
+               $templatedir_filename_processed         = "";
+               $templatedir_filename_length            = 0;
+               $templatedir_filename_finallength       = 0;
+
+       }
+
+       # Check that each template really does exist and put each valid
+       # template into the final list.
+
+       foreach $templatedir_processed_filename (@templatelist_processed){
+
+               if (-e $kiriwrite_config{"directory_data_template"} . '/' . $templatedir_processed_filename){
+
+                       # The template does exist, so add the template to the list of valid templates.
+
+                       $templatelist_final[$templatelist_final_count] = $templatedir_processed_filename;
+                       $templatelist_final_count++;
+
+               }
+
+       }
+
+       # Return the list of valid templates.
+
+       return @templatelist_final;
+
+}
+
+sub kiriwrite_fileexists{
+#################################################################################
+# kiriwrite_fileexists: Check if a file exists and returns a value depending on #
+# if the file exists or not.                                                   #
+#                                                                              # 
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_fileexists(filename);                                              #
+#                                                                              #
+# filename     Specifies the file name to check if it exists or not.           #
+#################################################################################
+       
+       # Get the value that was passed to the subroutine.
+
+       my ($filename) = @_;
+
+       # Check if the filename exists, if it does, return a value of 1, else
+       # return a value of 0, meaning that the file was not found.
+
+       if (-e $filename){
+
+               # Specified file does exist so return a value of 1.
+
+               return 0;
+
+       } else {
+
+               # Specified file does not exist so return a value of 0.
+
+               return 1;
+
+       }       
+
+}
+
+sub kiriwrite_filepermissions{
+#################################################################################
+# kiriwrite_filepermissions: Check if the file permissions of a file and return #
+# either a 1 saying that the permissions are valid or return a 0 saying that   #
+# the permissions are invalid.                                                 #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_filepermissions(filename, [read], [write], [filemissingskip]);     #
+#                                                                              #
+# filename             Specifies the filename to check for permissions.        #
+# read                 Preform check that the file is readable.                #
+# write                        Preform check that the file is writeable.               #
+# filemissingskip      Skip the check of seeing if it can read or write if the #
+#                      file is missing.                                        #
+#################################################################################
+
+       # Get the values that was passed to the subroutine.
+
+       my ($filename, $readpermission, $writepermission, $ignorechecks) = @_;
+
+       # Check to make sure that the read permission and write permission values
+       # are only 1 character long.
+
+       kiriwrite_variablecheck($readpermission, "maxlength", 1, 0);
+       kiriwrite_variablecheck($writepermission, "maxlength", 1, 0);
+       kiriwrite_variablecheck($ignorechecks, "maxlength", 1, 0);
+
+       my $ignorechecks_result = 0;
+
+       # Check if the file should be ignored for read and write checking if 
+       # it doesn't exist.
+
+       if ($ignorechecks){
+
+               if (-e $filename){
+
+                       # The file exists so the checks are to be done.
+
+                       $ignorechecks_result = 0;
+
+               } else {
+
+                       # The file does not exist so the checks don't need to
+                       # be done to prevent false positives.
+
+                       $ignorechecks_result = 1;
+
+               }
+       
+       } else {
+
+               $ignorechecks_result = 0;
+
+       }
+
+       # Check if the file should be checked to see if it can be read.
+
+       if ($readpermission && $ignorechecks_result eq 0){
+
+               # The file should be checked to see if it does contain read permissions
+               # and return a 0 if it is invalid.
+
+               if (-r $filename){
+
+                       # The file is readable, so do nothing.
+
+               } else {
+
+                       # The file is not readable, so return 1.
+
+                       return 1;
+
+               }
+
+       }
+
+       # Check if the file should be checked to see if it can be written.
+
+       if ($writepermission && $ignorechecks_result eq 0){
+
+               # The file should be checked to see if it does contain write permissions
+               # and return a 0 if it is invalid.
+
+               if (-w $filename){
+
+                       # The file is writeable, so do nothing.
+
+               } else {
+
+                       # The file is not writeable, so return 1.
+
+                       return 1;
+
+               }
+
+       }
+
+       # No problems have occured, so return 0.
+
+       return 0;
+
+}
+
+sub kiriwrite_utf8convert{
+#################################################################################
+# kiriwrite_utf8convert: Properly converts values into UTF-8 and make sure     #
+# that the size of the string is correct when doing input validation.          #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# utfstring    # The UTF-8 string to convert.                                  #
+#################################################################################
+
+       # Get the values passed to the subroutine.
+
+       my ($utfstring) = @_;
+
+       # Load the Encode perl module.
+
+       use Encode;
+
+       # Convert the string.
+
+       my $finalutf8 = Encode::decode_utf8( $utfstring );
+
+       return $finalutf8;
+
+}
+
+sub kiriwrite_critical{
+#################################################################################
+# kiriwrite_critical: Displays a critical error message that cannot be         #
+# normally by the kiriwrite_error subroutine.                                  #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# errortype    Specifies the type of critical error that has occured.          #
+#################################################################################
+
+       # Get the value that was passed to the subroutine.
+
+       my ($error_type) = @_;
+
+       # Get the error type from the errortype string.
+
+       if ($error_type eq "configfilemissing"){
+
+               # The error is that the Kiriwrite configuration file is missing. 
+               # Print the header, error message and then end the script.
+
+               print header();
+               print "Critical Error: The Kiriwrite configuration file is missing! Running the setup script for Kiriwrite is recommended.";
+               exit;
+
+       } elsif ($error_type eq "configfileinvalidpermissions") {
+
+               # The error is that the Kiriwrite configuration file has invalid
+               # permission settings. Print the header, error messsage and then
+               # end the script.
+
+               print header();
+               print "Critical Error: The Kiriwrite configuration file contains invalid permission settings! Please set the valid permission settings for the configuration file.";
+               exit; 
+
+       } elsif ($error_type eq "outputsystemmissing") {
+
+               # The error is that the output system module is missing. Print the
+               # header, error message and then end the script.
+
+               print header();
+               print "Critical Error: The output system module is missing! Running the setup script for Kiriwrite is recommended.";
+               exit;
+
+       } elsif ($error_type eq "outputsysteminvalidpermissions"){
+
+               # The error is that the output system module has invalid permissions
+               # set. Print the header, error message and then end the script.
+
+               print header();
+               print "Critical Error: The output system module contains invalid permission settings! Please set the valid permission settings for the output module.";
+               exit;
+
+       }else {
+
+               # The error type is unspecified, so return a generic error message.
+
+               print header();
+               print "Critical Error: An unspecified critical error has occured.";
+               exit;
+
+       }
+
+}
+
+sub kiriwrite_output_page{
+#################################################################################
+# kiriwrite_output_page: Outputs the page to the browser/stdout/console.       #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_output_page(pagetitle, pagedata, menutype);                                #
+#                                                                              #
+# pagetitle    Specifies the page title.                                       #
+# pagedata     Specifies the page data.                                        #
+# menutype     Prints out which menu to use.                                   #
+#################################################################################
+
+       my ($pagetitle, $pagedata, $menutype) = @_;
+
+       # Open the script page template and load it into the scriptpage variable,
+       # while declaring the variable.
+
+       open (SCRIPTPAGE, 'page.html');
+       my @scriptpage = <SCRIPTPAGE>;
+       close (SCRIPTPAGE);
+       
+       # Define the variables required.
+       
+       my $scriptpageline = "";
+       my $pageoutput = "";
+       my $menuoutput = "";
+       
+       # Print out the main menu for Kiriwrite.
+       
+       $menuoutput = "<a href=\"kiriwrite.cgi?mode=db\">View Databases</a> | <a href=\"kiriwrite.cgi?mode=page\">View Pages</a> | <a href=\"kiriwrite.cgi?mode=filter\">View Filters</a> | <a href=\"kiriwrite.cgi?mode=template\">View Templates</a> | <a href=\"kiriwrite.cgi?mode=compile\">Compile Pages</a> | <a href=\"kiriwrite.cgi?mode=settings\">View Settings</a>\r\n<br />";
+       
+       # Check what menu is going to be printed along with the default 'top' menu.
+       
+       if ($menutype eq "database"){
+               # If the menu type is database then print out the database sub-menu.
+               $menuoutput = $menuoutput . "<a href=\"kiriwrite.cgi?mode=db\">Show Databases</a> | <a href=\"kiriwrite.cgi?mode=db&action=new\">Add Database</a>";     
+               
+       } elsif ($menutype eq "pages"){
+               # If the menu type is pages then print out the pages sub-menu.
+               
+               # First, fetch the database name from the HTTP query string.
+               
+               my $query = new CGI;
+               my $db_filename = $query->param('database');
+               
+               # Check if a value has been placed in the db_filename string.
+               
+               if (!$db_filename){
+               
+                       # As the database filename is blank, don't add an option to add a page.
+                               
+               } else {
+                                       
+                       # A database file has been specified so add an option to add a page to
+                       # the selected database.
+               
+                       $menuoutput = $menuoutput . "<a href=\"kiriwrite.cgi?mode=page&action=add&database=" . $db_filename . "\">Add Page</a>";
+               
+               }
+       
+       } elsif ($menutype eq "filter"){
+       
+               # If the menu type is filters then print out the filter sub-menu.
+               $menuoutput = $menuoutput . "<a href=\"kiriwrite.cgi?mode=filter\">Show Filters</a> | <a href=\"kiriwrite.cgi?mode=filter&action=add\">Add Filter</a>";
+               
+       } elsif ($menutype eq "settings"){
+       
+               # If the menu type is options then print out the options sub-menu.
+               $menuoutput = $menuoutput . "<a href=\"kiriwrite.cgi?mode=settings\">Show Settings</a> | <a href=\"kiriwrite.cgi?mode=settings&action=edit\">Edit Settings</a>";
+               
+       } elsif ($menutype eq "template"){
+               
+               # If the menu type is template then print out the template sub-menu.
+               $menuoutput = $menuoutput . "<a href=\"kiriwrite.cgi?mode=template\">Show Templates</a> | <a href=\"kiriwrite.cgi?mode=template&action=add\">Add Template</a>"; 
+       
+       } elsif ($menutype eq "compile"){
+       
+               # If the menu type is compile then print out the compile sub-menu.
+               $menuoutput = $menuoutput . "<a href=\"kiriwrite.cgi?mode=compile&action=all\">Compile All</a> | <a href=\"kiriwrite.cgi?mode=compile&action=clean\">Clean Output Directory</a>";
+       
+       }
+                       
+       # Find <kiriwrite> tages and replace with the apporiate variables.
+               
+       foreach $scriptpageline (@scriptpage){
+               
+               $scriptpageline =~ s/<kiriwrite:menu>/$menuoutput/g;
+               $scriptpageline =~ s/<kiriwrite:pagedata>/$pagedata/g;
+               
+               
+               # Check if page title specified is blank, otherwise add a page title
+               # to the title.
+               
+               if ($pagetitle eq ""){
+                       $scriptpageline =~ s/<kiriwrite:title>//g;
+               } else {
+                       $scriptpageline =~ s/<kiriwrite:title>/ ($pagetitle)/g;
+               }               
+
+               # Append processed line to the pageoutput variable.
+                               
+               $pageoutput = $pageoutput . $scriptpageline;
+               
+       }
+       
+       # Print out the page to the browser/console/stdout.
+       
+       print $pageoutput;
+       
+       return;
+
+}
+
+sub kiriwrite_output_xml{
+#################################################################################
+# kiriwrite_output_xml: Outputs several types of data to an XML file           #
+#                                                                              #
+# Usage:                                                                       #
+#                                                                              #
+# kiriwrite_output_xml(filename, type, data);                                  #
+#                                                                              #
+# filename     Specifies the filename of the XML file.                         #
+# type         Specifies the type of the XML file to be written.               #
+# newsettings  Specifies the new settings for the XML file.                    #
+#################################################################################
+
+       # Get the variables passed from the subroutine.
+
+       my ($xml_filename, $xml_type, @newsettings) = @_;
+       
+       # Check if filename is blank, if it is then return an error.
+       
+       if ($xml_filename eq ""){
+               # Filename is blank, return an error.
+               kiriwrite_error("blankfilename");
+       }
+       
+       # Validate the XML filename to make sure nothing supicious is being passed.
+       
+       kiriwrite_variablecheck($xml_filename, "maxlength", 64, 0);
+       kiriwrite_variablecheck($xml_filename, "filename", "", 0);
+       
+       # Check what type of XML data to output.
+       
+       if ($xml_type eq "config") {
+               
+               # The type of XML data to output is a Kiriwrite configuration file.
+               
+               # Get the data that has been passed to xml_data from the subroutine and
+               # split them into seperate values.
+               
+               my ($xml_config_databasedir, $xml_config_outputdir, $xml_config_imagesuri, $xml_config_datetime, $xml_config_systemlanguage, $xml_config_outputsystem) = @newsettings;
+               
+               # Create the XML data layout.
+               
+               my $xmldata = "<?xml version=\"1.0\"?>\r\n\r\n<kiriwrite-config>\r\n";
+               
+               $xmldata = $xmldata . "<!-- This file was automatically generated by Kiriwrite, please feel free to edit to your own needs. -->\r\n";
+               $xmldata = $xmldata . "\t<settings>\r\n\t\t<directories>\r\n";
+               
+               $xmldata = $xmldata . "\t\t\t<database>" . $xml_config_databasedir . "</database>\r\n";
+               $xmldata = $xmldata . "\t\t\t<output>" . $xml_config_outputdir  . "</output>\r\n";
+               $xmldata = $xmldata . "\t\t\t<images>" . $xml_config_imagesuri . "</images>\r\n";
+               $xmldata = $xmldata . "\t\t</directories>\r\n";
+               
+               $xmldata = $xmldata . "\t\t<language>\r\n";
+               $xmldata = $xmldata . "\t\t\t<type>" . $xml_config_systemlanguage . "</type>\r\n";
+               $xmldata = $xmldata . "\t\t</language>\r\n";
+               
+               $xmldata = $xmldata . "\t\t<system>\r\n";
+               $xmldata = $xmldata . "\t\t\t<output>" . $xml_config_outputsystem . "</output>\r\n";
+               $xmldata = $xmldata . "\t\t\t<datetime>" . $xml_config_datetime . "</datetime>\r\n";
+               $xmldata = $xmldata . "\t\t</system>\r\n";
+               
+               $xmldata = $xmldata . "\t</settings>\r\n";
+               
+               $xmldata = $xmldata . "</kiriwrite-config>";
+
+               # Open the Kiriwrite XML configuration file and write the new settings to the
+               # configuration file.
+               
+               open(XMLCONFIG, "> kiriwrite.xml");
+               print XMLCONFIG $xmldata;
+               close(XMLCONFIG);
+               
+       } else {
+       
+               # The type of XML data is something else that is not supported by
+               # Kiriwrite, so return an error.
+               
+               kiriwrite_error("invalidoption");
+               
+       }
+       
+       return;
+
+}
+
+#################################################################################
+# End listing the functions needed.                                            #
+#################################################################################
+
+#################################################################################
+# Begin proper script execution.                                               #
+#################################################################################
+
+kiriwrite_settings_load;       # Load the configuration options.
+
+my $query = new CGI;           # Easily fetch variables from the HTTP string.
+
+
+
+# Check if a mode has been specified and if a mode has been specified, continue
+# and work out what mode has been specified.
+
+if ($query->param('mode')){
+       my $http_query_mode = $query->param('mode');
+       
+       if ($http_query_mode eq "db"){
+       
+               # If mode is 'db' (database), then check what action is required.
+       
+               if ($query->param('action')){
+                       # An action has been specified, so find out what action has been specified.
+                       
+                       my $http_query_action = $query->param('action');
+                       
+                       if ($http_query_action eq "edit"){
+                               # The edit action (which mean edit the settings for the selected database) has been specified,
+                               # get the database name and check if the action to edit an database has been confirmed.
+                               
+                               if ($query->param('database')){
+                                       # If there is a value in the database variable check if it is a valid database. Otherwise,
+                                       # return an error.
+                                       
+                                       my $http_query_database = $query->param('database');
+                                                                               
+                                       # Check if a value for confirm has been specified, if there is, check if it is the correct
+                                       # value, otherwise return an error.
+                                       
+                                       if ($query->param('confirm')){
+                                               # A value for confirm has been specified, find out what value it is. If the value is correct
+                                               # then edit the database settings, otherwise return an error.
+                                       
+                                               my $http_query_confirm = $query->param('confirm');
+                                               
+                                               if ($http_query_confirm eq "yes"){
+                                                       # Value is correct, collect the variables to pass onto the database variable.
+                                                       
+                                                       # Load the XML::Simple module.
+                                                       
+                                                       use XML::Simple;
+                                                       my $xsl = XML::Simple->new();
+                                                       
+                                                       # Get the variables from the HTTP query.
+                                                       
+                                                       my $newdatabasename             = $query->param('databasename');
+                                                       my $newdatabasedescription      = $query->param('databasedescription');
+                                                       my $newdatabasefilename         = $query->param('databasefilename');
+                                                       my $databasename                = $query->param('olddatabasename');     
+                                                       my $databasedescription         = $query->param('olddatabasedescription');
+                                                       my $databaseshortname           = $query->param('database');
+                                                       my $databasenotes               = $query->param('databasenotes');
+                                                       my $databasecategories          = $query->param('databasecategories');
+
+                                                       # Check the permissions of the database configuration file and return
+                                                       # an error if the database permissions are invalid.
+                                                       
+                                                       # Pass the variables to the database editing subroutine.
+                                                       
+                                                       my $pagedata = kiriwrite_database_edit($databaseshortname, $databasename, $databasedescription, $newdatabasefilename, $newdatabasename, $newdatabasedescription, $databasenotes, $databasecategories, 1);
+                                                       
+                                                       kiriwrite_output_header;
+                                                       kiriwrite_output_page("Database Edited", $pagedata, "database");
+                                                       exit;
+                                                       
+                                               } else {
+                                                       # Value is incorrect, return and error.
+                                                       kiriwrite_error("invalidvariable");
+                                               } 
+                                               
+                                       }
+                                       
+                                       # Display the form for editing an database.
+                                       my $pagedata = kiriwrite_database_edit($http_query_database);
+                                       
+                                       kiriwrite_output_header;
+                                       kiriwrite_output_page("Edit Database", $pagedata, "database");
+                                       exit;
+                                       
+                               } else {
+                               
+                                       # If there is no value in the database variable, then return an error.
+                                       kiriwrite_error("invalidvariable");
+                                       
+                               }       
+                               
+                       } elsif ($http_query_action eq "delete"){
+                       
+                               # Action equested is to delete a database, find out if the user has already confirmed deletion of the database
+                               # and if the deletion of the database has been confirmed, delete the database.
+                               
+                               if ($query->param('confirm')){
+                                       
+                                       # User has confirmed to delete a database, pass the parameters to the kiriwrite_database_delete
+                                       # subroutine.
+                                       
+                                       my $database_filename = $query->param('database');
+                                       my $database_confirm = $query->param('confirm');
+                                       my $pagedata = kiriwrite_database_delete($database_filename, $database_confirm);
+                               
+                                       kiriwrite_output_header;
+                                       kiriwrite_output_page("Delete Database", $pagedata, "database");
+                                       
+                                       exit;
+                                       
+                               }
+                               
+                               # User has clicked on the delete link (thus hasn't confirmed the action to delete a database).
+                               
+                               my $database_filename = $query->param('database');
+                               my $pagedata = kiriwrite_database_delete($database_filename);
+                                       
+                               kiriwrite_output_header;
+                               kiriwrite_output_page("Delete Database", $pagedata, "database");
+                               
+                               exit;
+                       
+                       } elsif ($http_query_action eq "new"){
+                       
+                               # Action requested is to create a new database, find out if the user has already entered the information needed
+                               # to create a database and see if the user has confirmed the action, otherwise printout a form for adding a
+                               # database.
+                       
+                               my $http_query_confirm = $query->param('confirm');
+                               
+                               # Check if the confirm value is correct.
+                               
+                               if ($http_query_confirm){
+                                       if ($http_query_confirm eq 1){
+                                       
+                                               # User has confirmed to create a database, pass the parameters to the 
+                                               # kiriwrite_database_add subroutine.
+                               
+                                               my $http_query_confirm = $query->param('confirm');
+                                       
+                                               my $database_name               = $query->param('databasename');
+                                               my $database_description        = $query->param('databasedescription');
+                                               my $database_filename           = $query->param('databasefilename');
+                                               my $database_notes              = $query->param('databasenotes');
+                                               my $database_categories         = $query->param('databasecategories');
+                                       
+                                               my $pagedata = kiriwrite_database_add($database_filename, $database_name, $database_description, $database_notes, $database_categories, $http_query_confirm);
+                                       
+                                               kiriwrite_output_header;
+                                               kiriwrite_output_page("Add Database", $pagedata, "database");
+                                               exit;
+                                       
+                                       } else {
+                                       
+                                               # The confirm value is something else other than 1 (which it shouldn't be), so
+                                               # return an error.
+                                       
+                                       }
+                               }
+                               
+                               # User has clicked on the 'Add Database' link.
+                               
+                               my $pagedata = kiriwrite_database_add;
+                               
+                               kiriwrite_output_header;
+                               kiriwrite_output_page("Add Database", $pagedata, "database");
+                               exit;
+                       
+                       } else {
+                               # Another option has been specified, so return an error.
+                               
+                               kiriwrite_error("invalidaction");
+                       }
+               }
+       
+               # No action has been specified, do the default action of displaying a list
+               # of databases.
+               
+               my $pagedata = kiriwrite_database_list;
+       
+               kiriwrite_output_header;                # Output the header to browser/console/stdout.
+               kiriwrite_output_page("", $pagedata, "database");       # Output the page to browser/console/stdout.
+               exit;                                   # End the script.       
+                       
+       } elsif ($http_query_mode eq "page"){
+       
+               # If mode is 'page', then check what action is required.
+       
+               if ($query->param('action')){
+                       my $http_query_action = $query->param('action');
+               
+                       # Check if the action requested matches with one of the options below. If it does,
+                       # go to that section, otherwise return an error.
+                       
+                       if ($http_query_action eq "view"){
+                               
+                               # The action selected was to view pages from a database, 
+                       
+                               my $database_name       = $query->param('database');                    
+                               my $pagedata            = kiriwrite_page_list($database_name);
+                       
+                               kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                               kiriwrite_output_page("Viewing Database", $pagedata, "pages");  # Output the page to browser/console/stdout.
+                               exit;                   # End the script.
+                               
+                       } elsif ($http_query_action eq "add"){
+                               
+                               # The action selected was to add a page to the selected database.
+
+                               my $http_query_confirm  = $query->param('confirm');
+                               
+                               if (!$http_query_confirm){
+                               
+                                       $http_query_confirm = 0;
+                               
+                               }
+                               
+                               if ($http_query_confirm eq 1){
+                                                               
+                                       my $http_query_database         = $query->param('database');
+                                       my $http_query_filename         = $query->param('pagefilename');
+                                       my $http_query_name             = $query->param('pagename');
+                                       my $http_query_description      = $query->param('pagedescription');
+                                       my $http_query_section          = $query->param('pagesection');
+                                       my $http_query_template         = $query->param('pagetemplate');
+                                       my $http_query_settings         = $query->param('pagesettings');
+                                       my $http_query_content          = $query->param('pagecontent');
+                                                                       
+                                       my $pagedata                    = kiriwrite_page_add($http_query_database, $http_query_filename, $http_query_name, $http_query_description, $http_query_section, $http_query_template, $http_query_settings, $http_query_content, $http_query_confirm);
+                                       
+                                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Add Page", $pagedata, "pages");  # Output the page to browser/console/stdout.
+                                       exit;                           # End the script.
+                               
+                               }
+                                                               
+                               my $http_query_database = $query->param('database');
+                               my $pagedata            = kiriwrite_page_add($http_query_database);
+                               
+                               kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                               kiriwrite_output_page("Add Page", $pagedata, "pages");  # Output the page to browser/console/stdout.
+                               exit;                           # End the script.
+                       
+                       } elsif ($http_query_action eq "edit"){
+                        
+                               # The action selected was to edit a page from a database.
+                               
+                               my $http_query_confirm = $query->param('confirm');
+                               
+                               if (!$http_query_confirm){
+                               
+                                       $http_query_confirm = 0;
+                               
+                               }
+                               
+                               if ($http_query_confirm eq 1){
+                               
+                                       # Get the needed values from the HTTP query.
+                                       
+                                       my $http_query_database         = $query->param('database');
+                                       my $http_query_filename         = $query->param('page');
+                                       my $http_query_newfilename      = $query->param('pagefilename');
+                                       my $http_query_name             = $query->param('pagename');
+                                       my $http_query_description      = $query->param('pagedescription');
+                                       my $http_query_section          = $query->param('pagesection');
+                                       my $http_query_template         = $query->param('pagetemplate');
+                                       my $http_query_settings         = $query->param('pagesettings');
+                                       my $http_query_content          = $query->param('pagecontent');                         
+                                       
+                                       # Pass the values to the editing pages subroutine.
+                                       
+                                       my $pagedata = kiriwrite_page_edit($http_query_database, $http_query_filename, $http_query_newfilename, $http_query_name, $http_query_description, $http_query_section, $http_query_template, $http_query_settings, $http_query_content, $http_query_confirm);
+                                       
+                                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Edit Page", $pagedata, "pages"); # Output the page to browser/console/stdout.
+                                       exit;                           # End the script.       
+                               
+                               }
+                               
+                               # Get the needed values from the HTTP query.
+                               
+                               my $http_query_database = $query->param('database');
+                               my $http_query_filename = $query->param('page');
+                       
+                               # Pass the values to the editing pages subroutine.
+                               
+                               my $pagedata = kiriwrite_page_edit($http_query_database, $http_query_filename);
+                               
+                               kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                               kiriwrite_output_page("Edit Page", $pagedata, "pages"); # Output the page to browser/console/stdout.
+                               exit;                           # End the script.
+                               
+                               
+                       } elsif ($http_query_action eq "delete"){
+                       
+                               # The action selected was to delete a page from a database.
+                               
+                               my $http_query_database = $query->param('database');
+                               my $http_query_page     = $query->param('page');
+                               my $http_query_confirm  = $query->param('confirm');
+                               
+                               my $pagedata = "";
+                               my $selectionlist = "";
+                               
+                               if ($http_query_confirm){
+                               
+                                       # The action has been confirmed, so try to delete the selected page
+                                       # from the database.
+                                       
+                                       $pagedata = kiriwrite_page_delete($http_query_database, $http_query_page, $http_query_confirm);
+                                       
+                                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Delete Page", $pagedata, "pages"); # Output the page to browser/console/stdout.
+                                       exit;                           # End the script.
+                               
+                               }
+
+                               $pagedata = kiriwrite_page_delete($http_query_database, $http_query_page);
+                               
+                               kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                               kiriwrite_output_page("Delete Page", $pagedata, "pages"); # Output the page to browser/console/stdout.
+                               exit;                           # End the script.
+                               
+                               
+                       } elsif ($http_query_action eq "multidelete"){
+
+                               # The action selected was to delete multiple pages from a
+                               # database.
+
+                               my $http_query_database = $query->param('database');
+                               my $http_query_confirm  = $query->param('confirm');
+
+                               my @filelist;
+                               my $pagedata;
+
+                               if ($http_query_confirm){
+
+                                       # The action to delete multiple pages from the selected
+                                       # database has been confirmed.
+
+                                       @filelist       = kiriwrite_selectedlist();
+                                       $pagedata       = kiriwrite_page_multidelete($http_query_database, $http_query_confirm, @filelist);
+
+                                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Delete selected pages", $pagedata, "pages"); # Output the page to browser/console/stdout.
+                                       exit;                           # End the script.
+
+                               }
+
+                               # Get the list of selected pages and pass them to the
+                               # multiple page delete subroutine.
+
+                               @filelist       = kiriwrite_selectedlist();
+                               $pagedata       = kiriwrite_page_multidelete($http_query_database, $http_query_confirm, @filelist);
+
+                               kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                               kiriwrite_output_page("Delete selected pages", $pagedata, "pages"); # Output the page to browser/console/stdout.
+                               exit;                           # End the script.
+
+                       } elsif ($http_query_action eq "multimove"){
+
+                               # The action selected was to move multiple pages from a
+                               # database.
+
+                               my $http_query_database         = $query->param('database');
+                               my $http_query_newdatabase      = $query->param('newdatabase');
+                               my $http_query_confirm          = $query->param('confirm');
+
+                               my @filelist;
+                               my $pagedata;
+
+                               if ($http_query_confirm){
+
+                                       # The action to move multiple pages from the selected
+                                       # database has been confirmed.
+
+                                       @filelist       = kiriwrite_selectedlist();
+                                       $pagedata       = kiriwrite_page_multimove($http_query_database, $http_query_newdatabase, $http_query_confirm, @filelist);
+
+                                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Move selected pages", $pagedata, "pages"); # Output the page to browser/console/stdout.
+                                       exit;                           # End the script.
+
+                               }
+
+                               # Get the list of selected pages and pass them to the
+                               # multiple page move subroutine.
+
+                               @filelist       = kiriwrite_selectedlist();
+                               $pagedata       = kiriwrite_page_multimove($http_query_database, $http_query_newdatabase, $http_query_confirm, @filelist);
+
+                               kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                               kiriwrite_output_page("Move selected pages", $pagedata, "pages"); # Output the page to browser/console/stdout.
+                               exit;                           # End the script.
+
+                       } elsif ($http_query_action eq "multicopy"){
+
+                               # The action selected was to copy multiple pages from a
+                               # database.
+
+                               my $http_query_database         = $query->param('database');
+                               my $http_query_newdatabase      = $query->param('newdatabase');
+                               my $http_query_confirm          = $query->param('confirm');
+
+                               my @filelist;
+                               my $pagedata;
+
+                               if ($http_query_confirm){
+
+                                       # The action to copy multiple pages from the selected
+                                       # database has been confirmed.
+
+                                       @filelist       = kiriwrite_selectedlist();
+                                       $pagedata       = kiriwrite_page_multicopy($http_query_database, $http_query_newdatabase, $http_query_confirm, @filelist);
+
+                                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Copy selected pages", $pagedata, "pages"); # Output the page to browser/console/stdout.
+                                       exit;                           # End the script.
+
+                               }
+
+                               # Get the list of selected pages and pass them to the
+                               # multiple page copy subroutine.
+
+                               @filelist       = kiriwrite_selectedlist();
+                               $pagedata       = kiriwrite_page_multicopy($http_query_database, $http_query_newdatabase, $http_query_confirm, @filelist);
+
+                               kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                               kiriwrite_output_page("Copy selected pages", $pagedata, "pages"); # Output the page to browser/console/stdout.
+                               exit;                           # End the script.
+
+                       } elsif ($http_query_action eq "multiedit"){
+
+                               # The action selected was to edit multiple pages from a
+                               # database.
+
+                               my $http_query_database         = $query->param('database');
+                               my $http_query_newsection       = $query->param('newsection');
+                               my $http_query_altersection     = $query->param('altersection');
+                               my $http_query_newtemplate      = $query->param('newtemplate');
+                               my $http_query_altertemplate    = $query->param('altertemplate');
+                               my $http_query_newsettings      = $query->param('newsettings');
+                               my $http_query_altersettings    = $query->param('altersettings');
+                               my $http_query_confirm          = $query->param('confirm');
+
+                               my @filelist;
+                               my $pagedata;
+
+                               if (!$http_query_confirm){
+
+                                       @filelist       = kiriwrite_selectedlist();
+                                       $pagedata       = kiriwrite_page_multiedit($http_query_database, $http_query_newsection, $http_query_altersection, $http_query_newtemplate, $http_query_altertemplate, $http_query_newsettings, $http_query_altersettings, $http_query_confirm, @filelist);
+
+                                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Edit selected pages", $pagedata, "pages"); # Output the page to browser/console/stdout.
+                                       exit;   
+
+                               }
+
+                               # Get the list of selected pages and pass them to the
+                               # multiple page edit subroutine.
+
+                               @filelist       = kiriwrite_selectedlist();
+                               $pagedata       = kiriwrite_page_multiedit($http_query_database, $http_query_newsection, $http_query_altersection, $http_query_newtemplate, $http_query_altertemplate, $http_query_newsettings, $http_query_altersettings, $http_query_confirm, @filelist);
+
+                               kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                               kiriwrite_output_page("Edit selected pages", $pagedata, "pages"); # Output the page to browser/console/stdout.
+                               exit;                           # End the script.       
+
+                       } else {
+                               kiriwrite_error("invalidaction");
+                       }                               
+                       
+               } else {
+                       
+                       # If there the action option is left blank, then print out a form where the database
+                       # can be selected to view pages from.
+                       
+                       my $pagedata = kiriwrite_page_list;
+                       
+                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                       kiriwrite_output_page("Database Selection", $pagedata, "pages");        # Output the page to browser/console/stdout.
+                       exit;                           # End the script.
+                       
+               }
+       
+               # No action has been specified, do the default action of listing pages from
+               # the first database found in the directory.
+               
+       } elsif ($http_query_mode eq "filter"){
+       
+               # If there's a value for action in the HTTP query, then
+               # get that value that is in the HTTP query.
+               
+               if ($query->param('action')){
+               
+                       # There is a value for action in the HTTP query,
+                       # so get the value from it.
+                       
+                       my $http_query_action = $query->param('action');
+                       
+                       if ($http_query_action eq "add"){
+               
+                               # The action the user requested is to add a filter to the
+                               # filters database.
+                               
+                               # Check if there is a value in confirm and if there is
+                               # then pass it on to the new find and replace words
+                               # to add to the filter database.
+                               
+                               my $http_query_confirm = $query->param('confirm');
+                               
+                               if ($http_query_confirm){
+                               
+                                       # There is a value in http_query_confirm, so pass on the
+                                       # new find and replace words so that they can be added
+                                       # to the filters database.
+                                       
+                                       my $http_query_findwords        = $query->param('findword');
+                                       my $http_query_replacewords     = $query->param('replaceword');
+                                       my $http_query_priority         = $query->param('priority');
+                                       my $http_query_notes            = $query->param('notes');
+                                                                               
+                                       my $pagedata = kiriwrite_filter_add($http_query_findwords, $http_query_replacewords, $http_query_priority, $http_query_notes, $http_query_confirm);
+                                       
+                                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Add Filters", $pagedata, "filter"); # Output the page to browser/console/stdout.
+                                       exit;                           # End the script.
+                               
+                               }
+                               
+                               my $pagedata = kiriwrite_filter_add();
+                               
+                               kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                               kiriwrite_output_page("Add Filters", $pagedata, "filter"); # Output the page to browser/console/stdout.
+                               exit;                           # End the script.
+               
+                       } elsif ($http_query_action eq "edit"){
+
+                               # The action the user requested is to edit an filter from
+                               # the filters database.
+                               
+                               my $http_query_number = $query->param('filter');
+                               my $http_query_confirm = $query->param('confirm');
+                               
+                               if ($http_query_confirm){
+                               
+                                       # There is a value in http_query_confirm, so pass on the
+                                       # new find and replace words so that the filters database
+                                       # can be edited.
+                                       
+                                       my $http_query_findwords        = $query->param('filterfind');
+                                       my $http_query_replacewords     = $query->param('filterreplace');
+                                       my $http_query_priority         = $query->param('priority');
+                                       my $http_query_notes            = $query->param('notes');
+                                       
+                                       my $pagedata = kiriwrite_filter_edit($http_query_number, $http_query_findwords, $http_query_replacewords, $http_query_priority, $http_query_notes, $http_query_confirm);
+                                       
+                                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Edit Filter", $pagedata, "filter");      # Output the page to browser/console/stdout.
+                                       exit;                           # End the script.
+                               
+                               }
+                               
+                               my $pagedata = kiriwrite_filter_edit($http_query_number);
+
+                               kiriwrite_output_header;                # Output the header to browser/console/stdout.
+                               kiriwrite_output_page("Edit Filter", $pagedata, "filter");      # Output the page to browser/console/stdout.
+                               exit;                                   # End the script.
+                               
+                       } elsif ($http_query_action eq "delete"){
+               
+                               # The action the user requested is to delete an filter
+                               # from the filters database.
+                               
+                               my $http_query_number = $query->param('filter');
+                               my $http_query_confirm = $query->param('confirm');
+                               
+                               if ($http_query_confirm){
+                               
+                                       my $pagedata = kiriwrite_filter_delete($http_query_number, $http_query_confirm);
+                                       
+                                       kiriwrite_output_header;                # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Delete Filter", $pagedata, "filter"); # Output the page to browser/console/stdout.
+                                       exit;                                   # End the script
+                               
+                               }
+                               
+                               my $pagedata = kiriwrite_filter_delete($http_query_number);
+                               
+                               kiriwrite_output_header;                # Output the header to browser/console/stdout.
+                               kiriwrite_output_page("Delete Filter", $pagedata, "filter");    # Output the page to browser/console/stdout.
+                               exit;                                   # End the script.
+               
+                       } else {
+               
+                               # Another action was requested that was not one of 
+                               # the ones prcedding this catch all, so return
+                               # an error saying that an invalid option was
+                               # specified.
+                       
+                               kiriwrite_error("invalidaction");
+               
+                       }
+               
+               } else {
+               
+                       my $pagedata = kiriwrite_filter_list();
+                       
+                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                       kiriwrite_output_page("View Filters", $pagedata, "filter"); # Output the page to browser/console/stdout.
+                       exit;                           # End the script.
+               
+               }
+               
+               
+               
+       } elsif ($http_query_mode eq "template"){
+       
+               # Check if an action has been specified in the HTTP query.
+       
+               if ($query->param('action')){
+                       
+                       # An action has been specified in the HTTP query.
+               
+                       my $http_query_action = $query->param('action');
+                       
+                       if ($http_query_action eq "delete"){
+                               # Get the required parameters from the HTTP query.
+                       
+                               my $http_query_template = $query->param('template');
+                               my $http_query_confirm  = $query->param('confirm');
+                               
+                               # Check if a value for confirm has been specified (it shouldn't)
+                               # be blank.
+                               
+                               if ($http_query_confirm eq ""){
+                                       # The confirm parameter of the HTTP query is blank, so
+                                       # write out a form asking the user to confirm the deletion
+                                       # of the selected template.
+                                       
+                                       my $pagedata = kiriwrite_template_delete($http_query_template);
+                       
+                                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Delete Template", $pagedata, "template");        # Output the page to browser/console/stdout.
+                                       exit;                           # End the script.
+                                       
+                               } else {
+                                       
+                                       my $pagedata = kiriwrite_template_delete($http_query_template, $http_query_confirm);
+                                       
+                                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Delete Template", $pagedata, "template");        # Output the page to browser/console/stdout.
+                                       exit;                           # End the script.                               
+                                       
+                               }
+                               
+                       } elsif ($http_query_action eq "add") {
+                       
+                               # Get the variables from the HTTP query in preperation for processing.
+                       
+                               my $http_query_confirm  = $query->param('confirm');
+                               my $http_query_templatelayout   = $query->param('templatelayout');
+                               my $http_query_templatename     = $query->param('templatename');
+                               my $http_query_templatedescription = $query->param('templatedescription');
+                               my $http_query_templatefilename = $query->param('templatefilename');
+                               
+                               # Check if there is a confirmed value in the http_query_confirm variable.
+                               
+                               if (!$http_query_confirm){
+                               
+                                       # Since there is no confirm value, print out a form for creating a new
+                                       # template.
+                               
+                                       my $pagedata = kiriwrite_template_add();
+                               
+                                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Add Template", $pagedata, "template");   # Output the page to browser/console/stdout.
+                                       exit;                           # End the script.
+                               
+                               } else {
+                               
+                                       # A value in the http_query_confirm value is specified, so pass the
+                                       # variables onto the kiriwrite_template_add subroutine.
+                                       
+                                       my $pagedata = kiriwrite_template_add($http_query_templatefilename, $http_query_templatename, $http_query_templatedescription, $http_query_templatelayout, $http_query_confirm);
+                                       
+                                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Add Template", $pagedata, "template");   # Output the page to browser/console/stdout.
+                                       exit;                           # End the script.
+                               
+                               }
+                       
+                       } elsif ($http_query_action eq "edit") {
+                       
+                               # Get the required parameters from the HTTP query.      
+                       
+                               my $http_query_templatefile     = $query->param('template');
+                               my $http_query_confirm          = $query->param('confirm');
+                               
+                               # Check to see if http_query_confirm has a value of '1' in it and
+                               # if it does, edit the template using the settings providied.
+                               
+                               if (!$http_query_confirm){
+                               
+                                       # Since there is no confirm value, open the template configuration
+                                       # file and the template file itself then print out the data on to
+                                       # the form.
+                                       
+                                       my $pagedata = kiriwrite_template_edit($http_query_templatefile);
+                                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Edit Template", $pagedata, "template");  # Output the page to browser/console/stdout.
+                                       exit;                           # End the script.
+                               
+                               } elsif ($http_query_confirm eq 1) {
+                               
+                                       # Since there is a confirm value of 1, the user has confirm the
+                                       # action of editing of a template so get the other variables 
+                                       # that were also sent and pass the variables to the subroutine.
+                                       
+                                       my $http_query_newfilename      = $query->param('newfilename');
+                                       my $http_query_newname          = $query->param('newname');
+                                       my $http_query_newdescription   = $query->param('newdescription');
+                                       my $http_query_newlayout        = $query->param('newlayout');
+                                       
+                                       my $pagedata = kiriwrite_template_edit($http_query_templatefile, $http_query_newfilename, $http_query_newname, $http_query_newdescription, $http_query_newlayout, $http_query_confirm);
+                                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Edit Template", $pagedata, "template");  # Output the page to browser/console/stdout.
+                                       exit;                           # End the script.
+                               
+                               } else {
+                               
+                                       # Another confirm value is there instead of '0' or '1'. Return
+                                       # an error saying it is invalid.
+                                       
+                                       kiriwrite_error("invalidvariable");
+                               
+                               }
+                               
+                       } else {
+
+                               # Another action was specified and was not one of the ones above, so
+                               # return an error.
+
+                               kiriwrite_error("invalidaction");
+
+                       }
+                       
+               } else {
+               
+                       # If the action option is left blank, then print out a form where the list
+                       # of templates are available.
+                       
+                       my $pagedata = kiriwrite_template_list;
+                       
+                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                       kiriwrite_output_page("View Templates", $pagedata, "template"); # Output the page to browser/console/stdout.
+                       exit;                           # End the script.
+               
+               }
+       
+       } elsif ($http_query_mode eq "compile"){
+               
+               # The mode selected is to compile pages from databases.
+       
+               # If the action option is left blank, then print out a form where the list
+               # of databases to compile are available.
+               
+               if ($query->param('action')){
+               
+                       my $http_query_action = $query->param('action');
+               
+                       if ($http_query_action eq "compile"){
+                       
+                               # The specified action is to compile the pages, check if the
+                               # action to compile the page has been confirmed.
+
+                               my $http_query_confirm  = $query->param('confirm');
+                               my $http_query_type     = $query->param('type');
+                               
+                               # If it is blank, set the confirm value to 0.
+                               
+                               if (!$http_query_confirm){
+                               
+                                       # The http_query_confirm variable is uninitalised, so place a
+                                       # '0' (meaning an unconfirmed action).
+                               
+                                       $http_query_confirm = 0;
+                               
+                               }
+
+                               # If the compile type is blank then return an error.
+
+                               if (!$http_query_type){
+
+                                       # Compile type is blank so return an error.
+
+                                       kiriwrite_error("blankcompiletype");
+
+                               }
+
+                               if ($http_query_type eq "multiple"){    
+       
+                                       if ($http_query_confirm eq 1){
+                                               
+                                               # The action to compile the pages has been confirmed so
+                                               # compile the pages.
+                                       
+                                               my @selectedlist = kiriwrite_selectedlist();
+                                               my $pagedata = kiriwrite_compile_makepages($http_query_type, $http_query_confirm, @selectedlist);
+                                               
+                                               kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                               kiriwrite_output_page("Compiled Pages", $pagedata, "compile"); # Output the page to browser/console/stdout.
+                                               exit;                           # End the script.
+                                       
+                                       } else {
+                                       
+                                               # The action to compile the pages has not been confirmed
+                                               # so write a form asking the user to confirm the action
+                                               # of compiling the pages.
+                                               
+                                               my @selectedlist = kiriwrite_selectedlist();
+                                               my $pagedata = kiriwrite_compile_makepages($http_query_type, $http_query_confirm, @selectedlist);
+                               
+                                               kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                               kiriwrite_output_page("Compile mulitple databases", $pagedata, "compile"); # Output the page to browser/console/stdout.
+                                               exit;                           # End the script.
+                                               
+                                       }
+
+                               } elsif ($http_query_type eq "single"){
+
+                                       my $http_query_database = $query->param('database');
+                                       my @selectedlist;
+                                       $selectedlist[0] = $http_query_database;
+                                       my $pagedata = kiriwrite_compile_makepages($http_query_type, $http_query_confirm, @selectedlist);
+
+                                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Compile one database", $pagedata, "compile");
+                                       exit;                           # End the script.
+
+                               } else {
+
+                                       kiriwrite_error("invalidcompiletype");
+
+                               }
+                       
+                       } elsif ($http_query_action eq "all"){
+
+                               # The selected action is to compile all of the databases
+                               # in the database directory. Check if the action to
+                               # compile all of the databases has been confirmed.
+
+                               my $http_query_confirm = $query->param('confirm');
+
+                               if (!$http_query_confirm){
+
+                                       # The http_query_confirm variable is uninitalised, so place a
+                                       # '0' (meaning an unconfirmed action).
+
+                                       $http_query_confirm = 0;
+
+                               }
+
+                               if ($http_query_confirm eq 1){
+
+                                       # The action to compile all the databases has been confirmed.
+
+                               }
+
+                               my $pagedata = kiriwrite_compile_all();
+
+                               kiriwrite_output_header;                        # Output the header to browser/console/stdout.
+                               kiriwrite_output_page("Compile All Databases", $pagedata, "compile");
+                               exit;
+
+                       } elsif ($http_query_action eq "clean") {
+                               
+                               # The selected action is to clean the output directory.
+                               # Check if the action to clean the output directory
+                               # has been confirmed.
+                               
+                               my $http_query_confirm = $query->param('confirm');
+                               
+                               if (!$http_query_confirm){
+                               
+                                       # The http_query_confirm variable is uninitalised, so place a
+                                       # '0' (meaning an unconfirmed action).
+                                       
+                                       $http_query_confirm = 0;
+                               
+                               }
+                               
+                               if ($http_query_confirm eq 1){
+                               
+                                       # The action to clean the output directory has been confirmed.
+
+                                       my $pagedata = kiriwrite_compile_clean($http_query_confirm);
+                       
+                                       kiriwrite_output_header;                # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Clean Output Directory", $pagedata, "compile");  # Output the page to browser/console/stdout.
+                                       exit;                                   # End the script.
+                                                                       
+                               }
+                               
+                               # The action to clean the output directory is not
+                               # confirmed, so write a page asking the user
+                               # to confirm cleaning the output directory.
+                       
+                               my $pagedata = kiriwrite_compile_clean();
+                       
+                               kiriwrite_output_header;                # Output the header to browser/console/stdout.
+                               kiriwrite_output_page("Clean Output Directory", $pagedata, "compile");  # Output the page to browser/console/stdout.
+                               exit;                                   # End the script.
+                       
+                       } else {
+
+                               # The action specified was something else other than those
+                               # above, so return an error.
+
+                               kiriwrite_error("invalidaction");
+
+                       }
+               }
+               
+               my $pagedata = kiriwrite_compile_list;
+               
+               kiriwrite_output_header;                # Output the header to browser/console/stdout.
+               kiriwrite_output_page("Compile Pages", $pagedata, "compile");   # Output the page to browser/console/stdout.
+               exit;                                   # End the script.
+               
+       } elsif ($http_query_mode eq "settings"){
+       
+               # The mode selected is view (and change settings).
+       
+               # If the action value has been left blank, then view the list of
+               # current settings.
+               
+               if ($query->param('action')){
+                       my $http_query_action = $query->param('action');
+                       
+                       if ($http_query_action eq "edit"){
+                       
+                               # The action specified is to edit the settings. Check if the action
+                               # to edit the settings has been confirmed.
+                               
+                               my $http_query_confirm = $query->param('confirm');
+
+                               if (!$http_query_confirm){
+
+                                       # The confirm value is blank, so set it to 0.
+
+                                       $http_query_confirm = 0;
+
+                               }
+                               
+                               if ($http_query_confirm eq 1){
+                               
+                                       # The action to edit the settings has been confirmed. Get the
+                                       # required settings from the HTTP query.
+                               
+                                       my $http_query_database         = $query->param('databasedir');
+                                       my $http_query_output           = $query->param('outputdir');
+                                       my $http_query_imagesuri        = $query->param('imagesuripath');
+                                       my $http_query_datetimeformat   = $query->param('datetime');
+                                       my $http_query_systemlanguage   = $query->param('language');
+                                       my $http_query_outputsystem     = $query->param('outputsys');
+                                       
+                                       my $pagedata = kiriwrite_settings_edit($http_query_database, $http_query_output, $http_query_imagesuri, $http_query_datetimeformat, $http_query_systemlanguage, $http_query_outputsystem, $http_query_confirm);
+                                       
+                                       kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                                       kiriwrite_output_page("Edit Settings", $pagedata, "settings");  # Output the page to browser/console/stdout.
+                                       exit;                           # End the script.
+                               
+                               }
+                               
+                               # The action to edit the settings has not been confirmed.
+                       
+                               my $pagedata = kiriwrite_settings_edit;
+                       
+                               kiriwrite_output_header;        # Output the header to browser/console/stdout.
+                               kiriwrite_output_page("Edit Settings", $pagedata, "settings");  # Output the page to browser/console/stdout.
+                               exit;                           # End the script.
+                       
+                       } else {
+
+                               # The action specified was something else other than those
+                               # above, so return an error.
+
+                               kiriwrite_error("invalidaction");
+
+                       }
+                       
+               }
+       
+               # No action has been specified, so print out the list of settings currently being used.
+               
+               my $pagedata = kiriwrite_settings_view;
+               
+               kiriwrite_output_header;                # Output the header to browser/console/stdout.
+               kiriwrite_output_page("View Settings", $pagedata, "settings");  # Output the page to browser/console/stdout.
+               exit;                                   # End the script.
+               
+       } else {
+               # Another mode has been specified than the ones above, so return an error saying that
+               # an invalid option was specified.
+               
+               kiriwrite_error("invalidmode");
+       }
+               
+} else {
+
+       # No mode has been specified, so print the default "first-run" view of the
+       # database list.
+
+       my $pagedata = kiriwrite_database_list;
+       
+       kiriwrite_output_header;                # Output the header to browser/console/stdout.
+       kiriwrite_output_page("", $pagedata, "database");       # Output the page to browser/console/stdout.
+       exit;                                   # End the script.
+       
+}
+
+__END__
+
+=head1 NAME
+
+Kiriwrite
+
+=head1 DESCRIPTION
+
+Web-based webpage compiler.
+
+=head1 AUTHOR
+
+Steve Brokenshire <sbrokenshire@xestia.co.uk>
+
+=head1 USAGE
+
+This perl script is intended to be used on a web server which has CGI with Perl support or with mod_perl support.
+
+=head1 DOCUMENTATION
+
+For more information on how to use Kiriwrite, please see the documentation that was included with Kiriwrite.
+
+- From the Xestia Documentation website: http://documentation.xestia.co.uk and click on the Kiriwrite link on the page.
+
+- From the Documentation directory from the Kiriwrite source packages (.tar/.tar.gz/.tar.bz2).
+
+- In the /usr/share/doc/kiriwrite directory if you installed the distribution-specific packages (and also have access to the server itself).
\ No newline at end of file
diff --git a/cgi-files/kiriwrite.xml b/cgi-files/kiriwrite.xml
new file mode 100644 (file)
index 0000000..5b1e5dd
--- /dev/null
@@ -0,0 +1,19 @@
+<?xml version="1.0"?>
+
+<kiriwrite-config>
+<!-- This file was automatically generated by Kiriwrite, please feel free to edit to your own needs. -->
+       <settings>
+               <directories>
+                       <database>db</database>
+                       <output>output</output>
+                       <images>/images/kiriwrite/</images>
+               </directories>
+               <language>
+                       <type>en-uk</type>
+               </language>
+               <system>
+                       <output>HTML4T</output>
+                       <datetime>DD/MM/Y (hh:mm:ss)</datetime>
+               </system>
+       </settings>
+</kiriwrite-config>
diff --git a/cgi-files/lang/en-uk.xml b/cgi-files/lang/en-uk.xml
new file mode 100644 (file)
index 0000000..2c7fa00
--- /dev/null
@@ -0,0 +1,10 @@
+<?xml version="1.0"?>
+
+<kiriwrite-language>
+       <about>
+               <name>English UK</name>
+               <systemname>English UK</systemname>
+       </about>
+       <strings>
+       </strings>
+</kiriwrite-language>
diff --git a/cgi-files/page.html b/cgi-files/page.html
new file mode 100644 (file)
index 0000000..07e30e2
--- /dev/null
@@ -0,0 +1,165 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+       <head>
+               <title>Kiriwrite<kiriwrite:title></title>
+               <style type="text/css" media="screen">
+                       body {
+                               background-color: #408080; 
+                               color: #ffffff; 
+                               font-family: sans-serif; 
+                               font-size: 12px;
+                       }
+                       
+                       a:link {
+                               color: #ffffff;
+                       }
+                               
+                       a:hover {
+                               color: #bbbbbb;
+                       }
+                               
+                       a:visited {
+                               color: #ffffff;
+                       }
+                       
+                       table {
+                               width: 100%;
+                       }
+                       
+                       tr {
+                               padding: 5px;
+                       }
+                       
+                       select, input, button {
+                               font-size: 12px;
+                               background-color: #408080;
+                               color: #ffffff;
+                               border-style: solid;
+                               border-style: 1px;
+                               border-color: #102020;
+                               padding: 2px;
+                       }
+                       
+                       textarea {
+                               font-size: 12px;
+                               background-color: #408080;
+                               color: #ffffff;
+                               border-style: solid;
+                               border-style: 1px;
+                               border-color: #102020;
+                               padding: 2px;
+                       }
+                       
+                       .page {
+                               border-style: solid;
+                               border-width: 1px;
+                               background-color: #153030;
+                               border-top-color: #80cccc;
+                               border-left-color: #80cccc;
+                               border-right-color: #204040;
+                               border-bottom-color: #204040;
+                       }
+                       
+                       .pagedata {
+                               padding: 10px;
+                       }
+                       
+                       .topbar {
+                               background-color: #255050;
+                               padding: 5px;
+                       }
+                       
+                       .menubar {
+                               background-color: #204040;
+                               padding: 5px;
+                       }
+                       
+                       .title {
+                               font-size: 22px;
+                               font-weight: bold;
+                       }
+                       
+                       .tablecellheader {
+                               font-size: 12px;
+                               background-color: #204040;      
+                               font-weight: bold;
+                       }
+                       
+                       .tablecell1 {
+                               background-color: #408080;
+                               font-size: 12px;
+                       }
+                       
+                       .tablecell2 {
+                               background-color: #306060;
+                               font-size: 12px;
+                       }
+                       
+                       .copyrightbar {
+                               background-color: #30AAAA;
+                               padding: 7px;
+                               border-top: solid;
+                               border-top-color: #70bbbb;
+                               border-top-width: 1px;
+                       }
+                       
+                       .errorheader {
+                               font-size: 18px;
+                               font-weight: bold;
+                       }
+                       
+                       .errorbox {
+                               border-top: solid;
+                               border-top-color: #80dddd;
+                               border-top-width: 1px;
+                               border-left: solid;
+                               border-left-color: #90ffff;
+                               border-left-width: 1px;
+                               border-right: solid;
+                               border-right-color: #459090;
+                               border-right-width: 1px;
+                               border-bottom: solid;
+                               border-bottom-color: #459090;
+                               border-bottom-width: 1px;
+                               padding: 5px;
+                               background-color: #306060;
+                       }
+                       
+                       .copyrighttext {
+                               font-size:12px;
+                       }
+                       
+                       .datalist {
+                               border: solid;
+                               border-width: 1px;
+                               border-color: #60CCCC;
+                               padding: 5px;
+                               background-color: #306060;
+                       }
+
+                       .warningcell {
+                               background-color: #902020;
+                               font-size: 12px;
+                       }
+
+                       .warningoption {
+                               background-color: #902020;
+                       }
+               </style>
+               <meta http-equiv="Content-Type" content="text/html; charset=utf-8;">
+       </head>
+       <body>
+               <div class="page">
+                       <div class="topbar">
+                               <span class="title">Kiriwrite</span><br />
+                               <div class="menubar"><kiriwrite:menu></div>
+                       </div>
+                       <div class="pagedata">
+                       <kiriwrite:pagedata>
+                       </div>
+                       <div class="copyrightbar">
+                               &copy;2005-2006 Steve Brokenshire<br />
+                       </div>
+               </div>
+       </body>
+</html> 
diff --git a/misc/dbspecs/kiriwrite_database.sqlite b/misc/dbspecs/kiriwrite_database.sqlite
new file mode 100644 (file)
index 0000000..3d9ac7f
--- /dev/null
@@ -0,0 +1,25 @@
+/*
+Kiriwrite Page Database Format Specifications
+Version 1.0
+*/
+
+create table kiriwrite_database_info(
+       name varchar(256) primary key,
+       description varchar(512),
+       notes text,
+       categories varchar(512),
+       kiriwrite_version_major int(4),
+       kiriwrite_version_minor int(4),
+       kiriwrite_version_revision int(4)
+);
+
+create table kiriwrite_database_pages(
+       filename varchar(256) primary key,
+       pagename varchar(256),
+       pagedescription varchar(512),
+       pagesection varchar(128),
+       pagetemplate varchar(64),
+       pagedata text,
+       pagesettings int(1),
+       lastmodified datetime
+);
diff --git a/misc/dbspecs/kiriwrite_filters.sqlite b/misc/dbspecs/kiriwrite_filters.sqlite
new file mode 100644 (file)
index 0000000..96bd8e2
--- /dev/null
@@ -0,0 +1,12 @@
+/*
+Kiriwrite Filters Database Format
+Version 1.0
+*/
+
+create table kiriwrite_filters(
+        id int(7) primary key,
+        priority int(5),
+        findsetting varchar(1024),
+        replacesetting varchar(1024),
+        notes text
+);
diff --git a/misc/dbspecs/kiriwrite_template.sqlite b/misc/dbspecs/kiriwrite_template.sqlite
new file mode 100644 (file)
index 0000000..d1ed725
--- /dev/null
@@ -0,0 +1,12 @@
+/*
+Kiriwrite Template Database Format
+Version 1.0
+*/
+
+create table kiriwrite_templates(
+       filename varchar(256) primary key,
+       templatename varchar(512),
+       templatedescription varchar(512),
+       templatelayout text,
+       datemodified datetime
+);
Xestia Software Development
Yn Maystri
© 2006 - 2019 Xestia Software Development
Software

Xestia Address Book
Xestia Calendar
Development

Xestia Gelforn
Everything else

About
News
Privacy Policy