From: zuber Date: Tue, 13 Oct 2009 09:03:46 +0000 (+0200) Subject: Zmiana nazwy project -> platforma. X-Git-Url: https://git.mdrn.pl/redakcja.git/commitdiff_plain/78644811ca0c6042212788dc67add42bc41fb74c?ds=inline Zmiana nazwy project -> platforma. --- diff --git a/platforma/__init__.py b/platforma/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/platforma/dispatch.wsgi b/platforma/dispatch.wsgi new file mode 100755 index 00000000..5724b23c --- /dev/null +++ b/platforma/dispatch.wsgi @@ -0,0 +1,25 @@ +#!/usr/bin/env python +import os +from os import path +import sys + +PROJECT_ROOT = path.realpath(path.dirname(__file__)) + +# Redirect sys.stdout to sys.stderr for bad libraries like geopy that use +# print statements for optional import exceptions. +sys.stdout = sys.stderr + +# Add apps and lib directories to PYTHONPATH +sys.path.insert(0, path.join(PROJECT_ROOT, '../apps')) +sys.path.insert(0, path.join(PROJECT_ROOT, '../lib')) + +# Emulate manage.py path hacking. +sys.path.insert(0, path.join(PROJECT_ROOT, "..")) +sys.path.insert(0, PROJECT_ROOT) + +# Run Django +os.environ['DJANGO_SETTINGS_MODULE'] = 'settings' + +from django.core.handlers.wsgi import WSGIHandler +application = WSGIHandler() + diff --git a/platforma/localsettings.sample b/platforma/localsettings.sample new file mode 100644 index 00000000..1bac9557 --- /dev/null +++ b/platforma/localsettings.sample @@ -0,0 +1,39 @@ +# +# localsettings template for Platforma +# +# Duplicate this file as localsettings.py and change it to your liking. +# Settings defined in localsettings.py will override settings from +# settings.py file. localsettings.py should never be commited +# to a version control system. Please make changes to settings.py +# or localsettings.sample instead. +# + +# Path to repository with managed documents +REPOSITORY_PATH = '/home/user/repository' + +# Subdirectory of STATIC_ROOT containing images +IMAGE_DIR = 'images' + +# Authentication via Central Authentication Server +INSTALLED_APPS = ( + 'django.contrib.auth', + 'django.contrib.contenttypes', + 'django.contrib.sessions', + 'django.contrib.sites', + 'django.contrib.admin', + 'django.contrib.admindocs', + + 'cas_consumer', + 'explorer', + 'toolbar', + 'api', + 'wysiwyg', +) + +AUTHENTICATION_BACKENDS = ( + 'cas_consumer.backends.CASBackend', +) + +CAS_BASE = 'http://localhost:7000/' +CAS_SERVICE = 'http://localhost:8000/accounts/login/' + diff --git a/platforma/manage.py b/platforma/manage.py new file mode 100755 index 00000000..8e180f0e --- /dev/null +++ b/platforma/manage.py @@ -0,0 +1,18 @@ +#!/usr/bin/env python +from django.core.management import execute_manager +try: + import settings # Assumed to be in the same directory. +except ImportError: + import sys + sys.stderr.write("Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n(If the file settings.py does indeed exist, it's causing an ImportError somehow.)\n" % __file__) + sys.exit(1) + +if __name__ == "__main__": + # Append lib and apps directories to PYTHONPATH + from os import path + import sys + + PROJECT_ROOT = path.realpath(path.dirname(__file__)) + sys.path += [PROJECT_ROOT + '/../apps', PROJECT_ROOT + '/../lib'] + + execute_manager(settings) diff --git a/platforma/settings.py b/platforma/settings.py new file mode 100644 index 00000000..3a1f3ad9 --- /dev/null +++ b/platforma/settings.py @@ -0,0 +1,155 @@ +# -*- coding: utf-8 -*- +from os import path + +PROJECT_ROOT = path.realpath(path.dirname(__file__)) + +DEBUG = True +TEMPLATE_DEBUG = DEBUG + +ADMINS = ( + (u'Marek Stępniowski', 'marek@stepniowski.com'), + (u'Łukasz Rekucki', 'lrekucki@gmail.com'), +) + +MANAGERS = ADMINS + +DATABASE_ENGINE = 'sqlite3' # 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'oracle'. +DATABASE_NAME = PROJECT_ROOT + '/dev.sqlite' # Or path to database file if using sqlite3. +DATABASE_USER = '' # Not used with sqlite3. +DATABASE_PASSWORD = '' # Not used with sqlite3. +DATABASE_HOST = '' # Set to empty string for localhost. Not used with sqlite3. +DATABASE_PORT = '' # Set to empty string for default. Not used with sqlite3. + +# Local time zone for this installation. Choices can be found here: +# http://en.wikipedia.org/wiki/List_of_tz_zones_by_name +# although not all choices may be available on all operating systems. +# If running in a Windows environment this must be set to the same as your +# system time zone. +TIME_ZONE = 'Europe/Warsaw Poland' + +# Language code for this installation. All choices can be found here: +# http://www.i18nguy.com/unicode/language-identifiers.html +LANGUAGE_CODE = 'pl' + +#import locale +#locale.setlocale(locale.LC_ALL, '') + +SITE_ID = 1 + +# If you set this to False, Django will make some optimizations so as not +# to load the internationalization machinery. +USE_I18N = True + +# Absolute path to the directory that holds media. +# Example: "/home/media/media.lawrence.com/" +MEDIA_ROOT = PROJECT_ROOT + '/media/' +STATIC_ROOT = PROJECT_ROOT + '/static/' + +# URL that handles the media served from MEDIA_ROOT. Make sure to use a +# trailing slash if there is a path component (optional in other cases). +# Examples: "http://media.lawrence.com", "http://example.com/media/" +MEDIA_URL = '/media/' +STATIC_URL = '/static/' + +# URL prefix for admin media -- CSS, JavaScript and images. Make sure to use a +# trailing slash. +# Examples: "http://foo.com/media/", "/media/". +ADMIN_MEDIA_PREFIX = '/admin-media/' + +# Make this unique, and don't share it with anybody. +SECRET_KEY = 'ife@x^_lak+x84=lxtr!-ur$5g$+s6xt85gbbm@e_fk6q3r8=+' + +# List of callables that know how to import templates from various sources. +TEMPLATE_LOADERS = ( + 'django.template.loaders.filesystem.load_template_source', + 'django.template.loaders.app_directories.load_template_source', +# 'django.template.loaders.eggs.load_template_source', +) + +TEMPLATE_CONTEXT_PROCESSORS = ( + "django.core.context_processors.auth", + "django.core.context_processors.debug", + "django.core.context_processors.i18n", + "explorer.context_processors.settings", + "django.core.context_processors.request", +) + + +MIDDLEWARE_CLASSES = ( + 'django.middleware.common.CommonMiddleware', + 'django.contrib.sessions.middleware.SessionMiddleware', + 'django.contrib.auth.middleware.AuthenticationMiddleware', + 'explorer.middleware.EditorSettingsMiddleware', + 'django.middleware.doc.XViewMiddleware', + + 'maintenancemode.middleware.MaintenanceModeMiddleware', +) + +ROOT_URLCONF = 'urls' + +TEMPLATE_DIRS = ( + PROJECT_ROOT + '/templates', +) + +# CSS and JS files to compress +# COMPRESS_CSS = { +# 'all': { +# 'source_filenames': ('css/master.css', 'css/jquery.date_input.css', 'css/jquery.countdown.css',), +# 'output_filename': 'css/all.min.css', +# } +# } +# +# COMPRESS_JS = { +# 'all': { +# 'source_filenames': ('js/jquery.js', 'js/jquery.date_input.js', 'js/jquery.date_input-pl.js', +# 'js/jquery.countdown.js', 'js/jquery.countdown-pl.js',), +# 'output_filename': 'js/all.min.js', +# } +# } +# +# COMPRESS_CSS_FILTERS = None + +INSTALLED_APPS = ( + 'django.contrib.auth', + 'django.contrib.contenttypes', + 'django.contrib.sessions', + 'django.contrib.sites', + 'django.contrib.admin', + 'django.contrib.admindocs', + + 'piston', + 'explorer', + 'toolbar', + 'api', + 'wysiwyg', +) + + +# REPOSITORY_PATH = '/Users/zuber/Projekty/platforma/files/books' +IMAGE_DIR = 'images' +EDITOR_COOKIE_NAME = 'options' +EDITOR_DEFAULT_SETTINGS = { + 'panels': [ + {'name': 'htmleditor', 'ratio': 0.5}, + {'name': 'gallery', 'ratio': 0.5} + ], +} + +# Python logging settings +import logging + +log = logging.getLogger('platforma') +log.setLevel(logging.DEBUG) +ch = logging.StreamHandler() +ch.setLevel(logging.DEBUG) +formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') +ch.setFormatter(formatter) +log.addHandler(ch) + + +# Import localsettings file, which may override settings defined here +try: + from localsettings import * +except ImportError: + pass + diff --git a/platforma/static/css/autumn.css b/platforma/static/css/autumn.css new file mode 100644 index 00000000..dddd8996 --- /dev/null +++ b/platforma/static/css/autumn.css @@ -0,0 +1,49 @@ +/* + Document : autumn + Created on : 2009-10-01, 00:23:51 + Author : lreqc + Description: + Autumn colors for PR. +*/ + +body { + background-color: #C28800; +} + +#header { + background-color: #E2CF62; + border-bottom-color: #860000; +} + +.panel-main-toolbar { + background-color: #412F1D; +} + +.splitview-splitbar { + /* border-color: #412F1D; */ + border: none; + background-color: #860000; +} + +.image-gallery-header { + background-color: #E2CF62; +} + +a:link, a:visited, a:active { + color: #860000; + text-decoration: none; + font-weight: bold; +} + +a:hover { + text-decoration: underline; +} + +.toolbar-buttons-container { + background-color: #E2CF62; +} + +.toolbar-tabs-container { + background-color: #860000; +} + diff --git a/platforma/static/css/filelist.css b/platforma/static/css/filelist.css new file mode 100755 index 00000000..91e9b8dc --- /dev/null +++ b/platforma/static/css/filelist.css @@ -0,0 +1,47 @@ +/* + Document : filelist + Created on : 2009-09-04, 20:44:44 + Author : lreqc + Description: + Dodatkowe style dla listy plików na stronie głównej. +*/ + +#main-page-widgets > div { + float: left; + border: 1px solid black; + padding: 0.5em 2em; + margin: 1em; +} + +.file-list-widget { + background: #DDF; + max-width: 60%; +} + +.file-list-widget .page-nav-wrap button { + width: 2.5em; +} + +.upload-file-widget { + min-width: 20%; + width: 35%; +} + +ul.file-tree-part { + margin: 0.5em 1em; + padding: 0em; +} + +ul.file-tree-part li { + list-style: square; + padding: 0em; +} + +ul.file-tree-part a { + padding: 0em; +} + + + + + diff --git a/platforma/static/css/html.css b/platforma/static/css/html.css new file mode 100644 index 00000000..336a365e --- /dev/null +++ b/platforma/static/css/html.css @@ -0,0 +1,227 @@ +/* Style widoku HTML. Nie należy tu ustawiać position ani marginesów */ +.htmlview { + font-size: 16px; + font: Georgia, "Times New Roman", serif; + line-height: 1.5em; + padding: 3em; +} + +.htmlview div { + max-width: 36em; +} + +.htmlview #toc { + display: none; +} + +.htmlview a { + color: blue; + text-decoration: none; +} + +.htmlview h1 { + font-size: 3em; + margin: 1.5em 0; + text-align: center; + line-height: 1.5em; + font-weight: bold; +} + +.htmlview h2 { + font-size: 2em; + margin: 1.5em 0 0; + font-weight: bold; + line-height: 1.5em; +} + +.htmlview h3 { + font-size: 1.5em; + margin: 1.5em 0 0; + font-weight: normal; + line-height: 1.5em; +} + +.htmlview h4 { + font-size: 1em; + margin: 1.5em 0 0; + line-height: 1.5em; +} + +.htmlview p { + margin: 0; +} + +/* ======================== */ +/* = Footnotes and themes = */ +/* ======================== */ +.htmlview .theme-begin { + border-left: 0.1em solid #DDDDDD; + color: #777; + padding: 0 0.5em; + width: 7.5em; + font-style: normal; + font-weight: normal; + font-size: 16px; + float: right; + margin-right: -9.5em; + clear: both; + left: 40em; + line-height: 1.5em; + text-align: left; +} + +.htmlview .annotation { + font-style: normal; + font-weight: normal; + font-size: 12px; +} + +.htmlview #footnotes .annotation { + display: block; + float: left; + width: 2.5em; + clear: both; +} + +.htmlview #footnotes div { + margin: 1.5em 0 0 0; +} + +.htmlview #footnotes p { + margin-left: 2.5em; + font-size: 0.875em; +} + +.htmlview blockquote { + font-size: 0.875em; +} + +/* ============= */ +/* = Numbering = */ +/* ============= */ +.htmlview .anchor { + position: relative; + margin: 0em; + left: -2.2em; + color: #777; + font-size: 12px; + width: 2em; + text-align: center; + padding: 0.25em 0.7em; + line-height: 1.5em; +} + +.htmlview .anchor:hover, .htmlview .anchor:active { + color: #FFF; + background-color: #CCC; +} + +/* =================== */ +/* = Custom elements = */ +/* =================== */ +.htmlview .autor_utwor { + font-size: 0.5em; + display: block; + line-height: 1.5em; + margin-bottom: 0.25em; +} + +.htmlview .dzielo_nadrzedne { + font-size: 0.375em; + display: block; + line-height: 1.5em; + margin-bottom: -0.25em; +} + +.htmlview .podtytul { + font-size: 0.5em; + display: block; + line-height: 1.5em; + margin-top: -0.25em; +} + +.htmlview .didaskalia { + font-style: italic; + margin: 0.5em 0 0 1.5em; +} + +.htmlview .kwestia { + margin: 0.5em 0 0; +} + +.htmlview .strofa { + margin: 1.5em 0 0; +} + +.htmlview .kwestia .strofa { + margin: 0; +} + +.htmlview .akap, .htmlview .akap_cd, .htmlview .akap_dialog { + text-align: justify; + margin: 1.5em 0 0; +} + +.htmlview p.motto { + text-align: justify; + font-style: italic; + margin: 1.5em 0 0; +} + +.htmlview p.motto_podpis { + font-size: 0.875em; + text-align: right; +} + +.htmlview div.fragment { + border-bottom: 0.1em solid #999; + padding-bottom: 1.5em; +} + +.htmlview div.nota p, +.htmlview div.dedykacja p { + text-align: right; + font-style: italic; +} + +.htmlview br.sekcja_swiatlo { + height: 3em; + /* visibility: hidden; */ +} + +.htmlview hr.separator_linia { + margin: 1.5em 0; + border: none; + border-bottom: 0.1em solid #000; +} + +.htmlview p.sekcja_asterysk { + padding: 0; + margin: 1.5em 0; + text-align: center; +} + +.htmlview div.lista_osob ol { + list-style: none; + padding: 0 0 0 1.5em; +} + +.htmlview p.miejsce_czas { + font-style: italic; +} + +.htmlview .mat, +.htmlview .slowo_obce, +.htmlview .tytul_dziela, +.htmlview .didaskalia { + font-style: italic; +} + +.htmlview .wyroznienie { + letter-spacing: 0.1em; +} + +.htmlview .osoba { + font-style: normal; + font-variant: small-caps; +} diff --git a/platforma/static/css/html_print.css b/platforma/static/css/html_print.css new file mode 100644 index 00000000..38cb5968 --- /dev/null +++ b/platforma/static/css/html_print.css @@ -0,0 +1,229 @@ +/* Style widoku HTML. Nie należy tu ustawiać position ani marginesów */ +.htmlview { + font-size: 16px; + font: Georgia, "Times New Roman", serif; + line-height: 1.5em; + padding: 3em; +} + +.htmlview div { + max-width: 36em; +} + +.htmlview #toc { + display: none; +} + +.htmlview a { + color: blue; + text-decoration: none; +} + +.htmlview h1 { + font-size: 3em; + margin: 1.5em 0; + text-align: center; + line-height: 1.5em; + font-weight: bold; +} + +.htmlview h2 { + font-size: 2em; + margin: 1.5em 0 0; + font-weight: bold; + line-height: 1.5em; +} + +.htmlview h3 { + font-size: 1.5em; + margin: 1.5em 0 0; + font-weight: normal; + line-height: 1.5em; +} + +.htmlview h4 { + font-size: 1em; + margin: 1.5em 0 0; + line-height: 1.5em; +} + +.htmlview p { + margin: 0; +} + +/* ======================== */ +/* = Footnotes and themes = */ +/* ======================== */ +.htmlview .theme-begin { + border-left: 0.1em solid #DDDDDD; + color: #777; + padding: 0 0.5em; + width: 7.5em; + font-style: normal; + font-weight: normal; + font-size: 16px; + float: right; + margin-right: -9.5em; + clear: both; + left: 40em; + line-height: 1.5em; + text-align: left; +} + +.htmlview .annotation { + font-style: normal; + font-weight: normal; + font-size: 12px; +} + +.htmlview #footnotes .annotation { + display: block; + float: left; + width: 2.5em; + clear: both; +} + +.htmlview #footnotes div { + margin: 1.5em 0 0 0; +} + +.htmlview #footnotes p { + margin-left: 2.5em; + font-size: 0.875em; +} + +.htmlview blockquote { + font-size: 0.875em; +} + +/* ============= */ +/* = Numbering = */ +/* ============= */ +.htmlview p { + position: relative; +} + +.htmlview .anchor { + position: absolute; + margin: 0em; + left: -3em; + color: #777; + font-size: 12px; + width: 2em; + text-align: center; + padding: 0.25em 0.5em; + line-height: 1.5em; +} + +.htmlview .anchor:hover, .htmlview .anchor:active { + color: #FFF; + background-color: #CCC; +} + +/* =================== */ +/* = Custom elements = */ +/* =================== */ +.htmlview span.author { + font-size: 0.5em; + display: block; + line-height: 1.5em; + margin-bottom: 0.25em; +} + +.htmlview span.collection { + font-size: 0.375em; + display: block; + line-height: 1.5em; + margin-bottom: -0.25em; +} + +.htmlview span.subtitle { + font-size: 0.5em; + display: block; + line-height: 1.5em; + margin-top: -0.25em; +} + +.htmlview div.didaskalia { + font-style: italic; + margin: 0.5em 0 0 1.5em; +} + +.htmlview div.kwestia { + margin: 0.5em 0 0; +} + +.htmlview div.stanza { + margin: 1.5em 0 0; +} + +.htmlview div.kwestia div.stanza { + margin: 0; +} + +.htmlview p.paragraph { + text-align: justify; + margin: 1.5em 0 0; +} + +.htmlview p.motto { + text-align: justify; + font-style: italic; + margin: 1.5em 0 0; +} + +.htmlview p.motto_podpis { + font-size: 0.875em; + text-align: right; +} + +.htmlview div.fragment { + border-bottom: 0.1em solid #999; + padding-bottom: 1.5em; +} + +.htmlview div.note p, .htmlview div.dedication p, +.htmlview div.note p.paragraph, .htmlview div.dedication p.paragraph { + text-align: right; + font-style: italic; +} + +.htmlview hr.spacer { + height: 3em; + visibility: hidden; +} + +.htmlview hr.spacer-line { + margin: 1.5em 0; + border: none; + border-bottom: 0.1em solid #000; +} + +.htmlview p.spacer-asterisk { + padding: 0; + margin: 1.5em 0; + text-align: center; +} + +.htmlview div.person-list ol { + list-style: none; + padding: 0 0 0 1.5em; +} + +.htmlview p.place-and-time { + font-style: italic; +} + +.htmlview em.math, .htmlview em.foreign-word, +.htmlview em.book-title, .htmlview em.didaskalia { + font-style: italic; +} + +.htmlview em.author-emphasis { + letter-spacing: 0.1em; +} + +.htmlview em.person { + font-style: normal; + font-variant: small-caps; +} diff --git a/platforma/static/css/jquery.modal.css b/platforma/static/css/jquery.modal.css new file mode 100755 index 00000000..4717ad45 --- /dev/null +++ b/platforma/static/css/jquery.modal.css @@ -0,0 +1,28 @@ +/* jqModal base Styling courtesy of; + Brice Burgess */ + +/* The Window's CSS z-index value is respected (takes priority). If none is supplied, + the Window's z-index value will be set to 3000 by default (via jqModal.js). */ + +.jqmWindow { + display: none; + + position: absolute; + top: 40px; + left: 25%; + bottom: auto; + height: auto; + width: auto; + + max-width: 80%; + max-height: 80%; + + overflow: auto; + + background-color: #EEE; + color: #333; + border: 1px solid black; + padding: 1em; +} + +.jqmOverlay { background-color: #000; } diff --git a/platforma/static/css/managment.css b/platforma/static/css/managment.css new file mode 100644 index 00000000..3777bcfc --- /dev/null +++ b/platforma/static/css/managment.css @@ -0,0 +1,36 @@ +table.request-report +{ + border: 2px groove black; + font-size: 12pt; + + margin-top: 3em; + margin-bottom: 2em; + margin-left: auto; + margin-right: auto; +} + +.request-report td, .request-report th { + vertical-align: top; + border-right: 1px solid black; + border-bottom: 1px solid black; + + padding: 0.4em 1em; + margin: 0em; +} + +.request-report th { + background-color: black; + color: white; +} + +.request-report .status-N { + background-color: teal; +} + +.request-report .status-R { + background-color: red; +} + +.request-report .status-A { + background-color: gray; +} \ No newline at end of file diff --git a/platforma/static/css/master.css b/platforma/static/css/master.css new file mode 100644 index 00000000..ae51e475 --- /dev/null +++ b/platforma/static/css/master.css @@ -0,0 +1,415 @@ +body { + margin: 0; + + font: 12px Helvetica, Verdana, sans-serif; + overflow: hidden; + background: #AAA; +} + +/* fix icon buttons */ + +button img { + vertical-align: middle; + margin: 0px; +} + +/* default form style hacks */ +select { + border: none; + margin-left: 0.1em; +} + +#body-wrap { + margin: 0px; + padding: 0px; +} + +#header { + position: absolute; + padding: 2px 0.5em; + background-color: #CDCDCD; /* !unused */ + border-bottom: 2px solid black; + + font-size: 14px; + + line-height: 26px; + vertical-align: middle; + + /* height: 30px; */ + top: 0px; left: 0px; right: 0px; + z-index: 300; +} + +#content { + position: absolute; + top: 32px; left: 0px; right: 0px; bottom: 0px; + overflow: auto; + background-color: white; +} + +#header #breadcrumbs { +} + +#header-right-toolbar { + position: absolute; + right: 1em; +} + +#header button { + vertical-align: middle; +} + +/* ========== */ +/* = Panels = */ +/* ========== */ + +/* #panels { + height: 100%; + width: 100%; +} + +.panel-wrap { + overflow: hidden; + position: absolute; + top: 0px; + bottom: 0px; +} + +#left-panel-wrap { + left: 0px; + width: 8px; +} + +#right-panel-wrap { + right: 0px; + width: auto; + left: 8px; +} + +.panel-content { + position: absolute; + overflow: auto; + overflow-x: hidden; + top: 25px; left: 0px; bottom:0px; right: 0px; +} + +.panel-overlay { + position: absolute; + top: 0px; bottom: 0px; left: 0px; right: 0px; + z-index: 100; + background: gray; + opacity: 0.8; + text-align: center; + overflow: hidden; + display: none; + cursor: col-resize; +} + +.panel-content-overlay { +} + +.panel-wrap.last-panel .panel-content { + right: 0px; +} + +.panel-wrap.last-panel .panel-slider { + display: none; +} + +.panel-wrap .panel-toolbar { + position: absolute; + top: 0px; left:0px; right: 0px; height: 26px; + padding: 0px; + + border-bottom: 1px solid #AAA; + z-index: 80; +} +.panel-wrap .panel-slider { + position: absolute; + background-color: #DDD; + + top: 0px; bottom: 0px; right: 0px; width: 4px; + + border-left: 1px solid #999; + border-right: 1px solid #999; + border-top: none; + border-bottom: none; + + z-index: 90; + cursor: col-resize; +} + +.panel-wrap .panel-slider:hover { + background-color: #999; +} + +.panel-content-overlay.panel-wrap .panel-slider { + background-color: #DDD; +} + +*/ + +/* OLD STUFF AGAIN */ + +/* Commit dialog */ +#commit-dialog-error-empty-message { + color: red; + display: none; + font-weight: bold; +} + +text#commit-dialog-message { + width: 80%; + margin: auto; +} + +#split-dialog .container-box form { + margin: 0.2em 1em; +} + +#split-dialog .container-box fieldset { + margin: 0.5em; +} + + + + +/* ======= */ +/* = New = */ +/* ======= */ +#splitview { + width: 100%; + height: 100%; + padding: 0; + margin: 0; +} + +.splitview-splitbar { + width: 5px; + border-left: 1px solid #999; + border-right: 1px solid #999; + height: 100%; + background-color: #CCC; + z-index: 100; +} + +.splitview-overlay { + z-index: 90; + background: #FFF; + opacity: 0.5; +} + +.panel-container { + height: 100%; + position: relative; +} + +.content-view { + position: absolute; + top: 25px; + right: 0; + bottom: 0; + left: 0; + overflow: hidden; +} + +.panel-main-toolbar { + z-index: 1100; + position: absolute; + + top: 0px; + right: 0px; + left: 0px; + height: 24px; + + border-bottom: 1px solid black; + background: gray; + + padding: 0px; +} + +.panel-main-toolbar p { + margin: 0px; + padding: 2px; + line-height: 20px; + font-size: 13px; +} + +.xmlview { + height: 100%; +} + +.view-overlay { + z-index: 1000; + background: #FFF; + opacity: 0.8; + text-align: center; + text-valign: center; +} + +.view-overlay p { + display: block; + position: relative; + top: auto; + bottom: auto; + height: 40px; +} + +/* .buttontoolbarview { + display: block; + background-color: #CCC; +} + +.buttontoolbarview a { + color: #000; + text-decoration: none; +} */ /* Similar classes already exist in toolbar.css */ + + +/* ================= */ +/* = Gallery panel = */ +/* ================= */ +.image-gallery-view-template { + position: absolute; + top: 0px; left: 0px; right: 0px; bottom: 0px; + overflow: hidden; +} + +.image-gallery-header { + position: absolute; + bottom: 0px; + left: 0px; + right: 0px; + height: 30px; + + background: gray; + border-top: 1px solid #780000; + z-index: 100; +} + +input.image-gallery-current-page { + text-align: center; +} + +.image-gallery-header p { + margin: 0px; + padding: 3px 1em; + height: 30px; + line-height: 24px; + text-align: center; + white-space: nowrap; +} + +.image-gallery-page-list { + position: absolute; + top: 0px; + left: 0px; + right: 0px; + bottom: 31px; + background: black; + z-index: 0; + + overflow: hidden; +} + +.image-gallery-page-container { + display: none; + border: none; + + position: absolute; + top: 0px; left: 0px; + + text-align: center; + padding: 0px; +} + +.htmlview { + position: absolute; + top: 25px; + right: 0; + bottom: 0; + left: 0; + overflow: auto; + margin: 0; +} + +.image-gallery-page-container img { + /* border: 2px solid green; */ + margin: 0px; +} + +body#base button { + background-color: #DDD; + border-width: 1px; + padding: 0px 0.5em; + font-family: Sans-Serif; + /* color: #000; */ + margin: 2px 4px; +} + +body#base button:hover { + background-color: #EEE; +} + +/* HTML editor interactive elements */ + +.html-editarea { + border: 2px solid black; + background-color: gray; + padding: 1px; + + z-index: 2000; +} + +.html-editarea textarea +{ + + border: 0px; + margin: 0px; + padding: 0px; + + width: 100%; + height: 100%; + + z-index: 0; + font-size: 10pt; + background-color: ivory; +} + +.html-editarea p.html-editarea-toolbar { + position: absolute; + background: gray; + + bottom: -26px; + height: 24px; + + left: 0px; + right: 0px; + + border: 2px solid black; + + margin: 0px; + padding: 0px; + + z-index: 100; +} + +/* ================= */ +/* = Message boxes = */ +/* ================= */ +.info { + background-color: gray; +} + +.success { + background-color: green; +} + +.error { + background-color: yellow; +} + +.critical { + background-color: red; +} + diff --git a/platforma/static/css/toolbar.css b/platforma/static/css/toolbar.css new file mode 100644 index 00000000..b5df66f3 --- /dev/null +++ b/platforma/static/css/toolbar.css @@ -0,0 +1,5 @@ +.toolbar-buttons-container { + padding-top: 2px; + padding-bottom: 2px; +} + diff --git a/platforma/static/css/xmlcolors.css b/platforma/static/css/xmlcolors.css new file mode 100644 index 00000000..aa26579e --- /dev/null +++ b/platforma/static/css/xmlcolors.css @@ -0,0 +1,51 @@ +.editbox { + margin: .4em; + padding: 0; + font-family: monospace; + font-size: 10pt; + color: black; +} + +.editbox p { + margin: 0; +} + +span.xml-tagname { + color: #A0B; +} + +span.xml-attribute { + color: #281; +} + +span.xml-punctuation { + color: black; +} + +span.xml-attname { + color: #00F; +} + +span.xml-comment { + color: #A70; +} + +span.xml-cdata { + color: #48A; +} + +span.xml-processing { + color: #999; +} + +span.xml-entity { + color: #A22; +} + +span.xml-error { + color: #F00; +} + +span.xml-text { + color: black; +} diff --git a/platforma/static/icons/go-next.png b/platforma/static/icons/go-next.png new file mode 100644 index 00000000..6ef8de76 Binary files /dev/null and b/platforma/static/icons/go-next.png differ diff --git a/platforma/static/icons/go-previous.png b/platforma/static/icons/go-previous.png new file mode 100644 index 00000000..659cd90d Binary files /dev/null and b/platforma/static/icons/go-previous.png differ diff --git a/platforma/static/icons/zoom.png b/platforma/static/icons/zoom.png new file mode 100644 index 00000000..6033b4d5 Binary files /dev/null and b/platforma/static/icons/zoom.png differ diff --git a/platforma/static/icons/zoom_in.png b/platforma/static/icons/zoom_in.png new file mode 100644 index 00000000..c7feedc6 Binary files /dev/null and b/platforma/static/icons/zoom_in.png differ diff --git a/platforma/static/icons/zoom_out.png b/platforma/static/icons/zoom_out.png new file mode 100644 index 00000000..fdd7124e Binary files /dev/null and b/platforma/static/icons/zoom_out.png differ diff --git a/platforma/static/img/spinner.gif b/platforma/static/img/spinner.gif new file mode 100644 index 00000000..f864d5fd Binary files /dev/null and b/platforma/static/img/spinner.gif differ diff --git a/platforma/static/js/app.js b/platforma/static/js/app.js new file mode 100644 index 00000000..fde15393 --- /dev/null +++ b/platforma/static/js/app.js @@ -0,0 +1,185 @@ +/*global Class*/ +var editor; +var panel_hooks; + + +// prevent a console.log from blowing things up if we are on a browser that +// does not support it +if (typeof console === 'undefined') { + window.console = {} ; + console.log = console.info = console.warn = console.error = function(){}; +} + + +(function(){ + // Classes + var initializing = false, fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/; + this.Class = function(){}; + Class.extend = function(prop) { + var _super = this.prototype; + initializing = true; + var prototype = new this(); + initializing = false; + for (var name in prop) { + prototype[name] = typeof prop[name] == "function" && + typeof _super[name] == "function" && fnTest.test(prop[name]) ? + (function(name, fn){ + return function() { + var tmp = this._super; + this._super = _super[name]; + var ret = fn.apply(this, arguments); + this._super = tmp; + return ret; + }; + })(name, prop[name]) : + prop[name]; + } + function Class() { + if ( !initializing && this.init ) + this.init.apply(this, arguments); + } + Class.prototype = prototype; + Class.constructor = Class; + Class.extend = arguments.callee; + return Class; + }; + + // Templates + var cache = {}; + + this.render_template = function render_template(str, data){ + // Figure out if we're getting a template, or if we need to + // load the template - and be sure to cache the result. + var fn = !/^[\d\s-_]/.test(str) ? + cache[str] = cache[str] || + render_template(document.getElementById(str).innerHTML) : + + // Generate a reusable function that will serve as a template + // generator (and which will be cached). + + new Function("obj", + "var p=[],print=function(){p.push.apply(p,arguments);};" + + + // Introduce the data as local variables using with(){} + "with(obj){p.push('" + + + // Convert the template into pure JavaScript + str + .replace(/[\r\t\n]/g, " ") + .split("<%").join("\t") + .replace(/((^|%>)[^\t]*)'/g, "$1\r") + .replace(/\t=(.*?)%>/g, "',$1,'") + .split("\t").join("');") + .split("%>").join("p.push('") + .split("\r").join("\\'") + + "');}return p.join('');"); + + // Provide some basic currying to the user + return data ? fn( data ) : fn; + }; +})(); + + +(function() { + var slice = Array.prototype.slice; + + function update(array, args) { + var arrayLength = array.length, length = args.length; + while (length--) array[arrayLength + length] = args[length]; + return array; + }; + + function merge(array, args) { + array = slice.call(array, 0); + return update(array, args); + }; + + Function.prototype.bind = function(context) { + if (arguments.length < 2 && typeof arguments[0] === 'undefined') { + return this; + } + var __method = this; + var args = slice.call(arguments, 1); + return function() { + var a = merge(args, arguments); + return __method.apply(context, a); + } + } + +})(); + + +var Editor = Editor || {}; + +// Obiekt implementujący wzorzec KVC/KVO +Editor.Object = Class.extend({ + _className: 'Editor.Object', + _observers: {}, + _guid: null, + + init: function() { + this._observers = {}; + }, + + description: function() { + return this._className + '(guid = ' + this.guid() + ')'; + }, + + addObserver: function(observer, property, callback) { + // console.log('Add observer', observer.description(), 'to', this.description(), '[', property, ']'); + if (!this._observers[property]) { + this._observers[property] = {} + } + this._observers[property][observer.guid()] = callback; + return this; + }, + + removeObserver: function(observer, property) { + if (!property) { + for (var property in this._observers) { + this.removeObserver(observer, property) + } + } else { + // console.log('Remove observer', observer.description(), 'from', this.description(), '[', property, ']'); + delete this._observers[property][observer.guid()]; + } + return this; + }, + + notifyObservers: function(property) { + var currentValue = this[property]; + for (var guid in this._observers[property]) { + // console.log(this._observers[property][guid]); + // console.log('Notifying', guid, 'of', this.description(), '[', property, ']'); + this._observers[property][guid](property, currentValue, this); + } + return this; + }, + + guid: function() { + if (!this._guid) { + this._guid = ('editor-' + Editor.Object._lastGuid++); + } + return this._guid; + }, + + get: function(property) { + return this[property]; + }, + + set: function(property, value) { + if (this[property] != value) { + this[property] = value; + this.notifyObservers(property); + } + return this; + }, + + dispose: function() { + delete this._observers; + } +}); + +Editor.Object._lastGuid = 0; + +var panels = []; diff --git a/platforma/static/js/button_scripts.js b/platforma/static/js/button_scripts.js new file mode 100644 index 00000000..40f45f6f --- /dev/null +++ b/platforma/static/js/button_scripts.js @@ -0,0 +1,210 @@ +function ScriptletCenter() +{ + this.scriptlets = {}; + + this.scriptlets['insert_tag'] = function(context, params) + { + var text = this.XMLEditorSelectedText(context); + var start_tag = '<'+params.tag; + + for (var attr in params.attrs) { + start_tag += ' '+attr+'="' + params.attrs[attr] + '"'; + } + + start_tag += '>'; + var end_tag = ''; + + if(text.length > 0) { + // tokenize + var output = ''; + var token = ''; + for(var index=0; index < text.length; index++) + { + if (text[index].match(/\s/)) { // whitespace + token += text[index]; + } + else { // character + output += token; + if(output == token) output += start_tag; + token = ''; + output += text[index]; + } + } + + if( output[output.length-1] == '\\' ) { + output = output.substr(0, output.length-1) + end_tag + '\\'; + } else { + output += end_tag; + } + output += token; + } + else { + output = start_tag + end_tag; + } + + this.XMLEditorReplaceSelectedText(context, output); + + if (text.length == 0) { + this.XMLEditorMoveCursorForward(context, -params.tag.length-3); + } + }.bind(this); + + this.scriptlets['lineregexp'] = function(context, params) { + + var exprs = $.map(params.exprs, function(expr) { + var opts = "g"; + if(expr.length > 2) { + opts = expr[2]; + } return { + rx: new RegExp(expr[0], opts), + repl: expr[1] + }; + }); + + var partial = true; + var text = this.XMLEditorSelectedText(context); + if(!text) return; + + var changed = 0; + var lines = text.split('\n'); + lines = $.map(lines, function(line) { + var old_line = line; + $(exprs).each(function() { + var expr = this; + line = line.replace(expr.rx, expr.repl); + }); + + if(old_line != line) changed += 1; + return line; + }); + + if(changed > 0) { + this.XMLEditorReplaceSelectedText(context, lines.join('\n') ); + } + }.bind(this); + + this.scriptlets['codemirror_fontsize'] = function(context, params) { + var frameBody = this.XMLEditorBody(context); + + if(params.fontSize) { + frameBody.css('font-size', params.fontSize); + } + else { + var old_size = parseInt(frameBody.css('font-size'), 10); + frameBody.css('font-size', old_size + (params.change || 0) ); + } + + }.bind(this); + + this.scriptlets['fulltextregexp'] = function(context, params) { + var exprs = $.map(params.exprs, function(expr) { + var opts = "mg"; + if(expr.length > 2) { + opts = expr[2]; + } + return { + rx: new RegExp(expr[0], opts), + repl: expr[1] + }; + }); + + var text = this.XMLEditorSelectedText(context); + if(!text) return; + var original = text; + $(exprs).each(function() { + text = text.replace(this.rx, this.repl); + }); + + if( original != text) { + this.XMLEditorReplaceSelectedText(context, text); + } + }.bind(this); + + this.scriptlets['macro'] = function(context, params) { + var self = this; + + $(params).each(function() { + $.log(this[0], this[1]); + self.scriptlets[this[0]](context, this[1]); + }); + }.bind(this); + + this.scriptlets['lowercase'] = function(context, params) + { + var text = this.XMLEditorSelectedText(context); + + if(!text) return; + + var repl = ''; + var lcase = text.toLowerCase(); + var ucase = text.toUpperCase(); + + if(lcase == text) repl = ucase; /* was lowercase */ + else if(ucase != text) repl = lcase; /* neither lower- or upper-case */ + else { /* upper case -> camel-case */ + var words = $(lcase.split(/\s/)).map(function() { + if(this.length > 0) { + return this[0].toUpperCase() + this.slice(1); + } else { + return ''; + } + }); + repl = words.join(' '); + } + + if(repl != text) this.XMLEditorReplaceSelectedText(context, repl); + }.bind(this); + + + this.scriptlets["insert_stanza"] = function(context, params) { + var text = this.XMLEditorSelectedText(context); + + if(text) { + var verses = text.split('\n'); + text = ''; var buf = ''; var ebuf = ''; + var first = true; + + for(var i=0; i < verses.length; i++) { + var verse = verses[i].replace(/^\s+/, "").replace(/\s+$/, ""); + if(verse) { + text += (buf ? buf + '/\n' : '') + ebuf; + buf = (first ? '\n' : '') + verses[i]; + ebuf = ''; + first = false; + } else { + ebuf += '\n' + verses[i]; + } + } + text = text + buf + '\n' + ebuf; + this.XMLEditorReplaceSelectedText(context, text); + } + + if (!text) { + this.XMLEditorMoveCursorForward(context, params.tag.length + 2); + } + + }.bind(this); + +} + +ScriptletCenter.prototype.XMLEditorSelectedText = function(panel) { + return panel.contentView.editor.selection(); +}; + +ScriptletCenter.prototype.XMLEditorReplaceSelectedText = function(panel, replacement) +{ + panel.contentView.editor.replaceSelection(replacement); + // Tell XML view that it's data has changed + panel.contentView.editorDataChanged(); +}; + +ScriptletCenter.prototype.XMLEditorMoveCursorForward = function(panel, n) { + var pos = panel.contentView.editor.cursorPosition(); + panel.contentView.editor.selectLines(pos.line, pos.character + n); +}; + +var scriptletCenter; + +$(function() { + scriptletCenter = new ScriptletCenter(); +}); \ No newline at end of file diff --git a/platforma/static/js/editor.js b/platforma/static/js/editor.js new file mode 100644 index 00000000..f52950ff --- /dev/null +++ b/platforma/static/js/editor.js @@ -0,0 +1,578 @@ +var editor; +var panel_hooks; + +function Hotkey(code) { + this.code = code; + this.has_alt = ((code & 0x01 << 8) !== 0); + this.has_ctrl = ((code & 0x01 << 9) !== 0); + this.has_shift = ((code & 0x01 << 10) !== 0); + this.character = String.fromCharCode(code & 0xff); +} + +Hotkey.prototype.toString = function() { + var mods = []; + if(this.has_alt) mods.push('Alt'); + if(this.has_ctrl) mods.push('Ctrl'); + if(this.has_shift) mods.push('Shift'); + mods.push('"'+this.character+'"'); + return mods.join('+'); +}; + +function Panel(panelWrap) { + var self = this; + self.hotkeys = []; + self.wrap = panelWrap; + self.contentDiv = $('.panel-content', panelWrap); + self.instanceId = Math.ceil(Math.random() * 1000000000); + // $.log('new panel - wrap: ', self.wrap); + + $(document).bind('panel:unload.' + self.instanceId, + function(event, data) { + self.unload(event, data); + }); + + $(document).bind('panel:contentChanged', function(event, data) { + $.log(self, ' got changed event from: ', data); + if(self != data) { + self.otherPanelChanged(event.target); + } else { + self.markChanged(); + } + return false; + }); +} + +Panel.prototype.callHook = function() { + var args = $.makeArray(arguments); + var hookName = args.splice(0,1)[0]; + var noHookAction = args.splice(0,1)[0]; + var result = false; + + $.log('calling hook: ', hookName, 'with args: ', args); + if(this.hooks && this.hooks[hookName]) { + result = this.hooks[hookName].apply(this, args); + } else if (noHookAction instanceof Function) { + result = noHookAction(args); + } + return result; +}; + +Panel.prototype._endload = function () { + // this needs to be here, so we + this.connectToolbar(); + this.callHook('toolbarResized'); +}; + +Panel.prototype.load = function (url) { + // $.log('preparing xhr load: ', this.wrap); + $(document).trigger('panel:unload', this); + var self = this; + self.current_url = url; + + $.ajax({ + url: url, + dataType: 'html', + success: function(data, tstat) { + panel_hooks = null; + $(self.contentDiv).html(data); + self.hooks = panel_hooks; + panel_hooks = null; + self.callHook('load'); + }, + error: function(request, textStatus, errorThrown) { + $.log('ajax', url, this.target, 'error:', textStatus, errorThrown); + $(self.contentDiv).html("

Wystapił błąd podczas wczytywania panelu.

"); + } + }); +}; + +Panel.prototype.unload = function(event, data) { + // $.log('got unload signal', this, ' target: ', data); + if( data == this ) { + $(this.contentDiv).html(''); + + // disconnect the toolbar + $('div.panel-toolbar span.panel-toolbar-extra', this.wrap).html( + ''); + + this.callHook('unload'); + this.hooks = null; // flush the hooks + return false; + } +}; + +Panel.prototype.refresh = function(event, data) { + var self = this; + var reload = function() { + $.log('hard reload for panel ', self.current_url); + self.load(self.current_url); + return true; + }; + + if( this.callHook('refresh', reload) ) { + $('.change-notification', this.wrap).fadeOut(); + } +}; + +Panel.prototype.otherPanelChanged = function(other) { + $.log('Panel ', this, ' is aware that ', other, ' changed.'); + if(!this.callHook('dirty')) { + $('.change-notification', this.wrap).fadeIn(); + } +}; + +Panel.prototype.markChanged = function () { + this.wrap.addClass('changed'); +}; + +Panel.prototype.changed = function () { + return this.wrap.hasClass('changed'); +}; + +Panel.prototype.unmarkChanged = function () { + this.wrap.removeClass('changed'); +}; + +Panel.prototype.saveInfo = function() { + var saveInfo = {}; + this.callHook('saveInfo', null, saveInfo); + return saveInfo; +}; + +Panel.prototype.connectToolbar = function() +{ + var self = this; + self.hotkeys = []; + + // check if there is a one + var toolbar = $("div.toolbar", this.contentDiv); + // $.log('Connecting toolbar', toolbar); + if(toolbar.length === 0) return; + + // move the extra + var extra_buttons = $('span.panel-toolbar-extra button', toolbar); + var placeholder = $('div.panel-toolbar span.panel-toolbar-extra > span', this.wrap); + placeholder.replaceWith(extra_buttons); + + // connect group-switch buttons + var group_buttons = $('*.toolbar-tabs-container button', toolbar); + + // $.log('Found groups:', group_buttons); + + group_buttons.each(function() { + var group = $(this); + var group_name = group.attr('ui:group'); + // $.log('Connecting group: ' + group_name); + + group.click(function() { + // change the active group + var active = $("*.toolbar-tabs-container button.active", toolbar); + if (active != group) { + active.removeClass('active'); + group.addClass('active'); + $(".toolbar-button-groups-container p", toolbar).each(function() { + if ( $(this).attr('ui:group') != group_name) { + $(this).hide(); + } else { + $(this).show(); + } + }); + self.callHook('toolbarResized'); + } + }); + }); + + // connect action buttons + var allbuttons = $.makeArray(extra_buttons); + $.merge(allbuttons, + $.makeArray($('*.toolbar-button-groups-container button', toolbar)) ); + + $(allbuttons).each(function() { + var button = $(this); + var hk = button.attr('ui:hotkey'); + if(hk) hk = new Hotkey( parseInt(hk) ); + + try { + var params = $.evalJSON(button.attr('ui:action-params')); + } catch(object) { + $.log('JSON exception in ', button, ': ', object); + button.attr('disabled', 'disabled'); + return; + } + + var callback = function() { + editor.callScriptlet(button.attr('ui:action'), self, params); + }; + + // connect button + button.click(callback); + + // connect hotkey + if(hk) { + self.hotkeys[hk.code] = callback; + // $.log('hotkey', hk); + } + + // tooltip + if (button.attr('ui:tooltip') ) + { + var tooltip = button.attr('ui:tooltip'); + if(hk) tooltip += ' ['+hk+']'; + + button.wTooltip({ + delay: 1000, + style: { + border: "1px solid #7F7D67", + opacity: 0.9, + background: "#FBFBC6", + padding: "1px", + fontSize: "12px" + }, + content: tooltip + }); + } + }); +}; + +Panel.prototype.hotkeyPressed = function(event) +{ + var code = event.keyCode; + if(event.altKey) code = code | 0x100; + if(event.ctrlKey) code = code | 0x200; + if(event.shiftKey) code = code | 0x400; + + var callback = this.hotkeys[code]; + if(callback) callback(); +}; + +Panel.prototype.isHotkey = function(event) { + var code = event.keyCode; + if(event.altKey) code = code | 0x100; + if(event.ctrlKey) code = code | 0x200; + if(event.shiftKey) code = code | 0x400; + + $.log(event.character, this.hotkeys[code]); + + if(this.hotkeys[code]) { + return true; + } + return false; +}; + +Panel.prototype.fireEvent = function(name) { + $(document).trigger('panel:'+name, this); +}; + +function Editor() +{ + this.rootDiv = $('#panels'); + this.popupQueue = []; + this.autosaveTimer = null; + this.scriplets = {}; +} + +Editor.prototype.loadConfig = function() { + // Load options from cookie + var defaultOptions = { + panels: [ + { + name: 'htmleditor', + ratio: 0.5 + }, + + { + name: 'gallery', + ratio: 0.5 + } + ], + recentFiles: [], + lastUpdate: 0 + }; + + try { + var cookie = $.cookie('options'); + this.options = $.secureEvalJSON(cookie); + if (!this.options) { + this.options = defaultOptions; + } + } catch (e) { + this.options = defaultOptions; + } + + this.fileOptions = this.options; + var self = this; + + if(!this.options.recentFiles) + this.options.recentFiles = []; + + $.each(this.options.recentFiles, function(index) { + if (fileId == self.options.recentFiles[index].fileId) { + $.log('Found options for', fileId); + self.fileOptions = self.options.recentFiles[index]; + } + }); + + $.log(this.options); + $.log('fileOptions', this.fileOptions); + + this.loadPanelOptions(); + this.savePanelOptions(); +}; + +Editor.prototype.loadPanelOptions = function() { + // var self = this; + // var totalWidth = 0; + // + // $('.panel-wrap', self.rootDiv).each(function(index) { + // var panelWidth = self.fileOptions.panels[index].ratio * self.rootDiv.width(); + // if ($(this).hasClass('last-panel')) { + // $(this).css({ + // left: totalWidth, + // right: 0 + // }); + // } else { + // $(this).css({ + // left: totalWidth, + // width: panelWidth + // }); + // totalWidth += panelWidth; + // } + // $.log('panel:', this, $(this).css('left')); + // $('.panel-toolbar option', this).each(function() { + // if ($(this).attr('p:panel-name') == self.fileOptions.panels[index].name) { + // $(this).parent('select').val($(this).attr('value')); + // } + // }); + // }); +}; + +Editor.prototype.savePanelOptions = function() { + var self = this; + var panels = []; + $('.panel-wrap', self.rootDiv).not('.panel-content-overlay').each(function() { + panels.push({ + name: $('.panel-toolbar option:selected', this).attr('p:panel-name'), + ratio: $(this).width() / self.rootDiv.width() + }); + }); + self.options.panels = panels; + + // Dodaj obecnie oglądany plik do listy recentFiles + var recentFiles = [{fileId: fileId, panels: panels}]; + var count = 1; + $.each(self.options.recentFiles, function(index) { + if (count < 5 && fileId != self.options.recentFiles[index].fileId) { + recentFiles.push(self.options.recentFiles[index]); + count++; + } + }); + self.options.recentFiles = recentFiles; + + self.options.lastUpdate = new Date().getTime() / 1000; + $.log($.toJSON(self.options)); + $.cookie('options', $.toJSON(self.options), { + expires: 7, + path: '/' + }); +}; + +Editor.prototype.saveToBranch = function(msg) +{ + var changed_panel = $('.panel-wrap.changed'); + var self = this; + $.log('Saving to local branch - panel:', changed_panel); + + if(!msg) msg = "Szybki zapis z edytora platformy."; + + if( changed_panel.length === 0) { + $.log('Nothing to save.'); + return true; /* no changes */ + } + + if( changed_panel.length > 1) { + alert('Błąd: więcej niż jeden panel został zmodyfikowany. Nie można zapisać.'); + return false; + } + + var saveInfo = changed_panel.data('ctrl').saveInfo(); + var postData = ''; + + if (saveInfo.postData instanceof Object) { + postData = $.param(saveInfo.postData); + } else { + postData = saveInfo.postData; + } + + postData += '&' + $.param({ + 'commit_message': msg + }); + + self.showPopup('save-waiting', '', -1); + + $.ajax({ + url: saveInfo.url, + dataType: 'json', + success: function(data, textStatus) { + if (data.result != 'ok') { + self.showPopup('save-error', (data.errors && data.errors[0]) || 'Nieznany błąd X_X.'); + } + else { + self.refreshPanels(); + + + if(self.autosaveTimer) { + clearTimeout(self.autosaveTimer); + } + if (data.warnings === null || data.warning === undefined) { + self.showPopup('save-successful'); + } else { + self.showPopup('save-warn', data.warnings[0]); + } + } + + self.advancePopupQueue(); + }, + error: function(rq, tstat, err) { + self.showPopup('save-error', '- bład wewnętrzny serwera.'); + self.advancePopupQueue(); + }, + type: 'POST', + data: postData + }); + + return true; +}; + +Editor.prototype.autoSave = function() +{ + this.autosaveTimer = null; + // first check if there is anything to save + $.log('Autosave'); + this.saveToBranch("Automatyczny zapis z edytora platformy."); +}; + +Editor.prototype.onContentChanged = function(event, data) { + var self = this; + + $('button.provides-save').removeAttr('disabled'); + $('button.requires-save').attr('disabled', 'disabled'); + + if(this.autosaveTimer) return; + this.autosaveTimer = setTimeout( function() { + self.autoSave(); + }, 300000 ); +}; + +Editor.prototype.updateUserBranch = function() { + if($('.panel-wrap.changed').length !== 0) { + alert("There are unsaved changes - can't update."); + } + + var self = this; + $.ajax({ + url: $('#toolbar-button-update').attr('ui:ajax-action'), + dataType: 'json', + success: function(data, textStatus) { + switch(data.result) { + case 'done': + self.showPopup('generic-yes', 'Plik uaktualniony.'); + self.refreshPanels(); + break; + case 'nothing-to-do': + self.showPopup('generic-info', 'Brak zmian do uaktualnienia.'); + break; + default: + self.showPopup('generic-error', data.errors && data.errors[0]); + } + }, + error: function(rq, tstat, err) { + self.showPopup('generic-error', 'Błąd serwera: ' + err); + }, + type: 'POST', + data: {} + }); +}; + +Editor.prototype.sendMergeRequest = function (message) { + if( $('.panel-wrap.changed').length !== 0) { + alert("There are unsaved changes - can't commit."); + } + + var self = this; + + $.ajax({ + url: $('#commit-dialog form').attr('action'), + dataType: 'json', + success: function(data, textStatus) { + switch(data.result) { + case 'done': + self.showPopup('generic-yes', 'Łączenie zmian powiodło się.'); + + if(data.localmodified) { + self.refreshPanels(); + } + + break; + case 'nothing-to-do': + self.showPopup('generic-info', 'Brak zmian do połaczenia.'); + break; + default: + self.showPopup('generic-error', data.errors && data.errors[0]); + } + }, + error: function(rq, tstat, err) { + self.showPopup('generic-error', 'Błąd serwera: ' + err); + }, + type: 'POST', + data: { + 'message': message + } + }); +}; + +Editor.prototype.postSplitRequest = function(s, f) +{ + $.ajax({ + url: $('#split-dialog form').attr('action'), + dataType: 'html', + success: s, + error: f, + type: 'POST', + data: $('#split-dialog form').serialize() + }); +}; + + +Editor.prototype.allPanels = function() { + return $('#' + this.rootDiv.attr('id') +' > *.panel-wrap', this.rootDiv.parent()); +}; + +Editor.prototype.registerScriptlet = function(scriptlet_id, scriptlet_func) +{ + // I briefly assume, that it's verified not to break the world on SS + if (!this[scriptlet_id]) { + this[scriptlet_id] = scriptlet_func; + } +}; + +Editor.prototype.callScriptlet = function(scriptlet_id, panel, params) { + var func = this[scriptlet_id]; + if(!func) { + throw 'No scriptlet named "' + scriptlet_id + '" found.'; + } + return func(this, panel, params); +}; + +$(function() { + $.fbind = function (self, func) { + return function() { + return func.apply(self, arguments); + }; + }; + + editor = new Editor(); + + // do the layout + editor.loadConfig(); + editor.setupUI(); +}); diff --git a/platforma/static/js/lib/codemirror/codemirror.js b/platforma/static/js/lib/codemirror/codemirror.js new file mode 100644 index 00000000..f63ed07e --- /dev/null +++ b/platforma/static/js/lib/codemirror/codemirror.js @@ -0,0 +1,309 @@ +/* CodeMirror main module + * + * Implements the CodeMirror constructor and prototype, which take care + * of initializing the editor frame, and providing the outside interface. + */ + +// The CodeMirrorConfig object is used to specify a default +// configuration. If you specify such an object before loading this +// file, the values you put into it will override the defaults given +// below. You can also assign to it after loading. +var CodeMirrorConfig = window.CodeMirrorConfig || {}; + +var CodeMirror = (function(){ + function setDefaults(object, defaults) { + for (var option in defaults) { + if (!object.hasOwnProperty(option)) + object[option] = defaults[option]; + } + } + function forEach(array, action) { + for (var i = 0; i < array.length; i++) + action(array[i]); + } + + // These default options can be overridden by passing a set of + // options to a specific CodeMirror constructor. See manual.html for + // their meaning. + setDefaults(CodeMirrorConfig, { + stylesheet: "", + path: "", + parserfile: [], + basefiles: ["util.js", "stringstream.js", "select.js", "undo.js", "editor.js", "tokenize.js"], + iframeClass: null, + passDelay: 200, + passTime: 50, + continuousScanning: false, + saveFunction: null, + onChange: null, + undoDepth: 50, + undoDelay: 800, + disableSpellcheck: true, + textWrapping: true, + readOnly: false, + width: "100%", + height: "300px", + autoMatchParens: false, + parserConfig: null, + tabMode: "indent", // or "spaces", "default", "shift" + reindentOnLoad: false, + activeTokens: null, + cursorActivity: null, + lineNumbers: false, + indentUnit: 2 + }); + + function wrapLineNumberDiv(place) { + return function(node) { + var container = document.createElement("DIV"), + nums = document.createElement("DIV"), + scroller = document.createElement("DIV"); + container.style.position = "relative"; + nums.style.position = "absolute"; + nums.style.height = "100%"; + if (nums.style.setExpression) { + try {nums.style.setExpression("height", "this.previousSibling.offsetHeight + 'px'");} + catch(e) {} // Seems to throw 'Not Implemented' on some IE8 versions + } + nums.style.top = "0px"; + nums.style.overflow = "hidden"; + place(container); + container.appendChild(node); + container.appendChild(nums); + scroller.className = "CodeMirror-line-numbers"; + nums.appendChild(scroller); + } + } + + function applyLineNumbers(frame) { + var win = frame.contentWindow, doc = win.document, + nums = frame.nextSibling, scroller = nums.firstChild; + + var nextNum = 1, barWidth = null; + function sizeBar() { + for (var root = frame; root.parentNode; root = root.parentNode); + if (root != document || !win.Editor) { + clearInterval(sizeInterval); + return; + } + + if (nums.offsetWidth != barWidth) { + barWidth = nums.offsetWidth; + nums.style.left = "-" + (frame.parentNode.style.marginLeft = barWidth + "px"); + } + } + function update() { + var diff = 20 + Math.max(doc.body.offsetHeight, frame.offsetHeight) - scroller.offsetHeight; + for (var n = Math.ceil(diff / 10); n > 0; n--) { + var div = document.createElement("DIV"); + div.appendChild(document.createTextNode(nextNum++)); + scroller.appendChild(div); + } + nums.scrollTop = doc.body.scrollTop || doc.documentElement.scrollTop || 0; + } + sizeBar(); + update(); + win.addEventHandler(win, "scroll", update); + win.addEventHandler(win, "resize", update); + var sizeInterval = setInterval(sizeBar, 500); + } + + function CodeMirror(place, options) { + // Backward compatibility for deprecated options. + if (options.dumbTabs) options.tabMode = "spaces"; + else if (options.normalTab) options.tabMode = "default"; + + // Use passed options, if any, to override defaults. + this.options = options = options || {}; + setDefaults(options, CodeMirrorConfig); + + var frame = this.frame = document.createElement("IFRAME"); + if (options.iframeClass) frame.className = options.iframeClass; + frame.frameBorder = 0; + frame.src = "javascript:false;"; + frame.style.border = "0"; + frame.style.width = options.width; + frame.style.height = options.height; + // display: block occasionally suppresses some Firefox bugs, so we + // always add it, redundant as it sounds. + frame.style.display = "block"; + + if (place.appendChild) { + var node = place; + place = function(n){node.appendChild(n);}; + } + + if (options.lineNumbers) place = wrapLineNumberDiv(place); + place(frame); + + // Link back to this object, so that the editor can fetch options + // and add a reference to itself. + frame.CodeMirror = this; + this.win = frame.contentWindow; + + if (typeof options.parserfile == "string") + options.parserfile = [options.parserfile]; + if (typeof options.stylesheet == "string") + options.stylesheet = [options.stylesheet]; + + var html = [""]; + // Hack to work around a bunch of IE8-specific problems. + html.push(""); + forEach(options.stylesheet, function(file) { + html.push(""); + }); + forEach(options.basefiles.concat(options.parserfile), function(file) { + html.push(""); + }); + html.push(""); + + var doc = this.win.document; + doc.open(); + doc.write(html.join("")); + doc.close(); + } + + CodeMirror.prototype = { + init: function() { + if (this.options.initCallback) this.options.initCallback(this); + if (this.options.lineNumbers) applyLineNumbers(this.frame); + if (this.options.reindentOnLoad) this.reindent(); + }, + + getCode: function() {return this.editor.getCode();}, + setCode: function(code) {this.editor.importCode(code);}, + selection: function() {this.focusIfIE(); return this.editor.selectedText();}, + reindent: function() {this.editor.reindent();}, + reindentSelection: function() {this.focusIfIE(); this.editor.reindentSelection(null);}, + + focusIfIE: function() { + // in IE, a lot of selection-related functionality only works when the frame is focused + if (this.win.select.ie_selection) this.focus(); + }, + focus: function() { + this.win.focus(); + if (this.editor.selectionSnapshot) // IE hack + this.win.select.selectCoords(this.win, this.editor.selectionSnapshot); + }, + replaceSelection: function(text) { + this.focus(); + this.editor.replaceSelection(text); + return true; + }, + replaceChars: function(text, start, end) { + this.editor.replaceChars(text, start, end); + }, + getSearchCursor: function(string, fromCursor) { + return this.editor.getSearchCursor(string, fromCursor); + }, + + undo: function() {this.editor.history.undo();}, + redo: function() {this.editor.history.redo();}, + historySize: function() {return this.editor.history.historySize();}, + clearHistory: function() {this.editor.history.clear();}, + + grabKeys: function(callback, filter) {this.editor.grabKeys(callback, filter);}, + ungrabKeys: function() {this.editor.ungrabKeys();}, + + setParser: function(name) {this.editor.setParser(name);}, + + cursorPosition: function(start) {this.focusIfIE(); return this.editor.cursorPosition(start);}, + firstLine: function() {return this.editor.firstLine();}, + lastLine: function() {return this.editor.lastLine();}, + nextLine: function(line) {return this.editor.nextLine(line);}, + prevLine: function(line) {return this.editor.prevLine(line);}, + lineContent: function(line) {return this.editor.lineContent(line);}, + setLineContent: function(line, content) {this.editor.setLineContent(line, content);}, + insertIntoLine: function(line, position, content) {this.editor.insertIntoLine(line, position, content);}, + selectLines: function(startLine, startOffset, endLine, endOffset) { + this.win.focus(); + this.editor.selectLines(startLine, startOffset, endLine, endOffset); + }, + nthLine: function(n) { + var line = this.firstLine(); + for (; n > 1 && line !== false; n--) + line = this.nextLine(line); + return line; + }, + lineNumber: function(line) { + var num = 0; + while (line !== false) { + num++; + line = this.prevLine(line); + } + return num; + }, + + // Old number-based line interface + jumpToLine: function(n) { + this.selectLines(this.nthLine(n), 0); + this.win.focus(); + }, + currentLine: function() { + return this.lineNumber(this.cursorPosition().line); + } + }; + + CodeMirror.InvalidLineHandle = {toString: function(){return "CodeMirror.InvalidLineHandle";}}; + + CodeMirror.replace = function(element) { + if (typeof element == "string") + element = document.getElementById(element); + return function(newElement) { + element.parentNode.replaceChild(newElement, element); + }; + }; + + CodeMirror.fromTextArea = function(area, options) { + if (typeof area == "string") + area = document.getElementById(area); + + options = options || {}; + if (area.style.width && options.width == null) + options.width = area.style.width; + if (area.style.height && options.height == null) + options.height = area.style.height; + if (options.content == null) options.content = area.value; + + if (area.form) { + function updateField() { + area.value = mirror.getCode(); + } + if (typeof area.form.addEventListener == "function") + area.form.addEventListener("submit", updateField, false); + else + area.form.attachEvent("onsubmit", updateField); + } + + function insert(frame) { + if (area.nextSibling) + area.parentNode.insertBefore(frame, area.nextSibling); + else + area.parentNode.appendChild(frame); + } + + area.style.display = "none"; + var mirror = new CodeMirror(insert, options); + return mirror; + }; + + CodeMirror.isProbablySupported = function() { + // This is rather awful, but can be useful. + var match; + if (window.opera) + return Number(window.opera.version()) >= 9.52; + else if (/Apple Computers, Inc/.test(navigator.vendor) && (match = navigator.userAgent.match(/Version\/(\d+(?:\.\d+)?)\./))) + return Number(match[1]) >= 3; + else if (document.selection && window.ActiveXObject && (match = navigator.userAgent.match(/MSIE (\d+(?:\.\d*)?)\b/))) + return Number(match[1]) >= 6; + else if (match = navigator.userAgent.match(/gecko\/(\d{8})/i)) + return Number(match[1]) >= 20050901; + else if (match = navigator.userAgent.match(/AppleWebKit\/(\d+)/)) + return Number(match[1]) >= 525; + else + return null; + }; + + return CodeMirror; +})(); diff --git a/platforma/static/js/lib/codemirror/editor.js b/platforma/static/js/lib/codemirror/editor.js new file mode 100644 index 00000000..3d7a2053 --- /dev/null +++ b/platforma/static/js/lib/codemirror/editor.js @@ -0,0 +1,1314 @@ +/* The Editor object manages the content of the editable frame. It + * catches events, colours nodes, and indents lines. This file also + * holds some functions for transforming arbitrary DOM structures into + * plain sequences of and
elements + */ + +// Make sure a string does not contain two consecutive 'collapseable' +// whitespace characters. +function makeWhiteSpace(n) { + var buffer = [], nb = true; + for (; n > 0; n--) { + buffer.push((nb || n == 1) ? nbsp : " "); + nb = !nb; + } + return buffer.join(""); +} + +// Create a set of white-space characters that will not be collapsed +// by the browser, but will not break text-wrapping either. +function fixSpaces(string) { + if (string.charAt(0) == " ") string = nbsp + string.slice(1); + return string.replace(/\t/g, function(){return makeWhiteSpace(indentUnit);}) + .replace(/[ \u00a0]{2,}/g, function(s) {return makeWhiteSpace(s.length);}); +} + +function cleanText(text) { + return text.replace(/\u00a0/g, " ").replace(/\u200b/g, ""); +} + +// Create a SPAN node with the expected properties for document part +// spans. +function makePartSpan(value, doc) { + var text = value; + if (value.nodeType == 3) text = value.nodeValue; + else value = doc.createTextNode(text); + + var span = doc.createElement("SPAN"); + span.isPart = true; + span.appendChild(value); + span.currentText = text; + return span; +} + +// On webkit, when the last BR of the document does not have text +// behind it, the cursor can not be put on the line after it. This +// makes pressing enter at the end of the document occasionally do +// nothing (or at least seem to do nothing). To work around it, this +// function makes sure the document ends with a span containing a +// zero-width space character. The traverseDOM iterator filters such +// character out again, so that the parsers won't see them. This +// function is called from a few strategic places to make sure the +// zwsp is restored after the highlighting process eats it. +var webkitLastLineHack = webkit ? + function(container) { + var last = container.lastChild; + if (!last || !last.isPart || last.textContent != "\u200b") + container.appendChild(makePartSpan("\u200b", container.ownerDocument)); + } : function() {}; + +var Editor = (function(){ + // The HTML elements whose content should be suffixed by a newline + // when converting them to flat text. + var newlineElements = {"P": true, "DIV": true, "LI": true}; + + function asEditorLines(string) { + var tab = makeWhiteSpace(indentUnit); + return map(string.replace(/\t/g, tab).replace(/\u00a0/g, " ").replace(/\r\n?/g, "\n").split("\n"), fixSpaces); + } + + // Helper function for traverseDOM. Flattens an arbitrary DOM node + // into an array of textnodes and
tags. + function simplifyDOM(root, atEnd) { + var doc = root.ownerDocument; + var result = []; + var leaving = true; + + function simplifyNode(node, top) { + if (node.nodeType == 3) { + var text = node.nodeValue = fixSpaces(node.nodeValue.replace(/[\r\u200b]/g, "").replace(/\n/g, " ")); + if (text.length) leaving = false; + result.push(node); + } + else if (isBR(node) && node.childNodes.length == 0) { + leaving = true; + result.push(node); + } + else { + forEach(node.childNodes, simplifyNode); + if (!leaving && newlineElements.hasOwnProperty(node.nodeName.toUpperCase())) { + leaving = true; + if (!atEnd || !top) + result.push(doc.createElement("BR")); + } + } + } + + simplifyNode(root, true); + return result; + } + + // Creates a MochiKit-style iterator that goes over a series of DOM + // nodes. The values it yields are strings, the textual content of + // the nodes. It makes sure that all nodes up to and including the + // one whose text is being yielded have been 'normalized' to be just + // and
elements. + // See the story.html file for some short remarks about the use of + // continuation-passing style in this iterator. + function traverseDOM(start){ + function yield(value, c){cc = c; return value;} + function push(fun, arg, c){return function(){return fun(arg, c);};} + function stop(){cc = stop; throw StopIteration;}; + var cc = push(scanNode, start, stop); + var owner = start.ownerDocument; + var nodeQueue = []; + + // Create a function that can be used to insert nodes after the + // one given as argument. + function pointAt(node){ + var parent = node.parentNode; + var next = node.nextSibling; + return function(newnode) { + parent.insertBefore(newnode, next); + }; + } + var point = null; + + // Insert a normalized node at the current point. If it is a text + // node, wrap it in a , and give that span a currentText + // property -- this is used to cache the nodeValue, because + // directly accessing nodeValue is horribly slow on some browsers. + // The dirty property is used by the highlighter to determine + // which parts of the document have to be re-highlighted. + function insertPart(part){ + var text = "\n"; + if (part.nodeType == 3) { + select.snapshotChanged(); + part = makePartSpan(part, owner); + text = part.currentText; + } + part.dirty = true; + nodeQueue.push(part); + point(part); + return text; + } + + // Extract the text and newlines from a DOM node, insert them into + // the document, and yield the textual content. Used to replace + // non-normalized nodes. + function writeNode(node, c, end) { + var toYield = []; + forEach(simplifyDOM(node, end), function(part) { + toYield.push(insertPart(part)); + }); + return yield(toYield.join(""), c); + } + + // Check whether a node is a normalized element. + function partNode(node){ + if (node.isPart && node.childNodes.length == 1 && node.firstChild.nodeType == 3) { + node.currentText = node.firstChild.nodeValue; + return !/[\n\t\r]/.test(node.currentText); + } + return false; + } + + // Handle a node. Add its successor to the continuation if there + // is one, find out whether the node is normalized. If it is, + // yield its content, otherwise, normalize it (writeNode will take + // care of yielding). + function scanNode(node, c){ + if (node.nextSibling) + c = push(scanNode, node.nextSibling, c); + + if (partNode(node)){ + nodeQueue.push(node); + return yield(node.currentText, c); + } + else if (isBR(node)) { + nodeQueue.push(node); + return yield("\n", c); + } + else { + var end = !node.nextSibling; + point = pointAt(node); + removeElement(node); + return writeNode(node, c, end); + } + } + + // MochiKit iterators are objects with a next function that + // returns the next value or throws StopIteration when there are + // no more values. + return {next: function(){return cc();}, nodes: nodeQueue}; + } + + // Determine the text size of a processed node. + function nodeSize(node) { + return isBR(node) ? 1 : node.currentText.length; + } + + // Search backwards through the top-level nodes until the next BR or + // the start of the frame. + function startOfLine(node) { + while (node && !isBR(node)) node = node.previousSibling; + return node; + } + function endOfLine(node, container) { + if (!node) node = container.firstChild; + else if (isBR(node)) node = node.nextSibling; + + while (node && !isBR(node)) node = node.nextSibling; + return node; + } + + function time() {return new Date().getTime();} + + // Client interface for searching the content of the editor. Create + // these by calling CodeMirror.getSearchCursor. To use, call + // findNext on the resulting object -- this returns a boolean + // indicating whether anything was found, and can be called again to + // skip to the next find. Use the select and replace methods to + // actually do something with the found locations. + function SearchCursor(editor, string, fromCursor) { + this.editor = editor; + this.history = editor.history; + this.history.commit(); + + // Are we currently at an occurrence of the search string? + this.atOccurrence = false; + // The object stores a set of nodes coming after its current + // position, so that when the current point is taken out of the + // DOM tree, we can still try to continue. + this.fallbackSize = 15; + var cursor; + // Start from the cursor when specified and a cursor can be found. + if (fromCursor && (cursor = select.cursorPos(this.editor.container))) { + this.line = cursor.node; + this.offset = cursor.offset; + } + else { + this.line = null; + this.offset = 0; + } + this.valid = !!string; + + // Create a matcher function based on the kind of string we have. + var target = string.split("\n"), self = this; + this.matches = (target.length == 1) ? + // For one-line strings, searching can be done simply by calling + // indexOf on the current line. + function() { + var match = cleanText(self.history.textAfter(self.line).slice(self.offset)).indexOf(string); + if (match > -1) + return {from: {node: self.line, offset: self.offset + match}, + to: {node: self.line, offset: self.offset + match + string.length}}; + } : + // Multi-line strings require internal iteration over lines, and + // some clunky checks to make sure the first match ends at the + // end of the line and the last match starts at the start. + function() { + var firstLine = cleanText(self.history.textAfter(self.line).slice(self.offset)); + var match = firstLine.lastIndexOf(target[0]); + if (match == -1 || match != firstLine.length - target[0].length) + return false; + var startOffset = self.offset + match; + + var line = self.history.nodeAfter(self.line); + for (var i = 1; i < target.length - 1; i++) { + if (cleanText(self.history.textAfter(line)) != target[i]) + return false; + line = self.history.nodeAfter(line); + } + + if (cleanText(self.history.textAfter(line)).indexOf(target[target.length - 1]) != 0) + return false; + + return {from: {node: self.line, offset: startOffset}, + to: {node: line, offset: target[target.length - 1].length}}; + }; + } + + SearchCursor.prototype = { + findNext: function() { + if (!this.valid) return false; + this.atOccurrence = false; + var self = this; + + // Go back to the start of the document if the current line is + // no longer in the DOM tree. + if (this.line && !this.line.parentNode) { + this.line = null; + this.offset = 0; + } + + // Set the cursor's position one character after the given + // position. + function saveAfter(pos) { + if (self.history.textAfter(pos.node).length > pos.offset) { + self.line = pos.node; + self.offset = pos.offset + 1; + } + else { + self.line = self.history.nodeAfter(pos.node); + self.offset = 0; + } + } + + while (true) { + var match = this.matches(); + // Found the search string. + if (match) { + this.atOccurrence = match; + saveAfter(match.from); + return true; + } + this.line = this.history.nodeAfter(this.line); + this.offset = 0; + // End of document. + if (!this.line) { + this.valid = false; + return false; + } + } + }, + + select: function() { + if (this.atOccurrence) { + select.setCursorPos(this.editor.container, this.atOccurrence.from, this.atOccurrence.to); + select.scrollToCursor(this.editor.container); + } + }, + + replace: function(string) { + if (this.atOccurrence) { + var end = this.editor.replaceRange(this.atOccurrence.from, this.atOccurrence.to, string); + this.line = end.node; + this.offset = end.offset; + this.atOccurrence = false; + } + } + }; + + // The Editor object is the main inside-the-iframe interface. + function Editor(options) { + this.options = options; + window.indentUnit = options.indentUnit; + this.parent = parent; + this.doc = document; + var container = this.container = this.doc.body; + this.win = window; + this.history = new History(container, options.undoDepth, options.undoDelay, + this, options.onChange); + var self = this; + + if (!Editor.Parser) + throw "No parser loaded."; + if (options.parserConfig && Editor.Parser.configure) + Editor.Parser.configure(options.parserConfig); + + if (!options.readOnly) + select.setCursorPos(container, {node: null, offset: 0}); + + this.dirty = []; + if (options.content) + this.importCode(options.content); + + if (!options.readOnly) { + if (options.continuousScanning !== false) { + this.scanner = this.documentScanner(options.passTime); + this.delayScanning(); + } + + function setEditable() { + // In IE, designMode frames can not run any scripts, so we use + // contentEditable instead. + if (document.body.contentEditable != undefined && internetExplorer) + document.body.contentEditable = "true"; + else + document.designMode = "on"; + + document.documentElement.style.borderWidth = "0"; + if (!options.textWrapping) + container.style.whiteSpace = "nowrap"; + } + + // If setting the frame editable fails, try again when the user + // focus it (happens when the frame is not visible on + // initialisation, in Firefox). + try { + setEditable(); + } + catch(e) { + var focusEvent = addEventHandler(document, "focus", function() { + focusEvent(); + setEditable(); + }, true); + } + + addEventHandler(document, "keydown", method(this, "keyDown")); + addEventHandler(document, "keypress", method(this, "keyPress")); + addEventHandler(document, "keyup", method(this, "keyUp")); + + function cursorActivity() {self.cursorActivity(false);} + addEventHandler(document.body, "mouseup", cursorActivity); + addEventHandler(document.body, "cut", cursorActivity); + + addEventHandler(document.body, "paste", function(event) { + cursorActivity(); + var text = null; + try { + var clipboardData = event.clipboardData || window.clipboardData; + if (clipboardData) text = clipboardData.getData('Text'); + } + catch(e) {} + if (text !== null) { + self.replaceSelection(text); + event.stop(); + } + }); + + addEventHandler(document.body, "beforepaste", method(this, "reroutePasteEvent")); + + if (this.options.autoMatchParens) + addEventHandler(document.body, "click", method(this, "scheduleParenBlink")); + } + else if (!options.textWrapping) { + container.style.whiteSpace = "nowrap"; + } + } + + function isSafeKey(code) { + return (code >= 16 && code <= 18) || // shift, control, alt + (code >= 33 && code <= 40); // arrows, home, end + } + + Editor.prototype = { + // Import a piece of code into the editor. + importCode: function(code) { + this.history.push(null, null, asEditorLines(code)); + this.history.reset(); + }, + + // Extract the code from the editor. + getCode: function() { + if (!this.container.firstChild) + return ""; + + var accum = []; + select.markSelection(this.win); + forEach(traverseDOM(this.container.firstChild), method(accum, "push")); + webkitLastLineHack(this.container); + select.selectMarked(); + return cleanText(accum.join("")); + }, + + checkLine: function(node) { + if (node === false || !(node == null || node.parentNode == this.container)) + throw parent.CodeMirror.InvalidLineHandle; + }, + + cursorPosition: function(start) { + if (start == null) start = true; + var pos = select.cursorPos(this.container, start); + if (pos) return {line: pos.node, character: pos.offset}; + else return {line: null, character: 0}; + }, + + firstLine: function() { + return null; + }, + + lastLine: function() { + if (this.container.lastChild) return startOfLine(this.container.lastChild); + else return null; + }, + + nextLine: function(line) { + this.checkLine(line); + var end = endOfLine(line, this.container); + return end || false; + }, + + prevLine: function(line) { + this.checkLine(line); + if (line == null) return false; + return startOfLine(line.previousSibling); + }, + + selectLines: function(startLine, startOffset, endLine, endOffset) { + this.checkLine(startLine); + var start = {node: startLine, offset: startOffset}, end = null; + if (endOffset !== undefined) { + this.checkLine(endLine); + end = {node: endLine, offset: endOffset}; + } + select.setCursorPos(this.container, start, end); + select.scrollToCursor(this.container); + }, + + lineContent: function(line) { + this.checkLine(line); + var accum = []; + for (line = line ? line.nextSibling : this.container.firstChild; + line && !isBR(line); line = line.nextSibling) + accum.push(nodeText(line)); + return cleanText(accum.join("")); + }, + + setLineContent: function(line, content) { + this.history.commit(); + this.replaceRange({node: line, offset: 0}, + {node: line, offset: this.history.textAfter(line).length}, + content); + this.addDirtyNode(line); + this.scheduleHighlight(); + }, + + insertIntoLine: function(line, position, content) { + var before = null; + if (position == "end") { + before = endOfLine(line, this.container); + } + else { + for (var cur = line ? line.nextSibling : this.container.firstChild; cur; cur = cur.nextSibling) { + if (position == 0) { + before = cur; + break; + } + var text = nodeText(cur); + if (text.length > position) { + before = cur.nextSibling; + content = text.slice(0, position) + content + text.slice(position); + removeElement(cur); + break; + } + position -= text.length; + } + } + + var lines = asEditorLines(content), doc = this.container.ownerDocument; + for (var i = 0; i < lines.length; i++) { + if (i > 0) this.container.insertBefore(doc.createElement("BR"), before); + this.container.insertBefore(makePartSpan(lines[i], doc), before); + } + this.addDirtyNode(line); + this.scheduleHighlight(); + }, + + // Retrieve the selected text. + selectedText: function() { + var h = this.history; + h.commit(); + + var start = select.cursorPos(this.container, true), + end = select.cursorPos(this.container, false); + if (!start || !end) return ""; + + if (start.node == end.node) + return h.textAfter(start.node).slice(start.offset, end.offset); + + var text = [h.textAfter(start.node).slice(start.offset)]; + for (var pos = h.nodeAfter(start.node); pos != end.node; pos = h.nodeAfter(pos)) + text.push(h.textAfter(pos)); + text.push(h.textAfter(end.node).slice(0, end.offset)); + return cleanText(text.join("\n")); + }, + + // Replace the selection with another piece of text. + replaceSelection: function(text) { + this.history.commit(); + + var start = select.cursorPos(this.container, true), + end = select.cursorPos(this.container, false); + if (!start || !end) return; + + end = this.replaceRange(start, end, text); + select.setCursorPos(this.container, end); + webkitLastLineHack(this.container); + }, + + reroutePasteEvent: function() { + if (this.capturingPaste || window.opera) return; + this.capturingPaste = true; + var te = parent.document.createElement("TEXTAREA"); + te.style.position = "absolute"; + te.style.left = "-500px"; + te.style.width = "10px"; + te.style.top = nodeTop(frameElement) + "px"; + parent.document.body.appendChild(te); + parent.focus(); + te.focus(); + + var self = this; + this.parent.setTimeout(function() { + self.capturingPaste = false; + self.win.focus(); + if (self.selectionSnapshot) // IE hack + self.win.select.selectCoords(self.win, self.selectionSnapshot); + var text = te.value; + if (text) self.replaceSelection(text); + removeElement(te); + }, 10); + }, + + replaceRange: function(from, to, text) { + var lines = asEditorLines(text); + lines[0] = this.history.textAfter(from.node).slice(0, from.offset) + lines[0]; + var lastLine = lines[lines.length - 1]; + lines[lines.length - 1] = lastLine + this.history.textAfter(to.node).slice(to.offset); + var end = this.history.nodeAfter(to.node); + this.history.push(from.node, end, lines); + return {node: this.history.nodeBefore(end), + offset: lastLine.length}; + }, + + getSearchCursor: function(string, fromCursor) { + return new SearchCursor(this, string, fromCursor); + }, + + // Re-indent the whole buffer + reindent: function() { + if (this.container.firstChild) + this.indentRegion(null, this.container.lastChild); + }, + + reindentSelection: function(direction) { + if (!select.somethingSelected(this.win)) { + this.indentAtCursor(direction); + } + else { + var start = select.selectionTopNode(this.container, true), + end = select.selectionTopNode(this.container, false); + if (start === false || end === false) return; + this.indentRegion(start, end, direction); + } + }, + + grabKeys: function(eventHandler, filter) { + this.frozen = eventHandler; + this.keyFilter = filter; + }, + ungrabKeys: function() { + this.frozen = "leave"; + this.keyFilter = null; + }, + + setParser: function(name) { + Editor.Parser = window[name]; + if (this.container.firstChild) { + forEach(this.container.childNodes, function(n) { + if (n.nodeType != 3) n.dirty = true; + }); + this.addDirtyNode(this.firstChild); + this.scheduleHighlight(); + } + }, + + // Intercept enter and tab, and assign their new functions. + keyDown: function(event) { + if (this.frozen == "leave") this.frozen = null; + if (this.frozen && (!this.keyFilter || this.keyFilter(event))) { + event.stop(); + this.frozen(event); + return; + } + + var code = event.keyCode; + // Don't scan when the user is typing. + this.delayScanning(); + // Schedule a paren-highlight event, if configured. + if (this.options.autoMatchParens) + this.scheduleParenBlink(); + + // The various checks for !altKey are there because AltGr sets both + // ctrlKey and altKey to true, and should not be recognised as + // Control. + if (code == 13) { // enter + if (event.ctrlKey && !event.altKey) { + this.reparseBuffer(); + } + else { + select.insertNewlineAtCursor(this.win); + this.indentAtCursor(); + select.scrollToCursor(this.container); + } + event.stop(); + } + else if (code == 9 && this.options.tabMode != "default") { // tab + this.handleTab(!event.ctrlKey && !event.shiftKey); + event.stop(); + } + else if (code == 32 && event.shiftKey && this.options.tabMode == "default") { // space + this.handleTab(true); + event.stop(); + } + else if (code == 36 && !event.shiftKey && !event.ctrlKey) { // home + if (this.home()) + event.stop(); + } + else if ((code == 219 || code == 221) && event.ctrlKey && !event.altKey) { // [, ] + this.blinkParens(event.shiftKey); + event.stop(); + } + else if (event.metaKey && !event.shiftKey && (code == 37 || code == 39)) { // Meta-left/right + var cursor = select.selectionTopNode(this.container); + if (cursor === false || !this.container.firstChild) return; + + if (code == 37) select.focusAfterNode(startOfLine(cursor), this.container); + else { + var end = endOfLine(cursor, this.container); + select.focusAfterNode(end ? end.previousSibling : this.container.lastChild, this.container); + } + event.stop(); + } + else if ((event.ctrlKey || event.metaKey) && !event.altKey) { + if ((event.shiftKey && code == 90) || code == 89) { // shift-Z, Y + select.scrollToNode(this.history.redo()); + event.stop(); + } + else if (code == 90 || (safari && code == 8)) { // Z, backspace + select.scrollToNode(this.history.undo()); + event.stop(); + } + else if (code == 83 && this.options.saveFunction) { // S + this.options.saveFunction(); + event.stop(); + } + } + }, + + // Check for characters that should re-indent the current line, + // and prevent Opera from handling enter and tab anyway. + keyPress: function(event) { + var electric = Editor.Parser.electricChars, self = this; + // Hack for Opera, and Firefox on OS X, in which stopping a + // keydown event does not prevent the associated keypress event + // from happening, so we have to cancel enter and tab again + // here. + if ((this.frozen && (!this.keyFilter || this.keyFilter(event.keyCode))) || + event.code == 13 || (event.code == 9 && this.options.tabMode != "default") || + (event.keyCode == 32 && event.shiftKey && this.options.tabMode == "default")) + event.stop(); + else if (electric && electric.indexOf(event.character) != -1) + this.parent.setTimeout(function(){self.indentAtCursor(null);}, 0); + else if ((event.character == "v" || event.character == "V") + && (event.ctrlKey || event.metaKey) && !event.altKey) // ctrl-V + this.reroutePasteEvent(); + }, + + // Mark the node at the cursor dirty when a non-safe key is + // released. + keyUp: function(event) { + this.cursorActivity(isSafeKey(event.keyCode)); + }, + + // Indent the line following a given
, or null for the first + // line. If given a
element, this must have been highlighted + // so that it has an indentation method. Returns the whitespace + // element that has been modified or created (if any). + indentLineAfter: function(start, direction) { + // whiteSpace is the whitespace span at the start of the line, + // or null if there is no such node. + var whiteSpace = start ? start.nextSibling : this.container.firstChild; + if (whiteSpace && !hasClass(whiteSpace, "whitespace")) + whiteSpace = null; + + // Sometimes the start of the line can influence the correct + // indentation, so we retrieve it. + var firstText = whiteSpace ? whiteSpace.nextSibling : (start ? start.nextSibling : this.container.firstChild); + var nextChars = (start && firstText && firstText.currentText) ? firstText.currentText : ""; + + // Ask the lexical context for the correct indentation, and + // compute how much this differs from the current indentation. + var newIndent = 0, curIndent = whiteSpace ? whiteSpace.currentText.length : 0; + if (direction != null && this.options.tabMode == "shift") + newIndent = direction ? curIndent + indentUnit : Math.max(0, curIndent - indentUnit) + else if (start) + newIndent = start.indentation(nextChars, curIndent, direction); + else if (Editor.Parser.firstIndentation) + newIndent = Editor.Parser.firstIndentation(nextChars, curIndent, direction); + var indentDiff = newIndent - curIndent; + + // If there is too much, this is just a matter of shrinking a span. + if (indentDiff < 0) { + if (newIndent == 0) { + if (firstText) select.snapshotMove(whiteSpace.firstChild, firstText.firstChild, 0); + removeElement(whiteSpace); + whiteSpace = null; + } + else { + select.snapshotMove(whiteSpace.firstChild, whiteSpace.firstChild, indentDiff, true); + whiteSpace.currentText = makeWhiteSpace(newIndent); + whiteSpace.firstChild.nodeValue = whiteSpace.currentText; + } + } + // Not enough... + else if (indentDiff > 0) { + // If there is whitespace, we grow it. + if (whiteSpace) { + whiteSpace.currentText = makeWhiteSpace(newIndent); + whiteSpace.firstChild.nodeValue = whiteSpace.currentText; + } + // Otherwise, we have to add a new whitespace node. + else { + whiteSpace = makePartSpan(makeWhiteSpace(newIndent), this.doc); + whiteSpace.className = "whitespace"; + if (start) insertAfter(whiteSpace, start); + else this.container.insertBefore(whiteSpace, this.container.firstChild); + } + if (firstText) select.snapshotMove(firstText.firstChild, whiteSpace.firstChild, curIndent, false, true); + } + if (indentDiff != 0) this.addDirtyNode(start); + return whiteSpace; + }, + + // Re-highlight the selected part of the document. + highlightAtCursor: function() { + var pos = select.selectionTopNode(this.container, true); + var to = select.selectionTopNode(this.container, false); + if (pos === false || to === false) return; + + select.markSelection(this.win); + if (this.highlight(pos, endOfLine(to, this.container), true, 20) === false) + return false; + select.selectMarked(); + return true; + }, + + // When tab is pressed with text selected, the whole selection is + // re-indented, when nothing is selected, the line with the cursor + // is re-indented. + handleTab: function(direction) { + if (this.options.tabMode == "spaces") + select.insertTabAtCursor(this.win); + else + this.reindentSelection(direction); + }, + + home: function() { + var cur = select.selectionTopNode(this.container, true), start = cur; + if (cur === false || !(!cur || cur.isPart || isBR(cur)) || !this.container.firstChild) + return false; + + while (cur && !isBR(cur)) cur = cur.previousSibling; + var next = cur ? cur.nextSibling : this.container.firstChild; + if (next && next != start && next.isPart && hasClass(next, "whitespace")) + select.focusAfterNode(next, this.container); + else + select.focusAfterNode(cur, this.container); + + select.scrollToCursor(this.container); + return true; + }, + + // Delay (or initiate) the next paren blink event. + scheduleParenBlink: function() { + if (this.parenEvent) this.parent.clearTimeout(this.parenEvent); + var self = this; + this.parenEvent = this.parent.setTimeout(function(){self.blinkParens();}, 300); + }, + + // Take the token before the cursor. If it contains a character in + // '()[]{}', search for the matching paren/brace/bracket, and + // highlight them in green for a moment, or red if no proper match + // was found. + blinkParens: function(jump) { + if (!window.select) return; + // Clear the event property. + if (this.parenEvent) this.parent.clearTimeout(this.parenEvent); + this.parenEvent = null; + + // Extract a 'paren' from a piece of text. + function paren(node) { + if (node.currentText) { + var match = node.currentText.match(/^[\s\u00a0]*([\(\)\[\]{}])[\s\u00a0]*$/); + return match && match[1]; + } + } + // Determine the direction a paren is facing. + function forward(ch) { + return /[\(\[\{]/.test(ch); + } + + var ch, self = this, cursor = select.selectionTopNode(this.container, true); + if (!cursor || !this.highlightAtCursor()) return; + cursor = select.selectionTopNode(this.container, true); + if (!(cursor && ((ch = paren(cursor)) || (cursor = cursor.nextSibling) && (ch = paren(cursor))))) + return; + // We only look for tokens with the same className. + var className = cursor.className, dir = forward(ch), match = matching[ch]; + + // Since parts of the document might not have been properly + // highlighted, and it is hard to know in advance which part we + // have to scan, we just try, and when we find dirty nodes we + // abort, parse them, and re-try. + function tryFindMatch() { + var stack = [], ch, ok = true;; + for (var runner = cursor; runner; runner = dir ? runner.nextSibling : runner.previousSibling) { + if (runner.className == className && isSpan(runner) && (ch = paren(runner))) { + if (forward(ch) == dir) + stack.push(ch); + else if (!stack.length) + ok = false; + else if (stack.pop() != matching[ch]) + ok = false; + if (!stack.length) break; + } + else if (runner.dirty || !isSpan(runner) && !isBR(runner)) { + return {node: runner, status: "dirty"}; + } + } + return {node: runner, status: runner && ok}; + } + // Temporarily give the relevant nodes a colour. + function blink(node, ok) { + node.style.fontWeight = "bold"; + node.style.color = ok ? "#8F8" : "#F88"; + self.parent.setTimeout(function() {node.style.fontWeight = ""; node.style.color = "";}, 500); + } + + while (true) { + var found = tryFindMatch(); + if (found.status == "dirty") { + this.highlight(found.node, endOfLine(found.node)); + // Needed because in some corner cases a highlight does not + // reach a node. + found.node.dirty = false; + continue; + } + else { + blink(cursor, found.status); + if (found.node) { + blink(found.node, found.status); + if (jump) select.focusAfterNode(found.node.previousSibling, this.container); + } + break; + } + } + }, + + // Adjust the amount of whitespace at the start of the line that + // the cursor is on so that it is indented properly. + indentAtCursor: function(direction) { + if (!this.container.firstChild) return; + // The line has to have up-to-date lexical information, so we + // highlight it first. + if (!this.highlightAtCursor()) return; + var cursor = select.selectionTopNode(this.container, false); + // If we couldn't determine the place of the cursor, + // there's nothing to indent. + if (cursor === false) + return; + var lineStart = startOfLine(cursor); + var whiteSpace = this.indentLineAfter(lineStart, direction); + if (cursor == lineStart && whiteSpace) + cursor = whiteSpace; + // This means the indentation has probably messed up the cursor. + if (cursor == whiteSpace) + select.focusAfterNode(cursor, this.container); + }, + + // Indent all lines whose start falls inside of the current + // selection. + indentRegion: function(start, end, direction) { + var current = (start = startOfLine(start)), before = start && startOfLine(start.previousSibling); + if (!isBR(end)) end = endOfLine(end, this.container); + + do { + var next = endOfLine(current, this.container); + if (current) this.highlight(before, next, true); + this.indentLineAfter(current, direction); + before = current; + current = next; + } while (current != end); + select.setCursorPos(this.container, {node: start, offset: 0}, {node: end, offset: 0}); + }, + + // Find the node that the cursor is in, mark it as dirty, and make + // sure a highlight pass is scheduled. + cursorActivity: function(safe) { + if (internetExplorer) { + this.container.createTextRange().execCommand("unlink"); + this.selectionSnapshot = select.selectionCoords(this.win); + } + + var activity = this.options.cursorActivity; + if (!safe || activity) { + var cursor = select.selectionTopNode(this.container, false); + if (cursor === false || !this.container.firstChild) return; + cursor = cursor || this.container.firstChild; + if (activity) activity(cursor); + if (!safe) { + this.scheduleHighlight(); + this.addDirtyNode(cursor); + } + } + }, + + reparseBuffer: function() { + forEach(this.container.childNodes, function(node) {node.dirty = true;}); + if (this.container.firstChild) + this.addDirtyNode(this.container.firstChild); + }, + + // Add a node to the set of dirty nodes, if it isn't already in + // there. + addDirtyNode: function(node) { + node = node || this.container.firstChild; + if (!node) return; + + for (var i = 0; i < this.dirty.length; i++) + if (this.dirty[i] == node) return; + + if (node.nodeType != 3) + node.dirty = true; + this.dirty.push(node); + }, + + // Cause a highlight pass to happen in options.passDelay + // milliseconds. Clear the existing timeout, if one exists. This + // way, the passes do not happen while the user is typing, and + // should as unobtrusive as possible. + scheduleHighlight: function() { + // Timeouts are routed through the parent window, because on + // some browsers designMode windows do not fire timeouts. + var self = this; + this.parent.clearTimeout(this.highlightTimeout); + this.highlightTimeout = this.parent.setTimeout(function(){self.highlightDirty();}, this.options.passDelay); + }, + + // Fetch one dirty node, and remove it from the dirty set. + getDirtyNode: function() { + while (this.dirty.length > 0) { + var found = this.dirty.pop(); + // IE8 sometimes throws an unexplainable 'invalid argument' + // exception for found.parentNode + try { + // If the node has been coloured in the meantime, or is no + // longer in the document, it should not be returned. + while (found && found.parentNode != this.container) + found = found.parentNode + if (found && (found.dirty || found.nodeType == 3)) + return found; + } catch (e) {} + } + return null; + }, + + // Pick dirty nodes, and highlight them, until options.passTime + // milliseconds have gone by. The highlight method will continue + // to next lines as long as it finds dirty nodes. It returns + // information about the place where it stopped. If there are + // dirty nodes left after this function has spent all its lines, + // it shedules another highlight to finish the job. + highlightDirty: function(force) { + // Prevent FF from raising an error when it is firing timeouts + // on a page that's no longer loaded. + if (!window.select) return; + + if (!this.options.readOnly) select.markSelection(this.win); + var start, endTime = force ? null : time() + this.options.passTime; + while ((time() < endTime || force) && (start = this.getDirtyNode())) { + var result = this.highlight(start, endTime); + if (result && result.node && result.dirty) + this.addDirtyNode(result.node); + } + if (!this.options.readOnly) select.selectMarked(); + if (start) this.scheduleHighlight(); + return this.dirty.length == 0; + }, + + // Creates a function that, when called through a timeout, will + // continuously re-parse the document. + documentScanner: function(passTime) { + var self = this, pos = null; + return function() { + // FF timeout weirdness workaround. + if (!window.select) return; + // If the current node is no longer in the document... oh + // well, we start over. + if (pos && pos.parentNode != self.container) + pos = null; + select.markSelection(self.win); + var result = self.highlight(pos, time() + passTime, true); + select.selectMarked(); + var newPos = result ? (result.node && result.node.nextSibling) : null; + pos = (pos == newPos) ? null : newPos; + self.delayScanning(); + }; + }, + + // Starts the continuous scanning process for this document after + // a given interval. + delayScanning: function() { + if (this.scanner) { + this.parent.clearTimeout(this.documentScan); + this.documentScan = this.parent.setTimeout(this.scanner, this.options.continuousScanning); + } + }, + + // The function that does the actual highlighting/colouring (with + // help from the parser and the DOM normalizer). Its interface is + // rather overcomplicated, because it is used in different + // situations: ensuring that a certain line is highlighted, or + // highlighting up to X milliseconds starting from a certain + // point. The 'from' argument gives the node at which it should + // start. If this is null, it will start at the beginning of the + // document. When a timestamp is given with the 'target' argument, + // it will stop highlighting at that time. If this argument holds + // a DOM node, it will highlight until it reaches that node. If at + // any time it comes across two 'clean' lines (no dirty nodes), it + // will stop, except when 'cleanLines' is true. maxBacktrack is + // the maximum number of lines to backtrack to find an existing + // parser instance. This is used to give up in situations where a + // highlight would take too long and freeze the browser interface. + highlight: function(from, target, cleanLines, maxBacktrack){ + var container = this.container, self = this, active = this.options.activeTokens; + var endTime = (typeof target == "number" ? target : null); + + if (!container.firstChild) + return; + // Backtrack to the first node before from that has a partial + // parse stored. + while (from && (!from.parserFromHere || from.dirty)) { + if (maxBacktrack != null && isBR(from) && (--maxBacktrack) < 0) + return false; + from = from.previousSibling; + } + // If we are at the end of the document, do nothing. + if (from && !from.nextSibling) + return; + + // Check whether a part ( node) and the corresponding token + // match. + function correctPart(token, part){ + return !part.reduced && part.currentText == token.value && part.className == token.style; + } + // Shorten the text associated with a part by chopping off + // characters from the front. Note that only the currentText + // property gets changed. For efficiency reasons, we leave the + // nodeValue alone -- we set the reduced flag to indicate that + // this part must be replaced. + function shortenPart(part, minus){ + part.currentText = part.currentText.substring(minus); + part.reduced = true; + } + // Create a part corresponding to a given token. + function tokenPart(token){ + var part = makePartSpan(token.value, self.doc); + part.className = token.style; + return part; + } + + function maybeTouch(node) { + if (node) { + var old = node.oldNextSibling; + if (lineDirty || old === undefined || node.nextSibling != old) + self.history.touch(node); + node.oldNextSibling = node.nextSibling; + } + else { + var old = self.container.oldFirstChild; + if (lineDirty || old === undefined || self.container.firstChild != old) + self.history.touch(null); + self.container.oldFirstChild = self.container.firstChild; + } + } + + // Get the token stream. If from is null, we start with a new + // parser from the start of the frame, otherwise a partial parse + // is resumed. + var traversal = traverseDOM(from ? from.nextSibling : container.firstChild), + stream = stringStream(traversal), + parsed = from ? from.parserFromHere(stream) : Editor.Parser.make(stream); + + // parts is an interface to make it possible to 'delay' fetching + // the next DOM node until we are completely done with the one + // before it. This is necessary because often the next node is + // not yet available when we want to proceed past the current + // one. + var parts = { + current: null, + // Fetch current node. + get: function(){ + if (!this.current) + this.current = traversal.nodes.shift(); + return this.current; + }, + // Advance to the next part (do not fetch it yet). + next: function(){ + this.current = null; + }, + // Remove the current part from the DOM tree, and move to the + // next. + remove: function(){ + container.removeChild(this.get()); + this.current = null; + }, + // Advance to the next part that is not empty, discarding empty + // parts. + getNonEmpty: function(){ + var part = this.get(); + // Allow empty nodes when they are alone on a line, needed + // for the FF cursor bug workaround (see select.js, + // insertNewlineAtCursor). + while (part && isSpan(part) && part.currentText == "") { + var old = part; + this.remove(); + part = this.get(); + // Adjust selection information, if any. See select.js for details. + select.snapshotMove(old.firstChild, part && (part.firstChild || part), 0); + } + return part; + } + }; + + var lineDirty = false, prevLineDirty = true, lineNodes = 0; + + // This forEach loops over the tokens from the parsed stream, and + // at the same time uses the parts object to proceed through the + // corresponding DOM nodes. + forEach(parsed, function(token){ + var part = parts.getNonEmpty(); + + if (token.value == "\n"){ + // The idea of the two streams actually staying synchronized + // is such a long shot that we explicitly check. + if (!isBR(part)) + throw "Parser out of sync. Expected BR."; + + if (part.dirty || !part.indentation) lineDirty = true; + maybeTouch(from); + from = part; + + // Every
gets a copy of the parser state and a lexical + // context assigned to it. The first is used to be able to + // later resume parsing from this point, the second is used + // for indentation. + part.parserFromHere = parsed.copy(); + part.indentation = token.indentation; + part.dirty = false; + + // If the target argument wasn't an integer, go at least + // until that node. + if (endTime == null && part == target) throw StopIteration; + + // A clean line with more than one node means we are done. + // Throwing a StopIteration is the way to break out of a + // MochiKit forEach loop. + if ((endTime != null && time() >= endTime) || (!lineDirty && !prevLineDirty && lineNodes > 1 && !cleanLines)) + throw StopIteration; + prevLineDirty = lineDirty; lineDirty = false; lineNodes = 0; + parts.next(); + } + else { + if (!isSpan(part)) + throw "Parser out of sync. Expected SPAN."; + if (part.dirty) + lineDirty = true; + lineNodes++; + + // If the part matches the token, we can leave it alone. + if (correctPart(token, part)){ + part.dirty = false; + parts.next(); + } + // Otherwise, we have to fix it. + else { + lineDirty = true; + // Insert the correct part. + var newPart = tokenPart(token); + container.insertBefore(newPart, part); + if (active) active(newPart, token, self); + var tokensize = token.value.length; + var offset = 0; + // Eat up parts until the text for this token has been + // removed, adjusting the stored selection info (see + // select.js) in the process. + while (tokensize > 0) { + part = parts.get(); + var partsize = part.currentText.length; + select.snapshotReplaceNode(part.firstChild, newPart.firstChild, tokensize, offset); + if (partsize > tokensize){ + shortenPart(part, tokensize); + tokensize = 0; + } + else { + tokensize -= partsize; + offset += partsize; + parts.remove(); + } + } + } + } + }); + maybeTouch(from); + webkitLastLineHack(this.container); + + // The function returns some status information that is used by + // hightlightDirty to determine whether and where it has to + // continue. + return {node: parts.getNonEmpty(), + dirty: lineDirty}; + } + }; + + return Editor; +})(); + +addEventHandler(window, "load", function() { + var CodeMirror = window.frameElement.CodeMirror; + CodeMirror.editor = new Editor(CodeMirror.options); + this.parent.setTimeout(method(CodeMirror, "init"), 0); +}); diff --git a/platforma/static/js/lib/codemirror/parsexml.js b/platforma/static/js/lib/codemirror/parsexml.js new file mode 100644 index 00000000..95a80993 --- /dev/null +++ b/platforma/static/js/lib/codemirror/parsexml.js @@ -0,0 +1,292 @@ +/* This file defines an XML parser, with a few kludges to make it + * useable for HTML. autoSelfClosers defines a set of tag names that + * are expected to not have a closing tag, and doNotIndent specifies + * the tags inside of which no indentation should happen (see Config + * object). These can be disabled by passing the editor an object like + * {useHTMLKludges: false} as parserConfig option. + */ + +var XMLParser = Editor.Parser = (function() { + var Kludges = { + autoSelfClosers: {"br": true, "img": true, "hr": true, "link": true, "input": true, + "meta": true, "col": true, "frame": true, "base": true, "area": true}, + doNotIndent: {"pre": true, "!cdata": true} + }; + var NoKludges = {autoSelfClosers: {}, doNotIndent: {"!cdata": true}}; + var UseKludges = Kludges; + var alignCDATA = false; + + // Simple stateful tokenizer for XML documents. Returns a + // MochiKit-style iterator, with a state property that contains a + // function encapsulating the current state. See tokenize.js. + var tokenizeXML = (function() { + function inText(source, setState) { + var ch = source.next(); + if (ch == "<") { + if (source.equals("!")) { + source.next(); + if (source.equals("[")) { + if (source.lookAhead("[CDATA[", true)) { + setState(inBlock("xml-cdata", "]]>")); + return null; + } + else { + return "xml-text"; + } + } + else if (source.lookAhead("--", true)) { + setState(inBlock("xml-comment", "-->")); + return null; + } + else { + return "xml-text"; + } + } + else if (source.equals("?")) { + source.next(); + source.nextWhileMatches(/[\w\._\-]/); + setState(inBlock("xml-processing", "?>")); + return "xml-processing"; + } + else { + if (source.equals("/")) source.next(); + setState(inTag); + return "xml-punctuation"; + } + } + else if (ch == "&") { + while (!source.endOfLine()) { + if (source.next() == ";") + break; + } + return "xml-entity"; + } + else { + source.nextWhileMatches(/[^&<\n]/); + return "xml-text"; + } + } + + function inTag(source, setState) { + var ch = source.next(); + if (ch == ">") { + setState(inText); + return "xml-punctuation"; + } + else if (/[?\/]/.test(ch) && source.equals(">")) { + source.next(); + setState(inText); + return "xml-punctuation"; + } + else if (ch == "=") { + return "xml-punctuation"; + } + else if (/[\'\"]/.test(ch)) { + setState(inAttribute(ch)); + return null; + } + else { + source.nextWhileMatches(/[^\s\u00a0=<>\"\'\/?]/); + return "xml-name"; + } + } + + function inAttribute(quote) { + return function(source, setState) { + while (!source.endOfLine()) { + if (source.next() == quote) { + setState(inTag); + break; + } + } + return "xml-attribute"; + }; + } + + function inBlock(style, terminator) { + return function(source, setState) { + while (!source.endOfLine()) { + if (source.lookAhead(terminator, true)) { + setState(inText); + break; + } + source.next(); + } + return style; + }; + } + + return function(source, startState) { + return tokenizer(source, startState || inText); + }; + })(); + + // The parser. The structure of this function largely follows that of + // parseJavaScript in parsejavascript.js (there is actually a bit more + // shared code than I'd like), but it is quite a bit simpler. + function parseXML(source) { + var tokens = tokenizeXML(source); + var cc = [base]; + var tokenNr = 0, indented = 0; + var currentTag = null, context = null; + var consume, marked; + + function push(fs) { + for (var i = fs.length - 1; i >= 0; i--) + cc.push(fs[i]); + } + function cont() { + push(arguments); + consume = true; + } + function pass() { + push(arguments); + consume = false; + } + + function mark(style) { + marked = style; + } + function expect(text) { + return function(style, content) { + if (content == text) cont(); + else mark("xml-error") || cont(arguments.callee); + }; + } + + function pushContext(tagname, startOfLine) { + var noIndent = UseKludges.doNotIndent.hasOwnProperty(tagname) || (context && context.noIndent); + context = {prev: context, name: tagname, indent: indented, startOfLine: startOfLine, noIndent: noIndent}; + } + function popContext() { + context = context.prev; + } + function computeIndentation(baseContext) { + return function(nextChars, current) { + var context = baseContext; + if (context && context.noIndent) + return current; + if (alignCDATA && /")); + else if (style == "xml-cdata") { + if (!context || context.name != "!cdata") pushContext("!cdata"); + if (/\]\]>$/.test(content)) popContext(); + cont(); + } + else if (harmlessTokens.hasOwnProperty(style)) cont(); + else mark("xml-error") || cont(); + } + function tagname(style, content) { + if (style == "xml-name") { + currentTag = content.toLowerCase(); + mark("xml-tagname"); + cont(); + } + else { + currentTag = null; + pass(); + } + } + function closetagname(style, content) { + if (style == "xml-name" && context && content.toLowerCase() == context.name) { + popContext(); + mark("xml-tagname"); + } + else { + mark("xml-error"); + } + cont(); + } + function endtag(startOfLine) { + return function(style, content) { + if (content == "/>" || (content == ">" && UseKludges.autoSelfClosers.hasOwnProperty(currentTag))) cont(); + else if (content == ">") pushContext(currentTag, startOfLine) || cont(); + else mark("xml-error") || cont(arguments.callee); + }; + } + function attributes(style) { + if (style == "xml-name") mark("xml-attname") || cont(attribute, attributes); + else pass(); + } + function attribute(style, content) { + if (content == "=") cont(value); + else if (content == ">" || content == "/>") pass(endtag); + else pass(); + } + function value(style) { + if (style == "xml-attribute") cont(value); + else pass(); + } + + return { + indentation: function() {return indented;}, + + next: function(){ + var token = tokens.next(); + if (token.style == "whitespace" && tokenNr == 0) + indented = token.value.length; + else + tokenNr++; + if (token.content == "\n") { + indented = tokenNr = 0; + token.indentation = computeIndentation(context); + } + + if (token.style == "whitespace" || token.type == "xml-comment") + return token; + + while(true){ + consume = marked = false; + cc.pop()(token.style, token.content); + if (consume){ + if (marked) + token.style = marked; + return token; + } + } + }, + + copy: function(){ + var _cc = cc.concat([]), _tokenState = tokens.state, _context = context; + var parser = this; + + return function(input){ + cc = _cc.concat([]); + tokenNr = indented = 0; + context = _context; + tokens = tokenizeXML(input, _tokenState); + return parser; + }; + } + }; + } + + return { + make: parseXML, + electricChars: "/", + configure: function(config) { + if (config.useHTMLKludges != null) + UseKludges = config.useHTMLKludges ? Kludges : NoKludges; + if (config.alignCDATA) + alignCDATA = config.alignCDATA; + } + }; +})(); diff --git a/platforma/static/js/lib/codemirror/select.js b/platforma/static/js/lib/codemirror/select.js new file mode 100644 index 00000000..7746240e --- /dev/null +++ b/platforma/static/js/lib/codemirror/select.js @@ -0,0 +1,624 @@ +/* Functionality for finding, storing, and restoring selections + * + * This does not provide a generic API, just the minimal functionality + * required by the CodeMirror system. + */ + +// Namespace object. +var select = {}; + +(function() { + select.ie_selection = document.selection && document.selection.createRangeCollection; + + // Find the 'top-level' (defined as 'a direct child of the node + // passed as the top argument') node that the given node is + // contained in. Return null if the given node is not inside the top + // node. + function topLevelNodeAt(node, top) { + while (node && node.parentNode != top) + node = node.parentNode; + return node; + } + + // Find the top-level node that contains the node before this one. + function topLevelNodeBefore(node, top) { + while (!node.previousSibling && node.parentNode != top) + node = node.parentNode; + return topLevelNodeAt(node.previousSibling, top); + } + + var fourSpaces = "\u00a0\u00a0\u00a0\u00a0"; + + select.scrollToNode = function(element) { + if (!element) return; + var doc = element.ownerDocument, body = doc.body, + win = (doc.defaultView || doc.parentWindow), + html = doc.documentElement, + atEnd = !element.nextSibling || !element.nextSibling.nextSibling + || !element.nextSibling.nextSibling.nextSibling; + // In Opera (and recent Webkit versions), BR elements *always* + // have a scrollTop property of zero. + var compensateHack = 0; + while (element && !element.offsetTop) { + compensateHack++; + element = element.previousSibling; + } + // atEnd is another kludge for these browsers -- if the cursor is + // at the end of the document, and the node doesn't have an + // offset, just scroll to the end. + if (compensateHack == 0) atEnd = false; + + var y = compensateHack * (element ? element.offsetHeight : 0), x = 0, pos = element; + while (pos && pos.offsetParent) { + y += pos.offsetTop; + // Don't count X offset for
nodes + if (!isBR(pos)) + x += pos.offsetLeft; + pos = pos.offsetParent; + } + + var scroll_x = body.scrollLeft || html.scrollLeft || 0, + scroll_y = body.scrollTop || html.scrollTop || 0, + screen_x = x - scroll_x, screen_y = y - scroll_y, scroll = false; + + if (screen_x < 0 || screen_x > (win.innerWidth || html.clientWidth || 0)) { + scroll_x = x; + scroll = true; + } + if (screen_y < 0 || atEnd || screen_y > (win.innerHeight || html.clientHeight || 0) - 50) { + scroll_y = atEnd ? 1e10 : y; + scroll = true; + } + if (scroll) win.scrollTo(scroll_x, scroll_y); + }; + + select.scrollToCursor = function(container) { + select.scrollToNode(select.selectionTopNode(container, true) || container.firstChild); + }; + + // Used to prevent restoring a selection when we do not need to. + var currentSelection = null; + + select.snapshotChanged = function() { + if (currentSelection) currentSelection.changed = true; + }; + + // This is called by the code in editor.js whenever it is replacing + // a text node. The function sees whether the given oldNode is part + // of the current selection, and updates this selection if it is. + // Because nodes are often only partially replaced, the length of + // the part that gets replaced has to be taken into account -- the + // selection might stay in the oldNode if the newNode is smaller + // than the selection's offset. The offset argument is needed in + // case the selection does move to the new object, and the given + // length is not the whole length of the new node (part of it might + // have been used to replace another node). + select.snapshotReplaceNode = function(from, to, length, offset) { + if (!currentSelection) return; + + function replace(point) { + if (from == point.node) { + currentSelection.changed = true; + if (length && point.offset > length) { + point.offset -= length; + } + else { + point.node = to; + point.offset += (offset || 0); + } + } + } + replace(currentSelection.start); + replace(currentSelection.end); + }; + + select.snapshotMove = function(from, to, distance, relative, ifAtStart) { + if (!currentSelection) return; + + function move(point) { + if (from == point.node && (!ifAtStart || point.offset == 0)) { + currentSelection.changed = true; + point.node = to; + if (relative) point.offset = Math.max(0, point.offset + distance); + else point.offset = distance; + } + } + move(currentSelection.start); + move(currentSelection.end); + }; + + // Most functions are defined in two ways, one for the IE selection + // model, one for the W3C one. + if (select.ie_selection) { + function selectionNode(win, start) { + var range = win.document.selection.createRange(); + range.collapse(start); + + function nodeAfter(node) { + var found = null; + while (!found && node) { + found = node.nextSibling; + node = node.parentNode; + } + return nodeAtStartOf(found); + } + + function nodeAtStartOf(node) { + while (node && node.firstChild) node = node.firstChild; + return {node: node, offset: 0}; + } + + var containing = range.parentElement(); + if (!isAncestor(win.document.body, containing)) return null; + if (!containing.firstChild) return nodeAtStartOf(containing); + + var working = range.duplicate(); + working.moveToElementText(containing); + working.collapse(true); + for (var cur = containing.firstChild; cur; cur = cur.nextSibling) { + if (cur.nodeType == 3) { + var size = cur.nodeValue.length; + working.move("character", size); + } + else { + working.moveToElementText(cur); + working.collapse(false); + } + + var dir = range.compareEndPoints("StartToStart", working); + if (dir == 0) return nodeAfter(cur); + if (dir == 1) continue; + if (cur.nodeType != 3) return nodeAtStartOf(cur); + + working.setEndPoint("StartToEnd", range); + return {node: cur, offset: size - working.text.length}; + } + return nodeAfter(containing); + } + + select.markSelection = function(win) { + currentSelection = null; + var sel = win.document.selection; + if (!sel) return; + var start = selectionNode(win, true), + end = selectionNode(win, false); + if (!start || !end) return; + currentSelection = {start: start, end: end, window: win, changed: false}; + }; + + select.selectMarked = function() { + if (!currentSelection || !currentSelection.changed) return; + var win = currentSelection.window, doc = win.document; + + function makeRange(point) { + var range = doc.body.createTextRange(), + node = point.node; + if (!node) { + range.moveToElementText(currentSelection.window.document.body); + range.collapse(false); + } + else if (node.nodeType == 3) { + range.moveToElementText(node.parentNode); + var offset = point.offset; + while (node.previousSibling) { + node = node.previousSibling; + offset += (node.innerText || "").length; + } + range.move("character", offset); + } + else { + range.moveToElementText(node); + range.collapse(true); + } + return range; + } + + var start = makeRange(currentSelection.start), end = makeRange(currentSelection.end); + start.setEndPoint("StartToEnd", end); + start.select(); + }; + + // Get the top-level node that one end of the cursor is inside or + // after. Note that this returns false for 'no cursor', and null + // for 'start of document'. + select.selectionTopNode = function(container, start) { + var selection = container.ownerDocument.selection; + if (!selection) return false; + + var range = selection.createRange(), range2 = range.duplicate(); + range.collapse(start); + var around = range.parentElement(); + if (around && isAncestor(container, around)) { + // Only use this node if the selection is not at its start. + range2.moveToElementText(around); + if (range.compareEndPoints("StartToStart", range2) == 1) + return topLevelNodeAt(around, container); + } + + // Move the start of a range to the start of a node, + // compensating for the fact that you can't call + // moveToElementText with text nodes. + function moveToNodeStart(range, node) { + if (node.nodeType == 3) { + var count = 0, cur = node.previousSibling; + while (cur && cur.nodeType == 3) { + count += cur.nodeValue.length; + cur = cur.previousSibling; + } + if (cur) { + try{range.moveToElementText(cur);} + catch(e){return false;} + range.collapse(false); + } + else range.moveToElementText(node.parentNode); + if (count) range.move("character", count); + } + else { + try{range.moveToElementText(node);} + catch(e){return false;} + } + return true; + } + + // Do a binary search through the container object, comparing + // the start of each node to the selection + var start = 0, end = container.childNodes.length - 1; + while (start < end) { + var middle = Math.ceil((end + start) / 2), node = container.childNodes[middle]; + if (!node) return false; // Don't ask. IE6 manages this sometimes. + if (!moveToNodeStart(range2, node)) return false; + if (range.compareEndPoints("StartToStart", range2) == 1) + start = middle; + else + end = middle - 1; + } + return container.childNodes[start] || null; + }; + + // Place the cursor after this.start. This is only useful when + // manually moving the cursor instead of restoring it to its old + // position. + select.focusAfterNode = function(node, container) { + var range = container.ownerDocument.body.createTextRange(); + range.moveToElementText(node || container); + range.collapse(!node); + range.select(); + }; + + select.somethingSelected = function(win) { + var sel = win.document.selection; + return sel && (sel.createRange().text != ""); + }; + + function insertAtCursor(window, html) { + var selection = window.document.selection; + if (selection) { + var range = selection.createRange(); + range.pasteHTML(html); + range.collapse(false); + range.select(); + } + } + + // Used to normalize the effect of the enter key, since browsers + // do widely different things when pressing enter in designMode. + select.insertNewlineAtCursor = function(window) { + insertAtCursor(window, "
"); + }; + + select.insertTabAtCursor = function(window) { + insertAtCursor(window, fourSpaces); + }; + + // Get the BR node at the start of the line on which the cursor + // currently is, and the offset into the line. Returns null as + // node if cursor is on first line. + select.cursorPos = function(container, start) { + var selection = container.ownerDocument.selection; + if (!selection) return null; + + var topNode = select.selectionTopNode(container, start); + while (topNode && !isBR(topNode)) + topNode = topNode.previousSibling; + + var range = selection.createRange(), range2 = range.duplicate(); + range.collapse(start); + if (topNode) { + range2.moveToElementText(topNode); + range2.collapse(false); + } + else { + // When nothing is selected, we can get all kinds of funky errors here. + try { range2.moveToElementText(container); } + catch (e) { return null; } + range2.collapse(true); + } + range.setEndPoint("StartToStart", range2); + + return {node: topNode, offset: range.text.length}; + }; + + select.setCursorPos = function(container, from, to) { + function rangeAt(pos) { + var range = container.ownerDocument.body.createTextRange(); + if (!pos.node) { + range.moveToElementText(container); + range.collapse(true); + } + else { + range.moveToElementText(pos.node); + range.collapse(false); + } + range.move("character", pos.offset); + return range; + } + + var range = rangeAt(from); + if (to && to != from) + range.setEndPoint("EndToEnd", rangeAt(to)); + range.select(); + } + + // Some hacks for storing and re-storing the selection when the editor loses and regains focus. + select.selectionCoords = function (win) { + var selection = win.document.selection; + if (!selection) return null; + var start = selection.createRange(), end = start.duplicate(); + start.collapse(true); + end.collapse(false); + + var body = win.document.body; + return {start: {x: start.boundingLeft + body.scrollLeft - 1, + y: start.boundingTop + body.scrollTop}, + end: {x: end.boundingLeft + body.scrollLeft - 1, + y: end.boundingTop + body.scrollTop}}; + }; + + // Restore a stored selection. + select.selectCoords = function(win, coords) { + if (!coords) return; + + var range1 = win.document.body.createTextRange(), range2 = range1.duplicate(); + // This can fail for various hard-to-handle reasons. + try { + range1.moveToPoint(coords.start.x, coords.start.y); + range2.moveToPoint(coords.end.x, coords.end.y); + range1.setEndPoint("EndToStart", range2); + range1.select(); + } catch(e) {} + }; + } + // W3C model + else { + // Store start and end nodes, and offsets within these, and refer + // back to the selection object from those nodes, so that this + // object can be updated when the nodes are replaced before the + // selection is restored. + select.markSelection = function (win) { + var selection = win.getSelection(); + if (!selection || selection.rangeCount == 0) + return (currentSelection = null); + var range = selection.getRangeAt(0); + + currentSelection = { + start: {node: range.startContainer, offset: range.startOffset}, + end: {node: range.endContainer, offset: range.endOffset}, + window: win, + changed: false + }; + + // We want the nodes right at the cursor, not one of their + // ancestors with a suitable offset. This goes down the DOM tree + // until a 'leaf' is reached (or is it *up* the DOM tree?). + function normalize(point){ + while (point.node.nodeType != 3 && !isBR(point.node)) { + var newNode = point.node.childNodes[point.offset] || point.node.nextSibling; + point.offset = 0; + while (!newNode && point.node.parentNode) { + point.node = point.node.parentNode; + newNode = point.node.nextSibling; + } + point.node = newNode; + if (!newNode) + break; + } + } + + normalize(currentSelection.start); + normalize(currentSelection.end); + }; + + select.selectMarked = function () { + var cs = currentSelection; + if (!(cs && (cs.changed || (webkit && cs.start.node == cs.end.node)))) return; + var win = cs.window, range = win.document.createRange(); + + function setPoint(point, which) { + if (point.node) { + // Some magic to generalize the setting of the start and end + // of a range. + if (point.offset == 0) + range["set" + which + "Before"](point.node); + else + range["set" + which](point.node, point.offset); + } + else { + range.setStartAfter(win.document.body.lastChild || win.document.body); + } + } + + setPoint(cs.end, "End"); + setPoint(cs.start, "Start"); + selectRange(range, win); + }; + + // Helper for selecting a range object. + function selectRange(range, window) { + var selection = window.getSelection(); + selection.removeAllRanges(); + selection.addRange(range); + }; + function selectionRange(window) { + var selection = window.getSelection(); + if (!selection || selection.rangeCount == 0) + return false; + else + return selection.getRangeAt(0); + } + + // Finding the top-level node at the cursor in the W3C is, as you + // can see, quite an involved process. + select.selectionTopNode = function(container, start) { + var range = selectionRange(container.ownerDocument.defaultView); + if (!range) return false; + + var node = start ? range.startContainer : range.endContainer; + var offset = start ? range.startOffset : range.endOffset; + // Work around (yet another) bug in Opera's selection model. + if (window.opera && !start && range.endContainer == container && range.endOffset == range.startOffset + 1 && + container.childNodes[range.startOffset] && isBR(container.childNodes[range.startOffset])) + offset--; + + // For text nodes, we look at the node itself if the cursor is + // inside, or at the node before it if the cursor is at the + // start. + if (node.nodeType == 3){ + if (offset > 0) + return topLevelNodeAt(node, container); + else + return topLevelNodeBefore(node, container); + } + // Occasionally, browsers will return the HTML node as + // selection. If the offset is 0, we take the start of the frame + // ('after null'), otherwise, we take the last node. + else if (node.nodeName.toUpperCase() == "HTML") { + return (offset == 1 ? null : container.lastChild); + } + // If the given node is our 'container', we just look up the + // correct node by using the offset. + else if (node == container) { + return (offset == 0) ? null : node.childNodes[offset - 1]; + } + // In any other case, we have a regular node. If the cursor is + // at the end of the node, we use the node itself, if it is at + // the start, we use the node before it, and in any other + // case, we look up the child before the cursor and use that. + else { + if (offset == node.childNodes.length) + return topLevelNodeAt(node, container); + else if (offset == 0) + return topLevelNodeBefore(node, container); + else + return topLevelNodeAt(node.childNodes[offset - 1], container); + } + }; + + select.focusAfterNode = function(node, container) { + var win = container.ownerDocument.defaultView, + range = win.document.createRange(); + range.setStartBefore(container.firstChild || container); + // In Opera, setting the end of a range at the end of a line + // (before a BR) will cause the cursor to appear on the next + // line, so we set the end inside of the start node when + // possible. + if (node && !node.firstChild) + range.setEndAfter(node); + else if (node) + range.setEnd(node, node.childNodes.length); + else + range.setEndBefore(container.firstChild || container); + range.collapse(false); + selectRange(range, win); + }; + + select.somethingSelected = function(win) { + var range = selectionRange(win); + return range && !range.collapsed; + }; + + function insertNodeAtCursor(window, node) { + var range = selectionRange(window); + if (!range) return; + + range.deleteContents(); + range.insertNode(node); + webkitLastLineHack(window.document.body); + range = window.document.createRange(); + range.selectNode(node); + range.collapse(false); + selectRange(range, window); + } + + select.insertNewlineAtCursor = function(window) { + insertNodeAtCursor(window, window.document.createElement("BR")); + }; + + select.insertTabAtCursor = function(window) { + insertNodeAtCursor(window, window.document.createTextNode(fourSpaces)); + }; + + select.cursorPos = function(container, start) { + var range = selectionRange(window); + if (!range) return; + + var topNode = select.selectionTopNode(container, start); + while (topNode && !isBR(topNode)) + topNode = topNode.previousSibling; + + range = range.cloneRange(); + range.collapse(start); + if (topNode) + range.setStartAfter(topNode); + else + range.setStartBefore(container); + return {node: topNode, offset: range.toString().length}; + }; + + select.setCursorPos = function(container, from, to) { + var win = container.ownerDocument.defaultView, + range = win.document.createRange(); + + function setPoint(node, offset, side) { + if (!node) + node = container.firstChild; + else + node = node.nextSibling; + + if (!node) + return; + + if (offset == 0) { + range["set" + side + "Before"](node); + return true; + } + + var backlog = [] + function decompose(node) { + if (node.nodeType == 3) + backlog.push(node); + else + forEach(node.childNodes, decompose); + } + while (true) { + while (node && !backlog.length) { + decompose(node); + node = node.nextSibling; + } + var cur = backlog.shift(); + if (!cur) return false; + + var length = cur.nodeValue.length; + if (length >= offset) { + range["set" + side](cur, offset); + return true; + } + offset -= length; + } + } + + to = to || from; + if (setPoint(to.node, to.offset, "End") && setPoint(from.node, from.offset, "Start")) + selectRange(range, win); + }; + } +})(); diff --git a/platforma/static/js/lib/codemirror/stringstream.js b/platforma/static/js/lib/codemirror/stringstream.js new file mode 100644 index 00000000..8c1c0422 --- /dev/null +++ b/platforma/static/js/lib/codemirror/stringstream.js @@ -0,0 +1,140 @@ +/* String streams are the things fed to parsers (which can feed them + * to a tokenizer if they want). They provide peek and next methods + * for looking at the current character (next 'consumes' this + * character, peek does not), and a get method for retrieving all the + * text that was consumed since the last time get was called. + * + * An easy mistake to make is to let a StopIteration exception finish + * the token stream while there are still characters pending in the + * string stream (hitting the end of the buffer while parsing a + * token). To make it easier to detect such errors, the stringstreams + * throw an exception when this happens. + */ + +// Make a stringstream stream out of an iterator that returns strings. +// This is applied to the result of traverseDOM (see codemirror.js), +// and the resulting stream is fed to the parser. +window.stringStream = function(source){ + // String that's currently being iterated over. + var current = ""; + // Position in that string. + var pos = 0; + // Accumulator for strings that have been iterated over but not + // get()-ed yet. + var accum = ""; + // Make sure there are more characters ready, or throw + // StopIteration. + function ensureChars() { + while (pos == current.length) { + accum += current; + current = ""; // In case source.next() throws + pos = 0; + try {current = source.next();} + catch (e) { + if (e != StopIteration) throw e; + else return false; + } + } + return true; + } + + return { + // Return the next character in the stream. + peek: function() { + if (!ensureChars()) return null; + return current.charAt(pos); + }, + // Get the next character, throw StopIteration if at end, check + // for unused content. + next: function() { + if (!ensureChars()) { + if (accum.length > 0) + throw "End of stringstream reached without emptying buffer ('" + accum + "')."; + else + throw StopIteration; + } + return current.charAt(pos++); + }, + // Return the characters iterated over since the last call to + // .get(). + get: function() { + var temp = accum; + accum = ""; + if (pos > 0){ + temp += current.slice(0, pos); + current = current.slice(pos); + pos = 0; + } + return temp; + }, + // Push a string back into the stream. + push: function(str) { + current = current.slice(0, pos) + str + current.slice(pos); + }, + lookAhead: function(str, consume, skipSpaces, caseInsensitive) { + function cased(str) {return caseInsensitive ? str.toLowerCase() : str;} + str = cased(str); + var found = false; + + var _accum = accum, _pos = pos; + if (skipSpaces) this.nextWhileMatches(/[\s\u00a0]/); + + while (true) { + var end = pos + str.length, left = current.length - pos; + if (end <= current.length) { + found = str == cased(current.slice(pos, end)); + pos = end; + break; + } + else if (str.slice(0, left) == cased(current.slice(pos))) { + accum += current; current = ""; + try {current = source.next();} + catch (e) {break;} + pos = 0; + str = str.slice(left); + } + else { + break; + } + } + + if (!(found && consume)) { + current = accum.slice(_accum.length) + current; + pos = _pos; + accum = _accum; + } + + return found; + }, + + // Utils built on top of the above + more: function() { + return this.peek() !== null; + }, + applies: function(test) { + var next = this.peek(); + return (next !== null && test(next)); + }, + nextWhile: function(test) { + var next; + while ((next = this.peek()) !== null && test(next)) + this.next(); + }, + matches: function(re) { + var next = this.peek(); + return (next !== null && re.test(next)); + }, + nextWhileMatches: function(re) { + var next; + while ((next = this.peek()) !== null && re.test(next)) + this.next(); + }, + equals: function(ch) { + return ch === this.peek(); + }, + endOfLine: function() { + var next = this.peek(); + return next == null || next == "\n"; + } + }; +}; diff --git a/platforma/static/js/lib/codemirror/tokenize.js b/platforma/static/js/lib/codemirror/tokenize.js new file mode 100644 index 00000000..071970ce --- /dev/null +++ b/platforma/static/js/lib/codemirror/tokenize.js @@ -0,0 +1,57 @@ +// A framework for simple tokenizers. Takes care of newlines and +// white-space, and of getting the text from the source stream into +// the token object. A state is a function of two arguments -- a +// string stream and a setState function. The second can be used to +// change the tokenizer's state, and can be ignored for stateless +// tokenizers. This function should advance the stream over a token +// and return a string or object containing information about the next +// token, or null to pass and have the (new) state be called to finish +// the token. When a string is given, it is wrapped in a {style, type} +// object. In the resulting object, the characters consumed are stored +// under the content property. Any whitespace following them is also +// automatically consumed, and added to the value property. (Thus, +// content is the actual meaningful part of the token, while value +// contains all the text it spans.) + +function tokenizer(source, state) { + // Newlines are always a separate token. + function isWhiteSpace(ch) { + // The messy regexp is because IE's regexp matcher is of the + // opinion that non-breaking spaces are no whitespace. + return ch != "\n" && /^[\s\u00a0]*$/.test(ch); + } + + var tokenizer = { + state: state, + + take: function(type) { + if (typeof(type) == "string") + type = {style: type, type: type}; + + type.content = (type.content || "") + source.get(); + if (!/\n$/.test(type.content)) + source.nextWhile(isWhiteSpace); + type.value = type.content + source.get(); + return type; + }, + + next: function () { + if (!source.more()) throw StopIteration; + + var type; + if (source.equals("\n")) { + source.next(); + return this.take("whitespace"); + } + + if (source.applies(isWhiteSpace)) + type = "whitespace"; + else + while (!type) + type = this.state(source, function(s) {tokenizer.state = s;}); + + return this.take(type); + } + }; + return tokenizer; +} diff --git a/platforma/static/js/lib/codemirror/undo.js b/platforma/static/js/lib/codemirror/undo.js new file mode 100644 index 00000000..97daf593 --- /dev/null +++ b/platforma/static/js/lib/codemirror/undo.js @@ -0,0 +1,403 @@ +/** + * Storage and control for undo information within a CodeMirror + * editor. 'Why on earth is such a complicated mess required for + * that?', I hear you ask. The goal, in implementing this, was to make + * the complexity of storing and reverting undo information depend + * only on the size of the edited or restored content, not on the size + * of the whole document. This makes it necessary to use a kind of + * 'diff' system, which, when applied to a DOM tree, causes some + * complexity and hackery. + * + * In short, the editor 'touches' BR elements as it parses them, and + * the History stores these. When nothing is touched in commitDelay + * milliseconds, the changes are committed: It goes over all touched + * nodes, throws out the ones that did not change since last commit or + * are no longer in the document, and assembles the rest into zero or + * more 'chains' -- arrays of adjacent lines. Links back to these + * chains are added to the BR nodes, while the chain that previously + * spanned these nodes is added to the undo history. Undoing a change + * means taking such a chain off the undo history, restoring its + * content (text is saved per line) and linking it back into the + * document. + */ + +// A history object needs to know about the DOM container holding the +// document, the maximum amount of undo levels it should store, the +// delay (of no input) after which it commits a set of changes, and, +// unfortunately, the 'parent' window -- a window that is not in +// designMode, and on which setTimeout works in every browser. +function History(container, maxDepth, commitDelay, editor, onChange) { + this.container = container; + this.maxDepth = maxDepth; this.commitDelay = commitDelay; + this.editor = editor; this.parent = editor.parent; + this.onChange = onChange; + // This line object represents the initial, empty editor. + var initial = {text: "", from: null, to: null}; + // As the borders between lines are represented by BR elements, the + // start of the first line and the end of the last one are + // represented by null. Since you can not store any properties + // (links to line objects) in null, these properties are used in + // those cases. + this.first = initial; this.last = initial; + // Similarly, a 'historyTouched' property is added to the BR in + // front of lines that have already been touched, and 'firstTouched' + // is used for the first line. + this.firstTouched = false; + // History is the set of committed changes, touched is the set of + // nodes touched since the last commit. + this.history = []; this.redoHistory = []; this.touched = []; +} + +History.prototype = { + // Schedule a commit (if no other touches come in for commitDelay + // milliseconds). + scheduleCommit: function() { + var self = this; + this.parent.clearTimeout(this.commitTimeout); + this.commitTimeout = this.parent.setTimeout(function(){self.tryCommit();}, this.commitDelay); + }, + + // Mark a node as touched. Null is a valid argument. + touch: function(node) { + this.setTouched(node); + this.scheduleCommit(); + }, + + // Undo the last change. + undo: function() { + // Make sure pending changes have been committed. + this.commit(); + + if (this.history.length) { + // Take the top diff from the history, apply it, and store its + // shadow in the redo history. + var item = this.history.pop(); + this.redoHistory.push(this.updateTo(item, "applyChain")); + if (this.onChange) this.onChange(); + return this.chainNode(item); + } + }, + + // Redo the last undone change. + redo: function() { + this.commit(); + if (this.redoHistory.length) { + // The inverse of undo, basically. + var item = this.redoHistory.pop(); + this.addUndoLevel(this.updateTo(item, "applyChain")); + if (this.onChange) this.onChange(); + return this.chainNode(item); + } + }, + + clear: function() { + this.history = []; + this.redoHistory = []; + }, + + // Ask for the size of the un/redo histories. + historySize: function() { + return {undo: this.history.length, redo: this.redoHistory.length}; + }, + + // Push a changeset into the document. + push: function(from, to, lines) { + var chain = []; + for (var i = 0; i < lines.length; i++) { + var end = (i == lines.length - 1) ? to : this.container.ownerDocument.createElement("BR"); + chain.push({from: from, to: end, text: cleanText(lines[i])}); + from = end; + } + this.pushChains([chain], from == null && to == null); + }, + + pushChains: function(chains, doNotHighlight) { + this.commit(doNotHighlight); + this.addUndoLevel(this.updateTo(chains, "applyChain")); + this.redoHistory = []; + }, + + // Retrieve a DOM node from a chain (for scrolling to it after undo/redo). + chainNode: function(chains) { + for (var i = 0; i < chains.length; i++) { + var start = chains[i][0], node = start && (start.from || start.to); + if (node) return node; + } + }, + + // Clear the undo history, make the current document the start + // position. + reset: function() { + this.history = []; this.redoHistory = []; + }, + + textAfter: function(br) { + return this.after(br).text; + }, + + nodeAfter: function(br) { + return this.after(br).to; + }, + + nodeBefore: function(br) { + return this.before(br).from; + }, + + // Commit unless there are pending dirty nodes. + tryCommit: function() { + if (!window.History) return; // Stop when frame has been unloaded + if (this.editor.highlightDirty()) this.commit(true); + else this.scheduleCommit(); + }, + + // Check whether the touched nodes hold any changes, if so, commit + // them. + commit: function(doNotHighlight) { + this.parent.clearTimeout(this.commitTimeout); + // Make sure there are no pending dirty nodes. + if (!doNotHighlight) this.editor.highlightDirty(true); + // Build set of chains. + var chains = this.touchedChains(), self = this; + + if (chains.length) { + this.addUndoLevel(this.updateTo(chains, "linkChain")); + this.redoHistory = []; + if (this.onChange) this.onChange(); + } + }, + + // [ end of public interface ] + + // Update the document with a given set of chains, return its + // shadow. updateFunc should be "applyChain" or "linkChain". In the + // second case, the chains are taken to correspond the the current + // document, and only the state of the line data is updated. In the + // first case, the content of the chains is also pushed iinto the + // document. + updateTo: function(chains, updateFunc) { + var shadows = [], dirty = []; + for (var i = 0; i < chains.length; i++) { + shadows.push(this.shadowChain(chains[i])); + dirty.push(this[updateFunc](chains[i])); + } + if (updateFunc == "applyChain") + this.notifyDirty(dirty); + return shadows; + }, + + // Notify the editor that some nodes have changed. + notifyDirty: function(nodes) { + forEach(nodes, method(this.editor, "addDirtyNode")) + this.editor.scheduleHighlight(); + }, + + // Link a chain into the DOM nodes (or the first/last links for null + // nodes). + linkChain: function(chain) { + for (var i = 0; i < chain.length; i++) { + var line = chain[i]; + if (line.from) line.from.historyAfter = line; + else this.first = line; + if (line.to) line.to.historyBefore = line; + else this.last = line; + } + }, + + // Get the line object after/before a given node. + after: function(node) { + return node ? node.historyAfter : this.first; + }, + before: function(node) { + return node ? node.historyBefore : this.last; + }, + + // Mark a node as touched if it has not already been marked. + setTouched: function(node) { + if (node) { + if (!node.historyTouched) { + this.touched.push(node); + node.historyTouched = true; + } + } + else { + this.firstTouched = true; + } + }, + + // Store a new set of undo info, throw away info if there is more of + // it than allowed. + addUndoLevel: function(diffs) { + this.history.push(diffs); + if (this.history.length > this.maxDepth) + this.history.shift(); + }, + + // Build chains from a set of touched nodes. + touchedChains: function() { + var self = this; + + // The temp system is a crummy hack to speed up determining + // whether a (currently touched) node has a line object associated + // with it. nullTemp is used to store the object for the first + // line, other nodes get it stored in their historyTemp property. + var nullTemp = null; + function temp(node) {return node ? node.historyTemp : nullTemp;} + function setTemp(node, line) { + if (node) node.historyTemp = line; + else nullTemp = line; + } + + function buildLine(node) { + var text = []; + for (var cur = node ? node.nextSibling : self.container.firstChild; + cur && !isBR(cur); cur = cur.nextSibling) + if (cur.currentText) text.push(cur.currentText); + return {from: node, to: cur, text: cleanText(text.join(""))}; + } + + // Filter out unchanged lines and nodes that are no longer in the + // document. Build up line objects for remaining nodes. + var lines = []; + if (self.firstTouched) self.touched.push(null); + forEach(self.touched, function(node) { + if (node && node.parentNode != self.container) return; + + if (node) node.historyTouched = false; + else self.firstTouched = false; + + var line = buildLine(node), shadow = self.after(node); + if (!shadow || shadow.text != line.text || shadow.to != line.to) { + lines.push(line); + setTemp(node, line); + } + }); + + // Get the BR element after/before the given node. + function nextBR(node, dir) { + var link = dir + "Sibling", search = node[link]; + while (search && !isBR(search)) + search = search[link]; + return search; + } + + // Assemble line objects into chains by scanning the DOM tree + // around them. + var chains = []; self.touched = []; + forEach(lines, function(line) { + // Note that this makes the loop skip line objects that have + // been pulled into chains by lines before them. + if (!temp(line.from)) return; + + var chain = [], curNode = line.from, safe = true; + // Put any line objects (referred to by temp info) before this + // one on the front of the array. + while (true) { + var curLine = temp(curNode); + if (!curLine) { + if (safe) break; + else curLine = buildLine(curNode); + } + chain.unshift(curLine); + setTemp(curNode, null); + if (!curNode) break; + safe = self.after(curNode); + curNode = nextBR(curNode, "previous"); + } + curNode = line.to; safe = self.before(line.from); + // Add lines after this one at end of array. + while (true) { + if (!curNode) break; + var curLine = temp(curNode); + if (!curLine) { + if (safe) break; + else curLine = buildLine(curNode); + } + chain.push(curLine); + setTemp(curNode, null); + safe = self.before(curNode); + curNode = nextBR(curNode, "next"); + } + chains.push(chain); + }); + + return chains; + }, + + // Find the 'shadow' of a given chain by following the links in the + // DOM nodes at its start and end. + shadowChain: function(chain) { + var shadows = [], next = this.after(chain[0].from), end = chain[chain.length - 1].to; + while (true) { + shadows.push(next); + var nextNode = next.to; + if (!nextNode || nextNode == end) + break; + else + next = nextNode.historyAfter || this.before(end); + // (The this.before(end) is a hack -- FF sometimes removes + // properties from BR nodes, in which case the best we can hope + // for is to not break.) + } + return shadows; + }, + + // Update the DOM tree to contain the lines specified in a given + // chain, link this chain into the DOM nodes. + applyChain: function(chain) { + // Some attempt is made to prevent the cursor from jumping + // randomly when an undo or redo happens. It still behaves a bit + // strange sometimes. + var cursor = select.cursorPos(this.container, false), self = this; + + // Remove all nodes in the DOM tree between from and to (null for + // start/end of container). + function removeRange(from, to) { + var pos = from ? from.nextSibling : self.container.firstChild; + while (pos != to) { + var temp = pos.nextSibling; + removeElement(pos); + pos = temp; + } + } + + var start = chain[0].from, end = chain[chain.length - 1].to; + // Clear the space where this change has to be made. + removeRange(start, end); + + // Insert the content specified by the chain into the DOM tree. + for (var i = 0; i < chain.length; i++) { + var line = chain[i]; + // The start and end of the space are already correct, but BR + // tags inside it have to be put back. + if (i > 0) + self.container.insertBefore(line.from, end); + + // Add the text. + var node = makePartSpan(fixSpaces(line.text), this.container.ownerDocument); + self.container.insertBefore(node, end); + // See if the cursor was on this line. Put it back, adjusting + // for changed line length, if it was. + if (cursor && cursor.node == line.from) { + var cursordiff = 0; + var prev = this.after(line.from); + if (prev && i == chain.length - 1) { + // Only adjust if the cursor is after the unchanged part of + // the line. + for (var match = 0; match < cursor.offset && + line.text.charAt(match) == prev.text.charAt(match); match++); + if (cursor.offset > match) + cursordiff = line.text.length - prev.text.length; + } + select.setCursorPos(this.container, {node: line.from, offset: Math.max(0, cursor.offset + cursordiff)}); + } + // Cursor was in removed line, this is last new line. + else if (cursor && (i == chain.length - 1) && cursor.node && cursor.node.parentNode != this.container) { + select.setCursorPos(this.container, {node: line.from, offset: line.text.length}); + } + } + + // Anchor the chain in the DOM tree. + this.linkChain(chain); + return start; + } +}; diff --git a/platforma/static/js/lib/codemirror/util.js b/platforma/static/js/lib/codemirror/util.js new file mode 100644 index 00000000..0cd91d4e --- /dev/null +++ b/platforma/static/js/lib/codemirror/util.js @@ -0,0 +1,134 @@ +/* A few useful utility functions. */ + +var internetExplorer = document.selection && window.ActiveXObject && /MSIE/.test(navigator.userAgent); +var webkit = /AppleWebKit/.test(navigator.userAgent); +var safari = /Apple Computers, Inc/.test(navigator.vendor); + +// Capture a method on an object. +function method(obj, name) { + return function() {obj[name].apply(obj, arguments);}; +} + +// The value used to signal the end of a sequence in iterators. +var StopIteration = {toString: function() {return "StopIteration"}}; + +// Apply a function to each element in a sequence. +function forEach(iter, f) { + if (iter.next) { + try {while (true) f(iter.next());} + catch (e) {if (e != StopIteration) throw e;} + } + else { + for (var i = 0; i < iter.length; i++) + f(iter[i]); + } +} + +// Map a function over a sequence, producing an array of results. +function map(iter, f) { + var accum = []; + forEach(iter, function(val) {accum.push(f(val));}); + return accum; +} + +// Create a predicate function that tests a string againsts a given +// regular expression. No longer used but might be used by 3rd party +// parsers. +function matcher(regexp){ + return function(value){return regexp.test(value);}; +} + +// Test whether a DOM node has a certain CSS class. Much faster than +// the MochiKit equivalent, for some reason. +function hasClass(element, className){ + var classes = element.className; + return classes && new RegExp("(^| )" + className + "($| )").test(classes); +} + +// Insert a DOM node after another node. +function insertAfter(newNode, oldNode) { + var parent = oldNode.parentNode; + parent.insertBefore(newNode, oldNode.nextSibling); + return newNode; +} + +function removeElement(node) { + if (node.parentNode) + node.parentNode.removeChild(node); +} + +function clearElement(node) { + while (node.firstChild) + node.removeChild(node.firstChild); +} + +// Check whether a node is contained in another one. +function isAncestor(node, child) { + while (child = child.parentNode) { + if (node == child) + return true; + } + return false; +} + +// The non-breaking space character. +var nbsp = "\u00a0"; +var matching = {"{": "}", "[": "]", "(": ")", + "}": "{", "]": "[", ")": "("}; + +// Standardize a few unportable event properties. +function normalizeEvent(event) { + if (!event.stopPropagation) { + event.stopPropagation = function() {this.cancelBubble = true;}; + event.preventDefault = function() {this.returnValue = false;}; + } + if (!event.stop) { + event.stop = function() { + this.stopPropagation(); + this.preventDefault(); + }; + } + + if (event.type == "keypress") { + event.code = (event.charCode == null) ? event.keyCode : event.charCode; + event.character = String.fromCharCode(event.code); + } + return event; +} + +// Portably register event handlers. +function addEventHandler(node, type, handler, removeFunc) { + function wrapHandler(event) { + handler(normalizeEvent(event || window.event)); + } + if (typeof node.addEventListener == "function") { + node.addEventListener(type, wrapHandler, false); + if (removeFunc) return function() {node.removeEventListener(type, wrapHandler, false);}; + } + else { + node.attachEvent("on" + type, wrapHandler); + if (removeFunc) return function() {node.detachEvent("on" + type, wrapHandler);}; + } +} + +function nodeText(node) { + return node.textContent || node.innerText || node.nodeValue || ""; +} + +function nodeTop(node) { + var top = 0; + while (node.offsetParent) { + top += node.offsetTop; + node = node.offsetParent; + } + return top; +} + +function isBR(node) { + var nn = node.nodeName; + return nn == "BR" || nn == "br"; +} +function isSpan(node) { + var nn = node.nodeName; + return nn == "SPAN" || nn == "span"; +} diff --git a/platforma/static/js/lib/jquery.cookie.js b/platforma/static/js/lib/jquery.cookie.js new file mode 100644 index 00000000..6df1faca --- /dev/null +++ b/platforma/static/js/lib/jquery.cookie.js @@ -0,0 +1,96 @@ +/** + * Cookie plugin + * + * Copyright (c) 2006 Klaus Hartl (stilbuero.de) + * Dual licensed under the MIT and GPL licenses: + * http://www.opensource.org/licenses/mit-license.php + * http://www.gnu.org/licenses/gpl.html + * + */ + +/** + * Create a cookie with the given name and value and other optional parameters. + * + * @example $.cookie('the_cookie', 'the_value'); + * @desc Set the value of a cookie. + * @example $.cookie('the_cookie', 'the_value', { expires: 7, path: '/', domain: 'jquery.com', secure: true }); + * @desc Create a cookie with all available options. + * @example $.cookie('the_cookie', 'the_value'); + * @desc Create a session cookie. + * @example $.cookie('the_cookie', null); + * @desc Delete a cookie by passing null as value. Keep in mind that you have to use the same path and domain + * used when the cookie was set. + * + * @param String name The name of the cookie. + * @param String value The value of the cookie. + * @param Object options An object literal containing key/value pairs to provide optional cookie attributes. + * @option Number|Date expires Either an integer specifying the expiration date from now on in days or a Date object. + * If a negative value is specified (e.g. a date in the past), the cookie will be deleted. + * If set to null or omitted, the cookie will be a session cookie and will not be retained + * when the the browser exits. + * @option String path The value of the path atribute of the cookie (default: path of page that created the cookie). + * @option String domain The value of the domain attribute of the cookie (default: domain of page that created the cookie). + * @option Boolean secure If true, the secure attribute of the cookie will be set and the cookie transmission will + * require a secure protocol (like HTTPS). + * @type undefined + * + * @name $.cookie + * @cat Plugins/Cookie + * @author Klaus Hartl/klaus.hartl@stilbuero.de + */ + +/** + * Get the value of a cookie with the given name. + * + * @example $.cookie('the_cookie'); + * @desc Get the value of a cookie. + * + * @param String name The name of the cookie. + * @return The value of the cookie. + * @type String + * + * @name $.cookie + * @cat Plugins/Cookie + * @author Klaus Hartl/klaus.hartl@stilbuero.de + */ +jQuery.cookie = function(name, value, options) { + if (typeof value != 'undefined') { // name and value given, set cookie + options = options || {}; + if (value === null) { + value = ''; + options.expires = -1; + } + var expires = ''; + if (options.expires && (typeof options.expires == 'number' || options.expires.toUTCString)) { + var date; + if (typeof options.expires == 'number') { + date = new Date(); + date.setTime(date.getTime() + (options.expires * 24 * 60 * 60 * 1000)); + } else { + date = options.expires; + } + expires = '; expires=' + date.toUTCString(); // use expires attribute, max-age is not supported by IE + } + // CAUTION: Needed to parenthesize options.path and options.domain + // in the following expressions, otherwise they evaluate to undefined + // in the packed version for some reason... + var path = options.path ? '; path=' + (options.path) : ''; + var domain = options.domain ? '; domain=' + (options.domain) : ''; + var secure = options.secure ? '; secure' : ''; + document.cookie = [name, '=', encodeURIComponent(value), expires, path, domain, secure].join(''); + } else { // only name given, get cookie + var cookieValue = null; + if (document.cookie && document.cookie != '') { + var cookies = document.cookie.split(';'); + for (var i = 0; i < cookies.length; i++) { + var cookie = jQuery.trim(cookies[i]); + // Does this cookie string begin with the name we want? + if (cookie.substring(0, name.length + 1) == (name + '=')) { + cookieValue = decodeURIComponent(cookie.substring(name.length + 1)); + break; + } + } + } + return cookieValue; + } +}; \ No newline at end of file diff --git a/platforma/static/js/lib/jquery.hpanel.js b/platforma/static/js/lib/jquery.hpanel.js new file mode 100644 index 00000000..1ad0d17f --- /dev/null +++ b/platforma/static/js/lib/jquery.hpanel.js @@ -0,0 +1,94 @@ +(function($){ + + /* behaviour */ + $.hpanel = { + settings: {}, + current_data: {}, + resize_start: function(event, mydata) { + $(document).bind('mousemove', mydata, $.hpanel.resize_changed). + bind('mouseup', mydata, $.hpanel.resize_stop); + + $('.panel-overlay', mydata.root).css('display', 'block'); + return false; + }, + resize_changed: function(event) { + var old_width = parseInt(event.data.overlay.css('width')); + var delta = event.pageX + event.data.hotspot_x - old_width; + event.data.overlay.css({'width': old_width + delta}); + + if(event.data.overlay.next) { + var left = parseInt(event.data.overlay.next.css('left')); + event.data.overlay.next.css('left', left+delta); + } + + return false; + }, + resize_stop: function(event) { + $(document).unbind('mousemove', $.hpanel.resize_changed).unbind('mouseup', $.hpanel.resize_stop); + // $('.panel-content', event.data.root).css('display', 'block'); + var overlays = $('.panel-content-overlay', event.data.root); + $('.panel-content-overlay', event.data.root).each(function(i) { + if( $(this).data('panel').hasClass('last-panel') ) + $(this).data('panel').css({ + 'left': $(this).css('left'), 'right': $(this).css('right')}); + else + $(this).data('panel').css({ + 'left': $(this).css('left'), 'width': $(this).css('width')}); + }); + $('.panel-overlay', event.data.root).css('display', 'none'); + $(event.data.root).trigger('stopResize'); + } + }; + + $.fn.makeHorizPanel = function(options) + { + var root = $(this) + + /* create an overlay */ + var overlay_root = $("
"); + root.append(overlay_root); + + var prev = null; + + $('*.panel-wrap', root).each( function() + { + var panel = $(this); + var handle = $('.panel-slider', panel); + var overlay = $("
 
"); + overlay_root.append(overlay); + overlay.data('panel', panel); + overlay.data('next', null); + + if (prev) prev.next = overlay; + + if( panel.hasClass('last-panel') ) + { + overlay.css({'left': panel.css('left'), 'right': panel.css('right')}); + } + else { + overlay.css({'left': panel.css('left'), 'width': panel.css('width')}); + $.log('Has handle: ' + panel.attr('id')); + overlay.append(handle.clone()); + /* attach the trigger */ + handle.mousedown(function(event) { + var touch_data = { + root: root, overlay: overlay, + hotspot_x: event.pageX - handle.position().left + }; + + $(this).trigger('hpanel:panel-resize-start', touch_data); + return false; + }); + $('.panel-content', panel).css('right', + (handle.outerWidth() || 10) + 'px'); + $('.panel-content-overlay', panel).css('right', + (handle.outerWidth() || 10) + 'px'); + }; + + prev = overlay; + }); + + root.bind('hpanel:panel-resize-start', $.hpanel.resize_start); + }; +})(jQuery); + diff --git a/platforma/static/js/lib/jquery.js b/platforma/static/js/lib/jquery.js new file mode 100644 index 00000000..92635743 --- /dev/null +++ b/platforma/static/js/lib/jquery.js @@ -0,0 +1,4376 @@ +/*! + * jQuery JavaScript Library v1.3.2 + * http://jquery.com/ + * + * Copyright (c) 2009 John Resig + * Dual licensed under the MIT and GPL licenses. + * http://docs.jquery.com/License + * + * Date: 2009-02-19 17:34:21 -0500 (Thu, 19 Feb 2009) + * Revision: 6246 + */ +(function(){ + +var + // Will speed up references to window, and allows munging its name. + window = this, + // Will speed up references to undefined, and allows munging its name. + undefined, + // Map over jQuery in case of overwrite + _jQuery = window.jQuery, + // Map over the $ in case of overwrite + _$ = window.$, + + jQuery = window.jQuery = window.$ = function( selector, context ) { + // The jQuery object is actually just the init constructor 'enhanced' + return new jQuery.fn.init( selector, context ); + }, + + // A simple way to check for HTML strings or ID strings + // (both of which we optimize for) + quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/, + // Is it a simple selector + isSimple = /^.[^:#\[\.,]*$/; + +jQuery.fn = jQuery.prototype = { + init: function( selector, context ) { + // Make sure that a selection was provided + selector = selector || document; + + // Handle $(DOMElement) + if ( selector.nodeType ) { + this[0] = selector; + this.length = 1; + this.context = selector; + return this; + } + // Handle HTML strings + if ( typeof selector === "string" ) { + // Are we dealing with HTML string or an ID? + var match = quickExpr.exec( selector ); + + // Verify a match, and that no context was specified for #id + if ( match && (match[1] || !context) ) { + + // HANDLE: $(html) -> $(array) + if ( match[1] ) + selector = jQuery.clean( [ match[1] ], context ); + + // HANDLE: $("#id") + else { + var elem = document.getElementById( match[3] ); + + // Handle the case where IE and Opera return items + // by name instead of ID + if ( elem && elem.id != match[3] ) + return jQuery().find( selector ); + + // Otherwise, we inject the element directly into the jQuery object + var ret = jQuery( elem || [] ); + ret.context = document; + ret.selector = selector; + return ret; + } + + // HANDLE: $(expr, [context]) + // (which is just equivalent to: $(content).find(expr) + } else + return jQuery( context ).find( selector ); + + // HANDLE: $(function) + // Shortcut for document ready + } else if ( jQuery.isFunction( selector ) ) + return jQuery( document ).ready( selector ); + + // Make sure that old selector state is passed along + if ( selector.selector && selector.context ) { + this.selector = selector.selector; + this.context = selector.context; + } + + return this.setArray(jQuery.isArray( selector ) ? + selector : + jQuery.makeArray(selector)); + }, + + // Start with an empty selector + selector: "", + + // The current version of jQuery being used + jquery: "1.3.2", + + // The number of elements contained in the matched element set + size: function() { + return this.length; + }, + + // Get the Nth element in the matched element set OR + // Get the whole matched element set as a clean array + get: function( num ) { + return num === undefined ? + + // Return a 'clean' array + Array.prototype.slice.call( this ) : + + // Return just the object + this[ num ]; + }, + + // Take an array of elements and push it onto the stack + // (returning the new matched element set) + pushStack: function( elems, name, selector ) { + // Build a new jQuery matched element set + var ret = jQuery( elems ); + + // Add the old object onto the stack (as a reference) + ret.prevObject = this; + + ret.context = this.context; + + if ( name === "find" ) + ret.selector = this.selector + (this.selector ? " " : "") + selector; + else if ( name ) + ret.selector = this.selector + "." + name + "(" + selector + ")"; + + // Return the newly-formed element set + return ret; + }, + + // Force the current matched set of elements to become + // the specified array of elements (destroying the stack in the process) + // You should use pushStack() in order to do this, but maintain the stack + setArray: function( elems ) { + // Resetting the length to 0, then using the native Array push + // is a super-fast way to populate an object with array-like properties + this.length = 0; + Array.prototype.push.apply( this, elems ); + + return this; + }, + + // Execute a callback for every element in the matched set. + // (You can seed the arguments with an array of args, but this is + // only used internally.) + each: function( callback, args ) { + return jQuery.each( this, callback, args ); + }, + + // Determine the position of an element within + // the matched set of elements + index: function( elem ) { + // Locate the position of the desired element + return jQuery.inArray( + // If it receives a jQuery object, the first element is used + elem && elem.jquery ? elem[0] : elem + , this ); + }, + + attr: function( name, value, type ) { + var options = name; + + // Look for the case where we're accessing a style value + if ( typeof name === "string" ) + if ( value === undefined ) + return this[0] && jQuery[ type || "attr" ]( this[0], name ); + + else { + options = {}; + options[ name ] = value; + } + + // Check to see if we're setting style values + return this.each(function(i){ + // Set all the styles + for ( name in options ) + jQuery.attr( + type ? + this.style : + this, + name, jQuery.prop( this, options[ name ], type, i, name ) + ); + }); + }, + + css: function( key, value ) { + // ignore negative width and height values + if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 ) + value = undefined; + return this.attr( key, value, "curCSS" ); + }, + + text: function( text ) { + if ( typeof text !== "object" && text != null ) + return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) ); + + var ret = ""; + + jQuery.each( text || this, function(){ + jQuery.each( this.childNodes, function(){ + if ( this.nodeType != 8 ) + ret += this.nodeType != 1 ? + this.nodeValue : + jQuery.fn.text( [ this ] ); + }); + }); + + return ret; + }, + + wrapAll: function( html ) { + if ( this[0] ) { + // The elements to wrap the target around + var wrap = jQuery( html, this[0].ownerDocument ).clone(); + + if ( this[0].parentNode ) + wrap.insertBefore( this[0] ); + + wrap.map(function(){ + var elem = this; + + while ( elem.firstChild ) + elem = elem.firstChild; + + return elem; + }).append(this); + } + + return this; + }, + + wrapInner: function( html ) { + return this.each(function(){ + jQuery( this ).contents().wrapAll( html ); + }); + }, + + wrap: function( html ) { + return this.each(function(){ + jQuery( this ).wrapAll( html ); + }); + }, + + append: function() { + return this.domManip(arguments, true, function(elem){ + if (this.nodeType == 1) + this.appendChild( elem ); + }); + }, + + prepend: function() { + return this.domManip(arguments, true, function(elem){ + if (this.nodeType == 1) + this.insertBefore( elem, this.firstChild ); + }); + }, + + before: function() { + return this.domManip(arguments, false, function(elem){ + this.parentNode.insertBefore( elem, this ); + }); + }, + + after: function() { + return this.domManip(arguments, false, function(elem){ + this.parentNode.insertBefore( elem, this.nextSibling ); + }); + }, + + end: function() { + return this.prevObject || jQuery( [] ); + }, + + // For internal use only. + // Behaves like an Array's method, not like a jQuery method. + push: [].push, + sort: [].sort, + splice: [].splice, + + find: function( selector ) { + if ( this.length === 1 ) { + var ret = this.pushStack( [], "find", selector ); + ret.length = 0; + jQuery.find( selector, this[0], ret ); + return ret; + } else { + return this.pushStack( jQuery.unique(jQuery.map(this, function(elem){ + return jQuery.find( selector, elem ); + })), "find", selector ); + } + }, + + clone: function( events ) { + // Do the clone + var ret = this.map(function(){ + if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) { + // IE copies events bound via attachEvent when + // using cloneNode. Calling detachEvent on the + // clone will also remove the events from the orignal + // In order to get around this, we use innerHTML. + // Unfortunately, this means some modifications to + // attributes in IE that are actually only stored + // as properties will not be copied (such as the + // the name attribute on an input). + var html = this.outerHTML; + if ( !html ) { + var div = this.ownerDocument.createElement("div"); + div.appendChild( this.cloneNode(true) ); + html = div.innerHTML; + } + + return jQuery.clean([html.replace(/ jQuery\d+="(?:\d+|null)"/g, "").replace(/^\s*/, "")])[0]; + } else + return this.cloneNode(true); + }); + + // Copy the events from the original to the clone + if ( events === true ) { + var orig = this.find("*").andSelf(), i = 0; + + ret.find("*").andSelf().each(function(){ + if ( this.nodeName !== orig[i].nodeName ) + return; + + var events = jQuery.data( orig[i], "events" ); + + for ( var type in events ) { + for ( var handler in events[ type ] ) { + jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data ); + } + } + + i++; + }); + } + + // Return the cloned set + return ret; + }, + + filter: function( selector ) { + return this.pushStack( + jQuery.isFunction( selector ) && + jQuery.grep(this, function(elem, i){ + return selector.call( elem, i ); + }) || + + jQuery.multiFilter( selector, jQuery.grep(this, function(elem){ + return elem.nodeType === 1; + }) ), "filter", selector ); + }, + + closest: function( selector ) { + var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(selector) : null, + closer = 0; + + return this.map(function(){ + var cur = this; + while ( cur && cur.ownerDocument ) { + if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selector) ) { + jQuery.data(cur, "closest", closer); + return cur; + } + cur = cur.parentNode; + closer++; + } + }); + }, + + not: function( selector ) { + if ( typeof selector === "string" ) + // test special case where just one selector is passed in + if ( isSimple.test( selector ) ) + return this.pushStack( jQuery.multiFilter( selector, this, true ), "not", selector ); + else + selector = jQuery.multiFilter( selector, this ); + + var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType; + return this.filter(function() { + return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector; + }); + }, + + add: function( selector ) { + return this.pushStack( jQuery.unique( jQuery.merge( + this.get(), + typeof selector === "string" ? + jQuery( selector ) : + jQuery.makeArray( selector ) + ))); + }, + + is: function( selector ) { + return !!selector && jQuery.multiFilter( selector, this ).length > 0; + }, + + hasClass: function( selector ) { + return !!selector && this.is( "." + selector ); + }, + + val: function( value ) { + if ( value === undefined ) { + var elem = this[0]; + + if ( elem ) { + if( jQuery.nodeName( elem, 'option' ) ) + return (elem.attributes.value || {}).specified ? elem.value : elem.text; + + // We need to handle select boxes special + if ( jQuery.nodeName( elem, "select" ) ) { + var index = elem.selectedIndex, + values = [], + options = elem.options, + one = elem.type == "select-one"; + + // Nothing was selected + if ( index < 0 ) + return null; + + // Loop through all the selected options + for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) { + var option = options[ i ]; + + if ( option.selected ) { + // Get the specifc value for the option + value = jQuery(option).val(); + + // We don't need an array for one selects + if ( one ) + return value; + + // Multi-Selects return an array + values.push( value ); + } + } + + return values; + } + + // Everything else, we just grab the value + return (elem.value || "").replace(/\r/g, ""); + + } + + return undefined; + } + + if ( typeof value === "number" ) + value += ''; + + return this.each(function(){ + if ( this.nodeType != 1 ) + return; + + if ( jQuery.isArray(value) && /radio|checkbox/.test( this.type ) ) + this.checked = (jQuery.inArray(this.value, value) >= 0 || + jQuery.inArray(this.name, value) >= 0); + + else if ( jQuery.nodeName( this, "select" ) ) { + var values = jQuery.makeArray(value); + + jQuery( "option", this ).each(function(){ + this.selected = (jQuery.inArray( this.value, values ) >= 0 || + jQuery.inArray( this.text, values ) >= 0); + }); + + if ( !values.length ) + this.selectedIndex = -1; + + } else + this.value = value; + }); + }, + + html: function( value ) { + return value === undefined ? + (this[0] ? + this[0].innerHTML.replace(/ jQuery\d+="(?:\d+|null)"/g, "") : + null) : + this.empty().append( value ); + }, + + replaceWith: function( value ) { + return this.after( value ).remove(); + }, + + eq: function( i ) { + return this.slice( i, +i + 1 ); + }, + + slice: function() { + return this.pushStack( Array.prototype.slice.apply( this, arguments ), + "slice", Array.prototype.slice.call(arguments).join(",") ); + }, + + map: function( callback ) { + return this.pushStack( jQuery.map(this, function(elem, i){ + return callback.call( elem, i, elem ); + })); + }, + + andSelf: function() { + return this.add( this.prevObject ); + }, + + domManip: function( args, table, callback ) { + if ( this[0] ) { + var fragment = (this[0].ownerDocument || this[0]).createDocumentFragment(), + scripts = jQuery.clean( args, (this[0].ownerDocument || this[0]), fragment ), + first = fragment.firstChild; + + if ( first ) + for ( var i = 0, l = this.length; i < l; i++ ) + callback.call( root(this[i], first), this.length > 1 || i > 0 ? + fragment.cloneNode(true) : fragment ); + + if ( scripts ) + jQuery.each( scripts, evalScript ); + } + + return this; + + function root( elem, cur ) { + return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ? + (elem.getElementsByTagName("tbody")[0] || + elem.appendChild(elem.ownerDocument.createElement("tbody"))) : + elem; + } + } +}; + +// Give the init function the jQuery prototype for later instantiation +jQuery.fn.init.prototype = jQuery.fn; + +function evalScript( i, elem ) { + if ( elem.src ) + jQuery.ajax({ + url: elem.src, + async: false, + dataType: "script" + }); + + else + jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" ); + + if ( elem.parentNode ) + elem.parentNode.removeChild( elem ); +} + +function now(){ + return +new Date; +} + +jQuery.extend = jQuery.fn.extend = function() { + // copy reference to target object + var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options; + + // Handle a deep copy situation + if ( typeof target === "boolean" ) { + deep = target; + target = arguments[1] || {}; + // skip the boolean and the target + i = 2; + } + + // Handle case when target is a string or something (possible in deep copy) + if ( typeof target !== "object" && !jQuery.isFunction(target) ) + target = {}; + + // extend jQuery itself if only one argument is passed + if ( length == i ) { + target = this; + --i; + } + + for ( ; i < length; i++ ) + // Only deal with non-null/undefined values + if ( (options = arguments[ i ]) != null ) + // Extend the base object + for ( var name in options ) { + var src = target[ name ], copy = options[ name ]; + + // Prevent never-ending loop + if ( target === copy ) + continue; + + // Recurse if we're merging object values + if ( deep && copy && typeof copy === "object" && !copy.nodeType ) + target[ name ] = jQuery.extend( deep, + // Never move original objects, clone them + src || ( copy.length != null ? [ ] : { } ) + , copy ); + + // Don't bring in undefined values + else if ( copy !== undefined ) + target[ name ] = copy; + + } + + // Return the modified object + return target; +}; + +// exclude the following css properties to add px +var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i, + // cache defaultView + defaultView = document.defaultView || {}, + toString = Object.prototype.toString; + +jQuery.extend({ + noConflict: function( deep ) { + window.$ = _$; + + if ( deep ) + window.jQuery = _jQuery; + + return jQuery; + }, + + // See test/unit/core.js for details concerning isFunction. + // Since version 1.3, DOM methods and functions like alert + // aren't supported. They return false on IE (#2968). + isFunction: function( obj ) { + return toString.call(obj) === "[object Function]"; + }, + + isArray: function( obj ) { + return toString.call(obj) === "[object Array]"; + }, + + // check if an element is in a (or is an) XML document + isXMLDoc: function( elem ) { + return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" || + !!elem.ownerDocument && jQuery.isXMLDoc( elem.ownerDocument ); + }, + + // Evalulates a script in a global context + globalEval: function( data ) { + if ( data && /\S/.test(data) ) { + // Inspired by code by Andrea Giammarchi + // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html + var head = document.getElementsByTagName("head")[0] || document.documentElement, + script = document.createElement("script"); + + script.type = "text/javascript"; + if ( jQuery.support.scriptEval ) + script.appendChild( document.createTextNode( data ) ); + else + script.text = data; + + // Use insertBefore instead of appendChild to circumvent an IE6 bug. + // This arises when a base node is used (#2709). + head.insertBefore( script, head.firstChild ); + head.removeChild( script ); + } + }, + + nodeName: function( elem, name ) { + return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase(); + }, + + // args is for internal usage only + each: function( object, callback, args ) { + var name, i = 0, length = object.length; + + if ( args ) { + if ( length === undefined ) { + for ( name in object ) + if ( callback.apply( object[ name ], args ) === false ) + break; + } else + for ( ; i < length; ) + if ( callback.apply( object[ i++ ], args ) === false ) + break; + + // A special, fast, case for the most common use of each + } else { + if ( length === undefined ) { + for ( name in object ) + if ( callback.call( object[ name ], name, object[ name ] ) === false ) + break; + } else + for ( var value = object[0]; + i < length && callback.call( value, i, value ) !== false; value = object[++i] ){} + } + + return object; + }, + + prop: function( elem, value, type, i, name ) { + // Handle executable functions + if ( jQuery.isFunction( value ) ) + value = value.call( elem, i ); + + // Handle passing in a number to a CSS property + return typeof value === "number" && type == "curCSS" && !exclude.test( name ) ? + value + "px" : + value; + }, + + className: { + // internal only, use addClass("class") + add: function( elem, classNames ) { + jQuery.each((classNames || "").split(/\s+/), function(i, className){ + if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) ) + elem.className += (elem.className ? " " : "") + className; + }); + }, + + // internal only, use removeClass("class") + remove: function( elem, classNames ) { + if (elem.nodeType == 1) + elem.className = classNames !== undefined ? + jQuery.grep(elem.className.split(/\s+/), function(className){ + return !jQuery.className.has( classNames, className ); + }).join(" ") : + ""; + }, + + // internal only, use hasClass("class") + has: function( elem, className ) { + return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1; + } + }, + + // A method for quickly swapping in/out CSS properties to get correct calculations + swap: function( elem, options, callback ) { + var old = {}; + // Remember the old values, and insert the new ones + for ( var name in options ) { + old[ name ] = elem.style[ name ]; + elem.style[ name ] = options[ name ]; + } + + callback.call( elem ); + + // Revert the old values + for ( var name in options ) + elem.style[ name ] = old[ name ]; + }, + + css: function( elem, name, force, extra ) { + if ( name == "width" || name == "height" ) { + var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ]; + + function getWH() { + val = name == "width" ? elem.offsetWidth : elem.offsetHeight; + + if ( extra === "border" ) + return; + + jQuery.each( which, function() { + if ( !extra ) + val -= parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0; + if ( extra === "margin" ) + val += parseFloat(jQuery.curCSS( elem, "margin" + this, true)) || 0; + else + val -= parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0; + }); + } + + if ( elem.offsetWidth !== 0 ) + getWH(); + else + jQuery.swap( elem, props, getWH ); + + return Math.max(0, Math.round(val)); + } + + return jQuery.curCSS( elem, name, force ); + }, + + curCSS: function( elem, name, force ) { + var ret, style = elem.style; + + // We need to handle opacity special in IE + if ( name == "opacity" && !jQuery.support.opacity ) { + ret = jQuery.attr( style, "opacity" ); + + return ret == "" ? + "1" : + ret; + } + + // Make sure we're using the right name for getting the float value + if ( name.match( /float/i ) ) + name = styleFloat; + + if ( !force && style && style[ name ] ) + ret = style[ name ]; + + else if ( defaultView.getComputedStyle ) { + + // Only "float" is needed here + if ( name.match( /float/i ) ) + name = "float"; + + name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase(); + + var computedStyle = defaultView.getComputedStyle( elem, null ); + + if ( computedStyle ) + ret = computedStyle.getPropertyValue( name ); + + // We should always get a number back from opacity + if ( name == "opacity" && ret == "" ) + ret = "1"; + + } else if ( elem.currentStyle ) { + var camelCase = name.replace(/\-(\w)/g, function(all, letter){ + return letter.toUpperCase(); + }); + + ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ]; + + // From the awesome hack by Dean Edwards + // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291 + + // If we're not dealing with a regular pixel number + // but a number that has a weird ending, we need to convert it to pixels + if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) { + // Remember the original values + var left = style.left, rsLeft = elem.runtimeStyle.left; + + // Put in the new values to get a computed value out + elem.runtimeStyle.left = elem.currentStyle.left; + style.left = ret || 0; + ret = style.pixelLeft + "px"; + + // Revert the changed values + style.left = left; + elem.runtimeStyle.left = rsLeft; + } + } + + return ret; + }, + + clean: function( elems, context, fragment ) { + context = context || document; + + // !context.createElement fails in IE with an error but returns typeof 'object' + if ( typeof context.createElement === "undefined" ) + context = context.ownerDocument || context[0] && context[0].ownerDocument || document; + + // If a single string is passed in and it's a single tag + // just do a createElement and skip the rest + if ( !fragment && elems.length === 1 && typeof elems[0] === "string" ) { + var match = /^<(\w+)\s*\/?>$/.exec(elems[0]); + if ( match ) + return [ context.createElement( match[1] ) ]; + } + + var ret = [], scripts = [], div = context.createElement("div"); + + jQuery.each(elems, function(i, elem){ + if ( typeof elem === "number" ) + elem += ''; + + if ( !elem ) + return; + + // Convert html string into DOM nodes + if ( typeof elem === "string" ) { + // Fix "XHTML"-style tags in all browsers + elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){ + return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ? + all : + front + ">"; + }); + + // Trim whitespace, otherwise indexOf won't work as expected + var tags = elem.replace(/^\s+/, "").substring(0, 10).toLowerCase(); + + var wrap = + // option or optgroup + !tags.indexOf("", "" ] || + + !tags.indexOf("", "" ] || + + tags.match(/^<(thead|tbody|tfoot|colg|cap)/) && + [ 1, "", "
" ] || + + !tags.indexOf("", "" ] || + + // matched above + (!tags.indexOf("", "" ] || + + !tags.indexOf("", "" ] || + + // IE can't serialize and + + {% block extrahead %} + {% endblock %} + + +
+ +
{% block maincontent %} {% endblock %}
+ + {% block extrabody %}{% endblock %} +
+ + diff --git a/platforma/templates/explorer/edit_dc.html b/platforma/templates/explorer/edit_dc.html new file mode 100644 index 00000000..1ad0c22d --- /dev/null +++ b/platforma/templates/explorer/edit_dc.html @@ -0,0 +1,4 @@ +
+{{ form.as_p }} + +
diff --git a/platforma/templates/explorer/edit_text.html b/platforma/templates/explorer/edit_text.html new file mode 100644 index 00000000..1ad0c22d --- /dev/null +++ b/platforma/templates/explorer/edit_text.html @@ -0,0 +1,4 @@ +
+{{ form.as_p }} + +
diff --git a/platforma/templates/explorer/editor.html b/platforma/templates/explorer/editor.html new file mode 100644 index 00000000..3c775d4e --- /dev/null +++ b/platforma/templates/explorer/editor.html @@ -0,0 +1,195 @@ +{% extends "base.html" %} + +{% block extrahead %} + + + + + + + + {# Libraries #} + + + + {# Scriptlets #} + + + {# App and views #} + + + + + + + + + + + + + + + {# JavaScript templates #} + + + + + + + + + + + +{% endblock extrahead %} + +{% block breadcrumbs %}Platforma Redakcyjna > {{ fileid }}{% endblock breadcrumbs %} + +{% block header-toolbar %} + Historia + + + + +{% endblock %} + +{% block maincontent %} + + + +
+
+
+
+ + + + +{% endblock maincontent %} + +{% block extrabody %} +
+{% endblock %} \ No newline at end of file diff --git a/platforma/templates/explorer/file_html.html b/platforma/templates/explorer/file_html.html new file mode 100644 index 00000000..ab8e40b4 --- /dev/null +++ b/platforma/templates/explorer/file_html.html @@ -0,0 +1,42 @@ +{% extends "base.html" %} + +{% block extrahead %} + + +{% endblock extrahead %} + +{% block breadcrumbs %}Platforma Redakcyjna ❯ plik {{ hash }}{% endblock breadcrumbs %} + +{% block maincontent %} +
ŹródłoHTML
{{ image_folders_form.folders }}
 
+ + +
+ {{ object|safe }} +
+{% endblock maincontent %} \ No newline at end of file diff --git a/platforma/templates/explorer/file_list.html b/platforma/templates/explorer/file_list.html new file mode 100644 index 00000000..f44a105c --- /dev/null +++ b/platforma/templates/explorer/file_list.html @@ -0,0 +1,94 @@ +{% extends "base.html" %} + +{% block extrahead %} + + + + +{% endblock extrahead %} + +{% block maincontent %} +
+ +
+
+

+ + +

+
+ {% load explorer_tags %} +
    + {% for file in filetree %} + {% tree_part file %} + {% endfor %} +
+
+ +
+

Ostatnio oglądane pliki:

+
    +
+
+ +{% if perms.explorer.can_add_files %} +
+

Dodaj nowy utwór

+ +
+ {{ bookform }} +

+
+ +
+{% endif %} + +
+{% endblock maincontent %} diff --git a/platforma/templates/explorer/file_tree_part.html b/platforma/templates/explorer/file_tree_part.html new file mode 100644 index 00000000..f65cf28a --- /dev/null +++ b/platforma/templates/explorer/file_tree_part.html @@ -0,0 +1,13 @@ +{% load explorer_tags %} + +
  • + {{ document.name|bookname }} + {% if document.parts %} +
      + {% for part in document.parts %} + {% tree_part part %} + {% endfor %} +
    + {% endif %} +
    • + diff --git a/platforma/templates/explorer/file_upload.html b/platforma/templates/explorer/file_upload.html new file mode 100755 index 00000000..1deedac4 --- /dev/null +++ b/platforma/templates/explorer/file_upload.html @@ -0,0 +1,17 @@ +{% extends "base.html" %} + +{% block maincontent %} +

    Dodawanie nowego utworu:

    + +{% if errors %} +
    +{% for error in errors %} +

    {{ error }}: {{ error.errors }}

    +{% endfor %} +
    +{% endif %} +
    + {{ bookform.as_p }} +

    +
    +{% endblock maincontent %} diff --git a/platforma/templates/explorer/folder_images.html b/platforma/templates/explorer/folder_images.html new file mode 100644 index 00000000..8f5f600f --- /dev/null +++ b/platforma/templates/explorer/folder_images.html @@ -0,0 +1,3 @@ +{% for image in images %} +
    {{ image }}
    +{% endfor %} \ No newline at end of file diff --git a/platforma/templates/explorer/split.html b/platforma/templates/explorer/split.html new file mode 100755 index 00000000..8d3b67bb --- /dev/null +++ b/platforma/templates/explorer/split.html @@ -0,0 +1,26 @@ +
    +
    + Split options + {% for field in splitform %} + {% if field.is_hidden %} + {{ field}} + {% else %} + {{ field.errors }} + {% ifequal field.html_name 'splitform-autoxml' %} +

    + {% else %} +

    + {% endifequal %} + {% endif %} + {% endfor %} +
    + + +

    + + +

    +
    diff --git a/platforma/templates/explorer/split_success.html b/platforma/templates/explorer/split_success.html new file mode 100755 index 00000000..4f3a57b8 --- /dev/null +++ b/platforma/templates/explorer/split_success.html @@ -0,0 +1,3 @@ +

    Split successful. You can edit the new part here: +{% url editor_view cfileid %}

    +

    \ No newline at end of file diff --git a/platforma/templates/html4print.html b/platforma/templates/html4print.html new file mode 100644 index 00000000..1b4ef319 --- /dev/null +++ b/platforma/templates/html4print.html @@ -0,0 +1,13 @@ + + + + {{docid}} + + + + +
    + {{ output|safe }} +
    + + diff --git a/platforma/templates/manager/pull_request.html b/platforma/templates/manager/pull_request.html new file mode 100644 index 00000000..c2964c22 --- /dev/null +++ b/platforma/templates/manager/pull_request.html @@ -0,0 +1,75 @@ +{% extends 'base.html' %} + +{% block extrahead %} + + +{% endblock %} + +{% block maincontent %} + + + + + +{% if objects %} + {% for pullreq in objects %} + + + + + + + + + {% endfor %} +{% else %} + +{% endif %} +
    UtwórUżytkownikKomentarzStanAkcje
    {{ pullreq.document }}{{ pullreq.comitter }}{{ pullreq.comment }} {{ pullreq.status }}
    Brak żądań
    + +{% endblock %} diff --git a/platforma/templates/registration/head_login.html b/platforma/templates/registration/head_login.html new file mode 100644 index 00000000..5eb353d0 --- /dev/null +++ b/platforma/templates/registration/head_login.html @@ -0,0 +1,10 @@ +{% if user.is_authenticated %} +{{ user.username }} | +Wyloguj +{% else %} +{% url login as login_url %} +{% ifnotequal login_url request.path %} + Logowanie +{% endifnotequal %} + +{% endif %} diff --git a/platforma/templates/registration/login.html b/platforma/templates/registration/login.html new file mode 100644 index 00000000..810bd4ec --- /dev/null +++ b/platforma/templates/registration/login.html @@ -0,0 +1,15 @@ +{% extends "base.html" %} + +{% block subtitle %} - Logowanie {% endblock subtitle %} + +{% block maincontent %} + +
    +
    +{{ form.as_p }} +

    + +
    +
    + +{% endblock maincontent %} diff --git a/platforma/templates/wysiwyg.html b/platforma/templates/wysiwyg.html new file mode 100644 index 00000000..a592bf11 --- /dev/null +++ b/platforma/templates/wysiwyg.html @@ -0,0 +1,30 @@ +{% extends 'base.html' %} + +{% block maincontent %} +

    Wysiwyg editor

    +
    This part is not editable!
    +
    + +

    +

    Lorem ipsum dolor sit amet, consectetur adipiscing elit. + Suspendisse a urna eu enim rutrum elementum nec sed nibh. Quisque sed tortor + nulla, et euismod turpis. Morbi purus nulla, vulputate in vulputate id, gravida + id eros. In interdum est tempor est consequat imperdiet. Vivamus vitae ligula quam. + Proin nibh quam, tincidunt sit amet auctor eget, laoreet sit amet eros. Cras augue + lectus, euismod nec posuere ac, ultricies sed magna. Aliquam a lacinia sapien. + Cras imperdiet urna vel dui accumsan mollis. Suspendisse convallis tincidunt ornare. + Aenean convallis libero in lectus dictum vestibulum interdum ipsum suscipit. + Suspendisse sed justo sapien, eu egestas libero. Sed tincidunt sagittis sollicitudin. + Aliquam erat volutpat. Nullam egestas dolor id massa sagittis at sagittis ipsum + hendrerit. +

    + +

    Phasellus sed purus non orci eleifend posuere ac eu elit. Etiam orci justo, porta vitae varius in, scelerisque sed metus. Phasellus faucibus lorem at metus scelerisque sit amet sollicitudin dolor dignissim. Aliquam eu justo in diam blandit posuere at a diam. Pellentesque tristique sem eu odio gravida eleifend. Phasellus cursus adipiscing metus, nec pharetra enim pharetra ac. Pellentesque faucibus volutpat lorem nec vulputate. Mauris in faucibus ipsum. Nulla ut urna nulla. Sed at tellus nec diam posuere porttitor. Duis faucibus, libero nec rhoncus facilisis, tortor ligula adipiscing massa, nec varius justo ante et magna. Donec orci mauris, ultrices nec blandit vel, lacinia in ante. Maecenas libero mi, pretium id ultricies eget, fringilla sit amet risus. Integer ut ante sem, et condimentum odio. Nam nec est erat. Etiam ut metus ligula. In vel condimentum orci.

    + +

    Suspendisse potenti. Proin in augue nibh. Curabitur in sollicitudin ipsum. In ut leo vel purus volutpat tempus. Proin ut neque at augue euismod ullamcorper nec ac dui. Vestibulum id quam nunc, eu porta augue. Pellentesque interdum neque eu nulla rhoncus vulputate. Sed viverra diam ac sem consectetur semper. Quisque consectetur fringilla quam, in feugiat nisl vulputate quis. Fusce vel ipsum lectus, eu interdum nunc. Donec luctus libero vitae mauris imperdiet at iaculis magna aliquet. Curabitur ullamcorper, diam nec pulvinar venenatis, nibh ante volutpat mauris, nec tristique lectus sem in urna. Aenean eu malesuada metus. Integer auctor nulla sit amet ligula sollicitudin ut accumsan velit ullamcorper. Donec nec auctor augue.

    + +

    Maecenas eget lacus vitae velit tincidunt bibendum quis et diam. In ullamcorper condimentum velit, et elementum felis vestibulum facilisis. Donec vitae cursus ipsum. Cras accumsan tincidunt aliquet. Nulla pellentesque mattis magna aliquet hendrerit. Pellentesque pellentesque odio enim. Duis viverra rhoncus tristique. In in risus ligula. Nullam dapibus lacinia facilisis. Ut eu neque neque, tristique laoreet nisl. Aliquam placerat dignissim leo, tristique tempor est vestibulum ut.

    + +

    Donec semper tempus ante, eget gravida erat varius et. Suspendisse aliquam rutrum nunc ac pulvinar. Aliquam erat volutpat. Nulla consectetur ultricies imperdiet. Nulla tincidunt est vitae augue porttitor a faucibus odio facilisis. In nec nisl odio. Aliquam et libero tortor, eu tincidunt mi. Vivamus suscipit erat sed mi hendrerit fringilla. Integer iaculis tempus nulla, at egestas velit faucibus ut. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Vestibulum vel massa enim. Aliquam erat volutpat. In ligula tortor, fermentum eu suscipit at, posuere vel nunc. Nullam nibh magna, sollicitudin at semper et, mattis ut quam. Curabitur accumsan semper elit ac posuere. Sed sit amet lorem tortor, vel porttitor justo. Fusce odio metus, bibendum ut bibendum sit amet, luctus a ipsum.

    +
    +{% endblock %} \ No newline at end of file diff --git a/platforma/urls.py b/platforma/urls.py new file mode 100644 index 00000000..e107635e --- /dev/null +++ b/platforma/urls.py @@ -0,0 +1,71 @@ +# -*- coding: utf-8 -*- + +from django.conf.urls.defaults import * +from django.contrib import admin +from django.conf import settings + +admin.autodiscover() +PATH_SEC = r"(?P[^/]+)" +PATH_END = PATH_SEC + "/$" + +urlpatterns = patterns('', + # Explorer: + url(r'^$', 'explorer.views.file_list', name='file_list'), + url(r'^file/upload', 'explorer.views.file_upload', name='file_upload'), + + + url(r'^managment/pull-requests$', 'explorer.views.pull_requests'), + +# url(r'^images/(?P[^/]+)/$', 'explorer.views.folder_images', name='folder_image'), +# url(r'^images/$', 'explorer.views.folder_images', {'folder': '.'}, name='folder_image_ajax'), + + # Editor panels + # url(r'^editor/'+PATH_SEC+'/panel/(?P[a-z]+)/$', 'explorer.views.panel_view', name='panel_view'), + url(r'^editor/'+PATH_END, 'explorer.views.display_editor', name='editor_view'), + url(r'^editor/$', 'explorer.views.file_list', name='editor_base'), + + # url(r'^editor/'+PATH_SEC+'/split$', 'explorer.views.split_text'), + # url(r'^editor/'+PATH_SEC+'/split-success', + # 'explorer.views.split_success', name='split-success'), + + # url(r'^editor/'+PATH_SEC+'/print/html$', 'explorer.views.print_html'), + # url(r'^editor/'+PATH_SEC+'/print/xml$', 'explorer.views.print_xml'), + + url(r'^file/(?P[^/]+)/print$', 'explorer.views.print_html', name="file_print"), + # Task managment + # url(r'^manager/pull-requests$', 'explorer.views.pull_requests'), + + # Admin panel + url(r'^admin/doc/', include('django.contrib.admindocs.urls')), + url(r'^admin/(.*)', admin.site.root), + + # Prototypes +# url(r'^wysiwyg-proto/', include('wysiwyg.urls')), + + # Our über-restful api + url(r'^api/', include('api.urls') ), + +) + +if 'cas_consumer' in settings.INSTALLED_APPS: + urlpatterns += patterns('', + # django-cas-consumer + url(r'^accounts/login/$', 'cas_consumer.views.login', name='login'), + url(r'^accounts/logout/$', 'cas_consumer.views.logout', name='logout'), + ) +else: + urlpatterns += patterns('', + # Django auth + url(r'^accounts/login/$', 'django.contrib.auth.views.login', {'redirect_field_name': 'next'}, name='login'), + url(r'^accounts/logout/$', 'django.contrib.auth.views.logout', {'next_page': '/'}, name='logout'), + ) + +# Static files +if settings.DEBUG and not hasattr(settings, 'DONT_SERVE_STATIC'): + urlpatterns += patterns('', + url(r'^%s(?P.+)$' % settings.MEDIA_URL[1:], 'django.views.static.serve', + {'document_root': settings.MEDIA_ROOT, 'show_indexes': True}), + url(r'^%s(?P.+)$' % settings.STATIC_URL[1:], 'django.views.static.serve', + {'document_root': settings.STATIC_ROOT, 'show_indexes': True}), + ) +# \ No newline at end of file diff --git a/project/__init__.py b/project/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/project/dispatch.wsgi b/project/dispatch.wsgi deleted file mode 100755 index 5724b23c..00000000 --- a/project/dispatch.wsgi +++ /dev/null @@ -1,25 +0,0 @@ -#!/usr/bin/env python -import os -from os import path -import sys - -PROJECT_ROOT = path.realpath(path.dirname(__file__)) - -# Redirect sys.stdout to sys.stderr for bad libraries like geopy that use -# print statements for optional import exceptions. -sys.stdout = sys.stderr - -# Add apps and lib directories to PYTHONPATH -sys.path.insert(0, path.join(PROJECT_ROOT, '../apps')) -sys.path.insert(0, path.join(PROJECT_ROOT, '../lib')) - -# Emulate manage.py path hacking. -sys.path.insert(0, path.join(PROJECT_ROOT, "..")) -sys.path.insert(0, PROJECT_ROOT) - -# Run Django -os.environ['DJANGO_SETTINGS_MODULE'] = 'settings' - -from django.core.handlers.wsgi import WSGIHandler -application = WSGIHandler() - diff --git a/project/localsettings.sample b/project/localsettings.sample deleted file mode 100644 index 1bac9557..00000000 --- a/project/localsettings.sample +++ /dev/null @@ -1,39 +0,0 @@ -# -# localsettings template for Platforma -# -# Duplicate this file as localsettings.py and change it to your liking. -# Settings defined in localsettings.py will override settings from -# settings.py file. localsettings.py should never be commited -# to a version control system. Please make changes to settings.py -# or localsettings.sample instead. -# - -# Path to repository with managed documents -REPOSITORY_PATH = '/home/user/repository' - -# Subdirectory of STATIC_ROOT containing images -IMAGE_DIR = 'images' - -# Authentication via Central Authentication Server -INSTALLED_APPS = ( - 'django.contrib.auth', - 'django.contrib.contenttypes', - 'django.contrib.sessions', - 'django.contrib.sites', - 'django.contrib.admin', - 'django.contrib.admindocs', - - 'cas_consumer', - 'explorer', - 'toolbar', - 'api', - 'wysiwyg', -) - -AUTHENTICATION_BACKENDS = ( - 'cas_consumer.backends.CASBackend', -) - -CAS_BASE = 'http://localhost:7000/' -CAS_SERVICE = 'http://localhost:8000/accounts/login/' - diff --git a/project/manage.py b/project/manage.py deleted file mode 100755 index 8e180f0e..00000000 --- a/project/manage.py +++ /dev/null @@ -1,18 +0,0 @@ -#!/usr/bin/env python -from django.core.management import execute_manager -try: - import settings # Assumed to be in the same directory. -except ImportError: - import sys - sys.stderr.write("Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n(If the file settings.py does indeed exist, it's causing an ImportError somehow.)\n" % __file__) - sys.exit(1) - -if __name__ == "__main__": - # Append lib and apps directories to PYTHONPATH - from os import path - import sys - - PROJECT_ROOT = path.realpath(path.dirname(__file__)) - sys.path += [PROJECT_ROOT + '/../apps', PROJECT_ROOT + '/../lib'] - - execute_manager(settings) diff --git a/project/settings.py b/project/settings.py deleted file mode 100644 index 3a1f3ad9..00000000 --- a/project/settings.py +++ /dev/null @@ -1,155 +0,0 @@ -# -*- coding: utf-8 -*- -from os import path - -PROJECT_ROOT = path.realpath(path.dirname(__file__)) - -DEBUG = True -TEMPLATE_DEBUG = DEBUG - -ADMINS = ( - (u'Marek Stępniowski', 'marek@stepniowski.com'), - (u'Łukasz Rekucki', 'lrekucki@gmail.com'), -) - -MANAGERS = ADMINS - -DATABASE_ENGINE = 'sqlite3' # 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'oracle'. -DATABASE_NAME = PROJECT_ROOT + '/dev.sqlite' # Or path to database file if using sqlite3. -DATABASE_USER = '' # Not used with sqlite3. -DATABASE_PASSWORD = '' # Not used with sqlite3. -DATABASE_HOST = '' # Set to empty string for localhost. Not used with sqlite3. -DATABASE_PORT = '' # Set to empty string for default. Not used with sqlite3. - -# Local time zone for this installation. Choices can be found here: -# http://en.wikipedia.org/wiki/List_of_tz_zones_by_name -# although not all choices may be available on all operating systems. -# If running in a Windows environment this must be set to the same as your -# system time zone. -TIME_ZONE = 'Europe/Warsaw Poland' - -# Language code for this installation. All choices can be found here: -# http://www.i18nguy.com/unicode/language-identifiers.html -LANGUAGE_CODE = 'pl' - -#import locale -#locale.setlocale(locale.LC_ALL, '') - -SITE_ID = 1 - -# If you set this to False, Django will make some optimizations so as not -# to load the internationalization machinery. -USE_I18N = True - -# Absolute path to the directory that holds media. -# Example: "/home/media/media.lawrence.com/" -MEDIA_ROOT = PROJECT_ROOT + '/media/' -STATIC_ROOT = PROJECT_ROOT + '/static/' - -# URL that handles the media served from MEDIA_ROOT. Make sure to use a -# trailing slash if there is a path component (optional in other cases). -# Examples: "http://media.lawrence.com", "http://example.com/media/" -MEDIA_URL = '/media/' -STATIC_URL = '/static/' - -# URL prefix for admin media -- CSS, JavaScript and images. Make sure to use a -# trailing slash. -# Examples: "http://foo.com/media/", "/media/". -ADMIN_MEDIA_PREFIX = '/admin-media/' - -# Make this unique, and don't share it with anybody. -SECRET_KEY = 'ife@x^_lak+x84=lxtr!-ur$5g$+s6xt85gbbm@e_fk6q3r8=+' - -# List of callables that know how to import templates from various sources. -TEMPLATE_LOADERS = ( - 'django.template.loaders.filesystem.load_template_source', - 'django.template.loaders.app_directories.load_template_source', -# 'django.template.loaders.eggs.load_template_source', -) - -TEMPLATE_CONTEXT_PROCESSORS = ( - "django.core.context_processors.auth", - "django.core.context_processors.debug", - "django.core.context_processors.i18n", - "explorer.context_processors.settings", - "django.core.context_processors.request", -) - - -MIDDLEWARE_CLASSES = ( - 'django.middleware.common.CommonMiddleware', - 'django.contrib.sessions.middleware.SessionMiddleware', - 'django.contrib.auth.middleware.AuthenticationMiddleware', - 'explorer.middleware.EditorSettingsMiddleware', - 'django.middleware.doc.XViewMiddleware', - - 'maintenancemode.middleware.MaintenanceModeMiddleware', -) - -ROOT_URLCONF = 'urls' - -TEMPLATE_DIRS = ( - PROJECT_ROOT + '/templates', -) - -# CSS and JS files to compress -# COMPRESS_CSS = { -# 'all': { -# 'source_filenames': ('css/master.css', 'css/jquery.date_input.css', 'css/jquery.countdown.css',), -# 'output_filename': 'css/all.min.css', -# } -# } -# -# COMPRESS_JS = { -# 'all': { -# 'source_filenames': ('js/jquery.js', 'js/jquery.date_input.js', 'js/jquery.date_input-pl.js', -# 'js/jquery.countdown.js', 'js/jquery.countdown-pl.js',), -# 'output_filename': 'js/all.min.js', -# } -# } -# -# COMPRESS_CSS_FILTERS = None - -INSTALLED_APPS = ( - 'django.contrib.auth', - 'django.contrib.contenttypes', - 'django.contrib.sessions', - 'django.contrib.sites', - 'django.contrib.admin', - 'django.contrib.admindocs', - - 'piston', - 'explorer', - 'toolbar', - 'api', - 'wysiwyg', -) - - -# REPOSITORY_PATH = '/Users/zuber/Projekty/platforma/files/books' -IMAGE_DIR = 'images' -EDITOR_COOKIE_NAME = 'options' -EDITOR_DEFAULT_SETTINGS = { - 'panels': [ - {'name': 'htmleditor', 'ratio': 0.5}, - {'name': 'gallery', 'ratio': 0.5} - ], -} - -# Python logging settings -import logging - -log = logging.getLogger('platforma') -log.setLevel(logging.DEBUG) -ch = logging.StreamHandler() -ch.setLevel(logging.DEBUG) -formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') -ch.setFormatter(formatter) -log.addHandler(ch) - - -# Import localsettings file, which may override settings defined here -try: - from localsettings import * -except ImportError: - pass - diff --git a/project/static/css/autumn.css b/project/static/css/autumn.css deleted file mode 100644 index dddd8996..00000000 --- a/project/static/css/autumn.css +++ /dev/null @@ -1,49 +0,0 @@ -/* - Document : autumn - Created on : 2009-10-01, 00:23:51 - Author : lreqc - Description: - Autumn colors for PR. -*/ - -body { - background-color: #C28800; -} - -#header { - background-color: #E2CF62; - border-bottom-color: #860000; -} - -.panel-main-toolbar { - background-color: #412F1D; -} - -.splitview-splitbar { - /* border-color: #412F1D; */ - border: none; - background-color: #860000; -} - -.image-gallery-header { - background-color: #E2CF62; -} - -a:link, a:visited, a:active { - color: #860000; - text-decoration: none; - font-weight: bold; -} - -a:hover { - text-decoration: underline; -} - -.toolbar-buttons-container { - background-color: #E2CF62; -} - -.toolbar-tabs-container { - background-color: #860000; -} - diff --git a/project/static/css/filelist.css b/project/static/css/filelist.css deleted file mode 100755 index 91e9b8dc..00000000 --- a/project/static/css/filelist.css +++ /dev/null @@ -1,47 +0,0 @@ -/* - Document : filelist - Created on : 2009-09-04, 20:44:44 - Author : lreqc - Description: - Dodatkowe style dla listy plików na stronie głównej. -*/ - -#main-page-widgets > div { - float: left; - border: 1px solid black; - padding: 0.5em 2em; - margin: 1em; -} - -.file-list-widget { - background: #DDF; - max-width: 60%; -} - -.file-list-widget .page-nav-wrap button { - width: 2.5em; -} - -.upload-file-widget { - min-width: 20%; - width: 35%; -} - -ul.file-tree-part { - margin: 0.5em 1em; - padding: 0em; -} - -ul.file-tree-part li { - list-style: square; - padding: 0em; -} - -ul.file-tree-part a { - padding: 0em; -} - - - - - diff --git a/project/static/css/html.css b/project/static/css/html.css deleted file mode 100644 index 336a365e..00000000 --- a/project/static/css/html.css +++ /dev/null @@ -1,227 +0,0 @@ -/* Style widoku HTML. Nie należy tu ustawiać position ani marginesów */ -.htmlview { - font-size: 16px; - font: Georgia, "Times New Roman", serif; - line-height: 1.5em; - padding: 3em; -} - -.htmlview div { - max-width: 36em; -} - -.htmlview #toc { - display: none; -} - -.htmlview a { - color: blue; - text-decoration: none; -} - -.htmlview h1 { - font-size: 3em; - margin: 1.5em 0; - text-align: center; - line-height: 1.5em; - font-weight: bold; -} - -.htmlview h2 { - font-size: 2em; - margin: 1.5em 0 0; - font-weight: bold; - line-height: 1.5em; -} - -.htmlview h3 { - font-size: 1.5em; - margin: 1.5em 0 0; - font-weight: normal; - line-height: 1.5em; -} - -.htmlview h4 { - font-size: 1em; - margin: 1.5em 0 0; - line-height: 1.5em; -} - -.htmlview p { - margin: 0; -} - -/* ======================== */ -/* = Footnotes and themes = */ -/* ======================== */ -.htmlview .theme-begin { - border-left: 0.1em solid #DDDDDD; - color: #777; - padding: 0 0.5em; - width: 7.5em; - font-style: normal; - font-weight: normal; - font-size: 16px; - float: right; - margin-right: -9.5em; - clear: both; - left: 40em; - line-height: 1.5em; - text-align: left; -} - -.htmlview .annotation { - font-style: normal; - font-weight: normal; - font-size: 12px; -} - -.htmlview #footnotes .annotation { - display: block; - float: left; - width: 2.5em; - clear: both; -} - -.htmlview #footnotes div { - margin: 1.5em 0 0 0; -} - -.htmlview #footnotes p { - margin-left: 2.5em; - font-size: 0.875em; -} - -.htmlview blockquote { - font-size: 0.875em; -} - -/* ============= */ -/* = Numbering = */ -/* ============= */ -.htmlview .anchor { - position: relative; - margin: 0em; - left: -2.2em; - color: #777; - font-size: 12px; - width: 2em; - text-align: center; - padding: 0.25em 0.7em; - line-height: 1.5em; -} - -.htmlview .anchor:hover, .htmlview .anchor:active { - color: #FFF; - background-color: #CCC; -} - -/* =================== */ -/* = Custom elements = */ -/* =================== */ -.htmlview .autor_utwor { - font-size: 0.5em; - display: block; - line-height: 1.5em; - margin-bottom: 0.25em; -} - -.htmlview .dzielo_nadrzedne { - font-size: 0.375em; - display: block; - line-height: 1.5em; - margin-bottom: -0.25em; -} - -.htmlview .podtytul { - font-size: 0.5em; - display: block; - line-height: 1.5em; - margin-top: -0.25em; -} - -.htmlview .didaskalia { - font-style: italic; - margin: 0.5em 0 0 1.5em; -} - -.htmlview .kwestia { - margin: 0.5em 0 0; -} - -.htmlview .strofa { - margin: 1.5em 0 0; -} - -.htmlview .kwestia .strofa { - margin: 0; -} - -.htmlview .akap, .htmlview .akap_cd, .htmlview .akap_dialog { - text-align: justify; - margin: 1.5em 0 0; -} - -.htmlview p.motto { - text-align: justify; - font-style: italic; - margin: 1.5em 0 0; -} - -.htmlview p.motto_podpis { - font-size: 0.875em; - text-align: right; -} - -.htmlview div.fragment { - border-bottom: 0.1em solid #999; - padding-bottom: 1.5em; -} - -.htmlview div.nota p, -.htmlview div.dedykacja p { - text-align: right; - font-style: italic; -} - -.htmlview br.sekcja_swiatlo { - height: 3em; - /* visibility: hidden; */ -} - -.htmlview hr.separator_linia { - margin: 1.5em 0; - border: none; - border-bottom: 0.1em solid #000; -} - -.htmlview p.sekcja_asterysk { - padding: 0; - margin: 1.5em 0; - text-align: center; -} - -.htmlview div.lista_osob ol { - list-style: none; - padding: 0 0 0 1.5em; -} - -.htmlview p.miejsce_czas { - font-style: italic; -} - -.htmlview .mat, -.htmlview .slowo_obce, -.htmlview .tytul_dziela, -.htmlview .didaskalia { - font-style: italic; -} - -.htmlview .wyroznienie { - letter-spacing: 0.1em; -} - -.htmlview .osoba { - font-style: normal; - font-variant: small-caps; -} diff --git a/project/static/css/html_print.css b/project/static/css/html_print.css deleted file mode 100644 index 38cb5968..00000000 --- a/project/static/css/html_print.css +++ /dev/null @@ -1,229 +0,0 @@ -/* Style widoku HTML. Nie należy tu ustawiać position ani marginesów */ -.htmlview { - font-size: 16px; - font: Georgia, "Times New Roman", serif; - line-height: 1.5em; - padding: 3em; -} - -.htmlview div { - max-width: 36em; -} - -.htmlview #toc { - display: none; -} - -.htmlview a { - color: blue; - text-decoration: none; -} - -.htmlview h1 { - font-size: 3em; - margin: 1.5em 0; - text-align: center; - line-height: 1.5em; - font-weight: bold; -} - -.htmlview h2 { - font-size: 2em; - margin: 1.5em 0 0; - font-weight: bold; - line-height: 1.5em; -} - -.htmlview h3 { - font-size: 1.5em; - margin: 1.5em 0 0; - font-weight: normal; - line-height: 1.5em; -} - -.htmlview h4 { - font-size: 1em; - margin: 1.5em 0 0; - line-height: 1.5em; -} - -.htmlview p { - margin: 0; -} - -/* ======================== */ -/* = Footnotes and themes = */ -/* ======================== */ -.htmlview .theme-begin { - border-left: 0.1em solid #DDDDDD; - color: #777; - padding: 0 0.5em; - width: 7.5em; - font-style: normal; - font-weight: normal; - font-size: 16px; - float: right; - margin-right: -9.5em; - clear: both; - left: 40em; - line-height: 1.5em; - text-align: left; -} - -.htmlview .annotation { - font-style: normal; - font-weight: normal; - font-size: 12px; -} - -.htmlview #footnotes .annotation { - display: block; - float: left; - width: 2.5em; - clear: both; -} - -.htmlview #footnotes div { - margin: 1.5em 0 0 0; -} - -.htmlview #footnotes p { - margin-left: 2.5em; - font-size: 0.875em; -} - -.htmlview blockquote { - font-size: 0.875em; -} - -/* ============= */ -/* = Numbering = */ -/* ============= */ -.htmlview p { - position: relative; -} - -.htmlview .anchor { - position: absolute; - margin: 0em; - left: -3em; - color: #777; - font-size: 12px; - width: 2em; - text-align: center; - padding: 0.25em 0.5em; - line-height: 1.5em; -} - -.htmlview .anchor:hover, .htmlview .anchor:active { - color: #FFF; - background-color: #CCC; -} - -/* =================== */ -/* = Custom elements = */ -/* =================== */ -.htmlview span.author { - font-size: 0.5em; - display: block; - line-height: 1.5em; - margin-bottom: 0.25em; -} - -.htmlview span.collection { - font-size: 0.375em; - display: block; - line-height: 1.5em; - margin-bottom: -0.25em; -} - -.htmlview span.subtitle { - font-size: 0.5em; - display: block; - line-height: 1.5em; - margin-top: -0.25em; -} - -.htmlview div.didaskalia { - font-style: italic; - margin: 0.5em 0 0 1.5em; -} - -.htmlview div.kwestia { - margin: 0.5em 0 0; -} - -.htmlview div.stanza { - margin: 1.5em 0 0; -} - -.htmlview div.kwestia div.stanza { - margin: 0; -} - -.htmlview p.paragraph { - text-align: justify; - margin: 1.5em 0 0; -} - -.htmlview p.motto { - text-align: justify; - font-style: italic; - margin: 1.5em 0 0; -} - -.htmlview p.motto_podpis { - font-size: 0.875em; - text-align: right; -} - -.htmlview div.fragment { - border-bottom: 0.1em solid #999; - padding-bottom: 1.5em; -} - -.htmlview div.note p, .htmlview div.dedication p, -.htmlview div.note p.paragraph, .htmlview div.dedication p.paragraph { - text-align: right; - font-style: italic; -} - -.htmlview hr.spacer { - height: 3em; - visibility: hidden; -} - -.htmlview hr.spacer-line { - margin: 1.5em 0; - border: none; - border-bottom: 0.1em solid #000; -} - -.htmlview p.spacer-asterisk { - padding: 0; - margin: 1.5em 0; - text-align: center; -} - -.htmlview div.person-list ol { - list-style: none; - padding: 0 0 0 1.5em; -} - -.htmlview p.place-and-time { - font-style: italic; -} - -.htmlview em.math, .htmlview em.foreign-word, -.htmlview em.book-title, .htmlview em.didaskalia { - font-style: italic; -} - -.htmlview em.author-emphasis { - letter-spacing: 0.1em; -} - -.htmlview em.person { - font-style: normal; - font-variant: small-caps; -} diff --git a/project/static/css/jquery.modal.css b/project/static/css/jquery.modal.css deleted file mode 100755 index 4717ad45..00000000 --- a/project/static/css/jquery.modal.css +++ /dev/null @@ -1,28 +0,0 @@ -/* jqModal base Styling courtesy of; - Brice Burgess */ - -/* The Window's CSS z-index value is respected (takes priority). If none is supplied, - the Window's z-index value will be set to 3000 by default (via jqModal.js). */ - -.jqmWindow { - display: none; - - position: absolute; - top: 40px; - left: 25%; - bottom: auto; - height: auto; - width: auto; - - max-width: 80%; - max-height: 80%; - - overflow: auto; - - background-color: #EEE; - color: #333; - border: 1px solid black; - padding: 1em; -} - -.jqmOverlay { background-color: #000; } diff --git a/project/static/css/managment.css b/project/static/css/managment.css deleted file mode 100644 index 3777bcfc..00000000 --- a/project/static/css/managment.css +++ /dev/null @@ -1,36 +0,0 @@ -table.request-report -{ - border: 2px groove black; - font-size: 12pt; - - margin-top: 3em; - margin-bottom: 2em; - margin-left: auto; - margin-right: auto; -} - -.request-report td, .request-report th { - vertical-align: top; - border-right: 1px solid black; - border-bottom: 1px solid black; - - padding: 0.4em 1em; - margin: 0em; -} - -.request-report th { - background-color: black; - color: white; -} - -.request-report .status-N { - background-color: teal; -} - -.request-report .status-R { - background-color: red; -} - -.request-report .status-A { - background-color: gray; -} \ No newline at end of file diff --git a/project/static/css/master.css b/project/static/css/master.css deleted file mode 100644 index ae51e475..00000000 --- a/project/static/css/master.css +++ /dev/null @@ -1,415 +0,0 @@ -body { - margin: 0; - - font: 12px Helvetica, Verdana, sans-serif; - overflow: hidden; - background: #AAA; -} - -/* fix icon buttons */ - -button img { - vertical-align: middle; - margin: 0px; -} - -/* default form style hacks */ -select { - border: none; - margin-left: 0.1em; -} - -#body-wrap { - margin: 0px; - padding: 0px; -} - -#header { - position: absolute; - padding: 2px 0.5em; - background-color: #CDCDCD; /* !unused */ - border-bottom: 2px solid black; - - font-size: 14px; - - line-height: 26px; - vertical-align: middle; - - /* height: 30px; */ - top: 0px; left: 0px; right: 0px; - z-index: 300; -} - -#content { - position: absolute; - top: 32px; left: 0px; right: 0px; bottom: 0px; - overflow: auto; - background-color: white; -} - -#header #breadcrumbs { -} - -#header-right-toolbar { - position: absolute; - right: 1em; -} - -#header button { - vertical-align: middle; -} - -/* ========== */ -/* = Panels = */ -/* ========== */ - -/* #panels { - height: 100%; - width: 100%; -} - -.panel-wrap { - overflow: hidden; - position: absolute; - top: 0px; - bottom: 0px; -} - -#left-panel-wrap { - left: 0px; - width: 8px; -} - -#right-panel-wrap { - right: 0px; - width: auto; - left: 8px; -} - -.panel-content { - position: absolute; - overflow: auto; - overflow-x: hidden; - top: 25px; left: 0px; bottom:0px; right: 0px; -} - -.panel-overlay { - position: absolute; - top: 0px; bottom: 0px; left: 0px; right: 0px; - z-index: 100; - background: gray; - opacity: 0.8; - text-align: center; - overflow: hidden; - display: none; - cursor: col-resize; -} - -.panel-content-overlay { -} - -.panel-wrap.last-panel .panel-content { - right: 0px; -} - -.panel-wrap.last-panel .panel-slider { - display: none; -} - -.panel-wrap .panel-toolbar { - position: absolute; - top: 0px; left:0px; right: 0px; height: 26px; - padding: 0px; - - border-bottom: 1px solid #AAA; - z-index: 80; -} -.panel-wrap .panel-slider { - position: absolute; - background-color: #DDD; - - top: 0px; bottom: 0px; right: 0px; width: 4px; - - border-left: 1px solid #999; - border-right: 1px solid #999; - border-top: none; - border-bottom: none; - - z-index: 90; - cursor: col-resize; -} - -.panel-wrap .panel-slider:hover { - background-color: #999; -} - -.panel-content-overlay.panel-wrap .panel-slider { - background-color: #DDD; -} - -*/ - -/* OLD STUFF AGAIN */ - -/* Commit dialog */ -#commit-dialog-error-empty-message { - color: red; - display: none; - font-weight: bold; -} - -text#commit-dialog-message { - width: 80%; - margin: auto; -} - -#split-dialog .container-box form { - margin: 0.2em 1em; -} - -#split-dialog .container-box fieldset { - margin: 0.5em; -} - - - - -/* ======= */ -/* = New = */ -/* ======= */ -#splitview { - width: 100%; - height: 100%; - padding: 0; - margin: 0; -} - -.splitview-splitbar { - width: 5px; - border-left: 1px solid #999; - border-right: 1px solid #999; - height: 100%; - background-color: #CCC; - z-index: 100; -} - -.splitview-overlay { - z-index: 90; - background: #FFF; - opacity: 0.5; -} - -.panel-container { - height: 100%; - position: relative; -} - -.content-view { - position: absolute; - top: 25px; - right: 0; - bottom: 0; - left: 0; - overflow: hidden; -} - -.panel-main-toolbar { - z-index: 1100; - position: absolute; - - top: 0px; - right: 0px; - left: 0px; - height: 24px; - - border-bottom: 1px solid black; - background: gray; - - padding: 0px; -} - -.panel-main-toolbar p { - margin: 0px; - padding: 2px; - line-height: 20px; - font-size: 13px; -} - -.xmlview { - height: 100%; -} - -.view-overlay { - z-index: 1000; - background: #FFF; - opacity: 0.8; - text-align: center; - text-valign: center; -} - -.view-overlay p { - display: block; - position: relative; - top: auto; - bottom: auto; - height: 40px; -} - -/* .buttontoolbarview { - display: block; - background-color: #CCC; -} - -.buttontoolbarview a { - color: #000; - text-decoration: none; -} */ /* Similar classes already exist in toolbar.css */ - - -/* ================= */ -/* = Gallery panel = */ -/* ================= */ -.image-gallery-view-template { - position: absolute; - top: 0px; left: 0px; right: 0px; bottom: 0px; - overflow: hidden; -} - -.image-gallery-header { - position: absolute; - bottom: 0px; - left: 0px; - right: 0px; - height: 30px; - - background: gray; - border-top: 1px solid #780000; - z-index: 100; -} - -input.image-gallery-current-page { - text-align: center; -} - -.image-gallery-header p { - margin: 0px; - padding: 3px 1em; - height: 30px; - line-height: 24px; - text-align: center; - white-space: nowrap; -} - -.image-gallery-page-list { - position: absolute; - top: 0px; - left: 0px; - right: 0px; - bottom: 31px; - background: black; - z-index: 0; - - overflow: hidden; -} - -.image-gallery-page-container { - display: none; - border: none; - - position: absolute; - top: 0px; left: 0px; - - text-align: center; - padding: 0px; -} - -.htmlview { - position: absolute; - top: 25px; - right: 0; - bottom: 0; - left: 0; - overflow: auto; - margin: 0; -} - -.image-gallery-page-container img { - /* border: 2px solid green; */ - margin: 0px; -} - -body#base button { - background-color: #DDD; - border-width: 1px; - padding: 0px 0.5em; - font-family: Sans-Serif; - /* color: #000; */ - margin: 2px 4px; -} - -body#base button:hover { - background-color: #EEE; -} - -/* HTML editor interactive elements */ - -.html-editarea { - border: 2px solid black; - background-color: gray; - padding: 1px; - - z-index: 2000; -} - -.html-editarea textarea -{ - - border: 0px; - margin: 0px; - padding: 0px; - - width: 100%; - height: 100%; - - z-index: 0; - font-size: 10pt; - background-color: ivory; -} - -.html-editarea p.html-editarea-toolbar { - position: absolute; - background: gray; - - bottom: -26px; - height: 24px; - - left: 0px; - right: 0px; - - border: 2px solid black; - - margin: 0px; - padding: 0px; - - z-index: 100; -} - -/* ================= */ -/* = Message boxes = */ -/* ================= */ -.info { - background-color: gray; -} - -.success { - background-color: green; -} - -.error { - background-color: yellow; -} - -.critical { - background-color: red; -} - diff --git a/project/static/css/toolbar.css b/project/static/css/toolbar.css deleted file mode 100644 index b5df66f3..00000000 --- a/project/static/css/toolbar.css +++ /dev/null @@ -1,5 +0,0 @@ -.toolbar-buttons-container { - padding-top: 2px; - padding-bottom: 2px; -} - diff --git a/project/static/css/xmlcolors.css b/project/static/css/xmlcolors.css deleted file mode 100644 index aa26579e..00000000 --- a/project/static/css/xmlcolors.css +++ /dev/null @@ -1,51 +0,0 @@ -.editbox { - margin: .4em; - padding: 0; - font-family: monospace; - font-size: 10pt; - color: black; -} - -.editbox p { - margin: 0; -} - -span.xml-tagname { - color: #A0B; -} - -span.xml-attribute { - color: #281; -} - -span.xml-punctuation { - color: black; -} - -span.xml-attname { - color: #00F; -} - -span.xml-comment { - color: #A70; -} - -span.xml-cdata { - color: #48A; -} - -span.xml-processing { - color: #999; -} - -span.xml-entity { - color: #A22; -} - -span.xml-error { - color: #F00; -} - -span.xml-text { - color: black; -} diff --git a/project/static/icons/go-next.png b/project/static/icons/go-next.png deleted file mode 100644 index 6ef8de76..00000000 Binary files a/project/static/icons/go-next.png and /dev/null differ diff --git a/project/static/icons/go-previous.png b/project/static/icons/go-previous.png deleted file mode 100644 index 659cd90d..00000000 Binary files a/project/static/icons/go-previous.png and /dev/null differ diff --git a/project/static/icons/zoom.png b/project/static/icons/zoom.png deleted file mode 100644 index 6033b4d5..00000000 Binary files a/project/static/icons/zoom.png and /dev/null differ diff --git a/project/static/icons/zoom_in.png b/project/static/icons/zoom_in.png deleted file mode 100644 index c7feedc6..00000000 Binary files a/project/static/icons/zoom_in.png and /dev/null differ diff --git a/project/static/icons/zoom_out.png b/project/static/icons/zoom_out.png deleted file mode 100644 index fdd7124e..00000000 Binary files a/project/static/icons/zoom_out.png and /dev/null differ diff --git a/project/static/js/app.js b/project/static/js/app.js deleted file mode 100644 index fde15393..00000000 --- a/project/static/js/app.js +++ /dev/null @@ -1,185 +0,0 @@ -/*global Class*/ -var editor; -var panel_hooks; - - -// prevent a console.log from blowing things up if we are on a browser that -// does not support it -if (typeof console === 'undefined') { - window.console = {} ; - console.log = console.info = console.warn = console.error = function(){}; -} - - -(function(){ - // Classes - var initializing = false, fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/; - this.Class = function(){}; - Class.extend = function(prop) { - var _super = this.prototype; - initializing = true; - var prototype = new this(); - initializing = false; - for (var name in prop) { - prototype[name] = typeof prop[name] == "function" && - typeof _super[name] == "function" && fnTest.test(prop[name]) ? - (function(name, fn){ - return function() { - var tmp = this._super; - this._super = _super[name]; - var ret = fn.apply(this, arguments); - this._super = tmp; - return ret; - }; - })(name, prop[name]) : - prop[name]; - } - function Class() { - if ( !initializing && this.init ) - this.init.apply(this, arguments); - } - Class.prototype = prototype; - Class.constructor = Class; - Class.extend = arguments.callee; - return Class; - }; - - // Templates - var cache = {}; - - this.render_template = function render_template(str, data){ - // Figure out if we're getting a template, or if we need to - // load the template - and be sure to cache the result. - var fn = !/^[\d\s-_]/.test(str) ? - cache[str] = cache[str] || - render_template(document.getElementById(str).innerHTML) : - - // Generate a reusable function that will serve as a template - // generator (and which will be cached). - - new Function("obj", - "var p=[],print=function(){p.push.apply(p,arguments);};" + - - // Introduce the data as local variables using with(){} - "with(obj){p.push('" + - - // Convert the template into pure JavaScript - str - .replace(/[\r\t\n]/g, " ") - .split("<%").join("\t") - .replace(/((^|%>)[^\t]*)'/g, "$1\r") - .replace(/\t=(.*?)%>/g, "',$1,'") - .split("\t").join("');") - .split("%>").join("p.push('") - .split("\r").join("\\'") - + "');}return p.join('');"); - - // Provide some basic currying to the user - return data ? fn( data ) : fn; - }; -})(); - - -(function() { - var slice = Array.prototype.slice; - - function update(array, args) { - var arrayLength = array.length, length = args.length; - while (length--) array[arrayLength + length] = args[length]; - return array; - }; - - function merge(array, args) { - array = slice.call(array, 0); - return update(array, args); - }; - - Function.prototype.bind = function(context) { - if (arguments.length < 2 && typeof arguments[0] === 'undefined') { - return this; - } - var __method = this; - var args = slice.call(arguments, 1); - return function() { - var a = merge(args, arguments); - return __method.apply(context, a); - } - } - -})(); - - -var Editor = Editor || {}; - -// Obiekt implementujący wzorzec KVC/KVO -Editor.Object = Class.extend({ - _className: 'Editor.Object', - _observers: {}, - _guid: null, - - init: function() { - this._observers = {}; - }, - - description: function() { - return this._className + '(guid = ' + this.guid() + ')'; - }, - - addObserver: function(observer, property, callback) { - // console.log('Add observer', observer.description(), 'to', this.description(), '[', property, ']'); - if (!this._observers[property]) { - this._observers[property] = {} - } - this._observers[property][observer.guid()] = callback; - return this; - }, - - removeObserver: function(observer, property) { - if (!property) { - for (var property in this._observers) { - this.removeObserver(observer, property) - } - } else { - // console.log('Remove observer', observer.description(), 'from', this.description(), '[', property, ']'); - delete this._observers[property][observer.guid()]; - } - return this; - }, - - notifyObservers: function(property) { - var currentValue = this[property]; - for (var guid in this._observers[property]) { - // console.log(this._observers[property][guid]); - // console.log('Notifying', guid, 'of', this.description(), '[', property, ']'); - this._observers[property][guid](property, currentValue, this); - } - return this; - }, - - guid: function() { - if (!this._guid) { - this._guid = ('editor-' + Editor.Object._lastGuid++); - } - return this._guid; - }, - - get: function(property) { - return this[property]; - }, - - set: function(property, value) { - if (this[property] != value) { - this[property] = value; - this.notifyObservers(property); - } - return this; - }, - - dispose: function() { - delete this._observers; - } -}); - -Editor.Object._lastGuid = 0; - -var panels = []; diff --git a/project/static/js/button_scripts.js b/project/static/js/button_scripts.js deleted file mode 100644 index 40f45f6f..00000000 --- a/project/static/js/button_scripts.js +++ /dev/null @@ -1,210 +0,0 @@ -function ScriptletCenter() -{ - this.scriptlets = {}; - - this.scriptlets['insert_tag'] = function(context, params) - { - var text = this.XMLEditorSelectedText(context); - var start_tag = '<'+params.tag; - - for (var attr in params.attrs) { - start_tag += ' '+attr+'="' + params.attrs[attr] + '"'; - } - - start_tag += '>'; - var end_tag = ''; - - if(text.length > 0) { - // tokenize - var output = ''; - var token = ''; - for(var index=0; index < text.length; index++) - { - if (text[index].match(/\s/)) { // whitespace - token += text[index]; - } - else { // character - output += token; - if(output == token) output += start_tag; - token = ''; - output += text[index]; - } - } - - if( output[output.length-1] == '\\' ) { - output = output.substr(0, output.length-1) + end_tag + '\\'; - } else { - output += end_tag; - } - output += token; - } - else { - output = start_tag + end_tag; - } - - this.XMLEditorReplaceSelectedText(context, output); - - if (text.length == 0) { - this.XMLEditorMoveCursorForward(context, -params.tag.length-3); - } - }.bind(this); - - this.scriptlets['lineregexp'] = function(context, params) { - - var exprs = $.map(params.exprs, function(expr) { - var opts = "g"; - if(expr.length > 2) { - opts = expr[2]; - } return { - rx: new RegExp(expr[0], opts), - repl: expr[1] - }; - }); - - var partial = true; - var text = this.XMLEditorSelectedText(context); - if(!text) return; - - var changed = 0; - var lines = text.split('\n'); - lines = $.map(lines, function(line) { - var old_line = line; - $(exprs).each(function() { - var expr = this; - line = line.replace(expr.rx, expr.repl); - }); - - if(old_line != line) changed += 1; - return line; - }); - - if(changed > 0) { - this.XMLEditorReplaceSelectedText(context, lines.join('\n') ); - } - }.bind(this); - - this.scriptlets['codemirror_fontsize'] = function(context, params) { - var frameBody = this.XMLEditorBody(context); - - if(params.fontSize) { - frameBody.css('font-size', params.fontSize); - } - else { - var old_size = parseInt(frameBody.css('font-size'), 10); - frameBody.css('font-size', old_size + (params.change || 0) ); - } - - }.bind(this); - - this.scriptlets['fulltextregexp'] = function(context, params) { - var exprs = $.map(params.exprs, function(expr) { - var opts = "mg"; - if(expr.length > 2) { - opts = expr[2]; - } - return { - rx: new RegExp(expr[0], opts), - repl: expr[1] - }; - }); - - var text = this.XMLEditorSelectedText(context); - if(!text) return; - var original = text; - $(exprs).each(function() { - text = text.replace(this.rx, this.repl); - }); - - if( original != text) { - this.XMLEditorReplaceSelectedText(context, text); - } - }.bind(this); - - this.scriptlets['macro'] = function(context, params) { - var self = this; - - $(params).each(function() { - $.log(this[0], this[1]); - self.scriptlets[this[0]](context, this[1]); - }); - }.bind(this); - - this.scriptlets['lowercase'] = function(context, params) - { - var text = this.XMLEditorSelectedText(context); - - if(!text) return; - - var repl = ''; - var lcase = text.toLowerCase(); - var ucase = text.toUpperCase(); - - if(lcase == text) repl = ucase; /* was lowercase */ - else if(ucase != text) repl = lcase; /* neither lower- or upper-case */ - else { /* upper case -> camel-case */ - var words = $(lcase.split(/\s/)).map(function() { - if(this.length > 0) { - return this[0].toUpperCase() + this.slice(1); - } else { - return ''; - } - }); - repl = words.join(' '); - } - - if(repl != text) this.XMLEditorReplaceSelectedText(context, repl); - }.bind(this); - - - this.scriptlets["insert_stanza"] = function(context, params) { - var text = this.XMLEditorSelectedText(context); - - if(text) { - var verses = text.split('\n'); - text = ''; var buf = ''; var ebuf = ''; - var first = true; - - for(var i=0; i < verses.length; i++) { - var verse = verses[i].replace(/^\s+/, "").replace(/\s+$/, ""); - if(verse) { - text += (buf ? buf + '/\n' : '') + ebuf; - buf = (first ? '\n' : '') + verses[i]; - ebuf = ''; - first = false; - } else { - ebuf += '\n' + verses[i]; - } - } - text = text + buf + '\n' + ebuf; - this.XMLEditorReplaceSelectedText(context, text); - } - - if (!text) { - this.XMLEditorMoveCursorForward(context, params.tag.length + 2); - } - - }.bind(this); - -} - -ScriptletCenter.prototype.XMLEditorSelectedText = function(panel) { - return panel.contentView.editor.selection(); -}; - -ScriptletCenter.prototype.XMLEditorReplaceSelectedText = function(panel, replacement) -{ - panel.contentView.editor.replaceSelection(replacement); - // Tell XML view that it's data has changed - panel.contentView.editorDataChanged(); -}; - -ScriptletCenter.prototype.XMLEditorMoveCursorForward = function(panel, n) { - var pos = panel.contentView.editor.cursorPosition(); - panel.contentView.editor.selectLines(pos.line, pos.character + n); -}; - -var scriptletCenter; - -$(function() { - scriptletCenter = new ScriptletCenter(); -}); \ No newline at end of file diff --git a/project/static/js/editor.js b/project/static/js/editor.js deleted file mode 100644 index f52950ff..00000000 --- a/project/static/js/editor.js +++ /dev/null @@ -1,578 +0,0 @@ -var editor; -var panel_hooks; - -function Hotkey(code) { - this.code = code; - this.has_alt = ((code & 0x01 << 8) !== 0); - this.has_ctrl = ((code & 0x01 << 9) !== 0); - this.has_shift = ((code & 0x01 << 10) !== 0); - this.character = String.fromCharCode(code & 0xff); -} - -Hotkey.prototype.toString = function() { - var mods = []; - if(this.has_alt) mods.push('Alt'); - if(this.has_ctrl) mods.push('Ctrl'); - if(this.has_shift) mods.push('Shift'); - mods.push('"'+this.character+'"'); - return mods.join('+'); -}; - -function Panel(panelWrap) { - var self = this; - self.hotkeys = []; - self.wrap = panelWrap; - self.contentDiv = $('.panel-content', panelWrap); - self.instanceId = Math.ceil(Math.random() * 1000000000); - // $.log('new panel - wrap: ', self.wrap); - - $(document).bind('panel:unload.' + self.instanceId, - function(event, data) { - self.unload(event, data); - }); - - $(document).bind('panel:contentChanged', function(event, data) { - $.log(self, ' got changed event from: ', data); - if(self != data) { - self.otherPanelChanged(event.target); - } else { - self.markChanged(); - } - return false; - }); -} - -Panel.prototype.callHook = function() { - var args = $.makeArray(arguments); - var hookName = args.splice(0,1)[0]; - var noHookAction = args.splice(0,1)[0]; - var result = false; - - $.log('calling hook: ', hookName, 'with args: ', args); - if(this.hooks && this.hooks[hookName]) { - result = this.hooks[hookName].apply(this, args); - } else if (noHookAction instanceof Function) { - result = noHookAction(args); - } - return result; -}; - -Panel.prototype._endload = function () { - // this needs to be here, so we - this.connectToolbar(); - this.callHook('toolbarResized'); -}; - -Panel.prototype.load = function (url) { - // $.log('preparing xhr load: ', this.wrap); - $(document).trigger('panel:unload', this); - var self = this; - self.current_url = url; - - $.ajax({ - url: url, - dataType: 'html', - success: function(data, tstat) { - panel_hooks = null; - $(self.contentDiv).html(data); - self.hooks = panel_hooks; - panel_hooks = null; - self.callHook('load'); - }, - error: function(request, textStatus, errorThrown) { - $.log('ajax', url, this.target, 'error:', textStatus, errorThrown); - $(self.contentDiv).html("

    Wystapił błąd podczas wczytywania panelu.

    "); - } - }); -}; - -Panel.prototype.unload = function(event, data) { - // $.log('got unload signal', this, ' target: ', data); - if( data == this ) { - $(this.contentDiv).html(''); - - // disconnect the toolbar - $('div.panel-toolbar span.panel-toolbar-extra', this.wrap).html( - ''); - - this.callHook('unload'); - this.hooks = null; // flush the hooks - return false; - } -}; - -Panel.prototype.refresh = function(event, data) { - var self = this; - var reload = function() { - $.log('hard reload for panel ', self.current_url); - self.load(self.current_url); - return true; - }; - - if( this.callHook('refresh', reload) ) { - $('.change-notification', this.wrap).fadeOut(); - } -}; - -Panel.prototype.otherPanelChanged = function(other) { - $.log('Panel ', this, ' is aware that ', other, ' changed.'); - if(!this.callHook('dirty')) { - $('.change-notification', this.wrap).fadeIn(); - } -}; - -Panel.prototype.markChanged = function () { - this.wrap.addClass('changed'); -}; - -Panel.prototype.changed = function () { - return this.wrap.hasClass('changed'); -}; - -Panel.prototype.unmarkChanged = function () { - this.wrap.removeClass('changed'); -}; - -Panel.prototype.saveInfo = function() { - var saveInfo = {}; - this.callHook('saveInfo', null, saveInfo); - return saveInfo; -}; - -Panel.prototype.connectToolbar = function() -{ - var self = this; - self.hotkeys = []; - - // check if there is a one - var toolbar = $("div.toolbar", this.contentDiv); - // $.log('Connecting toolbar', toolbar); - if(toolbar.length === 0) return; - - // move the extra - var extra_buttons = $('span.panel-toolbar-extra button', toolbar); - var placeholder = $('div.panel-toolbar span.panel-toolbar-extra > span', this.wrap); - placeholder.replaceWith(extra_buttons); - - // connect group-switch buttons - var group_buttons = $('*.toolbar-tabs-container button', toolbar); - - // $.log('Found groups:', group_buttons); - - group_buttons.each(function() { - var group = $(this); - var group_name = group.attr('ui:group'); - // $.log('Connecting group: ' + group_name); - - group.click(function() { - // change the active group - var active = $("*.toolbar-tabs-container button.active", toolbar); - if (active != group) { - active.removeClass('active'); - group.addClass('active'); - $(".toolbar-button-groups-container p", toolbar).each(function() { - if ( $(this).attr('ui:group') != group_name) { - $(this).hide(); - } else { - $(this).show(); - } - }); - self.callHook('toolbarResized'); - } - }); - }); - - // connect action buttons - var allbuttons = $.makeArray(extra_buttons); - $.merge(allbuttons, - $.makeArray($('*.toolbar-button-groups-container button', toolbar)) ); - - $(allbuttons).each(function() { - var button = $(this); - var hk = button.attr('ui:hotkey'); - if(hk) hk = new Hotkey( parseInt(hk) ); - - try { - var params = $.evalJSON(button.attr('ui:action-params')); - } catch(object) { - $.log('JSON exception in ', button, ': ', object); - button.attr('disabled', 'disabled'); - return; - } - - var callback = function() { - editor.callScriptlet(button.attr('ui:action'), self, params); - }; - - // connect button - button.click(callback); - - // connect hotkey - if(hk) { - self.hotkeys[hk.code] = callback; - // $.log('hotkey', hk); - } - - // tooltip - if (button.attr('ui:tooltip') ) - { - var tooltip = button.attr('ui:tooltip'); - if(hk) tooltip += ' ['+hk+']'; - - button.wTooltip({ - delay: 1000, - style: { - border: "1px solid #7F7D67", - opacity: 0.9, - background: "#FBFBC6", - padding: "1px", - fontSize: "12px" - }, - content: tooltip - }); - } - }); -}; - -Panel.prototype.hotkeyPressed = function(event) -{ - var code = event.keyCode; - if(event.altKey) code = code | 0x100; - if(event.ctrlKey) code = code | 0x200; - if(event.shiftKey) code = code | 0x400; - - var callback = this.hotkeys[code]; - if(callback) callback(); -}; - -Panel.prototype.isHotkey = function(event) { - var code = event.keyCode; - if(event.altKey) code = code | 0x100; - if(event.ctrlKey) code = code | 0x200; - if(event.shiftKey) code = code | 0x400; - - $.log(event.character, this.hotkeys[code]); - - if(this.hotkeys[code]) { - return true; - } - return false; -}; - -Panel.prototype.fireEvent = function(name) { - $(document).trigger('panel:'+name, this); -}; - -function Editor() -{ - this.rootDiv = $('#panels'); - this.popupQueue = []; - this.autosaveTimer = null; - this.scriplets = {}; -} - -Editor.prototype.loadConfig = function() { - // Load options from cookie - var defaultOptions = { - panels: [ - { - name: 'htmleditor', - ratio: 0.5 - }, - - { - name: 'gallery', - ratio: 0.5 - } - ], - recentFiles: [], - lastUpdate: 0 - }; - - try { - var cookie = $.cookie('options'); - this.options = $.secureEvalJSON(cookie); - if (!this.options) { - this.options = defaultOptions; - } - } catch (e) { - this.options = defaultOptions; - } - - this.fileOptions = this.options; - var self = this; - - if(!this.options.recentFiles) - this.options.recentFiles = []; - - $.each(this.options.recentFiles, function(index) { - if (fileId == self.options.recentFiles[index].fileId) { - $.log('Found options for', fileId); - self.fileOptions = self.options.recentFiles[index]; - } - }); - - $.log(this.options); - $.log('fileOptions', this.fileOptions); - - this.loadPanelOptions(); - this.savePanelOptions(); -}; - -Editor.prototype.loadPanelOptions = function() { - // var self = this; - // var totalWidth = 0; - // - // $('.panel-wrap', self.rootDiv).each(function(index) { - // var panelWidth = self.fileOptions.panels[index].ratio * self.rootDiv.width(); - // if ($(this).hasClass('last-panel')) { - // $(this).css({ - // left: totalWidth, - // right: 0 - // }); - // } else { - // $(this).css({ - // left: totalWidth, - // width: panelWidth - // }); - // totalWidth += panelWidth; - // } - // $.log('panel:', this, $(this).css('left')); - // $('.panel-toolbar option', this).each(function() { - // if ($(this).attr('p:panel-name') == self.fileOptions.panels[index].name) { - // $(this).parent('select').val($(this).attr('value')); - // } - // }); - // }); -}; - -Editor.prototype.savePanelOptions = function() { - var self = this; - var panels = []; - $('.panel-wrap', self.rootDiv).not('.panel-content-overlay').each(function() { - panels.push({ - name: $('.panel-toolbar option:selected', this).attr('p:panel-name'), - ratio: $(this).width() / self.rootDiv.width() - }); - }); - self.options.panels = panels; - - // Dodaj obecnie oglądany plik do listy recentFiles - var recentFiles = [{fileId: fileId, panels: panels}]; - var count = 1; - $.each(self.options.recentFiles, function(index) { - if (count < 5 && fileId != self.options.recentFiles[index].fileId) { - recentFiles.push(self.options.recentFiles[index]); - count++; - } - }); - self.options.recentFiles = recentFiles; - - self.options.lastUpdate = new Date().getTime() / 1000; - $.log($.toJSON(self.options)); - $.cookie('options', $.toJSON(self.options), { - expires: 7, - path: '/' - }); -}; - -Editor.prototype.saveToBranch = function(msg) -{ - var changed_panel = $('.panel-wrap.changed'); - var self = this; - $.log('Saving to local branch - panel:', changed_panel); - - if(!msg) msg = "Szybki zapis z edytora platformy."; - - if( changed_panel.length === 0) { - $.log('Nothing to save.'); - return true; /* no changes */ - } - - if( changed_panel.length > 1) { - alert('Błąd: więcej niż jeden panel został zmodyfikowany. Nie można zapisać.'); - return false; - } - - var saveInfo = changed_panel.data('ctrl').saveInfo(); - var postData = ''; - - if (saveInfo.postData instanceof Object) { - postData = $.param(saveInfo.postData); - } else { - postData = saveInfo.postData; - } - - postData += '&' + $.param({ - 'commit_message': msg - }); - - self.showPopup('save-waiting', '', -1); - - $.ajax({ - url: saveInfo.url, - dataType: 'json', - success: function(data, textStatus) { - if (data.result != 'ok') { - self.showPopup('save-error', (data.errors && data.errors[0]) || 'Nieznany błąd X_X.'); - } - else { - self.refreshPanels(); - - - if(self.autosaveTimer) { - clearTimeout(self.autosaveTimer); - } - if (data.warnings === null || data.warning === undefined) { - self.showPopup('save-successful'); - } else { - self.showPopup('save-warn', data.warnings[0]); - } - } - - self.advancePopupQueue(); - }, - error: function(rq, tstat, err) { - self.showPopup('save-error', '- bład wewnętrzny serwera.'); - self.advancePopupQueue(); - }, - type: 'POST', - data: postData - }); - - return true; -}; - -Editor.prototype.autoSave = function() -{ - this.autosaveTimer = null; - // first check if there is anything to save - $.log('Autosave'); - this.saveToBranch("Automatyczny zapis z edytora platformy."); -}; - -Editor.prototype.onContentChanged = function(event, data) { - var self = this; - - $('button.provides-save').removeAttr('disabled'); - $('button.requires-save').attr('disabled', 'disabled'); - - if(this.autosaveTimer) return; - this.autosaveTimer = setTimeout( function() { - self.autoSave(); - }, 300000 ); -}; - -Editor.prototype.updateUserBranch = function() { - if($('.panel-wrap.changed').length !== 0) { - alert("There are unsaved changes - can't update."); - } - - var self = this; - $.ajax({ - url: $('#toolbar-button-update').attr('ui:ajax-action'), - dataType: 'json', - success: function(data, textStatus) { - switch(data.result) { - case 'done': - self.showPopup('generic-yes', 'Plik uaktualniony.'); - self.refreshPanels(); - break; - case 'nothing-to-do': - self.showPopup('generic-info', 'Brak zmian do uaktualnienia.'); - break; - default: - self.showPopup('generic-error', data.errors && data.errors[0]); - } - }, - error: function(rq, tstat, err) { - self.showPopup('generic-error', 'Błąd serwera: ' + err); - }, - type: 'POST', - data: {} - }); -}; - -Editor.prototype.sendMergeRequest = function (message) { - if( $('.panel-wrap.changed').length !== 0) { - alert("There are unsaved changes - can't commit."); - } - - var self = this; - - $.ajax({ - url: $('#commit-dialog form').attr('action'), - dataType: 'json', - success: function(data, textStatus) { - switch(data.result) { - case 'done': - self.showPopup('generic-yes', 'Łączenie zmian powiodło się.'); - - if(data.localmodified) { - self.refreshPanels(); - } - - break; - case 'nothing-to-do': - self.showPopup('generic-info', 'Brak zmian do połaczenia.'); - break; - default: - self.showPopup('generic-error', data.errors && data.errors[0]); - } - }, - error: function(rq, tstat, err) { - self.showPopup('generic-error', 'Błąd serwera: ' + err); - }, - type: 'POST', - data: { - 'message': message - } - }); -}; - -Editor.prototype.postSplitRequest = function(s, f) -{ - $.ajax({ - url: $('#split-dialog form').attr('action'), - dataType: 'html', - success: s, - error: f, - type: 'POST', - data: $('#split-dialog form').serialize() - }); -}; - - -Editor.prototype.allPanels = function() { - return $('#' + this.rootDiv.attr('id') +' > *.panel-wrap', this.rootDiv.parent()); -}; - -Editor.prototype.registerScriptlet = function(scriptlet_id, scriptlet_func) -{ - // I briefly assume, that it's verified not to break the world on SS - if (!this[scriptlet_id]) { - this[scriptlet_id] = scriptlet_func; - } -}; - -Editor.prototype.callScriptlet = function(scriptlet_id, panel, params) { - var func = this[scriptlet_id]; - if(!func) { - throw 'No scriptlet named "' + scriptlet_id + '" found.'; - } - return func(this, panel, params); -}; - -$(function() { - $.fbind = function (self, func) { - return function() { - return func.apply(self, arguments); - }; - }; - - editor = new Editor(); - - // do the layout - editor.loadConfig(); - editor.setupUI(); -}); diff --git a/project/static/js/lib/codemirror/codemirror.js b/project/static/js/lib/codemirror/codemirror.js deleted file mode 100644 index f63ed07e..00000000 --- a/project/static/js/lib/codemirror/codemirror.js +++ /dev/null @@ -1,309 +0,0 @@ -/* CodeMirror main module - * - * Implements the CodeMirror constructor and prototype, which take care - * of initializing the editor frame, and providing the outside interface. - */ - -// The CodeMirrorConfig object is used to specify a default -// configuration. If you specify such an object before loading this -// file, the values you put into it will override the defaults given -// below. You can also assign to it after loading. -var CodeMirrorConfig = window.CodeMirrorConfig || {}; - -var CodeMirror = (function(){ - function setDefaults(object, defaults) { - for (var option in defaults) { - if (!object.hasOwnProperty(option)) - object[option] = defaults[option]; - } - } - function forEach(array, action) { - for (var i = 0; i < array.length; i++) - action(array[i]); - } - - // These default options can be overridden by passing a set of - // options to a specific CodeMirror constructor. See manual.html for - // their meaning. - setDefaults(CodeMirrorConfig, { - stylesheet: "", - path: "", - parserfile: [], - basefiles: ["util.js", "stringstream.js", "select.js", "undo.js", "editor.js", "tokenize.js"], - iframeClass: null, - passDelay: 200, - passTime: 50, - continuousScanning: false, - saveFunction: null, - onChange: null, - undoDepth: 50, - undoDelay: 800, - disableSpellcheck: true, - textWrapping: true, - readOnly: false, - width: "100%", - height: "300px", - autoMatchParens: false, - parserConfig: null, - tabMode: "indent", // or "spaces", "default", "shift" - reindentOnLoad: false, - activeTokens: null, - cursorActivity: null, - lineNumbers: false, - indentUnit: 2 - }); - - function wrapLineNumberDiv(place) { - return function(node) { - var container = document.createElement("DIV"), - nums = document.createElement("DIV"), - scroller = document.createElement("DIV"); - container.style.position = "relative"; - nums.style.position = "absolute"; - nums.style.height = "100%"; - if (nums.style.setExpression) { - try {nums.style.setExpression("height", "this.previousSibling.offsetHeight + 'px'");} - catch(e) {} // Seems to throw 'Not Implemented' on some IE8 versions - } - nums.style.top = "0px"; - nums.style.overflow = "hidden"; - place(container); - container.appendChild(node); - container.appendChild(nums); - scroller.className = "CodeMirror-line-numbers"; - nums.appendChild(scroller); - } - } - - function applyLineNumbers(frame) { - var win = frame.contentWindow, doc = win.document, - nums = frame.nextSibling, scroller = nums.firstChild; - - var nextNum = 1, barWidth = null; - function sizeBar() { - for (var root = frame; root.parentNode; root = root.parentNode); - if (root != document || !win.Editor) { - clearInterval(sizeInterval); - return; - } - - if (nums.offsetWidth != barWidth) { - barWidth = nums.offsetWidth; - nums.style.left = "-" + (frame.parentNode.style.marginLeft = barWidth + "px"); - } - } - function update() { - var diff = 20 + Math.max(doc.body.offsetHeight, frame.offsetHeight) - scroller.offsetHeight; - for (var n = Math.ceil(diff / 10); n > 0; n--) { - var div = document.createElement("DIV"); - div.appendChild(document.createTextNode(nextNum++)); - scroller.appendChild(div); - } - nums.scrollTop = doc.body.scrollTop || doc.documentElement.scrollTop || 0; - } - sizeBar(); - update(); - win.addEventHandler(win, "scroll", update); - win.addEventHandler(win, "resize", update); - var sizeInterval = setInterval(sizeBar, 500); - } - - function CodeMirror(place, options) { - // Backward compatibility for deprecated options. - if (options.dumbTabs) options.tabMode = "spaces"; - else if (options.normalTab) options.tabMode = "default"; - - // Use passed options, if any, to override defaults. - this.options = options = options || {}; - setDefaults(options, CodeMirrorConfig); - - var frame = this.frame = document.createElement("IFRAME"); - if (options.iframeClass) frame.className = options.iframeClass; - frame.frameBorder = 0; - frame.src = "javascript:false;"; - frame.style.border = "0"; - frame.style.width = options.width; - frame.style.height = options.height; - // display: block occasionally suppresses some Firefox bugs, so we - // always add it, redundant as it sounds. - frame.style.display = "block"; - - if (place.appendChild) { - var node = place; - place = function(n){node.appendChild(n);}; - } - - if (options.lineNumbers) place = wrapLineNumberDiv(place); - place(frame); - - // Link back to this object, so that the editor can fetch options - // and add a reference to itself. - frame.CodeMirror = this; - this.win = frame.contentWindow; - - if (typeof options.parserfile == "string") - options.parserfile = [options.parserfile]; - if (typeof options.stylesheet == "string") - options.stylesheet = [options.stylesheet]; - - var html = [""]; - // Hack to work around a bunch of IE8-specific problems. - html.push(""); - forEach(options.stylesheet, function(file) { - html.push(""); - }); - forEach(options.basefiles.concat(options.parserfile), function(file) { - html.push(""); - }); - html.push(""); - - var doc = this.win.document; - doc.open(); - doc.write(html.join("")); - doc.close(); - } - - CodeMirror.prototype = { - init: function() { - if (this.options.initCallback) this.options.initCallback(this); - if (this.options.lineNumbers) applyLineNumbers(this.frame); - if (this.options.reindentOnLoad) this.reindent(); - }, - - getCode: function() {return this.editor.getCode();}, - setCode: function(code) {this.editor.importCode(code);}, - selection: function() {this.focusIfIE(); return this.editor.selectedText();}, - reindent: function() {this.editor.reindent();}, - reindentSelection: function() {this.focusIfIE(); this.editor.reindentSelection(null);}, - - focusIfIE: function() { - // in IE, a lot of selection-related functionality only works when the frame is focused - if (this.win.select.ie_selection) this.focus(); - }, - focus: function() { - this.win.focus(); - if (this.editor.selectionSnapshot) // IE hack - this.win.select.selectCoords(this.win, this.editor.selectionSnapshot); - }, - replaceSelection: function(text) { - this.focus(); - this.editor.replaceSelection(text); - return true; - }, - replaceChars: function(text, start, end) { - this.editor.replaceChars(text, start, end); - }, - getSearchCursor: function(string, fromCursor) { - return this.editor.getSearchCursor(string, fromCursor); - }, - - undo: function() {this.editor.history.undo();}, - redo: function() {this.editor.history.redo();}, - historySize: function() {return this.editor.history.historySize();}, - clearHistory: function() {this.editor.history.clear();}, - - grabKeys: function(callback, filter) {this.editor.grabKeys(callback, filter);}, - ungrabKeys: function() {this.editor.ungrabKeys();}, - - setParser: function(name) {this.editor.setParser(name);}, - - cursorPosition: function(start) {this.focusIfIE(); return this.editor.cursorPosition(start);}, - firstLine: function() {return this.editor.firstLine();}, - lastLine: function() {return this.editor.lastLine();}, - nextLine: function(line) {return this.editor.nextLine(line);}, - prevLine: function(line) {return this.editor.prevLine(line);}, - lineContent: function(line) {return this.editor.lineContent(line);}, - setLineContent: function(line, content) {this.editor.setLineContent(line, content);}, - insertIntoLine: function(line, position, content) {this.editor.insertIntoLine(line, position, content);}, - selectLines: function(startLine, startOffset, endLine, endOffset) { - this.win.focus(); - this.editor.selectLines(startLine, startOffset, endLine, endOffset); - }, - nthLine: function(n) { - var line = this.firstLine(); - for (; n > 1 && line !== false; n--) - line = this.nextLine(line); - return line; - }, - lineNumber: function(line) { - var num = 0; - while (line !== false) { - num++; - line = this.prevLine(line); - } - return num; - }, - - // Old number-based line interface - jumpToLine: function(n) { - this.selectLines(this.nthLine(n), 0); - this.win.focus(); - }, - currentLine: function() { - return this.lineNumber(this.cursorPosition().line); - } - }; - - CodeMirror.InvalidLineHandle = {toString: function(){return "CodeMirror.InvalidLineHandle";}}; - - CodeMirror.replace = function(element) { - if (typeof element == "string") - element = document.getElementById(element); - return function(newElement) { - element.parentNode.replaceChild(newElement, element); - }; - }; - - CodeMirror.fromTextArea = function(area, options) { - if (typeof area == "string") - area = document.getElementById(area); - - options = options || {}; - if (area.style.width && options.width == null) - options.width = area.style.width; - if (area.style.height && options.height == null) - options.height = area.style.height; - if (options.content == null) options.content = area.value; - - if (area.form) { - function updateField() { - area.value = mirror.getCode(); - } - if (typeof area.form.addEventListener == "function") - area.form.addEventListener("submit", updateField, false); - else - area.form.attachEvent("onsubmit", updateField); - } - - function insert(frame) { - if (area.nextSibling) - area.parentNode.insertBefore(frame, area.nextSibling); - else - area.parentNode.appendChild(frame); - } - - area.style.display = "none"; - var mirror = new CodeMirror(insert, options); - return mirror; - }; - - CodeMirror.isProbablySupported = function() { - // This is rather awful, but can be useful. - var match; - if (window.opera) - return Number(window.opera.version()) >= 9.52; - else if (/Apple Computers, Inc/.test(navigator.vendor) && (match = navigator.userAgent.match(/Version\/(\d+(?:\.\d+)?)\./))) - return Number(match[1]) >= 3; - else if (document.selection && window.ActiveXObject && (match = navigator.userAgent.match(/MSIE (\d+(?:\.\d*)?)\b/))) - return Number(match[1]) >= 6; - else if (match = navigator.userAgent.match(/gecko\/(\d{8})/i)) - return Number(match[1]) >= 20050901; - else if (match = navigator.userAgent.match(/AppleWebKit\/(\d+)/)) - return Number(match[1]) >= 525; - else - return null; - }; - - return CodeMirror; -})(); diff --git a/project/static/js/lib/codemirror/editor.js b/project/static/js/lib/codemirror/editor.js deleted file mode 100644 index 3d7a2053..00000000 --- a/project/static/js/lib/codemirror/editor.js +++ /dev/null @@ -1,1314 +0,0 @@ -/* The Editor object manages the content of the editable frame. It - * catches events, colours nodes, and indents lines. This file also - * holds some functions for transforming arbitrary DOM structures into - * plain sequences of and
    elements - */ - -// Make sure a string does not contain two consecutive 'collapseable' -// whitespace characters. -function makeWhiteSpace(n) { - var buffer = [], nb = true; - for (; n > 0; n--) { - buffer.push((nb || n == 1) ? nbsp : " "); - nb = !nb; - } - return buffer.join(""); -} - -// Create a set of white-space characters that will not be collapsed -// by the browser, but will not break text-wrapping either. -function fixSpaces(string) { - if (string.charAt(0) == " ") string = nbsp + string.slice(1); - return string.replace(/\t/g, function(){return makeWhiteSpace(indentUnit);}) - .replace(/[ \u00a0]{2,}/g, function(s) {return makeWhiteSpace(s.length);}); -} - -function cleanText(text) { - return text.replace(/\u00a0/g, " ").replace(/\u200b/g, ""); -} - -// Create a SPAN node with the expected properties for document part -// spans. -function makePartSpan(value, doc) { - var text = value; - if (value.nodeType == 3) text = value.nodeValue; - else value = doc.createTextNode(text); - - var span = doc.createElement("SPAN"); - span.isPart = true; - span.appendChild(value); - span.currentText = text; - return span; -} - -// On webkit, when the last BR of the document does not have text -// behind it, the cursor can not be put on the line after it. This -// makes pressing enter at the end of the document occasionally do -// nothing (or at least seem to do nothing). To work around it, this -// function makes sure the document ends with a span containing a -// zero-width space character. The traverseDOM iterator filters such -// character out again, so that the parsers won't see them. This -// function is called from a few strategic places to make sure the -// zwsp is restored after the highlighting process eats it. -var webkitLastLineHack = webkit ? - function(container) { - var last = container.lastChild; - if (!last || !last.isPart || last.textContent != "\u200b") - container.appendChild(makePartSpan("\u200b", container.ownerDocument)); - } : function() {}; - -var Editor = (function(){ - // The HTML elements whose content should be suffixed by a newline - // when converting them to flat text. - var newlineElements = {"P": true, "DIV": true, "LI": true}; - - function asEditorLines(string) { - var tab = makeWhiteSpace(indentUnit); - return map(string.replace(/\t/g, tab).replace(/\u00a0/g, " ").replace(/\r\n?/g, "\n").split("\n"), fixSpaces); - } - - // Helper function for traverseDOM. Flattens an arbitrary DOM node - // into an array of textnodes and
    tags. - function simplifyDOM(root, atEnd) { - var doc = root.ownerDocument; - var result = []; - var leaving = true; - - function simplifyNode(node, top) { - if (node.nodeType == 3) { - var text = node.nodeValue = fixSpaces(node.nodeValue.replace(/[\r\u200b]/g, "").replace(/\n/g, " ")); - if (text.length) leaving = false; - result.push(node); - } - else if (isBR(node) && node.childNodes.length == 0) { - leaving = true; - result.push(node); - } - else { - forEach(node.childNodes, simplifyNode); - if (!leaving && newlineElements.hasOwnProperty(node.nodeName.toUpperCase())) { - leaving = true; - if (!atEnd || !top) - result.push(doc.createElement("BR")); - } - } - } - - simplifyNode(root, true); - return result; - } - - // Creates a MochiKit-style iterator that goes over a series of DOM - // nodes. The values it yields are strings, the textual content of - // the nodes. It makes sure that all nodes up to and including the - // one whose text is being yielded have been 'normalized' to be just - // and
    elements. - // See the story.html file for some short remarks about the use of - // continuation-passing style in this iterator. - function traverseDOM(start){ - function yield(value, c){cc = c; return value;} - function push(fun, arg, c){return function(){return fun(arg, c);};} - function stop(){cc = stop; throw StopIteration;}; - var cc = push(scanNode, start, stop); - var owner = start.ownerDocument; - var nodeQueue = []; - - // Create a function that can be used to insert nodes after the - // one given as argument. - function pointAt(node){ - var parent = node.parentNode; - var next = node.nextSibling; - return function(newnode) { - parent.insertBefore(newnode, next); - }; - } - var point = null; - - // Insert a normalized node at the current point. If it is a text - // node, wrap it in a , and give that span a currentText - // property -- this is used to cache the nodeValue, because - // directly accessing nodeValue is horribly slow on some browsers. - // The dirty property is used by the highlighter to determine - // which parts of the document have to be re-highlighted. - function insertPart(part){ - var text = "\n"; - if (part.nodeType == 3) { - select.snapshotChanged(); - part = makePartSpan(part, owner); - text = part.currentText; - } - part.dirty = true; - nodeQueue.push(part); - point(part); - return text; - } - - // Extract the text and newlines from a DOM node, insert them into - // the document, and yield the textual content. Used to replace - // non-normalized nodes. - function writeNode(node, c, end) { - var toYield = []; - forEach(simplifyDOM(node, end), function(part) { - toYield.push(insertPart(part)); - }); - return yield(toYield.join(""), c); - } - - // Check whether a node is a normalized element. - function partNode(node){ - if (node.isPart && node.childNodes.length == 1 && node.firstChild.nodeType == 3) { - node.currentText = node.firstChild.nodeValue; - return !/[\n\t\r]/.test(node.currentText); - } - return false; - } - - // Handle a node. Add its successor to the continuation if there - // is one, find out whether the node is normalized. If it is, - // yield its content, otherwise, normalize it (writeNode will take - // care of yielding). - function scanNode(node, c){ - if (node.nextSibling) - c = push(scanNode, node.nextSibling, c); - - if (partNode(node)){ - nodeQueue.push(node); - return yield(node.currentText, c); - } - else if (isBR(node)) { - nodeQueue.push(node); - return yield("\n", c); - } - else { - var end = !node.nextSibling; - point = pointAt(node); - removeElement(node); - return writeNode(node, c, end); - } - } - - // MochiKit iterators are objects with a next function that - // returns the next value or throws StopIteration when there are - // no more values. - return {next: function(){return cc();}, nodes: nodeQueue}; - } - - // Determine the text size of a processed node. - function nodeSize(node) { - return isBR(node) ? 1 : node.currentText.length; - } - - // Search backwards through the top-level nodes until the next BR or - // the start of the frame. - function startOfLine(node) { - while (node && !isBR(node)) node = node.previousSibling; - return node; - } - function endOfLine(node, container) { - if (!node) node = container.firstChild; - else if (isBR(node)) node = node.nextSibling; - - while (node && !isBR(node)) node = node.nextSibling; - return node; - } - - function time() {return new Date().getTime();} - - // Client interface for searching the content of the editor. Create - // these by calling CodeMirror.getSearchCursor. To use, call - // findNext on the resulting object -- this returns a boolean - // indicating whether anything was found, and can be called again to - // skip to the next find. Use the select and replace methods to - // actually do something with the found locations. - function SearchCursor(editor, string, fromCursor) { - this.editor = editor; - this.history = editor.history; - this.history.commit(); - - // Are we currently at an occurrence of the search string? - this.atOccurrence = false; - // The object stores a set of nodes coming after its current - // position, so that when the current point is taken out of the - // DOM tree, we can still try to continue. - this.fallbackSize = 15; - var cursor; - // Start from the cursor when specified and a cursor can be found. - if (fromCursor && (cursor = select.cursorPos(this.editor.container))) { - this.line = cursor.node; - this.offset = cursor.offset; - } - else { - this.line = null; - this.offset = 0; - } - this.valid = !!string; - - // Create a matcher function based on the kind of string we have. - var target = string.split("\n"), self = this; - this.matches = (target.length == 1) ? - // For one-line strings, searching can be done simply by calling - // indexOf on the current line. - function() { - var match = cleanText(self.history.textAfter(self.line).slice(self.offset)).indexOf(string); - if (match > -1) - return {from: {node: self.line, offset: self.offset + match}, - to: {node: self.line, offset: self.offset + match + string.length}}; - } : - // Multi-line strings require internal iteration over lines, and - // some clunky checks to make sure the first match ends at the - // end of the line and the last match starts at the start. - function() { - var firstLine = cleanText(self.history.textAfter(self.line).slice(self.offset)); - var match = firstLine.lastIndexOf(target[0]); - if (match == -1 || match != firstLine.length - target[0].length) - return false; - var startOffset = self.offset + match; - - var line = self.history.nodeAfter(self.line); - for (var i = 1; i < target.length - 1; i++) { - if (cleanText(self.history.textAfter(line)) != target[i]) - return false; - line = self.history.nodeAfter(line); - } - - if (cleanText(self.history.textAfter(line)).indexOf(target[target.length - 1]) != 0) - return false; - - return {from: {node: self.line, offset: startOffset}, - to: {node: line, offset: target[target.length - 1].length}}; - }; - } - - SearchCursor.prototype = { - findNext: function() { - if (!this.valid) return false; - this.atOccurrence = false; - var self = this; - - // Go back to the start of the document if the current line is - // no longer in the DOM tree. - if (this.line && !this.line.parentNode) { - this.line = null; - this.offset = 0; - } - - // Set the cursor's position one character after the given - // position. - function saveAfter(pos) { - if (self.history.textAfter(pos.node).length > pos.offset) { - self.line = pos.node; - self.offset = pos.offset + 1; - } - else { - self.line = self.history.nodeAfter(pos.node); - self.offset = 0; - } - } - - while (true) { - var match = this.matches(); - // Found the search string. - if (match) { - this.atOccurrence = match; - saveAfter(match.from); - return true; - } - this.line = this.history.nodeAfter(this.line); - this.offset = 0; - // End of document. - if (!this.line) { - this.valid = false; - return false; - } - } - }, - - select: function() { - if (this.atOccurrence) { - select.setCursorPos(this.editor.container, this.atOccurrence.from, this.atOccurrence.to); - select.scrollToCursor(this.editor.container); - } - }, - - replace: function(string) { - if (this.atOccurrence) { - var end = this.editor.replaceRange(this.atOccurrence.from, this.atOccurrence.to, string); - this.line = end.node; - this.offset = end.offset; - this.atOccurrence = false; - } - } - }; - - // The Editor object is the main inside-the-iframe interface. - function Editor(options) { - this.options = options; - window.indentUnit = options.indentUnit; - this.parent = parent; - this.doc = document; - var container = this.container = this.doc.body; - this.win = window; - this.history = new History(container, options.undoDepth, options.undoDelay, - this, options.onChange); - var self = this; - - if (!Editor.Parser) - throw "No parser loaded."; - if (options.parserConfig && Editor.Parser.configure) - Editor.Parser.configure(options.parserConfig); - - if (!options.readOnly) - select.setCursorPos(container, {node: null, offset: 0}); - - this.dirty = []; - if (options.content) - this.importCode(options.content); - - if (!options.readOnly) { - if (options.continuousScanning !== false) { - this.scanner = this.documentScanner(options.passTime); - this.delayScanning(); - } - - function setEditable() { - // In IE, designMode frames can not run any scripts, so we use - // contentEditable instead. - if (document.body.contentEditable != undefined && internetExplorer) - document.body.contentEditable = "true"; - else - document.designMode = "on"; - - document.documentElement.style.borderWidth = "0"; - if (!options.textWrapping) - container.style.whiteSpace = "nowrap"; - } - - // If setting the frame editable fails, try again when the user - // focus it (happens when the frame is not visible on - // initialisation, in Firefox). - try { - setEditable(); - } - catch(e) { - var focusEvent = addEventHandler(document, "focus", function() { - focusEvent(); - setEditable(); - }, true); - } - - addEventHandler(document, "keydown", method(this, "keyDown")); - addEventHandler(document, "keypress", method(this, "keyPress")); - addEventHandler(document, "keyup", method(this, "keyUp")); - - function cursorActivity() {self.cursorActivity(false);} - addEventHandler(document.body, "mouseup", cursorActivity); - addEventHandler(document.body, "cut", cursorActivity); - - addEventHandler(document.body, "paste", function(event) { - cursorActivity(); - var text = null; - try { - var clipboardData = event.clipboardData || window.clipboardData; - if (clipboardData) text = clipboardData.getData('Text'); - } - catch(e) {} - if (text !== null) { - self.replaceSelection(text); - event.stop(); - } - }); - - addEventHandler(document.body, "beforepaste", method(this, "reroutePasteEvent")); - - if (this.options.autoMatchParens) - addEventHandler(document.body, "click", method(this, "scheduleParenBlink")); - } - else if (!options.textWrapping) { - container.style.whiteSpace = "nowrap"; - } - } - - function isSafeKey(code) { - return (code >= 16 && code <= 18) || // shift, control, alt - (code >= 33 && code <= 40); // arrows, home, end - } - - Editor.prototype = { - // Import a piece of code into the editor. - importCode: function(code) { - this.history.push(null, null, asEditorLines(code)); - this.history.reset(); - }, - - // Extract the code from the editor. - getCode: function() { - if (!this.container.firstChild) - return ""; - - var accum = []; - select.markSelection(this.win); - forEach(traverseDOM(this.container.firstChild), method(accum, "push")); - webkitLastLineHack(this.container); - select.selectMarked(); - return cleanText(accum.join("")); - }, - - checkLine: function(node) { - if (node === false || !(node == null || node.parentNode == this.container)) - throw parent.CodeMirror.InvalidLineHandle; - }, - - cursorPosition: function(start) { - if (start == null) start = true; - var pos = select.cursorPos(this.container, start); - if (pos) return {line: pos.node, character: pos.offset}; - else return {line: null, character: 0}; - }, - - firstLine: function() { - return null; - }, - - lastLine: function() { - if (this.container.lastChild) return startOfLine(this.container.lastChild); - else return null; - }, - - nextLine: function(line) { - this.checkLine(line); - var end = endOfLine(line, this.container); - return end || false; - }, - - prevLine: function(line) { - this.checkLine(line); - if (line == null) return false; - return startOfLine(line.previousSibling); - }, - - selectLines: function(startLine, startOffset, endLine, endOffset) { - this.checkLine(startLine); - var start = {node: startLine, offset: startOffset}, end = null; - if (endOffset !== undefined) { - this.checkLine(endLine); - end = {node: endLine, offset: endOffset}; - } - select.setCursorPos(this.container, start, end); - select.scrollToCursor(this.container); - }, - - lineContent: function(line) { - this.checkLine(line); - var accum = []; - for (line = line ? line.nextSibling : this.container.firstChild; - line && !isBR(line); line = line.nextSibling) - accum.push(nodeText(line)); - return cleanText(accum.join("")); - }, - - setLineContent: function(line, content) { - this.history.commit(); - this.replaceRange({node: line, offset: 0}, - {node: line, offset: this.history.textAfter(line).length}, - content); - this.addDirtyNode(line); - this.scheduleHighlight(); - }, - - insertIntoLine: function(line, position, content) { - var before = null; - if (position == "end") { - before = endOfLine(line, this.container); - } - else { - for (var cur = line ? line.nextSibling : this.container.firstChild; cur; cur = cur.nextSibling) { - if (position == 0) { - before = cur; - break; - } - var text = nodeText(cur); - if (text.length > position) { - before = cur.nextSibling; - content = text.slice(0, position) + content + text.slice(position); - removeElement(cur); - break; - } - position -= text.length; - } - } - - var lines = asEditorLines(content), doc = this.container.ownerDocument; - for (var i = 0; i < lines.length; i++) { - if (i > 0) this.container.insertBefore(doc.createElement("BR"), before); - this.container.insertBefore(makePartSpan(lines[i], doc), before); - } - this.addDirtyNode(line); - this.scheduleHighlight(); - }, - - // Retrieve the selected text. - selectedText: function() { - var h = this.history; - h.commit(); - - var start = select.cursorPos(this.container, true), - end = select.cursorPos(this.container, false); - if (!start || !end) return ""; - - if (start.node == end.node) - return h.textAfter(start.node).slice(start.offset, end.offset); - - var text = [h.textAfter(start.node).slice(start.offset)]; - for (var pos = h.nodeAfter(start.node); pos != end.node; pos = h.nodeAfter(pos)) - text.push(h.textAfter(pos)); - text.push(h.textAfter(end.node).slice(0, end.offset)); - return cleanText(text.join("\n")); - }, - - // Replace the selection with another piece of text. - replaceSelection: function(text) { - this.history.commit(); - - var start = select.cursorPos(this.container, true), - end = select.cursorPos(this.container, false); - if (!start || !end) return; - - end = this.replaceRange(start, end, text); - select.setCursorPos(this.container, end); - webkitLastLineHack(this.container); - }, - - reroutePasteEvent: function() { - if (this.capturingPaste || window.opera) return; - this.capturingPaste = true; - var te = parent.document.createElement("TEXTAREA"); - te.style.position = "absolute"; - te.style.left = "-500px"; - te.style.width = "10px"; - te.style.top = nodeTop(frameElement) + "px"; - parent.document.body.appendChild(te); - parent.focus(); - te.focus(); - - var self = this; - this.parent.setTimeout(function() { - self.capturingPaste = false; - self.win.focus(); - if (self.selectionSnapshot) // IE hack - self.win.select.selectCoords(self.win, self.selectionSnapshot); - var text = te.value; - if (text) self.replaceSelection(text); - removeElement(te); - }, 10); - }, - - replaceRange: function(from, to, text) { - var lines = asEditorLines(text); - lines[0] = this.history.textAfter(from.node).slice(0, from.offset) + lines[0]; - var lastLine = lines[lines.length - 1]; - lines[lines.length - 1] = lastLine + this.history.textAfter(to.node).slice(to.offset); - var end = this.history.nodeAfter(to.node); - this.history.push(from.node, end, lines); - return {node: this.history.nodeBefore(end), - offset: lastLine.length}; - }, - - getSearchCursor: function(string, fromCursor) { - return new SearchCursor(this, string, fromCursor); - }, - - // Re-indent the whole buffer - reindent: function() { - if (this.container.firstChild) - this.indentRegion(null, this.container.lastChild); - }, - - reindentSelection: function(direction) { - if (!select.somethingSelected(this.win)) { - this.indentAtCursor(direction); - } - else { - var start = select.selectionTopNode(this.container, true), - end = select.selectionTopNode(this.container, false); - if (start === false || end === false) return; - this.indentRegion(start, end, direction); - } - }, - - grabKeys: function(eventHandler, filter) { - this.frozen = eventHandler; - this.keyFilter = filter; - }, - ungrabKeys: function() { - this.frozen = "leave"; - this.keyFilter = null; - }, - - setParser: function(name) { - Editor.Parser = window[name]; - if (this.container.firstChild) { - forEach(this.container.childNodes, function(n) { - if (n.nodeType != 3) n.dirty = true; - }); - this.addDirtyNode(this.firstChild); - this.scheduleHighlight(); - } - }, - - // Intercept enter and tab, and assign their new functions. - keyDown: function(event) { - if (this.frozen == "leave") this.frozen = null; - if (this.frozen && (!this.keyFilter || this.keyFilter(event))) { - event.stop(); - this.frozen(event); - return; - } - - var code = event.keyCode; - // Don't scan when the user is typing. - this.delayScanning(); - // Schedule a paren-highlight event, if configured. - if (this.options.autoMatchParens) - this.scheduleParenBlink(); - - // The various checks for !altKey are there because AltGr sets both - // ctrlKey and altKey to true, and should not be recognised as - // Control. - if (code == 13) { // enter - if (event.ctrlKey && !event.altKey) { - this.reparseBuffer(); - } - else { - select.insertNewlineAtCursor(this.win); - this.indentAtCursor(); - select.scrollToCursor(this.container); - } - event.stop(); - } - else if (code == 9 && this.options.tabMode != "default") { // tab - this.handleTab(!event.ctrlKey && !event.shiftKey); - event.stop(); - } - else if (code == 32 && event.shiftKey && this.options.tabMode == "default") { // space - this.handleTab(true); - event.stop(); - } - else if (code == 36 && !event.shiftKey && !event.ctrlKey) { // home - if (this.home()) - event.stop(); - } - else if ((code == 219 || code == 221) && event.ctrlKey && !event.altKey) { // [, ] - this.blinkParens(event.shiftKey); - event.stop(); - } - else if (event.metaKey && !event.shiftKey && (code == 37 || code == 39)) { // Meta-left/right - var cursor = select.selectionTopNode(this.container); - if (cursor === false || !this.container.firstChild) return; - - if (code == 37) select.focusAfterNode(startOfLine(cursor), this.container); - else { - var end = endOfLine(cursor, this.container); - select.focusAfterNode(end ? end.previousSibling : this.container.lastChild, this.container); - } - event.stop(); - } - else if ((event.ctrlKey || event.metaKey) && !event.altKey) { - if ((event.shiftKey && code == 90) || code == 89) { // shift-Z, Y - select.scrollToNode(this.history.redo()); - event.stop(); - } - else if (code == 90 || (safari && code == 8)) { // Z, backspace - select.scrollToNode(this.history.undo()); - event.stop(); - } - else if (code == 83 && this.options.saveFunction) { // S - this.options.saveFunction(); - event.stop(); - } - } - }, - - // Check for characters that should re-indent the current line, - // and prevent Opera from handling enter and tab anyway. - keyPress: function(event) { - var electric = Editor.Parser.electricChars, self = this; - // Hack for Opera, and Firefox on OS X, in which stopping a - // keydown event does not prevent the associated keypress event - // from happening, so we have to cancel enter and tab again - // here. - if ((this.frozen && (!this.keyFilter || this.keyFilter(event.keyCode))) || - event.code == 13 || (event.code == 9 && this.options.tabMode != "default") || - (event.keyCode == 32 && event.shiftKey && this.options.tabMode == "default")) - event.stop(); - else if (electric && electric.indexOf(event.character) != -1) - this.parent.setTimeout(function(){self.indentAtCursor(null);}, 0); - else if ((event.character == "v" || event.character == "V") - && (event.ctrlKey || event.metaKey) && !event.altKey) // ctrl-V - this.reroutePasteEvent(); - }, - - // Mark the node at the cursor dirty when a non-safe key is - // released. - keyUp: function(event) { - this.cursorActivity(isSafeKey(event.keyCode)); - }, - - // Indent the line following a given
    , or null for the first - // line. If given a
    element, this must have been highlighted - // so that it has an indentation method. Returns the whitespace - // element that has been modified or created (if any). - indentLineAfter: function(start, direction) { - // whiteSpace is the whitespace span at the start of the line, - // or null if there is no such node. - var whiteSpace = start ? start.nextSibling : this.container.firstChild; - if (whiteSpace && !hasClass(whiteSpace, "whitespace")) - whiteSpace = null; - - // Sometimes the start of the line can influence the correct - // indentation, so we retrieve it. - var firstText = whiteSpace ? whiteSpace.nextSibling : (start ? start.nextSibling : this.container.firstChild); - var nextChars = (start && firstText && firstText.currentText) ? firstText.currentText : ""; - - // Ask the lexical context for the correct indentation, and - // compute how much this differs from the current indentation. - var newIndent = 0, curIndent = whiteSpace ? whiteSpace.currentText.length : 0; - if (direction != null && this.options.tabMode == "shift") - newIndent = direction ? curIndent + indentUnit : Math.max(0, curIndent - indentUnit) - else if (start) - newIndent = start.indentation(nextChars, curIndent, direction); - else if (Editor.Parser.firstIndentation) - newIndent = Editor.Parser.firstIndentation(nextChars, curIndent, direction); - var indentDiff = newIndent - curIndent; - - // If there is too much, this is just a matter of shrinking a span. - if (indentDiff < 0) { - if (newIndent == 0) { - if (firstText) select.snapshotMove(whiteSpace.firstChild, firstText.firstChild, 0); - removeElement(whiteSpace); - whiteSpace = null; - } - else { - select.snapshotMove(whiteSpace.firstChild, whiteSpace.firstChild, indentDiff, true); - whiteSpace.currentText = makeWhiteSpace(newIndent); - whiteSpace.firstChild.nodeValue = whiteSpace.currentText; - } - } - // Not enough... - else if (indentDiff > 0) { - // If there is whitespace, we grow it. - if (whiteSpace) { - whiteSpace.currentText = makeWhiteSpace(newIndent); - whiteSpace.firstChild.nodeValue = whiteSpace.currentText; - } - // Otherwise, we have to add a new whitespace node. - else { - whiteSpace = makePartSpan(makeWhiteSpace(newIndent), this.doc); - whiteSpace.className = "whitespace"; - if (start) insertAfter(whiteSpace, start); - else this.container.insertBefore(whiteSpace, this.container.firstChild); - } - if (firstText) select.snapshotMove(firstText.firstChild, whiteSpace.firstChild, curIndent, false, true); - } - if (indentDiff != 0) this.addDirtyNode(start); - return whiteSpace; - }, - - // Re-highlight the selected part of the document. - highlightAtCursor: function() { - var pos = select.selectionTopNode(this.container, true); - var to = select.selectionTopNode(this.container, false); - if (pos === false || to === false) return; - - select.markSelection(this.win); - if (this.highlight(pos, endOfLine(to, this.container), true, 20) === false) - return false; - select.selectMarked(); - return true; - }, - - // When tab is pressed with text selected, the whole selection is - // re-indented, when nothing is selected, the line with the cursor - // is re-indented. - handleTab: function(direction) { - if (this.options.tabMode == "spaces") - select.insertTabAtCursor(this.win); - else - this.reindentSelection(direction); - }, - - home: function() { - var cur = select.selectionTopNode(this.container, true), start = cur; - if (cur === false || !(!cur || cur.isPart || isBR(cur)) || !this.container.firstChild) - return false; - - while (cur && !isBR(cur)) cur = cur.previousSibling; - var next = cur ? cur.nextSibling : this.container.firstChild; - if (next && next != start && next.isPart && hasClass(next, "whitespace")) - select.focusAfterNode(next, this.container); - else - select.focusAfterNode(cur, this.container); - - select.scrollToCursor(this.container); - return true; - }, - - // Delay (or initiate) the next paren blink event. - scheduleParenBlink: function() { - if (this.parenEvent) this.parent.clearTimeout(this.parenEvent); - var self = this; - this.parenEvent = this.parent.setTimeout(function(){self.blinkParens();}, 300); - }, - - // Take the token before the cursor. If it contains a character in - // '()[]{}', search for the matching paren/brace/bracket, and - // highlight them in green for a moment, or red if no proper match - // was found. - blinkParens: function(jump) { - if (!window.select) return; - // Clear the event property. - if (this.parenEvent) this.parent.clearTimeout(this.parenEvent); - this.parenEvent = null; - - // Extract a 'paren' from a piece of text. - function paren(node) { - if (node.currentText) { - var match = node.currentText.match(/^[\s\u00a0]*([\(\)\[\]{}])[\s\u00a0]*$/); - return match && match[1]; - } - } - // Determine the direction a paren is facing. - function forward(ch) { - return /[\(\[\{]/.test(ch); - } - - var ch, self = this, cursor = select.selectionTopNode(this.container, true); - if (!cursor || !this.highlightAtCursor()) return; - cursor = select.selectionTopNode(this.container, true); - if (!(cursor && ((ch = paren(cursor)) || (cursor = cursor.nextSibling) && (ch = paren(cursor))))) - return; - // We only look for tokens with the same className. - var className = cursor.className, dir = forward(ch), match = matching[ch]; - - // Since parts of the document might not have been properly - // highlighted, and it is hard to know in advance which part we - // have to scan, we just try, and when we find dirty nodes we - // abort, parse them, and re-try. - function tryFindMatch() { - var stack = [], ch, ok = true;; - for (var runner = cursor; runner; runner = dir ? runner.nextSibling : runner.previousSibling) { - if (runner.className == className && isSpan(runner) && (ch = paren(runner))) { - if (forward(ch) == dir) - stack.push(ch); - else if (!stack.length) - ok = false; - else if (stack.pop() != matching[ch]) - ok = false; - if (!stack.length) break; - } - else if (runner.dirty || !isSpan(runner) && !isBR(runner)) { - return {node: runner, status: "dirty"}; - } - } - return {node: runner, status: runner && ok}; - } - // Temporarily give the relevant nodes a colour. - function blink(node, ok) { - node.style.fontWeight = "bold"; - node.style.color = ok ? "#8F8" : "#F88"; - self.parent.setTimeout(function() {node.style.fontWeight = ""; node.style.color = "";}, 500); - } - - while (true) { - var found = tryFindMatch(); - if (found.status == "dirty") { - this.highlight(found.node, endOfLine(found.node)); - // Needed because in some corner cases a highlight does not - // reach a node. - found.node.dirty = false; - continue; - } - else { - blink(cursor, found.status); - if (found.node) { - blink(found.node, found.status); - if (jump) select.focusAfterNode(found.node.previousSibling, this.container); - } - break; - } - } - }, - - // Adjust the amount of whitespace at the start of the line that - // the cursor is on so that it is indented properly. - indentAtCursor: function(direction) { - if (!this.container.firstChild) return; - // The line has to have up-to-date lexical information, so we - // highlight it first. - if (!this.highlightAtCursor()) return; - var cursor = select.selectionTopNode(this.container, false); - // If we couldn't determine the place of the cursor, - // there's nothing to indent. - if (cursor === false) - return; - var lineStart = startOfLine(cursor); - var whiteSpace = this.indentLineAfter(lineStart, direction); - if (cursor == lineStart && whiteSpace) - cursor = whiteSpace; - // This means the indentation has probably messed up the cursor. - if (cursor == whiteSpace) - select.focusAfterNode(cursor, this.container); - }, - - // Indent all lines whose start falls inside of the current - // selection. - indentRegion: function(start, end, direction) { - var current = (start = startOfLine(start)), before = start && startOfLine(start.previousSibling); - if (!isBR(end)) end = endOfLine(end, this.container); - - do { - var next = endOfLine(current, this.container); - if (current) this.highlight(before, next, true); - this.indentLineAfter(current, direction); - before = current; - current = next; - } while (current != end); - select.setCursorPos(this.container, {node: start, offset: 0}, {node: end, offset: 0}); - }, - - // Find the node that the cursor is in, mark it as dirty, and make - // sure a highlight pass is scheduled. - cursorActivity: function(safe) { - if (internetExplorer) { - this.container.createTextRange().execCommand("unlink"); - this.selectionSnapshot = select.selectionCoords(this.win); - } - - var activity = this.options.cursorActivity; - if (!safe || activity) { - var cursor = select.selectionTopNode(this.container, false); - if (cursor === false || !this.container.firstChild) return; - cursor = cursor || this.container.firstChild; - if (activity) activity(cursor); - if (!safe) { - this.scheduleHighlight(); - this.addDirtyNode(cursor); - } - } - }, - - reparseBuffer: function() { - forEach(this.container.childNodes, function(node) {node.dirty = true;}); - if (this.container.firstChild) - this.addDirtyNode(this.container.firstChild); - }, - - // Add a node to the set of dirty nodes, if it isn't already in - // there. - addDirtyNode: function(node) { - node = node || this.container.firstChild; - if (!node) return; - - for (var i = 0; i < this.dirty.length; i++) - if (this.dirty[i] == node) return; - - if (node.nodeType != 3) - node.dirty = true; - this.dirty.push(node); - }, - - // Cause a highlight pass to happen in options.passDelay - // milliseconds. Clear the existing timeout, if one exists. This - // way, the passes do not happen while the user is typing, and - // should as unobtrusive as possible. - scheduleHighlight: function() { - // Timeouts are routed through the parent window, because on - // some browsers designMode windows do not fire timeouts. - var self = this; - this.parent.clearTimeout(this.highlightTimeout); - this.highlightTimeout = this.parent.setTimeout(function(){self.highlightDirty();}, this.options.passDelay); - }, - - // Fetch one dirty node, and remove it from the dirty set. - getDirtyNode: function() { - while (this.dirty.length > 0) { - var found = this.dirty.pop(); - // IE8 sometimes throws an unexplainable 'invalid argument' - // exception for found.parentNode - try { - // If the node has been coloured in the meantime, or is no - // longer in the document, it should not be returned. - while (found && found.parentNode != this.container) - found = found.parentNode - if (found && (found.dirty || found.nodeType == 3)) - return found; - } catch (e) {} - } - return null; - }, - - // Pick dirty nodes, and highlight them, until options.passTime - // milliseconds have gone by. The highlight method will continue - // to next lines as long as it finds dirty nodes. It returns - // information about the place where it stopped. If there are - // dirty nodes left after this function has spent all its lines, - // it shedules another highlight to finish the job. - highlightDirty: function(force) { - // Prevent FF from raising an error when it is firing timeouts - // on a page that's no longer loaded. - if (!window.select) return; - - if (!this.options.readOnly) select.markSelection(this.win); - var start, endTime = force ? null : time() + this.options.passTime; - while ((time() < endTime || force) && (start = this.getDirtyNode())) { - var result = this.highlight(start, endTime); - if (result && result.node && result.dirty) - this.addDirtyNode(result.node); - } - if (!this.options.readOnly) select.selectMarked(); - if (start) this.scheduleHighlight(); - return this.dirty.length == 0; - }, - - // Creates a function that, when called through a timeout, will - // continuously re-parse the document. - documentScanner: function(passTime) { - var self = this, pos = null; - return function() { - // FF timeout weirdness workaround. - if (!window.select) return; - // If the current node is no longer in the document... oh - // well, we start over. - if (pos && pos.parentNode != self.container) - pos = null; - select.markSelection(self.win); - var result = self.highlight(pos, time() + passTime, true); - select.selectMarked(); - var newPos = result ? (result.node && result.node.nextSibling) : null; - pos = (pos == newPos) ? null : newPos; - self.delayScanning(); - }; - }, - - // Starts the continuous scanning process for this document after - // a given interval. - delayScanning: function() { - if (this.scanner) { - this.parent.clearTimeout(this.documentScan); - this.documentScan = this.parent.setTimeout(this.scanner, this.options.continuousScanning); - } - }, - - // The function that does the actual highlighting/colouring (with - // help from the parser and the DOM normalizer). Its interface is - // rather overcomplicated, because it is used in different - // situations: ensuring that a certain line is highlighted, or - // highlighting up to X milliseconds starting from a certain - // point. The 'from' argument gives the node at which it should - // start. If this is null, it will start at the beginning of the - // document. When a timestamp is given with the 'target' argument, - // it will stop highlighting at that time. If this argument holds - // a DOM node, it will highlight until it reaches that node. If at - // any time it comes across two 'clean' lines (no dirty nodes), it - // will stop, except when 'cleanLines' is true. maxBacktrack is - // the maximum number of lines to backtrack to find an existing - // parser instance. This is used to give up in situations where a - // highlight would take too long and freeze the browser interface. - highlight: function(from, target, cleanLines, maxBacktrack){ - var container = this.container, self = this, active = this.options.activeTokens; - var endTime = (typeof target == "number" ? target : null); - - if (!container.firstChild) - return; - // Backtrack to the first node before from that has a partial - // parse stored. - while (from && (!from.parserFromHere || from.dirty)) { - if (maxBacktrack != null && isBR(from) && (--maxBacktrack) < 0) - return false; - from = from.previousSibling; - } - // If we are at the end of the document, do nothing. - if (from && !from.nextSibling) - return; - - // Check whether a part ( node) and the corresponding token - // match. - function correctPart(token, part){ - return !part.reduced && part.currentText == token.value && part.className == token.style; - } - // Shorten the text associated with a part by chopping off - // characters from the front. Note that only the currentText - // property gets changed. For efficiency reasons, we leave the - // nodeValue alone -- we set the reduced flag to indicate that - // this part must be replaced. - function shortenPart(part, minus){ - part.currentText = part.currentText.substring(minus); - part.reduced = true; - } - // Create a part corresponding to a given token. - function tokenPart(token){ - var part = makePartSpan(token.value, self.doc); - part.className = token.style; - return part; - } - - function maybeTouch(node) { - if (node) { - var old = node.oldNextSibling; - if (lineDirty || old === undefined || node.nextSibling != old) - self.history.touch(node); - node.oldNextSibling = node.nextSibling; - } - else { - var old = self.container.oldFirstChild; - if (lineDirty || old === undefined || self.container.firstChild != old) - self.history.touch(null); - self.container.oldFirstChild = self.container.firstChild; - } - } - - // Get the token stream. If from is null, we start with a new - // parser from the start of the frame, otherwise a partial parse - // is resumed. - var traversal = traverseDOM(from ? from.nextSibling : container.firstChild), - stream = stringStream(traversal), - parsed = from ? from.parserFromHere(stream) : Editor.Parser.make(stream); - - // parts is an interface to make it possible to 'delay' fetching - // the next DOM node until we are completely done with the one - // before it. This is necessary because often the next node is - // not yet available when we want to proceed past the current - // one. - var parts = { - current: null, - // Fetch current node. - get: function(){ - if (!this.current) - this.current = traversal.nodes.shift(); - return this.current; - }, - // Advance to the next part (do not fetch it yet). - next: function(){ - this.current = null; - }, - // Remove the current part from the DOM tree, and move to the - // next. - remove: function(){ - container.removeChild(this.get()); - this.current = null; - }, - // Advance to the next part that is not empty, discarding empty - // parts. - getNonEmpty: function(){ - var part = this.get(); - // Allow empty nodes when they are alone on a line, needed - // for the FF cursor bug workaround (see select.js, - // insertNewlineAtCursor). - while (part && isSpan(part) && part.currentText == "") { - var old = part; - this.remove(); - part = this.get(); - // Adjust selection information, if any. See select.js for details. - select.snapshotMove(old.firstChild, part && (part.firstChild || part), 0); - } - return part; - } - }; - - var lineDirty = false, prevLineDirty = true, lineNodes = 0; - - // This forEach loops over the tokens from the parsed stream, and - // at the same time uses the parts object to proceed through the - // corresponding DOM nodes. - forEach(parsed, function(token){ - var part = parts.getNonEmpty(); - - if (token.value == "\n"){ - // The idea of the two streams actually staying synchronized - // is such a long shot that we explicitly check. - if (!isBR(part)) - throw "Parser out of sync. Expected BR."; - - if (part.dirty || !part.indentation) lineDirty = true; - maybeTouch(from); - from = part; - - // Every
    gets a copy of the parser state and a lexical - // context assigned to it. The first is used to be able to - // later resume parsing from this point, the second is used - // for indentation. - part.parserFromHere = parsed.copy(); - part.indentation = token.indentation; - part.dirty = false; - - // If the target argument wasn't an integer, go at least - // until that node. - if (endTime == null && part == target) throw StopIteration; - - // A clean line with more than one node means we are done. - // Throwing a StopIteration is the way to break out of a - // MochiKit forEach loop. - if ((endTime != null && time() >= endTime) || (!lineDirty && !prevLineDirty && lineNodes > 1 && !cleanLines)) - throw StopIteration; - prevLineDirty = lineDirty; lineDirty = false; lineNodes = 0; - parts.next(); - } - else { - if (!isSpan(part)) - throw "Parser out of sync. Expected SPAN."; - if (part.dirty) - lineDirty = true; - lineNodes++; - - // If the part matches the token, we can leave it alone. - if (correctPart(token, part)){ - part.dirty = false; - parts.next(); - } - // Otherwise, we have to fix it. - else { - lineDirty = true; - // Insert the correct part. - var newPart = tokenPart(token); - container.insertBefore(newPart, part); - if (active) active(newPart, token, self); - var tokensize = token.value.length; - var offset = 0; - // Eat up parts until the text for this token has been - // removed, adjusting the stored selection info (see - // select.js) in the process. - while (tokensize > 0) { - part = parts.get(); - var partsize = part.currentText.length; - select.snapshotReplaceNode(part.firstChild, newPart.firstChild, tokensize, offset); - if (partsize > tokensize){ - shortenPart(part, tokensize); - tokensize = 0; - } - else { - tokensize -= partsize; - offset += partsize; - parts.remove(); - } - } - } - } - }); - maybeTouch(from); - webkitLastLineHack(this.container); - - // The function returns some status information that is used by - // hightlightDirty to determine whether and where it has to - // continue. - return {node: parts.getNonEmpty(), - dirty: lineDirty}; - } - }; - - return Editor; -})(); - -addEventHandler(window, "load", function() { - var CodeMirror = window.frameElement.CodeMirror; - CodeMirror.editor = new Editor(CodeMirror.options); - this.parent.setTimeout(method(CodeMirror, "init"), 0); -}); diff --git a/project/static/js/lib/codemirror/parsexml.js b/project/static/js/lib/codemirror/parsexml.js deleted file mode 100644 index 95a80993..00000000 --- a/project/static/js/lib/codemirror/parsexml.js +++ /dev/null @@ -1,292 +0,0 @@ -/* This file defines an XML parser, with a few kludges to make it - * useable for HTML. autoSelfClosers defines a set of tag names that - * are expected to not have a closing tag, and doNotIndent specifies - * the tags inside of which no indentation should happen (see Config - * object). These can be disabled by passing the editor an object like - * {useHTMLKludges: false} as parserConfig option. - */ - -var XMLParser = Editor.Parser = (function() { - var Kludges = { - autoSelfClosers: {"br": true, "img": true, "hr": true, "link": true, "input": true, - "meta": true, "col": true, "frame": true, "base": true, "area": true}, - doNotIndent: {"pre": true, "!cdata": true} - }; - var NoKludges = {autoSelfClosers: {}, doNotIndent: {"!cdata": true}}; - var UseKludges = Kludges; - var alignCDATA = false; - - // Simple stateful tokenizer for XML documents. Returns a - // MochiKit-style iterator, with a state property that contains a - // function encapsulating the current state. See tokenize.js. - var tokenizeXML = (function() { - function inText(source, setState) { - var ch = source.next(); - if (ch == "<") { - if (source.equals("!")) { - source.next(); - if (source.equals("[")) { - if (source.lookAhead("[CDATA[", true)) { - setState(inBlock("xml-cdata", "]]>")); - return null; - } - else { - return "xml-text"; - } - } - else if (source.lookAhead("--", true)) { - setState(inBlock("xml-comment", "-->")); - return null; - } - else { - return "xml-text"; - } - } - else if (source.equals("?")) { - source.next(); - source.nextWhileMatches(/[\w\._\-]/); - setState(inBlock("xml-processing", "?>")); - return "xml-processing"; - } - else { - if (source.equals("/")) source.next(); - setState(inTag); - return "xml-punctuation"; - } - } - else if (ch == "&") { - while (!source.endOfLine()) { - if (source.next() == ";") - break; - } - return "xml-entity"; - } - else { - source.nextWhileMatches(/[^&<\n]/); - return "xml-text"; - } - } - - function inTag(source, setState) { - var ch = source.next(); - if (ch == ">") { - setState(inText); - return "xml-punctuation"; - } - else if (/[?\/]/.test(ch) && source.equals(">")) { - source.next(); - setState(inText); - return "xml-punctuation"; - } - else if (ch == "=") { - return "xml-punctuation"; - } - else if (/[\'\"]/.test(ch)) { - setState(inAttribute(ch)); - return null; - } - else { - source.nextWhileMatches(/[^\s\u00a0=<>\"\'\/?]/); - return "xml-name"; - } - } - - function inAttribute(quote) { - return function(source, setState) { - while (!source.endOfLine()) { - if (source.next() == quote) { - setState(inTag); - break; - } - } - return "xml-attribute"; - }; - } - - function inBlock(style, terminator) { - return function(source, setState) { - while (!source.endOfLine()) { - if (source.lookAhead(terminator, true)) { - setState(inText); - break; - } - source.next(); - } - return style; - }; - } - - return function(source, startState) { - return tokenizer(source, startState || inText); - }; - })(); - - // The parser. The structure of this function largely follows that of - // parseJavaScript in parsejavascript.js (there is actually a bit more - // shared code than I'd like), but it is quite a bit simpler. - function parseXML(source) { - var tokens = tokenizeXML(source); - var cc = [base]; - var tokenNr = 0, indented = 0; - var currentTag = null, context = null; - var consume, marked; - - function push(fs) { - for (var i = fs.length - 1; i >= 0; i--) - cc.push(fs[i]); - } - function cont() { - push(arguments); - consume = true; - } - function pass() { - push(arguments); - consume = false; - } - - function mark(style) { - marked = style; - } - function expect(text) { - return function(style, content) { - if (content == text) cont(); - else mark("xml-error") || cont(arguments.callee); - }; - } - - function pushContext(tagname, startOfLine) { - var noIndent = UseKludges.doNotIndent.hasOwnProperty(tagname) || (context && context.noIndent); - context = {prev: context, name: tagname, indent: indented, startOfLine: startOfLine, noIndent: noIndent}; - } - function popContext() { - context = context.prev; - } - function computeIndentation(baseContext) { - return function(nextChars, current) { - var context = baseContext; - if (context && context.noIndent) - return current; - if (alignCDATA && /")); - else if (style == "xml-cdata") { - if (!context || context.name != "!cdata") pushContext("!cdata"); - if (/\]\]>$/.test(content)) popContext(); - cont(); - } - else if (harmlessTokens.hasOwnProperty(style)) cont(); - else mark("xml-error") || cont(); - } - function tagname(style, content) { - if (style == "xml-name") { - currentTag = content.toLowerCase(); - mark("xml-tagname"); - cont(); - } - else { - currentTag = null; - pass(); - } - } - function closetagname(style, content) { - if (style == "xml-name" && context && content.toLowerCase() == context.name) { - popContext(); - mark("xml-tagname"); - } - else { - mark("xml-error"); - } - cont(); - } - function endtag(startOfLine) { - return function(style, content) { - if (content == "/>" || (content == ">" && UseKludges.autoSelfClosers.hasOwnProperty(currentTag))) cont(); - else if (content == ">") pushContext(currentTag, startOfLine) || cont(); - else mark("xml-error") || cont(arguments.callee); - }; - } - function attributes(style) { - if (style == "xml-name") mark("xml-attname") || cont(attribute, attributes); - else pass(); - } - function attribute(style, content) { - if (content == "=") cont(value); - else if (content == ">" || content == "/>") pass(endtag); - else pass(); - } - function value(style) { - if (style == "xml-attribute") cont(value); - else pass(); - } - - return { - indentation: function() {return indented;}, - - next: function(){ - var token = tokens.next(); - if (token.style == "whitespace" && tokenNr == 0) - indented = token.value.length; - else - tokenNr++; - if (token.content == "\n") { - indented = tokenNr = 0; - token.indentation = computeIndentation(context); - } - - if (token.style == "whitespace" || token.type == "xml-comment") - return token; - - while(true){ - consume = marked = false; - cc.pop()(token.style, token.content); - if (consume){ - if (marked) - token.style = marked; - return token; - } - } - }, - - copy: function(){ - var _cc = cc.concat([]), _tokenState = tokens.state, _context = context; - var parser = this; - - return function(input){ - cc = _cc.concat([]); - tokenNr = indented = 0; - context = _context; - tokens = tokenizeXML(input, _tokenState); - return parser; - }; - } - }; - } - - return { - make: parseXML, - electricChars: "/", - configure: function(config) { - if (config.useHTMLKludges != null) - UseKludges = config.useHTMLKludges ? Kludges : NoKludges; - if (config.alignCDATA) - alignCDATA = config.alignCDATA; - } - }; -})(); diff --git a/project/static/js/lib/codemirror/select.js b/project/static/js/lib/codemirror/select.js deleted file mode 100644 index 7746240e..00000000 --- a/project/static/js/lib/codemirror/select.js +++ /dev/null @@ -1,624 +0,0 @@ -/* Functionality for finding, storing, and restoring selections - * - * This does not provide a generic API, just the minimal functionality - * required by the CodeMirror system. - */ - -// Namespace object. -var select = {}; - -(function() { - select.ie_selection = document.selection && document.selection.createRangeCollection; - - // Find the 'top-level' (defined as 'a direct child of the node - // passed as the top argument') node that the given node is - // contained in. Return null if the given node is not inside the top - // node. - function topLevelNodeAt(node, top) { - while (node && node.parentNode != top) - node = node.parentNode; - return node; - } - - // Find the top-level node that contains the node before this one. - function topLevelNodeBefore(node, top) { - while (!node.previousSibling && node.parentNode != top) - node = node.parentNode; - return topLevelNodeAt(node.previousSibling, top); - } - - var fourSpaces = "\u00a0\u00a0\u00a0\u00a0"; - - select.scrollToNode = function(element) { - if (!element) return; - var doc = element.ownerDocument, body = doc.body, - win = (doc.defaultView || doc.parentWindow), - html = doc.documentElement, - atEnd = !element.nextSibling || !element.nextSibling.nextSibling - || !element.nextSibling.nextSibling.nextSibling; - // In Opera (and recent Webkit versions), BR elements *always* - // have a scrollTop property of zero. - var compensateHack = 0; - while (element && !element.offsetTop) { - compensateHack++; - element = element.previousSibling; - } - // atEnd is another kludge for these browsers -- if the cursor is - // at the end of the document, and the node doesn't have an - // offset, just scroll to the end. - if (compensateHack == 0) atEnd = false; - - var y = compensateHack * (element ? element.offsetHeight : 0), x = 0, pos = element; - while (pos && pos.offsetParent) { - y += pos.offsetTop; - // Don't count X offset for
    nodes - if (!isBR(pos)) - x += pos.offsetLeft; - pos = pos.offsetParent; - } - - var scroll_x = body.scrollLeft || html.scrollLeft || 0, - scroll_y = body.scrollTop || html.scrollTop || 0, - screen_x = x - scroll_x, screen_y = y - scroll_y, scroll = false; - - if (screen_x < 0 || screen_x > (win.innerWidth || html.clientWidth || 0)) { - scroll_x = x; - scroll = true; - } - if (screen_y < 0 || atEnd || screen_y > (win.innerHeight || html.clientHeight || 0) - 50) { - scroll_y = atEnd ? 1e10 : y; - scroll = true; - } - if (scroll) win.scrollTo(scroll_x, scroll_y); - }; - - select.scrollToCursor = function(container) { - select.scrollToNode(select.selectionTopNode(container, true) || container.firstChild); - }; - - // Used to prevent restoring a selection when we do not need to. - var currentSelection = null; - - select.snapshotChanged = function() { - if (currentSelection) currentSelection.changed = true; - }; - - // This is called by the code in editor.js whenever it is replacing - // a text node. The function sees whether the given oldNode is part - // of the current selection, and updates this selection if it is. - // Because nodes are often only partially replaced, the length of - // the part that gets replaced has to be taken into account -- the - // selection might stay in the oldNode if the newNode is smaller - // than the selection's offset. The offset argument is needed in - // case the selection does move to the new object, and the given - // length is not the whole length of the new node (part of it might - // have been used to replace another node). - select.snapshotReplaceNode = function(from, to, length, offset) { - if (!currentSelection) return; - - function replace(point) { - if (from == point.node) { - currentSelection.changed = true; - if (length && point.offset > length) { - point.offset -= length; - } - else { - point.node = to; - point.offset += (offset || 0); - } - } - } - replace(currentSelection.start); - replace(currentSelection.end); - }; - - select.snapshotMove = function(from, to, distance, relative, ifAtStart) { - if (!currentSelection) return; - - function move(point) { - if (from == point.node && (!ifAtStart || point.offset == 0)) { - currentSelection.changed = true; - point.node = to; - if (relative) point.offset = Math.max(0, point.offset + distance); - else point.offset = distance; - } - } - move(currentSelection.start); - move(currentSelection.end); - }; - - // Most functions are defined in two ways, one for the IE selection - // model, one for the W3C one. - if (select.ie_selection) { - function selectionNode(win, start) { - var range = win.document.selection.createRange(); - range.collapse(start); - - function nodeAfter(node) { - var found = null; - while (!found && node) { - found = node.nextSibling; - node = node.parentNode; - } - return nodeAtStartOf(found); - } - - function nodeAtStartOf(node) { - while (node && node.firstChild) node = node.firstChild; - return {node: node, offset: 0}; - } - - var containing = range.parentElement(); - if (!isAncestor(win.document.body, containing)) return null; - if (!containing.firstChild) return nodeAtStartOf(containing); - - var working = range.duplicate(); - working.moveToElementText(containing); - working.collapse(true); - for (var cur = containing.firstChild; cur; cur = cur.nextSibling) { - if (cur.nodeType == 3) { - var size = cur.nodeValue.length; - working.move("character", size); - } - else { - working.moveToElementText(cur); - working.collapse(false); - } - - var dir = range.compareEndPoints("StartToStart", working); - if (dir == 0) return nodeAfter(cur); - if (dir == 1) continue; - if (cur.nodeType != 3) return nodeAtStartOf(cur); - - working.setEndPoint("StartToEnd", range); - return {node: cur, offset: size - working.text.length}; - } - return nodeAfter(containing); - } - - select.markSelection = function(win) { - currentSelection = null; - var sel = win.document.selection; - if (!sel) return; - var start = selectionNode(win, true), - end = selectionNode(win, false); - if (!start || !end) return; - currentSelection = {start: start, end: end, window: win, changed: false}; - }; - - select.selectMarked = function() { - if (!currentSelection || !currentSelection.changed) return; - var win = currentSelection.window, doc = win.document; - - function makeRange(point) { - var range = doc.body.createTextRange(), - node = point.node; - if (!node) { - range.moveToElementText(currentSelection.window.document.body); - range.collapse(false); - } - else if (node.nodeType == 3) { - range.moveToElementText(node.parentNode); - var offset = point.offset; - while (node.previousSibling) { - node = node.previousSibling; - offset += (node.innerText || "").length; - } - range.move("character", offset); - } - else { - range.moveToElementText(node); - range.collapse(true); - } - return range; - } - - var start = makeRange(currentSelection.start), end = makeRange(currentSelection.end); - start.setEndPoint("StartToEnd", end); - start.select(); - }; - - // Get the top-level node that one end of the cursor is inside or - // after. Note that this returns false for 'no cursor', and null - // for 'start of document'. - select.selectionTopNode = function(container, start) { - var selection = container.ownerDocument.selection; - if (!selection) return false; - - var range = selection.createRange(), range2 = range.duplicate(); - range.collapse(start); - var around = range.parentElement(); - if (around && isAncestor(container, around)) { - // Only use this node if the selection is not at its start. - range2.moveToElementText(around); - if (range.compareEndPoints("StartToStart", range2) == 1) - return topLevelNodeAt(around, container); - } - - // Move the start of a range to the start of a node, - // compensating for the fact that you can't call - // moveToElementText with text nodes. - function moveToNodeStart(range, node) { - if (node.nodeType == 3) { - var count = 0, cur = node.previousSibling; - while (cur && cur.nodeType == 3) { - count += cur.nodeValue.length; - cur = cur.previousSibling; - } - if (cur) { - try{range.moveToElementText(cur);} - catch(e){return false;} - range.collapse(false); - } - else range.moveToElementText(node.parentNode); - if (count) range.move("character", count); - } - else { - try{range.moveToElementText(node);} - catch(e){return false;} - } - return true; - } - - // Do a binary search through the container object, comparing - // the start of each node to the selection - var start = 0, end = container.childNodes.length - 1; - while (start < end) { - var middle = Math.ceil((end + start) / 2), node = container.childNodes[middle]; - if (!node) return false; // Don't ask. IE6 manages this sometimes. - if (!moveToNodeStart(range2, node)) return false; - if (range.compareEndPoints("StartToStart", range2) == 1) - start = middle; - else - end = middle - 1; - } - return container.childNodes[start] || null; - }; - - // Place the cursor after this.start. This is only useful when - // manually moving the cursor instead of restoring it to its old - // position. - select.focusAfterNode = function(node, container) { - var range = container.ownerDocument.body.createTextRange(); - range.moveToElementText(node || container); - range.collapse(!node); - range.select(); - }; - - select.somethingSelected = function(win) { - var sel = win.document.selection; - return sel && (sel.createRange().text != ""); - }; - - function insertAtCursor(window, html) { - var selection = window.document.selection; - if (selection) { - var range = selection.createRange(); - range.pasteHTML(html); - range.collapse(false); - range.select(); - } - } - - // Used to normalize the effect of the enter key, since browsers - // do widely different things when pressing enter in designMode. - select.insertNewlineAtCursor = function(window) { - insertAtCursor(window, "
    "); - }; - - select.insertTabAtCursor = function(window) { - insertAtCursor(window, fourSpaces); - }; - - // Get the BR node at the start of the line on which the cursor - // currently is, and the offset into the line. Returns null as - // node if cursor is on first line. - select.cursorPos = function(container, start) { - var selection = container.ownerDocument.selection; - if (!selection) return null; - - var topNode = select.selectionTopNode(container, start); - while (topNode && !isBR(topNode)) - topNode = topNode.previousSibling; - - var range = selection.createRange(), range2 = range.duplicate(); - range.collapse(start); - if (topNode) { - range2.moveToElementText(topNode); - range2.collapse(false); - } - else { - // When nothing is selected, we can get all kinds of funky errors here. - try { range2.moveToElementText(container); } - catch (e) { return null; } - range2.collapse(true); - } - range.setEndPoint("StartToStart", range2); - - return {node: topNode, offset: range.text.length}; - }; - - select.setCursorPos = function(container, from, to) { - function rangeAt(pos) { - var range = container.ownerDocument.body.createTextRange(); - if (!pos.node) { - range.moveToElementText(container); - range.collapse(true); - } - else { - range.moveToElementText(pos.node); - range.collapse(false); - } - range.move("character", pos.offset); - return range; - } - - var range = rangeAt(from); - if (to && to != from) - range.setEndPoint("EndToEnd", rangeAt(to)); - range.select(); - } - - // Some hacks for storing and re-storing the selection when the editor loses and regains focus. - select.selectionCoords = function (win) { - var selection = win.document.selection; - if (!selection) return null; - var start = selection.createRange(), end = start.duplicate(); - start.collapse(true); - end.collapse(false); - - var body = win.document.body; - return {start: {x: start.boundingLeft + body.scrollLeft - 1, - y: start.boundingTop + body.scrollTop}, - end: {x: end.boundingLeft + body.scrollLeft - 1, - y: end.boundingTop + body.scrollTop}}; - }; - - // Restore a stored selection. - select.selectCoords = function(win, coords) { - if (!coords) return; - - var range1 = win.document.body.createTextRange(), range2 = range1.duplicate(); - // This can fail for various hard-to-handle reasons. - try { - range1.moveToPoint(coords.start.x, coords.start.y); - range2.moveToPoint(coords.end.x, coords.end.y); - range1.setEndPoint("EndToStart", range2); - range1.select(); - } catch(e) {} - }; - } - // W3C model - else { - // Store start and end nodes, and offsets within these, and refer - // back to the selection object from those nodes, so that this - // object can be updated when the nodes are replaced before the - // selection is restored. - select.markSelection = function (win) { - var selection = win.getSelection(); - if (!selection || selection.rangeCount == 0) - return (currentSelection = null); - var range = selection.getRangeAt(0); - - currentSelection = { - start: {node: range.startContainer, offset: range.startOffset}, - end: {node: range.endContainer, offset: range.endOffset}, - window: win, - changed: false - }; - - // We want the nodes right at the cursor, not one of their - // ancestors with a suitable offset. This goes down the DOM tree - // until a 'leaf' is reached (or is it *up* the DOM tree?). - function normalize(point){ - while (point.node.nodeType != 3 && !isBR(point.node)) { - var newNode = point.node.childNodes[point.offset] || point.node.nextSibling; - point.offset = 0; - while (!newNode && point.node.parentNode) { - point.node = point.node.parentNode; - newNode = point.node.nextSibling; - } - point.node = newNode; - if (!newNode) - break; - } - } - - normalize(currentSelection.start); - normalize(currentSelection.end); - }; - - select.selectMarked = function () { - var cs = currentSelection; - if (!(cs && (cs.changed || (webkit && cs.start.node == cs.end.node)))) return; - var win = cs.window, range = win.document.createRange(); - - function setPoint(point, which) { - if (point.node) { - // Some magic to generalize the setting of the start and end - // of a range. - if (point.offset == 0) - range["set" + which + "Before"](point.node); - else - range["set" + which](point.node, point.offset); - } - else { - range.setStartAfter(win.document.body.lastChild || win.document.body); - } - } - - setPoint(cs.end, "End"); - setPoint(cs.start, "Start"); - selectRange(range, win); - }; - - // Helper for selecting a range object. - function selectRange(range, window) { - var selection = window.getSelection(); - selection.removeAllRanges(); - selection.addRange(range); - }; - function selectionRange(window) { - var selection = window.getSelection(); - if (!selection || selection.rangeCount == 0) - return false; - else - return selection.getRangeAt(0); - } - - // Finding the top-level node at the cursor in the W3C is, as you - // can see, quite an involved process. - select.selectionTopNode = function(container, start) { - var range = selectionRange(container.ownerDocument.defaultView); - if (!range) return false; - - var node = start ? range.startContainer : range.endContainer; - var offset = start ? range.startOffset : range.endOffset; - // Work around (yet another) bug in Opera's selection model. - if (window.opera && !start && range.endContainer == container && range.endOffset == range.startOffset + 1 && - container.childNodes[range.startOffset] && isBR(container.childNodes[range.startOffset])) - offset--; - - // For text nodes, we look at the node itself if the cursor is - // inside, or at the node before it if the cursor is at the - // start. - if (node.nodeType == 3){ - if (offset > 0) - return topLevelNodeAt(node, container); - else - return topLevelNodeBefore(node, container); - } - // Occasionally, browsers will return the HTML node as - // selection. If the offset is 0, we take the start of the frame - // ('after null'), otherwise, we take the last node. - else if (node.nodeName.toUpperCase() == "HTML") { - return (offset == 1 ? null : container.lastChild); - } - // If the given node is our 'container', we just look up the - // correct node by using the offset. - else if (node == container) { - return (offset == 0) ? null : node.childNodes[offset - 1]; - } - // In any other case, we have a regular node. If the cursor is - // at the end of the node, we use the node itself, if it is at - // the start, we use the node before it, and in any other - // case, we look up the child before the cursor and use that. - else { - if (offset == node.childNodes.length) - return topLevelNodeAt(node, container); - else if (offset == 0) - return topLevelNodeBefore(node, container); - else - return topLevelNodeAt(node.childNodes[offset - 1], container); - } - }; - - select.focusAfterNode = function(node, container) { - var win = container.ownerDocument.defaultView, - range = win.document.createRange(); - range.setStartBefore(container.firstChild || container); - // In Opera, setting the end of a range at the end of a line - // (before a BR) will cause the cursor to appear on the next - // line, so we set the end inside of the start node when - // possible. - if (node && !node.firstChild) - range.setEndAfter(node); - else if (node) - range.setEnd(node, node.childNodes.length); - else - range.setEndBefore(container.firstChild || container); - range.collapse(false); - selectRange(range, win); - }; - - select.somethingSelected = function(win) { - var range = selectionRange(win); - return range && !range.collapsed; - }; - - function insertNodeAtCursor(window, node) { - var range = selectionRange(window); - if (!range) return; - - range.deleteContents(); - range.insertNode(node); - webkitLastLineHack(window.document.body); - range = window.document.createRange(); - range.selectNode(node); - range.collapse(false); - selectRange(range, window); - } - - select.insertNewlineAtCursor = function(window) { - insertNodeAtCursor(window, window.document.createElement("BR")); - }; - - select.insertTabAtCursor = function(window) { - insertNodeAtCursor(window, window.document.createTextNode(fourSpaces)); - }; - - select.cursorPos = function(container, start) { - var range = selectionRange(window); - if (!range) return; - - var topNode = select.selectionTopNode(container, start); - while (topNode && !isBR(topNode)) - topNode = topNode.previousSibling; - - range = range.cloneRange(); - range.collapse(start); - if (topNode) - range.setStartAfter(topNode); - else - range.setStartBefore(container); - return {node: topNode, offset: range.toString().length}; - }; - - select.setCursorPos = function(container, from, to) { - var win = container.ownerDocument.defaultView, - range = win.document.createRange(); - - function setPoint(node, offset, side) { - if (!node) - node = container.firstChild; - else - node = node.nextSibling; - - if (!node) - return; - - if (offset == 0) { - range["set" + side + "Before"](node); - return true; - } - - var backlog = [] - function decompose(node) { - if (node.nodeType == 3) - backlog.push(node); - else - forEach(node.childNodes, decompose); - } - while (true) { - while (node && !backlog.length) { - decompose(node); - node = node.nextSibling; - } - var cur = backlog.shift(); - if (!cur) return false; - - var length = cur.nodeValue.length; - if (length >= offset) { - range["set" + side](cur, offset); - return true; - } - offset -= length; - } - } - - to = to || from; - if (setPoint(to.node, to.offset, "End") && setPoint(from.node, from.offset, "Start")) - selectRange(range, win); - }; - } -})(); diff --git a/project/static/js/lib/codemirror/stringstream.js b/project/static/js/lib/codemirror/stringstream.js deleted file mode 100644 index 8c1c0422..00000000 --- a/project/static/js/lib/codemirror/stringstream.js +++ /dev/null @@ -1,140 +0,0 @@ -/* String streams are the things fed to parsers (which can feed them - * to a tokenizer if they want). They provide peek and next methods - * for looking at the current character (next 'consumes' this - * character, peek does not), and a get method for retrieving all the - * text that was consumed since the last time get was called. - * - * An easy mistake to make is to let a StopIteration exception finish - * the token stream while there are still characters pending in the - * string stream (hitting the end of the buffer while parsing a - * token). To make it easier to detect such errors, the stringstreams - * throw an exception when this happens. - */ - -// Make a stringstream stream out of an iterator that returns strings. -// This is applied to the result of traverseDOM (see codemirror.js), -// and the resulting stream is fed to the parser. -window.stringStream = function(source){ - // String that's currently being iterated over. - var current = ""; - // Position in that string. - var pos = 0; - // Accumulator for strings that have been iterated over but not - // get()-ed yet. - var accum = ""; - // Make sure there are more characters ready, or throw - // StopIteration. - function ensureChars() { - while (pos == current.length) { - accum += current; - current = ""; // In case source.next() throws - pos = 0; - try {current = source.next();} - catch (e) { - if (e != StopIteration) throw e; - else return false; - } - } - return true; - } - - return { - // Return the next character in the stream. - peek: function() { - if (!ensureChars()) return null; - return current.charAt(pos); - }, - // Get the next character, throw StopIteration if at end, check - // for unused content. - next: function() { - if (!ensureChars()) { - if (accum.length > 0) - throw "End of stringstream reached without emptying buffer ('" + accum + "')."; - else - throw StopIteration; - } - return current.charAt(pos++); - }, - // Return the characters iterated over since the last call to - // .get(). - get: function() { - var temp = accum; - accum = ""; - if (pos > 0){ - temp += current.slice(0, pos); - current = current.slice(pos); - pos = 0; - } - return temp; - }, - // Push a string back into the stream. - push: function(str) { - current = current.slice(0, pos) + str + current.slice(pos); - }, - lookAhead: function(str, consume, skipSpaces, caseInsensitive) { - function cased(str) {return caseInsensitive ? str.toLowerCase() : str;} - str = cased(str); - var found = false; - - var _accum = accum, _pos = pos; - if (skipSpaces) this.nextWhileMatches(/[\s\u00a0]/); - - while (true) { - var end = pos + str.length, left = current.length - pos; - if (end <= current.length) { - found = str == cased(current.slice(pos, end)); - pos = end; - break; - } - else if (str.slice(0, left) == cased(current.slice(pos))) { - accum += current; current = ""; - try {current = source.next();} - catch (e) {break;} - pos = 0; - str = str.slice(left); - } - else { - break; - } - } - - if (!(found && consume)) { - current = accum.slice(_accum.length) + current; - pos = _pos; - accum = _accum; - } - - return found; - }, - - // Utils built on top of the above - more: function() { - return this.peek() !== null; - }, - applies: function(test) { - var next = this.peek(); - return (next !== null && test(next)); - }, - nextWhile: function(test) { - var next; - while ((next = this.peek()) !== null && test(next)) - this.next(); - }, - matches: function(re) { - var next = this.peek(); - return (next !== null && re.test(next)); - }, - nextWhileMatches: function(re) { - var next; - while ((next = this.peek()) !== null && re.test(next)) - this.next(); - }, - equals: function(ch) { - return ch === this.peek(); - }, - endOfLine: function() { - var next = this.peek(); - return next == null || next == "\n"; - } - }; -}; diff --git a/project/static/js/lib/codemirror/tokenize.js b/project/static/js/lib/codemirror/tokenize.js deleted file mode 100644 index 071970ce..00000000 --- a/project/static/js/lib/codemirror/tokenize.js +++ /dev/null @@ -1,57 +0,0 @@ -// A framework for simple tokenizers. Takes care of newlines and -// white-space, and of getting the text from the source stream into -// the token object. A state is a function of two arguments -- a -// string stream and a setState function. The second can be used to -// change the tokenizer's state, and can be ignored for stateless -// tokenizers. This function should advance the stream over a token -// and return a string or object containing information about the next -// token, or null to pass and have the (new) state be called to finish -// the token. When a string is given, it is wrapped in a {style, type} -// object. In the resulting object, the characters consumed are stored -// under the content property. Any whitespace following them is also -// automatically consumed, and added to the value property. (Thus, -// content is the actual meaningful part of the token, while value -// contains all the text it spans.) - -function tokenizer(source, state) { - // Newlines are always a separate token. - function isWhiteSpace(ch) { - // The messy regexp is because IE's regexp matcher is of the - // opinion that non-breaking spaces are no whitespace. - return ch != "\n" && /^[\s\u00a0]*$/.test(ch); - } - - var tokenizer = { - state: state, - - take: function(type) { - if (typeof(type) == "string") - type = {style: type, type: type}; - - type.content = (type.content || "") + source.get(); - if (!/\n$/.test(type.content)) - source.nextWhile(isWhiteSpace); - type.value = type.content + source.get(); - return type; - }, - - next: function () { - if (!source.more()) throw StopIteration; - - var type; - if (source.equals("\n")) { - source.next(); - return this.take("whitespace"); - } - - if (source.applies(isWhiteSpace)) - type = "whitespace"; - else - while (!type) - type = this.state(source, function(s) {tokenizer.state = s;}); - - return this.take(type); - } - }; - return tokenizer; -} diff --git a/project/static/js/lib/codemirror/undo.js b/project/static/js/lib/codemirror/undo.js deleted file mode 100644 index 97daf593..00000000 --- a/project/static/js/lib/codemirror/undo.js +++ /dev/null @@ -1,403 +0,0 @@ -/** - * Storage and control for undo information within a CodeMirror - * editor. 'Why on earth is such a complicated mess required for - * that?', I hear you ask. The goal, in implementing this, was to make - * the complexity of storing and reverting undo information depend - * only on the size of the edited or restored content, not on the size - * of the whole document. This makes it necessary to use a kind of - * 'diff' system, which, when applied to a DOM tree, causes some - * complexity and hackery. - * - * In short, the editor 'touches' BR elements as it parses them, and - * the History stores these. When nothing is touched in commitDelay - * milliseconds, the changes are committed: It goes over all touched - * nodes, throws out the ones that did not change since last commit or - * are no longer in the document, and assembles the rest into zero or - * more 'chains' -- arrays of adjacent lines. Links back to these - * chains are added to the BR nodes, while the chain that previously - * spanned these nodes is added to the undo history. Undoing a change - * means taking such a chain off the undo history, restoring its - * content (text is saved per line) and linking it back into the - * document. - */ - -// A history object needs to know about the DOM container holding the -// document, the maximum amount of undo levels it should store, the -// delay (of no input) after which it commits a set of changes, and, -// unfortunately, the 'parent' window -- a window that is not in -// designMode, and on which setTimeout works in every browser. -function History(container, maxDepth, commitDelay, editor, onChange) { - this.container = container; - this.maxDepth = maxDepth; this.commitDelay = commitDelay; - this.editor = editor; this.parent = editor.parent; - this.onChange = onChange; - // This line object represents the initial, empty editor. - var initial = {text: "", from: null, to: null}; - // As the borders between lines are represented by BR elements, the - // start of the first line and the end of the last one are - // represented by null. Since you can not store any properties - // (links to line objects) in null, these properties are used in - // those cases. - this.first = initial; this.last = initial; - // Similarly, a 'historyTouched' property is added to the BR in - // front of lines that have already been touched, and 'firstTouched' - // is used for the first line. - this.firstTouched = false; - // History is the set of committed changes, touched is the set of - // nodes touched since the last commit. - this.history = []; this.redoHistory = []; this.touched = []; -} - -History.prototype = { - // Schedule a commit (if no other touches come in for commitDelay - // milliseconds). - scheduleCommit: function() { - var self = this; - this.parent.clearTimeout(this.commitTimeout); - this.commitTimeout = this.parent.setTimeout(function(){self.tryCommit();}, this.commitDelay); - }, - - // Mark a node as touched. Null is a valid argument. - touch: function(node) { - this.setTouched(node); - this.scheduleCommit(); - }, - - // Undo the last change. - undo: function() { - // Make sure pending changes have been committed. - this.commit(); - - if (this.history.length) { - // Take the top diff from the history, apply it, and store its - // shadow in the redo history. - var item = this.history.pop(); - this.redoHistory.push(this.updateTo(item, "applyChain")); - if (this.onChange) this.onChange(); - return this.chainNode(item); - } - }, - - // Redo the last undone change. - redo: function() { - this.commit(); - if (this.redoHistory.length) { - // The inverse of undo, basically. - var item = this.redoHistory.pop(); - this.addUndoLevel(this.updateTo(item, "applyChain")); - if (this.onChange) this.onChange(); - return this.chainNode(item); - } - }, - - clear: function() { - this.history = []; - this.redoHistory = []; - }, - - // Ask for the size of the un/redo histories. - historySize: function() { - return {undo: this.history.length, redo: this.redoHistory.length}; - }, - - // Push a changeset into the document. - push: function(from, to, lines) { - var chain = []; - for (var i = 0; i < lines.length; i++) { - var end = (i == lines.length - 1) ? to : this.container.ownerDocument.createElement("BR"); - chain.push({from: from, to: end, text: cleanText(lines[i])}); - from = end; - } - this.pushChains([chain], from == null && to == null); - }, - - pushChains: function(chains, doNotHighlight) { - this.commit(doNotHighlight); - this.addUndoLevel(this.updateTo(chains, "applyChain")); - this.redoHistory = []; - }, - - // Retrieve a DOM node from a chain (for scrolling to it after undo/redo). - chainNode: function(chains) { - for (var i = 0; i < chains.length; i++) { - var start = chains[i][0], node = start && (start.from || start.to); - if (node) return node; - } - }, - - // Clear the undo history, make the current document the start - // position. - reset: function() { - this.history = []; this.redoHistory = []; - }, - - textAfter: function(br) { - return this.after(br).text; - }, - - nodeAfter: function(br) { - return this.after(br).to; - }, - - nodeBefore: function(br) { - return this.before(br).from; - }, - - // Commit unless there are pending dirty nodes. - tryCommit: function() { - if (!window.History) return; // Stop when frame has been unloaded - if (this.editor.highlightDirty()) this.commit(true); - else this.scheduleCommit(); - }, - - // Check whether the touched nodes hold any changes, if so, commit - // them. - commit: function(doNotHighlight) { - this.parent.clearTimeout(this.commitTimeout); - // Make sure there are no pending dirty nodes. - if (!doNotHighlight) this.editor.highlightDirty(true); - // Build set of chains. - var chains = this.touchedChains(), self = this; - - if (chains.length) { - this.addUndoLevel(this.updateTo(chains, "linkChain")); - this.redoHistory = []; - if (this.onChange) this.onChange(); - } - }, - - // [ end of public interface ] - - // Update the document with a given set of chains, return its - // shadow. updateFunc should be "applyChain" or "linkChain". In the - // second case, the chains are taken to correspond the the current - // document, and only the state of the line data is updated. In the - // first case, the content of the chains is also pushed iinto the - // document. - updateTo: function(chains, updateFunc) { - var shadows = [], dirty = []; - for (var i = 0; i < chains.length; i++) { - shadows.push(this.shadowChain(chains[i])); - dirty.push(this[updateFunc](chains[i])); - } - if (updateFunc == "applyChain") - this.notifyDirty(dirty); - return shadows; - }, - - // Notify the editor that some nodes have changed. - notifyDirty: function(nodes) { - forEach(nodes, method(this.editor, "addDirtyNode")) - this.editor.scheduleHighlight(); - }, - - // Link a chain into the DOM nodes (or the first/last links for null - // nodes). - linkChain: function(chain) { - for (var i = 0; i < chain.length; i++) { - var line = chain[i]; - if (line.from) line.from.historyAfter = line; - else this.first = line; - if (line.to) line.to.historyBefore = line; - else this.last = line; - } - }, - - // Get the line object after/before a given node. - after: function(node) { - return node ? node.historyAfter : this.first; - }, - before: function(node) { - return node ? node.historyBefore : this.last; - }, - - // Mark a node as touched if it has not already been marked. - setTouched: function(node) { - if (node) { - if (!node.historyTouched) { - this.touched.push(node); - node.historyTouched = true; - } - } - else { - this.firstTouched = true; - } - }, - - // Store a new set of undo info, throw away info if there is more of - // it than allowed. - addUndoLevel: function(diffs) { - this.history.push(diffs); - if (this.history.length > this.maxDepth) - this.history.shift(); - }, - - // Build chains from a set of touched nodes. - touchedChains: function() { - var self = this; - - // The temp system is a crummy hack to speed up determining - // whether a (currently touched) node has a line object associated - // with it. nullTemp is used to store the object for the first - // line, other nodes get it stored in their historyTemp property. - var nullTemp = null; - function temp(node) {return node ? node.historyTemp : nullTemp;} - function setTemp(node, line) { - if (node) node.historyTemp = line; - else nullTemp = line; - } - - function buildLine(node) { - var text = []; - for (var cur = node ? node.nextSibling : self.container.firstChild; - cur && !isBR(cur); cur = cur.nextSibling) - if (cur.currentText) text.push(cur.currentText); - return {from: node, to: cur, text: cleanText(text.join(""))}; - } - - // Filter out unchanged lines and nodes that are no longer in the - // document. Build up line objects for remaining nodes. - var lines = []; - if (self.firstTouched) self.touched.push(null); - forEach(self.touched, function(node) { - if (node && node.parentNode != self.container) return; - - if (node) node.historyTouched = false; - else self.firstTouched = false; - - var line = buildLine(node), shadow = self.after(node); - if (!shadow || shadow.text != line.text || shadow.to != line.to) { - lines.push(line); - setTemp(node, line); - } - }); - - // Get the BR element after/before the given node. - function nextBR(node, dir) { - var link = dir + "Sibling", search = node[link]; - while (search && !isBR(search)) - search = search[link]; - return search; - } - - // Assemble line objects into chains by scanning the DOM tree - // around them. - var chains = []; self.touched = []; - forEach(lines, function(line) { - // Note that this makes the loop skip line objects that have - // been pulled into chains by lines before them. - if (!temp(line.from)) return; - - var chain = [], curNode = line.from, safe = true; - // Put any line objects (referred to by temp info) before this - // one on the front of the array. - while (true) { - var curLine = temp(curNode); - if (!curLine) { - if (safe) break; - else curLine = buildLine(curNode); - } - chain.unshift(curLine); - setTemp(curNode, null); - if (!curNode) break; - safe = self.after(curNode); - curNode = nextBR(curNode, "previous"); - } - curNode = line.to; safe = self.before(line.from); - // Add lines after this one at end of array. - while (true) { - if (!curNode) break; - var curLine = temp(curNode); - if (!curLine) { - if (safe) break; - else curLine = buildLine(curNode); - } - chain.push(curLine); - setTemp(curNode, null); - safe = self.before(curNode); - curNode = nextBR(curNode, "next"); - } - chains.push(chain); - }); - - return chains; - }, - - // Find the 'shadow' of a given chain by following the links in the - // DOM nodes at its start and end. - shadowChain: function(chain) { - var shadows = [], next = this.after(chain[0].from), end = chain[chain.length - 1].to; - while (true) { - shadows.push(next); - var nextNode = next.to; - if (!nextNode || nextNode == end) - break; - else - next = nextNode.historyAfter || this.before(end); - // (The this.before(end) is a hack -- FF sometimes removes - // properties from BR nodes, in which case the best we can hope - // for is to not break.) - } - return shadows; - }, - - // Update the DOM tree to contain the lines specified in a given - // chain, link this chain into the DOM nodes. - applyChain: function(chain) { - // Some attempt is made to prevent the cursor from jumping - // randomly when an undo or redo happens. It still behaves a bit - // strange sometimes. - var cursor = select.cursorPos(this.container, false), self = this; - - // Remove all nodes in the DOM tree between from and to (null for - // start/end of container). - function removeRange(from, to) { - var pos = from ? from.nextSibling : self.container.firstChild; - while (pos != to) { - var temp = pos.nextSibling; - removeElement(pos); - pos = temp; - } - } - - var start = chain[0].from, end = chain[chain.length - 1].to; - // Clear the space where this change has to be made. - removeRange(start, end); - - // Insert the content specified by the chain into the DOM tree. - for (var i = 0; i < chain.length; i++) { - var line = chain[i]; - // The start and end of the space are already correct, but BR - // tags inside it have to be put back. - if (i > 0) - self.container.insertBefore(line.from, end); - - // Add the text. - var node = makePartSpan(fixSpaces(line.text), this.container.ownerDocument); - self.container.insertBefore(node, end); - // See if the cursor was on this line. Put it back, adjusting - // for changed line length, if it was. - if (cursor && cursor.node == line.from) { - var cursordiff = 0; - var prev = this.after(line.from); - if (prev && i == chain.length - 1) { - // Only adjust if the cursor is after the unchanged part of - // the line. - for (var match = 0; match < cursor.offset && - line.text.charAt(match) == prev.text.charAt(match); match++); - if (cursor.offset > match) - cursordiff = line.text.length - prev.text.length; - } - select.setCursorPos(this.container, {node: line.from, offset: Math.max(0, cursor.offset + cursordiff)}); - } - // Cursor was in removed line, this is last new line. - else if (cursor && (i == chain.length - 1) && cursor.node && cursor.node.parentNode != this.container) { - select.setCursorPos(this.container, {node: line.from, offset: line.text.length}); - } - } - - // Anchor the chain in the DOM tree. - this.linkChain(chain); - return start; - } -}; diff --git a/project/static/js/lib/codemirror/util.js b/project/static/js/lib/codemirror/util.js deleted file mode 100644 index 0cd91d4e..00000000 --- a/project/static/js/lib/codemirror/util.js +++ /dev/null @@ -1,134 +0,0 @@ -/* A few useful utility functions. */ - -var internetExplorer = document.selection && window.ActiveXObject && /MSIE/.test(navigator.userAgent); -var webkit = /AppleWebKit/.test(navigator.userAgent); -var safari = /Apple Computers, Inc/.test(navigator.vendor); - -// Capture a method on an object. -function method(obj, name) { - return function() {obj[name].apply(obj, arguments);}; -} - -// The value used to signal the end of a sequence in iterators. -var StopIteration = {toString: function() {return "StopIteration"}}; - -// Apply a function to each element in a sequence. -function forEach(iter, f) { - if (iter.next) { - try {while (true) f(iter.next());} - catch (e) {if (e != StopIteration) throw e;} - } - else { - for (var i = 0; i < iter.length; i++) - f(iter[i]); - } -} - -// Map a function over a sequence, producing an array of results. -function map(iter, f) { - var accum = []; - forEach(iter, function(val) {accum.push(f(val));}); - return accum; -} - -// Create a predicate function that tests a string againsts a given -// regular expression. No longer used but might be used by 3rd party -// parsers. -function matcher(regexp){ - return function(value){return regexp.test(value);}; -} - -// Test whether a DOM node has a certain CSS class. Much faster than -// the MochiKit equivalent, for some reason. -function hasClass(element, className){ - var classes = element.className; - return classes && new RegExp("(^| )" + className + "($| )").test(classes); -} - -// Insert a DOM node after another node. -function insertAfter(newNode, oldNode) { - var parent = oldNode.parentNode; - parent.insertBefore(newNode, oldNode.nextSibling); - return newNode; -} - -function removeElement(node) { - if (node.parentNode) - node.parentNode.removeChild(node); -} - -function clearElement(node) { - while (node.firstChild) - node.removeChild(node.firstChild); -} - -// Check whether a node is contained in another one. -function isAncestor(node, child) { - while (child = child.parentNode) { - if (node == child) - return true; - } - return false; -} - -// The non-breaking space character. -var nbsp = "\u00a0"; -var matching = {"{": "}", "[": "]", "(": ")", - "}": "{", "]": "[", ")": "("}; - -// Standardize a few unportable event properties. -function normalizeEvent(event) { - if (!event.stopPropagation) { - event.stopPropagation = function() {this.cancelBubble = true;}; - event.preventDefault = function() {this.returnValue = false;}; - } - if (!event.stop) { - event.stop = function() { - this.stopPropagation(); - this.preventDefault(); - }; - } - - if (event.type == "keypress") { - event.code = (event.charCode == null) ? event.keyCode : event.charCode; - event.character = String.fromCharCode(event.code); - } - return event; -} - -// Portably register event handlers. -function addEventHandler(node, type, handler, removeFunc) { - function wrapHandler(event) { - handler(normalizeEvent(event || window.event)); - } - if (typeof node.addEventListener == "function") { - node.addEventListener(type, wrapHandler, false); - if (removeFunc) return function() {node.removeEventListener(type, wrapHandler, false);}; - } - else { - node.attachEvent("on" + type, wrapHandler); - if (removeFunc) return function() {node.detachEvent("on" + type, wrapHandler);}; - } -} - -function nodeText(node) { - return node.textContent || node.innerText || node.nodeValue || ""; -} - -function nodeTop(node) { - var top = 0; - while (node.offsetParent) { - top += node.offsetTop; - node = node.offsetParent; - } - return top; -} - -function isBR(node) { - var nn = node.nodeName; - return nn == "BR" || nn == "br"; -} -function isSpan(node) { - var nn = node.nodeName; - return nn == "SPAN" || nn == "span"; -} diff --git a/project/static/js/lib/jquery.cookie.js b/project/static/js/lib/jquery.cookie.js deleted file mode 100644 index 6df1faca..00000000 --- a/project/static/js/lib/jquery.cookie.js +++ /dev/null @@ -1,96 +0,0 @@ -/** - * Cookie plugin - * - * Copyright (c) 2006 Klaus Hartl (stilbuero.de) - * Dual licensed under the MIT and GPL licenses: - * http://www.opensource.org/licenses/mit-license.php - * http://www.gnu.org/licenses/gpl.html - * - */ - -/** - * Create a cookie with the given name and value and other optional parameters. - * - * @example $.cookie('the_cookie', 'the_value'); - * @desc Set the value of a cookie. - * @example $.cookie('the_cookie', 'the_value', { expires: 7, path: '/', domain: 'jquery.com', secure: true }); - * @desc Create a cookie with all available options. - * @example $.cookie('the_cookie', 'the_value'); - * @desc Create a session cookie. - * @example $.cookie('the_cookie', null); - * @desc Delete a cookie by passing null as value. Keep in mind that you have to use the same path and domain - * used when the cookie was set. - * - * @param String name The name of the cookie. - * @param String value The value of the cookie. - * @param Object options An object literal containing key/value pairs to provide optional cookie attributes. - * @option Number|Date expires Either an integer specifying the expiration date from now on in days or a Date object. - * If a negative value is specified (e.g. a date in the past), the cookie will be deleted. - * If set to null or omitted, the cookie will be a session cookie and will not be retained - * when the the browser exits. - * @option String path The value of the path atribute of the cookie (default: path of page that created the cookie). - * @option String domain The value of the domain attribute of the cookie (default: domain of page that created the cookie). - * @option Boolean secure If true, the secure attribute of the cookie will be set and the cookie transmission will - * require a secure protocol (like HTTPS). - * @type undefined - * - * @name $.cookie - * @cat Plugins/Cookie - * @author Klaus Hartl/klaus.hartl@stilbuero.de - */ - -/** - * Get the value of a cookie with the given name. - * - * @example $.cookie('the_cookie'); - * @desc Get the value of a cookie. - * - * @param String name The name of the cookie. - * @return The value of the cookie. - * @type String - * - * @name $.cookie - * @cat Plugins/Cookie - * @author Klaus Hartl/klaus.hartl@stilbuero.de - */ -jQuery.cookie = function(name, value, options) { - if (typeof value != 'undefined') { // name and value given, set cookie - options = options || {}; - if (value === null) { - value = ''; - options.expires = -1; - } - var expires = ''; - if (options.expires && (typeof options.expires == 'number' || options.expires.toUTCString)) { - var date; - if (typeof options.expires == 'number') { - date = new Date(); - date.setTime(date.getTime() + (options.expires * 24 * 60 * 60 * 1000)); - } else { - date = options.expires; - } - expires = '; expires=' + date.toUTCString(); // use expires attribute, max-age is not supported by IE - } - // CAUTION: Needed to parenthesize options.path and options.domain - // in the following expressions, otherwise they evaluate to undefined - // in the packed version for some reason... - var path = options.path ? '; path=' + (options.path) : ''; - var domain = options.domain ? '; domain=' + (options.domain) : ''; - var secure = options.secure ? '; secure' : ''; - document.cookie = [name, '=', encodeURIComponent(value), expires, path, domain, secure].join(''); - } else { // only name given, get cookie - var cookieValue = null; - if (document.cookie && document.cookie != '') { - var cookies = document.cookie.split(';'); - for (var i = 0; i < cookies.length; i++) { - var cookie = jQuery.trim(cookies[i]); - // Does this cookie string begin with the name we want? - if (cookie.substring(0, name.length + 1) == (name + '=')) { - cookieValue = decodeURIComponent(cookie.substring(name.length + 1)); - break; - } - } - } - return cookieValue; - } -}; \ No newline at end of file diff --git a/project/static/js/lib/jquery.hpanel.js b/project/static/js/lib/jquery.hpanel.js deleted file mode 100644 index 1ad0d17f..00000000 --- a/project/static/js/lib/jquery.hpanel.js +++ /dev/null @@ -1,94 +0,0 @@ -(function($){ - - /* behaviour */ - $.hpanel = { - settings: {}, - current_data: {}, - resize_start: function(event, mydata) { - $(document).bind('mousemove', mydata, $.hpanel.resize_changed). - bind('mouseup', mydata, $.hpanel.resize_stop); - - $('.panel-overlay', mydata.root).css('display', 'block'); - return false; - }, - resize_changed: function(event) { - var old_width = parseInt(event.data.overlay.css('width')); - var delta = event.pageX + event.data.hotspot_x - old_width; - event.data.overlay.css({'width': old_width + delta}); - - if(event.data.overlay.next) { - var left = parseInt(event.data.overlay.next.css('left')); - event.data.overlay.next.css('left', left+delta); - } - - return false; - }, - resize_stop: function(event) { - $(document).unbind('mousemove', $.hpanel.resize_changed).unbind('mouseup', $.hpanel.resize_stop); - // $('.panel-content', event.data.root).css('display', 'block'); - var overlays = $('.panel-content-overlay', event.data.root); - $('.panel-content-overlay', event.data.root).each(function(i) { - if( $(this).data('panel').hasClass('last-panel') ) - $(this).data('panel').css({ - 'left': $(this).css('left'), 'right': $(this).css('right')}); - else - $(this).data('panel').css({ - 'left': $(this).css('left'), 'width': $(this).css('width')}); - }); - $('.panel-overlay', event.data.root).css('display', 'none'); - $(event.data.root).trigger('stopResize'); - } - }; - - $.fn.makeHorizPanel = function(options) - { - var root = $(this) - - /* create an overlay */ - var overlay_root = $("
    "); - root.append(overlay_root); - - var prev = null; - - $('*.panel-wrap', root).each( function() - { - var panel = $(this); - var handle = $('.panel-slider', panel); - var overlay = $("
     
    "); - overlay_root.append(overlay); - overlay.data('panel', panel); - overlay.data('next', null); - - if (prev) prev.next = overlay; - - if( panel.hasClass('last-panel') ) - { - overlay.css({'left': panel.css('left'), 'right': panel.css('right')}); - } - else { - overlay.css({'left': panel.css('left'), 'width': panel.css('width')}); - $.log('Has handle: ' + panel.attr('id')); - overlay.append(handle.clone()); - /* attach the trigger */ - handle.mousedown(function(event) { - var touch_data = { - root: root, overlay: overlay, - hotspot_x: event.pageX - handle.position().left - }; - - $(this).trigger('hpanel:panel-resize-start', touch_data); - return false; - }); - $('.panel-content', panel).css('right', - (handle.outerWidth() || 10) + 'px'); - $('.panel-content-overlay', panel).css('right', - (handle.outerWidth() || 10) + 'px'); - }; - - prev = overlay; - }); - - root.bind('hpanel:panel-resize-start', $.hpanel.resize_start); - }; -})(jQuery); - diff --git a/project/static/js/lib/jquery.js b/project/static/js/lib/jquery.js deleted file mode 100644 index 92635743..00000000 --- a/project/static/js/lib/jquery.js +++ /dev/null @@ -1,4376 +0,0 @@ -/*! - * jQuery JavaScript Library v1.3.2 - * http://jquery.com/ - * - * Copyright (c) 2009 John Resig - * Dual licensed under the MIT and GPL licenses. - * http://docs.jquery.com/License - * - * Date: 2009-02-19 17:34:21 -0500 (Thu, 19 Feb 2009) - * Revision: 6246 - */ -(function(){ - -var - // Will speed up references to window, and allows munging its name. - window = this, - // Will speed up references to undefined, and allows munging its name. - undefined, - // Map over jQuery in case of overwrite - _jQuery = window.jQuery, - // Map over the $ in case of overwrite - _$ = window.$, - - jQuery = window.jQuery = window.$ = function( selector, context ) { - // The jQuery object is actually just the init constructor 'enhanced' - return new jQuery.fn.init( selector, context ); - }, - - // A simple way to check for HTML strings or ID strings - // (both of which we optimize for) - quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/, - // Is it a simple selector - isSimple = /^.[^:#\[\.,]*$/; - -jQuery.fn = jQuery.prototype = { - init: function( selector, context ) { - // Make sure that a selection was provided - selector = selector || document; - - // Handle $(DOMElement) - if ( selector.nodeType ) { - this[0] = selector; - this.length = 1; - this.context = selector; - return this; - } - // Handle HTML strings - if ( typeof selector === "string" ) { - // Are we dealing with HTML string or an ID? - var match = quickExpr.exec( selector ); - - // Verify a match, and that no context was specified for #id - if ( match && (match[1] || !context) ) { - - // HANDLE: $(html) -> $(array) - if ( match[1] ) - selector = jQuery.clean( [ match[1] ], context ); - - // HANDLE: $("#id") - else { - var elem = document.getElementById( match[3] ); - - // Handle the case where IE and Opera return items - // by name instead of ID - if ( elem && elem.id != match[3] ) - return jQuery().find( selector ); - - // Otherwise, we inject the element directly into the jQuery object - var ret = jQuery( elem || [] ); - ret.context = document; - ret.selector = selector; - return ret; - } - - // HANDLE: $(expr, [context]) - // (which is just equivalent to: $(content).find(expr) - } else - return jQuery( context ).find( selector ); - - // HANDLE: $(function) - // Shortcut for document ready - } else if ( jQuery.isFunction( selector ) ) - return jQuery( document ).ready( selector ); - - // Make sure that old selector state is passed along - if ( selector.selector && selector.context ) { - this.selector = selector.selector; - this.context = selector.context; - } - - return this.setArray(jQuery.isArray( selector ) ? - selector : - jQuery.makeArray(selector)); - }, - - // Start with an empty selector - selector: "", - - // The current version of jQuery being used - jquery: "1.3.2", - - // The number of elements contained in the matched element set - size: function() { - return this.length; - }, - - // Get the Nth element in the matched element set OR - // Get the whole matched element set as a clean array - get: function( num ) { - return num === undefined ? - - // Return a 'clean' array - Array.prototype.slice.call( this ) : - - // Return just the object - this[ num ]; - }, - - // Take an array of elements and push it onto the stack - // (returning the new matched element set) - pushStack: function( elems, name, selector ) { - // Build a new jQuery matched element set - var ret = jQuery( elems ); - - // Add the old object onto the stack (as a reference) - ret.prevObject = this; - - ret.context = this.context; - - if ( name === "find" ) - ret.selector = this.selector + (this.selector ? " " : "") + selector; - else if ( name ) - ret.selector = this.selector + "." + name + "(" + selector + ")"; - - // Return the newly-formed element set - return ret; - }, - - // Force the current matched set of elements to become - // the specified array of elements (destroying the stack in the process) - // You should use pushStack() in order to do this, but maintain the stack - setArray: function( elems ) { - // Resetting the length to 0, then using the native Array push - // is a super-fast way to populate an object with array-like properties - this.length = 0; - Array.prototype.push.apply( this, elems ); - - return this; - }, - - // Execute a callback for every element in the matched set. - // (You can seed the arguments with an array of args, but this is - // only used internally.) - each: function( callback, args ) { - return jQuery.each( this, callback, args ); - }, - - // Determine the position of an element within - // the matched set of elements - index: function( elem ) { - // Locate the position of the desired element - return jQuery.inArray( - // If it receives a jQuery object, the first element is used - elem && elem.jquery ? elem[0] : elem - , this ); - }, - - attr: function( name, value, type ) { - var options = name; - - // Look for the case where we're accessing a style value - if ( typeof name === "string" ) - if ( value === undefined ) - return this[0] && jQuery[ type || "attr" ]( this[0], name ); - - else { - options = {}; - options[ name ] = value; - } - - // Check to see if we're setting style values - return this.each(function(i){ - // Set all the styles - for ( name in options ) - jQuery.attr( - type ? - this.style : - this, - name, jQuery.prop( this, options[ name ], type, i, name ) - ); - }); - }, - - css: function( key, value ) { - // ignore negative width and height values - if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 ) - value = undefined; - return this.attr( key, value, "curCSS" ); - }, - - text: function( text ) { - if ( typeof text !== "object" && text != null ) - return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) ); - - var ret = ""; - - jQuery.each( text || this, function(){ - jQuery.each( this.childNodes, function(){ - if ( this.nodeType != 8 ) - ret += this.nodeType != 1 ? - this.nodeValue : - jQuery.fn.text( [ this ] ); - }); - }); - - return ret; - }, - - wrapAll: function( html ) { - if ( this[0] ) { - // The elements to wrap the target around - var wrap = jQuery( html, this[0].ownerDocument ).clone(); - - if ( this[0].parentNode ) - wrap.insertBefore( this[0] ); - - wrap.map(function(){ - var elem = this; - - while ( elem.firstChild ) - elem = elem.firstChild; - - return elem; - }).append(this); - } - - return this; - }, - - wrapInner: function( html ) { - return this.each(function(){ - jQuery( this ).contents().wrapAll( html ); - }); - }, - - wrap: function( html ) { - return this.each(function(){ - jQuery( this ).wrapAll( html ); - }); - }, - - append: function() { - return this.domManip(arguments, true, function(elem){ - if (this.nodeType == 1) - this.appendChild( elem ); - }); - }, - - prepend: function() { - return this.domManip(arguments, true, function(elem){ - if (this.nodeType == 1) - this.insertBefore( elem, this.firstChild ); - }); - }, - - before: function() { - return this.domManip(arguments, false, function(elem){ - this.parentNode.insertBefore( elem, this ); - }); - }, - - after: function() { - return this.domManip(arguments, false, function(elem){ - this.parentNode.insertBefore( elem, this.nextSibling ); - }); - }, - - end: function() { - return this.prevObject || jQuery( [] ); - }, - - // For internal use only. - // Behaves like an Array's method, not like a jQuery method. - push: [].push, - sort: [].sort, - splice: [].splice, - - find: function( selector ) { - if ( this.length === 1 ) { - var ret = this.pushStack( [], "find", selector ); - ret.length = 0; - jQuery.find( selector, this[0], ret ); - return ret; - } else { - return this.pushStack( jQuery.unique(jQuery.map(this, function(elem){ - return jQuery.find( selector, elem ); - })), "find", selector ); - } - }, - - clone: function( events ) { - // Do the clone - var ret = this.map(function(){ - if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) { - // IE copies events bound via attachEvent when - // using cloneNode. Calling detachEvent on the - // clone will also remove the events from the orignal - // In order to get around this, we use innerHTML. - // Unfortunately, this means some modifications to - // attributes in IE that are actually only stored - // as properties will not be copied (such as the - // the name attribute on an input). - var html = this.outerHTML; - if ( !html ) { - var div = this.ownerDocument.createElement("div"); - div.appendChild( this.cloneNode(true) ); - html = div.innerHTML; - } - - return jQuery.clean([html.replace(/ jQuery\d+="(?:\d+|null)"/g, "").replace(/^\s*/, "")])[0]; - } else - return this.cloneNode(true); - }); - - // Copy the events from the original to the clone - if ( events === true ) { - var orig = this.find("*").andSelf(), i = 0; - - ret.find("*").andSelf().each(function(){ - if ( this.nodeName !== orig[i].nodeName ) - return; - - var events = jQuery.data( orig[i], "events" ); - - for ( var type in events ) { - for ( var handler in events[ type ] ) { - jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data ); - } - } - - i++; - }); - } - - // Return the cloned set - return ret; - }, - - filter: function( selector ) { - return this.pushStack( - jQuery.isFunction( selector ) && - jQuery.grep(this, function(elem, i){ - return selector.call( elem, i ); - }) || - - jQuery.multiFilter( selector, jQuery.grep(this, function(elem){ - return elem.nodeType === 1; - }) ), "filter", selector ); - }, - - closest: function( selector ) { - var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(selector) : null, - closer = 0; - - return this.map(function(){ - var cur = this; - while ( cur && cur.ownerDocument ) { - if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selector) ) { - jQuery.data(cur, "closest", closer); - return cur; - } - cur = cur.parentNode; - closer++; - } - }); - }, - - not: function( selector ) { - if ( typeof selector === "string" ) - // test special case where just one selector is passed in - if ( isSimple.test( selector ) ) - return this.pushStack( jQuery.multiFilter( selector, this, true ), "not", selector ); - else - selector = jQuery.multiFilter( selector, this ); - - var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType; - return this.filter(function() { - return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector; - }); - }, - - add: function( selector ) { - return this.pushStack( jQuery.unique( jQuery.merge( - this.get(), - typeof selector === "string" ? - jQuery( selector ) : - jQuery.makeArray( selector ) - ))); - }, - - is: function( selector ) { - return !!selector && jQuery.multiFilter( selector, this ).length > 0; - }, - - hasClass: function( selector ) { - return !!selector && this.is( "." + selector ); - }, - - val: function( value ) { - if ( value === undefined ) { - var elem = this[0]; - - if ( elem ) { - if( jQuery.nodeName( elem, 'option' ) ) - return (elem.attributes.value || {}).specified ? elem.value : elem.text; - - // We need to handle select boxes special - if ( jQuery.nodeName( elem, "select" ) ) { - var index = elem.selectedIndex, - values = [], - options = elem.options, - one = elem.type == "select-one"; - - // Nothing was selected - if ( index < 0 ) - return null; - - // Loop through all the selected options - for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) { - var option = options[ i ]; - - if ( option.selected ) { - // Get the specifc value for the option - value = jQuery(option).val(); - - // We don't need an array for one selects - if ( one ) - return value; - - // Multi-Selects return an array - values.push( value ); - } - } - - return values; - } - - // Everything else, we just grab the value - return (elem.value || "").replace(/\r/g, ""); - - } - - return undefined; - } - - if ( typeof value === "number" ) - value += ''; - - return this.each(function(){ - if ( this.nodeType != 1 ) - return; - - if ( jQuery.isArray(value) && /radio|checkbox/.test( this.type ) ) - this.checked = (jQuery.inArray(this.value, value) >= 0 || - jQuery.inArray(this.name, value) >= 0); - - else if ( jQuery.nodeName( this, "select" ) ) { - var values = jQuery.makeArray(value); - - jQuery( "option", this ).each(function(){ - this.selected = (jQuery.inArray( this.value, values ) >= 0 || - jQuery.inArray( this.text, values ) >= 0); - }); - - if ( !values.length ) - this.selectedIndex = -1; - - } else - this.value = value; - }); - }, - - html: function( value ) { - return value === undefined ? - (this[0] ? - this[0].innerHTML.replace(/ jQuery\d+="(?:\d+|null)"/g, "") : - null) : - this.empty().append( value ); - }, - - replaceWith: function( value ) { - return this.after( value ).remove(); - }, - - eq: function( i ) { - return this.slice( i, +i + 1 ); - }, - - slice: function() { - return this.pushStack( Array.prototype.slice.apply( this, arguments ), - "slice", Array.prototype.slice.call(arguments).join(",") ); - }, - - map: function( callback ) { - return this.pushStack( jQuery.map(this, function(elem, i){ - return callback.call( elem, i, elem ); - })); - }, - - andSelf: function() { - return this.add( this.prevObject ); - }, - - domManip: function( args, table, callback ) { - if ( this[0] ) { - var fragment = (this[0].ownerDocument || this[0]).createDocumentFragment(), - scripts = jQuery.clean( args, (this[0].ownerDocument || this[0]), fragment ), - first = fragment.firstChild; - - if ( first ) - for ( var i = 0, l = this.length; i < l; i++ ) - callback.call( root(this[i], first), this.length > 1 || i > 0 ? - fragment.cloneNode(true) : fragment ); - - if ( scripts ) - jQuery.each( scripts, evalScript ); - } - - return this; - - function root( elem, cur ) { - return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ? - (elem.getElementsByTagName("tbody")[0] || - elem.appendChild(elem.ownerDocument.createElement("tbody"))) : - elem; - } - } -}; - -// Give the init function the jQuery prototype for later instantiation -jQuery.fn.init.prototype = jQuery.fn; - -function evalScript( i, elem ) { - if ( elem.src ) - jQuery.ajax({ - url: elem.src, - async: false, - dataType: "script" - }); - - else - jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" ); - - if ( elem.parentNode ) - elem.parentNode.removeChild( elem ); -} - -function now(){ - return +new Date; -} - -jQuery.extend = jQuery.fn.extend = function() { - // copy reference to target object - var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options; - - // Handle a deep copy situation - if ( typeof target === "boolean" ) { - deep = target; - target = arguments[1] || {}; - // skip the boolean and the target - i = 2; - } - - // Handle case when target is a string or something (possible in deep copy) - if ( typeof target !== "object" && !jQuery.isFunction(target) ) - target = {}; - - // extend jQuery itself if only one argument is passed - if ( length == i ) { - target = this; - --i; - } - - for ( ; i < length; i++ ) - // Only deal with non-null/undefined values - if ( (options = arguments[ i ]) != null ) - // Extend the base object - for ( var name in options ) { - var src = target[ name ], copy = options[ name ]; - - // Prevent never-ending loop - if ( target === copy ) - continue; - - // Recurse if we're merging object values - if ( deep && copy && typeof copy === "object" && !copy.nodeType ) - target[ name ] = jQuery.extend( deep, - // Never move original objects, clone them - src || ( copy.length != null ? [ ] : { } ) - , copy ); - - // Don't bring in undefined values - else if ( copy !== undefined ) - target[ name ] = copy; - - } - - // Return the modified object - return target; -}; - -// exclude the following css properties to add px -var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i, - // cache defaultView - defaultView = document.defaultView || {}, - toString = Object.prototype.toString; - -jQuery.extend({ - noConflict: function( deep ) { - window.$ = _$; - - if ( deep ) - window.jQuery = _jQuery; - - return jQuery; - }, - - // See test/unit/core.js for details concerning isFunction. - // Since version 1.3, DOM methods and functions like alert - // aren't supported. They return false on IE (#2968). - isFunction: function( obj ) { - return toString.call(obj) === "[object Function]"; - }, - - isArray: function( obj ) { - return toString.call(obj) === "[object Array]"; - }, - - // check if an element is in a (or is an) XML document - isXMLDoc: function( elem ) { - return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" || - !!elem.ownerDocument && jQuery.isXMLDoc( elem.ownerDocument ); - }, - - // Evalulates a script in a global context - globalEval: function( data ) { - if ( data && /\S/.test(data) ) { - // Inspired by code by Andrea Giammarchi - // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html - var head = document.getElementsByTagName("head")[0] || document.documentElement, - script = document.createElement("script"); - - script.type = "text/javascript"; - if ( jQuery.support.scriptEval ) - script.appendChild( document.createTextNode( data ) ); - else - script.text = data; - - // Use insertBefore instead of appendChild to circumvent an IE6 bug. - // This arises when a base node is used (#2709). - head.insertBefore( script, head.firstChild ); - head.removeChild( script ); - } - }, - - nodeName: function( elem, name ) { - return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase(); - }, - - // args is for internal usage only - each: function( object, callback, args ) { - var name, i = 0, length = object.length; - - if ( args ) { - if ( length === undefined ) { - for ( name in object ) - if ( callback.apply( object[ name ], args ) === false ) - break; - } else - for ( ; i < length; ) - if ( callback.apply( object[ i++ ], args ) === false ) - break; - - // A special, fast, case for the most common use of each - } else { - if ( length === undefined ) { - for ( name in object ) - if ( callback.call( object[ name ], name, object[ name ] ) === false ) - break; - } else - for ( var value = object[0]; - i < length && callback.call( value, i, value ) !== false; value = object[++i] ){} - } - - return object; - }, - - prop: function( elem, value, type, i, name ) { - // Handle executable functions - if ( jQuery.isFunction( value ) ) - value = value.call( elem, i ); - - // Handle passing in a number to a CSS property - return typeof value === "number" && type == "curCSS" && !exclude.test( name ) ? - value + "px" : - value; - }, - - className: { - // internal only, use addClass("class") - add: function( elem, classNames ) { - jQuery.each((classNames || "").split(/\s+/), function(i, className){ - if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) ) - elem.className += (elem.className ? " " : "") + className; - }); - }, - - // internal only, use removeClass("class") - remove: function( elem, classNames ) { - if (elem.nodeType == 1) - elem.className = classNames !== undefined ? - jQuery.grep(elem.className.split(/\s+/), function(className){ - return !jQuery.className.has( classNames, className ); - }).join(" ") : - ""; - }, - - // internal only, use hasClass("class") - has: function( elem, className ) { - return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1; - } - }, - - // A method for quickly swapping in/out CSS properties to get correct calculations - swap: function( elem, options, callback ) { - var old = {}; - // Remember the old values, and insert the new ones - for ( var name in options ) { - old[ name ] = elem.style[ name ]; - elem.style[ name ] = options[ name ]; - } - - callback.call( elem ); - - // Revert the old values - for ( var name in options ) - elem.style[ name ] = old[ name ]; - }, - - css: function( elem, name, force, extra ) { - if ( name == "width" || name == "height" ) { - var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ]; - - function getWH() { - val = name == "width" ? elem.offsetWidth : elem.offsetHeight; - - if ( extra === "border" ) - return; - - jQuery.each( which, function() { - if ( !extra ) - val -= parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0; - if ( extra === "margin" ) - val += parseFloat(jQuery.curCSS( elem, "margin" + this, true)) || 0; - else - val -= parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0; - }); - } - - if ( elem.offsetWidth !== 0 ) - getWH(); - else - jQuery.swap( elem, props, getWH ); - - return Math.max(0, Math.round(val)); - } - - return jQuery.curCSS( elem, name, force ); - }, - - curCSS: function( elem, name, force ) { - var ret, style = elem.style; - - // We need to handle opacity special in IE - if ( name == "opacity" && !jQuery.support.opacity ) { - ret = jQuery.attr( style, "opacity" ); - - return ret == "" ? - "1" : - ret; - } - - // Make sure we're using the right name for getting the float value - if ( name.match( /float/i ) ) - name = styleFloat; - - if ( !force && style && style[ name ] ) - ret = style[ name ]; - - else if ( defaultView.getComputedStyle ) { - - // Only "float" is needed here - if ( name.match( /float/i ) ) - name = "float"; - - name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase(); - - var computedStyle = defaultView.getComputedStyle( elem, null ); - - if ( computedStyle ) - ret = computedStyle.getPropertyValue( name ); - - // We should always get a number back from opacity - if ( name == "opacity" && ret == "" ) - ret = "1"; - - } else if ( elem.currentStyle ) { - var camelCase = name.replace(/\-(\w)/g, function(all, letter){ - return letter.toUpperCase(); - }); - - ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ]; - - // From the awesome hack by Dean Edwards - // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291 - - // If we're not dealing with a regular pixel number - // but a number that has a weird ending, we need to convert it to pixels - if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) { - // Remember the original values - var left = style.left, rsLeft = elem.runtimeStyle.left; - - // Put in the new values to get a computed value out - elem.runtimeStyle.left = elem.currentStyle.left; - style.left = ret || 0; - ret = style.pixelLeft + "px"; - - // Revert the changed values - style.left = left; - elem.runtimeStyle.left = rsLeft; - } - } - - return ret; - }, - - clean: function( elems, context, fragment ) { - context = context || document; - - // !context.createElement fails in IE with an error but returns typeof 'object' - if ( typeof context.createElement === "undefined" ) - context = context.ownerDocument || context[0] && context[0].ownerDocument || document; - - // If a single string is passed in and it's a single tag - // just do a createElement and skip the rest - if ( !fragment && elems.length === 1 && typeof elems[0] === "string" ) { - var match = /^<(\w+)\s*\/?>$/.exec(elems[0]); - if ( match ) - return [ context.createElement( match[1] ) ]; - } - - var ret = [], scripts = [], div = context.createElement("div"); - - jQuery.each(elems, function(i, elem){ - if ( typeof elem === "number" ) - elem += ''; - - if ( !elem ) - return; - - // Convert html string into DOM nodes - if ( typeof elem === "string" ) { - // Fix "XHTML"-style tags in all browsers - elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){ - return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ? - all : - front + ">"; - }); - - // Trim whitespace, otherwise indexOf won't work as expected - var tags = elem.replace(/^\s+/, "").substring(0, 10).toLowerCase(); - - var wrap = - // option or optgroup - !tags.indexOf("", "" ] || - - !tags.indexOf("", "" ] || - - tags.match(/^<(thead|tbody|tfoot|colg|cap)/) && - [ 1, "", "
    " ] || - - !tags.indexOf("", "" ] || - - // matched above - (!tags.indexOf("", "" ] || - - !tags.indexOf("", "" ] || - - // IE can't serialize and - - {% block extrahead %} - {% endblock %} - - -
    - -
    {% block maincontent %} {% endblock %}
    - - {% block extrabody %}{% endblock %} -
    - - diff --git a/project/templates/explorer/edit_dc.html b/project/templates/explorer/edit_dc.html deleted file mode 100644 index 1ad0c22d..00000000 --- a/project/templates/explorer/edit_dc.html +++ /dev/null @@ -1,4 +0,0 @@ -
    -{{ form.as_p }} - -
    diff --git a/project/templates/explorer/edit_text.html b/project/templates/explorer/edit_text.html deleted file mode 100644 index 1ad0c22d..00000000 --- a/project/templates/explorer/edit_text.html +++ /dev/null @@ -1,4 +0,0 @@ -
    -{{ form.as_p }} - -
    diff --git a/project/templates/explorer/editor.html b/project/templates/explorer/editor.html deleted file mode 100644 index 3c775d4e..00000000 --- a/project/templates/explorer/editor.html +++ /dev/null @@ -1,195 +0,0 @@ -{% extends "base.html" %} - -{% block extrahead %} - - - - - - - - {# Libraries #} - - - - {# Scriptlets #} - - - {# App and views #} - - - - - - - - - - - - - - - {# JavaScript templates #} - - - - - - - - - - - -{% endblock extrahead %} - -{% block breadcrumbs %}Platforma Redakcyjna > {{ fileid }}{% endblock breadcrumbs %} - -{% block header-toolbar %} - Historia - - - - -{% endblock %} - -{% block maincontent %} - - - -
    -
    -
    -
    - - - - -{% endblock maincontent %} - -{% block extrabody %} -
    -{% endblock %} \ No newline at end of file diff --git a/project/templates/explorer/file_html.html b/project/templates/explorer/file_html.html deleted file mode 100644 index ab8e40b4..00000000 --- a/project/templates/explorer/file_html.html +++ /dev/null @@ -1,42 +0,0 @@ -{% extends "base.html" %} - -{% block extrahead %} - - -{% endblock extrahead %} - -{% block breadcrumbs %}Platforma Redakcyjna ❯ plik {{ hash }}{% endblock breadcrumbs %} - -{% block maincontent %} -
    ŹródłoHTML
    {{ image_folders_form.folders }}
     
    - - -
    - {{ object|safe }} -
    -{% endblock maincontent %} \ No newline at end of file diff --git a/project/templates/explorer/file_list.html b/project/templates/explorer/file_list.html deleted file mode 100644 index f44a105c..00000000 --- a/project/templates/explorer/file_list.html +++ /dev/null @@ -1,94 +0,0 @@ -{% extends "base.html" %} - -{% block extrahead %} - - - - -{% endblock extrahead %} - -{% block maincontent %} -
    - -
    -
    -

    - - -

    -
    - {% load explorer_tags %} -
      - {% for file in filetree %} - {% tree_part file %} - {% endfor %} -
    -
    - -
    -

    Ostatnio oglądane pliki:

    -
      -
    -
    - -{% if perms.explorer.can_add_files %} -
    -

    Dodaj nowy utwór

    - -
    - {{ bookform }} -

    -
    - -
    -{% endif %} - -
    -{% endblock maincontent %} diff --git a/project/templates/explorer/file_tree_part.html b/project/templates/explorer/file_tree_part.html deleted file mode 100644 index f65cf28a..00000000 --- a/project/templates/explorer/file_tree_part.html +++ /dev/null @@ -1,13 +0,0 @@ -{% load explorer_tags %} - -
  • - {{ document.name|bookname }} - {% if document.parts %} -
      - {% for part in document.parts %} - {% tree_part part %} - {% endfor %} -
    - {% endif %} -
    • - diff --git a/project/templates/explorer/file_upload.html b/project/templates/explorer/file_upload.html deleted file mode 100755 index 1deedac4..00000000 --- a/project/templates/explorer/file_upload.html +++ /dev/null @@ -1,17 +0,0 @@ -{% extends "base.html" %} - -{% block maincontent %} -

    Dodawanie nowego utworu:

    - -{% if errors %} -
    -{% for error in errors %} -

    {{ error }}: {{ error.errors }}

    -{% endfor %} -
    -{% endif %} -
    - {{ bookform.as_p }} -

    -
    -{% endblock maincontent %} diff --git a/project/templates/explorer/folder_images.html b/project/templates/explorer/folder_images.html deleted file mode 100644 index 8f5f600f..00000000 --- a/project/templates/explorer/folder_images.html +++ /dev/null @@ -1,3 +0,0 @@ -{% for image in images %} -
    {{ image }}
    -{% endfor %} \ No newline at end of file diff --git a/project/templates/explorer/split.html b/project/templates/explorer/split.html deleted file mode 100755 index 8d3b67bb..00000000 --- a/project/templates/explorer/split.html +++ /dev/null @@ -1,26 +0,0 @@ -
    -
    - Split options - {% for field in splitform %} - {% if field.is_hidden %} - {{ field}} - {% else %} - {{ field.errors }} - {% ifequal field.html_name 'splitform-autoxml' %} -

    - {% else %} -

    - {% endifequal %} - {% endif %} - {% endfor %} -
    - - -

    - - -

    -
    diff --git a/project/templates/explorer/split_success.html b/project/templates/explorer/split_success.html deleted file mode 100755 index 4f3a57b8..00000000 --- a/project/templates/explorer/split_success.html +++ /dev/null @@ -1,3 +0,0 @@ -

    Split successful. You can edit the new part here: -{% url editor_view cfileid %}

    -

    \ No newline at end of file diff --git a/project/templates/html4print.html b/project/templates/html4print.html deleted file mode 100644 index 1b4ef319..00000000 --- a/project/templates/html4print.html +++ /dev/null @@ -1,13 +0,0 @@ - - - - {{docid}} - - - - -
    - {{ output|safe }} -
    - - diff --git a/project/templates/manager/pull_request.html b/project/templates/manager/pull_request.html deleted file mode 100644 index c2964c22..00000000 --- a/project/templates/manager/pull_request.html +++ /dev/null @@ -1,75 +0,0 @@ -{% extends 'base.html' %} - -{% block extrahead %} - - -{% endblock %} - -{% block maincontent %} - - - - - -{% if objects %} - {% for pullreq in objects %} - - - - - - - - - {% endfor %} -{% else %} - -{% endif %} -
    UtwórUżytkownikKomentarzStanAkcje
    {{ pullreq.document }}{{ pullreq.comitter }}{{ pullreq.comment }} {{ pullreq.status }}
    Brak żądań
    - -{% endblock %} diff --git a/project/templates/registration/head_login.html b/project/templates/registration/head_login.html deleted file mode 100644 index 5eb353d0..00000000 --- a/project/templates/registration/head_login.html +++ /dev/null @@ -1,10 +0,0 @@ -{% if user.is_authenticated %} -{{ user.username }} | -Wyloguj -{% else %} -{% url login as login_url %} -{% ifnotequal login_url request.path %} - Logowanie -{% endifnotequal %} - -{% endif %} diff --git a/project/templates/registration/login.html b/project/templates/registration/login.html deleted file mode 100644 index 810bd4ec..00000000 --- a/project/templates/registration/login.html +++ /dev/null @@ -1,15 +0,0 @@ -{% extends "base.html" %} - -{% block subtitle %} - Logowanie {% endblock subtitle %} - -{% block maincontent %} - -
    -
    -{{ form.as_p }} -

    - -
    -
    - -{% endblock maincontent %} diff --git a/project/templates/wysiwyg.html b/project/templates/wysiwyg.html deleted file mode 100644 index a592bf11..00000000 --- a/project/templates/wysiwyg.html +++ /dev/null @@ -1,30 +0,0 @@ -{% extends 'base.html' %} - -{% block maincontent %} -

    Wysiwyg editor

    -
    This part is not editable!
    -
    - -

    -

    Lorem ipsum dolor sit amet, consectetur adipiscing elit. - Suspendisse a urna eu enim rutrum elementum nec sed nibh. Quisque sed tortor - nulla, et euismod turpis. Morbi purus nulla, vulputate in vulputate id, gravida - id eros. In interdum est tempor est consequat imperdiet. Vivamus vitae ligula quam. - Proin nibh quam, tincidunt sit amet auctor eget, laoreet sit amet eros. Cras augue - lectus, euismod nec posuere ac, ultricies sed magna. Aliquam a lacinia sapien. - Cras imperdiet urna vel dui accumsan mollis. Suspendisse convallis tincidunt ornare. - Aenean convallis libero in lectus dictum vestibulum interdum ipsum suscipit. - Suspendisse sed justo sapien, eu egestas libero. Sed tincidunt sagittis sollicitudin. - Aliquam erat volutpat. Nullam egestas dolor id massa sagittis at sagittis ipsum - hendrerit. -

    - -

    Phasellus sed purus non orci eleifend posuere ac eu elit. Etiam orci justo, porta vitae varius in, scelerisque sed metus. Phasellus faucibus lorem at metus scelerisque sit amet sollicitudin dolor dignissim. Aliquam eu justo in diam blandit posuere at a diam. Pellentesque tristique sem eu odio gravida eleifend. Phasellus cursus adipiscing metus, nec pharetra enim pharetra ac. Pellentesque faucibus volutpat lorem nec vulputate. Mauris in faucibus ipsum. Nulla ut urna nulla. Sed at tellus nec diam posuere porttitor. Duis faucibus, libero nec rhoncus facilisis, tortor ligula adipiscing massa, nec varius justo ante et magna. Donec orci mauris, ultrices nec blandit vel, lacinia in ante. Maecenas libero mi, pretium id ultricies eget, fringilla sit amet risus. Integer ut ante sem, et condimentum odio. Nam nec est erat. Etiam ut metus ligula. In vel condimentum orci.

    - -

    Suspendisse potenti. Proin in augue nibh. Curabitur in sollicitudin ipsum. In ut leo vel purus volutpat tempus. Proin ut neque at augue euismod ullamcorper nec ac dui. Vestibulum id quam nunc, eu porta augue. Pellentesque interdum neque eu nulla rhoncus vulputate. Sed viverra diam ac sem consectetur semper. Quisque consectetur fringilla quam, in feugiat nisl vulputate quis. Fusce vel ipsum lectus, eu interdum nunc. Donec luctus libero vitae mauris imperdiet at iaculis magna aliquet. Curabitur ullamcorper, diam nec pulvinar venenatis, nibh ante volutpat mauris, nec tristique lectus sem in urna. Aenean eu malesuada metus. Integer auctor nulla sit amet ligula sollicitudin ut accumsan velit ullamcorper. Donec nec auctor augue.

    - -

    Maecenas eget lacus vitae velit tincidunt bibendum quis et diam. In ullamcorper condimentum velit, et elementum felis vestibulum facilisis. Donec vitae cursus ipsum. Cras accumsan tincidunt aliquet. Nulla pellentesque mattis magna aliquet hendrerit. Pellentesque pellentesque odio enim. Duis viverra rhoncus tristique. In in risus ligula. Nullam dapibus lacinia facilisis. Ut eu neque neque, tristique laoreet nisl. Aliquam placerat dignissim leo, tristique tempor est vestibulum ut.

    - -

    Donec semper tempus ante, eget gravida erat varius et. Suspendisse aliquam rutrum nunc ac pulvinar. Aliquam erat volutpat. Nulla consectetur ultricies imperdiet. Nulla tincidunt est vitae augue porttitor a faucibus odio facilisis. In nec nisl odio. Aliquam et libero tortor, eu tincidunt mi. Vivamus suscipit erat sed mi hendrerit fringilla. Integer iaculis tempus nulla, at egestas velit faucibus ut. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Vestibulum vel massa enim. Aliquam erat volutpat. In ligula tortor, fermentum eu suscipit at, posuere vel nunc. Nullam nibh magna, sollicitudin at semper et, mattis ut quam. Curabitur accumsan semper elit ac posuere. Sed sit amet lorem tortor, vel porttitor justo. Fusce odio metus, bibendum ut bibendum sit amet, luctus a ipsum.

    -
    -{% endblock %} \ No newline at end of file diff --git a/project/urls.py b/project/urls.py deleted file mode 100644 index e107635e..00000000 --- a/project/urls.py +++ /dev/null @@ -1,71 +0,0 @@ -# -*- coding: utf-8 -*- - -from django.conf.urls.defaults import * -from django.contrib import admin -from django.conf import settings - -admin.autodiscover() -PATH_SEC = r"(?P[^/]+)" -PATH_END = PATH_SEC + "/$" - -urlpatterns = patterns('', - # Explorer: - url(r'^$', 'explorer.views.file_list', name='file_list'), - url(r'^file/upload', 'explorer.views.file_upload', name='file_upload'), - - - url(r'^managment/pull-requests$', 'explorer.views.pull_requests'), - -# url(r'^images/(?P[^/]+)/$', 'explorer.views.folder_images', name='folder_image'), -# url(r'^images/$', 'explorer.views.folder_images', {'folder': '.'}, name='folder_image_ajax'), - - # Editor panels - # url(r'^editor/'+PATH_SEC+'/panel/(?P[a-z]+)/$', 'explorer.views.panel_view', name='panel_view'), - url(r'^editor/'+PATH_END, 'explorer.views.display_editor', name='editor_view'), - url(r'^editor/$', 'explorer.views.file_list', name='editor_base'), - - # url(r'^editor/'+PATH_SEC+'/split$', 'explorer.views.split_text'), - # url(r'^editor/'+PATH_SEC+'/split-success', - # 'explorer.views.split_success', name='split-success'), - - # url(r'^editor/'+PATH_SEC+'/print/html$', 'explorer.views.print_html'), - # url(r'^editor/'+PATH_SEC+'/print/xml$', 'explorer.views.print_xml'), - - url(r'^file/(?P[^/]+)/print$', 'explorer.views.print_html', name="file_print"), - # Task managment - # url(r'^manager/pull-requests$', 'explorer.views.pull_requests'), - - # Admin panel - url(r'^admin/doc/', include('django.contrib.admindocs.urls')), - url(r'^admin/(.*)', admin.site.root), - - # Prototypes -# url(r'^wysiwyg-proto/', include('wysiwyg.urls')), - - # Our über-restful api - url(r'^api/', include('api.urls') ), - -) - -if 'cas_consumer' in settings.INSTALLED_APPS: - urlpatterns += patterns('', - # django-cas-consumer - url(r'^accounts/login/$', 'cas_consumer.views.login', name='login'), - url(r'^accounts/logout/$', 'cas_consumer.views.logout', name='logout'), - ) -else: - urlpatterns += patterns('', - # Django auth - url(r'^accounts/login/$', 'django.contrib.auth.views.login', {'redirect_field_name': 'next'}, name='login'), - url(r'^accounts/logout/$', 'django.contrib.auth.views.logout', {'next_page': '/'}, name='logout'), - ) - -# Static files -if settings.DEBUG and not hasattr(settings, 'DONT_SERVE_STATIC'): - urlpatterns += patterns('', - url(r'^%s(?P.+)$' % settings.MEDIA_URL[1:], 'django.views.static.serve', - {'document_root': settings.MEDIA_ROOT, 'show_indexes': True}), - url(r'^%s(?P.+)$' % settings.STATIC_URL[1:], 'django.views.static.serve', - {'document_root': settings.STATIC_ROOT, 'show_indexes': True}), - ) -# \ No newline at end of file