witty-3.3.4+dfsg.orig/ 0000775 0001750 0001750 00000000000 12510340013 015012 5 ustar pgquiles pgquiles witty-3.3.4+dfsg.orig/INSTALL.win32.html 0000644 0001750 0001750 00000012040 12101461500 017743 0 ustar pgquiles pgquiles
Wt Installation
Wt Installation instructions for Windows
This page lists the instructions for building and installing Wt on Windows.
It is organized in 3 sections:
Requirements
Building and installing the library
Trying the examples (or your own Wt application)
Requirements
Wt for Windows uses the built-in web server connector or the ISAPI connector.
The fastcgi connector is not supported. The built-in web server is more
convenient during development and is easier to setup than the ISAPI connector.
To use the built-in server, you have to link your projects against libwt
and libwthttp. To use the ISAPI connector, you have to link to libwtisapi
instead of libwthttp.
Requirements:
Microsoft Visual Studio C++ 2005 or newer. Wt and its dependencies also
build on the Express Edition, which is free (as in beer) to use.
CMake cross-platform build system (www.cmake.org): cmake-2.6.x,
Windows version (2.8 or newer recommended).
Boost 1.36 (or later; a recent version is recommended)
Additional and optional requirements for some of the examples
For https support: OpenSSL, version 0.9.8d or newer.
To compress traffic: zlib 1.2.3
Postgres, mysql, firebird client libraries for Dbo database backends
Haru Free PDF Library , which is used to
provide support for rendering PDF (WPdfImage, WPdfRenderer).GraphicsMagick , for
supporting painting to raster images (PNG, GIF, ...) (WRasterImage).
We stronly recommend to use libraries which are all built using the same
compiler and the same runtime configuration (/MT, /MD, /MTd
or /MDd) to avoid incompatibilities with the C runtime libraries. Mixing
CRTs is NOT recommended, the zlib
DLL FAQ clearly explains why and what you should do about it (in
short: use prebuilt libraries for the exact same compiler as you use, and
if those are not available, rebuild the dependency libraries from the sources).
Step by step instructions to build and install the Wt library
Up to date instructions are located on the Wt wiki page:
Installing Wt on MS Windows
Instructions on how to use the ISAPI connector for deployment under IIS are
also available on the wiki page:
ISAPI on Microsoft IIS
Trying the examples (or your own Wt application) using wthttpd
1. Run the example in the MSVC IDE
Right-click on the example project you want to run, and select 'Properties'.
In Configuration Properties->Debugging, set the Command Arguments to
--http-address=0.0.0.0 --http-port=8080 --deploy-path=/hello --docroot=.
This will start a httpd server listening on all local interfaces, on
port 8080, and you may browse the example at http://127.0.0.1:8080/hello
Examples that need extra files to run, should be executed from their source
directory in order to find their dependency files (icons, css files, etc.
Watch for 404 errors in Wt's output). To do so, set the 'Working directory'
for the example to wt-x.y.z/examples/ExampleName. Some examples (e.g. the
wt home page) need the 'resources' directory to work correctly. Copy
the wt-2.x.x/resources to the example's source directory to solve this
problem. Other examples (such as the Charts example) may require the
installation of ExtJs. See the Wt reference manual for more information
on how to obtain and install ExtJs.
These are all the command-line options that are available (run the examples
with --help to see the most recent list of available options):
General options:
-h [ --help ] produce help message
-t [ --threads ] arg (=10) number of threads
--docroot arg document root for static files
--no-compression do not compress dynamic text/html and text/plain
responses
--deploy-path arg (=/) location for deployment
HTTP server options:
--http-address arg IPv4 (e.g. 0.0.0.0) or IPv6 Address (e.g. 0::0)
--http-port arg (=80) HTTP port (e.g. 80)
HTTPS server options:
--https-address arg IPv4 (e.g. 0.0.0.0) or IPv6 Address (e.g. 0::0)
--https-port arg (=443) HTTPS port (e.g. 443)
--ssl-certificate arg SSL server certificate chain file
e.g. "/etc/ssl/certs/vsign1.pem"
--ssl-private-key arg SSL server private key file
e.g. "/etc/ssl/private/company.pem"
--ssl-tmp-dh arg File for temporary Diffie-Hellman parameters
e.g. "/etc/ssl/dh512.pem"
witty-3.3.4+dfsg.orig/WConfig.h.in 0000644 0001750 0001750 00000002763 12432736450 017153 0 ustar pgquiles pgquiles #ifndef WCONFIG_H
#define WCONFIG_H
// Version defines
#define WT_SERIES ${VERSION_SERIES}
#define WT_MAJOR ${VERSION_MAJOR}
#define WT_MINOR ${VERSION_MINOR}
/*! \brief A constant that encodes the library version of %Wt
*
* You may use this constant to check for the version of %Wt at build-time.
*/
#define WT_VERSION (((WT_SERIES & 0xff) << 24) | ((WT_MAJOR & 0xff) << 16) | ((WT_MINOR & 0xff) << 8))
#define WT_VERSION_STR "${VERSION_SERIES}.${VERSION_MAJOR}.${VERSION_MINOR}"
#define WT_CLASS "Wt${VERSION_SERIES}_${VERSION_MAJOR}_${VERSION_MINOR}"
#define WT_INCLUDED_VERSION Wt_${VERSION_SERIES}_${VERSION_MAJOR}_${VERSION_MINOR}
#define RUNDIR "${RUNDIR}"
#define WT_CONFIG_XML "${CONFIGURATION}"
#define WTHTTP_CONFIGURATION "${WTHTTP_CONFIGURATION}"
#cmakedefine WT_STATIC
#cmakedefine WTDBO_STATIC
#cmakedefine WTDBOPOSTGRES_STATIC
#cmakedefine WTDBOSQLITE3_STATIC
#cmakedefine WTDBOFIREBIRD_STATIC
#cmakedefine WTDBOMYSQL_STATIC
#cmakedefine WTHTTP_STATIC
#cmakedefine WT_EXT_STATIC
#cmakedefine WT_EXT_STATIC
#cmakedefine WT_HAS_WRASTERIMAGE
#cmakedefine WT_HAS_WPDFIMAGE
#cmakedefine WT_WITH_SSL
#cmakedefine WT_NO_BOOST_INTRUSIVE
#cmakedefine WT_NO_BOOST_RANDOM
#cmakedefine WT_NO_STD_LOCALE
#cmakedefine WT_NO_STD_WSTRING
#cmakedefine WT_USE_OPENGL
#cmakedefine WT_DEBUG_ENABLED
#cmakedefine WT_THREADED
#cmakedefine WT_USE_BOOST_SIGNALS
#cmakedefine WT_USE_BOOST_SIGNALS2
// our win32: WIN32 (gcc) or _WIN32 (MSC)
#if defined(WIN32) || defined(_WIN32)
#define WT_WIN32 1
#endif
#endif
witty-3.3.4+dfsg.orig/Changelog 0000644 0001750 0001750 00000351265 12334344176 016660 0 ustar pgquiles pgquiles WARNING! This file is no longer used.
Please refer to the ReleaseNotes for major changes, and the git log for
more fine-grained information on changes.
28-11-2013:
* WRasterImage: now also support skia as backend. Cmake option
ENABLE_GM is replaced by WT_RASTERIMAGE_IMPLEMENTATION, which has
to be set to none, GraphicsMagick, or skia.
10-07-2013:
* WSignal: Due to boost 1.54 complaining on boost.signals being
deprecated, namespace Wt::Signals was created. This namespace contains
the boost signals implementation that is optimal for your boost: for
boost < 1.54 it will be signals, for boost > 1.54 it will be signals2.
15-05-2013:
* WStandardItem, WStandardItemModel: before: checkboxes are rendered
in enabled state when ItemIsUserCheckable flag is set. Now: checkboxes
are rendered when CheckStateRole is present. If ItemIsUserCheckable is
set, the checkbox will be editable. If ItemIsUserCheckable is not set,
the checkbox will be uneditable. setCheckable(true) will add a
CheckStateRole of false when no CheckStateRole was present on the
element.
05-04-2013:
* Client SSL certificates can be queried from (static) WResources
26-02-2013:
* Fixed bugs #1711, #1712, #1713, #1714, #1715
* Wt-3.3.0-rc3
19-02-2013:
* Fixed bugs #1689, #1698, #1687 (from Starius)
* Implemented features #1675 (from Thomas Saquet)
* Wt-3.3.0-rc2
18-02-2013:
* Fixed regression in resource continations
15-02-2013:
* Fixed bugs #1699, #1697, #1696, #1695, #1677, #1676
* Fixed WPopupMenu::triggered() behaviour change from 3.2.3
12-02-2013:
* Wt-3.3.0-rc1
25-01-2013:
* Merged in bootstrap branch, with many additions, changes and above
all addition of support for Twitter's Bootstrap framework as a new
theme
12-12-2012:
* Added binary WebGL VBO buffers, contributed by Tassilo Glander
01-11-2012:
* Wt-3.2.3
05-10-2012:
* Layouts: various bug fixes and improvements
* Render: added support for repeating table headers
* WApplication: added some tentative methods for 404 generation in
response to internal paths
13-09-2012:
* Render: added support for explicit page breaks and % widths
* layouts: fix popup widgets confusing preferred size calculations
(tentatively)
13-08-2012:
* Payment: new API for payment processing, with an implementation
for PayPal
10-08-2012:
* layouts: fix various issues
* WTextEdit: fix behaviour inside a WPanel
* Render: code reorganizations for java port
03-08-2012:
* QueryModel: added stableResultRow() method which has more guarantees
of consistently returning the same result regardless of database
changes
27-07-2012:
* Dbo/Exception: add support for SQLSTATE code information
* Mail/Client: log configuration that will be used on first use
* WAnchor: use tag even if no link has been provided (#1348)
* WDoubleSpinBox: fix formatting (#1358)
* WSlider: add more hooks for custom styles
25-07-2012:
* Layouts: fix error in switching to contents determining layout size
* Wt-3.2.2-p1
23-07-2012:
* WebController: workaround filesystem runtime problem for boost 1.50
* Wt-3.2.2
16-07-2012:
* Wt: fix compile issues with boost 1.50
* WPieChart: support TooltipRole data
* WGridLayout, WBoxLayout: fix dynamic add/remove behaviour, fix
behaviour in WGroupBox, and honor minimum size settings on container
* Wt-3.2.2-rc2
04-07-2012:
* Wt-3.2.2-rc1
28-06-2012:
* WAbstractSpinBox: fix (server-side) validate()
* WComboBox: handle current index when deleting rows
* WTreeView: use hasChildren() do determine need for expand icon
* layout: properly constrain minimum sizes in the application root
23-05-2012:
* dbo: add One-to-One relations, using Wt::Dbo::weak_ptr<>
* dbo: check relations are soundly defined instead of generating wrong
SQL
* dbo: collection::clear() method added
* Utils::base64Encode(): added option to omit CRLFs from generated
base64 stream
* WGridLayout, WBoxLayout: more fixes to be backwards compatible
with previous version
* http/WtReply: fix memory leak when too-large files are uploaded
leaving stale temporary files
* WebSession: clean-up session-id file for FastCGI (regression)
* WApplication::setInternalPath(): make it work properly when used
without JavaScript
15-05-2012:
* feature/dbo/tutorial9 example added: splits the classes over several
files
* WCartesianChart: add support for custom markers, and custom axis
padding
* WGridLayout, WBoxLayout: several bug fixes
14-05-2012:
* WInteractWidget::setMouseOverDelay() configures a delay before
the mouse over signal is fired
* WInteractWidget::doubleClicked() has been reimplemented using
mouseClicked() so that not both will fire in case both have events
attached
09-05-2012:
* WGridLayout, WBoxLayout: new implementation, which should get rid
of misfeatures and annoyances
* WebRenderer: do not generate double '//' when loading theme CSS
* WebSession: do not wait for 'load' signal if not using ajax puzzle
* WFileUpload: fix behaviour in MS HTA mode
05-04-2012:
* StdGridLayoutImpl.js: unbreak layout in WGroupBox behaviour
* Dbo/QueryModel: fix Firefox not showing header problem (LevelRole error)
03-04-2012:
* WGlobal: add more forwards
* WTreeView: relax fix for behaviour in layout manager
* Dbo::QueryModel: make const methods const
30-03-2012:
* Wt 3.2.1 (final) released
03-01-2012:
* Wt/Utils: new header with utility functions that implement
commonly used hash functions and encoding/decoding
* WAxis: fix Date and DateTime scale rendering, to take into acount
labelInterval() and better choice of label values
28-12-2011:
* Dbo/Transaction: do not require a commit() to commit a transaction
(but preserve behaviour to rollback in case of an exception)
27-12-2011:
* Auth/: reorganisation, more model/widget separation
26-12-2011:
* WSlider: implement disabled rendering
22-12-2011:
* hangman example: add Russian translation
19-12-2011:
* Render/: optimize table rendering
07-12-2011:
* WGoogleMap: unify loading for v2 and v3, fixes bugs in loading
a second v3 google map
01-12-2011:
* Wt.js, WtReply: more robust handling of flaky WebSocket connections
* hangman example: misc editorial changes
* WReadOnlyProxyModel: a simple proxy model that allows sharing of
source model between different sessions (but read-only)
* Dbo: added belongsTo() and hasMany() overloads which infers the
foreign key names from the foreign table
* Dbo: added session() method to actions
* WStringStream: optimization for string literals which avoids
strlen()
* WDialog: fix positionAt()
* wtfcgi: fix regression (data corruption) when built with DEBUG=ON
29-11-2011:
* Released: 3.2.0
21-11-2011:
* Wt/Dbo/backend/Firebird: merged Firebird backend contributed by
Lukasz Matuszewski from Technical University of Gdansk.
* Wt/WLogger: the library now uses macros that wrap around
Wt::log() by default for internal logging, but this could be
adapted to use another logging system of your choice. We also
abide the third law of logging libraries: that they will expand
their features until they become unusable: we added configurations
options to enable or disable specific logging.
* WServer: support catching SIGHUP (on unix-like) systems to
reread the configuration file.
* httpd: implement newer (and newest) WebSocket drafts (protocol
versions 7, 8 and 13)
* all: closed several bugs and feature requests (#956, #1015,
#1018, #1064)
18-11-2011:
* WString: we now store arguments as WString so they are also
properly i18n-ed (#1059).
07-11-2011:
* WException: new, public exception class (was previously an internal
one)
* WIOService: new, public service class for async I/O, and its
thread pool
* WStringStream: new, public fast stringstream implementation (was
previously an internal class)
* Wt/Auth: new, authentication module
* Wt/Json: new, JSON library
* Wt/Mail: new, mail client
* Wt/Http/Client: new, http client (former Client renamed to WtClient)
* Wt/Test/WTestEnvironment: has moved to a "wttest" pseudo-connector
library
* WFormWidget: added a valueText() that returns the textual
representation of the current value
* WApplication: added deferRendering() and resumeRendering() API,
useful for asynchronous client operations
* Wt::log(): global logging method, similar to but more useful
than WApplication::log()
* WTemplate: added support for functions, and two standard functions
id() and tr()
* WTemplate: implemented arguments parsing and use ("class")
* WebSession: added DoS meausures: ajax puzzle and plain session
rate limitation
19-10-2011:
* WAbstractItemView: reimplemented and simplified header item rendering
* Wt.js: workaround browser bugs in scrollLeft reading in RTL mode,
fixing WAbstractItemView column resizing in RTL layouts.
12-10-2011:
* WRectF: fix isEmpty() to be more restrictive: only a rect with
width = 0 and height = 0 is now empty
11-10-2011:
* WPopupMenuItem: fix crash with re-showing hidden popup
* WDialog: add setClosable() which adds a close icon to the title bar
* WAbstractItemView: more flexible API for header height and vertical
alignment
05-10-2011
* WMediaPlayer: make sure that relative URLs resolve against deployment
path (#1007)
03-10-2011
* Dbo: added dialect option for 'rows ? to ?' (Firebird database).
23-09-2011
* Wt 3.1.11 released
19-09-2011
* WAnchor, RefEncoder: added indirection to strip session ID from the
referrer before navigating to an external URL (#607)
* wthttp: stabilized WebSockets handling
13-09-2011
* WConfig: added a check to detect header/library version mismatches
* Chart/WAxis.C: a fix from Joe Garcia, crash with log scaling
* WItemDelegate: set target new window for WLink data when it references
a resource
* WMenu: fix hiding of a menu item to hide the entire item, not just
the contents (label)
05-09-2011
* WResource, Http/ResponseContinuation: added API to suspend a response
while waiting for more data, and resuming later
31-08-2011:
* WResource: use suggestedFilename() also when set during
handleRequest() (#920)
22-08-2011:
* Dbo/DbAction: fix missing actId() in FromAnyAction triggered
by QueryModel with natural ids
* WAbstractServer, WebMain, WebSession: added support for
scheduling events, used to timeout bootstyle response to avoid problems
on IE(9) ?
* WCssDecorationStyle: fix border() segfault
10-08-2011:
* WContainerWidget, WScrollArea, DomElement: use overflow-x and
overflow-y CSS style since now well cross-browser supported (#830)
* Dbo/Session: add forceReread parameter to load()
* WLength: throw exception when unit is corrupt
* WTreeTable: throw exception on contract abuse
* examples/wt-homepage: Russian translation contributed by Dmitriy
Igrishin
09-08-2011:
* Wt.js: fix z-index for drag widget (#927)
* WTreeView.js: fix column 0 resizing with total treeview regression
* WFormWidget.C: do not allow editing when isReadOnly()
* Dbo/ptr: fix ptr operator bool() loading the object (#909)
* Dbo/CMakeLists.txt: support building and installing Wt::Dbo
independently from Wt (#907)
05-08-2011:
* WApplication: added a docRoot() method which returns the webserver
document root
03-08-2011:
* WMediaPlayer: new cross-browser, flexible, audio/video player widget
* WHTML5Video, WHTML5Audio, WHTML5Media: renamed to WVideo, WAudio, WAbstractMedia
* WSound, SoundManager: reimplemented using WMediaPlayer
* WPopupMenu: new method setAutoHide() for automatic hide when
the mouse leaves
* WLink, ...: new utility class that abstracts a link destination (be
it a URL, a WResource or an internal path)
* WPopupMenuItem: new methods setLink() and setLinkTarget()
associate a link with the popup menu
25-07-2011:
* WPopupMenu, WPopupMenuItem: improved triggered() signal API and
added setSelectable() signals
18-07-2011:
* WMenuItem: fix takeContents() (#897)
* WMenu, WMenuItem, WSubMenuItem: simplifiy internal path handling with submenus
15-07-2011:
* examples/feature/broadcast: add an example that illustrates
server push, WServer::post() and synchronizing a shared resource
across sessions
14-07-2011:
* fix min-width being ignored in layout managers
* WDialog: implement setResiable() (#612)
12-07-2011:
* collection: implemented count() method for relational
collections (#882)
11-07-2011:
* WFileUpload, WApplication: fix maximum request size and fileTooLarge()
bugs (#794)
* WTestEnvironment: add methods to test reentrant eventloops (#711)
08-07-2011:
* Wt 3.1.10 !
07-07-2011:
* Dbo: allow foreign key constraints to be passed to a
primary key (that is also a foreing key)
* Dbo: implement ostream<< for a ptr.
06-07-2011:
* Wt.js: fix HTML5 history spec weirdness with null state
* WFileUpload: fix second upload() crash (#888).
04-07-2011:
* WWebWidget: added childrenChanged() signal and use this in
WMenu to track contents stack updates
29-06-2011:
* WWidget: show/hide animations also work on FF5 now
* WMenu: better handling of internal path changes to use best
match (when components include more than one level)
* WMenu: fix stateless slot learning issue with submenu items
28-06-2011:
* Dbo/ptr: let modify() return a proxy mutator object which marks
dirty from its constructor and destructor, ensuring that
modifications are not lost in the case the session is flushed
amidst a modification.
27-06-2011:
* Dbo/collection: implement insert() and erase() for ManyToOne
collections
24-06-2011:
* WApplication: implemented changeSessionId() method, useful to
mitigate session fixation attacks
* WApplication: added removeMetaHeader() method
* WFontMetrics: solve pango font-based metrics for cursive fonts
* WTableCell, WTableRow, WTableColumn: add more convenience
methods for navigating the row, column
23-06-2011:
* WApplication: button img style to keep HTML4 behaviour of centering
the icon vertically in the button
* WWidget, WWebWidget, js/ToolTip: implement an XHTML tooltip using
JavaScript
* WTableView: fix setHeaderRowHeight() in plain HTML mode, other
plain HTML style consistency improvements
19-06-2011:
* collection: implement copy constructor which is needed for relational
collections
14-06-2011:
* WTemplate, WText: implement setInternalPathEncoding() method which
encodes anchors with internal path references
* WAnchor, ... resolve relative paths correctly when HTML5 History
internal path implementations are used
30-05-2011:
* WAbstractItemView, WTreeView: fix browser memory leaks of
inline stylesheet definitions (#834)
27-05-2011:
* WebRenderer, WebSession: better detection of IE9 and workaround
its bugs (box-sizeing border-box)
* WWebWidget: do not set an offset auto for IE (gets confused)
23-05-2011:
* WTextEdit: implement missing toolBar() method
* WCssDecorationStyle: fix operator= behaviour and unset properties
(#816)
20-05-2011:
* WServer, http: remove singleton objects to allow multiple
WServer instances
* WAbstractSpinBox: fix behaviour on IE
* Wt.js: fix button up registration
19-05-2011:
* WTextEdit: make all things configurable per instance (#801).
13-05-2011:
* WebSession: relax needs for setting baseURL. Looks good !
* WWidget, WAnimation: added animation options for setHidden(),
and new methods animateShow() and animateHide()
* WStackedWidget: added support for a transition animation
* WDialog: added animation support for the dialog cover as well,
and improved centering on IE (at least it seems to me ?)
06-05-2011:
* WebSession: fix baseURL property usage and internal path
inconsistencies
* WObject: fixed memory leak (signal destroyed was never deleted)
* WTreeTable: fixed progressive bootstrap behaviour
* WTableView: pageSize is minimally 1
* http/Connection: fix HTTP1.0 + continuations error (#810)
* WTestEnvironment: fix reading from server_ = 0 bug
27-04-2011:
* backend/Postgres: use actual autogenerated id field name instead
of "id"
26-04-2011:
* http/Connection: fix a leak in websocket sockets (file descriptors)
* WLayout: added a clear() method which removes all contents
* WDataSeries: fix setLabelColor() being ignored
* Dbo/backend/Postgres: set client encoding to UTF8
* WTable: added moveRow() and moveColumn() methods
* WTableView: fix setColumnHidden() with headerColumns()
* WebSession: use baseURL property for self-referencing URLs
* WServer: post() with optional fallbackFunction that is called
when the targeted session is dead (by Gaetano Mendola)
14-04-2011:
* WAbstractArea: fix anchor not being deleted
13-04-2011:
* WebSession: fix setting cookies when using websockets
* WApplication: fix unload() interfering with session reload
when reload-is-new-session is set to false
* sqlite3: bump to version 3.7.6
12-04-2011:
* WebSession, WebRenderer: handle WidgetSet session reloading
11-04-2011:
* http/Configuration.C: fix missing --docroot segfault problem
* web/WebRenderer: option to allow splitting skeleton file in an
invariant and variant part (useful if refreshing frequently)
* WGoogleMap: fix rendering in layout manager on webkit
* WStreamResource: refactored WFileResource, contributed by Dmitriy
Igrishin
07-04-2011:
* 3.1.9: release time !
05-04-2011:
* target/android, target/osx: starting to support these mobile targets
* Ext/Calendar: set selected date on render
01-04-2011:
* Chart/WChart2DRenderer.C: avoid clipping with WRasterImage backend of
labels, titles by rendering in a wider box
* WServer::post(): for lock-free event delivery to a session, instead of
taking the WApplication::UpdateLock. Simplechat and codeview exapmles were
adapted to use this approach.
29-03-2011:
* WAbstractItemView: fix API usage when not rendered
* WDate: patches from Gaetano Mendola w.r.t. invalid dates after month/year
operations + isLeapYear() implementation
25-03-2011:
* FontSupportPango: store leaky pango_font_map in thread local memory
* WRasterImage: fix clipping problem with text rendering
* W*Slider: fix 0 value and readonly attribute behaviour (#748, #749)
* Wt.js: fitToWindow() when object is wider/taller than window (#766)
* WebSession: support cookies in CORS (withCredentials flag)
* Wt/WAxis: setResolution() implementation, contributed by Gaetano Mendola
23-03-2011:
* target/osx: Add script to generate an OSX Framework for iPad/iPhone
* Dbo/Query: fix limit_ and offset_ not being copied in copy constructor
* Chart/WCartesianChart: allow custom color for a single bar in a bar
series using BarPenColorRole and BarBrushColorRole data roles
21-03-2011:
* Dbo/QueryModel: honour original limit() and offset()
25-02-2011:
* WSpinBox, WDoubleSpinBox: separated integer from double spinbox,
rewrite to take into account #737, #727, #721. Note that the API
changed in several ways.
23-02-2011:
* WRasterImage: implement drawImage() and improved text rendering,
using libpango as font selector and glyph shaper, if available.
* WPdfImage: use libpango for selecting (truetype) fonts, if available.
15-02-2011:
* WebSession: support HTML5 History API for internal paths
* wthttpd: a value for docroot like .:/css,/resources,/style is
interpreted as defaulting to a deployed app except for the given
paths, allowing deployment without ugly URLs (?_=)
12-02-2011:
* WSubMenuItem: behave more consistently w.r.t selection (#694)
11-02-2011:
* WString, WMessageResourceBundle: added i18n support for plural forms
* WSlider: provide better CSS-ability and support for HTML5 input range
native control
10-02-2011:
* WRun(), WServer::addEntryPoint(): uses a boost::function for the
application creator callback, so that you can bind additional arguments
* WServer::initializeThread() a virtual method which can be used to
initialize thread in a specialized WServer class (only for built-in httpd)
09-02-2011:
* WTableView, WTreeView: renamed (and implemented for WTableView)
setColumn1Fixed to setRowHeaderCount()
04-02-2011:
* Released 3.1.8
28-01-2011:
* Dbo: belongsTo() and hasMany(/* ManyToMany */) can now be passed
foreign key constraints such as NotNull and OnDeleteCascade.
27-01-2011:
* StdGridLayout: collapse paddings of empty items (affects all non-Ext
layout managers)
25-01-2011:
* Wt/Text/Renderer: warn but proceed when minimum render width exceeds
page width
* Wt/WPaintDevice: solve inconsistencies w.r.t. clear()
* WebRenderer, WebSession, Boot.html: wait for stylesheets to load
before loading widget tree in default bootstrap mode
* WApplication: initial work for RTL layout, set using
setLayoutDirection()
19-01-2011:
* Wt/WPdfImage: add true type font support (libharu patch pending)
* Wt/WApplication.C: fix #693
(sloppy WApplication::internalPathMatches())
* Wt/WBoostAny.C: add support for bool types (#690)
* Boot.html, Hybrid.html: fix IE8 unreliable startup (occasional
blank screen)
13-01-2011:
* Wt/Chart/WCartesianChart: implement legend location, alignment,
and styling options
* Wt/Chart/WDataSeries: add setXSeriesColumn() to allow for
individual X series per Y series in a scatter plot.
11-01-2011:
* Wt/WAbstractItemView: implement setHeaderItemDelegate() and defer
rendering of header cells to the item delegate; also added
WStandardItemModel::setHeaderFlags() to allow configuration of
header flags.
07-01-2011:
* Wt/WAbstractItemView: implement scrollTo()
* Wt/Dbo: support for bool types
06-01-2011:
* Render/WTextRenderer, Render/WPdfRenderer: XHtml-to-(PDF) renderer.
* Wt/WFontMetrics: font metrics info
* Wt/WPaintDevice: add methods for font metrics
* WLength: add a string-based constructors which parses a CSS
length declaration like "50%"
* WFont: the string-based constructor now parses #aabbcc and
rgb(a,b,c) values into rgb components.
* WWidget: added setHeight() and setWidth() methods
21-12-2010:
* WAbstractItemView, WTableView, WTreeView: persist editors through
model changes and avoid closing editors when something changes
* WAbstractItemModel: clarify (and narrow down) usage of internal data
in a model index so that views can keep their relaxed take on stale
indexes.
16-12-2010:
* WEvent: add eventType() method
* wt-homepage, simplechat examples: show-case widget set mode
* blog example: add archive
* libwtwithqt: simplify implementation since notify() is now used
more consistently by Wt
* WObject: object ids are now seeded by a random start value, to
allow mixing of several wt applications
* WRasterImage: implemented a getPixel() method
08-12-2010:
* WApplication: fix unload event interfering with session refresh
* WebSession: handle session quit() during a websocket message
* WRandom: moved high-entropy random generator to public API, and
a utility method to create a random id
* wt-homepage example: illustrate use of a cookie to persist logins
across sessions
02-12-2010:
* WebSession, WApplication, ...: support CORS (Cross-Origin Resource
Sharing including IE's XDomainRequest and WebSockets), deprecated
WApplication::setAjaxMethod() which is now chosen automatically
and support request pref-flighting using OPTIONS.
01-12-2010:
* WApplication, examples/wtwithqt/DispatchThread: attach the Qt
thread only during event handling
* Dbo/Session: add rereadAll() option to reread single table
* WFileUpload: correctly handle non-ascii tokens in suggestFileName()
30-11-2010:
* fixed a regression in layout managers, released as 3.1.7a
27-11-2010:
* js/StdGridLayout.js: implement rowspan handling
26-11-2010:
* released 3.1.7
24-11-2010:
* WAbstractItemView: added support for column hiding
23-11-2010:
* Chart/WCartesianChart: support ToolTipRole data using WAbstractArea
areas
15-11-2010:
* Dbo/Sesion: add rereadAll()
* Wt.js: fix IE6-8 history management regression
10-11-2010:
* QueryModel: setData() now converts the incoming type to the database
field type (if possible), and also uses a transaction to persist the
result (if not nested in another transaction)
08-11-2010:
* WebSession: landed Web Sockets support, must be enabled in the
configuration file
05-11-2010:
* Wt.js: fix opera script loading indicating failure when loading from
cache
02-11-2010:
* WebSession: initialize() in first notify()
* WStringUtil: fix a bug in widen() when the underlying conversion
gives an error
* build: fixes suggested by Pau
29-10-2010:
* Wt 3.1.6 released
28-10-2010:
* WebSession: use sequence instead of random numbers for resources
* WebRenderer: be resilient to multiple GET requests for the main
script
* WApplication: unload() does not quite() when reload-is-new-session
is disabled
* WebRenderer: fix regression where timers are stopped by refreshing
a session when reload-is-new-session is disabled
27-10-2010:
* examples/feature/dbo: added examples from the Wt::Dbo tutorial
* WPushButton: added setRef() and setResource() APIs to make a button
behave like an anchor
* WString::widen() and WString::narrow(): fix broken implementation
26-10-2010:
* WMessageResourceBundle: better preservation of white-space when
parsing the XML resource bundle
25-10-2010:
* WFileUpload: added setMultiple() which alows multiple files to
be uploaded at once (and demonstrate in composer example)
* Http/Request: changed UploadedFileMap typedef from std::map to
std::multimap
* WAbstractItemView: added methods sortColumn() and sortOrder()
22-10-2010:
* WFileUpload, WResource: support upload progress tracking (currently
only with wthttpd)
21-10-2010:
* various: support IE9 in IE9 document mode, enabling HTML5 features
like canvas and disabling workarounds no longer needed -- hooray !
19-10-2010:
* WPopupMenu: fix recycling of popup menu
18-10-2010:
* WSignal: EventSignal::connect(): added an overload which accepts
a JavaScript function, as a short-cut for JSlot when connection
management is not needed
* WSpinBox: a spin box is in the making
* WApplication: deprecated getUpdateLock() in favour of the more
conventional RIIA UpdateLock(WApplication *app) constructor
* WebSession: do not access WebSession shared_ptr during ~WebSession
but allow acquiring the update lock to fail instead when an application
is slated for destruction (#564)
* SyncLock: an adaptor for a Boost Mutex lock which avoids dead-locks
when used while holding an application lock
15-10-2010:
* WApplication: addMetaHeader() allows now to set http-equiv meta
headers and override the X-UA-Compatible meta header
14-10-2010:
* WWebWidget: reimplemented buggy clear() optimisation.
12-10-2010:
* WBoostAny: added registerType() method to register
new types for boost::any support by standard item views.
11-10-2010:
* Dbo/WtSqlTraits, Dbo/backends: added support for WTime
* Dbo/QueryModel: added support for customized header data, and
option for setQuery() to keep the current columns.
* js/StdGridLayoutImpl: use parent node geometry for detecting need
for relayout, fixes IE7+ behaviour
07-10-2010:
* WTableView, WTreeView, *ProxyModel: shift model indexes only after
the source model has inserted or removed rows, see bug #546
* WProgressBar: added valueChanged() and progressCompleted() signals,
from Omer Katz.
05-10-2010:
* CMakeLists.txt: patch for gentoo, make many things optional which
can be enabled or disabled explicitly regardless of whether the
libraries and header files for it are found
01-10-2010:
* WebController, WebSession: use shared_ptr for WebSession to resolve
concurrency bug #544
* Wt::Dbo: use a spirit based parser for sql queries to handle more
complex queries like 'WITH ... SELECT ...' syntax, but also with
complex aggregate functions in the SELECT clause.
28-09-2010:
* WDatePicker: add setGlobalPopup() method which can be used to avoid
clipping problems on a date picker
* WDatePicker: add setPopupVisible() method
* Http/Request: add getRanges(), parsing the HTTP 1.1 Ranges header
* Http/Response: add setContentLength() allowing you to specify the
content length.
* WFileResource: support ranges to return partial file contents.
27-09-2010:
* WMenuItem: destructor now cleans up properly
* all connectors: consider appRoot as the location for the
wt_config.xml file and provide ways to configure appRoot for
wthttp and fastcgi connectors.
22-09-2010:
* WProgressBar: based on a contribution by Thomas Suckow.
21-09-2010:
* WRegExpValidator, WSortFilterProxyModel: support case-insensitive
regular expressions
* WSuggestionPopup: optimized behaviour w.r.t server-side and
client-side filtering
20-09-2010:
* WApplication: added makeAbsoluteUrl() method.
* WPopupMenuItem: support setDisabled().
16-09-2010:
* WPaintDevice: remove paintFlags() method; PaintUpdate is a property of
the painted widget, and no longer something which has to do with
WPainter. In this we revert to the old behaviour of supporting multiple
WPainters on a single paint device in turn.
14-09-2010:
* Wt.js: fix JavaScript memory leak after learning about the
surprising JavaScript scoping rules
* WApplication: add unload() and setConfirmCloseMessage() to handle the
event of the user closing the window respectively have a confirmation
* WInteractWidget, WMouseEvent: add mouseWheel() event
* WTabWidget: fixed polished style close icon, and wrapping to next line
if having many tabs
* WFormWidget: implement hasFocus()
* WLineEdit, WTextArea: implements methods for retrieving cursor
position and current selection
08-09-2010:
* WCheckBox: better tri-state support, using opacity: 0.5 as
workaround instead of an image
07-09-2010:
* WBoxLayout, WGridLayout: improved client-side performance by
selectively doing relayout
* WDate, WCalendar, WDatePicker, ...: support i18n through built-in
message resource bundle and get rid of ugly i18n bool in API
23-08-2010:
* fcgi: fix connector when using WDialog::exec() or server push
(this is broken in 3.1.4!)
* WSocketNotifier: finally (!) this beast works as advertised
10-08-2010:
* isapi: various improvements
* WSignal: SLOT/slots macro can be disabled using -DWT_NO_SLOT_MACROS
* examples: cleanups to use appRoot() and no longer use SLOT() macro
02-08-2010:
* WBatchEditProxyModel: a model that caches editing until submitted
in batch (or reverted)
* Dbo/QueryModel: remove edit strategy, this is now handled by
WBatchEditProxyModel
* WModelIndex: clarify usage when model rows/columns shift, implement
in-place toRaw/fromRaw conversion
* WDialog: add titleBar() to access the title bar
30-07-2010:
* Dbo/Query: support 'select distinct/all' syntax, and case-insenstive
query parsing
29-07-2010:
* WSuggestionPopup: misc improvements to server-side filtering, fixing
rendering glitches
* examples/feature/suggestionpopup: example demonstrating WSuggestionPopup
features
27-07-2010:
* WRasterImage: Graphicsmagick backend implementation for WPaintDevice,
sponsorted by Eurofer, can be used for PNG, GIF, etc... output
22-07-2010:
* WPdfImage: PDF backend implementation for WPaintDevice,
sponsored by Eurofer.
* http/Reply.C: enable compression for image/svg+xml mime-type.
* WInteractWidget: suppress click and double click mouse events when
disabled
20-07-2010:
* Wt/WTreeNode: added insertChildNode(), as suggested by
Aleksey Chirkin
19-07-2010:
* isapi: added a (first implementation) of an ISAPI connector,
which provides native support in Microsft IIS.
* WebSession: fix one possible race condition, and one possible dead-lock
when grabbing the session lock
* Dbo/QueryModel: implement write support (setData(), insertRows(),
and removeRows())
15-07-2010:
* Wt::Dbo: adds support for natural keys, including composite
keys, custom id and version field names, and foreign key
constraint definition that is compatible with mysql's broken sql.
* Wt::Dbo: Dbo base class is now changed to Dbo template
class to take into account customizable id type.
14-07-2010:
* resizable layout managers: reset total width percentage of all
remaining columns to 100
* WCanvasPaintDevice: fix transformation bug
07-07-2010:
* examples/feature/serverPush: fix WIN32 build problem
* Chart/WCartesianChart: fix clipping margin glitch
* Dbo/QueryModel: fix missing implementation fields() method
* WAbstractToggleButton: fix disabled/readonly properties #423
* WApplication: useStyleSheet(): allow media to be specified
* WCanvasPaintDevice: fix font rendering glitch
* WTableView: improved keyboard navigation through editors
30-06-2010:
* WTabWidget, WMenu: support for closing, hiding and disabing
items, contributed by Dmitriy Igrishin
* Wt::Dbo: fix boost::optional support
* WAbstractItemView: build fix for MSVC in non-Latin locales
* WAbstractItemModel: copyData() does first nullify existing data
* WSuggestionPopup: fix bug in handling of model row removal
* WWebWidget, WebRenderer: fix statelss slot learning bug when a
stubbed widget is affected (see treelist example)
* WWebWidget: fix addStyleClass(), removeStyleClass()
implementations with force=true (from Dmitriy Igrishin)
* WTableView: improved handling of arrow keys for navigating editors
10-06-2010:
* WTableView, WTreeView: workaround IE bug w.r.t. white-space: nowrap
* Chart/WCartesianChart: added createLegendItemWidget() to paint the
legend item outside the chart
* WItemDelegate, WAbstractItemView: add support for validation
* WBorderLayout: add missing setSpacing() method to control internal
spacing
* WWidget: addStyleClass() and removeStyleClass() (finally!)
* WContainerWidget: workaround scrolling bug in IE caused by
position: relative
* WEnvironment: agent() and agentIsXXX() methods
* WSvgImage: give in to inkscape's CSS font needs
* WHTML5Video, WHTML5Audio: HTML5 video and audio support
* WSuggestionPopup: implement explicit trigger (icon, key down)
* WTreeNode: support selection by click on whole row
* WWebWidget: added doJavaScript()
* examples/blog: improved support for MSVC builds, new feature allowing
profile editing
* examples/feature/serverpush: simple example illustrating use of
server push
20-05-2010:
* build: added support for cygwin
19-05-2010:
* WMenu: fix first selection not emitting internal path change (dmitry)
* WTableView: properly react to model changes
* WItemDelegate: explicit focus support
18-05-2010:
* Chart/WChart2DRenderer: fix rendering glitch when rendering grids
13-05-2010:
* WInteractWidget: added mouseDragged()
* WApplication: added addMetaHeader()
10-05-2010:
* WTableView: now supports (almost) same API as WTreeView, with the
similar style, but better performance for tabular data.
* WTableView, WTreeView, WAbstractItemView: support non-AJAX rendering
using a paging bar.
* WAbstractItemDelegate, WItemDelegate, WAbstractItemView:
supports editing
* Dbo/QueryModel: a Wt model for viewing data from a Dbo::Query
result (a first version).
* Dbo/SqlTraits: sql_result_traits was renamed to query_result_traits,
and its API updated to allow more robust query creation and result
interpretation as a list of boost::any's
* Signal: SignalBase and EventSignalBase are now documented API
* WFlashObject: reimplemented: no longer relies on JavaScript to load
the flash movie. WFlashObject no longer uses SwfObject.js. The objects
will also be resized when inserted in a layout manager.
* WHTML5Video: HTML-5 video implementation, will become part of
generic video support later
* http/Reply.C, http/StaticReply.C: support for http range header
and partial content
* web/CgiParser.C: fix parsing logic error for multi-part/formdata
28-04-2010:
* WTimer: implement singleShot(f) with f a function object variant
21-04-2010:
* WMenu: support usage without contentsStack_
* rapidxml.hpp: fix bug #344 (some special entity characters not being
handled properly)
* examples/planner: new example illustrating simple dbo usage
20-04-2010:
* Dbo/SqlConnectionPool, Dbo/FixedSqlConnectionPool: connection pool
implementations
* Dbo/Query: support for several bind strategies, including a new
DynamicBinding strategy which supports incremental query
specification
* Dbo/Session: add execute() method for executing SQL that does not
return results
08-04-2010:
* Http/Request: added headerValue()
07-04-2010:
* WSuggestionPopup: add setFilterLength() and filterModel() methods
which allow for server-side filtering based on initial input. Also
support setMaxSize() to specifiy maximum height of the popup and
scrolling through the list of suggestions
30-03-2010:
* WPanel: make titleBarWidget() public
26-03-2010:
* Wt/WShadow, Wt/WPainter: add support for drop shadows
* Wt/Chart/WDataSeries, Wt/Chart/WChart2DRenderer: add support for shadows
25-03-2010:
* Wt/Dbo/backend: provide generic properties() and API clean-ups
24-03-2010:
* Wt/Dbo/Query: also support queries without 'from' or 'select'
* Wt/Dbo/DbAction.C: create indexes on join table for each referenced
table id
* Wt/Dbo: support schema-qualified tables
23-03-2010:
* Wt/Dbo/Postgres, Wt/Dbo/Sqlite3: add proper support for dates,
time stamps, binary blobs, var chars
19-03-2010:
* WCheckBox, WRadioButton: fix inconsistencies when setting style
attributes and they have a non-empty label
15-03-2010:
* Dbo/backend/Postgres: a PostgreSQL backend, contributed by Hilary
Cheng
12-03-2010:
* EscapeOStream, WSvgImage: a host of performance improvements by
tossing away stringstream in favour of a simple SStream
* WWidget: add setLayoutSizeAware() and layoutSizeChanged() methods
08-03-2010:
* WResource: add setInternalPath() to deploy a resource at a
deterministic URL
05-03-2010:
* WebSession: add support for http PUT/DELETE methods.
* src/Http/Request: add method() to access request method
* src/Http/Response: add setStatus() to set the response status
03-03-2010:
* WCalendar: add HorizontalHeaderFormat enum (long day name support),
currentPageChanged signal, clicked signal, activated signal,
SelectionMode enum (NoSelection mode support), renderCell() virtual
method
01-03-2010:
* WGridLayout, WBoxLayout: add support for user resizing ('splitter')
functionality
* WTreeView, WGridLayout: externalize JS
25-02-2010:
* src/Wt/WString: fix narrow() and widen() character encoding
conversions
* http connector: spool large POSTs to a temporary file instead
of in-memory, and avoid extra copies
* web/CgiParser.C: skip large file uploads entirely (instead of
erroneously buffering them to memory)
22-02-2010:
* Dbo/StdSqlTraits: support float and double
* WApplication: missing initialization messes up refresh() by reload
* WPainter: now has defined behavior when missing horizontal or vertical
alignment flags in drawText()
18-02-2010:
* web/EscapeOStream.C: fix build error on MSVC
* Wt 3.1.1 released
12-02-2010:
* mxml: replace mxml with an (adapted) rapidxml browser.
28-01-2010:
* Ext/Container.C, WStackedWidget.C: fixed behavior in combination
with layout managers
25-01-2010:
* WTreeView.C: simplified column resize handling code
22-01-2010:
* WCanvasPaintDevice: Use HTML5 native canvas text when available
21-01-2010:
* WSuggestionPopup, WTree, WTreeNode, & co: make CSS themed
18-01-2010:
* Dbo: additional optional parameter to hasMany() allows the
definition of the joinId in the joinTable (you need this if you
are doing Many-to-Many between the same table).
* WDateTime, WTime: fix AM/PM parsing problem
* Dbo/SqlStatement: explicit null binding, since SQLite3 does not
reset bindings on reset()
* WTreeView: fix ite column 0 changing
12-01-2010:
* WTemplate: do not rerender bound widgets when rerendering the
template if the widget was already rendered
11-01-2010:
* themes/polished: several improvements
* WPanel, WCalendar, WDatePicker, WDialog: improved theme support
* WTreeView: several bug fixes and improved IE bug workaround support
05-01-2010:
* Chart/WAxis: added setLabelFont(), labelFont() methods
* WTreeNode: fix selection handling when removing and readding a node
* Boot.html, Hybrid.html: fix an XSS vulnerability arising from the
internal path
04-01-2010:
* Wt.js, CommAjax.js, CommScript.js: support communication problems
by retrying with exponential back-off
31-12-2009:
* Dbo: quote all identifiers
* WContainerWidget: support resetting a layout manager
29-12-2009:
* Release 3.1.0, after some more bug fixes
22-12-2009:
* Ext/FormWidget: add changed(), blurred() and focussed() signals
21-12-2009:
* WTemplate: add handleUnresolvedVariable() from Maurice Gittens
* WMenu: sanitize internal path handling
* documentation: integrate asciidoc and doxygen in CMake (target
'doc'), and improve Wt::Dbo documentation
18-12-2009:
* WTreeView: fix treeview column add/remove glitches with column 1 fixed
17-12-2009:
* WSlider: correct upside down behavior of WSlider, use more accurate
position handling
15-12-2009:
* Wt/Dbo: new C++ ORM layer
* test/: automated test suite (for non-GUI features)
* src/Wt/WTemplate: new XHTML template-based widget
* examples/blog: new example that implements a blog using Wt and
Wt::Dbo
* src/Wt/WDateTime, src/Wt/WTime: date time and time classes
15-12-2009:
* CMakeLists.txt: add XML_FEATURES option which can be used to disable
the (mini-)XML library
11-12-2009:
* WPaintedWidget, Ext::Container: properly react to resizes within
a Wt layout manager, both width and height
* StdGridLayoutItem.C, Ext::Widget: concatenate html and body style
classes to not have interference
09-12-2009:
* WDataSeries: added setHidden(bool) and isHidden()
* WCartesianChart: added renderLegendIcon()
* WTextEdit: fix updating of contents
07-12-2009:
* WWidget: added isRendered(), let widgets keep track of being rendered
* WSignal: added connect(Function& f) method
04-12-2009:
* src/web/skeleton/Wt.js: added getSelectionRange and setSelectionRange
utility functions for line edits and text areas
30-11-2009:
* src/mxml: updated to an unmodified mxml-2.6 (which includes our bug
UTF-8 bug fixes)
25-11-2009:
* all: added support for CSS-based themes.
* WAbstractItemModel, WAggregateProxyModel, WTreeView: addded support
for drilling down through treeview columns
* WSlider: added sliderMoved() signal
* Chart/WAxis: added setAutoLimits() and autoLimits() methods, and have
maximum() and minimum() return computed values
* Chart/WCartesianChart: use MarkerPenColorRole and
MarkerBrushColorRole to override colors for markers per data point
* WCanvasPaintDevice: several improvements for outputting more
concise JavaScript rendering statements
* WWidget: add find() method to find a widget with a particular
objectName()
* WFileUpload: fileTooLarge() signal now propagates within the
event loop
10-11-2009:
* Chart/WCartesianChart, Chart/WDataSeries: added mapFromDevice() and
mapToDevice() methods.
03-11-2009:
* WTreeView: fix for adding a first row to an otherwise empty model
(from Guy De Leeuw)
03-11-2009:
* 3.0.0: released!
21-10-2009:
* WMenu: set correct internal path before loading a menu item
09-10-2009:
* WAxis: add TimeDateScale to AxisScale enum
28-09-2009:
* WCartesianChart: seriesIndexOf() is now private
* WebRenderer: several small fixes for the hybrid bootstrap
23-09-2009:
* WTableView: table_ is now private and a protected getter table() was
added
18-09-2009
* Wt.js: cancelEvent() includes an option to only include cancelling
propagation or the default action
* WResource: add setChanged() and url() methods which are more
useful than the generateUrl() method
* http/RequestParser: fix possible shared_ptr corruption issue
reported by David Galicia
* WCssDecorationStyle: add method for WResource as background
image
* JSlot: fix internal consistency problem when connecting same
JSlot to same signal twice
* JSlot::exec() now takes parameters for object and event
* WTreeView: fix vertical scrolling showing mis-aligned columns
when column 1 is fixed
15-09-2009:
* WWidget: move WFormWidget::setEnabled() to WWidget::setDisabled(),
allowing all widgets to be set enabled or disabled.
* WWidget: isVisible() and isEnabled() reflect the computed visibility
respectively being enabled taking int account ancestors settings
* WWidget: added setHiddenKeepsGeometry(), which uses css visibility
for setHidden()
03-09-2009:
* WDialog, Ext::Dialog, and related: allow for multiple modal dialogs
and nested exec() calls.
* Boot.html, Hybrid.html: add a loadScript() method to defer loading of
user JavaScript
01-09-2009
* WDatePicker: Use 'positionAtWidget' to make sure the widget
is rendered visible even if at bottom of page (folds up instead of down)
* WDialog: Fix JavaScript positioning for IE6
* WFileUpload: Fix empty file regression (#53)
31-08-2009
* Wt.js: fix server push mayhem
* WTreeView: fix autoJavaScript performance
* Wt.js: fix mouse capture on IE, fix mouse capture of mouse up when
dragging outside the window
* Wt.js: fix synchronisation issue with 'load' request and loading
of JS libraries
* Wt.js, DomElement: use setExpression() to set a CSS expression
(for min/max-width)
* WApplication: fix conditional stylesheet condition parse error
with 'gte' expression
26-08-2009
* Wt.js: attach mouse grab events to body using DOM event
capture
* HybridBoot.html, WebSession, WebRenderer: assimilate new
bootstrap method with a refactoring, make it all a bit less
stateful
* WApplication: notify() can now be used as a generic request
handling point where you grab and free request-specific
resources
22-08-2009
* fcgi/Sever.C: make multi-threaded, using the
number of threads
19-08-2009
* ProgressiveBoot.html, WebSession, WebRenderer: a new bootstrap
method has been added which implements the principle of
"progressive enhancement"
* WebSession, Boot.html: avoid one extra round-trip when
redirecting to the canonical URL.
* Plain.html: better SEO: do not render the form to a spider engine
18-08-2009
* WWidget: add boxPadding() and boxBorder() methods, which are
used by the layout managers to correct for built-in borders and
paddings of form widgets
* WComboBox: listen to layoutChanged()
06-08-2009
* WGoogleMap: add setCenter() method without zoom argument, change
myHtml argument to WString
01-08-2009
* WLineEdit: work around IE's inability to change so that it works
as expected when used within a layout manager
* Test/WTestEnvironment: test environment, for instantiating
WApplication instances usable for (unit) tests
06-07-2009:
* WGridLayout, WBoxLayout, WTabWidget: better documentation that
discusses how to set contents with 100% height.
29-06-2009:
* JSlot: fix exec() call as suggested by Adrian Sutherland
25-06-2009:
* WCanvasPaintDevice, WSvgImage, WVmlImage: string -> stringstream
optimizations
* WTableCell: fix vertical component of content alignment
* WModelIndex: fix operator== to not use memcmp() since this gets
into trouble with struct padding bytes
19-06-2009:
* Chart/WAbstractChart: react well to modelReset() and
modelLayoutChanged()
* WCheckbox, WRadioButton: internal cleanup and simplifications
* WButtonGroup: added checkedChanged() signal
* WIntValidator: allow entry of +/- signs
15-06-2009:
* WGlobal: fix Horizontals = Left | Right and Verticals = Top | Bottom
* WPanel: clear the title bar
* DomElement: fix an unstubbing regression with ExtJS widgets
* Wt.js: fix server push + JSignal.emit()
* WGlobal: fix doxygen for WFlags masks
* http/Server.C: avoid http/https accept() to abort on Win32
* WResource, WFileResource: fix continuation + suggested filename
data corruption, and implement WFileResource::setBufferSize()
10-06-2009:
* WRectF: added isEmpty() method, removed isNull() method
09-06-2009:
* WEnvironment: added headerValue method
08-06-2009:
* WPoint, WPointF, WLineF: removed obsolete isNull methods
02-06-2009:
* WAbstractItemDelegate, WItemDelegate: new classes to which the
rendering of a model item is delegated.
* WTreeView: use WAbstractItemDelegate and WItemDelegates, and
API to customize the used item delegate class.
* WWidget: add setSelectable() method which can enable or disable
the rendering of the browser's default text selection handling
29-05-2009:
* fcgi/Server.C: build fixes for FreeBSD and OpenSolaris
* fcgi/Server.C: implement a (mostly stub) WServer implementation
* Http/Response: add continuation() method to get a continuation
created for the response.
28-05-2009:
* WMenu: show vertical scrollbar when needed
* WGridLayout: support row stretch value of -1, like 0, but
indicates that height of cell contents for that row still needs to
be managed
* DomElement.C: fix IE6 min/max-width workaround bugs
* WStackedWidget: make behave well in layout managers
* WPainter::Image: add constructor that fetches image dimensions
from file (from Daniel Derr)
* DomElement.C: fix style.float -> style.cssFloat or
style.styleFloat property
26-05-2009:
* WebRenderer, Configuration, WebSession, http/WServer: add support
for a favicon per EntryPoint, and in general for a favicon not in
"/favicon.ico"
18-05-2009:
* WAbstractItemModel: add reset() method and modelReset() signal, which
are used to invalidate the whole model. Adjusted the views to listen
to this signal, and make WStandardItemModel::clear() call reset()
* Ext/ToolBar: implement addStretch()
* WPaintedWidget, WPaintDevice: support PaintUpdate flag which does
not erase the painting but merely adds to it
* WTreeView: fix setColumnWidth() for column 0 bug,
setSortingEnabled() when no model yet set bug, column removal
behavior bug, JavaScript error when no column sort/resize handles
* StdGridLayoutImpl, WStackedWidget: make WStackedWidget manage
children height actively when in a layout manager
* WebSession: make server push survive refresh(), and fix cookie
support detection regression
* WApplication.C: fix expose logic for widgets removed from the
widget tree
* WCssDecorationStyle: WBorder::None is not always default
11-05-2009
* WDate: refactor modifiedJulianDate() to toJulianDate(), replaced
modifiedJulianDate constructor to static fromJulianDate function
05-05-2009
* WebSession: fix WApplication::attachThread(), simplify use of
thread specific storage
04-05-2009
* WString: do not assume a message resource bundle as localized
strings
* Wt.js: fix empty line edit regression
* WCalendar: setSingleClickSelect()
* WEnvironment: getDeploymentPath()
23-04-2009:
* WCheckBox, WAbstractToggleButton: tri-state checkboxes
* WAbstractItemModel, WModelIndex, WStandardItem: support
tri-state checkboxes (ItemIsTriState ItemFlag)
22-04-2009:
* WebRenderer: keep iterating the update map as long as render()
calls add new widgets to it
21-04-2009:
* WFormWidget: add setReadOnly(), isReadOnly() methods
* WTimer.C: fix multiple signals firing when stopping and
restarting, and use client-side repetition if the signal is not
exposed
* WFileUpload: deprecated isUploaded(), new method canUpload()
16-04-2009:
* WApplication, WDialog: simplify dialog rendering, allow
(multiple) non-modal dialogs (WDialog::setModal(false)), allow
dialogs to be moved around by dragging in the title bar
* WWebWidget: saner handling of z-index, only apply IE6 shim to DIVs
* WPaintedWidget: fix use of WImage for WAbstractArea's
* WImage, Wt.js: fix position reporting in mouse events from
WAbstractArea's in non-compliant browsers (all except for Firefox)
07-04-2009:
* Ext/FormField: add setFocus() method
30-03-2009:
* WEnvironment.C, WebSession.C, wt_config.xml: allow configuration
of AJAX-capable user agents and bots in configuration file
* Configuration.C, wt_config.xml: synchronize configuration
defaults. WARNING: default settings have changed! (see
wt_config.xml what the default values are)
* WTabWidget.C: use a layout manager to manage vertical height
* WLabel.C: fix bug with placement of image and add option to place
image to left or right of label text
* WDatePicker.C: implement setEnabled()
* WT_SERIES, WT_MAJOR, WT_MINOR, WT_VERSION: change to hexadecimal
format for preprocessor defines
* Ext/TableView.C: fix access to null dataStore_
26-03-2009:
* Fixed cookie handling. Cookie parser is now less strict, and cookie
values are URL encoded, similar to PHP. Fixed setting multiple
cookies.
24-02-2009:
* WWebWidget: implement a real propagateRenderOk() that does not
cause render() of children widgets of stubbed widgets
* WTreeView: move JavaScript around that assumes jsRef() exists
* WGoogleMap: fix require() dependency
* install: do not overwrite existing configuration file wt_config.xml
20-03-2009:
* WFormWidget: refuse to give focus to a disabled widget
* Wt.js: make sure updated autoJavaScript() is executed by onresize
handler
19-03-2009:
* WGoogleMap: fix require() to depend on google.load
* filetostring: removed in favor of a CMAke-only solution
* simplechat: improve its behaviour
* WebSession/WebRenderer: update the form object list after
each event since it may contain stale objects
17-03-2009:
* Fixes for cookie parser
* Send along form values and hash in each 'update', and keep
JavaScript updates around until acknowledged by the browser
(avoids loss of updates especially for server push situations)
16-03-2009:
* fixed build errors and warnings on Sun Studio and Visual Studio
* WSignal: remove EventSignal specialization, use
EventSignal<> everywhere
* add WT_NO_BOOST_INTRUSIVE compile option to use std::list instead
of boost::intrusive::list (needed for Sun Studio)
* WTableColumn, WTableRow: support for custom id's with setId()
* WViewWidget: fix interference problem with stateless slot learning
* WWebWidget: complement quickPropagateRenderOk() with a clean
rerender of itself
* Configuration.C: add option inline-css useful to disable inline
CSS stylesheets, in case you prefer all of them in an external style
sheet
* WTableCell, WDomElement: support colspan/rowspan as properties
* WTable.C: fix rendering problem for th/td reordering
* WebRenderer: WLoadingIndicator: fix rendering and stateless slot
learning interference
* WebSession: avoid superfluous 'none' request
11-03-2009:
* WPushButton: allow line breaks in text using ('\n')
* WebController: fix widget set mode (default entry path parsing)
* CMakeLists.txt: also install Http/ directory
* XSSFilter: refactored
* WAbstractTableModel: new abstract model class
* WebSession: simplify session locking (and fix reentrant event
loop memory corrouption)
06-03-2009:
* win32: fix build problems
* WMemoryResource: change API to unsigned char
03-03-2009:
* WFileUpload.C: emit uploaded() signal in event loop.
27-02-2009:
* WApplication.C, WebSession.C, Wt.js: finally a robust and simple
server-push implementation instead of orbited
* WMenu.C, WTabWidget.C: simplify CSS (better IE workaround)
* WCssDecorationStyle, WGlobal, WText, Ext/TableView: remove
deprecated enums and methods
* WButtonGroup: make API more complete
* WDatePicker: provide default constructor
* fcgi/FCGIStream.C: make FCGI connector work again in new branch
* lots of documentation updates
24-02-2009:
* WOverlayLoadingIndicator.C: fixes for IE8 and opera
23-02-2009:
* WAbstractItemModel.C, Wt.js: fix IE date propagation problem
* WLineEdit.C, WTextArea.C: do not set style classes when no validator
is configured
* WSocketNotifier.C: fixes for boost >= 1.36 (does not work yet
for win32)
02-02-2009:
* fix konqueror show stopper bug
28-01-2009:
* fix bug causing mouseup being called twice at end of drag (for
example confused mandlebrot example)
* WApplication.C: found cause for long standing IE6 mystery 19px
offset
* WDate.C: require 2 digits for 'dd' or 'MM' format entries
* WFormWidget.C: auto-validate when contents changes
* WebRenderer.C, Wt.js: fix several widgetset mode problems for
IE.
* Wt.js: do not block when getting an AJAX error
26-01-2009:
* 2.2.3 released.
23-01-2009:
* examples: misc improvements, update homepage
* src/Wt/WAbstractItemModel: support for const char * data in
boost::any()
* src/Wt/WTreeView: better support for non-JavaScript situations
* WDialog: fix layout regression
21-01-2009:
* WRectF: normalized() returns a rectangle without negative width
or height, and is used within WPainter to normalize rectangle
arguments
* WebRenderer.C: fix embedded mode
16-01-2009:
* new example 'gitmodel': demonstrates how to create a custom model
class, to be used in conjunction with WTreeView.
* WGridLayout, WBoxLayout, WBorderLayout: when used in conjuction
with WContainerWidget, there is now the possibility to hint an
alternative implementation for managing space horizontally, which
uses the 'table-layout: fixed' CSS property.
* WCssStyleSheet: fix JavaScript error on IE
* WTreeView: fixes for when the treeview is not immediately shown
15-01-2009:
* WCanvasPaintDevice.C: fix arc drawing in singular case (width or
height == 0), and for very skewed arcs (widht / height <<< 1 or >>> 1)
08-01-2009:
* WTreeView: react to column insertion and removal, and
fix WTreeNode::load() unintentionally overriding WWidget::load()
* WAbstractProxyModel: implement toRawIndex() and fromRawIndex() so
that WTreeView does not lose selection or expanded index list when
resorting (or partial refiltering)
07-01-2009:
* WDialog: add setTitleBarEnabled() to disable the title bar
06-01-2009:
* WTreeView: setColumnBorder() allows setting the color for a
border line between columns, setColumnResizeEnabled() for
disabling the resize handles, and the content in each column is
now rendered with some padding (3px to the left and right).
05-01-2009:
* WAbstractTobbleButton.C: fix inserting label into widget tree when
parent is not passed in constructor
* Ext/Widget.C: fix hide() and show() to consistently use Ext methods
* Wt.js, WebRenderer.C, WApplication.C: fix IE CSS loading ?
24-12-2008:
* WTreeView: setColumn1Fixed() allows fixing of the first column while
scrolling through the other columns in a large model.
22-12-2008:
* WMenu, WTabWidget: implement removeItem() and removeTab()
* WebRenderer.C: fix internal path issue when starting with a path,
AJAX is available, and deployment ends on a /
* WDialog: fix usage of layout managers in contents area
* WJavaScript, WSignal: scope ::_1 in global scope
* WOverlayIndicator: allow style class customization (Goetz Babin-Ebell)
* CgiParser: cleanup when using GNU regexp API (Goetz Babin-Ebell)
* Ext/PagingToolBar.C: fix adding multiple additional toolbar items.
10-12-2008:
* WCompositeWidget.C: fix implementation not being load()ed
* Boot.html, Wt.js: do not create a new stylesheet but add rules to
existing inline stylesheet (for ordering consistency)
* Wt.js: fix regression for widget coordinates
06-12-2008:
* hello-widgetset: do not build with fcgi connector (Guy Deleeuw)
* global: do not use (unsigned) long long but
use (u)int64_t (Goetz Babin-Ebell and Pau)
* DomElement.C: convert configuration option for
FastCGI deployments, to allow usage of reentrant event loops, as
used by (W)Dialog::exec() methods when using shared session
process deployments.
10-09-2008:
* WLocalizedStrings: add an abstract class to localized WString,
which is by default implemented using WMessageResourceBundle, but
may be customized (as suggested by Lars Hamren)
* several files: fixes for RubyWt (Richard Dale)
* WTabWidget: CSS fix for IE7
21-08-2008:
* all: build fixes for Sun Studio 12, and boost 1.36
* various places: better use of STL containers
19-08-2008:
* src/web/WebSession.h: build fix for boost 1.36
* examples/wt-homepage: add Chinese translation (by Zhimin Song)
* various places: fixes suggested by Richard Dale and Pau
18-08-2008:
* CMakeFile.txt: default is now boost 1.35
13-08-2008:
* StdGridLayoutImpl.C: deal with padding in widgets correctly,
always fit item heights (this may cause rows to get stuck at a
particular height, but gives more consistent behaviour..., handle
UL children
* WApplication: simplify internalPath stuff
* WebController: propagate form values before touching the widget tree
11-08-2008:
* WMenu: add setInternalBasePath(), do not specify display: inline
for a horizontal menu item, instead, should be handled by
programmer CSS
* WMenuItem: do not erronously delete contents in destructor, if
it was already loaded.
08-08-2008:
* Bejing: olympics started! gogo Kim Gevaert!
* WApplication: more internal path small fixes
* Connection.C: build fixes for MSVC and Visual Age
07-08-2008:
* WApplication: fix old behaviour of applicationName(), deprecate it
* WebSession.C, WebController.C, WebRenderer.C: improved url and
internal path handling: handle redirecting to a new internal path,
properly initialize application with an initial internal path,
more flexible internal paths (do not enforce trailing '/')
* WMenu: properly restore application internal path when doing
stateless slot learning
06-08-2008:
* cmake/WtFindSsl.txt: removed redundant code
* src/web/skeleton/Wt.js: fix widget position bug when nested in scrolled
DOM elements or page on Safari/Opera/IE
* all: merged in prettyurls branch
- no longer use frameset in bootstrap page, load instead ajax script. Remove
all code that dealt with the frame, and Ajax skeleton page
- switch to own implementation of history management, remove really simple
history framework code
- add internal path API: see WApplication::setInternalPath(),
WAnchor::setRefInternalPath()
- remove internal iframes to deal with file uploads, found a workaround for IE
problem
- make JavaScript skeleton files compressable with YUI JS compressor
- WMenu and WMenuItems: API changes to work with internal path API
- improved marking of deprecated methods in API
* wt_config.xml: add new setting used in anchor
for redirecting to non-JavaScript version
05-08-2008:
* web/Configuration.C: remove cppfileno mess
04-08-2008:
* WFormWidget.C: fix crash when calling setBuddy() twice (or only
once in case of WAbstractToggleButton)
* WTreeTable.C: fix problem when height is not explicitly set
02-08-2008:
* WVMLImage.C: fix bounding box calculation for arc rendering in path when
rotated. It is still broken for non-uniform scale + rotation
* TableView.C: fix cellSelected signal when used together with a
PagingToolBar to not propagate the correct model indexes
01-08-2008:
* src/http/StaticReply.C, src/http/StockReply.C: transmit response only
when all POST'ed data was received
* src/http/StaticReply.C: call stream_.clear() to recover from error state
29-07-2008:
* WEnvironment.C, src/web/WebController.C, src/web/WebRenderer.C:
fix cookie setting and cookie parsing
* WMenuItem: move itemWidget() from protected to public scope.
25-07-2008:
* WTextEdit[.C]: implement an XHTML rich text editor wrapping the
TinyMCE javascript library
* CMakeListst.txt: install resources/ folder to share/Wt/resources
* WText[.C]: deprecated WText::Formatting enum,
WText::setFormatting() and WText::formatting() for Wt::TextFormat
enum, WText::setTextFormat() and textFormat(). Add a constructor
that accepts the format as an argument, and update examples
* http/Reply.C, http/StaticReply.C: serve a .gz version of a file
with gzip content-encoding if possible and available, fix a
problem with logging when the reply is relayed
22-07-2008:
* WAbstractArea, WRectArea, WCircleArea, WPolygonArea: new classes
that implement interactive areas on WImage and WPaintedWidget.
* WImage, WPaintedWidget: add methods for defining interactive
areas
* StdGridLayoutImpl.C: fix alignment margin glitch
* WApplication.C: default stylesheet: add border: 0px for images,
which are rendered using a border when adding a map.
* WMemoryResource: add constructors and methods for using C-style
array data.
* WLogger.C: fix error in ~WLogEntry
* all: misc build fixes for win32
15-07-2008:
* src/wt: renamed to src/Wt
* src/Ext: renamed to src/Wt/Ext
* src/Chart: renamed to src/Wt/Chart
* src: upgrade to new include file locations
* cmake/FindWt.cmake: update to new new include file locations,
and add some documentation for cmake newbies
* src/wt/StdLayoutImpl.C: fix itemAt() problem
* src/Wt/WMessageResource*, src/wt/WString[.C]: make literal
WString work properly with argument substitution (reported by
Micahel Ivanov)
* src/web/Configuration.C: setup loggers even if no wt_config.xml
file (reported by Goetz Babin-Ebell)
14-07-2008:
* src/wt/WComboBox[.C], src/Ext/ComboBox[.C]: fix problem with
setModel wrongly deleting the previous model (reported by Michael
Ivanov).
* src/wt/WApplication, examples/composer/ComposeExample.C,
src/wt/WMessageResourceBundle: document and contrast expected
location for relative URLs or relative paths (suggested by Pau
Garcia)
* doc/main: improved Inroduction to include logging and error
handling, and related configuration options
* src/Chart/WChart2DRenderer.C: fix regression with stacked bars,
introduced by WAxis::setBreak() implementation
* */CMakeListst.txt: install header files in Wt/ subdirectory to
not clobber the main include directory. You should make sure that
${CMAKE_INSTALL_PREFIX}/include/Wt is searched for these headers!
13-07-2008:
* src/wt/WLogger[.C], src/wt/WApplication: logging API, new method
WApplication::log()
* src/web/Configuration.[Ch], src/wt/Configuration.[Ch]: add
configuration options for accesslog and application logging
* src/wt/WText[.C], src/wt/WWebWidget[.C]: allow to detect XML
parse errors when using XHTMLFormatting
* allover: code cleanups to use logging instead of std::cerr, to
throw exceptions for fatal errors
* src/wt/WLayout[.C]: change contract of count() and itemAt() to
allow for '0' layout items, fix crash with WGridLayout (reported by
bvh).
10-07-2008:
* src/Ext/Widget.C: propagate CSS style class and inline style to
the Ext widget through the config.
* src/web/WtRandom.C: fix integer overflow compile warning (Pau
Garcia)
09-07-2008:
* src/Chart/WAxis[.C]: add setBreak() to support a "broken" axis
that omits a part of the entire value range.
07-07-2008:
* src/wt/WContainerWidget.C: implement clear() to also delete any
layout manager that was set, and support creation of a layout
manager in an existing widget
* examples/simplechat/SimpleChat.C: use clear() in conjunction
with layout managers
* src/web/DomElement.C: make sure style attribute is rendered as
JavaScript
* src/wt/WApplication.C: do not apply 19px IE6 offset bug to IE7 or
later
* src/wt/WGridLayout.C: use default spacing of 6px instead of 9px
* src/wt/WContainerWidget.C: setLayout() replace two bools
fitWidth and fitHeight with an alignment option
* examples/painting/PaintExample.C: use WGridLayout
03-07-2008:
* src/web/skeletons/*, src/web/DomElement.C,
src/web/WebRenderer.C: make sure Wt homepage validates as proper
HTML or XHTML.
* src/wt/WText.C: autodetect common block-style XHTHML content and
call setInline(false) for block elements (helps in producing valid
XHTML).
* src/Ext/Widget.C: fix for Ext date picker and calendar with Firefox 3
* src/web/WebRenderer.C: fix JavaScript to reload an old session
(again!)
02-07-2008:
* src/wt/WAppliation.C: block events from widgets under the modal
dialog cover
01-06-2008:
* src/wt/WServer[.C]: API to start and stop the embedded http
server programatically.
* src/Ext/TextEdit.C: fix forgotten string literal bug (Michael
Ivanov)
* src/wt/WApplication.C: add auto-centering for WDialog using
JavaScript (Michael Ivanov)
30-06-2008:
* src/wt/WGridLayout.C, src/wt/StdGridLayoutImpl.C: unify
cross-browser handling, fix alignment bugs, border handling
27-06-2008:
* src/Ext/Widget.C: eliminate client-side memory leak of ExtW array
* src/wt/StdGridLayoutImpl.C: fix minimum row height calculation
bug, and some clean up + internal doc improvements
* src/Ext/Container.C: fix interference bugs between Ext and Wt
layout managers
* src/wt/WBoxLayout, src/wt/WGridLayout: implement alignment
25-06-2008:
* src/wt/WBoxLayout[.C], src/wt/WGridLayout[.C],
src/wt/WBorderLayout[.C], src/wt/WContainerWidget[.C]: implemented
layout management for WContainerWidgets
* examples/chat: simplified by using layout managers instead of
absolute CSS layout.
* src/wt/WApplication.C: reset padding to 0 for the body. Add
padding to the WApplication::root() if you want to have it back.
* src/web/DomElement.C: change cancelEvent() signature, and add
emulate IE support for setMinimumSize() (using CSS expressions),
add support for CSS property white-space
* src/web/skeleton/Wt.js: add pixel calculation routines
* src/wt/WApplication.C: define declared functions as soon as
possible
* src/wt/WText[.C]: add setWordWrap() method
* src/wt/WLabel.C: use setWordWrap(false) for the text
* src/wt/WMenuItem.C: do not set margin-right for horizontal
items (Billy Muma)
18-06-2008:
* CMakeLists.txt: fixed CONFIGDIR issues
* src/http/Reply.[Ch]: fixed non-multi threaded build
* src/wt/WTabWidget[C], src/wt/WMenu[C]: reimplement
currentChanged signal
17-06-2008:
* src/wt/WContainerWidget.C: fix bug caused by not searching child
list before inserting child, triggered when using insertBefore()
* src/Ext/Dialog.C, src/Ext/MessageBox.C: workaround for missing
cursor problem in FireFox 1.5 and 2
16-06-2008:
* CMakeLists.txt: CONFIGDIR variable (from Pau Garcia i Quiles)
* src/CMakeLists.txt: use a macro for FileToString
* examples/wtwithqt: new example and library for interopability
between Wt and Qt4.
13-06-2008:
* LICENSE: Clarified that GPL Wt is only licensed under the
second version of the GNU GPL (requested by debian folks)
* src/wt/WWebWidget.C: performance improvement, do not search child
list before inserting child because we know for sure that it isn't
there
* src/Ext/Dialog.C: do not use display:none since this may
cause problems with certain Ext widgets that need hide-with-offsets
* src/Chart/WAxis[.C]: add support for axis titles with custom font
12-06-2008:
* src/Ext/WWidgetItemImpl: do not use display:none since this may
cause problems with certain Ext widgets that need hide-with-offsets
11-06-2008:
* add WEnvironment::pathInfo()
10-06-2008:
* refactoring to simplify WWebWidget implementations
* preliminary support for AJAX on IE Mobile. Things that do not
yet work include WFileUpload, WTimer, and there are many rendering
layout glitches (such as in the tree list stuff).
* src/web/DomElement.C, src/web/WebController.C: fix handling
multiple buttons when JavaScript is not available
* src/Ext/TableView.C: clearSelection() fix (Archimedes Cortes)
* src/wt/WFormWidget, src/wt/WValidator: add an inputFilter()
method which allows filtering input characters against a regular
expression.
* src/wt/WTree.C: let selection only on the label, so that other
interactive widgets may be present in other columns
* src/web/DomElement.C: support return value, note this may break
existing behaviour of JavaScript slots, since they really need to
return properly! Better cross-platform event handling.
30-05-2008:
* src/http/Server.[Ch]: fix potential thread safety issue on shutdown
(Max M)
28-05-2008:
* src/Ext/LineEdit[.C]: add setMaxLength()
* src/wt/WAnchor.C: fix targetChanged_ is uninitialized bug
27-05-2008:
* src/fcgi/Server.C, src/web/Configuration.C: support valgrind arguments
* src/web/Configuration.C: fix close(-1) valgrind warning, and
read 'valgrind-path' from fcgi-configuration
26-05-2008:
* charts example: better support without JavaScript
* src/Ext/NumberField: fix undefined reference: setDecimalPrecision()
* src/Ext/TableView: add setColumnAlignment() method
* src/web/DomElement.C: better support for anchor onclick events:
use browser default when used with a modifier, otherwise prevent
browser default
* src/web/WebSession, src/web/WebController: propagate initial history
as a history event after application construction
* various places: documentation improvements
21-05-2008:
* src/web/WWebWidget.C: allow disabling the stubbing of small
widgets (added setLoadLaterVisible() method)
* src/wt/WWidget: add htmlText() method to public API
20-05-2008:
* src/wt/WTreeNode.C, src/wt/WIconPair.C: performance improvements
* src/wt/WTree.C: suppress browser text selection when selection is
enabled
* src/web/skeleton/Ajax.html: support for IE 8 beta
* various places: documentation improvements
* src/wt/WApplication[.C]: added WApplication::applicationName(),
from Goetz Babin-Ebell.
* src/wt/WWebWidget.C: optimize widget destruction
15-05-2008:
* src/web/WebSession.C: fix build problem when threading is disabled
* src/wt/WVmlImage.C, Wt.js: fix selection problem on IE
14-05-2008:
* src/wt/WInteractWidget.C: block changed signal after enterPressed
when the enterPressed signal is connected to get same behaviour across
all browsers
* src/wt/WLenghtValidator.C: fix bug in constructor
* src/wt/WLineEdit[.C]: add setMaxLength()
* src/wt/WWidget.C: disable the fixed JavaScript implementation
for hide() and show() and revert to stateless slot learning by
default to take into account reimplement setHidden() methods. This
is now overridden only in WTreeNode.
* src/web/CgiParser.C: open spoolfile in binary mode, fixes wrong
behaviour with binary files on Windows platforms
* src/wt/WApplication: revert behaviour change for url() to return
the entire application path
* src/wt/WSlider.C: avoid compile warning with gcc 4.2
13-05-2008:
* src/wt/WValidator[.C], src/wt/WIntValidator[.C],
src/wt/WDoubleValidator[.C], src/wt/WDateValidator[.C],
src/wt/WRegExpValidator[.C]. src/wt/WLengthValidator[.C],
src/wt/WFormWidget[.C]: add javaScriptValidate() for
client-side validation
* src/wt/WDate[.C]: small cleanup and add conversion to perl
regular expression for client-side validation
* put Wt stateless client-side routines in a version-dependent
namespace WT_CLASS
* src/wt/WMessageResources.C: preserve white space and new lines for
message resources
11-05-2008:
* src/wt/WSignal[.C]: reduce memory for unused event signals, and
add support for preventing the default handler (untested)
* src/wt/WInteractWidget: better keyboard event documetation
* src/wt/WTree[.C]: support for standard behaviour of Control and
Shift modifiers in extended selection mode
10-05-2008:
* src/web/DomElement.C, src/web/skeleton/Wt.js, src/wt/WEvent[.C]:
improved keyboard and mouse event information
* src/wt/WInteractWidget: better keyboard event documetation
* src/wt/WTree[.C]: support for standard behaviour of Control and
Shift modifiers in extended selection mode
08-05-2008:
* cmake/WtFindBoost.txt, src/web/random_device.cpp: add support
for MacOS X
* src/wt/WAbstractItemModel: add asString(const boost::any&) and
asNumber(const boost::any&), and add warnings when trying to read
or write data outside the bounds
* src/wt/WAbstractToggleButton.C, src/wt/WFormWidget.C: avoid
double changed event propagation (needs exception for bug in IE6
and IE7).
* src/wt/WCanvasPaintDevice.C: improve text rendering, optimize
path rendering, and fix bug with clipping and transformations
* src/wt/WColor: documentation improvements, and specify default
colors numerically
* src/wt/WComboBox: documentation improvements
* src/wt/WComboBox.C: do not emit changed() event when changing
the values using setCurrentIndex()
* src/wt/WDate: add support for conversion to integers using
julian day calculation, and add methods addDays(), addMonths(),
and addYears(), and fix string parse bug s/1900/2000
* src/wt/WDoubleValidator: fix default argument to real -inf
* src/wt/WPainter, src/wt/WVmlImage: add support for rectangle
clipping to VML renderer
* src/wt/WPainterPath: add support for bounding box calculations,
fix inverted angle calculation in getArcPosition()
* src/wt/WRectF: add intersection test and united() method
* src/wt/WResource: add write(std::ostream&) method to serialize a
resource (e.g. to a file)
* src/wt/WSvgImage: optimize paths even when transformations
change (only translations), fix clipPath definition so that it
works with inkscape and opera, and make drawText() more accurate
* src/wt/WVmlImage: optimize paths through transformations, and
use multiple parallel paths to avoid overlap artefacts, and add
full text support (including rotations and scales)
* src/wt/WWebWidget: fix bug with double processing of new siblings
* src/wt/WWidget: move enums to Wt:: scope (with full backwards
compatible support)
* src/Chart/: first release of the Wt charting library
* examples/charts/: example demonstrating the Wt charting library
* src/wt/WPanel: new widget (will evolve to support many standard
options you want for a panel)
29-04-2008:
* src/wt/WLength: Added multiplication operator, and toPixels()
method
* src/wt/WFont: Fixed equality operator: fixed sizes are now also
compared
* src/wt/WVmlImage.C, src/web/WebController.C, src/wt/WEnvironment,
src/web/skeleton/Boot.html: Fixed rendering on high density
displays (DPI scaling)
25-04-2008:
* CMakeLists.txt: Dynamic/static boost build fix
24-04-2008:
* CMakeLists.txt: FindWt.cmake is now installed in /usr/share/...
instead of /usr/usr/share/...
* src/wt/WCssDecorationStyle.C: bugfix for setting background colors
19-04-2008:
* src/web/WWebWidget.C: also update form objects in addChild()
and removeChild (could be optimized later)
18-04-2008:
* CMakeLists.txt: LIB_INSTALL_DIR fixes. LIB_INSTALL_DIR must now be
a relative path.
* src/web/WebController.C: reroute all methods that may call user
code through WApplication::notify() (including rendering and
application refresh())
* src/wt/WApplication[.C], src/web/WebSession[.C]: allow
post-construction and pre-destruction application initialization
and finalization
* src/wt/WApplication[.C], src/web/WebSession[.C]: attachThread()
attaches an auxiliary thread to an application context
* src/http/Connection.C: use graceful connection shutdown on timeout,
to avoid the occasional 502 proxy errors
17-04-2008:
* src/http/Connection.C. src/http/Reply.C: fix race condition on
shutdown, protect connection_ with a mutex, and illegal access to
dead connection's request in the logging
* src/http/HTTPRequest.[Ch]: keep a shared pointer (ReplyPtr)
instead of raw pointer for the WtReply
* src/web/WebController.C: remove killed sessions from sessions
map from sessions map in forceShutDown() so that they do not get
illegally accessed from expireSessions().
* src/web/WebSession: do not call finalize() on 0 app_
* src/wt/WResource: setRequest() flushes a previous request if
there is already one
* src/wt/WMenuItem.C: fix memory leak with LazyLoading
* various places: make build work on gcc 3.4.0 (thanks to Petr Cerny)
14-04-2008:
* src/web/DomElement.C: do not use innerHTML in xhtml (opera
doesn't like it with inline SVG)
* src/wt/WPaintedWidget.C: prefer InlineSVG on Opera
* src/wt/WPaintDevice.C, src/wt/WVmlImage.C: scale pen widths with
transform
* src/web/skeletons/Wt.js: import XML nodes with correct namespace
into DOM
* revert commit 4e7766d105888ae898ca6a8d7446d2188ae09846, since IE
cannot handle special tokens in DOM element id's
* release 2.1.2
13-04-2008:
* src/wt/WPainter[.C], src/wt/WCanvasPaintDevice[.C],
src/wt/WVmlImage[.C], src/wt/WSvgImage[.C]: add drawImage() methods
* src/wt/WRectF.C: fix setX() and setY() incorrect width adaptation
* src/wt/WSvgImage.C: fix regression in drawLine
* src/wt/WTransform.C: fix double comparison in SVD decomposition
* src/wt/WVmlImage.C: fix drawArc() wrong transformation problem
12-04-2008:
* src/web/DomElement.C, src/web/skeleton/Wt.js: capture() mouse
down so that all subsequent mouse events are received by the same
element/widget
* src/web/WebRenderer.C: use JS reload(true) to force reload, and
disallow caching of bootstrap HTML
* src/web/WebRenderer.C, src/wt/WVmlImage.C: use VML in standards
compliant rendering mode
* src/web/skeleton/Wt.js: make private functions really sit within
"Wt" closure
* src/wt/WJavaScriptSlot.C: fix wrong JavaScript code when JSlot
is not owned by a WWidget, and thus not using function
declaration, and define JavaScript functions before loading
* src/wt/WPaintedWidget[.C]: update() on resize()
* src/wt/WSlider[.C]: initial implementation of a slider
control (rendered using WPaintedWidget)
* src/Ext/TabWidget[.C]: make sure currentIndex() is updated before
propagating the signal
* src/wt/WVmlImage.C: correct -1 vertical offset problem
* src/wt/WTreeTableNode.C: fix seg fault of calling virtual method
addChildNode() from WTreeNode constructor
* src/wt/WTree.C: fix seg fault on consecutive calls of setTreeRoot()
* src/wt/WTreeNode[.C]: rename expanded() to isExpanded() and add
two signals, expanded and collapsed
* src/wt/WSignal: allow late binding of a relay signal to
EventSignal
* src/wt/WTableTreeNode: change incorrect protected scope of
addChildNode() to public
11-04-2008:
* src/wt/WPainter[.C]: expand API with setViewPort() and
setWindow() methods
* src/wt/WTransform.C: fix reflexion bug in WTransform's SVD
* src/wt/WPen[.C]: define 0 width as cosmetic pen of width 1
pixel, independent of transformation matrix
* Boost 1.35 support
* CMakeLists.txt: The static version of Wt is now default
built on Windows
10-04-2008:
* src/wt/WApplication[.C]: fix regression in
WApplication::processEvents()
* src/wt/WPainter[.C]: add WPainter::save() and
WPainter::restore() methods
* src/wt/WTransform.C: handle reflexions correctly in the singular
value decomposition
* Released 2.1.1
09-04-2008:
* src/wt/WLineF, WPointF, WRectF, WPaintDevice, WPainter, WPen,
WBrush, WPainterPath, WVmlImage, WSVGImage, WCanvasPaintDevice:
complete implementation and documentation
* src/wt/WString: improve documentation
07-04-2008:
* src/wt/WTreeNode[.C]: add virtual expandable() method which
returns whether a node is expandable (even when not populated)
* src/Ext/TabWidget.C: addTab(WWidget *, const WString&) checks if
the widget is a Panel, and only creates a Panel if not.
* src/wt/WJavaScriptSlot[.C], WObject[.C], add
implementPrelearned() to directly specify the JavaScript behavior
for a method. Add support to switch the implementation of a method
between implementStateless() and implementJavaScript().
* src/wt/WTreeNode[.C]: add setChildCountPolicy() to enable the
child count next to the label, which now by default is disabled
* src/wt/WWidget.C, src/wt/WWebWidget.C: performance optimization:
change implementation of hide() and show() from stateless to
prelearned
* src/wt/WTreeTable[.C]: use offsetHeight instead of clientHeight and
offsetTop to solve layout problem ?
* src/wt/WObject[.C]: use a simple 64-bit encoding for a valid
JavaScript identifier id
02-04-2008:
* src/Ext/*.C: performance improvement: change config generation
to use streaming instead of string concatenation
* src/Ext/*.C: performance improvement: do not use addUpdateJS
when not yet rendered
01-04-2008:
* src/wt/WApplication: support dynamic loading of scripts,
internal stylesheet changes, and external stylesheets. This fixes
the problem with using Ext widgets only later in the application.
* src/wt/WTableRow[.C], src/wt/WTableColumn[.C]: add support in
public API
* src/wt/WApplication.C: move default CSS for widgets to the
widget constructors
* src/wt/Ext/Widget.C, src/wt/WJavaScriptSlot.C: fix bugs when
using setId() to override the auto-generated id's.
* src/wt/WEnvironment[.C]: make hostName() and clientAddress()
robust to proxies at either the client or server side, add
urlScheme() method.
* src/fcgi/Server.C, src/http/PosixMain.C,
src/web/WebController.C: add support for multiple entry points
* src/http/Configuration.C: add --servername option to override
the DNS name as default host name
* src/http/Configuration.C: fix -1 error when removing trailing
'/' from directories.
* src/web/CgiParser.C: use GNU regex when HAVE_GNU_REGEX is defined.
* src/web/Configuration.C: add behind-reverse-proxy boolean
configuration option, and separate general from FastCGI specific
settings
* src/web/DomElement.C, src/web/EscapeOStream.C,
src/web/WebRenderer.C: more rendering performance improvements
* src/web/WebController.C: use GNU regex when HAVE_GNU_REGEX is defined.
* src/web/WebController.C, src/web/WebRenderer.C,
src/web/WebSession.C: preliminary support for embedded application
mode, cross-domain AJAX using dynamic script tags, and automatic
conversion from relative to absolute URLs
* src/web/skeletons/: reorganisation to have modular javascript,
and encapsulation in JavaScript "classes" to allow multiple
applications in a single page (in the future)
* src/wt/WApplication.C: make "Loading" feedback work properly on
all browsers
* src/wt/WCssDecorationStyle.C: do not generate no-op JavaScript
* src/wt/WCssStyleSheet[.C]: add functionality to check whether a
particular rule has already been added
* src/wt/WMessageResources.C: do not read the same XML file twice
when locale is empty
* src/wt/WPushButton.C: do not generated no-op JavaScript
* src/wt/WResource: change suggestFilename to suggestFileName, add
addHeader() method
* src/wt/WSignal.C: fix double removal of a user event signal from
the exposed signals list
18-03-2008:
* src/wt/WStackedWidget[.C]: fix bug when trying to add a composite
widget to a stack (cannot yet call hide()) through parent passing,
reported by Michael Ivanov
17-03-2008:
* src/web/DomElement.C: fix regression introduced 04-03-2008 with
alternate hiding method interfering with setPositionScheme()
* src/Ext/ComboBox.C: use modelColumn when indexing into model.
* src/web/DomElement.C: various performance improvements (const
char * for string literals)
* src/web/EscapeOStream[.C]: performance improvements
* src/web/FileServe.C: performance improvement: avoid char-based I/O
* src/web/WebRenderer.C: performance improvements: do not use
formName(), instead use pointer, do not propagateRenderOk() before
initial render, do stateless slot learning in JavaScript update
* src/wt/WObject.C: performance improvement: use sprintf() in formName()
* src/wt/WSignal.C: performance improvements: use local info to
track whether a signal was exposed instead of the expensive call
to WApplication
* src/wt/WWebWidget.C: performance improvements
* src/wt/WTreeNode[.C]: virtual method displayedChildCount()
* src/web/skeleton/Ajax.html: fix offset problem in coordinate
calculations
* src/wt/TableView[.C]: use SelectionBehavior instead of
SelectionUnit, which is now deprecated
* src/wt/WSelectionBox[.C]: add support for multiple selection
* src/web/DomElement.C: fix button wrap when using IE6 with
JavaScript disabled
* all: various documentation cleanups
13-03-2008:
* wthttpd: make build without thread support really work without
linking to a thread library
* src/mxml/mxml-file.c: fix unicode encoding to not encode twice,
bug that was triggered on linux-arm platforms
* src/mxml: merge with latest official release 2.5
* src/wt/WDate.C, src/http/Request.C: fix non-cost string literals
* src/web/CgiParser.C: fix a regression to detect content-type
12-03-2008:
* src/wt/WPainterPath: complete API, largely untested
10-03-2008:
* src/wt/WPainterPath and devices: implement painter path arcTo()
06-03-2008:
* examples/wt-homepage/: updated to emweb design
* src/wt/WApplication.C: disable state system for WebKit, since it
does not work at all
* src/wt/WMessageResources.C, src/wt/WWebWidget.C, src/web/DomElement.C:
do not let mxml self-close non-self-closing tags (gives problems in IE)
05-03-2008:
* src/wt/WMenu[.C]: added method setRenderAsList() which allows
the menu to be rendered as an HTML list
* src/wt/WContainerWidget[.C]: added methods setList(), isList(),
isOrderedList(), isUnorderedList(), that allow the container to
be used to render HTML and lists.
04-03-2008:
* src/wt/WTable.C: correctly participate in slot learning when
stubbed
* src/wt/WWebWidget[.C]: allow alternate method for hiding, which
propagates to parents. methods does not use display: none
* src/Ext/ComboBox.C, src/Ext/DateField.C: use alternate method
for hiding
03-03-2008:
* examples/extkitchen/ExtKitchenExample.C: modify example to use
a WTable for layout
02-03-2008:
* src/wt/WSignal: connect new signals at_front, since it seems
that boost signals will call slots being appended to the signal
during slot invocation -- contrary to the documentation
* src/wt/W[.*]Image: add support for VML rendering
* src/wt/WVmlImage.C: make text alignment work properly
01-03-2008:
* src/wt/WMenu[Item][.C]: make itemSelected signal normal signal,
instead of being called from within stateless slot
* src/web/WebRenderer.C: do not show 'ignore' for updates to widgets
not inserted into the widget hierarchy
* src/wt/WObject.C: do not show internal error when (no)FormData
is called
* src/http/WinMain.C: adapted for non-boost asio
* src/wt/WWebWidget.C: Allow widget reparenting. setParent() for a
widget who has already a parent used to be a no-op; now it reparents
the widget.
* */CMakelists.txt: added 'd' suffix to debug libraries; added
FindWt.cmake (from Pau Garcia i Quiles)
* Released 2.1.0
29-02-2008:
* */CMakeList.txt: Restructured the cmake files
* wthttp: made zlib dependency optional
* wthttp: asio_error becomes asio_error_code and asio_system_error
* src/Ext/Widget.C: make setHidden() behave properly also when
not yet rendered
25-02-2008:
* documentation updates
23-02-2008:
* several fixes for JavaScript handling after a reload of the same
session
22-02-2008:
* src/wt/WTreeTable.C: fix layout bug when using a border for the
header
16-02-2008:
* src/wt/WAnchor[.C]: allow referencing to dynamically generated
documents
15-02-2008:
* src/Ext/TableView.C: implement enableColumnHiding() methods
* src/, src/http: move to boost-1.34.1 and (boost/non-boost) asio 0.3.9
* src/Ext/Dialog.C: implement setSizeGripEnabled(bool) method
* src/Ext/Panel[.C]: add collapse(), expand() methods and fix
setCollapsed() implementation
* src/Ext/TableView.C: fix setAutoExpandColumn min and max widths
14-02-2008:
* src/Ext/PagingToolBar.C: render other buttons that were added,
as suggested by Michael Ivanov, 08-01-2008
* src/wt/WLabel[.C]: add setBuddy(Ext::FormField *) as suggested
by Pau Garcia i Quiles, 16-01-2008
* src/wt/WAnchor[.C]: add setTarget() method
13-02-2008:
* src/Ext/MessageBox.[Ch]: fix delete from buttonClicked crash,
reported by Alex, 05-01-2008
* src/wt/WAnchor[.C]: fix anchor implementation problem reported
by Lasse Karkkainen, 15-01-2008. Note that the API has changed,
since we no longer use a WLabel (which caused the problem). Unless
your code relied on the fact that it was implemented using a label
there should be no problem in adapting to the new API.
* src/web/WebController.C: fix IE6 history problem reported by Joe
Croft, 28-01-2008
* src/web/WebRender.C: fix synchronization problem of form
objects, bug and patch by Goetz Babin-Ebell
* src/wt/WContainerWidget.C: syntax fix, by Goetz Babin-Ebell
* src/wt/WString and related: use UTF8 internally, as suggested by
Goetz Babin-Ebell
02-01-2008:
* src/wt/WTreeTable[.C]: scroll content while keeping headers fixed
* src/wt/WTreeNode[.C]: add support for an invisible root node
* src/Ext/LayoutImpl.C: trigget layout recalculation after adding a
panel
* src/Ext/Button.C: fix bug not showing initial enabled/disabled state
* src/Ext/WWidgetItemImpl.C: wrap non-Container Widgets also, so that
their style is not lost
* src/Wt/WPainter: drawLine methods
* src/web/skeleton/Ajax.html: fix mouse position calculations in
presence of scrolled widgets
01-01-2008:
* src/web/WebController.[Ch], src/http/HTTPStream.[Ch]:
addSocketNotifier and removeSocketNotifier as virtual methods in
WebStream instead of callbacks from wt lib to connector lib
30-12-2007:
* src/wt/WRectF[.C], src/wt/WCanvasPaintDevice[.C], ...: further
improvements to painting infrastructure
* src/wt/WSignalMapper: API changes to be able to build on MSVC
* src/wt/WEnvironment: allow reading content type, and raw CGI
environment variables
* src/web/Configuration.C: switch back to default to HTML mime type
29-12-2007:
* src/http/PosixMain.C: use asio::thread by default
* src/wt/WContainerWidget.C: fix bug to use delete[] instead of delete
on overflow_ array
* src/wt/WApplication: add notify(const WEvent& e) method to allow
custom event exception handling.
* src/wt/WEnvironment: add cgiValue() method to inspect any CGI
environment variable
18-12-2007:
* various places: pass string by reference where it makes sense
* Ext/*: upgrade from Ext 1.x to Ext 2.x series, main addition is a
full layout management system
12-12-2007:
* src/web/WebRenderer.C, src/web/DomElement.C, ...: serve XHTML
content-type if the browser accepts it, and if it is not disabled
in the config.xml file
* resources/orbited.js: produce valid XHTML (no document.write())
* resources/rsh.js: produce valid XHMTL (except for IE)
* src/wt/WApplication[.C]: split javascript in javascript that
needs to be run before starting the DOM (which is rendered
everytime the page is reloaded), and javascript that is run to
manipulate the DOM (which is the default)
* src/web/DomElement.C: fix button wrap layout that was adding
extra padding in non-javascript support rendering
* src/wt/WApplication.C: use lowercase CSS element selectors!
you will need to change your style sheets accordingly!
* src/wt/WBrush[.C], src/wt/WPaintDevice[.C],
src/wt/WPaintedWidget[.C], src/wt/WPainter[.C], src/wt/WPen[.C],
src/wt/WPointF[.C], src/wt/WVectorImageResource[.C]: initial
check-in of incomplete painting infrastructure
10-12-2007:
* src/web/WebController.C: keep the server push connection alive
when receiving a heart-beat
* src/web/skeleton/Ajax.html: preliminary WinCE IE support
* src/wt/WImage[.C]: add loaded event
02-12-2007:
* examples/simplechat: added a chat example (replaces previous
stupid serverpush example)
* src/web/WServerPushResource.C, resources/orbited.js: several
improvements to make server-push work
* src/web/WebSession.C: allow updating another session from within an
existing session
* src/wt/WContainerWidget: add setOverflow() method for easier
scrollbars
* src/wt/WString: add operator< to be able to put them in std::set<>
01-12-2007:
* src/mxml: updated to mxml-2.4
* resources/rhs.js, resources/json2005.js, src/wt/WApplication.C,
src/web/WebController.C: upgraded to RSH 0.6 RC1 (works now in IE,
Firefox and Opera)
* examples/hello/hello.C: make example more interesting
* examples/serverpush/serverpush.C: adapted to test intermixing
event server and client events
* src/Ext/TableView.C: disconnect connections when changing model
* src/fcgi/FCGIStream.[Ch]: add socket notifier stubs
* src/http/Server.[Ch], src/web/WebController.[Ch]: implement
socket notification
* src/http/WtReply.[Ch]: robust handling of server shutdown and
connection closing
* src/web/WServerPushResource.C: adapted for orbited.js for as
server-push library
* src/web/WebController.C: no longer add --Quited to application
title when quiting an application
27-11-2007:
* src/Ext/MessageBox.C: fix setting prompt value
* src/Ext/DataStore[.C], src/Ext/ComboBox[.C],
src/Ext/TableView[.C]: bundle model changes leading to
significant reduction in generated JS for model changes.
* src/Ext/DataStore[.C], src/Ext/TableView[.C]: support resetting the
model, and process row removals in reverse order
* src/wt/WAbstractToggleButton.C: use click signal instead of
change to make checked/unChecked signals work in IE.
* src/wt/WSignal.C: reorder emission of stateless and dynamic slots,
to avoid processing on a signal that has been deleted (which should
not happen in a stateless slot).
23-11-2007:
* src/wt/WButtonGroup, src/Ext/RadioButton.C: add support for
Ext::RadioButton in WButtonGroup
23-11-2007:
* CMakeLists.txt, src/CMakeLists.txt: add build option to disable
thread (in wthttpd) altogether
22-11-2007:
* src/Ext/DataStore.C: fix use of DataStore when removing rows
15-11-2007:
* src/Ext/DataStore.C: fix regression bug when inserting rows
* src/Ext/ComboBox.[Ch]: add activated signal
* src/Ext/DataStore.C: fix use of DataStore when inserting rows
12-11-2007:
* src/Ext/ProgressDialog.C: don't show by default (unlike Qt)
26-10-2007:
* src/Ext/TableView.C: add missing method implementations
21-10-2007:
* src/Ext/DataStore.[Ch], src/Ext/TableView.[Ch]: support multiple row
selection, and be robust to sorting by using ids instead of row
indexes
* src/Ext/TabWidget[.C]: fix bug where children were not inserted
into the widget tree, and thus could not implement event handling
* src/wt/WTreeTableNode.C: fix konqueror/IE6 rendering problems
18-10-2007:
* src/Ext/TableView[.C]: add methods for modifying and inspecting
the current selection
17-10-2007:
* src/wt/WMessageResources.C: remove the trailing '\n' that was
being added to every WString in a resourcefile by mxml
10-10-2007:
* examples/extkitchen/ExtKitchenExample.[Ch]: add a password prompt
dialog example
* src/wt/WAbstractToggletButton.[C], src/wt/WCheckBox.[Ch],
src/wt/WRadioButton.[C]: fix reversion caused by constructor with
bool as first argument resulting in missing label text
* src/wt/WFormWidget.[C]: add setFocus() method
* src/wt/WInPlaceEdit.C: focus line edit using setFocus()
stateless slot
* src/wt/WScrollArea.[C]: add vertical scrollbar stuff
01-10-2007:
* src/web/skeleton/*.html: Reorder inline and external stylesheets so
that Wt's default rules can be overridden by applications
* src/wt/WAnchor: Inherit from WContainerWidget so that other stuff can
be added to it
27-09-2007:
* src/CMakeLists.txt: integrate mxml sources directly in libwt.so (to
avoid the static non-PIC .a in dynamic .so problem with CMake)
24-09-2007:
* resources/dhtml_dhtmlHistory.js, src/web/WebController.C: use
dynamically generated blank image
* src/wt/WApplication.C: use dhtml_dhtmlHistory.js in directory
specified using resourcesURL property
* src/web/skeleton/Ajax.html: fix Loading... CSS for Internet Explorer
21-09-2007:
* src/wt/WMenuItem.C: fix segfault when container stack is deleted
before menu.
* src/mxml/*: supply a version of mxml(patched 2.3) which is used
by default instead of a system-installed mxml.
11-09-2007:
* src/wt/WSignal: fixed EventSignal.emit() to also emit stateless
slots.
08-09-2007:
* src/wt/WMenuItem, src/wt/WMenuItem.C: decouple render widget
from activate signal, move margin for horizontal items from WMenu.C
* src/wt/WObject, src/wt/WSignal: use WObject::Method typedef
* src/examples/wt/RoundedWidget.C: implement missing method, add
enabledRoundedCorners method for changing color in stateless
slot functions.
* src/wt/WTabWidget, src/wt/WTabWidget.C, others: implement
WTabWidget with doxygen look, based on WMenu.C
07-09-2007:
* src/Ext/SplitterHandle.C, src/Ext/Splitter.C: implemented full
awareness of configured minimum and maximum sizes.
* src/Ext/TableView.C, src/wt/WAbstractItemModel.C: added full
support for other data types in models with respect to rendering
and editing
04-09-2007:
* src/CMakeLists.txt: added -DBOOST_SPIRIT_THREADSAFE, fixes
thread safety problem (Max M)
* src/http/Reply.C: implemented If-Modified-Since, Last-Modified,
and 304 Not Modified response codes
* *CMakeLists.txt: add soversioning
* src/wt/WDllDefs: added WT_VERSION define (4gsystems)
* src/wt/WTimer: WTimer memory leak patch (4gsystems)
03-09-2007:
* all: Released 2.0.5.
Didn't keep track of ChangeLog, intending to improve on
that, using GNU Changelog guidelines.
12-05-2007:
* Haven't kept track of things in ChangeLog.. Sorry.
18-02-2007:
* various transient and widget memory improvements
sample of sizeof() before and after:
WObject: 48 40
WResource: 84 60
WWidget: 92 68
WWebWidget: 592 108
WInteractWidget: 1356 300
WText: 1384 328
WTable: 1376 320
16-02-2007:
* New widget: WTreeTable and example File Browser.
18-12-2006:
* Use Boost.Signals instead of home-brew signal/slots
* Drag&Drop seems to work with firefox/konqueror, probably needs more
testing
* valgrind checked, no warnings no errors !
* adopt wide string array
05-12-2006:
* Solaris patches by Patrick Mauritz
* Drag&Drop, initial implementation (not yet complete)
* Drag&Drop example
01-12-2006:
* Happy birthday, Wt.
* many changes not documented in the Changelog.
07-09-2006:
* Support for cookies for session management (when available) instead
of URL rewriting
* Support for reading and setting cookies (in respectively WEnvironment
and WApplication)
04-09-2006:
* Starting to finalize event handling: WMouseEvent and WKeyEvent
* working on a new example and a new widget: WVirtualImage
02-09-2006:
* Added WTreeNode and WIconPair widgets, derived from the
treelist example with different loading policies, and OO
overloading capabilities.
* Corrected API bug: hide() and show() are non-virtual but
setHidden() is the virtual one that you should reimplement
* Remove WCssDecorationStyle from WWebWidget header, and do
not allocated it until needed. Saves alot on memory usage
when using many widgets.
01-09-2006:
* Moved Menu from the homepage example to become WMenu. Provides now
different loading policies for the items, and customizable
WMenuItem look (through OO inheritance).
* Fixed a nasty bug in stateless slot learning.
30-08-2006:
* implemented WJavascriptSlot (abdiel) for pure client-side event
handling
* implemented WSuggestionPopup
* use two-phase rendering for all updates, and configuration option
to change the threshold
* separated examples in their own doxygen documentation
* added ContactSuggestions widget to the composer example
* various documentation improvements
* fix a bug with deleting a signal while emitting the slots (abdiel)
* avoid (?) race condition in blur() and click() handler in WSuggestionPopup.C
24-08-2006:
* mindfully implemented all quoting stuff
* change behaviour at quit(): simply render the last changes, but
add -- Quited. to the title, and avoid receiving new events.
* fix non-javascript look for the wrap buttons.
22-08-2006:
* add WWidget::isVisible()
* workaround for Firefox keeping 'Transferring data from:'
* yet another WFileUpload implementation -- the final one ?
* misc improvements to Composer example
* add support for external stylesheets
* fix stateless slots discarding changes after serving resource
* allow caching of WWidget resources
21-08-2006:
* Added the composer example
* Fixed bug not quoting href attribute in DemoTreeList
* CgiParser: revert old behaviour, parsing through big requests
* move helper function escape and replace to DomElement
* WFileUpload::fileTooLarge in addition to WAppliation::requestTooLarge
* isLoaded is broken because of WCompositeWidget..., but not needed anyway
* add WEnvironment::getArgument, by Tomek Mazurek
* WFileUpload: looks much better (konqueror, opera & firefox).
* WFileUpload: added alternative firefox implementation that is even better (but is not used now)
* WFileUpload: add isUploaded to check if calling upload() will do anything
* WLineEdit: bugfix: escape preset text
* WText: bugfix: replace newlines with
#include
#include
#include "Configuration.h"
#include "FCGIStream.h"
#include "Server.h"
#include "WebController.h"
#include "WebMain.h"
namespace {
Wt::WebMain *webMainInstance = 0;
}
namespace Wt {
LOGGER("WServer/wtfcgi");
struct WServer::Impl
{
Impl(WServer& server)
: server_(server),
running_(false),
webMain_(0)
{ }
void run()
{
running_ = true;
if (sessionId_.empty())
startSharedProcess();
else
runSession();
}
void runSession()
{
Configuration& conf = server_.configuration();
if (!Server::bindUDStoStdin(conf.runDirectory() + "/" + sessionId_,
server_))
exit(1);
try {
FCGIStream fcgiStream;
webMainInstance = webMain_
= new WebMain(&server_, &fcgiStream, sessionId_);
webMain_->run();
sleep(1);
delete webMain_;
webMainInstance = webMain_ = 0;
} catch (std::exception& e) {
LOG_ERROR_S(&server_,
"fatal: dedicated session process for " << sessionId_ <<
": caught unhandled exception: " << e.what());
throw;
} catch (...) {
LOG_ERROR_S(&server_,
"fatal: dedicated session process for " << sessionId_ <<
": caught unkown, unhandled exception.");
throw;
}
}
void startSharedProcess()
{
Configuration& conf = server_.configuration();
if (!Server::bindUDStoStdin(conf.runDirectory() + "/server-"
+ boost::lexical_cast(getpid()),
server_))
exit(1);
try {
FCGIStream fcgiStream;
webMainInstance = webMain_ = new WebMain(&server_, &fcgiStream);
webMain_->run();
delete webMain_;
webMainInstance = webMain_ = 0;
} catch (std::exception& e) {
LOG_ERROR_S(&server_,
"fatal: shared session process: caught unhandled exception: "
<< e.what());
throw;
} catch (...) {
LOG_ERROR_S(&server_,
"fatal: shared session process: caught unknown, unhandled "
"exception.");
throw;
}
}
WServer& server_;
bool running_;
std::string sessionId_;
WebMain *webMain_;
};
namespace {
void doShutdown(const char *signal)
{
if (webMainInstance) {
LOG_INFO_S(webMainInstance->controller().server(), "Caught " << signal);
webMainInstance->shutdown();
}
}
void handleSigTerm(int)
{
doShutdown("SIGTERM");
}
void handleSigUsr1(int)
{
doShutdown("SIGUSR1");
}
void handleSigHup(int)
{
doShutdown("SIGHUP");
}
}
WServer::WServer(const std::string& applicationPath,
const std::string& wtConfigurationFile)
: impl_(new Impl(*this))
{
init(applicationPath, wtConfigurationFile);
}
WServer::WServer(int argc, char *argv[], const std::string& wtConfigurationFile)
: impl_(new Impl(*this))
{
init(argv[0], "");
setServerConfiguration(argc, argv, wtConfigurationFile);
}
WServer::~WServer()
{
delete impl_;
destroy();
}
std::vector WServer::sessions() const
{
return std::vector();
}
void WServer::setServerConfiguration(int argc, char *argv[],
const std::string&)
{
bool isRelayServer = argc < 2 || strcmp(argv[1], "client") != 0;
if (isRelayServer) {
LOG_INFO_S(this, "initializing relay server");
Server relayServer(*this, argc, argv);
exit(relayServer.run());
} else {
if (argc >= 3)
impl_->sessionId_ = argv[2];
}
}
bool WServer::start()
{
if (isRunning()) {
LOG_ERROR_S(this, "start(): server already started!");
return false;
}
LOG_INFO_S(this, "initializing " <<
(impl_->sessionId_.empty() ? "shared" : "dedicated") <<
" wtfcgi session process");
if (configuration().webSockets()) {
LOG_ERROR_S(this, "FastCGI does not support web-sockets, disabling");
configuration().setWebSockets(false);
}
configuration().setNeedReadBodyBeforeResponse(true);
if (signal(SIGTERM, Wt::handleSigTerm) == SIG_ERR)
LOG_ERROR_S(this, "cannot catch SIGTERM: signal(): " << strerror(errno));
if (signal(SIGUSR1, Wt::handleSigUsr1) == SIG_ERR)
LOG_ERROR_S(this, "cannot catch SIGUSR1: signal(): " << strerror(errno));
if (signal(SIGHUP, Wt::handleSigHup) == SIG_ERR)
LOG_ERROR_S(this, "cannot catch SIGHUP: signal(): " << strerror(errno));
webController_ = new Wt::WebController(*this, impl_->sessionId_, false);
impl_->run();
return false;
}
bool WServer::isRunning() const
{
return impl_->running_;
}
int WServer::httpPort() const
{
// FIXME, we could get this from the CGI environment.
return -1;
}
void WServer::stop()
{
if (!isRunning()) {
LOG_ERROR_S(this, "stop(): server not yet started!");
return;
}
}
void WServer::run()
{
if (start()) {
waitForShutdown();
stop();
}
}
void WServer::resume()
{
if (!isRunning()) {
LOG_ERROR_S(this, "resume(): server not yet started!");
return;
}
}
void WServer::setSslPasswordCallback(
boost::function cb)
{
LOG_INFO_S(this,
"setSslPasswordCallback(): has no effect in fcgi connector");
}
int WRun(int argc, char *argv[], ApplicationCreator createApplication)
{
try {
WServer server(argv[0], "");
try {
server.setServerConfiguration(argc, argv);
server.addEntryPoint(Application, createApplication);
server.start();
return 0;
} catch (std::exception& e) {
LOG_ERROR_S(&server, "fatal: " << e.what());
return 1;
}
} catch (Wt::WServer::Exception& e) {
LOG_ERROR("fatal: " << e.what());
return 1;
} catch (std::exception& e) {
LOG_ERROR("fatal exception: " << e.what());
return 1;
}
}
}
witty-3.3.4+dfsg.orig/src/fcgi/Server.C 0000644 0001750 0001750 00000042063 12356520372 020106 0 ustar pgquiles pgquiles /*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "fcgiapp.h"
#include "Configuration.h"
#include "FCGIRecord.h"
#include "Server.h"
#include "SessionInfo.h"
#include "WebUtils.h"
#include "WebController.h"
#include "Wt/WIOService"
#include "Wt/WServer"
#include "Wt/WLogger"
using std::exit;
using std::strcpy;
using std::strlen;
using std::memset;
namespace Wt {
LOGGER("wtfcgi");
/*
* From the FCGI Specifaction
*/
// const int FCGI_BEGIN_REQUEST = 1; // unused
// const int FCGI_ABORT_REQUEST = 2; // unused
const int FCGI_END_REQUEST = 3;
const int FCGI_PARAMS = 4;
Server *Server::instance = 0;
bool Server::bindUDStoStdin(const std::string& socketPath, Wt::WServer& server)
{
int s = socket(AF_UNIX, SOCK_STREAM, 0);
if (s == -1) {
LOG_ERROR_S(&server, "fatal: socket(): " << strerror(errno));
return false;
}
struct sockaddr_un local;
local.sun_family = AF_UNIX;
strncpy (local.sun_path, socketPath.c_str(), sizeof (local.sun_path));
local.sun_path[sizeof (local.sun_path) - 1] = '\0';
unlink(local.sun_path);
socklen_t len = offsetof (struct sockaddr_un, sun_path)
+ strlen(local.sun_path) + 1;
if (bind(s, (struct sockaddr *)& local, len) == -1) {
LOG_ERROR_S(&server, "fatal: bind(): " << strerror(errno));
close(s);
return false;
}
if (listen(s, 5) == -1) {
LOG_ERROR_S(&server, "fatal: listen(): " << strerror(errno));
close(s);
return false;
}
if (dup2(s, STDIN_FILENO) == -1) {
LOG_ERROR_S(&server, "fatal: dup2(): " << strerror(errno));
close(s);
return false;
}
return true;
}
Server::Server(WServer& wt, int argc, char *argv[])
: wt_(wt),
argc_(argc),
argv_(argv),
childrenDied_(0),
handleSigChld_(0)
{
instance = this;
srand48(getpid());
/*
* Spawn the session processes for shared process policy
*/
Configuration& conf = wt_.configuration();
if (conf.sessionPolicy() == Configuration::SharedProcess)
for (int i = 0; i < conf.numProcesses(); ++i)
spawnSharedProcess();
}
void Server::execChild(bool debug, const std::string& extraArg)
{
Configuration& conf = wt_.configuration();
std::string prepend;
if (debug && conf.debug())
prepend = conf.valgrindPath();
std::vector prependArgv;
if (!prepend.empty())
boost::split(prependArgv, prepend, boost::is_any_of(" "));
/* up to 3 arguments + 0: argv_[0] client [extraArg] */
const char **argv = new const char *[prependArgv.size() + 4];
unsigned i = 0;
for (; i < prependArgv.size(); ++i)
argv[i] = prependArgv[i].c_str();
argv[i++] = argv_[0];
argv[i++] = "client";
if (!extraArg.empty())
argv[i++] = extraArg.c_str();
argv[i++] = 0;
for (unsigned i = 0; ; ++i) {
if (argv[i] == 0)
break;
LOG_DEBUG("argv[" << i << "]: " << argv[i]);
}
#ifdef WT_THREADED
// Unblocking all signals before exec
sigset_t mask;
sigfillset(&mask);
pthread_sigmask(SIG_UNBLOCK, &mask, 0);
#endif // WT_THREADED
execv(argv[0], const_cast(argv));
delete[] argv;
}
void Server::spawnSharedProcess()
{
pid_t pid = fork();
if (pid == -1) {
LOG_ERROR_S(&wt_, "fatal error: fork(): " << strerror(errno));
exit(1);
} else if (pid == 0) {
/* the child process */
execChild(true, std::string());
exit(1);
} else {
LOG_INFO_S(&wt_, "spawned session process: pid = " << pid);
#ifdef WT_THREADED
boost::recursive_mutex::scoped_lock sessionsLock(mutex_);
#endif
sessionProcessPids_.push_back(pid);
}
}
const std::string Server::socketPath(const std::string& sessionId)
{
Configuration& conf = wt_.configuration();
std::string sessionPath = conf.runDirectory() + "/" + sessionId;
if (conf.sessionPolicy() == Configuration::SharedProcess) {
std::ifstream f(sessionPath.c_str());
if (f) {
std::string pid;
f >> pid;
if (!pid.empty())
return conf.runDirectory() + "/server-" + pid;
else
return std::string();
} else
return std::string();
} else
return sessionPath;
}
void handleSigChld(int)
{
Server::instance->handleSigChld();
}
void handleServerSigTerm(int)
{
Server::instance->handleSignal("SIGTERM");
}
void handleServerSigUsr1(int)
{
Server::instance->handleSignal("SIGUSR1");
}
void handleServerSigHup(int)
{
Server::instance->handleSignal("SIGHUP");
}
void Server::handleSignal(const char *signal)
{
LOG_INFO_S(&wt_, "shutdown (caught " << signal << ")");
/* We need to kill all children */
for (unsigned i = 0; i < sessionProcessPids_.size(); ++i)
kill(sessionProcessPids_[i], SIGTERM);
exit(0);
}
void Server::handleSigChld()
{
handleSigChld_ = 1;
}
void Server::doHandleSigChld()
{
pid_t cpid;
int stat;
while ((cpid = waitpid(0, &stat, WNOHANG)) > 0) {
LOG_INFO_S(&wt_, "caught SIGCHLD: pid=" << cpid << ", stat=" << stat);
Configuration& conf = wt_.configuration();
if (conf.sessionPolicy() == Configuration::DedicatedProcess) {
#ifdef WT_THREADED
boost::recursive_mutex::scoped_lock sessionsLock(mutex_);
#endif
for (SessionMap::iterator i = sessions_.begin(); i != sessions_.end(); ++i) {
if (i->second->childPId() == cpid) {
LOG_INFO_S(&wt_, "deleting session: " << i->second->sessionId());
unlink(socketPath(i->second->sessionId()).c_str());
delete i->second;
sessions_.erase(i);
break;
}
}
} else {
#ifdef WT_THREADED
boost::recursive_mutex::scoped_lock sessionsLock(mutex_);
#endif
for (unsigned i = 0; i < sessionProcessPids_.size(); ++i) {
if (sessionProcessPids_[i] == cpid) {
sessionProcessPids_.erase(sessionProcessPids_.begin() + i);
/*
* TODO: cleanup all sessions that pointed to this pid
*/
++childrenDied_;
if (childrenDied_ < 5) {
spawnSharedProcess();
} else
LOG_ERROR_S(&wt_, "sessions process restart limit (5) reached");
break;
}
}
}
}
}
bool Server::getSessionFromQueryString(const std::string& queryString,
std::string& sessionId)
{
Configuration& conf = wt_.configuration();
static const boost::regex
session_e(".*wtd=([a-zA-Z0-9]{"
+ boost::lexical_cast(conf.sessionIdLength())
+ "}).*");
boost::smatch what;
if (boost::regex_match(queryString, what, session_e)) {
sessionId = what[1];
return true;
}
return false;
}
int Server::connectToSession(const std::string& sessionId,
const std::string& socketPath, int maxTries)
{
int s = socket(AF_UNIX, SOCK_STREAM, 0);
if (s == -1) {
LOG_ERROR_S(&wt_, "fatal: socket(): " << strerror(errno));
exit(1);
}
struct sockaddr_un local;
local.sun_family = AF_UNIX;
strcpy(local.sun_path, socketPath.c_str());
socklen_t len = strlen(local.sun_path) + sizeof(local.sun_family) + 1;
int tries = 0;
for (tries = 0; tries < maxTries; ++tries) {
int result = connect(s, (struct sockaddr *)&local, len);
if (result == -1) {
usleep(100000); // 0.1 second
} else
break;
}
if (tries == maxTries) {
LOG_ERROR_S(&wt_, "connect(): " << strerror(errno));
LOG_INFO_S(&wt_, "giving up on session: " << sessionId
<< " (" << socketPath << ")");
close(s);
unlink(socketPath.c_str());
return -1;
}
return s;
}
void Server::checkConfig()
{
/*
* Create the run directory if it does not yet exist.
*/
Configuration& conf = wt_.configuration();
FILE *test = fopen((conf.runDirectory() + "/test").c_str(), "w+");
if (test == NULL) {
if (mkdir(conf.runDirectory().c_str(), 777) != 0) {
LOG_ERROR_S(&wt_, "fatal: cannot create run directory '"
<< conf.runDirectory() << "'");
exit(1);
}
} else {
unlink((conf.runDirectory() + "/test").c_str());
fclose(test);
}
}
int Server::run()
{
checkConfig();
/*
* We partially parse the FCGI protocol. We need to delineate the
* FCGI_BEGIN_REQUEST in the server stream,
* and the end-of FCGI_PARAMS, for determining presence of the session ID.
* and FCGI_END_REQUEST messages from the application stream.
*/
struct sockaddr_un clientname;
socklen_t socklen = sizeof(clientname);
if (signal(SIGCHLD, Wt::handleSigChld) == SIG_ERR)
LOG_ERROR_S(&wt_, "cannot catch SIGCHLD: signal(): " << strerror(errno));
if (signal(SIGTERM, Wt::handleServerSigTerm) == SIG_ERR)
LOG_ERROR_S(&wt_, "cannot catch SIGTERM: signal(): " << strerror(errno));
if (signal(SIGUSR1, Wt::handleServerSigUsr1) == SIG_ERR)
LOG_ERROR_S(&wt_, "cannot catch SIGUSR1: signal(): " << strerror(errno));
if (signal(SIGHUP, Wt::handleServerSigHup) == SIG_ERR)
LOG_ERROR_S(&wt_, "cannot catch SIGHUP: signal(): " << strerror(errno));
if (argc_ == 2 && boost::starts_with(argv_[1], "--socket=")) {
std::string socketName = std::string(argv_[1]).substr(9);
boost::trim(socketName);
if (!bindUDStoStdin(socketName, wt_))
return -1;
LOG_INFO_S(&wt_,
"reading FastCGI stream from socket '" << socketName << '\'');
} else
LOG_INFO_S(&wt_, "reading FastCGI stream from stdin");
wt_.ioService().start();
for (;;) {
int serverSocket = accept(STDIN_FILENO, (sockaddr *) &clientname,
&socklen);
if (serverSocket < 0) {
LOG_ERROR_S(&wt_, "fatal: accept(): " << strerror(errno));
exit (1);
}
checkAndQueueSigChld();
handleRequestThreaded(serverSocket);
}
return 0;
}
void Server::checkAndQueueSigChld()
{
if (handleSigChld_ == 1) {
sigset_t new_mask;
sigemptyset(&new_mask);
sigaddset(&new_mask, SIGCHLD);
sigset_t old_mask;
#ifdef WT_THREADED
pthread_sigmask(SIG_BLOCK, &new_mask, &old_mask);
#else
sigprocmask(SIG_BLOCK, &new_mask, &old_mask);
#endif // WT_THREADED
if (handleSigChld_ == 1) {
handleSigChld_ = 0;
#ifdef WT_THREADED
wt_.ioService().post(boost::bind(&Server::doHandleSigChld, this));
#else
doHandleSigChld();
#endif // WT_THREADED
}
#ifdef WT_THREADED
pthread_sigmask(SIG_SETMASK, &old_mask, 0);
#else
sigprocmask(SIG_SETMASK, &old_mask, 0);
#endif // WT_THREADED
}
}
void Server::handleRequestThreaded(int serverSocket)
{
#ifdef WT_THREADED
wt_.ioService().post(boost::bind(&Server::handleRequest, this, serverSocket));
#else
handleRequest(serverSocket);
#endif // WT_THREADED
}
bool Server::writeToSocket(int socket, const unsigned char *buf, int bufsize)
{
while (bufsize > 0) {
int result = write(socket, buf, bufsize);
if (result < 0)
return false;
else {
bufsize -= result;
buf += result;
}
}
return true;
}
void Server::handleRequest(int serverSocket)
{
int clientSocket = -1;
try {
/*
* handle a new request
*/
std::vector consumedRecords_;
bool haveSessionId = false;
std::string sessionId = "";
std::string cookies;
std::string scriptName;
for (;;) {
FCGIRecord *d = new FCGIRecord();
d->read(serverSocket);
LOG_DEBUG_S(&wt_, "server read");
if (d->good()) {
// LOG_DEBUG_S(&wt_, *d); BROKEN !
consumedRecords_.push_back(d);
if (d->type() == FCGI_PARAMS) {
if (d->contentLength() == 0)
break;
else {
std::string value;
if (d->getParam("QUERY_STRING", value))
haveSessionId = getSessionFromQueryString(value, sessionId);
if (d->getParam("HTTP_COOKIE", value))
cookies = value;
if (d->getParam("SCRIPT_NAME", value))
scriptName = value;
}
}
} else {
delete d;
break;
}
}
/*
* Session tracking:
* what should we give priority ? We should give priority to the
* cookie, because in that case the URL may still contain an invalid
* session id (when the user had for example bookmarked like that)
*
* But not when we want to get a new session when reloading, in that
* case we ignore the set cookie.
*/
Configuration& conf = wt_.configuration();
if ((conf.sessionTracking() == Configuration::CookiesURL)
&& !cookies.empty() && !scriptName.empty()
&& !conf.reloadIsNewSession()) {
std::string cookieSessionId
= WebController::sessionFromCookie(cookies.c_str(), scriptName,
conf.sessionIdLength());
if (!cookieSessionId.empty()) {
sessionId = cookieSessionId;
haveSessionId = true;
}
}
/*
* Forward the request to the session.
*/
clientSocket = -1;
/*
* See if the session is alive.
*/
if (haveSessionId) {
struct stat finfo;
// exists, try to connect (for 1 second)
std::string path = socketPath(sessionId);
if (stat(path.c_str(), &finfo) != -1)
clientSocket = connectToSession(sessionId, path, 10);
}
while (clientSocket == -1) {
/*
* New session
*/
if (conf.sessionPolicy() == Configuration::DedicatedProcess) {
/*
* For dedicated process, create session at server, so that we
* can keep track of process id for the session
*/
do {
sessionId = conf.generateSessionId();
if (!conf.registerSessionId(std::string(), sessionId))
sessionId.clear();
} while (sessionId.empty());
std::string path = socketPath(sessionId);
/*
* Create and fork a new session.
*
* But not if we have already too many sessions running...
*/
if ((int)sessions_.size() > conf.maxNumSessions()) {
LOG_ERROR_S(&wt_, "session limit reached (" <<
conf.maxNumSessions() << ')');
break;
}
pid_t pid = fork();
if (pid == -1) {
LOG_ERROR_S(&wt_, "fatal: fork(): " << strerror(errno));
exit(1);
} else if (pid == 0) {
/* the child process */
execChild(true, sessionId);
exit(1);
} else {
LOG_INFO_S(&wt_, "spawned dedicated process for " << sessionId
<< ": pid=" << pid);
{
#ifdef WT_THREADED
boost::recursive_mutex::scoped_lock sessionsLock(mutex_);
#endif
sessions_[sessionId] = new SessionInfo(sessionId, pid);
}
clientSocket = connectToSession(sessionId, path, 1000);
}
} else {
/*
* For SharedProcess, connect to a random server.
*/
/*
* Patch from Andrii Arsirii: it could be that the
* sessionProcessPids_ vector is empty because concurrently a
* shared process died: we need to wait until it is respawned.
*/
for (;;) {
int processCount = sessionProcessPids_.size();
if (processCount == 0)
sleep(1);
else {
unsigned i = lrand48() % processCount;
if (i >= sessionProcessPids_.size())
sleep(1);
else {
// This is still not entirely okay: a race condition could
// still occur between checking the size and getting the
// element.
int pid = sessionProcessPids_[i];
std::string path = conf.runDirectory() + "/server-"
+ boost::lexical_cast(pid);
clientSocket = connectToSession("", path, 100);
if (clientSocket == -1)
LOG_ERROR_S(&wt_, "session process " << pid <<
" not responding ?");
break;
}
}
}
}
}
if (clientSocket == -1) {
close(serverSocket);
return;
}
/*
* Forward all data that was consumed to the application.
*/
for (unsigned i = 0; i < consumedRecords_.size(); ++i) {
if (!writeToSocket(clientSocket, consumedRecords_[i]->plainText(),
consumedRecords_[i]->plainTextLength())) {
LOG_ERROR_S(&wt_, "error writing to client");
return;
}
delete consumedRecords_[i];
}
/*
* Now, we must copy data from both the server to the application,
* as well as from the application to the server, until the application
* sends the FCGI_END_REQUEST message.
*/
for (;;) {
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(serverSocket, &rfds);
FD_SET(clientSocket, &rfds);
LOG_DEBUG_S(&wt_, "select()");
if (select(FD_SETSIZE, &rfds, NULL, NULL, NULL) < 0) {
if (errno != EINTR)
LOG_ERROR_S(&wt_, "fatal: select(): " << strerror(errno));
break;
}
if (FD_ISSET(serverSocket, &rfds)) {
FCGIRecord d;
d.read(serverSocket);
if (d.good()) {
// LOG_DEBUG_S(&wt_, "record from server: " << d); BROKEN !
if (!writeToSocket(clientSocket, d.plainText(),
d.plainTextLength())) {
LOG_ERROR_S(&wt_, "error writing to application");
break;
}
} else {
LOG_ERROR_S(&wt_, "error reading from web server");
break;
}
}
if (FD_ISSET(clientSocket, &rfds)) {
FCGIRecord d;
d.read(clientSocket);
if (d.good()) {
// LOG_DEBUG_S(&wt_, "record from client: " << d); BROKEN !
if (!writeToSocket(serverSocket, d.plainText(),
d.plainTextLength())) {
LOG_ERROR_S(&wt_, "error writing to web server");
break;
}
if (d.type() == FCGI_END_REQUEST)
break;
} else {
LOG_ERROR_S(&wt_, "error reading from application");
break;
}
}
}
LOG_DEBUG_S(&wt_, "request done.");
shutdown(serverSocket, SHUT_RDWR);
close(serverSocket);
close(clientSocket);
} catch (std::exception&) {
close(serverSocket);
if (clientSocket != -1)
close(clientSocket);
}
}
}
witty-3.3.4+dfsg.orig/src/fcgi/CMakeLists.txt 0000644 0001750 0001750 00000002016 12200763306 021260 0 ustar pgquiles pgquiles IF(CONNECTOR_FCGI)
IF(NOT FCGI_FOUND)
MESSAGE("** Disabling FCGI connector: requires libfcgi ")
MESSAGE(" Indicate the location of libfcgi using -DFCGI_PREFIX=..., or omit this connector using -DCONNECTOR_FCGI=OFF")
ELSE(NOT FCGI_FOUND)
MESSAGE("** Enabling FastCGI connector.")
SET(libfcgisources
FCGIRecord.C
FCGIStream.C
Server.C
SessionInfo.C
WServer.C
)
INCLUDE_DIRECTORIES(${FCGI_INCLUDE_DIRS})
ADD_LIBRARY(wtfcgi ${libfcgisources})
TARGET_LINK_LIBRARIES(wtfcgi wt ${FCGI_LIB} ${FCGIPP_LIB})
SET_TARGET_PROPERTIES(
wtfcgi
PROPERTIES
VERSION ${VERSION_SERIES}.${VERSION_MAJOR}.${VERSION_MINOR}
SOVERSION ${WTFCGI_SOVERSION}
DEBUG_POSTFIX ${DEBUG_LIB_POSTFIX}
)
INSTALL(TARGETS wtfcgi
RUNTIME DESTINATION bin
LIBRARY DESTINATION ${LIB_INSTALL_DIR}
ARCHIVE DESTINATION ${LIB_INSTALL_DIR})
ENDIF(NOT FCGI_FOUND)
ELSE(CONNECTOR_FCGI)
MESSAGE("** Disabling FastCGI connector.")
ENDIF(CONNECTOR_FCGI)
witty-3.3.4+dfsg.orig/src/fcgi/SessionInfo.C 0000644 0001750 0001750 00000000424 11456336247 021100 0 ustar pgquiles pgquiles /*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#include "SessionInfo.h"
namespace Wt {
SessionInfo::SessionInfo(const std::string sessionId, pid_t childPId)
: sessionId_(sessionId),
childPId_(childPId)
{ }
}
witty-3.3.4+dfsg.orig/src/fcgi/SessionInfo.h 0000644 0001750 0001750 00000001113 12064102701 021117 0 ustar pgquiles pgquiles /*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
// This may look like C code, but it's really -*- C++ -*-
#ifndef WT_SESSIONINFO_H_
#define WT_SESSIONINFO_H_
#include
#include
#include
namespace Wt {
class SessionInfo
{
public:
SessionInfo(const std::string sessionId, pid_t childPId);
const std::string sessionId() const { return sessionId_; }
pid_t childPId() const { return childPId_; }
private:
std::string sessionId_;
pid_t childPId_;
};
}
#endif // WT_SESSIONINFO_H_
witty-3.3.4+dfsg.orig/src/fcgi/FCGIStream.C 0000644 0001750 0001750 00000017165 12372071307 020526 0 ustar pgquiles pgquiles /*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#include
#include
#include
#include
#include
#include
#include "FCGIStream.h"
#include "WebController.h"
#include "Configuration.h"
#include "SslUtils.h"
#include "Wt/WSslInfo"
#include "Wt/WLogger"
#include "fcgio.h"
#include "fcgi_config.h" // HAVE_IOSTREAM_WITHASSIGN_STREAMBUF
#include
#ifdef WT_WITH_SSL
#include
#endif
#define SSL_CLIENT_CERT_CHAIN_PREFIX "SSL_CLIENT_CERT_CHAIN"
using std::memset;
using std::exit;
namespace Wt {
LOGGER("wtfcgi");
}
namespace {
using namespace Wt;
inline std::string str(const char *v) {
return v ? std::string(v) : std::string();
}
class FCGIRequest : public WebRequest
{
mutable std::string scriptName_, serverName_, queryString_,
serverPort_, pathInfo_, remoteAddr_;
public:
FCGIRequest(FCGX_Request *request)
: request_(request),
headersCommitted_(false)
{
in_streambuf_ = new fcgi_streambuf(request_->in, &buf_[0], buf_.size());
out_streambuf_ = new fcgi_streambuf(request_->out);
err_streambuf_ = new fcgi_streambuf(request_->err);
in_ = new std::istream(in_streambuf_);
out_ = new std::ostream(out_streambuf_);
err_ = new std::ostream(err_streambuf_);
}
~FCGIRequest() {
delete err_;
delete out_;
delete in_;
delete err_streambuf_;
delete out_streambuf_;
delete in_streambuf_;
FCGX_Finish_r(request_);
delete request_;
}
virtual void flush(ResponseState state, const WriteCallback& callback) {
out().flush();
if (state == ResponseFlush) {
setAsyncCallback(callback);
} else {
setAsyncCallback(0);
}
emulateAsync(state);
}
virtual std::istream& in() { return *in_; }
virtual std::ostream& out() {
if (!headersCommitted_) {
headersCommitted_ = true;
*out_ << "\r\n";
}
return *out_;
}
virtual std::ostream& err() { return *err_; }
virtual void setStatus(int status)
{
*out_ << "Status: " << status << "\r\n";
}
virtual void setContentType(const std::string& value)
{
addHeader("Content-Type", value);
}
virtual void addHeader(const std::string& name, const std::string& value)
{
if (!headersCommitted_)
*out_ << name << ": " << value << "\r\n";
else
LOG_WARN("addHeader(): " << name << ": " << value
<< " ignored because headers already committed.");
}
virtual void setContentLength(::int64_t length)
{
addHeader("Content-Length", boost::lexical_cast(length));
}
virtual void setRedirect(const std::string& url)
{
*out_ << "Location: " << url << "\r\n\r\n";
}
virtual const char *headerValue(const char *name) const {
return envValue(cgiEnvName(name).c_str());
}
virtual const char *envValue(const char *name) const {
char *result = FCGX_GetParam(name, request_->envp);
if (result)
return result;
else
return 0;
}
std::string cgiEnvName(const char *name) const {
std::string result = name;
std::string::size_type i;
while ((i = result.find('-')) != std::string::npos)
result[i] = '_';
std::transform(result.begin(), result.end(), result.begin(), toupper);
return "HTTP_" + result;
}
virtual const std::string& scriptName() const {
if (scriptName_.empty()) {
if (entryPoint_)
scriptName_ = str(envValue("SCRIPT_NAME")) + entryPoint_->path();
else
scriptName_ = str(envValue("SCRIPT_NAME"));
}
return scriptName_;
}
virtual const std::string& serverName() const {
if (serverName_.empty())
serverName_ = str(envValue("SERVER_NAME"));
return serverName_;
}
virtual const char *requestMethod() const {
return envValue("REQUEST_METHOD");
}
virtual const std::string& queryString() const {
if (queryString_.empty())
queryString_ = str(envValue("QUERY_STRING"));
return queryString_;
}
virtual const std::string& serverPort() const {
if (serverPort_.empty())
serverPort_ = str(envValue("SERVER_PORT"));
return serverPort_;
}
virtual const std::string& pathInfo() const {
if (pathInfo_.empty()) {
pathInfo_ = str(envValue("PATH_INFO"));
if (entryPoint_) {
/* Do we actually know what this is supposed to do? */
if (pathInfo_.length() >= entryPoint_->path().length()) {
pathInfo_ = pathInfo_.substr(entryPoint_->path().length());
}
}
}
return pathInfo_;
}
virtual const std::string& remoteAddr() const {
if (remoteAddr_.empty())
remoteAddr_ = str(envValue("REMOTE_ADDR"));
return remoteAddr_;
}
virtual const char *urlScheme() const {
const char *https = envValue("HTTPS");
if (https && strcasecmp(https, "ON") == 0)
return "https";
else
return "http";
}
virtual bool isSynchronous() const {
return true;
}
virtual WSslInfo *sslInfo() const {
#ifdef WT_WITH_SSL
std::string clientCert = str(envValue("SSL_CLIENT_CERT"));
if (!clientCert.empty()) {
X509 *x509 = Wt::Ssl::readFromPem(clientCert);
if (x509) {
Wt::WSslCertificate clientCert = Wt::Ssl::x509ToWSslCertificate(x509);
X509_free(x509);
std::vector clientCertChain;
unsigned depth = UINT_MAX;
for (unsigned i = 0; i < depth; i++) {
std::string name = SSL_CLIENT_CERT_CHAIN_PREFIX;
name += boost::lexical_cast(i);
char *cc = FCGX_GetParam(name.c_str(), request_->envp);
if (cc) {
X509 *x509_i = Wt::Ssl::readFromPem(cc);
clientCertChain.push_back(Wt::Ssl::x509ToWSslCertificate(x509_i));
X509_free(x509_i);
} else
break;
}
Wt::WValidator::State state = Wt::WValidator::Invalid;
std::string verify = str(envValue("SSL_CLIENT_VERIFY"));
std::string verifyInfo;
if (verify == "SUCCESS") {
state = Wt::WValidator::Valid;
} else if (verify.empty()) {
state = Wt::WValidator::Invalid;
verifyInfo = "SSL_CLIENT_VERIFY variable was empty";
} else {
state = Wt::WValidator::Invalid;
verifyInfo = verify;
}
Wt::WValidator::Result clientVerificationResult(state, verifyInfo);
return new Wt::WSslInfo(clientCert,
clientCertChain,
clientVerificationResult);
}
}
#endif
return 0;
}
private:
FCGX_Request *request_;
fcgi_streambuf *in_streambuf_, *out_streambuf_, *err_streambuf_;
boost::array buf_; // Workaround for bug with fcgi_streambuf::underflow()
std::istream *in_;
std::ostream *out_, *err_;
bool headersCommitted_;
};
}
namespace Wt {
FCGIStream::FCGIStream()
{
FCGX_Init();
}
FCGIStream::~FCGIStream()
{ }
WebRequest *FCGIStream::getNextRequest(int timeoutsec)
{
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(0, &rfds);
struct timeval timeout;
timeout.tv_sec = timeoutsec;
timeout.tv_usec = 0;
for(;;) {
int result = select(FD_SETSIZE, &rfds, 0, 0, &timeout);
if (result == 0)
return 0; // timeout
else if (result == -1) {
if (errno != EINTR) {
perror("select");
exit(1); // FIXME: throw exception
} else {
// EINTR, try again
}
} else
break;
}
FCGX_Request *request = new FCGX_Request();
FCGX_InitRequest(request, 0, 0);
if (FCGX_Accept_r(request) == 0) {
return new FCGIRequest(request);
} else {
LOG_ERROR("could not FCGX_Accept ?");
delete request;
exit(1); // FIXME: throw exception
}
}
}
witty-3.3.4+dfsg.orig/src/fcgi/FCGIStream.h 0000644 0001750 0001750 00000000717 12330010677 020563 0 ustar pgquiles pgquiles // This may look like C code, but it's really -*- C++ -*-
/*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#ifndef FCGI_STREAM_H_
#define FCGI_STREAM_H_
#include "WebStream.h"
#include "WebRequest.h"
struct FCGX_Request;
namespace Wt {
class FCGIStream : public WebStream
{
public:
FCGIStream();
~FCGIStream();
virtual WebRequest *getNextRequest(int timeoutsec);
};
}
#endif // FCGI_STREAM_H_
witty-3.3.4+dfsg.orig/src/fcgi/FCGIRecord.C 0000644 0001750 0001750 00000012416 12140701215 020472 0 ustar pgquiles pgquiles /*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#include
#include "FCGIRecord.h"
#include
#include
#include
#include
using std::malloc;
using std::free;
using std::realloc;
using std::memcpy;
FCGIRecord::FCGIRecord()
: good_(false),
contentData_(0),
plainTextBuf_(0)
{ }
FCGIRecord::FCGIRecord(short requestId, char version)
: good_(true),
contentData_(0),
plainTextBuf_(0)
{
plainTextBufLength_ = 8 + 8;
plainTextBuf_ = (unsigned char *) malloc(plainTextBufLength_ * sizeof(char));
plainTextBuf_[0] = version;
plainTextBuf_[1] = 3; // FCGI_END_REQUEST
plainTextBuf_[2] = requestId >> 8;
plainTextBuf_[3] = requestId & 0x0F;
plainTextBuf_[4] = 0;
plainTextBuf_[5] = 8;
plainTextBuf_[6] = 0;
plainTextBuf_[7] = 0;
plainTextBuf_[8] = 0;
plainTextBuf_[9] = 0;
plainTextBuf_[10] = 0;
plainTextBuf_[11] = 0;
plainTextBuf_[12] = 0; // FCGI_REQUEST_COMPLETE
}
FCGIRecord::~FCGIRecord()
{
clear();
}
void FCGIRecord::clear()
{
delete contentData_;
if (plainTextBuf_)
free(plainTextBuf_);
contentData_ = 0;
plainTextBufLength_ = 0;
plainTextBuf_ = 0;
plainTextLength_ = 0;
}
int FCGIRecord::getChar(int fd, bool waitForIt)
{
unsigned char buf[1];
int result;
for (;;) {
result = ::read(fd, buf, 1);
if (result == -1) {
if (errno != EINTR) {
perror("read");
throw Wt::WException("Error reading (1)");
}
} else
break;
}
if (result == 0) {
if (waitForIt) {
while (result == 0) {
usleep(100);
result = ::read(fd, buf, 1);
if (result == -1) {
if (errno != EINTR) {
perror("read");
throw Wt::WException("Error reading (2)");
} else
result = 0; // try again
}
}
} else
return -1;
}
if (plainTextLength_ >= plainTextBufLength_) {
plainTextBufLength_ += 1024;
plainTextBuf_ = (unsigned char *)
realloc(plainTextBuf_, plainTextBufLength_);
}
plainTextBuf_[plainTextLength_++] = buf[0];
return buf[0];
}
bool FCGIRecord::getAndAssign(int fd, unsigned char& result,
bool waitForIt)
{
int c = getChar(fd, waitForIt);
if (c != -1) {
result = c;
return true;
} else {
return false;
}
}
bool FCGIRecord::getBuffer(int fd, unsigned char *buf,
int length)
{
int count = 0;
while (count < length) {
int result = ::read(fd, buf + count, length - count);
if (result == -1) {
if (errno != EINTR) {
perror("read");
throw Wt::WException("Error reading (3)");
} // else try again
} else {
count += result;
}
}
if (plainTextLength_ + length > plainTextBufLength_) {
plainTextBufLength_ += length;
plainTextBufLength_ = (plainTextBufLength_ + 8) / 8 * 8;
plainTextBuf_ = (unsigned char *)
realloc(plainTextBuf_, plainTextBufLength_);
}
memcpy(plainTextBuf_ + plainTextLength_, buf, length);
plainTextLength_ += length;
return true;
}
void FCGIRecord::read(int fd)
{
clear();
if (!getAndAssign(fd, version_, false))
return;
if (!getAndAssign(fd, type_, true))
return;
unsigned char IdB1;
unsigned char IdB0;
if (!getAndAssign(fd, IdB1, true))
return;
if (!getAndAssign(fd, IdB0, true))
return;
requestId_ = (IdB1 << 8) | IdB0;
unsigned char contentLengthB1;
unsigned char contentLengthB0;
if (!getAndAssign(fd, contentLengthB1, true))
return;
if (!getAndAssign(fd, contentLengthB0, true))
return;
contentLength_ = (contentLengthB1 << 8) | contentLengthB0;
if (!getAndAssign(fd, paddingLength_, true))
return;
if (!getAndAssign(fd, reserved_, true))
return;
contentData_ = new unsigned char[contentLength_];
if (!getBuffer(fd, contentData_, contentLength_))
return;
unsigned char c;
for (unsigned i = 0; i < paddingLength_; ++i)
if (!getAndAssign(fd, c, true))
return;
good_ = true;
}
std::ostream& operator<< (std::ostream& o, const FCGIRecord& r)
{
o << "version = " << (int)r.version()
<< " type = " << (int)r.type()
<< " requestId = " << (int)r.requestId()
<< " contentLength = " << r.contentLength();
if (true || (r.type() == 5)) {
o << " content =\n";
for (unsigned i = 0; i < r.contentLength(); ++i)
o << r.contentData()[i];
}
return o;
}
bool FCGIRecord::getParam(const std::string name, std::string& value) const
{
for (unsigned i = 0; i < contentLength_;) {
unsigned int nameLen;
if ((contentData_[i] >> 7) == 0) {
nameLen = contentData_[i];
i += 1;
} else {
nameLen =
((unsigned)(contentData_[i] & 0x7F) << 24)
| ((unsigned)contentData_[i+1] << 16)
| ((unsigned)contentData_[i+2] << 8)
| ((unsigned)contentData_[i+3]);
i += 4;
}
unsigned int valueLen;
if ((contentData_[i] >> 7) == 0) {
valueLen = contentData_[i];
i += 1;
} else {
valueLen =
(((unsigned)contentData_[i] & 0x7F) << 24)
| ((unsigned)contentData_[i+1] << 16)
| ((unsigned)contentData_[i+2] << 8)
| ((unsigned)contentData_[i+3]);
i += 4;
}
std::string thisname = std::string((char *)contentData_ + i, nameLen);
value = std::string((char *)contentData_ + i + nameLen, valueLen);
if (name == thisname)
return true;
i += nameLen + valueLen;
}
return false;
}
witty-3.3.4+dfsg.orig/src/fcgi/Server.h 0000644 0001750 0001750 00000003277 12356520372 020157 0 ustar pgquiles pgquiles // This may look like C code, but it's really -*- C++ -*-
/*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#ifndef SERVER_H_
#define SERVER_H_
#include
#include
#ifdef WT_THREADED
#include
#endif // WT_THREADED
namespace Wt {
class SessionInfo;
class WServer;
/*
* A FastCGI relay server
*/
class Server
{
public:
static bool bindUDStoStdin(const std::string& socketPath,
Wt::WServer& server);
Server(WServer& wt, int argc, char *argv[]);
int run();
static Server *instance;
void handleSigChld();
void handleSignal(const char *signal);
private:
WServer& wt_;
int argc_;
char **argv_;
int childrenDied_;
volatile sig_atomic_t handleSigChld_;
#ifdef WT_THREADED
// mutex to protect access to the sessions map
boost::recursive_mutex mutex_;
#endif
void checkAndQueueSigChld();
void doHandleSigChld();
void spawnSharedProcess();
void execChild(bool debug, const std::string& extraArg);
int connectToSession(const std::string& sessionId,
const std::string& socketPath,
int maxTries);
bool getSessionFromQueryString(const std::string& uri,
std::string& sessionId);
void checkConfig();
bool writeToSocket(int socket, const unsigned char *buf, int bufsize);
/*
* For DedicatedProcess session policy
*/
typedef std::map SessionMap;
SessionMap sessions_;
void handleRequestThreaded(int serverSocket);
void handleRequest(int serverSocket);
/*
* For SharedProcess session policy
*/
std::vector sessionProcessPids_;
const std::string socketPath(const std::string& sessionId);
};
}
#endif // WT_SERVER_H_
witty-3.3.4+dfsg.orig/src/fcgi/FCGIRecord.h 0000644 0001750 0001750 00000002742 12140701215 020540 0 ustar pgquiles pgquiles /*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
// This may look like C code, but it's really -*- C++ -*-
#ifndef FCGIRECORD_H_
#define FCGIRECORD_H_
#include
#include
class FCGIRecord
{
public:
FCGIRecord();
FCGIRecord(short requestId, char version);
~FCGIRecord();
void clear();
bool good() { return good_; }
unsigned char type() const { return type_; }
unsigned char version() const { return version_; }
unsigned short requestId() const { return requestId_; }
unsigned int contentLength() const { return contentLength_; }
const unsigned char *contentData() const { return contentData_; }
unsigned int plainTextLength() const { return plainTextLength_; }
const unsigned char *plainText() const { return plainTextBuf_; }
void read(int fd);
bool getParam(const std::string name, std::string& value) const;
private:
bool good_;
unsigned char version_;
unsigned char type_;
unsigned short requestId_;
unsigned int contentLength_;
unsigned char paddingLength_;
unsigned char reserved_;
unsigned char *contentData_;
unsigned int plainTextLength_;
unsigned char *plainTextBuf_;
unsigned int plainTextBufLength_;
int getChar(int fd, bool waitForIt);
bool getBuffer(int fd, unsigned char *buf, int length);
bool getAndAssign(int fd, unsigned char& r, bool waitForIt);
};
extern std::ostream& operator<< (std::ostream&, const FCGIRecord& r);
#endif // FCGIRECORD_H_
witty-3.3.4+dfsg.orig/src/js/ 0000775 0001750 0001750 00000000000 12510340013 016215 5 ustar pgquiles pgquiles witty-3.3.4+dfsg.orig/src/js/WTreeTable.js 0000644 0001750 0001750 00000002220 12056151517 020561 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WTreeTable",
function(APP, table) {
jQuery.data(table, 'obj', this);
var self = this, WT = APP.WT;
var content = $(table).find('.Wt-content').get(0),
spacer = $(table).find('.Wt-sbspacer').get(0);
this.wtResize = function(el, w, h) {
var hdefined = h >= 0;
if (hdefined)
el.style.height = h + 'px';
else
el.style.height = '';
var c = el.lastChild;
var t = el.firstChild;
h -= $(t).outerHeight();
if (hdefined && h > 0) {
if (c.style.height != h + 'px')
c.style.height = h + 'px';
} else
c.style.height = '';
};
this.autoJavaScript = function() {
if (table.parentNode) {
if (content.scrollHeight > content.offsetHeight) {
spacer.style.display='block';
} else {
spacer.style.display='none';
}
var h = WT.pxself(table, 'height');
if (h)
self.wtResize(table, 0, h, true);
}
};
});
witty-3.3.4+dfsg.orig/src/js/WLengthValidator.js 0000644 0001750 0001750 00000001413 11563251527 022010 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WLengthValidator",
function(mandatory, minLength, maxLength, blankError,
tooShortError, tooLongError) {
this.validate = function(text) {
if (text.length == 0)
if (mandatory)
return { valid: false, message: blankError };
else
return { valid: true };
if (minLength !== null)
if (text.length < minLength)
return { valid: false, message: tooShortError };
if (maxLength !== null)
if (text.length > maxLength)
return { valid: false, message: tooLongError };
return { valid: true };
};
}); witty-3.3.4+dfsg.orig/src/js/ToolTip.js 0000644 0001750 0001750 00000005707 12420210325 020156 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(10, JavaScriptFunction, "toolTip",
function(APP, id, text, deferred, ToolTipInnerStyle, ToolTipOuterStyle) {
var $el = $("#" + id), el = $el.get(0);
var WT = APP.WT;
var obj = el.toolTip;
if (!obj) {
el.toolTip = new function() {
var showTimer = null, checkInt = null, coords = null, toolTipEl = null;
/* const */ var MouseDistance = 10;
/* const */ var Delay = 500;
var waitingForText = false, toolTipText = text;
function checkIsOver() {
if (!$('#' + id + ':hover').length) {
hideToolTip();
}
}
function loadToolTipText() {
waitingForText = true;
APP.emit(el, "Wt-loadToolTip");
}
this.setToolTipText = function(text) {
toolTipText = text;
if (waitingForText) {
this.showToolTip();
clearTimeout(showTimer);
waitingforText = false;
}
}
this.showToolTip = function() {
if (deferred && !toolTipText && !waitingForText)
loadToolTipText();
if (toolTipText){
toolTipEl = document.createElement('div');
toolTipEl.className = ToolTipInnerStyle;
toolTipEl.innerHTML = toolTipText;
outerDiv = document.createElement('div');
outerDiv.className = ToolTipOuterStyle;
document.body.appendChild(outerDiv);
outerDiv.appendChild(toolTipEl);
var x = coords.x, y = coords.y;
WT.fitToWindow(outerDiv, x + MouseDistance, y + MouseDistance,
x - MouseDistance, y - MouseDistance);
}
checkInt = setInterval(function() { checkIsOver(); }, 200);
}
function hideToolTip() {
clearTimeout(showTimer);
if (toolTipEl) {
$(toolTipEl).parent().remove();
toolTipEl = null;
clearInterval(checkInt);
checkInt = null;
}
}
function resetTimer(e) {
clearTimeout(showTimer);
coords = WT.pageCoordinates(e);
if (!toolTipEl)
showTimer = setTimeout(function() { el.toolTip.showToolTip(); }, Delay);
}
$el.mouseenter(resetTimer);
$el.mousemove(resetTimer);
$el.mouseleave(hideToolTip);
};
}
if (obj)
obj.setToolTipText(text);
});
witty-3.3.4+dfsg.orig/src/js/WSpinBox.js 0000644 0001750 0001750 00000014433 12330010677 020301 0 ustar pgquiles pgquiles /*
* Copyright (C) 2010 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WSpinBox",
function(APP, edit, precision, prefix, suffix, minValue, maxValue,
stepValue, decimalPoint, groupSeparator) {
/** @const */ var TYPE_INTEGER = 0;
/** @const */ var TYPE_FLOAT = 1;
/** @const */ var NaNError = "Must be a number";
/** @const */ var tooSmallError = "The number must be at least ";
/** @const */ var tooLargeError = "The number may be at most ";
/** @const */ var CLASS_DOWN = 'dn';
/** @const */ var CLASS_UP = 'up';
/** @const */ var CLASS_UNSELECTABLE = 'unselectable';
jQuery.data(edit, 'obj', this);
var self = this, WT = APP.WT, key_up = 38, key_down = 40, CH = 'crosshair',
$edit = $(edit);
var dragStartXY = null, dragStartValue, changed = false;
var validator = null;
var isDoubleSpinBox = false;
function isReadOnly() {
return !!edit.getAttribute("readonly");
}
function addGrouping(input) {
var result = "";
for (var i = 0; i < input.length(); i++) {
result += input.charAt(i);
}
}
function getValue() {
var lineEdit = $edit.data("lobj");
var v = "";
if (lineEdit !== undefined) {
v = lineEdit.getValue();
if (v === "") {
v = prefix + "0" + suffix;
}
} else {
v = edit.value;
}
if (v.substr(0, prefix.length) == prefix) {
v = v.substr(prefix.length);
if (v.length > suffix.length
&& v.substr(v.length - suffix.length, suffix.length) == suffix) {
v = v.substr(0, v.length - suffix.length);
if (groupSeparator) {
v = v.split(groupSeparator).join("");
}
v = v.replace(decimalPoint, ".");
return Number(v);
}
}
return null;
}
function setValue(v) {
var lineEdit = $edit.data("lobj");
if (v > maxValue)
v = maxValue;
else if (v < minValue)
v = minValue;
var newValue = v.toFixed(precision);
newValue = newValue.replace(".", decimalPoint);
var dotPos = newValue.indexOf(decimalPoint);
var result = "";
if (dotPos !== -1) {
for (var i = 0; i < dotPos; i++) {
result += newValue.charAt(i);
if (i < dotPos - 1 && ((dotPos - i - 1) % 3 === 0)) {
result += groupSeparator;
}
}
result += newValue.substr(dotPos);
} else {
result = newValue;
}
if (lineEdit !== undefined) {
lineEdit.setValue(prefix + result + suffix);
} else {
edit.value = prefix + result + suffix;
}
changed = true;
}
function inc() {
var v = getValue();
if (v !== null) {
v += stepValue;
setValue(v);
}
}
function dec() {
var v = getValue();
if (v !== null) {
v -= stepValue;
setValue(v);
}
}
this.setIsDoubleSpinBox = function(isDouble) {
isDoubleSpinBox = isDouble;
this.configure(precision, prefix, suffix, minValue, maxValue, stepValue);
};
this.configure = function(newPrecision, newPrefix, newSuffix,
newMinValue, newMaxValue, newStepValue) {
precision = newPrecision;
prefix = newPrefix;
suffix = newSuffix;
minValue = newMinValue;
maxValue = newMaxValue;
stepValue = newStepValue;
var Validator = (isDoubleSpinBox ||
typeof WT.WIntValidator === 'undefined') ?
WT.WDoubleValidator : WT.WIntValidator;
validator = new Validator(true, minValue, maxValue,
NaNError, NaNError,
tooSmallError + minValue,
tooLargeError + maxValue);
};
this.mouseOut = function(o, event) {
$edit.removeClass(CLASS_DOWN).removeClass(CLASS_UP);
};
this.mouseMove = function(o, event) {
if (isReadOnly())
return;
if (!dragStartXY) {
var xy = WT.widgetCoordinates(edit, event);
if ($edit.hasClass(CLASS_DOWN) || $edit.hasClass(CLASS_UP))
$edit.removeClass(CLASS_DOWN).removeClass(CLASS_UP);
if (xy.x > edit.offsetWidth - 16) {
var mid = edit.offsetHeight/2;
if (xy.y >= mid - 1 && xy.y <= mid + 1)
edit.style.cursor = CH;
else {
edit.style.cursor = 'default';
if (xy.y < mid - 1)
$edit.addClass(CLASS_UP);
else
$edit.addClass(CLASS_DOWN);
}
} else
if (edit.style.cursor != '')
edit.style.cursor = '';
} else {
var dy = WT.pageCoordinates(event).y - dragStartXY.y;
var v = dragStartValue;
if (v !== null) {
v = v - dy*stepValue;
setValue(v);
}
}
};
this.mouseDown = function(o, event) {
WT.capture(null);
if (isReadOnly())
return;
if (edit.style.cursor == CH) {
WT.capture(null);
WT.capture(edit);
$edit.addClass(CLASS_UNSELECTABLE);
dragStartXY = WT.pageCoordinates(event);
dragStartValue = getValue();
} else {
var xy = WT.widgetCoordinates(edit, event);
if (xy.x > edit.offsetWidth - 16) {
// suppress selection, focus
WT.cancelEvent(event);
WT.capture(edit);
$edit.addClass(CLASS_UNSELECTABLE);
var mid = edit.offsetHeight/2;
if (xy.y < mid)
WT.eventRepeat(function() { inc(); });
else
WT.eventRepeat(function() { dec(); });
}
}
};
this.mouseUp = function(o, event) {
$edit.removeClass(CLASS_UNSELECTABLE);
if (isReadOnly())
return;
if (changed || dragStartXY != null) {
dragStartXY = null;
o.onchange();
}
WT.stopRepeat();
};
this.keyDown = function(o, event) {
if (isReadOnly())
return;
if (event.keyCode == key_down)
WT.eventRepeat(function() { dec(); });
else if (event.keyCode == key_up)
WT.eventRepeat(function() { inc(); });
};
this.keyUp = function(o, event) {
if (isReadOnly())
return;
if (changed) {
changed = false;
o.onchange();
}
WT.stopRepeat();
};
this.setLocale = function(point, separator) {
decimalPoint = point;
groupSeparator = separator;
};
/*
* Customized validation function, called from WFormWidget
*/
this.validate = function(text) {
var v = getValue();
if (v === null)
v = "a"; // NaN
return validator.validate(v);
};
this.setIsDoubleSpinBox(isDoubleSpinBox);
});
witty-3.3.4+dfsg.orig/src/js/WtResize.js 0000644 0001750 0001750 00000006551 12330010677 020346 0 ustar pgquiles pgquiles /*
* Copyright (C) 2010 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(10, JavaScriptFunction, "ChildrenResize",
function(self, w, h, layout) {
var WT = this;
var defined = h >= 0;
self.lh = defined && layout;
if (defined)
self.style.height = h + 'px';
else
self.style.height = '';
if (WT.boxSizing(self)) {
h -= WT.px(self, 'marginTop');
h -= WT.px(self, 'marginBottom');
h -= WT.px(self, 'borderTopWidth');
h -= WT.px(self, 'borderBottomWidth');
h -= WT.px(self, 'paddingTop');
h -= WT.px(self, 'paddingBottom');
w -= WT.px(self, 'marginLeft');
w -= WT.px(self, 'marginRight');
w -= WT.px(self, 'borderLeftWidth');
w -= WT.px(self, 'borderRightWidth');
w -= WT.px(self, 'paddingLeft');
w -= WT.px(self, 'paddingRight');
}
function marginV(el) {
var result = WT.px(el, 'marginTop');
result += WT.px(el, 'marginBottom');
if (!WT.boxSizing(el)) {
result += WT.px(el, 'borderTopWidth');
result += WT.px(el, 'borderBottomWidth');
result += WT.px(el, 'paddingTop');
result += WT.px(el, 'paddingBottom');
}
return result;
}
var j, jl, c;
for (j = 0, jl = self.childNodes.length; j < jl; ++j) {
c = self.childNodes[j];
if (c.nodeType == 1) {
if (defined) {
var ch = h - marginV(c);
if (ch > 0) {
/*
to prevent that the first child widget's top margin bleeds
to shift this child down, we set overflow. See also #2809
and the original work-around 548948b63
*/
if (c.offsetTop > 0) {
var of = WT.css(c, 'overflow');
if (of === 'visible' || of === '')
c.style.overflow = 'auto';
}
if (c.wtResize)
c.wtResize(c, w, ch, layout);
else {
var cheight = ch + 'px';
if (c.style.height != cheight) {
c.style.height = cheight;
c.lh = layout;
}
}
}
} else {
if (c.wtResize)
c.wtResize(c, w, -1);
else {
c.style.height = '';
c.lh = false;
}
}
}
}
}
);
WT_DECLARE_WT_MEMBER
(11, JavaScriptFunction, "ChildrenGetPS",
function(self, child, dir, size) {
return size;
}
);
WT_DECLARE_WT_MEMBER
(12, JavaScriptFunction, "LastResize",
function(self, w, h, layout) {
var WT = this;
var defined = h >= 0;
self.lh = defined && layout;
if (defined)
self.style.height = h + 'px';
else
self.style.height = '';
var t = self.lastChild;
var c = t.previousSibling;
if (defined) {
h -= c.offsetHeight + WT.px(c, 'marginTop') + WT.px(c, 'marginBottom');
if (h > 0) {
if (t.wtResize)
t.wtResize(t, w, h, layout);
else {
t.style.height = h + 'px';
t.lh = layout;
}
}
} else {
if (t.wtResize)
t.wtResize(t, -1, -1);
else {
t.style.height = '';
t.lh = false;
}
}
}
);
WT_DECLARE_WT_MEMBER
(13, JavaScriptFunction, "LastGetPS",
function(self, child, dir, size) {
var WT = this, i, il;
for (i = 0, il = self.childNodes.length; i < il; ++i) {
var c = self.childNodes[i];
if (c != child) {
var pc = WT.css(c, 'position');
if (pc != 'absolute' && pc != 'fixed') {
if (dir === 0) {
size = Math.max(size, c.offsetWidth);
} else {
size += c.offsetHeight + WT.px(c, 'marginTop')
+ WT.px(c, 'marginBottom');
}
}
}
}
return size;
}
);
witty-3.3.4+dfsg.orig/src/js/WDialog-center.js 0000644 0001750 0001750 00000002020 11715747045 021375 0 ustar pgquiles pgquiles (function(id, centerX, centerY) {
function windowSize() {
var x, y;
if (typeof (window.innerWidth) === 'number') {
x = window.innerWidth;
y = window.innerHeight;
} else {
x = document.documentElement.clientWidth;
y = document.documentElement.clientHeight;
}
return { x: x, y: y};
}
function centerDialog() {
var el = document.getElementById(id);
if ((el.style.display != 'none') && (el.style.visibility != 'hidden')) {
var ws = windowSize();
var w = el.offsetWidth, h = el.offsetHeight;
if (centerX) {
el.style.left = Math.round((ws.x - w)/2) + 'px';
el.style.marginLeft = '0px';
}
if (centerY) {
el.style.top = Math.round((ws.y - h)/2) + 'px';
el.style.marginTop = '0px';
}
el.style.visibility = 'visible';
}
}
if (window.addEventListener) {
window.addEventListener('DOMContentLoaded', centerDialog, false);
} else {
document.attachEvent('onDOMContentLoaded', centerDialog);
}
})($el, $centerX, $centerY);
witty-3.3.4+dfsg.orig/src/js/Resizable.js 0000644 0001750 0001750 00000005430 12503041145 020501 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "Resizable",
function(WT, el) {
var handler = null, downXY = null,
iwidth, iheight, /* initial CSS width and height */
cwidth, cheight, /* initial client width and height */
minwidth, minheight,
cssMinWidth, cssMinHeight;
function onMouseMove(event) {
var xy = WT.pageCoordinates(event);
var dx = xy.x - downXY.x, dy = xy.y - downXY.y, overflow = 0;
var p_width = WT.px(el, 'width');
var p_height = WT.px(el, 'height');
var vw = Math.max(iwidth + dx, minwidth + (iwidth - cwidth));
el.style.width = vw + 'px';
var vh = Math.max(iheight + dy, minheight + (iheight - cheight));
el.style.height = vh + 'px';
if (el.style.left === 'auto')
el.style.right = (WT.px(el, 'right') - (vw - p_width)) + 'px';
if (el.style.top === 'auto')
el.style.bottom = (WT.px(el, 'bottom') - (vh - p_height)) + 'px';
if (handler)
handler(vw, vh);
}
function onMouseUp(event) {
$(window.document).unbind("mousemove", onMouseMove);
$(window.document).unbind("mouseup", onMouseUp);
if (handler)
handler(WT.pxself(el, 'width'), WT.pxself(el, 'height'), true);
}
function onMouseDown(event) {
var xy = WT.widgetCoordinates(el, event);
if (el.offsetWidth - xy.x < 16 && el.offsetHeight - xy.y < 16) {
if (!cssMinWidth) {
cssMinWidth = WT.css(el, 'minWidth'),
cssMinHeight = WT.css(el, 'minHeight');
if (WT.isIE6) {
/*
* IE6 does not support min-width, min-height, but still provides them
* in the cssText
*/
function fishCssText(el, property) {
var m = new RegExp(property + ":\\s*(\\d+(?:\\.\\d+)?)\\s*px", "i")
.exec(el.style.cssText);
return (m && m.length == 2) ? m[1] + 'px' : '';
}
cssMinWidth = fishCssText(el, 'min-width');
cssMinHeight = fishCssText(el, 'min-height');
}
if (cssMinWidth == '0px')
minwidth = el.clientWidth;
else
minwidth = WT.parsePx(cssMinWidth);
if (cssMinHeight == '0px')
minheight = el.clientHeight;
else
minheight = WT.parsePx(cssMinHeight);
}
downXY = WT.pageCoordinates(event);
iwidth = WT.innerWidth(el);
iheight = WT.innerHeight(el);
cwidth = el.clientWidth;
cheight = el.clientHeight;
WT.capture(null);
$(window.document).bind("mousemove", onMouseMove);
$(window.document).bind("mouseup", onMouseUp);
}
}
$(el).mousedown(onMouseDown);
this.onresize = function(f) {
handler = f;
};
});
witty-3.3.4+dfsg.orig/src/js/WTableView.js 0000644 0001750 0001750 00000030357 12503633026 020605 0 ustar pgquiles pgquiles /*
* Copyright (C) 2010 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WTableView",
function(APP, el, contentsContainer, headerContainer, headerColumnsContainer,
selectedClass) {
jQuery.data(el, 'obj', this);
var self = this;
var WT = APP.WT;
var rtl = $(document.body).hasClass('Wt-rtl');
/** @const */ var EnsureVisible = 0;
/** @const */ var PositionAtTop = 1;
/** @const */ var PositionAtBottom = 2;
/** @const */ var PositionAtCenter = 3;
function rtlScrollLeft(o) {
if (rtl) {
if (WT.isGecko)
return -o.scrollLeft;
else
return o.scrollWidth - o.clientWidth - o.scrollLeft;
} else
return o.scrollLeft;
}
var scrollX1 = 0, scrollX2 = 0, scrollY1 = 0, scrollY2 = 0;
var scrollToPending = false;
/*
* We need to remember this for when going through a hide()
* show() cycle.
*/
var scrollTop = 0, scrollLeft = 0, currentWidth = 0, currentHeight = 0;
headerContainer.onscroll = function(obj, event) {
contentsContainer.scrollLeft = headerContainer.scrollLeft;
self.onContentsContainerScroll();
};
this.onContentsContainerScroll = function() {
scrollLeft = headerContainer.scrollLeft
= contentsContainer.scrollLeft;
scrollTop = headerColumnsContainer.scrollTop
= contentsContainer.scrollTop;
if (contentsContainer.scrollTop == 0 && WT.isAndroid)
return;
if (contentsContainer.clientWidth && contentsContainer.clientHeight
&& (!scrollToPending)
&& (contentsContainer.scrollTop < scrollY1
|| contentsContainer.scrollTop > scrollY2
|| contentsContainer.scrollLeft < scrollX1
|| contentsContainer.scrollLeft > scrollX2)) {
APP.emit(el, 'scrolled',
Math.round(rtlScrollLeft(contentsContainer)),
Math.round(contentsContainer.scrollTop),
Math.round(contentsContainer.clientWidth),
Math.round(contentsContainer.clientHeight));
}
};
contentsContainer.wtResize = function(o, w, h) {
if ((w - currentWidth) > (scrollX2 - scrollX1)/2 ||
(h - currentHeight) > (scrollY2 - scrollY1)/2) {
currentWidth = w; currentHeight = h;
var height = o.clientHeight == o.firstChild.clientHeight
? -1
: o.clientHeight;
APP.emit(el, 'scrolled',
Math.round(rtlScrollLeft(o)),
Math.round(o.scrollTop),
Math.round(o.clientWidth),
Math.round(height));
}
};
function getItem(event) {
var columnId = -1, rowIdx = -1, selected = false,
drop = false, ele = null;
var t = WT.target(event);
while (t) {
var $t = $(t);
if ($t.hasClass('Wt-tv-contents')) {
break;
} else if ($t.hasClass('Wt-tv-c')) {
if (t.getAttribute('drop') === 'true')
drop = true;
if ($t.hasClass(selectedClass))
selected = true;
ele = t;
t = t.parentNode;
columnId = t.className.split(' ')[0].substring(7) * 1;
rowIdx = $t.index();
break;
}
t = t.parentNode;
}
return { columnId: columnId, rowIdx: rowIdx, selected: selected,
drop: drop, el: ele };
};
function rowHeight() {
return WT.pxself(contentsContainer.firstChild, "lineHeight");
}
function indexOf(child) {
var i, il, plist = child.parentNode.childNodes;
for (i = 0, il = plist.length; i < il; ++i)
if (plist[i] == child)
return i;
return -1;
}
function resizeColumn(header, delta) {
var rtl = $(document.body).hasClass('Wt-rtl');
if (rtl)
delta = -delta;
var columnClass = header.className.split(' ')[0],
columnId = columnClass.substring(7) * 1,
headers = header.parentNode,
headerColumn = headers.parentNode !== headerContainer,
contents = headerColumn
? headerColumnsContainer.firstChild
: contentsContainer.firstChild,
wt_tv_contents = contents.firstChild,
column = $(contents).find('.' + columnClass).get(0),
h = header.nextSibling, c = column.nextSibling,
newWidth = WT.pxself(header, 'width') - 1 + delta;
var cwidth = (WT.pxself(headers, 'width') + delta) + 'px';
headers.style.width
= contents.style.width
= wt_tv_contents.style.width
= cwidth;
if (headerColumn) {
headerColumnsContainer.style.width = cwidth;
headerColumnsContainer.firstChild.style.width = cwidth;
contentsContainer.style.left = cwidth;
headerContainer.style.left = cwidth;
}
header.style.width = (newWidth + 1) + 'px';
column.style.width = (newWidth + 7) + 'px';
APP.layouts2.adjust(el.childNodes[0].id, [[1,1]]);
for (; h; h = h.nextSibling) {
if (c) {
if (!rtl)
c.style.left = (WT.pxself(c, 'left') + delta) + 'px';
else
c.style.right = (WT.pxself(c, 'right') + delta) + 'px';
c = c.nextSibling;
}
}
APP.emit(el, 'columnResized', columnId, parseInt(newWidth));
self.autoJavaScript();
}
this.mouseDown = function(obj, event) {
WT.capture(null);
var item = getItem(event);
if (el.getAttribute('drag') === 'true' && item.selected)
APP._p_.dragStart(el, event);
};
this.resizeHandleMDown = function(obj, event) {
var header = obj.parentNode,
cw = WT.pxself(header, 'width') - 1,
minDelta = -cw,
maxDelta = 10000;
var rtl = $(document.body).hasClass('Wt-rtl');
if (rtl) {
var tmp = minDelta;
minDelta = -maxDelta;
maxDelta = -tmp;
}
new WT.SizeHandle(WT, 'h', obj.offsetWidth, el.offsetHeight,
minDelta, maxDelta, 'Wt-hsh2',
function (delta) {
resizeColumn(header, delta);
}, obj, el, event, -2, -1);
};
this.scrolled = function(X1, X2, Y1, Y2) {
scrollX1 = X1;
scrollX2 = X2;
scrollY1 = Y1;
scrollY2 = Y2;
};
this.resetScroll = function() {
headerContainer.scrollLeft = scrollLeft;
contentsContainer.scrollLeft = scrollLeft;
contentsContainer.scrollTop = scrollTop;
headerColumnsContainer.scrollTop = scrollTop;
};
this.setScrollToPending = function() {
scrollToPending = true;
};
this.scrollToPx = function(x, y) {
scrollTop = y;
scrollLeft = x;
this.resetScroll();
};
this.scrollTo = function(x, y, hint) {
scrollToPending = false;
if (y != -1) {
var top = contentsContainer.scrollTop,
height = contentsContainer.clientHeight;
if (hint == EnsureVisible) {
if (top + height < y)
hint = PositionAtTop;
else if (y < top)
hint = PositionAtBottom;
}
switch (hint) {
case PositionAtTop:
contentsContainer.scrollTop = y; break;
case PositionAtBottom:
contentsContainer.scrollTop = y - (height - rowHeight()); break;
case PositionAtCenter:
contentsContainer.scrollTop = y - (height - rowHeight())/2; break;
}
contentsContainer.onscroll();
}
};
var dropEl = null;
el.handleDragDrop = function(action, object, event, sourceId, mimeType) {
if (dropEl) {
dropEl.className = dropEl.classNameOrig;
dropEl = null;
}
if (action == 'end')
return;
var item = getItem(event);
if (!item.selected && item.drop) {
if (action == 'drop') {
APP.emit(el, { name: 'dropEvent', eventObject: object, event: event },
item.rowIdx, item.columnId, sourceId, mimeType);
} else {
object.className = 'Wt-valid-drop';
dropEl = item.el;
dropEl.classNameOrig = dropEl.className;
dropEl.className = dropEl.className + ' Wt-drop-site';
}
} else {
object.className = '';
}
};
/* Handle TAB/SHIFT-TAB for cycling through editors in the right order */
el.onkeydown = function(e) {
var event = e||window.event;
var leftKey = 37,
upKey = 38,
rightKey = 39,
downKey = 40;
if (event.keyCode == 9) {
WT.cancelEvent(event);
/* Find next/prev input element, first by row, then by column */
var item = getItem(event);
if (!item.el)
return;
var col = item.el.parentNode,
rowi = indexOf(item.el),
coli = indexOf(col),
cols = col.parentNode.childNodes.length,
rows = col.childNodes.length,
back = event.shiftKey,
wrapped = false;
var i = rowi, j;
for (;;) {
for (;
back ? i >= 0 : i < rows;
i = (back ? i-1 : i+1)) {
if (i == rowi && !wrapped)
j = back ? coli - 1 : coli + 1;
else
j = back ? cols - 1 : 0;
for (;
back ? j >= 0 : j < cols;
j = (back ? j-1 : j+1)) {
/* We have wrapped and arrived back at the beginning */
if (i == rowi && j == coli)
return;
col = col.parentNode.childNodes[j];
var elij = col.childNodes[i];
var inputs = $(elij).find(":input");
if (inputs.size() > 0) {
setTimeout(function() { inputs.focus(); inputs.select();}, 0);
return;
}
}
}
i = back ? rows - 1 : 0;
wrapped = true;
}
}
/* If keycode is up/down/right/left */
else if (event.keyCode >= leftKey && event.keyCode <= downKey) {
var currentEl = WT.target(event);
function isInput(el) {
return (WT.hasTag(el,'INPUT') && el.type == 'text')
|| WT.hasTag(el, 'TEXTAREA');
}
// do not allow arrow navigation from select
if (WT.hasTag(currentEl, 'SELECT'))
return;
var item = getItem(event);
if (!item.el)
return;
var col = item.el.parentNode,
rowi = indexOf(item.el),
coli = indexOf(col),
cols = col.parentNode.childNodes.length,
rows = col.childNodes.length;
switch (event.keyCode) {
case rightKey:
if (isInput(currentEl)) {
var range = WT.getSelectionRange(currentEl);
if (range.start != currentEl.value.length)
return;
}
coli++; break;
case upKey:
rowi--; break;
case leftKey:
if (isInput(currentEl)) {
var range = WT.getSelectionRange(currentEl);
if (range.start != 0)
return;
}
coli--; break;
case downKey:
rowi++; break;
default:
return;
}
WT.cancelEvent(event);
if (rowi > -1 && rowi < rows && coli > -1 && coli < cols) {
col = col.parentNode.childNodes[coli];
var elToSelect = col.childNodes[rowi];
var inputs = $(elToSelect).find(":input");
if (inputs.size() > 0) {
setTimeout(function() { inputs.focus(); }, 0);
return;
}
}
}
};
this.autoJavaScript = function() {
if (el.parentNode == null) {
el = contentsContainer = headerContainer = null;
this.autoJavaScript = function() { };
return;
}
if (WT.isHidden(el))
return;
if (!WT.isIE && (scrollTop != contentsContainer.scrollTop
|| scrollLeft != contentsContainer.scrollLeft)) {
if (typeof scrollLeft === 'undefined') {
if (rtl && WT.isGecko) {
headerContainer.scrollLeft = contentsContainer.scrollLeft
= scrollLeft = 0;
} else {
scrollLeft = contentsContainer.scrollLeft;
}
} else {
headerContainer.scrollLeft = contentsContainer.scrollLeft
= scrollLeft;
}
headerColumnsContainer.scrollTop = contentsContainer.scrollTop
= scrollTop;
}
var tw = el.offsetWidth - WT.px(el, 'borderLeftWidth')
- WT.px(el, 'borderRightWidth');
var scrollwidth = contentsContainer.offsetWidth
- contentsContainer.clientWidth;
tw -= headerColumnsContainer.clientWidth;
if (tw > 200 // XXX: IE's incremental rendering foobars completely
&& (tw != contentsContainer.tw)) {
contentsContainer.tw = tw;
contentsContainer.style.width = tw + 'px';
headerContainer.style.width = (tw - scrollwidth) + 'px';
}
var rtl = $(document.body).hasClass('Wt-rtl');
if (!rtl)
headerContainer.style.marginRight = scrollwidth + 'px';
else
headerContainer.style.marginLeft = scrollwidth + 'px';
var scrollheight = contentsContainer.offsetHeight
- contentsContainer.clientHeight;
var pns = headerColumnsContainer.style;
if (pns && (pns.marginBottom !== scrollheight + 'px')) {
pns.marginBottom = scrollheight + 'px';
APP.layouts2.adjust(el.childNodes[0].id, [[1,0]]);
}
};
});
witty-3.3.4+dfsg.orig/src/js/WRegExpValidator.js 0000644 0001750 0001750 00000001456 12100524741 021755 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WRegExpValidator",
function(mandatory, regexp, modifiers, blankError, invalidError) {
var r = regexp ? new RegExp("^(" + regexp + ")$", modifiers) : null;
this.validate = function(text) {
if (text.length == 0)
if (mandatory)
return { valid: false, message: blankError };
else
return { valid: true };
if (r) {
var result = r.test(text);
if (result)
return { valid: true };
else
return { valid: false, message: invalidError };
} else
return { valid: true };
};
});
witty-3.3.4+dfsg.orig/src/js/WTextEdit.js 0000644 0001750 0001750 00000011427 12500556234 020454 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WTextEdit",
function(APP, el) {
jQuery.data(el, 'obj', this);
var lastW, lastH;
var self = this,
WT = APP.WT,
css;
if (!tinymce.dom.Event.domLoaded)
tinymce.dom.Event.domLoaded = true;
tinyMCE.init({ mode:"none" });
this.render = function(config, aCss, connectOnChange) {
css = aCss;
el.ed = new tinymce.Editor(el.id, config, tinymce.EditorManager);
el.ed.render();
if (connectOnChange) {
el.ed.onChange.add(function() {
APP.emit(el, 'change');
});
}
APP.emit(el, 'render');
};
this.init = function() {
var iframe = WT.getElement(el.id + '_ifr');
var topLevel, other;
if (tinymce.EditorManager.majorVersion < 4) {
var row = iframe.parentNode.parentNode,
tbl = row.parentNode.parentNode;
other = tbl;
topLevel = tbl.parentNode;
} else {
var item = iframe.parentNode,
container = item.parentNode,
i, il;
topLevel = container.parentNode;
}
if (other) {
other.style.cssText='width:100%;' + css;
el.style.height = other.offsetHeight + 'px';
}
topLevel.wtResize = el.wtResize;
if (WT.isGecko)
setTimeout(function() { self.wtResize(el, lastW, lastH); }, 100);
else
self.wtResize(el, lastW, lastH);
var doc;
if (WT.isIE)
doc = document.frames[iframe.id].document; // one day it may work? :-)
else
doc = iframe.contentDocument;
$(doc.body).bind('paste', function(event) {
var clipboardData =
event.clipboardData || event.originalEvent.clipboardData,
i, il;
function isImage(t) {
return t.indexOf('image/') == 0;
}
if (clipboardData && clipboardData.types) {
for (i = 0, il = clipboardData.types.length; i < il; ++i) {
var t = clipboardData.types[i];
if (isImage(clipboardData.types[i]) ||
isImage(clipboardData.items[i].type)) {
var file = clipboardData.items[i].getAsFile();
var reader = new FileReader();
reader.onload = function(evt) {
el.ed.insertContent(" widget.clientWidth ||
(scrollSize + offLeft == widget.clientWidth &&
WT.isGecko &&
widget.parentNode.parentNode.style.visibility === 'hidden')) {
l = element.style[DC.left];
setCss(element, DC.left, NA_px);
scrollSize = dir ? element.scrollHeight : element.scrollWidth;
}
}
var clientSize = dir ? element.clientHeight : element.clientWidth;
/*
* Firefox sets scrollSize = clientSize when there are no scrollbars
* configured (overflow == 'visible' or 'none') on the widget.
* But setting merely overflow does not help. Removing
* the size constraint temporarily does work.
*/
function isNone(overflow) {
return overflow == 'visible' || overflow == 'none';
}
if (WT.isGecko &&
!element.style[DC.size] &&
dir == HORIZONTAL &&
isNone(WT.css(element, 'overflow'))) {
p = element.style[DC.size];
setCss(element, DC.size, '');
}
var offsetSize = dir ? element.offsetHeight : element.offsetWidth;
if (l)
setCss(element, DC.left, l);
if (p)
setCss(element, DC.size, p);
/*
* Firefox sometimes adds the -NA offset to the reported size
*/
if (clientSize >= NA)
clientSize -= NA;
if (scrollSize >= NA)
scrollSize -= NA;
if (offsetSize >= NA)
offsetSize -= NA;
if (scrollSize === 0) {
scrollSize = WT.pxself(element, DC.size);
if (scrollSize !== 0 && !WT.isOpera && !WT.isGecko)
scrollSize -=
WT.px(element, 'border' + DC.Left + 'Width') +
WT.px(element, 'border' + DC.Right + 'Width');
}
if (scrollSize === clientSize) {
// might be too big, investigate children
// TODO
}
if (WT.isIE &&
(WT.hasTag(element, 'BUTTON') || WT.hasTag(element, 'TEXTAREA')
|| WT.hasTag(element, 'INPUT') || WT.hasTag(element, 'SELECT'))) {
scrollSize = clientSize;
}
if (scrollSize > offsetSize) {
/*
* could be because of a nested absolutely positioned element
* with z-index > 0 ?, or could be because of genuine contents that is
* not fitting the parent.
*
* the latter case is only possible if a size is currently set on the
* element
*/
if (WT.pxself(element, DC.size) == 0)
scrollSize = clientSize;
else {
var visiblePopup = false;
$(element).find(".Wt-popup").each
(function(index) {
if (this.style.display !== 'none')
visiblePopup = true;
});
if (visiblePopup)
scrollSize = clientSize;
}
}
var border = WT.px(element, 'border' + DC.Left + 'Width') +
WT.px(element, 'border' + DC.Right + 'Width');
var scrollbar = offsetSize - (clientSize + border) != 0;
if (asSet)
return [scrollSize, scrollBar];
if (WT.isGecko &&
dir == HORIZONTAL &&
element.getBoundingClientRect().width !=
Math.ceil(element.getBoundingClientRect().width))
scrollSize += 1;
if (!WT.boxSizing(element) && !WT.isOpera)
scrollSize += border;
scrollSize +=
WT.px(element, 'margin' + DC.Left) +
WT.px(element, 'margin' + DC.Right);
if (!WT.boxSizing(element) && !WT.isIE)
scrollSize +=
WT.px(element, 'padding' + DC.Left) +
WT.px(element, 'padding' + DC.Right);
/* Must be because of a scrollbar */
scrollSize += (offsetSize - (clientSize + border));
if (scrollSize < offsetSize) // happens on IE8?
scrollSize = offsetSize;
var maxSize = WT.px(element, 'max' + DC.Size);
if (maxSize > 0)
scrollSize = Math.min(maxSize, scrollSize);
return [Math.round(scrollSize), scrollbar];
}
function calcMinimumSize(element, dir) {
var DC = DirConfig[dir];
if (element.style.display === 'none')
return 0;
else {
if (element['layoutMin' + DC.Size])
return element['layoutMin' + DC.Size];
else {
var result = WT.px(element, 'min' + DC.Size);
if (!WT.boxSizing(element))
result += WT.px(element, 'padding' + DC.Left) +
WT.px(element, 'padding' + DC.Right);
return result;
}
}
}
function margin(el, dir) {
var DC = DirConfig[dir];
var result = WT.px(el, 'margin' + DC.Left)
+ WT.px(el, 'margin' + DC.Right);
/* Second condition: IE9 applys boxsizing to 'BUTTON' objects ? */
if (!WT.boxSizing(el)
&& !(WT.isIE && !WT.isIElt9 && WT.hasTag(el, 'BUTTON'))) {
result += WT.px(el, 'border' + DC.Left + 'Width') +
WT.px(el, 'border' + DC.Right + 'Width') +
WT.px(el, 'padding' + DC.Left) +
WT.px(el, 'padding' + DC.Right);
}
return result;
}
/*
* Returns padding: different between contents size and clientSize
*/
function padding(el, dir) {
var DC = DirConfig[dir];
return WT.px(el, 'padding' + DC.Left) + WT.px(el, 'padding' + DC.Right);
}
/*
* Returns padding: different between contents size and reported 'size'
*/
function sizePadding(el, dir) {
if (WT.boxSizing(el)) {
var DC = DirConfig[dir];
return WT.px(el, 'border' + DC.Left + 'Width') +
WT.px(el, 'border' + DC.Right + 'Width') +
WT.px(el, 'padding' + DC.Left) +
WT.px(el, 'padding' + DC.Right);
} else
return 0;
}
/*
* Returns all-inclusive margin, border and padding
*/
function boxMargin(el, dir) {
var DC = DirConfig[dir];
return Math.round(WT.px(el, 'border' + DC.Left + 'Width') +
WT.px(el, 'border' + DC.Right + 'Width') +
WT.px(el, 'margin' + DC.Left) +
WT.px(el, 'margin' + DC.Right) +
WT.px(el, 'padding' + DC.Left) +
WT.px(el, 'padding' + DC.Right));
}
/*
* dirt: 0 = not dirty
* 1 = remeasure size
* 2 = remeasure all
*/
function setItemDirty(item, dirt, scheduleAdjust) {
item.dirty = Math.max(item.dirty, dirt);
itemDirty = true;
if (scheduleAdjust)
APP.layouts2.scheduleAdjust();
};
function setCss(widget, property, value) {
if (widget.style[property] !== value) {
widget.style[property] = value;
return true;
} else
return false;
}
/*
* Only checks the single widget -- already assumes the ancestors are visible
*/
function isHidden(w) {
// XXX second condition is a hack for WTextEdit
return (w.style.display === 'none' && !w.ed) || $(w).hasClass('Wt-hidden');
}
function measure(dir, widget, container)
{
var DC = DirConfig[dir],
OC = DirConfig[dir ^ 1],
measures = DC.measures,
dirCount = DC.config.length,
otherCount = OC.config.length,
maxSize = DC.maxSize;
var prevMeasures = measures.slice();
if (prevMeasures.length == 5) {
prevMeasures[PREFERRED_SIZE] = prevMeasures[PREFERRED_SIZE].slice();
prevMeasures[MINIMUM_SIZE] = prevMeasures[MINIMUM_SIZE].slice();
}
/*
* If only layoutDirty then we do not need to remeasure children,
* but simply propagate up again the total preferred size and reapply the
* layout as the container may have changed in size.
*/
if (itemDirty) {
if (container && typeof DC.minSize == 'undefined') {
DC.minSize = WT.px(container, 'min' + DC.Size);
if (DC.minSize > 0)
DC.minSize -= sizePadding(container, dir);
}
var preferredSize = [], minimumSize = [],
totalPreferredSize = 0, totalMinSize = 0, di, oi;
var measurePreferredForStretching = true, spanned = false;
for (di = 0; di < dirCount; ++di) {
var dPreferred = 0;
var dMinimum = DC.config[di][MIN_SIZE];
var allHidden = true;
for (oi = 0; oi < otherCount; ++oi) {
var item = DC.getItem(di, oi);
if (item) {
if (!item.w || (dir == HORIZONTAL && item.dirty > 1)) {
var $w = $("#" + item.id);
var w2 = $w.get(0);
if (!w2) { // is missing, could be because it is overspanned!
DC.setItem(di, oi, null);
continue;
}
if (w2 != item.w) {
item.w = w2;
$w.find("img").add($w.filter("img"))
.bind('load',
{ item: item},
function(event) {
setItemDirty(event.data.item, 1, true);
});
}
}
if (!progressive && item.w.style.position != 'absolute') {
item.w.style.position = 'absolute';
item.w.style.visibility = 'hidden';
}
if (!item.ps)
item.ps = []; // preferred size
if (!item.sc)
item.sc = []; // scrollbar (if present needs forceful size set)
if (!item.ms)
item.ms = []; // minimum size
if (!item.size)
item.size = []; // set size
if (!item.psize)
item.psize = []; // set size (incl. margins, like preferred size)
if (!item.fs)
item.fs = []; // fixed size (size defined by inline size or CSS)
if (!item.margin)
item.margin = [];
var first = !item.set;
if (!item.set)
item.set = [false, false];
if (isHidden(item.w)) {
item.ps[dir] = item.ms[dir] = 0;
continue;
}
if (item.w) {
if (WT.isIE)
item.w.style.visibility = '';
if (debug)
console.log("measure " + dir + " "
+ item.id +
(item.w.className ? ' (' + item.w.className + '): '
: ': ') +
item.ps[0] + ',' + item.ps[1]
+ ',' + item.dirty + ', set: ['
+ item.set[0] + ',' + item.set[1] + '], sc: ['
+ item.sc[0] + ',' + item.sc[1] + ']');
if (item.dirty) {
var wMinimum;
if (item.dirty > 1) {
wMinimum = calcMinimumSize(item.w, dir);
item.ms[dir] = wMinimum;
} else
wMinimum = item.ms[dir];
if (wMinimum > dMinimum)
dMinimum = wMinimum;
/*
* if we do not have an size set, we can and should take into
* account the size set for a widget by CSS. But we can't really
* read this -- computedStyle for width or height measures
* instead of interpreting the stylesheet ... !
*
* we'll consider computedStyle only for vertical size, and only
* the first time
*/
if (item.dirty > 1)
item.margin[dir] = margin(item.w, dir);
if (!item.set[dir]) {
if (dir == HORIZONTAL || !first) {
var fw = WT.pxself(item.w, DC.size);
if (fw)
item.fs[dir] = fw + item.margin[dir];
else
item.fs[dir] = 0;
} else {
var fw = Math.round(WT.px(item.w, DC.size));
if (fw > Math.max(sizePadding(item.w, dir), wMinimum))
item.fs[dir] = fw + item.margin[dir];
else
item.fs[dir] = 0;
}
}
var alignment = (item.align >> DC.alignBits) & 0xF;
var wPreferred = item.fs[dir];
if (alignment
|| measurePreferredForStretching
|| (DC.config[di][STRETCH] <= 0)) {
if (!item.layout) {
if (item.wasLayout) {
item.wasLayout = false;
item.set = [false, false];
item.ps = [];
if (item.w.wtResize)
item.w.wtResize(item.w, -1, -1, true);
setCss(item.w, DirConfig[1].size, '');
}
var calc = calcPreferredSize(item.w, dir, false, widget);
var calculated = calc[0];
/*
* If we've set the size then we should not take the
* set size as the preferred size, instead we revert
* to a previous preferred size.
*/
var sizeSet = item.set[dir];
if (sizeSet) {
/*
* Make an exception for very small sizes set ...
* Typically to discount for margin/paddings on
* form elements which are not properly measured
* if the item is being reduced to very small
* width/height
*/
if (item.psize[dir] > 8)
sizeSet = (calculated >= item.psize[dir] - 4) &&
(calculated <= item.psize[dir] + 4);
}
/*
* If this is an item that is stretching and has
* been stretched (item.set[dir]), then we should
* not remeasure the preferred size since it might
* confuse the user with constant resizing.
*
* -- FIXME: what if sum stretch=0, we are actually
* also stretching ?
*/
var stretching = (typeof item.ps[dir] !== 'undefined')
&& (DC.config[di][STRETCH] > 0)
&& item.set[dir];
if (sizeSet || stretching)
wPreferred = Math.max(wPreferred, item.ps[dir]);
else
wPreferred = Math.max(wPreferred, calculated);
item.ps[dir] = wPreferred;
item.sc[dir] = calc[1];
} else {
if (wPreferred == 0)
wPreferred = item.ps[dir];
item.ps[dir] = wPreferred;
}
} else if (item.layout) {
if (wPreferred == 0)
wPreferred = item.ps[dir];
}
if (!item.span || item.span[dir] == 1) {
if (wPreferred > dPreferred)
dPreferred = wPreferred;
} else
spanned = true;
} else {
if (!item.span || item.span[dir] == 1) {
if (item.ps[dir] > dPreferred)
dPreferred = item.ps[dir];
if (item.ms[dir] > dMinimum)
dMinimum = item.ms[dir];
} else
spanned = true;
}
if (debug)
console.log(" ->" + item.id + ': ' + item.ps[0] + ","
+ item.ps[1]);
var hidden = isHidden(item.w);
if (!hidden && (!item.span || item.span[dir] == 1)) {
allHidden = false;
}
}
}
}
if (!allHidden) {
if (dMinimum > dPreferred)
dPreferred = dMinimum;
} else {
// make minimum width/height consistent with preferred
dMinimum = dPreferred = -1;
}
preferredSize[di] = dPreferred;
minimumSize[di] = dMinimum;
if (dMinimum > -1) {
totalPreferredSize += dPreferred;
totalMinSize += dMinimum;
}
}
if (spanned) {
if (debug)
console.log("(before spanned) "
+ id + ': ' + dir + " ps " + preferredSize);
function handleOverspanned(getItemSize, sizes) {
for (di = 0; di < dirCount; ++di) {
for (oi = 0; oi < otherCount; ++oi) {
var item = DC.getItem(di, oi);
if (item && item.span && item.span[dir] > 1) {
var ps = getItemSize(item), count = 0, stretch = 0, si;
for (si = 0; si < item.span[dir]; ++si) {
var cps = sizes[di + si];
if (cps != -1) {
ps -= cps;
++count;
if (DC.config[di + si][STRETCH] > 0)
stretch += DC.config[di + si][STRETCH];
}
}
if (ps >= 0) {
if (count > 0) {
if (stretch > 0)
count = stretch;
for (si = 0; si < item.span[dir]; ++si) {
var cps = sizes[di + si];
if (cps != -1) {
var portion;
if (stretch > 0)
portion = DC.config[di + si][STRETCH];
else
portion = 1;
if (portion > 0) {
var fract = Math.round(ps / portion);
ps -= fract; count -= portion;
sizes[di + si] += fract;
}
}
}
} else
sizes[di] = ps;
}
}
}
}
}
handleOverspanned(function(item) { return item.ps[dir]; },
preferredSize);
handleOverspanned(function(item) { return item.ms[dir]; },
minimumSize);
}
var totalMargin = 0, first = true, rh = false;
for (di = 0; di < dirCount; ++di) {
if (minimumSize[di] > -1) {
if (first) {
totalMargin += DC.margins[MARGIN_LEFT];
first = false;
} else {
totalMargin += DC.margins[SPACING];
if (rh)
totalMargin += RESIZE_HANDLE_MARGIN * 2;
}
rh = DC.config[di][RESIZABLE] !== 0;
}
}
if (!first)
totalMargin += DC.margins[MARGIN_RIGHT];
totalPreferredSize += totalMargin;
totalMinSize += totalMargin;
if (debug)
console.log("measured " + id + ': ' + dir + " ps " + preferredSize);
DC.measures = [
preferredSize,
minimumSize,
totalPreferredSize,
totalMinSize,
totalMargin
];
} // itemDirty
if (layoutDirty ||
(prevMeasures[TOTAL_PREFERRED_SIZE] !=
DC.measures[TOTAL_PREFERRED_SIZE]))
self.updateSizeInParent(dir);
/* If our minimum layout requirements have changed, then we want
* to communicate this up using the minimum widths
* -- FIXME IE6
*/
if (container
&& DC.minSize == 0
&& prevMeasures[TOTAL_MINIMUM_SIZE] != DC.measures[TOTAL_MINIMUM_SIZE]
&& container.parentNode.className != 'Wt-domRoot') {
var w = DC.measures[TOTAL_MINIMUM_SIZE] + 'px';
setCss(container, 'min' + DC.Size, w);
}
if (container) {
if (dir == HORIZONTAL && container && WT.hasTag(container, "TD")) {
/*
* A table will otherwise not provide any room for this 0-width cell
*/
setCss(container, DC.size, DC.measures[TOTAL_PREFERRED_SIZE] + 'px');
}
}
}
this.updateSizeInParent = function(dir) {
/*
* If we are directly in a parent layout, then we want to
* mark the corresponding cell as dirty if the TOTAL_PREFERRED_SIZE
* has changed (or force).
*/
if (parent && parentItemWidget.id) {
var piw = WT.$(parentItemWidget.id);
if (piw) {
if (parentItemWidget != piw) {
parent = jQuery.data(piw.parentNode, 'layout');
if (!parent) {
/* The parent item widget is no longer in the DOM. Need a test
* case for that. */
initializeParent();
} else
parentItemWidget = piw;
}
} else {
/* The parent item widget is no longer in the DOM. Need a test case
* for that. */
initializeParent();
}
}
if (parent) {
if (propagateSizeToParent) {
var DC = DirConfig[dir],
totalPs = DC.measures[TOTAL_PREFERRED_SIZE];
if (DC.maxSize > 0)
totalPs = Math.min(DC.maxSize, totalPs);
if (parentWithWtPS) {
var widget = WT.getElement(id);
if (!widget)
return;
/*
* Go back up and apply wtGetPS() to totalPs
*/
var c = widget, p = c.parentNode;
for (;;) {
if (p.wtGetPS)
totalPs = p.wtGetPS(p, c, dir, totalPs);
totalPs += boxMargin(p, dir);
if (p == parentItemWidget)
break;
if (dir == VERTICAL &&
p == widget.parentNode &&
!p.lh &&
p.offsetHeight > totalPs)
totalPs = p.offsetHeight;
c = p;
p = c.parentNode;
}
} else
totalPs += parentMargin[dir];
parent.setChildSize(parentItemWidget, dir, totalPs);
}
}
};
function finishResize(dir, di, delta) {
var DC = DirConfig[dir];
if (rtl) delta = -delta;
/*
* If di is stretchable and di + 1 isn't, then fix the size of
* di+1 (this seems to match with user intuition after around
* midnight).
*/
if (DC.config[di][STRETCH] > 0 && DC.config[di + 1][STRETCH] == 0) {
++di;
delta = -delta;
}
DC.fixedSize[di] = DC.sizes[di] + delta;
APP.layouts2.scheduleAdjust();
}
function startResize(dir, handle, event) {
var di = handle.di, DC = DirConfig[dir], OC = DirConfig[dir ^ 1],
minDelta, maxDelta,
widget = WT.getElement(id);
var ri;
for (ri = di - 1; ri >= 0; --ri) {
if (DC.sizes[ri] >= 0) {
minDelta = -(DC.sizes[ri] - DC.measures[MINIMUM_SIZE][ri]);
break;
}
}
maxDelta = DC.sizes[di] - DC.measures[MINIMUM_SIZE][di];
if (rtl) {
var t = minDelta;
minDelta = -maxDelta;
maxDelta = -t;
}
new WT.SizeHandle(WT, DC.resizeDir, WT.pxself(handle, DC.size),
WT.pxself(handle, OC.size), minDelta, maxDelta,
DC.resizerClass, function(delta) {
finishResize(dir, ri, delta);
}, handle, widget, event, 0, 0);
}
// does this column/row have an adjacent handle?
function hasResizeHandle(config, di) {
if (di == 0) {
return (config[di][RESIZABLE] !== 0);
} else {
return (config[di-1][RESIZABLE] !== 0 ||
config[di][RESIZABLE] !== 0);
}
}
function apply(dir, widget) {
var DC = DirConfig[dir],
OC = DirConfig[dir ^ 1],
measures = DC.measures,
cSize = 0, cClientSize = false, cPaddedSize = false, noStretch = false;
var container = topLevel ? widget.parentNode : null,
containerParent = topLevel ? container.parentNode : null;
if (DC.maxSize === 0) {
if (container) {
var pc = WT.css(container, 'position');
if (pc === 'absolute')
cSize = WT.pxself(container, DC.size);
if (cSize === 0) {
if (!DC.initialized) {
if (dir === HORIZONTAL && (pc === 'absolute' || pc === 'fixed')) {
/*
* On Chrome, somehow clientWidth is not reliable until
* we do this little hocus pocus
*/
container.style.display = 'none';
cSize = container.clientWidth;
container.style.display = '';
}
cSize = dir ? container.clientHeight : container.clientWidth;
cClientSize = true;
if (dir == 0 && cSize == 0 && WT.isIElt9) {
cSize = container.offsetWidth;
cClientSize = false;
}
/*
* heuristic to switch to layout-sizes-container mode
*/
var minSize, ieCSize;
if ((WT.hasTag(container, "TD") || WT.hasTag(container, "TH") ||
$(container.parentNode).hasClass('Wt-domRoot'))
&& !(WT.isIE && !WT.isIElt9)) {
minSize = 0;
ieCSize = 1;
} else {
if (DC.minSize) // original minSize
minSize = DC.minSize;
else // set minSize
minSize = measures[TOTAL_MINIMUM_SIZE];
ieCSize = 0;
}
if (debug)
console.log('cSize : ' + cSize
+ (cClientSize ? '(clientSize)' : '') + ', ieCSize : '
+ ieCSize
+ ', minSize : ' + minSize + ', padding: '
+ padding(container, dir) + ', sizePadding: '
+ sizePadding(container, dir));
function epsNotLarger(a, b) {
return a - b <= 1;
}
if ((WT.isIElt9 && epsNotLarger(cSize, ieCSize))
|| (epsNotLarger(cSize, minSize + padding(container, dir)))) {
if (debug)
console.log('switching to managed container size '
+ dir + ' ' + id);
DC.maxSize = 999999;
}
}
if (cSize === 0 && DC.maxSize === 0) {
cSize = dir ? container.clientHeight : container.clientWidth;
cClientSize = true;
}
}
} else {
cSize = WT.pxself(widget, DC.size);
cPaddedSize = true;
}
} else {
if (DC.sizeSet) {
cSize = WT.pxself(container, DC.size);
cPaddedSize = true;
}
}
var otherPadding = 0;
if (container && container.wtGetPS && dir == VERTICAL)
otherPadding = container.wtGetPS(container, widget, dir, 0);
var totalPreferredSize = measures[TOTAL_PREFERRED_SIZE];
if (totalPreferredSize < DC.minSize)
totalPreferredSize = DC.minSize;
if (DC.maxSize && !DC.sizeSet) {
// (2) adjust container width/height
var sz = Math.min(totalPreferredSize, DC.maxSize) + otherPadding;
if (setCss(container, DC.size,
(sz + sizePadding(container, dir)) + 'px')) {
if (parent)
parent.setElDirty(parentItemWidget);
}
cSize = sz;
cPaddedSize = true;
noStretch = true;
}
DC.cSize = cSize;
if (dir == VERTICAL && container && container.wtResize) {
var w = OC.cSize,
h = DC.cSize;
container.wtResize(container, Math.round(w), Math.round(h), true);
}
cSize -= otherPadding;
if (!cPaddedSize) {
var p = 0;
if (typeof DC.cPadding === 'undefined') {
if (cClientSize)
p = padding(container, dir);
else
p = sizePadding(container, dir);
DC.cPadding = p;
} else
p = DC.cPadding;
cSize -= p;
}
DC.initialized = true;
if (debug)
console.log("apply " + id + ': '
+ dir + " ps " + measures[PREFERRED_SIZE]
+ " cSize " + cSize);
if (container && cSize <= 0)
return;
// (2a) if we can't satisfy minimum sizes, then overflow container
if (cSize < measures[TOTAL_MINIMUM_SIZE] - otherPadding)
cSize = measures[TOTAL_MINIMUM_SIZE] - otherPadding;
// (3) compute column/row widths
var targetSize = [], dirCount = DC.config.length,
otherCount = OC.config.length;
for (di = 0; di < dirCount; ++di)
DC.stretched[di] = false;
if (cSize >= measures[TOTAL_MINIMUM_SIZE] - otherPadding) {
// (1) fixed size columns/rows get their fixed width
// (2) other colums/rows:
// if all columns are not stretchable: make them all stretchable
//
// can non-stretchable ones get their preferred size ?
// (assuming stretchables take minimum size)
// -> yes: do so;
// can stretchable ones get their preferred size ?
// -> yes; do so and distribute excess
// -> no: shrink according to their preferred size
// - min size difference
// -> no: shrink non-stretchable ones according to their preferred
// size - min size difference
// set stretchable ones to minimum size
/** @const */ var FIXED_SIZE = -1;
/** @const */ var HIDDEN = -2;
/** @const */ var NON_STRETCHABLES = 0;
/** @const */ var STRETCHABLES = 1;
var toDistribute = cSize - measures[TOTAL_MARGIN];
var stretch = [];
var totalMinimum = [0, 0], totalPreferred = [0, 0],
totalStretch = 0;
for (var di = 0; di < dirCount; ++di) {
if (measures[MINIMUM_SIZE][di] > -1) {
var fs = -1;
/* if resizable was disabled, remove fixedSize and go back to
* using the preferred size
*/
if (typeof DC.fixedSize[di] !== "undefined"
&& ! hasResizeHandle(DC.config, di) ) {
DC.fixedSize[di] = undefined;
}
/*
* If we have a fixedSize (set by resizing) then we should
* take it into account only if the resizer is still visible.
*
* This probably isn't entirely accurate, but neither is resizers
* when hiding/showing widgets ?
*/
if (typeof DC.fixedSize[di] !== "undefined"
&& (di + 1 == dirCount || measures[MINIMUM_SIZE][di + 1] > -1))
fs = DC.fixedSize[di];
else if ((DC.config[di][RESIZABLE] !== 0)
&& (DC.config[di][RESIZABLE][RS_INITIAL_SIZE] >= 0)) {
fs = DC.config[di][RESIZABLE][RS_INITIAL_SIZE];
if (DC.config[di][RESIZABLE][RS_PCT])
fs = (cSize - measures[TOTAL_MARGIN]) * fs / 100;
}
if (fs >= 0) {
stretch[di] = FIXED_SIZE;
targetSize[di] = fs;
toDistribute -= targetSize[di];
} else {
var category;
if (DC.config[di][STRETCH] > 0) {
category = STRETCHABLES;
stretch[di] = DC.config[di][STRETCH];
totalStretch += stretch[di];
} else {
category = NON_STRETCHABLES;
stretch[di] = 0;
}
totalMinimum[category] += measures[MINIMUM_SIZE][di];
totalPreferred[category] += measures[PREFERRED_SIZE][di];
targetSize[di] = measures[PREFERRED_SIZE][di];
}
} else {
stretch[di] = HIDDEN;
targetSize[di] = -1;
}
}
if (DC.fixedSize.length > dirCount)
DC.fixedSize.length = dirCount;
if (totalStretch == 0) {
for (di = 0; di < dirCount; ++di)
if (stretch[di] == 0) {
stretch[di] = 1;
++totalStretch;
}
totalPreferred[STRETCHABLES] = totalPreferred[NON_STRETCHABLES];
totalMinimum[STRETCHABLES] = totalMinimum[NON_STRETCHABLES];
totalPreferred[NON_STRETCHABLES] = 0;
totalMinimum[NON_STRETCHABLES] = 0;
}
if (toDistribute >
totalPreferred[NON_STRETCHABLES] + totalMinimum[STRETCHABLES]) {
toDistribute -= totalPreferred[NON_STRETCHABLES];
if (toDistribute > totalPreferred[STRETCHABLES]) {
if (DC.fitSize) {
// enlarge stretchables according to their stretch factor
toDistribute -= totalPreferred[STRETCHABLES];
var factor = toDistribute / totalStretch;
for (di = 0; di < dirCount; ++di) {
if (stretch[di] > 0) {
targetSize[di] += Math.round(stretch[di] * factor);
DC.stretched[di] = true;
}
}
}
} else {
// shrink stretchables up to their minimum size
var category = STRETCHABLES;
if (toDistribute < totalMinimum[category])
toDistribute = totalMinimum[category];
var factor;
if (totalPreferred[category] - totalMinimum[category] > 0)
factor = (toDistribute - totalMinimum[category])
/ (totalPreferred[category] - totalMinimum[category]);
else
factor = 0;
for (di = 0; di < dirCount; ++di) {
if (stretch[di] > 0) {
var s = measures[PREFERRED_SIZE][di]
- measures[MINIMUM_SIZE][di];
targetSize[di] = measures[MINIMUM_SIZE][di]
+ Math.round(s * factor);
}
}
}
} else {
for (di = 0; di < dirCount; ++di)
if (stretch[di] > 0)
targetSize[di] = measures[MINIMUM_SIZE][di];
toDistribute -= totalMinimum[STRETCHABLES];
// shrink non-stretchables up to their minimum size
var category = NON_STRETCHABLES;
if (toDistribute < totalMinimum[category])
toDistribute = totalMinimum[category];
var factor;
if (totalPreferred[category] - totalMinimum[category] > 0)
factor = (toDistribute - totalMinimum[category])
/ (totalPreferred[category] - totalMinimum[category]);
else
factor = 0;
for (di = 0; di < dirCount; ++di) {
if (stretch[di] == 0) {
var s = measures[PREFERRED_SIZE][di]
- measures[MINIMUM_SIZE][di];
targetSize[di] = measures[MINIMUM_SIZE][di]
+ Math.round(s * factor);
}
}
}
} else
targetSize = measures[MINIMUM_SIZE];
DC.sizes = targetSize;
if (debug)
console.log(" -> targetSize: " + targetSize);
// (4) set widths/heights of cells
var left = DC.margins[MARGIN_LEFT],
first = true, resizeHandle = false, oi, di;
for (di = 0; di < dirCount; ++di) {
if (targetSize[di] > -1) {
var thisResized = resizeHandle;
if (resizeHandle) {
var hid = id + "-rs" + dir + "-" + di;
var handle = WT.getElement(hid);
if (!handle) {
DC.resizeHandles[di] = hid;
handle = document.createElement('div');
handle.setAttribute('id', hid);
handle.di = di;
handle.style.position='absolute';
handle.style[OC.left] = OC.margins[MARGIN_LEFT] + 'px';
handle.style[DC.size] = DC.margins[SPACING] + 'px';
if (OC.cSize)
handle.style[OC.size] = (OC.cSize - OC.margins[MARGIN_RIGHT] -
OC.margins[MARGIN_LEFT]) + 'px';
handle.className = DC.handleClass;
widget.insertBefore(handle, widget.firstChild);
handle.onmousedown = handle.ontouchstart = function(event) {
var e = event||window.event;
startResize(dir, this, e);
};
}
left += RESIZE_HANDLE_MARGIN;
setCss(handle, DC.left, left + 'px');
left += RESIZE_HANDLE_MARGIN;
} else {
if (DC.resizeHandles[di]) {
var handle = WT.getElement(DC.resizeHandles[di]);
handle.parentNode.removeChild(handle);
DC.resizeHandles[di] = undefined;
}
}
resizeHandle = DC.config[di][RESIZABLE] !== 0;
if (first)
first = false;
else
left += DC.margins[SPACING];
}
for (oi = 0; oi < otherCount; ++oi) {
var item = DC.getItem(di, oi);
if (item && item.w) {
var w = item.w;
var ts = Math.max(targetSize[di], 0);
if (item.span) {
var si;
var rs = resizeHandle;
for (si = 1; si < item.span[dir]; ++si) {
if (di + si >= targetSize.length)
break;
if (rs)
ts += RESIZE_HANDLE_MARGIN * 2;
rs = DC.config[di + si][RESIZABLE] !== 0;
if (targetSize[di + si - 1] > -1 && targetSize[di + si] > -1)
ts += DC.margins[SPACING];
ts += targetSize[di + si];
}
}
var off;
setCss(w, 'visibility', '');
var alignment = (item.align >> DC.alignBits) & 0xF;
var ps = item.ps[dir];
if (ts < ps)
alignment = 0;
if (!alignment) {
var m = item.margin[dir];
var tsm = Math.max(0, ts - m);
/*
* We need to force setting a size if there is a scrollbar
* (reasons unknown, only for a vertical scrollbar?)
*/
var setSize = dir == 0 && item.sc[dir];
var hidden = isHidden(w);
if (!hidden && (setSize || ts != ps || item.layout)) {
if (setCss(w, DC.size, tsm + 'px')) {
/*
* Setting a size cancels the built-in margin!
*/
if (!WT.isIE && (WT.hasTag(w, 'TEXTAREA') ||
WT.hasTag(w, 'INPUT'))) {
setCss(w, 'margin-' + DC.left, item.margin[dir]/2 + 'px');
setCss(w, 'margin-' + OC.left, item.margin[!dir]/2 + 'px');
}
setItemDirty(item, 1);
item.set[dir] = true;
}
} else {
if (!item.fs[dir]) {
if (setCss(w, DC.size, ''))
setItemDirty(item, 1);
if (item.set)
item.set[dir] = false;
} else if (dir == HORIZONTAL)
setCss(w, DC.size, (item.fs[dir] - m) + 'px');
}
off = left;
item.size[dir] = tsm;
item.psize[dir] = ts;
} else {
switch (alignment) {
case ALIGN_LEFT: off = left; break;
case ALIGN_CENTER: off = left + (ts - ps)/2; break;
case ALIGN_RIGHT: off = left + (ts - ps); break;
}
ps -= item.margin[dir];
if (item.layout) {
if (setCss(w, DC.size, ps + 'px'))
setItemDirty(item, 1);
item.set[dir] = true;
} else if (ts >= ps && item.set[dir]) {
if (setCss(w, DC.size, ps + 'px'))
setItemDirty(item, 1);
item.set[dir] = false;
}
item.size[dir] = ps;
item.psize[dir] = ps;
}
if (!progressive)
setCss(w, DC.left, off + 'px');
else
if (thisResized) {
setCss(w, DC.left, (RESIZE_HANDLE_MARGIN * 2) + 'px');
var pc = WT.css(w, 'position');
if (pc !== 'absolute')
w.style.position = 'relative';
} else
setCss(w, DC.left, '0px');
if (dir == VERTICAL) {
if (w.wtResize)
w.wtResize(w,
item.set[HORIZONTAL]
? Math.round(item.size[HORIZONTAL]) : -1,
item.set[VERTICAL]
? Math.round(item.size[VERTICAL]) : -1,
true);
item.dirty = 0;
}
}
}
if (targetSize[di] > -1)
left += targetSize[di];
}
if (DC.resizeHandles.length > dirCount) {
for (var i=dirCount; i < DC.resizeHandles.length; i++) {
if (DC.resizeHandles[i]) {
var handle = WT.getElement(DC.resizeHandles[i]);
handle.parentNode.removeChild(handle);
}
}
DC.resizeHandles.length = dirCount;
}
$(widget).children("." + OC.handleClass)
.css(DC.size,
(cSize - DC.margins[MARGIN_RIGHT] - DC.margins[MARGIN_LEFT])
+ 'px');
}
this.setConfig = function(conf) {
/*
* Flush preferred size measurements
*/
var oldConfig = config;
config = conf;
DirConfig[0].config = config.cols;
DirConfig[1].config = config.rows;
DirConfig[0].stretched = [];
DirConfig[1].stretched = [];
var i, il, childLayouts = {};
for (i = 0, il = oldConfig.items.length; i < il; ++i) {
var oldItem = oldConfig.items[i];
if (oldItem) {
var newItem = getItem(oldItem.id);
if (newItem) {
newItem.ps = oldItem.ps;
newItem.sc = oldItem.sc;
newItem.ms = oldItem.ms;
newItem.size = oldItem.size;
newItem.psize = oldItem.psize;
newItem.fs = oldItem.fs;
newItem.margin = oldItem.margin;
newItem.set = oldItem.set;
} else {
if (oldItem.set) {
if (oldItem.set[HORIZONTAL])
setCss(oldItem.w, DirConfig[HORIZONTAL].size, '');
if (oldItem.set[VERTICAL])
setCss(oldItem.w, DirConfig[VERTICAL].size, '');
}
}
}
}
layoutDirty = true;
itemDirty = true;
APP.layouts2.scheduleAdjust();
};
this.getId = function() {
return id;
};
this.setElDirty = function(el) {
var item = getItem(el.id);
if (item) {
item.dirty = 2;
itemDirty = true;
APP.layouts2.scheduleAdjust();
}
};
this.setItemsDirty = function(items) {
var i, il;
var colCount = DirConfig[HORIZONTAL].config.length;
for (i = 0, il = items.length; i < il; ++i) {
var row = items[i][0], col = items[i][1];
var item = config.items[row * colCount + col];
if (item) {
item.dirty = 2;
/*
* When the item contains a layout, a change may also impact this:
* it could become a different layout (e.g. WStackedWidget) or
* a hidden layout (e.g. WPanel). Assume in general that it could
* be the case that we need to reset the layout-based size, but don't
* do it yet since it causes flicker when nothing drastic changed.
*/
if (item.layout) {
item.layout = false;
item.wasLayout = true;
APP.layouts2.setChildLayoutsDirty(self, item.w);
}
}
}
itemDirty = true;
};
this.setDirty = function() {
layoutDirty = true;
};
this.setAllDirty = function() {
var i, il;
for (i = 0, il = config.items.length; i < il; ++i) {
var item = config.items[i];
if (item)
item.dirty = 2;
}
itemDirty = true;
};
this.setChildSize = function(widget, dir, preferredSize) {
var colCount = DirConfig[HORIZONTAL].config.length,
DC = DirConfig[dir],
i, il;
var item = getItem(widget.id);
if (item) {
var di = (dir === HORIZONTAL ? i % colCount : i / colCount);
var alignment = (item.align >> DC.alignBits) & 0xF;
if (alignment || !DC.stretched[di]) {
if (!item.ps)
item.ps = [];
item.ps[dir] = preferredSize;
}
item.layout = true;
setItemDirty(item, 1);
}
};
function initializeParent() {
var widget = WT.getElement(id);
topLevel = parentId == null;
parent = null;
parentItemWidget = null;
propagateSizeToParent = true;
parentInitialized = true;
parentMargin = [];
parentWithWtPS = false;
if (!topLevel) {
parent = jQuery.data(document.getElementById(parentId), 'layout');
parentItemWidget = widget;
parentMargin[HORIZONTAL] = boxMargin(parentItemWidget, HORIZONTAL);
parentMargin[VERTICAL] = boxMargin(parentItemWidget, VERTICAL);
} else {
/*
* While we are a single child in a parent, or if we have a
* wtGetPS() function on that parent, we can go further up
* looking for an ancestor layout
*/
var c = widget, p = c.parentNode;
parentMargin = [0, 0];
for (;p != document;) {
parentMargin[HORIZONTAL] += boxMargin(p, HORIZONTAL);
parentMargin[VERTICAL] += boxMargin(p, VERTICAL);
if (p.wtGetPS)
parentWithWtPS = true;
var l = jQuery.data(p.parentNode, 'layout');
if (l) {
parentItemWidget = p;
parent = l;
break;
}
c = p;
p = c.parentNode;
if (p.childNodes.length != 1 && !p.wtGetPS)
propagateSizeToParent = false;
}
var container = widget.parentNode;
for (var i = 0; i < 2; ++i)
DirConfig[i].sizeSet = WT.pxself(container, DirConfig[i].size) != 0;
}
}
this.measure = function(dir) {
var widget = WT.getElement(id);
if (!widget)
return;
if (WT.isHidden(widget))
return;
if (!parentInitialized)
initializeParent();
if (itemDirty || layoutDirty) {
var container = topLevel ? widget.parentNode : null;
measure(dir, widget, container);
}
if (dir == VERTICAL)
itemDirty = layoutDirty = false;
};
this.setMaxSize = function(width, height) {
DirConfig[HORIZONTAL].maxSize = width;
DirConfig[VERTICAL].maxSize = height;
};
this.apply = function(dir) {
var widget = WT.getElement(id);
if (!widget)
return false;
if (WT.isHidden(widget))
return true;
apply(dir, widget);
return true;
};
this.contains = function(layout) {
var thisw = WT.getElement(id);
var otherw = WT.getElement(layout.getId());
if (thisw && otherw)
return WT.contains(thisw, otherw);
else
return false;
};
this.WT = WT;
});
WT_DECLARE_APP_MEMBER
(1, JavaScriptObject, "layouts2",
new (function() {
var topLevelLayouts = [], adjusting = false;
var self = this;
var measureVertical = false;
this.find = function(id) {
var el = document.getElementById(id);
return el ? jQuery.data(el, 'layout') : null;
};
this.setDirty = function(id) {
var layout = this.find(id);
if (layout) {
layout.setDirty();
self.scheduleAdjust();
}
};
this.setElementDirty = function(el) {
/*
* We need to find the first parent of el that is a layout item, and
* then mark it dirty.
*/
var item = el;
el = el.parentNode;
while (el && el != document.body) {
var layout = jQuery.data(el, 'layout');
if (layout)
layout.setElDirty(item);
item = el;
el = el.parentNode;
}
};
this.setChildLayoutsDirty = function(layout, itemWidget) {
var i, il;
for (i=0, il = layout.descendants.length; i < il; ++i) {
var ll = layout.descendants[i];
if (itemWidget) {
var lw = layout.WT.getElement(ll.getId());
if (lw && !layout.WT.contains(itemWidget, lw))
continue;
}
ll.setDirty();
}
};
this.add = function(layout) {
function addIn(layouts, layout) {
var i, il;
for (i=0, il = layouts.length; i < il; ++i) {
var ll = layouts[i];
if (ll.getId() == layout.getId()) {
/*
* Is being re-added (nested layout of item removed + added
* in same event)
*/
layouts[i] = layout;
layout.descendants = ll.descendants;
return;
} else if (ll.contains(layout)) {
addIn(ll.descendants, layout);
return;
} else if (layout.contains(ll)) {
layout.descendants.push(ll);
layouts.splice(i, 1);
--i; --il;
}
}
layouts.push(layout);
}
addIn(topLevelLayouts, layout);
self.scheduleAdjust();
};
var adjustScheduled = false, adjustLoop = 0;
this.scheduleAdjust = function(forceMeasureVertical) {
if (forceMeasureVertical)
measureVertical = true;
if (adjustScheduled)
return;
if (adjusting)
++adjustLoop;
else
adjustLoop = 0;
if (adjustLoop >= 6)
return;
adjustScheduled = true;
setTimeout(function() { self.adjust(); }, 0);
};
this.adjust = function(id, items) {
if (id) {
var layout = this.find(id);
if (layout)
layout.setItemsDirty(items);
self.scheduleAdjust();
return;
}
adjustScheduled = false;
if (adjusting)
return;
adjusting = true;
function measure(layouts, dir) {
var i, il;
for (i = 0, il = layouts.length; i < il; ++i) {
var ll = layouts[i];
measure(ll.descendants, dir);
if (dir == VERTICAL && measureVertical)
ll.setDirty();
else if (dir == HORIZONTAL)
ll.setAllDirty();
ll.measure(dir);
}
}
function apply(layouts, dir) {
var i, il;
for (i = 0, il = layouts.length; i < il; ++i) {
var ll = layouts[i];
if (!ll.apply(dir)) {
layouts.splice(i, 1);
--i; --il;
} else
apply(ll.descendants, dir);
}
}
/** @const */ var HORIZONTAL = 0;
/** @const */ var VERTICAL = 1;
measure(topLevelLayouts, HORIZONTAL);
apply(topLevelLayouts, HORIZONTAL);
measure(topLevelLayouts, VERTICAL);
apply(topLevelLayouts, VERTICAL);
adjusting = false;
measureVertical = false;
};
this.updateConfig = function(id, config) {
var layout = this.find(id);
if (layout)
layout.setConfig(config);
return;
};
this.adjustNow = function() {
if (adjustScheduled)
self.adjust();
};
var resizeDelay = null;
window.onresize = function() {
clearTimeout(resizeDelay);
resizeDelay = setTimeout(function() {
resizeDelay = null;
self.scheduleAdjust(true);
}, 20);
};
window.onshow = function() {
measureVertical = true;
self.adjust();
};
}) ()
);
witty-3.3.4+dfsg.orig/src/js/AuthModel.js 0000644 0001750 0001750 00000001717 11676565265 020477 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "AuthThrottle",
function(WT, button, text) {
jQuery.data(button, 'throttle', this);
var timer = null, originalText = null, counter = 0;
function restore() {
clearInterval(timer);
timer = null;
WT.setHtml(button, originalText);
button.disabled = false;
originalText = null;
}
function update() {
if (counter == 0) {
restore();
} else {
WT.setHtml(button, text.replace("{1}", counter));
--counter;
}
}
this.reset = function(timeout) {
if (timer) {
restore();
}
originalText = button.innerHTML;
counter = timeout;
if (counter) {
timer = setInterval(update, 1000);
button.disabled = true;
update();
}
};
}
); witty-3.3.4+dfsg.orig/src/js/WStackedWidget.js 0000644 0001750 0001750 00000021000 12330010677 021425 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WStackedWidget",
function (APP, widget) {
jQuery.data(widget, 'obj', this);
var WT = APP.WT, scrollTops = [], scrollLefts = [];
function isProperChild(el) {
return el.nodeType == 1;
}
this.wtResize = function(self, w, h, layout) {
var hdefined = h >= 0;
self.lh = hdefined && layout;
if (hdefined)
self.style.height = h + 'px';
else
self.style.height = '';
if (WT.boxSizing(self)) {
h -= WT.px(self, 'marginTop');
h -= WT.px(self, 'marginBottom');
h -= WT.px(self, 'borderTopWidth');
h -= WT.px(self, 'borderBottomWidth');
h -= WT.px(self, 'paddingTop');
h -= WT.px(self, 'paddingBottom');
w -= WT.px(self, 'marginLeft');
w -= WT.px(self, 'marginRight');
w -= WT.px(self, 'borderLeftWidth');
w -= WT.px(self, 'borderRightWidth');
w -= WT.px(self, 'paddingLeft');
w -= WT.px(self, 'paddingRight');
}
function marginV(el) {
var result = WT.px(el, 'marginTop');
result += WT.px(el, 'marginBottom');
if (!WT.boxSizing(el)) {
result += WT.px(el, 'borderTopWidth');
result += WT.px(el, 'borderBottomWidth');
result += WT.px(el, 'paddingTop');
result += WT.px(el, 'paddingBottom');
}
return result;
}
var j, jl, c;
for (j = 0, jl = self.childNodes.length; j < jl; ++j) {
c = self.childNodes[j];
if (isProperChild(c)) {
if (!WT.isHidden(c)) {
if (hdefined) {
var ch = h - marginV(c);
if (ch > 0) {
/*
to prevent that the first child widget's top margin bleeds
to shift this child down, we set overflow. See also #2809
and the original work-around 548948b63
*/
if (c.offsetTop > 0) {
var of = WT.css(c, 'overflow');
if (of === 'visible' || of === '')
c.style.overflow = 'auto';
}
if (c.wtResize)
c.wtResize(c, w, ch, layout);
else {
var cheight = ch + 'px';
if (c.style.height != cheight) {
c.style.height = cheight;
c.lh = layout;
}
}
}
} else {
if (c.wtResize)
c.wtResize(c, w, -1, layout);
else {
c.style.height = '';
c.lh = false;
}
}
}
}
}
};
this.wtGetPs = function(self, child, dir, size) {
return size;
};
this.adjustScroll = function(child) {
var j, jl, c;
var sl = widget.scrollLeft, st = widget.scrollTop;
for (j = 0, jl = widget.childNodes.length; j < jl; ++j) {
c = widget.childNodes[j];
if (isProperChild(c)) {
if (c != child) {
if (c.style.display != 'none') {
scrollLefts[j] = sl;
scrollTops[j] = st;
}
} else {
if (typeof scrollLefts[j] !== 'undefined') {
widget.scrollLeft = scrollLefts[j];
widget.scrollTop = scrollTops[j];
} else {
widget.scrollLeft = 0;
widget.scrollTop = 0;
}
}
}
}
};
this.setCurrent = function(child) {
var j, jl, c;
this.adjustScroll(child);
for (j = 0, jl = widget.childNodes.length; j < jl; ++j) {
c = widget.childNodes[j];
if (isProperChild(c)) {
if (c != child) {
if (c.style.display != 'none') {
c.style.display = 'none';
}
} else {
c.style.display = '';
if (widget.lh) {
widget.lh = false;
widget.style.height = '';
}
}
}
}
};
});
WT_DECLARE_WT_MEMBER
(2, JavaScriptPrototype, "WStackedWidget.prototype.animateChild",
function (WT, child, effects, timing, duration, style) {
var doAnimateChild = function(WT, child, effects, timing, duration, style) {
/* const */ var SlideInFromLeft = 0x1;
/* const */ var SlideInFromRight = 0x2;
/* const */ var SlideInFromBottom = 0x3;
/* const */ var SlideInFromTop = 0x4;
/* const */ var Pop = 0x5;
/* const */ var Fade = 0x100;
/* const */ var Ease = 0;
/* const */ var Linear = 1;
/* const */ var EaseIn = 2;
/* const */ var EaseOut = 3;
/* const */ var EaseInOut = 4;
/* const */ var CubicBezier = 5;
var timings = [ "ease", "linear", "ease-in", "ease-out", "ease-in-out" ],
inverseTiming = [ 0, 1, 3, 2, 4, 5 ],
prefix = WT.vendorPrefix(WT.styleAttribute("animation-duration"));
var animationEventEnd = prefix == "Webkit"
? "webkitAnimationEnd" : "animationend";
/*
* We only need to implement the show() -- we hide the currently
* active one at the same time
*/
if (style.display === 'none')
return;
var stack = child.parentNode;
var reverseIfPrecedes = stack.wtAutoReverse;
function getIndexes() {
var i, il=stack.childNodes.length, fromI = -1, toI = -1;
for (i = 0; i < il && (fromI == -1 || toI == -1); ++i) {
var ch = stack.childNodes[i];
if (ch == child)
toI = i;
else if (ch.style.display !== 'none' && !$(ch).hasClass('out'))
fromI = i;
}
return { from: fromI, to: toI };
}
var index = getIndexes();
if (index.from == -1 || index.to == -1 || index.from == index.to)
return;
var from = stack.childNodes[index.from],
to = stack.childNodes[index.to],
$from = $(from),
$to = $(to),
h = stack.scrollHeight, w = stack.scrollWidth;
function restoreTo() {
$to.removeClass(anim + ' in');
to.style.position = '';
to.style.left = '';
to.style.width = '';
to.style.top = '';
to.style.height = '';
if (WT.isGecko && (effects & Fade))
to.style.opacity = '1';
to.style[WT.styleAttribute('animation-duration')] = '';
to.style[WT.styleAttribute('animation-timing-function')] = '';
}
function restoreFrom() {
$from.removeClass(anim + ' out');
from.style.display = 'none';
from.style[WT.styleAttribute('animation-duration')] = '';
from.style[WT.styleAttribute('animation-timing-function')] = '';
}
/*
* If an animation is already busy, then wait until it is done
* FIXME: Ideally, accelerate existing animation to completion
* For now, reduce duration of any queued animations so that
* backlogs are minimized for faster resync.
*/
if ($from.hasClass("in")) {
$from.one(animationEventEnd, function() {
doAnimateChild(WT, child, effects, timing, 1, style);
});
return;
}
else if ($to.hasClass("out")) {
$to.one(animationEventEnd, function() {
doAnimateChild(WT, child, effects, timing, 1, style);
});
return;
}
h -= WT.px(stack, 'paddingTop');
h -= WT.px(stack, 'paddingBottom');
h -= WT.px(to, 'marginTop');
h -= WT.px(to, 'marginBottom');
h -= WT.px(to, 'borderTopWidth');
h -= WT.px(to, 'borderBottomWidth');
h -= WT.px(to, 'paddingTop');
h -= WT.px(to, 'paddingBottom');
w -= WT.px(stack, 'paddingLeft');
w -= WT.px(stack, 'paddingRight');
w -= WT.px(to, 'marginLeft');
w -= WT.px(to, 'marginRight');
w -= WT.px(to, 'borderLeftWidth');
w -= WT.px(to, 'borderRightWidth');
w -= WT.px(to, 'paddingLeft');
w -= WT.px(to, 'paddingRight');
to.style.left = from.style.left || WT.px(stack, 'paddingLeft');
to.style.top = from.style.top || WT.px(stack, 'paddingTop');
to.style.width = w + 'px';
to.style.height = h + 'px';
to.style.position = 'absolute';
if (WT.isGecko && (effects & Fade))
to.style.opacity = '0';
to.style.display = style.display;
var needReverse = reverseIfPrecedes && (index.to < index.from),
anim = "";
switch (effects & 0xFF) {
case SlideInFromLeft: needReverse = !needReverse;
case SlideInFromRight: anim = "slide"; break;
case SlideInFromBottom: anim = "slideup"; break;
case SlideInFromTop: anim = "slidedown"; break;
case Pop: anim = "pop"; break;
}
if (effects & Fade)
anim += " fade";
if (needReverse)
anim += " reverse";
from.style[WT.styleAttribute('animation-duration')] = duration + 'ms';
to.style[WT.styleAttribute('animation-duration')] = duration + 'ms';
from.style[WT.styleAttribute('animation-timing-function')]
= timings[inverseTiming[timing]];
to.style[WT.styleAttribute('animation-timing-function')] = timings[timing];
$from.addClass(anim + ' out');
$from.one(animationEventEnd, restoreFrom);
$to.addClass(anim + ' in');
$to.one(animationEventEnd, restoreTo);
};
doAnimateChild(WT, child, effects, timing, duration, style);
});
witty-3.3.4+dfsg.orig/src/js/WAbstractMedia.js 0000644 0001750 0001750 00000003047 11616173513 021426 0 ustar pgquiles pgquiles /*
* Copyright (C) 2010 Emweb bvba, Leuven, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WAbstractMedia",
function(APP, el) {
jQuery.data(el, 'obj', this);
var self = this;
var WT = APP.WT;
function handleMove(event) {
};
this.play = function() {
if (el.mediaId) {
var mediaEl = $('#' + el.mediaId).get(0);
if (mediaEl) {
mediaEl.play();
return;
}
}
if (el.alternativeId) {
var alternativeEl = $('#' + el.alternativeId).get(0);
if (alternativeEl && alternativeEl.WtPlay) {
alternativeEl.WtPlay();
}
}
};
this.pause = function() {
if (el.mediaId) {
var mediaEl = $('#' + el.mediaId).get(0);
if (mediaEl) {
mediaEl.pause();
return;
}
}
if (el.alternativeId) {
var alternativeEl = $('#' + el.alternativeId).get(0);
if (alternativeEl && alternativeEl.WtPlay) {
alternativeEl.WtPause();
}
}
};
function encodeValue() {
if (el.mediaId) {
var mediaEl = $('#' + el.mediaId).get(0);
if (mediaEl) {
return '' + mediaEl.volume + ';'
+ mediaEl.currentTime + ';'
+ (mediaEl.readyState >= 1 ? mediaEl.duration : 0) + ';'
+ (mediaEl.paused ? '1' : '0') + ';'
+ (mediaEl.ended ? ' 1' : '0') + ';'
+ mediaEl.readyState;
}
}
return null;
}
el.wtEncodeValue = encodeValue;
});
witty-3.3.4+dfsg.orig/src/js/WDialog.js 0000644 0001750 0001750 00000011730 12503041145 020107 0 ustar pgquiles pgquiles /*
* Copyright (C) 2010 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WDialog",
function(APP, el, titlebar, centerX, centerY, movedSignal, resizedSignal) {
jQuery.data(el, 'obj', this);
var self = this;
var layoutContainer = $(el).find(".dialog-layout").get(0);
var WT = APP.WT;
var dsx, dsy;
var x=-1, y=-1, w=-1, h=-1;
var resizeBusy = false;
function newPos() {
if (movedSignal) {
var newx = WT.pxself(el, 'left');
var newy = WT.pxself(el, 'top');
if (newx != x || newy != y) {
x = newx;
y = newy;
APP.emit(el, movedSignal, x, y);
}
}
}
function newSize(neww, newh) {
if (!resizeBusy && resizedSignal) {
if (neww != w || newh != h) {
w = neww;
h = newh;
APP.emit(el, resizedSignal, w, h);
}
}
}
function handleMove(event) {
var e = event||window.event;
var nowxy = WT.pageCoordinates(e);
var wxy = WT.windowCoordinates(e);
var wsize = WT.windowSize();
if (wxy.x > 0 && wxy.x < wsize.x && wxy.y > 0 && wxy.y < wsize.y) {
centerX = centerY = false;
if (el.style.right === 'auto' || el.style.right === '') {
el.style.left = (WT.px(el, 'left') + nowxy.x - dsx) + 'px';
el.style.right = '';
}
else {
el.style.right = (WT.px(el, 'right') + dsx - nowxy.x) + 'px';
el.style.left = 'auto';
}
if (el.style.bottom === 'auto' || el.style.bottom === '') {
el.style.top = (WT.px(el, 'top') + nowxy.y - dsy) + 'px';
el.style.bottom = '';
}
else {
el.style.bottom = (WT.px(el, 'bottom') + dsy - nowxy.y) + 'px';
el.style.top = 'auto';
}
dsx = nowxy.x;
dsy = nowxy.y;
}
};
if (titlebar) {
titlebar.onmousedown = function(event) {
var e = event||window.event;
WT.capture(titlebar);
var pc = WT.pageCoordinates(e);
dsx = pc.x;
dsy = pc.y;
titlebar.onmousemove = handleMove;
};
titlebar.onmouseup = function(event) {
titlebar.onmousemove = null;
newPos();
WT.capture(null);
};
}
this.centerDialog = function() {
if (el.parentNode == null) {
el = titlebar = null;
return;
}
if ((el.style.display != 'none') && (el.style.visibility != 'hidden')) {
var ws = WT.windowSize();
var w = el.offsetWidth, h = el.offsetHeight;
if (centerX) {
el.style.left = Math.round((ws.x - w)/2
+ (WT.isIE6 ? document.documentElement.scrollLeft : 0)) + 'px';
el.style.marginLeft = '0px';
}
if (centerY) {
el.style.top = Math.round((ws.y - h)/2
+ (WT.isIE6 ? document.documentElement.scrollTop : 0)) + 'px';
el.style.marginTop = '0px';
}
if (el.style.position != '') {
el.style.visibility = 'visible';
}
newPos();
}
};
function layoutResize(ignored, w, h) {
if (el.style.position == '') {
el.style.position = WT.isIE6 ? 'absolute' : 'fixed';
}
el.style.visibility = 'visible';
el.style.height = Math.max(0, h) + 'px';
el.style.width = Math.max(0, w) + 'px';
newSize(w, h);
self.centerDialog();
}
function wtResize(ignored, w, h) {
if (w > 0)
layoutContainer.style.width = w +
WT.parsePx($(layoutContainer).css('borderLeftWidth')) +
WT.parsePx($(layoutContainer).css('borderRightWidth')) + 'px';
if (h > 0)
layoutContainer.style.height = h +
WT.parsePx($(layoutContainer).css('borderTopWidth')) +
WT.parsePx($(layoutContainer).css('borderBottomWidth')) + 'px';
self.centerDialog();
if (el.wtResize)
el.wtResize(el, w, h);
};
function wtPosition() {
APP.layouts2.adjust();
}
this.bringToFront = function() {
var maxz = 0;
$('.Wt-dialog, .modal, .modal-dialog').each
(function(index, value)
{
maxz = Math.max(maxz,$(value).css('z-index'));
}
);
if (maxz > el.style['zIndex'])
el.style['zIndex'] = maxz + 1;
};
this.onresize = function(w, h, done) {
centerX = centerY = false;
resizeBusy = !done;
wtResize(el, w, h);
var layout = jQuery.data(layoutContainer.firstChild, 'layout');
layout.setMaxSize(0, 0);
APP.layouts2.scheduleAdjust();
if (done)
newSize(w, h);
};
layoutContainer.wtResize = layoutResize;
el.wtPosition = wtPosition;
if (el.style.width != '') {
if (WT.parsePx(el.style.width) > 0)
layoutContainer.style.width = el.style.width;
else
layoutContainer.style.width = el.offsetWidth + 'px';
}
if (el.style.height != '') {
if (WT.parsePx(el.style.height) > 0)
layoutContainer.style.height = el.style.height;
else
layoutContainer.style.height = el.offsetHeight + 'px';
}
self.centerDialog();
});
witty-3.3.4+dfsg.orig/src/js/BootstrapValidate.js 0000644 0001750 0001750 00000003705 12330010677 022217 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptFunction, "validate",
function(edit) {
var v;
if (edit.options)
v = edit.options.item(edit.selectedIndex).text;
else
v = edit.value;
v = edit.wtValidate.validate(v);
this.setValidationState(edit, v.valid, v.message, 1);
});
WT_DECLARE_WT_MEMBER
(2, JavaScriptFunction, "setValidationState",
function(edit, state, message, styles) {
/* const */ var ValidationInvalidStyle = 0x1;
/* const */ var ValidationValidStyle = 0x2;
var validStyle = (state == 1) &&
((styles & ValidationValidStyle) != 0);
var invalidStyle = (state != 1) &&
((styles & ValidationInvalidStyle) != 0);
var $edit = $(edit);
$edit
.toggleClass("Wt-valid", validStyle)
.toggleClass("Wt-invalid", invalidStyle);
var controlGroup;
var success;
var error;
controlGroup = $edit.closest(".control-group");
if (controlGroup.length > 0) { // bootstrapVersion === 2
success = "success";
error = "error";
} else {
controlGroup = $edit.closest(".form-group");
if (controlGroup.length > 0) { // bootstrapVersion === 3
success = "has-success";
error = "has-error";
}
}
if (controlGroup.length > 0) {
var validationMsg = controlGroup.find(".Wt-validation-message");
if (validationMsg) {
if (state)
validationMsg.text(edit.defaultTT);
else
validationMsg.text(message);
}
controlGroup
.toggleClass(success, validStyle)
.toggleClass(error, invalidStyle);
}
if (typeof edit.defaultTT === 'undefined')
edit.defaultTT = edit.getAttribute('title') || '';
if (state)
edit.setAttribute('title', edit.defaultTT);
else
edit.setAttribute('title', message);
});
witty-3.3.4+dfsg.orig/src/js/SizeHandle.js 0000644 0001750 0001750 00000004352 12254530670 020622 0 ustar pgquiles pgquiles /*
* Copyright (C) 2010 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "SizeHandle",
function(WT, orientation, width, height, minDelta, maxDelta,
dragWidgetClass, doneFn, el, parent, event, offsetX, offsetY) {
var handle = document.createElement('div');
handle.style.position = 'absolute';
handle.style.zIndex = '100';
if (orientation == 'v') {
handle.style.width = height + 'px';
handle.style.height = width + 'px';
} else {
handle.style.height = height + 'px';
handle.style.width = width + 'px';
}
var offset, elpos = WT.widgetPageCoordinates(el),
parentpos = WT.widgetPageCoordinates(parent);
if (event.touches) {
offset = WT.widgetCoordinates(el, event.touches[0]);
} else {
offset = WT.widgetCoordinates(el, event);
WT.capture(null);
WT.capture(handle);
}
offsetX -= WT.px(el, 'marginLeft');
offsetY -= WT.px(el, 'marginTop');
elpos.x += offsetX - parentpos.x;
elpos.y += offsetY - parentpos.y;
offset.x -= offsetX - parentpos.x;
offset.y -= offsetY - parentpos.y;
handle.style.left = elpos.x + 'px';
handle.style.top = elpos.y + 'px';
handle.className = dragWidgetClass;
parent.appendChild(handle);
WT.cancelEvent(event);
function computeDelta(event) {
var result, p = WT.pageCoordinates(event);
if (orientation == 'h')
result = (p.x - offset.x) - elpos.x;
else
result = (p.y - offset.y) - elpos.y;
return Math.min(Math.max(result, minDelta), maxDelta);
}
handle.onmousemove = parent.ontouchmove = function(event) {
var delta = computeDelta(event);
if (orientation == 'h')
handle.style.left = (elpos.x + delta) + 'px';
else
handle.style.top = (elpos.y + delta) + 'px';
WT.cancelEvent(event);
};
handle.onmouseup = parent.ontouchend = function(event) {
if (handle.parentNode != null) {
handle.parentNode.removeChild(handle);
doneFn(computeDelta(event));
parent.ontouchmove = null;
}
};
}
); witty-3.3.4+dfsg.orig/src/js/WTimeEdit.js 0000644 0001750 0001750 00000003411 12475324032 020420 0 ustar pgquiles pgquiles /*
* Copyright (C) 2010 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WTimeEdit",
function(APP, edit, popup) {
/** @const */ var CLASS_HOVER = 'hover';
/** @const */ var CLASS_ACTIVE = 'active';
/** @const */ var CLASS_UNSELECTABLE = 'unselectable';
jQuery.data(edit, 'dobj', this);
var self = this, WT = APP.WT, $edit = $(edit);
function isReadOnly() {
return !!edit.getAttribute("readonly");
}
function isPopupVisible() {
return popup.style.display === '';
}
function getPopup() {
var p = $('#' + popup.id).get(0);
return jQuery.data(p, 'popup');
}
function resetButton() {
$edit.removeClass(CLASS_ACTIVE);
}
function showPopup() {
var p = getPopup();
p.bindHide(resetButton);
p.show(edit, WT.Vertical);
}
this.mouseOut = function(o, event) {
$edit.removeClass(CLASS_HOVER);
};
this.mouseMove = function(o, event) {
if (isReadOnly())
return;
var xy = WT.widgetCoordinates(edit, event);
if (xy.x > edit.offsetWidth - 40) {
$edit.addClass(CLASS_HOVER);
} else {
if ($edit.hasClass(CLASS_HOVER))
$edit.removeClass(CLASS_HOVER);
}
};
this.mouseDown = function(o, event) {
if (isReadOnly())
return;
var xy = WT.widgetCoordinates(edit, event);
if (xy.x > edit.offsetWidth - 40) {
$edit.addClass(CLASS_UNSELECTABLE).addClass(CLASS_ACTIVE);
}
};
this.mouseUp = function(o, event) {
$edit.removeClass(CLASS_UNSELECTABLE);
var xy = WT.widgetCoordinates(edit, event);
if (xy.x > edit.offsetWidth - 40)
showPopup();
};
});
witty-3.3.4+dfsg.orig/src/js/PopupWindow.js 0000644 0001750 0001750 00000002610 12420210325 021045 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptFunction, "PopupWindow",
function(WT, url, width, height, onclose) {
function getScreenPos() {
var width = 0;
var height = 0;
if (typeof (window.screenLeft) === 'number') {
width = window.screenLeft;
height = window.screenTop;
} else if (typeof (window.screenX) === 'number') {
width = window.screenX;
height = window.screenY;
}
return { x: width, y: height };
};
function computePopupPos(width, height) {
var parentSize = WT.windowSize();
var parentPos = getScreenPos();
var xPos = parentPos.x +
Math.max(0, Math.floor((parentSize.x - width) / 2));
var yPos = parentPos.y +
Math.max(0, Math.floor((parentSize.y - height) / 2));
return { x: xPos, y: yPos };
}
var coordinates = computePopupPos(width, height);
var w = window.open(url, "",
"width=" + width + ",height=" + height +
",status=yes,location=yes,resizable=yes,scrollbars=yes" +
",left=" + coordinates.x + ",top=" + coordinates.y);
w.opener = window;
if (onclose) {
var timer = setInterval(function() {
if (w.closed) {
clearInterval(timer);
onclose(w);
}
}, 500);
}
});
witty-3.3.4+dfsg.orig/src/js/WLineEdit.js 0000644 0001750 0001750 00000027126 12347532102 020417 0 ustar pgquiles pgquiles /*
* Copyright (C) 2014 Emweb bvba, Herent, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WLineEdit",
function(APP, edit, mask, raw, displayValue, caseMap, spaceChar, flags) {
/** @const */ var BACKSPACE_KEY = 8;
/** @const */ var DELETE_KEY = 46;
/** @const */ var RIGHT_KEY = 39;
/** @const */ var LEFT_KEY = 37;
/** @const */ var HOME_KEY = 36;
/** @const */ var END_KEY = 35;
/** @const */ var LF_CHAR = 10;
/** @const */ var CR_CHAR = 13;
/** @const */ var A_LOWER_CHAR = 'a'.charCodeAt(0);
/** @const */ var F_LOWER_CHAR = 'f'.charCodeAt(0);
/** @const */ var Z_LOWER_CHAR = 'z'.charCodeAt(0);
/** @const */ var A_UPPER_CHAR = 'A'.charCodeAt(0);
/** @const */ var F_UPPER_CHAR = 'F'.charCodeAt(0);
/** @const */ var Z_UPPER_CHAR = 'Z'.charCodeAt(0);
/** @const */ var MINUS_CHAR = '-'.charCodeAt(0);
/** @const */ var PLUS_CHAR = '+'.charCodeAt(0);
/** @const */ var ZERO_CHAR = '0'.charCodeAt(0);
/** @const */ var ONE_CHAR = '1'.charCodeAt(0);
/** @const */ var NINE_CHAR = '9'.charCodeAt(0);
/** @const */ var KEEP_MASK_WHEN_BLURRED_FLAG = 0x1;
jQuery.data(edit, 'lobj', this);
var self = this, WT = APP.WT, $edit = $(edit);
this.getValue = function() {
if (mask === "") return edit.value;
var value = edit.value;
var result = "";
var currentChar = "";
var i = 0;
var nbChars = 0;
for (i = 0; i < value.length; i++) {
currentChar = value.charAt(i);
if (currentChar !== spaceChar && mask.charAt(i) !== '_') {
nbChars += 1;
}
if (currentChar !== spaceChar || mask.charAt(i) === '_') {
result += currentChar;
}
}
if (nbChars > 0) {
return result;
} else {
return "";
}
};
this.setValue = function(newValue) {
displayValue = newValue;
if (mask === "") {
edit.value = newValue;
return;
}
if (!(flags & KEEP_MASK_WHEN_BLURRED_FLAG) && !WT.hasFocus(edit)) {
edit.value = this.getValue();
return;
}
var selection = WT.getSelectionRange(edit);
var newCursor = -1;
edit.value = raw;
var i = 0;
var j = 0;
var charToInsert = "";
for (; i < newValue.length; i++) {
charToInsert = newValue.charAt(i);
if (selection.start === selection.end && selection.start === i)
newCursor = j;
j = insertChar(charToInsert, j, true);
}
if (WT.hasFocus(edit)) {
if (newCursor !== -1)
setCursor(newCursor);
else if (newValue.length == 0)
setCursor(0);
}
};
this.setInputMask = function(newMask, newRaw, newDisplayValue,
newCaseMap, newSpaceChar) {
mask = newMask;
raw = newRaw;
caseMap = newCaseMap;
spaceChar = newSpaceChar;
this.setValue(newDisplayValue);
};
if (mask !== "") {
this.setInputMask(mask, raw, displayValue, caseMap, spaceChar);
}
function skippable(position) {
return mask.charAt(position) === '_';
}
function setCursor(position) {
WT.setSelectionRange(edit, position, position+1);
}
function moveForward(position) {
while (skippable(position)) {
position ++;
}
setCursor(position);
return position;
}
function moveBackward(position) {
while (position > 0 && skippable(position)) {
position --;
}
setCursor(position);
return position;
}
function acceptKey(code, position) {
if (position >= mask.length)
return false;
switch(mask.charAt(position)) {
case 'a':
case 'A': // alphabetical: A-Za-z
return code >= A_LOWER_CHAR && code <= Z_LOWER_CHAR ||
code >= A_UPPER_CHAR && code <= Z_UPPER_CHAR;
case 'n':
case 'N': // alphanumeric: A-Za-z0-9
return code >= A_LOWER_CHAR && code <= Z_LOWER_CHAR ||
code >= A_UPPER_CHAR && code <= Z_UPPER_CHAR ||
code >= ZERO_CHAR && code <= NINE_CHAR;
case 'X':
case 'x': // Anything goes
return true;
case '0':
case '9': // 0-9
return code >= ZERO_CHAR && code <= NINE_CHAR;
case 'd':
case 'D': // 1-9
return code >= ONE_CHAR && code <= NINE_CHAR;
case '#': // 0-9, + and -
return code >= ZERO_CHAR && code <= NINE_CHAR ||
code === MINUS_CHAR || code === PLUS_CHAR;
case 'h':
case 'H': // hex
return code >= A_UPPER_CHAR && code <= F_UPPER_CHAR ||
code >= ZERO_CHAR && code <= NINE_CHAR ||
code >= A_LOWER_CHAR && code <= F_LOWER_CHAR;
case 'b':
case 'B': // binary
return code === ZERO_CHAR || code === ONE_CHAR;
}
return false;
}
function clearSelection(selection) {
var before = edit.value.substring(0, selection.start);
var after = edit.value.substring(selection.end);
var between = raw.substring(selection.start, selection.end);
edit.value = before + between + after;
WT.setSelectionRange(edit, selection.start, selection.start);
}
function insertChar(charToInsert, position, pasteMode) {
var j = position;
var jBefore = j;
// If the previous static character was typed, don't move forward.
// This causes an input sequence like "192.168.0.1" to be handled properly.
if (!pasteMode && raw.charAt(j) !== charToInsert &&
!acceptKey(charToInsert.charCodeAt(0), j) &&
j - 1 >= 0 && raw.charAt(j - 1) === charToInsert) {
return j;
}
while (raw.charAt(j) !== charToInsert &&
!acceptKey(charToInsert.charCodeAt(0), j) && j < mask.length) {
j++;
}
if (j === mask.length) { // This char didn't fit, discard
return jBefore;
}
var before = edit.value.substring(0, j);
var after = edit.value.substring(j + 1);
if (raw.charAt(j) !== charToInsert) {
if (caseMap.charAt(j) === '>') {
charToInsert = charToInsert.toUpperCase();
} else if (caseMap.charAt(j) === '<') {
charToInsert = charToInsert.toLowerCase();
}
}
edit.value = before + charToInsert + after;
j++;
return j;
}
this.keyDown = function(o, event) {
if (mask === "" || edit.readOnly) return;
var selection;
switch(event.keyCode) {
case RIGHT_KEY:
WT.cancelEvent(event, WT.CancelDefaultAction);
selection = WT.getSelectionRange(edit);
if (selection.end - selection.start <= 1) {
moveForward(selection.start + 1);
} else {
WT.setSelectionRange(edit, selection.end, selection.end);
}
break;
case LEFT_KEY:
WT.cancelEvent(event, WT.CancelDefaultAction);
selection = WT.getSelectionRange(edit);
if (selection.end - selection.start <= 1) {
moveBackward(selection.start - 1);
} else {
WT.setSelectionRange(edit, selection.start, selection.start);
}
break;
case HOME_KEY:
WT.cancelEvent(event, WT.CancelDefaultAction);
moveForward(0);
break;
case END_KEY:
WT.cancelEvent(event, WT.CancelDefaultAction);
WT.setSelectionRange(edit, mask.length, mask.length);
break;
case DELETE_KEY:
WT.cancelEvent(event, WT.CancelDefaultAction);
selection = WT.getSelectionRange(edit);
if (selection.end - selection.start <= 1) {
var position = selection.start;
if (position < mask.length &&
!skippable(position)) {
var before = edit.value.substring(0, position);
var after = edit.value.substring(position + 1);
edit.value = before + spaceChar + after;
WT.setSelectionRange(edit, position, position);
}
} else {
clearSelection(selection);
}
break;
case BACKSPACE_KEY:
WT.cancelEvent(event, WT.CancelDefaultAction);
selection = WT.getSelectionRange(edit);
if (selection.end - selection.start <= 1) {
var position = selection.start - 1;
if (position >= 0) {
position = moveBackward(position);
if (!skippable(position)) {
var before = edit.value.substring(0, position);
var after = edit.value.substring(position + 1);
edit.value = before + spaceChar + after;
setCursor(position);
}
}
} else {
clearSelection(selection);
}
break;
}
};
this.keyPressed = function(o, event) {
if (mask === "" || edit.readOnly) return;
var charCode = event.charCode || event.keyCode;
if (charCode === 0 || charCode === CR_CHAR || charCode === LF_CHAR)
return;
WT.cancelEvent(event, WT.CancelDefaultAction);
var selection = WT.getSelectionRange(edit);
if (selection.start < selection.end) {
clearSelection(selection);
}
var currentPosition = insertChar(String.fromCharCode(charCode),
selection.start);
moveForward(currentPosition);
};
var previousValue = this.getValue();
this.focussed = function(o, event) {
if (mask === "" || edit.readOnly || (flags & KEEP_MASK_WHEN_BLURRED_FLAG)) return;
previousValue = this.getValue();
setTimeout(function() {
self.setValue(displayValue);
}, 0);
};
this.blurred = function(o, event) {
if (mask === "" || edit.readOnly || (flags & KEEP_MASK_WHEN_BLURRED_FLAG)) return;
displayValue = edit.value;
edit.value = this.getValue();
if (edit.value !== previousValue)
$edit.change();
};
this.clicked = function(o, event) {
if (mask === "" || edit.readOnly) return;
var selection = WT.getSelectionRange(edit);
if (selection.start === selection.end)
setCursor(selection.start);
};
function paste(event) {
if (mask === "" || edit.readOnly) return;
WT.cancelEvent(event, WT.CancelDefaultAction);
var selection = WT.getSelectionRange(edit);
if (selection.start !== selection.end) {
clearSelection(selection);
}
var pasteData = undefined;
if (window.clipboardData && window.clipboardData.getData) {
pasteData = window.clipboardData.getData("Text");
} else if (event.clipboardData && event.clipboardData.getData) {
pasteData = event.clipboardData.getData("text/plain");
} else {
return;
}
var text = edit.value;
var charToInsert = "";
var i = 0, j = selection.start;
for (; i < pasteData.length; i++) {
charToInsert = pasteData.charAt(i);
j = insertChar(charToInsert, j, true);
}
moveForward(j);
}
if (edit.addEventListener) {
edit.addEventListener("paste", paste, false);
} else if (edit.attachEvent) {
edit.attachEvent("onpaste", paste);
}
function cut(event) {
if (mask === "" || edit.readOnly) return;
WT.cancelEvent(event, WT.CancelDefaultAction);
var selection = WT.getSelectionRange(edit);
if (selection.start !== selection.end) {
var cutData = edit.value.substring(selection.start, selection.end);
if (window.clipboardData && window.clipboardData.setData) {
window.clipboardData.setData("Text", cutData);
} else if (event.clipboardData && event.clipboardData.setData) {
event.clipboardData.setData("text/plain", cutData);
}
clearSelection(selection);
}
}
if (edit.addEventListener) {
edit.addEventListener("cut", cut, false);
} else if (edit.attachEvent) {
edit.attachEvent("oncut", cut);
}
function input(event) {
if (mask === "" || edit.readOnly) return;
// When the value was cleared, reset it to "raw".
// e.g. IE does this when the X button is clicked.
if (edit.value === "") {
edit.value = raw;
moveForward(0);
}
}
if (edit.addEventListener) {
edit.addEventListener("input", input, false);
} else if (edit.attachEvent) {
edit.attachEvent("oninput", input);
}
edit.wtEncodeValue = function() {
if (mask === "" || (flags & KEEP_MASK_WHEN_BLURRED_FLAG) || WT.hasFocus(edit)) {
return edit.value;
} else {
return displayValue;
}
};
});
witty-3.3.4+dfsg.orig/src/js/WDateEdit.js 0000644 0001750 0001750 00000003406 12202722512 020374 0 ustar pgquiles pgquiles /*
* Copyright (C) 2010 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WDateEdit",
function(APP, edit, popup) {
/** @const */ var CLASS_HOVER = 'hover';
/** @const */ var CLASS_ACTIVE = 'active';
/** @const */ var CLASS_UNSELECTABLE = 'unselectable';
jQuery.data(edit, 'dobj', this);
var self = this, WT = APP.WT, $edit = $(edit);
function isReadOnly() {
return !!edit.getAttribute("readonly");
}
function isPopupVisible() {
return popup.style.display === '';
}
function getPopup() {
var p = $('#' + popup.id).get(0);
return jQuery.data(p, 'popup');
}
function resetButton() {
$edit.removeClass(CLASS_ACTIVE);
}
function showPopup() {
var p = getPopup();
p.bindHide(resetButton);
p.show(edit, WT.Vertical);
}
this.mouseOut = function(o, event) {
$edit.removeClass(CLASS_HOVER);
};
this.mouseMove = function(o, event) {
if (isReadOnly())
return;
var xy = WT.widgetCoordinates(edit, event);
if (xy.x > edit.offsetWidth - 40) {
$edit.addClass(CLASS_HOVER);
} else {
if ($edit.hasClass(CLASS_HOVER))
$edit.removeClass(CLASS_HOVER);
}
};
this.mouseDown = function(o, event) {
if (isReadOnly())
return;
var xy = WT.widgetCoordinates(edit, event);
if (xy.x > edit.offsetWidth - 40) {
$edit.addClass(CLASS_UNSELECTABLE).addClass(CLASS_ACTIVE);
}
};
this.mouseUp = function(o, event) {
$edit.removeClass(CLASS_UNSELECTABLE);
var xy = WT.widgetCoordinates(edit, event);
if (xy.x > edit.offsetWidth - 40)
showPopup();
};
});
witty-3.3.4+dfsg.orig/src/js/WMediaPlayer.js 0000644 0001750 0001750 00000002171 11616173513 021114 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Leuven, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WMediaPlayer",
function(APP, el) {
jQuery.data(el, 'obj', this);
var self = this;
var WT = APP.WT;
function encodeValue() {
var jplayer = $(el).find(".jp-jplayer").data("jPlayer"),
status = jplayer.status,
options = jplayer.options;
return options.volume
+ ';' + status.currentTime
+ ';' + status.duration
+ ';' + (status.paused ? 1 : 0)
+ ';' + (status.ended ? 1 : 0)
+ ';' + status.readyState
+ ';' + (status.playbackRate ? status.playbackRate : 1)
+ ';' + status.seekPercent;
}
el.wtEncodeValue = encodeValue;
function setPlaybackRate(rate) {
var jplayer = this,
media = jplayer.htmlElement.video || jplayer.htmlElement.audio;
if (media)
media.playbackRate = rate;
return this;
};
var jplayer = $(el).find(".jp-jplayer").data("jPlayer");
jplayer.wtPlaybackRate = setPlaybackRate;
});
witty-3.3.4+dfsg.orig/src/js/WtGlMatrix.js 0000755 0001750 0001750 00000115002 12352240341 020624 0 ustar pgquiles pgquiles /*
* glMatrix.js - High performance matrix and vector operations for WebGL
* version 0.9.5
*
* This is a MODIFIED copy of glMatrix.js for the purpose of integration
* with the Wt C++ toolkit. This is therefore not the original software.
*
* Copyright (c) 2010 Brandon Jones
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source
* distribution.
*/
WT_DECLARE_WT_MEMBER
(2, JavaScriptObject, "glMatrix",
(function() {
// Fallback for systems that don't support WebGL
if(typeof Float32Array != 'undefined') {
glMatrixArrayType = Float32Array;
} else if(typeof WebGLFloatArray != 'undefined') {
glMatrixArrayType = WebGLFloatArray; // This is officially deprecated and should dissapear in future revisions.
} else {
glMatrixArrayType = Array;
}
/*
* vec3 - 3 Dimensional Vector
*/
var vec3 = {};
/*
* vec3.create
* Creates a new instance of a vec3 using the default array type
* Any javascript array containing at least 3 numeric elements can serve as a vec3
*
* Params:
* vec - Optional, vec3 containing values to initialize with
*
* Returns:
* New vec3
*/
vec3.create = function(vec) {
var dest = new glMatrixArrayType(3);
if(vec) {
dest[0] = vec[0];
dest[1] = vec[1];
dest[2] = vec[2];
}
return dest;
};
/*
* vec3.set
* Copies the values of one vec3 to another
*
* Params:
* vec - vec3 containing values to copy
* dest - vec3 receiving copied values
*
* Returns:
* dest
*/
vec3.set = function(vec, dest) {
dest[0] = vec[0];
dest[1] = vec[1];
dest[2] = vec[2];
return dest;
};
/*
* vec3.add
* Performs a vector addition
*
* Params:
* vec - vec3, first operand
* vec2 - vec3, second operand
* dest - Optional, vec3 receiving operation result. If not specified result is written to vec
*
* Returns:
* dest if specified, vec otherwise
*/
vec3.add = function(vec, vec2, dest) {
if(!dest || vec == dest) {
vec[0] += vec2[0];
vec[1] += vec2[1];
vec[2] += vec2[2];
return vec;
}
dest[0] = vec[0] + vec2[0];
dest[1] = vec[1] + vec2[1];
dest[2] = vec[2] + vec2[2];
return dest;
};
/*
* vec3.subtract
* Performs a vector subtraction
*
* Params:
* vec - vec3, first operand
* vec2 - vec3, second operand
* dest - Optional, vec3 receiving operation result. If not specified result is written to vec
*
* Returns:
* dest if specified, vec otherwise
*/
vec3.subtract = function(vec, vec2, dest) {
if(!dest || vec == dest) {
vec[0] -= vec2[0];
vec[1] -= vec2[1];
vec[2] -= vec2[2];
return vec;
}
dest[0] = vec[0] - vec2[0];
dest[1] = vec[1] - vec2[1];
dest[2] = vec[2] - vec2[2];
return dest;
};
/*
* vec3.negate
* Negates the components of a vec3
*
* Params:
* vec - vec3 to negate
* dest - Optional, vec3 receiving operation result. If not specified result is written to vec
*
* Returns:
* dest if specified, vec otherwise
*/
vec3.negate = function(vec, dest) {
if(!dest) { dest = vec; }
dest[0] = -vec[0];
dest[1] = -vec[1];
dest[2] = -vec[2];
return dest;
};
/*
* vec3.scale
* Multiplies the components of a vec3 by a scalar value
*
* Params:
* vec - vec3 to scale
* val - Numeric value to scale by
* dest - Optional, vec3 receiving operation result. If not specified result is written to vec
*
* Returns:
* dest if specified, vec otherwise
*/
vec3.scale = function(vec, val, dest) {
if(!dest || vec == dest) {
vec[0] *= val;
vec[1] *= val;
vec[2] *= val;
return vec;
}
dest[0] = vec[0]*val;
dest[1] = vec[1]*val;
dest[2] = vec[2]*val;
return dest;
};
/*
* vec3.normalize
* Generates a unit vector of the same direction as the provided vec3
* If vector length is 0, returns [0, 0, 0]
*
* Params:
* vec - vec3 to normalize
* dest - Optional, vec3 receiving operation result. If not specified result is written to vec
*
* Returns:
* dest if specified, vec otherwise
*/
vec3.normalize = function(vec, dest) {
if(!dest) { dest = vec; }
var x = vec[0], y = vec[1], z = vec[2];
var len = Math.sqrt(x*x + y*y + z*z);
if (!len) {
dest[0] = 0;
dest[1] = 0;
dest[2] = 0;
return dest;
} else if (len == 1) {
dest[0] = x;
dest[1] = y;
dest[2] = z;
return dest;
}
len = 1 / len;
dest[0] = x*len;
dest[1] = y*len;
dest[2] = z*len;
return dest;
};
/*
* vec3.cross
* Generates the cross product of two vec3s
*
* Params:
* vec - vec3, first operand
* vec2 - vec3, second operand
* dest - Optional, vec3 receiving operation result. If not specified result is written to vec
*
* Returns:
* dest if specified, vec otherwise
*/
vec3.cross = function(vec, vec2, dest){
if(!dest) { dest = vec; }
var x = vec[0], y = vec[1], z = vec[2];
var x2 = vec2[0], y2 = vec2[1], z2 = vec2[2];
dest[0] = y*z2 - z*y2;
dest[1] = z*x2 - x*z2;
dest[2] = x*y2 - y*x2;
return dest;
};
/*
* vec3.length
* Caclulates the length of a vec3
*
* Params:
* vec - vec3 to calculate length of
*
* Returns:
* Length of vec
*/
vec3.length = function(vec){
var x = vec[0], y = vec[1], z = vec[2];
return Math.sqrt(x*x + y*y + z*z);
};
/*
* vec3.dot
* Caclulates the dot product of two vec3s
*
* Params:
* vec - vec3, first operand
* vec2 - vec3, second operand
*
* Returns:
* Dot product of vec and vec2
*/
vec3.dot = function(vec, vec2){
return vec[0]*vec2[0] + vec[1]*vec2[1] + vec[2]*vec2[2];
};
/*
* vec3.direction
* Generates a unit vector pointing from one vector to another
*
* Params:
* vec - origin vec3
* vec2 - vec3 to point to
* dest - Optional, vec3 receiving operation result. If not specified result is written to vec
*
* Returns:
* dest if specified, vec otherwise
*/
vec3.direction = function(vec, vec2, dest) {
if(!dest) { dest = vec; }
var x = vec[0] - vec2[0];
var y = vec[1] - vec2[1];
var z = vec[2] - vec2[2];
var len = Math.sqrt(x*x + y*y + z*z);
if (!len) {
dest[0] = 0;
dest[1] = 0;
dest[2] = 0;
return dest;
}
len = 1 / len;
dest[0] = x * len;
dest[1] = y * len;
dest[2] = z * len;
return dest;
};
/*
* vec3.str
* Returns a string representation of a vector
*
* Params:
* vec - vec3 to represent as a string
*
* Returns:
* string representation of vec
*/
vec3.str = function(vec) {
return '[' + vec[0] + ', ' + vec[1] + ', ' + vec[2] + ']';
};
/*
* mat3 - 3x3 Matrix
*/
var mat3 = {};
/*
* mat3.create
* Creates a new instance of a mat3 using the default array type
* Any javascript array containing at least 9 numeric elements can serve as a mat3
*
* Params:
* mat - Optional, mat3 containing values to initialize with
*
* Returns:
* New mat3
*/
mat3.create = function(mat) {
var dest = new glMatrixArrayType(9);
if(mat) {
dest[0] = mat[0];
dest[1] = mat[1];
dest[2] = mat[2];
dest[3] = mat[3];
dest[4] = mat[4];
dest[5] = mat[5];
dest[6] = mat[6];
dest[7] = mat[7];
dest[8] = mat[8];
dest[9] = mat[9];
}
return dest;
};
/*
* mat3.set
* Copies the values of one mat3 to another
*
* Params:
* mat - mat3 containing values to copy
* dest - mat3 receiving copied values
*
* Returns:
* dest
*/
mat3.set = function(mat, dest) {
dest[0] = mat[0];
dest[1] = mat[1];
dest[2] = mat[2];
dest[3] = mat[3];
dest[4] = mat[4];
dest[5] = mat[5];
dest[6] = mat[6];
dest[7] = mat[7];
dest[8] = mat[8];
return dest;
};
/*
* mat3.identity
* Sets a mat3 to an identity matrix
*
* Params:
* dest - mat3 to set
*
* Returns:
* dest
*/
mat3.identity = function(dest) {
dest[0] = 1;
dest[1] = 0;
dest[2] = 0;
dest[3] = 0;
dest[4] = 1;
dest[5] = 0;
dest[6] = 0;
dest[7] = 0;
dest[8] = 1;
return dest;
};
/*
* mat3.toMat4
* Copies the elements of a mat3 into the upper 3x3 elements of a mat4
*
* Params:
* mat - mat3 containing values to copy
* dest - Optional, mat4 receiving copied values
*
* Returns:
* dest if specified, a new mat4 otherwise
*/
mat3.toMat4 = function(mat, dest) {
if(!dest) { dest = mat4.create(); }
dest[0] = mat[0];
dest[1] = mat[1];
dest[2] = mat[2];
dest[3] = 0;
dest[4] = mat[3];
dest[5] = mat[4];
dest[6] = mat[5];
dest[7] = 0;
dest[8] = mat[6];
dest[9] = mat[7];
dest[10] = mat[8];
dest[11] = 0;
dest[12] = 0;
dest[13] = 0;
dest[14] = 0;
dest[15] = 1;
return dest;
}
/*
* mat3.str
* Returns a string representation of a mat3
*
* Params:
* mat - mat3 to represent as a string
*
* Returns:
* string representation of mat
*/
mat3.str = function(mat) {
return '[' + mat[0] + ', ' + mat[1] + ', ' + mat[2] +
', ' + mat[3] + ', '+ mat[4] + ', ' + mat[5] +
', ' + mat[6] + ', ' + mat[7] + ', '+ mat[8] + ']';
};
/*
* mat4 - 4x4 Matrix
*/
var mat4 = {};
/*
* mat4.create
* Creates a new instance of a mat4 using the default array type
* Any javascript array containing at least 16 numeric elements can serve as a mat4
*
* Params:
* mat - Optional, mat4 containing values to initialize with
*
* Returns:
* New mat4
*/
mat4.create = function(mat) {
var dest = new glMatrixArrayType(16);
if(mat) {
dest[0] = mat[0];
dest[1] = mat[1];
dest[2] = mat[2];
dest[3] = mat[3];
dest[4] = mat[4];
dest[5] = mat[5];
dest[6] = mat[6];
dest[7] = mat[7];
dest[8] = mat[8];
dest[9] = mat[9];
dest[10] = mat[10];
dest[11] = mat[11];
dest[12] = mat[12];
dest[13] = mat[13];
dest[14] = mat[14];
dest[15] = mat[15];
}
return dest;
};
/*
* mat4.set
* Copies the values of one mat4 to another
*
* Params:
* mat - mat4 containing values to copy
* dest - mat4 receiving copied values
*
* Returns:
* dest
*/
mat4.set = function(mat, dest) {
dest[0] = mat[0];
dest[1] = mat[1];
dest[2] = mat[2];
dest[3] = mat[3];
dest[4] = mat[4];
dest[5] = mat[5];
dest[6] = mat[6];
dest[7] = mat[7];
dest[8] = mat[8];
dest[9] = mat[9];
dest[10] = mat[10];
dest[11] = mat[11];
dest[12] = mat[12];
dest[13] = mat[13];
dest[14] = mat[14];
dest[15] = mat[15];
return dest;
};
/*
* mat4.identity
* Sets a mat4 to an identity matrix
*
* Params:
* dest - mat4 to set
*
* Returns:
* dest
*/
mat4.identity = function(dest) {
dest[0] = 1;
dest[1] = 0;
dest[2] = 0;
dest[3] = 0;
dest[4] = 0;
dest[5] = 1;
dest[6] = 0;
dest[7] = 0;
dest[8] = 0;
dest[9] = 0;
dest[10] = 1;
dest[11] = 0;
dest[12] = 0;
dest[13] = 0;
dest[14] = 0;
dest[15] = 1;
return dest;
};
/*
* mat4.transpose
* Transposes a mat4 (flips the values over the diagonal)
*
* Params:
* mat - mat4 to transpose
* dest - Optional, mat4 receiving transposed values. If not specified result is written to mat
*
* Returns:
* dest is specified, mat otherwise
*/
mat4.transpose = function(mat, dest) {
// If we are transposing ourselves we can skip a few steps but have to cache some values
if(!dest || mat == dest) {
var a01 = mat[1], a02 = mat[2], a03 = mat[3];
var a12 = mat[6], a13 = mat[7];
var a23 = mat[11];
mat[1] = mat[4];
mat[2] = mat[8];
mat[3] = mat[12];
mat[4] = a01;
mat[6] = mat[9];
mat[7] = mat[13];
mat[8] = a02;
mat[9] = a12;
mat[11] = mat[14];
mat[12] = a03;
mat[13] = a13;
mat[14] = a23;
return mat;
}
dest[0] = mat[0];
dest[1] = mat[4];
dest[2] = mat[8];
dest[3] = mat[12];
dest[4] = mat[1];
dest[5] = mat[5];
dest[6] = mat[9];
dest[7] = mat[13];
dest[8] = mat[2];
dest[9] = mat[6];
dest[10] = mat[10];
dest[11] = mat[14];
dest[12] = mat[3];
dest[13] = mat[7];
dest[14] = mat[11];
dest[15] = mat[15];
return dest;
};
/*
* mat4.determinant
* Calculates the determinant of a mat4
*
* Params:
* mat - mat4 to calculate determinant of
*
* Returns:
* determinant of mat
*/
mat4.determinant = function(mat) {
// Cache the matrix values (makes for huge speed increases!)
var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3];
var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7];
var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11];
var a30 = mat[12], a31 = mat[13], a32 = mat[14], a33 = mat[15];
return a30*a21*a12*a03 - a20*a31*a12*a03 - a30*a11*a22*a03 + a10*a31*a22*a03 +
a20*a11*a32*a03 - a10*a21*a32*a03 - a30*a21*a02*a13 + a20*a31*a02*a13 +
a30*a01*a22*a13 - a00*a31*a22*a13 - a20*a01*a32*a13 + a00*a21*a32*a13 +
a30*a11*a02*a23 - a10*a31*a02*a23 - a30*a01*a12*a23 + a00*a31*a12*a23 +
a10*a01*a32*a23 - a00*a11*a32*a23 - a20*a11*a02*a33 + a10*a21*a02*a33 +
a20*a01*a12*a33 - a00*a21*a12*a33 - a10*a01*a22*a33 + a00*a11*a22*a33;
};
/*
* mat4.inverse
* Calculates the inverse matrix of a mat4
*
* Params:
* mat - mat4 to calculate inverse of
* dest - Optional, mat4 receiving inverse matrix. If not specified result is written to mat
*
* Returns:
* dest is specified, mat otherwise
*/
mat4.inverse = function(mat, dest) {
if(!dest) { dest = mat; }
// Cache the matrix values (makes for huge speed increases!)
var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3];
var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7];
var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11];
var a30 = mat[12], a31 = mat[13], a32 = mat[14], a33 = mat[15];
var b00 = a00*a11 - a01*a10;
var b01 = a00*a12 - a02*a10;
var b02 = a00*a13 - a03*a10;
var b03 = a01*a12 - a02*a11;
var b04 = a01*a13 - a03*a11;
var b05 = a02*a13 - a03*a12;
var b06 = a20*a31 - a21*a30;
var b07 = a20*a32 - a22*a30;
var b08 = a20*a33 - a23*a30;
var b09 = a21*a32 - a22*a31;
var b10 = a21*a33 - a23*a31;
var b11 = a22*a33 - a23*a32;
// Calculate the determinant (inlined to avoid double-caching)
var invDet = 1/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06);
dest[0] = (a11*b11 - a12*b10 + a13*b09)*invDet;
dest[1] = (-a01*b11 + a02*b10 - a03*b09)*invDet;
dest[2] = (a31*b05 - a32*b04 + a33*b03)*invDet;
dest[3] = (-a21*b05 + a22*b04 - a23*b03)*invDet;
dest[4] = (-a10*b11 + a12*b08 - a13*b07)*invDet;
dest[5] = (a00*b11 - a02*b08 + a03*b07)*invDet;
dest[6] = (-a30*b05 + a32*b02 - a33*b01)*invDet;
dest[7] = (a20*b05 - a22*b02 + a23*b01)*invDet;
dest[8] = (a10*b10 - a11*b08 + a13*b06)*invDet;
dest[9] = (-a00*b10 + a01*b08 - a03*b06)*invDet;
dest[10] = (a30*b04 - a31*b02 + a33*b00)*invDet;
dest[11] = (-a20*b04 + a21*b02 - a23*b00)*invDet;
dest[12] = (-a10*b09 + a11*b07 - a12*b06)*invDet;
dest[13] = (a00*b09 - a01*b07 + a02*b06)*invDet;
dest[14] = (-a30*b03 + a31*b01 - a32*b00)*invDet;
dest[15] = (a20*b03 - a21*b01 + a22*b00)*invDet;
return dest;
};
/*
* mat4.toRotationMat
* Copies the upper 3x3 elements of a mat4 into another mat4
*
* Params:
* mat - mat4 containing values to copy
* dest - Optional, mat4 receiving copied values
*
* Returns:
* dest is specified, a new mat4 otherwise
*/
mat4.toRotationMat = function(mat, dest) {
if(!dest) { dest = mat4.create(); }
dest[0] = mat[0];
dest[1] = mat[1];
dest[2] = mat[2];
dest[3] = mat[3];
dest[4] = mat[4];
dest[5] = mat[5];
dest[6] = mat[6];
dest[7] = mat[7];
dest[8] = mat[8];
dest[9] = mat[9];
dest[10] = mat[10];
dest[11] = mat[11];
dest[12] = 0;
dest[13] = 0;
dest[14] = 0;
dest[15] = 1;
return dest;
};
/*
* mat4.toMat3
* Copies the upper 3x3 elements of a mat4 into a mat3
*
* Params:
* mat - mat4 containing values to copy
* dest - Optional, mat3 receiving copied values
*
* Returns:
* dest is specified, a new mat3 otherwise
*/
mat4.toMat3 = function(mat, dest) {
if(!dest) { dest = mat3.create(); }
dest[0] = mat[0];
dest[1] = mat[1];
dest[2] = mat[2];
dest[3] = mat[4];
dest[4] = mat[5];
dest[5] = mat[6];
dest[6] = mat[8];
dest[7] = mat[9];
dest[8] = mat[10];
return dest;
};
/*
* mat4.toInverseMat3
* Calculates the inverse of the upper 3x3 elements of a mat4 and copies the result into a mat3
* The resulting matrix is useful for calculating transformed normals
*
* Params:
* mat - mat4 containing values to invert and copy
* dest - Optional, mat3 receiving values
*
* Returns:
* dest is specified, a new mat3 otherwise
*/
mat4.toInverseMat3 = function(mat, dest) {
// Cache the matrix values (makes for huge speed increases!)
var a00 = mat[0], a01 = mat[1], a02 = mat[2];
var a10 = mat[4], a11 = mat[5], a12 = mat[6];
var a20 = mat[8], a21 = mat[9], a22 = mat[10];
var b01 = a22*a11-a12*a21;
var b11 = -a22*a10+a12*a20;
var b21 = a21*a10-a11*a20;
var d = a00*b01 + a01*b11 + a02*b21;
if (!d) { return null; }
var id = 1/d;
if(!dest) { dest = mat3.create(); }
dest[0] = b01*id;
dest[1] = (-a22*a01 + a02*a21)*id;
dest[2] = (a12*a01 - a02*a11)*id;
dest[3] = b11*id;
dest[4] = (a22*a00 - a02*a20)*id;
dest[5] = (-a12*a00 + a02*a10)*id;
dest[6] = b21*id;
dest[7] = (-a21*a00 + a01*a20)*id;
dest[8] = (a11*a00 - a01*a10)*id;
return dest;
};
/*
* mat4.multiply
* Performs a matrix multiplication
*
* Params:
* mat - mat4, first operand
* mat2 - mat4, second operand
* dest - Optional, mat4 receiving operation result. If not specified result is written to mat
*
* Returns:
* dest if specified, mat otherwise
*/
mat4.multiply = function(mat, mat2, dest) {
if(!dest) { dest = mat }
// Cache the matrix values (makes for huge speed increases!)
var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3];
var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7];
var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11];
var a30 = mat[12], a31 = mat[13], a32 = mat[14], a33 = mat[15];
var b00 = mat2[0], b01 = mat2[1], b02 = mat2[2], b03 = mat2[3];
var b10 = mat2[4], b11 = mat2[5], b12 = mat2[6], b13 = mat2[7];
var b20 = mat2[8], b21 = mat2[9], b22 = mat2[10], b23 = mat2[11];
var b30 = mat2[12], b31 = mat2[13], b32 = mat2[14], b33 = mat2[15];
dest[0] = b00*a00 + b01*a10 + b02*a20 + b03*a30;
dest[1] = b00*a01 + b01*a11 + b02*a21 + b03*a31;
dest[2] = b00*a02 + b01*a12 + b02*a22 + b03*a32;
dest[3] = b00*a03 + b01*a13 + b02*a23 + b03*a33;
dest[4] = b10*a00 + b11*a10 + b12*a20 + b13*a30;
dest[5] = b10*a01 + b11*a11 + b12*a21 + b13*a31;
dest[6] = b10*a02 + b11*a12 + b12*a22 + b13*a32;
dest[7] = b10*a03 + b11*a13 + b12*a23 + b13*a33;
dest[8] = b20*a00 + b21*a10 + b22*a20 + b23*a30;
dest[9] = b20*a01 + b21*a11 + b22*a21 + b23*a31;
dest[10] = b20*a02 + b21*a12 + b22*a22 + b23*a32;
dest[11] = b20*a03 + b21*a13 + b22*a23 + b23*a33;
dest[12] = b30*a00 + b31*a10 + b32*a20 + b33*a30;
dest[13] = b30*a01 + b31*a11 + b32*a21 + b33*a31;
dest[14] = b30*a02 + b31*a12 + b32*a22 + b33*a32;
dest[15] = b30*a03 + b31*a13 + b32*a23 + b33*a33;
return dest;
};
/*
* mat4.multiplyVec3
* Transforms a vec3 with the given matrix
* 4th vector component is implicitly '1'
*
* Params:
* mat - mat4 to transform the vector with
* vec - vec3 to transform
* dest - Optional, vec3 receiving operation result. If not specified result is written to vec
*
* Returns:
* dest if specified, vec otherwise
*/
mat4.multiplyVec3 = function(mat, vec, dest) {
if(!dest) { dest = vec; }
var x = vec[0], y = vec[1], z = vec[2];
dest[0] = mat[0]*x + mat[4]*y + mat[8]*z + mat[12];
dest[1] = mat[1]*x + mat[5]*y + mat[9]*z + mat[13];
dest[2] = mat[2]*x + mat[6]*y + mat[10]*z + mat[14];
return dest;
};
/*
* mat4.multiplyVec4
* Transforms a vec4 with the given matrix
*
* Params:
* mat - mat4 to transform the vector with
* vec - vec4 to transform
* dest - Optional, vec4 receiving operation result. If not specified result is written to vec
*
* Returns:
* dest if specified, vec otherwise
*/
mat4.multiplyVec4 = function(mat, vec, dest) {
if(!dest) { dest = vec;}
var x = vec[0], y = vec[1], z = vec[2], w = vec[3];
dest[0] = mat[0]*x + mat[4]*y + mat[8]*z + mat[12]*w;
dest[1] = mat[1]*x + mat[5]*y + mat[9]*z + mat[13]*w;
dest[2] = mat[2]*x + mat[6]*y + mat[10]*z + mat[14]*w;
dest[3] = mat[3]*x + mat[7]*y + mat[11]*z + mat[15]*w;
return dest;
};
/*
* mat4.translate
* Translates a matrix by the given vector
*
* Params:
* mat - mat4 to translate
* vec - vec3 specifying the translation
* dest - Optional, mat4 receiving operation result. If not specified result is written to mat
*
* Returns:
* dest if specified, mat otherwise
*/
mat4.translate = function(mat, vec, dest) {
var x = vec[0], y = vec[1], z = vec[2];
if(!dest || mat == dest) {
mat[12] = mat[0]*x + mat[4]*y + mat[8]*z + mat[12];
mat[13] = mat[1]*x + mat[5]*y + mat[9]*z + mat[13];
mat[14] = mat[2]*x + mat[6]*y + mat[10]*z + mat[14];
mat[15] = mat[3]*x + mat[7]*y + mat[11]*z + mat[15];
return mat;
}
var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3];
var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7];
var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11];
dest[0] = a00;
dest[1] = a01;
dest[2] = a02;
dest[3] = a03;
dest[4] = a10;
dest[5] = a11;
dest[6] = a12;
dest[7] = a13;
dest[8] = a20;
dest[9] = a21;
dest[10] = a22;
dest[11] = a23;
dest[12] = a00*x + a10*y + a20*z + mat[12];
dest[13] = a01*x + a11*y + a21*z + mat[13];
dest[14] = a02*x + a12*y + a22*z + mat[14];
dest[15] = a03*x + a13*y + a23*z + mat[15];
return dest;
};
/*
* mat4.scale
* Scales a matrix by the given vector
*
* Params:
* mat - mat4 to scale
* vec - vec3 specifying the scale for each axis
* dest - Optional, mat4 receiving operation result. If not specified result is written to mat
*
* Returns:
* dest if specified, mat otherwise
*/
mat4.scale = function(mat, vec, dest) {
var x = vec[0], y = vec[1], z = vec[2];
if(!dest || mat == dest) {
mat[0] *= x;
mat[1] *= x;
mat[2] *= x;
mat[3] *= x;
mat[4] *= y;
mat[5] *= y;
mat[6] *= y;
mat[7] *= y;
mat[8] *= z;
mat[9] *= z;
mat[10] *= z;
mat[11] *= z;
return mat;
}
dest[0] = mat[0]*x;
dest[1] = mat[1]*x;
dest[2] = mat[2]*x;
dest[3] = mat[3]*x;
dest[4] = mat[4]*y;
dest[5] = mat[5]*y;
dest[6] = mat[6]*y;
dest[7] = mat[7]*y;
dest[8] = mat[8]*z;
dest[9] = mat[9]*z;
dest[10] = mat[10]*z;
dest[11] = mat[11]*z;
dest[12] = mat[12];
dest[13] = mat[13];
dest[14] = mat[14];
dest[15] = mat[15];
return dest;
};
/*
* mat4.rotate
* Rotates a matrix by the given angle around the specified axis
* If rotating around a primary axis (X,Y,Z) one of the specialized rotation functions should be used instead for performance
*
* Params:
* mat - mat4 to rotate
* angle - angle (in radians) to rotate
* axis - vec3 representing the axis to rotate around
* dest - Optional, mat4 receiving operation result. If not specified result is written to mat
*
* Returns:
* dest if specified, mat otherwise
*/
mat4.rotate = function(mat, angle, axis, dest) {
var x = axis[0], y = axis[1], z = axis[2];
var len = Math.sqrt(x*x + y*y + z*z);
if (!len) { return null; }
if (len != 1) {
len = 1 / len;
x *= len;
y *= len;
z *= len;
}
var s = Math.sin(angle);
var c = Math.cos(angle);
var t = 1-c;
// Cache the matrix values (makes for huge speed increases!)
var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3];
var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7];
var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11];
// Construct the elements of the rotation matrix
var b00 = x*x*t + c, b01 = y*x*t + z*s, b02 = z*x*t - y*s;
var b10 = x*y*t - z*s, b11 = y*y*t + c, b12 = z*y*t + x*s;
var b20 = x*z*t + y*s, b21 = y*z*t - x*s, b22 = z*z*t + c;
if(!dest) {
dest = mat;
} else if(mat != dest) { // If the source and destination differ, copy the unchanged last row
dest[12] = mat[12];
dest[13] = mat[13];
dest[14] = mat[14];
dest[15] = mat[15];
}
// Perform rotation-specific matrix multiplication
dest[0] = a00*b00 + a10*b01 + a20*b02;
dest[1] = a01*b00 + a11*b01 + a21*b02;
dest[2] = a02*b00 + a12*b01 + a22*b02;
dest[3] = a03*b00 + a13*b01 + a23*b02;
dest[4] = a00*b10 + a10*b11 + a20*b12;
dest[5] = a01*b10 + a11*b11 + a21*b12;
dest[6] = a02*b10 + a12*b11 + a22*b12;
dest[7] = a03*b10 + a13*b11 + a23*b12;
dest[8] = a00*b20 + a10*b21 + a20*b22;
dest[9] = a01*b20 + a11*b21 + a21*b22;
dest[10] = a02*b20 + a12*b21 + a22*b22;
dest[11] = a03*b20 + a13*b21 + a23*b22;
return dest;
};
/*
* mat4.rotateX
* Rotates a matrix by the given angle around the X axis
*
* Params:
* mat - mat4 to rotate
* angle - angle (in radians) to rotate
* dest - Optional, mat4 receiving operation result. If not specified result is written to mat
*
* Returns:
* dest if specified, mat otherwise
*/
mat4.rotateX = function(mat, angle, dest) {
var s = Math.sin(angle);
var c = Math.cos(angle);
// Cache the matrix values (makes for huge speed increases!)
var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7];
var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11];
if(!dest) {
dest = mat
} else if(mat != dest) { // If the source and destination differ, copy the unchanged rows
dest[0] = mat[0];
dest[1] = mat[1];
dest[2] = mat[2];
dest[3] = mat[3];
dest[12] = mat[12];
dest[13] = mat[13];
dest[14] = mat[14];
dest[15] = mat[15];
}
// Perform axis-specific matrix multiplication
dest[4] = a10*c + a20*s;
dest[5] = a11*c + a21*s;
dest[6] = a12*c + a22*s;
dest[7] = a13*c + a23*s;
dest[8] = a10*-s + a20*c;
dest[9] = a11*-s + a21*c;
dest[10] = a12*-s + a22*c;
dest[11] = a13*-s + a23*c;
return dest;
};
/*
* mat4.rotateY
* Rotates a matrix by the given angle around the Y axis
*
* Params:
* mat - mat4 to rotate
* angle - angle (in radians) to rotate
* dest - Optional, mat4 receiving operation result. If not specified result is written to mat
*
* Returns:
* dest if specified, mat otherwise
*/
mat4.rotateY = function(mat, angle, dest) {
var s = Math.sin(angle);
var c = Math.cos(angle);
// Cache the matrix values (makes for huge speed increases!)
var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3];
var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11];
if(!dest) {
dest = mat
} else if(mat != dest) { // If the source and destination differ, copy the unchanged rows
dest[4] = mat[4];
dest[5] = mat[5];
dest[6] = mat[6];
dest[7] = mat[7];
dest[12] = mat[12];
dest[13] = mat[13];
dest[14] = mat[14];
dest[15] = mat[15];
}
// Perform axis-specific matrix multiplication
dest[0] = a00*c + a20*-s;
dest[1] = a01*c + a21*-s;
dest[2] = a02*c + a22*-s;
dest[3] = a03*c + a23*-s;
dest[8] = a00*s + a20*c;
dest[9] = a01*s + a21*c;
dest[10] = a02*s + a22*c;
dest[11] = a03*s + a23*c;
return dest;
};
/*
* mat4.rotateZ
* Rotates a matrix by the given angle around the Z axis
*
* Params:
* mat - mat4 to rotate
* angle - angle (in radians) to rotate
* dest - Optional, mat4 receiving operation result. If not specified result is written to mat
*
* Returns:
* dest if specified, mat otherwise
*/
mat4.rotateZ = function(mat, angle, dest) {
var s = Math.sin(angle);
var c = Math.cos(angle);
// Cache the matrix values (makes for huge speed increases!)
var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3];
var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7];
if(!dest) {
dest = mat
} else if(mat != dest) { // If the source and destination differ, copy the unchanged last row
dest[8] = mat[8];
dest[9] = mat[9];
dest[10] = mat[10];
dest[11] = mat[11];
dest[12] = mat[12];
dest[13] = mat[13];
dest[14] = mat[14];
dest[15] = mat[15];
}
// Perform axis-specific matrix multiplication
dest[0] = a00*c + a10*s;
dest[1] = a01*c + a11*s;
dest[2] = a02*c + a12*s;
dest[3] = a03*c + a13*s;
dest[4] = a00*-s + a10*c;
dest[5] = a01*-s + a11*c;
dest[6] = a02*-s + a12*c;
dest[7] = a03*-s + a13*c;
return dest;
};
/*
* mat4.frustum
* Generates a frustum matrix with the given bounds
*
* Params:
* left, right - scalar, left and right bounds of the frustum
* bottom, top - scalar, bottom and top bounds of the frustum
* near, far - scalar, near and far bounds of the frustum
* dest - Optional, mat4 frustum matrix will be written into
*
* Returns:
* dest if specified, a new mat4 otherwise
*/
mat4.frustum = function(left, right, bottom, top, near, far, dest) {
if(!dest) { dest = mat4.create(); }
var rl = (right - left);
var tb = (top - bottom);
var fn = (far - near);
dest[0] = (near*2) / rl;
dest[1] = 0;
dest[2] = 0;
dest[3] = 0;
dest[4] = 0;
dest[5] = (near*2) / tb;
dest[6] = 0;
dest[7] = 0;
dest[8] = (right + left) / rl;
dest[9] = (top + bottom) / tb;
dest[10] = -(far + near) / fn;
dest[11] = -1;
dest[12] = 0;
dest[13] = 0;
dest[14] = -(far*near*2) / fn;
dest[15] = 0;
return dest;
};
/*
* mat4.perspective
* Generates a perspective projection matrix with the given bounds
*
* Params:
* fovy - scalar, vertical field of view
* aspect - scalar, aspect ratio. typically viewport width/height
* near, far - scalar, near and far bounds of the frustum
* dest - Optional, mat4 frustum matrix will be written into
*
* Returns:
* dest if specified, a new mat4 otherwise
*/
mat4.perspective = function(fovy, aspect, near, far, dest) {
var top = near*Math.tan(fovy*Math.PI / 360.0);
var right = top*aspect;
return mat4.frustum(-right, right, -top, top, near, far, dest);
};
/*
* mat4.ortho
* Generates a orthogonal projection matrix with the given bounds
*
* Params:
* left, right - scalar, left and right bounds of the frustum
* bottom, top - scalar, bottom and top bounds of the frustum
* near, far - scalar, near and far bounds of the frustum
* dest - Optional, mat4 frustum matrix will be written into
*
* Returns:
* dest if specified, a new mat4 otherwise
*/
mat4.ortho = function(left, right, bottom, top, near, far, dest) {
if(!dest) { dest = mat4.create(); }
var rl = (right - left);
var tb = (top - bottom);
var fn = (far - near);
dest[0] = 2 / rl;
dest[1] = 0;
dest[2] = 0;
dest[3] = 0;
dest[4] = 0;
dest[5] = 2 / tb;
dest[6] = 0;
dest[7] = 0;
dest[8] = 0;
dest[9] = 0;
dest[10] = -2 / fn;
dest[11] = 0;
dest[12] = -(left + right) / rl;
dest[13] = -(top + bottom) / tb;
dest[14] = -(far + near) / fn;
dest[15] = 1;
return dest;
};
/*
* mat4.ortho
* Generates a look-at matrix with the given eye position, focal point, and up axis
*
* Params:
* eye - vec3, position of the viewer
* center - vec3, point the viewer is looking at
* up - vec3 pointing "up"
* dest - Optional, mat4 frustum matrix will be written into
*
* Returns:
* dest if specified, a new mat4 otherwise
*/
mat4.lookAt = function(eye, center, up, dest) {
if(!dest) { dest = mat4.create(); }
var eyex = eye[0],
eyey = eye[1],
eyez = eye[2],
upx = up[0],
upy = up[1],
upz = up[2],
centerx = center[0],
centery = center[1],
centerz = center[2];
if (eyex == centerx && eyey == centery && eyez == centerz) {
return mat4.identity(dest);
}
var z0,z1,z2,x0,x1,x2,y0,y1,y2,len;
//vec3.direction(eye, center, z);
z0 = eyex - center[0];
z1 = eyey - center[1];
z2 = eyez - center[2];
// normalize (no check needed for 0 because of early return)
len = 1/Math.sqrt(z0*z0 + z1*z1 + z2*z2);
z0 *= len;
z1 *= len;
z2 *= len;
//vec3.normalize(vec3.cross(up, z, x));
x0 = upy*z2 - upz*z1;
x1 = upz*z0 - upx*z2;
x2 = upx*z1 - upy*z0;
len = Math.sqrt(x0*x0 + x1*x1 + x2*x2);
if (!len) {
x0 = 0;
x1 = 0;
x2 = 0;
} else {
len = 1/len;
x0 *= len;
x1 *= len;
x2 *= len;
};
//vec3.normalize(vec3.cross(z, x, y));
y0 = z1*x2 - z2*x1;
y1 = z2*x0 - z0*x2;
y2 = z0*x1 - z1*x0;
len = Math.sqrt(y0*y0 + y1*y1 + y2*y2);
if (!len) {
y0 = 0;
y1 = 0;
y2 = 0;
} else {
len = 1/len;
y0 *= len;
y1 *= len;
y2 *= len;
}
dest[0] = x0;
dest[1] = y0;
dest[2] = z0;
dest[3] = 0;
dest[4] = x1;
dest[5] = y1;
dest[6] = z1;
dest[7] = 0;
dest[8] = x2;
dest[9] = y2;
dest[10] = z2;
dest[11] = 0;
dest[12] = -(x0*eyex + x1*eyey + x2*eyez);
dest[13] = -(y0*eyex + y1*eyey + y2*eyez);
dest[14] = -(z0*eyex + z1*eyey + z2*eyez);
dest[15] = 1;
return dest;
};
/*
* mat4.str
* Returns a string representation of a mat4
*
* Params:
* mat - mat4 to represent as a string
*
* Returns:
* string representation of mat
*/
mat4.str = function(mat) {
return '[' + mat[0] + ', ' + mat[1] + ', ' + mat[2] + ', ' + mat[3] +
', '+ mat[4] + ', ' + mat[5] + ', ' + mat[6] + ', ' + mat[7] +
', '+ mat[8] + ', ' + mat[9] + ', ' + mat[10] + ', ' + mat[11] +
', '+ mat[12] + ', ' + mat[13] + ', ' + mat[14] + ', ' + mat[15] + ']';
};
/*
* quat4 - Quaternions
*/
var quat4 = {};
/*
* quat4.create
* Creates a new instance of a quat4 using the default array type
* Any javascript array containing at least 4 numeric elements can serve as a quat4
*
* Params:
* quat - Optional, quat4 containing values to initialize with
*
* Returns:
* New quat4
*/
quat4.create = function(quat) {
var dest = new glMatrixArrayType(4);
if(quat) {
dest[0] = quat[0];
dest[1] = quat[1];
dest[2] = quat[2];
dest[3] = quat[3];
}
return dest;
};
/*
* quat4.set
* Copies the values of one quat4 to another
*
* Params:
* quat - quat4 containing values to copy
* dest - quat4 receiving copied values
*
* Returns:
* dest
*/
quat4.set = function(quat, dest) {
dest[0] = quat[0];
dest[1] = quat[1];
dest[2] = quat[2];
dest[3] = quat[3];
return dest;
};
/*
* quat4.calculateW
* Calculates the W component of a quat4 from the X, Y, and Z components.
* Assumes that quaternion is 1 unit in length.
* Any existing W component will be ignored.
*
* Params:
* quat - quat4 to calculate W component of
* dest - Optional, quat4 receiving calculated values. If not specified result is written to quat
*
* Returns:
* dest if specified, quat otherwise
*/
quat4.calculateW = function(quat, dest) {
var x = quat[0], y = quat[1], z = quat[2];
if(!dest || quat == dest) {
quat[3] = -Math.sqrt(Math.abs(1.0 - x*x - y*y - z*z));
return quat;
}
dest[0] = x;
dest[1] = y;
dest[2] = z;
dest[3] = -Math.sqrt(Math.abs(1.0 - x*x - y*y - z*z));
return dest;
};
/*
* quat4.inverse
* Calculates the inverse of a quat4
*
* Params:
* quat - quat4 to calculate inverse of
* dest - Optional, quat4 receiving inverse values. If not specified result is written to quat
*
* Returns:
* dest if specified, quat otherwise
*/
quat4.inverse = function(quat, dest) {
if(!dest || quat == dest) {
quat[0] *= 1;
quat[1] *= 1;
quat[2] *= 1;
return quat;
}
dest[0] = -quat[0];
dest[1] = -quat[1];
dest[2] = -quat[2];
dest[3] = quat[3];
return dest;
};
/*
* quat4.length
* Calculates the length of a quat4
*
* Params:
* quat - quat4 to calculate length of
*
* Returns:
* Length of quat
*/
quat4.length = function(quat) {
var x = quat[0], y = quat[1], z = quat[2], w = quat[3];
return Math.sqrt(x*x + y*y + z*z + w*w);
};
/*
* quat4.normalize
* Generates a unit quaternion of the same direction as the provided quat4
* If quaternion length is 0, returns [0, 0, 0, 0]
*
* Params:
* quat - quat4 to normalize
* dest - Optional, quat4 receiving operation result. If not specified result is written to quat
*
* Returns:
* dest if specified, quat otherwise
*/
quat4.normalize = function(quat, dest) {
if(!dest) { dest = quat; }
var x = quat[0], y = quat[1], z = quat[2], w = quat[3];
var len = Math.sqrt(x*x + y*y + z*z + w*w);
if(len == 0) {
dest[0] = 0;
dest[1] = 0;
dest[2] = 0;
dest[3] = 0;
return dest;
}
len = 1/len;
dest[0] = x * len;
dest[1] = y * len;
dest[2] = z * len;
dest[3] = w * len;
return dest;
};
/*
* quat4.multiply
* Performs a quaternion multiplication
*
* Params:
* quat - quat4, first operand
* quat2 - quat4, second operand
* dest - Optional, quat4 receiving operation result. If not specified result is written to quat
*
* Returns:
* dest if specified, quat otherwise
*/
quat4.multiply = function(quat, quat2, dest) {
if(!dest) { dest = quat; }
var qax = quat[0], qay = quat[1], qaz = quat[2], qaw = quat[3];
var qbx = quat2[0], qby = quat2[1], qbz = quat2[2], qbw = quat2[3];
dest[0] = qax*qbw + qaw*qbx + qay*qbz - qaz*qby;
dest[1] = qay*qbw + qaw*qby + qaz*qbx - qax*qbz;
dest[2] = qaz*qbw + qaw*qbz + qax*qby - qay*qbx;
dest[3] = qaw*qbw - qax*qbx - qay*qby - qaz*qbz;
return dest;
};
/*
* quat4.multiplyVec3
* Transforms a vec3 with the given quaternion
*
* Params:
* quat - quat4 to transform the vector with
* vec - vec3 to transform
* dest - Optional, vec3 receiving operation result. If not specified result is written to vec
*
* Returns:
* dest if specified, vec otherwise
*/
quat4.multiplyVec3 = function(quat, vec, dest) {
if(!dest) { dest = vec; }
var x = vec[0], y = vec[1], z = vec[2];
var qx = quat[0], qy = quat[1], qz = quat[2], qw = quat[3];
// calculate quat * vec
var ix = qw*x + qy*z - qz*y;
var iy = qw*y + qz*x - qx*z;
var iz = qw*z + qx*y - qy*x;
var iw = -qx*x - qy*y - qz*z;
// calculate result * inverse quat
dest[0] = ix*qw + iw*-qx + iy*-qz - iz*-qy;
dest[1] = iy*qw + iw*-qy + iz*-qx - ix*-qz;
dest[2] = iz*qw + iw*-qz + ix*-qy - iy*-qx;
return dest;
};
/*
* quat4.toMat3
* Calculates a 3x3 matrix from the given quat4
*
* Params:
* quat - quat4 to create matrix from
* dest - Optional, mat3 receiving operation result
*
* Returns:
* dest if specified, a new mat3 otherwise
*/
quat4.toMat3 = function(quat, dest) {
if(!dest) { dest = mat3.create(); }
var x = quat[0], y = quat[1], z = quat[2], w = quat[3];
var x2 = x + x;
var y2 = y + y;
var z2 = z + z;
var xx = x*x2;
var xy = x*y2;
var xz = x*z2;
var yy = y*y2;
var yz = y*z2;
var zz = z*z2;
var wx = w*x2;
var wy = w*y2;
var wz = w*z2;
dest[0] = 1 - (yy + zz);
dest[1] = xy - wz;
dest[2] = xz + wy;
dest[3] = xy + wz;
dest[4] = 1 - (xx + zz);
dest[5] = yz - wx;
dest[6] = xz - wy;
dest[7] = yz + wx;
dest[8] = 1 - (xx + yy);
return dest;
};
/*
* quat4.toMat4
* Calculates a 4x4 matrix from the given quat4
*
* Params:
* quat - quat4 to create matrix from
* dest - Optional, mat4 receiving operation result
*
* Returns:
* dest if specified, a new mat4 otherwise
*/
quat4.toMat4 = function(quat, dest) {
if(!dest) { dest = mat4.create(); }
var x = quat[0], y = quat[1], z = quat[2], w = quat[3];
var x2 = x + x;
var y2 = y + y;
var z2 = z + z;
var xx = x*x2;
var xy = x*y2;
var xz = x*z2;
var yy = y*y2;
var yz = y*z2;
var zz = z*z2;
var wx = w*x2;
var wy = w*y2;
var wz = w*z2;
dest[0] = 1 - (yy + zz);
dest[1] = xy - wz;
dest[2] = xz + wy;
dest[3] = 0;
dest[4] = xy + wz;
dest[5] = 1 - (xx + zz);
dest[6] = yz - wx;
dest[7] = 0;
dest[8] = xz - wy;
dest[9] = yz + wx;
dest[10] = 1 - (xx + yy);
dest[11] = 0;
dest[12] = 0;
dest[13] = 0;
dest[14] = 0;
dest[15] = 1;
return dest;
};
/*
* quat4.str
* Returns a string representation of a quaternion
*
* Params:
* quat - quat4 to represent as a string
*
* Returns:
* string representation of quat
*/
quat4.str = function(quat) {
return '[' + quat[0] + ', ' + quat[1] + ', ' + quat[2] + ', ' + quat[3] + ']';
};
return {
vec3: vec3,
mat3: mat3,
mat4: mat4
};
})());
witty-3.3.4+dfsg.orig/src/js/WTreeView.js 0000644 0001750 0001750 00000030337 12420210325 020442 0 ustar pgquiles pgquiles /*
* Copyright (C) 2010 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WTreeView",
function(APP, el, contentsContainer, headerContainer, rowHeaderCount, selectedClass) {
jQuery.data(el, 'obj', this);
var contents = contentsContainer.firstChild;
var headers = headerContainer.firstChild;
var self = this;
var WT = APP.WT;
var sizeSet = false;
/** @const */ var EnsureVisible = 0;
/** @const */ var PositionAtTop = 1;
/** @const */ var PositionAtBottom = 2;
/** @const */ var PositionAtCenter = 3;
function getItem(event) {
var columnId = -1, nodeId = null, selected = false,
drop = false, ele = null;
var t = WT.target(event);
while (t && t != el) {
if (WT.hasTag(t, 'LI')) {
if (columnId == -1)
columnId = 0;
nodeId = t.id;
break;
} else if (t.className.indexOf('Wt-tv-c') == 0) {
if (t.className.indexOf('Wt-tv-c') == 0)
columnId = t.className.split(' ')[0].substring(7) * 1;
else if (columnId == -1)
columnId = 0;
if (t.getAttribute('drop') === 'true')
drop = true;
ele = t;
}
if ($(t).hasClass(selectedClass))
selected = true;
t = t.parentNode;
}
return { columnId: columnId, nodeId: nodeId, selected: selected,
drop: drop, el: ele };
}
this.click = function(obj, event) {
var item = getItem(event);
if (item.columnId != -1) {
APP.emit(el, { name: 'itemEvent', eventObject: obj, event: event },
item.nodeId + ':' + item.columnId, 'clicked', '', '');
}
};
this.dblClick = function(obj, event) {
var item = getItem(event);
if (item.columnId != -1) {
APP.emit(el, { name: 'itemEvent', eventObject: obj, event: event },
item.nodeId + ':' + item.columnId, 'dblclicked', '', '');
}
};
this.mouseDown = function(obj, event) {
WT.capture(null);
var item = getItem(event);
if (item.columnId != -1) {
APP.emit(el, { name: 'itemEvent', eventObject: obj, event: event },
item.nodeId + ':' + item.columnId, 'mousedown', '', '');
if (el.getAttribute('drag') === 'true' && item.selected)
APP._p_.dragStart(el, event);
}
};
this.mouseUp = function(obj, event) {
var item = getItem(event);
if (item.columnId != -1) {
APP.emit(el, { name: 'itemEvent', eventObject: obj, event: event },
item.nodeId + ':' + item.columnId, 'mouseup', '', '');
}
};
this.rootClick = function(obj, event) {
APP.emit(el, { name: 'itemEvent', eventObject: obj, event: event },
'', 'clicked', '', '');
};
this.rootDblclick = function(obj, event) {
APP.emit(el, { name: 'itemEvent', eventObject: obj, event: event },
'', 'dblclicked', '', '');
};
this.rootMouseDown = function(obj, event) {
APP.emit(el, { name: 'itemEvent', eventObject: obj, event: event },
'', 'mousedown', '', '');
};
this.rootMouseUp = function(obj, event) {
APP.emit(el, { name: 'itemEvent', eventObject: obj, event: event },
'', 'mouseup', '', '');
};
this.resizeHandleMDown = function(obj, event) {
var parent = obj.parentNode,
c = parent.className.split(' ')[0];
if (c) {
var r = WT.getCssRule('#' + el.id + ' .' + c),
cw = WT.pxself(r, 'width'),
minDelta = -cw,
maxDelta = 10000,
rtl = $(document.body).hasClass('Wt-rtl');
if (rtl) {
var tmp = minDelta;
minDelta = -maxDelta;
maxDelta = -tmp;
}
new WT.SizeHandle(WT, 'h', obj.offsetWidth, el.offsetHeight,
minDelta, maxDelta, 'Wt-hsh2',
function (delta) {
var newWidth = cw + (rtl ? -delta : delta),
columnId = c.substring(7) * 1;
r.style.width = newWidth + 'px';
self.adjustColumns();
APP.emit(el, 'columnResized', columnId,
parseInt(newWidth));
}, obj, el, event, -2, -1);
}
};
/*
* this adjusts invariants that take into account column resizes
*
* c0w is set as soon as possible.
*
* if (!column1 fixed):
* 1) width('Wt-headerdiv') = sum(column widths)
* 2) width('float: right') = sum(column(-1) widths)
* 3) width(table parent) = width('Wt-headerdiv')
* else
* 4) width('Wt-rowc') = sum(column(-1) widths)
*/
var adjustScheduled = false;
function doAdjustColumns() {
if (!adjustScheduled || !sizeSet)
return;
if (WT.isHidden(el))
return;
adjustScheduled = false;
var wrapRoot = contents.firstChild, // table parent
hc = headers.firstChild, // Wt-tv-row
allw_1=0, allw=0,
c0id = headers.lastChild.className.split(' ')[0],
c0r = WT.getCssRule('#' + el.id + ' .' + c0id);
if (rowHeaderCount)
hc = hc.firstChild; // Wt-tv-rowc
for (var i=0, length=hc.childNodes.length; i < length; ++i) {
if (hc.childNodes[i].className) { // IE may have only a text node
var cl = hc.childNodes[i].className.split(' ')[0],
r = WT.getCssRule('#' + el.id + ' .' + cl);
if (r.style.display == 'none')
continue;
// 7 = 2 * 3px (padding) + 1px border
allw_1 += WT.pxself(r, 'width') + 7;
}
}
if (!rowHeaderCount) {
/*
* A floating container does not relate to size of contained
* children. It needs an explicit width (as to the letter of the
* @!@#$%! CSS spec, btw.). Only IE in RTL mode (when float: left)
* seems to implement this correctly and thus needs the following:
*/
if (WT.isIE && $(document.body).hasClass('Wt-rtl')) {
var rrow = WT.getCssRule('#' + el.id + ' .Wt-tv-row');
if (rrow)
rrow.style.width = allw_1 + 'px';
}
if (!c0r.style.width) {
// first resize and c0 width not set
// 9 = 2px (widget border) - 7px column padding - 22px (scrollbar room)
var c0rw = el.scrollWidth - hc.offsetWidth - 9 - 15;
if (c0rw > 0)
c0r.style.width = c0rw + 'px';
} else
$(el).find('.Wt-headerdiv .' + c0id).css('width', c0r.style.width);
}
if (c0r.style['width'] == 'auto')
return;
/*
* IE6 is still not entirely right. It seems to be caused by a padding
* of 7 pixels in the first column which gets added to the width.
*/
allw = allw_1 + WT.pxself(c0r, 'width') + (WT.isIE6 ? 10 : 7);
if (!rowHeaderCount) {
headers.style.width = wrapRoot.style.width = allw + 'px';
hc.style.width = allw_1 + 'px';
} else {
var r = WT.getCssRule('#' + el.id + ' .Wt-tv-rowc');
r.style.width = allw_1 + 'px';
APP.layouts2.adjust();
if (WT.isIE) {
setTimeout(function() {
$(el).find('.Wt-tv-rowc')
.css('width', allw_1 + 'px')
.css('width', '');
}, 0);
}
el.changed = true;
}
}
this.adjustColumns = function() {
if (adjustScheduled)
return;
adjustScheduled = true;
setTimeout(doAdjustColumns, 0);
};
var dropEl = null;
el.handleDragDrop=function(action, object, event, sourceId, mimeType) {
if (dropEl) {
dropEl.className = dropEl.classNameOrig;
dropEl = null;
}
if (action=='end')
return;
var item = getItem(event);
if (!item.selected && item.drop && item.columnId != -1) {
if (action=='drop') {
APP.emit(el, { name: 'itemEvent', eventObject: object, event: event },
item.nodeId + ':' + item.columnId, 'drop', sourceId, mimeType);
} else {
object.className = 'Wt-valid-drop';
dropEl = item.el;
dropEl.classNameOrig = dropEl.className;
dropEl.className = dropEl.className + ' Wt-drop-site';
}
} else {
object.className = '';
}
};
/*
* This adjusts invariants that depend on the size of the whole
* treeview:
*
* - changes to the total width (tw inc. affected by scrollbar)
* - when column1 is fixed:
* * .row width
* * table parent width
*/
this.wtResize = function() {
sizeSet = true;
doAdjustColumns();
var $el=$(el),
c0id, c0r, c0w = null;
var tw = WT.pxself(el, 'width');
if (tw == 0)
tw = el.clientWidth;
else if (WT.boxSizing(el)) {
tw -= WT.px(el, 'borderLeftWidth');
tw -= WT.px(el, 'borderRightWidth');
}
var scrollwidth = contentsContainer.offsetWidth
- contentsContainer.clientWidth;
// IE cannot accurately estimate scrollwidth from time to time ?
if (scrollwidth > 50)
scrollwidth = 0;
if (contentsContainer.clientWidth > 0)
tw -= scrollwidth;
if ($el.hasClass('column1')) {
c0id = $el.find('.Wt-headerdiv').get(0)
.lastChild.className.split(' ')[0];
c0r = WT.getCssRule('#' + el.id + ' .' + c0id);
c0w = WT.pxself(c0r, 'width');
}
// XXX: IE's incremental rendering foobars completely
if ((!WT.isIE || tw > 100)
&& (tw != contentsContainer.tw ||
c0w != contentsContainer.c0w ||
el.changed)) {
var adjustColumns = !el.changed;
contentsContainer.tw = tw;
contentsContainer.c0w = c0w;
c0id = $el.find('.Wt-headerdiv').get(0)
.lastChild.className.split(' ')[0];
c0r = WT.getCssRule('#' + el.id + ' .' + c0id);
var table = contents.firstChild,
r = WT.getCssRule('#' + el.id + ' .cwidth'),
contentstoo = (r.style.width == (table.offsetWidth + 1) + 'px'),
hc = headers.firstChild;
r.style.width = tw + 'px';
contentsContainer.style.width = (tw + scrollwidth) + 'px';
var rtl = $(document.body).hasClass('Wt-rtl');
if (!rtl) {
headerContainer.style.marginRight = scrollwidth + 'px';
$('#' + el.id + ' .Wt-scroll').css('marginRight', scrollwidth + 'px');
}
if (c0w != null) {
var w = tw - c0w - (WT.isIE6 ? 10 : 7);
if (w > 0) {
var w2
= Math.min(w, WT.pxself
(WT.getCssRule('#' + el.id + ' .Wt-tv-rowc'),'width'));
tw -= (w - w2);
headers.style.width=tw + 'px';
table.style.width=tw + 'px';
/* This is really slow in FF, slower than the jquery equivalent */
WT.getCssRule('#' + el.id + ' .Wt-tv-row').style.width = w2 + 'px';
if (WT.isIE)
setTimeout(function() {
$el.find(' .Wt-tv-row')
.css('width', w2 + 'px')
.css('width', '');
}, 0);
}
} else {
if (contentstoo) {
headers.style.width=r.style.width;
table.style.width=r.style.width;
} else
headers.style.width = table.offsetWidth + 'px';
}
if (!rowHeaderCount && (table.offsetWidth - hc.offsetWidth >= 7))
c0r.style.width = (table.offsetWidth - hc.offsetWidth - 7) + 'px';
el.changed = false;
if (adjustColumns/* && WT.isIE */)
self.adjustColumns();
}
};
this.scrollTo = function(x, y, rowHeight, hint) {
if (y != -1) {
y *= rowHeight;
var top = contentsContainer.scrollTop,
height = contentsContainer.clientHeight;
if (hint == EnsureVisible) {
if (top + height < y)
hint = PositionAtTop;
else if (y < top)
hint = PositionAtBottom;
}
switch (hint) {
case PositionAtTop:
contentsContainer.scrollTop = y; break;
case PositionAtBottom:
contentsContainer.scrollTop = y - (height - rowHeight); break;
case PositionAtCenter:
contentsContainer.scrollTop = y - (height - rowHeight)/2; break;
}
window.fakeEvent = {object: contentsContainer};
contentsContainer.onscroll(window.fakeEvent);
window.fakeEvent = null;
}
};
var rowHeight;
this.setRowHeight = function(height) {
rowHeight = height;
};
// bug #1352: when the browser is zoomed the alternating rowcolors get
// out of sync when scrolling down. fix = offset the alternating colors
// image to repeat starting from the current scrolled position.
var offsetRowColorImg = function() {
if (rowHeight == 0)
return;
var scrollPos = contentsContainer.scrollTop;
var rootNode = contents.children[0].children[0];
rootNode.style.backgroundPosition = "0px " + Math.floor(scrollPos/(2*rowHeight)) * (2*rowHeight) + "px";
};
if (contentsContainer.addEventListener) {
contentsContainer.addEventListener("scroll", offsetRowColorImg);
} else if (contentsContainer.attachEvent) {
contentsContainer.attachEvent("onscroll", offsetRowColorImg);
}
self.adjustColumns();
});
witty-3.3.4+dfsg.orig/src/js/WDoubleValidator.js 0000644 0001750 0001750 00000002352 12346325710 022000 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
/*
* We could merge this with WIntValidator ...
*/
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WDoubleValidator",
function(mandatory, bottom, top, decimalPoint, groupSeparator, blankError,
NaNError, tooSmallError, tooLargeError) {
this.validate = function(text) {
text = String(text);
function toRegexp(value) {
return value.replace(new RegExp("([\\^\\\\\\][\\-.$*+?()|{}])","g"), "\\$1");
}
if (text.length == 0)
if (mandatory)
return { valid: false, message: blankError };
else
return { valid: true };
if (groupSeparator != '')
text = text.replace(new RegExp(toRegexp(groupSeparator), 'g'), '');
if (decimalPoint != '.')
text = text.replace(decimalPoint, '.');
var n = Number(text);
if (isNaN(n))
return { valid: false, message: NaNError };
if (bottom !== null)
if (n < bottom)
return { valid: false, message: tooSmallError };
if (top !== null)
if (n > top)
return { valid: false, message: tooLargeError };
return { valid: true };
};
});
witty-3.3.4+dfsg.orig/src/js/WDateValidator.js 0000644 0001750 0001750 00000003100 12200763306 021427 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
/*
* We could merge this with WIntValidator ...
*/
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WDateValidator",
function(mandatory, formats, bottom, top, blankError,
formatError, tooSmallError, tooLargeError) {
this.validate = function(text) {
if (text.length == 0)
if (mandatory)
return { valid: false, message: blankError };
else
return { valid: true };
var results;
var m = -1, d = -1, y = -1;
for (var i = 0, il = formats.length; i < il; ++i) {
var f = formats[i];
var r = new RegExp("^" + f.regexp + "$");
results = r.exec(text);
if (results != null) {
m = f.getMonth(results);
d = f.getDay(results);
y = f.getYear(results);
break;
}
}
if (results == null)
return { valid: false, message: formatError };
if ((d <= 0) || (d > 31) || (m <=0 ) || (m > 12))
return { valid: false, message: formatError };
var dt = new Date(y, m - 1, d);
if (dt.getDate() != d ||
dt.getMonth() != m-1 ||
dt.getFullYear() != y ||
dt.getFullYear() < 1400) {
return { valid: false, message: formatError };
}
if (bottom)
if (dt.getTime() < bottom.getTime())
return { valid: false, message: tooSmallError};
if (top)
if (dt.getTime() > top.getTime())
return { valid:false, message: tooLargeError};
return { valid: true };
};
}); witty-3.3.4+dfsg.orig/src/js/WWebWidget.js 0000644 0001750 0001750 00000016404 12455727400 020607 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptFunction, "animateDisplay",
function(id, effects, timing, duration, display) {
var WT = this;
var doAnimateDisplay = function(id, effects, timing, duration, display) {
/* const */ var NoEffect = 0x0;
/* const */ var SlideInFromLeft = 0x1;
/* const */ var SlideInFromRight = 0x2;
/* const */ var SlideInFromBottom = 0x3;
/* const */ var SlideInFromTop = 0x4;
/* const */ var Pop = 0x5;
/* const */ var Fade = 0x100;
/* const */ var Ease = 0;
/* const */ var Linear = 1;
/* const */ var EaseIn = 2;
/* const */ var EaseOut = 3;
/* const */ var EaseInOut = 4;
/* const */ var CubicBezier = 5;
var timings = [ "ease", "linear", "ease-in", "ease-out", "ease-in-out" ],
inverseTiming = [ 0, 1, 3, 2, 4, 5 ];
var animationPrefix = WT.vendorPrefix(WT.styleAttribute('animation'));
var transitionPrefix = WT.vendorPrefix(WT.styleAttribute('transition'));
var transformPrefix = WT.vendorPrefix(WT.styleAttribute('transform'));
var $el = $("#" + id), el = $el.get(0),
animationEventEnd = animationPrefix == "Webkit"
? "webkitAnimationEnd": "animationend",
transitionEventEnd = transitionPrefix == "Webkit"
? "webkitTransitionEnd" : "transitionend";
if ($el.css("display") !== display) {
var p = el.parentNode;
if (p.wtAnimateChild) {
p.wtAnimateChild(WT, $el.get(0), effects, timing, duration,
{ display: display });
return;
}
if ($el.hasClass("animating")) {
$(el).one(transitionEventEnd, function() {
doAnimateDisplay(id, effects, timing, duration, display);
});
return;
}
$el.addClass("animating");
var effect = effects & 0xFF,
hide = display === "none",
cssTiming = timings[hide ? inverseTiming[timing] : timing],
elStyle = {};
function set(el, style, savedStyle) {
var i, il;
for (i in style) {
var k = i;
if (k == "animationDuration" && animationPrefix != '')
k = animationPrefix + k.substring(0, 1).toUpperCase()
+ k.substring(1);
else if (k == "transform" && transformPrefix != '')
k = transformPrefix + k.substring(0, 1).toUpperCase()
+ k.substring(1);
else if (k == "transition" && transitionPrefix != '')
k = transitionPrefix + k.substring(0, 1).toUpperCase()
+ k.substring(1);
if (savedStyle && typeof(savedStyle[k]) === "undefined")
savedStyle[k] = el.style[k];
el.style[k] = style[i];
}
}
var restore = set;
function onEnd() {
if (el.wtAnimatedHidden)
el.wtAnimatedHidden(hide);
$el.removeClass("animating");
// FIXME: APP instead of Wt
if (Wt.layouts2)
Wt.layouts2.setElementDirty(el);
}
function show() {
el.style.display = display;
if (el.wtPosition)
el.wtPosition();
if (window.onshow) window.onshow();
}
function animateStaticVertical() {
var targetHeight, currentHeight, elcStyle = {}, elc;
if (hide) {
currentHeight = $el.height() + "px";
set(el,
{ height: currentHeight,
overflow: "hidden" },
elStyle);
if (effect == SlideInFromTop && el.childNodes.length == 1) {
elc = el.firstChild;
set(elc, { transform: "translateY(0)" }, elcStyle);
if (!WT.hasTag(elc, 'TABLE'))
set(elc, { display: "block" }, elcStyle);
}
targetHeight = "0px";
} else {
var $p = $(p), pStyle = { };
set(p,
{ height: $p.height() + "px",
overflow: "hidden" },
pStyle);
show();
if ($el.height() == 0)
el.style.height = 'auto';
targetHeight = $el.height() + "px";
set(el,
{ height: "0px",
overflow: "hidden" },
elStyle);
restore(p, pStyle);
if (effect == SlideInFromTop) {
set (el, { WebkitBackfaceVisibility: "visible"} , elStyle);
el.scrollTop = 1000;
}
}
if (effects & Fade)
set(el, { opacity: (hide ? 1 : 0) }, elStyle);
var currentHeight = el.clientHeight; // force 'absorbing' set height
setTimeout(function() {
set(el,
{ transition: "all " + duration + "ms " + cssTiming,
height: targetHeight },
elStyle);
if (effects & Fade)
set(el, { opacity: (hide ? 0 : 1) });
if (elc) {
set(elc,
{ transition: "all " + duration + "ms " + cssTiming,
transform: "translateY(-" + currentHeight + ")" },
elcStyle);
}
$el.one(transitionEventEnd, function() {
if (hide)
el.style.display = display;
restore(el, elStyle);
if (effect == SlideInFromTop) {
el.scrollTop = 0;
if (elc)
restore(elc, elcStyle);
}
onEnd();
});
}, 0);
}
function animateAbsolute(cssSize, cssOffset, topleft, U) {
if (!hide)
show();
var size = WT.px(el, cssSize),
hiddenU = (WT.px(el, cssOffset) + size) * (topleft ? -1 : 1);
var targetU;
if (hide) {
set(el, { transform: "translate" + U + "(0px)" }, elStyle);
targetU = hiddenU;
} else {
set(el, { transform: "translate" + U + "(" + hiddenU + "px)" },
elStyle);
targetU = 0;
}
if (effects & Fade)
set(el, { opacity: (hide ? 1 : 0) }, elStyle);
setTimeout(function() {
set(el,
{ transition: "all " + duration + "ms " + cssTiming,
transform: "translate" + U + "(" + targetU + "px)" },
elStyle);
if (effects & Fade)
set(el, { opacity: (hide ? 0 : 1) });
$el.one(transitionEventEnd, function() {
if (hide)
el.style.display = display;
restore(el, elStyle);
onEnd();
});
}, 0);
}
function animateAbsoluteVertical() {
animateAbsolute("height", effect == SlideInFromTop ? "top" : "bottom",
effect == SlideInFromTop, "Y");
}
function animateAbsoluteHorizontal() {
animateAbsolute("width", effect == SlideInFromLeft ? "left" : "right",
effect == SlideInFromLeft, "X");
}
function animateTransition() {
set(el, { animationDuration: duration + 'ms' }, elStyle);
var cl;
switch (effect) {
case Pop: cl = "pop"; break;
case SlideInFromLeft: cl = hide ? "slide" : "slide reverse"; break;
case SlideInFromRight: cl = hide ? "slide reverse" : "slide"; break;
}
cl += hide ? " out" : " in";
if (effects & Fade)
cl += " fade";
if (!hide)
show();
$el.addClass(cl);
$el.one(animationEventEnd, function() {
$el.removeClass(cl);
if (hide)
el.style.display = display;
restore(el, elStyle);
onEnd();
});
}
setTimeout(function() {
var position = $el.css('position'),
absolute = (position === 'absolute' || position === 'fixed');
switch (effect) {
case SlideInFromTop:
case SlideInFromBottom:
if (!absolute)
animateStaticVertical();
else
animateAbsoluteVertical();
break;
case SlideInFromLeft:
case SlideInFromRight:
if (absolute)
animateAbsoluteHorizontal();
else
animateTransition();
break;
case NoEffect:
case Pop:
animateTransition();
break;
}
} , 0);
}
};
doAnimateDisplay(id, effects, timing, duration, display);
}
);
WT_DECLARE_WT_MEMBER
(2, JavaScriptFunction, "animateVisible",
function(id, effects, timing, duration, visibility, position, top, left) {
}
);
witty-3.3.4+dfsg.orig/src/js/WSuggestionPopup.js 0000644 0001750 0001750 00000025413 12272250010 022062 0 ustar pgquiles pgquiles /*
* Copyright (C) 2010 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WSuggestionPopup",
function(APP, el, replacerJS, matcherJS, filterMinLength, filterMore,
defaultValue, isDropDownIconUnfiltered) {
$('.Wt-domRoot').add(el);
jQuery.data(el, 'obj', this);
var self = this;
var WT = APP.WT;
var key_tab = 9;
var key_enter = 13;
var key_escape = 27;
var key_pup = 33;
var key_pdown = 34;
var key_left = 37;
var key_up = 38;
var key_right = 39;
var key_down = 40;
var selId = null, editId = null, kd = false,
filter = null, filtering = null, filterPartial = filterMore,
delayHideTimeout = null,
lastFilterValue = null, droppedDown = false;
this.defaultValue = defaultValue;
/* Checks if we are (still) assisting the given edit */
function checkEdit(edit) {
return $(edit).hasClass("Wt-suggest-onedit")
|| $(edit).hasClass("Wt-suggest-dropdown");
}
function visible() {
return el.style.display != 'none';
}
function positionPopup(edit) {
el.style.display='block';
WT.positionAtWidget(el.id, edit.id, WT.Vertical);
}
function contentClicked(event) {
var e = event || window.event;
var line = WT.target(e);
if (WT.hasTag(line, "UL"))
return;
while (line && !WT.hasTag(line, "LI"))
line = line.parentNode;
if (line)
suggestionClicked(line);
}
function suggestionClicked(line) {
var suggestion = line.firstChild.firstChild,
edit = WT.getElement(editId),
sText = suggestion.innerHTML,
sValue = suggestion.getAttribute('sug');
edit.focus();
replacerJS(edit, sText, sValue);
APP.emit(el, "select", line.id, edit.id);
hidePopup();
editId = null;
};
var keyDownFun = null;
this.showPopup = function(edit) {
el.style.display = 'block';
selId = null;
lastFilterValue = null;
keyDownFun = edit.onkeydown;
edit.onkeydown = function(event) {
var e=event||window.event,o=this;
self.editKeyDown(o, e);
};
};
function hidePopup() {
el.style.display = 'none';
if (editId != null && keyDownFun != null) {
var edit = WT.getElement(editId);
edit.onkeydown = keyDownFun;
keyDownFun = null;
}
}
this.editMouseMove = function(edit, event) {
if (!checkEdit(edit))
return;
var xy = WT.widgetCoordinates(edit, event);
if (xy.x > edit.offsetWidth - 16)
edit.style.cursor = 'default';
else
edit.style.cursor = '';
};
this.showAt = function(edit, value) {
hidePopup();
editId = edit.id;
droppedDown = true;
self.refilter(value);
};
this.editClick = function(edit, event) {
if (!checkEdit(edit))
return;
var xy = WT.widgetCoordinates(edit, event);
if (xy.x > edit.offsetWidth - 16) {
if (editId != edit.id || !visible()) {
self.showAt(edit, '');
} else {
hidePopup();
editId = null;
}
}
};
function next(n, down) {
for (n = down ? n.nextSibling : n.previousSibling;
n;
n = down ? n.nextSibling : n.previousSibling) {
if (WT.hasTag(n, 'LI'))
if (n.style.display != 'none')
return n;
}
return null;
}
this.editKeyDown = function(edit, event) {
if (!checkEdit(edit))
return true;
if (editId != edit.id) {
if ($(edit).hasClass("Wt-suggest-onedit")) {
editId = edit.id;
droppedDown = false;
} else if ($(edit).hasClass("Wt-suggest-dropdown")
&& event.keyCode == key_down) {
editId = edit.id;
droppedDown = true;
} else {
editId = null;
return true;
}
}
var sel = selId ? WT.getElement(selId) : null;
if (visible() && sel) {
if ((event.keyCode == key_enter) || (event.keyCode == key_tab)) {
/*
* Select currently selectd
*/
suggestionClicked(sel);
WT.cancelEvent(event);
setTimeout(function() { edit.focus(); }, 0);
return false;
} else if ( event.keyCode == key_down
|| event.keyCode == key_up
|| event.keyCode == key_pdown
|| event.keyCode == key_pup) {
/*
* Handle navigation in list
*/
if (event.type.toUpperCase() == 'KEYDOWN') {
kd = true;
WT.cancelEvent(event, WT.CancelDefaultAction);
}
if (event.type.toUpperCase() == 'KEYPRESS' && kd == true) {
WT.cancelEvent(event);
return false;
}
/*
* Find next selected node
*/
var n = sel,
down = event.keyCode == key_down || event.keyCode == key_pdown,
count = (event.keyCode == key_pdown || event.keyCode == key_pup ?
el.clientHeight / sel.offsetHeight : 1),
i;
for (i = 0; n && i < count; ++i) {
var l = next(n, down);
if (!l)
break;
n = l;
}
if (n && WT.hasTag(n, 'LI')) {
sel.className = '';
n.className = 'active';
selId = n.id;
}
return false;
}
}
return (event.keyCode != key_enter && event.keyCode != key_tab);
};
this.filtered = function(f, partial) {
filter = f;
filterPartial = partial;
self.refilter(lastFilterValue);
};
function scrollToSelected(sel) {
var p = sel.parentNode;
if (sel.offsetTop + sel.offsetHeight > p.scrollTop + p.clientHeight)
p.scrollTop = sel.offsetTop + sel.offsetHeight - p.clientHeight;
else if (sel.offsetTop < p.scrollTop)
p.scrollTop = sel.offsetTop;
}
/*
* Refilter the current selection list based on the edit value.
*/
this.refilter = function(value) {
var sel = selId ? WT.getElement(selId) : null,
edit = WT.getElement(editId),
matcher = matcherJS(edit),
sels = el.childNodes,
text = (isDropDownIconUnfiltered && value != null) ? value : matcher(null);
lastFilterValue = isDropDownIconUnfiltered ? value : edit.value;
if (filterMinLength > 0 || filterMore) {
if (text.length < filterMinLength && !droppedDown) {
hidePopup();
return;
} else {
var nf = filterPartial ?
text :
text.substring(0, Math.max(filter !== null ? filter.length : 0,
filterMinLength));
if (nf != filter) {
if (nf != filtering) {
filtering = nf;
APP.emit(el, "filter", nf);
}
}
}
}
var first = null, toselect = null,
showall = droppedDown && text.length == 0,
i, il;
for (i = 0, il = sels.length; i < il; ++i) {
var child = sels[i];
if (WT.hasTag(child, 'LI')) {
var a = child.firstChild;
if (child.orig == null) {
child.orig = a.firstChild.innerHTML;
}
var result = matcher(child.orig),
match = showall || result.match;
if (result.suggestion != a.firstChild.innerHTML)
a.firstChild.innerHTML = result.suggestion;
if (match) {
if (child.style.display != '')
child.style.display = '';
if (first == null)
first = child;
if (i == this.defaultValue) {
toselect = child;
}
} else if (child.style.display != 'none')
child.style.display = 'none';
if (child.className != '')
child.className = '';
}
}
if (first == null) {
hidePopup();
} else {
if (!visible()) {
positionPopup(edit);
self.showPopup(edit);
sel = null;
}
if (!sel || (sel.style.display == 'none')) {
sel = toselect || first ;
sel.parentNode.scrollTop = 0;
selId = sel.id;
}
sel.className = 'active';
scrollToSelected(sel);
}
};
this.editKeyUp = function(edit, event) {
if (editId == null)
return;
if (!checkEdit(edit))
return;
if (!visible()
&& (event.keyCode == key_enter
|| event.keyCode == key_tab)) {
return;
}
if (event.keyCode == key_escape
|| event.keyCode == key_left
|| event.keyCode == key_right) {
hidePopup();
} else {
if (edit.value != lastFilterValue)
self.refilter(edit.value);
else {
var sel = selId ? WT.getElement(selId) : null;
if (sel)
scrollToSelected(sel);
}
}
};
el.onclick = contentClicked;
/*
* In Safari, scrolling causes the edit to lose focus, but we don't want
* that. Can it be avoided? In any case, this fixes it.
*/
el.onscroll = function() {
if (delayHideTimeout) {
clearTimeout(delayHideTimeout);
var edit = WT.getElement(editId);
if (edit)
edit.focus();
}
};
this.delayHide = function(edit, event) {
delayHideTimeout = setTimeout(function() {
delayHideTimeout = null;
if (el && (edit == null || editId == edit.id))
hidePopup();
}, 300);
};
});
WT_DECLARE_WT_MEMBER
(2, JavaScriptConstructor, "WSuggestionPopupStdMatcher",
function(highlightBeginTag, highlightEndTag, listSeparator, whiteSpace,
wordSeparators, wordRegexp, appendReplacedText) {
function parseEdit(edit) {
var value = edit.value;
var pos = edit.selectionStart ? edit.selectionStart : value.length;
var start = listSeparator
? value.lastIndexOf(listSeparator, pos - 1) + 1 : 0;
while ((start < pos)
&& (whiteSpace.indexOf(value.charAt(start)) != -1))
++start;
return { start: start, end: pos };
}
this.match = function(edit) {
var range = parseEdit(edit);
var value = edit.value.substring(range.start, range.end);
var regexp;
if (wordRegexp.length == 0) {
if (wordSeparators.length != 0)
regexp = "(^|(?:[" + wordSeparators + "]))";
else
regexp = "(^)";
} else
regexp = "(" + wordRegexp + ")";
regexp += "(" + value.replace
(new RegExp("([\\^\\\\\\][\\-.$*+?()|{}])","g"), "\\$1") + ")";
regexp = new RegExp(regexp, "gi");
return function(suggestion) {
if (!suggestion)
return value;
var matched = false;
if (value.length) {
var highlighted
= suggestion.replace(regexp, "$1" + highlightBeginTag + "$2"
+ highlightEndTag);
if (highlighted != suggestion) {
matched = true;
suggestion = highlighted;
}
}
return { match: matched, suggestion: suggestion };
};
};
this.replace = function(edit, suggestionText, suggestionValue) {
var range = parseEdit(edit);
var nv = edit.value.substring(0, range.start) + suggestionValue
+ appendReplacedText;
if (range.end < edit.value.length)
nv += edit.value.substring(range.end, edit.value.length);
edit.value = nv;
if (edit.selectionStart) {
edit.selectionStart = range.start + suggestionValue.length
+ appendReplacedText.length;
edit.selectionEnd = edit.selectionStart;
}
};
});
witty-3.3.4+dfsg.orig/src/js/WFormWidget.js 0000644 0001750 0001750 00000002124 12276661056 020774 0 ustar pgquiles pgquiles /*
* Copyright (C) 2010 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WFormWidget",
function(APP, el, emptyText) {
jQuery.data(el, 'obj', this);
var self = this, WT = APP.WT, emptyTextStyle = 'Wt-edit-emptyText';
this.applyEmptyText = function() {
if (WT.hasFocus(el)) {
if ($(el).hasClass(emptyTextStyle)) {
if (!WT.isIE && el.oldtype) {
el.type = el.oldtype;
}
$(el).removeClass(emptyTextStyle);
el.value = '';
}
} else {
if (el.value == '') {
if (el.type == 'password') {
if (!WT.isIE) {
el.oldtype = 'password';
el.type = 'text';
} else
return;
}
$(el).addClass(emptyTextStyle);
el.value = emptyText;
} else {
$(el).removeClass(emptyTextStyle);
}
}
};
this.setEmptyText = function(newEmptyText) {
emptyText = newEmptyText;
if ($(el).hasClass(emptyTextStyle))
el.value = emptyText;
};
this.applyEmptyText();
});
witty-3.3.4+dfsg.orig/src/js/WIntValidator.js 0000644 0001750 0001750 00000002027 12272250010 021303 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
/*
* We could merge this with WDoubleValidator ...
*/
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WIntValidator",
function(mandatory, bottom, top, groupSeparator, blankError,
NaNError, tooSmallError, tooLargeError) {
this.validate = function(text) {
text = String(text);
if (text.length == 0)
if (mandatory)
return { valid: false, message: blankError };
else
return { valid: true };
if (groupSeparator != '')
text = text.replace(groupSeparator, '', 'g');
var n = Number(text);
if (isNaN(n) || (Math.round(n) != n))
return { valid: false, message: NaNError };
if (bottom !== null)
if (n < bottom)
return { valid: false, message: tooSmallError };
if (top !== null)
if (n > top)
return { valid: false, message: tooLargeError };
return { valid: true };
};
});
witty-3.3.4+dfsg.orig/src/js/CssThemeValidate.js 0000644 0001750 0001750 00000002252 12164270255 021756 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptFunction, "validate",
function(edit) {
var v;
if (edit.options)
v = edit.options.item(edit.selectedIndex).text;
else
v = edit.value;
v = edit.wtValidate.validate(v);
this.setValidationState(edit, v.valid, v.message, 1);
});
WT_DECLARE_WT_MEMBER
(2, JavaScriptFunction, "setValidationState",
function(edit, state, message, styles) {
/* const */ var ValidationInvalidStyle = 0x1;
/* const */ var ValidationValidStyle = 0x2;
var validStyle = (state == 1) &&
((styles & ValidationValidStyle) != 0);
var invalidStyle = (state != 1) &&
((styles & ValidationInvalidStyle) != 0);
var $edit = $(edit);
$edit
.toggleClass("Wt-valid", validStyle)
.toggleClass("Wt-invalid", invalidStyle);
if (typeof edit.defaultTT === 'undefined')
edit.defaultTT = edit.getAttribute('title') || '';
if (state)
edit.setAttribute('title', edit.defaultTT);
else
edit.setAttribute('title', message);
});
witty-3.3.4+dfsg.orig/src/js/WGLWidget.js 0000644 0001750 0001750 00000024223 12475324032 020366 0 ustar pgquiles pgquiles /*
* Copyright (C) 2010 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WGLWidget",
function(APP, canvas) {
jQuery.data(canvas, 'obj', this);
var self = this;
var WT = APP.WT;
var vec3 = WT.glMatrix.vec3;
var mat3 = WT.glMatrix.mat3;
var mat4 = WT.glMatrix.mat4;
this.ctx = null;
// Placeholders for the initializeGL and paintGL functions,
// which will be overwritten by whatever is rendered
this.initializeGL = function() {};
this.paintGL = function() {};
this.resizeGL = function() {};
this.updates = new Array();
this.initialized = false;
this.preloadingTextures = 0;
this.preloadingBuffers = 0;
this.jsValues = [];
this.discoverContext = function(noGLHandler, antialiasingEnabled) {
if (canvas.getContext) {
try {
this.ctx = canvas.getContext('webgl', {antialias: antialiasingEnabled});
} catch (e) {}
if (this.ctx === null) {
try {
this.ctx = canvas.getContext('experimental-webgl', {antialias: antialiasingEnabled});
} catch (e) {}
}
if (this.ctx === null) {
var alternative = canvas.firstChild;
var parentNode = canvas.parentNode;
parentNode.insertBefore(alternative, canvas);
canvas.style.display = 'none';
noGLHandler();
}
}
return this.ctx;
};
if (canvas.addEventListener) {
canvas.addEventListener("webglcontextlost",
function(event) {
event.preventDefault();
self.initialized = false;
}, false);
canvas.addEventListener("webglcontextrestored",
function(event) {
Wt.emit(canvas, 'contextRestored');
}, false);
}
var mouseHandler = null;
this.setMouseHandler = function(newMouseHandler) {
mouseHandler = newMouseHandler;
if (mouseHandler.setTarget) {
mouseHandler.setTarget(this);
}
};
this.LookAtMouseHandler = function(matrix, center, up, pitchRate, yawRate) {
var cameraMatrix = matrix;
var lookAtCenter = center;
var lookAtUpDir = up;
var lookAtPitchRate = pitchRate;
var lookAtYawRate = yawRate;
var pinchWidth = null;
var singleTouch = null;
var doubleTouch = null;
var dragPreviousXY = null;
this.mouseDown = function(o, event) {
WT.capture(null);
WT.capture(canvas);
dragPreviousXY = WT.pageCoordinates(event);
}
this.mouseUp = function(o, event) {
if (dragPreviousXY !== null)
dragPreviousXY = null;
};
this.mouseDrag = function(o, event) {
if (dragPreviousXY === null)
return;
var c = WT.pageCoordinates(event);
if (WT.buttons === 1) {
rotate(c);
}
};
// Mouse wheel = zoom in/out
this.mouseWheel = function(o, event) {
WT.cancelEvent(event);
var d = WT.wheelDelta(event);
zoom(d);
};
function zoom(delta) {
var s = Math.pow(1.2, delta);
mat4.translate(cameraMatrix, lookAtCenter);
mat4.scale(cameraMatrix, [s, s, s]);
vec3.negate(lookAtCenter);
mat4.translate(cameraMatrix, lookAtCenter);
vec3.negate(lookAtCenter);
// Repaint!
self.paintGL();
}
function rotate(newCoords) {
var prevPitchCos = cameraMatrix[5] / vec3.length([cameraMatrix[1], cameraMatrix[5], cameraMatrix[9]]);
var prevPitchSin = cameraMatrix[6] / vec3.length([cameraMatrix[2], cameraMatrix[6], cameraMatrix[10]]);
var prevPitch = Math.atan2(prevPitchSin, prevPitchCos);
var dx=(newCoords.x - dragPreviousXY.x);
var dy=(newCoords.y - dragPreviousXY.y);
var s=vec3.create();
s[0]=cameraMatrix[0];
s[1]=cameraMatrix[4];
s[2]=cameraMatrix[8];
var r=mat4.create();
mat4.identity(r);
mat4.translate(r, lookAtCenter);
var dPitch = dy * lookAtPitchRate;
if (Math.abs(prevPitch + dPitch) >= Math.PI / 2) {
var sign = prevPitch > 0 ? 1 : -1;
dPitch = sign * Math.PI / 2 - prevPitch;
}
mat4.rotate(r, dPitch, s);
mat4.rotate(r, dx * lookAtYawRate, lookAtUpDir);
vec3.negate(lookAtCenter);
mat4.translate(r, lookAtCenter);
vec3.negate(lookAtCenter);
mat4.multiply(cameraMatrix,r,cameraMatrix);
// Repaint!
self.paintGL();
// store mouse coord for next action
dragPreviousXY = newCoords;
};
this.touchStart = function(o, event) {
singleTouch = event.touches.length === 1 ? true : false;
doubleTouch = event.touches.length === 2 ? true : false;
if (singleTouch) {
WT.capture(null);
WT.capture(canvas);
dragPreviousXY = WT.pageCoordinates(event.touches[0]);
} else if (doubleTouch) {
var c0 = WT.pageCoordinates(event.touches[0]);
var c1 = WT.pageCoordinates(event.touches[1]);
pinchWidth = Math.sqrt( (c0.x-c1.x)*(c0.x-c1.x) + (c0.y-c1.y)*(c0.y-c1.y) );
} else {
return;
}
event.preventDefault();
};
this.touchEnd = function(o, event) {
var noTouch = event.touches.length === 0 ? true : false;
singleTouch = event.touches.length === 1 ? true : false;
doubleTouch = event.touches.length === 2 ? true : false;
if (noTouch)
this.mouseUp(null, null);
if (singleTouch || doubleTouch)
this.touchStart(o, event);
};
this.touchMoved = function(o, event) {
if ( (!singleTouch) && (!doubleTouch) )
return;
event.preventDefault();
if (singleTouch)
this.mouseDrag(o, event.touches[0]);
if (doubleTouch) {
var c0 = WT.pageCoordinates(event.touches[0]);
var c1 = WT.pageCoordinates(event.touches[1]);
var d = Math.sqrt( (c0.x-c1.x)*(c0.x-c1.x) + (c0.y-c1.y)*(c0.y-c1.y) );
var scale = d / pinchWidth;
if (Math.abs(scale-1) < 0.05) {
return;
} else if (scale > 1) {
scale = 1;
} else {
scale = -1;
}
pinchWidth = d;
zoom(scale);
}
};
};
this.WalkMouseHandler = function(matrix, frontRate, yawRate) {
var cameraMatrix = matrix;
var walkFrontRate = frontRate;
var walkYawRate = yawRate;
var dragPreviousXY = null;
this.mouseDown = function(o, event) {
WT.capture(null);
WT.capture(canvas);
dragPreviousXY = WT.pageCoordinates(event);
}
this.mouseUp = function(o, event) {
if (dragPreviousXY !== null)
dragPreviousXY = null;
};
this.mouseDrag = function(o, event) {
if (dragPreviousXY === null)
return;
var c = WT.pageCoordinates(event);
walk(c);
};
function walk(newCoords) {
var dx=(newCoords.x - dragPreviousXY.x);
var dy=(newCoords.y - dragPreviousXY.y);
var r=mat4.create();
mat4.identity(r);
mat4.rotateY(r, dx * walkYawRate);
var t=vec3.create();
t[0]=0;
t[1]=0;
t[2]=-walkFrontRate * dy;
mat4.translate(r, t);
mat4.multiply(r, cameraMatrix, cameraMatrix);
self.paintGL();
dragPreviousXY = WT.pageCoordinates(event);
};
};
this.mouseDrag = function(o, event) {
if ((this.initialized || !this.ctx) && mouseHandler && mouseHandler.mouseDrag)
mouseHandler.mouseDrag(o, event);
};
this.mouseMove = function(o, event) {
if ((this.initialized || !this.ctx) && mouseHandler && mouseHandler.mouseMove)
mouseHandler.mouseMove(o, event);
};
this.mouseDown = function(o, event) {
if ((this.initialized || !this.ctx) && mouseHandler && mouseHandler.mouseDown)
mouseHandler.mouseDown(o, event);
};
this.mouseUp = function(o, event) {
if ((this.initialized || !this.ctx) && mouseHandler && mouseHandler.mouseUp)
mouseHandler.mouseUp(o, event);
};
this.mouseWheel = function(o, event) {
if ((this.initialized || !this.ctx) && mouseHandler && mouseHandler.mouseWheel)
mouseHandler.mouseWheel(o, event);
};
this.touchStart = function(o, event) {
if ((this.initialized || !this.ctx) && mouseHandler && mouseHandler.touchStart)
mouseHandler.touchStart(o, event);
};
this.touchEnd = function(o, event) {
if ((this.initialized || !this.ctx) && mouseHandler && mouseWheel.touchEnd)
mouseWheel.touchEnd(o, event);
};
this.touchMoved = function(o, event) {
if ((this.initialized || !this.ctx) && mouseHandler && mouseWheel.touchMoved)
mouseWheel.touchMoved(o, event);
};
// To be called after a load of buffer/texture completes; will
// check if it is safe to render
this.handlePreload = function() {
if (this.preloadingTextures === 0 && this.preloadingBuffers === 0) {
if(this.initialized){
var key;
// execute all updates scheduled in o.updates
for(key in this.updates) this.updates[key]();
this.updates = new Array();
// Delay calling of resizeGL() to after updates are executed
this.resizeGL();
this.paintGL();
} else {
// initializeGL will call updates and resizeGL
this.initializeGL();
this.resizeGL();
this.paintGL();
}
} else {
// still waiting for data to arrive...
}
};
function encodeJSValues() {
var obj = jQuery.data(canvas, 'obj');
var str = '';
for (var index=0; index < obj.jsValues.length; index++) {
str += index + ':';
for (var i=0; i < obj.jsValues[index].length; i++) {
str += obj.jsValues[index][i];
if (i !== obj.jsValues[index].length - 1) {
str += ',';
} else {
str += ';';
}
}
}
return str;
}
canvas.wtEncodeValue = encodeJSValues;
// For server-side rendering: avoid that image loads are aborted because
// URL is changed too quickly (before image is fully loaded)
var nextImage = null;
var loader = new Image();
loader.busy = false;
loader.onload = function() {
canvas.src = loader.src;
if (nextImage != null) {
loader.src = nextImage;
} else {
loader.busy = false;
}
nextImage = null;
};
loader.onerror = loader.onload;
this.loadImage = function(url) {
if (loader.busy) {
nextImage = url;
} else {
loader.src = url;
loader.busy = true;
}
}
});
witty-3.3.4+dfsg.orig/src/js/WPopupWidget.js 0000644 0001750 0001750 00000004364 12426236651 021200 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WPopupWidget",
function(APP, el, tr, ahd, shown) {
jQuery.data(el, 'popup', this);
var self = this,
WT = APP.WT,
hideTimeout = null,
isTransient = tr,
autoHideDelay = ahd,
showF = null, hideF = null;
function mouseLeave() {
clearTimeout(hideTimeout);
if (autoHideDelay > 0)
hideTimeout = setTimeout(function() { self.hide(); }, autoHideDelay);
}
function mouseEnter() {
clearTimeout(hideTimeout);
}
function isHidden() {
return el.style.display == 'hidden';
}
function onDocumentClick(event) {
function isAncestor(a, b) {
for (b = b.parentNode; b; b = b.parentNode)
if (a == b)
return true;
return false;
}
if (WT.target(event) == document && WT.WPopupWidget.popupClicked == el)
return;
if (!isAncestor(el, WT.target(event)))
self.hide();
}
this.bindShow = function(f) {
showF = f;
};
this.bindHide = function(f) {
hideF = f;
};
this.shown = function(f) {
if (isTransient) {
setTimeout(function() {
$(document).bind('click', onDocumentClick);
}, 0);
}
if (showF) showF();
};
this.show = function(anchorWidget, side) {
if (el.style.display != '') {
el.style.display = '';
if (anchorWidget)
WT.positionAtWidget(el.id, anchorWidget.id, side);
APP.emit(el, "shown");
}
};
this.hidden = function() {
if (hideF) hideF();
if (isTransient)
$(document).unbind('click', onDocumentClick);
};
this.hide = function() {
if (el.style.display != 'none') {
el.style.display = 'none';
}
APP.emit(el, "hidden");
self.hidden();
};
this.setTransient = function(t, delay) {
isTransient = t;
autoHideDelay = delay;
if (isTransient && !isHidden())
setTimeout(function() {
$(document).bind('click', onDocumentClick);
}, 0);
};
$(el).mouseleave(mouseLeave).mouseenter(mouseEnter);
if (shown)
this.shown();
});
witty-3.3.4+dfsg.orig/src/js/WPopupMenu.js 0000644 0001750 0001750 00000010535 12420210325 020636 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
/* Note: this is at the same time valid JavaScript and C++. */
WT_DECLARE_WT_MEMBER
(1, JavaScriptConstructor, "WPopupMenu",
function(APP, el, autoHideDelay) {
jQuery.data(el, 'obj', this);
var self = this,
WT = APP.WT,
hideTimeout = null,
entered = false,
current = null;
function doHide() {
setOthersInactive(el, null);
el.style.display = 'none';
APP.emit(el.id, 'cancel');
}
function setActive(item, active) {
$(item).toggleClass("active", active);
}
function submenu(item) {
if (item.subMenu)
return item.subMenu;
else {
var u = item.lastChild;
if (u && WT.hasTag(u, "UL")) {
item.subMenu = u;
u.parentItem = item;
$(u).mousemove(handleSubMenus);
bindOverEvents(u);
return u;
} else
return null;
}
}
function showSubmenu(menu) {
menu.style.display='block';
if (menu.parentNode == menu.parentItem) {
menu.parentNode.removeChild(menu);
el.parentNode.appendChild(menu);
}
/*
* we actually want to align the first item, so we need to adjust
* for the menu padding and border
*/
var margin = WT.px(menu, 'paddingTop') + WT.px(menu, 'borderTopWidth')
WT.positionAtWidget(menu.id, menu.parentItem.id, WT.Horizontal, -margin);
setOthersInactive(menu, null);
}
function setOthersInactive(topLevelMenu, activeItem) {
function itemLeadsTo(item1, item2) {
if (item1 == item2)
return true;
else if (item2) {
var parent = item2.parentNode.parentItem;
if (parent)
return itemLeadsTo(item1, parent);
else
return false;
} else
return false;
}
function processMenu(menu) {
var i, il;
for (i = 0, il = menu.childNodes.length; i < il; ++i) {
var item = menu.childNodes[i];
if (!itemLeadsTo(item, activeItem)) {
setActive(item, false);
var sm = submenu(item);
if (sm) {
sm.style.display = 'none';
processMenu(sm);
}
} else if (item !== activeItem) {
var sm = submenu(item);
if (sm)
processMenu(sm);
}
}
}
processMenu(topLevelMenu);
}
function handleSubMenus(e) {
/*
* If mouse is over an item that has a sub menu, then show the sub menu
* if it is not already shown
*/
var item = WT.target(e);
while (item && !WT.hasTag(item, "LI") && !WT.hasTag(item, "UL"))
item = item.parentNode;
if (WT.hasTag(item, "LI")) {
if (item === current)
return;
current = item;
setActive(item, true);
var menu = submenu(item);
if (menu)
showSubmenu(menu);
/*
* collapse all submenus not leading to this item
*/
setOthersInactive(el, item);
}
}
function mouseLeave() {
entered = false;
clearTimeout(hideTimeout);
if (autoHideDelay >= 0)
hideTimeout = setTimeout(doHide, autoHideDelay);
}
function mouseEnter() {
entered = true;
clearTimeout(hideTimeout);
}
function bindOverEvents(popup) {
$(popup).mouseleave(mouseLeave).mouseenter(mouseEnter);
}
function onDocumentDown(event) {
if (WT.button(event) != 1)
doHide();
}
function onDocumentClick(event) {
doHide();
}
function onDocumentKeyDown(event) {
if (event.keyCode == 27)
doHide();
}
this.setHidden = function(hidden) {
if (hideTimeout) {
clearTimeout(hideTimeout);
hideTimeout = null;
}
entered = false;
current = null;
if (hidden) {
el.style.position = '';
el.style.display = '';
el.style.left = '';
el.style.top = '';
$(document).unbind('mousedown', onDocumentDown);
$(document).unbind('click', onDocumentClick);
$(document).unbind('keydown', onDocumentKeyDown);
} else {
setTimeout(function() {
$(document).bind('mousedown', onDocumentDown);
$(document).bind('click', onDocumentClick);
$(document).bind('keydown', onDocumentKeyDown);
}, 0);
el.style.display = 'block';
}
setOthersInactive(el, null);
};
this.popupAt = function(widget) {
bindOverEvents(widget);
};
setTimeout(function() { bindOverEvents(el); }, 0);
$(el).mousemove(handleSubMenus);
});
witty-3.3.4+dfsg.orig/src/CMakeLists.txt 0000644 0001750 0001750 00000033054 12475324032 020361 0 ustar pgquiles pgquiles SUBDIRS(web Wt)
INCLUDE_DIRECTORIES(
${CMAKE_CURRENT_SOURCE_DIR}/web
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_BINARY_DIR} # for WConfig.h
${BOOST_INCLUDE_DIRS}
Wt/Dbo/backend/amalgamation # for sqlite3.h
)
LINK_DIRECTORIES(${BOOST_LIB_DIRS})
MACRO (FILE_TO_STRING infile outfile var)
ADD_CUSTOM_COMMAND(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${outfile}
COMMAND ${CMAKE_COMMAND}
ARGS -Dinfile:FILEPATH=${CMAKE_CURRENT_SOURCE_DIR}/${infile}
-Doutfile:FILEPATH=${CMAKE_CURRENT_BINARY_DIR}/${outfile}
-Dvar:STRING=${var}
-P ${CMAKE_CURRENT_SOURCE_DIR}/filetostring.cmake
MAIN_DEPENDENCY
${CMAKE_CURRENT_SOURCE_DIR}/${infile}
)
ENDMACRO (FILE_TO_STRING)
FILE_TO_STRING(web/skeleton/Plain.html Plain_html.C Plain_html)
FILE_TO_STRING(web/skeleton/Hybrid.html Hybrid_html.C Hybrid_html)
FILE_TO_STRING(web/skeleton/Boot.html Boot_html.C Boot_html)
IF(CMAKE_BUILD_TYPE STREQUAL "Debug")
FILE_TO_STRING(web/skeleton/Wt.js Wt_js.C Wt_js)
ELSE(CMAKE_BUILD_TYPE STREQUAL "Debug")
FILE_TO_STRING(web/skeleton/Wt.min.js Wt_js.C Wt_js)
ENDIF(CMAKE_BUILD_TYPE STREQUAL "Debug")
IF(CMAKE_BUILD_TYPE STREQUAL "Debug")
FILE_TO_STRING(web/skeleton/Boot.js Boot_js.C Boot_js)
ELSE(CMAKE_BUILD_TYPE STREQUAL "Debug")
FILE_TO_STRING(web/skeleton/Boot.min.js Boot_js.C Boot_js)
ENDIF(CMAKE_BUILD_TYPE STREQUAL "Debug")
FILE_TO_STRING(web/skeleton/jquery.min.js JQuery_js.C JQuery_js)
FILE_TO_STRING(xml/wt.xml Wt_xml.C Wt_xml)
FILE_TO_STRING(xml/auth_strings.xml AuthStrings_xml.C AuthStrings_xml)
FILE_TO_STRING(xml/bootstrap_theme.xml
BootstrapTheme_xml.C BootstrapTheme_xml)
FILE_TO_STRING(xml/bootstrap3_theme.xml
Bootstrap3Theme_xml.C Bootstrap3Theme_xml)
FILE_TO_STRING(xml/auth_css_theme.xml
AuthCssTheme_xml.C AuthCssTheme_xml)
SET(libsources
Wt/PopupWindow.C
Wt/Resizable.C
Wt/ServerSideFontMetrics.C
Wt/SizeHandle.C
Wt/StdGridLayoutImpl2.C
Wt/StdLayoutImpl.C
Wt/StdLayoutItemImpl.C
Wt/StdWidgetItemImpl.C
Wt/Utils.C
Wt/WAbstractArea.C
Wt/WAbstractItemDelegate.C
Wt/WAbstractItemModel.C
Wt/WAbstractItemView.C
Wt/WAbstractListModel.C
Wt/WAbstractMedia.C
Wt/WAbstractProxyModel.C
Wt/WAbstractSpinBox.C
Wt/WAbstractTableModel.C
Wt/WAbstractToggleButton.C
Wt/WAccordionLayout.C
Wt/WAggregateProxyModel.C
Wt/WAnchor.C
Wt/WAnimation.C
Wt/WApplication.C
Wt/WAudio.C
Wt/WBatchEditProxyModel.C
Wt/WBoostAny.C
Wt/WBootstrapTheme.C
Wt/WBorder.C
Wt/WBorderLayout.C
Wt/WBoxLayout.C
Wt/WBreak.C
Wt/WBrush.C
Wt/WButtonGroup.C
Wt/WCalendar.C
Wt/WCanvasPaintDevice.C
Wt/WCheckBox.C
Wt/WCircleArea.C
Wt/WColor.C
Wt/WCombinedLocalizedStrings.C
Wt/WComboBox.C
Wt/WCompositeWidget.C
Wt/WContainerWidget.C
Wt/WCssDecorationStyle.C
Wt/WCssStyleSheet.C
Wt/WCssTheme.C
Wt/WDate.C
Wt/WDateEdit.C
Wt/WDatePicker.C
Wt/WDateTime.C
Wt/WDateValidator.C
Wt/WDefaultLayout.C
Wt/WDefaultLoadingIndicator.C
Wt/WDialog.C
Wt/WDoubleSpinBox.C
Wt/WDoubleValidator.C
Wt/WEnvironment.C
Wt/WEvent.C
Wt/WException.C
Wt/WFileResource.C
Wt/WFileUpload.C
Wt/WFitLayout.C
Wt/WFlashObject.C
Wt/WFont.C
Wt/WFontMetrics.C
Wt/WFormModel.C
Wt/WFormWidget.C
Wt/WGLWidget.C
Wt/WAbstractGLImplementation.C
Wt/WClientGLWidget.C
Wt/WGoogleMap.C
Wt/WGradient.C
Wt/WGridLayout.C
Wt/WGroupBox.C
Wt/WHBoxLayout.C
Wt/WIcon.C
Wt/WIconPair.C
Wt/WImage.C
Wt/WInPlaceEdit.C
Wt/WIntValidator.C
Wt/WInteractWidget.C
Wt/WIOService.C
Wt/WLocale.C
Wt/WLocalDateTime.C
Wt/WIdentityProxyModel.C
Wt/WItemDelegate.C
Wt/WItemSelectionModel.C
Wt/WJavaScript.C
Wt/WJavaScriptPreamble.C
Wt/WJavaScriptSlot.C
Wt/WLabel.C
Wt/WLayout.C
Wt/WLayoutItem.C
Wt/WLayoutItemImpl.C
Wt/WLength.C
Wt/WLengthValidator.C
Wt/WLineEdit.C
Wt/WLineF.C
Wt/WLink.C
Wt/WLoadingIndicator.C
Wt/WLocalizedStrings.C
Wt/WLogger.C
Wt/WMatrix4x4.C
Wt/WMeasurePaintDevice.C
Wt/WMediaPlayer.C
Wt/WMemoryResource.C
Wt/WMenu.C
Wt/WMenuItem.C
Wt/WMessageBox.C
Wt/WMessageResourceBundle.C
Wt/WMessageResources.C
Wt/WModelIndex.C
Wt/WNavigationBar.C
Wt/WObject.C
Wt/WOverlayLoadingIndicator.C
Wt/WPaintDevice.C
Wt/WPaintedWidget.C
Wt/WPainter.C
Wt/WPainterPath.C
Wt/WPanel.C
Wt/WPen.C
Wt/WPoint.C
Wt/WPointF.C
Wt/WPolygonArea.C
Wt/WPopupMenu.C
Wt/WPopupWidget.C
Wt/WProgressBar.C
Wt/WPushButton.C
Wt/WRadioButton.C
Wt/WRandom.C
Wt/WReadOnlyProxyModel.C
Wt/WRectArea.C
Wt/WRectF.C
Wt/WRegExp.C
Wt/WRegExpValidator.C
Wt/WResource.C
Wt/WScrollArea.C
Wt/WScrollBar.C
Wt/WSelectionBox.C
Wt/WServer.C
Wt/WShadow.C
Wt/WSignal.C
Wt/WSlider.C
Wt/WSocketNotifier.C
Wt/WSortFilterProxyModel.C
Wt/WSpinBox.C
Wt/WSplitButton.C
Wt/WSound.C
Wt/WSslCertificate.C
Wt/WSslInfo.C
Wt/WStackedWidget.C
Wt/WStandardItem.C
Wt/WStandardItemModel.C
Wt/WStatelessSlot.C
Wt/WString.C
Wt/WStreamResource.C
Wt/WStringListModel.C
Wt/WStringStream.C
Wt/WStringUtil.C
Wt/WSuggestionPopup.C
Wt/WSvgImage.C
Wt/WTabWidget.C
Wt/WTable.C
Wt/WTableCell.C
Wt/WTableColumn.C
Wt/WTableRow.C
Wt/WTemplate.C
Wt/WTemplateFormView.C
Wt/WTableView.C
Wt/WText.C
Wt/WTextArea.C
Wt/WTextEdit.C
Wt/WTheme.C
Wt/WTime.C
Wt/WTimeEdit.C
Wt/WTimer.C
Wt/WTimerWidget.C
Wt/WTimePicker.C
Wt/WTimeValidator.C
Wt/WToolBar.C
Wt/WTransform.C
Wt/WTree.C
Wt/WTreeNode.C
Wt/WTreeTable.C
Wt/WTreeTableNode.C
Wt/WTreeView.C
Wt/WValidationStatus.C
Wt/WValidator.C
Wt/WVBoxLayout.C
Wt/WVector3.C
Wt/WVector4.C
Wt/WVectorImage.C
Wt/WVideo.C
Wt/WVmlImage.C
Wt/WViewWidget.C
Wt/WVirtualImage.C
Wt/WWebWidget.C
Wt/WWidget.C
Wt/WWidgetItem.C
Wt/Auth/AbstractPasswordService.C
Wt/Auth/AbstractUserDatabase.C
Wt/Auth/AuthModel.C
Wt/Auth/AuthService.C
Wt/Auth/AuthWidget.C
Wt/Auth/FacebookService.C
Wt/Auth/FormBaseModel.C
Wt/Auth/GoogleService.C
Wt/Auth/HashFunction.C
Wt/Auth/Identity.C
Wt/Auth/Login.C
Wt/Auth/LostPasswordWidget.C
Wt/Auth/OAuthService.C
Wt/Auth/passwdqc_check.c
Wt/Auth/PasswordHash.C
Wt/Auth/PasswordPromptDialog.C
Wt/Auth/PasswordService.C
Wt/Auth/PasswordStrengthValidator.C
Wt/Auth/PasswordVerifier.C
Wt/Auth/RegistrationModel.C
Wt/Auth/RegistrationWidget.C
Wt/Auth/Token.C
Wt/Auth/UpdatePasswordWidget.C
Wt/Auth/User.C
Wt/Auth/AuthUtils.C
Wt/Auth/MailUtils.C
Wt/Chart/WAbstractChart.C
Wt/Chart/WAxis.C
Wt/Chart/WDataSeries.C
Wt/Chart/WPieChart.C
Wt/Chart/WCartesianChart.C
Wt/Chart/WCartesian3DChart.C
Wt/Chart/WAbstractChartImplementation.C
Wt/Chart/WChart2DImplementation.C
Wt/Chart/WChart3DImplementation.C
Wt/Chart/WChartPalette.C
Wt/Chart/WStandardPalette.C
Wt/Chart/WStandardColorMap.C
Wt/Chart/WLegend.C
Wt/Chart/WLegend3D.C
Wt/Chart/WAbstractDataSeries3D.C
Wt/Chart/WAbstractGridData.C
Wt/Chart/WGridData.C
Wt/Chart/WEquidistantGridData.C
Wt/Chart/WScatterData.C
Wt/Chart/WSelection.C
Wt/Json/Array.C
Wt/Json/Object.C
Wt/Json/Parser.C
Wt/Json/Serializer.C
Wt/Json/Value.C
Wt/Http/HttpUtils.C
Wt/Http/Client.C
Wt/Http/Message.C
Wt/Http/Request.C
Wt/Http/Response.C
Wt/Http/ResponseContinuation.C
Wt/Http/WtClient.C
Wt/Mail/Client.C
Wt/Mail/Mailbox.C
Wt/Mail/Message.C
Wt/Payment/Address.C
Wt/Payment/PayPal.C
Wt/Payment/Customer.C
Wt/Payment/Money.C
Wt/Payment/Order.C
Wt/Payment/OrderItem.C
Wt/Payment/Result.C
Wt/Render/Block.C
Wt/Render/CssData.C
Wt/Render/CssData_p.C
Wt/Render/CssParser.C
Wt/Render/Line.C
Wt/Render/LayoutBox.C
Wt/Render/RenderUtils.C
Wt/Render/Specificity.C
Wt/Render/WTextRenderer.C
web/md5.c
web/sha1.c
web/CgiParser.C
web/Configuration.C
web/DomElement.C
web/EscapeOStream.C
web/FileServe.C
web/ColorUtils.C
web/ImageUtils.C
web/RefEncoder.C
web/SoundManager.C
web/WebController.C
web/WebMain.C
web/WebRequest.C
web/WebStream.C
web/WebSession.C
web/WebSocketMessage.C
web/WebRenderer.C
web/WebUtils.C
web/FileUtils.C
web/PdfUtils.C
web/TimeUtil.C
web/XSSFilter.C
web/XSSUtils.C
web/SslUtils.C
web/UriUtils.C
web/random_device.cpp
web/base64.cpp
Plain_html.C
Boot_html.C
Hybrid_html.C
Boot_js.C
Wt_js.C
Wt_xml.C
AuthStrings_xml.C
BootstrapTheme_xml.C
Bootstrap3Theme_xml.C
AuthCssTheme_xml.C
JQuery_js.C
)
ADD_DEFINITIONS(-DWT_BUILDING)
IF (MULTI_THREADED_BUILD)
SET(libsources ${libsources} web/SocketNotifier.C)
ENDIF(MULTI_THREADED_BUILD)
# How to include x86.S ?
SET(libsources ${libsources}
Wt/Auth/bcrypt/crypt_blowfish.c
Wt/Auth/bcrypt/crypt_gensalt.c
Wt/Auth/bcrypt/wrapper.c)
IF(HAVE_HARU)
SET(libsources ${libsources} Wt/WPdfImage.C Wt/Render/WPdfRenderer.C)
SET(BOOST_WT_LIBRARIES ${BOOST_WT_LIBRARIES} ${BOOST_FS_LIB})
ADD_DEFINITIONS(-DHAVE_PDF_IMAGE)
ENDIF(HAVE_HARU)
IF("${WT_WRASTERIMAGE_IMPLEMENTATION}" STREQUAL "GraphicsMagick")
SET(libsources ${libsources} Wt/WRasterImage-gm.C)
ELSEIF("${WT_WRASTERIMAGE_IMPLEMENTATION}" STREQUAL "skia")
SET(libsources ${libsources} Wt/WRasterImage-skia.C)
ENDIF("${WT_WRASTERIMAGE_IMPLEMENTATION}" STREQUAL "GraphicsMagick")
IF(HAVE_GL)
SET(libsources ${libsources} Wt/WServerGLWidget.C)
IF(NOT USE_SYSTEM_GLEW)
ADD_DEFINITIONS(-DGLEW_STATIC)
SET(libsources
${libsources}
3rdparty/glew-1.10.0/src/glew.c
)
ENDIF(NOT USE_SYSTEM_GLEW)
ENDIF(HAVE_GL)
IF(HAVE_HARU OR "${WT_WRASTERIMAGE_IMPLEMENTATION}" STREQUAL "GraphicsMagick")
IF(HAVE_PANGO)
SET(libsources ${libsources} Wt/FontSupportPango.C)
ELSE(HAVE_PANGO)
SET(libsources ${libsources} Wt/FontSupportSimple.C)
ENDIF(HAVE_PANGO)
ELSE(HAVE_HARU OR "${WT_WRASTERIMAGE_IMPLEMENTATION}" STREQUAL "GraphicsMagick")
SET(HAVE_PANGO false) # font support is not needed
ENDIF(HAVE_HARU OR "${WT_WRASTERIMAGE_IMPLEMENTATION}" STREQUAL "GraphicsMagick")
# check if we need -lrt, used in boost::chrone::steady_clock::now()
SET(RT_test_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/rt.c")
FILE(WRITE
"${RT_test_fname}"
"#include \nint main() { struct timespec time1; clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time1); return 0; }"
)
TRY_COMPILE(RT_required
"${CMAKE_BINARY_DIR}" "${RT_test_fname}"
CMAKE_FLAGS
-DLINK_LIBRARIES:STRING=rt
)
IF(RT_required)
SET(RT_LIBRARY "rt")
ENDIF(RT_required)
IF(WIN32)
IF(SHARED_LIBS)
CONFIGURE_FILE(Wt/wt-version.rc.in
${CMAKE_CURRENT_BINARY_DIR}/wt-version.rc)
SET(libsources ${libsources} ${CMAKE_CURRENT_BINARY_DIR}/wt-version.rc)
ENDIF(SHARED_LIBS)
ENDIF(WIN32)
ADD_LIBRARY(wt ${libsources})
TARGET_LINK_LIBRARIES(wt
${BOOST_WT_LIBRARIES}
${WT_SOCKET_LIBRARY}
${WT_MATH_LIBRARY}
${RT_LIBRARY}
)
IF(ENABLE_LIBWTTEST)
ADD_LIBRARY(wttest
Wt/Test/WTestEnvironment.C
)
TARGET_LINK_LIBRARIES(wttest wt)
INSTALL(TARGETS wttest
RUNTIME DESTINATION bin
LIBRARY DESTINATION ${LIB_INSTALL_DIR}
ARCHIVE DESTINATION ${LIB_INSTALL_DIR})
IF(MSVC)
SET_TARGET_PROPERTIES(wttest PROPERTIES COMPILE_FLAGS "${BUILD_PARALLEL} /wd4251 /wd4275 /wd4355 /wd4800 /wd4996 /wd4101 /wd4267")
ENDIF(MSVC)
SET_TARGET_PROPERTIES(
wttest
PROPERTIES
VERSION ${VERSION_SERIES}.${VERSION_MAJOR}.${VERSION_MINOR}
SOVERSION ${WTTEST_SOVERSION}
DEBUG_POSTFIX ${DEBUG_LIB_POSTFIX}
)
ELSE(ENABLE_LIBWTTEST)
MESSAGE("** Not building libwttest")
ENDIF(ENABLE_LIBWTTEST)
IF(HAVE_SSL)
TARGET_LINK_LIBRARIES(wt ${SSL_LIBRARIES})
INCLUDE_DIRECTORIES(${SSL_INCLUDE_DIRS})
ELSE(HAVE_SSL)
MESSAGE("** Disabling crypto support (Auth::SHA1HashFunction, HTTPS support): requires OpenSSL.")
IF(ENABLE_SSL)
MESSAGE(" Indicate the location of your OpenSSL library using -DSSL_PREFIX=...")
ENDIF(ENABLE_SSL)
ENDIF(HAVE_SSL)
IF(HAVE_HARU)
TARGET_LINK_LIBRARIES(wt ${HARU_LIBRARIES})
INCLUDE_DIRECTORIES(${HARU_INCLUDE_DIRS})
ELSE(HAVE_HARU)
MESSAGE("** Disabling PDF support (WPdfImage, WPdfRenderer): requires libharu.")
IF(ENABLE_HARU)
MESSAGE(" Indicate the location of your haru library using -DHARU_PREFIX=...")
ENDIF(ENABLE_HARU)
ENDIF(HAVE_HARU)
IF("${WT_WRASTERIMAGE_IMPLEMENTATION}" STREQUAL "GraphicsMagick")
TARGET_LINK_LIBRARIES(wt ${GM_LIBRARIES})
INCLUDE_DIRECTORIES(${GM_INCLUDE_DIRS})
ADD_DEFINITIONS(-DHAVE_GRAPHICSMAGICK)
ELSEIF("${WT_WRASTERIMAGE_IMPLEMENTATION}" STREQUAL "skia")
TARGET_LINK_LIBRARIES(wt ${SKIA_LIBRARIES})
INCLUDE_DIRECTORIES(${SKIA_INCLUDE_DIRS})
ADD_DEFINITIONS(${SKIA_DEFINES})
ELSE("${WT_WRASTERIMAGE_IMPLEMENTATION}" STREQUAL "GraphicsMagick")
MESSAGE("** Disabling raster image support (WRasterImage): set WT_WRASTERIMAGE_IMPLEMENTATION to GraphicsMagick or skia.")
ENDIF("${WT_WRASTERIMAGE_IMPLEMENTATION}" STREQUAL "GraphicsMagick")
IF(HAVE_GL)
INCLUDE_DIRECTORIES(${GL_INCLUDE_DIRS})
IF(USE_SYSTEM_GLEW)
TARGET_LINK_LIBRARIES(wt GLEW)
ENDIF(USE_SYSTEM_GLEW)
TARGET_LINK_LIBRARIES(wt ${GL_LIBRARIES})
ELSE(HAVE_GL)
MESSAGE("** Disabling server-side opengl rendering for WGLWidget: requires gl, glew and WRasterImage (GraphicsMagick or skia).")
ENDIF(HAVE_GL)
IF(HAVE_PANGO)
TARGET_LINK_LIBRARIES(wt ${PANGO_FT2_LIBRARIES})
INCLUDE_DIRECTORIES(${PANGO_FT2_INCLUDE_DIRS})
ADD_DEFINITIONS(-DHAVE_PANGO)
MESSAGE("** Enabling advanced font support using libpango")
ELSE(HAVE_PANGO)
MESSAGE("** Disabling advanced font rendering support: requires libpango.")
IF(ENABLE_PANGO)
MESSAGE(" Wt will use pkg-config to retrieve your libpango installation location.")
ENDIF(ENABLE_PANGO)
ENDIF(HAVE_PANGO)
IF(MULTI_THREADED_BUILD)
TARGET_LINK_LIBRARIES(wt ${CMAKE_THREAD_LIBS_INIT})
ENDIF(MULTI_THREADED_BUILD)
INSTALL(TARGETS wt
RUNTIME DESTINATION bin
LIBRARY DESTINATION ${LIB_INSTALL_DIR}
ARCHIVE DESTINATION ${LIB_INSTALL_DIR})
CONFIGURE_FILE(
${WT_SOURCE_DIR}/WtInstall.cmake
${WT_BINARY_DIR}/WtInstall.cmake
)
SET_TARGET_PROPERTIES(
wt
PROPERTIES
POST_INSTALL_SCRIPT ${WT_BINARY_DIR}/WtInstall.cmake
VERSION ${VERSION_SERIES}.${VERSION_MAJOR}.${VERSION_MINOR}
SOVERSION ${WT_SOVERSION}
DEBUG_POSTFIX ${DEBUG_LIB_POSTFIX}
)
IF(MSVC)
SET_TARGET_PROPERTIES(wt PROPERTIES COMPILE_FLAGS "${BUILD_PARALLEL} /wd4251 /wd4275 /wd4355 /wd4800 /wd4996 /wd4101 /wd4267")
TARGET_LINK_LIBRARIES(wt winmm)
ENDIF(MSVC)
SUBDIRS(isapi fcgi http)
witty-3.3.4+dfsg.orig/src/web/ 0000775 0001750 0001750 00000000000 12510340013 016356 5 ustar pgquiles pgquiles witty-3.3.4+dfsg.orig/src/web/TimeUtil.C 0000644 0001750 0001750 00000004711 12222311752 020227 0 ustar pgquiles pgquiles #include "TimeUtil.h"
#include
#if BOOST_VERSION >= 104700
// Define below to avoid linking to boost.chrono library
#define BOOST_CHRONO_HEADER_ONLY
#include
#endif
#ifndef BOOST_CHRONO_HAS_CLOCK_STEADY
#ifdef _MSC_VER
#include "winsock2.h"
#pragma comment (lib, "winmm.lib")
namespace {
#include
int gettimeofday(struct timeval* tp, void* tzp)
{
DWORD t;
t = timeGetTime();
tp->tv_sec = t / 1000;
tp->tv_usec = t % 1000;
return 0;
}
// Next line is to make std::max operational again after loading windows.h
#undef max
}
#else
#include
#include
#endif
#endif
namespace Wt {
#ifndef BOOST_CHRONO_HAS_CLOCK_STEADY
class TimeImpl {
public:
struct timeval tv;
};
Time::Time()
{
t_ = new TimeImpl;
gettimeofday(&t_->tv, 0);
}
Time::Time(const Time &other)
{
t_ = new TimeImpl;
memcpy(&t_->tv, &other.t_->tv, sizeof(timeval));
}
Time::~Time()
{
delete t_;
t_ = 0;
}
Time& Time::operator+= (int msec)
{
t_->tv.tv_sec += (msec / 1000);
msec %= 1000;
t_->tv.tv_usec += (msec * 1000);
t_->tv.tv_sec += (t_->tv.tv_usec / 1000000);
t_->tv.tv_usec %= 1000000;
return *this;
}
Time& Time::operator= (const Time &other)
{
if(&other != this) {
memcpy(&t_->tv, &other.t_->tv, sizeof(timeval));
}
return *this;
}
Time Time::operator+ (int msec) const
{
Time result(*this);
result += msec;
return result;
}
int Time::operator- (const Time& other) const
{
int diffsec = t_->tv.tv_sec - other.t_->tv.tv_sec;
int diffmsec = (t_->tv.tv_usec - other.t_->tv.tv_usec) / 1000;
if (diffmsec < 0) {
diffsec -= 1;
diffmsec += 1000;
}
return diffsec * 1000 + diffmsec;
}
#else
class TimeImpl {
public:
boost::chrono::steady_clock::time_point tp;
};
Time::Time()
{
t_ = new TimeImpl;
t_->tp = boost::chrono::steady_clock::now();
}
Time::Time(const Time &other)
{
t_ = new TimeImpl;
t_->tp = other.t_->tp;
}
Time::~Time()
{
delete t_;
t_ = 0;
}
Time& Time::operator+= (int msec)
{
t_->tp += boost::chrono::milliseconds(msec);
return *this;
}
Time& Time::operator= (const Time &other)
{
t_->tp = other.t_->tp;
return *this;
}
Time Time::operator+ (int msec) const
{
Time result(*this);
result += msec;
return result;
}
int Time::operator- (const Time& other) const
{
boost::chrono::milliseconds m =
boost::chrono::duration_cast
(t_->tp - other.t_->tp);
return m.count();
}
#endif
}
witty-3.3.4+dfsg.orig/src/web/md5.h 0000644 0001750 0001750 00000006511 11715747045 017243 0 ustar pgquiles pgquiles /*
Copyright (C) 1999, 2002 Aladdin Enterprises. All rights reserved.
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
L. Peter Deutsch
ghost@aladdin.com
*/
/* $Id: md5.h,v 1.4 2002/04/13 19:20:28 lpd Exp $ */
/*
Independent implementation of MD5 (RFC 1321).
This code implements the MD5 Algorithm defined in RFC 1321, whose
text is available at
http://www.ietf.org/rfc/rfc1321.txt
The code is derived from the text of the RFC, including the test suite
(section A.5) but excluding the rest of Appendix A. It does not include
any code or documentation that is identified in the RFC as being
copyrighted.
The original and principal author of md5.h is L. Peter Deutsch
. Other authors are noted in the change history
that follows (in reverse chronological order):
2002-04-13 lpd Removed support for non-ANSI compilers; removed
references to Ghostscript; clarified derivation from RFC 1321;
now handles byte order either statically or dynamically.
1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
added conditionalization for C++ compilation from Martin
Purschke .
1999-05-03 lpd Original version.
*/
#ifndef md5_INCLUDED
# define md5_INCLUDED
/*
* This package supports both compile-time and run-time determination of CPU
* byte order. If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be
* compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is
* defined as non-zero, the code will be compiled to run only on big-endian
* CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to
* run on either big- or little-endian CPUs, but will run slightly less
* efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined.
*/
typedef unsigned char md5_byte_t; /* 8-bit byte */
typedef unsigned int md5_word_t; /* 32-bit word */
/* Define the state of the MD5 Algorithm. */
typedef struct md5_state_s {
md5_word_t count[2]; /* message length in bits, lsw first */
md5_word_t abcd[4]; /* digest buffer */
md5_byte_t buf[64]; /* accumulate block */
} md5_state_t;
#ifdef __cplusplus
extern "C"
{
#endif
/* Initialize the algorithm. */
void wt_md5_init(md5_state_t *pms);
/* Append a string to the message. */
void wt_md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes);
/* Finish the message and return the digest. */
void wt_md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
#ifdef __cplusplus
} /* end extern "C" */
#endif
#endif /* md5_INCLUDED */
witty-3.3.4+dfsg.orig/src/web/sha1.h 0000755 0001750 0001750 00000004302 11715747045 017411 0 ustar pgquiles pgquiles /*
* sha1.h
*
* Copyright (C) 1998, 2009
* Paul E. Jones
* All Rights Reserved
*
* Freeware Public License (FPL)
*
* This software is licensed as "freeware." Permission to distribute
* this software in source and binary forms, including incorporation
* into other products, is hereby granted without a fee. THIS SOFTWARE
* IS PROVIDED 'AS IS' AND WITHOUT ANY EXPRESSED OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHOR SHALL NOT BE HELD
* LIABLE FOR ANY DAMAGES RESULTING FROM THE USE OF THIS SOFTWARE, EITHER
* DIRECTLY OR INDIRECTLY, INCLUDING, BUT NOT LIMITED TO, LOSS OF DATA
* OR DATA BEING RENDERED INACCURATE.
*
*****************************************************************************
* $Id: sha1.h 12 2009-06-22 19:34:25Z paulej $
*****************************************************************************
*
* Description:
* This class implements the Secure Hashing Standard as defined
* in FIPS PUB 180-1 published April 17, 1995.
*
* Many of the variable names in the SHA1Context, especially the
* single character names, were used because those were the names
* used in the publication.
*
* Please read the file sha1.c for more information.
*
*/
#ifndef _SHA1_H_
#define _SHA1_H_
/*
* This structure will hold context information for the hashing
* operation
*/
typedef struct SHA1Context
{
unsigned Message_Digest[5]; /* Message Digest (output) */
unsigned Length_Low; /* Message length in bits */
unsigned Length_High; /* Message length in bits */
unsigned char Message_Block[64]; /* 512-bit message blocks */
int Message_Block_Index; /* Index into message block array */
int Computed; /* Is the digest computed? */
int Corrupted; /* Is the message digest corruped? */
} SHA1Context;
/*
* Function Prototypes
*/
void wt_SHA1Reset(SHA1Context *);
int wt_SHA1Result(SHA1Context *);
void wt_SHA1Input( SHA1Context *,
const unsigned char *,
unsigned);
#endif
witty-3.3.4+dfsg.orig/src/web/sha1.c 0000755 0001750 0001750 00000025452 11715747045 017415 0 ustar pgquiles pgquiles /*
* sha1.c
*
* Copyright (C) 1998, 2009
* Paul E. Jones
* All Rights Reserved
*
* Freeware Public License (FPL)
*
* This software is licensed as "freeware." Permission to distribute
* this software in source and binary forms, including incorporation
* into other products, is hereby granted without a fee. THIS SOFTWARE
* IS PROVIDED 'AS IS' AND WITHOUT ANY EXPRESSED OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHOR SHALL NOT BE HELD
* LIABLE FOR ANY DAMAGES RESULTING FROM THE USE OF THIS SOFTWARE, EITHER
* DIRECTLY OR INDIRECTLY, INCLUDING, BUT NOT LIMITED TO, LOSS OF DATA
* OR DATA BEING RENDERED INACCURATE.
*
*****************************************************************************
* $Id: sha1.c 12 2009-06-22 19:34:25Z paulej $
*****************************************************************************
*
* Description:
* This file implements the Secure Hashing Standard as defined
* in FIPS PUB 180-1 published April 17, 1995.
*
* The Secure Hashing Standard, which uses the Secure Hashing
* Algorithm (SHA), produces a 160-bit message digest for a
* given data stream. In theory, it is highly improbable that
* two messages will produce the same message digest. Therefore,
* this algorithm can serve as a means of providing a "fingerprint"
* for a message.
*
* Portability Issues:
* SHA-1 is defined in terms of 32-bit "words". This code was
* written with the expectation that the processor has at least
* a 32-bit machine word size. If the machine word size is larger,
* the code should still function properly. One caveat to that
* is that the input functions taking characters and character
* arrays assume that only 8 bits of information are stored in each
* character.
*
* Caveats:
* SHA-1 is designed to work with messages less than 2^64 bits
* long. Although SHA-1 allows a message digest to be generated for
* messages of any number of bits less than 2^64, this
* implementation only works with messages with a length that is a
* multiple of the size of an 8-bit character.
*
*/
#include "sha1.h"
/*
* Define the circular shift macro
*/
#define SHA1CircularShift(bits,word) \
((((word) << (bits)) & 0xFFFFFFFF) | \
((word) >> (32-(bits))))
/* Function prototypes */
void SHA1ProcessMessageBlock(SHA1Context *);
void SHA1PadMessage(SHA1Context *);
/*
* SHA1Reset
*
* Description:
* This function will initialize the SHA1Context in preparation
* for computing a new message digest.
*
* Parameters:
* context: [in/out]
* The context to reset.
*
* Returns:
* Nothing.
*
* Comments:
*
*/
void wt_SHA1Reset(SHA1Context *context)
{
context->Length_Low = 0;
context->Length_High = 0;
context->Message_Block_Index = 0;
context->Message_Digest[0] = 0x67452301;
context->Message_Digest[1] = 0xEFCDAB89;
context->Message_Digest[2] = 0x98BADCFE;
context->Message_Digest[3] = 0x10325476;
context->Message_Digest[4] = 0xC3D2E1F0;
context->Computed = 0;
context->Corrupted = 0;
}
/*
* SHA1Result
*
* Description:
* This function will return the 160-bit message digest into the
* Message_Digest array within the SHA1Context provided
*
* Parameters:
* context: [in/out]
* The context to use to calculate the SHA-1 hash.
*
* Returns:
* 1 if successful, 0 if it failed.
*
* Comments:
*
*/
int wt_SHA1Result(SHA1Context *context)
{
if (context->Corrupted)
{
return 0;
}
if (!context->Computed)
{
SHA1PadMessage(context);
context->Computed = 1;
}
return 1;
}
/*
* SHA1Input
*
* Description:
* This function accepts an array of octets as the next portion of
* the message.
*
* Parameters:
* context: [in/out]
* The SHA-1 context to update
* message_array: [in]
* An array of characters representing the next portion of the
* message.
* length: [in]
* The length of the message in message_array
*
* Returns:
* Nothing.
*
* Comments:
*
*/
void wt_SHA1Input( SHA1Context *context,
const unsigned char *message_array,
unsigned length)
{
if (!length)
{
return;
}
if (context->Computed || context->Corrupted)
{
context->Corrupted = 1;
return;
}
while(length-- && !context->Corrupted)
{
context->Message_Block[context->Message_Block_Index++] =
(*message_array & 0xFF);
context->Length_Low += 8;
/* Force it to 32 bits */
context->Length_Low &= 0xFFFFFFFF;
if (context->Length_Low == 0)
{
context->Length_High++;
/* Force it to 32 bits */
context->Length_High &= 0xFFFFFFFF;
if (context->Length_High == 0)
{
/* Message is too long */
context->Corrupted = 1;
}
}
if (context->Message_Block_Index == 64)
{
SHA1ProcessMessageBlock(context);
}
message_array++;
}
}
/*
* SHA1ProcessMessageBlock
*
* Description:
* This function will process the next 512 bits of the message
* stored in the Message_Block array.
*
* Parameters:
* None.
*
* Returns:
* Nothing.
*
* Comments:
* Many of the variable names in the SHAContext, especially the
* single character names, were used because those were the names
* used in the publication.
*
*
*/
void SHA1ProcessMessageBlock(SHA1Context *context)
{
const unsigned K[] = /* Constants defined in SHA-1 */
{
0x5A827999,
0x6ED9EBA1,
0x8F1BBCDC,
0xCA62C1D6
};
int t; /* Loop counter */
unsigned temp; /* Temporary word value */
unsigned W[80]; /* Word sequence */
unsigned A, B, C, D, E; /* Word buffers */
/*
* Initialize the first 16 words in the array W
*/
for(t = 0; t < 16; t++)
{
W[t] = ((unsigned) context->Message_Block[t * 4]) << 24;
W[t] |= ((unsigned) context->Message_Block[t * 4 + 1]) << 16;
W[t] |= ((unsigned) context->Message_Block[t * 4 + 2]) << 8;
W[t] |= ((unsigned) context->Message_Block[t * 4 + 3]);
}
for(t = 16; t < 80; t++)
{
W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
}
A = context->Message_Digest[0];
B = context->Message_Digest[1];
C = context->Message_Digest[2];
D = context->Message_Digest[3];
E = context->Message_Digest[4];
for(t = 0; t < 20; t++)
{
temp = SHA1CircularShift(5,A) +
((B & C) | ((~B) & D)) + E + W[t] + K[0];
temp &= 0xFFFFFFFF;
E = D;
D = C;
C = SHA1CircularShift(30,B);
B = A;
A = temp;
}
for(t = 20; t < 40; t++)
{
temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
temp &= 0xFFFFFFFF;
E = D;
D = C;
C = SHA1CircularShift(30,B);
B = A;
A = temp;
}
for(t = 40; t < 60; t++)
{
temp = SHA1CircularShift(5,A) +
((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
temp &= 0xFFFFFFFF;
E = D;
D = C;
C = SHA1CircularShift(30,B);
B = A;
A = temp;
}
for(t = 60; t < 80; t++)
{
temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];
temp &= 0xFFFFFFFF;
E = D;
D = C;
C = SHA1CircularShift(30,B);
B = A;
A = temp;
}
context->Message_Digest[0] =
(context->Message_Digest[0] + A) & 0xFFFFFFFF;
context->Message_Digest[1] =
(context->Message_Digest[1] + B) & 0xFFFFFFFF;
context->Message_Digest[2] =
(context->Message_Digest[2] + C) & 0xFFFFFFFF;
context->Message_Digest[3] =
(context->Message_Digest[3] + D) & 0xFFFFFFFF;
context->Message_Digest[4] =
(context->Message_Digest[4] + E) & 0xFFFFFFFF;
context->Message_Block_Index = 0;
}
/*
* SHA1PadMessage
*
* Description:
* According to the standard, the message must be padded to an even
* 512 bits. The first padding bit must be a '1'. The last 64
* bits represent the length of the original message. All bits in
* between should be 0. This function will pad the message
* according to those rules by filling the Message_Block array
* accordingly. It will also call SHA1ProcessMessageBlock()
* appropriately. When it returns, it can be assumed that the
* message digest has been computed.
*
* Parameters:
* context: [in/out]
* The context to pad
*
* Returns:
* Nothing.
*
* Comments:
*
*/
void SHA1PadMessage(SHA1Context *context)
{
/*
* Check to see if the current message block is too small to hold
* the initial padding bits and length. If so, we will pad the
* block, process it, and then continue padding into a second
* block.
*/
if (context->Message_Block_Index > 55)
{
context->Message_Block[context->Message_Block_Index++] = 0x80;
while(context->Message_Block_Index < 64)
{
context->Message_Block[context->Message_Block_Index++] = 0;
}
SHA1ProcessMessageBlock(context);
while(context->Message_Block_Index < 56)
{
context->Message_Block[context->Message_Block_Index++] = 0;
}
}
else
{
context->Message_Block[context->Message_Block_Index++] = 0x80;
while(context->Message_Block_Index < 56)
{
context->Message_Block[context->Message_Block_Index++] = 0;
}
}
/*
* Store the message length as the last 8 octets
*/
context->Message_Block[56] = (context->Length_High >> 24) & 0xFF;
context->Message_Block[57] = (context->Length_High >> 16) & 0xFF;
context->Message_Block[58] = (context->Length_High >> 8) & 0xFF;
context->Message_Block[59] = (context->Length_High) & 0xFF;
context->Message_Block[60] = (context->Length_Low >> 24) & 0xFF;
context->Message_Block[61] = (context->Length_Low >> 16) & 0xFF;
context->Message_Block[62] = (context->Length_Low >> 8) & 0xFF;
context->Message_Block[63] = (context->Length_Low) & 0xFF;
SHA1ProcessMessageBlock(context);
}
witty-3.3.4+dfsg.orig/src/web/WebStream.h 0000644 0001750 0001750 00000001355 11624460266 020444 0 ustar pgquiles pgquiles // This may look like C code, but it's really -*- C++ -*-
/*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#ifndef WEB_STREAM_H_
#define WEB_STREAM_H_
#include
namespace Wt {
class WebRequest;
class WSocketNotifier;
/*
* Class that implements a stream of (http)-requests.
*
* An instance may be passed to the WebController, which will call the
* method getNextRequest() to get the next request.
*/
class WT_API WebStream
{
public:
WebStream();
virtual ~WebStream();
/*
* Get the next request, return 0 when a timeout occurs.
* Otherwise throws an exception.
*/
virtual WebRequest *getNextRequest(int timeoutsec) = 0;
};
}
#endif // WEB_STREAM_H_
witty-3.3.4+dfsg.orig/src/web/CgiParser.C 0000644 0001750 0001750 00000027117 12273674107 020373 0 ustar pgquiles pgquiles /*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
* In addition to these terms, permission is also granted to use and
* modify these two files (CgiParser.C and CgiParser.h) so long as the
* copyright above is maintained, modifications are documented, and
* credit is given for any use of the library.
*
* CGI parser modelled after the PERL implementation cgi-lib.pl 2.18 by
* Steven E. Brenner with the following original copyright:
# Perl Routines to Manipulate CGI input
# cgi-lib@pobox.com
#
# Copyright (c) 1993-1999 Steven E. Brenner
# Unpublished work.
# Permission granted to use and modify this library so long as the
# copyright above is maintained, modifications are documented, and
# credit is given for any use of the library.
#
# Thanks are due to many people for reporting bugs and suggestions
# For more information, see:
# http://cgi-lib.stanford.edu/cgi-lib/
*/
#include
#include
#ifdef WT_HAVE_GNU_REGEX
#include
#else
#include
#endif // WT_HAVE_GNU_REGEX
#include "CgiParser.h"
#include "WebRequest.h"
#include "WebUtils.h"
#include "FileUtils.h"
#include "Wt/WException"
#include "Wt/WLogger"
#include "Wt/Http/Request"
using std::memmove;
using std::strcpy;
using std::strtol;
namespace {
#ifndef WT_HAVE_GNU_REGEX
const boost::regex boundary_e("\\bboundary=(?:(?:\"([^\"]+)\")|(\\S+))",
boost::regex::perl|boost::regex::icase);
const boost::regex name_e("\\bname=(?:(?:\"([^\"]+)\")|([^\\s:;]+))",
boost::regex::perl|boost::regex::icase);
const boost::regex filename_e("\\bfilename=(?:(?:\"([^\"]*)\")|([^\\s:;]+))",
boost::regex::perl|boost::regex::icase);
const boost::regex content_e("^\\s*Content-type:"
"\\s*(?:(?:\"([^\"]+)\")|([^\\s:;]+))",
boost::regex::perl|boost::regex::icase);
const boost::regex content_disposition_e("^\\s*Content-Disposition:",
boost::regex::perl|boost::regex::icase);
const boost::regex content_type_e("^\\s*Content-Type:",
boost::regex::perl|boost::regex::icase);
bool fishValue(const std::string& text,
const boost::regex& e, std::string& result)
{
boost::smatch what;
if (boost::regex_search(text, what, e)) {
result = what[1] + what[2];
return true;
} else
return false;
}
bool regexMatch(const std::string& text, const boost::regex& e)
{
return boost::regex_search(text, e);
}
#else
regex_t boundary_e, name_e, filename_e, content_e,
content_disposition_e, content_type_e;
const char *boundary_ep = "\\bboundary=((\"([^\"]*)\")|([^ \t]*))";
const char *name_ep = "\\bname=((\"([^\"]*)\")|([^ \t:;]*))";
const char *filename_ep = "\\bfilename=((\"([^\"]*)\")|([^ \t:;]*))";
const char *content_ep = "^[ \t]*Content-type:"
"[ \t]*((\"([^\"]*)\")|([^ \t:;]*))";
const char *content_disposition_ep = "^[ \t]*Content-Disposition:";
const char *content_type_ep = "^[ \t]*Content-Type:";
bool fishValue(const std::string& text,
regex_t& e1, std::string& result)
{
regmatch_t pmatch[5];
int res = regexec(&e1, text.c_str(), 5, pmatch, 0);
if (res == 0) {
if (pmatch[3].rm_so != -1)
result = text.substr(pmatch[3].rm_so,
pmatch[3].rm_eo - pmatch[3].rm_so);
if (pmatch[4].rm_so != -1)
result = text.substr(pmatch[4].rm_so,
pmatch[4].rm_eo - pmatch[4].rm_so);
return true;
} else
return false;
}
bool regexMatch(const std::string& text, regex_t& e)
{
regmatch_t pmatch[1];
return regexec(&e, text.c_str(), 1, pmatch, 0) == 0;
}
class RegInitializer {
protected:
static bool regInitialized_;
public:
RegInitializer()
{}
~RegInitializer() {
cleanup();
}
static void setup() {
if (!regInitialized_) {
regcomp(&boundary_e, boundary_ep, REG_ICASE | REG_EXTENDED);
regcomp(&name_e, name_ep, REG_ICASE | REG_EXTENDED);
regcomp(&filename_e, filename_ep, REG_ICASE | REG_EXTENDED);
regcomp(&content_e, content_ep, REG_ICASE | REG_EXTENDED);
regcomp(&content_disposition_e, content_disposition_ep,
REG_ICASE | REG_EXTENDED);
regcomp(&content_type_e, content_type_ep, REG_ICASE | REG_EXTENDED);
regInitialized_ = true;
}
}
static void cleanup() {
if (regInitialized_) {
regfree(&boundary_e);
regfree(&name_e);
regfree(&filename_e);
regfree(&content_e);
regfree(&content_disposition_e);
regfree(&content_type_e);
regInitialized_ = false;
}
}
};
bool RegInitializer::regInitialized_ = false;
static RegInitializer regInitializer;
#endif
}
namespace Wt {
LOGGER("CgiParser");
void CgiParser::init()
{
#ifdef WT_HAVE_GNU_REGEX
RegInitializer::setup();
#endif
}
CgiParser::CgiParser(::int64_t maxPostData)
: maxPostData_(maxPostData)
{ }
void CgiParser::parse(WebRequest& request, ReadOption readOption)
{
/*
* TODO: optimize this ...
*/
request_ = &request;
::int64_t len = request.contentLength();
const char *type = request.contentType();
const char *meth = request.requestMethod();
request.postDataExceeded_ = (len > maxPostData_ ? len : 0);
std::string queryString = request.queryString();
// XDomainRequest cannot set a contentType header, we therefore pass it
// as a request parameter
if (readOption != ReadHeadersOnly &&
strcmp(meth, "POST") == 0 &&
((type && strstr(type, "application/x-www-form-urlencoded") == type) ||
(queryString.find("&contentType=x-www-form-urlencoded") !=
std::string::npos))) {
/*
* TODO: parse this stream-based to avoid the malloc here. For now
* we protect the maximum that can be POST'ed as form data.
*/
if (len > 5*1024*1024)
throw WException("Oversized application/x-www-form-urlencoded ("
+ boost::lexical_cast(len) + ")");
char *buf = new char[len + 1];
request.in().read(buf, len);
if (request.in().gcount() != (int)len) {
delete[] buf;
throw WException("Unexpected short read.");
}
buf[len] = 0;
// This is a special Wt feature, I do not think it standard.
// For POST, parameters in url-encoded URL are still parsed.
if (!queryString.empty())
queryString += '&';
queryString += buf;
delete[] buf;
}
LOG_DEBUG("queryString (len=" << len << "): " << queryString);
if (!queryString.empty())
Http::Request::parseFormUrlEncoded(queryString, request_->parameters_);
if (readOption != ReadHeadersOnly &&
type && strstr(type, "multipart/form-data") == type) {
if (strcmp(meth, "POST") != 0) {
throw WException("Invalid method for multipart/form-data: "
+ std::string(meth));
}
if (!request.postDataExceeded_)
readMultipartData(request, type, len);
else if (readOption == ReadBodyAnyway) {
for (;len > 0;) {
::int64_t toRead = std::min(::int64_t(BUFSIZE), len);
request.in().read(buf_, toRead);
if (request.in().gcount() != (::int64_t)toRead)
throw WException("CgiParser: short read");
len -= toRead;
}
}
}
}
void CgiParser::readMultipartData(WebRequest& request,
const std::string type, ::int64_t len)
{
std::string boundary;
if (!fishValue(type, boundary_e, boundary))
throw WException("Could not find a boundary for multipart data.");
boundary = "--" + boundary;
buflen_ = 0;
left_ = len;
spoolStream_ = 0;
currentKey_.clear();
if (!parseBody(request, boundary))
return;
for (;;) {
if (!parseHead(request))
break;
if (!parseBody(request,boundary))
break;
}
}
/*
* Read until finding the boundary, saving to resultString or
* resultFile. The boundary itself is not consumed.
*
* tossAtBoundary controls how many characters extra (<0)
* or few (>0) are saved at the start of the boundary in the result.
*/
void CgiParser::readUntilBoundary(WebRequest& request,
const std::string boundary,
int tossAtBoundary,
std::string *resultString,
std::ostream *resultFile)
{
int bpos;
while ((bpos = index(boundary)) == -1) {
/*
* If we couldn't find it. We need to wind the buffer, but only save
* not including the boundary length.
*/
if (left_ == 0)
throw WException("CgiParser: reached end of input while seeking end of "
"headers or content. Format of CGI input is wrong");
/* save (up to) BUFSIZE from buffer to file or value string, but
* mind the boundary length */
int save = std::min((buflen_ - (int)boundary.length()), (int)BUFSIZE);
if (save > 0) {
if (resultString)
*resultString += std::string(buf_, save);
if (resultFile)
resultFile->write(buf_, save);
/* wind buffer */
windBuffer(save);
}
unsigned amt = static_cast
(std::min(left_,
static_cast< ::int64_t >(BUFSIZE + MAXBOUND - buflen_)));
request.in().read(buf_ + buflen_, amt);
if (request.in().gcount() != (int)amt)
throw WException("CgiParser: short read");
left_ -= amt;
buflen_ += amt;
}
if (resultString)
*resultString += std::string(buf_, bpos - tossAtBoundary);
if (resultFile)
resultFile->write(buf_, bpos - tossAtBoundary);
/* wind buffer */
windBuffer(bpos);
}
void CgiParser::windBuffer(int offset)
{
if (offset < buflen_) {
memmove(buf_, buf_ + offset, buflen_ - offset);
buflen_ -= offset;
} else
buflen_ = 0;
}
int CgiParser::index(const std::string search)
{
std::string bufS = std::string(buf_, buflen_);
std::string::size_type i = bufS.find(search);
if (i == std::string::npos)
return -1;
else
return i;
}
bool CgiParser::parseHead(WebRequest& request)
{
std::string head;
readUntilBoundary(request, "\r\n\r\n", -2, &head, 0);
std::string name;
std::string fn;
std::string ctype;
for (unsigned current = 0; current < head.length();) {
/* read line by line */
std::string::size_type i = head.find("\r\n", current);
const std::string text = head.substr(current, (i == std::string::npos
? std::string::npos
: i - current));
if (regexMatch(text, content_disposition_e)) {
fishValue(text, name_e, name);
fishValue(text, filename_e, fn);
}
if (regexMatch(text, content_type_e)) {
fishValue(text, content_e, ctype);
}
current = i + 2;
}
LOG_DEBUG("name: " << name << " ct: " << ctype << " fn: " << fn);
currentKey_ = name;
if (!fn.empty()) {
if (!request.postDataExceeded_) {
/*
* It is not easy to create a std::ostream pointing to a
* temporary file name.
*/
std::string spool = FileUtils::createTempFileName();
spoolStream_ = new std::ofstream(spool.c_str(),
std::ios::out | std::ios::binary);
request_->files_.insert
(std::make_pair(name, Http::UploadedFile(spool, fn, ctype)));
LOG_DEBUG("spooling file to " << spool.c_str());
} else {
spoolStream_ = 0;
// Clear currentKey so that file we don't do harm by reading this
// giant blob in memory
currentKey_ = "";
}
}
windBuffer(4);
return true;
}
bool CgiParser::parseBody(WebRequest& request, const std::string boundary)
{
std::string value;
readUntilBoundary(request, boundary, 2,
spoolStream_ ? 0 : (!currentKey_.empty() ? &value : 0),
spoolStream_);
if (spoolStream_) {
LOG_DEBUG("completed spooling");
delete spoolStream_;
spoolStream_ = 0;
} else {
if (!currentKey_.empty()) {
LOG_DEBUG("value: \"" << value << "\"");
request_->parameters_[currentKey_].push_back(value);
}
}
currentKey_.clear();
if (std::string(buf_ + boundary.length(), 2) == "--")
return false;
windBuffer(boundary.length() + 2);
return true;
}
} // namespace Wt
witty-3.3.4+dfsg.orig/src/web/FileUtils.h 0000644 0001750 0001750 00000002121 12226715321 020435 0 ustar pgquiles pgquiles // This may look like C code, but it's really -*- C++ -*-
/*
* Copyright (C) 2012 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#ifndef WT_FILE_UTILS_H_
#define WT_FILE_UTILS_H_
#include
#include
#include
#include
namespace Wt {
namespace FileUtils {
extern WT_API
std::vector fileHeader(const std::string &fileName,
unsigned size);
extern WT_API unsigned long long size(const std::string &file);
extern WT_API std::string* fileToString(const std::string &fileName);
#ifndef WT_TARGET_JAVA
extern WT_API std::time_t lastWriteTime(const std::string &file);
#endif
extern WT_API bool exists(const std::string &file);
extern bool isDirectory(const std::string &file);
extern void listFiles(const std::string &directory,
std::vector &files);
extern std::string leaf(const std::string &file);
// Returns a filename that can be used as temporary file
extern WT_API std::string createTempFileName();
}
}
#endif // WT_FILE_UTILS_H_
witty-3.3.4+dfsg.orig/src/web/WebRenderer.C 0000644 0001750 0001750 00000145721 12501513341 020704 0 ustar pgquiles pgquiles /*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#include
#include
#include
#include "Wt/WApplication"
#include "Wt/WContainerWidget"
#include "Wt/WRandom"
#include "Wt/WRegExp"
#include "Wt/WWebWidget"
#include "Wt/WStringStream"
#include "Wt/WTheme"
#include "Wt/Utils"
#include "Configuration.h"
#include "DomElement.h"
#include "EscapeOStream.h"
#include "FileServe.h"
#include "WebController.h"
#include "WebRenderer.h"
#include "WebRequest.h"
#include "WebSession.h"
#include "WebUtils.h"
#ifdef WT_WIN32
#include // for getpid()
#ifdef min
#undef min
#endif
#endif
#ifndef WT_TARGET_JAVA
#define DESCRIBE(w) typeid(*(w)).name()
#else
#define DESCRIBE(w) "(fixme)"
#endif
namespace {
bool isAbsoluteUrl(const std::string& url) {
return url.find("://") != std::string::npos;
}
void appendAttribute(Wt::EscapeOStream& eos,
const std::string& name,
const std::string& value) {
eos << ' ' << name << "=\"";
eos.pushEscape(Wt::EscapeOStream::HtmlAttribute);
eos << value;
eos.popEscape();
eos << '"';
}
void closeSpecial(Wt::WStringStream& s) {
s << ">\n";
}
void closeSpecial(Wt::EscapeOStream& s) {
s << ">\n";
}
}
namespace skeletons {
extern const char *Boot_html1;
extern const char *Plain_html1;
extern const char *Hybrid_html1;
extern const char *Wt_js1;
extern const char *Boot_js1;
extern const char *JQuery_js1;
extern std::vector JQuery_js();
extern std::vector Wt_js();
}
namespace Wt {
LOGGER("WebRenderer");
WebRenderer::CookieValue::CookieValue()
: secure(false)
{ }
WebRenderer::CookieValue::CookieValue(const std::string& v,
const std::string& p,
const std::string& d,
const WDateTime& e,
bool s)
: value(v),
path(p),
domain(d),
expires(e),
secure(s)
{ }
WebRenderer::WebRenderer(WebSession& session)
: session_(session),
visibleOnly_(true),
rendered_(false),
initialStyleRendered_(false),
twoPhaseThreshold_(5000),
pageId_(0),
expectedAckId_(0),
scriptId_(0),
formObjectsChanged_(true),
updateLayout_(false),
learning_(false)
{ }
void WebRenderer::setRendered(bool how)
{
if (rendered_ != how) {
LOG_DEBUG("setRendered: " << how);
rendered_ = how;
}
}
void WebRenderer::setTwoPhaseThreshold(int bytes)
{
twoPhaseThreshold_ = bytes;
}
void WebRenderer::needUpdate(WWidget *w, bool laterOnly)
{
LOG_DEBUG("needUpdate: " << w->id() << " (" << DESCRIBE(w) << ")");
updateMap_.insert(w);
if (!laterOnly)
moreUpdates_ = true;
}
void WebRenderer::doneUpdate(WWidget *w)
{
LOG_DEBUG("doneUpdate: " << w->id() << " (" << DESCRIBE(w) << ")");
updateMap_.erase(w);
}
bool WebRenderer::isDirty() const
{
return !updateMap_.empty()
|| formObjectsChanged_
|| session_.app()->isQuited()
|| !session_.app()->afterLoadJavaScript_.empty()
|| session_.app()->serverPushChanged_
|| session_.app()->styleSheetsAdded_
|| !session_.app()->styleSheetsToRemove_.empty()
|| session_.app()->styleSheet().isDirty()
|| session_.app()->internalPathIsChanged_
|| !collectedJS1_.empty()
|| !collectedJS2_.empty()
|| !invisibleJS_.empty();
}
const WebRenderer::FormObjectsMap& WebRenderer::formObjects() const
{
return currentFormObjects_;
}
std::string WebRenderer::bodyClassRtl() const
{
if (session_.app()) {
std::string s = session_.app()->bodyClass_;
if (!s.empty())
s += ' ';
s += session_.app()->layoutDirection() == LeftToRight
? "Wt-ltr" : "Wt-rtl";
session_.app()->bodyHtmlClassChanged_ = false;
return s;
} else
return std::string();
}
void WebRenderer::saveChanges()
{
collectJS(&collectedJS1_);
}
void WebRenderer::discardChanges()
{
collectJS(0);
}
bool WebRenderer::ackUpdate(int updateId)
{
/*
* If we are using an unreliable transport, then we remember
* JavaScript updates until they are ack'ed. This works because
* requests are not pipelined.
*
* WebSocket requests are pipelined so this simple mechanism will
* not work. When switching from web sockets to AJAX or vice-versa ?
*
* If normal AJAX request -> web socket closes. We assume everything
* got delivered and start doing ack updates again.
*
* If web socket request -> we assume last AJAX request got
* delivered ?
*/
if (updateId == expectedAckId_) {
setJSSynced(false);
++expectedAckId_;
return true;
} else if ((updateId < expectedAckId_ && expectedAckId_ - updateId < 5)
|| (expectedAckId_ - 5 < updateId)) {
return true; // That's still acceptible but no longer plausible
} else
return false;
}
void WebRenderer::letReloadJS(WebResponse& response, bool newSession,
bool embedded)
{
if (!embedded) {
setCaching(response, false);
setHeaders(response, "text/javascript; charset=UTF-8");
}
// FIXME: we should foresee something independent of app->javaScriptClass()
response.out() <<
"if (window.Wt) window.Wt._p_.quit(null); window.location.reload(true);";
}
void WebRenderer::letReloadHTML(WebResponse& response, bool newSession)
{
setCaching(response, false);
setHeaders(response, "text/html; charset=UTF-8");
response.out() << "";
}
void WebRenderer::streamRedirectJS(WStringStream& out,
const std::string& redirect)
{
if (session_.app() && session_.app()->internalPathIsChanged_)
out << "if (window." << session_.app()->javaScriptClass() << ") "
<< session_.app()->javaScriptClass()
<< "._p_.setHash("
<< WWebWidget::jsStringLiteral(session_.app()->newInternalPath_)
<< ", false);\n";
out <<
"if (window.location.replace)"
" window.location.replace('" << redirect << "');"
"else"
" window.location.href='" << redirect << "';\n";
}
void WebRenderer::serveResponse(WebResponse& response)
{
session_.setTriggerUpdate(false);
switch (response.responseType()) {
case WebResponse::Update:
serveJavaScriptUpdate(response);
break;
case WebResponse::Page:
initialStyleRendered_ = false;
if (session_.app())
serveMainpage(response);
else
serveBootstrap(response);
break;
case WebResponse::Script:
bool hybridPage = session_.progressiveBoot() || session_.env().ajax();
if (!hybridPage)
setRendered(false);
serveMainscript(response);
break;
}
}
void WebRenderer::setPageVars(FileServe& page)
{
WApplication *app = session_.app();
page.setVar("DOCTYPE", session_.docType());
std::string htmlAttr;
if (app && !app->htmlClass_.empty()) {
htmlAttr = " class=\"" + app->htmlClass_ + "\"";
}
if (session_.env().agentIsIE())
page.setVar("HTMLATTRIBUTES",
"xmlns:v=\"urn:schemas-microsoft-com:vml\""
" lang=\"en\" dir=\"ltr\"" + htmlAttr);
else
page.setVar("HTMLATTRIBUTES", "lang=\"en\" dir=\"ltr\"" + htmlAttr);
page.setVar("METACLOSE", ">");
std::string attr = bodyClassRtl();
if (!attr.empty())
attr = " class=\"" + attr + "\"";
if (app && app->layoutDirection() == RightToLeft)
attr += " dir=\"RTL\"";
page.setVar("BODYATTRIBUTES", attr);
page.setVar("HEADDECLARATIONS", headDeclarations());
page.setCondition("FORM", !session_.env().agentIsSpiderBot()
&& !session_.env().ajax());
page.setCondition("BOOT_STYLE", true);
}
void WebRenderer::streamBootContent(WebResponse& response,
FileServe& boot, bool hybrid)
{
Configuration& conf = session_.controller()->configuration();
WStringStream out(response.out());
FileServe bootJs(skeletons::Boot_js1);
boot.setVar("BLANK_HTML",
session_.bootstrapUrl(response, WebSession::ClearInternalPath)
+ "&request=resource&resource=blank");
boot.setVar("SESSION_ID", session_.sessionId());
//TODO remove APP_CLASS, will later only be used in the javascript
boot.setVar("APP_CLASS", "Wt");
bootJs.setVar("SELF_URL",
safeJsStringLiteral
(session_.bootstrapUrl(response,
WebSession::ClearInternalPath)));
bootJs.setVar("SESSION_ID", session_.sessionId());
expectedAckId_ = scriptId_ = WRandom::get();
bootJs.setVar("SCRIPT_ID", scriptId_);
bootJs.setVar("RANDOMSEED", WRandom::get());
bootJs.setVar("RELOAD_IS_NEWSESSION", conf.reloadIsNewSession());
bootJs.setVar("USE_COOKIES",
conf.sessionTracking() == Configuration::CookiesURL);
bootJs.setVar("AJAX_CANONICAL_URL",
safeJsStringLiteral(session_.ajaxCanonicalUrl(response)));
bootJs.setVar("APP_CLASS", "Wt");
bootJs.setVar("PATH_INFO", WWebWidget::jsStringLiteral
(session_.pagePathInfo_));
bootJs.setCondition("COOKIE_CHECKS", conf.cookieChecks());
bootJs.setCondition("SPLIT_SCRIPT", conf.splitScript());
bootJs.setCondition("HYBRID", hybrid);
bootJs.setCondition("PROGRESS", hybrid && !session_.env().ajax());
bootJs.setCondition("DEFER_SCRIPT", true);
bootJs.setCondition("WEBGL_DETECT", conf.webglDetect());
std::string internalPath
= hybrid ? session_.app()->internalPath() : session_.env().internalPath();
bootJs.setVar("INTERNAL_PATH", safeJsStringLiteral(internalPath));
boot.streamUntil(out, "BOOT_JS");
bootJs.stream(out);
out.spool(response.out());
}
void WebRenderer::serveLinkedCss(WebResponse& response)
{
response.setContentType("text/css");
if (!initialStyleRendered_) {
WApplication *app = session_.app();
WStringStream out(response.out());
if (app->theme())
app->theme()->serveCss(out);
for (unsigned i = 0; i < app->styleSheets_.size(); ++i)
app->styleSheets_[i].cssText(out, true);
app->styleSheetsAdded_ = 0;
initialStyleRendered_ = true;
out.spool(response.out());
}
}
void WebRenderer::serveBootstrap(WebResponse& response)
{
Configuration& conf = session_.controller()->configuration();
FileServe boot(skeletons::Boot_html1);
setPageVars(boot);
WStringStream noJsRedirectUrl;
DomElement::htmlAttributeValue
(noJsRedirectUrl,
session_.bootstrapUrl(response, WebSession::KeepInternalPath) + "&js=no");
boot.setVar("REDIRECT_URL", noJsRedirectUrl.str());
boot.setVar("AUTO_REDIRECT",
"Error occurred. "
<< "Error occurred. "
<< WWebWidget::escapeText(WString(message), true).toUTF8()
<< '\n';
} else {
response.out() << app->javaScriptClass()
<< "._p_.quit(null);"
<< "document.title = 'Error occurred.';"
<< "document.body.innerHtml='Error occurred. ' +"
<< WWebWidget::jsStringLiteral(message)
<< ';';
}
}
void WebRenderer::setCookie(const std::string name, const std::string value,
const WDateTime& expires,
const std::string domain, const std::string path,
bool secure)
{
cookiesToSet_[name] = CookieValue(value, path, domain, expires, secure);
}
void WebRenderer::setCaching(WebResponse& response, bool allowCache)
{
if (allowCache)
response.addHeader("Cache-Control", "max-age=2592000,private");
else {
response.addHeader("Cache-Control", "no-cache, no-store, must-revalidate");
response.addHeader("Pragma", "no-cache");
response.addHeader("Expires", "0");
}
}
void WebRenderer::setHeaders(WebResponse& response, const std::string mimeType)
{
for (std::map::const_iterator
i = cookiesToSet_.begin(); i != cookiesToSet_.end(); ++i) {
const CookieValue& cookie = i->second;
WStringStream header;
std::string value = cookie.value;
if (value.empty())
value = "deleted";
header << Utils::urlEncode(i->first) << '=' << Utils::urlEncode(value)
<< "; Version=1;";
if (!cookie.expires.isNull()) {
#ifndef WT_TARGET_JAVA
std::string formatString = "ddd, dd-MMM-yyyy hh:mm:ss 'GMT'";
#else
std::string formatString = "EEE, dd-MMM-yyyy hh:mm:ss 'GMT'";
#endif
std::string d
= cookie.expires.toString
(WString::fromUTF8(formatString), false).toUTF8();
header << "Expires=" << d << ';';
}
if (!cookie.domain.empty())
header << " Domain=" << cookie.domain << ';';
if (cookie.path.empty())
header << " Path=" << session_.env().deploymentPath() << ';';
else
header << " Path=" << cookie.path << ';';
// a httponly cookie cannot be set using JavaScript
if (!response.isWebSocketMessage())
header << " httponly;";
if (cookie.secure)
header << " secure;";
response.addHeader("Set-Cookie", header.str());
}
cookiesToSet_.clear();
#ifndef WT_TARGET_JAVA
Configuration& conf = session_.controller()->configuration();
if (conf.behindReverseProxy() && conf.singleSession()) {
response.addHeader("X-Wt-Session", session_.sessionId());
}
#endif // WT_TARGET_JAVA
response.setContentType(mimeType);
}
void WebRenderer::renderSetServerPush(WStringStream& out)
{
if (session_.app()->serverPushChanged_) {
out << session_.app()->javaScriptClass()
<< "._p_.setServerPush("
<< session_.app()->updatesEnabled()
<< ");";
session_.app()->serverPushChanged_ = false;
}
}
std::string WebRenderer::sessionUrl() const
{
std::string result = session_.applicationUrl();
if (isAbsoluteUrl(result))
return session_.appendSessionQuery(result);
else {
// Wt.js will prepand the correct deployment path
return session_.appendSessionQuery(".").substr(1);
}
}
void WebRenderer::serveJavaScriptUpdate(WebResponse& response)
{
setCaching(response, false);
setHeaders(response, "text/javascript; charset=UTF-8");
if (session_.sessionIdChanged_) {
collectedJS1_ << session_.app()->javaScriptClass()
<< "._p_.setSessionUrl("
<< WWebWidget::jsStringLiteral(sessionUrl())
<< ");";
}
WStringStream out(response.out());
if (!rendered_) {
serveMainAjax(out);
} else {
collectJavaScript();
addResponseAckPuzzle(out);
renderSetServerPush(out);
LOG_DEBUG("js: " << collectedJS1_.str() << collectedJS2_.str());
out << collectedJS1_.str() << collectedJS2_.str();
if (response.isWebSocketMessage())
setJSSynced(false);
}
out.spool(response.out());
}
void WebRenderer::addContainerWidgets(WWebWidget *w,
std::vector& result)
{
for (unsigned i = 0; i < w->children().size(); ++i) {
WWidget *c = w->children()[i];
if (!c->isRendered())
return;
if (!c->isHidden())
addContainerWidgets(c->webWidget(), result);
WContainerWidget *wc = dynamic_cast(c);
if (wc)
result.push_back(wc);
}
}
void WebRenderer::addResponseAckPuzzle(WStringStream& out)
{
std::string puzzle;
Configuration& conf = session_.controller()->configuration();
if (conf.ajaxPuzzle() && expectedAckId_ == scriptId_) {
/*
* We need to pick a random WContainerWidget. Let's be dumb for now.
*/
std::vector widgets;
WApplication *app = session_.app();
addContainerWidgets(app->domRoot_, widgets);
if (app->domRoot2_)
addContainerWidgets(app->domRoot2_, widgets);
unsigned r = WRandom::get() % widgets.size();
WContainerWidget *wc = widgets[r];
puzzle = '"' + wc->id() + '"';
std::string l;
for (WWidget *w = wc->parent(); w; w = w->parent()) {
if (w->id().empty())
continue;
if (w->id() == l)
continue;
l = w->id();
if (!solution_.empty())
solution_ += ',';
solution_ += l;
}
}
/*
* Passing the expectedAckId_ within the collectedJS1_ +
* collectedJS2_ risks of inflating responses when a script loading
* is blocked. The purpose of the ackId is to detect what has been
* succesfully transmitted (mostly in the presence of server push
* which can cancel ajax requests. Therefore we chose here to use
* the ackIds_ only to signal proper ajax transfers, and thus at the
* end of the request transfer.
*
* It does present us with another probem: what if e.g. an ExtJS
* library is still loading and we already update one of its widgets
* assuming it has been rendered ? This should be handled
* client-side: only when libraries have been loaded, the application can
* continue. TO BE DONE.
*/
out << session_.app()->javaScriptClass()
<< "._p_.response(" << expectedAckId_;
if (!puzzle.empty())
out << "," << puzzle;
out << ");";
}
bool WebRenderer::checkResponsePuzzle(const WebRequest& request)
{
if (!solution_.empty()) {
const std::string *ackPuzzleE = request.getParameter("ackPuzzle");
if (!ackPuzzleE) {
LOG_SECURE("Ajax puzzle fail: solution missing");
return false;
}
std::string ackPuzzle = *ackPuzzleE;
Utils::SplitVector answer, solution;
boost::split(solution, solution_, boost::is_any_of(","));
boost::split(answer, ackPuzzle, boost::is_any_of(","));
unsigned j = 0;
bool fail = false;
for (unsigned i = 0; i < solution.size(); ++i) {
for (; j < answer.size(); ++j) {
if (solution[i] == answer[j])
break;
else {
/* Verify that answer[j] is not a valid widget id */
}
}
if (j == answer.size()) {
fail = true;
break;
}
}
if (j < answer.size() - 1)
fail = true;
if (fail) {
LOG_SECURE("Ajax puzzle fail: '" << ackPuzzle << "' vs '"
<< solution_ << '\'');
solution_.clear();
return false;
} else {
solution_.clear();
return true;
}
} else
return true;
}
void WebRenderer::collectJavaScript()
{
WApplication *app = session_.app();
Configuration& conf = session_.controller()->configuration();
/*
* Pending invisible changes are also collected into JS1. This is
* also done in ackUpdate(), but just in case an update was not
* acknowledged.
*
* This is also used to render JavaScript that was rendered in asHtml()
* in a hybrid page.
*/
collectedJS1_ << invisibleJS_.str();
invisibleJS_.clear();
if (conf.inlineCss())
app->styleSheet().javaScriptUpdate(app, collectedJS1_, false);
loadStyleSheets(collectedJS1_, app);
if (app->bodyHtmlClassChanged_) {
bool widgetset = session_.type() == WidgetSet;
std::string op = widgetset ? "+=" : "=";
collectedJS1_ << "document.body.parentNode.className" << op << '\''
<< app->htmlClass_ << "';"
<< "document.body.className" << op << '\'' << bodyClassRtl() << "';"
<< "document.body.setAttribute('dir', '";
if (app->layoutDirection() == LeftToRight)
collectedJS1_ << "LTR";
else
collectedJS1_ << "RTL";
collectedJS1_ << "');";
}
/*
* This opens scopes, waiting for new libraries to be loaded.
*/
int librariesLoaded = loadScriptLibraries(collectedJS1_, app);
/*
* This closes the same scopes.
*/
loadScriptLibraries(collectedJS2_, app, librariesLoaded);
/*
* Everything else happens inside JS1: after libraries have been loaded.
*/
app->streamBeforeLoadJavaScript(collectedJS1_, false);
if (app->domRoot2_)
app->domRoot2_->rootAsJavaScript(app, collectedJS1_, false);
collectJavaScriptUpdate(collectedJS1_);
if (visibleOnly_) {
bool needFetchInvisible = false;
if (!updateMap_.empty()) {
needFetchInvisible = true;
if (twoPhaseThreshold_ > 0) {
/*
* See how large the invisible changes are, perhaps we can
* send them along
*/
visibleOnly_ = false;
collectJavaScriptUpdate(invisibleJS_);
if (invisibleJS_.length() < (unsigned)twoPhaseThreshold_) {
collectedJS1_ << invisibleJS_.str();
invisibleJS_.clear();
needFetchInvisible = false;
}
visibleOnly_ = true;
}
}
if (needFetchInvisible)
collectedJS1_ << app->javaScriptClass()
<< "._p_.update(null, 'none', null, false);";
}
if (app->autoJavaScriptChanged_) {
collectedJS1_ << app->javaScriptClass()
<< "._p_.autoJavaScript=function(){"
<< app->autoJavaScript_ << "};";
app->autoJavaScriptChanged_ = false;
}
visibleOnly_ = true;
app->domRoot_->doneRerender();
if (app->domRoot2_)
app->domRoot2_->doneRerender();
std::string redirect = session_.getRedirect();
if (!redirect.empty())
streamRedirectJS(collectedJS1_, redirect);
}
void WebRenderer::serveMainscript(WebResponse& response)
{
/*
* Serving a script is using a GET request, which can be replayed.
* Therefore we need to either be able to reconstruct the response
* (possible if !rendered_), or we need to save the response in
* collectedJS variables.
*/
Configuration& conf = session_.controller()->configuration();
bool widgetset = session_.type() == WidgetSet;
bool serveSkeletons = !conf.splitScript()
|| response.getParameter("skeleton");
bool serveRest = !conf.splitScript() || !serveSkeletons;
session_.sessionIdChanged_ = false;
setCaching(response, conf.splitScript() && serveSkeletons);
setHeaders(response, "text/javascript; charset=UTF-8");
WStringStream out(response.out());
if (!widgetset) {
// FIXME: this cannot be replayed
std::string redirect = session_.getRedirect();
if (!redirect.empty()) {
streamRedirectJS(out, redirect);
return;
}
} else {
expectedAckId_ = scriptId_ = WRandom::get();
}
WApplication *app = session_.app();
const bool innerHtml = true;
if (serveSkeletons) {
bool haveJQuery = app->customJQuery();
if (!haveJQuery) {
out << "if (typeof window.$ === 'undefined') {";
#ifndef WT_TARGET_JAVA
std::vector parts = skeletons::JQuery_js();
for (std::size_t i = 0; i < parts.size(); ++i)
out << const_cast(parts[i]);
#else
out << const_cast(skeletons::JQuery_js1);
#endif
out << '}';
}
#ifndef WT_TARGET_JAVA
std::vector parts = skeletons::Wt_js();
#else
std::vector parts = std::vector();
#endif
std::string Wt_js_combined;
if (parts.size() > 1)
for (std::size_t i = 0; i < parts.size(); ++i)
Wt_js_combined += parts[i];
FileServe script(parts.size() > 1
? Wt_js_combined.c_str() : skeletons::Wt_js1);
script.setCondition
("CATCH_ERROR", conf.errorReporting() != Configuration::NoErrors);
script.setCondition
("SHOW_ERROR", conf.errorReporting() == Configuration::ErrorMessage);
script.setCondition
("UGLY_INTERNAL_PATHS", session_.useUglyInternalPaths());
#ifdef WT_DEBUG_JS
script.setCondition("DYNAMIC_JS", true);
#else
script.setCondition("DYNAMIC_JS", false);
#endif // WT_DEBUG_JS
script.setVar("WT_CLASS", WT_CLASS);
script.setVar("APP_CLASS", app->javaScriptClass());
script.setCondition("STRICTLY_SERIALIZED_EVENTS", conf.serializedEvents());
script.setCondition("WEB_SOCKETS", conf.webSockets());
script.setVar("INNER_HTML", innerHtml);
script.setVar("ACK_UPDATE_ID", expectedAckId_);
script.setVar("SESSION_URL", WWebWidget::jsStringLiteral(sessionUrl()));
script.setVar("QUITTED_STR",
WString::tr("Wt.QuittedMessage").jsStringLiteral());
std::string deployPath = session_.env().publicDeploymentPath_;
if (deployPath.empty())
deployPath = session_.deploymentPath();
script.setVar("DEPLOY_PATH", WWebWidget::jsStringLiteral(deployPath));
int keepAlive;
if (conf.sessionTimeout() == -1)
keepAlive = 1000000;
else
keepAlive = conf.sessionTimeout() / 2;
script.setVar("KEEP_ALIVE", boost::lexical_cast(keepAlive));
script.setVar("INDICATOR_TIMEOUT", conf.indicatorTimeout());
script.setVar("SERVER_PUSH_TIMEOUT", conf.serverPushTimeout() * 1000);
/*
* Was in honor of Mozilla Bugzilla #246651
*/
script.setVar("CLOSE_CONNECTION", false);
/*
* Set the original script params for a widgetset session, so that any
* Ajax update request has all the information to reload the session.
*/
std::string params;
if (session_.type() == WidgetSet) {
const Http::ParameterMap& m = session_.env().getParameterMap();
for (Http::ParameterMap::const_iterator i = m.begin();
i != m.end(); ++i) {
if (!params.empty())
params += '&';
params
+= Utils::urlEncode(i->first) + '=' + Utils::urlEncode(i->second[0]);
}
}
script.setVar("PARAMS", params);
script.stream(out);
}
if (!serveRest) {
out.spool(response.out());
return;
}
out << app->javaScriptClass() << "._p_.setPage(" << pageId_ << ");";
formObjectsChanged_ = true;
app->autoJavaScriptChanged_ = true;
if (session_.type() == WidgetSet) {
out << app->javaScriptClass() << "._p_.update(null, 'load', null, false);";
} else if (!rendered_) {
serveMainAjax(out);
} else {
bool enabledAjax = app->enableAjax_;
if (app->enableAjax_) {
// Before-load JavaScript of libraries that were loaded directly
// in HTML
collectedJS1_ << "var form = " WT_CLASS ".getElement('Wt-form'); "
"if (form) {" << beforeLoadJS_.str();
beforeLoadJS_.clear();
collectedJS1_
<< "var domRoot=" << app->domRoot_->jsRef() << ';'
<< WT_CLASS ".progressed(domRoot);";
// Load JavaScript libraries that were added during enableAjax()
int librariesLoaded = loadScriptLibraries(collectedJS1_, app);
app->streamBeforeLoadJavaScript(collectedJS1_, false);
collectedJS2_
<< WT_CLASS ".resolveRelativeAnchors();"
<< "domRoot.style.visibility = 'visible';"
<< app->javaScriptClass() << "._p_.doAutoJavaScript();";
loadScriptLibraries(collectedJS2_, app, librariesLoaded);
collectedJS2_ << '}';
app->enableAjax_ = false;
} else
app->streamBeforeLoadJavaScript(out, true);
out << "window." << app->javaScriptClass()
<< "LoadWidgetTree = function(){\n";
if (app->internalPathsEnabled_)
out << app->javaScriptClass() << "._p_.enableInternalPaths("
<< WWebWidget::jsStringLiteral(app->renderedInternalPath_)
<< ");\n";
visibleOnly_ = false;
formObjectsChanged_ = true;
currentFormObjectsList_.clear();
collectJavaScript();
updateLoadIndicator(collectedJS1_, app, true);
LOG_DEBUG("js: " << collectedJS1_.str() << collectedJS2_.str());
out << collectedJS1_.str();
addResponseAckPuzzle(out);
out << app->javaScriptClass()
<< "._p_.setHash("
<< WWebWidget::jsStringLiteral(app->newInternalPath_)
<< ", false);\n";
if (!app->environment().internalPathUsingFragments())
session_.setPagePathInfo(app->newInternalPath_);
out << app->javaScriptClass()
<< "._p_.update(null, 'load', null, false);"
<< collectedJS2_.str()
<< "};"; // LoadWidgetTree = function() { ... }
session_.app()->serverPushChanged_ = true;
renderSetServerPush(out);
if (enabledAjax)
out
/*
* Firefox < 3.5 doesn't have this and in that case it could be
* that we are already ready and jqeury doesn't fire the callback.
*/
<< "\nif (typeof document.readyState === 'undefined')"
<< " setTimeout(function() { "
<< app->javaScriptClass() << "._p_.load(true);"
<< "}, 400);"
<< "else ";
out << "$(document).ready(function() { "
<< app->javaScriptClass() << "._p_.load(true);});\n";
}
out.spool(response.out());
}
void WebRenderer::serveMainAjax(WStringStream& out)
{
Configuration& conf = session_.controller()->configuration();
bool widgetset = session_.type() == WidgetSet;
WApplication *app = session_.app();
WWebWidget *mainWebWidget = app->domRoot_;
visibleOnly_ = true;
/*
* Render root widgets (domRoot_, and for widget set, also children of
* domRoot2_). This automatically creates loading stubs for
* invisible widgets.
*/
app->loadingIndicatorWidget_->show();
DomElement *mainElement = mainWebWidget->createSDomElement(app);
app->loadingIndicatorWidget_->hide();
app->scriptLibrariesAdded_ = app->scriptLibraries_.size();
int librariesLoaded = loadScriptLibraries(out, app);
out << app->javaScriptClass() << "._p_.autoJavaScript=function(){"
<< app->autoJavaScript_ << "};\n";
app->autoJavaScriptChanged_ = false;
app->streamBeforeLoadJavaScript(out, true);
if (!widgetset)
out << "window." << app->javaScriptClass()
<< "LoadWidgetTree = function(){\n";
if (!initialStyleRendered_) {
/*
* In case we have not yet served the bootstyle for this page:
*/
if (app->theme()) {
std::vector styleSheets = app->theme()->styleSheets();
for (unsigned i = 0; i < styleSheets.size(); ++i)
loadStyleSheet(out, app, styleSheets[i]);
}
app->styleSheetsAdded_ = app->styleSheets_.size();
loadStyleSheets(out, app);
initialStyleRendered_ = true;
}
/*
* Need to do this after createSDomElement, since additional CSS/JS
* may be made during rendering, e.g. from WViewWidget::render()
*/
if (conf.inlineCss())
app->styleSheet().javaScriptUpdate(app, out, true);
if (app->bodyHtmlClassChanged_) {
std::string op = widgetset ? "+=" : "=";
out << "document.body.parentNode.className" << op << '\'' << app->htmlClass_ << "';"
<< "document.body.className" << op << '\'' << bodyClassRtl() << "';"
<< "document.body.setAttribute('dir', '";
if (app->layoutDirection() == LeftToRight)
out << "LTR";
else
out << "RTL";
out << "');";
}
#ifdef WT_DEBUG_ENABLED
WStringStream s;
#else
WStringStream& s = out;
#endif // WT_DEBUG_ENABLED
mainElement->addToParent(s, "document.body", widgetset ? 0 : -1, app);
delete mainElement;
addResponseAckPuzzle(s);
if (app->hasQuit())
s << app->javaScriptClass() << "._p_.quit("
<< (app->quittedMessage_.empty() ? "null" :
app->quittedMessage_.jsStringLiteral()) + ");";
if (widgetset)
app->domRoot2_->rootAsJavaScript(app, s, true);
#ifdef WT_DEBUG_ENABLED
LOG_DEBUG("js: " << s.str());
out << s.str();
#endif // WT_DEBUG_ENABLED
currentFormObjectsList_ = createFormObjectsList(app);
out << app->javaScriptClass()
<< "._p_.setFormObjects([" << currentFormObjectsList_ << "]);\n";
formObjectsChanged_ = false;
setRendered(true);
setJSSynced(true);
preLearnStateless(app, collectedJS1_);
LOG_DEBUG("js: " << collectedJS1_.str());
out << collectedJS1_.str();
collectedJS1_.clear();
updateLoadIndicator(out, app, true);
if (widgetset) {
const std::string *historyE = app->environment().getParameter("Wt-history");
if (historyE) {
out << WT_CLASS << ".history.initialize('"
<< (*historyE)[0] << "-field', '"
<< (*historyE)[0] << "-iframe', '');\n";
}
}
app->streamAfterLoadJavaScript(out);
out << "{var o=null,e=null;"
<< app->hideLoadingIndicator_.javaScript()
<< '}';
if (!widgetset) {
if (!app->isQuited())
out << session_.app()->javaScriptClass()
<< "._p_.update(null, 'load', null, false);\n";
out << "};\n";
}
renderSetServerPush(out);
out << "$(document).ready(function() { "
<< app->javaScriptClass() << "._p_.load(" << !widgetset << ");});\n";
loadScriptLibraries(out, app, librariesLoaded);
}
void WebRenderer::setJSSynced(bool invisibleToo)
{
LOG_DEBUG("setJSSynced: " << invisibleToo);
collectedJS1_.clear();
collectedJS2_.clear();
if (!invisibleToo)
collectedJS1_ << invisibleJS_.str();
invisibleJS_.clear();
}
std::string WebRenderer::safeJsStringLiteral(const std::string& value)
{
std::string s = WWebWidget::jsStringLiteral(value);
return Wt::Utils::replace(s, "<", "<'+'");
}
void WebRenderer::updateLoadIndicator(WStringStream& out, WApplication *app,
bool all)
{
if (app->showLoadingIndicator_.needsUpdate(all)) {
out << "showLoadingIndicator = function() {var o=null,e=null;\n"
<< app->showLoadingIndicator_.javaScript() << "};\n";
app->showLoadingIndicator_.updateOk();
}
if (app->hideLoadingIndicator_.needsUpdate(all)) {
out << "hideLoadingIndicator = function() {var o=null,e=null;\n"
<< app->hideLoadingIndicator_.javaScript() << "};\n";
app->hideLoadingIndicator_.updateOk();
}
}
void WebRenderer::renderStyleSheet(WStringStream& out,
const WCssStyleSheet& sheet,
WApplication *app)
{
out << " sheets = app->theme()->styleSheets();
for (unsigned i = 0; i < sheets.size(); ++i)
renderStyleSheet(styleSheets, sheets[i], app);
}
for (unsigned i = 0; i < app->styleSheets_.size(); ++i)
renderStyleSheet(styleSheets, app->styleSheets_[i], app);
app->styleSheetsAdded_ = 0;
initialStyleRendered_ = true;
beforeLoadJS_.clear();
for (unsigned i = 0; i < app->scriptLibraries_.size(); ++i) {
std::string url = app->scriptLibraries_[i].uri;
styleSheets << "\n";
beforeLoadJS_ << app->scriptLibraries_[i].beforeLoadJS;
}
app->scriptLibrariesAdded_ = 0;
app->newBeforeLoadJavaScript_ = app->beforeLoadJavaScript_.length();
bool hybridPage = session_.progressiveBoot() || session_.env().ajax();
FileServe page(hybridPage ? skeletons::Hybrid_html1 : skeletons::Plain_html1);
setPageVars(page);
page.setVar("SESSION_ID", session_.sessionId());
std::string url
= (app->environment().agentIsSpiderBot() || !session_.useUrlRewriting())
? session_.bookmarkUrl(app->newInternalPath_)
: session_.mostRelativeUrl(app->newInternalPath_);
url = session_.fixRelativeUrl(url);
url = Wt::Utils::replace(url, '&', "&");
page.setVar("RELATIVE_URL", url);
if (conf.inlineCss()) {
WStringStream css;
app->styleSheet().cssText(css, true);
page.setVar("STYLESHEET", css.str());
} else
page.setVar("STYLESHEET", "");
page.setVar("STYLESHEETS", styleSheets.str());
page.setVar("TITLE", WWebWidget::escapeText(app->title()).toUTF8());
app->titleChanged_ = false;
std::string contentType = "text/html; charset=UTF-8";
setCaching(response, false);
response.addHeader("X-Frame-Options", "SAMEORIGIN");
setHeaders(response, contentType);
currentFormObjectsList_ = createFormObjectsList(app);
if (hybridPage)
streamBootContent(response, page, true);
WStringStream out(response.out());
page.streamUntil(out, "HTML");
DomElement::TimeoutList timeouts;
{
EscapeOStream js;
EscapeOStream eout(out);
mainElement->asHTML(eout, js, timeouts);
/*
* invisibleJS_ is being streamed as the first JavaScript inside
* collectJavaScript(). This is where this belongs since between
* the HTML and the script there may already be changes (because
* of server push) that delete elements that were rendered.
*/
invisibleJS_ << js.str();
delete mainElement;
app->domRoot_->doneRerender();
}
int refresh;
if (app->environment().ajax()) {
WStringStream str;
DomElement::createTimeoutJs(str, timeouts, app);
app->doJavaScript(str.str());
refresh = 1000000;
} else {
if (app->isQuited() || conf.sessionTimeout() == -1)
refresh = 1000000;
else {
refresh = conf.sessionTimeout() / 3;
for (unsigned i = 0; i < timeouts.size(); ++i)
refresh = std::min(refresh, 1 + timeouts[i].msec/1000);
}
}
page.setVar("REFRESH", boost::lexical_cast(refresh));
page.stream(out);
app->internalPathIsChanged_ = false;
out.spool(response.out());
}
int WebRenderer::loadScriptLibraries(WStringStream& out,
WApplication *app, int count)
{
if (count == -1) {
int first = app->scriptLibraries_.size() - app->scriptLibrariesAdded_;
for (unsigned i = first; i < app->scriptLibraries_.size(); ++i) {
std::string uri = session_.fixRelativeUrl(app->scriptLibraries_[i].uri);
out << app->scriptLibraries_[i].beforeLoadJS
<< app->javaScriptClass() << "._p_.loadScript('" << uri << "',";
DomElement::jsStringLiteral(out, app->scriptLibraries_[i].symbol, '\'');
out << ");\n";
out << app->javaScriptClass() << "._p_.onJsLoad(\""
<< uri << "\",function() {\n";
}
count = app->scriptLibrariesAdded_;
app->scriptLibrariesAdded_ = 0;
return count;
} else {
if (count) {
out << app->javaScriptClass() << "._p_.doAutoJavaScript();";
for (int i = 0; i < count; ++i)
out << "});";
}
return 0;
}
}
void WebRenderer::loadStyleSheet(WStringStream& out, WApplication *app,
const WCssStyleSheet& sheet)
{
out << WT_CLASS << ".addStyleSheet('"
<< sheet.link().resolveUrl(app) << "', '"
<< sheet.media() << "');\n ";
}
void WebRenderer::removeStyleSheets(WStringStream& out, WApplication *app)
{
for (int i = (int)app->styleSheetsToRemove_.size() - 1; i > -1; --i){
out << WT_CLASS << ".removeStyleSheet('"
<< app->styleSheetsToRemove_[i].link().resolveUrl(app) << "');\n ";
app->styleSheetsToRemove_.erase(app->styleSheetsToRemove_.begin() + i);
}
}
void WebRenderer::loadStyleSheets(WStringStream& out, WApplication *app)
{
int first = app->styleSheets_.size() - app->styleSheetsAdded_;
for (unsigned i = first; i < app->styleSheets_.size(); ++i)
loadStyleSheet(out, app, app->styleSheets_[i]);
removeStyleSheets(out, app);
app->styleSheetsAdded_ = 0;
}
void WebRenderer::collectChanges(std::vector& changes)
{
WApplication *app = session_.app();
do {
moreUpdates_ = false;
std::multimap depthOrder;
for (UpdateMap::const_iterator i = updateMap_.begin();
i != updateMap_.end(); ++i) {
int depth = 1;
WWidget *ww = *i;
WWidget *w = ww;
for (; w->parent(); ++depth)
w = w->parent();
if (w != app->domRoot_ && w != app->domRoot2_) {
LOG_DEBUG("ignoring: " << ww->id() << " (" << DESCRIBE(ww) << ") " <<
w->id() << " (" << DESCRIBE(w) << ")");
// not in displayed widgets: will be removed from the update list
depth = 0;
}
#ifndef WT_TARGET_JAVA
depthOrder.insert(std::make_pair(depth, ww));
#else
depthOrder.insert(depth, ww);
#endif // WT_TARGET_JAVA
}
for (std::multimap::const_iterator i = depthOrder.begin();
i != depthOrder.end(); ++i) {
UpdateMap::iterator j = updateMap_.find(i->second);
if (j != updateMap_.end()) {
WWidget *w = i->second;
// depth == 0: remove it from the update list
if (i->first == 0) {
w->webWidget()->propagateRenderOk();
continue;
}
LOG_DEBUG("updating: " << w->id() << " (" << DESCRIBE(w) << ")");
if (!learning_ && visibleOnly_) {
if (w->isRendered()) {
w->getSDomChanges(changes, app);
/* if (!w->isVisible()) {
// We should postpone rendering the changes -- but
// at the same time need to propageRenderOk() now for stateless
// slot learning to work properly.
w->getSDomChanges(changes, app);
} else
w->getSDomChanges(changes, app); */
} else {
LOG_DEBUG("Ignoring: " << w->id());
}
} else {
w->getSDomChanges(changes, app);
}
}
}
} while (!learning_ && moreUpdates_);
}
void WebRenderer::collectJavaScriptUpdate(WStringStream& out)
{
WApplication *app = session_.app();
out << '{';
if (session_.sessionIdChanged_) {
if (session_.hasSessionIdInUrl()) {
if (app->environment().ajax() &&
!app->environment().internalPathUsingFragments()) {
streamRedirectJS(out, app->url(app->internalPath()));
// better would be to use HTML5 history in this case but that would
// need some minor JavaScript reorganizations
} else {
streamRedirectJS(out, app->url(app->internalPath()));
}
out << '}';
return;
}
out << session_.app()->javaScriptClass()
<< "._p_.setSessionUrl("
<< WWebWidget::jsStringLiteral(sessionUrl())
<< ");";
session_.sessionIdChanged_ = false;
}
collectJS(&out);
/*
* Now, as we have cleared and recorded all JavaScript changes that were
* caused by the actual code, we can learn stateless code and collect
* changes that result.
*/
preLearnStateless(app, out);
if (formObjectsChanged_) {
std::string formObjectsList = createFormObjectsList(app);
if (formObjectsList != currentFormObjectsList_) {
currentFormObjectsList_ = formObjectsList;
out << app->javaScriptClass()
<< "._p_.setFormObjects([" << currentFormObjectsList_ << "]);";
}
}
app->streamAfterLoadJavaScript(out);
if (app->isQuited())
out << app->javaScriptClass() << "._p_.quit("
<< (app->quittedMessage_.empty() ? "null" :
app->quittedMessage_.jsStringLiteral()) + ");";
if (updateLayout_) {
out << "window.onresize();";
updateLayout_ = false;
}
app->renderedInternalPath_ = app->newInternalPath_;
updateLoadIndicator(out, app, false);
out << '}';
}
void WebRenderer::updateFormObjects(WWebWidget *source, bool checkDescendants)
{
formObjectsChanged_ = true;
}
void WebRenderer::updateFormObjectsList(WApplication *app)
{
if (formObjectsChanged_) {
currentFormObjects_.clear();
app->domRoot_->getFormObjects(currentFormObjects_);
if (app->domRoot2_)
app->domRoot2_->getFormObjects(currentFormObjects_);
}
}
std::string WebRenderer::createFormObjectsList(WApplication *app)
{
updateFormObjectsList(app);
std::string result;
for (FormObjectsMap::const_iterator i = currentFormObjects_.begin();
i != currentFormObjects_.end(); ++i) {
if (!result.empty())
result += ',';
result += "'" + i->first + "'";
}
formObjectsChanged_ = false;
return result;
}
void WebRenderer::collectJS(WStringStream* js)
{
std::vector changes;
collectChanges(changes);
WApplication *app = session_.app();
if (js) {
if (!preLearning())
app->streamBeforeLoadJavaScript(*js, false);
Configuration& conf = session_.controller()->configuration();
if (conf.inlineCss())
app->styleSheet().javaScriptUpdate(app, *js, false);
EscapeOStream sout(*js);
for (unsigned i = 0; i < changes.size(); ++i)
changes[i]->asJavaScript(sout, DomElement::Delete);
for (unsigned i = 0; i < changes.size(); ++i) {
changes[i]->asJavaScript(sout, DomElement::Update);
delete changes[i];
}
} else {
for (unsigned i = 0; i < changes.size(); ++i)
delete changes[i];
}
if (js) {
if (app->titleChanged_) {
*js << app->javaScriptClass()
<< "._p_.setTitle(" << app->title().jsStringLiteral() << ");\n";
}
if (app->closeMessageChanged_) {
*js << app->javaScriptClass()
<< "._p_.setCloseMessage(" << app->closeMessage().jsStringLiteral()
<< ");\n";
}
if (app->localeChanged_) {
*js << app->javaScriptClass()
<< "._p_.setLocale(" << WString(app->locale().name()).jsStringLiteral()
<< ");\n";
}
}
app->titleChanged_ = false;
app->closeMessageChanged_ = false;
app->localeChanged_ = false;
if (js) {
int librariesLoaded = loadScriptLibraries(*js, app);
app->streamAfterLoadJavaScript(*js);
if (app->internalPathIsChanged_) {
*js << app->javaScriptClass()
<< "._p_.setHash("
<< WWebWidget::jsStringLiteral(app->newInternalPath_)
<< ", false);\n";
if (!preLearning() && !app->environment().internalPathUsingFragments())
session_.setPagePathInfo(app->newInternalPath_);
}
loadScriptLibraries(*js, app, librariesLoaded);
} else
app->afterLoadJavaScript_.clear();
app->internalPathIsChanged_ = false;
app->renderedInternalPath_ = app->newInternalPath_;
}
void WebRenderer::preLearnStateless(WApplication *app, WStringStream& out)
{
if (!session_.env().ajax())
return;
collectJS(&out);
// TODO optimize this so that only signals which require an update
// are processed instead of looping through all signals.
WApplication::SignalMap& ss = session_.app()->exposedSignals();
for (WApplication::SignalMap::iterator i = ss.begin();
i != ss.end(); ) {
#ifdef WT_TARGET_JAVA
Wt::EventSignalBase *s = i->second.get();
if (!s) {
Utils::eraseAndNext(ss, i);
continue;
}
#else
Wt::EventSignalBase* s = i->second;
#endif // WT_TARGET_JAVA
if (s->sender() == app)
s->processPreLearnStateless(this);
else if (s->canAutoLearn()) {
WWidget *ww = static_cast(s->sender());
if (ww && ww->isRendered())
s->processPreLearnStateless(this);
}
++i;
}
out << statelessJS_.str();
statelessJS_.clear();
}
std::string WebRenderer::learn(WStatelessSlot* slot)
{
if (slot->type() == WStatelessSlot::PreLearnStateless)
learning_ = true;
learningIncomplete_ = false;
slot->trigger();
WStringStream js;
collectJS(&js);
std::string result = js.str();
LOG_DEBUG("learned: " << result);
if (slot->type() == WStatelessSlot::PreLearnStateless) {
slot->undoTrigger();
collectJS(0);
learning_ = false;
} else { // AutoLearnStateless
statelessJS_ << result;
}
if (!learningIncomplete_)
slot->setJavaScript(result);
collectJS(&statelessJS_);
return result;
}
void WebRenderer::learningIncomplete()
{
learningIncomplete_ = true;
}
std::string WebRenderer::headDeclarations() const
{
EscapeOStream result;
const Configuration& conf = session_.env().server()->configuration();
const std::vector& confMetaHeaders = conf.metaHeaders();
std::vector metaHeaders;
for (unsigned i = 0; i < confMetaHeaders.size(); ++i) {
const MetaHeader& m = confMetaHeaders[i];
bool add = true;
if (!m.userAgent.empty()) {
WT_USTRING s = WT_USTRING::fromUTF8(session_.env().userAgent());
WRegExp expr(WT_USTRING::fromUTF8(m.userAgent));
if (!expr.exactMatch(s))
add = false;
}
if (add)
metaHeaders.push_back(confMetaHeaders[i]);
}
if (session_.app()) {
const std::vector& appMetaHeaders
= session_.app()->metaHeaders_;
for (unsigned i = 0; i < appMetaHeaders.size(); ++i) {
const MetaHeader& m = appMetaHeaders[i];
bool add = true;
for (unsigned j = 0; j < metaHeaders.size(); ++j) {
MetaHeader& m2 = metaHeaders[j];
if (m.type == m2.type && m.name == m2.name) {
m2.content = m.content;
add = false;
break;
}
}
if (add)
metaHeaders.push_back(m);
}
}
for (unsigned i = 0; i < metaHeaders.size(); ++i) {
const MetaHeader& m = metaHeaders[i];
result << "metaLinks_.size(); ++i) {
const WApplication::MetaLink& ml = session_.app()->metaLinks_[i];
result << "hide();
decorationStyle().setBorder(WBorder());
WStringStream ss;
ss <<
"function() { "
"""var s = " << jsRef() << ", l = s.getAttribute('loops');"
"""if (l && l != '0') {"
"" "s.setAttribute('loops', l - 1);"
"" << jsPlayerRef() << ".jPlayer('play');"
"""}"
"}";
ended().connect(ss.str());
ended().setNotExposed();
}
void SoundManager::setup(WSound *sound)
{
for (unsigned i = 0; i < sound->media_.size(); ++i) {
const WSound::Source& m = sound->media_[i];
if (getSource(m.encoding) != m.link) {
clearSources();
for (unsigned j = 0; j < sound->media_.size(); ++j) {
const WSound::Source& m2 = sound->media_[j];
addSource(m2.encoding, m2.link);
}
break;
}
}
}
void SoundManager::add(WSound *sound)
{
setup(sound);
}
void SoundManager::play(WSound *sound, int loops)
{
setup(sound);
setAttributeValue("loops", std::string());
setAttributeValue("loops", boost::lexical_cast(loops - 1));
current_ = sound;
WMediaPlayer::play();
}
void SoundManager::stop(WSound *sound)
{
WMediaPlayer::stop();
current_ = 0;
}
bool SoundManager::isFinished(WSound *sound) const
{
if (current_ == sound)
return !playing();
else
return true;
}
// There are no visible elements, so ignore refresh
void SoundManager::refresh()
{ }
}
witty-3.3.4+dfsg.orig/src/web/UriUtils.h 0000644 0001750 0001750 00000001027 12115205475 020322 0 ustar pgquiles pgquiles // This may look like C code, but it's really -*- C++ -*-
/*
* Copyright (C) 2012 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#ifndef URI_UTILS_H_
#define URI_UTILS_H_
#include
#include
namespace Wt {
class DataUri
{
public:
DataUri(const std::string& dataUri);
std::string mimeType;
std::vector data;
static bool isDataUri(const std::string& uri);
private:
void parse(const std::string& dataUri);
};
}
#endif // URI_UTILS_H_
witty-3.3.4+dfsg.orig/src/web/WebController.C 0000644 0001750 0001750 00000047324 12432736450 021274 0 ustar pgquiles pgquiles /*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#include
#ifdef WT_HAVE_GNU_REGEX
#include
#else
#include
#endif // WT_HAVE_GNU_REGEX
#include
#include
#ifdef WT_THREADED
#include
#endif // WT_THREADED
#include "Wt/Utils"
#include "Wt/WApplication"
#include "Wt/WEvent"
#include "Wt/WRandom"
#include "Wt/WResource"
#include "Wt/WServer"
#include "Wt/WSocketNotifier"
#include "Configuration.h"
#include "CgiParser.h"
#include "WebController.h"
#include "WebRequest.h"
#include "WebSession.h"
#include "TimeUtil.h"
#include "WebUtils.h"
#ifdef HAVE_GRAPHICSMAGICK
#include
#endif
#ifndef WT_HAVE_POSIX_FILEIO
// boost bug workaround: see WebController constructor
#include
#endif
#include
namespace {
bool matchesPath(const std::string& path, const std::string& prefix)
{
if (boost::starts_with(path, prefix)) {
unsigned prefixLength = prefix.length();
if (path.length() > prefixLength) {
char next = path[prefixLength];
if (next == '/')
return true;
} else
return true;
}
return false;
}
}
namespace Wt {
LOGGER("WebController");
WebController::WebController(WServer& server,
const std::string& singleSessionId,
bool autoExpire)
: conf_(server.configuration()),
singleSessionId_(singleSessionId),
autoExpire_(autoExpire),
plainHtmlSessions_(0),
ajaxSessions_(0),
#ifdef WT_THREADED
socketNotifier_(this),
#endif // WT_THREADED
server_(server)
{
CgiParser::init();
#ifndef WT_DEBUG_JS
WObject::seedId(WRandom::get());
#else
WObject::seedId(0);
#endif
redirectSecret_ = WRandom::generateId(32);
#ifdef HAVE_GRAPHICSMAGICK
InitializeMagick(0);
#endif
#ifndef WT_HAVE_POSIX_FILEIO
// attempted workaround for:
// https://svn.boost.org/trac/boost/ticket/6320
// https://svn.boost.org/trac/boost/ticket/4889
// https://svn.boost.org/trac/boost/ticket/6690
// https://svn.boost.org/trac/boost/ticket/6737
// Invoking the path constructor here should create the global variables
// in boost.filesystem before the threads are started.
boost::filesystem::path bugFixFilePath("please-initialize-globals");
#endif
start();
}
WebController::~WebController()
{
#ifdef HAVE_GRAPHICSMAGICK
DestroyMagick();
#endif
}
void WebController::start()
{
running_ = true;
}
void WebController::shutdown()
{
std::vector > sessionList;
{
#ifdef WT_THREADED
boost::recursive_mutex::scoped_lock lock(mutex_);
#endif // WT_THREADED
running_ = false;
LOG_INFO_S(&server_, "shutdown: stopping sessions.");
for (SessionMap::iterator i = sessions_.begin(); i != sessions_.end(); ++i)
sessionList.push_back(i->second);
sessions_.clear();
ajaxSessions_ = 0;
plainHtmlSessions_ = 0;
}
for (unsigned i = 0; i < sessionList.size(); ++i) {
boost::shared_ptr session = sessionList[i];
WebSession::Handler handler(session, WebSession::Handler::TakeLock);
session->expire();
}
}
Configuration& WebController::configuration()
{
return conf_;
}
int WebController::sessionCount() const
{
return sessions_.size();
}
std::vector WebController::sessions()
{
#ifdef WT_THREADED
boost::recursive_mutex::scoped_lock lock(mutex_);
#endif
std::vector sessionIds;
for (SessionMap::const_iterator i = sessions_.begin(); i != sessions_.end(); ++i) {
sessionIds.push_back(i->first);
}
return sessionIds;
}
bool WebController::expireSessions()
{
std::vector > toExpire;
bool result;
{
Time now;
#ifdef WT_THREADED
boost::recursive_mutex::scoped_lock lock(mutex_);
#endif // WT_THREADED
for (SessionMap::iterator i = sessions_.begin(); i != sessions_.end();) {
boost::shared_ptr session = i->second;
int diff = session->expireTime() - now;
if (diff < 1000 && configuration().sessionTimeout() != -1) {
if (session->shouldDisconnect()) {
if (session->app()->connected_) {
session->app()->connected_ = false;
LOG_INFO_S(session, "timeout: disconnected");
}
++i;
} else {
toExpire.push_back(session);
if (session->env().ajax())
--ajaxSessions_;
else
--plainHtmlSessions_;
sessions_.erase(i++);
}
} else
++i;
}
result = !sessions_.empty();
}
for (unsigned i = 0; i < toExpire.size(); ++i) {
boost::shared_ptr session = toExpire[i];
LOG_INFO_S(session, "timeout: expiring");
WebSession::Handler handler(session, WebSession::Handler::TakeLock);
session->expire();
}
toExpire.clear();
if (configuration().singleSession()) {
#ifdef WT_THREADED
boost::recursive_mutex::scoped_lock lock(mutex_);
#endif // WT_THREADED
if (sessions_.size() == 0) {
server_.scheduleStop();
}
}
return result;
}
void WebController::addSession(boost::shared_ptr session)
{
#ifdef WT_THREADED
boost::recursive_mutex::scoped_lock lock(mutex_);
#endif // WT_THREADED
sessions_[session->sessionId()] = session;
}
void WebController::removeSession(const std::string& sessionId)
{
#ifdef WT_THREADED
boost::recursive_mutex::scoped_lock lock(mutex_);
#endif // WT_THREADED
LOG_INFO("Removing session " << sessionId);
SessionMap::iterator i = sessions_.find(sessionId);
if (i != sessions_.end()) {
if (i->second->env().ajax())
--ajaxSessions_;
else
--plainHtmlSessions_;
sessions_.erase(i);
}
if (configuration().singleSession() && sessions_.size() == 0) {
server_.scheduleStop();
}
}
std::string WebController::appSessionCookie(const std::string& url)
{
return Utils::urlEncode(url);
}
std::string WebController::sessionFromCookie(const char *cookies,
const std::string& scriptName,
int sessionIdLength)
{
if (!cookies)
return std::string();
std::string cookieName = appSessionCookie(scriptName);
#ifndef WT_HAVE_GNU_REGEX
boost::regex
cookieSession_e(".*\\Q" + cookieName
+ "\\E=\"?([a-zA-Z0-9]{"
+ boost::lexical_cast(sessionIdLength)
+ "})\"?.*");
boost::smatch what;
std::string cookiesAsStdString(cookies);
if (boost::regex_match(cookiesAsStdString, what, cookieSession_e))
return what[1];
else
return std::string();
#else
std::string cookieSession_ep
= cookieName + "=\"\\?\\([a-zA-Z0-9]\\{"
+ boost::lexical_cast(sessionIdLength) + "\\}\\)\"\\?";
regex_t cookieSession_e;
regcomp(&cookieSession_e, cookieSession_ep.c_str(), 0);
regmatch_t pmatch[2];
int res = regexec(&cookieSession_e, cookies.c_str(), 2, pmatch, 0);
regfree(&cookieSession_e);
if (res == 0) {
return cookies.substr(pmatch[1].rm_so,
pmatch[1].rm_eo - pmatch[1].rm_so);
} else
return std::string();
#endif
}
#ifdef WT_THREADED
WebController::SocketNotifierMap&
WebController::socketNotifiers(WSocketNotifier::Type type)
{
switch (type) {
case WSocketNotifier::Read:
return socketNotifiersRead_;
case WSocketNotifier::Write:
return socketNotifiersWrite_;
case WSocketNotifier::Exception:
default: // to avoid return warning
return socketNotifiersExcept_;
}
}
#endif // WT_THREADED
void WebController::socketSelected(int descriptor, WSocketNotifier::Type type)
{
#ifdef WT_THREADED
/*
* Find notifier, extract session Id
*/
std::string sessionId;
{
boost::recursive_mutex::scoped_lock lock(notifierMutex_);
SocketNotifierMap ¬ifiers = socketNotifiers(type);
SocketNotifierMap::iterator k = notifiers.find(descriptor);
if (k == notifiers.end()) {
LOG_ERROR_S(&server_, "socketSelected(): socket notifier should have been "
"cancelled?");
return;
} else {
sessionId = k->second->sessionId();
}
}
server_.post(sessionId, boost::bind(&WebController::socketNotify,
this, descriptor, type));
#endif // WT_THREADED
}
#ifdef WT_THREADED
void WebController::socketNotify(int descriptor, WSocketNotifier::Type type)
{
WSocketNotifier *notifier = 0;
{
boost::recursive_mutex::scoped_lock lock(notifierMutex_);
SocketNotifierMap ¬ifiers = socketNotifiers(type);
SocketNotifierMap::iterator k = notifiers.find(descriptor);
if (k != notifiers.end()) {
notifier = k->second;
notifiers.erase(k);
}
}
if (notifier)
notifier->notify();
}
#endif // WT_THREADED
void WebController::addSocketNotifier(WSocketNotifier *notifier)
{
#ifdef WT_THREADED
{
boost::recursive_mutex::scoped_lock lock(notifierMutex_);
socketNotifiers(notifier->type())[notifier->socket()] = notifier;
}
switch (notifier->type()) {
case WSocketNotifier::Read:
socketNotifier_.addReadSocket(notifier->socket());
break;
case WSocketNotifier::Write:
socketNotifier_.addWriteSocket(notifier->socket());
break;
case WSocketNotifier::Exception:
socketNotifier_.addExceptSocket(notifier->socket());
break;
}
#endif // WT_THREADED
}
void WebController::removeSocketNotifier(WSocketNotifier *notifier)
{
#ifdef WT_THREADED
switch (notifier->type()) {
case WSocketNotifier::Read:
socketNotifier_.removeReadSocket(notifier->socket());
break;
case WSocketNotifier::Write:
socketNotifier_.removeWriteSocket(notifier->socket());
break;
case WSocketNotifier::Exception:
socketNotifier_.removeExceptSocket(notifier->socket());
break;
}
boost::recursive_mutex::scoped_lock lock(notifierMutex_);
SocketNotifierMap ¬ifiers = socketNotifiers(notifier->type());
SocketNotifierMap::iterator i = notifiers.find(notifier->socket());
if (i != notifiers.end())
notifiers.erase(i);
#endif // WT_THREADED
}
bool WebController::requestDataReceived(WebRequest *request,
boost::uintmax_t current,
boost::uintmax_t total)
{
#ifdef WT_THREADED
boost::mutex::scoped_lock lock(uploadProgressUrlsMutex_);
#endif // WT_THREADED
if (!running_)
return false;
if (uploadProgressUrls_.find(request->queryString())
!= uploadProgressUrls_.end()) {
#ifdef WT_THREADED
lock.unlock();
#endif // WT_THREADED
CgiParser cgi(conf_.maxRequestSize());
try {
cgi.parse(*request, CgiParser::ReadHeadersOnly);
} catch (std::exception& e) {
LOG_ERROR_S(&server_, "could not parse request: " << e.what());
return false;
}
const std::string *wtdE = request->getParameter("wtd");
if (!wtdE)
return false;
std::string sessionId = *wtdE;
ApplicationEvent event(sessionId,
boost::bind(&WebController::updateResourceProgress,
this, request, current, total));
if (handleApplicationEvent(event))
return !request->postDataExceeded();
else
return false;
}
return true;
}
void WebController::updateResourceProgress(WebRequest *request,
boost::uintmax_t current,
boost::uintmax_t total)
{
WebSession::Handler::instance()->setRequest(request, (WebResponse *)request);
WApplication *app = WApplication::instance();
const std::string *requestE = request->getParameter("request");
WResource *resource = 0;
if (!requestE && !request->pathInfo().empty())
resource = app->decodeExposedResource("/path/" + request->pathInfo());
if (!resource) {
const std::string *resourceE = request->getParameter("resource");
resource = app->decodeExposedResource(*resourceE);
}
if (resource)
resource->dataReceived().emit(current, total);
}
bool WebController::handleApplicationEvent(const ApplicationEvent& event)
{
/*
* This should always be run from within a virgin thread of the
* thread-pool
*/
assert(!WebSession::Handler::instance());
/*
* Find session (and guard it against deletion)
*/
boost::shared_ptr session;
{
#ifdef WT_THREADED
boost::recursive_mutex::scoped_lock lock(mutex_);
#endif // WT_THREADED
SessionMap::iterator i = sessions_.find(event.sessionId);
if (i != sessions_.end() && !i->second->dead())
session = i->second;
}
if (!session) {
if (event.fallbackFunction)
event.fallbackFunction();
return false;
} else
session->queueEvent(event);
/*
* Try to take the session lock now to propagate the event to the
* application.
*/
{
WebSession::Handler handler(session, WebSession::Handler::TryLock);
}
return true;
}
void WebController::addUploadProgressUrl(const std::string& url)
{
#ifdef WT_THREADED
boost::mutex::scoped_lock lock(uploadProgressUrlsMutex_);
#endif // WT_THREADED
uploadProgressUrls_.insert(url.substr(url.find("?") + 1));
}
void WebController::removeUploadProgressUrl(const std::string& url)
{
#ifdef WT_THREADED
boost::mutex::scoped_lock lock(uploadProgressUrlsMutex_);
#endif // WT_THREADED
uploadProgressUrls_.erase(url.substr(url.find("?") + 1));
}
std::string WebController::computeRedirectHash(const std::string& url)
{
return Utils::base64Encode(Utils::md5(redirectSecret_ + url));
}
void WebController::handleRequest(WebRequest *request)
{
if (!running_) {
request->setStatus(500);
request->flush();
return;
}
if (!request->entryPoint_) {
request->entryPoint_ = getEntryPoint(request);
if (!request->entryPoint_) {
request->setStatus(404);
request->flush();
return;
}
}
CgiParser cgi(conf_.maxRequestSize());
try {
cgi.parse(*request, conf_.needReadBodyBeforeResponse()
? CgiParser::ReadBodyAnyway
: CgiParser::ReadDefault);
} catch (std::exception& e) {
LOG_ERROR_S(&server_, "could not parse request: " << e.what());
request->setContentType("text/html");
request->out()
<< "Error occurred. "
<< "Error occurred. "
"Error parsing CGI request: " << e.what() << std::endl;
request->flush(WebResponse::ResponseDone);
return;
}
if (request->entryPoint_->type() == StaticResource) {
request
->entryPoint_->resource()->handle(request, (WebResponse *)request);
return;
}
const std::string *requestE = request->getParameter("request");
if (requestE && *requestE == "redirect") {
const std::string *urlE = request->getParameter("url");
const std::string *hashE = request->getParameter("hash");
if (urlE && hashE) {
if (*hashE != computeRedirectHash(*urlE))
hashE = 0;
}
if (urlE && hashE) {
request->setRedirect(*urlE);
} else {
request->setContentType("text/html");
request->out()
<< "Error occurred. "
<< "Error occurred. Invalid redirect.
" << std::endl;
}
request->flush(WebResponse::ResponseDone);
return;
}
std::string sessionId;
/*
* Get session from request.
*/
const std::string *wtdE = request->getParameter("wtd");
if (conf_.sessionTracking() == Configuration::CookiesURL
&& !conf_.reloadIsNewSession())
sessionId = sessionFromCookie(request->headerValue("Cookie"),
request->scriptName(),
conf_.sessionIdLength());
if (sessionId.empty() && wtdE)
sessionId = *wtdE;
boost::shared_ptr session;
{
#ifdef WT_THREADED
boost::recursive_mutex::scoped_lock lock(mutex_);
#endif // WT_THREADED
if (!singleSessionId_.empty() && sessionId != singleSessionId_) {
if (conf_.persistentSessions()) {
// This may be because of a race condition in the filesystem:
// the session file is renamed in generateNewSessionId() but
// still a request for an old session may have arrived here
// while this was happening.
//
// If it is from the old app, We should be sent a reload signal,
// this is what will be done by a new session (which does not create
// an application).
//
// If it is another request to take over the persistent session,
// it should be handled by the persistent session. We can distinguish
// using the type of the request
LOG_INFO_S(&server_,
"persistent session requested Id: " << sessionId << ", "
<< "persistent Id: " << singleSessionId_);
if (sessions_.empty() || strcmp(request->requestMethod(), "GET") == 0)
sessionId = singleSessionId_;
} else
sessionId = singleSessionId_;
}
SessionMap::iterator i = sessions_.find(sessionId);
if (i == sessions_.end() || i->second->dead()) {
try {
if (singleSessionId_.empty()) {
do {
sessionId = conf_.generateSessionId();
if (!conf_.registerSessionId(std::string(), sessionId))
sessionId.clear();
} while (sessionId.empty());
}
std::string favicon = request->entryPoint_->favicon();
if (favicon.empty())
conf_.readConfigurationProperty("favicon", favicon);
session.reset(new WebSession(this, sessionId,
request->entryPoint_->type(),
favicon, request));
if (configuration().sessionTracking() == Configuration::CookiesURL)
request->addHeader("Set-Cookie",
appSessionCookie(request->scriptName())
+ "=" + sessionId + "; Version=1;"
+ " Path=" + session->env().deploymentPath()
+ "; httponly;");
sessions_[sessionId] = session;
++plainHtmlSessions_;
} catch (std::exception& e) {
LOG_ERROR_S(&server_, "could not create new session: " << e.what());
request->flush(WebResponse::ResponseDone);
return;
}
} else {
session = i->second;
}
}
bool handled = false;
{
WebSession::Handler handler(session, *request, *(WebResponse *)request);
if (!session->dead()) {
handled = true;
session->handleRequest(handler);
}
}
if (session->dead())
removeSession(sessionId);
session.reset();
if (autoExpire_)
expireSessions();
if (!handled)
handleRequest(request);
}
WApplication *WebController::doCreateApplication(WebSession *session)
{
const EntryPoint *ep
= WebSession::Handler::instance()->request()->entryPoint_;
return ep->appCallback()(session->env());
}
const EntryPoint *WebController::getEntryPoint(WebRequest *request)
{
const std::string& scriptName = request->scriptName();
const std::string& pathInfo = request->pathInfo();
// Only one default entry point.
if (conf_.entryPoints().size() == 1
&& conf_.entryPoints()[0].path().empty())
return &conf_.entryPoints()[0];
// Multiple entry points.
int bestMatch = -1;
std::size_t bestLength = 0;
for (unsigned i = 0; i < conf_.entryPoints().size(); ++i) {
const Wt::EntryPoint& ep = conf_.entryPoints()[i];
if (ep.path().empty()) {
if (bestLength == 0)
bestMatch = i;
} else {
if (ep.path().length() > bestLength) {
if (matchesPath(scriptName + pathInfo, ep.path()) ||
matchesPath(pathInfo, ep.path())) {
bestLength = ep.path().length();
bestMatch = i;
}
}
}
}
if (bestMatch >= 0)
return &conf_.entryPoints()[bestMatch];
else
return 0;
}
std::string
WebController::generateNewSessionId(boost::shared_ptr session)
{
#ifdef WT_THREADED
boost::recursive_mutex::scoped_lock lock(mutex_);
#endif // WT_THREADED
std::string newSessionId;
do {
newSessionId = conf_.generateSessionId();
if (!conf_.registerSessionId(session->sessionId(), newSessionId))
newSessionId.clear();
} while (newSessionId.empty());
sessions_[newSessionId] = session;
SessionMap::iterator i = sessions_.find(session->sessionId());
sessions_.erase(i);
if (!singleSessionId_.empty())
singleSessionId_ = newSessionId;
return newSessionId;
}
void WebController::newAjaxSession()
{
#ifdef WT_THREADED
boost::recursive_mutex::scoped_lock lock(mutex_);
#endif // WT_THREADED
--plainHtmlSessions_;
++ajaxSessions_;
}
bool WebController::limitPlainHtmlSessions()
{
if (conf_.maxPlainSessionsRatio() > 0) {
#ifdef WT_THREADED
boost::recursive_mutex::scoped_lock lock(mutex_);
#endif // WT_THREADED
if (plainHtmlSessions_ + ajaxSessions_ > 20)
return plainHtmlSessions_ > conf_.maxPlainSessionsRatio()
* (ajaxSessions_ + plainHtmlSessions_);
else
return false;
} else
return false;
}
}
witty-3.3.4+dfsg.orig/src/web/CMakeLists.txt 0000644 0001750 0001750 00000000124 12303212464 021121 0 ustar pgquiles pgquiles INSTALL_FILES(/include/Wt DomElement.h)
INSTALL_FILES(/include/Wt EscapeOStream.h)
witty-3.3.4+dfsg.orig/src/web/TimeUtil.h 0000644 0001750 0001750 00000001206 12222311752 020270 0 ustar pgquiles pgquiles // This may look like C code, but it's really -*- C++ -*-
/*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#ifndef TIMEUTIL_H_
#define TIMEUTIL_H_
#include
struct timeval;
namespace Wt {
class TimeImpl;
class WT_API Time
{
public:
Time(); // now
~Time(); // now
Time(const Time &other);
Time operator+ (int msec) const;
Time& operator+= (int msec);
Time& operator= (const Time &other);
int operator- (const Time& other) const;
private:
// Pointer to avoid inclusion of windows header files in wt
class TimeImpl *t_;
};
}
#endif // TIMEUTIL_H_
witty-3.3.4+dfsg.orig/src/web/base64.h 0000644 0001750 0001750 00000010770 11757153720 017641 0 ustar pgquiles pgquiles /* base64.hpp - base64 encoder/decoder implementing section 6.8 of RFC2045
Copyright (C) 2002 Ryan Petrie (ryanpetrie@netscape.net)
and released under the zlib license:
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
--------------------------------------------------------------------------
base64::encoder and base64::decoder are intended to be identical in usage
as the STL's std::copy and similar algorithms. They require as parameters
an input iterator range and an output iterator, and just as std::copy, the
iterators can be bare pointers, container iterators, or even adaptors such
as ostream_iterator.
Examples:
// encode/decode with in-place memory buffers
char source[size], dest[size*2];
base64::encode(source, source+size, dest);
base64::decode(dest, dest+size*2, source);
// encode from memory to a file
char source[size];
ofstream file("output.txt");
base64::encode((char*)source, source+size, ostream_iterator(file));
// decode from file to a standard container
ifstream file("input.txt");
vector dest;
base64::decode(istream_iterator(file), istream_iterator(),
back_inserter(dest)
);
*/
#ifndef _BASE64_HPP
#define _BASE64_HPP
#include
#include "Wt/WDllDefs.h"
namespace base64
{
typedef unsigned uint32;
typedef unsigned char uint8;
extern WT_API const char* to_table;
extern WT_API const char* to_table_end;
extern WT_API const char* from_table;
template
void encode(const InputIterator& begin,
const InputIterator& end,
OutputIterator out,
bool crlf = true)
{
InputIterator it = begin;
int lineSize = 0;
int bytes;
do
{
uint32 input = 0;
// get the next three bytes into "in" (and count how many we actually get)
bytes = 0;
for(; (bytes < 3) && (it != end); ++bytes, ++it)
{
input <<= 8;
input += static_cast(*it);
}
// convert to base64
int bits = bytes*8;
while (bits > 0)
{
bits -= 6;
const uint8 index = ((bits < 0) ? input << -bits : input >> bits) & 0x3F;
*out = to_table[index];
++out;
++lineSize;
}
if (lineSize >= 76) // ensure proper line length
{
if (crlf) {
*out = 13;
++out;
*out = 10;
++out;
}
lineSize = 0;
}
} while (bytes == 3);
// add pad characters if necessary
if (bytes > 0)
for(int i=bytes; i < 3; ++i)
{
*out = '=';
++out;
}
}
template
void decode(const InputIterator& begin,
const InputIterator& end,
OutputIterator out)
{
InputIterator it = begin;
int chars;
do
{
uint8 input[4] = {0, 0, 0, 0};
// get four characters
chars=0;
while((chars<4) && (it != end))
{
uint8 c = static_cast(*it);
if (c == '=') break; // pad character marks the end of the stream
++it;
if (std::find(to_table, to_table_end, c) != to_table_end)
{
input[chars] = from_table[c];
chars++;
}
}
// output the binary data
if (chars >= 2)
{
*out = static_cast((input[0] << 2) + (input[1] >> 4));
++out;
if (chars >= 3)
{
*out = static_cast((input[1] << 4) + (input[2] >> 2));
++out;
if (chars >= 4)
{
*out = static_cast((input[2] << 6) + input[3]);
++out;
}
}
}
} while (chars == 4);
}
} // end namespace
#endif
witty-3.3.4+dfsg.orig/src/web/PdfUtils.C 0000644 0001750 0001750 00000002577 12011162670 020234 0 ustar pgquiles pgquiles /*
* Copyright (C) 2012 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#include "PdfUtils.h"
#include
namespace Wt {
namespace Pdf {
#ifdef WT_TARGET_JAVA
class PdfUtils {
};
#endif //WT_TARGET_JAVA
std::string toBase14Font(const WFont& font)
{
const char *base = 0;
const char *italic = 0;
const char *bold = 0;
switch (font.genericFamily()) {
case WFont::Default:
case WFont::Serif:
case WFont::Fantasy: // Not really !
case WFont::Cursive: // Not really !
base = "Times";
italic = "Italic";
bold = "Bold";
break;
case WFont::SansSerif:
base = "Helvetica";
italic = "Oblique";
bold = "Bold";
break;
case WFont::Monospace:
base = "Courier";
italic = "Oblique";
bold = "Bold";
break;
}
if (font.specificFamilies() == "Symbol")
base = "Symbol";
else if (font.specificFamilies() == "ZapfDingbats")
base = "ZapfDingbats";
if (italic)
switch (font.style()) {
case WFont::NormalStyle:
italic = 0;
break;
default:
break;
}
if (font.weightValue() <= 400)
bold = 0;
std::string name = base;
if (bold) {
name += std::string("-") + bold;
if (italic)
name += italic;
} else if (italic)
name += std::string("-") + italic;
if (name == "Times")
name = "Times-Roman";
return name;
}
}
}
witty-3.3.4+dfsg.orig/src/web/WebSocketMessage.C 0000644 0001750 0001750 00000006436 12273674107 021710 0 ustar pgquiles pgquiles /*
* Copyright (C) 2010 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#include
#include "Wt/WLogger"
#include "WebSession.h"
#include "WebSocketMessage.h"
namespace Wt {
LOGGER("WebSocketMessage");
WebSocketMessage::WebSocketMessage(WebSession *session)
: session_(session)
{
queryString_ = "wtd=" + session_->sessionId() + "&request=jsupdate";
}
void WebSocketMessage::flush(ResponseState state,
const WriteCallback& callback)
{
if (state != ResponseDone)
error("flush(" + boost::lexical_cast(state) + ") expected");
session_->pushUpdates();
delete this;
}
void WebSocketMessage::setWebSocketMessageCallback(const ReadCallback& callback)
{
error("setWebSocketMessageCallback() not supported");
}
bool WebSocketMessage::webSocketMessagePending() const
{
error("webSocketMessagePending() not supported");
return false;
}
std::istream& WebSocketMessage::in()
{
return webSocket()->in();
}
std::ostream& WebSocketMessage::out()
{
return webSocket()->out();
}
std::ostream& WebSocketMessage::err()
{
return webSocket()->err();
}
void WebSocketMessage::setRedirect(const std::string& url)
{
error("setRedirect() not supported");
}
void WebSocketMessage::setStatus(int status)
{
error("setStatus() not supported");
}
void WebSocketMessage::setContentType(const std::string& value)
{
if (value != "text/javascript; charset=UTF-8")
error("setContentType(): text/javascript expected");
}
void WebSocketMessage::setContentLength(::int64_t length)
{
// We have no use for it, web socket messages are framed
}
void WebSocketMessage::addHeader(const std::string& name,
const std::string& value)
{
if (name == "Set-Cookie")
out() << "document.cookie=" << WWebWidget::jsStringLiteral(value) << ";";
}
const char *WebSocketMessage::envValue(const char *name) const
{
return webSocket()->envValue(name);
}
::int64_t WebSocketMessage::contentLength() const
{
webSocket()->in().seekg(0, std::ios::end);
int length = webSocket()->in().tellg();
webSocket()->in().seekg(0, std::ios::beg);
return length;
}
const char *WebSocketMessage::contentType() const
{
return "application/x-www-form-urlencoded";
}
const std::string& WebSocketMessage::serverName() const
{
return webSocket()->serverName();
}
const std::string& WebSocketMessage::serverPort() const
{
return webSocket()->serverPort();
}
const std::string& WebSocketMessage::scriptName() const
{
return webSocket()->scriptName();
}
const char *WebSocketMessage::requestMethod() const
{
return "POST";
}
const std::string& WebSocketMessage::queryString() const
{
return queryString_;
}
const std::string& WebSocketMessage::pathInfo() const
{
return webSocket()->pathInfo();
}
const std::string& WebSocketMessage::remoteAddr() const
{
return webSocket()->remoteAddr();
}
const char *WebSocketMessage::urlScheme() const
{
return "http";
}
Wt::WSslInfo *WebSocketMessage::sslInfo() const
{
return webSocket()->sslInfo();
}
const char *WebSocketMessage::headerValue(const char *name) const
{
return webSocket()->headerValue(name);
}
void WebSocketMessage::error(const std::string& msg) const
{
LOG_ERROR("WebSocketMessage error: " + msg);
}
WebRequest *WebSocketMessage::webSocket() const
{
return session_->asyncResponse_;
}
}
witty-3.3.4+dfsg.orig/src/web/random_device.cpp 0000644 0001750 0001750 00000011530 12303212464 021667 0 ustar pgquiles pgquiles #include
#ifdef WT_NO_BOOST_RANDOM
/* boost random_device.cpp implementation
*
* Copyright Jens Maurer 2000
* Distributed under the Boost Software License, Version 1.0. (See
* accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt)
*
* $Id: random_device.cpp,v 1.4 2008/05/14 09:34:04 kdf Exp $
*
*/
#if WT_WIN32
// Don't link to boost_random
#define BOOST_RANDOM_NO_LIB
// And when compiling, don't add declspec to the classnames.
// We have our own implementation of random_device.cpp (older boosts
// didn't support windows well)
#ifdef BOOST_ALL_DYN_LINK
#undef BOOST_ALL_DYN_LINK
#endif
#ifdef BOOST_RANDOM_DYN_LINK
#undef BOOST_RANDOM_DYN_LINK
#endif
#endif
#include
#include
#include
#include
#ifndef WT_WIN32
# ifndef __CYGWIN__
# define USE_URANDOM
# endif
#endif
#if defined(WT_WIN32) || defined(__CYGWIN__)
# define USE_WIN32_CRYPT
#endif
#ifdef USE_URANDOM
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
// A definition is required even for integral static constants
const bool boost::random_device::has_fixed_range;
const boost::random_device::result_type boost::random_device::min_value;
const boost::random_device::result_type boost::random_device::max_value;
#endif
// the default is the unlimited capacity device, using some secure hash
// try "/dev/random" for blocking when the entropy pool has drained
const char * const boost::random_device::default_token = "/dev/urandom";
/*
* This uses the POSIX interface for unbuffered reading.
* Using buffered std::istream would consume entropy which may
* not actually be used. Entropy is a precious good we avoid
* wasting.
*/
#if defined(__GNUC__) && defined(_CXXRT_STD_NAME)
// I have severe difficulty to get the POSIX includes to work with
// -fhonor-std and Dietmar Kühl's standard C++ library. Hack around that
// problem for now.
extern "C" {
static const int O_RDONLY = 0;
extern int open(const char *__file, int __oflag, ...);
extern int read(int __fd, __ptr_t __buf, size_t __nbytes);
extern int close(int __fd);
}
#else
#include
#include
#include // open
#include // read, close
#endif
#include // errno
#include // strerror
#include // std::invalid_argument
class boost::random_device::impl
{
public:
impl(const std::string & token) : path(token) {
fd = open(token.c_str(), O_RDONLY);
if(fd < 0)
error("cannot open");
}
~impl() { if(close(fd) < 0) error("could not close"); }
unsigned int next() {
unsigned int result;
long sz = read(fd, reinterpret_cast(&result), sizeof(result));
if(sz == -1)
error("error while reading");
else if(sz != sizeof(result)) {
errno = 0;
error("EOF while reading");
}
return result;
}
private:
void error(const std::string & msg) {
throw std::invalid_argument("boost::random_device: " + msg +
" random-number pseudo-device " + path +
": " + strerror(errno));
}
const std::string path;
int fd;
};
#endif
#ifdef USE_WIN32_CRYPT
#include
#include
#include
const char * const boost::random_device::default_token = "";
// Note about thread-safety: according to my reading of the MSDN page
// 'Threading Issues with Cryptographic Service Providers', both the
// CryptAcquireContext and CryptGenRandom functions are thread-safe,
// as we specify CRYPT_VERIFYCONTEXT (IO operations will not be performed
// and aparently those are the only ones causing threading problems)
class boost::random_device::impl
{
public:
impl(const std::string & ) {
InitOk_ = CryptAcquireContext(&hProv_, 0, 0,
PROV_RSA_FULL, CRYPT_VERIFYCONTEXT|CRYPT_SILENT) ? true : false;
if (!InitOk_) error("error while initializing crypt random context");
}
~impl() { if (InitOk_) CryptReleaseContext(hProv_, 0); }
unsigned int next() {
unsigned int result = 0;
if((!InitOk_) ||
(!CryptGenRandom(hProv_, sizeof(result), (BYTE*)&result))) {
error("error while generating random number");
}
return result % RAND_MAX;
}
private:
void error(const std::string & msg) {
throw std::invalid_argument(msg + " ; error code " + boost::lexical_cast(GetLastError()));
}
bool InitOk_;
HCRYPTPROV hProv_;
};
#endif
boost::random_device::random_device(const std::string& token)
: pimpl(new impl(token))
{
assert((std::numeric_limits::max)() == max_value);
}
boost::random_device::~random_device()
{
// the complete class impl is now visible, so we're safe
// (see comment in random.hpp)
delete pimpl;
}
double boost::random_device::entropy() const
{
return 10;
}
unsigned int boost::random_device::operator()()
{
return pimpl->next();
}
#endif
witty-3.3.4+dfsg.orig/src/web/ImageUtils.C 0000644 0001750 0001750 00000007346 12450776057 020565 0 ustar pgquiles pgquiles /*
* Copyright (C) 2012 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#include "ImageUtils.h"
#include "FileUtils.h"
#include "WebUtils.h"
#include "Wt/WException"
#include
namespace {
const int mimeTypeCount = 10;
const char *imageMimeTypes [] = {
"image/png",
"image/jpeg",
"image/gif",
"image/gif",
"image/bmp",
"image/bmp",
"image/bmp",
"image/bmp",
"image/bmp",
"image/bmp"
};
const char *imageHeaders [] = {
"\211PNG\r\n\032\n",
"\377\330\377",
"GIF87a",
"GIF89a",
"BA",
"BM",
"CI",
"CP",
"IC",
"PI"
};
static const int imageHeaderSize [] = {
8,
3,
6,
6,
2,
2,
2,
2,
2,
2
};
#ifndef WT_TARGET_JAVA
#define toUnsigned unsigned
#else
static unsigned toUnsigned(int c) {
unsigned result = c;
if (result < 0)
result += 256;
return result;
}
#endif
}
namespace Wt {
std::string ImageUtils::identifyMimeType(const std::string& fileName)
{
std::vector header = FileUtils::fileHeader(fileName, 25);
if (header.empty())
return "";
else
return identifyMimeType(header);
}
std::string ImageUtils::identifyMimeType(const std::vector&
header)
{
// TODO: also check the filename extension, if parsing the file did not work
for (int i = 0; i < mimeTypeCount; ++i) {
#ifndef WT_TARGET_JAVA
if (std::memcmp(&header[0],
imageHeaders[i], imageHeaderSize[i]) == 0)
return std::string(imageMimeTypes[i]);
#else
if (std::memcmp(header.data(),
imageHeaders[i], imageHeaderSize[i]) == 0)
return std::string(imageMimeTypes[i]);
#endif
}
return std::string();
}
WPoint ImageUtils::getSize(const std::string& fileName)
{
std::vector header =
FileUtils::fileHeader(fileName, 25);
if (header.empty())
return WPoint();
else{
std::string mimeType = identifyMimeType(header);
if (mimeType == "image/jpeg")
return getJpegSize(fileName);
else
return getSize(header);
}
}
WPoint ImageUtils::getJpegSize(const std::string& fileName){
std::vector header =
FileUtils::fileHeader(fileName, 1000);
int pos = 2;
while (toUnsigned(header[pos])==0xFF) {
if (toUnsigned(header[pos + 1])==0xC0 ||
toUnsigned(header[pos + 1])==0xC1 ||
toUnsigned(header[pos + 1])==0xC2 ||
toUnsigned(header[pos + 1])==0xC3 ||
toUnsigned(header[pos + 1])==0xC9 ||
toUnsigned(header[pos + 1])==0xCA ||
toUnsigned(header[pos + 1])==0xCB)
break;
pos += 2+(toUnsigned(header[pos + 2])<<8) + toUnsigned(header[pos + 3]);
if (pos +12 > (int)header.size())
break;
}
int height = (toUnsigned(header[pos + 5] << 8)) + toUnsigned(header[pos + 6]);
int width = (toUnsigned(header[pos + 7] << 8)) + toUnsigned(header[pos + 8]);
return WPoint(width, height);
}
WPoint ImageUtils::getSize(const std::vector& header)
{
/*
* Contributed by Daniel Derr @ ArrowHead Electronics Health-Care
*/
std::string mimeType = identifyMimeType(header);
if (mimeType == "image/png") {
int width = ( ( ( toUnsigned(header[16]) << 8
| toUnsigned(header[17])) << 8
| toUnsigned(header[18])) << 8
| toUnsigned(header[19]));
int height = ( ( ( toUnsigned(header[20]) << 8
| toUnsigned(header[21])) << 8
| toUnsigned(header[22])) << 8
| toUnsigned(header[23]));
return WPoint(width, height);
} else if (mimeType == "image/gif") {
int width = toUnsigned(header[7]) << 8 | toUnsigned(header[6]);
int height = toUnsigned(header[9]) << 8 | toUnsigned(header[8]);
return WPoint(width, height);
} else
return WPoint();
}
}
witty-3.3.4+dfsg.orig/src/web/RefEncoder.C 0000644 0001750 0001750 00000012157 12372071307 020517 0 ustar pgquiles pgquiles /*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#include "Wt/WApplication"
#include "Wt/WEnvironment"
#include "Wt/WLogger"
#include "Wt/WString"
#include "Wt/WStringStream"
#include "DomElement.h"
#include "RefEncoder.h"
#include "WebSession.h"
#include "WebUtils.h"
#include
#include
#include "3rdparty/rapidxml/rapidxml.hpp"
#include "3rdparty/rapidxml/rapidxml_print.hpp"
using namespace Wt::rapidxml;
namespace Wt {
LOGGER("RefEncoder");
static std::string replaceUrlInStyle(std::string& style, WApplication *app)
{
boost::regex re("url\\((.*//.*)\\)",
boost::regex::perl | boost::regex::icase);
boost::sregex_iterator i(style.begin(), style.end(), re);
boost::sregex_iterator end;
WStringStream result;
std::size_t pos = 0;
for (; i != end; ++i) {
result << style.substr(pos, i->position(1) - pos);
std::string url = style.substr(i->position(1), i->length(1));
boost::algorithm::trim(url);
if (url.length() > 2)
if (url[0] == '\'' || url[1] == '"')
url = url.substr(1, url.length() - 2);
result << WWebWidget::jsStringLiteral(app->encodeUntrustedUrl(url), '\'');
pos = i->position(1) + i->length(1);
}
result << style.substr(pos);
return result.str();
}
void EncodeRefs(xml_node<> *x_node, WApplication *app,
WFlags options)
{
xml_document<> *doc = x_node->document();
if (strcmp(x_node->name(), "a") == 0) {
xml_attribute<> *x_href = x_node->first_attribute("href");
if (x_href) {
std::string path = x_href->value();
if ((options & EncodeInternalPaths)
&& path.length() >= 2 && path.substr(0, 2) == "#/") {
path = path.substr(1);
std::string addClass, url;
if (app->environment().ajax()) {
url = app->bookmarkUrl(path);
const char *name = "onclick";
char *value
= doc->allocate_string
((WT_CLASS".navigateInternalPath(event, "
+ WWebWidget::jsStringLiteral(path) + ");").c_str());
xml_attribute<> *x_click = doc->allocate_attribute(name, value);
x_node->insert_attribute(0, x_click);
addClass = "Wt-rr";
} else {
if (app->environment().agentIsSpiderBot())
url = app->bookmarkUrl(path);
else
url = app->session()->mostRelativeUrl(path);
addClass = "Wt-ip";
}
xml_attribute<> *x_class = x_node->first_attribute("class");
std::string styleClass = x_class ? x_class->value() : std::string();
styleClass = Utils::addWord(styleClass, addClass);
if (x_class)
x_class->value(doc->allocate_string(styleClass.c_str()));
else {
x_class = doc->allocate_attribute
("class", doc->allocate_string(styleClass.c_str()));
x_node->insert_attribute(0, x_class);
}
x_href->value
(doc->allocate_string(app->resolveRelativeUrl(url).c_str()));
} else if (options & EncodeRedirectTrampoline) {
if (path.find("://") != std::string::npos ||
boost::starts_with(path, "//")) {
path = app->encodeUntrustedUrl(path);
x_href->value(doc->allocate_string(path.c_str()));
}
}
}
}
if (options & EncodeRedirectTrampoline) {
xml_attribute<> *x_style = x_node->first_attribute("style");
if (x_style) {
std::string style = x_style->value();
if (style.find("//") != std::string::npos) {
style = replaceUrlInStyle(style, app);
x_style->value(doc->allocate_string(style.c_str()));
}
}
if (strcmp(x_node->name(), "img") == 0) {
xml_attribute<> *x_scr = x_node->first_attribute("src");
if (x_scr) {
std::string path = x_scr->value();
if (path.find("://") != std::string::npos ||
boost::starts_with(path, "//")) {
path = app->encodeUntrustedUrl(path);
x_scr->value(doc->allocate_string(path.c_str()));
}
}
}
}
for (xml_node<> *x_child = x_node->first_node(); x_child;
x_child = x_child->next_sibling())
EncodeRefs(x_child, app, options);
if (!x_node->first_node()
&& x_node->value_size() == 0
&& !DomElement::isSelfClosingTag(x_node->name())) {
// We need to add an emtpy data node since
is illegal HTML
// (but valid XML / XHTML)
xml_node<> *empty
= x_node->document()->allocate_node(node_data, 0, 0, 0, 0);
x_node->append_node(empty);
}
}
void EncodeRefs(WString& text, WFlags options)
{
if (text.empty())
return;
std::string result = "" + text.toUTF8() + " ";
char *ctext = const_cast(result.c_str()); // Shhht it's okay !
WApplication *app = WApplication::instance();
try {
xml_document<> doc;
doc.parse(ctext);
EncodeRefs(doc.first_node(), app, options);
WStringStream out;
print(out.back_inserter(), *doc.first_node(), print_no_indenting);
result = out.str();
} catch (parse_error& e) {
LOG_ERROR("Error reading XHTML string: " << e.what());
return;
}
if (result.length() < 13)
result.clear();
else
result = result.substr(6, result.length() - 13);
text = WString::fromUTF8(result);
}
}
witty-3.3.4+dfsg.orig/src/web/FileServe.h 0000644 0001750 0001750 00000002237 12100524741 020424 0 ustar pgquiles pgquiles // This may look like C code, but it's really -*- C++ -*-
/*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#ifndef FILE_SERVE_H_
#define FILE_SERVE_H_
#include
#include
namespace Wt {
class WStringStream;
/*
* A simple template streaming class.
*
* It supports:
* - variables (_$_name_$_)
* - conditions:
* _$_$if_condition_$_
* ...
* _$_$endif_$_
* and
* _$_$ifnot_condition_$_;
* ...
* _$_$endif_$_;
*/
class FileServe
{
public:
FileServe(const char *contents);
void setVar(const std::string& name, const std::string& value);
void setVar(const std::string& name, const char *value);
void setVar(const std::string& name, bool value);
void setVar(const std::string& name, int value);
void setVar(const std::string& name, unsigned value);
void setCondition(const std::string& name, bool value);
void stream(WStringStream& out);
void streamUntil(WStringStream& out, const std::string& until);
private:
const char *template_;
int currentPos_;
std::map vars_;
std::map conditions_;
};
}
#endif // FILE_SERVE_H_
witty-3.3.4+dfsg.orig/src/web/WebRenderer.h 0000644 0001750 0001750 00000011426 12500556234 020752 0 ustar pgquiles pgquiles // This may look like C code, but it's really -*- C++ -*-
/*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#ifndef WEBRENDERER_H_
#define WEBRENDERER_H_
#include
#include
#include
#include "Wt/WDateTime"
#include "Wt/WEnvironment"
#include "Wt/WStatelessSlot"
namespace Wt {
class WebRequest;
class WebResponse;
class WebStream;
class DomElement;
class EscapeOStream;
class FileServe;
class MetaHeader;
class WApplication;
class WWidget;
class WWebWidget;
class WObject;
class WResource;
class WStatelessSlot;
class WWidget;
class WT_API WebRenderer : public Wt::SlotLearnerInterface
{
public:
typedef std::map FormObjectsMap;
WebRenderer(WebSession& session);
void setTwoPhaseThreshold(int bytes);
bool visibleOnly() const { return visibleOnly_; }
void setVisibleOnly(bool how) { visibleOnly_ = how; }
bool isRendered() const { return rendered_; }
void setRendered(bool how);
void needUpdate(WWidget *w, bool laterOnly);
void doneUpdate(WWidget *w);
void updateFormObjects(WWebWidget *w, bool checkDescendants);
void updateFormObjectsList(WApplication *app);
const FormObjectsMap& formObjects() const;
void saveChanges();
void discardChanges();
void letReloadJS(WebResponse& request, bool newSession,
bool embedded = false);
void letReloadHTML(WebResponse& request, bool newSession);
bool isDirty() const;
int scriptId() const { return scriptId_; }
int pageId() const { return pageId_; }
void serveResponse(WebResponse& request);
void serveError(int status, WebResponse& request,
const std::string& message);
void serveLinkedCss(WebResponse& request);
void setCookie(const std::string name, const std::string value,
const WDateTime& expires, const std::string domain,
const std::string path, bool secure);
bool preLearning() const { return learning_; }
void learningIncomplete();
void updateLayout() { updateLayout_ = true; }
bool ackUpdate(int updateId);
void streamRedirectJS(WStringStream& out, const std::string& redirect);
bool checkResponsePuzzle(const WebRequest& request);
void setJSSynced(bool invisibleToo);
private:
struct CookieValue {
std::string value;
std::string path;
std::string domain;
WDateTime expires;
bool secure;
CookieValue();
CookieValue(const std::string& v, const std::string& p,
const std::string& d, const WDateTime& e, bool secure);
};
WebSession& session_;
bool visibleOnly_, rendered_, initialStyleRendered_;
int twoPhaseThreshold_, pageId_, expectedAckId_, scriptId_;
std::string solution_;
std::map cookiesToSet_;
FormObjectsMap currentFormObjects_;
std::string currentFormObjectsList_;
bool formObjectsChanged_;
bool updateLayout_;
void setHeaders(WebResponse& request, const std::string mimeType);
void setCaching(WebResponse& response, bool allowCache);
void serveJavaScriptUpdate(WebResponse& response);
void serveMainscript(WebResponse& response);
void serveBootstrap(WebResponse& request);
void serveMainpage(WebResponse& response);
void serveMainAjax(WStringStream& out);
void serveWidgetSet(WebResponse& request);
void collectJavaScript();
void collectChanges(std::vector& changes);
void collectJavaScriptUpdate(WStringStream& out);
void loadStyleSheet(WStringStream& out, WApplication *app,
const WCssStyleSheet& sheet);
void loadStyleSheets(WStringStream& out, WApplication *app);
void removeStyleSheets(WStringStream& out, WApplication *app);
int loadScriptLibraries(WStringStream& out, WApplication *app,
int count = -1);
void updateLoadIndicator(WStringStream& out, WApplication *app, bool all);
void renderSetServerPush(WStringStream& out);
void renderStyleSheet(WStringStream& out, const WCssStyleSheet& sheet,
WApplication *app);
std::string createFormObjectsList(WApplication *app);
void preLearnStateless(WApplication *app, WStringStream& out);
WStringStream collectedJS1_, collectedJS2_, invisibleJS_, statelessJS_,
beforeLoadJS_;
void collectJS(WStringStream *js);
void setPageVars(FileServe& page);
void streamBootContent(WebResponse& response,
FileServe& boot, bool hybrid);
void addResponseAckPuzzle(WStringStream& out);
void addContainerWidgets(WWebWidget *w,
std::vector& v);
std::string headDeclarations() const;
std::string bodyClassRtl() const;
std::string sessionUrl() const;
typedef std::set UpdateMap;
UpdateMap updateMap_;
bool learning_, learningIncomplete_, moreUpdates_;
std::string safeJsStringLiteral(const std::string& value);
public:
std::string learn(WStatelessSlot* slot);
friend class WApplication;
friend class WebSession;
};
}
#endif // WEBRENDERER_H_
witty-3.3.4+dfsg.orig/src/web/XSSUtils.h 0000644 0001750 0001750 00000000715 11456336247 020254 0 ustar pgquiles pgquiles // This may look like C code, but it's really -*- C++ -*-
/*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#ifndef XSSUTILS_H_
#define XSSUTILS_H_
#include
namespace Wt {
namespace XSS {
bool isBadTag(const std::string& name);
bool isBadAttribute(const std::string& name);
bool isBadAttributeValue(const std::string& name, const std::string& value);
}
}
#endif // XSSUTILS_H_
witty-3.3.4+dfsg.orig/src/web/RefEncoder.h 0000644 0001750 0001750 00000000772 12323463453 020567 0 ustar pgquiles pgquiles // This may look like C code, but it's really -*- C++ -*-
/*
* Copyright (C) 2011 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#ifndef REF_ENCODER_H_
#define REF_ENCODER_H_
#include
namespace Wt {
class WString;
enum RefEncoderOption {
EncodeInternalPaths = 0x1,
EncodeRedirectTrampoline = 0x2
};
W_DECLARE_OPERATORS_FOR_FLAGS(RefEncoderOption)
extern void EncodeRefs(WString& text, WFlags options);
}
#endif // REF_ENCODER_H_
witty-3.3.4+dfsg.orig/src/web/SocketNotifier.C 0000644 0001750 0001750 00000025234 12303212464 021426 0 ustar pgquiles pgquiles /*
* Copyright (C) 2010 Emweb bvba, Leuven, Belgium.
*
* See the LICENSE file for terms of use.
*/
#include "SocketNotifier.h"
#include "WebController.h"
#include "Wt/WLogger"
#include "Wt/WSocketNotifier"
#include
#if WT_WIN32
#include
typedef int socklen_t;
#else
#include
#include
#include
#include
#include
#include
#include
#include
#endif
namespace Wt {
LOGGER("SocketNotifier");
class SocketNotifierImpl
{
public:
SocketNotifierImpl():
terminate_(false),
socket1_(-1),
socket2_(-1),
controller_(0),
good_(false)
{}
boost::thread thread_;
boost::mutex mutex_;
bool interruptProcessed_;
boost::condition_variable interrupted_;
bool terminate_;
int socket1_, socket2_;
std::set readFds_, writeFds_, exceptFds_;
WebController *controller_;
bool good_;
void reportError(const char *msg)
{
#ifdef WT_WIN32
int error = GetLastError();
#else
int error = errno;
#endif
LOG_ERROR(msg << ". Error code " << error);
}
};
namespace {
void Close(int s)
{
#ifdef WT_WIN32
::closesocket(s);
#else
::close(s);
#endif
}
}
SocketNotifier::SocketNotifier(WebController *controller):
impl_(new SocketNotifierImpl)
{
impl_->controller_ = controller;
impl_->interruptProcessed_ = true;
createSocketPair();
}
SocketNotifier::~SocketNotifier()
{
impl_->terminate_ = true;
interruptThread();
if (impl_->thread_.joinable())
impl_->thread_.join();
if (impl_->socket1_ != -1)
Close(impl_->socket1_);
if (impl_->socket2_ != -1)
Close(impl_->socket2_);
delete impl_;
}
void SocketNotifier::createSocketPair()
{
// create a socket
int listenSocket = ::socket(PF_INET, SOCK_STREAM, 0);
if (listenSocket < 0) {
impl_->reportError("create listen socket failed");
return;
}
// set the nodelay option
{
int flag = 1;
if (::setsockopt(listenSocket, IPPROTO_TCP, TCP_NODELAY,
(char *)&flag, sizeof(int))) {
// This is not fatal
impl_->reportError("Configuring NODELAY failed");
}
}
unsigned long selfAddr = 0x7f000001; // 127.0.0.1, host order
{
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = 0;
addr.sin_addr.s_addr = htonl(selfAddr);
memset(addr.sin_zero, 0, sizeof(addr.sin_zero));
if (::bind(listenSocket, (struct sockaddr *)&addr, sizeof(addr))) {
impl_->reportError("bind() listen socket failed");
Close(listenSocket);
return;
}
}
unsigned listenPort; // in host byte order
{
struct sockaddr_in addr;
socklen_t addr_size = sizeof(addr);
if (::getsockname(listenSocket, (struct sockaddr *)&addr, &addr_size)) {
impl_->reportError("getsockname() listen socket failed");
Close(listenSocket);
return;
} else {
selfAddr = ntohl(addr.sin_addr.s_addr);
listenPort = ntohs(addr.sin_port);
}
}
if (::listen(listenSocket, 5)) {
impl_->reportError("listen() failed");
Close(listenSocket);
return;
}
impl_->socket1_ = ::socket(PF_INET, SOCK_STREAM, 0);
if (impl_->socket1_ < 0) {
impl_->reportError("create socket1 failed");
Close(listenSocket);
return;
}
// set the nodelay option
{
int flag = 1;
if (::setsockopt(impl_->socket1_, IPPROTO_TCP, TCP_NODELAY,
(char *)&flag, sizeof(int))) {
impl_->reportError("NODELAY socket1 failed");
// Not fatal
}
}
{
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(listenPort);
addr.sin_addr.s_addr = htonl(selfAddr);
memset(addr.sin_zero, 0, sizeof(addr.sin_zero));
if (::connect(impl_->socket1_, (struct sockaddr *)&addr, sizeof(addr))) {
impl_->reportError("connect socket1 failed");
Close(listenSocket);
Close(impl_->socket1_);
return;
}
}
unsigned connectPort;
{
struct sockaddr_in addr;
socklen_t addr_size = sizeof(addr);
if (::getsockname(impl_->socket1_, (struct sockaddr *)&addr, &addr_size)) {
impl_->reportError("getsockname socket1 failed");
Close(listenSocket);
Close(impl_->socket1_);
return;
} else {
selfAddr = ntohl(addr.sin_addr.s_addr);
connectPort = ntohs(addr.sin_port);
}
}
unsigned long peerAddr;
unsigned peerPort;
{
struct sockaddr_in addr;
socklen_t addr_size = sizeof addr;
impl_->socket2_ =
::accept(listenSocket, (struct sockaddr *)&addr, &addr_size);
if (impl_->socket2_ >= 0) {
peerAddr = ntohl(addr.sin_addr.s_addr);
peerPort = ntohs(addr.sin_port);
} else {
impl_->reportError("accept failed");
Close(listenSocket);
Close(impl_->socket1_);
return;
}
}
if (peerPort != connectPort && peerAddr != selfAddr) {
// A hacker has hijacked our secret port!!
impl_->reportError("socketpair: Accept from unexpected port");
Close(listenSocket);
Close(impl_->socket1_);
Close(impl_->socket2_);
return;
}
Close(listenSocket);
// Set both sockets to non-blockin so that they won't be the cause
// of deadlocks
#ifndef WT_WIN32
{
int flags = ::fcntl(impl_->socket1_, F_GETFL, 0);
flags |= O_NONBLOCK;
::fcntl(impl_->socket1_, F_SETFL, flags);
}
{
int flags = ::fcntl(impl_->socket2_, F_GETFL, 0);
flags |= O_NONBLOCK;
::fcntl(impl_->socket2_, F_SETFL, flags);
}
#else
{
u_long enabled = 1;
::ioctlsocket(impl_->socket1_, FIONBIO, &enabled);
::ioctlsocket(impl_->socket2_, FIONBIO, &enabled);
}
#endif
impl_->good_ = true;
}
void SocketNotifier::startThread()
{
#ifndef BOOST_THREAD_MAKE_RV_REF
impl_->thread_ = boost::thread(&SocketNotifier::threadEntry, this).move();
#else
// Use macro instead of thread.move()
impl_->thread_ = BOOST_THREAD_MAKE_RV_REF(boost::thread(&SocketNotifier::threadEntry, this));
#endif
}
void SocketNotifier::interruptThread()
{
if (!impl_->good_)
return;
if (impl_->thread_.joinable()) {
impl_->interruptProcessed_ = false;
char data = 0;
sendto(impl_->socket1_, &data, 1, 0, 0, 0);
} else {
if (!impl_->terminate_) {
// Just start the thread - there's no need for signaling
startThread();
}
}
}
void SocketNotifier::threadEntry()
{
boost::mutex::scoped_lock lock(impl_->mutex_);
while (!impl_->terminate_) {
int maxFd = 0;
fd_set read_fds, write_fds, except_fds;
FD_ZERO(&read_fds);
FD_ZERO(&write_fds);
FD_ZERO(&except_fds);
std::set read_in = impl_->readFds_;
std::set write_in = impl_->writeFds_;
std::set except_in = impl_->exceptFds_;
FD_SET(impl_->socket2_, &read_fds);
maxFd = (std::max)(maxFd, impl_->socket2_);
for (std::set::const_iterator i = impl_->readFds_.begin();
i != impl_->readFds_.end(); ++i) {
FD_SET(*i, &read_fds);
maxFd = (std::max)(maxFd, *i);
}
for (std::set::const_iterator i = impl_->writeFds_.begin();
i != impl_->writeFds_.end(); ++i) {
FD_SET(*i, &write_fds);
maxFd = (std::max)(maxFd, *i);
}
for (std::set::const_iterator i = impl_->exceptFds_.begin();
i != impl_->exceptFds_.end(); ++i) {
FD_SET(*i, &except_fds);
maxFd = (std::max)(maxFd, *i);
}
lock.unlock();
int result = ::select(maxFd + 1, &read_fds, &write_fds, &except_fds, 0);
lock.lock();
if (result > 0) {
if (FD_ISSET(impl_->socket2_, &read_fds)) {
// interruption of select() was requested. Read all data from
// the interruption connection. Normally contains a single byte,
// unless we were interrupted a couple of times already.
char buf[128];
::recvfrom(impl_->socket2_, buf, sizeof(buf), 0, 0, 0);
// Shortcut
if (impl_->terminate_)
return;
}
// Callbacks to invoke
std::vector > callbacks;
// The WebController will re-enable listening after processing the event
for (std::set::iterator i = read_in.begin();
i != read_in.end(); ++i) {
if (FD_ISSET(*i, &read_fds)) {
if (impl_->readFds_.find(*i) != impl_->readFds_.end()) {
impl_->readFds_.erase(*i);
callbacks.push_back(std::make_pair((int)*i, WSocketNotifier::Read));
}
}
}
for (std::set::iterator i = write_in.begin();
i != write_in.end(); ++i) {
if (FD_ISSET(*i, &write_fds)) {
if (impl_->writeFds_.find(*i) != impl_->writeFds_.end()) {
impl_->writeFds_.erase(*i);
callbacks.push_back(std::make_pair((int)*i,
WSocketNotifier::Write));
}
}
}
for (std::set::iterator i = except_in.begin();
i != except_in.end(); ++i) {
if (FD_ISSET(*i, &except_fds)) {
if (impl_->exceptFds_.find(*i) != impl_->exceptFds_.end()) {
impl_->exceptFds_.erase(*i);
callbacks.push_back(std::make_pair((int)*i,
WSocketNotifier::Exception));
}
}
}
impl_->interruptProcessed_ = true;
impl_->interrupted_.notify_all();
lock.unlock();
// Invoke callbacks
for (unsigned int i = 0; i < callbacks.size(); ++i) {
impl_->controller_->socketSelected(callbacks[i].first,
callbacks[i].second);
}
lock.lock();
} else {
LOG_ERROR("select() returned -1");
}
}
}
void SocketNotifier::addReadSocket(int socket)
{
boost::mutex::scoped_lock lock(impl_->mutex_);
impl_->readFds_.insert(socket);
interruptThread();
}
void SocketNotifier::addWriteSocket(int socket)
{
boost::mutex::scoped_lock lock(impl_->mutex_);
impl_->writeFds_.insert(socket);
interruptThread();
}
void SocketNotifier::addExceptSocket(int socket)
{
boost::mutex::scoped_lock lock(impl_->mutex_);
impl_->exceptFds_.insert(socket);
interruptThread();
}
void SocketNotifier::removeReadSocket(int socket)
{
boost::mutex::scoped_lock lock(impl_->mutex_);
impl_->readFds_.erase(socket);
while (!impl_->interruptProcessed_)
impl_->interrupted_.wait(lock);
interruptThread();
// In order to avoid late event invocation (especially on socket id's
// that were recycled by the OS), we must wait until the socket was
// really removed
impl_->interrupted_.wait(lock);
}
void SocketNotifier::removeWriteSocket(int socket)
{
boost::mutex::scoped_lock lock(impl_->mutex_);
impl_->writeFds_.erase(socket);
interruptThread();
impl_->interrupted_.wait(lock);
}
void SocketNotifier::removeExceptSocket(int socket)
{
boost::mutex::scoped_lock lock(impl_->mutex_);
impl_->exceptFds_.erase(socket);
interruptThread();
impl_->interrupted_.wait(lock);
}
}
witty-3.3.4+dfsg.orig/src/web/ColorUtils.C 0000644 0001750 0001750 00000005763 12100524741 020601 0 ustar pgquiles pgquiles /*
* Copyright (C) 2012 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#include "ColorUtils.h"
#include "Wt/WLogger"
#include "web/WebUtils.h"
#include
#include
#include
namespace Wt {
LOGGER("ColorUtils");
namespace Color {
int parseRgbArgument(const std::string& argument)
{
std::string arg = boost::trim_copy(argument);
try {
if (boost::ends_with(arg, "%"))
return (int) (boost::lexical_cast(arg.substr(0, arg.size() - 1))
* 255 / 100);
else
return boost::lexical_cast(arg);
} catch (boost::bad_lexical_cast &e) {
LOG_ERROR("invalid color component: " << arg);
return 0;
}
}
int replicateHex(const std::string& s)
{
int result = Utils::hexToInt(s.c_str());
return result | (result << 4);
}
WColor parseCssColor(const std::string &name)
{
std::string n = name;
boost::trim(n);
int red = 0;
int green = 0;
int blue = 0;
int alpha = 255;
if (boost::starts_with(n, "#")) {
if (n.size() - 1 == 3) { // #rgb
red = replicateHex(n.substr(1, 1));
green = replicateHex(n.substr(2,1));
blue = replicateHex(n.substr(3,1));
} else if (n.size() - 1 == 6) { // #rrggbb
red = Utils::hexToInt(n.substr(1,2).c_str());
green = Utils::hexToInt(n.substr(3,2).c_str());
blue = Utils::hexToInt(n.substr(5,2).c_str());
} else {
LOG_ERROR("could not parse rgb format: " << n);
red = green = blue = -1;
return WColor(red, green, blue, alpha);
}
} else if (boost::starts_with(n, "rgb")) { // rgb(r,g,b) or rgba(r,g,b,a)
if (n.size() < 5) {
LOG_ERROR("could not parse rgb format: " << n);
return WColor(red, green, blue, alpha);
}
bool has_alpha = (n[3] == 'a');
int start_bracket = 3 + (has_alpha ? 1 : 0);
if (n[start_bracket] != '(' || n[n.size() - 1] != ')') {
LOG_ERROR("could not parse rgb format: " << n);
return WColor(red, green, blue, alpha);
}
std::string argumentsStr = n.substr(start_bracket + 1,
n.size() - 1 - (start_bracket + 1));
std::vector arguments;
boost::split(arguments,
argumentsStr,
boost::is_any_of(","));
if (!has_alpha && arguments.size() != 3) {
LOG_ERROR("could not parse rgb format: " << n);
return WColor(red, green, blue, alpha);
}
if (has_alpha && arguments.size() != 4) {
LOG_ERROR("could not parse rgb format: " << n);
return WColor(red, green, blue, alpha);
}
red = parseRgbArgument(arguments[0]);
green = parseRgbArgument(arguments[1]);
blue = parseRgbArgument(arguments[2]);
if (has_alpha) {
try {
alpha = boost::lexical_cast(boost::trim_copy(arguments[3]));
} catch (boost::bad_lexical_cast &e) {
LOG_ERROR("could not parse rgb format: " << n);
alpha = 255;
return WColor(red, green, blue, alpha);
}
}
}
return WColor(red, green, blue, alpha);
}
}
}
witty-3.3.4+dfsg.orig/src/web/EscapeOStream.C 0000644 0001750 0001750 00000012272 12273674107 021203 0 ustar pgquiles pgquiles /*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#include "EscapeOStream.h"
#include "WebUtils.h"
namespace Wt {
const EscapeOStream::Entry EscapeOStream::htmlAttributeEntries_[] = {
{ '&', "&" },
{ '\"', """ },
{ '<', "<" }
};
const EscapeOStream::Entry EscapeOStream::plainTextEntries_[] = {
{ '&', "&" },
{ '>', ">" },
{ '<', "<" }
};
const EscapeOStream::Entry EscapeOStream::plainTextNewLinesEntries_[] = {
{ '&', "&" },
{ '>', ">" },
{ '<', "<" },
{ '\n', " EscapeOStream::standardSets_[] = {
std::vector(),
std::vector(htmlAttributeEntries_,
htmlAttributeEntries_ + 3),
std::vector(jsStringLiteralSQuoteEntries_,
jsStringLiteralSQuoteEntries_ + 5),
std::vector(jsStringLiteralDQuoteEntries_,
jsStringLiteralDQuoteEntries_ + 5),
std::vector(plainTextEntries_,
plainTextEntries_ + 3),
std::vector(plainTextNewLinesEntries_,
plainTextNewLinesEntries_ + 4)
};
const std::string EscapeOStream::standardSetsSpecial_[] = {
std::string(),
std::string("&\"<"),
std::string("\\\n\r\t'"),
std::string("\\\n\r\t\""),
std::string("&><"),
std::string("&><\n")
};
EscapeOStream::EscapeOStream()
: stream_(own_stream_),
c_special_(0)
{ }
EscapeOStream::EscapeOStream(std::ostream& sink)
: own_stream_(sink),
stream_(own_stream_),
c_special_(0)
{ }
EscapeOStream::EscapeOStream(WStringStream& sink)
: stream_(sink),
c_special_(0)
{ }
EscapeOStream::EscapeOStream(EscapeOStream& other)
: stream_(own_stream_),
mixed_(other.mixed_),
special_(other.special_),
c_special_(special_.empty() ? 0 : special_.c_str()),
ruleSets_(other.ruleSets_)
{ }
void EscapeOStream::mixRules()
{
mixed_.clear();
special_.clear();
const int ruleSetsSize = ruleSets_.size();
if (ruleSetsSize == 0) {
c_special_ = 0;
} else {
if (ruleSetsSize == 1) {
mixed_ = standardSets_[ruleSets_[0]];
special_ = standardSetsSpecial_[ruleSets_[0]];
} else
for (int i = ruleSetsSize - 1; i >= 0; --i) {
const std::vector& toMix = standardSets_[ruleSets_[i]];
for (unsigned j = 0; j < mixed_.size(); ++j)
for (unsigned k = 0; k < toMix.size(); ++k)
Utils::replace(mixed_[j].s, toMix[k].c, toMix[k].s);
mixed_.insert(mixed_.end(), toMix.begin(), toMix.end());
for (unsigned j = 0; j < toMix.size(); ++j)
special_.push_back(toMix[j].c);
}
if (!special_.empty())
c_special_ = special_.c_str();
else
c_special_ = 0;
}
}
void EscapeOStream::pushEscape(RuleSet rules)
{
ruleSets_.push_back(rules);
mixRules();
}
void EscapeOStream::popEscape()
{
ruleSets_.pop_back();
mixRules();
}
EscapeOStream& EscapeOStream::operator<< (char c)
{
if (c_special_ == 0) {
stream_ << c;
} else {
std::size_t i = special_.find(c);
if (i != std::string::npos)
stream_ << mixed_[i].s;
else
stream_ << c;
}
return *this;
}
void EscapeOStream::append(const char *s, std::size_t len)
{
if (c_special_ == 0)
stream_.append(s, len);
else
put(s, *this);
}
EscapeOStream& EscapeOStream::operator<< (char *s)
{
if (c_special_ == 0)
stream_ << s;
else
put(s, *this);
return *this;
}
void EscapeOStream::append(const std::string& s, const EscapeOStream& rules)
{
if (rules.c_special_ == 0)
stream_ << s;
else
put(s.c_str(), rules);
}
EscapeOStream& EscapeOStream::operator<< (const std::string& s)
{
append(s, *this);
return *this;
}
EscapeOStream& EscapeOStream::operator<< (int i)
{
stream_ << i;
return *this;
}
EscapeOStream& EscapeOStream::operator<< (long long i)
{
stream_ << i;
return *this;
}
void EscapeOStream::put(const char *s, const EscapeOStream& rules)
{
for (;s;) {
const char *f = std::strpbrk(s, rules.c_special_);
if (f != 0) {
stream_.append(s, static_cast(f - s));
unsigned i = 0;
for (; i < rules.mixed_.size(); ++i)
if (rules.mixed_[i].c == *f) {
stream_ << rules.mixed_[i].s;
break;
}
if (i == rules.mixed_.size())
stream_ << *f;
s = f + 1;
} else {
stream_ << const_cast(s);
s = 0;
}
}
}
EscapeOStream& EscapeOStream::operator<< (bool b)
{
stream_ << b;
return *this;
}
EscapeOStream& EscapeOStream::operator<< (const EscapeOStream& other)
{
if (!other.empty())
*this << other.str(); // FIXME could be optimized ?
return *this;
}
const char *EscapeOStream::c_str()
{
return stream_.c_str();
}
std::string EscapeOStream::str() const
{
return stream_.str();
}
void EscapeOStream::clear()
{
stream_.clear();
}
bool EscapeOStream::empty() const
{
return stream_.empty();
}
}
witty-3.3.4+dfsg.orig/src/web/WebSession.h 0000644 0001750 0001750 00000024351 12475324032 020630 0 ustar pgquiles pgquiles // This may look like C code, but it's really -*- C++ -*-
/*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#ifndef WEBSESSION_H_
#define WEBSESSION_H_
#include
#include
#include
#if defined(WT_THREADED) || defined(WT_TARGET_JAVA)
#define WT_BOOST_THREADS
#endif
#ifdef WT_BOOST_THREADS
#include
#include