newObjects (fromerly known as ZmeY soft) newObjects ActiveX Pack1
Home Products Development
pixel.gif (49 bytes)
Products by category
ALP area
ISAPI filters
Forums (discussions)
Articles and samples
Code snippets
A little help

Read more ...
Click here
ALP is implemented as an Asynchronous Pluggable Protocol. It acts like a WEB server but without need of network. It executes WEB applications such as ASP pages and CGI applications. ALP makes Internet Explorer to be server and client. With ALP you can write stand-alone desktop applications, CD-ROM autoruns, use ASP for pure desktop software and still keep your code ready to run on WEB servers too.
Write desktop software in ASP and CGI!
download it

ASP Index

Site navigation
ActiveX components

Licensing types legend
(M) Single machine license
(U) Unlimited per-company license
(D) Unlimited development license
(S) Special type of licensing

Web development portal

Quick contact

Active visitors
Suggested links
Suggest this page to the other visitors. Click the button below to place this page in the list above .

 newObjects ActiveX Pack1   
Price: FREEWARE Discount for resalers FREEWARE
Information Download Buy
Storages and Files
Hosting Active Scripts
Config, INI files and Registry
Download (SFX 1.8MB PC/PPC)
Download (ZIP 3.1MB PC/PPC)
PC Only (SFX 0.8M)
PC Only (ZIP 1.2M)
CAB (Pocket PC ARM)
CAB (Pocket PC SH3)
CAB (Pocket PC MIPS)
All the downloads


Related products and tools
More about the networking part of ActiveX Pack1 family.
SQLite COM database
More about the SQL database part of the ActiveX Pack1 family.

Active Local Pages
Write desktop applications in ASP and CGI. (the pack is also included with it).
Script any ActiveX in Pocket IE
CE App manager Inovker
You may need this for your Pocket PC installations.
Script service
If you want to build Windows NT/XP service in script.
newObjects Development Library - combined documentation.
ASP Compiler
Compile scripts in DLL through VB or/and Create active projects to generate static content. Uses ActiveX Pack1 as run-time library.

A Family of COM objects that provides ultimate set of functionality

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 etc.).

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 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 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 a developer can build SMPT,PO3/IMAP components 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 and later and with Windows CE 3.0/CE.NET 4.0 and later (including Pocket PC).

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 - Implements 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. Depends only on the AXPack1 core (e.g. you need to have installed the both DLL-s if SQLite COM is to be used). 

As it is seen above the AXPack1 family uses the AXPack1 core as a kernel and all the other members of the family need it in order to work properly. However none of them depends on anything outside (unless otherwise specified). 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 size of the entire family is about 600k (unpacked - installed). 

The AXPack1 core 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 the functionality of popular components from 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) 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) 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.

What's new

(the changes from the last year only).

Version (February 2005):
- 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.

Version 2.4.2 (September  2004). 
- COMSleeper, Event, Mutex and Semaphore objects have been added to aid muti-threaded and networking (see NetStreams) programming.

Version 2.4 (June  2004)
 - COMScriptThread - Easy and cross-platform compatible way to run script in background thread(s)
 - Full port to Windows CE/CE.NET
 - SFBinaryData class added to support advanced operations over binary blocks of data
 - UDS tools (ConfigFile class) now support wide strings and unsigned values.
 - 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. 


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.

You want to gain support for the AXPack1 family separately  - contact us. 

System requirements:

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 support. 

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.


Some Highlights

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 application.

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 to files.

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.

Hosting scripts

There are the ScriptManager2 and the ScriptAggregate 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 them.

Universal collections/dictionaries

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 application needs.

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 setup program.

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.

Components in the pack 

The list is in alphabetical order. See the notes description after the list.

Class Reference Information and articles Notes
COMApartment Reference, Creation CBF
COMThread Reference,
(UDS Manager)
See Config, INI files and registry CBF
CustomLock Reference,
IniFile* Reference See Config, INI files and registry CBF
NodeInfo Reference P
Pack1Creator Reference,
ScriptAggregate Reference CBF
ScriptManager2 Reference See Hosting active scripts CBF
SFBinaryData Reference, Creation CBF
SFDirStorage Reference,
SFDrive Reference, Creation CBFP
SFField Reference, Creation CBFP
SFFileStream Reference, Creation CBFP
SFFilter Reference, Creation CBFP
SFInfo Reference P
SFMain** Reference, Creation See storages and files CBF
SFRecord Reference, Creation CBF
SFShellLink*** Reference, Creation CAF
SFStorage Reference, Creation See storages and files CBFP
SFStream Reference, Creation See storages and files CBFP
TypeConvertor Reference, Creation CBF
UtilStringList Reference,
VarDictionary Reference,
VaryDisp Reference,
VaryDispCreator Reference,
VaryDispCtx Reference P
COMScriptThread Reference,
COMSleeper     CF
Event     CF
Mutex     CF
Semaphore     CF
StringUtilities     CBF
SQLite COM See its page
NetStreams See its page

* - 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 little.

Copyright newObjects (ZmeY soft) 2001