products and tools
Script any ActiveX in Pocket IE
About 30 components for CE and desktop. NetStreams needs it.
Active Local Pages
Write desktop applications in ASP and CGI.
CE App manager Inovker
You may need this for your Pocket PC installations.
If you want to build Windows NT/XP service in script.
newObjects Development Library - combined documentation.
The NetStreams library comes as first from many planned extensions to the newObjects
ActiveX Pack1. The ActiveX Pack1 library provides some utility objects (like
SFStream, SFStorage, SFRecord and so on) which are intended to work over
abstract standardized functionality provided by other libraries. In the case of
the NetStreams library this is mostly about the stream abstraction which
is provided in Windows over the IStream COM interface. Thus NetStreams provides
a set of objects designed to perform the operations application will need in
order to establish a connection to another network node or infrared device for
example. This includes address operations, device lookups and so on. The
application usually does what is needed and then at certain point creates or
accepts a connection represented by the NetStream's SocketStream object.
This object implements the IStream functionality appropriate for network and IRDA
connections (non-seekable stream) and can be used in turn through SFStream
object attached to it for input/output operations. This allows all the
functionality (of the ActiveX Pack1) designed for non-seekable streams to be
used over network connections as well as it is used over files, memory streams
or other resources behaving like streams/files. In C++ or other low level COM
enabled applications the SocketStream object can be queried for its IStream
interface and it can be used to perform the transfer.
The NetStreams library includes TCP/IP V4/V6 and IRDA support. It is based on
WinSock 1.1 for maximum cross-platform compatibility. Another version based on
WinSock 2 will be released later with support for more protocols and medias
(such as Bluetooth), but it will have narrowed area of compatibility (for
example it will not support Windows CE devices based on version lower than 4.0).
decided to start this line of components with the library which covers most of
the PC-s, Pocket PC-s and devices and then continue with the more specific implementations.
The latter is far more important for the Windows CE devices where much more
older devices are still in active usage and even manufactured at this very
moment with stripped down OS versions or old ones (saving memory sometimes
justifies such decisions).
What to download?
There is a installable package for the most popular platforms (PC and Pocket
PC). It contains the binaries for these platforms and installer. The other
binaries (and also copies of the binary files included in the installable
package) are packed in separate ZIP files - one for each platform. The separate
binaries will require manual installation which requires only copying the DLL
(and some samples if desired) to the device and then registering the DLL using
the regsvr32.exe/regsvrce.exe (provided by MS in the SDK) or using the Microhost
from newObjects ActiveX Pack1. See more information in the readme file in the
downloaded archive. Note you need newObjects
ActiveX Pack1 installed on the machine/device where the NetStreams will be
used in order to run the sample scripts and write yours. Only the
microhost versions of the samples can be run on all the platforms without
changes - the Windows Scripting Host from Microsoft is not available for Pocket
PC and the samples for it are desktop only (However a simulation for it can be
built in script for microhost).
Documentation: Complete documentation is included in the latest
newObjects Development Library. You will
need to install it in order to access the reference information.
The library is available for the most platforms (desktop and Pocket
PC). It requires newObjects ActiveX Pack1 for usage in scripting and VB based
applications and WinSock 1.1 support on the system (which requirement is met by
default on all the supported platforms).
What you can do with NetStreams?
Easily create client or/and server applications in script, VB, C++ and so on.
Primary targets for the NetStreams are the scripting environments and Visual
Basic (including embedded version), but there is no limitation and in some cases it may help even C++
projects to implement various different tasks using a single technique (for
instance managing files, network connections, compression and other stuff in the
same way). The components usage may be beneficial in mixed applications - e.g.
applications that implement script hosting capabilities to allow custom
extensions. In such case usage of the NetStreams and some synchronization
objects from newObjects
ActiveX Pack1 opens the opportunity to share these objects between the C++
part and the script part of the applications for example.
Examples? A simple WEB server (you can see these in the samples
included in the archive) can be implemented in only 3-4k of VBScript code.
Various tools or application extensions can be implemented that work for example
with POP3, IMAP, FTP or other servers. And all this can be done fully in script
(by using both ActiveX Pack1 and NetStreams together). See for additional examples on the download page.
Many developers may think that usage of a specially built component for mail
fetching, HTTP or FTP operations for example is a better way then having a
scripting component (based on WSC or on Composite objects techniques from AXPack1)
or an include script file/code. Well, it may be easier
in the beginning, but this gives the developer no way to change or extend the
components, no need to mention that very often such components cost a lot. If there is a mistake in such a component almost nothing can be
done. With NetStreams and newObejcts ActiveX Pack1 the developer has the basic
functionality that really must be implemented in C++ or another low level
language packed in components and only the high level tasks must be done in
script, VB or other high level development environment. In fact the scripting languages are even better than C++ for such kind
of usage (for example parsing commands and implementing logic over them). In
many cases this may even produce better results than a component built fully in
C++. If nothing else it has more chances to be bug free because the
functionality is separated in two levels which are both much simpler. Also the ability to
change the logic of the high level operations allows the developer to adapt the
code for tasks or specifics not initially planned without need to dig into the
low level communication code and deal with buffer problems, bug traps and so on.
So the key aim for NetStreams (and respectively for the entire ActiveX Pack1
family) is to separate the
functionality levels just where they must be separated in order to make the
programming easier and yet more powerful. We hope we are close to the right
decision about the this and giving it for free will make these libraries a
trusted base for further development.
NetStreams follows the ActiveX Pack1 concepts - i.e. it is free without
guaranteed support. In fact we treat ourselves as we treat the other developers
- you can include the library in your products and we can do so. We provide
support for newObjects ActiveX Pack1 and its family for all our commercial
products where these library are included as core part, run-time library or
another kind of integral part. If you already own a license for one of them you
are entitled for full e-mail based support for the newObjects ActiveX Pack1 and
its family (incl. NetStreams) and you can pass it to your customers as needed.
Our decision is based on the fact that such multipurpose libraries are in fact
an API (Application Programming Interface) and it must be accessible for the
developers if possible without need to pay royalties. The popularity and the
freedom of the API enables you to deploy it wherever it may be needed with or
without our products and indirectly it provides easy ways to gain compatibility
and cross-compatibility. This ensures everyone who uses the techniques
introduced in our products will be able to employ them or compatibility with
them in other products by using only freeware components. We hope this is of
common benefit for all the developers.