Free decorator software for windows

Decorators Edinburgh toolbar for Internet Explorer. Decorators Edinburgh, all types of painting and decorating in the Edinburgh and Lothians. Interior painting, exterior painting of private and commercial properties.

System Requirements: Internet Explorer

Porcupine is an object oriented web application server that features the Porcupine Object Query Language, an integrated transactional object database and QuiX(an AJAX powered XUL motor).
Porcupine is a web application server that provides an object oriented framework for developing web applications rapidly.
Many of the tasks required for building web applications as you know them, are either eliminated or simplified. For instance, when developing a Porcupine application you dont have to design a relational database.
You only have to design and implement your business objects as classes, using the building blocks provided by the framework (datatypes). Porcupine integrates a native object database, no mapping required.
Another tedious task for web applications is the interface design, and the constraints imposed by HTML. QuiX, the servers integrated XML User-Interface Language, simplifies the interface design process.
All you have to do is describe your applications interface in XML and write the appropriate event handlers. You dont have to waste time and money on widget implementations. QuiX comes with a variety of ready to use widgets, accelerating the development process.
Generally, every Porcupine application consists of three distinct layers. The first is the business layer consisting of the business objects which encapsulate the business logic.
The second layer binds the HTTP protocol with the first layers business objects. This layer is implemented using Python Server Pages or Servlets. If using XML-RPC, one common approach is to directly map an XML-RPC method to a business objects method.
The third layer, the presentation layer, usually consists of XML UI definitions and JavaScript event handlers.
The first two layers are executed server side and the third layer is executed on the client (browser).
Main features:
- Embedded hierarhical object database with transaction support
- Porcupine Object Query Language
- Role based security
- Supports custom datatypes and custom datatype event handlers
- Supported protocols: HTTP, XML-RPC
- Integrates QuiX, Innoscripts XUL javascript rendering engine
- Consistent and easy to learn API
- Three different types of Servlets (HTTP, XUL, XML-RPC) for enhanced productivity
- HTTP-exposed methods can be secured with policies
- Compiled Python Server Pages
- Custom post processing filters (GZIP compression filter included)
- Extensible session manager
- Support for Apache and IIS. CGI and MOD_PYTHON connectors are included.
- Easy application localization. String resources are held in UTF-8 encoded Python script files (version 0.0.6 or later).
- Single file deployment. Use the pakager utility to include all of your application files and objects in a single file. Installation is done by the same utility using a single command.
- Full UTF-8 support

Enhancements:
- Ability to define image dimensions explicitily for Icon and TreeNode widgets using the "imgwidth" and "imgheight" attributes. Accepted values are integers or percentages.
- Added "onmousedown" to the list of supported QuiX events.
- Added "focus" method to Field widgets.
- Added "maxlength" and "textalign" attributes to fields.
- Added "getFile" method to the internal file data type.
- Support for pre-processing filters.
- New pre-processing filter "porcupine.filters.authorization.RequiresLogin". Use "porcupine.filters.requires_login" decorator for web methods. As the name denotes this filter protects assets from non authenticated users. Ability to redirect such users to a predefined URL if the optional "redirect" argument is used.
- Added new "QuiX.getTargetWidget" function.
- New "QuiX.getOS" function.
- QuiX context menus now have a new "target" attribute which contains the target widget.
- Added new "getWidgetsByAttributeValue" method applying to all widgets.
- POQL now has two new functions "upper" and "lower". Useful when performing case-insensitive searches on string attributes.
- QuiX now has a universal mouse button detection method (QuiX.getMouseButton)
- Added "deletePermanent" remote method applying to all content classes.
- ListView widgets now have a "select" method that selects items by index.
- New "rowheight" parameter for ListView widgets.
- Ability to specify which splitter pane collapses by using the "_collapse" custom attribute.
- New "editundef" attribute for data grids. If set to "false" then the datasets undefined values are not editable.
- New "List" data type.
- New "onclose" custom event for ContextMenu widgets.
- Service oriented architecture. Currently, the supported services include an asynchronous network server and a scheduler used for executing Python code at fixed intervals.
- Data types are now type safe.
- The porcupine database singleton is now accessible from everywhere by using "from porcupine import db".
- The main Porcupine configuration file is now a Python dict.
- The "config.xml" configuration files can now contain smart registrations with regular expressions matching providing with a powerful rewriting engine.
- QuiX is now using a pooled set of XmlHttp objects for better resource usage on the client side.
- Enhanced detection method for droppables.
- Using the standard "mimetypes" Python module for guessing the responses content types.
- Changed the default mode of the "getFile" method of the external files datatypes to rb.
- Session objects are now using __slots__ for more efficient memory usage.
- Added the required hooks that allow the integration of other popular Python template engines easily.
- The cookie detect page is removed. The code is transferred inside the "porcupine.webmethods.quixui" decorator when this is defined as a page (by using the isPage=True directive).
- The Porcupine exceptions module has been greatly simplified. The error codes have become equivalent to those of the HTTP protocol.
- Object sets have become far more memory efficient.
- The date locales are transfered inside the "porcupine.utils.date" module.
- Ability to define custom attributes to tree nodes of FolderTree widgets if and only when the remote call returns an "attributes" parameter for each tree node.
- Allow more than one non-nested transactions per request.
- Fixed scroll bars bleed through on MacOS Firefox.
- QuiX FlowBox now supports multiple selection by using "multiple=true".
- Allow alternate row colors for ListView widgets by using the "altcolors" attribute. Ability to define highlight colors by using the "hightlightcolors" attribute.
- Added the missing email field on the users form.
- Ability to define accepted file types for each QuiX file control by using the "filetypes" attribute.
- File controls now have an "oncomplete" event which is fired when upload is finished.
- Removed limitation that required file controls to be placed inside a QuiX window.
- New "reset" method for MultiFile widgets.
- The main widget for all QuiX Window is now a vertical Box in order to support themes in a simpler way.
- Enhanced resolution of QuiX modules dependencies.
- The object cache returns deep copies of objects, so that each request is accessing its own copies.
- Optimized the "Composition" data type now accepts subclasses of the designated type.
- TabPanes "activateTab" now accepts both an integer or a tab widget as argument.
- Optimized wrapped tooltips.
- Automatically generated forms now support date data types.
- Optimized the "create" and "update" remote methods handle integer data types.
- Optimized the remote method "update" handles date data types.
- The XML-RPC module now encodes unicode keys of dict types using the appropriate encoding.
- Fixed the "Content-Disposition" header when the filename contains spaces.
- Fixed the "getCaption" method of QuiX Labels when these contain special characters such as &,.
- Fixed removing the active editing widget when refreshing a data grid.
- Fixed the "getImageURL" and "setImageURL" methods for icons that do not have initially an image set.
- Fixed error when packaging directories with unicode paths using the pakager utility.
- Fixed row dragging of list views on IE.
- Added missing "__slots__" class attribure to ExternalFile data type and PersonalFolder content class.
- Tree widgets "getSelection" now returns null if no tree node is selected.
- Fixed list views header placement when padding top is other than 0.
- Fixed the orphaned context menus.
- Fixed length distribution after removing a child of a Box.
- Fixed The boxes which now display correctly if the first child is hidden.
- Fixed filenames for duplicated external files when cloning an object.
- Fixed date formatting when using the "yy" parameter on the server side.
- Fixed the "iconpadding" parameter for QuiX buttons.
- Fixed possible transaction deadlock when moving or copying multiple items.
- Fixed selection of "Reference1" data types with POQL.
- Fixed the server side XML-RPC module serializes composites.
- Fixed content classes event handlers are called before datatype event handlers to reflect any possible data type updates.
- Fixed do not update the object cache if a transaction handle is given on read operations.
- Fixed the "onchange" event for date pickers is now fired.

Fans of Python use the phrase "batteries included" to describe the standard library, which covers everything from asynchronous processing to zip files. The language itself is a flexible powerhouse that can handle practically any problem domain. Build your own web server in three lines of code. Build flexible data-driven code using Pythons powerful and dynamic introspection capabilities and advanced language features such as meta-classes, duck typing and decorators.

Python lets you write the code you need, quickly. And, thanks to a highly optimized byte compiler and support libraries, Python code runs more than fast enough for most applications.

Major Features:

1. Very clear, readable syntax
2. strong introspection capabilities
3. Intuitive object orientation
4. Natural expression of procedural code
5. Full modularity, supporting hierarchical packages
6. Exception-based error handling
7. Very high level dynamic data types
8. Extensive standard libraries and third party modules for virtually every task
9. Extensions and modules easily written in C, C++ (or Java for Jython, or .NET languages for IronPython)
10. Embeddable within applications as a scripting interface
11. Python is powerful... and fast
    • Fans of Python use the phrase "batteries included" to describe the standard library, which covers everything from asynchronous processing to zip files. The language itself is a flexible powerhouse that can handle practically any problem domain. Build your own web server in three lines of code.
12. Python plays well with others
    • Python can integrate with COM, .NET, and CORBA objects.
    • For Java libraries, use Jython, an implementation of Python for the Java Virtual Machine.
    • For .NET, try IronPython , Microsoft's new implementation of Python for .NET, or Python for .NET.
13. Python runs everywhere
    • Python is available for all major operating systems: Windows, Linux/Unix, OS/2, Mac, Amiga, among others.
      
14. Python is friendly... and easy to learn
    • The Python newsgroup is known as one of the friendliest around. The avid developer and user community maintains a wiki, hosts international and local conferences, runs development sprints, and contributes to online code repositories.
15. Python is Open
    • The Python implementation is under an open source license that makes it freely usable and distributable, even for commercial use. The Python license is administered by the Python Software Foundation.

Enhancements

• Regular Python dictionaries iterate over key/value pairs in arbitrary order. Over the years, a number of authors have written alternative implementations that remember the order that the keys were originally inserted. Based on the experiences from those implementations, a new collections.OrderedDict class has been introduced.
• The OrderedDict API is substantially the same as regular dictionaries but will iterate over keys and values in a guaranteed order depending on when a key was first inserted. If a new entry overwrites an existing entry, the original insertion position is left unchanged. Deleting an entry and reinserting it will move it to the end.
• The standard library now supports use of ordered dictionaries in several modules. The configparser module uses them by default. This lets configuration files be read, modified, and then written back in their original order. The _asdict() method for collections.namedtuple() now returns an ordered dictionary with the values appearing