A Family of COM objects that provides ultimate
set of functionality
products and tools
The home pages of the particular AXPack1's components
More about the networking part of ActiveX Pack1 family.
SQLite COM database /
SQLite3 COM database
More about the SQL database part of the ActiveX Pack1 family.
Cryptography made easy on low level.
newObjects Development Library - combined documentation.
Products using AXPack1 as run-time library
Active Local Pages
Write desktop applications in ASP and CGI. (the pack is also included
Script any ActiveX in Pocket IE
If you want to build Windows NT/XP service in script.
Compile scripts in DLL through VB or/and Create active projects to
generate static content. Uses ActiveX Pack1 as run-time library.
Development tools from other vendors offering AXPack1 as
NSBasic - form based (VB-like)
programming environment for desktop and CE.
CE App manager Inovker
You may need this for your Pocket PC installations.
The newObjects ActiveX Pack1 family (AXPack1
family) contains over 50 COM classes mainly designed for
scripting environments (such as ASP, ALP, WSH, IE etc.) and mixed
applications where the scripts do part of the work (such as C++
applications that can be scripted, applications that support plug-ins
The family provides components in areas such as file access; binary
data management; custom script hosting; utility collections (dictionary
objects); string formatting, UDS (Universal Data Structures - an XML
altrernative) that can be used for data storing, configurations, data
transfer; system information and tasks; network connectivity;
self-dependent, zero-configuration SQL database engine; composite objects
- write your own COM classes in script, cryptography and many others.
The AXPack1 family is built as a foundation over which the
developers can create extensions, implementations of specific features and
technologies by utilizing the AXPack1 family features thus lowering the
costs and obtaining maximum cross-platform and cross-application compatibility. The family
components are planned carefully to provide universal features on the
right level so that the developers can build over them more specialized
solutions without need to dig deep into the OS API. For instance using the
binary data and streaming/networking functionality it is possible with
feasible effort to implement protocols like SMPT,PO3/IMAP fully in script without need to resort to any
other external components.
The structure of the family. Currently
the AXPack1 family consists of:
ActiveX Pack1 core (AXPack1). It is implemented in a single
DLL: newobjectspack1.dll. It contains over 30 COM classes that cover
core OS functions, frequently needed utilities and other features that
are often used together. It is self dependent and is compatible with
Windows 95/98/ME/NT4/2k/XP/2k3/Vista and later and with Windows CE 3.0/CE.NET
4/5 and later (including Pocket PC and Smartphone editions). See the
list of the components below
NetStreams - Implements
TCP/IP and IRDA functionality over WinSock 1.1 and is compatible with
all the Windows versions the core (AXPack1) supports. It is
implemented in a DLL named: NetStreams.dll. Depends only on the
AXPack1 core (e.g. you need to have installed the both DLL-s if
NetStreams is to be used).
SQLite COM / SQLite3
COM - Implement a fully functional, self-dependent,
zero-configuration SQL database engine. It is compatible with all the
Windows versions the core (AXPack1) supports. Implemented in a DLL
named: SQLITECOMUTF8.DLL and SQLITE3COMUTF8.DLL respectively. Depend only on the AXPack1 core (e.g. you
need to have installed the both DLL-s if SQLite COM is to be
used). From the both obviously SQLite3 COM is more advanced.
Cryptography library. The aim of the initial version is to establish a
programming interface for the most frequently used kinds of algorithms
on lower level than the Windows Crypto API. It is completely
independent of the cryptography libraries of the OS. The first version
comes with support for DES/3DES, AES, SHA1, SHA256, MD5, RSA. Having a
well-defined programming interface we will add many more algorithms in
the next issues of AXPack1 thus enabling you to use them without any
code changes other than specifying the name of the algorithm (note
this is not the case with RSA - the public key cryptography algorithms
are specific and it is not possible to devise a common programming API
for all of them on the algorithm level).
The AXPack1 family uses the AXPack1 core DLL as a
kernel and all the other members of the family make use of it in to some
degree. However none of them depends on anything outside. As the non-core members of the family provide more
specific features the developers may choose which DLL-s are needed for
their applications and they must include the AXPack1 core DLL and
whichever members they actually need. Of course, there is nothing wrong in
deploying the entire family with the application as long as the size is
not a concern, even if some DLL-s will remain unused.
The AXPack1 core DLL (newobjectspack1.dll) is a good replacement for FSO (FileSystemObject) and is also available for Windows
CE/Pocket PC/CE.NET as
well. Some of the other classes resemble a functionality you may know from
components of other vendors. However the similarity is not the only
virtue of AXPack1 family! The AXPack1 family is designed with universality
in mind and where the similar components you already know provide the
feature you need in a narrow area AXPack1 provides it in a form usable in
much more scenarios. One of the best examples is the Storages and Files
group of components (in the core DLL) which in contrast to FSO provides the
same set of features not only for files but also for memory streams, OLE
storages, network connections (with NetStreams), transparent
encryption/decryption and can do the same with
3-d party stream and storage objects. While FSO gives you only text based
access the Storages and Files group gives you also binary and record based
access (known also as flat file or also as database like).
The internal integration between many of the components allows better
performance and some unique features in otherwise familiar areas.
The documentation is NOT included download packages. To access the
documentation you will need to download the newObjects
Development Library separately. This library contains combined
documentation for all our the products which means there are
cross-references you can follow without need to download additional
documentations. Even if you do not plan to use any other product of ours
some of the illustrations of the AXPack1 usage in them may be useful for
you in other environments as well.
Last update September 2006
New modules added:
- SQLite3 COM - SQLite3 based
database engine - see more here.
- HashCryptStreams - the initial
version of cryptography support in AXPack1. Comes with several hash and
encryption algorithms and establishes an algorithm independent programming
- Some new features added to SFBinaryData
- Various other small additions and improvements.
- CE.NET binaries have been re-compiled and do not need ATLCE DLL any
edition for Smartphone 2003 and later has been added with Micro Script
Host designed for smartphone user interface.
This update is minor - only developers who need files for non Pocket PC
based CE.NET devices need it.
- StrngUtilities object has been added. Powerful string formatting
compatible with the printf functions from the standard C libraries but
extended with many additional useful features.
- Improved behavior of the composite objects (now they can be used as ASP
objects more easily), COMScriptThread minor issue has been fixed.
- COMSleeper, Event, Mutex and Semaphore objects have been added to aid
muti-threaded and networking (see NetStreams)
- Easy and cross-platform compatible way to
run script in background thread(s)
- Full port to Windows CE/CE.NET
class added to support advanced operations
over binary blocks of data
- UDS tools (ConfigFile class) now support wide strings and
- Byte ordering parameters are supported by all the classes
where data in foreign byte order can be read (e.g. you can manipulate data
that uses big endian values).
- Micro Script Host is extended with a few methods
Note: From 2003 The ActiveX Pack1 core DLL replaces some of our
components previously available as separate DLL-s. It now includes all
of them in the AXPack1 core DLL. This concerns the following DLL-s
distributed separately before 2003: newobjectscollections.dll,
ASPIniFile.dll, scphost.dll. IF you are using any of them you can install
the AXPack1 family and delete them safely - all the applications that use
them will continue to work properly.
We change this part of this page from time to time to point out
certain interesting parts of the family.
The pack is a base on which you can build your
own components and libraries.
The composite objects is a technique that allows developers build
new COM components in Active scripts (VBScript, JScript etc.) and/or other
languages in combination (for example part of the component can be in
script and part in C++ or VB). Using the existing library components the
developer can produce more specialized components. For example an upload
handling components (SFStream and VarDictionary provide all the needed
base features - the rest is simple enough for a script language - mostly data
organization). Instead of having a boxed upload component this way you can
build something that is both closed (when you just want to use it) and
opened for evolution (when you want to extend it).
The threading components allow the developer run scripts or objects as
background threads. For example this allows ASP WEB applications to
perform tasks otherwise inappropriate for the WEB. for example
COMScriptThread can be created and kept in an Application variable. Then
some pages may schedule tasks for the script loaded in it and check if
their tasks are finished in another request. A good example is a scenario
where you need data mining - you need to extract summary information from
the database in a way that is not the primary target for the database
design and thus requires considerable time. Another sample is custom
content indexing or fetching and caching network resources used in the ASP
The SFxxxx components (Storages and Files sub-set/group) implement abstract
stream/storage manipulation which allows their features to be applied over
external objects with similar behavior. For example there is a NetStreams
module member of the pack's family
which allows network connection to be treated as stream. In this case you
will need to call one Connect method to establish a connection and then
you need just to attach a SFStream to it and read/write it in text/binary
or record oriented mode the same way you do this with files.
Micro script host
Many developers know the difficult situation in which you have no
script host application on the PC. On the Pocket PC platform there is no such
standard tool. This is the purpose of the simple Micro script host
included with the pack. It is an application offering the same
functionality on PC and Pocket PC/Windows CE.NET device. The interface supplied
is simple but enough for many handy tasks a developer or power user may
want to perform.
Record based file access or as many developers
know it "flat file" access or "database-like" access
If you know some of the compiled languages probably you miss this in
ASP and ALP - random access to records in a binary file - just like
in a DB table. SFRecord and
SFField objects provide it and, again,
not only on files but on any stream. If a resource behaves in way
similar to a file you are able to use it like a DB table, define records
and write/read them at any position (if the stream is seekable) and
sequentially (on any stream).
What for? Access from script application (ASP, WSH, ALP, etc.)
non-text file formats and not only access but work with them as the C++
or VB applications do. Use binary files to store the application data if
you want to avoid DB (sometimes deployment requirements make it more
than reasonable). Create scripts for import/export from/to files created
by other applications and so on.
There are the ScriptManager2 and
components. You can build with them custom scripting environments for minutes - that is the idea.
Imagine how much flexibility will gain a VB or C++ application if
you are able to move part of the logic outside in easy to replace
scripts. And all the mess with the scripting interfaces is transparent -
you need only to add the environment objects, put some script and the
host is ready to go.
What for? Almost any project will need twice less work if the
logic is outside and only the core functionality and critical
calculations are in VB or C++ part. The script could play different roles -
configuration role, driving the components in the application to do
their work, extend the application, allow the user to program macros and
extensions. And why not use it in another scripting application? One
scripting application (for example ASP page) may construct a host, tune
it and run another script which will run in an environment much
convenient for the particular task than the ASP page may offer. While
the popular environments such as Java and .NET seem to offer such an
oprotunity the fact is that they are most often inconvenient because
they cannot separate the application in something hard to code and
something simple and thus split the work between different kind of
developers. Still using the available COM gateways in such environments
you can add active scripting functionality to applications based on
VarDictionary and UtilStringList implement multipurpose
collections. Compared with the Dictionary object from the standard
library coming with VBScript/JScript they offer its
functionality and much more. Behavior can be tuned as appropriate,
it is easy to keep collections of collections in memory - tree
like data structures. There are cloning and searching methods which
allow in a single line complex operations over trees of data. Tuning -
you tell the collection how to behave: what to enumerate the values or
their names, allow/disallow assignment ( collection("SomeValue")
= newValue ), allow/disallow unnamed values etc. If the collection
contains sub collections you can just call FindByName or FindByValue to
find values or sub collections in depth.
What for? First they are used by other objects returning
structured data - for example registry branches, directory contents etc.
You are able to construct and manage complex structures of data in
memory. Why use XML just because its DOM objects (if no XML is to be
parsed)? You are able to construct exactly what you need. Keep various
data in memory in structured form with ability to find what the
INI files, Registry, other configurations
ConfigFile allows you to manage custom configuration files, registry
and data stored in binary files through a single function call. One call
is needed to load entire tree of various settings and other values in
the memory or save it back to the same or another storage.
Additional samples and information sources
Samples/articles that often involve usage of components from the pack.
The included documentation (ndl.chm) and samples installed by the
In Active Local Pages
product where the library is included as standard run-time library. Most
of the samples can be used without changes on Microsoft IIS as well.
newObjects ActiveX pack1 family is a freeware! You can use it wherever
you need it or include it with your applications if they need it. We will
be glad to learn about your usages of the package, but you are not
required to inform us!
Is there support for it? Yes - the ActiveX pack1 family is a standard
run-time library for our commercial products. Therefore it is a vital part
of our work and as core components for many other products is tested very
carefully. If you need support you will receive it by e-mail if you have a
development oriented license for one or more of our commercial products
including it. We will try to answer also questions from users who have no
such license but of course our
customers will have priority.
Versions higher than 1.0 of the HashCryptStreams
DLL may require license for part of their functionality. However it is a
strict rule for us to keep freeware what once has been such! Therefore
what is free at the moment you notice it will remain such.
You want to gain support for the AXPack1 family separately -
PC version: Windows 95 and later, Windows NT4/2000/XP/2k3 and later.
On Windows 95/N4 IE4 is recommended (as it ships with DCOM update which
allows extended usage).
Windows CE version: Windows CE 3.0, CE.NET 4.0 or later, with standard SDK
Special versions for older and specific CE distributions may be
requested/available, but they may not be able to support all the features
on CE versions prior to 3.0.
Components in the pack
The list is in alphabetical order. See the notes description
after the list.
INI files and registry
INI files and registry
COM - SQLITECOMUTF8.DLL
COM - SQLITE3COMUTF8.DLL
COM functions and session parameters
* - Not supported on Windows CE/CE.NET
** - Some members have important platform notes
*** - Not supported on all CE/CE.NET based platforms
C - Creatable
B - "Both" threading
F - "Free" threading
A - "Apartment threading"
P - Parent threading - inherits the threading model of
the object that creates (internally) and returns it.
- The link is to
the online copy of NDL (newObjects Development Library)
On Windows CE there is no support for Apartment threading.
To gain compatibility the Class ID/ProgID that are registered
for this threading model on the desktop Windows OS-es are
registered as "Both" on Windows CE. For example the
VaryDisp class has Apartment, Both and Free threaded ProgID/ClassID
on Windows CE the ID-s for Apartment and Both will both be
registered as "Both".
The ActiveX Pack1 family is suitable for client side and server side
usage as well. Note that most objects (for which it makes sense) have
normal and free-threaded ProgID/ClassID. In certain applications (mostly
on servers - IIS is a good example) there is a benefit in using
free-threaded components in some places. Also there are applications that
need free-threaded COM objects explicitly. If there is such a reason - use
the free-threaded versions of the COM objects.
Note that SQLite COM
performs its operations in a single thread (no matter which - the thread
over which it is called). I.e. you have as much potential parallel
operations as is the number of SQLite COM objects opened - you can open
the same database from several such objects. This means that the most
effective way to use it in a multi-user and in a single-user application
is a bit different. While in a single-user application you can open one
connection and perform everything through it, on a server it is better to
open connections as needed and close them immediately after completing the
task (this operation is very fast). Keep this in mind if the code you
write will work in the both scenarios and try to find a design line that
will make it possible to get best performance in the both cases. This is
true for the most in-process database engines and is caused by the typical
specifics of the single-user and multi-user operations. While one user may
perform parallel operations they are most often related to the same data
relations and limiting the connections to one helps the db engine optimize
its work (this has impact over the internal cache, the indexing and so
on). With multiple users it is important to minimize the locking time for
any part of the database even if this will slow down some operations a