This describes an older ST-Developer release (2007). You can find the details for the latest release here

What's new in ST-Developer v12

ST-Developer v12 Supported Platforms

Operating System Architecture Supported C++ Compilers
Windows 2000/XP/Vista Intel x86 Visual C++ 8.0 (Visual Studio 2005) and Visual C++ 6.0 with the /MT and /MD options.
Windows 64bit Intel x64
AMD64
EM64T		 Visual C++ 8.0 (Visual Studio 2005) with the /MT and /MD options
MacOS X 10.4
on PowerPC (Tiger)		 PowerPC GCC 3.3 and GCC 4.0
(Xcode 2.0)
MacOS X 10.4
on Intel (Tiger)		 Intel x86 GCC 4.0 (Xcode 2.3)
MacOS X 10.5 64bit
on Intel (Leopard)		 Intel 64bit GCC 4.0 (Xcode 2.3)
Linux
LSB 2.x or 3.x distros, RedHat 9, RHEL 3/4/5, SuSE 9.x and up, and others		 Intel x86 GCC 3.2/3.3 and GCC 3.4/4.x
Linux 64bit
LSB 3.x distros.		 Intel 64bit
AMD64
EM64T		 GCC 3.4/4.x
Hewlett Packard
HP-UX v11		 PA-RISC HP ANSI C++
Hewlett Packard
HP-UX v11		 Itanium HP ANSI C++
Silicon Graphics
IRIX v6.x		 MIPS SGI C++ default and -n32
Sun Solaris v7 or better SPARC Forte 6, Sun Studio v7-11 (with and w/o -PIC -mt), GCC 3.4/4.x
Sun Solaris v10 Intel x86 Sun Studio v11 64bit default and with -PIC -mt

Supported Application Protocols

ST-Developer v12 ships with a wide selection of C++ and Java class libraries, HTML-documented schemas, and usage guides. In this release we have added or updated support for AP203 edition 2, AP224 edition 3, AP219, AP221, AP236, AP238, AP239, AP240, and IFC 2x3.

You can start programming immediately, with out-of-the-box support for nineteen STEP Application Protocols, the CIMsteel Integration Standard (CIS/2) as well as two versions of the Industry Foundation Classes (IFC). If we missed your favorite, you can use EXPRESS compiler and other ST-Developer tools to install them yourself! The electronic manuals have quick links to each of the following:

Part 28 XML Support

ST-Developer C++ applications can now read and write STEP Part 28 Edition 2 XML exchange files (ISO 10303-28:2007). All of the sample programs have been extended to include this support. To enable this functionality in your own application, simply link against the p28e2 library, include the rose_p28.h file, then call rose_p28_init() at the start of your program to register the XML reader and writer.

From then on, your application will automatically recognize STEP Part 28 XML files when reading. By default, new files are written as Part 21 but you can switch to Part 28 XML by calling RoseDesign::format() with "p28" or p28-raw" strings.

    RoseDesign * d;
    d-> format ("p21");
    d-> save()  // write as Part 21 text
     
    d-> format ("p28");
    d-> save()  // write compressed Part 28 XML
     
    d-> format ("p28-raw");
    d-> save()  // write raw Part 28 XML

When the "p28" format is specified, the XML will be zip compressed to reduce size, and the file will be given the ".p28" extension if none is specified. If you run unzip on the result, you will see a single file called iso_10303_28.xml, which contains the raw XML.

With the "p28-raw" format is specified, the XML will be written without any compression, and the file will be given the ".xml" extension if none is specified.

The small Part 28 XML file below shows some AP238 instance data with an axis placement, cartesian point, and two directions. The specifics of the Part 28 encoding are discussed in Chapter 2 of the ROSE Library Reference Manual 

    <?xml version="1.0"?>
    <iso_10303_28_terse
        xmlns="urn:oid:1.0.10303.238.1.0.1"
        xmlns:exp="urn:oid:1.0.10303.28.2.1.1"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        schema="integrated_cnc_schema">
     
       <exp:header>
         <exp:name>dataset</exp:name>
         <exp:preprocessor_version>stepnc writer</exp:preprocessor_version>
       </exp:header>
     
      <!-- instance data -->
      <Axis2_placement_3d id="id1" Name="" Location="id2" Axis="id3"
        Ref_direction="id4"/>
      <Cartesian_point id="id2" Name="loc" Coordinates="3.5 -3.5 -4.16875"/>
      <Direction id="id3" Name="Z direction" Direction_ratios="0 0 1"/>
      <Direction id="id4" Name="X direction" Direction_ratios="1 0 0"/>
    </iso_10303_28_terse>

Sample Part 28 Program

The program below reads a STEP file (Part 21 or Part 28) and writes it back out to a different name and format. Including rose_p28.h and calling rose_p28_init() forces the program to recognize Part 28 as well as Part 21.

    #include <rose.h>
    #include <rose_p28.h>  // bring in Part 28 support
     
    void main(int argc, char ** argv)
    {
        rose_p28_init();   // call at start of program
        if (argc != 4) {
            printf ("usage: format <p21|p28|p28-raw> <in-name> <out-name>\n");
            return;
        }
     
        const char * fmt = argv[1];
        const char * in_name = argv[2];
        const char * out_name = argv[3];
     
        RoseDesign * d = ROSE.findDesign(in_name);
        if (d) {
            d->path (out_name);
            d->format(fmt);
            d->save();
        }
        else printf ("ERROR: Could not read design '%s'\n", in_name);
    }

To build this sample program, compile normally, but add the p28e2 library to the link line as shown in the following commands:

    On UNIX and MacOS
    % CC -I$ROSE_INCLUDE format.cxx -L$ROSE_LIB -lrose -lp28e2
     
    On Windows
    > cl /I"%ROSE_INCLUDE%" format.cxx /LIBPATH:"%ROSE_LIB%" rose.lib p28e2.lib

Part 28 XML Browser

ST-Developer makes it simple to examine STEP XML files in any web browser with the Part 28 to HTML conversion tool. On Windows, this tool integrates into the Explorer so you can open a file in a web browser by simply right clicking on it and selecting "Browse P28 XML" as shown below.

Browse P28 XML

On other platforms just run the p28html command-line tool to prepare HTML for your browser as shown below:

    % p28html datafile.p28    ==> writes datafile.html in the current dir
    % firefox datafile.html

All of the entity instances are linked, so you can move through the file simply by clicking on references.

STEP P28 XML in a Web Browser

As shown in the figure above, clicking on any instance in the file pops up a window showing all attributes, their types and their values, even unset attributes. Required attributes are shown in bold, while optional attributes are italicized. You will also see a complete USEDIN() listing of objects that refer to the instance, and can quickly jump to any of them.

Some simple validation checks are done and objects that have missing required attributes are hilighted in red on the main page, along with each offending attribute in the attributes popup window.

To make it easier for others to examine the XML data in the new Part 28 format, the p28view and p28html executables are not locked, so that you can distribute them for non-commercial use to any third party who might be interested in the new data.

ST-Developer Message Window

ST-Developer for Windows now contains the rose_logwin extension to simplify the display of status and debugging information from GUI applications. The extension creates a window to hold a cumulative log of status messages issued by the ROSE library or your application. The messages can be cleared, copied, and saved, and the window can be dismissed when not needed.

The the rose_logwin extension provides its own Windows message pump in a dedicated thread, and can be used by any type of ROSE C++ application: MFC, raw Windows API, or even a console application. The screendump below shows the message window and some diagnostic messages from a sample application.

ST-Developer Message Window

To enable this functionality, simply link against the rose_logwin.lib library, include the rose_logwin.h file, then call rose_logwin_init() at the start of your program to register the message window with the ROSE library.

After this call, all ROSE messages are redirected to the window. No other changes are required for your application. Calling rose_logwin_wait() at the end of your program will block until the user dismisses the message box. This gives the user a chance to view the messages, particularly in short-lived programs.

The following example shows how to initialize the message window:

    #include <rose.h>
    #include <rose_logwin.h>
     
    int main (int argc, char ** argv) 
    {
        rose_logwin_init();
        /* your code */
        rose_logwin_wait();
    }

The roselog DLL must be in your path for the log window to appear. It is installed in the ST-Developer bin directory, which should be in your path. If the DLL cannot be found, rose_logwin_init() will return zero and the default error handling used.

If you want to display your own status messages in the window, simply call one of the ROSE error reporting functions:

    ROSE.message ("a status message");  // supressed if ROSE.quiet(1);
    ROSE.warning ("a warning message");
    ROSE.error ("an error message");    // will exit by default

ROSE Library Enhancements

We have added a number of improvements to ROSE to simplify STEP data processing and improve the performance of applications. Consult the ROSE Library Reference Manual for a complete description of these capabilities.

Binary Type Support

Until recently, the EXPRESS "binary" primitive type has never been used by any of the STEP application protocols, but the new AP221 and IFC 2x3 schemas define entities that contain a binary attribute or list of binary values. Previous versions of ST-Developer supported individual values of the binary primitive type but not aggregates of binary.

We have changed the in-memory representation of the EXPRESS "binary" type so that these values are now stored as strings. This simplified use of binary values and allowed us to implement aggregates of binary. The EXPRESS compiler has been updated to generate the new C++ representation, and any existing classes that used binary should be regenerated.

The C++ type used for getting and putting a binary value is RoseBinarySTR and values are stored in the string encoding used by the Part 21 file format. We provide the RoseBinaryObject helper class to handle bit and byte level access to the data.

The example below shows an object with a binary attribute called "binary_att" and puts, gets, and manupulates some binary data. Consult the ROSE Library Reference Manual for a complete description of the RoseBinaryObject class.

    SomeEntity * obj;
     
     
    // Set attribute to hex 0xFFFF
    obj-> binary_att ("0FFFF");  
     
    // print the value back out again
    printf ("Binary Value %s\n", obj-> binary_att());
     
    // use helper class for bit and byte level access
    RoseBinaryObject helper (obj-> binary_att());
     
    helper.putBit (8, 0)        // changes to 0xFFEF
    helper.putByte (1, 0xA7)    // changes to 0xA7EF
    helper.putWord (1, 0x1234)  // resizes to 0x1234A7EF
     
    // Update the attribute to with the modified value
    obj-> binary_att (helper.asString());

Other Library Changes

Changed the STR typedef to RoseSTR to avoid potential conflicts between packages. The old definitions can still be used, but can also be turned off by defining the ROSE_DISABLE_COMPAT_DEFS symbol on the command line.

Added the following convenience functions to RoseAttribute to simplify type testing. There were already tests for string, double, boolean, and other primitive types, but the following functions complete the range of possible types.

    RoseAttribute::isAggregate()
    RoseAttribute::isEntity()
    RoseAttribute::isEnumeration()
    RoseAttribute::isSelect()
    RoseAttribute::isSimple()

Added the rose_is_system_schema() function so that applications can distinguish between system schemas that are used internally by the ROSE library and schemas that represent an application protocol or other public schema. This is useful when deciding which schemas to write in the header of a STEP file. 

    int rose_is_system_schema(RoseDesign *);

Added the RoseEidCursor class to simplify traversing a design in numeric order by the Part 21 file entity identifiers. The following code fragment shows how this can be used:

    RoseDesign * d;
    RoseEidCursor objs (d);
    RoseStructure * obj;
     
    while (obj = objs.next()) {
        // do something
    }

Deprecated Functions

Many of the functions in the RoseInterface object have been deprecated. These functions are simply aliases of RoseDesign functions and will be removed in a future release.

    RoseInterface::addName()
    RoseInterface::addSchema()
    RoseInterface::designName()
    RoseInterface::display()
    RoseInterface::findDomain()
    RoseInterface::findObject()
    RoseInterface::findObjects()
    RoseInterface::format()
    RoseInterface::nameTable()    
    RoseInterface::pnewInstance()
    RoseInterface::removeDesign()
    RoseInterface::removeName()
    RoseInterface::rootObject()
    RoseInterface::saveDesign()
    RoseInterface::saveDesignAs()
    RoseInterface::setDesignName()
    RoseInterface::setFormat()
    RoseInterface::setRootObject()
    RoseInterface::useSchema()

In addition, the following type aliases have been deprecated and will be removed in a future release. The previously deprecated BaseManager alias for RoseManager has been removed.

    STR         ==> use RoseSTR
    ArrayOfSTR  ==> use ArrayOfString
    BagOfSTR    ==> use BagOfString
    ListOfSTR   ==> use ListOfString
    SetOfSTR    ==> use SetOfString
    DictionaryOfSTR  ==> use DictionaryOfString
     
Copyright © 1991-2024 STEP Tools Inc. All Rights Reserved.