c trial software / shareware for linux

Zoidcom is a network library, UDP based networking library providing features for automatic replication of gameobjects and synchronization of their states over a network connection in a highly bandwidth efficient manner.
This is achieved by multiplexing and demultiplexing object information from and into bitstreams, which make it easily possible to avoid sending redundant data. Bools only take one single bit, integers and floats are stripped down to as many bits as needed.
A great deal of the tedious work that appears when attempting to develop an efficient network protocol is handled by Zoidcom, e.g. deciding when to send which data to which client, how to get it efficiently and reliably through the line, what to do when data gets lost and a lot more.
Main features:
Easy And Flexible
- simple and straightforward C++ API
- no additional build steps needed
- custom memory management
Connectivity
- fast, UDP based networking protocol using bitstreams - very little control data overhead
- NAT friendly - the whole system can operate on one single UDP port
- maximize the header/payload ratio by sending fewer big packets instead of lots of small ones
- dynamic bandwidth distribution & limitation
Advanced Object Replication - Make best use of the available bandwidth
- delegate ownership of objects to arbitrary clients (e.g. for AI processing or player control)
- adjustable object priorities
- adjustable object relevance per client (e.g. field of view)
- object subscription groups (e.g. for different, distinct game areas)
Object Events - Easy as communication can become
- direct communication between authority and (groups of) replicated object(s)
- no need to pass around object messages throughout your whole application
- full control - intercept object events for debugging, monitoring and cheatprotection
- object based file transfer - transmit files easily in the background of a running session - the higher the objects priority, the faster the transfer will complete
Automatic Object State Synchronization
- synchronize bools, ints, floats and strings
- interpolate ints and floats
- only send data that really changed
- full control
- minimum and maximum update frequency for each single data item
- intercept, manipulate and prevent data updates for debugging, monitoring and cheatprotection
- efficient
- adjust the amount of relevant bits per replicated item
- default values to avoid transmission of redundant data
- interpolation with adjustable interpolation strength or totally custom interpolation
Useful Utilities
- asynchronous hostname resolution
- accurate ping measurement
- LAN session discovery
- quickrequest feature - talk to a remote host without creating a full connection
- connection grouping
- extensive connection statistics
Enhancements:
- This release adds a method for defining the default relevance of an object to all connections.

PureBasic is a new "high level" programming language based on established BASIC rules. PureBasic is similar to any other BASIC compiler you may have used, whether for the Amiga or PC. Learning PureBasic is very easy! PureBasic has been created for the beginner and expert alike. Compilation time is really fast. We have put a lot of effort into its realization to produce a fast, reliable and system friendly language.
The syntax is simple but the possibilities are endless with PureBasics advanced features, such as pointers, structures, procedures, dynamically linked lists and much more. The experienced coder will have no problem in gaining access to any of the legal OS structures or API objects.
PureBasic is a portable programming language which currently works on AmigaOS (680x0 and PowerPC), Linux, MacOS X (PowerPC) and Windows computer systems. This means that the same code can be compiled natively the three systems and still use the full power of each. There are no bottlenecks like a virtual machine or a code translator; the generated code produces highly optimized executables regardless of the OS on which it is compiled. The external libraries are mainly written in hand optimized assembler, which produces very fast commands, often much faster than the C/C++ equivalent.
Main features:
- Huge set of internal commands (800+) to quickly and easily build any application or game
- All BASIC keywords are supported
- Very fast compiler which creates highly optimized executables
- No external DLLs, runtime interpreter or anything else required when creating executables
- Procedure support for structured programming with local and global variables
- Access to full OS API for advanced programmers
- Easy but very fast 2D game support trough dedicated libraries (DirectX, SDL, ...)
- Easy and high quality 3D support based on OGRE
- Optimal use of the available hardware by using highly optimized (assembly) commands
- Source code is portable between AmigaOS, Windows, MacOS X and Linux, for games and applications
- Dedicated editor and development environment
- Integrated debugger to easily trace programming bugs.
Technical Features:
- 486, Pentium (Pro, II, III) support
- Built-in arrays, dynamically linked lists, complex structures, pointers and variable definitions
- Supported types: Byte (8 bits), Word (16 bits), Long (32 bits), Float (32 bits) and also user defined types (structures)
- Built-in string types (characters)
- Constants, binary and hexadecimal numbers supported
- Expression reducer (grouping constants and explicit numbers together)
- Standard arithmetic support in respect of sign priority and parenthesis: +, -, /, *, and, or, lsl, asl, lsr, asr
- Very fast compilation (about 300 000 lines/min on a P200)
- Procedure support for structured programming with local and global variables
- All Standard BASIC keywords: If-Else-EndIf, Repeat-Until, etc.
- External library support to manipulate objects like BMP pictures, windows, gadgets, SDL, etc.
- External libraries are fully written in hand optimized assembler for maximum speed and compactness
- The Linux API functions are fully supported as if they were BASIC keywords
Inline assembler
- Precompiled structures with constants files for extra fast compilation
- Configurable CLI compiler
- System friendly, easy to install and use

PDF417, or Portable Data File 417, is a two-dimensional stacked bar code symbology capable of encoding over a kilobyte of data per label.

A CGI (Common Gateway Interface) Application is an application that a WWW server can execute. The easiest way to create barcodes on your web server is to use a CGI application that generates barcodes. It is enough to install just one executable file on the server. Embedding a barcode into an HTML page is as easy as using IMG tags.

Our CGI applications are written in C++ and are executable files, which ensures higher speed and lower load for the web server. You can use our CGI applications both on the Windows platform and on Linux with either IIS or Apache servers.

Examples:

If you specify the following parameters:

http://localhost/test/pdf417cgi.exe?data=HelloWorld&xdim=2&bcolor=ffff00&fcolor=0000ff

"HelloWorld" will be encoded in the PDF417 barcode, the x-dimension is 2 pixels, the background color is yellow, the foreground color is blue.

To get information about the PDF417 CGI application (and also the license information), just specify the parameter help:

http://localhost/test/pdf417cgi.exe?help=1

If the web server returns an error for some reason (for example, a CGI Error for a Windows server or an Internal Server Error for Linux), you may have specified some parameters incorrectly. Try specifying the parameters as shown below and you will get such an error.

http://localhost/test/pdf417cgi.exe?data=HelloWorld&w=1

As you can see, the width of the PDF417 image is set to 1 pixel. Of course, a PDF417 barcode image cannot have this size. To get debugging information, add the parameter debug and you will see an error message:

http://localhost/test/pdf417cgi.exe?data=HelloWorld&w=1&debug=1

DialogBlocks software is a sizer-based resource editor that quickly gets you creating professional-looking dialogs, wizards and frames for deployment on Windows, Linux, Mac or any other supported wxWidgets platform.
Main features:
wxAUI support
- New! Now DialogBlocks supports wxAUI - any dialog, frame or panel can be a wxAUI manager, handling sizing and positioning of its child windows.
wxGridBagSizer support
- DialogBlocks handles wxGridBagSizer, with drag and drop positioning of controls in a grid.
wxPropertySheetDialog, for settings dialogs
- DialogBlocks directly supports wxPropertySheetDialog, for easy editing of your applications settings pages.
Conditional user interfaces
- DialogBlocks supports the ability to adapt the user interface to the UI guidelines of different platform. Just mark elements as for one platform (or several), and preview the look for any given platform.
wxFrame, wxMenuBar, wxToolBar and wxStatusBar editing
- DialogBlocks handles frames, complete with wxMenuBar, wxToolBar and wxStatusBar.
Validators
- DialogBlocks now supports validators and custom variables. Just add a variable, select the variable and a validator, and the data transfer between variable and control is done for you.
wxWizard editing
- DialogBlocks is the only wxWidgets dialog editor to support in-situ wxWizard editing. You add pages and change the wizard bitmap while viewing the wizard as it will appear to the user. Just add data transfer, validation and page route logic to the generated C++ code.
C++ and XRC output
- DialogBlocks exports C++ and XRC (the wxWidgets resource format). You can optionally generate the C++ to reflect the use of an XRC file; or you can leave it to generate explicit control creation calls. The generated C++ needs very few additional changes to get it compiling with your project.
Version restrictions:
When you register you get these benefits:
- UNREGISTERED is removed from the titlebar;
- you can create more than 30 dialog elements;
- no more nag screens;
- limited Windows RC import is available;
- many more features and GUI classes are available;
- you can download a free copy of ImageBlocks, a simple image converter.

AMPC is a C Integrated Development Environment (IDE) that generates Java Bytecode.
The resulting executables will be able to run on any Java Virtual Machine (JVM). AMPC enables programmers to develop applications using the C language to run on JVM-enabled devices such as the PDAs, smart-phones, game consoles, set-top boxes, automotive systems (GPS based displays, On Star, Satellite radio systems, etc), and so forth, (with a single source base to manage), hence, opening up new revenue streams for your business.
Axiomatic Multi-Platform C could also be used to turn legacy applications written in C to run on the JVM, thus, opening up a whole new market dimension for your existing software products.
While students will be able to learn C which is a real-world programming language targeting the platform independent JVM.
Main features:
- Axiomatic C Compiler
- ANSI C Library
- Application Programming Interfaces (APIs)
- Jasmin Assembler
- Project Navigator
- Source Code Editor
- Activities Logger
Version restrictions:
- Expires after 15 days.

Code Forge IDE is Integrated Development Environment for Unix and Linux, that provides full project management and a complete edit, compile and debug cycle support for over 30 programming languages. Its advanced project management features allow it to scale from simple to extremely large and multi-language as well as multi-user projects. Total integration between various IDE tools provide the programmer with unprecedented control over the development process.
The Project Manager gives a visual representation of all of its components through the use of a dependency tree. Users can easily set up multiple targets of different types, mix programming languages and even revision control types within the same project.
The GUI project manager provides full abstraction of the "Makefile" concept. Project Makefiles are generated and maintained automatically by the CodeForge project engine. Intuitive Drag and Drop operations on the Dependency Tree and project desktop, are automatically converted to make script statements. A GNU Makefile representation of the Project is kept up to date with every change applied to the project. The resulting Makefile can be executed from the command line.
Tools options
The IDE hides the details of working with different compiled programming languages. The simple concept of creating a target from source files and even other targets works exactly the same for all compiled languages. Creating an "Executable" target and adding source files will automatically generate the the rules necessary to build that target. Creating a "Library" target is just as simple. Linking your "Library" target to an "Executable" target is as simple as dragging the icon of the "library" target onto the "Executable" targets icon.
Development tool interfaces are also abstracted. The IDE has preconfigured support for all major free and commercial compilers on the market today. Appropriate compilation and linker options are selected automatically and are graphically configurable. Dozens of other tools such as (ar, lexx, yacc, etc) are also supported by the development environment.
Code Forge IDE is fully Drag and Drop enabled between tools. Operations such as file modification, file comparison and revision control are all performed simply by dragging a file form the project desktop to the desired drop site.
The IDE provides the facilities to control the build, debug and execute actions at the target level. An environment variable editor allows the user to define a custom environment for each Project.
Project Window
A built-in advanced programmers editor is the first and only editor to maintain the correct indentation of the entire source file with each keystroke. (The indentation policy can be "downgraded" to the level of other editors via options) The editor features context-sensitive auto-completion and prototype-hinting.
The IDE includes a "best-in-class" debugger interface, that interfaces seemlessly with the editor so you can edit, rebuild and continue debugging never leaving the debugger itself.
Code Forge IDE makes Team Development a snap through the use of local "sandboxes", project merge and transparent support of all major types of Revision Control. Complete abstraction of the Revision Control interface makes revision control specifics transparent to the user. Interaction will all revision control types looks the same to the user. Drag and Drop operations within Dependency Tree generate and execute the correct revision control commands.
The Code Forge Integrated Development Environment provides a uniform interface to all its features for all programming languages, compilers and revision control systems on all unix-like operating systems. You will never have to learn another IDE again!
Main features:
- As you type context highlighting and Automatic (WYSIWYG) indentation
- Auto-competion and prototype hinting for C/C++
- Auto-completes C/C++ object attributes and functions when ., -> and :: are typed
- Offers both context-sensitive and context-less symbol completion hints.
- Displays function prototype hints and highlights each argument as it is typed
- Word completion
- Fully customizable fonts and colors and indentation
- As you type Begin/End construct matching and brace matching
- Multi-level undo, Bookmarks and Macro record/play
- SMED can also be run from the Command-line
- On-the-fly Function/Method List gathering and browsing for all supported languages
- Collapse/Expand Functionality
- Auto-save functionality
Enhancements:
- New project-wide live symbol panel and symbol server - maintains a live view of all the symbols defined in the project. A database of all the symbols is maintained by the symbol server and used by the symbol navigation facilities and the Coding Assistant. Code changes are parsed in the background without interrupting workflow.
- Improved Code Assistant - faster, smarter and more efficient. Can parse even the most complex C/C++ expressions. Saves time and prevents syntax errors.
- Improved code navigation capabilities - right-clicking on symbols in the symbol panel and editor now presents navigation options such as jump to definition, jump to declaration.
- New class/method/attribute management dialogs - add class, add method and add attribute accessible by rightclicking on targets and symbols in symbol panel and symbol names in editor.
- Improved Team Development - Project Structure, Build Configurations and environment variables are now store in Revision Control and shared between users.
- User-Configurable Build Configurations - User can define multiple build configurations, each with their own set of tools options and switch between them on the fly. Environment variables definitions are now also Build Configuration based.
- Recursively add directory trees to projects - user-defined filters are used to add source and include files to the project.
- New Include Path generation facility.
- Directories can now be linked to targets - Filters can be defined to compile and link directory contents into the target.
- Automated license request and installation.
- GUI updates (dockable panels)
- Support for upcoming VSS Bridge v2