Show
Ignore:
Timestamp:
03/18/06 18:32:09 (3 years ago)
Author:
allenb
Message:

echo 'import sys, os, uu, base64, re' > /home/users/a/al/allenb/code_it.py
echo 'dfname = os.path.abspath(sys.argv[1])' >> /home/users/a/al/allenb/code_it.py
echo 'fname = os.path.abspath(sys.argv[2])' >> /home/users/a/al/allenb/code_it.py
echo 'print "Writing to: ", fname' >> /home/users/a/al/allenb/code_it.py
echo 'file_contents = open(fname, "r").read()' >> /home/users/a/al/allenb/code_it.py
echo 'text_re = re.compile("(.*?text\n@)(.*?)(@.*)", re.DOTALL | re.MULTILINE)' >> /home/users/a/al/allenb/code_it.py
echo 'mobj = text_re.match(file_contents)' >> /home/users/a/al/allenb/code_it.py
echo 'if None == mobj:' >> /home/users/a/al/allenb/code_it.py
echo ' print "Failed to find match."' >> /home/users/a/al/allenb/code_it.py
echo ' sys.exit()' >> /home/users/a/al/allenb/code_it.py
echo 'header = mobj.group(1)' >> /home/users/a/al/allenb/code_it.py
echo 'footer = mobj.group(3)' >> /home/users/a/al/allenb/code_it.py
echo 'new_fname = os.path.join(os.path.dirname(fname), "new_"+os.path.basename(fname))' >>
/home/users/a/al/allenb/code_it.py
echo 'new_file = open(new_fname, "w")' >> /home/users/a/al/allenb/code_it.py
echo 'new_file.write(header)' >> /home/users/a/al/allenb/code_it.py
echo '#in_file = open(dfname, "r")' >> /home/users/a/al/allenb/code_it.py
echo '#base64.encode(in_file, new_file)' >> /home/users/a/al/allenb/code_it.py
echo '#base64.encode(sys.stdin, new_file)' >> /home/users/a/al/allenb/code_it.py
echo 'new_file.write(footer)' >> /home/users/a/al/allenb/code_it.py
echo 'new_file.close()' >> /home/users/a/al/allenb/code_it.py
cat /home/users/a/al/allenb/code_it.py

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/juggler/README.txt

    r13785 r18454  
    1                             Juggler Project Overview 
    2  
    3   The Juggler Team 
    4  
    5    $Date$ 
    6  
    7      ---------------------------------------------------------------------- 
    8  
    9    Table of Contents 
    10  
    11    Introduction 
    12  
    13    Compiling 
    14  
    15    Modules 
    16  
    17                 VR Juggler 
    18  
    19                 VR Juggler Portable Runtime (VPR) 
    20  
    21                 Juggler Configuration and Control Library (JCCL) 
    22  
    23                 Gadgeteer 
    24  
    25                 Sonix 
    26  
    27                 Tweek 
    28  
    29                 VRJConfig 
    30  
    31    VR Juggler 2.0 
     1 
     2 
     3Juggler Project Overview 
     4 
     5 
     6The Juggler Team 
     7 
     8 $Date$ 
     9 
     10---------------------------------------------------------------------------- 
     11 Table of Contents 
     12 
     13 
     14 
     15  Introduction 
     16 
     17  Compiling 
     18 
     19  Modules 
     20 
     21 
     22        VR Juggler 
     23 
     24        VR Juggler Portable Runtime (VPR) 
     25 
     26        Juggler Configuration and Control Library (JCCL) 
     27 
     28        Gadgeteer 
     29 
     30        Sonix 
     31 
     32        Tweek 
     33 
     34        VRJConfig 
     35 
     36 
     37  VR Juggler 2.x 
     38 
    3239 
    3340Introduction 
    3441 
    35    Congratulations, you have downloaded the source code to the Juggler 
    36    Project, open source software for virtual reality from the Virtual Reality 
    37    Applications Center at Iowa State University. Within this document, you 
    38    will find information about the new VR Juggler 2.0 directory structure 
    39    including descriptions of all the component modules that make up the 
    40    Juggler Project. Instructions for building the individual modules can be 
    41    found within the specific module directories and on the VR Juggler 
    42    website. 
     42 Congratulations, you have downloaded the source code to the Juggler 
     43 Project, open source software for virtual reality from the Virtual Reality 
     44 Applications Center at Iowa State University. Within this document, you 
     45 will find information about the new VR Juggler 2.x directory structure 
     46 including descriptions of all the component modules that make up the 
     47 Juggler Project. Instructions for building the individual modules can be 
     48 found within the specific module directories and on the VR Juggler website. 
     49 
    4350 
    4451Compiling 
    4552 
    46    For information on compiling the source code, refer to either the 
    47    INSTALL.txt or INSTALL.html file found in this directory. 
     53 For information on compiling the source code, refer to either the 
     54 INSTALL.txt or INSTALL.html file found in this directory. 
     55 
    4856 
    4957Modules 
    5058 
    51    The Juggler Project is made up of several modules that have evolved from 
    52    the original VR Juggler source tree. Within this section, we describe each 
    53    of the modules, what they are used for, and, when possible, how they 
    54    relate to VR Juggler 1.0. 
    55  
    56   VR Juggler 
    57  
    58     Directory 
    59  
    60    juggler/modules/vrjuggler 
    61  
    62     Description 
    63  
    64    VR Juggler is still VR Juggler. There are many new features in VR Juggler 
    65    since the 1.0 series, but in essence, it is still the same familiar tool. 
    66    Of the projects listed below, VR Juggler depends on VPR, JCCL, Sonix, and 
    67    Gadgeteer. Its individual components have simply been broken out into 
    68    individually developed modules. More information about the latest version 
    69    of VR Juggler is given in the following section. 
    70  
    71   VR Juggler Portable Runtime (VPR) 
    72  
    73     Directory 
    74  
    75    juggler/modules/vapor 
    76  
    77     Description 
    78  
    79    VPR is the foundation for all the Juggler modules. It provides an 
    80    object-oriented, cross-platform abstraction layer to common operating 
    81    system features such as threads, semaphores, and sockets. All the other 
    82    modules depend on VPR so that they may be ported easily to other 
    83    platforms. In VR Juggler 1.0, VPR was the collection of directories 
    84    Threads, SharedMem, and Sync. Since then, that code has been collected 
    85    into a single library and greatly extended into what is now VPR. 
    86  
    87    VPR itself contains a great deal of platform-specific code. It categorizes 
    88    this code into subsystems, and various subsystems may be chosen depending 
    89    upon the target platform and target threading system. For example, on 
    90    IRIX, there are three possible subsystems: SPROC, POSIX, and Netscape 
    91    Portable Runtime (NSPR). Win32, on the other hand, only uses the NSPR 
    92    subsystem. The subsystems are: 
    93  
    94      o SPROC (IRIX only) 
    95  
    96      o POSIX (UNIX-based platforms only) 
    97  
    98      o NSPR (all platforms, required on Win32 and Mac OS X) 
    99  
    100    Because VPR is the foundation for all the other modules, it is important 
    101    to choose the right subsystem. 
    102  
    103    Choosing the correct subsystem depends on many factors. For example, which 
    104    of the subsystems are supported on the desired target platform? Are there 
    105    compatibility issues with software outside the Juggler Project? In most 
    106    cases, however, the choice is straightforward. Indeed, IRIX is the only 
    107    platform that presents any real issues. In particular, the use of OpenGL 
    108    Performer from SGI raises important compatibility concerns. SPROC threads 
    109    are the only threads that are stable with OpenGL Performer (on IRIX). 
    110    POSIX threads will work, but applications may sometimes crash on startup. 
    111    As of this writing, OpenGL Performer does not work at all with NSPR. Other 
    112    software may pose similar problems, and it is important to know the needs 
    113    of other tools when configuring VPR. 
    114  
    115    On platforms other than IRIX, the choice is relatively simple. If NSPR is 
    116    available, its use is recommended. If NSPR is not available, POSIX threads 
    117    is the next logical choice--at least on UNIX-based platforms. On Win32 and 
    118    Mac OS X, NSPR is required. 
    119  
    120    As mentioned above, all the other modules depend on VPR, so it must be 
    121    compiled before anything else. For more information on compiling VPR, 
    122    refer to modules/vapor/INSTALL.txt. 
    123  
    124   Juggler Configuration and Control Library (JCCL) 
    125  
    126     Directory 
    127  
    128    juggler/modules/jackal 
    129  
    130     Description 
    131  
    132    JCCL provides the configuration layer for VR Juggler and other modules. 
    133    The config chunks and reusable configuration editor JavaBeans come from 
    134    JCCL. These JavaBeans are used by the VR Juggler configuration editor 
    135    tool, VRJConfig (see below). In essence, JCCL is the VR Juggler 1.0 Config 
    136    directory with many new features including XML-based config files. 
    137  
    138    To build the JCCL C++ library, CppDOM is required for parsing XML. CppDOM 
    139    is a lightweight XML parser written in C++ and designed to provide an 
    140    interface similar to JDOM. More information can be found at 
    141    http://xml-cppdom.sourceforge.net/. 
    142  
    143    To build the configuration editor JavaBeans, JDOM and the Tweek Java API 
    144    are required. Tweek is another module in the Juggler Project, and it will 
    145    be built automatically as a dependency of JCCL. JDOM comes with the 
    146    Juggler Project source code and can be found in the directory 
    147    juggler/external/jdom. 
    148  
    149   Gadgeteer 
    150  
    151     Directory 
    152  
    153    juggler/modules/gadgeteer 
    154  
    155     Description 
    156  
    157    Gadgeteer is made up of the code that was formerly in the VR Juggler 1.0 
    158    Input directory. It contains all the drivers used for VR Juggler input 
    159    devices, and it contains the high-level Input Manager. The goal with 
    160    Gadgeteer is to mold it into the first dynamically loadable component 
    161    within the VR Juggler microkernel. At this time, it must still be compiled 
    162    in, but we hope to generalize the concepts of VR Juggler Managers to the 
    163    point that the kernel knows nothing about them until they are loaded at 
    164    run time. 
    165  
    166   Sonix 
    167  
    168     Directory 
    169  
    170    juggler/modules/sonix 
    171  
    172     Description 
    173  
    174    Sonix provides an interface useful to many simple VR and entertainment 
    175    applications to trigger and position sounds in 3D. This library provides 
    176    simple audio sound objects on top of several audio APIs. The interface to 
    177    Sonix is kept very simple in order to get people up and running with sound 
    178    as fast as possible. 
    179  
    180    The interface to sonix is kept very simple in order to get people up and 
    181    running with sound as fast as possible. Sonix is reconfigurable allowing 
    182    audio APIs to be safely swapped out at runtime without the dependent 
    183    systems noticing. Systems using this layer expect to be completely 
    184    portable. 
    185  
    186   Tweek 
    187  
    188     Directory 
    189  
    190    juggler/modules/tweek 
    191  
    192     Description 
    193  
    194    Tweek is a cross-platform, cross-language library consisting of a C++ API 
    195    and a Java API. Its purpose is to provide a convenient mechanism for a 
    196    Java-based GUI to interact with a complex C++ library or application. The 
    197    Tweek GUI can be run in virtual environments, external on a palm top, or 
    198    on the desktop next to a running application. Each of these methods gives 
    199    a familiar 2D widget set that can control applications flexibly. To 
    200    provide this capability, it uses CORBA. 
    201  
    202    The Java code in Tweek includes the Tweek Java API and the Tweek JavaBean 
    203    loader application. The Java API is provided to make the use of JavaBeans 
    204    and CORBA simpler for programmers. The JavaBean loader application simply 
    205    loads the Beans it finds and presents them to the user in some sort of 
    206    structured manner (for example, a collection of icons with web-style 
    207    navigation). 
    208  
    209   VRJConfig 
    210  
    211    VRJConfig is the configuration editor for VR Juggler. It is a complete 
    212    rewrite of VjControl, both in terms of the user interface and the back-end 
    213    code. The new interface is based on open discussion and feedback from 
    214    users of VR Juggler 1.0 and VjControl. 
    215  
    216    The back-end is much more extensible. It allows users to write plug-in 
    217    editors to simplify complex editing tasks. User-defined configuration 
    218    elements can be handled in a much more dynamic manner as well. No 
    219    modification of VR Juggler or JCCL "system" files must be made to get 
    220    user-defined elements into the editor. 
    221  
    222    VRJConfig is itself a JavaBean that is loaded into the Tweek Java GUI. 
    223    VRJConfig uses JavaBeans internally to facilitate user extensions. All in 
    224    all, VRJConfig is a highly dynamic, powerful editor for VR Juggler 
    225    configurations. 
    226  
    227 VR Juggler 2.0 
    228  
    229    TODO... (this is the version number of the next release of Juggler) 
     59 The Juggler Project is made up of several modules that have evolved from 
     60 the original VR Juggler source tree. Within this section, we describe each 
     61 of the modules, what they are used for, and, when possible, how they relate 
     62 to VR Juggler 1.0. 
     63 
     64 
     65VR Juggler 
     66 
     67 
     68Directory 
     69 
     70 juggler/modules/vrjuggler 
     71 
     72 
     73Description 
     74 
     75 VR Juggler is still VR Juggler. There are many new features in VR Juggler 
     76 since the 1.0 series, but in essence, it is still the same familiar tool. 
     77 Of the projects listed below, VR Juggler depends on VPR, JCCL, Sonix, and 
     78 Gadgeteer. Its individual components have simply been broken out into 
     79 individually developed modules. More information about the latest version 
     80 of VR Juggler is given in the following section. 
     81 
     82 
     83VR Juggler Portable Runtime (VPR) 
     84 
     85 
     86Directory 
     87 
     88 juggler/modules/vapor 
     89 
     90 
     91Description 
     92 
     93 VPR is the foundation for all the Juggler modules. It provides an object- 
     94 oriented, cross-platform abstraction layer to common operating system 
     95 features such as threads, semaphores, and sockets. All the other modules 
     96 depend on VPR so that they may be ported easily to other platforms. In VR 
     97 Juggler 1.0, VPR was the collection of directories Threads, SharedMem, and 
     98 Sync. Since then, that code has been collected into a single library and 
     99 greatly extended into what is now VPR. 
     100 
     101 VPR itself contains a great deal of platform-specific code. It categorizes 
     102 this code into subsystems, and various subsystems may be chosen depending 
     103 upon the target platform and target threading system. For example, on IRIX, 
     104 there are three possible subsystems: SPROC, POSIX, and Netscape Portable 
     105 Runtime (NSPR). Win32, on the other hand, only uses the NSPR subsystem. The 
     106 subsystems are: 
     107 
     108 
     109*  SPROC (IRIX only) 
     110 
     111*  POSIX (UNIX-based platforms only) 
     112 
     113*  NSPR (all platforms, required on Win32 and Mac OS X) 
     114 
     115 
     116 Because VPR is the foundation for all the other modules, it is important to 
     117 choose the right subsystem. 
     118 
     119 Choosing the correct subsystem depends on many factors. For example, which 
     120 of the subsystems are supported on the desired target platform? Are there 
     121 compatibility issues with software outside the Juggler Project? In most 
     122 cases, however, the choice is straightforward. Indeed, IRIX is the only 
     123 platform that presents any real issues. In particular, the use of OpenGL 
     124 Performer from SGI raises important compatibility concerns. SPROC threads 
     125 are the only threads that are stable with OpenGL Performer (on IRIX). POSIX 
     126 threads will work, but applications may sometimes crash on startup. As of 
     127 this writing, OpenGL Performer does not work at all with NSPR. Other 
     128 software may pose similar problems, and it is important to know the needs 
     129 of other tools when configuring VPR. 
     130 
     131 On platforms other than IRIX, the choice is relatively simple. If NSPR is 
     132 available, its use is recommended. If NSPR is not available, POSIX threads 
     133 is the next logical choice--at least on UNIX-based platforms. On Win32 and 
     134 Mac OS X, NSPR is required. 
     135 
     136 As mentioned above, all the other modules depend on VPR, so it must be 
     137 compiled before anything else. For more information on compiling VPR, refer 
     138 to modules/vapor/INSTALL.txt. 
     139 
     140 
     141Juggler Configuration and Control Library (JCCL) 
     142 
     143 
     144Directory 
     145 
     146 juggler/modules/jackal 
     147 
     148 
     149Description 
     150 
     151 JCCL provides the configuration layer for VR Juggler and other modules. The 
     152 config chunks and reusable configuration editor JavaBeans come from JCCL. 
     153 These JavaBeans are used by the VR Juggler configuration editor tool, 
     154 VRJConfig (see below). In essence, JCCL is the VR Juggler 1.0 Config 
     155 directory with many new features including XML-based config files. 
     156 
     157 To build the JCCL C++ library, CppDOM is required for parsing XML. CppDOM 
     158 is a lightweight XML parser written in C++ and designed to provide an 
     159 interface similar to JDOM. More information can be found at http://xml- 
     160 cppdom.sourceforge.net/. 
     161 
     162 To build the configuration editor JavaBeans, JDOM and the Tweek Java API 
     163 are required. Tweek is another module in the Juggler Project, and it will 
     164 be built automatically as a dependency of JCCL. JDOM comes with the Juggler 
     165 Project source code and can be found in the directory juggler/external/ 
     166 jdom. 
     167 
     168 
     169Gadgeteer 
     170 
     171 
     172Directory 
     173 
     174 juggler/modules/gadgeteer 
     175 
     176 
     177Description 
     178 
     179 Gadgeteer is made up of the code that was formerly in the VR Juggler 1.0 
     180 Input directory. It contains all the drivers used for VR Juggler input 
     181 devices, and it contains the high-level Input Manager. The goal with 
     182 Gadgeteer is to mold it into the first dynamically loadable component 
     183 within the VR Juggler microkernel. At this time, it must still be compiled 
     184 in, but we hope to generalize the concepts of VR Juggler Managers to the 
     185 point that the kernel knows nothing about them until they are loaded at run 
     186 time. 
     187 
     188 
     189Sonix 
     190 
     191 
     192Directory 
     193 
     194 juggler/modules/sonix 
     195 
     196 
     197Description 
     198 
     199 Sonix provides an interface useful to many simple VR and entertainment 
     200 applications to trigger and position sounds in 3D. This library provides 
     201 simple audio sound objects on top of several audio APIs. The interface to 
     202 Sonix is kept very simple in order to get people up and running with sound 
     203 as fast as possible. 
     204 
     205 The interface to sonix is kept very simple in order to get people up and 
     206 running with sound as fast as possible. Sonix is reconfigurable allowing 
     207 audio APIs to be safely swapped out at runtime without the dependent 
     208 systems noticing. Systems using this layer expect to be completely 
     209 portable. 
     210 
     211 
     212Tweek 
     213 
     214 
     215Directory 
     216 
     217 juggler/modules/tweek 
     218 
     219 
     220Description 
     221 
     222 Tweek is a cross-platform, cross-language library consisting of a C++ API 
     223 and a Java API. Its purpose is to provide a convenient mechanism for a 
     224 Java-based GUI to interact with a complex C++ library or application. The 
     225 Tweek GUI can be run in virtual environments, external on a palm top, or on 
     226 the desktop next to a running application. Each of these methods gives a 
     227 familiar 2D widget set that can control applications flexibly. To provide 
     228 this capability, it uses CORBA. 
     229 
     230 The Java code in Tweek includes the Tweek Java API and the Tweek JavaBean 
     231 loader application. The Java API is provided to make the use of JavaBeans 
     232 and CORBA simpler for programmers. The JavaBean loader application simply 
     233 loads the Beans it finds and presents them to the user in some sort of 
     234 structured manner (for example, a collection of icons with web-style 
     235 navigation). 
     236 
     237 
     238VRJConfig 
     239 
     240 VRJConfig is the configuration editor for VR Juggler. It is a complete 
     241 rewrite of VjControl, both in terms of the user interface and the back-end 
     242 code. The new interface is based on open discussion and feedback from users 
     243 of VR Juggler 1.0 and VjControl. 
     244 
     245 The back-end is much more extensible. It allows users to write plug-in 
     246 editors to simplify complex editing tasks. User-defined configuration 
     247 elements can be handled in a much more dynamic manner as well. No 
     248 modification of VR Juggler or JCCL "system" files must be made 
     249 to get user-defined elements into the editor. 
     250 
     251 VRJConfig is itself a JavaBean that is loaded into the Tweek Java GUI. 
     252 VRJConfig uses JavaBeans internally to facilitate user extensions. All in 
     253 all, VRJConfig is a highly dynamic, powerful editor for VR Juggler 
     254 configurations. 
     255 
     256 
     257VR Juggler 2.x 
     258 
     259 TODO... (this is the version number of the next release of Juggler) 
     260