pax_global_header00006660000000000000000000000064126414737610014525gustar00rootroot0000000000000052 comment=2beab165ccef354115870a685e9882cdea06c467 dactyl-1.2~r20151231/000077500000000000000000000000001264147376100140465ustar00rootroot00000000000000dactyl-1.2~r20151231/.gitignore000066400000000000000000000006611264147376100160410ustar00rootroot00000000000000## To see if new rules exclude any existing files, run ## ## git ls-files -i --exclude-standard ## ## after modifying this file. ## Generated by the build process *.xpi */locale/*/*.html */chrome */contrib/vim/*.vba ## Editor backup and swap files *~ .\#* \#**\# .*.sw[op] .sw[op] ## Generated by Mac filesystem .DS_Store ## For rejects *.orig *.rej *.ancestor *.current *.patched ## Generated by StGit patches-* .stgit-*.txt dactyl-1.2~r20151231/.hgignore000066400000000000000000000007651264147376100156610ustar00rootroot00000000000000## To see if new rules exclude any existing files, run ## ## hg status -i ## ## after modifying this file. syntax: glob ## Generated by the build process *.xpi *.o *.so *.xpt */.depend */config.local.mk */locale/*/*.html */chrome */contrib/vim/*.vba */bak/* downloads/* .git/* binary/src/*/*.h common/tests/functional/log *.py[co] ## Editor backup and swap files *~ .#* \#**\# .*.sw[op] .sw[op] ## Generated by Mac filesystem .DS_Store syntax: regexp ## For rejects \.(orig|rej|bak|diff)$ dactyl-1.2~r20151231/.hgtags000066400000000000000000000034321264147376100153260ustar00rootroot00000000000000c5d6d5cd0dd426585f8e5afa314183208a610e59 muttator-0.5 fe9ffcfb48c7050f5e6872285ff0197eb54cf213 vimperator-0.4.1 d063e0e23d668dcf807e2032f032a3d23486ec48 vimperator-0.5 ce28bfd79dcc119abf59e9318d524144f45d53f5 vimperator-0.5-branch-HEAD-merge-1 019506ce1fa1a647f27fb4aed293b6e0fe629d31 vimperator-0.5.1 605db9f5c6cb5a1d65c95211f78d0a480a1566fd vimperator-0.5.2 3b8c0bcbbf8663fde9f959efbc1ad5fda3d9d1f6 vimperator-0.5.3 c9273973fc735678c3930bc15fb4915414907d23 vimperator-1.0 96b65677b4c5a29525fd791aaadbc51a4ba7b7c2 vimperator-1.1 ff456886599eb7ad2cdd718eac498b6c8a9efc75 vimperator-1.2 e34e4c4a9c24488f570d08200182542134e05f29 vimperator-2.0 e34e4c4a9c24488f570d08200182542134e05f29 vimperator-2.0 f65383ca4fc4872827f3f23350ae503c93cd66a4 vimperator-2.0a1 75873caffbe7327bfd1c27e615378d2a196a9286 vimperator-2.1 7777c3e4d29893701a64f46adbd60b3b06cda7a6 vimperator-2.2b1 d4c91b705d551c63c5a0d929248ec873e978a188 vimperator-2.2 ca14d185b1506c77b748925770731b66d3dddfbe xulmus-0.1 a82034b6ed8fe0c5bc43123969b655423f95511d pentadactyl-1.0b1 15d6abbda4221b30181f8459a3627e00b42f93d6 pentadactyl-1.0b2 ffa3aaf7882250fb665d8ead4375f529f3e99070 pentadactyl-1.0b3 2c21fc6135f832c7bbadf43586d2ffe585f02f60 pentadactyl-1.0b4 1f1342f58d8e7d3972928f193e3f40cbf4425230 pentadactyl-1.0b4.1 962d8a1e823d0855e14aecaa294ef02e718401b1 pentadactyl-1.0b4.2 d783bcace8c6a24bee7bd22ead22fe44baaebe90 pentadactyl-1.0b4.3 b83bb8e6d273f71b1278c4ee03376594ad6dd039 pentadactyl-1.0b6 0000000000000000000000000000000000000000 vimperator-2.2~beta1 0000000000000000000000000000000000000000 vimperator-2.0~alpha1 2281deb4c1323643dfc130c43d79f1a14f4a761a pentadactyl-1.0b7 5dd2b03a5cec255665f2502177d228c76ed93711 pentadactyl-1.0b7.1 91d4f03a135efe65e2e7de46c00ef09c78fdaae3 pentadactyl-1.0rc1 04b371d79ec323e4ddeb1a956539afb4992fbb33 pentadactyl-1.1 dactyl-1.2~r20151231/BREAKING_CHANGES000066400000000000000000000000701264147376100163000ustar00rootroot000000000000001.0b8: • The chrome-data: protocol has been removed. dactyl-1.2~r20151231/HACKING000066400000000000000000000115111264147376100150340ustar00rootroot00000000000000= Hacking = If you've taken to hacking Pentadactyl source code, we hope that you'll share your changes. In case you do, please keep the following in mind, and we'll be happy to accept your patches. == Documentation == First of all, all new features and all user-visible changes to existing features need to be documented. That means editing the appropriate help files and adding a NEWS entry where appropriate. When editing the NEWS file, you should add your change to the top of the list of changes. If your change alters an interface (key binding, command) and is likely to cause trouble, prefix it with 'IMPORTANT:', otherwise, place it below the other 'IMPORTANT' entries. If you're not sure if your change merits a news entry, or if it's important, please ask. == Coding Style == In general: Just look at the existing source code! === The most important style issues are: === * Use 4 spaces to indent things, no tabs, not 2, nor 8 spaces. If you use Vim, this should be taken care of automatically by the modeline (like the one below). * No trailing whitespace. * Use " for enclosing strings instead of ', unless using ' avoids escaping of lots of " Example: alert("foo") instead of alert('foo'); * Use // regexp literals rather than RegExp constructors, unless you're constructing an expression on the fly, or RegExp constructors allow you to escape less /s than the additional escaping of special characters required by string quoting. Good: /application\/xhtml\+xml/ Bad: RegExp("application/xhtml\\+xml") Good: RegExp("http://(www\\.)vimperator.org/(.*)/(.*)") Bad: /http:\/\/(www\.)vimperator.org\/(.*)\/(.*)/ * Exactly one space after if/for/while/catch etc. and after a comma, but none after a parenthesis or after a function call: for (pre; condition; post) but: alert("foo"); * Bracing is formatted as follows: function myFunction () { if (foo) return bar; else { baz = false; return baz; } } var quux = frob("you", { a: 1, b: 42, c: { hoopy: "frood" } }); When in doubt, look for similar code. * No braces for one-line conditional statements: Right: if (foo) frob(); else unfrob(); * Prefer lambda-style functions where suitable: Right: list.filter(function (elem) elem.good != elem.BAD); Wrong: list.filter(function (elem) { return elem.good != elem.BAD }); Right: list.forEach(function (elem) { window.alert(elem); }); Wrong: list.forEach(function (elem) window.alert(elem)); * Anonymous function definitions should be formatted with a space after the keyword "function". Example: function () {}, not function() {}. * Prefer the use of let over var i.e. only use var when required. For more details, see https://developer.mozilla.org/en/New_in_JavaScript_1.7#Block_scope_with_let * Reuse common local variable names E.g. "elem" is generally used for element, "win" for windows, "func" for functions, "res" for return values etc. * Prefer // over /* */ comments (exceptions for big comments are usually OK) Right: if (HACK) // TODO: remove hack Wrong: if (HACK) /* TODO: remove hack */ * Documentation comment blocks use /** ... */ Wrap these lines at 80 characters. * Only wrap lines if it makes the code obviously clearer. Lines longer than 132 characters should probably be broken up rather than wrapped anyway. * Use UNIX new lines (\n), not windows (\r\n) or old Mac ones (\r) * Use Iterators or Array#forEach to iterate over arrays. for (let i in ary) and for each (let i in ary) include members in an Array.prototype, which some extensions alter. Right: for (let [,elem] in Iterator(ary)) for (let [k, v] in Iterator(obj)) ary.forEach(function (elem) { ... Wrong: for each (let elem in ary) The exceptions to this rule are for objects with __iterator__ set. * Avoid using 'new' with constructors where possible, and use [] and {} rather than new Array/new Object. Right: RegExp("^" + foo + "$") Function(code) new Date Wrong: new RegExp("^" + foo + "$") new Function(code) Date() // Right if you want a string-representation of the date * Don't use abbreviations for public methods Right: function splitString()... let commands = ...; let cmds = ...; // Since it's only used locally, abbreviations are ok, but so are the full names Wrong: function splitStr() == Testing == Functional tests are implemented using the Mozmill automated testing framework -- https://developer.mozilla.org/en/Mozmill_Tests. A fresh profile is created for the duration of the test run. The host application binary tested can be overridden via the HOSTAPP_PATH makefile variable. E.g., $ HOSTAPP_PATH=/path/to/firefox make -e -C pentadactyl test // vim: fdm=marker sw=4 ts=4 et ai: dactyl-1.2~r20151231/LICENSE.txt000066400000000000000000000023771264147376100157020ustar00rootroot00000000000000Copyright © 2006-2009 by Martin Stubenschrott Copyright © 2007-2011 by Doug Kearns Copyright © 2008-2011 by Kris Maglione For a full list of authors, refer the AUTHORS file. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. dactyl-1.2~r20151231/Makefile000066400000000000000000000003311264147376100155030ustar00rootroot00000000000000DIRS = teledactyl pentadactyl melodactyl TARGETS = clean distclean doc help info jar release xpi .SILENT: all: xpi ; $(TARGETS:%=\%.%): echo MAKE $@ $(MAKE) -C $* $(@:$*.%=%) $(TARGETS): $(MAKE) $(DIRS:%=%.$@) dactyl-1.2~r20151231/binary/000077500000000000000000000000001264147376100153325ustar00rootroot00000000000000dactyl-1.2~r20151231/binary/chrome.manifest000066400000000000000000000004561264147376100203440ustar00rootroot00000000000000 manifest components/gecko-6.manifest appversion>=6.0 manifest components/gecko-7.manifest appversion>=7.0 manifest components/gecko-8.manifest platformversion>7.* manifest components/gecko-9.manifest platformversion>8.* manifest components/gecko-10.manifest platformversion>9.* # vim:se tw=0 ft=cfg: dactyl-1.2~r20151231/binary/config.mk000066400000000000000000000017001264147376100171260ustar00rootroot00000000000000 GECKO_MAJOR ?= 10 GECKO_MINOR ?= 0 ABI_OS := $(shell uname -s) ABI_ARCH := $(shell uname -m) ABI_COMPILER := gcc3 ABI_PLATFORM ?= $(ABI_OS)_$(ABI_ARCH)-$(ABI_COMPILER) ABI ?= $(GECKO_MAJOR).$(GECKO_MINOR)-$(ABI_PLATFORM) DEFINES = -DGECKO_MAJOR=$(GECKO_MAJOR) -DGECKO_MINOR=$(GECKO_MINOR) LIBEXT ?= so SED := $(shell if [ "xoo" = x$$(echo foo | sed -E 's/f(o)/\1/' 2>/dev/null) ]; \ then echo sed -E; else echo sed -r; \ fi) PKGCONFIG ?= pkg-config GECKO_SDK_PATH := $(shell $(PKGCONFIG) --libs libxul | $(SED) 's,([^-]|-[^L])*-L([^ ]+)/lib.*,\2,') CXX ?= c++ CPP = $(CXX) -o LINK ?= c++ MKDEP ?= $(CXX) -M PYTHON ?= python2 EXCPPFLAGS = -fno-rtti \ -fno-exceptions \ -fshort-wchar \ -fPIC \ -Os \ $(NULL) XPIDL ?= $(PYTHON) $(GECKO_SDK_PATH)/sdk/bin IDL_H ?= $(XPIDL)/header.py -o IDL_XPT ?= $(XPIDL)/typelib.py -o dactyl-1.2~r20151231/binary/install.rdf000066400000000000000000000021271264147376100174770ustar00rootroot00000000000000 dactyl-1.2~r20151231/binary/src/000077500000000000000000000000001264147376100161215ustar00rootroot00000000000000dactyl-1.2~r20151231/binary/src/Makefile000066400000000000000000000043671264147376100175730ustar00rootroot00000000000000ROOT = .. XPTDIR = $(ROOT)/components/$(ABI)/ SODIR = $(ROOT)/components/$(ABI)/ OBJDIR = $(ABI)/ MODULE = $(SODIR)dactyl XPIDLSRCS = \ dactylIUtils.idl \ $(NULL) CPPSRCS = \ dactylModule.cpp \ dactylUtils.cpp \ mozJSLoaderUtils.cpp \ subscriptLoader.cpp \ $(NULL) HEADERS = \ config.h \ dactylUtils.h \ mozJSLoaderUtils.h \ $(XPIDLSRCS:%.idl=$(ABI)/%.h) GECKO_DEFINES = -DMOZILLA_STRICT_API GECKO_INCLUDES = -I$(ABI)/ \ -I$(GECKO_SDK_PATH) \ -I$(GECKO_SDK_PATH)/idl \ -I$(GECKO_SDK_PATH)/include GECKO_LDFLAGS = -L$(GECKO_SDK_PATH)/bin \ -L$(GECKO_SDK_PATH)/lib \ -lxpcomglue_s \ -lxpcom \ -lnspr4 \ -shared \ $(NULL) ifeq "$(shell uname -s)" "Darwin" GECKO_LDFLAGS += -undefined dynamic_lookup endif include $(ROOT)/config.mk sinclude $(ROOT)/config.local.mk CPPFLAGS += $(EXCPPFLAGS) XPTS = $(XPIDLSRCS:%.idl=$(XPTDIR)%.xpt) OBJS = $(CPPSRCS:%.cpp=$(OBJDIR)%.o) MANIFEST = $(SODIR)/components.manifest all: build manifest dirs: $(XPTDIR) $(SODIR) $(OBJDIR) depend: .depend manifest: $(MANIFEST) module: dirs $(MODULE).so dll: dirs $(MODULE).dll xpts: $(XPTS) build: dirs module xpts clean: rm $(MODULE).so $(OBJS): $(HEADERS) $(ABI)/%.h: %.idl $(IDL_H) $@ $(GECKO_INCLUDES) $< $(XPTDIR)%.xpt: %.idl $(IDL_XPT) $@ $(GECKO_INCLUDES) $< $(MANIFEST): Makefile ( echo interfaces $(XPIDLSRCS:.idl=.xpt); \ echo binary-component $(MODULE:$(SODIR)%=%).$(LIBEXT) ) \ >$@ manifest=$(SODIR)/../gecko-$(GECKO_MAJOR).manifest; \ if [ $(GECKO_MAJOR) -lt 8 ]; then part=app; else part=platform; fi; \ line="manifest $(ABI)/components.manifest abi=$(ABI_PLATFORM) $${part}version<$(GECKO_MAJOR).*"; \ grep >/dev/null 2>&1 "^$$line$$" $$manifest || echo $$line >>$$manifest _CPPFLAGS = $(CPPFLAGS) $(CXXFLAGS) $(GECKO_DEFINES) $(GECKO_INCLUDES) $(DEFINES) $(OBJDIR)%.o: %.cpp Makefile $(CPP)$@ -c $(_CPPFLAGS) $< .depend: $(CPPSRCS) Makefile $(MKDEP) $(_CPPFLAGS) $(CPPSRCS) | $(SED) 's;^[^ ];$(OBJDIR)&;' >.depend $(MODULE).so: $(OBJS) $(LINK) -o $@ $(OBJS) $(LDFLAGS) $(GECKO_LDFLAGS) chmod +x $@ $(MODULE).dll: $(OBJS) $(LINK)$@ $(GECKO_LDFLAGS) $(OBJS) $(sort $(XPTDIR) $(SODIR) $(OBJDIR)): mkdir -p $@ .PHONY: module xpts build clean all depend manifest sinclude .depend dactyl-1.2~r20151231/binary/src/config.h000066400000000000000000000000511264147376100175330ustar00rootroot00000000000000#pragma once #include "mozilla-config.h" dactyl-1.2~r20151231/binary/src/dactylIUtils.idl000066400000000000000000000017021264147376100212250ustar00rootroot00000000000000/* Public Domain */ #include "nsISupports.idl" #include "nsIDOMElement.idl" %{C++ #include "jsapi.h" %} [scriptable, uuid(d8ef4492-8f4a-4f5d-8f19-1d71f7f895ed)] interface dactylIUtils : nsISupports { const PRUint32 DIRECTION_HORIZONTAL = 1 << 0; const PRUint32 DIRECTION_VERTICAL = 1 << 1; [implicit_jscontext] jsval createGlobal(); [implicit_jscontext] jsval evalInContext(in AString source, in jsval target, [optional] in ACString filename, [optional] in PRInt32 lineNumber); void createContents(in nsIDOMElement element); [implicit_jscontext] jsval getGlobalForObject(in jsval object); PRUint32 getScrollable(in nsIDOMElement element); void loadSubScript (in wstring url /* [optional] in jsval context, */ /* [optional] in wstring charset */); }; /* vim:se sts=4 sw=4 et ft=idl: */ dactyl-1.2~r20151231/binary/src/dactylModule.cpp000066400000000000000000000017451264147376100212620ustar00rootroot00000000000000#include "dactylUtils.h" #include "mozilla/ModuleUtils.h" #define NS_DACTYLUTILS_CID \ { 0x4d55a47c, 0x0627, 0x4339, \ { 0x97, 0x91, 0x52, 0xef, 0x5e, 0xd4, 0xc3, 0xd1 } } #define NS_DACTYLUTILS_CONTRACTID \ "@dactyl.googlecode.com/extra/utils" NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(dactylUtils, Init) NS_DEFINE_NAMED_CID(NS_DACTYLUTILS_CID); static const mozilla::Module::CIDEntry kDactylCIDs[] = { { &kNS_DACTYLUTILS_CID, true, NULL, dactylUtilsConstructor }, { NULL } }; static const mozilla::Module::ContractIDEntry kDactylContracts[] = { { NS_DACTYLUTILS_CONTRACTID, &kNS_DACTYLUTILS_CID }, { NULL } }; static const mozilla::Module::CategoryEntry kDactylCategories[] = { { NULL } }; static const mozilla::Module kDactylUtilsModule = { mozilla::Module::kVersion, kDactylCIDs, kDactylContracts, kDactylCategories, NULL, NULL, NULL }; NSMODULE_DEFN(dactylUtilsModule) = &kDactylUtilsModule; /* vim:se sts=4 sw=4 et cin ft=cpp: */ dactyl-1.2~r20151231/binary/src/dactylUtils.cpp000066400000000000000000000262331264147376100211340ustar00rootroot00000000000000/* * ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. * * Contributors, possibly: * Kris Maglione * Jeff Walden * Mike Shaver * John Bandhauer * Robert Ginda * Pierre Phaneuf * * Alternatively, the contents of this file may be used under the terms of * either of the GNU General Public License Version 2 or later (the "GPL"), * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only * under the terms of either the GPL or the LGPL, and not to allow others to * use your version of this file under the terms of the MPL, indicate your * decision by deleting the provisions above and replace them with the notice * and other provisions required by the GPL or the LGPL. If you do not delete * the provisions above, a recipient may use your version of this file under * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ #include "dactylUtils.h" #include "jsdbgapi.h" // #include "jsobj.h" #include "nsStringAPI.h" #if GECKO_MAJOR < 10 static inline JSObject* JS_GetGlobalForScopeChain(JSContext *cx) { JSObject *callingScope = JS_GetScopeChain(cx); if (!callingScope) return nsnull; return JS_GetGlobalForObject(cx, callingScope); } #endif /* * Evil. Evil, evil, evil. */ #define MOZILLA_INTERNAL_API # define nsAString_h___ # define nsString_h___ # define nsStringFwd_h___ # define nsStringGlue_h__ # define nsContentUtils_h___ class nsAFlatCString; typedef nsString nsSubstring; # include "nsIScrollableFrame.h" #undef MOZILLA_INTERNAL_API #include "nsPresContext.h" #include "nsQueryFrame.h" #include "nsIContent.h" #include "nsIDOMXULElement.h" #include "nsIXULTemplateBuilder.h" #include "nsIObserverService.h" #include "nsIScriptSecurityManager.h" #include "nsIXPCScriptable.h" #include "nsComponentManagerUtils.h" #include "nsServiceManagerUtils.h" class autoDropPrincipals { public: autoDropPrincipals(JSContext *context, JSPrincipals *principals) : mContext(context), mJSPrincipals(principals) {} ~autoDropPrincipals() { JSPRINCIPALS_DROP(mContext, mJSPrincipals); } private: JSContext *mContext; JSPrincipals *mJSPrincipals; }; static JSBool Dump(JSContext *cx, uintN argc, jsval *vp) { JSString *str; if (!argc) return JS_TRUE; str = JS_ValueToString(cx, JS_ARGV(cx, vp)[0]); if (!str) return JS_FALSE; size_t length; const jschar *chars = JS_GetStringCharsAndLength(cx, str, &length); if (!chars) return JS_FALSE; fputs(NS_ConvertUTF16toUTF8(reinterpret_cast(chars)).get(), stderr); return JS_TRUE; } static JSFunctionSpec gGlobalFun[] = { {"dump", Dump, 1,0}, {nsnull,nsnull,0,0} }; static dactylUtils* gService = nsnull; dactylUtils::dactylUtils() : mRuntime(nsnull) { NS_ASSERTION(gService == nsnull, "Service already exists"); } dactylUtils::~dactylUtils() { mRuntimeService = nsnull; gService = nsnull; } nsresult dactylUtils::Init() { nsresult rv; NS_ENSURE_TRUE(!gService, NS_ERROR_UNEXPECTED); mRuntimeService = do_GetService("@mozilla.org/js/xpc/RuntimeService;1", &rv); NS_ENSURE_SUCCESS(rv, rv); rv = mRuntimeService->GetRuntime(&mRuntime); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr secman = do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID); NS_ENSURE_TRUE(secman, NS_ERROR_FAILURE); rv = secman->GetSystemPrincipal(getter_AddRefs(mSystemPrincipal)); NS_ENSURE_TRUE(rv, rv); NS_ENSURE_TRUE(mSystemPrincipal, NS_ERROR_FAILURE); return NS_OK; } NS_IMPL_ISUPPORTS1(dactylUtils, dactylIUtils) NS_IMETHODIMP dactylUtils::CreateGlobal(JSContext *cx, jsval *out) { nsresult rv; // JS::AutoPreserveCompartment pc(cx); nsCOMPtr backstagePass; rv = mRuntimeService->GetBackstagePass(getter_AddRefs(backstagePass)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr xpc = do_GetService("@mozilla.org/js/xpc/XPConnect;1", &rv); NS_ENSURE_SUCCESS(rv, rv); // Make sure InitClassesWithNewWrappedGlobal() installs the // backstage pass as the global in our compilation context. JS_SetGlobalObject(cx, nsnull); nsCOMPtr holder; rv = xpc->InitClassesWithNewWrappedGlobal(cx, backstagePass, NS_GET_IID(nsISupports), mSystemPrincipal, nsnull, nsIXPConnect:: FLAG_SYSTEM_GLOBAL_OBJECT, getter_AddRefs(holder)); NS_ENSURE_SUCCESS(rv, rv); JSObject *global; rv = holder->GetJSObject(&global); NS_ENSURE_SUCCESS(rv, rv); JSAutoEnterCompartment ac; NS_ENSURE_TRUE(ac.enter(cx, global), NS_ERROR_FAILURE); NS_ENSURE_TRUE(JS_DefineFunctions(cx, global, gGlobalFun), NS_ERROR_FAILURE); NS_ENSURE_TRUE(JS_DefineProfilingFunctions(cx, global), NS_ERROR_FAILURE); *out = OBJECT_TO_JSVAL(global); return NS_OK; } NS_IMETHODIMP dactylUtils::EvalInContext(const nsAString &aSource, const jsval &aTarget, const nsACString &aFilename, PRInt32 aLineNumber, JSContext *cx, jsval *rval) { nsresult rv; nsCOMPtr xpc(do_GetService(nsIXPConnect::GetCID(), &rv)); NS_ENSURE_SUCCESS(rv, rv); nsCString filename; if (!aFilename.IsEmpty()) filename.Assign(aFilename); else { nsCOMPtr frame; xpc->GetCurrentJSStack(getter_AddRefs(frame)); NS_ENSURE_TRUE(frame, NS_ERROR_FAILURE); frame->GetFilename(getter_Copies(filename)); frame->GetLineNumber(&aLineNumber); } JSObject *target; NS_ENSURE_FALSE(JSVAL_IS_PRIMITIVE(aTarget), NS_ERROR_UNEXPECTED); target = JSVAL_TO_OBJECT(aTarget); JSObject *result = target; target = JS_FindCompilationScope(cx, target); NS_ENSURE_TRUE(target, NS_ERROR_FAILURE); nsCOMPtr secman = do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID); NS_ENSURE_TRUE(secman, NS_ERROR_FAILURE); nsCOMPtr principal; rv = secman->GetObjectPrincipal(cx, target, getter_AddRefs(principal)); NS_ENSURE_SUCCESS(rv, rv); JSPrincipals *jsPrincipals; rv = principal->GetJSPrincipals(cx, &jsPrincipals); NS_ENSURE_SUCCESS(rv, rv); autoDropPrincipals adp(cx, jsPrincipals); JSObject *callingScope; { JSAutoRequest req(cx); callingScope = JS_GetGlobalForScopeChain(cx); NS_ENSURE_TRUE(callingScope, NS_ERROR_FAILURE); } { JSAutoRequest req(cx); JSAutoEnterCompartment ac; jsval v; NS_ENSURE_TRUE(ac.enter(cx, target), NS_ERROR_FAILURE); JSBool ok = JS_EvaluateUCScriptForPrincipals(cx, target, jsPrincipals, reinterpret_cast (PromiseFlatString(aSource).get()), aSource.Length(), filename.get(), aLineNumber, &v); if (!ok) { jsval exn; if (!JS_GetPendingException(cx, &exn)) rv = NS_ERROR_FAILURE; else { JS_ClearPendingException(cx); if (JS_WrapValue(cx, &exn)) JS_SetPendingException(cx, exn); } } else { // Convert the result into something safe for our caller. JSAutoRequest req(cx); JSAutoEnterCompartment ac; if (!ac.enter(cx, callingScope) || !JS_WrapValue(cx, &v)) rv = NS_ERROR_FAILURE; if (NS_SUCCEEDED(rv)) *rval = v; } } return rv; } NS_IMETHODIMP dactylUtils::CreateContents(nsIDOMElement *aElement) { nsCOMPtr content = do_QueryInterface(aElement); for (nsIContent *element = content; element; element = element->GetParent()) { nsCOMPtr xulelem = do_QueryInterface(element); if (xulelem) { nsCOMPtr builder; xulelem->GetBuilder(getter_AddRefs(builder)); if (builder) { builder->CreateContents(content, PR_TRUE); break; } } } return NS_OK; } namespace XPCWrapper { extern JSObject *UnsafeUnwrapSecurityWrapper(JSObject *obj); }; NS_IMETHODIMP dactylUtils::GetGlobalForObject(const jsval &aObject, JSContext *cx, jsval *rval) { nsresult rv; NS_ENSURE_FALSE(JSVAL_IS_PRIMITIVE(aObject), NS_ERROR_XPC_BAD_CONVERT_JS); JSObject *obj = XPCWrapper::UnsafeUnwrapSecurityWrapper(JSVAL_TO_OBJECT(aObject)); JSObject *global = JS_GetGlobalForObject(cx, obj); *rval = OBJECT_TO_JSVAL(global); /* // Outerize if necessary. if (JSObjectOp outerize = global->getClass()->ext.outerObject) *rval = OBJECT_TO_JSVAL(outerize(cx, global)); */ return NS_OK; } NS_IMETHODIMP dactylUtils::GetScrollable(nsIDOMElement *aElement, PRUint32 *rval) { nsCOMPtr content = do_QueryInterface(aElement); nsIFrame *frame = content->GetPrimaryFrame(); nsIScrollableFrame *scrollFrame = do_QueryFrame(frame); *rval = 0; if (scrollFrame) { nsPresContext::ScrollbarStyles ss = scrollFrame->GetScrollbarStyles(); PRUint32 scrollbarVisibility = scrollFrame->GetScrollbarVisibility(); nsRect scrollRange = scrollFrame->GetScrollRange(); if (ss.mHorizontal != NS_STYLE_OVERFLOW_HIDDEN && ((scrollbarVisibility & nsIScrollableFrame::HORIZONTAL) || scrollRange.width > 0)) *rval |= dactylIUtils::DIRECTION_HORIZONTAL; if (ss.mVertical != NS_STYLE_OVERFLOW_HIDDEN && ((scrollbarVisibility & nsIScrollableFrame::VERTICAL) || scrollRange.height > 0)) *rval |= dactylIUtils::DIRECTION_VERTICAL; } return NS_OK; } /* vim:se sts=4 sw=4 et cin ft=cpp: */ dactyl-1.2~r20151231/binary/src/dactylUtils.h000066400000000000000000000011771264147376100206010ustar00rootroot00000000000000 #pragma once #include "config.h" #include "dactylIUtils.h" #include "nsISupports.h" #include "nsIPrincipal.h" #include "nsIXPConnect.h" #include "jsapi.h" #include "jsfriendapi.h" #include "nsIJSRuntimeService.h" #include "nsIJSContextStack.h" #include "nsCOMPtr.h" class dactylUtils : public dactylIUtils { public: dactylUtils() NS_HIDDEN; ~dactylUtils() NS_HIDDEN; NS_DECL_ISUPPORTS NS_DECL_DACTYLIUTILS NS_HIDDEN_(nsresult) Init(); private: nsCOMPtr mRuntimeService; JSRuntime *mRuntime; nsCOMPtr mSystemPrincipal; }; /* vim:se sts=4 sw=4 et cin ft=cpp: */ dactyl-1.2~r20151231/binary/src/mozJSLoaderUtils.cpp000066400000000000000000000155501264147376100220450ustar00rootroot00000000000000/* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. * * The Original Code is mozilla.org * * The Initial Developer of the Original Code is * Mozilla Foundation. * Portions created by the Initial Developer are Copyright (C) 2010-2011 * the Initial Developer. All Rights Reserved. * * Contributor(s): * Michael Wu * * Alternatively, the contents of this file may be used under the terms of * either of the GNU General Public License Version 2 or later (the "GPL"), * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only * under the terms of either the GPL or the LGPL, and not to allow others to * use your version of this file under the terms of the MPL, indicate your * decision by deleting the provisions above and replace them with the notice * and other provisions required by the GPL or the LGPL. If you do not delete * the provisions above, a recipient may use your version of this file under * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ #include "mozJSLoaderUtils.h" #include "nsAutoPtr.h" #include "jsapi.h" #include "jsxdrapi.h" #include "mozilla/scache/StartupCache.h" #include "mozilla/scache/StartupCacheUtils.h" #include "nsIChromeRegistry.h" #include "nsIIOService.h" #include "nsIResProtocolHandler.h" #include "nsNetUtil.h" using namespace mozilla::scache; static nsresult ReadScriptFromStream(JSContext *cx, nsIObjectInputStream *stream, JSScriptType **script) { *script = nsnull; PRUint32 size; nsresult rv = stream->Read32(&size); NS_ENSURE_SUCCESS(rv, rv); char *data; rv = stream->ReadBytes(size, &data); NS_ENSURE_SUCCESS(rv, rv); JSXDRState *xdr = JS_XDRNewMem(cx, JSXDR_DECODE); NS_ENSURE_TRUE(xdr, NS_ERROR_OUT_OF_MEMORY); xdr->userdata = stream; JS_XDRMemSetData(xdr, data, size); if (!JS_XDRScript(xdr, script)) { rv = NS_ERROR_FAILURE; } // Update data in case ::JS_XDRScript called back into C++ code to // read an XPCOM object. // // In that case, the serialization process must have flushed a run // of counted bytes containing JS data at the point where the XPCOM // object starts, after which an encoding C++ callback from the JS // XDR code must have written the XPCOM object directly into the // nsIObjectOutputStream. // // The deserialization process will XDR-decode counted bytes up to // but not including the XPCOM object, then call back into C++ to // read the object, then read more counted bytes and hand them off // to the JSXDRState, so more JS data can be decoded. // // This interleaving of JS XDR data and XPCOM object data may occur // several times beneath the call to ::JS_XDRScript, above. At the // end of the day, we need to free (via nsMemory) the data owned by // the JSXDRState. So we steal it back, nulling xdr's buffer so it // doesn't get passed to ::JS_free by ::JS_XDRDestroy. uint32 length; data = static_cast(JS_XDRMemGetData(xdr, &length)); JS_XDRMemSetData(xdr, nsnull, 0); JS_XDRDestroy(xdr); // If data is null now, it must have been freed while deserializing an // XPCOM object (e.g., a principal) beneath ::JS_XDRScript. nsMemory::Free(data); return rv; } static nsresult WriteScriptToStream(JSContext *cx, JSScriptType *script, nsIObjectOutputStream *stream) { JSXDRState *xdr = JS_XDRNewMem(cx, JSXDR_ENCODE); NS_ENSURE_TRUE(xdr, NS_ERROR_OUT_OF_MEMORY); xdr->userdata = stream; nsresult rv = NS_OK; if (JS_XDRScript(xdr, &script)) { // Get the encoded JSXDRState data and write it. The JSXDRState owns // this buffer memory and will free it beneath ::JS_XDRDestroy. // // If an XPCOM object needs to be written in the midst of the JS XDR // encoding process, the C++ code called back from the JS engine (e.g., // nsEncodeJSPrincipals in caps/src/nsJSPrincipals.cpp) will flush data // from the JSXDRState to aStream, then write the object, then return // to JS XDR code with xdr reset so new JS data is encoded at the front // of the xdr's data buffer. // // However many XPCOM objects are interleaved with JS XDR data in the // stream, when control returns here from ::JS_XDRScript, we'll have // one last buffer of data to write to aStream. uint32 size; const char* data = reinterpret_cast (JS_XDRMemGetData(xdr, &size)); NS_ASSERTION(data, "no decoded JSXDRState data!"); rv = stream->Write32(size); if (NS_SUCCEEDED(rv)) { rv = stream->WriteBytes(data, size); } } else { rv = NS_ERROR_FAILURE; // likely to be a principals serialization error } JS_XDRDestroy(xdr); return rv; } nsresult ReadCachedScript(nsIStartupCache* cache, nsACString &uri, JSContext *cx, JSScriptType **script) { nsresult rv; nsAutoArrayPtr buf; PRUint32 len; rv = cache->GetBuffer(PromiseFlatCString(uri).get(), getter_Transfers(buf), &len); if (NS_FAILED(rv)) { return rv; // don't warn since NOT_AVAILABLE is an ok error } nsCOMPtr ois; rv = NewObjectInputStreamFromBuffer(buf, len, getter_AddRefs(ois)); NS_ENSURE_SUCCESS(rv, rv); buf.forget(); return ReadScriptFromStream(cx, ois, script); } nsresult WriteCachedScript(nsIStartupCache* cache, nsACString &uri, JSContext *cx, JSScriptType *script) { nsresult rv; nsCOMPtr oos; nsCOMPtr storageStream; rv = NewObjectOutputWrappedStorageStream(getter_AddRefs(oos), getter_AddRefs(storageStream), true); NS_ENSURE_SUCCESS(rv, rv); rv = WriteScriptToStream(cx, script, oos); oos->Close(); NS_ENSURE_SUCCESS(rv, rv); nsAutoArrayPtr buf; PRUint32 len; rv = NewBufferFromStorageStream(storageStream, getter_Transfers(buf), &len); NS_ENSURE_SUCCESS(rv, rv); rv = cache->PutBuffer(PromiseFlatCString(uri).get(), buf, len); return rv; } dactyl-1.2~r20151231/binary/src/mozJSLoaderUtils.h000066400000000000000000000057121264147376100215110ustar00rootroot00000000000000/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- * * ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. * * The Original Code is mozilla.org. * * The Initial Developer of the Original Code is * Mozilla Foundation. * Portions created by the Initial Developer are Copyright (C) 2011 * the Initial Developer. All Rights Reserved. * * Contributor(s): * Michael Wu * * Alternatively, the contents of this file may be used under the terms of * either of the GNU General Public License Version 2 or later (the "GPL"), * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only * under the terms of either the GPL or the LGPL, and not to allow others to * use your version of this file under the terms of the MPL, indicate your * decision by deleting the provisions above and replace them with the notice * and other provisions required by the GPL or the LGPL. If you do not delete * the provisions above, a recipient may use your version of this file under * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ #ifndef mozJSLoaderUtils_h #define mozJSLoaderUtils_h #include "config.h" /* * This is evil. Very evil. #define nsString_h___ #include "nsStringGlue.h" */ #include "nsIStartupCache.h" #include "nsStringAPI.h" #include "jsapi.h" #if defined(GECKO_MAJOR) && GECKO_MAJOR < 9 #include "jsapi.h" # define JS_XDRScript JS_XDRScriptObject typedef JSObject JSScriptType; # if GECKO_MAJOR < 8 # define NewObjectInputStreamFromBuffer NS_NewObjectInputStreamFromBuffer # define NewBufferFromStorageStream NS_NewBufferFromStorageStream # if GECKO_MAJOR > 6 # define NewObjectOutputWrappedStorageStream NS_NewObjectOutputWrappedStorageStream # else # define NewObjectOutputWrappedStorageStream(a, b, c) NS_NewObjectOutputWrappedStorageStream((a), (b)) # endif # endif #else typedef JSScript JSScriptType; #endif class nsIURI; namespace mozilla { namespace scache { class StartupCache; } } nsresult ReadCachedScript(nsIStartupCache* cache, nsACString &uri, JSContext *cx, JSScriptType **scriptObj); nsresult WriteCachedScript(nsIStartupCache* cache, nsACString &uri, JSContext *cx, JSScriptType *scriptObj); #endif /* mozJSLoaderUtils_h */ dactyl-1.2~r20151231/binary/src/subscriptLoader.cpp000066400000000000000000000445761264147376100220120ustar00rootroot00000000000000/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- * vim: set ts=4 sw=4 et tw=80: * * ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. * * The Original Code is Mozilla Communicator client code, released * March 31, 1998. * * The Initial Developer of the Original Code is * Netscape Communications Corporation. * Portions created by the Initial Developer are Copyright (C) 1998 * the Initial Developer. All Rights Reserved. * * Contributor(s): * Robert Ginda * Kris Maglione * * Alternatively, the contents of this file may be used under the terms of * either of the GNU General Public License Version 2 or later (the "GPL"), * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only * under the terms of either the GPL or the LGPL, and not to allow others to * use your version of this file under the terms of the MPL, indicate your * decision by deleting the provisions above and replace them with the notice * and other provisions required by the GPL or the LGPL. If you do not delete * the provisions above, a recipient may use your version of this file under * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ /* * What follows is the ordinary mozIJSSubScriptLoader modified only to strip the * useless, irritating, and troublesome "foo -> " prefixes from filenames. */ #include "dactylUtils.h" #include "mozJSLoaderUtils.h" #include "nsIServiceManager.h" #include "nsIXPConnect.h" #include "nsIURI.h" #include "nsIIOService.h" #include "nsIChannel.h" #include "nsIConsoleService.h" #include "nsIScriptError.h" #include "nsIInputStream.h" #include "nsNetCID.h" #include "nsAutoPtr.h" #include "nsNetUtil.h" #include "nsIProtocolHandler.h" #include "nsIScriptSecurityManager.h" #include "nsIFileURL.h" // ConvertToUTF16 #include "nsICharsetConverterManager.h" #include "nsIUnicodeDecoder.h" template inline PRBool EnsureStringLength(T& aStr, PRUint32 aLen) { aStr.SetLength(aLen); return (aStr.Length() == aLen); } #include "jsapi.h" #include "jscntxt.h" #include "jsdbgapi.h" #include "jsfriendapi.h" #if GECKO_MAJOR < 10 static inline JSVersion JS_GetVersion(JSContext *cx) { return cx->findVersion(); } #endif #include "mozilla/FunctionTimer.h" #include "mozilla/scache/StartupCache.h" #include "mozilla/scache/StartupCacheUtils.h" using namespace mozilla::scache; class nsACString_internal : nsACString {}; namespace mozilla { namespace scache { nsresult PathifyURI(nsIURI *in, nsACString_internal &out); } } /* load() error msgs, XXX localize? */ #define LOAD_ERROR_NOSERVICE "Error creating IO Service." #define LOAD_ERROR_NOURI "Error creating URI (invalid URL scheme?)" #define LOAD_ERROR_NOSCHEME "Failed to get URI scheme. This is bad." #define LOAD_ERROR_URI_NOT_LOCAL "Trying to load a non-local URI." #define LOAD_ERROR_NOSTREAM "Error opening input stream (invalid filename?)" #define LOAD_ERROR_NOCONTENT "ContentLength not available (not a local URL?)" #define LOAD_ERROR_BADCHARSET "Error converting to specified charset" #define LOAD_ERROR_BADREAD "File Read Error." #define LOAD_ERROR_READUNDERFLOW "File Read Error (underflow.)" #define LOAD_ERROR_NOPRINCIPALS "Failed to get principals." #define LOAD_ERROR_NOSPEC "Failed to get URI spec. This is bad." /* Internal linkage, bloody hell... */ static nsresult ConvertToUTF16(nsIChannel* aChannel, const PRUint8* aData, PRUint32 aLength, const nsString& aHintCharset, nsString& aString) { if (!aLength) { aString.Truncate(); return NS_OK; } nsCAutoString characterSet; nsresult rv = NS_OK; if (aChannel) { rv = aChannel->GetContentCharset(characterSet); } if (!aHintCharset.IsEmpty() && (NS_FAILED(rv) || characterSet.IsEmpty())) { // charset name is always ASCII. LossyCopyUTF16toASCII(aHintCharset, characterSet); } if (characterSet.IsEmpty()) { // fall back to ISO-8859-1, see bug 118404 characterSet.AssignLiteral("ISO-8859-1"); } nsCOMPtr charsetConv = do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv); nsCOMPtr unicodeDecoder; if (NS_SUCCEEDED(rv) && charsetConv) { rv = charsetConv->GetUnicodeDecoder(characterSet.get(), getter_AddRefs(unicodeDecoder)); if (NS_FAILED(rv)) { // fall back to ISO-8859-1 if charset is not supported. (bug 230104) rv = charsetConv->GetUnicodeDecoderRaw("ISO-8859-1", getter_AddRefs(unicodeDecoder)); } } // converts from the charset to unicode if (NS_SUCCEEDED(rv)) { PRInt32 unicodeLength = 0; rv = unicodeDecoder->GetMaxLength(reinterpret_cast(aData), aLength, &unicodeLength); if (NS_SUCCEEDED(rv)) { if (!EnsureStringLength(aString, unicodeLength)) return NS_ERROR_OUT_OF_MEMORY; PRUnichar *ustr = aString.BeginWriting(); PRInt32 consumedLength = 0; PRInt32 originalLength = aLength; PRInt32 convertedLength = 0; PRInt32 bufferLength = unicodeLength; do { rv = unicodeDecoder->Convert(reinterpret_cast(aData), (PRInt32 *) &aLength, ustr, &unicodeLength); if (NS_FAILED(rv)) { // if we failed, we consume one byte, replace it with U+FFFD // and try the conversion again. ustr[unicodeLength++] = (PRUnichar)0xFFFD; ustr += unicodeLength; unicodeDecoder->Reset(); } aData += ++aLength; consumedLength += aLength; aLength = originalLength - consumedLength; convertedLength += unicodeLength; unicodeLength = bufferLength - convertedLength; } while (NS_FAILED(rv) && (originalLength > consumedLength) && (bufferLength > convertedLength)); aString.SetLength(convertedLength); } } return rv; } // We just use the same reporter as the component loader static void mozJSLoaderErrorReporter(JSContext *cx, const char *message, JSErrorReport *rep) { nsresult rv; /* Use the console service to register the error. */ nsCOMPtr consoleService = do_GetService(NS_CONSOLESERVICE_CONTRACTID); /* * Make an nsIScriptError, populate it with information from this * error, then log it with the console service. The UI can then * poll the service to update the Error console. */ nsCOMPtr errorObject = do_CreateInstance(NS_SCRIPTERROR_CONTRACTID); if (consoleService && errorObject) { /* * Got an error object; prepare appropriate-width versions of * various arguments to it. */ nsAutoString fileUni; fileUni.Assign(NS_ConvertUTF8toUTF16(rep->filename)); PRUint32 column = rep->uctokenptr - rep->uclinebuf; rv = errorObject->Init(reinterpret_cast (rep->ucmessage), fileUni.get(), reinterpret_cast (rep->uclinebuf), rep->lineno, column, rep->flags, "component javascript"); if (NS_SUCCEEDED(rv)) { rv = consoleService->LogMessage(errorObject); if (NS_SUCCEEDED(rv)) { // We're done! Skip return to fall thru to stderr // printout, for the benefit of those invoking the // browser with -console // return; } } } /* * If any of the above fails for some reason, fall back to * printing to stderr. */ } static JSBool Dump(JSContext *cx, uintN argc, jsval *vp) { JSString *str; if (!argc) return JS_TRUE; str = JS_ValueToString(cx, JS_ARGV(cx, vp)[0]); if (!str) return JS_FALSE; size_t length; const jschar *chars = JS_GetStringCharsAndLength(cx, str, &length); if (!chars) return JS_FALSE; fputs(NS_ConvertUTF16toUTF8(reinterpret_cast(chars)).get(), stderr); return JS_TRUE; } static nsresult ReportError(JSContext *cx, const char *msg) { JS_SetPendingException(cx, STRING_TO_JSVAL(JS_NewStringCopyZ(cx, msg))); return NS_OK; } static nsresult ReadScript(nsIURI *uri, JSContext *cx, JSObject *target_obj, jschar *charset, const char *uriStr, nsIIOService *serv, nsIPrincipal *principal, JSScriptType **scriptObjp) { nsCOMPtr chan; nsCOMPtr instream; JSPrincipals *jsPrincipals; JSErrorReporter er; nsresult rv; // Instead of calling NS_OpenURI, we create the channel ourselves and call // SetContentType, to avoid expensive MIME type lookups (bug 632490). rv = NS_NewChannel(getter_AddRefs(chan), uri, serv, nsnull, nsnull, nsIRequest::LOAD_NORMAL); if (NS_SUCCEEDED(rv)) { chan->SetContentType(NS_LITERAL_CSTRING("application/javascript")); rv = chan->Open(getter_AddRefs(instream)); } if (NS_FAILED(rv)) { return ReportError(cx, LOAD_ERROR_NOSTREAM); } PRInt32 len = -1; rv = chan->GetContentLength(&len); if (NS_FAILED(rv) || len == -1) { return ReportError(cx, LOAD_ERROR_NOCONTENT); } nsCString buf; rv = NS_ReadInputStreamToString(instream, buf, len); if (NS_FAILED(rv)) return rv; /* we can't hold onto jsPrincipals as a module var because the * JSPRINCIPALS_DROP macro takes a JSContext, which we won't have in the * destructor */ rv = principal->GetJSPrincipals(cx, &jsPrincipals); if (NS_FAILED(rv) || !jsPrincipals) { return ReportError(cx, LOAD_ERROR_NOPRINCIPALS); } /* set our own error reporter so we can report any bad things as catchable * exceptions, including the source/line number */ er = JS_SetErrorReporter(cx, mozJSLoaderErrorReporter); if (charset) { nsString script; rv = ConvertToUTF16( nsnull, reinterpret_cast(buf.get()), len, nsDependentString(reinterpret_cast(charset)), script); if (NS_FAILED(rv)) { JSPRINCIPALS_DROP(cx, jsPrincipals); return ReportError(cx, LOAD_ERROR_BADCHARSET); } *scriptObjp = JS_CompileUCScriptForPrincipals(cx, target_obj, jsPrincipals, reinterpret_cast(script.get()), script.Length(), uriStr, 1); } else { *scriptObjp = JS_CompileScriptForPrincipals(cx, target_obj, jsPrincipals, buf.get(), len, uriStr, 1); } JSPRINCIPALS_DROP(cx, jsPrincipals); /* repent for our evil deeds */ JS_SetErrorReporter(cx, er); return NS_OK; } NS_IMETHODIMP /* args and return value are delt with using XPConnect and JSAPI */ dactylUtils::LoadSubScript (const PRUnichar * aURL /* [, JSObject *target_obj] */) { /* * Loads a local url and evals it into the current cx * Synchronous (an async version would be cool too.) * url: The url to load. Must be local so that it can be loaded * synchronously. * target_obj: Optional object to eval the script onto (defaults to context * global) * returns: Whatever jsval the script pointed to by the url returns. * Should ONLY (O N L Y !) be called from JavaScript code. */ /* gotta define most of this stuff up here because of all the gotos, * defined the rest up here to be consistent */ nsresult rv; JSBool ok; #ifdef NS_FUNCTION_TIMER NS_TIME_FUNCTION_FMT("%s (line %d) (url: %s)", MOZ_FUNCTION_NAME, __LINE__, NS_LossyConvertUTF16toASCII(aURL).get()); #else (void)aURL; // prevent compiler warning #endif /* get JS things from the CallContext */ nsCOMPtr xpc = do_GetService(nsIXPConnect::GetCID()); if (!xpc) return NS_ERROR_FAILURE; nsAXPCNativeCallContext *cc = nsnull; rv = xpc->GetCurrentNativeCallContext(&cc); if (NS_FAILED(rv)) return NS_ERROR_FAILURE; JSContext *cx; rv = cc->GetJSContext (&cx); if (NS_FAILED(rv)) return NS_ERROR_FAILURE; PRUint32 argc; rv = cc->GetArgc (&argc); if (NS_FAILED(rv)) return NS_ERROR_FAILURE; jsval *argv; rv = cc->GetArgvPtr (&argv); if (NS_FAILED(rv)) return NS_ERROR_FAILURE; jsval *rval; rv = cc->GetRetValPtr (&rval); if (NS_FAILED(rv)) return NS_ERROR_FAILURE; /* set mJSPrincipals if it's not here already */ if (!mSystemPrincipal) { nsCOMPtr secman = do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID); if (!secman) return rv; rv = secman->GetSystemPrincipal(getter_AddRefs(mSystemPrincipal)); if (NS_FAILED(rv) || !mSystemPrincipal) return rv; } JSAutoRequest ar(cx); JSString *url; JSObject *target_obj = nsnull; jschar *charset = nsnull; ok = JS_ConvertArguments (cx, argc, argv, "S / o W", &url, &target_obj, &charset); if (!ok) { /* let the exception raised by JS_ConvertArguments show through */ return NS_OK; } JSAutoByteString urlbytes(cx, url); if (!urlbytes) { return NS_OK; } if (!target_obj) { /* if the user didn't provide an object to eval onto, find the global * object by walking the parent chain of the calling object */ nsCOMPtr wn; rv = cc->GetCalleeWrapper (getter_AddRefs(wn)); if (NS_FAILED(rv)) return NS_ERROR_FAILURE; rv = wn->GetJSObject (&target_obj); if (NS_FAILED(rv)) return NS_ERROR_FAILURE; JSObject *maybe_glob = JS_GetParent (cx, target_obj); while (maybe_glob != nsnull) { target_obj = maybe_glob; maybe_glob = JS_GetParent (cx, maybe_glob); } } // Remember an object out of the calling compartment so that we // can properly wrap the result later. nsCOMPtr principal = mSystemPrincipal; JSObject *result_obj = target_obj; target_obj = JS_FindCompilationScope(cx, target_obj); if (!target_obj) return NS_ERROR_FAILURE; if (target_obj != result_obj) { nsCOMPtr secman = do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID); if (!secman) return NS_ERROR_FAILURE; rv = secman->GetObjectPrincipal(cx, target_obj, getter_AddRefs(principal)); NS_ENSURE_SUCCESS(rv, rv); } JSAutoEnterCompartment ac; if (!ac.enter(cx, target_obj)) return NS_ERROR_UNEXPECTED; /* load up the url. From here on, failures are reflected as ``custom'' * js exceptions */ nsCOMPtr uri; nsCAutoString uriStr; nsCAutoString scheme; JSStackFrame* frame = nsnull; JSScript* script = nsnull; // Figure out who's calling us do { frame = JS_FrameIterator(cx, &frame); if (frame) script = JS_GetFrameScript(cx, frame); } while (frame && !script); if (!script) { // No script means we don't know who's calling, bail. return NS_ERROR_FAILURE; } nsCOMPtr serv = do_GetService(NS_IOSERVICE_CONTRACTID); if (!serv) { return ReportError(cx, LOAD_ERROR_NOSERVICE); } // Make sure to explicitly create the URI, since we'll need the // canonicalized spec. rv = NS_NewURI(getter_AddRefs(uri), urlbytes.ptr(), nsnull, serv); if (NS_FAILED(rv)) { return ReportError(cx, LOAD_ERROR_NOURI); } rv = uri->GetSpec(uriStr); if (NS_FAILED(rv)) { return ReportError(cx, LOAD_ERROR_NOSPEC); } rv = uri->GetScheme(scheme); if (NS_FAILED(rv)) { return ReportError(cx, LOAD_ERROR_NOSCHEME); } bool writeScript = false; JSScriptType *scriptObj = nsnull; JSVersion version = JS_GetVersion(cx); nsCAutoString cachePath; cachePath.Append("jssubloader/"); cachePath.AppendInt(version); if (charset) { cachePath.Append("/"); cachePath.Append(NS_ConvertUTF16toUTF8( nsDependentString(reinterpret_cast(charset)))); } if (false) // This is evil. Very evil. Unfortunately, the PathifyURI symbol is // exported, but with an argument type that we don't have access to. PathifyURI(uri, *(nsACString_internal*)&cachePath); else { cachePath.Append("/"); cachePath.Append(uriStr); } // Suppress caching if we're compiling as content. nsCOMPtr cache; if (mSystemPrincipal) { cache = do_GetService("@mozilla.org/startupcache/cache;1", &rv); NS_ENSURE_SUCCESS(rv, rv); rv = ReadCachedScript(cache, cachePath, cx, &scriptObj); } if (!scriptObj) { rv = ReadScript(uri, cx, target_obj, charset, (char *)uriStr.get(), serv, principal, &scriptObj); writeScript = true; } if (NS_FAILED(rv) || !scriptObj) return rv; ok = false; if (scriptObj) ok = JS_ExecuteScriptVersion(cx, target_obj, scriptObj, rval, version); if (ok) { JSAutoEnterCompartment rac; if (!rac.enter(cx, result_obj) || !JS_WrapValue(cx, rval)) return NS_ERROR_UNEXPECTED; } if (cache && ok && writeScript) { WriteCachedScript(cache, cachePath, cx, scriptObj); } cc->SetReturnValueWasSet (ok); return NS_OK; } dactyl-1.2~r20151231/common/000077500000000000000000000000001264147376100153365ustar00rootroot00000000000000dactyl-1.2~r20151231/common/Makefile000066400000000000000000000133101264147376100167740ustar00rootroot00000000000000#### configuration _SH := $(shell if which dash >/dev/null 2>&1; \ then echo dash; \ else echo sh; \ fi) SH ?= $(_SH) AWK ?= awk B64ENCODE ?= base64 CURL ?= curl SED := $(shell if [ "xoo" = x$$(echo foo | sed -E 's/f(o)/\1/' 2>/dev/null) ]; \ then echo sed -E; \ else echo sed -r; \ fi) TOP = $(shell pwd) OS = $(shell uname -s) BUILD_DATE = $(shell date "+%Y/%m/%d %H:%M:%S") BASE = $(TOP)/../common VERSION ?= $(shell $(SED) -n 's/.*em:version(>|=")(.*)["<].*/\2/p' $(TOP)/install.rdf | sed 1q) UUID := $(shell $(SED) -n 's/.*em:id(>|=")(.*)["<].*/\2/p' $(TOP)/install.rdf | sed 1q) MANGLE := chrome MOZMILL = mozmill HOSTAPP_PATH = $(shell which $(HOSTAPP)) TEST_DIR = $(BASE)/tests/functional TEST_LOG = $(TEST_DIR)/log IDNAME := $(shell echo "$(NAME)" | tr a-z A-Z) LOCALEDIR = locale DOC_FILES = $(wildcard $(LOCALEDIR)/*/*.xml) export VERSION BUILD_DATE MAKE_JAR = $(SH) $(BASE)/make_jar.sh # TODO: specify source files manually? JAR_BASES = $(TOP) $(BASE) JAR_FILES = config.json JAR_DIRS = content skin locale modules JAR_TEXTS = js jsm css dtd xml xul html xhtml xsl properties json JAR_BINS = png CHROME = $(MANGLE)/ JAR = $(CHROME)$(NAME).jar XPI_BASES = $(JAR_BASES) $(TOP)/.. XPI_FILES = icon.png icon64.png bootstrap.js TODO AUTHORS Donors NEWS LICENSE.txt XPI_DIRS = components $(MANGLE) defaults XPI_TEXTS = js jsm $(JAR_TEXTS) XPI_BINS = $(JAR_BINS) XPI_NAME = $(NAME)-$(VERSION) XPI = ../downloads/$(XPI_NAME).xpi XPI_PATH = $(TOP)/$(XPI:%.xpi=%) BUILD_DIR = build.$(VERSION).$(OS) .SILENT: #### rules TARGETS = all help info jar xpi install clean distclean install installxpi test $(CHROME) $(JAR) $(TARGETS:%=\%.%): echo MAKE $* $(@:$*.%=%) $(MAKE) -C $* $(@:$*.%=%) .PHONY: $(TARGETS) all: help help: @echo "$(NAME) $(VERSION) build" @echo @echo " make help - display this help" @echo " make info - show some info about the system" @echo " make jar - build a JAR ($(JAR))" @echo " make xpi - build an XPI ($(XPI_NAME))" @echo " make installxpi - build an XPI and install it to your profile" @echo " make install - installs this source tree directly to your $(HOSTAPP) profile" @echo ' set $$PROFILE to select a profile by name and $$PROFILEPATHS' @echo ' to change the directory where profiles are searched' @echo " make clean - clean up" @echo " make distclean - clean up more" @echo " make test - run functional tests" @echo @echo "running some commands with V=1 will show more build details" info: @echo "version $(VERSION)" @echo "release file $(XPI)" @echo "doc files $(DOC_FILES)" @echo "xpi files $(XPI_FILES)" jar: $(JAR) install: export dir; \ for dir in $(PROFILEPATHS); do \ test -f "$$dir/profiles.ini" && break; \ done; \ \ profile=$$(sed 's/^$$/\#/' "$$dir/profiles.ini" | \ awk -v "profile=$(PROFILE)" \ 'BEGIN { RS="#" } \ index($$0, "\nName=" profile "\n") { print; exit } \ !profile && /\nName=default\n/ { args["name=default"] = $$0 } \ !profile && /\nDefault=1/ { args["default=1"] = $$0 } \ END { \ if (args["default=1"]) print args["default=1"]; \ else print args["name=default"] \ }' | \ awk -F= '{ args[$$1] = $$2 } \ END { \ if (args["IsRelative"]) print ENVIRON["dir"] "/" args["Path"]; \ else print args["Path"] \ }'); \ \ if ! test -d "$$profile"; then \ echo >&2 "Can't locate profile directory"; \ exit 1; \ fi; \ \ install() { \ ext="$$profile/extensions/$$2"; \ mkdir -p "$$(dirname "$$ext")"; \ rm -rf "$$ext.xpi" "$$ext"; \ \ echo "Installing $$2 to $$ext"; \ if which cygpath >/dev/null 2>&1; \ then cygpath -wa $$1; \ else (cd $$1; pwd); \ fi >"$$ext"; \ }; \ install . $(UUID); \ install ../binary binary@dactyl.googlecode.com; \ installxpi: xpi $(HOSTAPP) $(XPI) clean: @echo "General $(NAME) cleanup..." rm -f $(JAR) $(XPI) distclean: @echo "More $(NAME) cleanup..." rm -rf $(BUILD_DIR) test: xpi @echo "Running $(NAME) functional tests..." $(IDNAME)_INIT="set loadplugins=" \ $(MOZMILL) --show-all -l $(TEST_LOG) -b $(HOSTAPP_PATH) --addons $(XPI) -t $(TEST_DIR) #### xpi xpi: $(CHROME) @echo "Building XPI..." mkdir -p "$(XPI_PATH)" $(AWK) -v 'name=$(NAME)' -v 'suffix=$(MANGLE)' \ -f $(BASE)/process_manifest.awk \ "$(TOP)/chrome.manifest" >"$(XPI_PATH)/chrome.manifest" $(AWK) -v 'name=$(NAME)' -v 'suffix=$(MANGLE)' \ -f $(BASE)/process_config.awk \ "$(TOP)/config.json" >"$(XPI_PATH)/config.json" version="$(VERSION)"; \ hg root >/dev/null 2>&1 && \ case "$$version" in \ *pre) version="$$version-hg$$(hg log -r . --template '{rev}')-$$(hg branch)";; \ esac; \ $(SED) -e 's/(em:version(>|="))([^"<]+)/\1'"$$version/" \ <"$(TOP)/install.rdf" >"$(XPI_PATH)/install.rdf" $(MAKE_JAR) "$(XPI)" "$(XPI_BASES)" "$(XPI_DIRS)" "$(XPI_TEXTS)" "$(XPI_BINS)" "$(XPI_FILES)" rm -r -- $(CHROME) @if ! which realpath >/dev/null 2>&1; \ then realpath() { \ local IFS="$$(echo)"; \ local x="$$1"; \ case "$$x" in \ /*) ;; \ *) x=$$(pwd);; \ esac; \ }; \ fi; \ echo "Built XPI: $$(realpath -s -- $(XPI))" #### jar $(CHROME) $(JAR): @echo "Packaging chrome..." $(MAKE_JAR) -r "$(@)" "$(JAR_BASES)" "$(JAR_DIRS)" "$(JAR_TEXTS)" "$(JAR_BINS)" "$(JAR_FILES)" @echo "SUCCESS: $@" dactyl-1.2~r20151231/common/bootstrap.js000077500000000000000000000362711264147376100177250ustar00rootroot00000000000000// Copyright (c) 2010-2015 by Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. // // See https://wiki.mozilla.org/Extension_Manager:Bootstrapped_Extensions // for details. "use strict"; const global = this; var { classes: Cc, interfaces: Ci, results: Cr, utils: Cu } = Components; function module(uri) { return Cu.import(uri, {}); } const DEBUG = true; __defineGetter__("BOOTSTRAP", () => "resource://" + moduleName + "/bootstrap.jsm"); var { AddonManager } = module("resource://gre/modules/AddonManager.jsm"); var { XPCOMUtils } = module("resource://gre/modules/XPCOMUtils.jsm"); var { Services } = module("resource://gre/modules/Services.jsm"); var Timer = Components.Constructor("@mozilla.org/timer;1", "nsITimer", "initWithCallback"); const resourceProto = Services.io.getProtocolHandler("resource") .QueryInterface(Ci.nsIResProtocolHandler); const categoryManager = Cc["@mozilla.org/categorymanager;1"].getService(Ci.nsICategoryManager); const manager = Components.manager.QueryInterface(Ci.nsIComponentRegistrar); const BOOTSTRAP_CONTRACT = "@dactyl.googlecode.com/base/bootstrap"; var name = "dactyl"; function reportError(e) { let stack = e.stack || Error().stack; dump("\n" + name + ": bootstrap: " + e + "\n" + stack + "\n"); Cu.reportError(e); Cc["@mozilla.org/consoleservice;1"].getService(Ci.nsIConsoleService) .logStringMessage(stack); } function debug(...args) { if (DEBUG) dump(name + ": " + args.join(", ") + "\n"); } function* entries(obj) { for (let key of Object.keys(obj)) yield [key, obj[key]] } function httpGet(uri) { let xmlhttp = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"].createInstance(Ci.nsIXMLHttpRequest); xmlhttp.overrideMimeType("text/plain"); xmlhttp.open("GET", uri.spec || uri, false); xmlhttp.send(null); return xmlhttp; } let moduleName; let initialized = false; var addon = null; var addonData = null; var basePath = null; let bootstrap; let bootstrap_jsm; let components = {}; let getURI = null; let JSMLoader = { DEBUG_HANGS: false, SANDBOX: Cu.nukeSandbox, get addon() { return addon; }, currentModule: null, factories: [], get name() { return name; }, get module() { return moduleName; }, globals: {}, modules: {}, times: { all: 0, add: function add(major, minor, delta) { this.all += delta; this[major] = (this[major] || 0) + delta; if (minor) { minor = ":" + minor; this[minor] = (this[minor] || 0) + delta; this[major + minor] = (this[major + minor] || 0) + delta; } }, clear: function clear() { for (let key in this) if (typeof this[key] !== "number") delete this[key]; } }, getTarget: function getTarget(url) { let uri = Services.io.newURI(url, null, null); if (uri.schemeIs("resource")) return resourceProto.resolveURI(uri); let chan = Services.io.newChannelFromURI(uri); try { chan.cancel(Cr.NS_BINDING_ABORTED); } catch (e) {} return chan.name; }, _atexit: [], atexit: function atexit(arg, self) { if (typeof arg !== "string") this._atexit.push([arg, self]); else for (let [fn, self] of this._atexit) try { fn.call(self, arg); } catch (e) { reportError(e); } }, _load: function _load(name, target) { let urls = [name]; if (name.indexOf(":") === -1) urls = this.config["module-paths"].map(path => path + name + ".jsm"); for (let url of urls) try { var uri = this.getTarget(url); if (uri in this.globals) return this.modules[name] = this.globals[uri]; this.globals[uri] = this.modules[name]; bootstrap_jsm.loadSubScript(url, this.modules[name], "UTF-8"); return; } catch (e) { debug("Loading " + name + ": " + e); delete this.globals[uri]; if (typeof e != "string") throw e; } throw Error("No such module: " + name); }, load: function load(name, target) { if (!this.modules.hasOwnProperty(name)) { this.modules[name] = this.modules.base ? bootstrap.create(this.modules.base) : bootstrap.import({ JSMLoader: this, module: global.module }); let currentModule = this.currentModule; this.currentModule = this.modules[name]; try { this._load(name, this.modules[name]); } catch (e) { delete this.modules[name]; reportError(e); throw e; } finally { this.currentModule = currentModule; } } let module = this.modules[name]; if (target) for (let symbol of module.EXPORTED_SYMBOLS) try { Object.defineProperty(target, symbol, { configurable: true, enumerable: true, writable: true, value: module[symbol] }); } catch (e) { target[symbol] = module[symbol]; } return module; }, // Cuts down on stupid, fscking url mangling. get loadSubScript() { return bootstrap_jsm.loadSubScript; }, cleanup: function cleanup() { for (let factory of this.factories.splice(0)) manager.unregisterFactory(factory.classID, factory); }, Factory(class_) { let res = Object.create(class_.prototype); res.createInstance = function (outer, iid) { try { if (outer != null) throw Cr.NS_ERROR_NO_AGGREGATION; if (!class_.instance) class_.instance = new class_(); return class_.instance.QueryInterface(iid); } catch (e) { Cu.reportError(e); throw e; } }; return res; }, registerFactory: function registerFactory(factory) { manager.registerFactory(factory.classID, String(factory.classID), factory.contractID, factory); this.factories.push(factory); } }; function init() { debug("bootstrap: init"); let manifest = JSON.parse(httpGet(getURI("config.json")) .responseText); if (!manifest.categories) manifest.categories = []; for (let [classID, { contract, path, categories }] of entries(manifest.components || {})) { components[classID] = new FactoryProxy(getURI(path).spec, classID, contract); if (categories) for (let [category, id] of entries(categories)) manifest.categories.push([category, id, contract]); } for (let [category, id, value] of manifest.categories) categoryManager.addCategoryEntry(category, id, value, false, true); for (let [pkg, path] of entries(manifest.resources || {})) { moduleName = moduleName || pkg; resourceProto.setSubstitution(pkg, getURI(path)); } JSMLoader.config = manifest; bootstrap_jsm = module(BOOTSTRAP); if (JSMLoader.DEBUG_HANGS) { bootstrap = Services.ww.openWindow( null, "chrome://dactyl/content/blank.xul", "dactyl-parent", "chrome,dialog,titlebar", null); Services.scriptloader.loadSubScript(BOOTSTRAP, bootstrap); } else if (!JSMLoader.SANDBOX) bootstrap = bootstrap_jsm; else { bootstrap = Cu.Sandbox(Cc["@mozilla.org/systemprincipal;1"].createInstance(), { sandboxName: BOOTSTRAP, addonId: addon.id, wantGlobalProperties: ["TextDecoder", "TextEncoder"], metadata: { addonID: addon.id } }); Services.scriptloader.loadSubScript(BOOTSTRAP, bootstrap); } bootstrap.require = JSMLoader.load("base").require; let pref = "extensions.dactyl.cacheFlushCheck"; let val = addon.version; if (!Services.prefs.prefHasUserValue(pref) || Services.prefs.getCharPref(pref) != val) { var cacheFlush = true; Services.prefs.setCharPref(pref, val); } Services.obs.notifyObservers(null, "dactyl-rehash", null); JSMLoader.bootstrap = global; JSMLoader.load("config", global); JSMLoader.load("main", global); JSMLoader.cacheFlush = cacheFlush; JSMLoader.load("base", global); if (!(BOOTSTRAP_CONTRACT in Cc)) { // Use Sandbox to prevent closures over this scope let sandbox = Cu.Sandbox(Cc["@mozilla.org/systemprincipal;1"].createInstance()); let factory = Cu.evalInSandbox("({ createInstance: function () { return this; }})", sandbox); factory.classID = Components.ID("{f541c8b0-fe26-4621-a30b-e77d21721fb5}"); factory.contractID = BOOTSTRAP_CONTRACT; factory.QueryInterface = XPCOMUtils.generateQI([Ci.nsIFactory]); factory.wrappedJSObject = factory; manager.registerFactory(factory.classID, String(factory.classID), BOOTSTRAP_CONTRACT, factory); } Cc[BOOTSTRAP_CONTRACT].getService().wrappedJSObject.loader = !Cu.unload && JSMLoader; for (let key in components) components[key].register(); updateVersion(); if (addon !== addonData) require("main", global); } /** * Performs necessary migrations after a version change. */ function updateVersion() { function isDev(ver) { return /^hg|pre$/.test(ver); } try { if (typeof require === "undefined" || addon === addonData) return; JSMLoader.load("prefs", global); config.lastVersion = localPrefs.get("lastVersion", null); localPrefs.set("lastVersion", addon.version); // We're switching from a nightly version to a stable or // semi-stable version or vice versa. // // Disable automatic updates when switching to nightlies, // restore the default action when switching to stable. if (!config.lastVersion || isDev(config.lastVersion) != isDev(addon.version)) addon.applyBackgroundUpdates = AddonManager[isDev(addon.version) ? "AUTOUPDATE_DISABLE" : "AUTOUPDATE_DEFAULT"]; } catch (e) { reportError(e); } } function startup(data, reason) { debug("bootstrap: startup " + reasonToString(reason)); basePath = data.installPath; if (!initialized) { initialized = true; debug("bootstrap: init " + data.id); addonData = data; addon = data; name = data.id.replace(/@.*/, ""); AddonManager.getAddonByID(addon.id, a => { addon = a; updateVersion(); if (typeof require !== "undefined") require("main", global); }); if (basePath.isDirectory()) getURI = function getURI(path) { let uri = Services.io.newFileURI(basePath); uri.path += path; return Services.io.newFileURI(uri.QueryInterface(Ci.nsIFileURL).file); }; else getURI = function getURI(path) { let base = Services.io.newFileURI(basePath).spec.replace(/!/g, "%21"); return Services.io.newURI("jar:" + base + "!" + "/" + path, null, null); }; try { init(); } catch (e) { reportError(e); } } } /** * An XPCOM class factory proxy. Loads the JavaScript module at *url* * when an instance is to be created and calls its NSGetFactory method * to obtain the actual factory. * * @param {string} url The URL of the module housing the real factory. * @param {string} classID The CID of the class this factory represents. */ function FactoryProxy(url, classID, contractID) { this.url = url; this.classID = Components.ID(classID); this.contractID = contractID; } FactoryProxy.prototype = { QueryInterface: XPCOMUtils.generateQI(Ci.nsIFactory), register: function () { debug("bootstrap: register: " + this.classID + " " + this.contractID); JSMLoader.registerFactory(this); }, get module() { debug("bootstrap: create module: " + this.contractID); Object.defineProperty(this, "module", { value: {}, enumerable: true }); JSMLoader.load(this.url, this.module); return this.module; }, createInstance: function (iids) { let factory = this.module.NSGetFactory(this.classID); return factory.createInstance.apply(factory, arguments); } } var timer; function shutdown(data, reason) { let strReason = reasonToString(reason); debug("bootstrap: shutdown " + strReason); if (reason != APP_SHUTDOWN) { if (~[ADDON_UPGRADE, ADDON_DOWNGRADE, ADDON_UNINSTALL].indexOf(reason)) Services.obs.notifyObservers(null, "dactyl-purge", null); Services.obs.notifyObservers(null, "dactyl-cleanup", strReason); Services.obs.notifyObservers(null, "dactyl-cleanup-modules", reasonToString(reason)); JSMLoader.atexit(strReason); JSMLoader.cleanup(strReason); for (let [category, entry] of JSMLoader.config.categories) categoryManager.deleteCategoryEntry(category, entry, false); for (let resource in JSMLoader.config.resources) resourceProto.setSubstitution(resource, null); timer = Timer(() => { bootstrap_jsm.require = null; if (JSMLoader.SANDBOX) Cu.nukeSandbox(bootstrap); else Cu.unload(BOOTSTRAP); bootstrap = null; bootstrap_jsm = null; }, 5000, Ci.nsITimer.TYPE_ONE_SHOT); } } function uninstall(data, reason) { debug("bootstrap: uninstall " + reasonToString(reason)); if (reason == ADDON_UNINSTALL) { Services.prefs.deleteBranch("extensions.dactyl."); if (BOOTSTRAP_CONTRACT in Cc) { let service = Cc[BOOTSTRAP_CONTRACT].getService().wrappedJSObject; manager.unregisterFactory(service.classID, service); } } } function reasonToString(reason) { for (let name of ["disable", "downgrade", "enable", "install", "shutdown", "startup", "uninstall", "upgrade"]) if (reason == global["ADDON_" + name.toUpperCase()] || reason == global["APP_" + name.toUpperCase()]) return name; } function install(data, reason) { debug("bootstrap: install " + reasonToString(reason)); } // vim: set fdm=marker sw=4 ts=4 et: dactyl-1.2~r20151231/common/chrome.manifest000066400000000000000000000000441264147376100203410ustar00rootroot00000000000000content dactyl ../common/content/ dactyl-1.2~r20151231/common/components/000077500000000000000000000000001264147376100175235ustar00rootroot00000000000000dactyl-1.2~r20151231/common/components/commandline-handler.js000066400000000000000000000052731264147376100237710ustar00rootroot00000000000000// Copyright (c) 2009 by Doug Kearns // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; function reportError(e) { dump("dactyl: command-line-handler: " + e + "\n" + (e.stack || Error().stack)); Cu.reportError(e); } var global = this; var NAME = "command-line-handler"; var { classes: Cc, interfaces: Ci, utils: Cu } = Components; Components.utils.import("resource://gre/modules/XPCOMUtils.jsm"); function init() { Cu.import("resource://dactyl/bootstrap.jsm"); require("config", global); require("util", global); } function CommandLineHandler() { this.wrappedJSObject = this; } CommandLineHandler.prototype = { classDescription: "Dactyl command line Handler", classID: Components.ID("{16dc34f7-6d22-4aa4-a67f-2921fb5dcb69}"), contractID: "@mozilla.org/commandlinehandler/general-startup;1?type=dactyl", _xpcom_categories: [ { category: "command-line-handler", entry: "m-dactyl" }, // FIXME: Belongs elsewhere { category: "profile-after-change", entry: "m-dactyl" } ], observe: function observe(subject, topic, data) { if (topic === "profile-after-change") { init(); require(global, "main"); } }, QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver, Ci.nsICommandLineHandler]), handle: function (commandLine) { init(); try { var remote = commandLine.handleFlagWithParam(config.name + "-remote", false); } catch (e) { util.dump("option '-" + config.name + "-remote' requires an argument\n"); } try { if (remote) { commandLine.preventDefault = true; require(global, "services"); util.dactyl.execute(remote); } } catch (e) { util.reportError(e); } try { this.optionValue = commandLine.handleFlagWithParam(config.name, false); } catch (e) { util.dump("option '-" + config.name + "' requires an argument\n"); } }, get helpInfo() { return " -" + config.name + " " + " Additional options for " + config.appName + " startup\n".substr(config.name.length); } }; if (XPCOMUtils.generateNSGetFactory) var NSGetFactory = XPCOMUtils.generateNSGetFactory([CommandLineHandler]); else var NSGetModule = XPCOMUtils.generateNSGetModule([CommandLineHandler]); var EXPORTED_SYMBOLS = ["NSGetFactory", "global"]; // vim: set fdm=marker sw=4 sts=4 ts=8 et: dactyl-1.2~r20151231/common/config.json000066400000000000000000000020001264147376100174660ustar00rootroot00000000000000{ "completers": { "abbreviation": "abbreviation", "altstyle": "alternateStyleSheet", "bookmark": "bookmark", "buffer": "buffer", "charset": "charset", "color": "colorScheme", "command": "command", "dialog": "dialog", "dir": "directory", "environment": "environment", "event": "autocmdEvent", "extension": "addon", "file": "file", "help": "help", "highlight": "highlightGroup", "history": "history", "javascript": "javascript", "macro": "macro", "mapping": "userMapping", "mark": "mark", "menu": "menuItem", "option": "option", "preference": "preference", "qmark": "quickmark", "runtime": "runtime", "search": "search", "shellcmd": "shellCommand", "toolbar": "toolbar", "url": "url", "usercommand": "userCommand" }, "option-defaults": { "guioptions": "rb" } } dactyl-1.2~r20151231/common/content/000077500000000000000000000000001264147376100170105ustar00rootroot00000000000000dactyl-1.2~r20151231/common/content/abbreviations.js000066400000000000000000000360201264147376100221770ustar00rootroot00000000000000// Copyright (c) 2006-2009 by Martin Stubenschrott // Copyright (c) 2010 by anekos // Copyright (c) 2010-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; /** @scope modules */ /** * A user-defined input mode binding of a typed string to an automatically * inserted expansion string. * * Abbreviations have a left-hand side (LHS) whose text is replaced by that of * the right-hand side (RHS) when triggered by an Input mode expansion key. * E.g. an abbreviation with a LHS of "gop" and RHS of "Grand Old Party" will * replace the former with the latter. * * @param {[Mode]} modes The modes in which this abbreviation is active. * @param {string} lhs The left hand side of the abbreviation; the text to * be replaced. * @param {string|function(nsIEditor):string} rhs The right hand side of * the abbreviation; the replacement text. This may either be a string * literal or a function that will be passed the appropriate nsIEditor. * @private */ var Abbreviation = Class("Abbreviation", { init: function (modes, lhs, rhs) { this.modes = modes.sort(); this.lhs = lhs; this.rhs = rhs; }, /** * Returns true if this abbreviation's LHS and RHS are equal to those in * *other*. * * @param {Abbreviation} other The abbreviation to test. * @returns {boolean} The result of the comparison. */ equals: function (other) { return this.lhs == other.lhs && this.rhs == other.rhs; }, /** * Returns the abbreviation's expansion text. * * @param {nsIEditor} editor The editor in which abbreviation expansion is * occurring. * @returns {string} */ expand: function (editor) { return String(callable(this.rhs) ? this.rhs(editor) : this.rhs); }, /** * Returns true if this abbreviation is defined for all *modes*. * * @param {[Mode]} modes The modes to test. * @returns {boolean} The result of the comparison. */ modesEqual: function (modes) { return Ary.equals(this.modes, modes); }, /** * Returns true if this abbreviation is defined for *mode*. * * @param {Mode} mode The mode to test. * @returns {boolean} The result of the comparison. */ inMode: function (mode) { return this.modes.some(m => m == mode); }, /** * Returns true if this abbreviation is defined in any of *modes*. * * @param {[Modes]} modes The modes to test. * @returns {boolean} The result of the comparison. */ inModes: function (modes) { return modes.some(mode => this.inMode(mode)); }, /** * Remove *mode* from the list of supported modes for this abbreviation. * * @param {Mode} mode The mode to remove. */ removeMode: function (mode) { this.modes = this.modes.filter(m => m != mode) .sort(); }, /** * @property {string} The mode display characters associated with the * supported mode combination. */ get modeChar() { return Abbreviation.modeChar(this.modes); } }, { modeChar: function (_modes) { let result = Ary.uniq(_modes.map(m => m.char)).join(""); if (result == "ci") result = "!"; return result; } }); var AbbrevHive = Class("AbbrevHive", Contexts.Hive, { init: function init(group) { init.superapply(this, arguments); this._store = {}; }, /** @property {boolean} True if there are no abbreviations. */ get empty() { return !values(this._store).find(identity); }, /** * Adds a new abbreviation. * * @param {Abbreviation} abbr The abbreviation to add. */ add: function (abbr) { if (!(abbr instanceof Abbreviation)) abbr = Abbreviation.apply(null, arguments); for (let mode of abbr.modes) { if (!this._store[mode]) this._store[mode] = {}; this._store[mode][abbr.lhs] = abbr; } }, /** * Returns the abbreviation with *lhs* in the given *mode*. * * @param {Mode} mode The mode of the abbreviation. * @param {string} lhs The LHS of the abbreviation. * @returns {Abbreviation} The matching abbreviation. */ get: function (mode, lhs) { let abbrevs = this._store[mode]; return abbrevs && hasOwnProp(abbrevs, lhs) ? abbrevs[lhs] : null; }, /** * @property {[Abbreviation]} The list of the abbreviations merged from * each mode. */ get merged() { // Wth? --Kris; let map = values(this._store).map(Iterator).map(iter.toArray) .flatten().toObject(); return Object.keys(map).sort().map(k => map[k]); }, /** * Remove the specified abbreviations. * * @param {Array} modes List of modes. * @param {string} lhs The LHS of the abbreviation. * @returns {boolean} Did the deleted abbreviation exist? */ remove: function (modes, lhs) { let result = false; for (let mode of modes) { if ((mode in this._store) && (lhs in this._store[mode])) { result = true; this._store[mode][lhs].removeMode(mode); delete this._store[mode][lhs]; } } return result; }, /** * Removes all abbreviations specified in *modes*. * * @param {Array} modes List of modes. */ clear: function (modes) { for (let mode of modes) { for (let abbr of values(this._store[mode])) abbr.removeMode(mode); delete this._store[mode]; } } }); var Abbreviations = Module("abbreviations", { init: function () { // (summarized from Vim's ":help abbreviations") // // There are three types of abbreviations. // // full-id: Consists entirely of keyword characters. // ("foo", "g3", "-1") // // end-id: Ends in a keyword character, but all other // are not keyword characters. // ("#i", "..f", "$/7") // // non-id: Ends in a non-keyword character, but the // others can be of any type other than space // and tab. // ("def#", "4/7$") // // Example strings that cannot be abbreviations: // "a.b", "#def", "a b", "_$r" // // For now, a keyword character is anything except for \s, ", or ' // (i.e., whitespace and quotes). In Vim, a keyword character is // specified by the 'iskeyword' setting and is a much less inclusive // list. // // TODO: Make keyword definition closer to Vim's default keyword // definition (which differs across platforms). let params = { // This is most definitely not Vim compatible. keyword: /[^\s"']/, nonkeyword: /[ "']/ }; this._match = util.regexp(String.raw` (^ | \s | ) (+ )$ | // full-id (^ | \s | ) (+ )$ | // end-id (^ | \s ) (\S* )$ // non-id `, "x", params); this._check = util.regexp(String.raw` ^ (?: + | // full-id + | // end-id \S* // non-id ) $ `, "x", params); }, get allHives() { return contexts.allGroups.abbrevs; }, get userHives() { return this.allHives.filter(h => h !== this.builtin); }, get: deprecated("group.abbrevs.get", { get: function get() { return this.user.bound.get; } }), set: deprecated("group.abbrevs.set", { get: function set() { return this.user.bound.set; } }), remove: deprecated("group.abbrevs.remove", { get: function remove() { return this.user.bound.remove; } }), removeAll: deprecated("group.abbrevs.clear", { get: function removeAll() { return this.user.bound.clear; } }), /** * Returns the abbreviation for the given *mode* if *text* matches the * abbreviation expansion criteria. * * @param {Mode} mode The mode to search. * @param {string} text The string to test against the expansion criteria. * * @returns {Abbreviation} */ match: function (mode, text) { let match = this._match.exec(text); if (match) return this.hives.map(h => h.get(mode, match[2] || match[4] || match[6])) .find(identity); return null; }, /** * Lists all abbreviations matching *modes*, *lhs* and optionally *hives*. * * @param {Array} modes List of modes. * @param {string} lhs The LHS of the abbreviation. * @param {[Hive]} hives List of hives. * @optional */ list: function (modes, lhs, hives) { hives = (hives || this.userHives).filter(h => !h.empty); function abbrevs(hive) { return hive.merged.filter(a => a.inModes(modes) && a.lhs.startsWith(lhs)); } let list = ["table", {}, ["tr", { highlight: "Title" }, ["td"], ["td", { style: "padding-right: 1em;" }, _("title.Mode")], ["td", { style: "padding-right: 1em;" }, _("title.Abbrev")], ["td", { style: "padding-right: 1em;" }, _("title.Replacement")]], ["col", { style: "min-width: 6em; padding-right: 1em;" }], hives.map(hive => { let i = 0; return [ ["tr", { style: "height: .5ex;" }], abbrevs(hive).map(abbrev => ["tr", {}, ["td", { highlight: "Title" }, !i++ ? String(hive.name) : ""], ["td", {}, abbrev.modeChar], ["td", {}, abbrev.lhs], ["td", {}, String(abbrev.rhs)]]), ["tr", { style: "height: .5ex;" }]]; })]; // FIXME? // // TODO: Move this to an ItemList to show this automatically // if (list.*.length() === list.text().length() + 2) // dactyl.echomsg(_("abbreviation.none")); // else commandline.commandOutput(list); } }, { }, { contexts: function initContexts(dactyl, modules, window) { update(Abbreviations.prototype, { hives: contexts.Hives("abbrevs", AbbrevHive), user: contexts.hives.abbrevs.user }); }, completion: function initCompletion() { completion.abbreviation = function abbreviation(context, modes, group) { group = group || abbreviations.user; let fn = modes ? abbr => abbr.inModes(modes) : abbr => abbr; context.keys = { text: "lhs" , description: "rhs" }; context.completions = group.merged.filter(fn); }; }, commands: function initCommands() { function addAbbreviationCommands(modes, ch, modeDescription) { modes.sort(); modeDescription = modeDescription ? " in " + modeDescription + " mode" : ""; commands.add([ch ? ch + "a[bbreviate]" : "ab[breviate]"], "Abbreviate a key sequence" + modeDescription, function (args) { let [lhs, rhs] = args; dactyl.assert(!args.length || abbreviations._check.test(lhs), _("error.invalidArgument")); if (!rhs) { let hives = args.explicitOpts["-group"] ? [args["-group"]] : null; abbreviations.list(modes, lhs || "", hives); } else { if (args["-javascript"]) rhs = contexts.bindMacro({ literalArg: rhs }, "-javascript", ["editor"]); args["-group"].add(modes, lhs, rhs); } }, { identifier: "abbreviate", completer: function (context, args) { if (args.length == 1) completion.abbreviation(context, modes, args["-group"]); else if (args["-javascript"]) completion.javascript(context); }, hereDoc: true, literal: 1, options: [ contexts.GroupFlag("abbrevs"), { names: ["-javascript", "-js", "-j"], description: "Expand this abbreviation by evaluating its right-hand-side as JavaScript" } ], serialize: function () { return abbreviations.userHives .filter(h => h.persist) .flatMap(hive => hive.merged .filter(abbr => abbr.modesEqual(modes)) .map(abbr => ({ command: this.name, arguments: [abbr.lhs], literalArg: abbr.rhs, options: { "-group": hive.name == "user" ? undefined : hive.name, "-javascript": callable(abbr.rhs) ? null : undefined } }))); }, }); commands.add([ch + "una[bbreviate]"], "Remove an abbreviation" + modeDescription, function (args) { util.assert(args.bang ^ !!args[0], _("error.argumentOrBang")); if (args.bang) args["-group"].clear(modes); else if (!args["-group"].remove(modes, args[0])) return dactyl.echoerr(_("abbreviation.noSuch")); }, { argCount: "?", bang: true, completer: function (context, args) { completion.abbreviation(context, modes, args["-group"]); }, literal: 0, options: [contexts.GroupFlag("abbrevs")] }); } addAbbreviationCommands([modes.INSERT, modes.COMMAND_LINE], "", ""); [modes.INSERT, modes.COMMAND_LINE].forEach(function (mode) { addAbbreviationCommands([mode], mode.char, mode.displayName); }); } }); // vim: set fdm=marker sw=4 sts=4 ts=8 et: dactyl-1.2~r20151231/common/content/about.xul000066400000000000000000000023321264147376100206540ustar00rootroot00000000000000 dactyl-1.2~r20151231/common/content/autocommands.js000066400000000000000000000276051264147376100220520ustar00rootroot00000000000000// Copyright (c) 2006-2008 by Martin Stubenschrott // Copyright (c) 2007-2011 by Doug Kearns // Copyright (c) 2008-2014 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; /** @scope modules */ var AutoCommand = Struct("event", "filter", "command"); update(AutoCommand.prototype, { eventName: Class.Memoize(function () { return this.event.toLowerCase(); }), match: function (event, pattern) { return (!event || this.eventName == event.toLowerCase()) && (!pattern || String(this.filter) === String(pattern)); } }); var AutoCmdHive = Class("AutoCmdHive", Contexts.Hive, { init: function init(group) { init.supercall(this, group); this._store = []; }, "@@iterator": function () { return this._store[Symbol.iterator](); }, /** * Adds a new autocommand. *cmd* will be executed when one of the specified * *events* occurs and the URL of the applicable buffer matches *regexp*. * * @param {Array} events The array of event names for which this * autocommand should be executed. * @param {string} pattern The URL pattern to match against the buffer URL. * @param {string} cmd The Ex command to run. */ add: function (events, pattern, cmd) { if (!callable(pattern)) pattern = Group.compileFilter(pattern); for (let event of events) this._store.push(AutoCommand(event, pattern, cmd)); }, /** * Returns all autocommands with a matching *event* and *filter*. * * @param {string} event The event name filter. * @param {string} filter The URL pattern filter. * @returns {[AutoCommand]} */ get: function (event, filter) { filter = filter && String(Group.compileFilter(filter)); return this._store.filter(cmd => cmd.match(event, filter)); }, /** * Deletes all autocommands with a matching *event* and *filter*. * * @param {string} event The event name filter. * @param {string} filter The URL pattern filter. */ remove: function (event, filter) { filter = filter && String(Group.compileFilter(filter)); this._store = this._store.filter(cmd => !cmd.match(event, filter)); } }); /** * @instance autocommands */ var AutoCommands = Module("autocommands", { get activeHives() { return contexts.allGroups.autocmd.filter(h => h._store.length); }, add: deprecated("group.autocmd.add", { get: function add() { return autocommands.user.bound.add; } }), get: deprecated("group.autocmd.get", { get: function get() { return autocommands.user.bound.get; } }), remove: deprecated("group.autocmd.remove", { get: function remove() { return autocommands.user.bound.remove; } }), /** * Lists all autocommands with a matching *event*, *regexp* and optionally * *hives*. * * @param {string} event The event name filter. * @param {string} regexp The URL pattern filter. * @param {[Hive]} hives List of hives. * @optional */ list: function (event, regexp, hives) { hives = hives || this.activeHives; function cmds(hive) { let cmds = {}; hive._store.forEach(function (autoCmd) { if (autoCmd.match(event, regexp)) { cmds[autoCmd.event] = cmds[autoCmd.event] || []; cmds[autoCmd.event].push(autoCmd); } }); return cmds; } let table = ( ["table", {}, ["tr", { highlight: "Title" }, ["td", { colspan: "3" }, "----- Auto Commands -----"]], hives.map(hive => [ ["tr", {}, ["td", { colspan: "3" }, ["span", { highlight: "Title" }, hive.name], " ", hive.filter.toJSONXML(modules)]], ["tr", { style: "height: .5ex;" }], iter(cmds(hive)).map(([event, items]) => [ ["tr", { style: "height: .5ex;" }], items.map((item, i) => ["tr", {}, ["td", { highlight: "Title", style: "padding-left: 1em; padding-right: 1em;" }, i == 0 ? event : ""], ["td", {}, item.filter.toJSONXML ? item.filter.toJSONXML(modules) : String(item.filter)], ["td", {}, String(item.command)]]), ["tr", { style: "height: .5ex;" }]]).toArray(), ["tr", { style: "height: .5ex;" }] ])]); commandline.commandOutput(table); }, /** * Triggers the execution of all autocommands registered for *event*. A map * of *args* is passed to each autocommand when it is being executed. * * @param {string} event The event to fire. * @param {Object} args The args to pass to each autocommand. */ trigger: function (event, args) { if (options.get("eventignore").has(event)) return; dactyl.echomsg(_("autocmd.executing", event, '"*"'), 8); let lastPattern = null; var { url, doc } = args; if (url) uri = util.createURI(url); else var { uri, doc } = buffer; event = event.toLowerCase(); for (let hive of this.matchingHives(uri, doc)) { let args = hive.makeArgs(doc, null, arguments[1]); for (let autoCmd of hive._store) if (autoCmd.eventName === event && autoCmd.filter(uri, doc)) { if (!lastPattern || lastPattern !== String(autoCmd.filter)) dactyl.echomsg(_("autocmd.executing", event, autoCmd.filter), 8); lastPattern = String(autoCmd.filter); dactyl.echomsg(_("autocmd.autocommand", autoCmd.command), 9); dactyl.trapErrors(autoCmd.command, autoCmd, args); } } } }, { }, { contexts: function initContexts() { update(AutoCommands.prototype, { hives: contexts.Hives("autocmd", AutoCmdHive), user: contexts.hives.autocmd.user, allHives: contexts.allGroups.autocmd, matchingHives: function matchingHives(uri, doc) { return contexts.matchingGroups(uri, doc).autocmd; } }); }, commands: function initCommands() { commands.add(["au[tocmd]"], "Execute commands automatically on events", function (args) { let [event, filter, cmd] = args; let events = []; if (event) { // NOTE: event can only be a comma separated list for |:au {event} {pat} {cmd}| let validEvents = Object.keys(config.autocommands).map(String.toLowerCase); validEvents.push("*"); events = Option.parse.stringlist(event); dactyl.assert(events.every(e => validEvents.indexOf(e.toLowerCase()) >= 0), _("autocmd.noGroup", event)); } if (args.length > 2) { // add new command, possibly removing all others with the same event/pattern if (args.bang) args["-group"].remove(event, filter); cmd = contexts.bindMacro(args, "-ex", params => params); args["-group"].add(events, filter, cmd); } else { if (event == "*") event = null; if (args.bang) { // TODO: "*" only appears to work in Vim when there is a {group} specified if (args[0] != "*" || args.length > 1) args["-group"].remove(event, filter); // remove all } else autocommands.list(event, filter, args.explicitOpts["-group"] ? [args["-group"]] : null); // list all } }, { bang: true, completer: function (context, args) { if (args.length == 1) completion.autocmdEvent(context); else if (args.length == 3) args["-javascript"] ? completion.javascript(context) : completion.ex(context); }, hereDoc: true, keepQuotes: true, literal: 2, options: [ contexts.GroupFlag("autocmd"), { names: ["-javascript", "-js"], description: "Interpret the action as JavaScript code rather than an Ex command" } ] }); [ { name: "do[autocmd]", description: "Apply the autocommands matching the specified URL pattern to the current buffer" }, { name: "doautoa[ll]", description: "Apply the autocommands matching the specified URL pattern to all buffers" } ].forEach(function (command) { commands.add([command.name], command.description, // TODO: Perhaps this should take -args to pass to the command? function (args) { // Vim compatible if (args.length == 0) return void dactyl.echomsg(_("autocmd.noMatching")); let [event, url] = args; let uri = util.createURI(url) || buffer.uri; let validEvents = Object.keys(config.autocommands); // TODO: add command validators dactyl.assert(event != "*", _("autocmd.cantExecuteAll")); dactyl.assert(validEvents.indexOf(event) >= 0, _("autocmd.noGroup", args)); dactyl.assert(autocommands.get(event).some(c => c.filter(uri)), _("autocmd.noMatching")); if (this.name == "doautoall" && dactyl.has("tabs")) { let current = tabs.index(); for (let i = 0; i < tabs.count; i++) { tabs.select(i); // if no url arg is specified use the current buffer's URL autocommands.trigger(event, { url: uri.spec }); } tabs.select(current); } else autocommands.trigger(event, { url: uri.spec }); }, { argCount: "*", // FIXME: kludged for proper error message should be "1". completer: function (context) { completion.autocmdEvent(context); }, keepQuotes: true }); }); }, completion: function initCompletion() { completion.autocmdEvent = function autocmdEvent(context) { context.completions = iter(config.autocommands); }; }, javascript: function initJavascript() { JavaScript.setCompleter(AutoCmdHive.prototype.get, [() => iter(config.autocommands)]); }, options: function initOptions() { options.add(["eventignore", "ei"], "List of autocommand event names which should be ignored", "stringlist", "", { values: iter(update({ all: "All Events" }, config.autocommands)).toArray(), has: Option.has.toggleAll }); } }); // vim: set fdm=marker sw=4 sts=4 ts=8 et: dactyl-1.2~r20151231/common/content/bindings.xml000066400000000000000000000074741264147376100213430ustar00rootroot00000000000000 dactyl-1.2~r20151231/common/content/blank.xul000066400000000000000000000003631264147376100206330ustar00rootroot00000000000000 Hello, there. dactyl-1.2~r20151231/common/content/bookmarks.js000066400000000000000000001003451264147376100213410ustar00rootroot00000000000000// Copyright (c) 2006-2008 by Martin Stubenschrott // Copyright (c) 2007-2011 by Doug Kearns // Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; // also includes methods for dealing with keywords and search engines var Bookmarks = Module("bookmarks", { init: function () { this.timer = Timer(0, 100, function () { this.checkBookmarked(buffer.uri); }, this); storage.addObserver("bookmark-cache", function (key, event, arg) { if (["add", "change", "remove"].indexOf(event) >= 0) autocommands.trigger("Bookmark" + util.capitalize(event), update({ bookmark: { toString: function () { return "bookmarkcache.bookmarks[" + arg.id + "]"; }, valueOf: function () { return arg; } } }, arg.toObject())); bookmarks.timer.tell(); }, window); }, signals: { "browser.locationChange": function (webProgress, request, uri) { statusline.bookmarked = false; this.checkBookmarked(uri); } }, get format() { return { anchored: false, title: ["URL", "Info"], keys: { text: "url", description: "title", icon: "icon", extra: "extra", tags: "tags", isURI: function () { return true; }}, process: [template.icon, template.bookmarkDescription] }; }, // TODO: why is this a filter? --djk get: function get(filter, tags, maxItems, extra) { return completion.runCompleter("bookmark", filter, maxItems, tags, extra); }, /** * Adds a new bookmark. The first parameter should be an object with * any of the following properties: * * @param {boolean} unfiled If true, the bookmark is added to the * Unfiled Bookmarks Folder. * @param {string} title The title of the new bookmark. * @param {string} url The URL of the new bookmark. * @param {string} keyword The keyword of the new bookmark. * @optional * @param {[string]} tags The tags for the new bookmark. * @optional * @param {boolean} force If true, a new bookmark is always added. * Otherwise, if a bookmark for the given URL exists it is * updated instead. * @optional * @returns {boolean} True if the bookmark was updated, false if a * new bookmark was added. */ add: function add(unfiled, title, url, keyword, tags, force) { // FIXME if (isObject(unfiled)) var { id, unfiled, title, url, keyword, tags, post, charset, force } = unfiled; let uri = util.createURI(url); if (id != null) var bmark = bookmarkcache.bookmarks[id]; else if (!force) { if (keyword && hasOwnProp(bookmarkcache.keywords, keyword)) bmark = bookmarkcache.keywords[keyword]; else if (bookmarkcache.isBookmarked(uri)) for (bmark of bookmarkcache) if (bmark.url == uri.spec) break; } if (tags) { PlacesUtils.tagging.untagURI(uri, null); PlacesUtils.tagging.tagURI(uri, tags); } let updated = !!bmark; if (bmark == undefined) bmark = bookmarkcache.bookmarks[ services.bookmarks.insertBookmark( services.bookmarks[unfiled ? "unfiledBookmarksFolder" : "bookmarksMenuFolder"], uri, -1, title || url)]; else { if (title) bmark.title = title; if (!uri.equals(bmark.uri)) bmark.uri = uri; } util.assert(bmark); if (charset !== undefined) bmark.charset = charset; if (post !== undefined) bmark.post = post; if (keyword) bmark.keyword = keyword; return updated; }, /** * Opens the command line in Ex mode pre-filled with a :bmark * command to add a new search keyword for the given form element. * * @param {Element} elem A form element for which to add a keyword. */ addSearchKeyword: function addSearchKeyword(elem) { if (elem instanceof Ci.nsIDOMHTMLFormElement || elem.form) var { url, postData, charset } = DOM(elem).formData; else var [url, postData, charset] = [elem.href || elem.src, null, elem.ownerDocument.characterSet]; let title = elem.title || elem instanceof Ci.nsIDOMHTMLAnchorElement && elem.textContent.trim(); let options = { "-title": title || "Search " + elem.ownerDocument.title }; if (postData != null) options["-post"] = postData; if (charset != null && charset !== "UTF-8") options["-charset"] = charset; CommandExMode().open( commands.commandToString({ command: "bmark", options: options, arguments: [url] }) + " -keyword "); }, checkBookmarked: function checkBookmarked(uri) { if (PlacesUtils.asyncGetBookmarkIds) PlacesUtils.asyncGetBookmarkIds(uri, function withBookmarkIDs(ids) { statusline.bookmarked = ids.length; }); else this.timeout(function () { statusline.bookmarked = bookmarkcache.isBookmarked(uri); }); }, /** * Toggles the bookmarked state of the given URL. If the URL is * bookmarked, all bookmarks for said URL are removed. * If it is not, a new bookmark is added to the Unfiled Bookmarks * Folder. The new bookmark has the title of the current buffer if * its URL is identical to *url*, otherwise its title will be the * value of *url*. * * @param {string} url The URL of the bookmark to toggle. */ toggle: function toggle(url) { if (!url) return; let count = this.remove(url); if (count > 0) dactyl.echomsg({ domains: [util.getHost(url)], message: _("bookmark.removed", url) }); else { let title = buffer.uri.spec == url && buffer.title || url; let extra = ""; if (title != url) extra = " (" + title + ")"; this.add({ unfiled: true, title: title, url: url }); dactyl.echomsg({ domains: [util.getHost(url)], message: _("bookmark.added", url + extra) }); } }, isBookmarked: deprecated("bookmarkcache.isBookmarked", { get: function isBookmarked() { return bookmarkcache.bound.isBookmarked; } }), /** * Remove a bookmark or bookmarks. If *ids* is an array, removes the * bookmarks with those IDs. If it is a string, removes all * bookmarks whose URLs match that string. * * @param {string|[number]} ids The IDs or URL of the bookmarks to * remove. * @returns {number} The number of bookmarks removed. */ remove: function remove(ids) { try { if (!isArray(ids)) { let uri = util.newURI(ids); ids = services.bookmarks .getBookmarkIdsForURI(uri, {}) .filter(bookmarkcache.bound.isRegularBookmark); } ids.forEach(function (id) { let bmark = bookmarkcache.bookmarks[id]; if (bmark) { PlacesUtils.tagging.untagURI(bmark.uri, null); bmark.charset = null; } services.bookmarks.removeItem(id); }); return ids.length; } catch (e) { dactyl.reportError(e, true); return 0; } }, getSearchEngines: deprecated("bookmarks.searchEngines", function getSearchEngines() { return this.searchEngines; }), /** * Returns a list of all visible search engines in the search * services, augmented with keyword, title, and icon properties for * use in completion functions. */ get searchEngines() { let aliases = {}; return iter(services.browserSearch.getVisibleEngines({})).map(function ([, engine]) { let alias = engine.alias; if (!alias || !/^[a-z0-9-]+$/.test(alias)) alias = engine.name.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/, "").toLowerCase(); if (!alias) alias = "search"; // for search engines which we can't find a suitable alias if (hasOwnProp(aliases, alias)) alias += ++aliases[alias]; else aliases[alias] = 0; return [alias, { keyword: alias, __proto__: engine, title: engine.description, icon: engine.iconURI && engine.iconURI.spec }]; }).toObject(); }, /** * Returns true if the given search engine provides suggestions. * engine based on the given *query*. The results are always in the * form of an array of strings. If *callback* is provided, the * request is executed asynchronously and *callback* is called on * completion. Otherwise, the request is executed synchronously and * the results are returned. * * @param {string} engineName The name of the search engine from * which to request suggestions. * @returns {boolean} */ hasSuggestions: function hasSuggestions(engineName, query, callback) { const responseType = "application/x-suggestions+json"; if (hasOwnProp(this.suggestionProviders, engineName)) return true; let engine = hasOwnProp(this.searchEngines, engineName) && this.searchEngines[engineName]; if (engine && engine.supportsResponseType(responseType)) return true; return false; }, /** * Retrieves a list of search suggestions from the named search * engine based on the given *query*. The results are always in the * form of an array of strings. If *callback* is provided, the * request is executed asynchronously and *callback* is called on * completion. Otherwise, the request is executed synchronously and * the results are returned. * * @param {string} engineName The name of the search engine from * which to request suggestions. * @param {string} query The query string for which to request * suggestions. * @param {function([string])} callback The function to call when * results are returned. * @returns {[string] | null} */ getSuggestions: function getSuggestions(engineName, query, callback) { const responseType = "application/x-suggestions+json"; if (hasOwnProp(this.suggestionProviders, engineName)) return this.suggestionProviders[engineName](query, callback); let engine = hasOwnProp(this.searchEngines, engineName) && this.searchEngines[engineName]; if (engine && engine.supportsResponseType(responseType)) var queryURI = engine.getSubmission(query, responseType).uri.spec; if (!queryURI) return Promise.reject(); function parse(req) { return JSON.parse(req.responseText)[1].filter(isString); } return this.makeSuggestions(queryURI, parse, callback); }, /** * Given a query URL, response parser, and optionally a callback, * fetch and parse search query results for {@link getSuggestions}. * * @param {string} url The URL to fetch. * @param {function(XMLHttpRequest):[string]} parser The function which * parses the response. * @returns {Promise} */ makeSuggestions: function makeSuggestions(url, parser) { return new CancelablePromise((resolve, reject, canceled) => { let req = util.fetchUrl(url); req.then(function process(req) { let results = []; try { results = parser(req); } catch (e) { reject(e); return; } resolve(results); }); canceled.then(req.cancel); }); }, suggestionProviders: {}, /** * Returns an array containing a search URL and POST data for the * given search string. If *useDefsearch* is true, the string is * always passed to the default search engine. If it is not, the * search engine name is retrieved from the first space-separated * token of the given string. * * Returns null if no search engine is found for the passed string. * * @param {string} text The text for which to retrieve a search URL. * @param {boolean} useDefsearch Whether to use the default search * engine. * @returns {[string, string | null] | null} */ getSearchURL: function getSearchURL(text, useDefsearch) { let query = (useDefsearch ? options["defsearch"] + " " : "") + text; let [keyword, param] = util.split(query, " ", 2); param = param || ""; var engine = hasOwnProp(bookmarks.searchEngines, keyword) && bookmarks.searchEngines[keyword]; if (engine) { if (engine.searchForm && !param) return engine.searchForm; let submission = engine.getSubmission(param, null); return [submission.uri.spec, submission.postData]; } let [url, postData] = PlacesUtils.getURLAndPostDataForKeyword(keyword); if (!url) return null; let data = window.unescape(postData || ""); if (/%s/i.test(url) || /%s/i.test(data)) { var charset = ""; var matches = url.match(/^(.*)\&mozcharset=([a-zA-Z][_\-a-zA-Z0-9]+)\s*$/); if (matches) [, url, charset] = matches; else try { charset = services.annotation.getPageAnnotation(util.newURI(url), PlacesUtils.CHARSET_ANNO); } catch (e) {} if (charset) var encodedParam = escape(window.convertFromUnicode(charset, param)).replace(/\+/g, encodeURIComponent); else encodedParam = bookmarkcache.keywords[keyword.toLowerCase()].encodeURIComponent(param); url = url.replace(/%s/g, () => encodedParam) .replace(/%S/g, () => param); if (/%s/i.test(data)) postData = window.getPostDataStream(data, param, encodedParam, "application/x-www-form-urlencoded"); } else if (param) postData = null; if (postData) return [url, postData]; return url; }, /** * Lists all bookmarks whose URLs match *filter*, tags match *tags*, * and other properties match the properties of *extra*. If * *openItems* is true, the items are opened in tabs rather than * listed. * * @param {string} filter A URL filter string which the URLs of all * matched items must contain. * @param {[string]} tags An array of tags each of which all matched * items must contain. * @param {boolean} openItems If true, items are opened rather than * listed. * @param {object} extra Extra properties which must be matched. */ list: function list(filter, tags, openItems, maxItems, extra) { // FIXME: returning here doesn't make sense // Why the hell doesn't it make sense? --Kris // Because it unconditionally bypasses the final error message // block and does so only when listing items, not opening them. In // short it breaks the :bmarks command which doesn't make much // sense to me but I'm old-fashioned. --djk if (!openItems) return completion.listCompleter("bookmark", filter, maxItems, tags, extra); let items = completion.runCompleter("bookmark", filter, maxItems, tags, extra); if (items.length) return dactyl.open(items.map(i => i.url), dactyl.NEW_TAB); if (filter.length > 0 && tags.length > 0) dactyl.echoerr(_("bookmark.noMatching", tags.map(JSON.stringify), JSON.stringify(filter))); else if (filter.length > 0) dactyl.echoerr(_("bookmark.noMatchingString", JSON.stringify(filter))); else if (tags.length > 0) dactyl.echoerr(_("bookmark.noMatchingTags", tags.map(JSON.stringify))); else dactyl.echoerr(_("bookmark.none")); return null; } }, { }, { commands: function initCommands() { // TODO: Clean this up. const tags = { names: ["-tags", "-T"], description: "A comma-separated list of tags", completer: function tags(context) { context.generate = () => new RealSet(Array.from(bookmarkcache) .flatMap(b.tags)); context.keys = { text: identity, description: identity }; }, type: CommandOption.LIST }; const title = { names: ["-title", "-t"], description: "Bookmark page title or description", completer: function title(context, args) { let frames = buffer.allFrames(); if (!args.bang) return frames.map(win => [win.document.title, frames.length == 1 ? /*L*/"Current Location" : /*L*/"Frame: " + win.location.href]); context.keys.text = "title"; context.keys.description = "url"; return bookmarks.get(args.join(" "), args["-tags"], null, { keyword: args["-keyword"], title: context.filter }); }, type: CommandOption.STRING }; const post = { names: ["-post", "-p"], description: "Bookmark POST data", completer: function post(context, args) { context.keys.text = "post"; context.keys.description = "url"; return bookmarks.get(args.join(" "), args["-tags"], null, { keyword: args["-keyword"], post: context.filter }); }, type: CommandOption.STRING }; const keyword = { names: ["-keyword", "-k"], description: "Keyword by which this bookmark may be opened (:open {keyword})", completer: function keyword(context, args) { context.keys.text = "keyword"; return bookmarks.get(args.join(" "), args["-tags"], null, { keyword: context.filter, title: args["-title"] }); }, type: CommandOption.STRING, validator: bind("test", /^\S+$/) }; commands.add(["bma[rk]"], "Add a bookmark", function (args) { dactyl.assert(!args.bang || args["-id"] == null, _("bookmark.bangOrID")); let opts = { force: args.bang, unfiled: false, id: args["-id"], keyword: args["-keyword"] || null, charset: args["-charset"], post: args["-post"], tags: args["-tags"] || [], title: args["-title"] || (args.length === 0 ? buffer.title : null), url: args.length === 0 ? buffer.uri.spec : args[0] }; let updated = bookmarks.add(opts); let action = updated ? "updated" : "added"; let extra = (opts.title && opts.title != opts.url) ? " (" + opts.title + ")" : ""; dactyl.echomsg({ domains: [util.getHost(opts.url)], message: _("bookmark." + action, opts.url + extra) }, 1, commandline.FORCE_SINGLELINE); }, { argCount: "?", bang: true, completer: function (context, args) { if (!args.bang) { context.title = ["Page URL"]; let frames = buffer.allFrames(); context.completions = frames.map(win => [win.document.documentURI, frames.length == 1 ? /*L*/"Current Location" : /*L*/"Frame: " + win.document.title]); } else completion.bookmark(context, args["-tags"], { keyword: args["-keyword"], title: args["-title"] }); }, options: [keyword, title, tags, post, { names: ["-charset", "-c"], description: "The character encoding of the bookmark", type: CommandOption.STRING, completer: function (context) { completion.charset(context); }, validator: io.bound.validateCharset }, { names: ["-id"], description: "The ID of the bookmark to update", type: CommandOption.INT } ] }); commands.add(["bmarks"], "List or open multiple bookmarks", function (args) { bookmarks.list(args.join(" "), args["-tags"] || [], args.bang, args["-max"], { keyword: args["-keyword"], title: args["-title"] }); }, { bang: true, completer: function completer(context, args) { context.filter = args.join(" "); completion.bookmark(context, args["-tags"], { keyword: args["-keyword"], title: args["-title"] }); }, options: [tags, keyword, title, { names: ["-max", "-m"], description: "The maximum number of items to list or open", type: CommandOption.INT } ] // Not privateData, since we don't treat bookmarks as private }); commands.add(["delbm[arks]"], "Delete a bookmark", function (args) { if (args.bang) commandline.input(_("bookmark.prompt.deleteAll") + " ").then( resp => { if (resp && resp.match(/^y(es)?$/i)) { bookmarks.remove(Object.keys(bookmarkcache.bookmarks)); dactyl.echomsg(_("bookmark.allDeleted")); } }); else { if (!(args.length || args["-tags"] || args["-keyword"] || args["-title"])) var deletedCount = bookmarks.remove(buffer.uri.spec); else { let context = CompletionContext(args.join(" ")); context.fork("bookmark", 0, completion, "bookmark", args["-tags"], { keyword: args["-keyword"], title: args["-title"] }); deletedCount = bookmarks.remove(context.allItems.items .map(item => item.item.id)); } dactyl.echomsg({ message: _("bookmark.deleted", deletedCount) }); } }, { argCount: "?", bang: true, completer: function completer(context, args) { completion.bookmark(context, args["-tags"], { keyword: args["-keyword"], title: args["-title"] }); }, domains: function (args) { return Ary.compact(args.map(util.getHost)); }, literal: 0, options: [tags, title, keyword], privateData: true }); }, mappings: function initMappings() { var myModes = config.browserModes; mappings.add(myModes, ["a"], "Open a prompt to bookmark the current URL", function () { let options = {}; let url = buffer.uri.spec; let bmarks = bookmarks.get(url).filter(bmark => bmark.url == url); if (bmarks.length == 1) { let bmark = bmarks[0]; options["-id"] = bmark.id; options["-title"] = bmark.title; if (bmark.charset) options["-charset"] = bmark.charset; if (bmark.keyword) options["-keyword"] = bmark.keyword; if (bmark.post) options["-post"] = bmark.post; if (bmark.tags.length > 0) options["-tags"] = bmark.tags; } else { if (buffer.title != buffer.uri.spec) options["-title"] = buffer.title; if (content.document.characterSet !== "UTF-8") options["-charset"] = content.document.characterSet; } CommandExMode().open( commands.commandToString({ command: "bmark", options: options, arguments: [buffer.uri.spec] })); }); mappings.add(myModes, ["A"], "Toggle bookmarked state of current URL", function () { bookmarks.toggle(buffer.uri.spec); }); }, options: function initOptions() { options.add(["defsearch", "ds"], "The default search engine", "string", "google", { completer: function completer(context) { completion.search(context, true); context.completions = [{ keyword: "", title: "Don't perform searches by default" }].concat(context.completions); } }); options.add(["suggestengines"], "Search engines used for search suggestions", "stringlist", "google", { completer: function completer(context) { completion.searchEngine(context, true); } }); }, completion: function initCompletion() { completion.bookmark = function bookmark(context, tags, extra={}) { context.title = ["Bookmark", "Title"]; context.format = bookmarks.format; iter(extra).forEach(function ([k, v]) { if (v != null) context.filters.push(function (item) { return item.item[k] != null && this.matchString(v, item.item[k]); }); }); context.generate = () => values(bookmarkcache.bookmarks); completion.urls(context, tags); }; completion.search = function search(context, noSuggest) { let [, keyword, space, args] = context.filter.match(/^\s*(\S*)(\s*)(.*)$/); let keywords = bookmarkcache.keywords; let engines = bookmarks.searchEngines; context.title = ["Search Keywords"]; context.completions = iter(values(keywords), values(engines)); context.keys = { text: "keyword", description: "title", icon: "icon" }; if (!space || noSuggest) return; context.fork("suggest", keyword.length + space.length, this, "searchEngineSuggest", keyword, true); let item = keywords[keyword]; if (item && item.url.includes("%s")) context.fork("keyword/" + keyword, keyword.length + space.length, null, context => { context.format = history.format; context.title = [/*L*/keyword + " Quick Search"]; context.keys = { text: "url", description: "title", icon: "icon" }; context.compare = CompletionContext.Sort.unsorted; context.generate = () => { let [begin, end] = item.url.split("%s"); let seen = new RealSet; return history.get({ uri: util.newURI(begin), uriIsPrefix: true }).map(function (item) { let rest = item.url.length - end.length; let query = item.url.substring(begin.length, rest); if (item.url.substr(rest) == end && query.includes("&")) try { item.url = decodeURIComponent(query.replace(/[&#].*/, "").replace(/\+/g, " ")); if (!seen.add(item.url)) return item; } catch (e) {} return null; }).filter(identity); }; }); }; completion.searchEngine = function searchEngine(context, suggest) { context.title = ["Suggest Engine", "Description"]; context.keys = { text: "keyword", description: "title", icon: "icon" }; context.completions = values(bookmarks.searchEngines); if (suggest) context.filters.push(({ item }) => item.supportsResponseType("application/x-suggestions+json")); }; completion.searchEngineSuggest = function searchEngineSuggest(context, engineAliases, kludge) { if (!context.filter) return; let engineList = (engineAliases || options["suggestengines"].join(",") || "google").split(","); engineList.forEach(function (name) { if (!bookmarks.hasSuggestions(name)) return; var desc = name; let engine = bookmarks.searchEngines[name]; if (engine) desc = engine.description; let [, word] = /^\s*(\S+)/.exec(context.filter) || []; if (!kludge && word == name) // FIXME: Check for matching keywords return; let ctxt = context.fork(name, 0); ctxt.title = [/*L*/desc + " Suggestions"]; ctxt.keys = { text: identity, description: function () { return ""; } }; ctxt.compare = CompletionContext.Sort.unsorted; ctxt.filterFunc = null; if (ctxt.waitingForTab) return; let words = ctxt.filter.toLowerCase().split(/\s+/g); ctxt.completions = ctxt.completions.filter(i => words.every(w => i.toLowerCase().includes(w))); ctxt.hasItems = ctxt.completions.length; ctxt.incomplete = true; ctxt.cache.request = bookmarks.getSuggestions(name, ctxt.filter); ctxt.cache.request.then(function (compl) { ctxt.incomplete = false; ctxt.completions = Ary.uniq(ctxt.completions.filter(c => ~compl.indexOf(c)) .concat(compl), true); }).catch(function (e) { ctxt.incomplete = false; ctxt.completions = []; if (e) Cu.reportError(e); }); }); }; completion.addUrlCompleter("suggestion", "Search engine suggestions", completion.searchEngineSuggest); completion.addUrlCompleter("bookmark", "Bookmarks", completion.bookmark); completion.addUrlCompleter("search", "Search engines and keyword URLs", completion.search); } }); // vim: set fdm=marker sw=4 sts=4 ts=8 et: dactyl-1.2~r20151231/common/content/browser.js000066400000000000000000000314671264147376100210440ustar00rootroot00000000000000// Copyright (c) 2006-2008 by Martin Stubenschrott // Copyright (c) 2007-2011 by Doug Kearns // Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; /** @scope modules */ /** * @instance browser */ var Browser = Module("browser", XPCOM(Ci.nsISupportsWeakReference, ModuleBase), { init: function init() { this.cleanupProgressListener = overlay.overlayObject(window.XULBrowserWindow, this.progressListener); util.addObserver(this); this._unoverlay = overlay.overlayObject(FullZoom, { get siteSpecific() { return false; }, set siteSpecific(val) {} }); config.tabbrowser.addTabsProgressListener(this.tabsProgressListener); }, destroy: function () { this.cleanupProgressListener(); this.observe.unregister(); this._unoverlay(); config.tabbrowser.removeTabsProgressListener(this.tabsProgressListener); }, observers: { "chrome-document-global-created": function (win, uri) { this.observe(win, "content-document-global-created", uri); }, "content-document-global-created": function (win, uri) { let top = util.topWindow(win); if (uri == "null") uri = null; if (top == window && (win.location.href || uri)) this._triggerLoadAutocmd("PageLoadPre", win.document, win.location.href || uri); } }, _triggerLoadAutocmd: function _triggerLoadAutocmd(name, doc, uri) { if (!(uri || doc.location)) return; uri = isObject(uri) ? uri : util.newURI(uri || doc.location.href); let args = { url: { toString: function () { return uri.spec; }, valueOf: function () { return uri; } }, title: doc.title }; if (!dactyl.has("tabs")) update(args, { doc: doc, win: doc.defaultView }); else { args.tab = tabs.getContentIndex(doc) + 1; args.doc = { valueOf: function () { return doc; }, toString: function () { return "tabs.getTab(" + (args.tab - 1) + ").linkedBrowser.contentDocument"; } }; args.win = { valueOf: function () { return doc.defaultView; }, toString: function () { return "tabs.getTab(" + (args.tab - 1) + ").linkedBrowser.contentWindow"; } }; } autocommands.trigger(name, args); }, events: { DOMContentLoaded: function onDOMContentLoaded(event) { let doc = event.originalTarget; if (doc instanceof Ci.nsIDOMHTMLDocument) this._triggerLoadAutocmd("DOMLoad", doc); }, // TODO: see what can be moved to onDOMContentLoaded() // event listener which is is called on each page load, even if the // page is loaded in a background tab load: function onLoad(event) { let doc = event.originalTarget; if (doc instanceof Ci.nsIDOMDocument) dactyl.initDocument(doc); if (doc instanceof Ci.nsIDOMHTMLDocument) { if (doc.defaultView.frameElement) { // document is part of a frameset // hacky way to get rid of "Transferring data from ..." on sites with frames // when you click on a link inside a frameset, because asyncUpdateUI // is not triggered there (Gecko bug?) this.timeout(function () { statusline.updateStatus(); }, 10); } else { // code which should happen for all (also background) newly loaded tabs goes here: if (doc != config.browser.contentDocument) dactyl.echomsg({ domains: [util.getHost(doc.location)], message: _("buffer.backgroundLoaded", (doc.title || doc.location.href)) }, 3); this._triggerLoadAutocmd("PageLoad", doc); } } } }, /** * @property {Object} The document loading progress listener. */ progressListener: { onStateChange: util.wrapCallback(function onStateChange(webProgress, request, flags, status) { const L = Ci.nsIWebProgressListener; if (request) dactyl.applyTriggerObserver("browser.stateChange", arguments); if (flags & (L.STATE_IS_DOCUMENT | L.STATE_IS_WINDOW)) { // This fires when the load event is initiated // only thrown for the current tab, not when another tab changes if (flags & L.STATE_START) { while (document.commandDispatcher.focusedWindow == webProgress.DOMWindow && modes.have(modes.INPUT)) modes.pop(); } else if (flags & L.STATE_STOP) { // Workaround for bugs 591425 and 606877, dactyl bug #81 config.browser.mCurrentBrowser.collapsed = false; if (!dactyl.focusedElement || dactyl.focusedElement === document.documentElement) dactyl.focusContent(); } } onStateChange.superapply(this, arguments); }), onSecurityChange: util.wrapCallback(function onSecurityChange(webProgress, request, state) { onSecurityChange.superapply(this, arguments); dactyl.applyTriggerObserver("browser.securityChange", arguments); }), onStatusChange: util.wrapCallback(function onStatusChange(webProgress, request, status, message) { onStatusChange.superapply(this, arguments); dactyl.applyTriggerObserver("browser.statusChange", arguments); }), onProgressChange: util.wrapCallback(function onProgressChange(webProgress, request, curSelfProgress, maxSelfProgress, curTotalProgress, maxTotalProgress) { onProgressChange.superapply(this, arguments); dactyl.applyTriggerObserver("browser.progressChange", arguments); }), onLocationChange: util.wrapCallback(function onLocationChange(webProgress, request, uri) { onLocationChange.superapply(this, arguments); dactyl.applyTriggerObserver("browser.locationChange", arguments); let win = webProgress.DOMWindow; if (win && uri && !Cu.isCrossProcessWrapper(win)) { Buffer(win).updateZoom(); let oldURI = overlay.getData(win.document)["uri"]; if (overlay.getData(win.document)["load-idx"] === webProgress.loadedTransIndex || !oldURI || uri.spec.replace(/#.*/, "") !== oldURI.replace(/#.*/, "")) for (let frame of buffer.allFrames(win)) overlay.setData(frame.document, "focus-allowed", false); overlay.setData(win.document, "uri", uri.spec); overlay.setData(win.document, "load-idx", webProgress.loadedTransIndex); } // Workaround for bugs 591425 and 606877, dactyl bug #81 let collapse = uri && uri.scheme === "dactyl" && webProgress.isLoadingDocument; if (collapse) dactyl.focus(document.documentElement); config.browser.mCurrentBrowser.collapsed = collapse; util.timeout(function () { browser._triggerLoadAutocmd("LocationChange", (win || content).document, uri); }); }), // called at the very end of a page load asyncUpdateUI: util.wrapCallback(function asyncUpdateUI() { asyncUpdateUI.superapply(this, arguments); util.timeout(function () { statusline.updateStatus(); }, 100); }), setOverLink: util.wrapCallback(function setOverLink(link, b) { setOverLink.superapply(this, arguments); dactyl.triggerObserver("browser.overLink", link); }) }, tabsProgressListener: { onStateChange: function onStateChange(webProgress, request, flags, status) {}, onSecurityChange: function onSecurityChange(webProgress, request, state) {}, onStatusChange: function onStatusChange(webProgress, request, status, message) {}, onProgressChange: function onProgressChange(webProgress, request, curSelfProgress, maxSelfProgress, curTotalProgress, maxTotalProgress) {}, onLocationChange: util.wrapCallback(function onLocationChange(browser) { Buffer(null, browser).locationChanged(); }) } }, { }, { events: function initEvents(dactyl, modules, window) { events.listen(config.browser, browser, "events", true); }, commands: function initCommands(dactyl, modules, window) { commands.add(["o[pen]"], "Open one or more URLs in the current tab", function (args) { dactyl.open(args[0] || "about:blank"); }, { completer: function (context) { completion.url(context); }, domains: function (args) { return Ary.compact(dactyl.parseURLs(args[0] || "") .map(url => util.getHost(url))); }, literal: 0, privateData: true }); commands.add(["redr[aw]"], "Redraw the screen", function () { statusline.overLink = null; statusline.updateStatus(); commandline.clear(); window.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIDOMWindowUtils) .redraw(); }, { argCount: "0" }); }, mappings: function initMappings(dactyl, modules, window) { let openModes = { [dactyl.CURRENT_TAB]: "", [dactyl.NEW_TAB]: "tab", [dactyl.NEW_BACKGROUND_TAB]: "background tab", [dactyl.NEW_WINDOW]: "win", }; function open(mode, args) { if (dactyl.forceTarget in openModes) mode = openModes[dactyl.forceTarget]; CommandExMode().open(mode + "open " + (args || "")); } function decode(uri) { return util.losslessDecodeURI(uri) .replace(/%20(?!(?:%20)*$)/g, " ") .replace(RegExp(options["urlseparator"], "g"), encodeURIComponent); } mappings.add([modes.NORMAL], ["o"], "Open one or more URLs", function () { open(""); }); mappings.add([modes.NORMAL], ["O"], "Open one or more URLs, based on current location", function () { open("", decode(buffer.uri.spec)); }); mappings.add([modes.NORMAL], ["s"], "Open a search prompt", function () { open("", options["defsearch"] + " "); }); mappings.add([modes.NORMAL], ["S"], "Open a search prompt for a new tab", function () { open("tab", options["defsearch"] + " "); }); mappings.add([modes.NORMAL], ["t"], "Open one or more URLs in a new tab", function () { CommandExMode().open("tabopen "); }); mappings.add([modes.NORMAL], ["T"], "Open one or more URLs in a new tab, based on current location", function () { open("tab", decode(buffer.uri.spec)); }); mappings.add([modes.NORMAL], ["w"], "Open one or more URLs in a new window", function () { open("win"); }); mappings.add([modes.NORMAL], ["W"], "Open one or more URLs in a new window, based on current location", function () { open("win", decode(buffer.uri.spec)); }); mappings.add([modes.NORMAL], ["", "~"], "Open home directory", function () { dactyl.open("~"); }); mappings.add([modes.NORMAL], ["", "gh"], "Open homepage", function () { window.BrowserHome(); }); mappings.add([modes.NORMAL], ["", "gH"], "Open homepage in a new tab", function () { let homepages = window.gHomeButton.getHomePage(); dactyl.open(homepages, { from: "homepage", where: dactyl.NEW_TAB }); }); mappings.add([modes.MAIN], ["", ""], "Redraw the screen", function () { ex.redraw(); }); } }); // vim: set fdm=marker sw=4 sts=4 ts=8 et: dactyl-1.2~r20151231/common/content/buffer.xhtml000066400000000000000000000004001264147376100213310ustar00rootroot00000000000000 </head> <body/> </html> ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������dactyl-1.2~r20151231/common/content/commandline.js��������������������������������������������������0000664�0000000�0000000�00000263064�12641473761�0021647�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Copyright (c) 2006-2008 by Martin Stubenschrott <stubenschrott@vimperator.org> // Copyright (c) 2007-2011 by Doug Kearns <dougkearns@gmail.com> // Copyright (c) 2008-2015 Kris Maglione <maglione.k@gmail.com> // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; /** @scope modules */ var CommandWidgets = Class("CommandWidgets", { depends: ["statusline"], init: function init() { let s = "dactyl-statusline-field-"; overlay.overlayWindow(window, { objects: { eventTarget: commandline }, append: [ ["vbox", { id: config.ids.commandContainer, xmlns: "xul" }, ["vbox", { class: "dactyl-container", hidden: "false", collapsed: "true" }, ["iframe", { class: "dactyl-completions", id: "dactyl-completions-dactyl-commandline", src: "dactyl://content/buffer.xhtml", contextmenu: "dactyl-contextmenu", flex: "1", hidden: "false", collapsed: "false", highlight: "Events", events: "mowEvents" }]], ["stack", { orient: "horizontal", align: "stretch", class: "dactyl-container", id: "dactyl-container", highlight: "CmdLine CmdCmdLine" }, ["textbox", { class: "plain", id: "dactyl-strut", flex: "1", crop: "end", collapsed: "true" }], ["textbox", { class: "plain", id: "dactyl-mode", flex: "1", crop: "end" }], ["hbox", { id: "dactyl-message-box" }, ["label", { class: "plain", id: "dactyl-message-pre", flex: "0", readonly: "true", highlight: "WarningMsg" }], ["textbox", { class: "plain", id: "dactyl-message", flex: "1", readonly: "true" }]], ["hbox", { id: "dactyl-commandline", hidden: "false", class: "dactyl-container", highlight: "Normal CmdNormal", collapsed: "true" }, ["label", { id: "dactyl-commandline-prompt", class: "dactyl-commandline-prompt plain", flex: "0", crop: "end", value: "", collapsed: "true" }], ["textbox", { id: "dactyl-commandline-command", class: "dactyl-commandline-command plain", flex: "1", type: "input", timeout: "100", highlight: "Events" }]]], ["vbox", { class: "dactyl-container", hidden: "false", collapsed: "false", highlight: "CmdLine" }, ["textbox", { id: "dactyl-multiline-input", class: "plain", flex: "1", rows: "1", hidden: "false", collapsed: "true", multiline: "true", highlight: "Normal Events", events: "multilineInputEvents" }]]], ["stack", { id: "dactyl-statusline-stack", xmlns: "xul" }, ["hbox", { id: s + "commandline", hidden: "false", class: "dactyl-container", highlight: "Normal StatusNormal", collapsed: "true" }, ["label", { id: s + "commandline-prompt", class: "dactyl-commandline-prompt plain", flex: "0", crop: "end", value: "", collapsed: "true" }], ["textbox", { id: s + "commandline-command", class: "dactyl-commandline-command plain", flex: "1", type: "text", timeout: "100", highlight: "Events" }]]]], before: [ ["toolbar", { id: statusline.statusBar.id, xmlns: "xul" }, ["vbox", { id: "dactyl-completions-" + s + "commandline-container", class: "dactyl-container", hidden: "false", collapsed: "true" }, ["iframe", { class: "dactyl-completions", id: "dactyl-completions-" + s + "commandline", src: "dactyl://content/buffer.xhtml", contextmenu: "dactyl-contextmenu", flex: "1", hidden: "false", collapsed: "false", highlight: "Events", events: "mowEvents" }]]]] }); this.elements = {}; this.addElement({ name: "container", noValue: true }); this.addElement({ name: "commandline", getGroup: function () { return options.get("guioptions").has("C") ? this.commandbar : this.statusbar; }, getValue: function () { return this.command; } }); this.addElement({ name: "strut", defaultGroup: "Normal", getGroup: function () { return this.commandbar; }, getValue: function () { return options.get("guioptions").has("c"); } }); this.addElement({ name: "command", test: function test(stack, prev) { return stack.pop && !isinstance(prev.main, modes.COMMAND_LINE); }, id: "commandline-command", get: function command_get(elem) { // The long path is because of complications with the // completion preview. try { return elem.inputField.editor.rootElement.firstChild.textContent; } catch (e) { return elem.value; } }, getElement: CommandWidgets.getEditor, getGroup: function (value) { return this.activeGroup.commandline; }, onChange: function command_onChange(elem, value) { if (elem.inputField != dactyl.focusedElement) try { elem.selectionStart = elem.value.length; elem.selectionEnd = elem.value.length; } catch (e) {} if (!elem.collapsed) dactyl.focus(elem); }, onVisibility: function command_onVisibility(elem, visible) { if (visible) dactyl.focus(elem); } }); this.addElement({ name: "prompt", id: "commandline-prompt", defaultGroup: "CmdPrompt", getGroup: function () { return this.activeGroup.commandline; } }); this.addElement({ name: "message", defaultGroup: "Normal", getElement: CommandWidgets.getEditor, getGroup: function (value) { if (this.command && !options.get("guioptions").has("M")) return this.statusbar; let statusElem = this.statusbar.message; // Currently doesn't work as expected with <hbox> parent. if (false && value && !value[2] && statusElem.editor && statusElem.editor.rootElement.scrollWidth > statusElem.scrollWidth) return this.commandbar; return this.activeGroup.mode; } }); this.addElement({ name: "message-pre", defaultGroup: "WarningMsg", getGroup: function () { return this.activeGroup.message; } }); this.addElement({ name: "message-box", defaultGroup: "Normal", getGroup: function () { return this.activeGroup.message; }, getValue: function () { return this.message; } }); this.addElement({ name: "mode", defaultGroup: "ModeMsg", getGroup: function (value) { if (!options.get("guioptions").has("M")) if (this.commandbar.container.clientHeight == 0 || value && !this.commandbar.commandline.collapsed) return this.statusbar; return this.commandbar; } }); this.updateVisibility(); this.initialized = true; }, addElement: function addElement(obj) { const self = this; this.elements[obj.name] = obj; function get(prefix, map, id) { return (obj.getElement || identity)(map[id] || document.getElementById(prefix + id)); } this.active.__defineGetter__(obj.name, () => this.activeGroup[obj.name][obj.name]); this.activeGroup.__defineGetter__(obj.name, () => this.getGroup(obj.name)); memoize(this.statusbar, obj.name, () => get("dactyl-statusline-field-", statusline.widgets, (obj.id || obj.name))); memoize(this.commandbar, obj.name, () => get("dactyl-", {}, (obj.id || obj.name))); if (!(obj.noValue || obj.getValue)) { Object.defineProperty(this, obj.name, Modes.boundProperty({ test: obj.test, get: function get_widgetValue() { let elem = self.getGroup(obj.name, obj.value)[obj.name]; if (obj.value != null) return [obj.value[0], obj.get ? obj.get.call(this, elem) : elem.value] .concat(obj.value.slice(2)); return null; }, set: function set_widgetValue(val) { if (val != null && !isArray(val)) val = [obj.defaultGroup || "", val]; obj.value = val; [this.commandbar, this.statusbar].forEach(function (nodeSet) { let elem = nodeSet[obj.name]; if (val == null) elem.value = ""; else { highlight.highlightNode(elem, (val[0] != null ? val[0] : obj.defaultGroup) .split(/\s/).filter(identity) .map(g => g + " " + nodeSet.group + g) .join(" ")); elem.value = val[1]; if (obj.onChange) obj.onChange.call(this, elem, val); } }, this); this.updateVisibility(); return val; } }).init(obj.name)); } else if (obj.defaultGroup) { [this.commandbar, this.statusbar].forEach(function (nodeSet) { let elem = nodeSet[obj.name]; if (elem) highlight.highlightNode(elem, obj.defaultGroup.split(/\s/) .map(g => g + " " + nodeSet.group + g) .join(" ")); }); } }, getGroup: function getgroup(name, value) { if (!statusline.visible) return this.commandbar; return this.elements[name].getGroup.call(this, arguments.length > 1 ? value : this[name]); }, updateVisibility: function updateVisibility() { let changed = 0; for (let elem of values(this.elements)) if (elem.getGroup) { let value = elem.getValue ? elem.getValue.call(this) : elem.noValue || this[elem.name]; let activeGroup = this.getGroup(elem.name, value); for (let group of [this.commandbar, this.statusbar]) { let meth, node = group[elem.name]; let visible = (value && group === activeGroup); if (node && !node.collapsed == !visible) { changed++; node.collapsed = !visible; if (elem.onVisibility) elem.onVisibility.call(this, node, visible); } } } // Hack. Collapse hidden elements in the stack. // Might possibly be better to use a deck and programmatically // choose which element to select. function check(node) { if (DOM(node).style.display === "-moz-stack") { let nodes = Array.filter(node.children, n => !n.collapsed && n.boxObject.height); nodes.forEach((node, i) => { node.style.opacity = (i == nodes.length - 1) ? "" : "0"; }); } Array.forEach(node.children, check); } [this.commandbar.container, this.statusbar.container].forEach(check); if (this.initialized && loaded.has("mow") && mow.visible) mow.resize(false); }, active: Class.Memoize(Object), activeGroup: Class.Memoize(Object), commandbar: Class.Memoize(() => ({ group: "Cmd" })), statusbar: Class.Memoize(() => ({ group: "Status" })), _ready: function _ready(elem) { return elem.contentDocument.documentURI === elem.getAttribute("src") && ["viewable", "complete"].indexOf(elem.contentDocument.readyState) >= 0; }, _whenReady: function* _whenReady(id, init) { let elem = document.getElementById(id); while (!this._ready(elem)) yield 10; if (init) init.call(this, elem); yield elem; }, completionContainer: Class.Memoize(function () { return this.completionList.parentNode; }), contextMenu: Class.Memoize(function () { ["copy", "copylink", "selectall"].forEach(function (tail) { // some host apps use "hostPrefixContext-copy" ids let css = "menuitem[id$='ontext-" + tail + "']:not([id^=dactyl-])"; let style = DOM(css, document).style; DOM("#dactyl-context-" + tail, document).css({ listStyleImage: style.listStyleImage, MozImageRegion: style.MozImageRegion }); }); return document.getElementById("dactyl-contextmenu"); }), multilineOutputReady: false, multilineOutput: Class.Memoize(function () { return this._whenReady("dactyl-multiline-output", elem => { this.multilineOutputReady = true; highlight.highlightNode(elem.contentDocument.body, "MOW"); }); }, true), multilineInput: Class.Memoize(() => document.getElementById("dactyl-multiline-input")), mowContainer: Class.Memoize(() => document.getElementById("dactyl-multiline-output-container")) }, { getEditor: function getEditor(elem) { elem.inputField.QueryInterface(Ci.nsIDOMNSEditableElement); return elem; } }); var CommandMode = Class("CommandMode", { init: function CM_init() { this.keepCommand = userContext.hidden_option_command_afterimage; }, get autocomplete() { return options["autocomplete"].length; }, get command() { return this.widgets.command[1]; }, set command(val) { this.widgets.command = val; }, get prompt() { return this._open ? this.widgets.prompt : this._prompt; }, set prompt(val) { if (this._open) this.widgets.prompt = val; else this._prompt = val; }, open: function CM_open(command) { dactyl.assert(isinstance(this.mode, modes.COMMAND_LINE), /*L*/"Not opening command line in non-command-line mode.", false); this.messageCount = commandline.messageCount; modes.push(this.mode, this.extendedMode, this.bound); this.widgets.active.commandline.collapsed = false; this.widgets.prompt = this.prompt; this.widgets.command = command || ""; this._open = true; this.input = this.widgets.active.command.inputField; if (this.historyKey) this.history = CommandLine.History(this.input, this.historyKey, this); if (this.complete) this.completions = CommandLine.Completions(this.input, this); if (this.completions && command && commandline.commandSession === this) this.completions.autocompleteTimer.flush(true); }, get active() { return this === commandline.commandSession; }, get holdFocus() { return this.widgets.active.command.inputField; }, get mappingSelf() { return this; }, get widgets() { return commandline.widgets; }, enter: function CM_enter(stack) { commandline.commandSession = this; if (stack.pop && commandline.command) { this.onChange(commandline.command); if (this.completions && stack.pop) this.completions.complete(true, false); } }, leave: function CM_leave(stack) { if (!stack.push) { commandline.commandSession = null; this.input.dactylKeyPress = undefined; let waiting = this.accepted && this.completions && this.completions.waiting; if (waiting) this.completions.onComplete = bind("onSubmit", this); if (this.completions) this.completions.cleanup(); if (this.history) this.history.save(); commandline.hideCompletions(); let result = this.command; commandline.saveCommand(); modes.delay(function () { if (!this.keepCommand || commandline.silent || commandline.quiet) commandline.hide(); if (!waiting) this[this.accepted ? "onSubmit" : "onCancel"](result); if (commandline.messageCount === this.messageCount) commandline.clearMessage(); }, this); } }, events: { input: function CM_onInput(event) { if (this.completions) { this.resetCompletions(); this.completions.autocompleteTimer.tell(false); } this.onChange(commandline.command); }, keyup: function CM_onKeyUp(event) { let key = DOM.Event.stringify(event); if (/-?Tab>$/.test(key) && this.completions) this.completions.tabTimer.flush(); } }, keepCommand: false, onKeyPress: function CM_onKeyPress(events) { if (this.completions) this.completions.previewClear(); return true; /* Pass event */ }, onCancel: function (value) {}, onChange: function (value) {}, onHistory: function (value) {}, onSubmit: function (value) {}, resetCompletions: function CM_resetCompletions() { if (this.completions) this.completions.clear(); if (this.history) this.history.reset(); } }); var CommandExMode = Class("CommandExMode", CommandMode, { get mode() { return modes.EX; }, historyKey: "command", prompt: ["Normal", ":"], complete: function CEM_complete(context) { try { context.fork("ex", 0, completion, "ex"); } catch (e) { context.message = _("error.error", e); } }, onSubmit: function CEM_onSubmit(command) { contexts.withContext({ file: /*L*/"[Command Line]", line: 1 }, function _onSubmit() { io.withSavedValues(["readHeredoc"], function _onSubmit() { this.readHeredoc = commandline.readHeredoc; commands.repeat = command; dactyl.execute(command); }); }); } }); var CommandPromptMode = Class("CommandPromptMode", CommandMode, { init: function init(prompt, params) { this.prompt = isArray(prompt) ? prompt : ["Question", prompt]; update(this, params); init.supercall(this); }, complete: function CPM_complete(context, ...args) { if (this.completer) context.forkapply("prompt", 0, this, "completer", args); }, get mode() { return modes.PROMPT; } }); /** * This class is used for prompting of user input and echoing of messages. * * It consists of a prompt and command field be sure to only create objects of * this class when the chrome is ready. */ var CommandLine = Module("commandline", { init: function init() { this._callbacks = {}; memoize(this, "_store", () => storage.newMap("command-history", { store: true, privateData: true })); for (let name of ["command", "search"]) if (storage.exists("history-" + name)) { let ary = storage.newArray("history-" + name, { store: true, privateData: true }); this._store.set(name, Array.from(ary, ([key, val]) => val)); ary.delete(); this._store.changed(); } this._messageHistory = { //{{{ _messages: [], get messages() { let max = options["messages"]; // resize if 'messages' has changed if (this._messages.length > max) this._messages = this._messages.splice(this._messages.length - max); return this._messages; }, get length() { return this._messages.length; }, clear: function clear() { this._messages = []; }, filter: function filter(fn, self) { this._messages = this._messages.filter(fn, self); }, add: function add(message) { if (!message) return; if (this._messages.length >= options["messages"]) this._messages.shift(); this._messages.push(update({ timestamp: Date.now() }, message)); } }; //}}} }, signals: { "browser.locationChange": function (webProgress, request, uri) { this.clear(); } }, /** * Determines whether the command line should be visible. * * @returns {boolean} */ get commandVisible() { return !!this.commandSession; }, /** * Ensure that the multiline input widget is the correct size. */ _autosizeMultilineInputWidget: function _autosizeMultilineInputWidget() { let lines = this.widgets.multilineInput.value.split("\n").length - 1; this.widgets.multilineInput.setAttribute("rows", Math.max(lines, 1)); }, HL_NORMAL: "Normal", HL_ERRORMSG: "ErrorMsg", HL_MODEMSG: "ModeMsg", HL_MOREMSG: "MoreMsg", HL_QUESTION: "Question", HL_INFOMSG: "InfoMsg", HL_WARNINGMSG: "WarningMsg", HL_LINENR: "LineNr", FORCE_MULTILINE : 1 << 0, FORCE_SINGLELINE : 1 << 1, DISALLOW_MULTILINE : 1 << 2, // If an echo() should try to use the single line // but output nothing when the MOW is open; when also // FORCE_MULTILINE is given, FORCE_MULTILINE takes precedence APPEND_TO_MESSAGES : 1 << 3, // Add the string to the message history. ACTIVE_WINDOW : 1 << 4, // Only echo in active window. get completionContext() { return this._completions.context; }, _silent: false, get silent() { return this._silent; }, set silent(val) { this._silent = val; this.quiet = this.quiet; }, _quite: false, get quiet() { return this._quiet; }, set quiet(val) { this._quiet = val; ["commandbar", "statusbar"].forEach(function (nodeSet) { Array.forEach(this.widgets[nodeSet].commandline.children, function (node) { node.style.opacity = this._quiet || this._silent ? "0" : ""; }, this); }, this); }, widgets: Class.Memoize(() => CommandWidgets()), runSilently: function runSilently(func, self) { this.withSavedValues(["silent"], function () { this.silent = true; func.call(self); }); }, get completionList() { let node = this.widgets.active.commandline; if (this.commandSession && this.commandSession.completionList) node = document.getElementById(this.commandSession.completionList); if (!node.completionList) { let elem = document.getElementById("dactyl-completions-" + node.id); util.waitFor(bind(this.widgets._ready, null, elem)); node.completionList = ItemList(elem); node.completionList.isAboveMow = node.id == this.widgets.statusbar.commandline.id; } return node.completionList; }, hideCompletions: function hideCompletions() { for (let nodeSet of [this.widgets.statusbar, this.widgets.commandbar]) if (nodeSet.commandline.completionList) nodeSet.commandline.completionList.visible = false; }, _lastClearable: Modes.boundProperty(), messages: Modes.boundProperty(), multilineInputVisible: Modes.boundProperty({ set: function set_miwVisible(value) { this.widgets.multilineInput.collapsed = !value; } }), saveCommand: function saveCommand() { if (this.commandVisible && this.widgets.command) commands.lastCommand = this.widgets.command[1]; }, get command() { this.saveCommand(); return commands.lastCommand; }, set command(val) { if (this.commandVisible && (modes.extended & modes.EX)) return this.widgets.command = val; return commands.lastCommand = val; }, clear: function clear(scroll) { if (!scroll || Date.now() - this._lastEchoTime > 5000) this.clearMessage(); this._lastEchoTime = 0; this.hiddenMessages = 0; if (!this.commandSession) { this.widgets.command = null; this.hideCompletions(); } if (modes.main == modes.OUTPUT_MULTILINE && !mow.isScrollable(1)) modes.pop(); if (!modes.have(modes.OUTPUT_MULTILINE)) mow.visible = false; }, clearMessage: function clearMessage() { if (this.widgets.message && this.widgets.message[1] === this._lastClearable) { this.widgets.message = null; this.hiddenMessages = 0; } }, /** * Displays the multi-line output of a command, preceded by the last * executed ex command string. * * @param {object} xml The output as a JSON XML object. */ commandOutput: function commandOutput(xml) { if (!this.command) this.echo(xml, this.HIGHLIGHT_NORMAL, this.FORCE_MULTILINE); else this.echo([["div", { xmlns: "html" }, ":" + this.command], "\n", xml], this.HIGHLIGHT_NORMAL, this.FORCE_MULTILINE); this.command = null; }, /** * Hides the command line, and shows any status messages that * are under it. */ hide: function hide() { this.widgets.command = null; }, /** * Display a message in the command-line area. * * @param {string} str * @param {string} highlightGroup * @param {boolean} forceSingle If provided, don't let over-long * messages move to the MOW. */ _echoLine: function echoLine(str, highlightGroup, forceSingle) { this.widgets.message = str ? [highlightGroup, str, forceSingle] : null; dactyl.triggerObserver("echoLine", str, highlightGroup, null, forceSingle); if (!this.commandVisible) this.hide(); let field = this.widgets.active.message.inputField; if (field.value && !forceSingle && field.editor.rootElement.scrollWidth > field.scrollWidth) { this.widgets.message = null; mow.echo(["span", { highlight: "Message" }, str], highlightGroup, true); } }, _hiddenMessages: 0, get hiddenMessages() { return this._hiddenMessages; }, set hiddenMessages(val) { this._hiddenMessages = val; if (val) this.widgets["message-pre"] = _("commandline.moreMessages", val) + " "; else this.widgets["message-pre"] = null; }, _lastEcho: null, /** * Output the given string onto the command line. With no flags, the * message will be shown in the status line if it's short enough to * fit, and contains no new lines, and isn't XML. Otherwise, it will be * shown in the MOW. * * @param {string} str * @param {string} highlightGroup The Highlight group for the * message. * @default "Normal" * @param {number} flags Changes the behavior as follows: * commandline.APPEND_TO_MESSAGES - Causes message to be added to the * messages history, and shown by :messages. * commandline.FORCE_SINGLELINE - Forbids the command from being * pushed to the MOW if it's too long or of there are already * status messages being shown. * commandline.DISALLOW_MULTILINE - Cancels the operation if the MOW * is already visible. * commandline.FORCE_MULTILINE - Forces the message to appear in * the MOW. */ messageCount: 0, echo: function echo(data, highlightGroup, flags) { // dactyl.echo uses different order of flags as it omits the highlight group, change commandline.echo argument order? --mst if (this._silent || !this.widgets) return; this.messageCount++; highlightGroup = highlightGroup || this.HL_NORMAL; let appendToMessages = data => { let message = isObject(data) && !DOM.isJSONXML(data) ? data : { message: data }; // Make sure the memoized message property is an instance property. message.message; this._messageHistory.add(update({ highlight: highlightGroup }, message)); return message.message; }; if (flags & this.APPEND_TO_MESSAGES) data = appendToMessages(data); if ((flags & this.ACTIVE_WINDOW) && window != overlay.activeWindow) return; if ((flags & this.DISALLOW_MULTILINE) && !this.widgets.mowContainer.collapsed) return; let forceSingle = flags & (this.FORCE_SINGLELINE | this.DISALLOW_MULTILINE); let action = this._echoLine; if ((flags & this.FORCE_MULTILINE) || (/\n/.test(data) || !isinstance(data, [_, "String"])) && !(flags & this.FORCE_SINGLELINE)) action = mow.bound.echo; let checkSingleLine = () => action == this._echoLine; if (forceSingle) { this._lastEcho = null; this.hiddenMessages = 0; } else { // So complicated... if (checkSingleLine() && !this.widgets.mowContainer.collapsed) { highlightGroup += " Message"; action = mow.bound.echo; } else if (!checkSingleLine() && this.widgets.mowContainer.collapsed) { if (this._lastEcho && this.widgets.message && this.widgets.message[1] == this._lastEcho.msg) { if (!(this._lastEcho.flags & this.APPEND_TO_MESSAGES)) appendToMessages(this._lastEcho.data); mow.echo( ["span", { highlight: "Message" }, ["span", { highlight: "WarningMsg" }, _("commandline.moreMessages", this.hiddenMessages + 1) + " "], this._lastEcho.msg], this.widgets.message[0], true); this.hiddenMessages = 0; } } else if (this._lastEcho && this.widgets.message && this.widgets.message[1] == this._lastEcho.msg) { if (!(this._lastEcho.flags & this.APPEND_TO_MESSAGES)) appendToMessages(this._lastEcho.data); if (checkSingleLine() && !(flags & this.APPEND_TO_MESSAGES)) appendToMessages(data); flags |= this.APPEND_TO_MESSAGES; this.hiddenMessages++; } this._lastEcho = checkSingleLine() && { flags: flags, msg: data, data: arguments[0] }; } this._lastClearable = action === this._echoLine && String(data); this._lastEchoTime = (flags & this.FORCE_SINGLELINE) && Date.now(); if (action) action.call(this, data, highlightGroup, checkSingleLine()); }, _lastEchoTime: 0, /** * Prompt the user. Sets modes.main to COMMAND_LINE, which the user may * pop at any time to close the prompt. * * @param {string} prompt The input prompt to use. * @param {Object} extra * @... {function} onChange - A function to be called with the current * input every time it changes. * @... {function(CompletionContext)} completer - A completion function * for the user's input. * @... {string} promptHighlight - The HighlightGroup used for the * prompt. @default "Question" * @... {string} default - The initial value that will be returned * if the user presses <CR> straightaway. @default "" */ input: function _input(prompt, extra={}, thing={}) { return new Promise((resolve, reject) => { if (callable(extra)) // Deprecated. [resolve, extra] = [extra, thing]; CommandPromptMode(prompt, update({ onSubmit: resolve, onCancel: reject }, extra)).open(); }); }, readHeredoc: function readHeredoc(end) { return util.waitFor(commandline.inputMultiline(end)); }, /** * Get a multi-line input from a user, up to but not including the line * which matches the given regular expression. Then execute the * callback with that string as a parameter. * * @param {string} end * @returns {Promise<string>} */ // FIXME: Buggy, especially when pasting. inputMultiline: function inputMultiline(end) { return new Promise((resolve, reject) => { let cmd = this.command; let self = { end: "\n" + end + "\n", callback: resolve }; modes.push(modes.INPUT_MULTILINE, null, { holdFocus: true, leave: function leave() { if (!self.done) self.callback(null); }, mappingSelf: self }); if (cmd != false) this._echoLine(cmd, this.HL_NORMAL); // save the arguments, they are needed in the event handler onKeyPress this.multilineInputVisible = true; this.widgets.multilineInput.value = ""; this._autosizeMultilineInputWidget(); this.timeout(function () { dactyl.focus(this.widgets.multilineInput); }, 10); }); }, get commandMode() { return this.commandSession && isinstance(modes.main, modes.COMMAND_LINE); }, events: update( iter(CommandMode.prototype.events).map( ([event, handler]) => [ event, function (event) { if (this.commandMode) handler.call(this.commandSession, event); } ]).toObject(), { focus: function onFocus(event) { if (!this.commandSession && event.originalTarget === this.widgets.active.command.inputField) { event.target.blur(); dactyl.beep(); } } } ), get mowEvents() { return mow.events; }, /** * Multiline input events, they will come straight from * #dactyl-multiline-input in the XUL. * * @param {Event} event */ multilineInputEvents: { blur: function onBlur(event) { if (modes.main == modes.INPUT_MULTILINE) this.timeout(function () { dactyl.focus(this.widgets.multilineInput.inputField); }); }, input: function onInput(event) { this._autosizeMultilineInputWidget(); } }, updateOutputHeight: deprecated("mow.resize", function updateOutputHeight(open, extra) { return mow.resize(open, extra); }), withOutputToString: function withOutputToString(fn, self, ...args) { dactyl.registerObserver("echoLine", observe, true); dactyl.registerObserver("echoMultiline", observe, true); let output = []; function observe(str, highlight, dom) { output.push(dom && !isString(str) ? dom : str); } this.savingOutput = true; apply(dactyl, "trapErrors", [fn, self].concat(args)); this.savingOutput = false; return output.map(elem => elem instanceof Ci.nsIDOMNode ? DOM.stringify(elem) : elem) .join("\n"); } }, { /** * A class for managing the history of an input field. * * @param {HTMLInputElement} inputField * @param {string} mode The mode for which we need history. */ History: Class("History", { init: function init(inputField, mode, session) { this.mode = mode; this.input = inputField; this.reset(); this.session = session; }, get store() { return commandline._store.get(this.mode, []); }, set store(ary) { commandline._store.set(this.mode, ary); }, /** * Reset the history index to the first entry. */ reset: function reset() { this.index = null; }, /** * Save the last entry to the permanent store. All duplicate entries * are removed and the list is truncated, if necessary. */ save: function save() { if (events.feedingKeys) return; let str = this.input.value; if (/^\s*$/.test(str)) return; let privateData = this.checkPrivate(str); if (privateData == "never-save") return; let store = Array.filter(this.store, line => (line.value || line) != str); dactyl.trapErrors( () => store.push({ value: str, timestamp: Date.now() * 1000, privateData: privateData })); this.store = store.slice(Math.max(0, store.length - options["history"])); }, /** * @property {function} Returns whether a data item should be * considered private. */ checkPrivate: function checkPrivate(str) { // Not really the ideal place for this check. if (this.mode == "command") return commands.hasPrivateData(str); return false; }, /** * Replace the current input field value. * * @param {string} val The new value. */ replace: function replace(val) { editor.withSavedValues(["skipSave"], function () { editor.skipSave = true; this.input.dactylKeyPress = undefined; if (this.completions) this.completions.previewClear(); this.input.value = val; this.session.onHistory(val); }, this); }, /** * Move forward or backward in history. * * @param {boolean} backward Direction to move. * @param {boolean} matchCurrent Search for matches starting * with the current input value. */ select: function select(backward, matchCurrent) { // always reset the tab completion if we use up/down keys if (this.session.completions) this.session.completions.reset(); let diff = backward ? -1 : 1; if (this.index == null) { this.original = this.input.value; this.index = this.store.length; } // search the history for the first item matching the current // command-line string while (true) { this.index += diff; if (this.index < 0 || this.index > this.store.length) { this.index = Math.constrain(this.index, 0, this.store.length); dactyl.beep(); // I don't know why this kludge is needed. It // prevents the caret from moving to the end of // the input field. if (this.input.value == "") { this.input.value = " "; this.input.value = ""; } break; } let hist = this.store[this.index]; // user pressed DOWN when there is no newer history item if (!hist) hist = this.original; else hist = (hist.value || hist); if (!matchCurrent || hist.substr(0, this.original.length) == this.original) { this.replace(hist); break; } } } }), /** * A class for tab completions on an input field. * * @param {Object} input */ Completions: Class("Completions", { UP: {}, DOWN: {}, CTXT_UP: {}, CTXT_DOWN: {}, PAGE_UP: {}, PAGE_DOWN: {}, RESET: null, init: function init(input, session) { let self = this; this.context = CompletionContext(input.QueryInterface(Ci.nsIDOMNSEditableElement).editor); this.context.onUpdate = function onUpdate() { self.asyncUpdate(this); }; this.editor = input.editor; this.input = input; this.session = session; this.wildmode = options.get("wildmode"); this.wildtypes = this.wildmode.value; this.itemList = commandline.completionList; this.itemList.open(this.context); dactyl.registerObserver("events.doneFeeding", this.bound.onDoneFeeding, true); this.autocompleteTimer = Timer(200, 500, function autocompleteTell(tabPressed) { if (events.feedingKeys && !tabPressed) this.ignoredCount++; else if (this.session.autocomplete) { this.itemList.visible = true; this.complete(true, false); } }, this); this.tabTimer = Timer(0, 0, function tabTell(event) { let tabCount = this.tabCount; this.tabCount = 0; this.tab(tabCount, event.altKey && options["altwildmode"]); }, this); }, tabCount: 0, ignoredCount: 0, /** * @private */ onDoneFeeding: function onDoneFeeding() { if (this.ignoredCount) this.autocompleteTimer.flush(true); this.ignoredCount = 0; }, /** * @private */ onTab: function onTab(event) { this.tabCount += event.shiftKey ? -1 : 1; this.tabTimer.tell(event); }, get activeContexts() { return this.context.contextList .filter(c => c.items.length || c.incomplete); }, /** * Returns the current completion string relative to the * offset of the currently selected context. */ get completion() { let offset = this.selected ? this.selected[0].offset : this.start; return commandline.command.slice(offset, this.caret); }, /** * Updates the input field from *offset* to {@link #caret} * with the value *value*. Afterward, the caret is moved * just after the end of the updated text. * * @param {number} offset The offset in the original input * string at which to insert *value*. * @param {string} value The value to insert. */ setCompletion: function setCompletion(offset, value) { editor.withSavedValues(["skipSave"], function () { editor.skipSave = true; this.previewClear(); if (value == null) var [input, caret] = [this.originalValue, this.originalCaret]; else { input = this.getCompletion(offset, value); caret = offset + value.length; } // Change the completion text. // The second line is a hack to deal with some substring // preview corner cases. commandline.widgets.active.command.value = input; this.editor.selection.focusNode.textContent = input; this.caret = caret; this._caret = this.caret; this.input.dactylKeyPress = undefined; }, this); }, /** * For a given offset and completion string, returns the * full input value after selecting that item. * * @param {number} offset The offset at which to insert the * completion. * @param {string} value The value to insert. * @returns {string}; */ getCompletion: function getCompletion(offset, value) { return this.originalValue.substr(0, offset) + value + this.originalValue.substr(this.originalCaret); }, get selected() { return this.itemList.selected; }, set selected(tuple) { if (!Ary.equals(tuple || [], this.itemList.selected || [])) this.itemList.select(tuple); if (!tuple) this.setCompletion(null); else { let [ctxt, idx] = tuple; this.setCompletion(ctxt.offset, ctxt.items[idx].result); } }, get caret() { return this.editor.selection.getRangeAt(0).startOffset; }, set caret(offset) { this.editor.selection.collapse(this.editor.rootElement.firstChild, offset); }, get start() { return this.context.allItems.start; }, get items() { return this.context.allItems.items; }, get substring() { return this.context.longestAllSubstring; }, get wildtype() { return this.wildtypes[this.wildIndex] || ""; }, /** * Cleanup resources used by this completion session. This * instance should not be used again once this method is * called. */ cleanup: function cleanup() { dactyl.unregisterObserver("events.doneFeeding", this.bound.onDoneFeeding); this.previewClear(); this.tabTimer.reset(); this.autocompleteTimer.reset(); if (!this.onComplete) this.context.cancelAll(); this.itemList.visible = false; this.input.dactylKeyPress = undefined; this.hasQuit = true; }, /** * Run the completer. * * @param {boolean} show Passed to {@link #reset}. * @param {boolean} tabPressed Should be set to true if, and * only if, this function is being called in response * to a <Tab> press. */ complete: function complete(show, tabPressed) { this.session.ignoredCount = 0; this.waiting = null; this.context.reset(); this.context.tabPressed = tabPressed; this.session.complete(this.context); if (!this.session.active) return; this.reset(show, tabPressed); this.wildIndex = 0; this._caret = this.caret; }, /** * Clear any preview string and cancel any pending * asynchronous context. Called when there is further input * to be processed. */ clear: function clear() { this.context.cancelAll(); this.wildIndex = -1; this.previewClear(); }, /** * Saves the current input state. To be called before an * item is selected in a new set of completion responses. * @private */ saveInput: function saveInput() { this.originalValue = this.context.value; this.originalCaret = this.caret; }, /** * Resets the completion state. * * @param {boolean} show If true and options allow the * completion list to be shown, show it. */ reset: function reset(show) { this.waiting = null; this.wildIndex = -1; this.saveInput(); if (show) { this.itemList.update(); this.context.updateAsync = true; if (this.haveType("list")) this.itemList.visible = true; this.wildIndex = 0; } this.preview(); }, /** * Calls when an asynchronous completion context has new * results to return. * * @param {CompletionContext} context The changed context. * @private */ asyncUpdate: function asyncUpdate(context) { if (this.hasQuit) { let item = this.getItem(this.waiting); if (item && this.waiting && this.onComplete) { util.trapErrors("onComplete", this, this.getCompletion(this.waiting[0].offset, item.result)); this.waiting = null; this.context.cancelAll(); } return; } this.saveInput(); if (this.itemList.visible) this.itemList.updateContext(context); if (this.waiting && this.waiting[0] == context) this.select(this.waiting); else if (!this.waiting) { let cursor = this.selected; if (cursor && cursor[0] == context) { let item = this.getItem(cursor); if (!item || this.completion != item.result) this.itemList.select(null); } this.preview(); } }, /** * Returns true if the currently selected 'wildmode' index * has the given completion type. */ haveType: function haveType(type) { return this.wildmode.checkHas(this.wildtype, type == "first" ? "" : type); }, /** * Returns the completion item for the given selection * tuple. * * @param {[CompletionContext,number]} tuple The spec of the * item to return. * @default {@link #selected} * @returns {object} */ getItem: function getItem(tuple=this.selected) { return tuple && tuple[0] && tuple[0].items[tuple[1]]; }, /** * Returns a tuple representing the next item, at the given * *offset*, from *tuple*. * * @param {[CompletionContext,number]} tuple The offset from * which to search. * @default {@link #selected} * @param {number} offset The positive or negative offset to * find. * @default 1 * @param {boolean} noWrap If true, and the search would * wrap, return null. */ nextItem: function nextItem(tuple, offset, noWrap) { if (tuple === undefined) tuple = this.selected; return this.itemList.getRelativeItem(offset || 1, tuple, noWrap); }, /** * The last previewed substring. * @private */ lastSubstring: "", /** * Displays a preview of the text provided by the next <Tab> * press if the current input is an anchored substring of * that result. */ preview: function preview() { this.previewClear(); if (this.wildIndex < 0 || this.caret < this.input.value.length || !this.activeContexts.length || this.waiting) return; let substring = ""; switch (this.wildtype.replace(/.*:/, "")) { case "": var cursor = this.nextItem(null); break; case "longest": if (this.items.length > 1) { substring = this.substring; break; } // Fallthrough case "full": cursor = this.nextItem(); break; } if (cursor) substring = this.getItem(cursor).result; // Don't show 1-character substrings unless we've just hit backspace if (substring.length < 2 && this.lastSubstring.indexOf(substring)) return; this.lastSubstring = substring; let value = this.completion; if (util.compareIgnoreCase(value, substring.substr(0, value.length))) return; substring = substring.substr(value.length); this.removeSubstring = substring; let node = DOM.fromJSON(["span", { highlight: "Preview" }, substring], document); this.withSavedValues(["caret"], function () { this.editor.insertNode(node, this.editor.rootElement, 1); }); }, /** * Clears the currently displayed next-<Tab> preview string. */ previewClear: function previewClear() { let node = this.editor.rootElement.firstChild; if (node && node.nextSibling) { try { DOM(node.nextSibling).remove(); } catch (e) { node.nextSibling.textContent = ""; } } else if (this.removeSubstring) { let str = this.removeSubstring; let cmd = commandline.widgets.active.command.value; if (cmd.substr(cmd.length - str.length) == str) commandline.widgets.active.command.value = cmd.substr(0, cmd.length - str.length); } let e = this.editor.selection.focusNode; if (e != this.editor.rootElement && e.parentNode != this.editor.rootElement) this.editor.selection.getRangeAt(0).selectNodeContents(this.editor.rootElement); delete this.removeSubstring; }, /** * Selects a completion based on the value of *idx*. * * @param {[CompletionContext,number]|const object} The * (context,index) tuple of the item to select, or an * offset constant from this object. * @param {number} count When given an offset constant, * select *count* units. * @default 1 * @param {boolean} fromTab If true, this function was * called by {@link #tab}. * @default false * @private */ select: function select(idx, count=1, fromTab=false) { switch (idx) { case this.UP: case this.DOWN: idx = this.nextItem(this.waiting || this.selected, idx == this.UP ? -count : count, true); break; case this.CTXT_UP: case this.CTXT_DOWN: let groups = this.itemList.activeGroups; let i = Math.max(0, groups.indexOf(this.itemList.selectedGroup)); i += idx == this.CTXT_DOWN ? 1 : -1; i %= groups.length; if (i < 0) i += groups.length; var position = 0; idx = [groups[i].context, 0]; break; case this.PAGE_UP: case this.PAGE_DOWN: idx = this.itemList.getRelativePage(idx == this.PAGE_DOWN ? 1 : -1); break; case this.RESET: idx = null; break; default: break; } if (!fromTab) this.wildIndex = this.wildtypes.length - 1; if (idx && idx[1] >= idx[0].items.length) { if (!idx[0].incomplete) this.waiting = null; else { this.waiting = idx; statusline.progress = _("completion.waitingForResults"); } return; } this.waiting = null; this.itemList.select(idx, null, position); this.selected = idx; this.preview(); if (this.selected == null) statusline.progress = ""; else statusline.progress = _("completion.matchIndex", this.itemList.getOffset(idx), this.itemList.itemCount); }, /** * Selects a completion result based on the 'wildmode' * option, or the value of the *wildmode* parameter. * * @param {number} offset The positive or negative number of * tab presses to process. * @param {[string]} wildmode A 'wildmode' value to * substitute for the value of the 'wildmode' option. * @optional */ tab: function tab(offset, wildmode) { this.autocompleteTimer.flush(); this.ignoredCount = 0; if (this._caret != this.caret) this.reset(); this._caret = this.caret; // Check if we need to run the completer. if (this.context.waitingForTab || this.wildIndex == -1) this.complete(true, true); this.wildtypes = wildmode || options["wildmode"]; let count = Math.abs(offset); let steps = Math.constrain(this.wildtypes.length - this.wildIndex, 1, count); count = Math.max(1, count - steps); while (steps--) { this.wildIndex = Math.min(this.wildIndex, this.wildtypes.length - 1); switch (this.wildtype.replace(/.*:/, "")) { case "": this.select(this.nextItem(null)); break; case "longest": if (this.itemList.itemCount > 1) { if (this.substring && this.substring.length > this.completion.length) this.setCompletion(this.start, this.substring); break; } // Fallthrough case "full": let c = steps ? 1 : count; this.select(offset < 0 ? this.UP : this.DOWN, c, true); break; } if (this.haveType("list")) this.itemList.visible = true; this.wildIndex++; } if (this.items.length == 0 && !this.waiting) dactyl.beep(); } }), /** * Evaluate a JavaScript expression and return a string suitable * to be echoed. * * @param {string} arg * @param {boolean} useColor When true, the result is a * highlighted XML object. */ echoArgumentToString: function (arg, useColor) { if (!arg) return ""; arg = dactyl.userEval(arg); if (isObject(arg)) arg = util.objectToString(arg, useColor); else if (callable(arg)) arg = String.replace(arg, "/* use strict */ \n", "/* use strict */ "); else if (!isString(arg) && useColor) arg = template.highlight(arg); return arg; } }, { commands: function initCommands() { [ { name: "ec[ho]", description: "Echo the expression", action: dactyl.echo }, { name: "echoe[rr]", description: "Echo the expression as an error message", action: dactyl.echoerr }, { name: "echom[sg]", description: "Echo the expression as an informational message", action: dactyl.echomsg } ].forEach(function (command) { commands.add([command.name], command.description, function (args) { command.action(CommandLine.echoArgumentToString(args[0] || "", true)); }, { completer: function (context) { completion.javascript(context); }, literal: 0 }); }); commands.add(["mes[sages]"], "Display previously shown messages", function () { // TODO: are all messages single line? Some display an aggregation // of single line messages at least. E.g. :source if (commandline._messageHistory.length == 1) { let message = commandline._messageHistory.messages[0]; commandline.echo(message.message, message.highlight, commandline.FORCE_SINGLELINE); } else if (commandline._messageHistory.length > 1) { commandline.commandOutput( template.map(commandline._messageHistory.messages, message => ["div", { highlight: message.highlight + " Message" }, message.message])); } }, { argCount: "0" }); commands.add(["messc[lear]"], "Clear the message history", function () { commandline._messageHistory.clear(); }, { argCount: "0" }); commands.add(["sil[ent]"], "Run a command silently", function (args) { commandline.runSilently(() => { commands.execute(args[0] || "", null, true); }); }, { completer: function (context) { completion.ex(context); }, literal: 0, subCommand: 0 }); }, modes: function initModes() { initModes.require("editor"); modes.addMode("COMMAND_LINE", { char: "c", description: "Active when the command line is focused", insert: true, ownsFocus: true, get mappingSelf() { return commandline.commandSession; } }); // this._extended modes, can include multiple modes, and even main modes modes.addMode("EX", { description: "Ex command mode, active when the command line is open for Ex commands", bases: [modes.COMMAND_LINE] }); modes.addMode("PROMPT", { description: "Active when a prompt is open in the command line", bases: [modes.COMMAND_LINE] }); modes.addMode("INPUT_MULTILINE", { description: "Active when the command line's multiline input buffer is open", bases: [modes.INSERT] }); }, mappings: function initMappings() { mappings.add([modes.COMMAND], [":"], "Enter Command Line mode", function () { CommandExMode().open(""); }); mappings.add([modes.INPUT_MULTILINE], ["<Return>", "<C-j>", "<C-m>"], "Begin a new line", function ({ self }) { let text = "\n" + commandline.widgets.multilineInput .value.substr(0, commandline.widgets.multilineInput.selectionStart) + "\n"; let index = text.indexOf(self.end); if (index >= 0) { self.done = true; text = text.substring(1, index); modes.pop(); return () => self.callback.call(commandline, text); } return Events.PASS; }); let bind = function bind(...args) { apply(mappings, "add", [[modes.COMMAND_LINE]].concat(args)); }; bind(["<Esc>", "<C-[>"], "Stop waiting for completions or exit Command Line mode", function ({ self }) { if (self.completions && self.completions.waiting) self.completions.waiting = null; else return Events.PASS; }); // Any "non-keyword" character triggers abbreviation expansion // TODO: Add "<CR>" and "<Tab>" to this list // At the moment, adding "<Tab>" breaks tab completion. Adding // "<CR>" has no effect. // TODO: Make non-keyword recognition smarter so that there need not // be two lists of the same characters (one here and a regexp in // mappings.js) bind(["<Space>", '"', "'"], "Expand command line abbreviation", function ({ self }) { self.resetCompletions(); editor.expandAbbreviation(modes.COMMAND_LINE); return Events.PASS; }); bind(["<Return>", "<C-j>", "<C-m>"], "Accept the current input", function ({ self }) { if (self.completions) self.completions.tabTimer.flush(); self.accepted = true; return () => { modes.pop(); }; }); [ [["<Up>", "<A-p>", "<cmd-prev-match>"], "previous matching", true, true], [["<S-Up>", "<C-p>", "<cmd-prev>"], "previous", true, false], [["<Down>", "<A-n>", "<cmd-next-match>"], "next matching", false, true], [["<S-Down>", "<C-n>", "<cmd-next>"], "next", false, false] ].forEach(function ([keys, desc, up, search]) { bind(keys, "Recall the " + desc + " command line from the history list", function ({ self }) { dactyl.assert(self.history); self.history.select(up, search); }); }); bind(["<A-Tab>", "<Tab>", "<A-compl-next>", "<compl-next>"], "Select the next matching completion item", function ({ keypressEvents, self }) { dactyl.assert(self.completions); self.completions.onTab(keypressEvents[0]); }); bind(["<A-S-Tab>", "<S-Tab>", "<A-compl-prev>", "<compl-prev>"], "Select the previous matching completion item", function ({ keypressEvents, self }) { dactyl.assert(self.completions); self.completions.onTab(keypressEvents[0]); }); bind(["<C-Tab>", "<A-f>", "<compl-next-group>"], "Select the next matching completion group", function ({ keypressEvents, self }) { dactyl.assert(self.completions); self.completions.tabTimer.flush(); self.completions.select(self.completions.CTXT_DOWN); }); bind(["<C-S-Tab>", "<A-S-f>", "<compl-prev-group>"], "Select the previous matching completion group", function ({ keypressEvents, self }) { dactyl.assert(self.completions); self.completions.tabTimer.flush(); self.completions.select(self.completions.CTXT_UP); }); bind(["<C-f>", "<PageDown>", "<compl-next-page>"], "Select the next page of completions", function ({ keypressEvents, self }) { dactyl.assert(self.completions); self.completions.tabTimer.flush(); self.completions.select(self.completions.PAGE_DOWN); }); bind(["<C-b>", "<PageUp>", "<compl-prev-page>"], "Select the previous page of completions", function ({ keypressEvents, self }) { dactyl.assert(self.completions); self.completions.tabTimer.flush(); self.completions.select(self.completions.PAGE_UP); }); bind(["<BS>", "<C-h>"], "Delete the previous character", function () { if (!commandline.command) modes.pop(); else return Events.PASS; }); bind(["<C-]>", "<C-5>"], "Expand command line abbreviation", function () { editor.expandAbbreviation(modes.COMMAND_LINE); }); }, options: function initOptions() { options.add(["history", "hi"], "Number of Ex commands and search patterns to store in the command-line history", "number", 500, { validator: function (value) { return value >= 0; } }); options.add(["maxitems"], "Maximum number of completion items to display at once", "number", 20, { validator: function (value) { return value >= 1; } }); options.add(["messages", "msgs"], "Number of messages to store in the :messages history", "number", 100, { validator: function (value) { return value >= 0; } }); }, sanitizer: function initSanitizer() { sanitizer.addItem("commandline", { description: "Command-line and search history", persistent: true, action: function (timespan, host) { let store = commandline._store; for (let [k, v] of store) { if (k == "command") store.set(k, v.filter(item => !(timespan.contains(item.timestamp) && (!host || commands.hasDomain(item.value, host))))); else if (!host) store.set(k, v.filter(item => !timespan.contains(item.timestamp))); } } }); // Delete history-like items from the commandline and messages on history purge sanitizer.addItem("history", { action: function (timespan, host) { commandline._store.set("command", commandline._store.get("command", []).filter(item => !(timespan.contains(item.timestamp) && (host ? commands.hasDomain(item.value, host) : item.privateData)))); commandline._messageHistory.filter(item => ( !timespan.contains(item.timestamp * 1000) || !item.domains && !item.privateData || host && ( !item.domains || !item.domains.some(d => util.isSubdomain(d, host))))); } }); sanitizer.addItem("messages", { description: "Saved :messages", action: function (timespan, host) { commandline._messageHistory.filter(item => ( !timespan.contains(item.timestamp * 1000) || host && ( !item.domains || !item.domains.some(d => util.isSubdomain(d, host))))); } }); } }); /** * The list which is used for the completion box. * * @param {string} id The id of the iframe which will display the list. It * must be in its own container element, whose height it will update as * necessary. */ var ItemList = Class("ItemList", { CONTEXT_LINES: 2, init: function init(frame) { this.frame = frame; this.doc = frame.contentDocument; this.win = frame.contentWindow; this.body = this.doc.body; this.container = frame.parentNode; highlight.highlightNode(this.doc.body, "Comp"); this._onResize = Timer(20, 400, function _onResize(event) { if (this.visible) this.onResize(event); }, this); this._resize = Timer(20, 400, function _resize(flags) { if (this.visible) this.resize(flags); }, this); DOM(this.win).resize(this._onResize.bound.tell); }, get rootXML() { return ["div", { highlight: "Normal", style: "white-space: nowrap", key: "root" }, ["div", { key: "wrapper" }, ["div", { highlight: "Completions", key: "noCompletions" }, ["span", { highlight: "Title" }, _("completion.noCompletions")]], ["div", { key: "completions" }]], ["div", { highlight: "Completions" }, template.map(util.range(0, options["maxitems"] * 2), i => ["div", { highlight: "CompItem NonText" }, "~"])]]; }, get itemCount() { return this.context.contextList .reduce((acc, ctxt) => acc + ctxt.items.length, 0); }, get visible() { return !this.container.collapsed; }, set visible(val) { this.container.collapsed = !val; }, get activeGroups() { return this.context.contextList .filter(c => c.items.length || c.message || c.incomplete) .map(this.getGroup, this); }, get selected() { let g = this.selectedGroup; return g && g.selectedIdx != null ? [g.context, g.selectedIdx] : null; }, getRelativeItem: function getRelativeItem(offset, tuple, noWrap) { let groups = this.activeGroups; if (!groups.length) return null; let group = this.selectedGroup || groups[0]; let start = group.selectedIdx || 0; if (tuple === null) { // Kludge. if (offset > 0) tuple = [this.activeGroups[0], -1]; else { let group = this.activeGroups.slice(-1)[0]; tuple = [group, group.itemCount]; } } if (tuple) [group, start] = tuple; group = this.getGroup(group); start = (group.offsets.start + start + offset); if (!noWrap) start %= this.itemCount || 1; if (start < 0 && (!noWrap || arguments[1] === null)) start += this.itemCount; if (noWrap && offset > 0) { // Check if we've passed any incomplete contexts let i = groups.indexOf(group); util.assert(i >= 0, undefined, false); for (; i < groups.length; i++) { let end = groups[i].offsets.start + groups[i].itemCount; if (start >= end && groups[i].context.incomplete) return [groups[i].context, start - groups[i].offsets.start]; if (start >= end); break; } } if (start < 0 || start >= this.itemCount) return null; group = groups.find(g => { let i = start - g.offsets.start; return i >= 0 && i < g.itemCount; }); return [group.context, start - group.offsets.start]; }, getRelativePage: function getRelativePage(offset, tuple, noWrap) { offset *= this.maxItems; // Try once with wrapping disabled. let res = this.getRelativeItem(offset, tuple, true); if (!res) { // Wrapped. let sign = offset / Math.abs(offset); let off = this.getOffset(tuple === null ? null : tuple || this.selected); if (off == null) // Unselected. Defer to getRelativeItem. res = this.getRelativeItem(offset, null, noWrap); else if (~[0, this.itemCount - 1].indexOf(off)) // At start or end. Jump to other end. res = this.getRelativeItem(sign, null, noWrap); else // Wrapped. Go to beginning or end. res = this.getRelativeItem(-sign, null); } return res; }, /** * Initializes the ItemList for use with a new root completion * context. * * @param {CompletionContext} context The new root context. */ open: function open(context) { this.context = context; this.nodes = {}; this.container.height = 0; this.minHeight = 0; this.maxItems = options["maxitems"]; DOM(this.rootXML, this.doc, this.nodes) .appendTo(DOM(this.body).empty()); this.update(); }, /** * Updates the absolute result indices of all groups after * results have changed. * @private */ updateOffsets: function updateOffsets() { let total = this.itemCount; let count = 0; for (let group of this.activeGroups) { group.offsets = { start: count, end: total - count - group.itemCount }; count += group.itemCount; } }, /** * Updates the set and state of active groups for a new set of * completion results. */ update: function update() { DOM(this.nodes.completions).empty(); let container = DOM(this.nodes.completions); let groups = this.activeGroups; for (let group of groups) { group.reset(); container.append(group.nodes.root); } this.updateOffsets(); DOM(this.nodes.noCompletions).toggle(!groups.length); this.startPos = null; this.select(groups[0] && groups[0].context, null); this._resize.tell(); }, /** * Updates the group for *context* after an asynchronous update * push. * * @param {CompletionContext} context The context which has * changed. */ updateContext: function updateContext(context) { let group = this.getGroup(context); this.updateOffsets(); if (~this.activeGroups.indexOf(group)) group.update(); else { DOM(group.nodes.root).remove(); if (this.selectedGroup == group) this.selectedGroup = null; } let g = this.selectedGroup; this.select(g, g && g.selectedIdx); }, /** * Updates the DOM to reflect the current state of all groups. * @private */ draw: function draw() { for (let group of this.activeGroups) group.draw(); // We need to collect all of the rescrolling functions in // one go, as the height calculation that they need to do // would force an expensive reflow after each call due to // DOM modifications, otherwise. this.activeGroups.filter(g => !g.collapsed) .map(g => g.rescrollFunc) .forEach(call); if (!this.selected) this.win.scrollTo(0, 0); this._resize.tell(ItemList.RESIZE_BRIEF); }, onResize: function onResize() { if (this.selectedGroup) this.selectedGroup.rescrollFunc(); }, minHeight: 0, /** * Resizes the list after an update. * @private */ resize: function resize(flags) { let { completions, root } = this.nodes; if (!this.visible) root.style.minWidth = document.getElementById("dactyl-commandline").scrollWidth + "px"; let { minHeight } = this; if (mow.visible && this.isAboveMow) // Kludge. minHeight -= mow.wantedHeight; let needed = this.win.scrollY + DOM(completions).rect.bottom; this.minHeight = Math.max(minHeight, needed); if (!this.visible) root.style.minWidth = ""; let height = this.visible ? parseFloat(this.container.height) : 0; if (this.minHeight <= minHeight || !mow.visible) this.container.height = Math.min(this.minHeight, height + config.outputHeight - mow.spaceNeeded); else { // FIXME: Belongs elsewhere. mow.resize(false, Math.max(0, this.minHeight - this.container.height)); this.container.height = this.minHeight - mow.spaceNeeded; mow.resize(false); this.timeout(function () { this.container.height -= mow.spaceNeeded; }); } }, /** * Selects the item at the given *group* and *index*. * * @param {CompletionContext|[CompletionContext,number]} *group* The * completion context to select, or a tuple specifying the * context and item index. * @param {number} index The item index in *group* to select. * @param {number} position If non-null, try to position the * selected item at the *position*th row from the top of * the screen. Note that at least {@link #CONTEXT_LINES} * lines will be visible above and below the selected item * unless there aren't enough results to make this possible. * @optional */ select: function select(group, index, position) { if (isArray(group)) [group, index] = group; group = this.getGroup(group); if (this.selectedGroup && (!group || group != this.selectedGroup)) this.selectedGroup.selectedIdx = null; this.selectedGroup = group; if (group) group.selectedIdx = index; let groups = this.activeGroups; if (position != null || !this.startPos && groups.length) this.startPos = [group || groups[0], position || 0]; if (groups.length) { group = group || groups[0]; let idx = groups.indexOf(group); let start = this.startPos[0].getOffset(this.startPos[1]); if (group) { let idx = group.selectedIdx || 0; let off = group.getOffset(idx); start = Math.constrain(start, off + Math.min(this.CONTEXT_LINES, group.itemCount - idx + group.offsets.end) - this.maxItems + 1, off - Math.min(this.CONTEXT_LINES, idx + group.offsets.start)); } let count = this.maxItems; for (let group of groups) { let off = Math.max(0, start - group.offsets.start); group.count = Math.constrain(group.itemCount - off, 0, count); count -= group.count; group.collapsed = group.offsets.start >= start + this.maxItems || group.offsets.start + group.itemCount < start; group.range = ItemList.Range(off, off + group.count); if (!startPos) var startPos = [group, group.range.start]; } this.startPos = startPos; } this.draw(); }, /** * Returns an ItemList group for the given completion context, * creating one if necessary. * * @param {CompletionContext} context * @returns {ItemList.Group} */ getGroup: function getGroup(context) { if (context instanceof ItemList.Group) return context; else return context && context.getCache("itemlist-group", () => ItemList.Group(this, context)); }, getOffset: function getOffset(tuple) { return tuple && this.getGroup(tuple[0]).getOffset(tuple[1]); } }, { RESIZE_BRIEF: 1 << 0, WAITING_MESSAGE: _("completion.generating"), Group: Class("ItemList.Group", { init: function init(parent, context) { this.parent = parent; this.context = context; this.offsets = {}; this.range = ItemList.Range(0, 0); }, get rootXML() { return ["div", { key: "root", highlight: "CompGroup" }, ["div", { highlight: "Completions" }, this.context.createRow(this.context.title || [], "CompTitle")], ["div", { highlight: "CompTitleSep" }], ["div", { key: "contents" }, ["div", { key: "up", highlight: "CompLess" }], ["div", { key: "message", highlight: "CompMsg" }, this.context.message || []], ["div", { key: "itemsContainer", class: "completion-items-container" }, ["div", { key: "items", highlight: "Completions" }]], ["div", { key: "waiting", highlight: "CompMsg" }, ItemList.WAITING_MESSAGE], ["div", { key: "down", highlight: "CompMore" }]]]; }, get doc() { return this.parent.doc; }, get win() { return this.parent.win; }, get maxItems() { return this.parent.maxItems; }, get itemCount() { return this.context.items.length; }, /** * Returns a function which will update the scroll offsets * and heights of various DOM members. * @private */ get rescrollFunc() { let container = this.nodes.itemsContainer; let pos = DOM(container).rect.top; let start = DOM(this.getRow(this.range.start)).rect.top; let height = DOM(this.getRow(this.range.end - 1)).rect.bottom - start || 0; let scroll = start + container.scrollTop - pos; let win = this.win; let row = this.selectedRow; if (row && this.parent.minHeight) { let { rect } = DOM(this.selectedRow); var scrollY = this.win.scrollY + rect.bottom - this.win.innerHeight; } return () => { container.style.height = height + "px"; container.scrollTop = scroll; if (scrollY != null) win.scrollTo(0, Math.max(scrollY, 0)); }; }, /** * Reset this group for use with a new set of results. */ reset: function reset() { this.nodes = {}; this.generatedRange = ItemList.Range(0, 0); DOM.fromJSON(this.rootXML, this.doc, this.nodes); }, /** * Update this group after an asynchronous results push. */ update: function update() { this.generatedRange = ItemList.Range(0, 0); DOM(this.nodes.items).empty(); if (this.context.message) DOM(this.nodes.message).empty() .append(DOM.fromJSON(this.context.message, this.doc)); if (this.selectedIdx > this.itemCount) this.selectedIdx = null; }, /** * Updates the DOM to reflect the current state of this * group. * @private */ draw: function draw() { DOM(this.nodes.contents).toggle(!this.collapsed); if (this.collapsed) return; DOM(this.nodes.message).toggle(this.context.message && this.range.start == 0); DOM(this.nodes.waiting).toggle(this.context.incomplete && this.range.end <= this.itemCount); DOM(this.nodes.up).toggle(this.range.start > 0); DOM(this.nodes.down).toggle(this.range.end < this.itemCount); if (!this.generatedRange.contains(this.range)) { if (this.generatedRange.end == 0) var [start, end] = Array.slice(this.range); else { start = this.range.start - (this.range.start <= this.generatedRange.start ? this.maxItems / 2 : 0); end = this.range.end + (this.range.end > this.generatedRange.end ? this.maxItems / 2 : 0); } let range = ItemList.Range(Math.max(0, start - start % 2), Math.min(this.itemCount, end)); let first; for (let [i, row] of this.context.getRows(this.generatedRange.start, this.generatedRange.end, this.doc)) { if (!range.contains(i)) DOM(row).remove(); else if (!first) first = row; } let container = DOM(this.nodes.items); let before = first ? DOM(first).bound.before : DOM(this.nodes.items).bound.append; for (let [i, row] of this.context.getRows(range.start, range.end, this.doc)) { if (i < this.generatedRange.start) before(row); else if (i >= this.generatedRange.end) container.append(row); if (i == this.selectedIdx) this.selectedIdx = this.selectedIdx; } this.generatedRange = range; } }, getRow: function getRow(idx) { return this.context.getRow(idx, this.doc); }, getOffset: function getOffset(idx) { return this.offsets.start + (idx || 0); }, get selectedRow() { return this.getRow(this._selectedIdx); }, get selectedIdx() { return this._selectedIdx; }, set selectedIdx(idx) { if (this.selectedRow && this._selectedIdx != idx) DOM(this.selectedRow).attr("selected", null); this._selectedIdx = idx; if (this.selectedRow) DOM(this.selectedRow).attr("selected", true); } }), Range: Class.Memoize(function () { let Range = Struct("ItemList.Range", "start", "end"); update(Range.prototype, { contains: function contains(idx) { if (typeof idx == "number") return idx >= this.start && idx < this.end; else return this.contains(idx.start) && idx.end >= this.start && idx.end <= this.end; } }); return Range; }) }); // vim: set fdm=marker sw=4 sts=4 ts=8 et: ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������dactyl-1.2~r20151231/common/content/dactyl.js�������������������������������������������������������0000664�0000000�0000000�00000233010�12641473761�0020625�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Copyright (c) 2006-2008 by Martin Stubenschrott <stubenschrott@vimperator.org> // Copyright (c) 2007-2011 by Doug Kearns <dougkearns@gmail.com> // Copyright (c) 2008-2015 Kris Maglione <maglione.k@gmail.com> // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; /** @scope modules */ var EVAL_ERROR = "__dactyl_eval_error"; var EVAL_RESULT = "__dactyl_eval_result"; var EVAL_STRING = "__dactyl_eval_string"; var Dactyl = Module("dactyl", XPCOM(Ci.nsISupportsWeakReference, ModuleBase), { init: function () { window.dactyl = this; // cheap attempt at compatibility let prop = { get: deprecated("dactyl", function liberator() { return dactyl; }), configurable: true }; Object.defineProperty(window, "liberator", prop); Object.defineProperty(modules, "liberator", prop); this.commands = {}; this.indices = {}; this.modules = modules; this._observers = {}; util.addObserver(this); this.commands["dactyl.restart"] = event => { dactyl.restart(); }; styles.registerSheet("resource://dactyl-skin/dactyl.css"); this.cleanups = []; this.cleanups.push(overlay.overlayObject(window, { focusAndSelectUrlBar: function focusAndSelectUrlBar() { switch (options.get("strictfocus").getKey(document.documentURIObject || util.newURI(document.documentURI), "moderate")) { case "laissez-faire": if (!Events.isHidden(window.gURLBar, true)) return focusAndSelectUrlBar.superapply(this, arguments); default: // Evil. Ignore. } } })); }, cleanup: function () { for (let cleanup of this.cleanups) cleanup.call(this); delete window.dactyl; delete window.liberator; // Prevents box ordering bugs after our stylesheet is removed. styles.system.add("cleanup-sheet", config.styleableChrome, String.raw` #TabsToolbar tab { display: none; } `); styles.unregisterSheet("resource://dactyl-skin/dactyl.css"); DOM('#TabsToolbar tab', document).style.display; }, destroy: function () { this.observe.unregister(); autocommands.trigger("LeavePre", {}); dactyl.triggerObserver("shutdown", null); util.dump("All dactyl modules destroyed\n"); autocommands.trigger("Leave", {}); }, // initially hide all GUI elements, they are later restored unless the user // has :set go= or something similar in his config hideGUI: function () { let guioptions = config.guioptions; for (let option of guioptions) { guioptions[option].forEach(function (elem) { try { document.getElementById(elem).collapsed = true; } catch (e) {} }); } }, observers: { "dactyl-cleanup": function dactyl_cleanup(subject, reason) { let modules = dactyl.modules; for (let mod of modules.moduleList.reverse()) { mod.stale = true; if ("cleanup" in mod) this.trapErrors("cleanup", mod, reason); if ("destroy" in mod) this.trapErrors("destroy", mod, reason); } modules.moduleManager.initDependencies("cleanup"); for (let name of Object.getOwnPropertyNames(modules).reverse()) try { delete modules[name]; } catch (e) {} modules.__proto__ = {}; } }, signals: { "io.source": function ioSource(context, file, modTime) { if (contexts.getDocs(context)) help.flush("help/plugins.xml", modTime); } }, profileName: deprecated("config.profileName", { get: function profileName() { return config.profileName; } }), /** * @property {Modes.Mode} The current main mode. * @see modes#mainModes */ mode: deprecated("modes.main", { get: function mode() { return modes.main; }, set: function mode(val) { modes.main = val; }, }), getMenuItems: function getMenuItems(targetPath) { function addChildren(node, parent) { DOM(node).createContents(); if (~["menu", "menupopup"].indexOf(node.localName) && node.children.length) DOM(node).popupshowing({ bubbles: false }); for (let item of node.childNodes) { if (item.childNodes.length == 0 && item.localName == "menuitem" && !item.hidden && !/rdf:http:/.test(item.getAttribute("label"))) { // FIXME item.dactylPath = parent + item.getAttribute("label"); if (!targetPath || targetPath.startsWith(item.dactylPath)) items.push(item); } else { let path = parent; if (item.localName == "menu") path += item.getAttribute("label") + "."; if (!targetPath || targetPath.startsWith(path)) addChildren(item, path); } } } let items = []; addChildren(document.getElementById(config.guioptions["m"][1]), ""); return items; }, get menuItems() { return this.getMenuItems(); }, // Global constants CURRENT_TAB: "here", NEW_TAB: "tab", NEW_BACKGROUND_TAB: "background-tab", NEW_WINDOW: "window", forceBackground: null, forcePrivate: null, forceTarget: null, get forceOpen() { return { background: this.forceBackground, target: this.forceTarget }; }, set forceOpen(val) { for (let [k, v] of iter({ background: "forceBackground", target: "forceTarget" })) if (k in val) this[v] = val[k]; }, version: deprecated("config.version", { get: function version() { return config.version; } }), /** * @property {Object} The map of command-line options. These are * specified in the argument to the host application's -{config.name} * option. E.g. $ firefox -pentadactyl '+u=/tmp/rcfile ++noplugin' * Supported options: * +u RCFILE Use RCFILE instead of .pentadactylrc. * ++noplugin Don't load plugins. * These two can be specified multiple times: * ++cmd CMD Execute an Ex command before initialization. * +c CMD Execute an Ex command after initialization. */ commandLineOptions: { /** @property Whether plugin loading should be prevented. */ noPlugins: false, /** @property An RC file to use rather than the default. */ rcFile: null, /** @property An Ex command to run before any initialization is performed. */ preCommands: null, /** @property An Ex command to run after all initialization has been performed. */ postCommands: null }, registerObserver: function registerObserver(type, callback, weak) { if (!(type in this._observers)) this._observers[type] = []; this._observers[type].push(weak ? util.weakReference(callback) : { get: function () { return callback; } }); }, registerObservers: function registerObservers(obj, prop) { for (let [signal, func] of iter(obj[prop || "signals"])) this.registerObserver(signal, func.bind(obj), false); }, unregisterObserver: function unregisterObserver(type, callback) { if (type in this._observers) this._observers[type] = this._observers[type].filter(c => c.get() != callback); }, applyTriggerObserver: function triggerObserver(type, args) { if (type in this._observers) this._observers[type] = this._observers[type] .filter(callback => { callback = callback.get(); if (callback) { util.trapErrors(() => callback.apply(null, args)); return true; } }); }, triggerObserver: function triggerObserver(type, ...args) { return this.applyTriggerObserver(type, args); }, addUsageCommand: function (params) { function keys(item) { return (item.names || [item.name]).concat(item.description, item.columns || []); } let name = commands.add(params.name, params.description, function (args) { let results = Array.from(params.iterate(args)) .sort((a, b) => String.localeCompare(a.name, b.name)); let filters = args.map(arg => { let re = util.regexp.escape(arg); return util.regexp("\\b" + re + "\\b|(?:^|[()\\s])" + re + "(?:$|[()\\s])", "i"); }); if (filters.length) results = results.filter(item => filters.every(re => keys(item).some(re.bound.test))); commandline.commandOutput( template.usage(results, params.format)); }, { argCount: "*", completer: function (context, args) { context.keys.text = identity; context.keys.description = function () { return seen[this.text] + /*L*/" matching items"; }; context.ignoreCase = true; let seen = {}; context.completions = new RealSet( Array.from(params.iterate(args)) .flatMap(item => Object.keys(item).join(" ") .toLowerCase().split(/[()\s]+/)) .map(k => { seen[k] = (seen[k] || 0) + 1; return k; })); }, options: params.options || [] }); if (params.index) this.indices[params.index] = function* () { let results = Array.from((params.iterateIndex || params.iterate).call(params, commands.get(name).newArgs())) .sort((a, b) => String.localeCompare(a.name, b.name)); for (let obj of results) { let res = dactyl.generateHelp(obj, null, null, true); if (!hasOwnProp(help.tags, obj.helpTag)) res[0][1].tag = obj.helpTag; yield res; } }; }, /** * Triggers the application bell to notify the user of an error. The * bell may be either audible or visual depending on the value of the * 'visualbell' option. */ beep: function () { this.triggerObserver("beep"); if (options["visualbell"]) { let elems = { bell: document.getElementById("dactyl-bell"), strut: document.getElementById("dactyl-bell-strut") }; if (!elems.bell) overlay.overlayWindow(window, { objects: elems, prepend: [ ["window", { id: document.documentElement.id, xmlns: "xul" }, ["hbox", { style: "display: none", highlight: "Bell", id: "dactyl-bell", key: "bell" }]]], append: [ ["window", { id: document.documentElement.id, xmlns: "xul" }, ["hbox", { style: "display: none", highlight: "Bell", id: "dactyl-bell-strut", key: "strut" }]]] }, elems); elems.bell.style.height = window.innerHeight + "px"; elems.strut.style.marginBottom = -window.innerHeight + "px"; elems.strut.style.display = elems.bell.style.display = ""; util.timeout(function () { elems.strut.style.display = elems.bell.style.display = "none"; }, 20); } else { let soundService = Cc["@mozilla.org/sound;1"].getService(Ci.nsISound); soundService.beep(); } }, /** * Reads a string from the system clipboard. * * This is same as Firefox's readFromClipboard function, but is needed for * apps like Thunderbird which do not provide it. * * @param {string} which Which clipboard to write to. Either * "global" or "selection". If not provided, both clipboards are * updated. * @optional * @returns {string} */ clipboardRead: function clipboardRead(which) { try { const { clipboard } = services; let transferable = services.Transferable(); transferable.addDataFlavor("text/unicode"); let source = clipboard[which == "global" || !clipboard.supportsSelectionClipboard() ? "kGlobalClipboard" : "kSelectionClipboard"]; clipboard.getData(transferable, source); let str = {}, len = {}; transferable.getTransferData("text/unicode", str, len); if (str) return str.value.QueryInterface(Ci.nsISupportsString) .data.substr(0, len.value / 2); } catch (e) {} return null; }, /** * Copies a string to the system clipboard. If *verbose* is specified the * copied string is also echoed to the command line. * * @param {string} str The string to write. * @param {boolean} verbose If true, the user is notified of the copied data. * @param {string} which Which clipboard to write to. Either * "global" or "selection". If not provided, both clipboards are * updated. * @optional */ clipboardWrite: function clipboardWrite(str, verbose, which) { if (which == null || which == "selection" && !services.clipboard.supportsSelectionClipboard()) services.clipboardHelper.copyString(str); else services.clipboardHelper.copyStringToClipboard(str, services.clipboard["k" + util.capitalize(which) + "Clipboard"]); if (verbose) { let message = { message: _("dactyl.yank", str) }; try { message.domains = [util.newURI(str).host]; } catch (e) {}; dactyl.echomsg(message); } }, dump: deprecated("util.dump", { get: function dump() { return util.bound.dump; } }), dumpStack: deprecated("util.dumpStack", { get: function dumpStack() { return util.bound.dumpStack; } }), /** * Outputs a plain message to the command line. * * @param {string} str The message to output. * @param {number} flags These control the multi-line message behavior. * See {@link CommandLine#echo}. */ echo: function echo(str, flags) { commandline.echo(str, commandline.HL_NORMAL, flags); }, /** * Outputs an error message to the command line. * * @param {string} str The message to output. * @param {number} flags These control the multi-line message behavior. * See {@link CommandLine#echo}. */ echoerr: function echoerr(str, flags) { flags |= commandline.APPEND_TO_MESSAGES; if (isinstance(str, ["DOMException", "Error", "Exception", ErrorBase]) || isinstance(str, ["XPCWrappedNative_NoHelper"]) && /^\[Exception/.test(str)) dactyl.reportError(str); if (isObject(str) && "echoerr" in str) str = str.echoerr; else if (isinstance(str, ["Error", FailedAssertion]) && str.fileName) str = [str.fileName.replace(/^.* -> /, ""), ": ", str.lineNumber, ": ", str].join(""); if (options["errorbells"]) dactyl.beep(); commandline.echo(str, commandline.HL_ERRORMSG, flags); }, /** * Outputs a warning message to the command line. * * @param {string} str The message to output. * @param {number} flags These control the multi-line message behavior. * See {@link CommandLine#echo}. */ warn: function warn(str, flags) { commandline.echo(str, "WarningMsg", flags | commandline.APPEND_TO_MESSAGES); }, // TODO: add proper level constants /** * Outputs an information message to the command line. * * @param {string} str The message to output. * @param {number} verbosity The messages log level (0 - 15). Only * messages with verbosity less than or equal to the value of the * *verbosity* option will be output. * @param {number} flags These control the multi-line message behavior. * See {@link CommandLine#echo}. */ echomsg: function echomsg(str, verbosity, flags) { if (verbosity == null) verbosity = 0; // verbosity level is exclusionary if (options["verbose"] >= verbosity) commandline.echo(str, commandline.HL_INFOMSG, flags | commandline.APPEND_TO_MESSAGES); }, /** * Loads and executes the script referenced by *uri* in the scope of the * *context* object. * * @param {string} uri The URI of the script to load. Should be a local * chrome:, file:, or resource: URL. * @param {Object} context The context object into which the script * should be loaded. */ loadScript: function loadScript(uri, context) { let prefix = "literal:" + uri + ":"; cache.flush(s => s.startsWith(prefix)); delete literal.files[uri]; JSMLoader.loadSubScript(uri, context, File.defaultEncoding); }, userEval: function userEval(str, context, fileName, lineNumber) { let ctxt, info = contexts.context; if (fileName == null) if (info) ({ file: fileName, line: lineNumber, context: ctxt } = info); if (fileName && fileName[0] == "[") fileName = "dactyl://command-line/"; else if (!context) context = ctxt || userContext; if (!context) context = userContext || ctxt; if (isinstance(context, ["Sandbox"])) return Cu.evalInSandbox(str, context, "1.8", fileName, lineNumber); if (services.has("dactyl") && services.dactyl.evalInContext) return services.dactyl.evalInContext(str, context, fileName, lineNumber); try { context[EVAL_ERROR] = null; context[EVAL_STRING] = str; context[EVAL_RESULT] = null; this.loadScript("resource://dactyl-content/eval.js", context); if (context[EVAL_ERROR]) { try { context[EVAL_ERROR].fileName = info.file; context[EVAL_ERROR].lineNumber += info.line; } catch (e) {} throw context[EVAL_ERROR]; } return context[EVAL_RESULT]; } finally { delete context[EVAL_ERROR]; delete context[EVAL_RESULT]; delete context[EVAL_STRING]; } }, /** * Acts like the Function builtin, but the code executes in the * userContext global. */ userFunc: function userFunc(...args) { return this.userEval( "(function userFunction(" + args.slice(0, -1).join(", ") + ")" + " { " + args.pop() + " })"); }, /** * Execute an Ex command string. E.g. ":zoom 300". * * @param {string} str The command to execute. * @param {Object} modifiers Any modifiers to be passed to * {@link Command#action}. * @param {boolean} silent Whether the command should be echoed on the * command line. */ execute: function execute(str, modifiers={}, silent=false) { // skip comments and blank lines if (/^\s*("|$)/.test(str)) return; if (!silent) commands.lastCommand = str.replace(/^\s*:\s*/, ""); let res = true; for (let [command, args] of commands.parseCommands(str.replace(/^'(.*)'$/, "$1"))) { if (command === null) throw FailedAssertion(_("dactyl.notCommand", config.appName, args.commandString)); res = res && command.execute(args, modifiers); } return res; }, focus: function focus(elem, flags) { DOM(elem).focus(flags); }, /** * Focuses the content window. * * @param {boolean} clearFocusedElement Remove focus from any focused * element. */ focusContent: function focusContent(clearFocusedElement) { if (window != services.focus.activeWindow) return; let win = document.commandDispatcher.focusedWindow; let elem = config.mainWidget || content; // TODO: make more generic try { if (this.has("mail") && !config.isComposeWindow) { let i = gDBView.selection.currentIndex; if (i == -1 && gDBView.rowCount >= 0) i = 0; gDBView.selection.select(i); } else { let frame = buffer.focusedFrame; if (frame && frame.top == content && !Editor.getEditor(frame)) elem = frame; } } catch (e) {} if (clearFocusedElement) { if (dactyl.focusedElement) dactyl.focusedElement.blur(); if (win && Editor.getEditor(win)) { this.withSavedValues(["ignoreFocus"], function _focusContent() { this.ignoreFocus = true; if (win.frameElement) win.frameElement.blur(); // Grr. if (content.document.activeElement instanceof Ci.nsIDOMHTMLIFrameElement) content.document.activeElement.blur(); }); } } if (elem instanceof Window && Editor.getEditor(elem)) elem = window; if (elem && elem != dactyl.focusedElement) dactyl.focus(elem); }, /** @property {Element} The currently focused element. */ get focusedElement() { return services.focus.getFocusedElementForWindow(window, true, {}); }, set focusedElement(elem) { dactyl.focus(elem); }, /** * Returns whether this Dactyl extension supports *feature*. * * @param {string} feature The feature name. * @returns {boolean} */ has: function has(feature) { return config.has(feature); }, /** * @private */ initDocument: function initDocument(doc) { try { if (doc.location.protocol === "dactyl:") { dactyl.initHelp(); config.styleHelp(); } } catch (e) { util.reportError(e); } }, help: deprecated("help.help", { get: function help() { return modules.help.bound.help; } }), findHelp: deprecated("help.findHelp", { get: function findHelp() { return help.bound.findHelp; } }), /** * @private * Initialize the help system. */ initHelp: function initHelp() { if ("noscriptOverlay" in window) window.noscriptOverlay.safeAllow("dactyl:", true, false); help.initialize(); }, /** * Generates a help entry and returns it as a string. * * @param {Command|Map|Option} obj A dactyl *Command*, *Map* or *Option* * object * @param {XMLList} extraHelp Extra help text beyond the description. * @returns {string} */ generateHelp: function generateHelp(obj, extraHelp, str, specOnly) { let link, tag, spec; link = tag = spec = identity; let args = null; if (obj instanceof Command) { link = cmd => ["ex", {}, cmd]; args = obj.parseArgs("", CompletionContext(str || "")); tag = cmd => DOM.DOMString(":" + cmd); spec = cmd => [ obj.count ? ["oa", {}, "count"] : [], cmd, obj.bang ? ["oa", {}, "!"] : [] ]; } else if (obj instanceof Map) { spec = map => (obj.count ? [["oa", {}, "count"], map] : DOM.DOMString(map)); tag = map => { let c = obj.modes[0].char; return [c ? c + "_" : "", map]; }; link = map => { let [, mode, name, extra] = /^(?:(.)_)?(?:<([^>]+)>)?(.*)$/.exec(map); let k = ["k", {}, extra]; if (name) k[1].name = name; if (mode) k[1].mode = mode; return k; }; } else if (obj instanceof Option) { spec = () => template.map(obj.names, tag, " "); tag = name => DOM.DOMString("'" + name + "'"); link = (opt, name) => ["o", {}, name]; args = { value: "", values: [] }; } let res = [ ["dt", {}, link(obj.helpTag || tag(obj.name), obj.name)], ["dd", {}, template.linkifyHelp(obj.description ? obj.description.replace(/\.$/, "") : "", true)]]; if (specOnly) return res; let description = ["description", {}, obj.description ? ["p", {}, template.linkifyHelp(obj.description.replace(/\.?$/, "."), true)] : "", extraHelp ? extraHelp : "", !(extraHelp || obj.description) ? ["p", {}, /*L*/ "Sorry, no help available."] : ""]; let name = (obj.specs || obj.names)[0]; res.push( ["item", {}, ["tags", {}, template.map(obj.names.slice().reverse(), tag, " ").join("")], ["spec", {}, spec(template.highlightRegexp(tag(name), /\[(.*?)\]/g, (m, n0) => ["oa", {}, n0]), name)], !obj.type ? "" : [ ["type", {}, obj.type], ["default", {}, obj.stringDefaultValue]], description]); function add(ary) { description.push( ["dl", {}, template.map(ary, ([a, b]) => [["dt", {}, a], " ", ["dd", {}, b]])]); } if (obj.completer && false) add(completion._runCompleter(obj.bound.completer, "", null, args).items .map(i => [i.text, i.description])); if (obj.options && obj.options.some(o => o.description) && false) add(obj.options.filter(o => o.description) .map(o => [ o.names[0], [o.description, o.names.length == 1 ? "" : ["", " (short name: ", template.map(o.names.slice(1), n => ["em", {}, n], ", "), ")"]] ])); return DOM.toPrettyXML(res, true, null, { "": String(NS) }); }, /** * The map of global variables. * * These are set and accessed with the "g:" prefix. */ _globalVariables: {}, globalVariables: deprecated(_("deprecated.for.theOptionsSystem"), { get: function globalVariables() { return this._globalVariables }, }), loadPlugins: function loadPlugins(args, force) { function sourceDirectory(dir) { dactyl.assert(dir.isReadable(), _("io.notReadable", dir.path)); dactyl.log(_("dactyl.sourcingPlugins", dir.path), 3); let loadplugins = options.get("loadplugins"); if (args) loadplugins = { __proto__: loadplugins, value: args.map(Option.parseRegexp) }; let shouldSource = file => { if (!loadplugins.getKey(file.path)) return false; if (force) return true; if (file.path in dactyl.pluginFiles) return dactyl.pluginFiles[file.path] < file.lastModifiedTime; return true; }; dir.readDirectory(true).forEach(file => { if (file.leafName.startsWith(".")) ; else if (file.isFile()) { if (shouldSource(file)) { try { io.source(file.path); dactyl.pluginFiles[file.path] = file.lastModifiedTime; } catch (e) { dactyl.reportError(e); } } } else if (file.isDirectory()) sourceDirectory(file); }); } let dirs = io.getRuntimeDirectories("plugins"); if (dirs.length == 0) { dactyl.log(_("dactyl.noPluginDir"), 3); return; } dactyl.echomsg( _("plugin.searchingForIn", JSON.stringify("plugins/**/*.{js," + config.fileExtension + "}"), JSON.stringify(dirs.map(dir => dir.path.replace(/.plugins$/, "")) .join(","))), 2); dirs.forEach(function (dir) { dactyl.echomsg(_("plugin.searchingFor", JSON.stringify(dir.path + "/**/*.{js," + config.fileExtension + "}")), 3); sourceDirectory(dir); }); }, // TODO: add proper level constants /** * Logs a message to the JavaScript error console. Each message has an * associated log level. Only messages with a log level less than or equal * to *level* will be printed. If *msg* is an object, it is pretty printed. * * @param {string|Object} msg The message to print. * @param {number} level The logging level 0 - 15. */ log: function log(msg, level) { let verbose = config.prefs.get("loglevel", 0); if (!level || level <= verbose) { if (isObject(msg) && !isinstance(msg, _)) msg = util.objectToString(msg, false); services.console.logStringMessage(config.name + ": " + msg); } }, events: { beforecustomization: function onbeforecustomization(event) { // Show navigation bar on Australis, where it's not supposed // to be collapsible, and is therefore not handled by // builtin code. if ("CustomizableUI" in window) this.setNodeVisible(document.getElementById("nav-bar"), true); }, aftercustomization: function onaftercustomization(event) { // Restore toolbar states. options["guioptions"] = options["guioptions"]; }, click: function onClick(event) { let elem = event.originalTarget; if (elem instanceof Ci.nsIDOMElement && !Cu.isCrossProcessWrapper(elem) && services.security.isSystemPrincipal(elem.nodePrincipal)) { let command = elem.getAttributeNS(NS, "command"); if (command && event.button == 0) { event.preventDefault(); if (dactyl.commands[command]) dactyl.withSavedValues(["forceTarget"], () => { if (event.ctrlKey || event.shiftKey || event.button == 1) dactyl.forceTarget = dactyl.NEW_TAB; dactyl.commands[command](event); }); } } }, "dactyl.execute": function onExecute(event) { let cmd = event.originalTarget.getAttribute("dactyl-execute"); commands.execute(cmd, null, false, null, { file: /*L*/"[Command Line]", line: 1 }); } }, /** * Opens one or more URLs. Returns true when load was initiated, or * false on error. * * @param {string|Array} urls A representation of the URLs to open. * A string will be passed to {@link Dactyl#parseURLs}. An array may * contain elements of the following forms: * * • {string} A URL to open. * • {[string, {string|Array}]} Pair of a URL and POST data. * • {object} Object compatible with those returned * by {@link DOM#formData}. * * @param {object} params A set of parameters specifying how to open the * URLs. The following properties are recognized: * * • background If true, new tabs are opened in the background. * * • from The designation of the opener, as appears in * 'activate' and 'newtab' options. If present, * the newtab option provides the default 'where' * parameter, and the value of the 'activate' * parameter is inverted if 'background' is true. * * • where One of CURRENT_TAB, NEW_TAB, or NEW_WINDOW * * As a deprecated special case, the where parameter may be provided * by itself, in which case it is transformed into { where: params }. * * @param {boolean} force Don't prompt whether to open more than 20 * tabs. * @returns {boolean} */ open: function open(urls, params={}, force=false) { if (typeof urls == "string") urls = dactyl.parseURLs(urls); if (urls.length > prefs.get("browser.tabs.maxOpenBeforeWarn", 20) && !force) return commandline.input(_("dactyl.prompt.openMany", urls.length) + " ") .then(function (resp) { if (resp && resp.match(/^y(es)?$/i)) dactyl.open(urls, params, true); }); if (isString(params)) params = { where: params }; let flags = 0; for (let [opt, flag] of iter({ replace: "REPLACE_HISTORY", hide: "BYPASS_HISTORY" })) flags |= params[opt] && Ci.nsIWebNavigation["LOAD_FLAGS_" + flag]; let where = params.where || dactyl.CURRENT_TAB; let background = dactyl.forceBackground != null ? dactyl.forceBackground : ("background" in params) ? params.background : params.where == dactyl.NEW_BACKGROUND_TAB; if (params.from && dactyl.has("tabs")) { if (!params.where && options.get("newtab").has(params.from)) where = dactyl.NEW_TAB; background ^= !options.get("activate").has(params.from); } if (urls.length == 0) return; let browser = config.tabbrowser; function open(loc, where) { try { if (isArray(loc)) loc = { url: loc[0], postData: loc[1] }; else if (isString(loc)) loc = { url: loc }; else loc = Object.create(loc); if (isString(loc.postData)) loc.postData = ["application/x-www-form-urlencoded", loc.postData]; if (isArray(loc.postData)) { let stream = services.MIMEStream(services.StringStream(loc.postData[1])); stream.addHeader("Content-Type", loc.postData[0]); stream.addContentLength = true; loc.postData = stream; } // decide where to load the first url switch (where) { case dactyl.NEW_TAB: if (!dactyl.has("tabs")) return open(loc, dactyl.NEW_WINDOW); return prefs.withContext(function () { prefs.set("browser.tabs.loadInBackground", true); return browser.loadOneTab(loc.url, null, null, loc.postData, background).linkedBrowser.contentDocument; }); case dactyl.NEW_WINDOW: let options = ["chrome", "all", "dialog=no"]; if (dactyl.forcePrivate) options.push("private"); let win = window.openDialog(document.documentURI, "_blank", options.join(",")); util.waitFor(() => win.document.readyState === "complete"); browser = win.dactyl && win.dactyl.modules.config.tabbrowser || win.getBrowser(); // FALLTHROUGH case dactyl.CURRENT_TAB: browser.loadURIWithFlags(loc.url, flags, null, null, loc.postData); return browser.contentWindow; } } catch (e) {} // Unfortunately, failed page loads throw exceptions and // cause a lot of unwanted noise. This solution means that // any genuine errors go unreported. } if (dactyl.forceTarget) where = dactyl.forceTarget; else if (!where) where = dactyl.CURRENT_TAB; return urls.map(function (url) { let res = open(url, where); where = dactyl.NEW_TAB; background = true; return res; }); }, /** * Returns an array of URLs parsed from *str*. * * Given a string like 'google bla, www.osnews.com' return an array * ['www.google.com/search?q=bla', 'www.osnews.com'] * * @param {string} str * @returns {[string]} */ parseURLs: function parseURLs(str) { let urls; if (options["urlseparator"]) urls = util.splitLiteral(str, util.regexp("\\s*" + options["urlseparator"] + "\\s*")); else urls = [str]; return urls.map(function (url) { url = url.trim(); if (/^(\.{0,2}|~)(\/|$)/.test(url) || config.OS.isWindows && /^[a-z]:/i.test(url)) { try { // Try to find a matching file. let file = io.File(url); if (file.exists() && file.isReadable()) return file.URI.spec; } catch (e) {} } // If it starts with a valid protocol, pass it through. let proto = /^([-\w]+):/.exec(url); if (proto && services.PROTOCOL + proto[1] in Cc) return url; // Check for a matching search keyword. let searchURL = this.has("bookmarks") && bookmarks.getSearchURL(url, false); if (searchURL) return searchURL; // If it looks like URL-ish (foo.com/bar), let Gecko figure it out. if (this.urlish.test(url) || !this.has("bookmarks")) return util.createURI(url).spec; // Pass it off to the default search engine or, failing // that, let Gecko deal with it as is. return bookmarks.getSearchURL(url, true) || util.createURI(url).spec; }, this); }, stringToURLArray: deprecated("dactyl.parseURLs", "parseURLs"), urlish: Class.Memoize(() => util.regexp(String.raw` ^ ( <domain>+ (:\d+)? (/ .*) | <domain>+ (:\d+) | <domain>+ \. [a-z0-9]+ | localhost ) $ `, "ix", { domain: util.regexp(String.raw` [^ U0000-U002c // U002d-U002e --. U002f // / // U0030-U0039 0-9 U003a-U0040 // U0041-U005a a-z U005b-U0060 // U0061-U007a A-Z U007b-U007f ] `.replace(/U/g, "\\u"), "x") })), pluginFiles: {}, get plugins() { return plugins; }, setNodeVisible: function setNodeVisible(node, visible) { if (window.setToolbarVisibility && node.localName == "toolbar") window.setToolbarVisibility(node, visible); else node.collapsed = !visible; }, confirmQuit: function confirmQuit() { return prefs.withContext(function () { prefs.set("browser.warnOnQuit", false); return window.canQuitApplication(); }); }, /** * Quit the host application, no matter how many tabs/windows are open. * * @param {boolean} saveSession If true the current session will be * saved and restored when the host application is restarted. * @param {boolean} force Forcibly quit irrespective of whether all * windows could be closed individually. */ quit: function quit(saveSession, force) { if (!force && !this.confirmQuit()) return; let pref = "browser.startup.page"; prefs.save(pref); if (saveSession) prefs.safeSet(pref, 3); if (!saveSession && prefs.get(pref) >= 2) prefs.safeSet(pref, 1); services.appStartup.quit(Ci.nsIAppStartup[force ? "eForceQuit" : "eAttemptQuit"]); }, /** * Restart the host application. */ restart: function restart(args) { if (!this.confirmQuit()) return; config.prefs.set("commandline-args", args); services.appStartup.quit(Ci.nsIAppStartup.eAttemptQuit | Ci.nsIAppStartup.eRestart); }, get assert() { return util.assert; }, /** * Traps errors in the called function, possibly reporting them. * * @param {function} func The function to call * @param {object} self The 'this' object for the function. */ trapErrors: function trapErrors(func, self, ...args) { try { if (isString(func)) func = self[func]; return func.apply(self || this, args); } catch (e) { try { dactyl.reportError(e, true); } catch (e) { util.reportError(e); } return e; } }, /** * Reports an error to both the console and the host application's * Error Console. * * @param {Object} error The error object. */ reportError: function reportError(error, echo) { if (error instanceof FailedAssertion && error.noTrace || error.message === "Interrupted") { let context = contexts.context; let prefix = context ? context.file + ":" + context.line + ": " : ""; if (error.message && !error.message.startsWith(prefix) && prefix != "[Command Line]:1: ") error.message = prefix + error.message; if (error.message) dactyl.echoerr(template.linkifyHelp(error.message)); else dactyl.beep(); if (!error.noTrace) util.reportError(error); return; } if (error.result == Cr.NS_BINDING_ABORTED) return; if (echo) dactyl.echoerr(error, commandline.FORCE_SINGLELINE); else util.reportError(error); }, /** * Parses a Dactyl command-line string i.e. the value of the * -dactyl command-line option. * * @param {string} cmdline The string to parse for command-line * options. * @returns {Object} * @see Commands#parseArgs */ parseCommandLine: function parseCommandLine(cmdline) { try { return commands.get("rehash").parseArgs(cmdline); } catch (e) { dactyl.reportError(e, true); return []; } }, wrapCallback: function wrapCallback(callback, self=this) { let save = ["forceOpen"]; let saved = save.map(p => dactyl[p]); return function wrappedCallback() { let args = arguments; return dactyl.withSavedValues(save, () => { saved.forEach((p, i) => { dactyl[save[i]] = p; }); try { return callback.apply(self, args); } catch (e) { dactyl.reportError(e, true); } }); }; }, /** * @property {[Window]} Returns an array of all the host application's * open windows. */ get windows() { return Array.from(overlay.windows); } }, { isToolbarHidden: function isToolbarHidden(toolbar) { return toolbar.getAttribute("autohide") == "true" || toolbar.getAttribute("collapsed") == "true"; }, getToolbarName: function getToolbarName(toolbar) { return toolbar.getAttribute("aria-label") || toolbar.getAttribute("toolbarname"); } }, { cache: function initCache() { cache.register("help/plugins.xml", () => { // Process plugin help entries. let body = []; for (let context of values(plugins.contexts)) try { let info = contexts.getDocs(context); if (DOM.isJSONXML(info)) { let langs = info.slice(2) .filter(e => isArray(e) && isObject(e[1]) && e[1].lang); if (langs) { let lang = config.bestLocale(langs.map(l => l[1].lang)); info = info.slice(0, 2).concat( info.slice(2).filter(e => !isArray(e) || !isObject(e[1]) || e[1].lang == lang)); info.slice(2) .filter(e => isArray(e) && e[0] == "info" && isObject(e[1])) .forEach(elem => { for (let attr of ["name", "summary", "href"]) if (attr in elem[1]) info[attr] = elem[1][attr]; }); } body.push(["h2", { xmlns: "dactyl", tag: info[1].name + '-plugin' }, String(info[1].summary)]); body.push(info); } } catch (e) { util.reportError(e); } return '<?xml version="1.0"?>\n' + '<?xml-stylesheet type="text/xsl" href="dactyl://content/help.xsl"?>\n' + DOM.toXML( ["document", { xmlns: "dactyl", name: "plugins", title: config.appName + ", Plugins" }, ["h1", { tag: "using-plugins" }, _("help.title.Using Plugins")], ["toc", { start: "2" }], body]); }, true); cache.register("help/index.xml", () => { return '<?xml version="1.0"?>\n' + DOM.toXML(["overlay", { xmlns: "dactyl" }, template.map(iter(dactyl.indices), ([name, iter]) => ["dl", { insertafter: name + "-index" }, template.map(iter(), identity)], "\n\n")]); }, true); cache.register("help/gui.xml", () => { return '<?xml version="1.0"?>\n' + DOM.toXML(["overlay", { xmlns: "dactyl" }, ["dl", { insertafter: "dialog-list" }, template.map(iter(config.dialogs), ([name, val]) => (!val[2] || val[2]()) ? [["dt", {}, name], ["dd", {}, val[0]]] : undefined, "\n")]]); }, true); cache.register("help/privacy.xml", () => { return '<?xml version="1.0"?>\n' + DOM.toXML(["overlay", { xmlns: "dactyl" }, ["dl", { insertafter: "sanitize-items" }, template.map(options.get("sanitizeitems").values .sort((a, b) => String.localeCompare(a.name, b.name)), ({ name, description }) => [["dt", {}, name], ["dd", {}, template.linkifyHelp(description, true)]], "\n")]]); }, true); }, events: function initEvents() { events.listen(window, dactyl, "events", true); }, // Only general options are added here, which are valid for all Dactyl extensions options: function initOptions() { options.add(["errorbells", "eb"], "Ring the bell when an error message is displayed", "boolean", false); options.add(["exrc", "ex"], "Enable automatic sourcing of an RC file in the current directory at startup", "boolean", false); options.add(["fullscreen", "fs"], "Show the current window fullscreen", "boolean", false, { setter: function (value) { return window.fullScreen = value; }, getter: function () { return window.fullScreen; } }); const groups = [ { opts: { c: ["Always show the command line, even when empty"], C: ["Always show the command line outside of the status line"], M: ["Always show messages outside of the status line"] }, setter: function (opts) { if (loaded.has("commandline") || ~opts.indexOf("c")) commandline.widgets.updateVisibility(); } }, { opts: update({ s: ["Status bar", [statusline.statusBar.id]] }, config.guioptions), setter: function (opts) { for (let [opt, [, ids]] of iter(this.opts)) { ids.map(id => document.getElementById(id)) .forEach(function (elem) { if (elem) dactyl.setNodeVisible(elem, opts.indexOf(opt) >= 0); }); } } }, { opts: { r: ["Right Scrollbar", "vertical"], l: ["Left Scrollbar", "vertical"], b: ["Bottom Scrollbar", "horizontal"] }, setter: function (opts) { let dir = ["horizontal", "vertical"].filter( dir => !Array.some(opts, o => this.opts[o] && this.opts[o][1] == dir)); let class_ = dir.map(dir => "html|html > xul|scrollbar[orient=" + dir + "]"); styles.system.add("scrollbar", "*", class_.length ? class_.join(", ") + " { visibility: collapse !important; }" : "", true); prefs.safeSet("layout.scrollbar.side", opts.indexOf("l") >= 0 ? 3 : 2, _("option.guioptions.safeSet")); }, validator: function (opts) { return Option.validIf(!(opts.indexOf("l") >= 0 && opts.indexOf("r") >= 0), UTF8("Only one of ‘l’ or ‘r’ allowed")); } }, { feature: "tabs", opts: { n: ["Tab number", highlight.selector("TabNumber")], N: ["Tab number over icon", highlight.selector("TabIconNumber")] }, setter: function (opts) { let classes = Object.entries(this.opts) .filter(([name]) => !opts.includes(name)) .map(([name, data]) => data[1]); styles.system.add("taboptions", "chrome://*", classes.length ? classes.join(",") + "{ display: none; }" : ""); if (config.tabbrowser.tabContainer._positionPinnedTabs) config.tabbrowser.tabContainer._positionPinnedTabs(); } } ].filter(group => !group.feature || dactyl.has(group.feature)); options.add(["guioptions", "go"], "Show or hide certain GUI elements like the menu or toolbar", "charlist", "", { // FIXME: cleanup cleanupValue: config.cleanups.guioptions || "rb" + Object.entries(groups[1].opts) .filter(([k, v]) => !Dactyl.isToolbarHidden(document.getElementById(v[1][0]))) .map(([k]) => k) .join(""), values: groups.flatMap(g => Object.entries(g.opts) .map(([k, v]) => [k, v[0]])), setter: function (value) { for (let group of groups) group.setter(value); events.checkFocus(); return value; }, validator: function (val) { return Option.validateCompleter.call(this, val) && groups.every(g => !g.validator || g.validator(val)); } }); options.add(["loadplugins", "lpl"], "A regexp list that defines which plugins are loaded at startup and via :loadplugins", "regexplist", "'\\.(js|" + config.fileExtension + ")$'"); options.add(["titlestring"], "The string shown at the end of the window title", "string", config.host, { setter: function (value) { let win = document.documentElement; function updateTitle(old, current) { if (config.browser.updateTitlebar) config.browser.updateTitlebar(); else document.title = document.title.replace(RegExp("(.*)" + util.regexp.escape(old)), "$1" + current); } if (win.hasAttribute("titlemodifier_privatebrowsing")) { let oldValue = win.getAttribute("titlemodifier_normal"); let suffix = win.getAttribute("titlemodifier_privatebrowsing").substr(oldValue.length); win.setAttribute("titlemodifier_normal", value); win.setAttribute("titlemodifier_privatebrowsing", value + suffix); if (storage.privateMode) { updateTitle(oldValue + suffix, value + suffix); win.setAttribute("titlemodifier", value + suffix); return value; } } updateTitle(win.getAttribute("titlemodifier"), value); win.setAttribute("titlemodifier", value); return value; } }); options.add(["urlseparator", "urlsep", "us"], "The regular expression used to separate multiple URLs in :open and friends", "string", " \\| ", { validator: function (value) { return RegExp(value); } }); options.add(["verbose", "vbs"], "Define which info messages are displayed", "number", 1, { validator: function (value) { return Option.validIf(value >= 0 && value <= 15, "Value must be between 0 and 15"); } }); options.add(["visualbell", "vb"], "Use visual bell instead of beeping on errors", "boolean", false, { setter: function (value) { prefs.safeSet("accessibility.typeaheadfind.enablesound", !value, _("option.safeSet", "visualbell")); return value; } }); }, mappings: function initMappings() { if (dactyl.has("session")) mappings.add([modes.NORMAL], ["ZQ"], "Quit and don't save the session", function () { dactyl.quit(false); }); mappings.add([modes.NORMAL], ["ZZ"], "Quit and save the session", function () { dactyl.quit(true); }); }, commands: function initCommands() { commands.add(["dia[log]"], "Open a " + config.appName + " dialog", function (args) { let dialog = args[0]; dactyl.assert(dialog in config.dialogs, _("error.invalidArgument", dialog)); dactyl.assert(!config.dialogs[dialog][2] || config.dialogs[dialog][2](), _("dialog.notAvailable", dialog)); try { config.dialogs[dialog][1](); } catch (e) { dactyl.echoerr(_("error.cantOpen", JSON.stringify(dialog), e.message || e)); } }, { argCount: "1", completer: function (context) { context.ignoreCase = true; completion.dialog(context); } }); commands.add(["em[enu]"], "Execute the specified menu item from the command line", function (args) { let arg = args[0] || ""; let items = dactyl.getMenuItems(arg); dactyl.assert(items.some(i => i.dactylPath == arg), _("emenu.notFound", arg)); for (let item of items) { if (item.dactylPath == arg) { dactyl.assert(!item.disabled, _("error.disabled", item.dactylPath)); item.doCommand(); } } }, { argCount: "1", completer: function (context) { completion.menuItem(context); }, literal: 0 }); commands.add(["exe[cute]"], "Execute the argument as an Ex command", function (args) { try { let cmd = dactyl.userEval(args[0] || ""); dactyl.execute(cmd || "", null, true); } catch (e) { dactyl.echoerr(e); } }, { completer: function (context) { completion.javascript(context); }, literal: 0 }); commands.add(["loadplugins", "lpl"], "Load all or matching plugins", function (args) { dactyl.loadPlugins(args.length ? args : null, args.bang); }, { argCount: "*", bang: true, keepQuotes: true, serialGroup: 10, serialize: function () { return [{ command: this.name, literalArg: options["loadplugins"].join(" ") }]; } }); commands.add(["norm[al]"], "Execute Normal mode commands", function (args) { events.feedkeys(args[0], args.bang, false, modes.NORMAL); }, { argCount: "1", bang: true, literal: 0 }); commands.add(["pr[ivate]", "pr0n", "porn"], "Enable privacy features of a command, when applicable, and do not save the invocation in command history", function (args) { dactyl.withSavedValues(["forcePrivate"], function () { this.forcePrivate = true; dactyl.execute(args[0], null, true); }); }, { argCount: "1", completer: function (context) { completion.ex(context); }, literal: 0, privateData: "never-save", subCommand: 0 }); commands.add(["exit", "x"], "Quit " + config.appName, function (args) { dactyl.quit(false, args.bang); }, { argCount: "0", bang: true }); commands.add(["q[uit]"], dactyl.has("tabs") ? "Quit current tab" : "Quit application", function (args) { if (dactyl.has("tabs") && tabs.remove(tabs.getTab(), 1, false)) return; else if (dactyl.windows.length > 1) window.close(); else dactyl.quit(false, args.bang); }, { argCount: "0", bang: true }); let startupOptions = [ { names: ["+u"], description: "The initialization file to execute at startup", type: CommandOption.STRING }, { names: ["++noplugin"], description: "Do not automatically load plugins" }, { names: ["++cmd"], description: "Ex commands to execute prior to initialization", type: CommandOption.STRING, multiple: true }, { names: ["+c"], description: "Ex commands to execute after initialization", type: CommandOption.STRING, multiple: true }, { names: ["+purgecaches"], description: "Purge " + config.appName + " caches at startup", type: CommandOption.NOARG } ]; commands.add(["reh[ash]"], "Reload the " + config.appName + " add-on", function (args) { if (args.trailing) storage.storeForSession("rehashCmd", args.trailing); // Hack. args.break = true; if (args["+purgecaches"]) cache.flush(); util.delay(() => { util.rehash(args); }); }, { argCount: "0", // FIXME options: startupOptions }); commands.add(["res[tart]"], "Force " + config.host + " to restart", function (args) { if (args["+purgecaches"]) cache.flush(); dactyl.restart(args.string); }, { argCount: "0", options: startupOptions }); if (config.toolbars.length) { let toolbarCommand = function (names, desc, action, filter) { commands.add(names, desc, function (args) { let name = args[0].trim(); let toolbar = config.toolbars.find(t => Dactyl.getToolbarName(t) === name); dactyl.assert(toolbar, _("error.invalidArgument")); action(toolbar); events.checkFocus(); }, { argCount: "1", completer: function (context) { completion.toolbar(context); if (filter) context.filters.push(filter); }, literal: 0 }); }; toolbarCommand(["toolbars[how]", "tbs[how]"], "Show the named toolbar", toolbar => dactyl.setNodeVisible(toolbar, true), ({ item }) => Dactyl.isToolbarHidden(item)); toolbarCommand(["toolbarh[ide]", "tbh[ide]"], "Hide the named toolbar", toolbar => dactyl.setNodeVisible(toolbar, false), ({ item }) => !Dactyl.isToolbarHidden(item)); toolbarCommand(["toolbart[oggle]", "tbt[oggle]"], "Toggle the named toolbar", toolbar => dactyl.setNodeVisible(toolbar, Dactyl.isToolbarHidden(toolbar))); } commands.add(["time"], "Profile a piece of code or run a command multiple times", function (args) { let count = args.count; let special = args.bang; args = args[0] || ""; if (args[0] == ":") var func = () => commands.execute(args, null, false); else func = dactyl.userFunc(args); try { if (count > 1) { let each, eachUnits, totalUnits; let total = 0; for (let i of util.interruptibleRange(0, count, 500)) { let now = Date.now(); func(); total += Date.now() - now; } if (special) return; if (total / count >= 100) { each = total / 1000.0 / count; eachUnits = "sec"; } else { each = total / count; eachUnits = "msec"; } if (total >= 100) { total = total / 1000.0; totalUnits = "sec"; } else totalUnits = "msec"; commandline.commandOutput( ["table", {} ["tr", { highlight: "Title", align: "left" }, ["th", { colspan: "3" }, _("title.Code execution summary")]], ["tr", {}, ["td", {}, _("title.Executed"), ":"], ["td", { align: "right" }, ["span", { class: "times-executed" }, count]], ["td", {}, /*L*/"times"]], ["tr", {}, ["td", {}, _("title.Average time"), ":"], ["td", { align: "right" }, ["span", { class: "time-average" }, each.toFixed(2)]], ["td", {}, eachUnits]], ["tr", {}, ["td", {}, _("title.Total time"), ":"], ["td", { align: "right" }, ["span", { class: "time-total" }, total.toFixed(2)]], ["td", {}, totalUnits]]]); } else { let beforeTime = Date.now(); func(); if (special) return; let afterTime = Date.now(); if (afterTime - beforeTime >= 100) dactyl.echo(_("time.total", ((afterTime - beforeTime) / 1000.0).toFixed(2) + " sec")); else dactyl.echo(_("time.total", (afterTime - beforeTime) + " msec")); } } catch (e) { dactyl.echoerr(e); } }, { argCount: "1", bang: true, completer: function (context) { if (/^:/.test(context.filter)) completion.ex(context); else completion.javascript(context); }, count: true, hereDoc: true, literal: 0, subCommand: 0 }); commands.add(["verb[ose]"], "Execute a command with 'verbose' set", function (args) { let vbs = options.get("verbose"); let value = vbs.value; let setFrom = vbs.setFrom; try { vbs.set(args.count || 1); vbs.setFrom = null; dactyl.execute(args[0] || "", null, true); } finally { vbs.set(value); vbs.setFrom = setFrom; } }, { argCount: "1", completer: function (context) { completion.ex(context); }, count: true, literal: 0, subCommand: 0 }); commands.add(["ve[rsion]"], "Show version information", function (args) { if (args.bang) dactyl.open("about:"); else { let date = config.buildDate; date = date ? " (" + date + ")" : ""; commandline.commandOutput([ ["div", {}, [config.appName, " ", config.version, date, " running on: "].join("")], ["div", {}, [window.navigator.userAgent].join("")] ]); } }, { argCount: "0", bang: true }); }, completion: function initCompletion() { completion.dialog = function dialog(context) { context.title = ["Dialog"]; context.filters.push(({ item }) => !item[2] || item[2]()); context.completions = ( Object.entries(config.dialogs) .map(([k, v]) => [k, v[0], v[2]])); }; completion.menuItem = function menuItem(context) { context.title = ["Menu Path", "Label"]; context.anchored = false; context.keys = { text: "dactylPath", description: item => item.getAttribute("label"), highlight: item => item.disabled ? "Disabled" : "", }; context.generate = () => dactyl.menuItems; }; completion.toolbar = function toolbar(context) { context.title = ["Toolbar"]; context.keys = { text: Dactyl.getToolbarName, description: () => "", }; context.completions = config.toolbars; }; completion.window = function window(context) { context.title = ["Window", "Title"]; context.keys = { text: win => dactyl.windows.indexOf(win) + 1, description: win => win.document.title }; context.completions = dactyl.windows; }; }, load: function initLoad() { dactyl.triggerObserver("load"); dactyl.log(_("dactyl.modulesLoaded"), 3); userContext.DOM = Class("DOM", DOM, { init(sel, ctxt) { return DOM(sel, ctxt || buffer.focusedFrame.document); } }); userContext.$ = modules.userContext.DOM; // Hack: disable disabling of Personas in private windows. let root = document.documentElement; if (PrivateBrowsingUtils && PrivateBrowsingUtils.isWindowPrivate(window) && root._lightweightTheme && root._lightweightTheme._lastScreenWidth == null) { dactyl.withSavedValues.call(PrivateBrowsingUtils, ["isWindowPrivate"], () => { PrivateBrowsingUtils.isWindowPrivate = () => false; Cu.import("resource://gre/modules/LightweightThemeConsumer.jsm", {}) .LightweightThemeConsumer.call(root._lightweightTheme, document); }); } if (config.has("default-theme") && "CustomizableUI" in window && config.tabbrowser.tabContainer.orient != "vertical") overlay.overlayWindow(window, { append: [ ["window", { id: document.documentElement.id, "dactyl-australis": "true", xmlns: "xul" }]] }); dactyl.timeout(function () { try { var args = config.prefs.get("commandline-args") || storage.session.commandlineArgs || services.commandLineHandler.optionValue; config.prefs.reset("commandline-args"); if (isString(args)) args = dactyl.parseCommandLine(args); if (args) { dactyl.commandLineOptions.rcFile = args["+u"]; dactyl.commandLineOptions.noPlugins = "++noplugin" in args; dactyl.commandLineOptions.postCommands = args["+c"]; dactyl.commandLineOptions.preCommands = args["++cmd"]; util.dump("Processing command-line option: " + args.string); } } catch (e) { dactyl.echoerr(_("dactyl.parsingCommandLine", e)); } dactyl.log(_("dactyl.commandlineOpts", util.objectToString(dactyl.commandLineOptions)), 3); if (config.prefs.get("first-run", true)) dactyl.timeout(function () { config.prefs.set("first-run", false); this.withSavedValues(["forceTarget"], function () { this.forceTarget = dactyl.NEW_TAB; help.help(); }); }, 1000); // TODO: we should have some class where all this guioptions stuff fits well // dactyl.hideGUI(); if (dactyl.userEval("typeof document", null, "test.js") === "undefined") jsmodules.__proto__ = window; if (dactyl.commandLineOptions.preCommands) dactyl.commandLineOptions.preCommands.forEach(function (cmd) { dactyl.execute(cmd); }); // finally, read the RC file and source plugins let init = services.environment.get(config.idName + "_INIT"); let rcFile = io.getRCFile("~"); try { if (dactyl.commandLineOptions.rcFile) { let filename = dactyl.commandLineOptions.rcFile; if (!/^(NONE|NORC)$/.test(filename)) io.source(io.File(filename).path, { group: contexts.user }); } else { if (init) dactyl.execute(init); else { if (rcFile) { io.source(rcFile.path, { group: contexts.user }); services.environment.set("MY_" + config.idName + "RC", rcFile.path); } else dactyl.log(_("dactyl.noRCFile"), 3); } if (options["exrc"] && !dactyl.commandLineOptions.rcFile) { let localRCFile = io.getRCFile(io.cwd); if (localRCFile && !localRCFile.equals(rcFile)) io.source(localRCFile.path, { group: contexts.user }); } } if (dactyl.commandLineOptions.rcFile == "NONE" || dactyl.commandLineOptions.noPlugins) options["loadplugins"] = []; if (options["loadplugins"].length) dactyl.loadPlugins(); } catch (e) { dactyl.reportError(e, true); } // after sourcing the initialization files, this function will set // all gui options to their default values, if they have not been // set before by any RC file for (let option of options.needInit) option.initValue(); if (dactyl.commandLineOptions.postCommands) dactyl.commandLineOptions.postCommands.forEach(function (cmd) { dactyl.execute(cmd); }); if (storage.session.rehashCmd) dactyl.execute(storage.session.rehashCmd); storage.session.rehashCmd = null; dactyl.fullyInitialized = true; dactyl.triggerObserver("enter", null); autocommands.trigger("Enter", {}); }, 100); statusline.update(); dactyl.log(_("dactyl.initialized", config.appName), 0); dactyl.initialized = true; util.delay(() => { if (services.focus.activeWindow === window) overlay.activeWindow = window; util.flushLateMethods(dactyl); }); } }); // vim: set fdm=marker sw=4 sts=4 ts=8 et: ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������dactyl-1.2~r20151231/common/content/editor.js�������������������������������������������������������0000664�0000000�0000000�00000154623�12641473761�0020647�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Copyright (c) 2008-2015 Kris Maglione <maglione.k at Gmail> // Copyright (c) 2006-2009 by Martin Stubenschrott <stubenschrott@vimperator.org> // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; /** @scope modules */ // command names taken from: // http://developer.mozilla.org/en/docs/Editor_Embedding_Guide /** @instance editor */ var Editor = Module("editor", XPCOM(Ci.nsIEditActionListener, ModuleBase), { init: function init(elem) { if (elem) this.element = elem; else this.__defineGetter__("element", () => { let elem = dactyl.focusedElement; if (elem) return elem.inputField || elem; let win = document.commandDispatcher.focusedWindow; return DOM(win).isEditable && win || null; }); }, get registers() { return storage.newMap("registers", { privateData: true, store: true }); }, get registerRing() { return storage.newArray("register-ring", { privateData: true, store: true }); }, skipSave: false, // Fixme: Move off this object. currentRegister: null, /** * Temporarily set the default register for the span of the next * mapping. */ pushRegister: function pushRegister(arg) { let restore = this.currentRegister; this.currentRegister = arg; mappings.afterCommands(2, function () { this.currentRegister = restore; }, this); }, defaultRegister: "*+", selectionRegisters: { "*": "selection", "+": "global" }, /** * Get the value of the register *name*. * * @param {string|number} name The name of the register to get. * @returns {string|null} * @see #setRegister */ getRegister: function getRegister(name) { if (name == null) name = editor.currentRegister || editor.defaultRegister; name = String(name)[0]; if (name == '"') name = 0; if (name == "_") var res = null; else if (hasOwnProp(this.selectionRegisters, name)) res = { text: dactyl.clipboardRead(this.selectionRegisters[name]) || "" }; else if (!/^[0-9]$/.test(name)) res = this.registers.get(name); else res = this.registerRing.get(name); return res != null ? res.text : res; }, /** * Sets the value of register *name* to value. The following * registers have special semantics: * * * - Tied to the PRIMARY selection value on X11 systems. * + - Tied to the primary global clipboard. * _ - The null register. Never has any value. * " - Equivalent to 0. * 0-9 - These act as a kill ring. Setting any of them pushes the * values of higher numbered registers up one slot. * * @param {string|number} name The name of the register to set. * @param {string|Range|Selection|Node} value The value to save to * the register. */ setRegister: function setRegister(name, value, verbose) { if (name == null) name = editor.currentRegister || editor.defaultRegister; if (isinstance(value, [Ci.nsIDOMRange, Ci.nsIDOMNode, Ci.nsISelection])) value = DOM.stringify(value); value = { text: value, isLine: modes.extended & modes.LINE, timestamp: Date.now() * 1000 }; for (let n of String(name)) { if (n == '"') n = 0; if (n == "_") ; else if (hasOwnProp(this.selectionRegisters, n)) dactyl.clipboardWrite(value.text, verbose, this.selectionRegisters[n]); else if (!/^[0-9]$/.test(n)) this.registers.set(n, value); else { this.registerRing.insert(value, n); this.registerRing.truncate(10); } } }, get isCaret() { return modes.getStack(1).main == modes.CARET; }, get isTextEdit() { return modes.getStack(1).main == modes.TEXT_EDIT; }, get editor() { return DOM(this.element).editor; }, getController: function getController(cmd) { let controllers = this.element && this.element.controllers; dactyl.assert(controllers); return controllers.getControllerForCommand(cmd || "cmd_beginLine"); }, get selection() { return this.editor && this.editor.selection || null; }, get selectionController() { return this.editor && this.editor.selectionController || null; }, deselect: function () { if (this.selection && this.selection.focusNode) this.selection.collapse(this.selection.focusNode, this.selection.focusOffset); }, get selectedRange() { if (!this.selection) return null; if (!this.selection.rangeCount) { let range = RangeFind.nodeContents(this.editor.rootElement.ownerDocument); range.collapse(true); this.selectedRange = range; } return this.selection.getRangeAt(0); }, set selectedRange(range) { this.selection.removeAllRanges(); if (range != null) this.selection.addRange(range); }, get selectedText() { return String(this.selection); }, get preserveSelection() { return this.editor && !this.editor.shouldTxnSetSelection; }, set preserveSelection(val) { if (this.editor) this.editor.setShouldTxnSetSelection(!val); }, copy: function copy(range, name) { range = range || this.selection; if (!range.collapsed) this.setRegister(name, range); }, cut: function cut(range, name, noStrip) { if (range) this.selectedRange = range; if (!this.selection.isCollapsed) this.setRegister(name, this.selection); this.editor.deleteSelection(0, this.editor[noStrip ? "eNoStrip" : "eStrip"]); }, paste: function paste(name) { let text = this.getRegister(name); dactyl.assert(text && this.editor instanceof Ci.nsIPlaintextEditor); this.editor.insertText(text); }, // count is optional, defaults to 1 executeCommand: function executeCommand(cmd, count) { if (!callable(cmd)) { var controller = this.getController(cmd); util.assert(controller && controller.supportsCommand(cmd) && controller.isCommandEnabled(cmd)); cmd = bind("doCommand", controller, cmd); } // XXX: better as a precondition if (count == null) count = 1; let didCommand = false; while (count--) { // some commands need this try/catch workaround, because a cmd_charPrevious triggered // at the beginning of the textarea, would hang the doCommand() // good thing is, we need this code anyway for proper beeping // What huh? --Kris try { cmd(this.editor, controller); didCommand = true; } catch (e) { util.reportError(e); dactyl.assert(didCommand); break; } } }, moveToPosition: function (pos, select) { if (isObject(pos)) var { startContainer, startOffset } = pos; else [startOffset, startOffset] = [this.selection.focusNode, pos]; this.selection[select ? "extend" : "collapse"](startContainer, startOffset); }, mungeRange: function mungeRange(range, munger, selectEnd) { let { editor } = this; editor.beginPlaceHolderTransaction(null); let [container, offset] = ["startContainer", "startOffset"]; if (selectEnd) [container, offset] = ["endContainer", "endOffset"]; try { // :( let idx = range[offset]; let parent = range[container].parentNode; let parentIdx = Array.indexOf(parent.childNodes, range[container]); let delta = 0; for (let node of Editor.TextsIterator(range)) { let text = node.textContent; let start = 0, end = text.length; if (node == range.startContainer) start = range.startOffset; if (node == range.endContainer) end = range.endOffset; if (start == 0 && end == text.length) text = munger(text); else text = text.slice(0, start) + munger(text.slice(start, end)) + text.slice(end); if (text == node.textContent) continue; if (selectEnd) delta = text.length - node.textContent.length; if (editor instanceof Ci.nsIPlaintextEditor) { this.selectedRange = RangeFind.nodeContents(node); editor.insertText(text); } else node.textContent = text; } let node = parent.childNodes[parentIdx]; if (node instanceof Text) idx = Math.constrain(idx + delta, 0, node.textContent.length); this.selection.collapse(node, idx); } finally { editor.endPlaceHolderTransaction(); } }, findChar: function findChar(key, count, backward, offset) { count = count || 1; // XXX ? offset = (offset || 0) - !!backward; // Grab the charcode of the key spec. Using the key name // directly will break keys like < let code = DOM.Event.parse(key)[0].charCode; let char = String.fromCharCode(code); util.assert(code); let range = this.selectedRange.cloneRange(); let collapse = DOM(this.element).whiteSpace == "normal"; // Find the *count*th occurance of *char* before a non-collapsed // \n, ignoring the character at the caret. let i = 0; function test(c) { return (collapse || c != "\n") && !!(!i++ || c != char || --count); } Editor.extendRange(range, !backward, { test: test }, true); dactyl.assert(count == 0); range.collapse(backward); // Skip to any requested offset. count = Math.abs(offset); Editor.extendRange(range, offset > 0, { test: c => !!count-- }, true); range.collapse(offset < 0); return range; }, findNumber: function findNumber(range) { if (!range) range = this.selectedRange.cloneRange(); // Find digit (or \n). Editor.extendRange(range, true, /[^\n\d]/, true); range.collapse(false); // Select entire number. Editor.extendRange(range, true, /\d/, true); Editor.extendRange(range, false, /\d/, true); // Sanity check. dactyl.assert(/^\d+$/.test(range)); if (false) // Skip for now. if (range.startContainer instanceof Text && range.startOffset > 2) { if (range.startContainer.textContent.substr(range.startOffset - 2, 2) == "0x") range.setStart(range.startContainer, range.startOffset - 2); } // Grab the sign, if it's there. Editor.extendRange(range, false, /[+-]/, true); return range; }, modifyNumber: function modifyNumber(delta, range) { range = this.findNumber(range); let number = parseInt(range) + delta; if (/^[+-]?0x/.test(range)) number = number.toString(16).replace(/^[+-]?/, "$&0x"); else if (/^[+-]?0\d/.test(range)) number = number.toString(8).replace(/^[+-]?/, "$&0"); this.selectedRange = range; this.editor.insertText(String(number)); this.selection.modify("move", "backward", "character"); }, /** * Edits the given file in the external editor as specified by the * 'editor' option. * * @param {object|File|string} args An object specifying the file, line, * and column to edit. If a non-object is specified, it is treated as * the file parameter of the object. * @param {boolean} blocking If true, this function does not return * until the editor exits. */ editFileExternally: function (args, blocking) { if (!isObject(args) || args instanceof File) args = { file: args }; args.file = args.file.path || args.file; args = options.get("editor").format(args); dactyl.assert(args.length >= 1, _("option.notSet", "editor")); return io.run(args.shift(), args, blocking); }, // TODO: clean up with 2 functions for textboxes and currentEditor? editFieldExternally: function editFieldExternally(forceEditing) { if (!options["editor"]) return; let textBox = config.isComposeWindow ? null : dactyl.focusedElement; if (!DOM(textBox).isInput) textBox = null; let line, column; let keepFocus = modes.stack.some(m => isinstance(m.main, modes.COMMAND_LINE)); if (!forceEditing && textBox && textBox.type == "password") { commandline.input(_("editor.prompt.editPassword") + " ") .then(function (resp) { if (resp && resp.match(/^y(es)?$/i)) editor.editFieldExternally(true); }); return; } if (textBox) { var text = textBox.value; var pre = text.substr(0, textBox.selectionStart); } else { var editor_ = window.GetCurrentEditor ? GetCurrentEditor() : Editor.getEditor(document.commandDispatcher.focusedWindow); dactyl.assert(editor_); text = Array.map(editor_.rootElement.childNodes, e => DOM.stringify(e, true)) .join(""); if (!editor_.selection.rangeCount) var sel = ""; else { let range = RangeFind.nodeContents(editor_.rootElement); let end = editor_.selection.getRangeAt(0); range.setEnd(end.startContainer, end.startOffset); pre = DOM.stringify(range, true); if (range.startContainer instanceof Text) pre = pre.replace(/^(?:<[^>"]+>)+/, ""); if (range.endContainer instanceof Text) pre = pre.replace(/(?:<\/[^>"]+>)+$/, ""); } } line = 1 + pre.replace(/[^\n]/g, "").length; column = 1 + pre.replace(/[^]*\n/, "").length; let origGroup = DOM(textBox).highlight.toString(); let cleanup = promises.task(function* cleanup(error) { if (timer) timer.cancel(); let blink = ["EditorBlink1", "EditorBlink2"]; if (error) { dactyl.reportError(error, true); blink[1] = "EditorError"; } else dactyl.trapErrors(update, null, true); if (tmpfile && tmpfile.exists()) tmpfile.remove(false); if (textBox) { DOM(textBox).highlight.remove("EditorEditing"); if (!keepFocus) dactyl.focus(textBox); for (let group of blink.concat(blink, "")) { highlight.highlightNode(textBox, origGroup + " " + group); yield promises.sleep(100); } } }); function update(force) { if (force !== true && tmpfile.lastModifiedTime <= lastUpdate) return; lastUpdate = Date.now(); let val = tmpfile.read(); if (textBox) { textBox.value = val; if (true) { let elem = DOM(textBox); elem.attrNS(NS, "modifiable", true) .style.MozUserInput; elem.input().attrNS(NS, "modifiable", null); } } else { while (editor_.rootElement.firstChild) editor_.rootElement.removeChild(editor_.rootElement.firstChild); editor_.rootElement.innerHTML = val; } } try { var tmpfile = io.createTempFile("txt", "." + buffer.uri.host); if (!tmpfile) throw Error(_("io.cantCreateTempFile")); if (textBox) { if (!keepFocus) textBox.blur(); DOM(textBox).highlight.add("EditorEditing"); } if (!tmpfile.write(text)) throw Error(_("io.cantEncode")); var lastUpdate = Date.now(); var timer = services.Timer(update, 100, services.Timer.TYPE_REPEATING_SLACK); this.editFileExternally({ file: tmpfile.path, line: line, column: column }, cleanup); } catch (e) { cleanup(e); } }, /** * Expands an abbreviation in the currently active textbox. * * @param {string} mode The mode filter. * @see Abbreviation#expand */ expandAbbreviation: function (mode) { if (!this.selection) return; let range = this.selectedRange.cloneRange(); if (!range.collapsed) return; Editor.extendRange(range, false, /\S/, true); let abbrev = abbreviations.match(mode, String(range)); if (abbrev) { range.setStart(range.startContainer, range.endOffset - abbrev.lhs.length); this.selectedRange = range; this.editor.insertText(abbrev.expand(this.element)); } }, // nsIEditActionListener: WillDeleteNode: util.wrapCallback(function WillDeleteNode(node) { if (!editor.skipSave && node.textContent) this.setRegister(0, node); }), WillDeleteSelection: util.wrapCallback(function WillDeleteSelection(selection) { if (!editor.skipSave && !selection.isCollapsed) this.setRegister(0, selection); }), WillDeleteText: util.wrapCallback(function WillDeleteText(node, start, length) { if (!editor.skipSave && length) this.setRegister(0, node.textContent.substr(start, length)); }) }, { TextsIterator: Class("TextsIterator", { init: function init(range, context, after) { this.after = after; this.start = context || range[after ? "endContainer" : "startContainer"]; if (after) this.context = this.start; this.range = range; }, "@@iterator": function* __iterator__() { while (this.nextNode()) yield this.context; }, prevNode: function prevNode() { if (!this.context) return this.context = this.start; var node = this.context; if (!this.after) node = node.previousSibling; if (!node) node = this.context.parentNode; else while (node.lastChild) node = node.lastChild; if (!node || !RangeFind.containsNode(this.range, node, true)) return null; this.after = false; return this.context = node; }, nextNode: function nextNode() { if (!this.context) return this.context = this.start; if (!this.after) var node = this.context.firstChild; if (!node) { node = this.context; while (node.parentNode && node != this.range.endContainer && !node.nextSibling) node = node.parentNode; node = node.nextSibling; } if (!node || !RangeFind.containsNode(this.range, node, true)) return null; this.after = false; return this.context = node; }, getPrev: function getPrev() { return this.filter("prevNode"); }, getNext: function getNext() { return this.filter("nextNode"); }, filter: function filter(meth) { let node; while (node = this[meth]()) if (node instanceof Ci.nsIDOMText && DOM(node).isVisible && DOM(node).style.MozUserSelect != "none") return node; } }), extendRange: function extendRange(range, forward, re, sameWord, root, end) { function advance(positive) { while (true) { while (idx == text.length && (node = iterator.getNext())) { if (node == iterator.start) idx = range[offset]; start = text.length; text += node.textContent; range[set](node, idx - start); } if (idx >= text.length || re.test(text[idx]) != positive) break; range[set](range[container], ++idx - start); } } function retreat(positive) { while (true) { while (idx == 0 && (node = iterator.getPrev())) { let str = node.textContent; if (node == iterator.start) idx = range[offset]; else idx = str.length; text = str + text; range[set](node, idx); } if (idx == 0 || re.test(text[idx - 1]) != positive) break; range[set](range[container], --idx); } } if (end == null) end = forward ? "end" : "start"; let [container, offset, set] = [end + "Container", end + "Offset", "set" + util.capitalize(end)]; if (!root) for (root = range[container]; root.parentNode instanceof Element && !DOM(root).isEditable; root = root.parentNode) ; if (root instanceof Ci.nsIDOMNSEditableElement) root = root.editor; if (root instanceof Ci.nsIEditor) root = root.rootElement; let node = range[container]; let iterator = Editor.TextsIterator(RangeFind.nodeContents(root), node, !forward); let text = ""; let idx = 0; let start = 0; if (forward) { advance(true); if (!sameWord) advance(false); } else { if (!sameWord) retreat(false); retreat(true); } return range; }, getEditor: function (elem) { if (arguments.length === 0) { dactyl.assert(dactyl.focusedElement); return dactyl.focusedElement; } if (!elem) elem = dactyl.focusedElement || document.commandDispatcher.focusedWindow; dactyl.assert(elem); return DOM(elem).editor; } }, { modes: function initModes() { modes.addMode("OPERATOR", { char: "o", description: "Mappings which move the cursor", bases: [] }); modes.addMode("VISUAL", { char: "v", description: "Active when text is selected", display: function () { return "VISUAL" + (this._extended & modes.LINE ? " LINE" : ""); }, bases: [modes.COMMAND], ownsFocus: true }, { enter: function (stack) { if (editor.selectionController) editor.selectionController.setCaretVisibilityDuringSelection(true); }, leave: function (stack, newMode) { if (newMode.main == modes.CARET) { let selection = content.getSelection(); if (selection && !selection.isCollapsed) selection.collapseToStart(); } else if (stack.pop) editor.deselect(); } }); modes.addMode("TEXT_EDIT", { char: "t", description: "Vim-like editing of input elements", bases: [modes.COMMAND], ownsFocus: true }, { onKeyPress: function (eventList) { const KILL = false, PASS = true; // Hack, really. if (eventList[0].charCode || /^<(?:.-)*(?:BS|Del|C-h|C-w|C-u|C-k)>$/.test(DOM.Event.stringify(eventList[0]))) { dactyl.beep(); return KILL; } return PASS; } }); modes.addMode("INSERT", { char: "i", description: "Active when an input element is focused", insert: true, ownsFocus: true }); modes.addMode("AUTOCOMPLETE", { description: "Active when an input autocomplete pop-up is active", display: function () { return "AUTOCOMPLETE (insert)"; }, bases: [modes.INSERT] }); }, commands: function initCommands() { commands.add(["reg[isters]"], "List the contents of known registers", function (args) { completion.listCompleter("register", args[0]); }, { argCount: "*" }); }, completion: function initCompletion() { completion.register = function complete_register(context) { context = context.fork("registers"); context.keys = { text: identity, description: editor.bound.getRegister }; context.match = function (r) { return !this.filter || this.filter.includes(r); }; context.fork("clipboard", 0, this, ctxt => { ctxt.match = context.match; ctxt.title = ["Clipboard Registers"]; ctxt.completions = Object.keys(editor.selectionRegisters); }); context.fork("kill-ring", 0, this, ctxt => { ctxt.match = context.match; ctxt.title = ["Kill Ring Registers"]; ctxt.completions = Array.slice("0123456789"); }); context.fork("user", 0, this, ctxt => { ctxt.match = context.match; ctxt.title = ["User Defined Registers"]; ctxt.completions = editor.registers.keys(); }); }; }, mappings: function initMappings() { Map.types["editor"] = { preExecute: function preExecute(args) { if (editor.editor && !this.editor) { this.editor = editor.editor; if (!this.noTransaction) this.editor.beginTransaction(); } editor.inEditMap = true; }, postExecute: function preExecute(args) { editor.inEditMap = false; if (this.editor) { if (!this.noTransaction) this.editor.endTransaction(); this.editor = null; } } }; Map.types["operator"] = { preExecute: function preExecute(args) { editor.inEditMap = true; }, postExecute: function preExecute(args) { editor.inEditMap = true; if (modes.main == modes.OPERATOR) modes.pop(); } }; // add mappings for commands like h,j,k,l,etc. in CARET, VISUAL and TEXT_EDIT mode function addMovementMap(keys, description, hasCount, caretModeMethod, caretModeArg, textEditCommand, visualTextEditCommand) { let extra = { count: !!hasCount, type: "operator" }; function caretExecute(arg) { let win = document.commandDispatcher.focusedWindow; let controller = util.selectionController(win); let sel = controller.getSelection(controller.SELECTION_NORMAL); let buffer = Buffer(win); if (!sel.rangeCount) // Hack. buffer.resetCaret(); if (caretModeMethod == "pageMove") { // Grr. buffer.scrollVertical("pages", caretModeArg ? 1 : -1); buffer.resetCaret(); } else controller[caretModeMethod](caretModeArg, arg); } mappings.add([modes.VISUAL], keys, description, function ({ count }) { count = count || 1; let caret = !dactyl.focusedElement; while (count-- && modes.main == modes.VISUAL) { if (caret) caretExecute(true, true); else { if (callable(visualTextEditCommand)) visualTextEditCommand(editor.editor); else editor.executeCommand(visualTextEditCommand); } } }, extra); mappings.add([modes.CARET, modes.TEXT_EDIT, modes.OPERATOR], keys, description, function ({ count }) { count = count || 1; if (editor.editor) editor.executeCommand(textEditCommand, count); else { while (count--) caretExecute(false); } }, extra); } // add mappings for commands like i,a,s,c,etc. in TEXT_EDIT mode function addBeginInsertModeMap(keys, commands, description) { mappings.add([modes.TEXT_EDIT], keys, description || "", function () { commands.forEach(function (cmd) { editor.executeCommand(cmd, 1); }); modes.push(modes.INSERT); }, { type: "editor" }); } function selectPreviousLine() { editor.executeCommand("cmd_selectLinePrevious"); if ((modes.extended & modes.LINE) && !editor.selectedText) editor.executeCommand("cmd_selectLinePrevious"); } function selectNextLine() { editor.executeCommand("cmd_selectLineNext"); if ((modes.extended & modes.LINE) && !editor.selectedText) editor.executeCommand("cmd_selectLineNext"); } function updateRange(editor, forward, re, modify, sameWord) { let sel = editor.selection; let range = sel.getRangeAt(0); let end = range.endContainer == sel.focusNode && range.endOffset == sel.focusOffset; if (range.collapsed) end = forward; Editor.extendRange(range, forward, re, sameWord, editor.rootElement, end ? "end" : "start"); modify(range); editor.selectionController.repaintSelection(editor.selectionController.SELECTION_NORMAL); } function clear(forward, re) { return function _clear(editor) { updateRange(editor, forward, re, range => {}); dactyl.assert(!editor.selection.isCollapsed); editor.selection.deleteFromDocument(); let parent = DOM(editor.rootElement.parentNode); if (parent.isInput) parent.input(); }; } function move(forward, re, sameWord) { return function _move(editor) { updateRange(editor, forward, re, range => { range.collapse(!forward); }, sameWord); }; } function select(forward, re) { return function _select(editor) { updateRange(editor, forward, re, range => {}); }; } function beginLine(editor_) { editor.executeCommand("cmd_beginLine"); move(true, /\s/, true)(editor_); } // COUNT CARET TEXT_EDIT VISUAL_TEXT_EDIT addMovementMap(["k", "<Up>"], "Move up one line", true, "lineMove", false, "cmd_linePrevious", selectPreviousLine); addMovementMap(["j", "<Down>", "<Return>"], "Move down one line", true, "lineMove", true, "cmd_lineNext", selectNextLine); addMovementMap(["h", "<Left>", "<BS>"], "Move left one character", true, "characterMove", false, "cmd_charPrevious", "cmd_selectCharPrevious"); addMovementMap(["l", "<Right>", "<Space>"], "Move right one character", true, "characterMove", true, "cmd_charNext", "cmd_selectCharNext"); addMovementMap(["b", "<C-Left>"], "Move left one word", true, "wordMove", false, move(false, /\w/), select(false, /\w/)); addMovementMap(["w", "<C-Right>"], "Move right one word", true, "wordMove", true, move(true, /\w/), select(true, /\w/)); addMovementMap(["B"], "Move left to the previous white space", true, "wordMove", false, move(false, /\S/), select(false, /\S/)); addMovementMap(["W"], "Move right to just beyond the next white space", true, "wordMove", true, move(true, /\S/), select(true, /\S/)); addMovementMap(["e"], "Move to the end of the current word", true, "wordMove", true, move(true, /\W/), select(true, /\W/)); addMovementMap(["E"], "Move right to the next white space", true, "wordMove", true, move(true, /\s/), select(true, /\s/)); addMovementMap(["<C-f>", "<PageDown>"], "Move down one page", true, "pageMove", true, "cmd_movePageDown", "cmd_selectNextPage"); addMovementMap(["<C-b>", "<PageUp>"], "Move up one page", true, "pageMove", false, "cmd_movePageUp", "cmd_selectPreviousPage"); addMovementMap(["gg", "<C-Home>"], "Move to the start of text", false, "completeMove", false, "cmd_moveTop", "cmd_selectTop"); addMovementMap(["G", "<C-End>"], "Move to the end of text", false, "completeMove", true, "cmd_moveBottom", "cmd_selectBottom"); addMovementMap(["0", "<Home>"], "Move to the beginning of the line", false, "intraLineMove", false, "cmd_beginLine", "cmd_selectBeginLine"); addMovementMap(["^"], "Move to the first non-whitespace character of the line", false, "intraLineMove", false, beginLine, "cmd_selectBeginLine"); addMovementMap(["$", "<End>"], "Move to the end of the current line", false, "intraLineMove", true, "cmd_endLine" , "cmd_selectEndLine"); addBeginInsertModeMap(["i", "<Insert>"], [], "Insert text before the cursor"); addBeginInsertModeMap(["a"], ["cmd_charNext"], "Append text after the cursor"); addBeginInsertModeMap(["I"], ["cmd_beginLine"], "Insert text at the beginning of the line"); addBeginInsertModeMap(["A"], ["cmd_endLine"], "Append text at the end of the line"); addBeginInsertModeMap(["s"], ["cmd_deleteCharForward"], "Delete the character in front of the cursor and start insert"); addBeginInsertModeMap(["S"], ["cmd_deleteToEndOfLine", "cmd_deleteToBeginningOfLine"], "Delete the current line and start insert"); addBeginInsertModeMap(["C"], ["cmd_deleteToEndOfLine"], "Delete from the cursor to the end of the line and start insert"); function addMotionMap(key, desc, select, cmd, mode, caretOk) { function doTxn(range, editor) { try { editor.editor.beginTransaction(); cmd(editor, range, editor.editor); } finally { editor.editor.endTransaction(); } } mappings.add([modes.TEXT_EDIT], key, desc, function ({ command, count, motion }) { let start = editor.selectedRange.cloneRange(); mappings.pushCommand(); modes.push(modes.OPERATOR, null, { forCommand: command, count: count, leave: function leave(stack) { try { if (stack.push || stack.fromEscape) return; editor.withSavedValues(["inEditMap"], function () { this.inEditMap = true; let range = RangeFind.union(start, editor.selectedRange); editor.selectedRange = select ? range : start; doTxn(range, editor); }); editor.currentRegister = null; modes.delay(function () { if (mode) modes.push(mode); }); } finally { if (!stack.push) mappings.popCommand(); } } }); }, { count: true, type: "motion" }); mappings.add([modes.VISUAL], key, desc, function ({ count, motion }) { dactyl.assert(caretOk || editor.isTextEdit); if (editor.isTextEdit) doTxn(editor.selectedRange, editor); else cmd(editor, buffer.selection.getRangeAt(0)); }, { count: true, type: "motion" }); } addMotionMap(["d", "x"], "Delete text", true, function (editor) { editor.cut(); }); addMotionMap(["c"], "Change text", true, function (editor) { editor.cut(null, null, true); }, modes.INSERT); addMotionMap(["y"], "Yank text", false, function (editor, range) { editor.copy(range); }, null, true); addMotionMap(["gu"], "Lowercase text", false, function (editor, range) { editor.mungeRange(range, String.toLocaleLowerCase); }); addMotionMap(["gU"], "Uppercase text", false, function (editor, range) { editor.mungeRange(range, String.toLocaleUpperCase); }); mappings.add([modes.OPERATOR], ["c", "d", "y"], "Select the entire line", function ({ command, count }) { dactyl.assert(command == modes.getStack(0).params.forCommand); let sel = editor.selection; sel.modify("move", "backward", "lineboundary"); sel.modify("extend", "forward", "lineboundary"); if (command != "c") sel.modify("extend", "forward", "character"); }, { count: true, type: "operator" }); let bind = function bind(names, description, action, params) { mappings.add([modes.INPUT], names, description, action, update({ type: "editor" }, params)); }; bind(["<C-w>"], "Delete previous word", function () { if (editor.editor) clear(false, /\w/)(editor.editor); else editor.executeCommand("cmd_deleteWordBackward", 1); }); bind(["<C-u>"], "Delete until beginning of current line", function () { // Deletes the whole line. What the hell. // editor.executeCommand("cmd_deleteToBeginningOfLine", 1); editor.executeCommand("cmd_selectBeginLine", 1); if (editor.selection && editor.selection.isCollapsed) { editor.executeCommand("cmd_deleteCharBackward", 1); editor.executeCommand("cmd_selectBeginLine", 1); } if (editor.getController("cmd_delete").isCommandEnabled("cmd_delete")) editor.executeCommand("cmd_delete", 1); }); bind(["<C-k>"], "Delete until end of current line", function () { editor.executeCommand("cmd_deleteToEndOfLine", 1); }); bind(["<C-a>"], "Move cursor to beginning of current line", function () { editor.executeCommand("cmd_beginLine", 1); }); bind(["<C-e>"], "Move cursor to end of current line", function () { editor.executeCommand("cmd_endLine", 1); }); bind(["<C-h>"], "Delete character to the left", function () { events.feedkeys("<BS>", true); }); bind(["<C-d>"], "Delete character to the right", function () { editor.executeCommand("cmd_deleteCharForward", 1); }); bind(["<S-Insert>"], "Insert clipboard/selection", function () { editor.paste(); }); bind(["<C-i>"], "Edit text field with an external editor", function () { editor.editFieldExternally(); }); bind(["<C-t>"], "Edit text field in Text Edit mode", function () { dactyl.assert(!editor.isTextEdit && editor.editor); if (!dactyl.focusedElement) { // Sites like Google like to use a // hidden, editable window for keyboard // focus and use their own WYSIWYG editor // implementations for the visible area, // which we can't handle. let f = document.commandDispatcher.focusedWindow.frameElement; dactyl.assert(f && Hints.isVisible(f, true)); } modes.push(modes.TEXT_EDIT); }); // Ugh. mappings.add([modes.INPUT, modes.CARET], ["<*-CR>", "<*-BS>", "<*-Del>", "<*-Left>", "<*-Right>", "<*-Up>", "<*-Down>", "<*-Home>", "<*-End>", "<*-PageUp>", "<*-PageDown>", "<M-c>", "<M-v>", "<*-Tab>"], "Handled by " + config.host, () => Events.PASS, { passThrough: true }); mappings.add([modes.INSERT], ["<Space>", "<Return>"], "Expand Insert mode abbreviation", function () { editor.expandAbbreviation(modes.INSERT); return Events.PASS; }, { passThrough: true }); mappings.add([modes.INSERT], ["<C-]>", "<C-5>"], "Expand Insert mode abbreviation", function () { editor.expandAbbreviation(modes.INSERT); }); bind = function bind(names, description, action, params) { mappings.add([modes.TEXT_EDIT], names, description, action, update({ type: "editor" }, params)); }; bind(["<C-a>"], "Increment the next number", function ({ count }) { editor.modifyNumber(count || 1); }, { count: true }); bind(["<C-x>"], "Decrement the next number", function ({ count }) { editor.modifyNumber(-(count || 1)); }, { count: true }); // text edit mode bind(["u"], "Undo changes", function ({ count }) { editor.editor.undo(Math.max(count, 1)); editor.deselect(); }, { count: true, noTransaction: true }); bind(["<C-r>"], "Redo undone changes", function ({ count }) { editor.editor.redo(Math.max(count, 1)); editor.deselect(); }, { count: true, noTransaction: true }); bind(["D"], "Delete characters from the cursor to the end of the line", function () { editor.executeCommand("cmd_deleteToEndOfLine"); }); bind(["o"], "Open line below current", function () { editor.executeCommand("cmd_endLine", 1); modes.push(modes.INSERT); events.feedkeys("<Return>"); }); bind(["O"], "Open line above current", function () { editor.executeCommand("cmd_beginLine", 1); modes.push(modes.INSERT); events.feedkeys("<Return>"); editor.executeCommand("cmd_linePrevious", 1); }); bind(["X"], "Delete character to the left", function (args) { editor.executeCommand("cmd_deleteCharBackward", Math.max(args.count, 1)); }, { count: true }); bind(["x"], "Delete character to the right", function (args) { editor.executeCommand("cmd_deleteCharForward", Math.max(args.count, 1)); }, { count: true }); // visual mode mappings.add([modes.CARET, modes.TEXT_EDIT], ["v"], "Start Visual mode", function () { modes.push(modes.VISUAL); }); mappings.add([modes.VISUAL], ["v", "V"], "End Visual mode", function () { modes.pop(); }); bind(["V"], "Start Visual Line mode", function () { modes.push(modes.VISUAL, modes.LINE); editor.executeCommand("cmd_beginLine", 1); editor.executeCommand("cmd_selectLineNext", 1); }); mappings.add([modes.VISUAL], ["s"], "Change selected text", function () { dactyl.assert(editor.isTextEdit); editor.executeCommand("cmd_cut"); modes.push(modes.INSERT); }); mappings.add([modes.VISUAL], ["o"], "Move cursor to the other end of the selection", function () { if (editor.isTextEdit) var selection = editor.selection; else selection = buffer.focusedFrame.getSelection(); util.assert(selection.focusNode); let { focusOffset, anchorOffset, focusNode, anchorNode } = selection; selection.collapse(focusNode, focusOffset); selection.extend(anchorNode, anchorOffset); }); bind(["p"], "Paste clipboard contents", function ({ count }) { dactyl.assert(!editor.isCaret); editor.executeCommand(modules.bind("paste", editor, null), count || 1); }, { count: true }); mappings.add([modes.COMMAND], ['"'], "Bind a register to the next command", function ({ arg }) { editor.pushRegister(arg); }, { arg: true }); mappings.add([modes.INPUT], ["<C-'>", '<C-">'], "Bind a register to the next command", function ({ arg }) { editor.pushRegister(arg); }, { arg: true }); bind = function bind(names, description, action, params) { mappings.add([modes.TEXT_EDIT, modes.OPERATOR, modes.VISUAL], names, description, action, update({ type: "editor" }, params)); }; // finding characters function offset(backward, before, pos) { if (!backward && modes.main != modes.TEXT_EDIT) return before ? 0 : 1; if (before) return backward ? +1 : -1; return 0; } bind(["f"], "Find a character on the current line, forwards", function ({ arg, count }) { editor.moveToPosition(editor.findChar(arg, Math.max(count, 1), false, offset(false, false)), modes.main == modes.VISUAL); }, { arg: true, count: true, type: "operator" }); bind(["F"], "Find a character on the current line, backwards", function ({ arg, count }) { editor.moveToPosition(editor.findChar(arg, Math.max(count, 1), true, offset(true, false)), modes.main == modes.VISUAL); }, { arg: true, count: true, type: "operator" }); bind(["t"], "Find a character on the current line, forwards, and move to the character before it", function ({ arg, count }) { editor.moveToPosition(editor.findChar(arg, Math.max(count, 1), false, offset(false, true)), modes.main == modes.VISUAL); }, { arg: true, count: true, type: "operator" }); bind(["T"], "Find a character on the current line, backwards, and move to the character after it", function ({ arg, count }) { editor.moveToPosition(editor.findChar(arg, Math.max(count, 1), true, offset(true, true)), modes.main == modes.VISUAL); }, { arg: true, count: true, type: "operator" }); // text edit and visual mode mappings.add([modes.TEXT_EDIT, modes.VISUAL], ["~"], "Switch case of the character under the cursor and move the cursor to the right", function ({ count }) { function munger(range) { return String(range).replace(/./g, c => { let lc = c.toLocaleLowerCase(); return c == lc ? c.toLocaleUpperCase() : lc; }); } var range = editor.selectedRange; if (range.collapsed) { count = count || 1; Editor.extendRange(range, true, { test: c => !!count-- }, true); } editor.mungeRange(range, munger, count != null); modes.pop(modes.TEXT_EDIT); }, { count: true }); bind = function bind(...args) { apply(mappings, "add", [[modes.AUTOCOMPLETE]].concat(args)); }; bind(["<Esc>"], "Return to Insert mode", () => Events.PASS_THROUGH); bind(["<C-[>"], "Return to Insert mode", function () { events.feedkeys("<Esc>", { skipmap: true }); }); bind(["<Up>"], "Select the previous autocomplete result", () => Events.PASS_THROUGH); bind(["<C-p>"], "Select the previous autocomplete result", function () { events.feedkeys("<Up>", { skipmap: true }); }); bind(["<Down>"], "Select the next autocomplete result", () => Events.PASS_THROUGH); bind(["<C-n>"], "Select the next autocomplete result", function () { events.feedkeys("<Down>", { skipmap: true }); }); }, options: function initOptions() { options.add(["editor"], "The external text editor", "string", 'gvim -f +<line> +"sil! call cursor(0, <column>)" <file>', { format: function (obj, value) { let args = commands.parseArgs(value || this.value, { argCount: "*", allowUnknownOptions: true }) .map(util.compileMacro) .filter(fmt => fmt.valid(obj)) .map(fmt => fmt(obj)); if (obj["file"] && !this.has("file")) args.push(obj["file"]); return args; }, has: function (key) { return util.compileMacro(this.value).seen.has(key); }, validator: function (value) { this.format({}, value); let allowed = new RealSet(["column", "file", "line"]); return util.compileMacro(value) .seen.difference(allowed) .size == 0; } }); options.add(["insertmode", "im"], "Enter Insert mode rather than Text Edit mode when focusing text areas", "boolean", true); options.add(["spelllang", "spl"], "The language used by the spell checker", "string", config.locale, { initValue: function () {}, getter: function getter() { try { return services.spell.dictionary || ""; } catch (e) { return ""; } }, setter: function setter(val) { services.spell.dictionary = val; }, completer: function completer(context) { let res = {}; services.spell.getDictionaryList(res, {}); context.completions = res.value; context.keys = { text: identity, description: identity }; } }); }, sanitizer: function initSanitizer() { sanitizer.addItem("registers", { description: "Register values", persistent: true, action: function (timespan, host) { if (!host) { for (let [k, v] of editor.registers) if (timespan.contains(v.timestamp)) editor.registers.remove(k); editor.registerRing.truncate(0); } } }); } }); // vim: set fdm=marker sw=4 sts=4 ts=8 et: �������������������������������������������������������������������������������������������������������������dactyl-1.2~r20151231/common/content/eval.js���������������������������������������������������������0000664�0000000�0000000�00000000722�12641473761�0020276�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������try { __dactyl_eval_result = eval(__dactyl_eval_string); } catch (e) { __dactyl_eval_error = e; } // IMPORTANT: The eval statement *must* remain on the first line // in order for line numbering in any errors to remain correct. // Copyright (c) 2008-2012 Kris Maglione <maglione.k at Gmail> // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. // vim: set fdm=marker sw=4 sts=4 ts=8 et: ����������������������������������������������dactyl-1.2~r20151231/common/content/events.js�������������������������������������������������������0000664�0000000�0000000�00000132301�12641473761�0020652�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Copyright (c) 2006-2008 by Martin Stubenschrott <stubenschrott@vimperator.org> // Copyright (c) 2007-2011 by Doug Kearns <dougkearns@gmail.com> // Copyright (c) 2008-2015 Kris Maglione <maglione.k at Gmail> // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; /** @scope modules */ /** * A hive used mainly for tracking event listeners and cleaning them up when a * group is destroyed. */ var EventHive = Class("EventHive", Contexts.Hive, { init: function init(group) { init.supercall(this, group); this.sessionListeners = []; }, cleanup: function cleanup() { this.unlisten(null); }, _events: function _events(event, callback) { if (isObject(event)) var [self, events] = [event, event[callback || "events"]]; else [self, events] = [null, { [event]: callback }]; if (hasOwnProp(events, "input") && !hasOwnProp(events, "dactyl-input")) events["dactyl-input"] = events.input; return [self, events]; }, /** * Adds an event listener for this session and removes it on * dactyl shutdown. * * @param {Element} target The element on which to listen. * @param {string} event The event to listen for. * @param {function} callback The function to call when the event is received. * @param {boolean} capture When true, listen during the capture * phase, otherwise during the bubbling phase. * @param {boolean} allowUntrusted When true, allow capturing of * untrusted events. */ listen: function (target, event, callback, capture, allowUntrusted) { var [self, events] = this._events(event, callback); for (let [event, callback] of iter(events)) { let args = [util.weakReference(target), util.weakReference(self), event, this.wrapListener(callback, self), capture, allowUntrusted]; apply(target, "addEventListener", args.slice(2)); this.sessionListeners.push(args); } }, /** * Remove an event listener. * * @param {Element} target The element on which to listen. * @param {string} event The event to listen for. * @param {function} callback The function to call when the event is received. * @param {boolean} capture When true, listen during the capture * phase, otherwise during the bubbling phase. */ unlisten: function (target, event, callback, capture) { if (target != null) var [self, events] = this._events(event, callback); this.sessionListeners = this.sessionListeners.filter(function (args) { let elem = args[0].get(); if (target == null || elem == target && self == args[1].get() && hasOwnProp(events, args[2]) && args[3].wrapped == events[args[2]] && args[4] == capture) { apply(elem, "removeEventListener", args.slice(2)); return false; } return elem; }); }, get wrapListener() { return events.bound.wrapListener; } }); /** * @instance events */ var Events = Module("events", { dbg: function (...args) { util.dump(...args); }, debug: false, init: function () { this.keyEvents = []; overlay.overlayWindow(window, { append: [ ["window", { id: document.documentElement.id, xmlns: "xul" }, // http://developer.mozilla.org/en/docs/XUL_Tutorial:Updating_Commands ["commandset", { id: "dactyl-onfocus", commandupdater: "true", events: "focus", commandupdate: this.bound.onFocusChange }], ["commandset", { id: "dactyl-onselect", commandupdater: "true", events: "select", commandupdate: this.bound.onSelectionChange }]]] }); this._fullscreen = window.fullScreen; this._lastFocus = { get: function () { return null; } }; this._macroKeys = []; this._lastMacro = ""; this._macros = storage.newMap("registers", { privateData: true, store: true }); if (storage.exists("macros")) { for (let [k, m] of storage.newMap("macros", { store: true })) this._macros.set(k, { text: m.keys, timestamp: m.timeRecorded * 1000 }); storage.remove("macros"); } this.popups = { active: [], activeMenubar: null, update: function update(elem) { if (elem) { if (elem instanceof Ci.nsIAutoCompletePopup || elem.localName == "tooltip" || !elem.popupBoxObject) return; if (!~this.active.indexOf(elem)) this.active.push(elem); } this.active = this.active.filter(e => e.popupBoxObject && e.popupBoxObject.popupState != "closed"); if (!this.active.length && !this.activeMenubar) modes.remove(modes.MENU, true); else if (modes.main != modes.MENU) modes.push(modes.MENU); }, events: { DOMMenuBarActive: function onDOMMenuBarActive(event) { this.activeMenubar = event.target; if (modes.main != modes.MENU) modes.push(modes.MENU); }, DOMMenuBarInactive: function onDOMMenuBarInactive(event) { this.activeMenubar = null; modes.remove(modes.MENU, true); }, popupshowing: function onPopupShowing(event) { this.update(event.originalTarget); }, popupshown: function onPopupShown(event) { let elem = event.originalTarget; this.update(elem); if (elem instanceof Ci.nsIAutoCompletePopup) { if (modes.main != modes.AUTOCOMPLETE) modes.push(modes.AUTOCOMPLETE); } else if (elem.hidePopup && elem.localName !== "tooltip" && Events.isHidden(elem) && Events.isHidden(elem.parentNode)) { elem.hidePopup(); } }, popuphidden: function onPopupHidden(event) { this.update(); modes.remove(modes.AUTOCOMPLETE); } } }; this.listen(window, this, "events", true); this.listen(window, this.popups, "events", true); this.grabFocus = 0; this.grabFocusTimer = Timer(100, 10000, () => { this.grabFocus = 0; }); }, cleanup: function cleanup() { let elem = dactyl.focusedElement; if (DOM(elem).isEditable) util.trapErrors("removeEditActionListener", DOM(elem).editor, editor); }, signals: { "browser.locationChange": function (webProgress, request, uri) { options.get("passkeys").flush(); }, "modes.change": function (oldMode, newMode) { delete this.processor; } }, get listen() { return this.builtin.bound.listen; }, addSessionListener: deprecated("events.listen", { get: function addSessionListener() { return this.listen; } }), /** * Wraps an event listener to ensure that errors are reported. */ wrapListener: function wrapListener(method, self=this) { method.wrapper = wrappedListener; wrappedListener.wrapped = method; function wrappedListener(event) { try { method.apply(self, arguments); } catch (e) { dactyl.reportError(e); if (e.message == "Interrupted") dactyl.echoerr(_("error.interrupted"), commandline.FORCE_SINGLELINE); else dactyl.echoerr(_("event.error", event.type, e.echoerr || e), commandline.FORCE_SINGLELINE); } }; return wrappedListener; }, /** * @property {boolean} Whether synthetic key events are currently being * processed. */ feedingKeys: false, /** * Initiates the recording of a key event macro. * * @param {string} macro The name for the macro. */ _recording: null, get recording() { return this._recording; }, set recording(macro) { dactyl.assert(macro == null || /[a-zA-Z0-9]/.test(macro), _("macro.invalid", macro)); modes.recording = macro; if (/[A-Z]/.test(macro)) { // Append. macro = macro.toLowerCase(); this._macroKeys = DOM.Event.iterKeys(editor.getRegister(macro)) .toArray(); } else if (macro) { // Record afresh. this._macroKeys = []; } else if (this.recording) { // Save. editor.setRegister(this.recording, this._macroKeys.join("")); dactyl.log(_("macro.recorded", this.recording, this._macroKeys.join("")), 9); dactyl.echomsg(_("macro.recorded", this.recording)); } this._recording = macro || null; }, /** * Replays a macro. * * @param {string} The name of the macro to replay. * @returns {boolean} */ playMacro: function (macro) { dactyl.assert(/^[a-zA-Z0-9@]$/.test(macro), _("macro.invalid", macro)); if (macro == "@") dactyl.assert(this._lastMacro, _("macro.noPrevious")); else this._lastMacro = macro.toLowerCase(); // XXX: sets last played macro, even if it does not yet exist let keys = editor.getRegister(this._lastMacro); if (keys) return modes.withSavedValues(["replaying"], function () { this.replaying = true; return events.feedkeys(keys, { noremap: true }); }); // TODO: ignore this like Vim? dactyl.echoerr(_("macro.noSuch", this._lastMacro)); return false; }, /** * Returns all macros matching *filter*. * * @param {string} filter A regular expression filter string. A null * filter selects all macros. */ getMacros: function (filter = null) { let re = RegExp(filter || ""); return Array.from(editor.registers, ([key, macro]) => [key, macro.text]) .filter(([key]) => re.test(key)); }, /** * Deletes all macros matching *filter*. * * @param {string} filter A regular expression filter string. A null * filter deletes all macros. */ deleteMacros: function (filter) { let re = RegExp(filter || ""); for (let [item, ] of editor.registers) { if (!filter || re.test(item)) editor.registers.remove(item); } }, /** * Feeds a list of events to *target* or the originalTarget member * of each event if *target* is null. * * @param {EventTarget} target The destination node for the events. * @optional * @param {[Event]} list The events to dispatch. * @param {object} extra Extra properties for processing by dactyl. * @optional */ feedevents: function feedevents(target, list, extra) { list.forEach(function _feedevent(event, i) { let elem = target || event.originalTarget; if (elem) { let doc = elem.ownerDocument || elem.document || elem; let evt = DOM.Event(doc, event.type, event); DOM.Event.dispatch(elem, evt, extra); } else if (i > 0 && event.type === "keypress") events.events.keypress.call(events, event); }); }, /** * Pushes keys onto the event queue from dactyl. It is similar to * Vim's feedkeys() method, but cannot cope with 2 partially-fed * strings, you have to feed one parseable string. * * @param {string} keys A string like "2<C-f>" to push onto the event * queue. If you want "<" to be taken literally, prepend it with a * "\\". * @param {boolean} noremap Whether recursive mappings should be * disallowed. * @param {boolean} silent Whether the command should be echoed to the * command line. * @returns {boolean} */ feedkeys: function (keys, noremap, quiet, mode) { try { var savedEvents = this._processor && this._processor.keyEvents; var wasFeeding = this.feedingKeys; this.feedingKeys = true; var wasQuiet = commandline.quiet; if (quiet) commandline.quiet = quiet; for (let evt_obj of DOM.Event.parse(keys)) { let key = DOM.Event.stringify(evt_obj); for (let type of ["keydown", "keypress", "keyup"]) { let evt = update({}, evt_obj, { type: type }); if (type !== "keypress" && !evt.keyCode) evt.keyCode = evt._keyCode || 0; if (isObject(noremap)) update(evt, noremap); else evt.noremap = !!noremap; evt.isMacro = true; evt.dactylMode = mode; evt.dactylSavedEvents = savedEvents; DOM.Event.feedingEvent = evt; let doc = document.commandDispatcher.focusedWindow.document; let target = dactyl.focusedElement || ["complete", "interactive"].indexOf(doc.readyState) >= 0 && doc.documentElement || doc.defaultView; if (target instanceof Element && !Events.isInputElement(target) && ["<Return>", "<Space>"].indexOf(key) == -1) target = target.ownerDocument.documentElement; let event = DOM.Event(doc, type, evt); if (!evt_obj.dactylString && !mode) DOM.Event.dispatch(target, event, evt); else if (type === "keypress") events.events.keypress.call(events, event); } if (!this.feedingKeys) return false; } } catch (e) { util.reportError(e); } finally { DOM.Event.feedingEvent = null; this.feedingKeys = wasFeeding; if (quiet) commandline.quiet = wasQuiet; dactyl.triggerObserver("events.doneFeeding"); } return true; }, canonicalKeys: deprecated("DOM.Event.canonicalKeys", { get: function canonicalKeys() { return DOM.Event.bound.canonicalKeys; } }), create: deprecated("DOM.Event", function create() { return DOM.Event.apply(null, arguments); }), dispatch: deprecated("DOM.Event.dispatch", function dispatch() { return apply(DOM.Event, "dispatch", arguments); }), fromString: deprecated("DOM.Event.parse", { get: function fromString() { return DOM.Event.bound.parse; } }), iterKeys: deprecated("DOM.Event.iterKeys", { get: function iterKeys() { return DOM.Event.bound.iterKeys; } }), toString: function toString() { if (!arguments.length) return toString.supercall(this); deprecated.warn(toString, "toString", "DOM.Event.stringify"); return apply(DOM.Event, "stringify", arguments); }, get defaultTarget() { return dactyl.focusedElement || content.document.body || document.documentElement; }, /** * Returns true if there's a known native key handler for the given * event in the given mode. * * @param {Event} event A keypress event. * @param {Modes.Mode} mode The main mode. * @param {boolean} passUnknown Whether unknown keys should be passed. */ hasNativeKey: function hasNativeKey(event, mode, passUnknown) { if (mode.input && event.charCode && !(event.ctrlKey || event.metaKey)) return true; if (!passUnknown) return false; var elements = document.getElementsByTagNameNS(XUL, "key"); var filters = []; if (event.keyCode) filters.push(["keycode", this._code_nativeKey[event.keyCode]]); if (event.charCode) { let key = String.fromCharCode(event.charCode); filters.push(["key", key.toUpperCase()], ["key", key.toLowerCase()]); } let accel = config.OS.isMacOSX ? "metaKey" : "ctrlKey"; let access = iter({ 1: "shiftKey", 2: "ctrlKey", 4: "altKey", 8: "metaKey" }) .filter(function ([k, v]) { return this & k; }, prefs.get("ui.key.chromeAccess")) // XXX .map(([k, v]) => [v, true]) .toObject(); outer: for (let key of elements) if (filters.some(([k, v]) => key.getAttribute(k) == v)) { let keys = { ctrlKey: false, altKey: false, shiftKey: false, metaKey: false }; let needed = { ctrlKey: event.ctrlKey, altKey: event.altKey, shiftKey: event.shiftKey, metaKey: event.metaKey }; let modifiers = (key.getAttribute("modifiers") || "").trim().split(/[\s,]+/); for (let modifier of modifiers) switch (modifier) { case "access": update(keys, access); break; case "accel": keys[accel] = true; break; default: keys[modifier + "Key"] = true; break; case "any": if (!iter(keys).some(([k, v]) => v && needed[k])) continue outer; for (let [k, v] of iter(keys)) { if (v) needed[k] = false; keys[k] = false; } break; } if (iter(needed).every(([k, v]) => (v == keys[k]))) return key; } return false; }, /** * Returns true if *key* is a key code defined to accept/execute input on * the command line. * * @param {string} key The key code to test. * @returns {boolean} */ isAcceptKey: function (key) { return key == "<Return>" || key == "<C-j>" || key == "<C-m>"; }, /** * Returns true if *key* is a key code defined to reject/cancel input on * the command line. * * @param {string} key The key code to test. * @returns {boolean} */ isCancelKey: function (key) { return key == "<Esc>" || key == "<C-[>" || key == "<C-c>"; }, /** * Returns true if *node* belongs to the current content document or any * sub-frame thereof. * * @param {Node|Document|Window} node The node to test. * @returns {boolean} */ isContentNode: function isContentNode(node) { let win = (node.ownerDocument || node).defaultView || node; return XPCNativeWrapper(win).top == content; }, /** * Waits for the current buffer to successfully finish loading. Returns * true for a successful page load otherwise false. * * @returns {boolean} */ waitForPageLoad: function (time) { if (buffer.loaded) return true; dactyl.echo(_("macro.loadWaiting"), commandline.FORCE_SINGLELINE); const maxWaitTime = (time || 25); util.waitFor(() => buffer.loaded, this, maxWaitTime * 1000, true); dactyl.echo("", commandline.FORCE_SINGLELINE); if (!buffer.loaded) dactyl.echoerr(_("macro.loadFailed", maxWaitTime)); return buffer.loaded; }, /** * Ensures that the currently focused element is visible and blurs * it if it's not. */ checkFocus: function () { if (dactyl.focusedElement) { let rect = dactyl.focusedElement.getBoundingClientRect(); if (!rect.width || !rect.height) { services.focus.clearFocus(window); document.commandDispatcher.focusedWindow = content; // onFocusChange needs to die. this.onFocusChange(); } } }, events: { blur: function onBlur(event) { let elem = event.originalTarget; if (DOM(elem).editor) util.trapErrors("removeEditActionListener", DOM(elem).editor, editor); if (elem instanceof Window && services.focus.activeWindow == null && document.commandDispatcher.focusedWindow !== window) { // Deals with circumstances where, after the main window // blurs while a collapsed frame has focus, re-activating // the main window does not restore focus and we lose key // input. services.focus.clearFocus(window); document.commandDispatcher.focusedWindow = Editor.getEditor(content) ? window : content; } let hold = modes.topOfStack.params.holdFocus; if (elem == hold) { dactyl.focus(hold); this.timeout(function () { dactyl.focus(hold); }); } }, // TODO: Merge with onFocusChange focus: function onFocus(event) { let elem = event.originalTarget; if (DOM(elem).editor) util.trapErrors("addEditActionListener", DOM(elem).editor, editor); if (elem == window) overlay.activeWindow = window; overlay.setData(elem, "had-focus", true); if (event.target instanceof Ci.nsIDOMXULTextBoxElement) if (Events.isHidden(elem, true)) elem.blur(); let win = (elem.ownerDocument || elem).defaultView || elem; if (!Cu.isCrossProcessWrapper(win) && !(services.focus.getLastFocusMethod(win) & 0x3000) && events.isContentNode(elem) && !buffer.focusAllowed(elem) && isinstance(elem, [Ci.nsIDOMHTMLInputElement, Ci.nsIDOMHTMLSelectElement, Ci.nsIDOMHTMLTextAreaElement, Ci.nsIDOMWindow])) { if (this.grabFocus++ > 5) ; // Something is fighting us. Give up. else { this.grabFocusTimer.tell(); if (elem.frameElement) dactyl.focusContent(true); else if (!(elem instanceof Window) || Editor.getEditor(elem)) dactyl.focus(window); } } if (elem instanceof Element) delete overlay.getData(elem)["focus-allowed"]; }, input: function onInput(event) { event.originalTarget.dactylKeyPress = undefined; }, // this keypress handler gets always called first, even if e.g. // the command-line has focus keypress: function onKeyPress(event) { event.dactylDefaultPrevented = event.defaultPrevented; let duringFeed = this.duringFeed || []; this.duringFeed = []; try { let ourEvent = DOM.Event.feedingEvent; DOM.Event.feedingEvent = null; if (ourEvent) for (let [k, v] of iter(ourEvent)) if (!(k in event)) event[k] = v; let key = DOM.Event.stringify(ourEvent || event); event.dactylString = key; // Hack to deal with <BS> and so forth not dispatching input // events if (key && event.originalTarget instanceof Ci.nsIDOMHTMLInputElement && !modes.main.passthrough) { let elem = event.originalTarget; elem.dactylKeyPress = elem.value; util.timeout(function () { if (elem.dactylKeyPress !== undefined && elem.value !== elem.dactylKeyPress) DOM(elem).dactylInput(); elem.dactylKeyPress = undefined; }); } if (!key) return null; if (modes.recording && !event.isReplay) events._macroKeys.push(key); // feedingKeys needs to be separate from interrupted so // we can differentiate between a recorded <C-c> // interrupting whatever it's started and a real <C-c> // interrupting our playback. if (events.feedingKeys && !event.isMacro) { if (key == "<C-c>") { events.feedingKeys = false; if (modes.replaying) { modes.replaying = false; this.timeout(function () { dactyl.echomsg(_("macro.canceled", this._lastMacro)); }, 100); } } else duringFeed.push(event); return Events.kill(event); } if (this.processor) { if (events.debug) events.dbg("ON KEYPRESS " + key + " processor: " + this.processor, event.originalTarget instanceof Element ? event.originalTarget : String(event.originalTarget)); } else { let mode = modes.getStack(0); if (event.dactylMode) mode = Modes.StackElement(event.dactylMode); let ignore = false; if (mode.main == modes.PASS_THROUGH) ignore = !Events.isEscape(key) && key != "<C-v>"; else if (mode.main == modes.QUOTE) { if (modes.getStack(1).main == modes.PASS_THROUGH) { mode = Modes.StackElement(modes.getStack(2).main); ignore = Events.isEscape(key); } else if (events.shouldPass(event)) mode = Modes.StackElement(modes.getStack(1).main); else ignore = true; modes.pop(); } else if (!event.isMacro && !event.noremap && events.shouldPass(event)) ignore = true; if (events.debug) { events.dbg("\n\n"); events.dbg("ON KEYPRESS " + key + " ignore: " + ignore, event.originalTarget instanceof Element ? event.originalTarget : String(event.originalTarget)); } if (ignore) return null; // FIXME: Why is this hard coded? --Kris if (key == "<C-c>") util.interrupted = true; this.processor = ProcessorStack(mode, mappings.hives.array, event.noremap); this.processor.keyEvents = this.keyEvents; } let { keyEvents, processor } = this; this._processor = processor; this.processor = null; this.keyEvents = []; if (!processor.process(event)) { this.keyEvents = keyEvents; this.processor = processor; } } catch (e) { dactyl.reportError(e); } finally { [duringFeed, this.duringFeed] = [this.duringFeed, duringFeed]; if (this.feedingKeys) this.duringFeed = this.duringFeed.concat(duringFeed); else for (let event of duringFeed) try { DOM.Event.dispatch(event.originalTarget, event, event); } catch (e) { util.reportError(e); } } }, keyup: function onKeyUp(event) { if (event.type == "keydown") this.keyEvents.push(event); else if (!this.processor) this.keyEvents = []; let key = DOM.Event.stringify(event); let hasCandidates = mode => { return mappings.hives.some(hive => (hive.get(mode, key, true) || hive.getCandidates(mode, key, true))); }; let pass = (() => { if (this.passing && !event.isMacro) return true; if (DOM.Event.feedingEvent && DOM.Event.feedingEvent.isReplay) return true; if (event.isReplay) return true; if (modes.main == modes.PASS_THROUGH) return true; if (modes.main == modes.QUOTE && modes.getStack(1).main !== modes.PASS_THROUGH && !this.shouldPass(event)) return true; if (!modes.passThrough && this.shouldPass(event)) return true; if (!this.processor && event.type === "keydown" && options.get("passunknown").getKey(modes.main.allBases)) { if (modes.main.count && /^\d$/.test(key)) return false; if (modes.main.allBases.some(hasCandidates)) return false; return true; } return false; })(); if (events.debug) events.dbg("ON " + event.type.toUpperCase() + " " + key + " passing: " + this.passing + " " + " pass: " + pass + " replay: " + event.isReplay + " macro: " + event.isMacro); if (event.type === "keydown") this.passing = pass; // Prevents certain sites from transferring focus to an input box // before we get a chance to process our key bindings on the // "keypress" event. if (!pass && Cu.getClassName(event, true) !== "Proxy") event.stopPropagation(); }, keydown: function onKeyDown(event) { if (!event.isMacro) this.passing = false; this.events.keyup.call(this, event); }, mousedown: function onMouseDown(event) { let elem = event.target; let win = elem.ownerDocument && elem.ownerDocument.defaultView || elem; for (; win; win = win != win.parent && win.parent) { for (; elem instanceof Element; elem = elem.parentNode) overlay.setData(elem, "focus-allowed", true); overlay.setData(win.document, "focus-allowed", true); } }, resize: function onResize(event) { if (window.fullScreen != this._fullscreen) { statusline.statusBar.removeAttribute("moz-collapsed"); this._fullscreen = window.fullScreen; dactyl.triggerObserver("fullscreen", this._fullscreen); autocommands.trigger("Fullscreen", { url: this._fullscreen ? "on" : "off", state: this._fullscreen }); } statusline.updateZoomLevel(); } }, onFocusChange: util.wrapCallback(function onFocusChange(event) { function hasHTMLDocument(win) { return win && win.document && win.document instanceof Ci.nsIDOMHTMLDocument; } if (dactyl.ignoreFocus) return; let win = window.document.commandDispatcher.focusedWindow; let elem = window.document.commandDispatcher.focusedElement; if (elem == null && Editor.getEditor(win)) elem = win; if (win && win.top == content && dactyl.has("tabs")) buffer.focusedFrame = win; try { if (elem && elem.readOnly) return; if (isinstance(elem, [Ci.nsIDOMHTMLEmbedElement, Ci.nsIDOMHTMLEmbedElement])) { if (!modes.main.passthrough && modes.main != modes.EMBED) modes.push(modes.EMBED); return; } let haveInput = modes.stack.some(m => m.main.input); if (DOM(elem || win).isEditable) { let e = elem || win; if (!(e instanceof Ci.nsIDOMWindow && DOM(e.document.activeElement).style.MozUserModify != "read-write")) { if (!haveInput) if (!isinstance(modes.main, [modes.INPUT, modes.TEXT_EDIT, modes.VISUAL])) if (options["insertmode"]) modes.push(modes.INSERT); else { modes.push(modes.TEXT_EDIT); if (elem.selectionEnd - elem.selectionStart > 0) modes.push(modes.VISUAL); } if (hasHTMLDocument(win)) buffer.lastInputField = elem || win; return; } } if (elem && Events.isInputElement(elem)) { if (!haveInput) modes.push(modes.INSERT); if (hasHTMLDocument(win)) buffer.lastInputField = elem; return; } if (config.focusChange) { config.focusChange(win); return; } let urlbar = document.getElementById("urlbar"); if (elem == null && urlbar && urlbar.inputField == this._lastFocus.get()) util.threadYield(true); // Why? --Kris let ownsFocus = () => { if (!modes.main.ownsFocus) return false; let { ownsFocus } = modes.topOfStack.params; if (ownsFocus && ~[elem, win].indexOf(ownsFocus.get())) return false; return !modes.topOfStack.params.holdFocus; }; while (ownsFocus()) modes.pop(null, { fromFocus: true }); } finally { this._lastFocus = util.weakReference(elem); if (modes.main.ownsFocus) modes.topOfStack.params.ownsFocus = util.weakReference(elem); } }), onSelectionChange: function onSelectionChange(event) { // Ignore selection events caused by editor commands. if (editor.inEditMap || modes.main == modes.OPERATOR) return; let controller = document.commandDispatcher.getControllerForCommand("cmd_copy"); let couldCopy = controller && controller.isCommandEnabled("cmd_copy"); if (couldCopy) { if (modes.main == modes.TEXT_EDIT) modes.push(modes.VISUAL); else if (modes.main == modes.CARET) modes.push(modes.VISUAL); } }, shouldPass: function shouldPass(event) { return !event.noremap && (!dactyl.focusedElement || events.isContentNode(dactyl.focusedElement)) && options.get("passkeys").has(DOM.Event.stringify(event)); } }, { ABORT: {}, KILL: true, PASS: false, PASS_THROUGH: {}, WAIT: null, isEscape: function isEscape(event) { let key = isString(event) ? event : DOM.Event.stringify(event); return key === "<Esc>" || key === "<C-[>"; }, isHidden: function isHidden(elem, aggressive) { if (DOM(elem).style.visibility !== "visible") return true; if (aggressive) for (let e = elem; e instanceof Element; e = e.parentNode) { if (!/set$/.test(e.localName) && e.boxObject && e.boxObject.height === 0) return true; else if (e.namespaceURI == XUL && e.localName === "panel") break; } return false; }, isInputElement: function isInputElement(elem) { return elem instanceof Ci.nsIDOMElement && DOM(elem).isEditable || isinstance(elem, [Ci.nsIDOMHTMLEmbedElement, Ci.nsIDOMHTMLObjectElement, Ci.nsIDOMHTMLSelectElement]); }, kill: function kill(event) { event.stopPropagation(); event.preventDefault(); } }, { contexts: function initContexts(dactyl, modules, window) { update(Events.prototype, { hives: contexts.Hives("events", EventHive), user: contexts.hives.events.user, builtin: contexts.hives.events.builtin }); }, commands: function initCommands() { commands.add(["delmac[ros]"], "Delete macros", function (args) { dactyl.assert(!args.bang || !args[0], _("error.invalidArgument")); if (args.bang) events.deleteMacros(); else if (args[0]) events.deleteMacros(args[0]); else dactyl.echoerr(_("error.argumentRequired")); }, { argCount: "?", bang: true, completer: function (context) { completion.macro(context); }, literal: 0 }); commands.add(["mac[ros]"], "List all macros", function (args) { completion.listCompleter("macro", args[0]); }, { argCount: "?", completer: function (context) { completion.macro(context); } }); }, completion: function initCompletion() { completion.macro = function macro(context) { context.title = ["Macro", "Keys"]; context.completions = Array.from(events.getMacros()); }; }, mappings: function initMappings() { mappings.add([modes.MAIN], ["<A-b>", "<pass-next-key-builtin>"], "Process the next key as a builtin mapping", function () { events.processor = ProcessorStack(modes.getStack(0), mappings.hives.array, true); events.processor.keyEvents = events.keyEvents; }); mappings.add([modes.MAIN], ["<C-z>", "<pass-all-keys>"], "Temporarily ignore all " + config.appName + " key bindings", function () { if (modes.main != modes.PASS_THROUGH) modes.push(modes.PASS_THROUGH); }); mappings.add([modes.MAIN, modes.PASS_THROUGH, modes.QUOTE], ["<C-v>", "<pass-next-key>"], "Pass through next key", function () { if (modes.main == modes.QUOTE) return Events.PASS; modes.push(modes.QUOTE); }); mappings.add([modes.BASE], ["<CapsLock>"], "Do Nothing", function () {}); mappings.add([modes.BASE], ["<Nop>"], "Do nothing", function () {}); mappings.add([modes.BASE], ["<Pass>"], "Pass the events consumed by the last executed mapping", function ({ keypressEvents: [event] }) { dactyl.assert(event.dactylSavedEvents, _("event.nothingToPass")); return () => { events.feedevents(null, event.dactylSavedEvents, { skipmap: true, isMacro: true, isReplay: true }); }; }); // macros mappings.add([modes.COMMAND], ["q", "<record-macro>"], "Record a key sequence into a macro", function ({ arg }) { util.assert(arg == null || /^[a-z]$/i.test(arg)); events._macroKeys.pop(); events.recording = arg; }, { get arg() { return !modes.recording; }}); mappings.add([modes.COMMAND], ["@", "<play-macro>"], "Play a macro", function ({ arg, count }) { count = Math.max(count, 1); while (count--) events.playMacro(arg); }, { arg: true, count: true }); mappings.add([modes.COMMAND], ["<A-m>s", "<sleep>"], "Sleep for {count} milliseconds before continuing macro playback", function ({ command, count }) { dactyl.assert(count, _("error.countRequired", command)); if (events.feedingKeys) util.sleep(count); }, { count: true }); mappings.add([modes.COMMAND], ["<A-m>l", "<wait-for-page-load>"], "Wait for the current page to finish loading before continuing macro playback", function ({ count }) { if (events.feedingKeys && !events.waitForPageLoad(count)) { util.interrupted = true; throw Error("Interrupted"); } }, { count: true }); }, options: function initOptions() { const Hive = Class("Hive", { init: function init(values, map) { this.name = "passkeys:" + map; this.stack = MapHive.Stack(values.map(v => Map(v[map + "Keys"]))); function Map(keys) { return { execute: function () { return Events.PASS_THROUGH; }, keys: keys }; } }, get active() { return this.stack.length; }, get: function get(mode, key) { return this.stack.mappings[key]; }, getCandidates: function getCandidates(mode, key) { return this.stack.candidates[key]; } }); options.add(["passkeys", "pk"], "Pass certain keys through directly for the given URLs", "sitemap", "", { flush: function flush() { memoize(this, "filters", function () { return this.value.filter(f => f(buffer.documentURI)); }); memoize(this, "pass", function () { return new RealSet(this.filters.flatMap(f => f.keys)); }); memoize(this, "commandHive", function hive() { return Hive(this.filters, "command"); }); memoize(this, "inputHive", function hive() { return Hive(this.filters, "input"); }); }, has: function (key) { return this.pass.has(key) || hasOwnProp(this.commandHive.stack.mappings, key); }, get pass() { this.flush(); return this.pass; }, parse: function parse() { let value = parse.superapply(this, arguments); value.forEach(function (filter) { let vals = Option.splitList(filter.result); filter.keys = DOM.Event.parse(vals[0]).map(DOM.Event.bound.stringify); filter.commandKeys = vals.slice(1).map(DOM.Event.bound.canonicalKeys); filter.inputKeys = filter.commandKeys.filter(bind("test", /^<[ACM]-/)); }); return value; }, keepQuotes: true, setter: function (value) { this.flush(); return value; } }); options.add(["strictfocus", "sf"], "Prevent scripts from focusing input elements without user intervention", "sitemap", "'chrome:*':laissez-faire,*:moderate", { values: { despotic: "Only allow focus changes when explicitly requested by the user", moderate: "Allow focus changes after user-initiated focus change", "laissez-faire": "Always allow focus changes" } }); options.add(["timeout", "tmo"], "Whether to execute a shorter key command after a timeout when a longer command exists", "boolean", true); options.add(["timeoutlen", "tmol"], "Maximum time (milliseconds) to wait for a longer key command when a shorter one exists", "number", 1000); } }); // vim: set fdm=marker sw=4 sts=4 ts=8 et: �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������dactyl-1.2~r20151231/common/content/help.css��������������������������������������������������������0000664�0000000�0000000�00000003310�12641473761�0020447�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������div.main { font-family: -moz-fixed; white-space: -moz-pre-wrap; width: 800px; margin-left: auto; margin-right: auto; } h1 { text-align: center; } p.tagline { text-align: center; font-weight: bold; } table.pentadactyl { border-width: 1px; border-style: dotted; border-color: gray; } table.pentadactyl td { border: none; padding: 3px; } tr.separator { height: 10px; } hr { height: 1px; background-color: white; border-style: none; margin-top: 0; margin-bottom: 0; } td.taglist { text-align: right; vertical-align: top; border-spacing: 13px 10px; } td.taglist td { width: 100px; padding: 3px 0px; } tr.taglist code, td.usage code { margin: 0px 2px; } td.usage code { white-space: nowrap; } td.taglist code { margin-left: 2em; } code.tag { font-weight: bold; color: rgb(255, 0, 255); /* magenta */ padding-left: 5px; } tr.description { margin-bottom: 4px; } table.commands { background-color: rgb(250, 240, 230); color: black; } table.mappings { background-color: rgb(230, 240, 250); color: black; } table.options { background-color: rgb(240, 250, 230); color: black; } fieldset.paypal { border: none; } .argument { color: #6A97D4; } .command { font-weight: bold; color: #632610; } .mapping { font-weight: bold; color: #102663; } .option { font-weight: bold; color: #106326; } .code { color: #108826; } .shorthelp { font-weight: bold; } .version { position: absolute; top: 10px; right: 2%; color: #C0C0C0; text-align: right; } .warning { font-weight: bold; color: red; } /* vim: set fdm=marker sw=4 ts=4 et: */ ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������dactyl-1.2~r20151231/common/content/help.js���������������������������������������������������������0000664�0000000�0000000�00000001525�12641473761�0020301�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Copyright (c) 2009-2012 Kris Maglione <kris@vimperator.org> // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; function checkFragment() { document.title = document.getElementsByTagNameNS("http://www.w3.org/1999/xhtml", "title")[0].textContent; function action() { content.scrollTo(0, content.scrollY + elem.getBoundingClientRect().top - 10); // 10px context } var frag = document.location.hash.substr(1); if (frag) { var elem = document.getElementById(frag); if (elem) { action(); setTimeout(action, 10); } } } document.addEventListener("load", checkFragment, true); document.addEventListener("hashChange", checkFragment, true); // vim: set fdm=marker sw=4 sts=4 ts=8 et: ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������dactyl-1.2~r20151231/common/content/help.xsl��������������������������������������������������������0000664�0000000�0000000�00000072335�12641473761�0020502�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE stylesheet SYSTEM "dactyl://content/dtd"> <!-- Header {{{1 --> <xsl:stylesheet version="1.0" xmlns="http://www.w3.org/1999/xhtml" xmlns:html="http://www.w3.org/1999/xhtml" xmlns:dactyl="http://vimperator.org/namespaces/liberator" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:exsl="http://exslt.org/common" xmlns:regexp="http://exslt.org/regular-expressions" xmlns:str="http://exslt.org/strings" extension-element-prefixes="exsl regexp str"> <xsl:output method="xml" indent="no"/> <!-- Variable Definitions {{{1 --> <!-- Process Overlays {{{1 --> <xsl:template name="splice-overlays"> <xsl:param name="elem"/> <xsl:param name="tag"/> <xsl:for-each select="ancestor::*/dactyl:overlay/*[@insertbefore=$tag]"> <xsl:apply-templates select="." mode="overlay"/> </xsl:for-each> <xsl:choose> <xsl:when test="ancestor::*/dactyl:overlay/*[@replace=$tag] and not($elem[@replace])"> <xsl:for-each select="ancestor::*/dactyl:overlay/*[@replace=$tag]"> <xsl:apply-templates select="." mode="overlay-2"/> </xsl:for-each> </xsl:when> <xsl:otherwise> <xsl:for-each select="$elem"> <xsl:apply-templates select="." mode="overlay-2"/> </xsl:for-each> </xsl:otherwise> </xsl:choose> <xsl:for-each select="ancestor::*/dactyl:overlay/*[@insertafter=$tag]"> <xsl:apply-templates select="." mode="overlay"/> </xsl:for-each> </xsl:template> <xsl:template match="dactyl:tags[parent::dactyl:document]|dactyl:tag" mode="overlay"> <xsl:call-template name="splice-overlays"> <xsl:with-param name="tag" select="substring-before(concat(., ' '), ' ')"/> <xsl:with-param name="elem" select="self::node()"/> </xsl:call-template> </xsl:template> <xsl:template match="*[dactyl:tags]" mode="overlay"> <xsl:call-template name="splice-overlays"> <xsl:with-param name="tag" select="substring-before(concat(dactyl:tags, ' '), ' ')"/> <xsl:with-param name="elem" select="self::node()"/> </xsl:call-template> </xsl:template> <xsl:template match="dactyl:*[@tag and not(@replace)]" mode="overlay"> <xsl:call-template name="splice-overlays"> <xsl:with-param name="tag" select="substring-before(concat(@tag, ' '), ' ')"/> <xsl:with-param name="elem" select="self::node()"/> </xsl:call-template> </xsl:template> <!-- Process Inclusions {{{1 --> <xsl:template name="include"> <xsl:param name="root-node" select="."/> <xsl:param name="overlay" select="concat('dactyl://help-overlay/', $root-node/@name)"/> <!-- Ridiculous three-pass processing is needed to deal with - lack of dynamic variable scope in XSL 1.0. --> <!-- Store a copy of the overlay for the current document. --> <xsl:variable name="doc"> <dactyl:document> <xsl:copy-of select="document($overlay)/dactyl:overlay"/> <xsl:copy-of select="$root-node/node()"/> </dactyl:document> </xsl:variable> <xsl:call-template name="parse-tags"> <xsl:with-param name="text" select="concat($root-node/@name, '.xml')"/> </xsl:call-template> <xsl:apply-templates select="exsl:node-set($doc)/dactyl:document/node()[position() != 1]" mode="overlay"/> </xsl:template> <xsl:template match="dactyl:include" mode="overlay-2"> <div dactyl:highlight="HelpInclude"> <xsl:call-template name="include"> <xsl:with-param name="root-node" select="document(@href)/dactyl:document"/> </xsl:call-template> </div> </xsl:template> <xsl:template match="@*|node()" mode="overlay"> <xsl:apply-templates select="." mode="overlay-2"/> </xsl:template> <xsl:template match="@*[starts-with(local-name(), 'on')]|*[local-name() = 'script']" mode="overlay-2"/> <xsl:template match="@*|node()" mode="overlay-2"> <xsl:copy> <xsl:apply-templates select="@*|node()" mode="overlay"/> </xsl:copy> </xsl:template> <!-- Root {{{1 --> <xsl:template match="/"> <!-- Ridiculous three-pass processing is needed to deal with - lack of dynamic variable scope in XSL 1.0. --> <xsl:variable name="doc1"> <xsl:call-template name="include"> <xsl:with-param name="root-node" select="dactyl:document"/> </xsl:call-template> </xsl:variable> <xsl:variable name="root" select="exsl:node-set($doc1)"/> <!-- Store a cache of all tags defined --> <xsl:variable name="doc2"> <dactyl:document> <xsl:attribute name="document-tags"> <xsl:text> </xsl:text> <xsl:for-each select="$root//@tag|$root//dactyl:tags/text()|$root//dactyl:tag/text()"> <xsl:value-of select="concat(., ' ')"/> </xsl:for-each> </xsl:attribute> <xsl:copy-of select="$root/node()"/> </dactyl:document> </xsl:variable> <xsl:variable name="root2" select="exsl:node-set($doc2)/dactyl:document"/> <html dactyl:highlight="Help"> <head> <title><xsl:value-of select="/dactyl:document/@title"/> dactyl-1.2~r20151231/common/content/quickmarks.js000066400000000000000000000163151264147376100215260ustar00rootroot00000000000000// Copyright (c) 2006-2008 by Martin Stubenschrott // Copyright (c) 2007-2011 by Doug Kearns // Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; /** @scope modules */ /** * @instance quickmarks */ var QuickMarks = Module("quickmarks", { init: function () { this._qmarks = storage.newMap("quickmarks", { store: true }); storage.addObserver("quickmarks", () => { statusline.updateStatus(); }, window); }, /** * Adds a new quickmark with name *qmark* referencing the URL *location*. * Any existing quickmark with the same name will be replaced. * * @param {string} qmark The name of the quickmark {A-Z}. * @param {string} location The URL accessed by this quickmark. */ add: function add(qmark, location) { this._qmarks.set(qmark, location); dactyl.echomsg({ domains: [util.getHost(location)], message: _("quickmark.added", qmark, location) }, 1); }, /** * Returns a list of QuickMarks associates with the given URL. * * @param {string} url The url to find QuickMarks for. * @returns {[string]} */ find: function find(url) { let res = []; for (let [k, v] of this._qmarks) if (dactyl.parseURLs(v).some(u => String.replace(u, /#.*/, "") == url)) res.push(k); return res; }, /** * Returns the URL of the given QuickMark, or null if none exists. * * @param {string} mark The mark to find. * @returns {string} The mark's URL. */ get: function (mark) { return this._qmarks.get(mark) || null; }, /** * Deletes the specified quickmarks. The *filter* is a list of quickmarks * and ranges are supported. Eg. "ab c d e-k". * * @param {string} filter The list of quickmarks to delete. * */ remove: function remove(filter) { let pattern = util.charListToRegexp(filter, "a-zA-Z0-9"); for (let [qmark, ] of this._qmarks) { if (pattern.test(qmark)) this._qmarks.remove(qmark); } }, /** * Removes all quickmarks. */ removeAll: function removeAll() { this._qmarks.clear(); }, /** * Opens the URL referenced by the specified *qmark*. * * @param {string} qmark The quickmark to open. * @param {object} where A set of parameters specifying how to open the * URL. See {@link Dactyl#open}. */ jumpTo: function jumpTo(qmark, where) { let url = this.get(qmark); if (url) dactyl.open(url, where); else dactyl.echoerr(_("quickmark.notSet")); }, /** * Lists all quickmarks matching *filter* in the message window. * * @param {string} filter The list of quickmarks to display, e.g. "a-c i O-X". */ list: function list(filter) { let marks = Array.from(this._qmarks, ([k]) => k); let lowercaseMarks = marks.filter(bind("test", /[a-z]/)).sort(); let uppercaseMarks = marks.filter(bind("test", /[A-Z]/)).sort(); let numberMarks = marks.filter(bind("test", /[0-9]/)).sort(); marks = Array.concat(lowercaseMarks, uppercaseMarks, numberMarks); dactyl.assert(marks.length > 0, _("quickmark.none")); if (filter.length > 0) { let pattern = util.charListToRegexp(filter, "a-zA-Z0-9"); marks = marks.filter(qmark => pattern.test(qmark)); dactyl.assert(marks.length >= 0, _("quickmark.noMatching", JSON.stringify(filter))); } commandline.commandOutput(template.tabular( ["QuickMark", "URL"], [], Array.from(marks, mark => [mark, quickmarks._qmarks.get(mark)]))); } }, { }, { commands: function initCommands() { commands.add(["delqm[arks]"], "Delete the specified QuickMarks", function (args) { // TODO: finish arg parsing - we really need a proper way to do this. :) // assert(args.bang ^ args[0]) dactyl.assert( args.bang || args[0], _("error.argumentRequired")); dactyl.assert(!args.bang || !args[0], _("error.invalidArgument")); if (args.bang) quickmarks.removeAll(); else quickmarks.remove(args[0]); }, { argCount: "?", bang: true, completer: function (context) { completion.quickmark(context); } }); commands.add(["qma[rk]"], "Mark a URL with a letter for quick access", function (args) { dactyl.assert(/^[a-zA-Z0-9]$/.test(args[0]), _("quickmark.invalid")); if (!args[1]) quickmarks.add(args[0], buffer.uri.spec); else quickmarks.add(args[0], args[1]); }, { argCount: "+", completer: function (context, args) { if (args.length == 1) completion.quickmark(context); else if (args.length == 2) { context.fork("current", 0, this, context => { context.title = ["Extra Completions"]; context.completions = [ [quickmarks.get(args[0]), _("option.currentValue")] ].filter(([k, v]) => k); }); context.fork("url", 0, completion, "url"); } }, literal: 1 }); commands.add(["qmarks"], "Show the specified QuickMarks", function (args) { quickmarks.list(args[0] || ""); }, { argCount: "?", completer: function (context) { completion.quickmark(context); } }); }, completion: function initCompletion() { completion.quickmark = context => { context.title = ["QuickMark", "URL"]; context.generate = () => iter(quickmarks._qmarks); }; }, mappings: function initMappings() { var myModes = config.browserModes; mappings.add(myModes, ["go"], "Jump to a QuickMark", function ({ arg }) { quickmarks.jumpTo(arg, dactyl.CURRENT_TAB); }, { arg: true }); mappings.add(myModes, ["gn"], "Jump to a QuickMark in a new tab", function ({ arg }) { quickmarks.jumpTo(arg, { from: "quickmark", where: dactyl.NEW_TAB }); }, { arg: true }); mappings.add(myModes, ["M"], "Add new QuickMark for current URL", function ({ arg }) { dactyl.assert(/^[a-zA-Z0-9]$/.test(arg), _("quickmark.invalid")); quickmarks.add(arg, buffer.uri.spec); }, { arg: true }); } }); // vim: set fdm=marker sw=4 sts=4 ts=8 et: dactyl-1.2~r20151231/common/content/statusline.js000066400000000000000000000434751264147376100215560ustar00rootroot00000000000000// Copyright (c) 2006-2008 by Martin Stubenschrott // Copyright (c) 2007-2011 by Doug Kearns // Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; /** @scope modules */ let securityState = new WeakMap(); var StatusLine = Module("statusline", { init: function init() { this._statusLine = document.getElementById("status-bar"); this.statusBar = document.getElementById("addon-bar") || this._statusLine; this.baseGroup = this.statusBar == this._statusLine ? "StatusLine " : ""; if (this.statusBar.localName == "toolbar" && this.statusBar.parentNode.id != "browser-bottombox") overlay.overlayWindow(window, { objects: this, append: [ ["vbox", { id: "browser-bottombox", xmlns: "xul" }, ["toolbar", { id: "dactyl-addon-bar", customizable: true, defaultset: "", toolboxid: "navigator-toolbox", toolbarname: /*L*/ "Add-on Bar", class: "toolbar-primary chromeclass-toolbar", mode: "icons", iconsize: "small", defaulticonsize: "small", key: "statusBar" }, ["statusbar", { id: "dactyl-status-bar", key: "_statusLine" }]]] ] }); config.tabbrowser.getStatusPanel().hidden = true; if (this.statusBar.localName == "toolbar") { styles.system.add("addon-bar", config.styleableChrome, String.raw` #status-bar, #dactyl-status-bar { margin-top: 0 !important; } #dactyl-status-bar { min-height: 0 !important; } :-moz-any(#addon-bar, #dactyl-addon-bar) > statusbar { -moz-box-flex: 1 } :-moz-any(#addon-bar, #dactyl-addon-bar) > xul|toolbarspring { visibility: collapse; } #browser-bottombox>#addon-bar > #addonbar-closebutton { visibility: collapse; } `); overlay.overlayWindow(window, { append: [ ["statusbar", { id: this._statusLine.id, ordinal: "0" }]] }); let padding = ""; if (config.OS.isMacOSX) padding = "padding-right: 10px !important;"; highlight.loadCSS(String.raw` !AddonBar;#browser-bottombox>#addon-bar,#dactyl-addon-bar { padding-left: 0 !important; padding-top: 0 !important; padding-bottom: 0 !important; min-height: 18px !important; -moz-appearance: none !important; ${padding} } !AddonButton;#browser-bottombox>#addon-bar xul|toolbarbutton, #dactyl-addon-bar xul|toolbarbutton { -moz-appearance: none !important; padding: 0 !important; border-width: 0px !important; min-width: 0 !important; color: inherit !important; } AddonButton:not(:hover) background: transparent; `); if (document.getElementById("appmenu-button")) highlight.loadCSS(String.raw` AppmenuButton min-width: 0 !important; padding: 0 .5em !important; `); } let prepend = [ ["button", { id: "appmenu-button", label: "", image: "chrome://branding/content/icon16.png", highlight: "AppmenuButton", xmlns: "xul" }], ["toolbarbutton", { id: "appmenu-toolbar-button", label: "", image: "chrome://branding/content/icon16.png" }], ["statusbar", { id: this._statusLine.id, highlight: "StatusLine", xmlns: "xul" }, // ["hbox", { key: "container", hidden: "false", align: "center", flex: "1" }, ["stack", { orient: "horizontal", align: "stretch", flex: "1", highlight: "CmdLine StatusCmdLine", class: "dactyl-container" }, ["hbox", { highlight: "CmdLine StatusCmdLine", class: "dactyl-container" }, ["label", { key: "mode", crop: "end", class: "plain", collapsed: "true" }], ["stack", { id: "dactyl-statusline-stack", flex: "1", highlight: "CmdLine StatusCmdLine", class: "dactyl-container" }, ["textbox", { key: "url", crop: "end", flex: "1", style: "background: transparent;", class: "plain dactyl-status-field-url", readonly: "true" }], ["hbox", { key: "message-box" }, ["label", { key: "message-pre", highlight: "WarningMsg StatusWarningMsg", class: "plain", readonly: "true" }], ["textbox", { key: "message", crop: "end", flex: "1", highlight: "Normal StatusNormal", class: "plain", readonly: "true" }]]]]], ["label", { class: "plain", key: "inputbuffer", flex: "0" }], ["label", { class: "plain", key: "progress", flex: "0" }], ["label", { class: "plain", key: "tabcount", flex: "0" }], ["label", { class: "plain", key: "bufferposition", flex: "0" }], ["label", { class: "plain", key: "zoomlevel", flex: "0" }]], // just hide them since other elements expect them ["statusbarpanel", { id: "statusbar-display", hidden: "true" }], ["statusbarpanel", { id: "statusbar-progresspanel", hidden: "true" }]]]; (function rec(ary) { ary.forEach(function (elem) { if ("key" in elem[1]) elem[1].id = "dactyl-statusline-field-" + elem[1].key; if (elem.length > 2) rec(elem.slice(2)); }); })(prepend); overlay.overlayWindow(window, { objects: this.widgets = { get status() { return this.container; } }, prepend: prepend }); try { this.security = securityState.get(content) || "insecure"; } catch (e) {} }, cleanup: function cleanup(reason) { if (reason != "unload" && "CustomizableUI" in window) CustomizableUI.unregisterArea(this.statusBar.id, false); }, get visible() { return !this.statusBar.collapsed && !this.statusBar.hidden; }, signals: { "browser.locationChange": function (webProgress, request, uri) { let win = webProgress.DOMWindow; this.status = uri; this.progress = uri && win && win.dactylProgress || ""; // if this is not delayed we get the position of the old buffer this.timeout(function () { this.updateBufferPosition(); this.updateZoomLevel(); }, 500); }, "browser.overLink": function (link) { switch (options["showstatuslinks"]) { case "status": this.overLink = link ? _("status.link", link) : null; this.status = link ? _("status.link", link) : buffer.uri; break; case "command": this.overLink = null; if (link) dactyl.echo(_("status.link", link), commandline.FORCE_SINGLELINE); else commandline.clear(); break; } }, "browser.progressChange": function onProgressChange(webProgress, request, curSelfProgress, maxSelfProgress, curTotalProgress, maxTotalProgress) { if (webProgress && webProgress.DOMWindow) webProgress.DOMWindow.dactylProgress = curTotalProgress / maxTotalProgress; this.progress = curTotalProgress / maxTotalProgress; }, "browser.securityChange": function onSecurityChange(webProgress, request, state) { if (state & Ci.nsIWebProgressListener.STATE_IS_BROKEN) this.security = "broken"; else if (state & Ci.nsIWebProgressListener.STATE_IDENTITY_EV_TOPLEVEL) this.security = "extended"; else if (state & Ci.nsIWebProgressListener.STATE_SECURE_HIGH) this.security = "secure"; else // if (state & Ci.nsIWebProgressListener.STATE_IS_INSECURE) this.security = "insecure"; if (webProgress && webProgress.DOMWindow) securityState.set(webProgress.DOMWindow, this.security); }, "browser.stateChange": function onStateChange(webProgress, request, flags, status) { const L = Ci.nsIWebProgressListener; if (flags & (L.STATE_IS_DOCUMENT | L.STATE_IS_WINDOW)) if (flags & L.STATE_START) this.progress = 0; else if (flags & L.STATE_STOP) this.progress = ""; if (flags & L.STATE_STOP) this.updateStatus(); }, "browser.statusChange": function onStatusChange(webProgress, request, status, message) { this.timeout(function () { this.status = message || buffer.uri; }); }, "fullscreen": function onFullscreen(fullscreen) { let go = options.get("guioptions"); if (fullscreen) { this.wasVisible = go.has("s"); go.op("-", "s"); } else if (this.wasVisible) { go.op("+", "s"); } } }, /** * Update the status bar to indicate how secure the website is: * extended - Secure connection with Extended Validation(EV) certificate. * secure - Secure connection with valid certificate. * broken - Secure connection with invalid certificate, or * mixed content. * insecure - Insecure connection. * * @param {'extended'|'secure'|'broken'|'insecure'} type */ set security(type) { this._security = type; const highlightGroup = { extended: "StatusLineExtended", secure: "StatusLineSecure", broken: "StatusLineBroken", insecure: "StatusLineNormal" }; highlight.highlightNode(this.statusBar, this.baseGroup + highlightGroup[type]); }, get security() { return this._security; }, // update all fields of the statusline update: function update() { this.updateStatus(); this.inputBuffer = ""; this.progress = ""; this.updateTabCount(); this.updateBufferPosition(); this.updateZoomLevel(); }, unsafeURI: deprecated("util.unsafeURI", { get: function unsafeURI() { return util.unsafeURI; } }), losslessDecodeURI: deprecated("util.losslessDecodeURI", function losslessDecodeURI() { return apply(util, "losslessDecodeURI", arguments); }), /** * Update the URL displayed in the status line. Also displays status * icons, [+-♥], when there are next and previous pages in the * current tab's history, and when the current URL is bookmarked, * respectively. * * @param {string} url The URL to display. */ get status() { return this._uri; }, set status(uri) { let modified = ""; let url = uri; if (isinstance(uri, Ci.nsIURI)) { // when session information is available, add [+] when we can go // backwards, [-] when we can go forwards if (uri.equals(buffer.uri)) { let { webNav } = buffer; if (webNav.canGoBack) modified += "-"; if (webNav.canGoForward) modified += "+"; if (this.bookmarked) modified += UTF8("❤"); } if (modules.quickmarks) modified += quickmarks.find(uri.spec.replace(/#.*/, "")).join(""); url = util.losslessDecodeURI(uri.spec); } if (url == "about:blank") { if (!buffer.title) url = _("buffer.noName"); } else { url = url.replace(RegExp("^dactyl://help/(\\S+)#(.*)"), (m, n1, n2) => n1 + " " + decodeURIComponent(n2) + " " + _("buffer.help")) .replace(RegExp("^dactyl://help/(\\S+)"), "$1 " + _("buffer.help")); } if (modified) url += " [" + modified + "]"; this.widgets.url.value = url; this._status = uri; }, get bookmarked() { return this._bookmarked; }, set bookmarked(val) { this._bookmarked = val; if (this.status) this.status = this.status; }, updateStatus: function updateStatus() { this.timeout(function () { this.status = this.overLink || buffer.uri; }); }, updateUrl: deprecated("statusline.status", function updateUrl(url) { this.status = url || buffer.uri; }), /** * Set the contents of the status line's input buffer to the given * string. Used primarily when a key press requires further input * before being processed, including mapping counts and arguments, * along with multi-key mappings. * * @param {string} buffer * @optional */ get inputBuffer() { return this.widgets.inputbuffer.value; }, set inputBuffer(val) { this.widgets.inputbuffer.value = val == null ? "" : val; }, updateInputBuffer: deprecated("statusline.inputBuffer", function updateInputBuffer(val) { this.inputBuffer = val; }), /** * Update the page load progress bar. * * @param {string|number} progress The current progress, as follows: * A string - Displayed literally. * A ratio 0 < n < 1 - Displayed as a progress bar. * A number n <= 0 - Displayed as a "Loading" message. * Any other number - The progress is cleared. */ progress: Modes.boundProperty({ get: function progress() { return this._progress; }, set: function progress(progress) { this._progress = progress || ""; if (isinstance(progress, ["String", _])) this.widgets.progress.value = this._progress; else if (typeof progress == "number") { let progressStr = ""; if (this._progress <= 0) progressStr = /*L*/"[ Loading... ]"; else if (this._progress < 1) { let progress = Math.round(this._progress * 20); progressStr = "[" + "===================> " .substr(20 - progress, 20) + "]"; } this.widgets.progress.value = progressStr; } } }), updateProgress: deprecated("statusline.progress", function updateProgress(progress) { this.progress = progress; }), /** * Display the correct tabcount (e.g., [1/5]) on the status bar. * * @param {boolean} delayed When true, update count after a brief timeout. * Useful in the many cases when an event that triggers an update is * broadcast before the tab state is fully updated. * @optional */ updateTabCount: function updateTabCount(delayed) { if (dactyl.has("tabs")) { if (delayed) { this.timeout(() => { this.updateTabCount(false); }, 0); return; } this.widgets.tabcount.value = "[" + (tabs.index(null, true) + 1) + "/" + tabs.visibleTabs.length + "]"; } }, /** * Display the main content's vertical scroll position in the status * bar. * * @param {number} percent The position, as a percentage. * @optional */ updateBufferPosition: function updateBufferPosition(percent) { if (percent == null) { let win = document.commandDispatcher.focusedWindow; if (!win) return; win.scrollY; // intentional - see Kris percent = win.scrollY == 0 ? 0 : // This prevents a forced rendering win.scrollMaxY == 0 ? -1 : win.scrollY / win.scrollMaxY; } percent = Math.round(percent * 100); if (percent < 0) var position = "All"; else if (percent == 0) position = "Top"; else if (percent >= 100) position = "Bot"; else if (percent < 10) position = " " + percent + "%"; else position = percent + "%"; this.widgets.bufferposition.value = position; }, /** * Display the main content's zoom level. * * @param {number} percent The zoom level, as a percentage. @optional * @param {boolean} full True if full zoom is in operation. @optional */ updateZoomLevel: function updateZoomLevel(percent=buffer.zoomLevel, full=buffer.fullZoom) { if (percent == 100) this.widgets.zoomlevel.value = ""; else { percent = (" " + Math.round(percent)).substr(-3); if (full) this.widgets.zoomlevel.value = " [" + percent + "%]"; else this.widgets.zoomlevel.value = " (" + percent + "%)"; } } }); // vim: set fdm=marker sw=4 sts=4 ts=8 et: dactyl-1.2~r20151231/common/content/tabs.js000066400000000000000000001441071264147376100203060ustar00rootroot00000000000000// Copyright (c) 2006-2008 by Martin Stubenschrott // Copyright (c) 2007-2011 by Doug Kearns // Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; /** @scope modules */ // TODO: many methods do not work with Thunderbird correctly yet /** * @instance tabs */ var Tabs = Module("tabs", { init: function () { // used for the "gb" and "gB" mappings to remember the last :buffer[!] command this._lastBufferSwitchArgs = ""; this._lastBufferSwitchSpecial = true; this.xulTabs = document.getElementById("tabbrowser-tabs"); // hide tabs initially to prevent flickering when 'stal' would hide them // on startup if (config.has("tabbrowser")) config.tabStrip.collapsed = true; this.tabStyle = styles.system.add("tab-strip-hiding", config.styleableChrome, (config.tabStrip.id ? "#" + config.tabStrip.id : ".tabbrowser-strip") + "{ visibility: collapse; }", false, true); dactyl.commands["tabs.select"] = event => { tabs.switchTo(event.originalTarget.getAttribute("identifier")); }; this.tabBinding = styles.system.add( "tab-binding", "chrome://browser/content/browser.xul", String.raw` xul|tab { -moz-binding: url(chrome://dactyl/content/bindings.xml#tab) !important; } `, false, true); this.timeout(function () { for (let { linkedBrowser: { contentDocument } } of this.allTabs) if (contentDocument.readyState === "complete") dactyl.initDocument(contentDocument); }, 1000); if (window.TabsInTitlebar) window.TabsInTitlebar.allowedBy("dactyl", false); }, signals: { enter: function enter() { if (window.TabsInTitlebar) window.TabsInTitlebar.allowedBy("dactyl", true); } }, _alternates: Class.Memoize(() => [gBrowser.mCurrentTab, null]), cleanup: function cleanup() { for (let tab of this.allTabs) { let node = function node(class_) { return document.getAnonymousElementByAttribute(tab, "class", class_); }; for (let elem of ["dactyl-tab-icon-number", "dactyl-tab-number"].map(node)) if (elem) elem.parentNode.parentNode.removeChild(elem.parentNode); delete tab.dactylOrdinal; tab.removeAttribute("dactylOrdinal"); } }, updateTabCount: function updateTabCount() { for (let [i, tab] of iter(this.visibleTabs)) { let node = function node(class_) { return document.getAnonymousElementByAttribute(tab, "class", class_); }; if (!node("dactyl-tab-number")) { let img = node("tab-icon-image"); if (img) { let dom = DOM([ ["xul:hbox", { highlight: "tab-number" }, ["xul:label", { key: "icon", align: "center", highlight: "TabIconNumber", class: "dactyl-tab-icon-number" }]], ["xul:hbox", { highlight: "tab-number" }, ["html:div", { key: "label", highlight: "TabNumber", class: "dactyl-tab-number" }]]], document).appendTo(img.parentNode); update(tab, { get dactylOrdinal() { return Number(dom.nodes.icon.value); }, set dactylOrdinal(i) { dom.nodes.icon.value = dom.nodes.label.textContent = i; this.setAttribute("dactylOrdinal", i); } }); } } tab.dactylOrdinal = i + 1; } statusline.updateTabCount(true); }, _onTabSelect: function _onTabSelect() { // TODO: is all of that necessary? // I vote no. --Kris modes.reset(); statusline.updateTabCount(true); this.updateSelectionHistory(); }, get allTabs() { return Array.slice(gBrowser.tabs); }, /** * @property {Object} The previously accessed tab or null if no tab * other than the current one has been accessed. */ get alternate() { let alt = this._alternates[1]; return this.allTabs.indexOf(alt) > -1 ? alt : null; }, /** * @property {Iterator(Object)} A genenerator that returns all browsers * in the current window. */ get browsers() { return function* () { for (let [i, browser] of gBrowser.browsers.entries()) if (browser !== undefined) // Bug in Google's Page Speed add-on. yield [i, browser]; }(); }, /** * @property {number} The number of tabs in the current window. */ get count() { return gBrowser.mTabs.length; }, /** * @property {Object} The local options store for the current tab. */ get options() { return this.localStore.options; }, get visibleTabs() { return gBrowser.visibleTabs || this.allTabs.filter(tab => !tab.hidden); }, /** * Returns the local state store for the tab at the specified *tabIndex*. * If *tabIndex* is not specified then the current tab is used. * * @param {number} tabIndex * @returns {Object} */ // FIXME: why not a tab arg? Why this and the property? // : To the latter question, because this works for any tab, the // property doesn't. And the property is so oft-used that it's // convenient. To the former question, because I think this is mainly // useful for autocommands, and they get index arguments. --Kris getLocalStore: function getLocalStore(tabIndex) { let tab = this.getTab(tabIndex); if (!tab.dactylStore) tab.dactylStore = Object.create(this.localStorePrototype); return tab.dactylStore.instance = tab.dactylStore; }, /** * @property {Object} The local state store for the currently selected * tab. */ get localStore() { return this.getLocalStore(); }, localStorePrototype: memoize({ instance: {}, get options() { return {}; } }), /** * @property {[Object]} The array of closed tabs for the current * session. */ get closedTabs() { return JSON.parse(services.sessionStore.getClosedTabData(window)); }, /** * Clones the specified *tab* and append it to the tab list. * * @param {Object} tab The tab to clone. * @param {boolean} activate Whether to select the newly cloned tab. */ cloneTab: function cloneTab(tab, activate) { let newTab = gBrowser.addTab("about:blank", { ownerTab: tab }); Tabs.copyTab(newTab, tab); if (activate) gBrowser.mTabContainer.selectedItem = newTab; return newTab; }, /** * Detaches the specified *tab* and open it in a new window. If no tab is * specified the currently selected tab is detached. * * @param {Object} tab The tab to detach. */ detachTab: function detachTab(tab) { if (!tab) tab = gBrowser.mTabContainer.selectedItem; services.windowWatcher .openWindow(window, window.getBrowserURL(), null, "chrome,dialog=no,all", tab); }, /** * Returns the index of the tab containing *content*. * * @param {Object} content Either a content window or a content * document. */ // FIXME: Only called once...necessary? getContentIndex: function getContentIndex(content) { for (let [i, browser] of this.browsers) { if (browser.contentWindow == content || browser.contentDocument == content) return i; } return -1; }, /** * If TabView exists, returns the Panorama window. If the Panorama * is has not yet initialized, this function will not return until * it has. * * @returns {Window} */ getGroups: function getGroups(func) { let iframe = document.getElementById("tab-view"); this._groups = iframe ? iframe.contentWindow : null; if ("_groups" in this && !func) return this._groups; if (func) func = bind(function (func) { func(this._groups); }, this, func); if (window.TabView && window.TabView._initFrame) window.TabView._initFrame(func); this._groups = iframe ? iframe.contentWindow : null; if (this._groups && !func) util.waitFor(() => this._groups.TabItems); return this._groups; }, /** * Returns the tab at the specified *index* or the currently selected tab * if *index* is not specified. This is a 0-based index. * * @param {number|Node} index The index of the tab required or the tab itself * @param {boolean} visible If true, consider only visible tabs rather than * all tabs. * @returns {Object} */ getTab: function getTab(index, visible) { if (index instanceof Node) return index; if (index != null) return this[visible ? "visibleTabs" : "allTabs"][index]; return gBrowser.mCurrentTab; }, /** * Returns the index of *tab* or the index of the currently selected tab if * *tab* is not specified. This is a 0-based index. * * @param {} tab A tab from the current tab list. * @param {boolean} visible Whether to consider only visible tabs. * @returns {number} */ index: function index(tab, visible) { let tabs = this[visible ? "visibleTabs" : "allTabs"]; return tabs.indexOf(tab || gBrowser.mCurrentTab); }, /** * @param spec can either be: * - an absolute integer * - "" for the current tab * - "+1" for the next tab * - "-3" for the tab, which is 3 positions left of the current * - "$" for the last tab */ indexFromSpec: function indexFromSpec(spec, wrap, offset) { if (spec instanceof Node) return this.allTabs.indexOf(spec); let tabs = this.visibleTabs; let position = this.index(null, true); if (spec == null) return -1; if (spec === "") return position; if (/^\d+$/.test(spec)) position = parseInt(spec, 10) + (offset || 0); else if (spec === "$") position = tabs.length - 1; else if (/^[+-]\d+$/.test(spec)) position += parseInt(spec, 10); else return -1; if (position >= tabs.length) position = wrap ? position % tabs.length : tabs.length - 1; else if (position < 0) position = wrap ? (position % tabs.length) + tabs.length : 0; return this.allTabs.indexOf(tabs[position]); }, /** * Removes all tabs from the tab list except the specified *tab*. * * @param {Object} tab The tab to keep. */ keepOnly: function keepOnly(tab) { gBrowser.removeAllTabsBut(tab); }, /** * Lists all tabs matching *filter*. * * @param {string} filter A filter matching a substring of the tab's * document title or URL. */ list: function list(filter) { completion.listCompleter("buffer", filter); }, /** * Return an iterator of tabs matching the given filter. If no * *filter* or *count* is provided, returns the currently selected * tab. If *filter* is a number or begins with a number followed * by a colon, the tab of that ordinal is returned. Otherwise, * tabs matching the filter as below are returned. * * @param {string} filter The filter. If *regexp*, this is a * regular expression against which the tab's URL or title * must match. Otherwise, it is a site filter. * @optional * @param {number|null} count If non-null, return only the * *count*th matching tab. * @optional * @param {boolean} regexp Whether to interpret *filter* as a * regular expression. * @param {boolean} all If true, match against all tabs. If * false, match only tabs in the current tab group. */ match: function* match(filter, count, regexp, all) { if (!filter && count == null) yield tabs.getTab(); else if (!filter) yield dactyl.assert(tabs.getTab(count - 1)); else { let matches = /^(\d+)(?:$|:)/.exec(filter); if (matches) yield dactyl.assert(count == null && tabs.getTab(parseInt(matches[1], 10) - 1, !all)); else { if (regexp) regexp = util.regexp(filter, "i"); else var matcher = Styles.matchFilter(filter); for (let tab of tabs[all ? "allTabs" : "visibleTabs"]) { let browser = tab.linkedBrowser; let uri = browser.currentURI; let title; if (uri.spec == "about:blank") title = "(Untitled)"; else title = browser.contentTitle; if (matcher && matcher(uri) || regexp && (regexp.test(title) || regexp.test(uri.spec))) if (count == null || --count == 0) yield tab; } } } }, /** * Moves a tab to a new position in the tab list. * * @param {Object} tab The tab to move. * @param {string} spec See {@link Tabs.indexFromSpec}. * @param {boolean} wrap Whether an out of bounds *spec* causes the * destination position to wrap around the start/end of the tab list. */ move: function move(tab, spec, wrap) { let index = tabs.indexFromSpec(spec, wrap, -1); gBrowser.moveTabTo(tab, index); }, /** * Removes the specified *tab* from the tab list. * * @param {Object} tab The tab to remove. * @param {number} count How many tabs to remove. * @param {boolean} focusLeftTab Focus the tab to the left of the removed tab. */ remove: function remove(tab, count=1, focusLeftTab=false) { let res = this.count > count; let tabs = this.visibleTabs; if (tabs.indexOf(tab) < 0) tabs = this.allTabs; let index = tabs.indexOf(tab); let next = index + (focusLeftTab ? -count : count); if (!(next in tabs)) next = index + (focusLeftTab ? 1 : -1); if (next in tabs) { this._alternates[0] = tabs[next]; gBrowser.mTabContainer.selectedItem = tabs[next]; } if (focusLeftTab) tabs.slice(Math.max(0, index + 1 - count), index + 1) .forEach(config.bound.removeTab); else tabs.slice(index, index + count) .forEach(config.bound.removeTab); return res; }, /** * Reloads the specified tab. * * @param {Object} tab The tab to reload. * @param {boolean} bypassCache Whether to bypass the cache when * reloading. */ reload: function reload(tab, bypassCache) { try { if (bypassCache) { const flags = Ci.nsIWebNavigation.LOAD_FLAGS_BYPASS_PROXY | Ci.nsIWebNavigation.LOAD_FLAGS_BYPASS_CACHE; gBrowser.getBrowserForTab(tab).reloadWithFlags(flags); } else gBrowser.reloadTab(tab); } catch (e if !(e instanceof Error)) {} }, /** * Reloads all tabs. * * @param {boolean} bypassCache Whether to bypass the cache when * reloading. */ reloadAll: function reloadAll(bypassCache) { this.visibleTabs.forEach(function (tab) { try { tabs.reload(tab, bypassCache); } catch (e) { dactyl.reportError(e, true); } }); }, /** * Selects the tab at the position specified by *spec*. * * @param {string} spec See {@link Tabs.indexFromSpec} * @param {boolean} wrap Whether an out of bounds *spec* causes the * selection position to wrap around the start/end of the tab list. */ select: function select(spec, wrap) { let index = tabs.indexFromSpec(spec, wrap); if (index == -1) dactyl.beep(); else gBrowser.mTabContainer.selectedIndex = index; }, /** * Selects the alternate tab. */ selectAlternateTab: function selectAlternateTab() { dactyl.assert(tabs.alternate != null && tabs.getTab() != tabs.alternate, _("buffer.noAlternate")); tabs.select(tabs.alternate); }, /** * Stops loading the specified tab. * * @param {Object} tab The tab to stop loading. */ stop: function stop(tab) { if (config.stop) config.stop(tab); else tab.linkedBrowser.stop(); }, /** * Stops loading all tabs. */ stopAll: function stopAll() { for (let [, browser] of this.browsers) browser.stop(); }, /** * Selects the tab containing the specified *buffer*. * * @param {string} buffer A string which matches the URL or title of a * buffer, if it is null, the last used string is used again. * @param {boolean} allowNonUnique Whether to select the first of * multiple matches. * @param {number} count If there are multiple matches select the * *count*th match. * @param {boolean} reverse Whether to search the buffer list in * reverse order. * */ // FIXME: help! switchTo: function switchTo(buffer, allowNonUnique, count, reverse) { if (buffer != null) { // store this command, so it can be repeated with "B" this._lastBufferSwitchArgs = buffer; this._lastBufferSwitchSpecial = allowNonUnique; } else { buffer = this._lastBufferSwitchArgs; if (allowNonUnique == null) // XXX allowNonUnique = this._lastBufferSwitchSpecial; } if (buffer == "#") return tabs.selectAlternateTab(); reverse = Boolean(reverse); count = Math.max(1, count || 1) * (1 + -2 * reverse); let matches = buffer.match(/^(\d+):?/); if (matches) return tabs.select(this.allTabs[parseInt(matches[1], 10) - 1], false); matches = tabs.allTabs.find(t => (t.linkedBrowser.lastURI || {}).spec === buffer); if (matches) return tabs.select(matches, false); matches = completion.runCompleter("buffer", buffer).map(obj => obj.tab); if (matches.length == 0) dactyl.echoerr(_("buffer.noMatching", buffer)); else if (matches.length > 1 && !allowNonUnique) dactyl.echoerr(_("buffer.multipleMatching", buffer)); else { let start = matches.indexOf(tabs.getTab()); if (start == -1 && reverse) start++; let index = (start + count) % matches.length; if (index < 0) index = matches.length + index; tabs.select(matches[index], false); } }, // NOTE: when restarting a session FF selects the first tab and then the // tab that was selected when the session was created. As a result the // alternate after a restart is often incorrectly tab 1 when there // shouldn't be one yet. /** * Sets the current and alternate tabs, updating the tab selection * history. * * @param {Array(Object)} tabs The current and alternate tab. * @see tabs#alternate */ updateSelectionHistory: function updateSelectionHistory(tabs) { if (!tabs) { if (this.getTab() == this._alternates[0] || this.alternate && this.allTabs.indexOf(this._alternates[0]) == -1 || this.alternate && gBrowser._removingTabs && gBrowser._removingTabs.indexOf(this._alternates[0]) >= 0) tabs = [this.getTab(), this.alternate]; } this._alternates = tabs || [this.getTab(), this._alternates[0]]; } }, { copyTab: function (to, from) { if (!from) from = gBrowser.mTabContainer.selectedItem; let tabState = services.sessionStore.getTabState(from); services.sessionStore.setTabState(to, tabState); } }, { load: function initLoad() { tabs.updateTabCount(); }, commands: function initCommands() { [ { name: ["bd[elete]"], description: "Delete matching buffers", visible: false }, { name: ["tabc[lose]"], description: "Delete matching tabs", visible: true } ].forEach(function (params) { commands.add(params.name, params.description, function (args) { let removed = 0; for (let tab of tabs.match(args[0], args.count, args.bang, !params.visible)) { config.removeTab(tab); removed++; } if (args[0]) if (removed > 0) dactyl.echomsg(_("buffer.fewerTab" + (removed == 1 ? "" : "s"), removed), 9); else dactyl.echoerr(_("buffer.noMatching", args[0])); }, { argCount: "?", bang: true, count: true, completer: function (context) { completion.buffer(context); }, literal: 0, privateData: true }); }); commands.add(["pin[tab]"], "Pin tab as an application tab", function (args) { for (let tab of tabs.match(args[0], args.count)) config.browser[!args.bang || !tab.pinned ? "pinTab" : "unpinTab"](tab); }, { argCount: "?", bang: true, count: true, completer: function (context, args) { if (!args.bang) context.filters.push(({ item }) => !item.tab.pinned); completion.buffer(context); } }); commands.add(["unpin[tab]"], "Unpin tab as an application tab", function (args) { for (let tab of tabs.match(args[0], args.count)) config.browser.unpinTab(tab); }, { argCount: "?", count: true, completer: function (context) { context.filters.push(({ item }) => item.tab.pinned); completion.buffer(context); } }); commands.add(["keepa[lt]"], "Execute a command without changing the current alternate buffer", function (args) { try { dactyl.execute(args[0], null, true); } finally { tabs.updateSelectionHistory([tabs.getTab(), tabs.alternate]); } }, { argCount: "1", completer: function (context) { completion.ex(context); }, literal: 0, subCommand: 0 }); commands.add(["tab"], "Execute a command and tell it to output in a new tab", function (args) { dactyl.withSavedValues(["forceTarget"], function () { this.forceTarget = dactyl.NEW_TAB; dactyl.execute(args[0], null, true); }); }, { argCount: "1", completer: function (context) { completion.ex(context); }, literal: 0, subCommand: 0 }); commands.add(["background", "bg"], "Execute a command opening any new tabs in the background", function (args) { dactyl.withSavedValues(["forceBackground"], function () { this.forceBackground = true; dactyl.execute(args[0], null, true); }); }, { argCount: "1", completer: function (context) { completion.ex(context); }, literal: 0, subCommand: 0 }); commands.add(["tabd[o]", "bufd[o]"], "Execute a command in each tab", function (args) { for (let tab of tabs.visibleTabs) { tabs.select(tab); dactyl.execute(args[0], null, true); } }, { argCount: "1", completer: function (context) { completion.ex(context); }, literal: 0, subCommand: 0 }); commands.add(["tabl[ast]", "bl[ast]"], "Switch to the last tab", function () { tabs.select("$", false); }, { argCount: "0" }); // TODO: "Zero count" if 0 specified as arg commands.add(["tabp[revious]", "tp[revious]", "tabN[ext]", "tN[ext]", "bp[revious]", "bN[ext]"], "Switch to the previous tab or go [count] tabs back", function (args) { let count = args.count; let arg = args[0]; // count is ignored if an arg is specified, as per Vim if (arg) { if (/^\d+$/.test(arg)) tabs.select("-" + arg, true); else dactyl.echoerr(_("error.trailingCharacters")); } else if (count > 0) tabs.select("-" + count, true); else tabs.select("-1", true); }, { argCount: "?", count: true }); // TODO: "Zero count" if 0 specified as arg commands.add(["tabn[ext]", "tn[ext]", "bn[ext]"], "Switch to the next or [count]th tab", function (args) { let count = args.count; let arg = args[0]; if (arg || count > 0) { let index; // count is ignored if an arg is specified, as per Vim if (arg) { dactyl.assert(/^\d+$/.test(arg), _("error.trailingCharacters")); index = arg - 1; } else index = count - 1; if (index < tabs.count) tabs.select(index, true); else dactyl.beep(); } else tabs.select("+1", true); }, { argCount: "?", count: true }); commands.add(["tabr[ewind]", "tabfir[st]", "br[ewind]", "bf[irst]"], "Switch to the first tab", function () { tabs.select(0, false); }, { argCount: "0" }); if (config.has("tabbrowser")) { commands.add(["b[uffer]"], "Switch to a buffer", function (args) { if (args.length) tabs.switchTo(args[0], args.bang, args.count); else if (args.count) tabs.switchTo(String(args.count)); }, { argCount: "?", bang: true, count: true, completer: function (context) { completion.buffer(context); }, literal: 0, privateData: true }); commands.add(["buffers", "files", "ls", "tabs"], "Show a list of all buffers", function (args) { tabs.list(args[0] || ""); }, { argCount: "?", literal: 0 }); commands.add(["quita[ll]", "qa[ll]"], "Quit this " + config.appName + " window", function () { window.close(); }, { argCount: "0" }); commands.add(["reloada[ll]"], "Reload all tab pages", function (args) { tabs.reloadAll(args.bang); }, { argCount: "0", bang: true }); commands.add(["stopa[ll]"], "Stop loading all tab pages", function () { tabs.stopAll(); }, { argCount: "0" }); // TODO: add count and bang multimatch support - unify with :buffer nonsense commands.add(["tabm[ove]"], "Move the current tab to the position of tab N", function (args) { let arg = args[0]; if (tabs.indexFromSpec(arg) == -1) { let list = Array.from(tabs.match(args[0], args.count, true)); dactyl.assert(list.length, _("error.invalidArgument", arg)); dactyl.assert(list.length == 1, _("buffer.multipleMatching", arg)); arg = list[0]; } tabs.move(tabs.getTab(), arg, args.bang); }, { argCount: "1", bang: true, completer: function (context) { completion.buffer(context, true); }, literal: 0 }); commands.add(["tabo[nly]"], "Close all other tabs", function () { tabs.keepOnly(tabs.getTab()); }, { argCount: "0" }); commands.add(["tabopen", "t[open]", "tabnew"], "Open one or more URLs in a new tab", function (args) { dactyl.open(args[0] || "about:blank", { from: "tabopen", where: dactyl.NEW_TAB, background: args.bang }); }, { bang: true, completer: function (context) { completion.url(context); }, domains: function (args) { return commands.get("open").domains(args); }, literal: 0, privateData: true }); commands.add(["tabde[tach]"], "Detach current tab to its own window", function () { tabs.detachTab(null); }, { argCount: "0" }); commands.add(["tabdu[plicate]"], "Duplicate current tab", function (args) { let tab = tabs.getTab(); let activate = args.bang ? true : false; if (options.get("activate").has("tabopen")) activate = !activate; for (let i of util.range(0, Math.max(1, args.count))) tabs.cloneTab(tab, activate); }, { argCount: "0", bang: true, count: true }); // TODO: match window by title too? // : accept the full :tabmove arg spec for the tab index arg? // : better name or merge with :tabmove? commands.add(["taba[ttach]"], "Attach the current tab to another window", function (args) { dactyl.assert(args.length <= 2 && !args.some(i => !/^\d+(?:$|:)/.test(i)), _("error.trailingCharacters")); let [winIndex, tabIndex] = args.map(arg => parseInt(arg)); if (args["-group"]) { util.assert(args.length == 1); window.TabView.moveTabTo(tabs.getTab(), winIndex); return; } let win = dactyl.windows[winIndex - 1]; let sourceTab = tabs.getTab(); dactyl.assert(win, _("window.noIndex", winIndex)); dactyl.assert(win != window, _("window.cantAttachSame")); let modules = win.dactyl.modules; let { browser } = modules.config; let newTab = browser.addTab("about:blank"); browser.stop(); // XXX: the implementation of DnD in tabbrowser.xml suggests // that we may not be guaranteed of having a docshell here // without this reference? browser.docShell; if (args[1]) { let { visibleTabs, allTabs } = modules.tabs; tabIndex = Math.constrain(tabIndex, 1, visibleTabs.length); let target = visibleTabs[tabIndex - 1]; browser.moveTabTo(newTab, Array.indexOf(allTabs, target)); } browser.selectedTab = newTab; // required browser.swapBrowsersAndCloseOther(newTab, sourceTab); }, { argCount: "+", literal: 1, completer: function (context, args) { switch (args.completeArg) { case 0: if (args["-group"]) completion.tabGroup(context); else { context.filters.push(({ item }) => item != window); completion.window(context); } break; case 1: if (!args["-group"]) { let win = dactyl.windows[Number(args[0]) - 1]; if (!win || !win.dactyl) context.message = _("Error", _("window.noIndex", winIndex)); else win.dactyl.modules.commands.get("tabmove").completer(context); } break; } }, options: [ { names: ["-group", "-g"], description: "Attach to a group rather than a window", type: CommandOption.NOARG } ] }); } if (dactyl.has("tabs_undo")) { commands.add(["u[ndo]"], "Undo closing of a tab", function (args) { if (args.length) args = args[0]; else args = args.count || 0; let m = /^(\d+)(:|$)/.exec(args || '1'); if (m) window.undoCloseTab(Number(m[1]) - 1); else if (args) { for (let [i, item] of iter(tabs.closedTabs)) if (item.state.entries[item.state.index - 1].url == args) { window.undoCloseTab(i); return; } dactyl.echoerr(_("buffer.noClosed")); } }, { argCount: "?", completer: function (context) { context.anchored = false; context.compare = CompletionContext.Sort.unsorted; context.filters = [CompletionContext.Filter.textDescription]; context.keys = { text: function ([i, { state: s }]) { return (i + 1) + ": " + s.entries[s.index - 1].url; }, description: "[1].title", icon: "[1].image" }; context.completions = tabs.closedTabs.entries(); }, count: true, literal: 0, privateData: true }); commands.add(["undoa[ll]"], "Undo closing of all closed tabs", function () { for (let i of iter(tabs.closedTabs)) window.undoCloseTab(0); }, { argCount: "0" }); } if (dactyl.has("session")) { commands.add(["wqa[ll]", "wq", "xa[ll]"], "Save the session and quit", function () { dactyl.quit(true); }, { argCount: "0" }); } }, completion: function initCompletion() { completion.buffer = function buffer(context, visible) { let { tabs } = modules; let filter = context.filter.toLowerCase(); let defItem = { parent: { getTitle: function () { return ""; } } }; let tabGroups = {}; tabs.getGroups(); tabs[visible ? "visibleTabs" : "allTabs"].forEach(function (tab, i) { let group = (tab.tabItem || tab._tabViewTabItem || defItem).parent || defItem.parent; if (!hasOwnProp(tabGroups, group.id)) tabGroups[group.id] = [group.getTitle(), []]; group = tabGroups[group.id]; group[1].push([i, tab.linkedBrowser]); }); context.pushProcessor(0, function (item, text, next) { return [ ["span", { highlight: "Indicator", style: "display: inline-block;" }, item.indicator], next.call(this, item, text) ]; }); context.process[1] = function (item, text) { return template.bookmarkDescription(item, template.highlightFilter(text, this.filter)); }; context.anchored = false; context.keys = { text: "text", description: "url", indicator: function (item) { return item.tab === tabs.getTab() ? "%" : item.tab === tabs.alternate ? "#" : " "; }, icon: "icon", id: "id", command: function () { return "tabs.select"; } }; context.compare = CompletionContext.Sort.number; context.filters[0] = CompletionContext.Filter.textDescription; for (let [id, vals] of iter(tabGroups)) context.fork(id, 0, this, function (context, [name, browsers]) { context.title = [name || "Buffers"]; context.generate = () => Array.map(browsers, function ([i, browser]) { let indicator = " "; if (i == tabs.index()) indicator = "%"; else if (i == tabs.index(tabs.alternate)) indicator = "#"; let tab = tabs.getTab(i, visible); let url = browser.contentDocument.location.href; i = i + 1; return { text: [i + ": " + (tab.label || /*L*/"(Untitled)"), i + ": " + url], tab: tab, id: i, url: url, icon: tab.image || BookmarkCache.DEFAULT_FAVICON }; }); }, vals); }; completion.tabGroup = function tabGroup(context) { context.title = ["Tab Groups"]; context.keys = { text: "id", description: function (group) { return group.getTitle() || group.getChildren().map(t => t.tab.label) .join(", "); } }; context.generate = () => { context.incomplete = true; tabs.getGroups(function ({ GroupItems }) { context.incomplete = false; context.completions = GroupItems.groupItems; }); }; }; }, events: function initEvents() { let tabContainer = gBrowser.mTabContainer; function callback() { tabs.timeout(function () { this.updateTabCount(); }); } for (let event of ["TabMove", "TabOpen", "TabClose"]) events.listen(tabContainer, event, callback, false); events.listen(tabContainer, "TabSelect", tabs.bound._onTabSelect, false); }, mappings: function initMappings() { mappings.add([modes.COMMAND], ["", ""], "Execute the next mapping in a new tab", function ({ count }) { dactyl.forceTarget = dactyl.NEW_TAB; mappings.afterCommands((count || 1) + 1, () => { dactyl.forceTarget = null; }); }, { count: true }); mappings.add([modes.NORMAL], ["g0", "g^"], "Go to the first tab", function () { tabs.select(0); }); mappings.add([modes.NORMAL], ["g$"], "Go to the last tab", function () { tabs.select("$"); }); mappings.add([modes.NORMAL], ["gt"], "Go to the next tab", function ({ count }) { if (count != null) tabs.select(count - 1, false); else tabs.select("+1", true); }, { count: true }); mappings.add([modes.NORMAL], ["", "", ""], "Go to the next tab", function ({ count }) { tabs.select("+" + (count || 1), true); }, { count: true }); mappings.add([modes.NORMAL], ["gT", "", "", ""], "Go to previous tab", function ({ count }) { tabs.select("-" + (count || 1), true); }, { count: true }); if (config.has("tabbrowser")) { mappings.add([modes.NORMAL], ["b"], "Open a prompt to switch buffers", function ({ count }) { if (count != null) tabs.switchTo(String(count)); else CommandExMode().open("buffer! "); }, { count: true }); mappings.add([modes.NORMAL], ["B"], "Show buffer list", function () { tabs.list(false); }); mappings.add([modes.NORMAL], ["d"], "Delete current buffer", function ({ count }) { tabs.remove(tabs.getTab(), count || 1, false); }, { count: true }); mappings.add([modes.NORMAL], ["D"], "Delete current buffer, focus tab to the left", function ({ count }) { tabs.remove(tabs.getTab(), count || 1, true); }, { count: true }); mappings.add([modes.NORMAL], ["gb"], "Repeat last :buffer command", function ({ count }) { tabs.switchTo(null, null, count, false); }, { count: true }); mappings.add([modes.NORMAL], ["gB"], "Repeat last :buffer command in reverse direction", function ({ count }) { tabs.switchTo(null, null, count, true); }, { count: true }); // TODO: feature dependencies - implies "session"? if (dactyl.has("tabs_undo")) { mappings.add([modes.NORMAL], ["u"], "Undo closing of a tab", function ({ count }) { ex.undo({ "#": count }); }, { count: true }); } mappings.add([modes.NORMAL], ["", ""], "Select the alternate tab or the [count]th tab", function ({ count }) { if (count != null) tabs.switchTo(String(count), false); else tabs.selectAlternateTab(); }, { count: true }); } }, options: function initOptions() { options.add(["showtabline", "stal"], "Define when the tab bar is visible", "string", true, { setter: function (value) { if (value === "never") tabs.tabStyle.enabled = true; else { prefs.safeSet("browser.tabs.autoHide", value === "multitab", _("option.safeSet", "showtabline")); tabs.tabStyle.enabled = false; } if (value !== "multitab") if (tabs.xulTabs) tabs.xulTabs.visible = value !== "never"; else config.tabStrip.collapsed = false; if (gBrowser.tabContainer._positionPinnedTabs) gBrowser.tabContainer._positionPinnedTabs(); return value; }, values: { "never": "Never show the tab bar", "multitab": "Show the tab bar when there are multiple tabs", "always": "Always show the tab bar" } }); if (config.has("tabbrowser")) { let activateGroups = [ ["all", "Activate everything"], ["addons", ":addo[ns] command"], ["bookmarks", "Tabs loaded from bookmarks", "loadBookmarksInBackground"], ["diverted", "Links with targets set to new tabs", "loadDivertedInBackground"], ["downloads", ":downl[oads] command"], ["extoptions", ":exto[ptions] command"], ["help", ":h[elp] command"], ["homepage", "gH mapping"], ["links", "Middle- or Control-clicked links", "loadInBackground"], ["quickmark", "go and gn mappings"], ["tabopen", ":tabopen[!] command"], ["paste", "P and gP mappings"] ]; options.add(["activate", "act"], "Define when newly created tabs are automatically activated", "stringlist", activateGroups.slice(1) .filter(g => (!g[2] || !prefs.get("browser.tabs." + g[2]))) .map(g => g[0]) .join(","), { values: activateGroups, has: Option.has.toggleAll, setter: function (newValues) { let valueSet = new RealSet(newValues); for (let group of activateGroups) if (group[2]) prefs.safeSet("browser.tabs." + group[2], !(valueSet.has("all") ^ valueSet.has(group[0])), _("option.safeSet", "activate")); return newValues; } }); options.add(["newtab"], "Define which commands should output in a new tab by default", "stringlist", "", { values: { "all": "All commands", "extoptions": ":exto[ptions] command", "help": ":h[elp] command", "prefs": ":pref[erences]! or :prefs! command" }, has: Option.has.toggleAll }); // TODO: Is this really applicable to Melodactyl? options.add(["popups", "pps"], "Where to show requested popup windows", "stringlist", "tab", { setter: function (values) { let open = 1, restriction = 0; for (let opt of values) { if (opt == "tab") open = 3; else if (opt == "window") open = 2; else if (opt == "resized") restriction = 2; } prefs.safeSet("browser.link.open_newwindow", open, _("option.safeSet", "popups")); prefs.safeSet("browser.link.open_newwindow.restriction", restriction, _("option.safeSet", "popups")); return values; }, values: { "tab": "Open popups in a new tab", "window": "Open popups in a new window", "resized": "Open resized popups in a new window" } }); } } }); // vim: set fdm=marker sw=4 sts=4 ts=8 et: dactyl-1.2~r20151231/common/contrib/000077500000000000000000000000001264147376100167765ustar00rootroot00000000000000dactyl-1.2~r20151231/common/contrib/fix_symlinks.py000066400000000000000000000012001264147376100220600ustar00rootroot00000000000000from mercurial import util import os def fix_symlinks(ui, repo, hooktype, parent1, **kwargs): revert = hooktype in ('precommit', 'preupdate') ctxt = repo[parent1] for filename in ctxt: file = ctxt[filename] if 'l' in file.flags(): path = repo.wjoin(file.path()) try: os.unlink(path) except Exception, e: print repr(e) if revert: repo.wwrite(file.path(), file.data(), '') else: target = os.path.join(os.path.dirname(path), file.data()) util.copyfiles(target, path, True) dactyl-1.2~r20151231/common/javascript.vim000066400000000000000000000431221264147376100202230ustar00rootroot00000000000000" Vim syntax file " Language: JavaScript " Maintainer: Yi Zhao (ZHAOYI) " Last Change: May 17, 2007 " Version: 0.7.5 " Changes: 1, Get the vimdiff problem fixed finally. " Matthew Gallant reported the problem and test the fix. ;) " 2, Follow the suggestioin from Ingo Karkat. " The 'foldtext' and 'foldlevel' settings should only be " changed if the file being edited is pure JavaScript, " not if JavaScript syntax is embedded inside other syntaxes. " 3, Remove function FT_JavaScriptDoc(). " Since VIM do the better than me. " " TODO: " - Add the HTML syntax inside the JSDoc if !exists("main_syntax") if version < 600 syntax clear elseif exists("b:current_syntax") finish endif let main_syntax = 'javascript' endif "" Drop fold if it set but VIM doesn't support it. let b:javascript_fold='true' if version < 600 " Don't support the old version unlet! b:javascript_fold endif syn include @xmlTop syntax/xml.vim unlet b:current_syntax syn include @cssTop syntax/css.vim unlet b:current_syntax "" dollar sigh is permittd anywhere in an identifier setlocal iskeyword+=$ syntax sync fromstart syntax sync maxlines=200 "" JavaScript comments syntax keyword javaScriptCommentTodo TODO FIXME XXX TBD contained syntax region javaScriptLineComment start=+\/\/+ end="\v$|(\)@=" keepend contains=javaScriptCommentTodo,@Spell syntax region javaScriptLineComment start=+^\s*\/\/+ skip=+\n\s*\/\/+ end="\v$|(\)@=" keepend contains=javaScriptCommentTodo,@Spell fold syntax region javaScriptCvsTag start="\$\cid:" end="\$" oneline contained syntax region javaScriptComment start="/\*" end="\v\*/|(\)@=" contains=javaScriptCommentTodo,javaScriptCvsTag,@Spell fold "" JSDoc support start if !exists("javascript_ignore_javaScriptdoc") syntax case ignore "" syntax coloring for javadoc comments (HTML) "syntax include @javaHtml :p:h/html.vim "unlet b:current_syntax syntax region javaScriptDocComment matchgroup=javaScriptComment start="/\*\*\s*$" end="\*/" contains=javaScriptDocTags,javaScriptCommentTodo,javaScriptCvsTag,@javaScriptHtml,@Spell fold syntax match javaScriptDocTags contained "@\(param\|argument\|requires\|exception\|throws\|type\|class\|extends\|see\|link\|member\|module\|method\|title\|namespace\|optional\|default\|base\|file\)\>" nextgroup=javaScriptDocParam,javaScriptDocSeeTag skipwhite syntax match javaScriptDocTags contained "@\(beta\|deprecated\|description\|fileoverview\|author\|license\|version\|returns\=\|constructor\|private\|protected\|final\|ignore\|addon\|exec\)\>" syntax match javaScriptDocParam contained "\%(#\|\w\|\.\|:\|\/\)\+" syntax region javaScriptDocSeeTag contained matchgroup=javaScriptDocSeeTag start="{" end="}" contains=javaScriptDocTags syntax case match endif "" JSDoc end syntax case match "" Syntax in the JavaScript code syntax match javaScriptSpecial "\\\d\d\d\|\\x\x\{2\}\|\\u\x\{4\}\|\\." syntax region javaScriptStringD start=+"+ skip=+\\\\\|\\$"+ end=+"+ contains=javaScriptSpecial,@htmlPreproc syntax region javaScriptStringS start=+'+ skip=+\\\\\|\\$'+ end=+'+ contains=javaScriptSpecial,@htmlPreproc syntax region javaScriptRegexpString start=+/\(\*\|/\)\@!+ skip=+\\\\\|\\/+ end=+/[gim]\{-,3}+ contains=javaScriptSpecial,@htmlPreproc oneline syntax match javaScriptNumber /\<-\=\d\+L\=\>\|\<0[xX]\x\+\>/ syntax match javaScriptFloat /\<-\=\%(\d\+\.\d\+\|\d\+\.\|\.\d\+\)\%([eE][+-]\=\d\+\)\=\>/ syntax match javaScriptLabel /\(?\s*\)\@/ syntax match javaScriptDomElemFuncs contained /\%(insertBefore\|replaceChild\|removeChild\|appendChild\|hasChildNodes\|cloneNode\|normalize\|isSupported\|hasAttributes\|getAttribute\|setAttribute\|removeAttribute\|getAttributeNode\|setAttributeNode\|removeAttributeNode\|getElementsByTagName\|getAttributeNS\|setAttributeNS\|removeAttributeNS\|getAttributeNodeNS\|setAttributeNodeNS\|getElementsByTagNameNS\|hasAttribute\|hasAttributeNS\)\>/ nextgroup=javaScriptParen skipwhite " HTML things syntax match javaScriptHtmlElemAttrs contained /\%(className\|clientHeight\|clientLeft\|clientTop\|clientWidth\|dir\|id\|innerHTML\|lang\|length\|offsetHeight\|offsetLeft\|offsetParent\|offsetTop\|offsetWidth\|scrollHeight\|scrollLeft\|scrollTop\|scrollWidth\|style\|tabIndex\|title\)\>/ syntax match javaScriptHtmlElemFuncs contained /\%(blur\|click\|focus\|scrollIntoView\|addEventListener\|dispatchEvent\|removeEventListener\|item\)\>/ nextgroup=javaScriptParen skipwhite " CSS Styles in JavaScript syntax keyword javaScriptCssStyles contained color font fontFamily fontSize fontSizeAdjust fontStretch fontStyle fontVariant fontWeight letterSpacing lineBreak lineHeight quotes rubyAlign rubyOverhang rubyPosition syntax keyword javaScriptCssStyles contained textAlign textAlignLast textAutospace textDecoration textIndent textJustify textJustifyTrim textKashidaSpace textOverflowW6 textShadow textTransform textUnderlinePosition syntax keyword javaScriptCssStyles contained unicodeBidi whiteSpace wordBreak wordSpacing wordWrap writingMode syntax keyword javaScriptCssStyles contained bottom height left position right top width zIndex syntax keyword javaScriptCssStyles contained border borderBottom borderLeft borderRight borderTop borderBottomColor borderLeftColor borderTopColor borderBottomStyle borderLeftStyle borderRightStyle borderTopStyle borderBottomWidth borderLeftWidth borderRightWidth borderTopWidth borderColor borderStyle borderWidth borderCollapse borderSpacing captionSide emptyCells tableLayout syntax keyword javaScriptCssStyles contained margin marginBottom marginLeft marginRight marginTop outline outlineColor outlineStyle outlineWidth padding paddingBottom paddingLeft paddingRight paddingTop syntax keyword javaScriptCssStyles contained listStyle listStyleImage listStylePosition listStyleType syntax keyword javaScriptCssStyles contained background backgroundAttachment backgroundColor backgroundImage gackgroundPosition backgroundPositionX backgroundPositionY backgroundRepeat syntax keyword javaScriptCssStyles contained clear clip clipBottom clipLeft clipRight clipTop content counterIncrement counterReset cssFloat cursor direction display filter layoutGrid layoutGridChar layoutGridLine layoutGridMode layoutGridType syntax keyword javaScriptCssStyles contained marks maxHeight maxWidth minHeight minWidth opacity MozOpacity overflow overflowX overflowY verticalAlign visibility zoom cssText syntax keyword javaScriptCssStyles contained scrollbar3dLightColor scrollbarArrowColor scrollbarBaseColor scrollbarDarkShadowColor scrollbarFaceColor scrollbarHighlightColor scrollbarShadowColor scrollbarTrackColor " Highlight ways syntax match javaScriptDotNotation "\." nextgroup=javaScriptPrototype,javaScriptDomElemAttrs,javaScriptDomElemFuncs,javaScriptHtmlElemAttrs,javaScriptHtmlElemFuncs syntax match javaScriptDotNotation "\.style\." nextgroup=javaScriptCssStyles endif "DOM/HTML/CSS "" end DOM/HTML/CSS specified things "" Code blocks syntax cluster javaScriptAll contains=javaScriptComment,javaScriptLineComment,javaScriptDocComment,javaScriptStringD,javaScriptStringS,javaScriptRegexpString,javaScriptNumber,javaScriptFloat,javaScriptLabel,javaScriptSource,javaScriptType,javaScriptOperator,javaScriptBoolean,javaScriptNull,javaScriptFunction,javaScriptConditional,javaScriptRepeat,javaScriptBranch,javaScriptStatement,javaScriptGlobalObjects,javaScriptExceptions,javaScriptFutureKeys,javaScriptDomErrNo,javaScriptDomNodeConsts,javaScriptHtmlEvents,javaScriptDotNotation,javascriptCSS,javascriptCDATA syntax region javaScriptBracket matchgroup=javaScriptBracket transparent start="\[" end="\]" contains=@javaScriptAll,javaScriptParensErrB,javaScriptParensErrC,javaScriptBracket,javaScriptParen,javaScriptBlock,@htmlPreproc syntax region javaScriptParen matchgroup=javaScriptParen transparent start="(" end=")" contains=@javaScriptAll,javaScriptParensErrA,javaScriptParensErrC,javaScriptParen,javaScriptBracket,javaScriptBlock,@htmlPreproc syntax region javaScriptBlock matchgroup=javaScriptBlock transparent start="{" end="}" contains=@javaScriptAll,javaScriptParensErrA,javaScriptParensErrB,javaScriptParen,javaScriptBracket,javaScriptBlock,@htmlPreproc syntax region javascriptCDATA matchgroup=javascriptCDATA start="<\!\[CDATA\[" end="\]\]>" keepend contains=javascriptCSS syntax region javascriptCSS matchgroup=javascriptCSSDelimiter start="" end="" contains=@cssTop "" catch errors caused by wrong parenthesis syntax match javaScriptParensError ")\|}\|\]" syntax match javaScriptParensErrA contained "\]" syntax match javaScriptParensErrB contained ")" syntax match javaScriptParensErrC contained "}" if main_syntax == "javascript" syntax sync ccomment javaScriptComment endif "" Fold control if exists("b:javascript_fold") syntax match javaScriptFunction /\/ nextgroup=javaScriptFuncName skipwhite syntax match javaScriptOpAssign /=\@= 508 || !exists("did_javascript_syn_inits") if version < 508 let did_javascript_syn_inits = 1 command -nargs=+ HiLink hi link else command -nargs=+ HiLink hi def link endif HiLink javascriptCDATA String HiLink javaScriptComment Comment HiLink javaScriptLineComment Comment HiLink javaScriptDocComment Comment HiLink javaScriptCommentTodo Todo HiLink javaScriptCvsTag Function HiLink javaScriptDocTags Special HiLink javaScriptDocSeeTag Function HiLink javaScriptDocParam Function HiLink javaScriptStringS String HiLink javaScriptStringD String HiLink javaScriptRegexpString String HiLink javaScriptCharacter Character HiLink javaScriptPrototype Type HiLink javaScriptConditional Conditional HiLink javaScriptBranch Conditional HiLink javaScriptRepeat Repeat HiLink javaScriptStatement Statement HiLink javaScriptFunction Function HiLink javaScriptError Error HiLink javaScriptParensError Error HiLink javaScriptParensErrA Error HiLink javaScriptParensErrB Error HiLink javaScriptParensErrC Error HiLink javaScriptOperator Operator HiLink javaScriptType Type HiLink javaScriptNull Type HiLink javaScriptNumber Number HiLink javaScriptFloat Number HiLink javaScriptBoolean Boolean HiLink javaScriptLabel Label HiLink javaScriptSpecial Special HiLink javaScriptSource Special HiLink javaScriptGlobalObjects Special HiLink javaScriptExceptions Special HiLink javaScriptDomErrNo Constant HiLink javaScriptDomNodeConsts Constant HiLink javaScriptDomElemAttrs Label HiLink javaScriptDomElemFuncs PreProc HiLink javaScriptHtmlEvents Special HiLink javaScriptHtmlElemAttrs Label HiLink javaScriptHtmlElemFuncs PreProc HiLink javaScriptCssStyles Label delcommand HiLink endif " Define the htmlJavaScript for HTML syntax html.vim "syntax clear htmlJavaScript "syntax clear javaScriptExpression syntax cluster htmlJavaScript contains=@javaScriptAll,javaScriptBracket,javaScriptParen,javaScriptBlock,javaScriptParenError syntax cluster javaScriptExpression contains=@javaScriptAll,javaScriptBracket,javaScriptParen,javaScriptBlock,javaScriptParenError,@htmlPreproc let b:current_syntax = "javascript" if main_syntax == 'javascript' unlet main_syntax endif if exists('b:did_indent') finish endif let b:did_indent = 1 setlocal indentexpr=GetJsIndent() setlocal indentkeys=0{,0},0),:,!^F,O,e,=*/ " Clean CR when the file is in Unix format if &fileformat == "unix" silent! %s/\r$//g endif " Only define the functions once per Vim session. "if exists("*GetJsIndent") " finish "endif "function! GetJsIndent() " let pnum = prevnonblank(v:lnum - 1) " if pnum == 0 " return 0 " endif " let line = getline(v:lnum) " let pline = getline(pnum) " let ind = indent(pnum) " " if pline =~ '{\s*$\|[\s*$\|(\s*$' " let ind = ind + &sw " endif " " if pline =~ ';\s*$' && line =~ '^\s*}' " let ind = ind - &sw " endif " " if pline =~ '\s*]\s*$' && line =~ '^\s*),\s*$' " let ind = ind - &sw " endif " " if pline =~ '\s*]\s*$' && line =~ '^\s*}\s*$' " let ind = ind - &sw " endif " " if line =~ '^\s*});\s*$\|^\s*);\s*$' && pline !~ ';\s*$' " let ind = ind - &sw " endif " " if line =~ '^\s*})' && pline =~ '\s*,\s*$' " let ind = ind - &sw " endif " " if line =~ '^\s*}();\s*$' && pline =~ '^\s*}\s*$' " let ind = ind - &sw " endif " " if line =~ '^\s*}),\s*$' " let ind = ind - &sw " endif " " if pline =~ '^\s*}\s*$' && line =~ '),\s*$' " let ind = ind - &sw " endif " " if pline =~ '^\s*for\s*' && line =~ ')\s*$' " let ind = ind + &sw " endif " " if line =~ '^\s*}\s*$\|^\s*]\s*$\|\s*},\|\s*]);\s*\|\s*}]\s*$\|\s*};\s*$\|\s*})$\|\s*}).el$' && pline !~ '\s*;\s*$\|\s*]\s*$' && line !~ '^\s*{' && line !~ '\s*{\s*}\s*' " let ind = ind - &sw " endif " " if pline =~ '^\s*/\*' " let ind = ind + 1 " endif " " if pline =~ '\*/$' " let ind = ind - 1 " endif " return ind "endfunction " vim: ts=4 dactyl-1.2~r20151231/common/locale/000077500000000000000000000000001264147376100165755ustar00rootroot00000000000000dactyl-1.2~r20151231/common/locale/en-US/000077500000000000000000000000001264147376100175245ustar00rootroot00000000000000dactyl-1.2~r20151231/common/locale/en-US/all.xml000066400000000000000000000026521264147376100210230ustar00rootroot00000000000000 all dactyl-1.2~r20151231/common/locale/en-US/autocommands.xml000066400000000000000000000073261264147376100227500ustar00rootroot00000000000000

Automatic commands

Autocommands are a way to automatically execute code when certain events happen.

:au :autocmd :autocmd! events filter cmd

Execute commands automatically on events.

When cmd is not given, list all commands defined for the given events and filter. When ! is given, delete the matching commands rather than listing them.

When cmd is given, add it to the list of commands to be executed when events occur for pages matching the comma-separated list of site-filters, filter. If the -javascript (short name -js) option is given, cmd is interpreted as JavaScript code. Otherwise, it is interpreted as an Ex command.

If the -group=group flag is given, add this autocommand to the named group. Any filters for group apply in addition to filter. When listing commands this limits the output to the specified group.

Available events:

For Ex cmds, the following keywords are replaced with the appropriate value before the commands are executed. For JavaScript commands, they may be accessed as ordinary variables, sans angle brackets.

:doautoa :doautoall :doautoall event url

Apply all event autocommands matching the specified url to all buffers. If no url is specified use the current URL.

:do :doautocmd :doautocmd event url

Apply all autocommands matching the specified url to the current buffer. If no url is specified use the current URL.

Examples

Enable Pass Through mode on all Google sites:

:autocmd LocationChange google.com :normal!

Enable Pass Through mode on some Google sites:

:autocmd LocationChange www.google.com,mail.google.com :normal!

or

:autocmd LocationChange ^https?://(www|mail)\.google\.com/ :normal!

Set the filetype to mail when editing email at Gmail:

:autocmd LocationChange !mail.google.com,* :autocmd LocationChange mail.google.com gvim -f -c 'set ft=mail' +<line> dactyl-1.2~r20151231/common/locale/en-US/browsing.xml000066400000000000000000000400211264147376100220750ustar00rootroot00000000000000

Browsing

Opening web pages

o :o :open :open args o

Open a single URL in the current tab, or multiple URLs in the current tab and background tabs. URLs may be separated with urlseparator, in which case the first URL is opened in the current tab and the rest are opened in new background tabs.

Each URL may be one of the following:

  1. A local filename, if it begins with /, ./, or ~/ and the specified file exists.

  2. A search or bookmark keyword, or a search engine name, followed by search arguments.

    :open wikipedia Linus Torvalds

    Search engines can be edited via :dialog searchengines and search keywords may be added by right clicking any search box and selecting Add a Keyword for this Search.

  3. Any search string which does not look like a URL or hostname, which will be passed to the default search engine (see defsearch).

    :open Linus Torvalds
  4. Any other value is passed directly to &dactyl.host; and must be a valid URL or hostname.

:open provides powerful URL completion from several possible sources, which can be adjusted via the complete option.

t :t :tabopen :tabnew :tabopen! args t

Like :open, but all arguments are opened in new tabs. The first new tab is activated if activate contains tabopen or ! is provided.

O O

Open an :open prompt followed by the current URL.

T T

Open a :tabopen prompt followed by the current URL.

s s

Open a search prompt.

 S S

Open a search prompt for a new tab.

 :tabdu :tabduplicate :counttabduplicate!

Duplicates current tab count times. The first new tab is activated if activate contains tabopen or ! is provided.

w :winopen :wopen :winopen! args w

Like :tabopen, but all arguments are opened in a single new window.

When called via :private, the new window is a private browsing window.

W W

Open a :winopen prompt followed by the current URL.

p]]> p

Open (put) a URL based on the current clipboard contents, or, on X11 systems, the currently selected text. All white space is stripped from the selection and it is opened in the same manner as :open.

<tab-open-clipboard-url> P P

Open (put) a URL based on the current clipboard contents in a new buffer. Works like p but opens a new tab. The new tab is activated if activate contains paste.

gP gP

Open (put) a URL based on the current clipboard contents in a new buffer. The new tab is activated if activate does not contain paste.

]]> count<C-x>

Decrements the last number in URL by 1, or by count if given. Negative numbers are not supported as trailing numbers in URLs are often preceded by hyphens.

]]> count<C-a>

Increments the last number in URL by 1, or by count if given.

History

]]> count]]>

Go to an older position in the jump list. If count is specified, jump count positions backward.

]]> count]]>

Go to a newer position in the jump list. If count is specified, jump count positions forward.

:ju :jumps :jumps

Display the jump list. The jump numbers shown are suitable as arguments to or .

H]]> [count]H

Go back in the browser history. If count is specified, go back count pages.

L]]> countL

Go forward in the browser history. If count is specified, go forward count pages.

:ba :back :countback url :countback!

Go back in the browser history. If count is specified, go back count pages.

The special version :back! goes to the beginning of the browser history.

:fw :fo :forward :countforward url :countforward!

Go forward in the browser history. If count is specified, go forward count pages.

The special version :forward! goes to the end of the browser history.

count[d

Go to the countth previous domain in the history stack.

count]d

Go to the countth next domain in the history stack.

:hs :hist :history :history! filter

Show recently visited URLs. Opens the message window at the bottom of the screen with all history items whose page titles or URLs match filter.

The special version :history! works the same as :history except that it opens all matching pages in new tabs rather than listing them.

The pages may also be filtered via the following options,

-max
The maximum number of items to list or open (short name -m).
-sort
The sort order of the results (short name -s).

Navigating

~]]> ~

Open home directory. Equivalent to :open ~/

 gh]]> gh

Go home. Opens the homepage in the current tab.

 gH]]> gH

Go home in a new tab. Opens the homepage in a new tab. The new tab is activated if activate contains homepage.

gu]]> countgu

Go to countth parent directory.

For example, at the URL http://www.example.com/dir1/dir2/file.htm, 2gu opens http://www.example.com/dir1/.

gU]]> gU

Go to the root of the web site.

For example, at the URL http://www.example.com/dir1/dir2/file.htm, gU opens http://www.example.com/.

Reloading

<reload> r r

Reload the current web page.

 <full-reload> R R

Reload the current web page without using the cache.

 :re :reload :reload!

Reload current web page. If ! is given, reload without using the cache.

:reloada :reloadall :reloadall!

Reload all tabs. If ! is given, reload without using the cache.

Stopping

:st :stop]]> <C-c> :stop

Stop loading the current web page.

 :stopa :stopall :stopall

Stop loading all web pages.

Writing

:w :write :sav :saveas :saveas! file

Save current web page to disk. If file is omitted, save to the page's default filename. If file is a directory or ends with your platform's path separator, save to the page's default filename in that directory. Existing documents will only be overwritten if ! is given.

:write >> file

Appends the current web page to the file file. The given file must already exist.

:write !cmd

Writes the current web page to cmd and prints the command's output.

Quitting

ZQ :x :exit :exit!

Quit &dactyl.appName;, no matter how many tabs/windows are open. The session is not stored. Use ! to forcibly quit.

:q :quit :quit

Quit current tab. If this is the last tab in the window, close the window.

:qa :qall :quita :quitall :quitall

Close the current &dactyl.appName; window, no matter how many tabs are open.

:wc :wclose :winc :winclose :winclose

Close the current window.

 :winon :winonly :winonly

Close all windows but the current.

 ZZ :xa :xall :wq :wqa :wqall :wqall :xall

Save the current session and quit.

Unlike Vim, :wq closes the entire window rather than just the current tab.

The current directory

:chd :chdir :cd :cd path

Change the current directory. If path is -, change to the previous directory. If it is omitted, change to the home directory.

:pw :pwd :pwd

Print the current directory name.

 dactyl-1.2~r20151231/common/locale/en-US/buffer.xml000066400000000000000000000357751264147376100215400ustar00rootroot00000000000000

Buffer

A buffer is a container that holds the given web page, including all of its history and frames. Each tab contains exactly one buffer, and for most purposes the two terms are interchangeable. See tabs for more.

Buffer information

]]> <C-g>

Print the current file name along with basic page information including last modification time, the number of feeds present, and the page title.

g]]> g<C-g>

Print file information. Same as :pageinfo.

 :pa :pageinfo :pageinfo items

Show various page information. The information provided is determined by the value of pageinfo, or items if present.

gf]]> gf

View source. Toggles between the source and rendered content of the page.

gF]]> gF

View source with an external editor. Opens the source code of the current web site with the external editor specified by the editor option.

:vie :viewsource :viewsource! url

View source code of current document. If url is specified then view the source of that document. When ! is given, it is opened with the external editor.

Motion commands

<scroll-begin> ^ 0 0

Scroll to the absolute left of the document. Unlike in Vim, 0 and ^ work exactly the same way.

<scroll-end> $ $

Scroll to the absolute right of the document

 gg]]> countgg

Go to the top of the document. With count, scroll vertically to count percent of the document.

G]]> countG

Go to the end of the document. With count, go to the countth line as determined by linenumbers, or by the line height of the document body otherwise.

<scroll-percent> N% % count%

Scroll to count percent of the document.

 h]]> counth

Scroll document to the left. If count is specified, repeat count times.

j]]> countj

Scroll document to the down. If count is specified, repeat count times.

k]]> countk

Scroll document to the up. If count is specified, repeat count times.

l]]> countl

Scroll document to the right. If count is specified, repeat count times.

]]> count<C-d>

Scroll window downwards by the amount specified in the scroll option. With count, set the scroll option to count before executing the command.

]]> count<C-u>

Scroll window upwards by the amount specified in the scroll option. With count, set the scroll option to count before executing the command.

]]> count<C-b>

Scroll up a full page. With count, scroll up count full pages.

]]> count<C-f>

Scroll down a full page. With count, scroll down count full pages.

Jumping to elements

]]> <Tab>

Advance keyboard focus to the next element.

 ]]> <S-Tab>

Rewind keyboard focus to the previous element.

 <focus-input> gi countgi

Focus last used input field. If there is no last input field, focus the first input field. With count, focus the countth input field.

<next-frame> ]f count]f

Transfer keyboard focus to the countth next frame. The newly focused frame is briefly highlighted with FrameIndicator.

<previous-frame> [f count[f

Transfer keyboard focus to the countth next previous frame. The newly focused frame is briefly highlighted with FrameIndicator.

<next-page> ]] count]]

Follow the last link matching nextpattern. Used, for instance, to move to the next page of search results.

<previous-page> [[ count[[

Follow the last link matching previouspattern. Used, for instance, to move to the previous page of search results.

[h [p [ count[arg

Jump to the previous element as defined by jumptags.

 ]h ]p ] count]arg

Jump to the next element as defined by jumptags.

 g] countg]arg

Jump to the next off-screen element as defined by jumptags.

 { count{

Jump to the previous paragraph. Identical to [p.

 } count}

Jump to the next paragraph. Identical to ]p.

Zooming

The zooming commands are dependent on two properties—a zoom range and a series of levels within that range.

The absolute value of the page zoom is limited to a value within the configured zoom range (default: 30%–300%). By default, commands which zoom in or out select between the zoom levels, 30%, 50%, 67%, 80%, 90%, 100%, 110%, 120%, 133%, 150%, 170%, 200%, 240%, 300%.

The available zoom range can be changed by setting the zoom.minPercent and zoom.maxPercent &dactyl.host; preferences. The zoom levels can be changed using the toolkit.zoomManager.zoomValues preference.

toolkit.zoomManager.zoomValues is specified as a list of values between 0 and 1 rather than percentages. For instance, 0.5 is equivalent to 50%. + zi]]> countzi

Enlarge text zoom of current web page. Mnemonic: zoom in.

 zm]]> countzm

Enlarge text zoom of current web page by a larger amount. Mnemonic: zoom more.

 - zo]]> countzo

Reduce text zoom of current web page. Mnemonic: zoom out.

 zr]]> countzr

Reduce text zoom of current web page by a larger amount. Mnemonic: zoom reduce.

 zz]]> countzz

Set text zoom value of current web page. Zoom value can be between 30% and 300%. If it is omitted, text zoom is reset to 100%.

ZI zI]]> countZI

Enlarge full zoom of current web page. Mnemonic: zoom in.

 ZM zM]]> countZM

Enlarge full zoom of current web page by a larger amount. Mnemonic: zoom more.

 ZO zO]]> countZO

Reduce full zoom of current web page. Mnemonic: zoom out.

 ZR zR]]> countZR

Reduce full zoom of current web page by a larger amount. Mnemonic: zoom reduce.

 zZ]]> countzZ

Set full zoom value of current web page. Zoom value can be between 30 and 300%. If it is omitted, full zoom is reset to 100%.

:zo :zoom :zoom! value :zoom! +value :zoom! -value

Set zoom value of current web page. value can be an absolute value between 30% and 300% or a relative value if prefixed with "-" or "+". If value is omitted, zoom is reset to 100%.

Normally this command operates on the text zoom; if used with !, it operates on full zoom.

Working with frames

:frameo :frameonly :frameonly

Show only the current frame's page.

Copying text

When running in X11, the text of the following commands is not only copied to the clipboard but is also put into the X11 selection, which can be pasted with the middle mouse button:

<yank-location> y y

Yank current location to the clipboard. See also yankshort.

 <yank-selection> Y Y

Copy currently selected text to the system clipboard.

Alternate style sheets

Page authors may specify alternate style sheets for an HTML document. Users can then switch between these various style sheets, selecting their favorite. :pagest :pagestyle :pagestyle stylesheet

Select the author style sheet to apply. If stylesheet is not specified the page's default style sheet is used.

All author styling can be removed by setting the usermode option.

 dactyl-1.2~r20151231/common/locale/en-US/cmdline.xml000066400000000000000000000252021264147376100216620ustar00rootroot00000000000000

Command Line mode

&dactyl.appName;'s Command Line mode is perhaps its most powerful interface. In this mode, the command input bar at the bottom of the window is given the keyboard focus for any of a variety of required inputs. In addition to access to almost every aspect of &dactyl.appName; and &dactyl.host;, the command line provides power and comprehensive completion for all of its commands, along with concise descriptions for each command and all of its arguments. Couple this with persistent, searchable command history, and you have a very efficient interface for easily performing simple and complex tasks.

Included among the several command-line modes are Ex command mode (the standard mode for entering commands), Find mode (for searching the current page), Prompt mode (for selecting files, confirming actions), and Hints mode (for selecting links and other items on a page).

: :

Opens the command line in Ex mode. This is the mode used for entering the various commands listed in ex-cmd-index.

Command-line editing

]]> <C-i>

Launch the external editor. See the editor option.

 ]]> <C-c>

Quit Command Line mode without executing.

 ]]> <C-]>

Expand a command-line abbreviation.

 c_ c_]]> <Up>

Recall from command history the previous command line which begins with the current input value.

c_ c_]]> <Down>

Recall from command history the next command line which begins with the current input value.

c_ c_]]> <S-Up> <PageUp>

Recall the previous command line from the history list.

 c_ c_]]> <S-Down> <PageDown>

Recall the next command line from the history list.

Command-line completion

c_]]> <Tab>

Complete the word in front of the cursor according to the behavior specified in wildmode. If wildmode contains list and there are multiple matches then the completion menu window is opened.

c_]]> <S-Tab>

Complete the previous full match when wildmode contains full.

 c_]]> <A-Tab>

Similar to , but the completion behavior is specified by the altwildmode option.

c_]]> <A-S-Tab>

The equivalent for altwildmode.

 c_ c_]]> <C-Tab>

Select the next matching completion group.

 c_ c_]]> <C-S-Tab>

Select the previous matching completion group.

Ex command lines

:bar

Multiple commands, separated by a | can be given in a single command line and will be executed consecutively. | can be included as an argument to a command by escaping it with a backslash. E.g. :map \| :echo bar Several commands process the entire command-line string literally. These commands will include any | as part of their argument string and so cannot be followed by another command. The list of these commands is:

  • :abbreviate
  • :autocmd
  • :cabbreviate
  • :cmap
  • :cnoremap
  • :command
  • :delmacros
  • :delmarks
  • :delqmarks
  • :delstyle
  • :echo
  • :echoerr
  • :echomsg
  • :elseif
  • :execute
  • :highlight
  • :iabbreviate
  • :if
  • :imap
  • :inoremap
  • :javascript
  • :let
  • :map
  • :marks
  • :nmap
  • :nnoremap
  • :noremap
  • :open
  • :qmarks
  • :silent
  • :style
  • :styledisable
  • :styleenable
  • :styletoggle
  • :tabopen
  • :toolbarhide
  • :toolbarshow
  • :toolbartoggle
  • :vmap
  • :vnoremap
  • :winopen
  • :yank

Ex command-line arguments

Most Ex commands accept a number of options and arguments. Arguments and options are generally separated by spaces, and treat a number of characters, including \, ', ", and |, specially. Moreover, certain arguments have their own special characters. For instance, when using :set to change a stringlist option, the comma character is used to separate elements of said list. Or when calling :autocmd, the pattern given may be negated by prefixing it with a !. In order to use these characters in command arguments, stripped of their special meaning, they must be quoted.

&dactyl.appName; offers four distinct quoting styles, each with its own distinct advantages and disadvantages. The first, and most basic, is the automatic quoting applied to the commands listed in :bar. When any of these commands is invoked, their final argument is always interpreted literally. No characters have special meaning whatsoever, and no care need be taken to quote anything. Additionally, the following three optional quoting characters are available:

\
This is the most basic quoting character. When it is encountered outside of single or double quotes, it forces the next character to be interpreted literally. So, for instance, \\ ⇒ \, \' ⇒ ', \a ⇒ a, and \␣ ⇒ ␣.
'
Any character inside single quotes aside from the ' character itself is interpreted literally. To include a literal single quote, it must be doubled. So, 'foo\ ''bar\\ baz\' ⇒ foo\ 'bar\\ baz\
"
Any character inside of double quotes except for " and \ is interpreted literally. A literal double quote may be included by preceding it with a backslash. Any other occurrence of a backslash starts an escape sequence as in JSON strings. Among the available escape sequences are:
\n
A newline character.
\t
A tab character.
\uxxxx
Where each x is a digit between 0 and F, a Unicode character at code-point xxxx.

Many Ex commands accept option arguments in addition to regular arguments. Option arguments begin with a hyphen (-), and often have a short form and a long form, such as -name and -n. Most options accept arguments, which come after the option separated by either a space or an equal sign. For instance, the following three forms, -name=foo, -name foo, and -n foo, are all acceptable and entirely equivalent.

dactyl-1.2~r20151231/common/locale/en-US/developer.xml000066400000000000000000000232671264147376100222450ustar00rootroot00000000000000 ]>

Developer information

Writing documentation

In order for any user-visible change to be accepted into the mainline, it must be accompanied by accurate documentation. The docs are written in an XML dialect similar to XHTML, with a few tags specific to our documentation. For example:

:help :h help :help subject

Open the help page. The default page, as specified by helpfile is shown unless subject is specified. If you need help for a specific topic, try :help overview.

creates a new help section for the command :help. It also creates help tags for the command, its shortcuts, the key binding, and the general topic, ‘help’. These tags enable linking to this section from other mentions of the topic and from the :help command.

Help tags

The following is a list of the more common XML tags used in help pages, along with their highlight groups.

Layout
p
A paragraph (HelpParagraph)
h1
A first-level heading (HelpHead1)
h2
A second-level heading (HelpHead2)
h3
A third-level heading (HelpHead3)
h4
A fourth-level heading (HelpHead4)
code
A pre-formatted code block. (HelpCode)
note
A note paragraph. (HelpNote)
strut
A horizontal strut which prevents any previous floating elements from appearing below it.
warning
A warning paragraph. (HelpWarning)
Generic
link
A generic link. (HelpLink)
&tab;@topic
The topic of the link. Either a help topic or a fully-qualified URI.
em
Emphasized text. (HelpEm)
str
A string, with its contents wrapped in quotes. (HelpString)
logo
&dactyl.appName;'s logo. (Logo)
Items
item
A help entry (HelpItem)
&tab;tags
See the 'Tagging' section (HelpTags)
&tab;spec
The specification for this item, such as an example command line. (HelpSpec)
&tab;strut
A horizontal formatting strut which ensures that all previous <tags> and <spec> elements appear above the ones that follow.
&tab;type
For options, the type of the option. number, boolean, string, stringlist, or charlist. (HelpType)
&tab;default
For options, the default value. (HelpDefault)
&tab;description
The description of this help item. (HelpDescription)
&tab;&tab;@short
Indicates that this is a short description which should appear between the specs and tags.
a
Required argument. (HelpArg)
oa
Optional argument. (HelpOptionalArg)
Tagging
tags
Space-separated list of strings to tag. Displayed right-aligned, and used for cross-linking. (HelpTags)
@tag
The tag attribute. Applied to any element, generates a <tags> element for the given tags. (HelpTag)
Linking
o
Link to an option. (HelpOpt)
ex
Link to an Ex command. (HelpEx)
k
Link to a key. (HelpKey)
&tab;@name
The name attribute to <k>. When provided, <value> is prepended to the element's contents, i.e., <k name="Tab"/> becomes .
&tab;@mode
The mode attribute to <k>. Some keys have different functions in different modes. You can use this attribute to specify which of the modes (other than Normal) a key pertains to. The <value> is prepended to the element's contents, i.e., <k name="C-i" mode="I"/> becomes , and <k mode="t">i</k> becomes i.
t
Links to an arbitrary help topic. (HelpTopic)
Plugins
@lang
When applied to any element under <plugin>, that element is only visible for a specific locale.
plugin
The container tag used for describing a plugin.
&tab;@name
The name of the plugin. Used as the plugin's help tag.
&tab;@version
The plugin's version number.
&tab;@href
The plugin's home page.
&tab;@summary
A short description of the plugin, shown in its section head.
info
An element with the same attributes as plugin, which may override the latter for specific locales
project
The project for which this plugin was intended.
&tab;@name
The name of the project (i.e., &dactyl.appName;)
&tab;@min-version
The minimum version of the project for which this plugin is intended to work.
&tab;@max-version
The maximum version of the project for which this plugin is intended to work.
author
The plugin's author. May appear more than once.
&tab;@href
The author's home page.
&tab;@email
The author's email address.
license
The plugin's license. May appear more than once.
&tab;@href
The URI of a page which shows or explains the license.

Generating documentation

You can also autogenerate most of the XML help after you have written a new command, mapping or option.

:echo dactyl.generateHelp(commands.get(addons), Extra text

]]>)

Writing plugins

Writing &dactyl.appName; plugins is incredibly simple. Plugins are simply JavaScript files which run with full chrome privileges and have full access to the &dactyl.appName; and &dactyl.host; APIs. Each plugin has its own global object, which means that the variables and functions that you create won't pollute the global window or private dactyl namespaces. This means that there's no need to wrap your plugin in a closure, as is often the practice in JavaScript development. Furthermore, any plugin which is installed in your runtimepath/plugins directory will find its context stored in plugins.<pluginName>, which is often invaluable during development and testing.

Plugins are always initialized after the main window is loaded, so there is no need to write load event handlers. Beyond that, what you may do with your plugins is practically limitless. Plugins have full access to all of the chrome resources that ordinary &dactyl.host; does, along with the entire power of the &dactyl.appName; API. If you need a starting point, have a look at some existing plugins or extensions, especially the &dactyl.appName; source.

Plugin documentation

Plugins should provide documentation, which will appear on the :help plugins page. The XML markup for help entries is similar to the above, but has to be written in JSON syntax. You can find some examples in the official plugins.

It is important that the documentation be assigned to the INFO variable, or &dactyl.appName; will not be able to find it. Beginning your file with use strict, while not required, helps to prevent a lot of common errors.

The documentation that you provide behaves exactly as other &dactyl.appName; documentation, which means that the tags you provide are available via :help with full tag completion and cross-referencing support. Although documentation is not required, we strongly recommend that all plugin authors provide at least basic documentation of the functionality of their plugins and of each of the options, commands, and especially mappings that they provide.

dactyl-1.2~r20151231/common/locale/en-US/editing.xml000066400000000000000000000024171264147376100216750ustar00rootroot00000000000000

Editing Text Fields

&dactyl.appName; provides several ways to edit text areas or input fields. After switching focus to a text field, Insert mode or Text Edit mode is activated, depending on your insertmode settings. You can also use an external editor.

Insert mode

In Insert mode, all keys except for those described in the index are passed directly to &dactyl.host;.

Text Edit mode

Text Edit mode provides basic Vim-like text editing. It can be entered from Insert mode by pressing or started directly when a text area is focused if insertmode is unset. See the index for a list of currently supported mappings.

dactyl-1.2~r20151231/common/locale/en-US/eval.xml000066400000000000000000000212111264147376100211720ustar00rootroot00000000000000

Expression evaluation

Much of the power of &dactyl.appName; lies in its scriptable expression evaluation. &dactyl.appName; understands two kinds of expressions: Ex commands, and JavaScript. Ex commands are simple, easy to type, and readily accessible from the &tag.command-line;. They form a core part of the user interface. JavaScript, on the other hand, is much less straightforward, but allows for any number of complex actions to be executed, with full access to all of the internals of &dactyl.appName; and &dactyl.host;. Both expression evaluation methods support sophisticated expression completion, including option lists and descriptions thereof, along with parentheses matching and syntax error highlighting.

JavaScript evaluation

:ec :echo :echo expr

Echo a JavaScript expression. expr may be a simple quoted string, in which case it is shown in the &tag.status-line;, or any arbitrary JavaScript expression. If the expression results in anything other than a string, it is pretty-printed in a multi-line frame just above the command line. The output depends on the type of object. Functions display their source, DOM nodes display the pretty-printed XML of the top-level node, XML literals are rendered as page content, and all other objects display their string representation and all of their enumerable properties.

See also :javascript.

 :echoe :echoerr :echoerr expr

Echo the expression as an error message. Just like :echo but echoes the result highlighted as with the ErrorMsg group and saves it to the message history.

:echom :echomsg :echomsg expr

Echo the expression as an informational message. Just like :echo but also saves the message in the message history.

:exe :execute :execute expr

Execute the Ex command string that results from the evaluation of the JavaScript expression expr. For example,

:execute open + content.location.host

opens the homepage of the currently opened site.

Unlike Vim this only supports a single argument. :js :javas :javascript :javascript cmd :javascript <<endpattern cmd … endpattern

Evaluates the given cmd as JavaScript. Behaves exactly as :echo, except that the result is not printed. Any exception raised by the evaluation will, however, be displayed as an error message and appended to :messages.

:javascript alert(Hello world) will open a dialog window with the message Hello world.

Moreover, multi-line scripts can be executed with shell-like here document syntax. For example, the following,

:javascript <<EOF for each (var tab in tabs.visibleTabs) tab.linkedBrowser.reload(); EOF

will reload all visible tabs.

Moreover, sophisticated, context-sensitive completion is available for JavaScript code, which extends to property names, object keys, and programmable completion for string function arguments. The completion code is designed to be both as safe and as powerful as possible. Expressions in a given command-line session will only be evaluated once, and, with auto-completion turned on, any completion which requires a function to be executed requires an explicit press to commence.

REPL :js! context :js! :javas! :javascript! :javascript! context

Starts the JavaScript Read Eval Print Loop, where JavaScript statements are entered and evaluated, their results printed, and the input modified and entered again. Within the REPL, the results of a given evaluation are available as variables named for the given prompt.

If context is given, then statements are executed in that global context.

js1> ({ foo: bar })[object Object]:: foo: "bar"js2> js1.foobar

Global Variables

:let :let var-name [+-.]= expr1 :let var-name :let All scripts which make use of :let should be updated to use the simpler and more powerful options system instead.

Sets or lists a variable. Sets the variable var-name to the value of the expression expr1. If no expression is given, the value of the variable is displayed. Without arguments, displays a list of all variables. This functionality has few useful applications and so is deprecated.

:unl :unlet :unlet! name … All scripts which make use of :unlet should be updated to use the simpler and more powerful options system instead.

Deletes the named variables. When ! is given, no error message is output for non-existing variables.

Conditionals

:if :if expr

Execute commands until the next :elseif, :else, or :endif only if the JavaScript expression expr evaluates to a true value.

:endif :en :fi :endif

Ends a string of :if/:elseif/:else conditionals.

:elseif :elsei :elif :elseif expr

Execute commands until the next :elseif, :else, or :endif only if the JavaScript expression expr evaluates to a true value.

:else :el :else

Execute commands until the next :endif only if the previous conditionals were not executed.

dactyl-1.2~r20151231/common/locale/en-US/faq.xml000066400000000000000000000220541264147376100210200ustar00rootroot00000000000000

Frequently Asked Questions

Below is a list of some of the commonest questions that come to our attention, along with their hopefully satisfactory answers. Please take a minute to search for your answers here before asking the mailing list or irc channel, and don't forget to peruse the NEWS file for recent changes that might throw you off balance.

General

Why did Pentadactyl split from Vimperator?

The reasons for the fork were mostly political, but mostly boil down to the fact that the current maintainer, while making no substantial contributions to the project for several years, continues to exercise full editorial control while actively soliciting donations with no transparency whatever. We considered the latter especially a slight on both our developers and our users, and after a considerable escalation of the degree of offense felt compelled to leave the project.

However, though we could no longer justify supporting the Vimperator project, we've invested considerable time and energy into the code over these past several years and still use and care about it. For that reason, we've decided to publicly release our personal changes and continue to develop the extension under a different name.

What differentiates Pentadactyl from Vimperator?

The main difference is that Vimperator's most active developers have moved on to Pentadactyl. More qualitative changes may be found in the change log, but essentially add up to what we consider more active and thoughtful development. Among the most visible differences, as of Pentadactyl 1.0, are more extensive Firefox 4 support, significantly better startup time and completion performance, considerably better :sanitize and private mode support, a greatly improved incremental find implementation, major improvements in Ex command parsing (including the ability to separate commands with | and split long commands across lines), conditionals (:if/:else) in configuration files, greatly updated documentation, and a number of bug fixes.

What do the "[-+♥]" symbols in the status bar mean?

These indicate that you can move backward through history, that you can move forward through history, and that the page is bookmarked, respectively. See also :help status-line.

How can I prevent d on the last tab from closing the window?

:set! browser.tabs.closeWindowWithLastTab=false

How can I prevent the command line completion list showing until I press ?

You can disable it entirely with or for specific types of command completion by choosing more restrictive values. See :help autocomplete and wildmode.

Why doesn't external input field editing work with my editor setting?

Unfortunately, external editors which return immediately, before editing is complete, are not supported. This means that gvim, for instance, must be run with the -f flag, and editors run from a terminal must not connect to a remote process. In the case of Rxvt-unicode, this means that the urxvtc program is not an option, and Gnome Terminal is very likely not useable under any circumstances.

If you are using a version of Firefox newer than 4.0 beta 7 and a version of Pentadactyl less than 1.0 βeta 4, you'll need to upgrade the latter.

Why can't I build/install from the Mercurial repository on Windows®?

We use symbolic links in our repository to deal with certain files which are common across projects. Mercurial for Windows®, unfortunately, doesn't deal with these very well. However, adding the following lines to the .hg\hgrc file in your repository should make things work:

[hooks] update = python:common/contrib/fix_symlinks.py:fix_symlinks preupdate = python:common/contrib/fix_symlinks.py:fix_symlinks commit = python:common/contrib/fix_symlinks.py:fix_symlinks precommit = python:common/contrib/fix_symlinks.py:fix_symlinks

:open behavior

Why can't I separate URLs in :open with a comma anymore?

See :help urlseparator

:open search-string or :open google search-string results in The url is not valid and cannot be loaded

You need a valid search engine name in the defsearch option. If it's stopped working suddenly, there's a good chance that you've either deleted a search engine or changed its alias. You can check by invoking :dialog searchengines There also appears to be a Firefox bug whereby the default engines are hidden after an update. This can be remedied by invoking :js services.browserSearch.getEngines().forEach(function (e) e.hidden = false)

Key bindings

How can I use the native key bindings of sites like Gmail?

See the passkeys option to automatically pass specific keys on sites of your choosing, or autocmd-examples to automatically enter Pass Through mode for certain websites.

Why doesn't my modes.passAllKeys autocmd work anymore?

See faq-website-keys above.

Hints

How can I use keys other than numbers for hinting?

Use the hintkeys option.

How can I display my hints in upper case but type them in lower case?

If you use alphabetic characters for your hintkeys and would like to be able to type them in lower case but still have the hints displayed in upper case, use:

:highlight -a Hint text-transform: uppercase;

How can I hide the hint text for input and image hints?

If you'd only like to show the numbered portion of hints, you can do so with:

:highlight Hint::after content: attr(number) !important; dactyl-1.2~r20151231/common/locale/en-US/gui.xml000066400000000000000000000234311264147376100210350ustar00rootroot00000000000000

&dactyl.host;'s GUI

Although &dactyl.appName; offers access to the most frequently used &dactyl.host; functionality via Ex and Normal mode commands, there may be times when direct access to the &dactyl.host; GUI is required. For such eventualities, there are commands to access menu items and to launch standard &dactyl.host; dialogs.

Menus

:emenu :emenu menu

Execute menu from the command line. This command provides command-line access to all menu items available from the main &dactyl.host; menubar. menu is a hierarchical path to the menu item with each submenu separated by a period. E.g. :emenu File.Open File… launches the standard &dactyl.host; ‘Open File’ dialog.

Dialogs

:ao :addo :addons :addons

Opens the add-on list.

 :dia :dialog :dialog &dactyl.host;-dialog

Open a &dactyl.host; dialog. Available dialogs include:

:dl :downl :downloads :downloads

Show progress of current downloads. Here, downloads can be paused, resumed, and canceled.

Available options include:

-sort
Sort order (see downloadsort) (short name: -s)
 :dlc :dlclear :dlclear

Clear completed downloads.

Add-ons

The following commands manipulate the currently installed add-ons. With the exception of :extadd, they all except the following arguments:

-types
The types of add-ons to operate on, the most common types being extension, theme, and plugin (short names -type, -t)
:exta :extadd :extadd file|url

Install an extension. file|uri must be the local file path or URL of an XPInstall (.xpi) file.

:extrm :extde :extdelete :extdelete extension :extdelete!

Uninstall an extension. extension is the extension's name. When ! is given all extensions are uninstalled.

:extd :extdisable :extdisable extension :extdisable!

Disable an extension. extension is the extension's name. When ! is given all extensions are disabled.

:exte :extenable :extenable extension :extenable!

Enable an extension. extension is the extension's name. When ! is given all extensions are enabled.

:exto :extoptions :extoptions! extension :extp :extpreferences :extpreferences! extension

Open the preferences dialog for an extension. If ! is given, open a dialog, otherwise open a buffer. See also newtab.

:extr :extrehash :extrehash extension :extrehash

Toggle an extension's enabled status twice. This is useful for rebooting a restartless extension.

:extt :exttoggle :exttoggle extension :exttoggle

Toggle an extension's enabled status.

:extu :extupdate :extupdate extension :extupdate!

Update an extension. When ! is given, update all extensions.

Sidebar

:sbcl :sbclose :sbclose

Close the sidebar window.

 :sbope :sbopen :sb :sbar :sideb :sidebar :sidebar name

Open the sidebar window. name is any of the menu items listed under the standard &dactyl.host; View->Sidebar menu. Add-ons, Preferences and Downloads are also available in the sidebar.

:sidebar! name

Toggle the sidebar window. When name is provided, the semantics are as follows: If the named sidebar is currently open, it is closed. Otherwise the named sidebar is opened. When name is not provided, the semantics are as follows: If the sidebar is currently open, it is closed. Otherwise the previously open sidebar panel is re-opened.

Status line

The status line appears at the bottom of each window. You can use guioptions to specify if and when the status line appears, as well as its relation to the command line and messages.

The status line contains several fields that provide information about the state of the current buffer. These are, in order:

  • URL: The URL of the currently loaded page. While the page is loading, progress messages are also output to this field.
  • History and bookmark status ([+-❤⋯]): The position of the current page in the tab's session history; - and + indicate that it is possible to move backwards and forwards through the history respectively. ❤ indicates that the current page is bookmarked. Any other character indicates a QuickMark matching the current page.
  • Tab index ([N/M]): N is the index of the currently selected tab and M is the total number of tabs in the current window.
  • Vertical scroll: The vertical scroll percentage of the current buffer, or Top or Bot for the top and bottom of the buffer respectively.
  • Security: The security information button is displayed when appropriate as per &dactyl.host;. The color of the status bar also changes to reflect the current security status of the loaded page.
    black
    The site's identity is unverified and the connection is unencrypted
    red
    The connection is encrypted, but the site's identity has not been verified or it contains unencrypted content
    blue
    The site's domain has been verified and the connection is encrypted
    green
    The site's domain and owner have been fully verified via an Extended Validation certificate and the connection is encrypted
  • Extensions: Any extension buttons that would normally be installed to the &dactyl.host; status bar are appended to the end of the status line.

Toolbars

:tbs :tbshow :toolbars :toolbarshow :toolbarshow name

Shows the named toolbar.

 :tbh :tbhide :toolbarh :toolbarhide :toolbarhide name

Hides the named toolbar.

 :tbt :tbtoggle :toolbart :toolbartoggle :toolbartoggle name

Toggles the named toolbar.

 dactyl-1.2~r20151231/common/locale/en-US/hints.xml000066400000000000000000000131361264147376100213770ustar00rootroot00000000000000

Hints

Hints are an easy way to interact with web pages without using your mouse. In Hints mode, &dactyl.appName; highlights and numbers all clickable elements. The elements can be selected either by typing their numbers, or typing parts of their text to narrow them down. While the default action is to click the selected link, other actions are available, including saving the resulting link, copying its URL, or saving an image. For each of these actions, only the set of applicable elements is highlighted.

quick-hints hint-mode f fhint

Start hint-mode. In this mode, every clickable element (as defined by the hinttags option) is highlighted and numbered. Elements can be selected either by typing their number, or by typing part of their text to narrow down the result. When an element has been selected, it is automatically clicked and hint mode ends. Additionally, the following keys have special meanings in Hints mode:

Selects the first highlighted element, or that focused by .
Moves the focus to the next hintable element
\
Temporarily treats all numbers (or other keys, depending on the value of hintkeys) as ordinary text
Exits Hints mode without selecting an element
 F Fhint

Start hint-mode, but the selected elements are clicked with the key pressed, which has the normal effect of opening it in a new tab (depending on the value of the browser.tabs.loadInBackground preference).

extended-hints ; ;modehint

Start an extended hints mode. Extended hints are exactly like quick-hints, except that each sub-mode highlights a more specialized set of elements, and performs a unique action on the selected link. Because of the panoply of extended hint modes available, after pressing ;, pressing brings up the completion list with each hints mode and its description.

mode may be one of:

  • ; to focus a link
  • ? to show information about the element (incomplete)
  • s to save its destination
  • f to focus a frame
  • F to focus a frame or pseudo-frame
  • o to open its location in the current tab
  • t to open its location in a new tab
  • b to open its location in a new background tab
  • w to open its destination in a new window
  • O to generate an :open prompt with hint’s URL
  • T to generate a :tabopen prompt with hint’s URL (like ;O)
  • W to generate a :winopen prompt with hint’s URL (like ;T)
  • a to add a bookmark
  • S to add a search keyword for the hint’s form
  • v to view its destination source
  • V to view its destination source in the external editor
  • y to yank its destination location
  • Y to yank its text description
  • A to yank its anchor URL
  • c to open its context menu
  • i to open an image
  • I to open an image in a new tab.

Of the previous modes, the value of the hinttags option is used to choose the highlighted elements, unless an override can be found in extendedhinttags.

g; g;modehint

Start an extended hints mode and stay there until is pressed. Like ;, except that after a hint is selected, hints remain visible so that another one can be selected with the same action as the first.

dactyl-1.2~r20151231/common/locale/en-US/index.xml000066400000000000000000000016531264147376100213620ustar00rootroot00000000000000

Index

This file contains a list of all available commands, mappings and options.

Base mode

Main mode

Input mode

Insert mode

Command mode

Normal mode

Caret mode

Visual mode

Command-line editing

Text editing

Ex commands

Options

 dactyl-1.2~r20151231/common/locale/en-US/intro.xml000066400000000000000000000044151264147376100214050ustar00rootroot00000000000000

Introduction

If this is your first time running &dactyl.appName;, you may need some time to adjust to the standard interface, which hides the menu, navigation, and tool bars by default. If you find it uncomfortable to work without them, you can re-enable them by typing

mT

If you have trouble remembering commands or keyboard shortcuts, you can bring up this help page at any time by typing :help. If you find that you don't like &dactyl.appName; at all, you can disable it by typing :extdisable &dactyl.appName; or delete it entirely by typing :extdelete &dactyl.appName;

Help topics

    You can also jump directly to the help of a specific command, key mapping, or topic via the :help command.

    :help :help

    Features

      Official Plugins

      In case you're not sufficiently overwhelmed by &dactyl.appName;'s default feature set, don't despair. You can find more entertainment in the officially supported (read: you can flame us when they stop working) plugins.

      Contact

      Please send comments, questions, or patches to the mailing list, where we will do our best to answer any inquiries. You can also find more information on the homepage. Issue reports can be entered in the issue tracker.

      dactyl-1.2~r20151231/common/locale/en-US/map.xml000066400000000000000000000734431264147376100210360ustar00rootroot00000000000000

      Keyboard shortcuts and commands

      &dactyl.appName; provides a number of commands to change the behavior of key presses. This can mean anything from automatically substituting one key for another or automatically replacing one typed word for another, to launching a dialog or running a command.

      Key mapping

      Key mappings are the most basic means &dactyl.appName; provides for altering the actions of key presses. Each key mapping is associated with a mode, such as Insert, Normal, or Command Line, and only has effect when that mode is active. Although each mode has a full suite of internal mappings, they may be easily augmented, altered, or removed with the :map command and its variants. These commands, in essence, allow the user to quickly substitute one sequence of key presses for another. For instance,

      :map :styletoggle -name

      causes “:styletoggle -name ” to be typed out whenever is pressed, providing a way to toggle a tab-completed named user style.

      You can also map keys to Ex or JavaScript commands, see the examples.

      Standard key mapping commands are provided for the five most common modes,

      n
      Normal mode: When browsing normally
      v
      Visual mode: When selecting text with the cursor keys
      i
      Insert mode: When interacting with text fields on a website
      t
      Text Edit mode: When editing text fields in Vim-like Normal mode
      c
      Command Line mode: When typing into the &dactyl.appName; command line
      o
      Operator mode: When moving the cursor

      The ordinary :map command adds mappings for Normal and Visual mode. In order to map key bindings in a different mode, any of the mapping commands may be prefixed with one of the above letters. For instance, :imap creates a new key mapping in Insert mode, while :cunmap removes a key mapping from Command Line mode. Other modes can be specified using the -modes option described below.

      It is important to note that mappings are not automatically saved between sessions. In order to preserve them, they must either be added to your &dactyl.name;rc or saved via the :mk&dactyl.name;rc command.

      The following tree represents all of the modes understood by dactyl. Mappings for a mode also apply to its children and descendants. So a mapping in the Base mode, for instance, is also active in Normal and Ex mode.

      &modes.tree;

      Map commands

      :map :map lhs rhs :nm :nmap :nmap lhs rhs :vm :vmap :vmap lhs rhs :im :imap :imap lhs rhs :tm :tmap :tmap lhs rhs :cm :cmap :cmap lhs rhs

      Map the key-sequence lhs to rhs for the applicable mode(s). The keys of rhs respect user-defined mappings, so the following will result in an infinite loop,

      :map a b :map b a

      In order to avoid this shortcoming, the :noremap command or the -builtin option may be used.

      Below is an overview of which modes each map command applies to:

      :map :unmap
      Normal and Visual modes
      :nmap :nunmap
      Normal mode
      :vmap :vunmap
      Visual mode
      :imap :iunmap
      Insert mode
      :tmap :tunmap
      Text Edit mode
      :cmap :cunmap
      Command Line mode
      The -modes option, described below, provides a more flexible way to specify the applicable modes.

      Map options

      Any of the map commands may be given the following options:

      -arg
      Accept an argument after the requisite key press. Sets the arg parameter to the result. (short name -a)
      -builtin
      Execute this mapping as if there were no user-defined mappings. (short name -b)
      -count
      Accept a count before the requisite key press. Sets the count parameter to the result. (short name -c)
      -description
      A description of this mapping. (short name -d)
      -ex
      Execute rhs as an Ex command rather than keys. (short name -e)
      -group=group
      Add this command to the given group (short name -g). When listing commands this limits the output to the specified group.
      -javascript
      Execute rhs as JavaScript rather than keys. (short names -js, -j)
      -literal=n
      Parse the nth argument without specially processing any quote or meta characters. (short name -l)
      -modes=modes
      Create this mapping in the given modes. (short names -mode, -m)
      -nopersist
      Do not save this mapping to an auto-generated rc file. (short name -n)
      -silent
      Do not echo any generated keys to the command line. (short name -s, also <silent> for Vim compatibility)
      :no :noremap :noremap lhs rhs :nno :nnoremap :nnoremap lhs rhs :vno :vnoremap :vnoremap lhs rhs :ino :inoremap :inoremap lhs rhs :tno :tnoremap :tnoremap lhs rhs :cno :cnoremap :cnoremap lhs rhs These aliases are deprecated. The -builtin flag should be used in their stead.

      Map the key-sequence lhs to rhs for the applicable mode(s). The keys in rhs do not respect user-defined key mappings, so the following effectively reverses the default meanings of the keys d and D

      :noremap d D :noremap D d       :unmap lhs :unm :unmap :unmap! :nunmap lhs :nun :nunmap :nunmap! :vunmap lhs :vun :vunmap :vunmap! :iunmap lhs :iu :iunmap :iunmap! :tunmap lhs :tu :tunmap :tunmap! :cunmap lhs :cu :cunmap :cunmap!

      Remove the mapping of lhs (or all mappings if ! is given) for the applicable mode(s).

             :map :nmap :vmap :imap :tmap :cmap

      List all mappings for the applicable mode(s). Mappings are partitioned into groups.

      :map_l :map lhs :nmap_l :nmap lhs :vmap_l :vmap lhs :imap_l :imap lhs :tmap_l :tmap lhs :cmap_l :cmap lhs

      List all mappings starting with lhs for the applicable mode(s).

      Mapping timeout

      When &dactyl.appName; receives a key event that has a separate binding and at the same time is part of a key chain, values of the timeout and timeoutlen options are used to decide what to do. See the documentation of those options for more information.

      Key sequences

      Most keys in key sequences are represented simply by the character that you see on the screen when you type them. However, as a number of these characters have special meanings, and a number of keys have no visual representation, a special notation is required.

      • The first argument to the :map commands must be quoted if it contains spaces, quotation marks or back-slashes. A space may additionally be typed as .
      • As special key names start with the < character, a literal < must be typed as .
      • , , , and represent the standard arrow keys.
      • , , , , , , and work as expected.
      • or represent the carriage return key.
      • represents the backspace key.
      • through work as expected.
      • through represent keys on the numeric keypad.
      • , where xxxx is any 4 hexadecimal digits, represents the character at that Unicode codepoint. For instance, represents ☺.

      In order to represent key presses using the Control, Alt, Meta, or Shift keys, the following prefixes may be used,

      1. : The control or ctrl key.
      2. : The alt key.
      3. : The meta key, windows key, or command key.
      4. : Same as .
      5. : The shift key.

      These prefixes can be combined however you see fit.

      Within angle brackets all alphabetic characters are read as lowercase. Uppercase characters can only be specified with the S- modifier.

      The following key sequences are interpreted as described:

      xc
      Press the ‘X’ key followed by the ‘C’ key.
      c
      Press the ‘X’ key while holding the ‘Control’ key, followed by the ‘C’ key.
      Type ‘2’ while holding the ‘Control’ key.
      Press the ‘@’ key while holding the ‘Control’ key.
      Press the space bar while holding the ‘Shift’ key.
      Press the ‘J’ key while holding both the ‘Control’ and ‘Alt’ keys.
      Exactly the same as above.
      Press the ‘J’ key while holding all of ‘Control’, ‘Alt’, and ‘Shift’ keys.

      Special characters

      ]]> ]]>

      Do nothing. This pseudo-key is useful for disabling a specific builtin mapping. For example, :map will prevent from doing anything.

      ]]> ]]>

      An arbitrary and meaningless key that some people seem attached to. The \ key will, by default, emit this pseudo-key so that it can be used at the start of other mappings. Note, however, that there is nothing special about it and any key can be mapped to emit any other arbitrary pseudo-key in the same way.

      :map , :map ; :map k -js doStuff() :map k -js doOtherReallyNiftyStuff()

      Needless to say this behavior is considered childish and discouraged.

      ]]> ]]>

      Pass the events consumed by the last executed mapping through to &dactyl.host;.

      map_return]]> ]]>

      Expand to a line terminator in a key mapping. An Ex command in the rhs of a mapping requires a line terminator after it so that it is executed when the mapping is expanded. should be used for this purpose.

      Mapping examples

      Make do the same as in input modes:

      :map -b -m input

      Toggle the tab line with :

      :map -ex always,never

      Make toggle image display:

      :map -js <<EOF let (pref = permissions.default.image) prefs.set(pref, prefs.get(pref) == 1 ? 2 : 1); tabs.reload(config.browser.mCurrentTab); EOF

      Bypassing &dactyl.appName;

      &dactyl.appName; overrides nearly all &dactyl.host; keys in order to make browsing more pleasant for Vim users. On the occasions when you want to bypass &dactyl.appName;'s key handling and pass keys directly to &dactyl.host; or to a web page, you have several options: ]]> ]]>

      Process the next key as a builtin mapping, ignoring any user defined mappings and passkeys settings.

      ]]> ]]>

      Pass the next key press directly to &dactyl.host;.

      ]]> ]]>

      Pass all keys except for directly to &dactyl.host;. When is pressed, resume normal key handling. This is especially useful for web sites which make heavy use of key bindings.

      See also passkeys and passunknown for ways to permanently pass all or particular keys under certain conditions.

      Abbreviations

      In addition to basic mappings, &dactyl.appName; can also automatically replace whole words after they've been typed. These shortcuts are known as abbreviations, and are most often useful for correcting spelling of commonly mistyped words, as well as shortening the typing of oft-typed but long words or phrases. There are three basic types of abbreviations, defined by the types of characters they contain,

      • ‘full-id’ abbreviations consist entirely of keyword characters (e.g., ‘teh’, ‘msoft’).
      • ‘end-id’ abbreviations end in keyword character but otherwise contains all non-keyword characters (e.g., ‘'i’).
      • ‘non-id’ abbreviations end in a non-keyword character but otherwise contains any non-whitespace character (e.g., ‘def'’).
      • Strings which fit none of the above patterns can not be defined as abbreviations (e.g., ‘a'b’ and ‘a b’).

      For the purposes of abbreviations, keyword characters include all non-whitespace characters except for single or double quotation marks. Abbreviations are expanded as soon as any non-keyword character, or the key , is typed.

      :ab :abbreviate :abbreviate -group=group -js lhs rhs :abbreviate -group=group lhs :abbreviate -group=group

      Abbreviate lhs to rhs. If only lhs is given, list all abbreviations that start with lhs. If no arguments are given, list all abbreviations.

      If the -javascript (short names -js, -j) option is given, lhs is expanded to the value returned by the JavaScript code rhs. The code is evaluated with the variable editor set to the editable element that the abbreviation is currently being expanded in. The code should not make any changes to the contents of the editor.

      If group is specified then abbreviations are created or listed for the given group.

      :ca :cabbreviate :cabbreviate lhs rhs :cabbreviate lhs :cabbreviate

      Abbreviate a key sequence for Command Line mode. Same as :abbreviate, but for &mode.command-line; mode only.

      :ia :iabbreviate :iabbreviate lhs rhs :iabbreviate lhs :iabbreviate

      Abbreviate a key sequence for Insert mode. Same as :abbreviate, but for Insert mode only.

      :una :unabbreviate :unabbreviate lhs :unabbreviate!

      Remove an abbreviation. With !, remove all abbreviations.

             :cuna :cunabbreviate :cunabbreviate lhs :cunabbreviate!

      Remove abbreviation(s) for Command Line mode. Same as :unabbreviate, but for &mode.command-line; mode only.

      :iuna :iunabbreviate :iunabbreviate lhs :iunabbreviate!

      Remove abbreviation(s) for Insert mode. Same as :unabbreviate but for Insert mode only.

      User-defined commands

      Defining new commands is perhaps the most straightforward way of repeating commonly used actions. User-defined commands may be entered from the command line or scripts exactly like standard commands, and may similarly accept arguments, options, counts, and !s, as well as provide command-line completion. These commands may be defined as either ordinary, macro-interpolated Ex commands, or otherwise as plain JavaScript statements.

      :com :command :command

      List all user-defined commands.

             :command cmd

      List all user-defined commands that start with cmd. Commands are partitioned into groups.

      :command! options… cmd rep

      Define a new user command. The name of the command is cmd and its replacement text is rep. If a command with this name already exists, an error is reported unless ! is specified, in which case the command is redefined. Unlike Vim, the command may start with a lowercase letter. cmd may also be multiple alternative command names separated by commas.

      The new command is usually defined by a string to be executed as an Ex command. In this case, before execution, strings of the form <var> are interpolated as described below, in order to insert arguments, options, and the like. If the -javascript (short name -js) flag is present, the command is executed as JavaScript, and the arguments are present as variables in its scope instead, and no interpolation is performed.

      The command's behavior can be altered by providing options when the command is defined.

      Grouping

      The -group flag (short name: -g) can be used to assign this command to a specific group. When listing commands this limits the output to the specified group.

      Argument handling

      By default, user commands accept no arguments. This can be changed by specifying the -nargs option.

      The valid values are:

      -nargs=0
      No arguments are allowed (default)
      -nargs=1
      One argument is allowed
      -nargs=*
      Zero or more arguments are allowed
      -nargs=?
      Zero or one argument is allowed
      -nargs=+
      One or more arguments are allowed

      Argument completion

      Completion for arguments to user-defined commands is not available by default. Completion can be enabled by specifying one of the following arguments to the -complete option when defining the command.

      Custom completion

      Custom completion can be provided by specifying the custom,thing argument to -complete. If thing evaluates to a function (i.e., it is a variable holding a function value, or a string containing the definition itself), it is called with two arguments: a completion context, and an object describing the command's arguments. It should set the context's completions property to the list of completion results. Other influential properties include title, sort, anchored, and filters, which are documented in the source code.

      completions is a two-dimensional array of the form: [[val1, description1], [val2, description2], …]

      Otherwise thing should evaluate to an array of the same form as the completions property of the context object.

      Example: :command foo -nargs=? -complete custom, \ function (context) context.completions = [["val1", "description1"], ["val2", "description2"]] \ :echo Useless + <q-args> :command foo -nargs=? \ -complete custom,[["val1", "description1"], ["val2", "description2"]] \ :echo Same as above but simpler + <q-args>

      Count handling

      By default, user commands do not accept a count. Use the -count option if you'd like to have a count passed to your user command. This will then be available for expansion as <count> in the replacement.

      Special cases

      By default, a user command does not have a special version, i.e. a version executed with the ! modifier. Providing the -bang option will enable this and <bang> will be available in the replacement.

      Command description

      The command's description text can be set with -description. Otherwise it will default to "User-defined command".

      Replacement text

      The replacement text rep is scanned for macro-strings and these are replaced with values from the user-entered command line. The resulting string is then executed as an Ex command.

      In addition to the standard parameters listed in macro-string, the following parameters are available:

      <args>
      The command arguments exactly as supplied
      <count>
      Any supplied count, e.g. 5
      <bang>
      ! if the command was executed with the ! modifier
      :delc :delcommand :delcommand cmd :delcommand!

      Delete the user-defined command cmd. With !, delete all user commands.

      Command examples

      A command to search via DuckDuckGo:

      :command -nargs=* ddg open ddg <args>

      A command to search for contents of the current selection using a tab-completed search engine in the current or a new tab (depending on how much you bang on the keyboard):

      :com! search-selection,ss -bang -nargs=? -complete search \ -js commands.execute((bang ? open : tabopen ) \ + args + + buffer.currentWord) dactyl-1.2~r20151231/common/locale/en-US/marks.xml000066400000000000000000000252461264147376100213740ustar00rootroot00000000000000

      Marks

      &dactyl.appName; supports a number of different methods of marking your place, in order to easily return later:

      • Bookmarks are the standard marks of &dactyl.host;, and are fully supported.
      • QuickMarks allow you to quickly save and return to as many as 62 (a-zA-Z0-9) different web sites with a quick keyboard shortcut.
      • Local marks allow you to store and return to a position within the current web page.
      • URL marks allow you to store and return to the position and URL of the current web page.

      Bookmarks

      Bookmarks are the most traditional kind of marks supported by &dactyl.appName;. They are accessible through &dactyl.host;'s bookmark menu, sidebar, and toolbar, in addition to its location bar completion system. &dactyl.appName; makes them accessible not only via several commands and its completion system (see the complete option), but also displays a ❤ in the status bar when a bookmarked page is displayed.

      a :bma :bmark :bmark! options url a

      Add a bookmark.

      The following options are available:

      -charset
      Character encoding to use for the bookmark. Useful e.g. for sites that require query parameters in encodings other than UTF-8 (short name -c).
      -id
      The numerical ID of a bookmark to update.
      -keyword
      A keyword which may be used to open the bookmark via the URL bar or :open prompt. If the url contains the string %s it is replaced by any text following the keyword when it is opened. See also ;S. (short name -k)
      -post
      Data to be POSTed to the server when the bookmark is opened.
      -tags
      Comma-separated list of tags for grouping and later access (short name -T).
      -title
      The title of the bookmark. Defaults to the page title, if available, or url otherwise. (short name -t)

      If url is omitted, the URL of the currently loaded web page is used.

      If ! is present, a new bookmark is always added. Otherwise, the first bookmark matching id, keyword, or url is updated.

      A A

      Toggle bookmarked state of current URL. Add/remove a bookmark for the current location, depending on whether it is already bookmarked. New bookmarks are placed in the Unfiled Bookmarks folder, and don't appear in the bookmarks menu or toolbar, but do appear in location bar and :open completions, as well as the :bmarks list.

      :bmarks :bmarks! filter

      List or open multiple bookmarks. Opens the message window at the bottom of the screen with all bookmarks with URLs matching filter. The resulting URLs can be clicked, or accessed via extended hint modes such as ;o.

      The special version :bmarks! works the same as :bmarks except that it opens all matching bookmarks in new tabs rather than listing them.

      The bookmarks may also be filtered via the following options:

      -keyword
      The bookmark's keyword (short name -k).
      -tags
      A comma-separated list of tags, all of which must be present for a match (short name -T).
      -title
      The title of the bookmark (short name -t).
      -max
      The maximum number of items to list or open (short name -m).
      :delbm :delbmarks :delbm[arks] url :delbm[arks]!

      Deletes all bookmarks which match url. If omitted, url defaults to the URL of the current buffer.

      Accepts the same options as :bmarks.

      If ! is specified then all bookmarks will be deleted.

      QuickMarks

      QuickMarks are bookmarks stripped to the bone for quickly getting to the pages that you visit most. A QuickMark is simply a URL assigned to a letter or digit. They can therefore be saved or opened with only three key presses each. QuickMarks are persistent across browser sessions.

      M Ma-zA-Z0-9

      Add new QuickMark for current URL. You can later jump to the mark with goa-zA-Z0-9 gna-zA-Z0-9.

      go goa-zA-Z0-9

      Jump to a QuickMark in the current tab. See also M and :qmark.

      gn gna-zA-Z0-9

      Jump to a QuickMark in a new tab. The new tab is focused only if activate contains quickmark or all. See also M and :qmark.

      Mnemonic: Go in a new tab.

             :delqm :delqmarks :delqmarks arg :delqmarks!

      Delete the specified QuickMarks.

      Examples:

      • :delqmarks Aa b p deletes QuickMarks A, a, b and p
      • :delqmarks b-p deletes all QuickMarks in the range b to p
      • :delqmarks! deletes all QuickMarks
             :qma :qmark :qmark a-zA-Z0-9 url

      Mark url with a letter or digit for quick access. See also go, gn, and M.

      In addition to simple URLs, url may be any string that can be passed to :open.

      :qmarks :qmarks arg

      List QuickMarks. If arg is given then limit the list to those QuickMarks mentioned, otherwise list them all.

      Local marks and URL marks

      Local and URL marks allow you to mark your position on the current page to quickly return later. Each mark is assigned to a letter. Lowercase letters behave as local marks, while uppercase letters act as URL marks. The difference between the two is that local marks apply uniquely to each page, while URL marks mark a specific position on a specific page. So, while the mark m may take you to the top of the page on Site 1, it may take you to the middle on Site 2. The mark M, on the other hand, will always return you to Site 1, possibly switching buffers or creating a new one. All marks are persistent across browser sessions.

      m ma-zA-Z

      Set mark at the cursor position. Marks a-z are local to the buffer, whereas A-Z are valid between buffers.

      ` ' 'a-zA-Z' `a-zA-Z'

      Jump to the mark. Marks a-z are local to the buffer, whereas A-Z are valid between buffers. The special mark ' holds the buffer position before the last scrolling action.

      :delm :delmarks :delmarks arg :delmarks!

      Delete the specified marks.

      Examples:

      • :delmarks Aa b p deletes marks A, a, b, and p
      • :delmarks b-p deletes all marks in the range b to p
      • :delmarks! deletes all marks for the current buffer
             :ma :mark :mark a-zA-Z

      Mark current location within the web page.

             :marks :marks arg

      Show all local marks for the current web page and all URL marks. If arg is specified then limit the list to those marks mentioned.

      dactyl-1.2~r20151231/common/locale/en-US/message.xml000066400000000000000000000054251264147376100217000ustar00rootroot00000000000000

      Error and informational messages

      message-history

      &dactyl.appName; stores all info and error messages in a message history. The type of info messages output can be controlled by the verbose option. The maximum number of stored messages can be limited with the messages option.

      :mes :messages :messages

      Display previously shown messages.

             :messc :messclear :messclear

      Clear the message history.

             g<

      Redisplay the last command output. Only the most recent command's output is available.

      pager more-prompt -- More -- -- More -- SPACE/d/j: screen/page/line down, b/u/k: up, q: quit

      This message is displayed when the message window is filled with messages and the more option is set. It is styled with the MoreMsg :highlight group. When the more message is shown, the following key mappings are available:

      or j or
      one more line
      d
      down a page (half a screen)
      or
      down a screen
      G
      down all the way, until the hit-enter prompt
      or k or
      one line back
      u
      up a page (half a screen)
      b or
      back a screen
      g
      back to the start
      q, or
      stop the listing
      :
      stop the listing and enter a command line
      ;
      start an extended-hints command
      yank (copy) a modeless selection to the clipboard
       dactyl-1.2~r20151231/common/locale/en-US/messages.properties000066400000000000000000000343711264147376100234610ustar00rootroot00000000000000# TODO: normalize this debacle of Vim legacy messages error.damnYouJägermonkey = + \ Hallo. It looks like you've run into a problem resulting from \ overzealous optimizations by the JavaScript engine. We've disabled \ future use of these optimizations, but you'll need to restart your \ browser in order to correct the problems they've caused. You can \ re-enable them by resetting the javascript.options.methodjit.chrome \ preference. abbreviation.noSuch = No such abbreviation abbreviation.none = No abbreviations found addon.check-1 = Checking updates for addons: %S addon.cantInstallDir-1 = Cannot install a directory: %S addon.unavailable = Don't have add-on yet addon.unknownCommand = Unknown command addon.commandNotAllowed = Command not allowed addon.installingUpdates-1 = Installing updates for addons: %S addon.noUpdates = No addon updates found addon.error-3 = Add-on %S %S: %S addon.action.On = On  addon.action.Off = Off addon.action.Delete = Del addon.action.Update = Upd addon.action.Options = Opt AddonManager.ERROR_NETWORK_FAILURE = A network error occurred AddonManager.ERROR_INCORRECT_HASH = The downloaded file did not match the expected hash AddonManager.ERROR_CORRUPT_FILE = The file appears to be corrupt AddonManager.ERROR_FILE_ACCESS = There was an error accessing the filesystem autocmd.executing-2 = Executing %S Auto commands for %S autocmd.autocommand-1 = autocommand %S autocmd.noMatching = No matching autocommands autocmd.noGroup-1 = No such group or event: %S autocmd.cantExecuteAll = Can't execute autocommands for ALL events autocomplete.description-1 = Native '%S' autocompletions autocomplete.noSuchProvider-1 = No such autocomplete provider: '%S' autocomplete.title-1 = '%S' bookmark.noMatching-2 = No bookmarks matching tags %S and string %S bookmark.noMatchingTags-1 = No bookmarks matching tags %S bookmark.noMatchingString-1 = No bookmarks matching string %S bookmark.none = No bookmarks set bookmark.bangOrID = Only one of ! or -id may be given bookmark.cantAdd-1 = Could not add bookmark %S bookmark.allDeleted = All bookmarks deleted bookmark.removed-1 = Removed bookmark: %S bookmark.added-1 = Added bookmark: %S bookmark.updated-1 = Updated bookmark: %S bookmark.deleted-1 = %S bookmark(s) deleted bookmark.prompt.deleteAll = This will delete all bookmarks. Would you like to continue? (yes/[no]): # TODO: add plurals support buffer.fewerTab-1 = %S fewer tab buffer.fewerTabs-1 = %S fewer tabs buffer.cantDetatchLast = Can't detach the last tab buffer.noMatching-1 = No matching buffer for %S buffer.multipleMatching-1 = More than one match for %S buffer.noClosed = No matching closed tab buffer.noAlternate = No alternate page buffer.backgroundLoaded = Background tab loaded: %S buffer.save.altText = Alternate Text buffer.save.filename = File Name buffer.save.linkText = Link Text buffer.save.pageName = Page Name buffer.save.suggested = Server-suggested Name # TODO: categorise these buffer.noTitle = [No Title] buffer.noName = [No Name] buffer.help = [Help] buffer.bookmarked = bookmarked buffer.prompt.uploadFile = Upload file: buffer.prompt.saveLink = Save link: context.scriptGroup-1 = Script group for %S command.commands = commands command.cantDelete = Cannot delete non-user commands command.cantReplace-1 = E182: Can't replace non-user command: %S command.wontReplace-1 = Not replacing command: %S command.eof-1 = Unexpected end of file waiting for %S command.noSuch = No such command command.noSuch-1 = No such command: %S command.noSuchUser-1 = No such user-defined command: %S command.notUseful-1 = This command is not useful in this version of %S command.invalidName-1 = Invalid command name: %S command.invalidOpt-1 = Invalid option: %S command.invalidOptArg-2 = Invalid argument for option %S: %S command.invalidOptTypeArg-3 = Invalid argument for %S option %S: %S command.parsing-1 = Error parsing arguments: %S command.none = No user-defined commands found command.exists = E174: Command already exists: add ! to replace it command.noPrevious = E30: No previous command line command.noCount = E481: No count allowed command.noBang = E477: No ! allowed command.colorscheme.notFound-1 = E185: Cannot find color scheme %S command.conditional.illegal = Invalid use of conditional command.finish.illegal = E168: :finish used outside of a sourced file command.let.illegalVar-1 = E461: Illegal variable name: %S command.let.invalidExpression-1 = E15: Invalid expression: %S command.let.noSuch-1 = E108: No such variable: %S command.let.undefinedVar-1 = E121: Undefined variable: %S command.let.unexpectedChar = E18: Unexpected characters in :let command.run.noPrevious = E34: No previous command command.sanitize.privateMode = Cannot sanitize items in private mode command.sanitize.allDeleted = All items sanitized command.sanitize.noneDeleted = No items sanitized command.scriptnames.none = No sourced scripts found command.set.errorParsing-1 = Error parsing :set command: %S command.set.numberRequired-2 = E521: Number required after =: %S=%S command.set.unknownOption-1 = E518: Unknown option: %S command.yank.yankedLine-1 = Yanked %S line command.yank.yankedLines-1 = Yanked %S lines commandline.moreMessages = [%S more. Type :messages to read] completion.additional = (additional) completion.generating = Generating results... completion.noCompletions = No Completions completion.waitingFor-1 = Waiting for %S completion.waitingForResults = Waiting for results completion.waitingForKeyPress = Waiting for key press completion.matchIndex-2 = match %S of %S dactyl.created-1 = created %S dactyl.parsingCommandLine-1 = Parsing command line options: %S dactyl.notCommand-2 = E492: Not a %S command: %S dactyl.sourcingPlugins-1 = Sourcing plugin directory: %S... dactyl.noPluginDir = No user plugin directory found dactyl.modulesLoaded = All modules loaded dactyl.commandlineOpts-1 = Command-line options: %S dactyl.noRCFile = No user RC file found dactyl.initialized-1 = %S fully initialized dactyl.sourced-1 = Sourced: %S dactyl.prompt.openMany-1 = This will open %S new tabs. Would you like to continue? (yes/[no]): dactyl.yank-1 = Yank %S dactyl.cheerUp = Cheer up dactyl.somberDown = Somber down deprecated.for.theOptionsSystem = the options system dialog.notAvailable-1 = Dialog %S not available # TODO: merge with addon.*? download.unknownCommand = Unknown command download.commandNotAllowed = Command not allowed download.givingUpAfter = Giving up loading downloads after %S seconds download.prompt.launchExecutable = This will launch an executable download. Would you like to continue? (yes/[no]/always): download.nActive-1 = %S active download.almostDone = ~1 second download.unknown = Unknown download.action.Clear = Clear download.action.Delete = Delete download.action.Stop = Stop download.action.Remove = Remove download.action.Resume = Resume editor.prompt.editPassword = Editing a password field externally will reveal the password. Would you like to continue? (yes/[no]): emenu.notFound-1 = Menu not found: %S event.error-2 = Processing %S event: %S event.nothingToPass = No events to pass finder.notFound-1 = E486: Pattern not found: %S finder.atTop = Find hit TOP, continuing at BOTTOM finder.atBottom = Find hit BOTTOM, continuing at TOP group.cantChangeBuiltin-1 = Cannot change %S in the builtin group group.cantModifyBuiltin = Cannot modify builtin group group.cantRemoveBuiltin = Cannot remove builtin group group.noSuch-1 = No such group: %S group.invalidName-1 = Invalid group name: %S group.noCurrent = No current group help.dontPanic = E478: Don't panic! help.Example = Example help.noFile-1 = Sorry, help file %S not found help.noTopic-1 = Sorry, no help for %S help.title.Using Plugins = Using Plugins hints.noMatcher-1 = Invalid 'hintmatching' type: %S history.noMatching-1 = No history matching %S history.none = No history set history.noURL = URL not found in history io.callingShell-1 = Calling shell to execute: %S io.cantCreateTempFile = Couldn't create temporary file io.cantEncode = Input contains characters not valid in the current file encoding io.commandFailed = E472: Command failed io.definedAt = Defined at io.downloadFinished-2 = Download of %S to %S finished io.eNotDir = Not a directory io.eNotDir-1 = Not a directory %S io.exists = File exists (add ! to override) io.exists-1 = File %S exists (add ! to override) # XXX io.existsNoOverride-1 = File %S exists io.noCommand-1 = Command not found: %S io.noPrevDir = E186: No previous directory io.noSuchDir-1 = E344: Can't find directory %S io.noSuchFile = File does not exist io.notInRTP-1 = not found in 'runtimepath': %S io.notReadable-1 = Can't open file %S io.notWriteable-1 = Can't open file %S for writing io.oneFileAllowed = E172: Only one file name allowed io.searchingFor-1 = Searching for %S io.searchingFor-2 = Searching for %S in %S io.shellReturn-1 = shell returned %S io.sourcing-1 = sourcing %S io.sourcingEnd-1 = finished sourcing %S io.sourcingError-1 = Sourcing file: %S io.writing-1 = writing %S macro.canceled-1 = Canceled playback of macro '%S' macro.recorded-1 = Recorded macro '%S' macro.recorded-2 = Recorded macro %S: %S macro.loadFailed-1 = Page did not load completely in %S seconds macro.loadWaiting = Waiting for page to load... macro.noSuch-1 = Macro '%S' not set macro.noPrevious = No previous macro macro.invalid-1 = Invalid macro name: '%S' map.builtinImmutable = Cannot change mappings in the builtin group map.none = No mapping found map.noSuch-1 = No such mapping: %S map.recursive-1 = Attempt to execute mapping recursively: %S mark.none = No marks set mark.invalid = Invalid mark mark.unset-1 = Mark not set: %S mark.noMatching-1 = E283: No marks matching %S # TODO: relies on mark formatter mark.addURL-1 = Adding URL mark: %S mark.addLocal-1 = Adding local mark: %S mark.jumpingToURL-1 = Jumping to URL mark: %S mark.jumpingToLocal-1 = Jumping to local mark: %S mode.recursiveSet = Not executing modes.set recursively mode.invalidBases = Invalid bases mow.noPreviousOutput = No previous command output mow.continue = Press ENTER or type command to continue mow.more = -- More -- mow.moreHelp = -- More -- SPACE//j: screen/page/line down, //k: up, q: quit mow.contextMenu.copyLink = Copy Link Location mow.contextMenu.copyPath = Copy File Path mow.contextMenu.copy = Copy mow.contextMenu.selectAll = Select All option.noSuch = No such option option.noSuch-1 = No such option: %S option.noSuchType-1 = No such option type: %S option.replaceExisting-1 = Warning: %S already exists: replacing existing option option.intRequired = Integer value required option.operatorNotSupported-2 = Operator %S not supported for option type %S option.notSet-1 = E764: Option '%S' is not set option.currentValue = Current Value option.defaultValue = Default Value option.bufferLocal = buffer local option.safeSet = See the '%S' option. option.guioptions.safeSet = See 'guioptions' scrollbar flags. option.hintkeys.duplicate = Duplicate keys not allowed # The string 'passkeys' must appear exactly, including U0027 apostrophes option.passkeys.passedBy = passed by 'passkeys' pageinfo.s.ownerUnverified = %S (unverified) plugin.searchingFor-1 = Searching for %S plugin.searchingForIn-2 = Searching for %S in %S plugin.notReplacingContext-1 = Not replacing plugin context for %S pref.hostPreferences-1 = %S Preferences pref.prompt.resetAll-1 = Warning: Resetting all preferences may make %S unusable. Would you like to continue (yes/[no]): pref.safeSet.warnChanged-1 = Warning: Setting preference %S, but it's changed from its default value. print.toFile-1 = Printing to file: %S print.sending = Sending to printer... print.sent = Print job sent print.printed-1 = Printed: %S quickmark.none = No QuickMarks set quickmark.noMatching-1 = No QuickMarks matching %S quickmark.notSet = QuickMark not set quickmark.invalid = Argument must be an ASCII letter or digit quickmark.added-2 = Added Quick Mark '%S': %S sanitize.prompt.deleteAll = This will sanitize all items. Would you like to continue? (yes/[no]): save.invalidDestination-1 = Invalid destination: %S sort.ascending = ascending sort.descending = descending status.link-1 = Link: %S style.none = No style found style.styles = styles style.inline = inline time.total-1 = Total time: %S title.Abbrev = Abbrev title.Action = Action title.Args = Args title.Average time = Average time title.CSS = CSS title.Code execution summary = Code execution summary title.Command = Command title.Complete = Complete title.Definition = Definition title.Description = Description title.Executed = Executed title.Filter = Filter title.Jump = Jump title.Mode = Mode title.Name = Name title.Progress = Progress title.Range = Range title.Replacement = Replacement title.Source = Source title.Speed = Speed title.Status = Status title.Time remaining = Time remaining title.Title = Title title.Total time = Total time title.Totals = Totals title.URI = URI title.Version = Version title.HPos = HPos title.VPos = VPos variable.none = No variables found window.cantAttachSame = Can't reattach to the same window window.noIndex-1 = Window %S does not exist # zoom.outOfRange-2 = Zoom value out of range (%S - %S%%) zoom.illegal = Illegal zoom value error.clipboardEmpty = No clipboard data error.countRequired-1 = Count required for %S error.cantOpen-2 = Error opening %S: %S error.error-1 = Error: %S error.disabled = Item is disabled error.disabled-1 = '%S' is disabled error.interrupted = Interrupted error.invalidSort-1 = Invalid sort order: %S error.missingQuote-1 = E114: Missing quote: %S error.trailingCharacters = Trailing characters error.trailingCharacters-1 = Trailing characters: %S error.invalid-1 = Invalid %S error.invalidArgument = Invalid argument error.invalidArgument-1 = Invalid argument: %S error.unavailable-2 = Not available on %S %S error.argumentRequired = Argument required error.argumentOrBang = Argument or ! required error.invalidOperation = Invalid operation error.monkeyPatchOverlay-1 = Not replacing property with eval-generated overlay by %S error.nullComputedStyle-1 = Computed style is null: %S error.syntaxError = Syntax error error.charactersOutsideRange-1 = Character list outside the range %S error.invalidCharacterRange = Invalid character range: %S error.notWriteable-2 = Could not write to %S: %S warn.deprecated-2 = %S is deprecated: Please use %S instead. warn.notDefaultBranch-2 = You are running %S from a testing branch: %S. Please do not report errors which do not also occur in the default branch. # vim:se ft=jproperties tw=0: dactyl-1.2~r20151231/common/locale/en-US/options.xml000066400000000000000000001735131264147376100217530ustar00rootroot00000000000000

      Options

      &dactyl.appName; has a number of internal variables and switches which can be set to achieve special effects. These options come in the following forms:

      boolean
      Can only be on (:set option) or off (:set nooption)
      number
      A numeric value
      string
      A string value
      charlist
      A string containing a discrete set of distinct characters
      stringlist
      A comma-separated list of strings. Any comma appearing within single or double quotes, or prefixed with a \, will not be treated as an item separator.
      stringmap
      A comma-separated list of key-value pairs, e.g., key:val,foo:bar
      regexplist
      A comma-separated list of regular expressions. Expressions may be prefixed with a !, in which case the match will be negated. A literal ! at the beginning of the expression may be matched with [!] or by placing the regular expression in quotes. Generally, the first matching regular expression is used. Any comma appearing within single or double quotes, or prefixed with a \, will not be treated as an item separator.
      regexpmap
      A combination of a stringmap and a regexplist. Each key in the key:value pair is a regexp. If the regexp begins with a !, the sense of the match is negated, such that a non-matching expression will be considered a match and vice versa. The first key to match yields value.
      sitelist
      sitemap
      Like regexplist and regexpmap, but the keys are site-filters rather than regular expressions.

      Some options may be given format strings containing macro replacements in the form of <name>. These tokens are replaced by the parameter name as specified in the relevant documentation. If the token is in the form <q-name>, the value of the parameter is automatically quoted. If it is in the form of <e-name>, its value is never shown but may be used to test whether the given parameter is empty.

      Array elements, such as in the <args> parameter of :command macros, may be accessed by appending [n], where n is the one-based array index, to the macro name. The first argument of a command is therefore accessed with <args[1]>.

      Any substring enclosed by <{ and }> is automatically elided if any of the contained macros aren't currently valid. A literal < or > character may be included with the special escape sequences <lt> or <gt> respectively.

      For example, given the format string <{(cmd: <column>) }><{line: <line> }><file>, where line=32 and file=Lieder eines fahrenden Gesellen.txt, the result is formatted as line: 32 'Lieder eines fahrenden Gesellen.txt'

      Setting options

      :set :se :set

      Show all options which differ from their default values.

             :set all

      Show all options.

             E518 E519 :set option?

      Show value of option.

             :set option …

      For boolean options, turn them on. For all other types, show their values.

      :set nooption …

      For boolean options, turn them off. For all other types, display an error.

      :set option! … :set invoption …

      For boolean options, invert their value. For all other types, display an error.

      :set!= :set invoption=value … :set option!=value …

      For list options, toggle the specified values.

      If the option is a list, the given values are toggled. Given, foo,bar then, foo,baz has the same result as bar,baz

      This extends to string options in a natural way, e.g., always,never toggles between the two values.

      :set-default :set option& …

      Reset option to its default value.

             :set-default-all :set all&

      Set all options to their default value.

             :set-args E487 E521 :set option=value …

      Set string or number option to value. For numeric options the value must be given in decimal. The old value can be inserted by typing .

      :set+= :set option+=value …

      Add the value to a number option, or append the value to a string option. When the option is a comma separated list, a comma is added, unless the value was empty. If the option is a list of flags, superfluous flags are removed. When adding a flag that was already present the option value doesn't change.

      :set^= :set option^=value …

      Multiply the value to a number option, or prepend the value to a string option. When the option is a comma separated list, a comma is added, unless the value was empty.

      :set-= :set option-=value …

      Subtract the value from a number option, or remove the value from a string option if it is there. If the value is not found in a string option, there is no error or warning. When the option is a comma separated list, a comma is deleted, unless the option becomes empty. When the option is a list of flags, value must be exactly as they appear in the option. Remove flags one by one to avoid problems.

      :setlocal :setl :setlocal …

      The same as :set command, but operates on current tab options only. See :set for details.

      :setglobal :setg :setglobal …

      The same as :set command, but operates on global options only. See :set for details.

      Environment variables are expanded for path options like cdpath and runtimepath. The variable notation is $VAR (terminated by a non-word character) or ${VAR}. %VAR% is also supported on Windows.

      Setting &dactyl.host; options

      &dactyl.host; options can be viewed and set with the following commands:

      :pref :prefs :preferences :preferences

      Show the &dactyl.host; preferences dialog. You can change the browser preferences from this dialog. Be aware that not all &dactyl.host; preferences work, because &dactyl.appName; overrides some key bindings and changes &dactyl.host;'s GUI.

      :pref! :prefs! :preferences! :preferences!

      Opens about:config in the current tab, where you can change advanced &dactyl.host; preferences.

      :set! :set-! :set! …

      The same as :set but operates on &dactyl.host; preferences (those on the about:config page). See :set for operator details.

      The no and inv prefix operators are not available for setting preferences.

      &dactyl.appName; needs to set several &dactyl.host; preferences at startup in order to function properly. If this is unacceptable, they can be changed in your RC file with the :set! command, but beware of unexpected behavior. The affected preferences are:

      • accessibility.typeaheadfind

      List of options

      'act' 'activate' 'activate' 'act' &option.activate.type; addons,bookmarks,diverted,downloads,extoptions, help,homepage,quickmark,tabopen,paste

      A list of items which, when opened in a new tab, are automatically focused. Available items:

      all
      Activate all items.
      addons
      :addons command
      bookmarks
      Tabs loaded from bookmarks
      diverted
      Links with targets set to new tabs
      downloads
      :downloads command
      extoptions
      :extoptions command
      help
      :help command
      homepage
      gH mapping
      links
      Middle- or Control-clicked links
      quickmark
      go and gn mappings
      tabopen
      :tabopen! command
      paste
      P and gP mappings
             'awim' 'altwildmode' 'altwildmode' 'awim' &option.altwildmode.type; &option.altwildmode.default;

      Like wildmode, but when the key is pressed.

      'au' 'autocomplete' 'autocomplete' 'au' &option.autocomplete.type; &option.autocomplete.default;

      Enables automatic completion for completion contexts (see :contexts) matching the given regular expressions. When automatic completion is enabled, the completion list is automatically opened when the &tag.command-line; is focused. Thereafter, any key press triggers a completion update for the matching contexts. Non-matching contexts will only be updated when the key is pressed. This option is useful for disabling auto-completion for computationally intensive contexts that don't perform well when your system is under load.

      Completion contexts have names very much like Unix path names. These denote the tree in which they're called. A completer will never be called unless every completer preceding it in the tree was also called. For example, if your completer excludes /ex/, it will also exclude /ex/bmarks, and so on. To enable auto-completion for everything but :history or :bmarks, you would choose a value such as !/ex/(bmarks|history),.?

      To go in the other direction, i.e. only enable auto-completion for those commands, you have to jump through some hoops, due to the way contexts work (see the note above): /ex/(bmarks|history),^(/|/ex/?)$

      'bh' 'banghist' 'banghist' 'bh' &option.banghist.type; &option.banghist.default;

      Replace occurrences of ! with the previous command when executing external commands.

      $CDPATH 'cd' 'cdpath' 'cdpath' 'cd' &option.cdpath.type; equivalent to . or .,$CDPATH

      List of directories searched when executing the :cd command. This is only used for relative paths; if an absolute path is specified, this option is ignored.

      If the CDPATH environment variable is set this path list is appended to the default value of ..

      'ca' 'cookieaccept' 'cookieaccept' 'ca' &option.cookieaccept.type; &option.cookieaccept.default;

      When to accept cookies.

      all
      Accept all cookies
      none
      Accept no cookies
      samesite
      Accept all non-third-party cookies
             'cl' 'cookielifetime' 'cookielifetime' 'cl' &option.cookielifetime.type; &option.cookielifetime.default;

      The lifetime for which to accept cookies. The available options are:

      default
      The lifetime requested by the setter
      prompt
      Always prompt for a lifetime
      session
      The current session
      days
      When a number is given, it is interpreted as the number of days for which to keep cookies
             'ck' 'cookies' 'cookies' 'ck' &option.cookies.type; &option.cookies.default;

      The default action for the :cookies command.

             'cpt' 'complete' 'complete' 'cpt' &option.complete.type; &option.complete.default;

      Items which are completed at the :open prompts. Available items:

      search
      Search engines and keyword URLs
      file
      Local files
      location
      &dactyl.host; location bar entries (bookmarks and history sorted in an intelligent way)
      bookmark
      Bookmarks
      history
      History
      suggestion
      Search engine suggestions

      Additionally, native search providers can be added by prefixing their names with the string native:. These providers are often added by other add-ons and are occasionally useful.

      The order is important, such that bookmark,search,file will list bookmarks followed by matching quick searches and then matching files.

      For backward compatibility, this option currently accepts a single entry containing single-letter names for completers. This usage is deprecated and will be removed in the future. Using bookmark and history can make completion very slow if there are many items.       'ds' 'defsearch' 'defsearch' 'ds' &option.defsearch.type; &option.defsearch.default;

      Sets the default search engine. The default search engine is used by :open and related commands for arguments which include no search or bookmark keywords and can't otherwise be converted into URLs or existing file names.

      This means that with defsearch set to youtube, :open Tim Minchin behaves exactly as :open youtube Tim Minchin, so long as you don't have a search or bookmark keyword called ‘Tim’.

      'dls' 'dlsort' 'downloadsort' 'downloadsort' 'dlsort' 'dls' &option.downloadsort.type; &option.downloadsort.default;

      :downloads sort order, in order of precedence. Each element must be preceded by a + or -, indicating ascending or descending sorting, respectively. Valid sort orders are:

      active
      Whether download is active
      complete
      Percent complete
      date
      Date and time the download began
      filename
      Target filename
      size
      File size
      speed
      Download speed
      time
      Time remaining
      url
      Source URL
      This option is currently unavailable in &dactyl.host; 26 and greater.       'editor' 'editor' &option.editor.type; &option.editor.default;

      Set the external text editor. This is the editor used by , gF, and other commands which launch an external text editor.

      Accepts a macro-string with the following escapes available. Arguments containing escapes which are not relevant to a given call are automatically elided. All field splitting is done before format characters are processed.

      <file>
      The file to edit. Appended as the final argument if missing.
      <line>
      The line number at which to position the cursor.
      <column>
      The column at which to position the cursor.
      &dactyl.appName; will not behave correctly if the editor forks its own process rather than blocking until editing is complete. Gvim invoked without the -f option is one such example.       'enc' 'encoding' 'encoding' 'enc' &option.encoding.type; &option.encoding.default;

      Changes the character encoding of the current buffer. Valid only until a new page is loaded.

      'noeb' 'noerrorbells' 'eb' 'errorbells' 'errorbells' 'eb' &option.errorbells.type; &option.errorbells.default;

      Ring the bell when an error message is displayed. See also visualbell.

      'ei' 'eventignore' 'eventignore' 'ei' &option.eventignore.type; &option.eventignore.default;

      A list of autocommand event names which should be ignored. If the list contains the value all then all events are ignored.

      'noex' 'noexrc' 'ex' 'exrc' 'exrc' 'ex' &option.exrc.type; &option.exrc.default;

      Allow reading of an RC file in the current directory. This file is sourced after the default &dactyl.name;rc file in your home directory.

      'eht' 'extendedhinttags' 'extendedhinttags' 'eht' &option.extendedhinttags.type; [asOTvVWy]:':-moz-any-link',area[href],img[src],iframe[src], [A]:[id],a[name], [f]:body, [F]:body,code,div,html,p,pre,span, [iI]:img, [S]:button,'input:not([type=hidden])',select,textarea

      Defines specialized CSS selectors or XPath expressions for arbitrary extended-hints modes. The syntax is the same as for hinttags. If no matches are found, the value of hinttags is used.

      'fenc' 'fileencoding' 'fileencoding' 'fenc' &option.fileencoding.type; &option.fileencoding.default;

      Changes the character encoding that &dactyl.appName; uses to read and write files.

      'fc' 'findcase' 'findcase' 'fc' &option.findcase.type; &option.findcase.default;

      Find case matching mode.

      ignore
      Case is never significant
      match
      Case is always significant
      smart
      Case is significant when capital letters are typed
             'ff' 'findflags' 'findflags' 'ff' &option.findflags.type; &option.findflags.default;

      Default flags for find invocations.

      C
      Match case
      L
      Search all text
      R
      Perform a plain string search
      c
      Ignore case
      l
      Search only in links
      r
      Perform a regular expression search
             'fh' 'followhints' 'followhints' 'fh' &option.followhints.type; &option.followhints.default;

      Define the conditions under which hints selected by typing the link substring are followed. Hints selected by typing their label (as specified by hintkeys) are always followed immediately.

      Possible values:

      0
      Follow the first hint as soon as typed text uniquely identifies it.
      1
      Follow the selected hint on .
             'nofs' 'nofullscreen' 'fs' 'fullscreen' 'fullscreen' 'fs' &option.fullscreen.type; &option.fullscreen.default;

      Show the current window full-screen. Also hide certain GUI elements, such as status-line and tab bar.

      'go' 'guioptions' 'guioptions' 'go' &option.guioptions.type; &option.guioptions.default;

      Show or hide certain GUI elements.

      Supported characters:

      B
      Bookmark bar
      C
      Always show the command line outside of the status line
      M
      Always show messages outside of the status line
      N
      Tab number over image
      T
      Toolbar
      b
      Bottom scrollbar
      c
      Always show the command line, even when empty
      l
      Left scrollbar (l and r are mutually exclusive)
      m
      Menu bar
      n
      Tab number
      r
      Right scrollbar
      s
      Status bar

      See also showtabline.

      Scrollbar changes require a page reload to take effect. Only one of l or r may be included.       'hf' 'helpfile' 'helpfile' 'hf' &option.helpfile.type; &option.helpfile.default;

      Name of the main help file. This is that page shown if the :help command is called without any arguments.

      'hin' 'hintinputs' 'hintinputs' 'hin' &option.hintinputs.type; &option.hintinputs.default;

      When generating hints for input elements that do not have an explicit caption, this specifies the methods used to generate a textual hint. The options are attempted in the order they are given, and the first successful value is used.

      value
      The hint is the value displayed in a text input, or the selected option for a drop-down.
      label
      The value of an explicit label for the input; this will not match most manually added labels that are found on sites.
      name
      The name of the input will be used; although the name is not designed for user consumption, it is frequently very similar to the label.
             'hk' 'hintkeys' 'hintkeys' 'hk' &option.hintkeys.type; &option.hintkeys.default;

      The keys used to label and select hints. With its default value, each hint has a unique number which can be typed to select it, while all other characters are used to filter hints based on their text. With a value such as asdfg;lkjh, each hint is ‘numbered’ based on the characters of the home row.

      'hm' 'hintmatching' 'hintmatching' 'hm' &option.hintmatching.type; &option.hintmatching.default;

      Change the hint matching algorithm used in Hints mode.

      Possible values are one of:

      contains
      The typed characters are split on whitespace, and these character groups have to match anywhere inside the text of the link.
      wordstartswith
      The typed characters are matched with the beginning of the first word (see wordseparators) in the link as long as possible. If no matches occur in the current word, then the matching is continued at the beginning of the next word. The words are worked through in the order they appear in the link. If the typed characters contain spaces, then the characters are split on whitespace. These character groups are then matched with the beginning of the words, beginning at the first one and continuing with the following words in the order they appear in the link.
      firstletters
      Behaves like wordstartswith, but non-matching words aren't skipped.
      custom
      Delegate to the function dactyl.plugins.customHintMatcher.

      and optionally:

      transliterated
      Certain alphanumeric characters are transliterated into their unaccented equivalents, such that ‘euro’ will match 'æuró', and ‘Ångström’ will match ‘angstrom’.
      'ht' 'hinttags' 'hinttags' 'ht' &option.hinttags.type; :-moz-any-link,area,button,iframe,input:not([type=hidden]), label[for],select,textarea, [onclick],[onmouseover],[onmousedown],[onmouseup],[oncommand], [tabindex],[role=link],[role=button],[contenteditable=true]

      A list of CSS selectors or XPath expressions used to select elements for hinting. Values beginning with the string xpath: are treated as XPath expressions, while any other values are treated as CSS selectors. Can be overridden for individual extended-hints modes with the extendedhinttags option.

      'hto' 'hinttimeout' 'hinttimeout' 'hto' &option.hinttimeout.type; &option.hinttimeout.default;

      Timeout in milliseconds before automatically following a non-unique hint. The timeout is measured since the last time a key listed in hintkeys was pressed. It has no effect when narrowing hints by typing part of their text. Set to 0 (the default) to only follow hints after pressing or when the hint is unique.

      'hi' 'history' 'history' 'hi' &option.history.type; &option.history.default;

      Maximum number of Ex commands and find patterns to store in the command-line history.

      'nohlf' 'nohlfind' 'hlf' 'hlfind' 'hlfind' 'hlf' &option.hlfind.type; &option.hlfind.default;

      Highlight previous find pattern matches.

             'noif' 'noincfind' 'if' 'incfind' 'incfind' 'if' &option.incfind.type; &option.incfind.default;

      Show the first match for a find pattern as it is typed.

             'noim' 'noinsertmode' 'im' 'insertmode' 'insertmode' 'im' &option.insertmode.type; &option.insertmode.default;

      Use Insert mode as the default for text areas. This is useful if you want to use the known &dactyl.host; interface for editing text areas. Input fields default to this behavior irrespective of this option's setting.

      Text Edit mode can be entered with from Insert mode.

      'isk' 'iskeyword' 'iskeyword' 'isk' &option.iskeyword.type; &option.iskeyword.default;

      Regular expression defining which characters constitute words.

             'jt' 'jumptags' 'jumptags' 'jt' &option.jumptags.type; &option.jumptags.default;

      XPath or CSS selector strings of jumpable elements for extended hint modes.

             'ln' 'linenumbers' 'linenumbers' 'ln' &option.linenumbers.type; *, mxr.mozilla.org:a.l, pastebin.com:#code_frame>div>ol>li, addons.mozilla.org:.gutter>.line>a, bugzilla.mozilla.org:.bz_comment:not(.bz_first_comment):not(.ih_history), *:'/* Hgweb/Gitweb */ .completecodeline a.codeline, a.linenr']]>

      Patterns used to determine line numbers used by G. May be either a selector expression as accepted by hinttags, or the string func: followed by a JavaScript expression which evaluates to a function. In the former case, the first matching element whose text content is equal to the desired line number is used. If no such element exists, the countth matching element is used. In the latter case, the provided function must accept two arguments, the document in question and the desired line number, and must return the element corresponding to the given line.

      'lpl' 'loadplugins' 'loadplugins' 'lpl' &option.loadplugins.type; &option.loadplugins.default;

      A regular expression list that defines which plugins are loaded at startup or via :loadplugins. The first item to match is the one that takes effect. If no items match, the file is not loaded. Setting this to a blank value effectively disables plugin loading.

      For example, to prepend to the default value of this option to load all plugins except for foobar-plugin, you could use:

      !foobar-plugin

      Alternatively, you can specify which plugins to load and which to omit in your &dactyl.name;rc using something like the following:

      !foo|bar,\.(js|&dactyl.fileExt;)$

      That will load all plugins but foo and bar.

      Note that in the first expression of the latter example you don't need parentheses, as the ! negates the whole of the following expression (cf. regexplist).

      See also :runtime.

      'maxitems' 'maxitems' &option.maxitems.type; &option.maxitems.default;

      Maximum number of items to display at once in a listing.

             'msgs' 'messages' 'messages' 'msgs' &option.messages.type; &option.messages.default;

      Maximum number of messages to store in the message history.

             'nomore' 'more' 'more' &option.more.type; &option.more.default;

      Pause the message list window when more than one screen of listings is displayed.

      'newtab' 'newtab' &option.newtab.type; &option.newtab.default;

      Defines which Ex commands open pages in new tabs rather than the current tab by default. This may be overridden with the :tab command, and is usually inverted by affixing a ! to the command in question.

      Possible values:

      all
      All commands
      addons
      :addons command
      downloads
      :downloads command
      extoptions
      :extoptions command
      help
      :help command
      javascript
      :javascript! or :js! command
      prefs
      :preferences! or :prefs! command
             'nextpattern' 'nextpattern' &option.nextpattern.type; &option.nextpattern.default;

      Patterns to use when guessing the next page in a document sequence after pressing the ]] key. Each pattern is successively tested against each link in the page (as defined by hinttags, starting with the last), and the first link to match is followed.

      'noonline' 'online' 'online' &option.online.type; &option.online.default;

      Enables or disables ‘offline’ mode, where network access is disabled and all web pages are loaded entirely from cache.

      'pa' 'pageinfo' 'pageinfo' 'pa' &option.pageinfo.type; &option.pageinfo.default;

      Info shown in the :pageinfo output.

      Items available by default:

      g
      General info
      e
      Search Engines
      f
      Feeds
      m
      Meta tags
      s
      Security information

      The order of the options defines the order in which they appear in the result.

      'pk' 'passkeys' 'passkeys' 'pk' &option.passkeys.type; &option.passkeys.default;

      Pass certain keys through directly for the given URLs. For any page with a URL matching a given site-filter, all key events for keys listed in the corresponding value are passed through directly to &dactyl.host;, and are not processed by &dactyl.appName; in any way. Key names are separated by commas, where the first key name is treated as a list of individual keys and each subsequent key is treated as a key chain. Individual key entries always apply to all modes. Key chains apply only to non-input modes unless they begin with a key requiring a modifier other than shift.

      mail.google.com:jk<CR>,gi

      More subtle and complex pass through can be achieved using groups and mode-specific mappings utilizing the pseudo-key.

      'pu' 'passunknown' 'passunknown' 'pu' &option.passunknown.type; &option.passunknown.default;

      Pass unknown keys through to &dactyl.host; in these modes. The first element matching a currently active mode is the one that takes effect. Modes may be negated by prefixing them with a !.

      'pps' 'popups' 'popups' 'pps' &option.popups.type; &option.popups.default;

      Defines where to show requested pop-up windows. Applies only to links which request to open in a new window. The behavior of middle-, shift-, or control- clicking a link is unaffected by this option.

      Possible values are:

      tab
      Open pop-ups in a new tab
      window
      Open pop-ups in a new window
      resized
      Open resized pop-ups in a new window

      If neither tab nor window is provided, all pop-ups open in the current tab. tab and window are mutually exclusive, and the last one listed is effective.

      This option does not alter the &dactyl.host; pop-up blocker behavior in any way.       'previouspattern' 'previouspattern' &option.previouspattern.type; &option.previouspattern.default;

      Patterns to use when guessing the previous page in a document sequence after pressing the [[ key. Each pattern is successively tested against each link in the page (as defined by hinttags, starting with the last), and the first link to match is followed.

      $&dactyl.idName;_RUNTIME 'rtp' 'runtimepath' 'runtimepath' 'rtp' &option.runtimepath.type; $&dactyl.idName;_RUNTIME or Unix, Mac: ~/.&dactyl.name; Windows: ~/&dactyl.name;

      List of directories searched for runtime files:

      • colors/
      • plugins/

      Example:

      ~/my&dactyl.name;,~/.&dactyl.name;

      This will search for plugins in both ~/my&dactyl.name;/plugins and ~/.&dactyl.name;/plugins

      On startup, if the environment variable $&dactyl.idName;_RUNTIME does not exist, &dactyl.appName; will set it to match this value.

      'si' 'sanitizeitems' 'sanitizeitems' 'si' &option.sanitizeitems.type; &option.sanitizeitems.default;

      The default list of private items to sanitize. See :sanitize for a list and explanation of possible values. A value of all will cause all items to be sanitized. Items may be excluded by prefixing them with a !. The first matching item takes precedence.

      'ss' 'sanitizeshutdown' 'sanitizeshutdown' 'ss' &option.sanitizeshutdown.type; &option.sanitizeshutdown.default;

      The items to sanitize automatically at shutdown.

             'sts' 'sanitizetimespan' 'sanitizetimespan' 'sts' &option.sanitizetimespan.type; &option.sanitizetimespan.default;

      The default sanitizer time span. Only items created within this timespan are deleted. The value must be of the one of:

      all
      Everything
      session
      The current session
      nm
      Past n Minutes
      nh
      Past n Hours
      nd
      Past n Days
      nw
      Past n Weeks
             'scr' 'scroll' 'scroll' 'scr' &option.scroll.type; &option.scroll.default;

      Number of lines to scroll with and commands. The number of lines scrolled defaults to half the window size. When a count is specified to the or commands, set this option to count before executing the command. Setting this to 0 restores the default behaviour.

      'scs' 'scrollsteps' 'scrollsteps' 'scs' &option.scrollsteps.type; &option.scrollsteps.default;

      The number of steps in which to smooth scroll to a new position. If set to 1, smooth scrolling is not used.

      'sct' 'scrolltime' 'scrolltime' 'sct' &option.scrolltime.type; &option.scrolltime.default;

      The time, in milliseconds, in which to smooth scroll to a new position.

             'sh' 'shell' 'shell' 'sh' &option.shell.type; $SHELL or sh, Windows: cmd.exe

      Shell to use for executing :! and :run commands.

             'shcf' 'shellcmdflag' 'shellcmdflag' 'shcf' &option.shellcmdflag.type; -c, Windows: /c

      Flag passed to shell when executing :! and :run commands.

             'smd' 'showmode' 'showmode' 'smd' &option.showmode.type; &option.showmode.default;

      Show the current mode in the command line if it or any of its parent modes is included in the list. Modes may be negated by prefixing them with a !.

      'ssli' 'showstatuslinks' 'showstatuslinks' 'ssli' &option.showstatuslinks.type; &option.showstatuslinks.default;

      When the mouse hovers over a link, or a link is otherwise focused, show its destination in the status bar.

      Possible values are:

      Don't show link destination
      status
      Show the link destination in the &tag.status-line;
      command
      Show the link destination in the &tag.command-line;
             'stal' 'showtabline' 'showtabline' 'stal' &option.showtabline.type; &option.showtabline.default;

      Define when the tab bar is visible.

      always
      Always show the tab bar
      multitab
      Show the tab bar when there are multiple tabs
      never
      Never show the tab bar
             'spl' 'spelllang' 'spelllang' 'spl' &option.spelllang.type; &option.spelllang.default;

      The language used by the spell checker.

             'sf' 'strictfocus' 'strictfocus' 'sf' &option.strictfocus.type; &option.strictfocus.default;

      Prevent scripts from focusing input elements without user intervention.

      Possible values:

      despotic
      Only allow focus changes when explicitly requested by the user
      laissez-faire
      Always allow focus changes
      moderate
      Allow focus changes after user-initiated focus change
             'suggestengines' 'suggestengines' &option.suggestengines.type; &option.suggestengines.default;

      Set the search engines which can be used for completion suggestions when complete contains S.

      'notmo' 'notimeout' 'tmo' 'timeout' 'timeout' 'tmo' &option.timeout.type; &option.timeout.default;

      When this option is set and a key sequence interpretable both as a complete command and as a start of a longer command is typed, execute the shorter command after timeoutlen milliseconds.

      'tmol' 'timeoutlen' 'timeoutlen' 'tmol' &option.timeoutlen.type; &option.timeoutlen.default;

      Maximum number of milliseconds to wait for a longer key command when a shorter one exists. Only effective when timeout is set.

      'titlestring' 'titlestring' &option.titlestring.type; &option.titlestring.default;

      Set the application name shown after the current page title in &dactyl.host;'s title bar.

      Mozilla &dactyl.host;       'us' 'urlsep' 'urlseparator' 'urlseparator' 'urlsep' 'us' &option.urlseparator.type; &option.urlseparator.default;

      The regular expression used to split URL lists in commands like :open. When set to the empty string, URL lists are never split. With the default settings, the following will open three URLs (the first one in the current tab and the latter two in two new background tabs):

      :open google Linux | wikipedia Arch Linux | imdb Serenity       'noum' 'nousermode' 'um' 'usermode' 'usermode' 'um' &option.usermode.type; &option.usermode.default;

      Show current website with minimal styling.

             'vbs' 'verbose' 'verbose' 'vbs' &option.verbose.type; &option.verbose.default;

      Define which info messages are displayed. As the value increases, &dactyl.appName; will show more messages about its progress. These can be viewed at any time with the :messages command. The highest useful value is 15, being the most verbose mode.

      'novb' 'novisualbell' 'vb' 'visualbell' 'visualbell' 'vb' &option.visualbell.type; &option.visualbell.default;

      Use visual bell instead of beeping on errors. The visual bell style is controlled by :highlight Bell. See also errorbells.

      'wia' 'wildanchor' 'wildanchor' 'wia' &option.wildanchor.type; &option.wildanchor.default;

      Regular expression list defining which completion groups show only matches anchored to the beginning of the result. The first matching expression is the one that applies. If the match is negated, then the current filter may match anywhere in the result. If it is not negated, then the match may only occur at the beginning of the result. If no items match, then a context-dependent default value is used.

      'wic' 'wildcase' 'wildcase' 'wic' &option.wildcase.type; &option.wildcase.default;

      Defines how completions are matched with regard to character case. Keys in the regexpmap refer to completion context names (see :contexts) for which the value applies. Possible values are:

      smart
      Case is significant when capital letters are typed
      match
      Case is always significant
      ignore
      Case is never significant
             'wig' 'wildignore' 'wildignore' 'wig' &option.wildignore.type; &option.wildignore.default;

      List of path name patterns to ignore when completing files and directories. For example, the following will ignore object files and Vim swap files:

      \.o$,^\..*\.s[a-z]{2}$ Unlike Vim, each pattern is a regular expression rather than a glob.       'wim' 'wildmode' 'wildmode' 'wim' &option.wildmode.type; &option.wildmode.default;

      Defines how command-line completion works. It is a comma-separated list of parts, where each part specifies what to do for each consecutive press of the key. The last element in the list is used for each succeeding after it has been reached.

      These are the possible values for each part:

      Complete only the first match.
      full
      Complete the next full match. After the last, the original string is used.
      longest
      Complete the longest common substring of all completions.
      list
      When more than one match, list all matches.
      list:full
      When more than one match, list all matches and complete the first match.
      list:longest
      When more than one match, list all matches and complete till the longest common string. When there is only a single match, it is fully completed regardless of the case.

      See also altwildmode.

      'wis' 'wildsort' 'wildsort' 'wis' &option.wildsort.type; &option.wildsort.default;

      A list of regular expressions defining which completion contexts should be sorted. The main purpose of this option is to prevent sorting of certain completion lists that don't perform well under load.

      See also :contexts.

             'wsp' 'wordseparators' 'wordseparators' 'wsp' &option.wordseparators.type; &option.wordseparators.default;

      A regular expression which defines how words are split for the hintmatching types wordstartswith and firstletters. Words are split on each occurrence of the given pattern.

      'ys' 'yankshort' 'yankshort' 'ys' &option.yankshort.type; &option.yankshort.default;

      Yank the canonical short URL of a web page where provided.

             dactyl-1.2~r20151231/common/locale/en-US/pattern.xml000066400000000000000000000075441264147376100217350ustar00rootroot00000000000000

      Text find commands

      &dactyl.appName; provides a Vim-like incremental find interface to replace &dactyl.host;'s crippled Typeahead Find. Among other improvements, our find service:

      • Starts at the cursor position in the currently selected frame, unlike &dactyl.host;, which always starts at the beginning of the first frame for documents with more than one frame.
      • Returns the cursor and viewport to their original position on cancel.
      • Backtracks to the first successful match after pressing backspace, unlike &dactyl.host;, which will always continue from the last match.
      • Supports reverse incremental find.
      • Escape sequences to toggle link-only and case-sensitive find.
      • Crude regular expression searches are supported.
      /]]> /pattern

      Find pattern starting at the current caret position.

      The following escape sequences can be used anywhere in pattern to modify the behavior of the search. When flags conflict, the last to appear is the one that takes effect.

      \c
      Perform case insensitive find (default if findcase=ignore).
      \C
      Perform case sensitive find (default if findcase=match).
      \l
      Search only in links, as defined by hinttags.
      \L
      Search the entire page.
      \r
      Process the entire pattern as a regular expression.
      \R
      Process the entire pattern as an ordinary string.

      findflags can be used to set flags that will be applied implicitly to each search.

      ?]]> ?pattern

      Find a pattern backward of the current caret position in exactly the same manner as /.

      n]]> n

      Find next. Repeat the last find.

             N]]> N

      Find previous. Repeat the last find in the opposite direction.

             *]]> *

      Search forward for the next occurrence of the word under cursor.

             #]]> #

      Search backward for the previous occurrence of the word under cursor.

             :noh :nohlfind :nohlfind

      Remove the find highlighting. The document is highlighted again when another find command is used or the hlfind option is set.

      dactyl-1.2~r20151231/common/locale/en-US/print.xml000066400000000000000000000023471264147376100214100ustar00rootroot00000000000000

      Printing

      :ha :hardcopy :hardcopy!

      Print current document. Open a GUI dialog where you can select the printer, number of copies, orientation, etc. When used with !, the dialog is skipped and the default printer used.

      :hardcopy! >filename

      As above, but write the output to filename.

      &dactyl.host; printing dialogs

      The "Print Preview" and "Page Setup" dialogs can be opened via the :dialog command

      :dialog printpreview

      and

      :dialog printsetup

      respectively.

      dactyl-1.2~r20151231/common/locale/en-US/privacy.xml000066400000000000000000000145701264147376100217320ustar00rootroot00000000000000

      Privacy and sensitive information

      Part of &dactyl.appName;'s user efficiency comes at the cost of storing a lot of potentially private data, including command-line history, page marks, visited page history, and the like. Because we know that keeping a detailed trail of all of your activities isn't always welcome, &dactyl.appName; provides comprehensive facilities for erasing potentially sensitive data.

      Private browsing

      &dactyl.appName; fully supports &dactyl.host;'s private browsing mode. When in private browsing mode, no data other than Bookmarks and QuickMarks are written to disk. Further, upon exiting private mode, all newly accumulated data, including command-line history, local and URL marks, and macros, are purged from memory.

      Clearing private data

      In addition to private mode, &dactyl.appName; provides a comprehensive facility for clearing any potentially sensitive data generated by either &dactyl.appName; or &dactyl.host;. It directly integrates with &dactyl.host;'s own sanitization facility, and so automatically clears any domain data and session history when requested. Further, &dactyl.appName; provides its own more granular sanitization facility, which allows, e.g., clearing only the command-line and macro history for the past ten minutes.

      :sa :sanitize :sanitize -host=host -older -timespan=timespan item … :sanitize! -host=host -older -timespan=timespan

      Clear private data items for timespan, where item … is a list of private items to delete. If ! is specified, then sanitizeitems is used for the list of items to delete. Items may be any of:

      Items may be excluded by prefixing them with a !. The first matching item takes precedence. Therefore, the value !commandline all will sanitize all items but the command line. A value of all !commandline will sanitize all items.

      When history items are sanitized, all command-line history items containing URLs or page titles (other than bookmark commands) are additionally cleared. Invocations of the :sanitize command are included in this set.

      If timespan (short name -t) is specified, only items within that timespan are deleted, otherwise the value of sanitizetimespan is used. If -older (short name -o) is specified, then only items older than timespan are deleted.

      The following items are always cleared entirely, regardless of timespan: cache, host, offlineapps, passwords, sessions, sitesettings. Conversely, host and options are never cleared unless a host is specified.

      If host (short name -h) is specified, only items containing a reference to that domain or a subdomain thereof are cleared. Moreover, if either of commandline or history is specified, the invocation of the :sanitize command is naturally cleared as well.

      This only applies to commandline, cookies, history, marks, messages, options, and sitesettings. All other domain-specific data is cleared only along with host, when a request is made to &dactyl.host; to purge all data for host. Included in this purge are all matching history entries, cookies, closed tabs, form data, and location bar entries. :private :pr :pr0n :porn :private cmd

      Execute cmd with privacy features enabled, and do not save the invocation in command history.

      Cookie settings

      :cookies :ck :cookies host action …

      Manage cookies for host. Additionally, the completion list will show you information about the cookies and permissions for the current page.

      Available actions:

      unset
      Unset special permissions for host
      allow
      Allow cookies from host
      deny
      Deny cookies from host
      session
      Allow cookies from host for the current session
      list
      List all cookies for host
      clear
      Clear all cookies for host
      clear-persistent
      Clear all persistent cookies for host
      clear-session
      Clear all session cookies for host

      If no action is given, the value of cookies is used.

      :map -b c :cookies       dactyl-1.2~r20151231/common/locale/en-US/repeat.xml000066400000000000000000000416221264147376100215330ustar00rootroot00000000000000

      Repeating commands

      &dactyl.appName; can repeat commands in a number of ways, from repeating the last command, to recording and playing macros, to saving its state and executing scripts.

      Single repeats

      <repeat-key> . count.

      Repeat the last keyboard mapping count times. Note that, unlike in Vim, this also applies to other than editing commands.

      @: count@:

      Repeat the last Ex command count times.

      Macros

      <record-macro> q qa-zA-Z

      Record a key sequence as a macro. Available macros are a-zA-Z. If the macro is an uppercase letter, the recorded keys are appended to the lowercase macro of the same name. Typing q again stops the recording.

      :macros :macros pat

      List recorded macros matching the optional regular expression pat. If no regexp is given, list all macros.

      :delmac :delmacros :delmacros pat :delmacros!

      Delete recorded macros matching the regular expression pat. If ! is given, all macros are deleted.

      <play-macro> @ count@a-z

      Plays the contents of macro with name a-z count times.

      @@ count@@

      Replay the last executed macro count times.

      Macro utilities

      The following key bindings facilitate the recording of efficient macros. They have no effect when typed normally, but are recorded and take effect during macro playback.

      s]]> counts]]>

      Sleep for count milliseconds before resuming playback.

      l]]> countl]]>

      Wait for the current page to finish loading before resuming playback. If count is given, wait no more than count seconds. Otherwise wait no more than 25 seconds.

      Groups

      In order to facilitate script writing, especially scripts which only apply to certain web sites, many types of commands and mappings can be assigned to a named group. In addition to helping identify the source of such mappings in listings, and aiding in the cleanup of scripts, these groups can be configured to apply only to certain web sites.

      :gr :group :group

      List all active groups.

             :group! group …

      Select, create, or modify a group. After invocation, group becomes the default group for all further commands issued in the current script. If ! is given the group is cleared of all mappings, commands, and any other entries bound to it before making the specified additions (if any).

      The following group names have special meanings:

      builtin
      The default group for builtin items. Can not be modified in any way by scripts.
      default
      The default group for the script containing this :group command.
      user
      The default group for the command line and &dactyl.name;rc.

      The following arguments are available:

      -args=javascript
      JavaScript Object which augments the arguments passed to commands, mappings, and autocommands, e.g., given { foo: "bar" }, foo (<foo> if the Ex syntax is used) will be replaced by bar inside the definitions (short name: -a)
      -description
      A description of this group (short names: -desc, -d)
      -locations=filters
      The URLs for which this group should be active. See site-filters (short names: -locs, -loc, -l)
      -nopersist
      Do not save this group to an auto-generated RC file (short name: -n)
             :delgr :delgroup :delgroup group :delgroup!

      Delete the specified group. With ! delete all user groups.

      Site Filters

      Many &dactyl.appName; commands accept filters so that they may be applied only to specific sites. Most of these commands accept filters in any of the following formats:

      domain
      Any filter which is a valid domain name will match any site on that domain or any sub-domain thereof. These filters may contain any letter of the Roman alphabet, Arabic numerals, hyphens, and full stops. Non-Latin domain names must be punycode encoded.
      URL prefix
      Any URL beginning with a valid protocol name and ending with a * is treated as a URL prefix. It will match any URL which begins with the given filter sans the trailing asterisk.
      Full URL
      Any URL beginning with a valid protocol name and not ending with an asterisk is treated as a full URL match. It will match any page which has a URL identical to the filter.
      Regular expression
      Any filter which does not fall into one of the above categories is treated as a case-sensitive regular expression.

      In most cases, any of the above may be prefixed with a ! character to exclude matching sites.

      Using scripts

      :so :source :source! file

      Read Ex commands, JavaScript, or CSS from file. Files are interpreted based on their extensions. Files which end in .js are executed as JavaScript, while those ending in .css are loaded as Cascading Stylesheets, and anything else is interpreted as Ex commands. In normal cases, any errors generated by the execution or non-existence of file are printed to the command-line area. When ! is provided, these are suppressed.

      Environment variables in file are expanded to their current value, and the prefix ~ is replaced with the value of $HOME. See expand-env and initialization for more information.

      Script Contexts

      Each script executes in its own JavaScript context. This means that any global variable or function, including those defined by :javascript and the -javascript flag of :map, :command, and :autocmd, is directly available only within the current script. Outside of the current script, they can only be accessed as properties of the script's global object, which is stored in the plugins global under the script's full path.

      Script Groups

      In addition to its own JavaScript context, each script is executed with its own default group into which its styles, mappings, commands, abbreviations and autocommands are placed. This means that commands such as :delcommand! can be issued without fear of trampling other user-defined mappings. The command :group! default can be issued to clear all such items at once, and should be placed at the head of most scripts to prevent the accumulation of stale items when the script is re-sourced.

      Cascading Stylesheets

      When a CSS file is sourced, its contents are applied to every web page and every chrome document, including all browser windows and dialogs. If the same file is sourced more than once, its previous rules are cleared before it is applied again. Rules can be restricted to specific documents by enclosing them in @-moz-document blocks.

      JavaScript

      JavaScript files are executed with full chrome privileges in their own global namespaces. These namespaces are stored as objects in the plugins object, in the property named after the full path of the sourced file. This means that any variables or functions created by your script are stored as properties of that object. Additionally, all properties of the global window and modules objects are accessible to your script as global variables.

      Files in ~/.&dactyl.name;/plugins may additionally be accessed in plugins.filename where filename is the last component of the file's path stripped of any extensions, with all hyphens stripped and any letter following a hyphen capitalized. So, the file ~/.&dactyl.name;/plugins/foo-bar.js may be accessed as plugins.fooBar. See also writing-plugins.

      Ex commands

      Ex command files are executed as if each line were entered into the &tag.command-line; individually. Additionally, certain commands support the same ‘here document’ syntax supported by most Unix shells and by the &tag.command-line;. So, to execute a JavaScript statement which does not comfortably fit on a single line, you can use:

      :js <<EOF var hello = function () { alert(Hello world); } EOF

      See also ex-scripts below.

             :lpl :loadplugins :loadplugins[!] pattern …

      Immediately load all plugins which have yet to be loaded. Because plugins are not automatically loaded until after &dactyl.name;rc is sourced, this command must be placed early in the &dactyl.name;rc file if &dactyl.name;rc uses commands or options which are defined by plugins. Additionally, this command allows newly installed plugins to be easily loaded without restarting &dactyl.appName;. See also loadplugins.

      If patterns are provided, the given regular expressions are used as filters rather than those in loadplugins.

      If ! is given the plugins are forcibly loaded.

      :runt :runtime :runtime! file …

      Source the specified file from the first directory in runtimepath in which it exists. When ! is given, source the file from all directories in runtimepath in which it exists.

      :runtime plugins/foobar.js       :scrip :scriptnames :scriptnames

      List all sourced script names, in the order they were first sourced.

             :fini :finish :finish

      Stop sourcing a script file. This can only be called from within a &dactyl.appName; script file.

      Ex Command Scripts

      Ex command scripts are similar to both entering commands on the &tag.command-line; and to Vim scripts, but with some notable differences.

      Commands in Ex command scripts can span multiple lines by prefixing the second and further lines with a \ character. For instance, the following all define commands whose definitions span multiple lines.

      :command! foo \ -description A command that frobs bars \ :javascript frob(content.bar) :style -name foo \ foobar.com \ p:first-line { font-variant: small-caps; } \ div#side-bar > :first-child { display: none; } :command! do-some-stuff \ -description A command which does some stuff in JavaScript \ :javascript <<EOF \ window.do(some); \ window.do(stuff); \EOF :command! do-some-stuff \ -description A command which does some stuff in JavaScript \ :javascript \\ window.do(some); \\ window.do(stuff);

      Lines may be commented out by prefixing them with a " character. Comments and commands cannot both occur in a single command line.

      " This is a comment foo bar " This is a syntax error This is not a comment foo bar This is not a comment

      Profiling

      :time :counttime! code|:command

      Profile a piece of JavaScript code or an Ex command. Run code count times and print the elapsed time. If code begins with a :, it is executed as an Ex command. Otherwise, it is executed as JavaScript, in which case it is evaluated only once and stored as a function which is executed count times.

      When ! is given, code is executed count times, but no statistics are printed.

      dactyl-1.2~r20151231/common/locale/en-US/starting.xml000066400000000000000000000156751264147376100221170ustar00rootroot00000000000000

      Starting &dactyl.appName;

      Command-line options

      Command-line options can be passed to &dactyl.appName; via the -&dactyl.name; &dactyl.host; option. These are passed as single string argument. E.g., &dactyl.hostbin; -&dactyl.name; ++cmd 'set exrc' +u 'tempRcFile' ++noplugin

      The -&dactyl.name;-remote command-line option can be used to execute a single Ex command in an already running Pentadactyl instance.

      +c +c command

      Execute a single Ex command after all initialization has been performed. See initialization.

      This option can be specified multiple times.

             ++cmd ++cmd command

      Execute a single Ex command before any initialization has been performed. See initialization.

      This option can be specified multiple times.

             +u +u rcfile

      The file rcfile is used for user initialization commands. If rcfile is NORC then no startup initialization is performed except for the loading of plugins, i.e., steps 1. and 2. in initialization are skipped. If rcfile is NONE then plugin loading is also skipped.

      ++noplugin ++noplugin

      Prevents plugin scripts from being loaded at startup. See loadplugins.

             +purgecaches +purgecaches

      Purges &dactyl.appName; caches at startup. May occasionally be necessary after making local changes to the source tree.

      Initialization

      At startup, &dactyl.appName; completes the following tasks in order.

      1. &dactyl.appName; first searches for user initialization commands in the following locations. The first of these to be found is executed, after which no further locations are searched.

        1. $&dactyl.idName;_INIT May contain a single Ex command (e.g., ":source file").
        2. ~/_&dactyl.name;rc Windows only. If this file exists, its contents are executed and $MY_&dactyl.idName;RC set to its path.
        3. ~/.&dactyl.name;rc If this file exists, its contents are executed.

      2. If exrc is set and the +u command-line option was not specified, then any RC file in the current directory is also sourced.

      3. All directories in runtimepath are searched for a ‘plugins’ subdirectory and all yet unloaded plugins are loaded. For each plugins directory, all *.{js,&dactyl.fileExt;} files (including those in further subdirectories) are sourced alphabetically. No plugins will be sourced if,

        • loadplugins is unset,
        • the ++noplugin command-line option was specified, or
        • the +u=NONE command-line option was specified.

        Any plugin which was already loaded (e.g., by an earlier invocation of the :loadplugins command) will be skipped.

      The user's home directory is determined as follows:

      • On Unix and Mac, the environment variable $HOME is used.
      • On Windows, &dactyl.appName; checks for the existence of %HOME%, then %USERPROFILE%, and then %HOMEDRIVE%%HOMEPATH%. It uses the first one it finds.

      Saving settings

      :mkp :mk&dactyl.name;rc :mkpentadactylrc! file

      Write current key mappings and changed options to file. If no file is specified then ~/.&dactyl.name;rc is written unless this file already exists. The special version :mk&dactyl.name;rc! will overwrite file if it exists.

      This behavior differs from that of Vim, which defaults to writing the file in the current directory.

      Restarting

      :reh :rehash :rehash arg …

      Reload the &dactyl.appName; add-on, including all code, plugins, and configuration. For users running directly from the development repository, this is a good way to update to the latest version or to test your changes.

      Any arguments supplied are parsed as command-line arguments as specified in startup-options.

      Not all plugins are designed to cleanly un-apply during a rehash. While official plugins are safe, beware of possible instability if you rehash while running third-party plugins.       :res :restart :restart arg …

      Force &dactyl.host; to restart. Useful when installing extensions.

      Any arguments supplied are parsed as command-line arguments as specified in startup-options.

      dactyl-1.2~r20151231/common/locale/en-US/styling.xml000066400000000000000000000565071264147376100217540ustar00rootroot00000000000000

      Styling the GUI and web pages

      &dactyl.appName; allows you to apply custom CSS styling to the web pages you view as well as to the browser itself. Although it is possible to style any user interface element via the :style command, most &dactyl.appName; elements can be styled more easily by means of the more specialized :highlight command.

      E185 :colo :colorscheme :colorscheme name

      Load a color scheme. name is found by searching the runtimepath for the first file matching colors/name.&dactyl.fileExt;. The special scheme default can be used to reload the default highlight settings.

      The ColorScheme autocommand is triggered after the color scheme has been sourced.

      :hi :highlight :highlight! groupselector :highlight! -append -link=group,… groupselector css

      Highlight group with css. css is one or more semicolon-separated CSS declarations (E.g. color: blue; background-color: red). selector, if provided, may be any valid CSS selector (such as :hover or [href]), and will restrict the highlighting to matching elements.

      If -link (short name -l) is supplied, the value of each of the listed groups is prepended to the style of this group.

      Valid groups include:

      Addon
      An add-on in the :addons manager
      AddonBar
      AddonButton
      AddonButtons
      AddonCell
      A cell in tell :addons manager
      AddonDescription
      AddonHead
      A heading in the :addons manager
      AddonName
      AddonStatus
      AddonVersion
      Addons
      The :addons manager
      AppmenuButton
      The app-menu button
      Bell
      &dactyl.appName;'s visual bell
      Boolean
      JavaScript booleans
      Button
      A button widget
      Buttons
      A group of buttons
      CmdCmdLine
      CmdErrorMsg
      CmdInfoMsg
      CmdInput
      CmdLine
      The command line
      CmdModeMsg
      CmdMoreMsg
      CmdNormal
      CmdOutput
      The output of commands executed by :run
      CmdPrompt
      CmdQuestion
      CmdWarningMsg
      Comment
      JavaScriptor CSS comments
      CompDesc
      The description column of the completion list
      CompGroup
      Item group in completion output
      CompIcon
      The favicon of a completion row
      CompIcon>img
      CompItem
      A single row of output in the completion list
      CompItem[selected]
      A selected row of completion list
      CompLess::after
      The character of indicator shown when completions may be scrolled up
      CompLess
      The indicator shown when completions may be scrolled up
      CompMore::after
      The character of indicator shown when completions may be scrolled down
      CompMore
      The indicator shown when completions may be scrolled down
      CompMsg
      The message which may appear at the top of a group of completion results
      CompResult
      The result column of the completion list
      CompTitle
      Completion row titles
      CompTitleSep
      The element which separates the completion title from its results
      Dense
      Arbitrary elements which should be packed densely together
      Disabled
      Disabled item indicator text
      Download[active]
      A currently active download
      Download
      A download in the :downloads manager
      DownloadButtons
      A button group in the :downloads manager
      DownloadCell
      A table cell in the :downloads manager
      DownloadHead
      A heading in the :downloads manager
      DownloadPercent
      The percentage column for a download
      DownloadProgress
      The progress column for a download
      DownloadProgressHave
      The completed portion of the progress column
      DownloadProgressTotal
      The remaining portion of the progress column
      DownloadSource
      The download source column for a download
      DownloadState
      The download state column for a download
      DownloadTime
      The time remaining column for a download
      DownloadTitle
      The title column for a download
      Downloads
      The :downloads manager
      EditorBlink1
      Text fields briefly after successfully running the external editor, alternated with EditorBlink2
      EditorBlink2
      Text fields briefly after successfully running the external editor, alternated with EditorBlink1
      EditorEditing
      Text fields for which an external editor is open
      EditorError
      Text fields briefly after an error has occurred running the external editor
      Enabled
      Enabled item indicator text
      ErrorMsg
      Error messages
      Filter
      The matching text in a completion list
      FontCode
      The font used for code listings
      FontFixed
      The font used for fixed-width text
      FontProportional
      The font used for proportionally spaced text
      Find
      Text find highlighting. Only background and foreground colors apply.
      FrameIndicator
      The styling applied to briefly indicate the active frame
      Function
      JavaScript functions
      Help
      A help page
      HelpArg
      A required command argument indicator
      HelpBody
      The body of a help page
      HelpBorder
      The styling of bordered elements
      HelpCode
      Code listings
      HelpDefault
      The default value of a help item
      HelpDescription
      The description of a help item
      HelpDescription[short]
      HelpEm
      Emphasized text
      HelpEx
      An Ex command
      HelpExample
      An example
      HelpHead1
      Any help heading
      HelpHead2
      A first-level help heading
      HelpHead3
      A second-level help heading
      HelpHead4
      A third-level help heading
      HelpHead
      A fourth-level help heading
      HelpInclude
      A help page included in the consolidated help listing
      HelpInfo
      Arbitrary information about a help item
      HelpInfoLabel
      The label for a HelpInfo item
      HelpInfoValue
      The details for a HelpInfo item
      HelpItem
      A help item
      HelpKey
      A keyboard key specification
      HelpKeyword
      A keyword
      HelpLink
      A hyperlink
      HelpLink[rel=external]
      A hyperlink to an external resource
      HelpList
      An unordered list
      HelpListItem
      A list item, ordered or unordered
      HelpNews
      A news item
      HelpNewsNew
      A new news item
      HelpNewsOld
      An old news item
      HelpNewsTag
      The version tag for a news item
      HelpNote
      The indicator for a note
      HelpOpt
      An option name
      HelpOptInfo
      Information about the type and default values for an option entry
      HelpOptionalArg
      An optional command argument indicator
      HelpOrderedList1
      A first-level ordered list
      HelpOrderedList2
      A second-level ordered list
      HelpOrderedList3
      A third-level ordered list
      HelpOrderedList4
      A fourth-level ordered list
      HelpOrderedList
      Any ordered list
      HelpParagraph
      An ordinary paragraph
      HelpSpec
      The specification for a help entry
      HelpString
      A quoted string
      HelpTOC
      The Table of Contents for a help page
      HelpTOC>ol
      HelpTT
      Teletype text
      HelpTab
      HelpTabColumn
      HelpTabDescription
      The description column of description tables
      HelpTabRow
      Entire rows in description tables
      HelpTabTitle
      The title column of description tables
      HelpTag
      A help tag
      HelpTags
      A group of help tags
      HelpTopic
      A link to a help topic
      HelpType
      An option type
      HelpWarning
      The indicator for a warning
      HelpXML
      Highlighted XML
      HelpXMLAttribute
      HelpXMLBlock
      HelpXMLComment
      HelpXMLNamespace
      HelpXMLProcessing
      HelpXMLString
      HelpXMLTagEnd
      HelpXMLTagStart
      HelpXMLText
      Hint
      HintActive
      The hint element of link which will be followed by
      HintElem
      The hintable element
      HintImage
      The indicator which floats above hinted images
      Hint[active]
      Indicator
      The # and % in the :buffers list
      InfoMsg
      Information messages
      InlineHelpLink
      A help link shown in the command line or multi-line output area
      Key
      Keywords
      Keyword
      A bookmark keyword for a URL
      LineNr
      The line number of an error
      Link
      A link with additional information shown on hover
      LinkInfo
      Information shown when hovering over a link
      Message
      Message
      A message as displayed in :messages
      ModeMsg
      The mode indicator
      MoreMsg
      The indicator that there is more text to view
      NonText
      The ~ indicators which mark blank lines in the completion list
      Normal
      Normal text
      Null
      JavaScript null values
      Number
      JavaScript numbers
      Object
      JavaScript objects
      Preview
      The completion preview displayed in the &tag.command-line;
      Question
      A prompt for a decision
      REPL-E
      Evaled input in REPL mode
      REPL-P
      Evaled output in REPL mode
      REPL-R
      Prompts in REPL mode
      REPL
      Read-Eval-Print-Loop output
      StatusInfoMsg
      Information messages in the status line
      StatusLine
      The status bar
      StatusLineBroken
      The status bar for a broken web page
      StatusLineExtended
      The status bar for a secure web page with an Extended Validation (EV) certificate
      StatusLineNormal
      The status bar for an ordinary web page
      StatusLineSecure
      The status bar for a secure web page
      StatusModeMsg
      The mode indicator in the status line
      StatusMoreMsg
      StatusNormal
      Normal text in the status line
      StatusQuestion
      A prompt for a decision in the status line
      StatusWarningMsg
      A warning message in the status line
      String
      String values
      TabClose
      The close button of a browser tab
      TabIcon
      The icon of a browser tab
      TabIconNumber
      The number of a browser tab, over its icon
      TabNumber
      The number of a browser tab, next to its icon
      TabText
      The text of a browser tab
      Tag
      A bookmark tag for a URL
      Title
      The title of a listing, including :pageinfo, :jumps
      URL:hover
      URL
      A URL
      URLExtra
      Extra information about a URL
      Usage
      Output from the :*usage commands
      UsageBody
      The body of listings in output from the :*usage commands
      UsageHead
      Headings in output from the :*usage commands
      UsageItem
      Individual items in output from the :*usage commands
      WarningMsg
      A warning message

      The help system also has a comprehensive set of styling groups which are not explained here, but many of which are described along with writing-docs.

      Every invocation completely replaces the styling of any previous invocation, unless -append (short name -a) is provided, in which case css is appended to its current value. If css is not provided, any styles beginning with group are listed.

      :highlight-clear :highlight clear group

      Reset the highlighting for group to its default value. If group is not given, reset all highlighting groups.

      :sty :style :style -name=name -group=name -agent filter css :style -name=name -append filter css :style -name=name -group=name filter

      Add CSS styles to the browser or to web pages. filter is a comma-separated list of site-filters for which the style will apply. The ! character may not be used to invert the sense of the match. css is a full CSS rule set (e.g., body { color: blue; }).

      The following options are available:

      -append
      If provided along with -name, css and filter are appended to its current value. (short name -a)
      -agent
      If provided, the style is installed as an Agent sheet, which applies to contents user interface widgets as well as normal elements. (short name -A)
      -group=group
      The group to which to add this style. Please note that this grouping is for semantic and cleanup purposes only. No additional site filtering is applied.
      -name=name
      If provided, any existing style with the same name is overridden, and the style may later be deleted using name. (short name -n)

      If css isn't provided, matching styles are listed.

             :dels :delstyle :delstyle! -name=name -index=index filter css

      Delete any matching styles. With !, delete all styles. If filter is provided, only matching elements of the filter are disabled. For instance, when run with a filter mozilla.org, an existing style with a filter www.google.com,mozilla.org, will result in a style for www.google.com.

      The available options are:

      -name
      The name provided to :style (short name -n)
      -index
      For unnamed styles, the index listed by :style (short name -i)
             :styleenable :stylee :styenable :stye :styleenable! -name=name -index=index filter css

      Enable any matching styles. With !, enable all styles. Arguments are the same as for :delstyle

             :styledisable :styled :stydisable :styd :styledisable! -name=name -index=index filter css

      Disable any matching styles. With !, disable all styles. Arguments are the same as for :delstyle

             :styletoggle :stylet :stytoggle :styt :styletoggle! -name=name -index=index filter css

      Toggle any matching styles. With !, toggle all styles. Arguments are the same as for :delstyle

             dactyl-1.2~r20151231/common/locale/en-US/tabs.xml000066400000000000000000000316101264147376100212000ustar00rootroot00000000000000

      Tabs and buffers

      Tabs allow you to keep many web pages open at the same time and to quickly switch between them. Each tab contains exactly one buffer. If your version of &dactyl.host; supports tab groups, only buffers in the active group will be attached to visible tabs. Although not all buffers are always attached to visible tabs, they are all always accessible via the buffer-centric commands and key bindings. Tab-centric commands and key bindings, however, only operate on the set of visible tabs.

      Listing tabs

      B :tabs :ls :files :buffers :buffers filter B

      Show a list of buffers matching filter. Buffers are listed according to their tab groups, whether they are visible or not.

      A buffer may be marked with one of the following indicators:

      %
      The current buffer
      #
      The alternate buffer for :buffer # and
      :keepa :keepalt :keepalt cmd

      Execute a command without changing the current alternate buffer.

      Opening tabs

      ]]> count]]>

      Execute the next count mappings in a new tab.

             :bg :background :background

      Execute a command opening any new tabs in the background.

             :tab :tab cmd

      Execute cmd, but open any new pages in a new tab rather than the currently focused tab.

      :window :wind :window cmd

      Execute cmd, but open any new pages in a new window rather than the currently focused tab.

      See opening for other ways to open new tabs.

      Changing tabs

      gb countgb

      Repeat last :buffer command. This is useful to quickly jump between buffers which have a similar URL or title.

      gB countgB

      Repeat last :buffer command in the reverse direction.

      gt countgt

      Go to the next tab. Cycles to the first tab when the last one is selected. If count is specified, go to the countth tab.

      ]]> count<C-n>

      Go to the next tab. Cycles to the first tab when the last one is selected. If count is specified, go to the countth next tab.

      gT]]> countgT

      Go to the previous tab. Cycles to the last tab when the first one is selected. If count is specified, go to the countth previous tab.

      :tabn :tabnext :counttabnext count :tn :tnext :counttnext count :bn :bnext :countbnext count

      Switch to the next or countth tab. Cycles to the first tab when the last one is selected and count is not specified.

      :bN :bNext :bp :bprevious :countbprevious count :countbNext count :tN :tNext :tabN :tabNext :counttabNext count :tp :tprevious :tabp :tabprevious :counttabprevious count :counttprevious count

      Switch to the previous tab or go count tabs back. Wraps around from the first tab to the last tab.

      ]]> count<C-^>

      Select the previously selected tab. This provides a quick method of toggling between two tabs. If count is specified, go to the countth tab.

      b :b :buffer :countbuffer! url|index :countbuffer! match countb

      Go to the specified buffer from the buffer list. Argument can be either the buffer index or the full URL opened in an existing buffer. If count is given, go to the countth buffer.

      If argument is neither a full URL nor an index but uniquely identifies a buffer, by a partial match with the URL or title, it is selected. With ! the next, or countth, buffer matching the argument is selected, even if it cannot be identified uniquely. Use b as a shortcut to open this prompt.

      If argument is #, the alternate buffer will be selected (see ).

      If no argument is given, the current buffer remains current.

             g^ g0 g0 g^ :bf :bfirst :br :brewind :brewind :bfirst :tabfir :tabfirst :tabr :tabrewind :tabrewind :tabfirst

      Switch to the first tab.

             g$ :bl :blast :tabl :tablast :tablast :blast g$

      Switch to the last tab.

             :tabde :tabdetach :tabdetach

      Detach the current tab, and open it in its own window. As each window must contain at least one buffer, it is not possible to detach the last buffer in a window.

      :taba :tabattach :tabattach window-index buffer-index

      Attach the current tab to another window. window-index is an index into the list of open windows and buffer-index is the index at which to insert the tab in the other window's buffer list. If this is the last buffer in a window, the window will be closed.

      The following options are available:

      -group
      Attach to a tab group in the current window rather than to a separate window. (short name -g).

      Reordering tabs

      :tabm :tabmove :tabmove N :tabmove match :tabmove! +N|-N

      Move the current tab to the position of tab N. When N is $, the current tab is made the last one. N can also be prefixed with + or - to indicate a relative movement. If ! is specified the movement wraps around the start or end of the tab list.

      The tab index may also be selected by a general match string like :buffer.

      Closing tabs

      d :tabc :tabclose :counttabclose! arg countd

      Delete current buffer. If count is specified then count tabs are removed. Afterwards, the tab to the right of the deleted tabs is selected.

      When used with arg, remove all visible tabs which match the site-filter arg. With !, remove all tabs for which the currently opened page's URL or title matches the regular expression arg.

      :bd :bdelete :countbdelete! arg

      Like :tabclose but include hidden tabs.

      D countD

      Like d but selects the tab to the left of the deleted tabs after deletion.

             :tabo :tabonly :tabonly

      Close all buffers other than the currently visible tab.

             u :u :undo :countundo url countu

      Restore a closed tab. If a count is given, restore the countth closed tab. With url, restores most recently closed tab with a matching URL.

      :undoa :undoall :undoall

      Restore all closed tabs in the closed tabs list.

      Looping over tabs

      :tabd :tabdo :bufd :bufdo :tabdo cmd

      Execute cmd once in each buffer. Each buffer is focused, in turn, and cmd is executed therein. The last buffer remains focused after execution.

      cmd should not alter the tab list state by adding, removing or reordering tabs.

      Application Tabs

      :pin :pintab :countpintab! arg

      Pin tab as an application tab. If ! is given, the tab's pinned state is toggled. Arguments and count are the same as for :bdelete and :buffer.

      :unpin :unpintab :countunpintab arg

      Unpin tab as an application tab. Arguments and count are the same as for :pintab.

      dactyl-1.2~r20151231/common/locale/en-US/various.xml000066400000000000000000000203561264147376100217440ustar00rootroot00000000000000

      Other help

      Various commands

      :comp :completions :completions ex-command

      List the completion results for a given command substring.

      :completions :set! browser.tabs.       :contexts :contexts ex-command

      Lists the completion contexts used during the completion of its arguments. These context names may be used to tune the function of the completion system via options like autocomplete and wildcase. Note that completion must be triggered in order for this command to be effective, so if auto-completion is not active, you'll need to press the key at least once. You should also be aware that this command is only useful from the command line.

      :fk :feedkeys feedkeys! keys

      Fake key events. If ! is given, key remappings are ignored, similarly to the :map command's -builtin option.

      -mode
      The mode in which to feed the keys (short name -m)
             :norm :normal :normal! keys

      Execute key mappings for keys as if they were typed in Normal mode. If ! is provided, only builtin key mappings are executed. This makes it possible to fake Normal mode key presses from scripts, key mappings, autocommands, and the command line.

      :mkv :mkvimruntime :mkvimruntime! dir

      Creates and installs Vim ftdetect, ftplugin and syntax files. If dir is not given, the local Vim runtime path is guessed. An existing file will never be overwritten unless ! is given.

      See :help 'runtimepath' and :help after-directory in Vim for an explanation of how best to manage personal changes to these files.

      :redr :redraw]]> :redraw

      Redraws the screen. Useful for updating the screen during the execution of a script or function.

             :run :! :!cmd :!cmd

      Run an external command. Runs cmd through system() and displays its output. Any ‘!’ in cmd is replaced with the previous external command, so long as it is not preceded by a backslash and banghist is enabled.

      :!! :!!

      Repeat last :!cmd.

             :sil :silent :silent command

      Execute a command silently. Normal messages and error messages generated by the command invocation will not be displayed and will not be added to the message history.

      :verb :verbose :countverbose command

      Execute a command with verbose set to count. If count is not specified then 1 is used.

      :ve :version :version!

      Print &dactyl.appName; and &dactyl.host; version information. When ! is provided, show the &dactyl.host; version page.

      :yank :y :y[ank] :cmd :y[ank] js

      Yanks the output of the given Ex command cmd or JavaScript js to the clipboard.

      Online help

      :help :h help]]> :help subject

      Open a help page for subject. If subject is omitted, open the default page as specified in helpfile. If you're not sure of the exact topic you need help with, try completion or :help overview.

      :helpall :helpa help-all]]> :helpall subject

      Open all help pages consolidated into a single page and scroll to subject if given.

      See :help.

             :lc :listcommands :listcommands filter :lc filter

      List all Ex commands matching filter along with their short descriptions. The output contains links to the source code definitions.

      :lk :listkeys :listkeys -mode mode filter :lk -mode mode filter

      List the key mappings defined for mode (Normal by default) matching filter along with their short descriptions. The output contains links to the source code definitions.

      :lo :listoptions :listoptions filter :lo filter

      List all options matching filter along with their short descriptions. The output contains links to the source code definitions.

      42

      What is the meaning of life, the universe and everything? Douglas Adams, the only person who knew what this question really was about is now dead, unfortunately. So now you might wonder what the meaning of death is…

      Uncategorized help

      ]]> <Esc>

      Exits Command-line, Insert, or Hints mode and returns to Normal mode. Focuses the content web page.

      ]]> i caret-mode visual-mode i

      Start Caret mode. This mode resembles Vim's Normal mode where the text cursor is visible on the web page. The v key enters Visual mode, where text is selected as the cursor moves.

      You can see all mappings effective in Caret or Visual mode using the :listkeys command.

      dactyl-1.2~r20151231/common/make_jar.sh000066400000000000000000000053041264147376100174450ustar00rootroot00000000000000#!/bin/sh set -e fromrepo= if [ "$1" = -r ]; then shift; fromrepo=1; fi top=$(pwd) jar=$1 bases=$2 dirs=$3 text=$4 bin=$5 shift 5; files="$@" HG=${HG:-hg} stage="$top/${jar%.*}" mkdir -p "$stage" sed=$(which sed) if [ "xoo" = x$(echo foo | sed -E 's/f(o)/\1/' 2>/dev/null) ] then sed() { $sed -E "$@"; } else sed() { $sed -r "$@"; } fi if test -n "$fromrepo" && $HG root >/dev/null 2>&1 then root="$($HG root)" which cygpath >/dev/null 2>&1 && root=$(cygpath $root) mf="$($HG --config ui.debug=false --config ui.verbose=false manifest)" find=$(which find) find() { echo "$mf" | sed -n "s!$(pwd | sed "s!$root/?!!")/?!!p" | grep "^$1" exit 1 } fi mungeliterals_() { cat <<'!' local $/; $_ = <>; s{(?/dev/null 2>&1 then perl -e "$(mungeliterals_)" else cat fi } getfiles() { filter="\.($(echo $1 | tr ' ' '|'))$"; shift find "$@" -not -path '*\.hg*' 2>/dev/null | grep -E "$filter" || true } copytext() { mungeliterals <"$1" | sed -e "s,@VERSION@,$VERSION,g" \ -e "s,@DATE@,$BUILD_DATE,g" \ >"$2" cmp -s -- "$1" "$2" || ( echo "modified: $1"; diff -u -- "$1" "$2" | grep '^[-+][^-+]' ) } [ -f "$jar" ] && rm -f "$jar" case "$jar" in /*) ;; *) [ -d "$jar" ] && rm -rf "$jar" jar="$top/$jar";; esac for base in $bases do ( set -e cd $base [ ${jar##*.} != xpi ] && stage="$stage/${base##*/}" for dir in $dirs do for f in $(getfiles "$bin" "$dir") do mkdir -p "$stage/${f%/*}" cp -- "$f" "$stage/$f" done for f in $(getfiles "$text" "$dir") do mkdir -p "$stage/${f%/*}" copytext "$f" "$stage/$f" done done for f in $files do if [ -f "$f" ] then case "$f" in *.js|*.jsm|*.css|*.dtd|*.xml|*.xul|*.html|*.xhtml|*.xsl|*.properties|*.json) copytext "$f" "$stage/$f";; *) cp -- "$f" "$stage/$f";; esac fi done true ) || exit 1 done ( set -e; cd "$stage"; case "$jar" in (*/) if [ "$stage" != "$jar" ]; then mv -- * "$jar"; fi;; (*) zip -9r "$jar" -- *;; esac ) || exit 1 [ "$stage" != "$jar" ] && rm -rf "$stage" true # vim:se ft=sh sts=4 sw=4 et: dactyl-1.2~r20151231/common/modules/000077500000000000000000000000001264147376100170065ustar00rootroot00000000000000dactyl-1.2~r20151231/common/modules/addons.jsm000066400000000000000000000467641264147376100210120ustar00rootroot00000000000000// Copyright (c) 2009-2014 Kris Maglione // Copyright (c) 2009-2010 by Doug Kearns // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; try { defineModule("addons", { exports: ["AddonManager", "Addons", "Addon", "addons"], require: ["services", "util"] }); this.lazyRequire("completion", ["completion"]); lazyRequire("template", ["template"]); var callResult = function callResult(method, ...args) { return function (result) { result[method].apply(result, args); }; }; var listener = function listener(action, event) { return function addonListener(install) { this.dactyl[install.error ? "echoerr" : "echomsg"]( _("addon.error", action, event, (install.name || install.sourceURI.spec) + (install.error ? ": " + addons.errors[install.error] : ""))); }; }; var AddonListener = Class("AddonListener", { init: function init(modules) { this.dactyl = modules.dactyl; }, onNewInstall: function (install) {}, onExternalInstall: function (addon, existingAddon, needsRestart) {}, onDownloadStarted: listener("download", "started"), onDownloadEnded: listener("download", "complete"), onDownloadCancelled: listener("download", "canceled"), onDownloadFailed: listener("download", "failed"), onDownloadProgress: function (install) {}, onInstallStarted: function (install) {}, onInstallEnded: listener("installation", "complete"), onInstallCancelled: listener("installation", "canceled"), onInstallFailed: listener("installation", "failed") }); var updateAddons = Class("UpgradeListener", AddonListener, { init: function init(addons, modules) { init.supercall(this, modules); util.assert(!addons.length || addons[0].findUpdates, _("error.unavailable", config.host, services.runtime.version)); this.remaining = addons; this.upgrade = []; this.dactyl.echomsg(_("addon.check", addons.map(a => a.name).join(", "))); for (let addon of addons) addon.findUpdates(this, AddonManager.UPDATE_WHEN_USER_REQUESTED, null, null); }, onUpdateAvailable: function (addon, install) { this.upgrade.push(addon); install.addListener(this); install.install(); }, onUpdateFinished: function (addon, error) { this.remaining = this.remaining.filter(a => (a.type != addon.type || a.id != addon.id)); if (!this.remaining.length) this.dactyl.echomsg( this.upgrade.length ? _("addon.installingUpdates", this.upgrade.map(i => i.name).join(", ")) : _("addon.noUpdates")); } }); var actions = { delete: { name: ["extde[lete]", "extrm"], description: "Uninstall an extension", action: callResult("uninstall"), perm: "uninstall" }, enable: { name: "exte[nable]", description: "Enable an extension", action: function (addon) { addon.userDisabled = false; }, filter: function (addon) { return addon.userDisabled; }, perm: "enable" }, disable: { name: "extd[isable]", description: "Disable an extension", action: function (addon) { addon.userDisabled = true; }, filter: function (addon) { return !addon.userDisabled; }, perm: "disable" }, options: { name: ["exto[ptions]", "extp[references]"], description: "Open an extension's preference dialog", bang: true, action: function (addon, bang) { if (bang) this.window.openDialog(addon.optionsURL, "_blank", "chrome"); else this.dactyl.open(addon.optionsURL, { from: "extoptions" }); }, filter: function (addon) { return addon.isActive && addon.optionsURL; } }, rehash: { name: "extr[ehash]", description: "Reload an extension", action: function (addon) { util.flushCache(); util.timeout(function () { addon.userDisabled = true; addon.userDisabled = false; }); }, get filter() { return addon => ( !addon.userDisabled && !(addon.operationsRequiringRestart & (AddonManager.OP_NEEDS_RESTART_ENABLE | AddonManager.OP_NEEDS_RESTART_DISABLE))); }, perm: "disable" }, toggle: { name: "extt[oggle]", description: "Toggle an extension's enabled status", action: function (addon) { addon.userDisabled = !addon.userDisabled; } }, update: { name: "extu[pdate]", description: "Update an extension", actions: updateAddons, perm: "upgrade" } }; var Addon = Class("Addon", { init: function init(addon, list) { this.addon = addon; this.instance = this; this.list = list; this.nodes = { commandTarget: this }; DOM.fromJSON( ["tr", { highlight: "Addon", key: "row" }, ["td", { highlight: "AddonName", key: "name" }], ["td", { highlight: "AddonVersion", key: "version" }], ["td", { highlight: "AddonButtons Buttons" }, ["a", { highlight: "Button", href: "javascript:0", key: "enable" }, _("addon.action.On")], ["a", { highlight: "Button", href: "javascript:0", key: "disable" }, _("addon.action.Off")], ["a", { highlight: "Button", href: "javascript:0", key: "delete" }, _("addon.action.Delete")], ["a", { highlight: "Button", href: "javascript:0", key: "update" }, _("addon.action.Update")], ["a", { highlight: "Button", href: "javascript:0", key: "options" }, _("addon.action.Options")]], ["td", { highlight: "AddonStatus", key: "status" }], ["td", { highlight: "AddonDescription", key: "description" }]], this.list.document, this.nodes); this.update(); }, commandAllowed: function commandAllowed(cmd) { util.assert(hasOwnProp(actions, cmd), _("addon.unknownCommand")); let action = actions[cmd]; if ("perm" in action && !(this.permissions & AddonManager["PERM_CAN_" + action.perm.toUpperCase()])) return false; if ("filter" in action && !action.filter(this)) return false; return true; }, command: function command(cmd) { util.assert(this.commandAllowed(cmd), _("addon.commandNotAllowed")); let action = actions[cmd]; if (action.action) action.action.call(this.list.modules, this, true); else action.actions([this], this.list.modules); }, compare: function compare(other) { return String.localeCompare(this.name, other.name); }, get statusInfo() { let info = this.isActive ? ["span", { highlight: "Enabled" }, "enabled"] : ["span", { highlight: "Disabled" }, "disabled"]; let pending; if (this.pendingOperations & AddonManager.PENDING_UNINSTALL) pending = ["Disabled", "uninstalled"]; else if (this.pendingOperations & AddonManager.PENDING_DISABLE) pending = ["Disabled", "disabled"]; else if (this.pendingOperations & AddonManager.PENDING_INSTALL) pending = ["Enabled", "installed"]; else if (this.pendingOperations & AddonManager.PENDING_ENABLE) pending = ["Enabled", "enabled"]; else if (this.pendingOperations & AddonManager.PENDING_UPGRADE) pending = ["Enabled", "upgraded"]; if (pending) return [info, " (", ["span", { highlight: pending[0] }, pending[1]], " on ", ["a", { href: "#", "dactyl:command": "dactyl.restart" }, "restart"], ")"]; return info; }, update: function callee() { let update = (key, xml) => { let node = this.nodes[key]; while (node.firstChild) node.removeChild(node.firstChild); DOM(node).append(isArray(xml) ? xml : DOM.DOMString(xml)); }; update("name", template.icon({ icon: this.iconURL }, this.name)); this.nodes.version.textContent = this.version; update("status", this.statusInfo); this.nodes.description.textContent = this.description; DOM(this.nodes.row).attr("active", this.isActive || null); for (let node of values(this.nodes)) if (node.update && node.update !== callee) node.update(); let event = this.list.document.createEvent("Events"); event.initEvent("dactyl-commandupdate", true, false); this.list.document.dispatchEvent(event); } }); ["cancelUninstall", "findUpdates", "getResourceURI", "hasResource", "isCompatibleWith", "uninstall"].forEach(function (prop) { Addon.prototype[prop] = function proxy() { return apply(this.addon, prop, arguments); }; }); ["aboutURL", "appDisabled", "applyBackgroundUpdates", "blocklistState", "contributors", "creator", "description", "developers", "homepageURL", "iconURL", "id", "install", "installDate", "isActive", "isCompatible", "isPlatformCompatible", "name", "operationsRequiringRestart", "optionsURL", "pendingOperations", "pendingUpgrade", "permissions", "providesUpdatesSecurely", "releaseNotesURI", "scope", "screenshots", "size", "sourceURI", "translators", "type", "updateDate", "userDisabled", "version"].forEach(function (prop) { Object.defineProperty(Addon.prototype, prop, { get: function get_proxy() { return this.addon[prop]; }, set: function set_proxy(val) { this.addon[prop] = val; } }); }); var AddonList = Class("AddonList", { init: function init(modules, types, filter) { this.modules = modules; this.filter = filter && filter.toLowerCase(); this.nodes = {}; this.addons = {}; this.ready = false; AddonManager.getAddonsByTypes(types, addons => { this._addons = addons; if (this.document) this._init(); }); AddonManager.addAddonListener(this); }, cleanup: function cleanup() { AddonManager.removeAddonListener(this); }, _init: function _init() { this._addons.forEach(this.bound.addAddon); this.ready = true; this.update(); }, message: Class.Memoize(function () { DOM.fromJSON(["table", { highlight: "Addons", key: "list" }, ["tr", { highlight: "AddonHead" }, ["td", {}, _("title.Name")], ["td", {}, _("title.Version")], ["td"], ["td", {}, _("title.Status")], ["td", {}, _("title.Description")]]], this.document, this.nodes); if (this._addons) this._init(); return this.nodes.list; }), addAddon: function addAddon(addon) { if (addon.id in this.addons) this.update(addon); else { if (this.filter && addon.name.toLowerCase().indexOf(this.filter) === -1) return; addon = Addon(addon, this); this.addons[addon.id] = addon; let index = values(this.addons).sort((a, b) => a.compare(b)) .indexOf(addon); this.nodes.list.insertBefore(addon.nodes.row, this.nodes.list.childNodes[index + 1]); this.update(); } }, removeAddon: function removeAddon(addon) { if (addon.id in this.addons) { this.nodes.list.removeChild(this.addons[addon.id].nodes.row); delete this.addons[addon.id]; this.update(); } }, leave: function leave(stack) { if (stack.pop) this.cleanup(); }, update: function update(addon) { if (addon && addon.id in this.addons) this.addons[addon.id].update(); if (this.ready) this.modules.mow.resize(false); }, onDisabled: function (addon) { this.update(addon); }, onDisabling: function (addon) { this.update(addon); }, onEnabled: function (addon) { this.update(addon); }, onEnabling: function (addon) { this.update(addon); }, onInstalled: function (addon) { this.addAddon(addon); }, onInstalling: function (addon) { this.update(addon); }, onUninstalled: function (addon) { this.removeAddon(addon); }, onUninstalling: function (addon) { this.update(addon); }, onOperationCancelled: function (addon) { this.update(addon); }, onPropertyChanged: function onPropertyChanged(addon, properties) {} }); var Addons = Module("addons", { errors: Class.Memoize(() => Ary(["ERROR_NETWORK_FAILURE", "ERROR_INCORRECT_HASH", "ERROR_CORRUPT_FILE", "ERROR_FILE_ACCESS"]) .map(e => [AddonManager[e], _("AddonManager." + e)]) .toObject()) }, { }, { commands: function initCommands(dactyl, modules, window) { const { CommandOption, commands, completion, io } = modules; commands.add(["addo[ns]", "ao"], "List installed extensions", function (args) { let addons = AddonList(modules, args["-types"], args[0]); modules.commandline.echo(addons); if (modules.commandline.savingOutput) util.waitFor(() => addons.ready); }, { argCount: "?", options: [ { names: ["-types", "-type", "-t"], description: "The add-on types to list", default: ["extension"], completer: function (context) { completion.addonType(context); }, type: CommandOption.LIST } ] }); let addonListener = AddonListener(modules); commands.add(["exta[dd]"], "Install an extension", function (args) { let url = args[0]; let file = io.File(url); function install(addonInstall) { addonInstall.addListener(addonListener); addonInstall.install(); } if (!file.exists()) AddonManager.getInstallForURL(url, install, "application/x-xpinstall"); else if (file.isReadable() && file.isFile()) AddonManager.getInstallForFile(file.file, install, "application/x-xpinstall"); else if (file.isDirectory()) dactyl.echoerr(_("addon.cantInstallDir", JSON.stringify(file.path))); else dactyl.echoerr(_("io.notReadable", file.path)); }, { argCount: "1", completer: function (context) { context.filters.push(({ isdir, text }) => isdir || /\.xpi$/.test(text)); completion.file(context); }, literal: 0 }); // TODO: handle extension dependencies values(actions).forEach(function (command) { let perm = command.perm && AddonManager["PERM_CAN_" + command.perm.toUpperCase()]; function ok(addon) { return (!perm || addon.permissions & perm) && (!command.filter || command.filter(addon)); } commands.add(Array.concat(command.name), command.description, function (args) { let name = args[0]; if (args.bang && !command.bang) dactyl.assert(!name, _("error.trailingCharacters")); else dactyl.assert(name, _("error.argumentRequired")); AddonManager.getAddonsByTypes(args["-types"], dactyl.wrapCallback(function (list) { if (!args.bang || command.bang) { list = list.filter(addon => (addon.id == name || addon.name == name)); dactyl.assert(list.length, _("error.invalidArgument", name)); dactyl.assert(list.some(ok), _("error.invalidOperation")); list = list.filter(ok); } dactyl.assert(list.every(ok)); if (command.actions) command.actions(list, this.modules); else list.forEach(addon => { command.action.call(this.modules, addon, args.bang); }); })); }, { argCount: "?", // FIXME: should be "1" bang: true, completer: function (context, args) { completion.addon(context, args["-types"]); context.filters.push(({ item }) => ok(item)); }, literal: 0, options: [ { names: ["-types", "-type", "-t"], description: "The add-on types to operate on", default: ["extension"], completer: function (context) { completion.addonType(context); }, type: CommandOption.LIST } ] }); }); }, completion: function initCompletion(dactyl, modules, window) { completion.addonType = function addonType(context) { let base = ["extension", "theme"]; function update(types) { context.completions = types.map(t => [t, util.capitalize(t)]); } context.generate = function generate() { update(base); if (AddonManager.getAllAddons) { context.incomplete = true; AddonManager.getAllAddons(function (addons) { context.incomplete = false; update(Ary.uniq(base.concat(addons.map(a => a.type)), true)); }); } }; }; completion.addon = function addon(context, types) { context.title = ["Add-on"]; context.anchored = false; context.keys = { text: addon => [addon.name, addon.id], description: "description", icon: "iconURL" }; context.generate = () => { context.incomplete = true; AddonManager.getAddonsByTypes(types || ["extension"], addons => { context.incomplete = false; context.completions = addons; }); }; }; } }); Components.utils.import("resource://gre/modules/AddonManager.jsm", this); endModule(); } catch(e){ if (isString(e)) e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); } // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/base.jsm000066400000000000000000001720341264147376100204420ustar00rootroot00000000000000// Copyright (c) 2009-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; var { classes: Cc, interfaces: Ci, results: Cr, utils: Cu } = Components; var Cs = new Proxy(Components.stack, { get: function Cs_get(target, prop) { return Components.stack.caller[prop]; } }); function module(url) { let obj = {}; Cu.import(url, obj); return obj; } var { XPCOMUtils } = module("resource://gre/modules/XPCOMUtils.jsm"); var { OS } = module("resource://gre/modules/osfile.jsm"); try { var { ctypes } = module("resource://gre/modules/ctypes.jsm"); } catch (e) {} let objproto = Object.prototype; var { __lookupGetter__, __lookupSetter__, __defineGetter__, __defineSetter__, hasOwnProperty, propertyIsEnumerable } = objproto; var hasOwnProp = Function.call.bind(hasOwnProperty); hasOwnProperty = hasOwnProp; propertyIsEnumerable = Function.call.bind(propertyIsEnumerable); function require(module_, target) { if (/^[A-Za-z0-9]+:/.test(module_)) return module(module_); return JSMLoader.load(module_, target); } function lazyRequire(module, names, target) { for (let name of names) memoize(target || this, name, name => require(module)[name]); } var jsmodules = { lazyRequire: lazyRequire }; jsmodules.jsmodules = jsmodules; function toString() { return "[module-global " + this.NAME + "]"; } function objToString(obj) { try { return objproto.toString.call(obj); } catch (e) { var type_ = typeof obj; if (e == null) type_ = String(e); return "[non-object " + type_ + "]"; } } var use = {}; var loaded = {}; var currentModule; var global = this; function defineModule(name, params, module) { if (!module) module = this; module.NAME = name; module.EXPORTED_SYMBOLS = params.exports || []; if (!~module.EXPORTED_SYMBOLS.indexOf("File")) delete module.File; defineModule.loadLog.push("[Begin " + name + "]"); defineModule.prefix += " "; for (let mod of (params.require || [])) require(mod, module); module._lastModule = currentModule; currentModule = module; module.startTime = Date.now(); } defineModule.loadLog = []; Object.defineProperty(defineModule.loadLog, "push", { value: function (val) { val = defineModule.prefix + val; if (true) defineModule.dump(val + "\n"); this[this.length] = Date.now() + " " + val; } }); defineModule.prefix = ""; defineModule.dump = function dump_(...args) { try { let msg = args.map(function (msg) { if (loaded.util && typeof msg == "object") msg = util.objectToString(msg); return msg; }).join(", "); dump(String.replace(msg, /\n?$/, "\n") .replace(/^./gm, JSMLoader.name + ": $&")); } catch (e) { let msg = "Error dumping object: " + e + "\n" + (e && e.stack || Error.stack); dump(String.replace(msg, /\n?$/, "\n") .replace(/^./gm, JSMLoader.name + ": $&")); } }; defineModule.modules = []; defineModule.time = function time(major, minor, func, self, ...args) { let time = Date.now(); if (typeof func !== "function") func = self[func]; try { var res = func.apply(self, args); } catch (e) { loaded.util && util.reportError(e); } JSMLoader.times.add(major, minor, Date.now() - time); return res; }; function endModule() { defineModule.prefix = defineModule.prefix.slice(0, -2); defineModule.loadLog.push("(End " + currentModule.NAME + ")"); loaded[currentModule.NAME] = 1; require(currentModule.NAME, jsmodules); currentModule = currentModule._lastModule; } function require_(obj, name, from, targetName) { try { if (arguments.length === 1) [obj, name] = [{}, obj]; let caller = Components.stack.caller; if (!loaded[name]) defineModule.loadLog.push((from || "require") + ": loading " + name + " into " + (targetName || obj.NAME || caller.filename + ":" + caller.lineNumber)); JSMLoader.load(name + ".jsm", obj); if (!loaded[name] && obj != jsmodules) JSMLoader.load(name + ".jsm", jsmodules); return obj; } catch (e) { defineModule.dump("loading " + JSON.stringify(name + ".jsm") + "\n"); if (loaded.util) util.reportError(e); else defineModule.dump(" " + (e.filename || e.fileName) + ":" + e.lineNumber + ": " + e + "\n"); } } defineModule("base", { // sed -n 's/^(const|var|function) ([a-zA-Z0-9_]+).*/ "\2",/p' base.jsm | sort | fmt exports: [ "Ary", "Cc", "Ci", "Class", "Cr", "Cs", "Cu", "ErrorBase", "Finished", "JSMLoader", "Module", "OS", "RealSet", "Set", "Struct", "StructBase", "TextEncoder", "TextDecoder", "Timer", "UTF8", "XPCOM", "XPCOMShim", "XPCOMUtils", "apply", "array", "bind", "call", "callable", "ctypes", "curry", "defineModule", "deprecated", "endModule", "hasOwnProperty", "hasOwnProp", "identity", "isArray", "isGenerator", "isObject", "isString", "isSubclass", "isinstance", "iter", "iterOwnProperties", "keys", "literal", "loadPolyfill", "memoize", "module", "octal", "properties", "require", "set", "update", "values", ] }); function loadPolyfill(obj) { JSMLoader.loadSubScript("resource://dactyl/polyfill.jsm", obj); } loadPolyfill(this); this.lazyRequire("cache", ["cache"]); this.lazyRequire("config", ["config"]); this.lazyRequire("messages", ["_", "Messages"]); this.lazyRequire("promises", ["Task", "promises"]); this.lazyRequire("services", ["services"]); this.lazyRequire("storage", ["File"]); this.lazyRequire("util", ["FailedAssertion", "util"]); let literal_ = function literal(comment) { if (comment) return /^function.*?\/\*([^]*)\*\/(?:\/\* use strict \*\/)\s*\S$/.exec(comment)[1]; let { caller } = Components.stack; while (caller && caller.language != 2) caller = caller.caller; // Immediate caller is the `deprecate` helper. caller = caller.caller; let file = caller.filename.replace(/.* -> /, ""); let key = "literal:" + file + ":" + caller.lineNumber; return cache.get(key, function() { let source = literal.files[file] || File.readURL(file); literal.files[file] = source; let match = RegExp("(?:.*\\n){" + (caller.lineNumber - 1) + "}" + ".*literal\\(/\\*([^]*?)\\*/\\)").exec(source); return match[1]; }); }; literal_.files = {}; literal_.locations = {}; // This needs to happen after `files` and `locations` have been defined // as properties of the real `literal` function. var literal = deprecated("template strings", literal_); literal.files = literal_.files; literal.locations = literal_.locations; function apply(obj, meth, args) { // The function's own apply method breaks in strange ways // when using CPOWs. if (callable(meth)) return Function.apply.call(meth, obj, args); return Function.apply.call(obj[meth], obj, args); } /** * Iterates over the names of all of the top-level properties of an * object or, if prototypes is given, all of the properties in the * prototype chain below the top. * * @param {object} obj The object to inspect. * @param {boolean} properties Whether to inspect the prototype chain * @default false * @returns {Generator} */ function prototype(obj) { return obj.__proto__ || Object.getPrototypeOf(obj) || XPCNativeWrapper.unwrap(obj).__proto__ || Object.getPrototypeOf(XPCNativeWrapper.unwrap(obj)); } function* properties(obj, prototypes) { let orig = obj; let seen = new RealSet(["dactylPropertyNames"]); try { if ("dactylPropertyNames" in obj && !prototypes) for (let key of obj.dactylPropertyNames) if (key in obj && !seen.add(key)) yield key; } catch (e) {} function props(obj) { // Grr. try { return Object.getOwnPropertyNames(obj); } catch (e) { if (e.result === Cr.NS_ERROR_FAILURE) { // This is being thrown for PDF.js content windows, // currently. let filter = function filter(prop) { try { return prop in obj; } catch (e) { util.reportError("Filtering properties for " + JSON.stringify(obj) + ", " + "error checking presence of " + JSON.stringify(prop) + ": " + e); } return false; }; let keys_ = function* (obj) { for (let key in object) yield key; }; return [...new RealSet( [...keys_(obj), ...Object.getOwnPropertyNames(Cu.waiveXrays(obj)) .filter(filter)]) ]; } else if (!e.stack) { throw Error(e); } throw e; } } for (; obj; obj = prototypes && prototype(obj)) { for (let key of props(obj)) if (!prototypes || !seen.add(key) && obj != orig) yield key; } } function* iterOwnProperties(obj) { for (let prop of properties(obj)) yield [prop, Object.getOwnPropertyDescriptor(obj, prop)]; } function deprecated(alternative, fn) { if (isObject(fn)) return Class.Property(iter(fn).map(([k, v]) => [k, callable(v) ? deprecated(alternative, v) : v]) .toObject()); let name, func = callable(fn) ? fn : function () { return apply(this, fn, arguments); }; function deprecatedMethod() { let obj = !this ? "" : this.className ? this.className + "#" : this.constructor.className ? this.constructor.className + "#" : ""; deprecated.warn(func, obj + (fn.realName || fn.name || name || "").replace(/__/g, "."), alternative); return func.apply(this, arguments); } if (func.name) deprecatedMethod.realName = func.name; return callable(fn) ? deprecatedMethod : Class.Property({ get: function () { return deprecatedMethod; }, init: function (prop) { name = prop; } }); } deprecated.warn = function warn(func, name, alternative, frame) { if (!func.seenCaller) func.seenCaller = new RealSet([ "resource://dactyl/javascript.jsm", "resource://dactyl/util.jsm" ]); if (!(loaded.util && util && loaded.config && config.protocolLoaded)) { dump("DACTYL: deprecated method called too early [" + [name, alternative] + "]:\n" + Error().stack + "\n\n"); return; } frame = frame || Components.stack.caller.caller; let filename = util.fixURI(frame.filename || "unknown"); if (!func.seenCaller.add(filename)) util.dactyl(func).warn([util.urlPath(filename), frame.lineNumber, " "].join(":") + _("warn.deprecated", name, alternative)); }; /** * Iterates over all of the top-level, iterable property names of an * object. * * @param {object} obj The object to inspect. * @returns {Iter} */ function keys(obj) { if (isinstance(obj, ["Map"])) return iter(obj.keys()); return iter(function* () { for (let k in obj) if (hasOwnProp(obj, k)) yield k; }()); } /** * Iterates over all of the top-level, iterable property values of an * object. * * @param {object} obj The object to inspect. * @returns {Iter} */ function values(obj) { if (isinstance(obj, ["Map"])) return iter(obj.values()); if (isinstance(obj, ["Generator", "Iterator", Iter])) return iter(obj); if (Symbol.iterator in obj) return iter(obj[Symbol.iterator]()); return iter(function* () { for (let k in obj) if (hasOwnProp(obj, k)) yield obj[k]; }()); } var RealSet = Set; let Set_add = RealSet.prototype.add; Object.defineProperty(RealSet.prototype, "add", { configurable: true, writable: true, value: function RealSet_add(val) { let res = this.has(val); Set_add.apply(this, arguments); return res; } }); Object.defineProperty(RealSet.prototype, "difference", { configurable: true, writable: true, value: function RealSet_difference(set) { return new RealSet(Array.from(this).filter(i => !set.has(i))); } }); Object.defineProperty(RealSet.prototype, "intersection", { configurable: true, writable: true, value: function RealSet_intersection(set) { return new RealSet(Array.from(this).filter(i => set.has(i))); } }); Object.defineProperty(RealSet.prototype, "union", { configurable: true, writable: true, value: function RealSet_union(set) { let res = new RealSet(this); for (let item of set) res.add(item); return res; } }); /** * Utility for managing sets of strings. Given an array, returns an * object with one key for each value thereof. * * @param {[string]} ary @optional * @returns {object} */ this.Set = deprecated("RealSet", function Set(ary) { let obj = {}; if (ary) for (let val of ary) obj[val] = true; return obj; }); /** * Adds an element to a set and returns true if the element was * previously contained. * * @param {object} set The set. * @param {string} key The key to add. * @returns boolean */ Set.add = deprecated("RealSet#add", curry(function Set__add(set, key) { if (isinstance(set, ["Set"])) { let res = set.has(key); set.add(key); return res; } let res = this.has(set, key); set[key] = true; return res; })); /** * Returns true if the given set contains the given key. * * @param {object} set The set. * @param {string} key The key to check. * @returns {boolean} */ Set.has = deprecated("hasOwnProperty or Set#has", curry(function Set__has(set, key) { if (isinstance(set, ["Set"])) return set.has(key); return hasOwnProp(set, key) && propertyIsEnumerable(set, key); })); /** * Returns a new set containing the members of the first argument which * do not exist in any of the other given arguments. * * @param {object} set The set. * @returns {object} */ Set.subtract = deprecated("RealSet#difference", function set_subtract(set) { set = update({}, set); for (let i = 1; i < arguments.length; i++) for (let k of keys(arguments[i])) delete set[k]; return set; }); /** * Removes an element from a set and returns true if the element was * previously contained. * * @param {object} set The set. * @param {string} key The key to remove. * @returns boolean */ Set.remove = deprecated("RealSet#delete", curry(function Set__remove(set, key) { if (isinstance(set, ["Set"])) return set.delete(key); let res = set.has(set, key); delete set[key]; return res; })); function set() { deprecated.warn(set, "set", "Set"); return Set.apply(this, arguments); } Object.keys(Set).forEach(function (meth) { set[meth] = function proxy() { deprecated.warn(proxy, "set." + meth, "Set." + meth); return apply(Set, meth, arguments); }; }); /** * Curries a function to the given number of arguments. Each * call of the resulting function returns a new function. When * a call does not contain enough arguments to satisfy the * required number, the resulting function is another curried * function with previous arguments accumulated. * * function foo(a, b, c) [a, b, c].join(" "); * curry(foo)(1, 2, 3) -> "1 2 3"; * curry(foo)(4)(5, 6) -> "4 5 6"; * curry(foo)(7)(8)(9) -> "7 8 9"; * * @param {function} fn The function to curry. * @param {integer} length The number of arguments expected. * @default fn.length * @optional * @param {object} self The 'this' value for the returned function. When * omitted, the value of 'this' from the first call to the function is * preserved. * @optional */ function curry(fn, length, self, acc) { if (length == null) length = fn.length; if (length == 0) return fn; // Close over function with 'this' function close(self, fn) { return (...args) => fn.apply(self, args); } if (acc == null) acc = []; function curried(...args) { // The curried result should preserve 'this' if (args.length == 0) return close(self || this, curried); args = acc.concat(args); if (args.length >= length) return fn.apply(self || this, args); return curry(fn, length, self || this, args); } curried.realName = fn.realName || fn.name; return curried; } var bind = function bind(meth, self, ...args) { let func = callable(meth) ? meth : self[meth]; return apply(func, "bind", [self].concat(args)); }; /** * Returns true if both arguments are functions and * (targ() instanceof src) would also return true. * * @param {function} targ * @param {function} src * @returns {boolean} */ function isSubclass(targ, src) { return src === targ || targ && typeof targ === "function" && targ.prototype instanceof src; } /** * Returns true if *object* is an instance of *interfaces*. If *interfaces* is * an array, returns true if *object* is an instance of any element of * *interfaces*. If *interfaces* is the object form of a primitive type, * returns true if *object* is a non-boxed version of the type, i.e., if * (typeof object == "string"), isinstance(object, String) is true. Finally, if * *interfaces* is a string, returns true if ({}.toString.call(object) == * "[object ]"). * * @param {object} object The object to check. * @param {constructor|[constructor|string]} interfaces The types to check *object* against. * @returns {boolean} */ var isinstance_types = { boolean: Boolean, string: String, function: Function, number: Number, symbol: Symbol }; function isinstance(object, interfaces) { if (object == null) return false; return Array.concat(interfaces).some(function isinstance_some(iface) { if (typeof iface === "string") { if (objToString(object) === "[object " + iface + "]") return true; } else if (typeof object === "object" && "isinstance" in object && object.isinstance !== isinstance) { if (object.isinstance(iface)) return true; } else { if (object instanceof iface) return true; var type = isinstance_types[typeof object]; if (type && isSubclass(iface, type)) return true; } return false; }); } /** * Returns true if obj is a non-null object. */ function isObject(obj) { return typeof obj === "object" && obj != null || obj instanceof Ci.nsISupports; } /** * Returns true if and only if its sole argument is an * instance of the builtin Array type. The array may come from * any window, frame, namespace, or execution context, which * is not the case when using (obj instanceof Array). */ var isArray = // This is bloody stupid. function isArray(val) { return Array.isArray(val) || val && val.constructor && val.constructor.name === "Array"; } /** * Returns true if and only if its sole argument is an * instance of the builtin Generator type. This includes * functions containing the 'yield' statement and generator * statements such as (x for (x in obj)). */ function isGenerator(val) { return objToString(val) == "[object Generator]"; } /** * Returns true if and only if its sole argument is a String, * as defined by the builtin type. May be constructed via * String(foo) or new String(foo) from any window, frame, * namespace, or execution context, which is not the case when * using (obj instanceof String) or (typeof obj == "string"). */ function isString(val) { return objToString(val) == "[object String]"; } /** * Returns true if and only if its sole argument may be called * as a function. This includes classes and function objects. * * Excludes callable DOM objects: https://bugzil.la/268945 * * @param {*} val * @returns {boolean} */ function callable(val) { return typeof val === "function" && !(val instanceof Ci.nsIDOMElement); } function call(fn, self, ...args) { fn.apply(self, args); return fn; } /** * Returns *val*. * * @param {*} val * @returns {*} */ function identity(val) { return val; } /** * Memoizes an object property value. * * @param {object} obj The object to add the property to. * @param {string} key The property name. * @param {function} getter The function which will return the initial * value of the property. */ function memoize(obj, key, getter) { if (arguments.length == 1) { let res = update(Object.create(obj), obj); for (let prop of Object.getOwnPropertyNames(obj)) { let get = __lookupGetter__.call(obj, prop); if (get) memoize(res, prop, get); } return res; } try { Object.defineProperty(obj, key, { configurable: true, enumerable: true, get: function g_replaceProperty() { try { Class.replaceProperty(this.instance || this, key, null); return Class.replaceProperty(this.instance || this, key, getter.call(this, key)); } catch (e) { util.reportError(e); } }, set: function s_replaceProperty(val) { Class.replaceProperty(this.instance || this, key, val); } }); } catch (e) { obj[key] = getter.call(obj, key); } } /** * Updates an object with the properties of another object. Getters * and setters are copied as expected. Moreover, any function * properties receive new 'supercall' and 'superapply' properties, * which will call the identically named function in target's * prototype. * * let a = { foo: function (arg) "bar " + arg } * let b = { __proto__: a } * update(b, { foo: function foo() foo.supercall(this, "baz") }); * * a.foo("foo") -> "bar foo" * b.foo() -> "bar baz" * * @param {Object} target The object to update. * @param {Object} src The source object from which to update target. * May be provided multiple times. * @returns {Object} Returns its updated first argument. */ function update(target) { for (let i = 1; i < arguments.length; i++) { let src = arguments[i]; Object.getOwnPropertyNames(src || {}).forEach(function (k) { let desc = Object.getOwnPropertyDescriptor(src, k); if (desc.value instanceof Class.Property) desc = desc.value.init(k, target) || desc.value; try { if (callable(desc.value) && Cu.getClassName(desc.value, true) != "Proxy" && Object.getPrototypeOf(target)) { let func = desc.value.wrapped || desc.value; if (!func.superapply) { func.__defineGetter__("super", function get_super() { return Object.getPrototypeOf(target)[k]; }); func.superapply = function superapply(self, args) { let meth = Object.getPrototypeOf(target)[k]; return meth && meth.apply(self, args); }; func.supercall = function supercall(self, ...args) { return func.superapply(self, args); }; } } if (k.startsWith("@@") && k.slice(2) in Symbol) k = Symbol[k.slice(2)]; Object.defineProperty(target, k, desc); } catch (e) { dump("Hmm... " + e + "\n" + (e && e.stack || new Error().stack) + "\n"); } }); } return target; } /** * @constructor Class * * Constructs a new Class. Arguments marked as optional must be * either entirely elided, or they must have the exact type * specified. * * @param {string} name The class's as it will appear when toString * is called, as well as in stack traces. * @optional * @param {function} base The base class for this module. May be any * callable object. * @optional * @default Class * @param {Object} prototype The prototype for instances of this * object. The object itself is copied and not used as a prototype * directly. * @param {Object} classProperties The class properties for the new * module constructor. More than one may be provided. * @optional * * @returns {function} The constructor for the resulting class. */ function Class(...args) { if (isString(args[0])) var name = args.shift(); var superclass = Class; if (callable(args[0])) superclass = args.shift(); var Constructor = eval(String.replace('\n\ (function constructor(PARAMS) { \n\ var self = Object.create(Constructor.prototype); \n\ self.instance = self; \n\ self.globalInstance = self; \n\ \n\ if ("_metaInit_" in self && self._metaInit_) \n\ self._metaInit_.apply(self, arguments); \n\ \n\ var res = self.init.apply(self, arguments); \n\ return res !== undefined ? res : self; \n\ })', "constructor", (name || superclass.className).replace(/\W/g, "_")) .replace("PARAMS", /^function .*?\((.*?)\)/ .exec(args[0] && args[0].init || Class.prototype.init)[1] .replace(/\b(self|res|Constructor)\b/g, "$1_"))); Constructor.className = name || superclass.className || superclass.name; if ("init" in superclass.prototype) Constructor.__proto__ = superclass; else { let superc = superclass; superclass = function Shim() {}; Class.extend(superclass, superc, { init: superc }); superclass.__proto__ = superc; } Class.extend(Constructor, superclass, args[0]); memoize(Constructor, "bound", Class.makeClosure); if (Iter && Ary) // Hack. :/ Object.defineProperty(Constructor, "closure", deprecated("bound", { get: function closure() { return this.bound; } })); update(Constructor, args[1]); Constructor.__proto__ = superclass; args.slice(2).forEach(function (obj) { if (callable(obj)) obj = obj.prototype; update(Constructor.prototype, obj); }); return Constructor; } Class.objectGlobal = object => { try { return Cu.getGlobalForObject(object); } catch (e) { return null; } }; /** * @class Class.Property * A class which, when assigned to a property in a Class's prototype * or class property object, defines that property's descriptor * rather than its value. If the desc object has an init property, it * will be called with the property's name before the descriptor is * assigned. * * @param {Object} desc The property descriptor. */ Class.Property = function Property(desc) { return update(Object.create(Property.prototype), desc || { configurable: true, writable: true }); }; Class.Property.prototype.init = () => {}; /** * Extends a subclass with a superclass. The subclass's * prototype is replaced with a new object, which inherits * from the superclass's prototype, {@see update}d with the * members of *overrides*. * * @param {function} subclass * @param {function} superclass * @param {Object} overrides @optional */ Class.extend = function extend(subclass, superclass, overrides) { subclass.superclass = superclass; subclass.prototype = Object.create(superclass.prototype); update(subclass.prototype, overrides); subclass.prototype.constructor = subclass; subclass.prototype._class_ = subclass; if (superclass.prototype.constructor === objproto.constructor) superclass.prototype.constructor = superclass; }; /** * Memoizes the value of a class property to the value returned by * the passed function the first time the property is accessed. * * @param {function(string)} getter The function which returns the * property's value. * @returns {Class.Property} */ Class.Memoize = function Memoize(getter, wait) { return Class.Property({ configurable: true, enumerable: true, init: function (key) { let done = false; if (wait) // Crazy, yeah, I know. -- Kris this.get = function replace() { let obj = this.instance || this; Object.defineProperty(obj, key, { configurable: true, enumerable: false, get: function get() { util.waitFor(() => done); return this[key]; } }); Task.spawn(function* () { let wait; for (var res of getter.call(obj)) { if (wait !== undefined) yield promises.sleep(wait); wait = res; } Class.replaceProperty(obj, key, res); done = true; }); return this[key]; }; else this.get = function g_Memoize() { let obj = this.instance || this; try { Class.replaceProperty(obj, key, null); return Class.replaceProperty(obj, key, getter.call(this, key)); } catch (e) { if (loaded.util) util.reportError(e); else defineModule.dump(" " + (e.filename || e.fileName) + ":" + e.lineNumber + ": " + e + "\n" + (e.stack || Error().stack) + "\n"); } }; this.set = function s_Memoize(val) { return Class.replaceProperty(this.instance || this, key, val); }; } }); }; /** * Updates the given object with the object in the target class's * prototype. */ Class.Update = function Update(obj) { return Class.Property({ configurable: true, enumerable: true, writable: true, init: function (key, target) { this.value = update({}, target[key], obj); } }); }; Class.replaceProperty = function replaceProperty(obj, prop, value) { Object.defineProperty(obj, prop, { configurable: true, enumerable: true, value: value, writable: true }); return value; }; Class.toString = function toString() { return "[class " + this.className + "]"; }; Class.prototype = { /** * Initializes new instances of this class. Called automatically * when new instances are created. */ init: function c_init() {}, get instance() { return {}; }, set instance(val) { Class.replaceProperty(this, "instance", val); }, withSavedValues: function withSavedValues(names, callback, self) { let vals = names.map(name => this[name]); try { return callback.call(self || this); } finally { names.forEach((name, i) => { this[name] = vals[i]; }); } }, toString: function C_toString() { if (this.toStringParams) var params = "(" + this.toStringParams.map(m => (isArray(m) ? "[" + m + "]" : isString(m) ? JSON.stringify(m) : String(m))) .join(", ") + ")"; return "[instance " + this.constructor.className + (params || "") + "]"; }, /** * Executes *callback* after *timeout* milliseconds. The value of * 'this' is preserved in the invocation of *callback*. * * @param {function} callback The function to call after *timeout* * @param {number} timeout The time, in milliseconds, to wait * before calling *callback*. * @returns {nsITimer} The timer which backs this timeout. */ timeout: function timeout(callback, timeout) { let timeout_notify = timer => { if (this.stale || util.rehashing && !isinstance(Cu.getGlobalForObject(callback), ["BackstagePass"])) return; this.timeouts.splice(this.timeouts.indexOf(timer), 1); try { callback.call(this); } catch (e) { try { util.dump("Error invoking timer callback registered at " + [frame.filename, frame.lineNumber, ""].join(":")); util.reportError(e); } catch (e) { Cu.reportError(e); } } }; let frame = Components.stack.caller; let timer = services.Timer(timeout_notify, timeout || 0, services.Timer.TYPE_ONE_SHOT); this.timeouts.push(timer); return timer; }, timeouts: [], /** * Updates this instance with the properties of the given objects. * Like the update function, but with special semantics for * localized properties. */ update: function update() { // XXX: Duplication. for (let i = 0; i < arguments.length; i++) { let src = arguments[i]; Object.getOwnPropertyNames(src || {}).forEach(k => { if (k.startsWith("@@") && k.slice(2) in Symbol) k = Symbol[k.slice(2)]; let desc = Object.getOwnPropertyDescriptor(src, k); if (desc.value instanceof Class.Property) desc = desc.value.init(k, this) || desc.value; if (typeof desc.value === "function") { let func = desc.value.wrapped || desc.value; if (!func.superapply) { func.__defineGetter__("super", () => Object.getPrototypeOf(this)[k]); func.superapply = function superapply(self, args) { let meth = Object.getPrototypeOf(self)[k]; return meth && meth.apply(self, args); }; func.supercall = function supercall(self, ...args) { return func.superapply(self, args); }; } } try { if (k.startsWith("@@") && k.slice(2) in Symbol) k = Symbol[k.slice(2)]; if ("value" in desc && (this.localizedProperties.has(k) || this.magicalProperties.has(k))) this[k] = desc.value; else Object.defineProperty(this, k, desc); } catch (e) {} }, this); } return this; }, localizedProperties: new RealSet, magicalProperties: new RealSet }; /* Object.defineProperty(Class.prototype, Symbol.iterator, { get: function () this.__iterator__, set: function (val) { this.__iterator__ = val }, configurable: true }); */ for (let name of properties(Class.prototype)) { let desc = Object.getOwnPropertyDescriptor(Class.prototype, name); desc.enumerable = false; Object.defineProperty(Class.prototype, name, desc); } var closureHooks = { get(target, prop) { if (prop in target._closureCache) return target._closureCache[prop]; let p = target[prop]; if (callable(p)) return target._closureCache[prop] = p.bind(target); return p; }, }; Class.makeClosure = function makeClosure() { this._closureCache = Object.create(null); return new Proxy(this, closureHooks); }; memoize(Class.prototype, "bound", Class.makeClosure); /** * A base class generator for classes which implement XPCOM interfaces. * * @param {nsIIID|[nsIJSIID]} interfaces The interfaces which the class * implements. * @param {Class} superClass A super class. @optional * @returns {Class} */ function XPCOM(interfaces, superClass) { interfaces = Array.concat(interfaces); let shim = XPCOMShim(interfaces); let base = { QueryInterface: XPCOMUtils.generateQI(interfaces) }; for (let [k, v] of iter(shim)) { if (v === undefined || callable(v)) base[k] = stub; else base[k] = v; } let res = Class("XPCOM(" + interfaces + ")", superClass || Class, base); return res; } function XPCOMShim(interfaces) { let ip = services.InterfacePointer({ QueryInterface: function (iid) { if (iid.equals(Ci.nsISecurityCheckedComponent)) throw Cr.NS_ERROR_NO_INTERFACE; return this; }, getHelperForLanguage: function () { return null; }, getInterfaces: function (count) { count.value = 0; } }); return (interfaces || []).reduce((shim, iface) => shim.QueryInterface(Ci[iface]), ip.data); } let stub = Class.Property({ configurable: true, enumerable: false, value: function stub() { return null; }, writable: true }); /** * An abstract base class for classes that wish to inherit from Error. */ var ErrorBase = Class("ErrorBase", Error, { level: 2, init: function EB_init(message, level=0) { let error = Error(message); update(this, error); this.stack = error.stack; this.message = message; let frame = Components.stack; for (let i = 0; i < this.level + level; i++) { frame = frame.caller; this.stack = this.stack.replace(/^.*\n/, ""); } this.fileName = frame.filename; this.lineNumber = frame.lineNumber; }, toString: function () { return String(this.message); } }); /** * An Error subclass to throw in order to stop sourcing a plugin without * printing a stack trace. */ var Finished = Class("Finished", ErrorBase); /** * Constructs a new Module class and instantiates an instance into the current * module global object. * * @param {string} name The name of the instance. * @param {Object} prototype The instance prototype. * @param {Object} classProperties Properties to be applied to the class constructor. * @returns {Class} */ function Module(name, prototype, ...args) { try { let init = callable(prototype) ? 2 : 1; let proto = callable(prototype) ? args[0] : prototype; proto._metaInit_ = function () { module.prototype._metaInit_ = null; currentModule[name.toLowerCase()] = this; }; const module = Class.apply(Class, [name, prototype, ...args.slice(0, init)]); let instance = module(); module.className = name.toLowerCase(); instance.INIT = update(Object.create(Module.INIT), args[init] || {}); currentModule[module.className] = instance; defineModule.modules.push(instance); return module; } catch (e) { if (typeof e === "string") e = Error(e); dump(e.fileName + ":" + e.lineNumber + ": " + e + "\n" + (e.stack || Error().stack)); } } Module.INIT = { init: function Module_INIT_init(dactyl, modules, window) { let args = arguments; let locals = []; for (let local = this.Local; local; local = local.super) locals.push(local); if (locals.length) { let module = this, objs = {}; for (let i in locals) { module = objs[i] = Object.create(module); module.modules = modules; } module.isLocalModule = true; modules.jsmodules[this.constructor.className] = module; locals.reverse().forEach((fn, i) => { update(objs[i], fn.apply(module, args)); }); memoize(module, "closure", Class.makeClosure); module.instance = module; module.init(); if (module.signals) modules.dactyl.registerObservers(module); } } }; /** * @class Struct * * Creates a new Struct constructor, used for creating objects with * a fixed set of named members. Each argument should be the name of * a member in the resulting objects. These names will correspond to * the arguments passed to the resultant constructor. Instances of * the new struct may be treated very much like arrays, and provide * many of the same methods. * * const Point = Struct("x", "y", "z"); * let p1 = Point(x, y, z); * * @returns {function} The constructor for the new Struct. */ function Struct(...args) { if (/^[A-Z]/.test(args[0])) var className = args.shift(); const Struct = Class(className || "Struct", StructBase, { length: args.length, members: Ary.toObject(args.map((v, k) => [v, k])), }); args.forEach(function (name, i) { Struct.prototype.__defineGetter__(name, function () { return this[i]; }); Struct.prototype.__defineSetter__(name, function (val) { this[i] = val; }); }); return Struct; } var StructBase = Class("StructBase", Array, { init: function struct_init() { for (let i = 0; i < arguments.length; i++) if (arguments[i] != undefined) this[i] = arguments[i]; }, get toStringParams() { return this; }, clone: function struct_clone() { return this.constructor.apply(null, this.slice()); }, bound: Class.Property(Object.getOwnPropertyDescriptor(Class.prototype, "bound")), closure: Class.Property(Object.getOwnPropertyDescriptor(Class.prototype, "closure")), get: function struct_get(key, val) { return this[this.members[key]]; }, set: function struct_set(key, val) { return this[this.members[key]] = val; }, toObject: function struct_toObject() { return Ary.toObject(Object.keys(this.members).map(k => [k, this[k]])); }, toString: function struct_toString() { return Class.prototype.toString.apply(this, arguments); }, // Iterator over our named members "@@iterator": function* struct__iterator__() { for (let k of keys(this.members)) yield this[k]; } }, { fromArray: function fromArray(ary) { if (!(ary instanceof this)) ary.__proto__ = this.prototype; return ary; }, /** * Sets a lazily constructed default value for a member of * the struct. The value is constructed once, the first time * it is accessed and memoized thereafter. * * @param {string} key The name of the member for which to * provide the default value. * @param {function} val The function which is to generate * the default value. */ defaultValue: function defaultValue(key, val) { let i = this.prototype.members[key]; this.prototype.__defineGetter__(i, function () { return this[i] = val.call(this); }); this.prototype.__defineSetter__(i, function (value) { return Class.replaceProperty(this, i, value); }); return this; }, localize: function localize(key, defaultValue) { let i = this.prototype.members[key]; Object.defineProperty(this.prototype, i, Messages.Localized(defaultValue).init(key, this.prototype)); return this; } }); var Timer = Class("Timer", { init: function init(minInterval, maxInterval, callback, self=this) { this._timer = services.Timer(); this.callback = callback; this.self = self; this.minInterval = minInterval; this.maxInterval = maxInterval; this.doneAt = 0; this.latest = 0; }, notify: function notify(timer, force) { try { if (!loaded || loaded.util && util.rehashing || typeof util === "undefined" || !force && this.doneAt == 0) return; this._timer.cancel(); this.latest = 0; // minInterval is the time between the completion of the command and the next firing this.doneAt = Date.now() + this.minInterval; this.callback.call(this.self, this.arg); } catch (e) { if (typeof util === "undefined") dump(JSMLoader.name + ": " + e + "\n" + (e.stack || Error().stack)); else util.reportError(e); } finally { this.doneAt = Date.now() + this.minInterval; } }, tell: function tell(arg) { if (arguments.length > 0) this.arg = arg; let now = Date.now(); if (this.doneAt == -1) this._timer.cancel(); let timeout = this.minInterval; if (now > this.doneAt && this.doneAt > -1) timeout = 0; else if (this.latest) timeout = Math.min(timeout, this.latest - now); else this.latest = now + this.maxInterval; this._timer.initWithCallback(this, Math.max(timeout, 0), this._timer.TYPE_ONE_SHOT); this.doneAt = -1; }, reset: function reset() { this._timer.cancel(); this.doneAt = 0; }, flush: function flush(force) { if (this.doneAt == -1 || force) this.notify(null, true); } }); /** * Idempotent function which returns the UTF-8 encoded value of an * improperly-decoded string. * * @param {string} str * @returns {string} */ function UTF8(str) { try { return decodeURIComponent(escape(str)); } catch (e) { return str; } } var octal = deprecated("octal integer literals", function octal(decimal) { return parseInt(decimal, 8); }); /** * Iterates over an arbitrary object. The following iterator types are * supported, and work as a user would expect: * * • nsIDOMNodeIterator * • mozIStorageStatement * * Additionally, the following array-like objects yield a tuple of the * form [index, element] for each contained element: * * • nsIDOMHTMLCollection * • nsIDOMNodeList * * and the following likewise yield one element of the form * [name, element] for each contained element: * * • nsIDOMNamedNodeMap * * Duck typing is implemented for any other type. If the object * contains the "enumerator" property, iter is called on that. If the * property is a function, it is called first. If it contains the * property "getNext" along with either "hasMoreItems" or "hasMore", it * is iterated over appropriately. * * For all other cases, this function behaves exactly like the Iterator * function. * * @param {object} obj * @param {nsIJSIID} iface The interface to which to query all elements. * @returns {Generator} */ function iter(obj, iface) { if (arguments.length == 2 && iface instanceof Ci.nsIJSIID) return iter(obj).map(item => item.QueryInterface(iface)); let args = arguments; let res; if (args.length > 1) res = (function* () { for (let i = 0; i < args.length; i++) for (let j of iter(args[i])) yield j; })(); else if (isinstance(obj, ["Array", StructBase])) res = obj.entries(); else if (Symbol.iterator in obj) res = obj[Symbol.iterator](); else if (isinstance(obj, [Ci.nsIDOMHTMLCollection, Ci.nsIDOMNodeList])) res = Array.from(obj).entries(); else if (ctypes && ctypes.CData && obj instanceof ctypes.CData) { while (obj.constructor instanceof ctypes.PointerType) obj = obj.contents; if (obj.constructor instanceof ctypes.ArrayType) res = Array.from(obj).entries(); else if (obj.constructor instanceof ctypes.StructType) res = (function* () { for (let prop of obj.constructor.fields) { let [name, type] = Iterator(prop).next(); yield [name, obj[name]]; } })(); else return iter({}); } else if (Ci.nsIDOMNamedNodeMap && obj instanceof Ci.nsIDOMNamedNodeMap || Ci.nsIDOMMozNamedAttrMap && obj instanceof Ci.nsIDOMMozNamedAttrMap) res = (function* () { for (let i = 0; i < obj.length; i++) yield [obj.name, obj]; })(); else if (obj instanceof Ci.mozIStorageStatement) res = (function* (obj) { while (obj.executeStep()) yield obj.row; obj.reset(); })(obj); else if ("getNext" in obj) { if ("hasMoreElements" in obj) res = (function* () { while (obj.hasMoreElements()) yield obj.getNext(); })(); else if ("hasMore" in obj) res = (function* () { while (obj.hasMore()) yield obj.getNext(); })(); } else if ("enumerator" in obj) { if (callable(obj.enumerator)) return iter(obj.enumerator()); return iter(obj.enumerator); } if (res === undefined) res = Object.entries(obj).values(); return Iter(res); } update(iter, { toArray: deprecated("Array.from", function toArray(iter) { return Array.from(iter); }), // See Ary.prototype for API docs. toObject: function toObject(iter) { let obj = {}; for (let [k, v] of iter) if (v instanceof Class.Property) Object.defineProperty(obj, k, v.init(k, obj) || v); else obj[k] = v; return obj; }, compact: function* compact(iter) { for (let item of iter) if (item != null) yield item; }, every: function every(iter, pred, self) { pred = pred || identity; for (let elem of iter) if (!pred.call(self, elem)) return false; return true; }, some: function every(iter, pred, self) { pred = pred || identity; for (let elem of iter) if (pred.call(self, elem)) return true; return false; }, filter: function* filter(iter, pred, self) { for (let elem of iter) if (pred.call(self, elem)) yield elem; }, /** * Iterates over an iterable object and calls a callback for each * element. * * @param {object} iter The iterator. * @param {function} fn The callback. * @param {object} self The this object for *fn*. */ forEach: function forEach(iter, func, self) { for (let val of iter) func.call(self, val); }, indexOf: function indexOf(iter, elem) { let i = 0; for (let item of iter) { if (item == elem) return i; i++; } return -1; }, /** * Returns the array that results from applying *func* to each property of * *obj*. * * @param {Object} obj * @param {function} func * @returns {Array} */ map: function* map(iter, func, self) { for (let i of iter) yield func.call(self, i); }, /** * Returns the nth member of the given array that matches the * given predicate. */ nth: function nth(iter, pred, n, self) { if (typeof pred === "number") [pred, n] = [() => true, pred]; // Hack. for (let elem of iter) if (pred.call(self, elem) && n-- === 0) return elem; return undefined; }, /** * Analog of Array.find method. Returns the first item in the * iterator for which `pred` returns true. */ find: function find(iter, pred, self) { for (let elem of iter) if (pred.call(self, elem)) return elem; return undefined; }, sort: function sort(iter, fn, self) { return Ary(iter).sort(fn, self); }, uniq: function* uniq(iter) { let seen = new RealSet; for (let item of iter) if (!seen.add(item)) yield item; }, /** * Zips the contents of two iterables. The resulting iterable is the length * of iter1, with any shortcomings of iter2 replaced with null strings. * * @param {Iterable} iter1 * @param {Iterable} iter2 * @returns {Generator} */ zip: function* zip(iter1, iter2) { let i = iter2[Symbol.iterator](); for (let x of iter1) { let y = i.next().value; yield [x, y === undefined ? "" : y]; } } }); var Iter = Class("Iter", { init(iter) { this.iter = iter; if (!(Symbol.iterator in iter) && "__iterator__" in iter) this.iter = iter.__iterator__(); if (this.iter.finalize) this.finalize = function finalize() { return apply(this.iter, "finalize", arguments); }; }, next() { return this.iter.next() }, send() { return apply(this.iter, "send", arguments) }, "@@iterator": function () { return this.iter }, __iterator__: function () { Cu.reportError( "Dear sir or madam,\n" + "You are attempting to use this iterator object as a\n" + "deprecated, pre-ES6 iterator, which is known to cause\n" + "major problems. Please use it in a for-of loop instead.\n\n" + "Since I don't know how far back in the call chain you\n" + "originate, I'm just going to give you an entire stack.\n" + "Here you go:\n\n" + Error().stack); throw Error("Iter object used as a pre-ES6 iterator"); } }); iter.Iter = Iter; function arrayWrap(fn) { function wrapper() { let res = fn.apply(this, arguments); if (isArray(res)) return Ary(res); if (isObject(res) && Symbol.iterator in res) return iter(res); return res; } wrapper.wrapped = fn; return wrapper; } /** * Array utility methods. */ var Ary = Class("Ary", Array, { init: function (ary) { if (Symbol.iterator in ary && !isArray(ary)) ary = Array.from(ary); return new Proxy(ary, { get: function array_get(target, prop) { if (prop == "array") return target; if (hasOwnProp(Ary, prop) && callable(Ary[prop])) return arrayWrap(Ary[prop].bind(Ary, target)); let p = target[prop]; if (typeof prop == "symbol" || /^\d+$/.test(prop) || prop == "toString" || prop == "toSource" || !callable(p)) return p; return arrayWrap(p); } }); } }, { /** * Converts an array to an object. As in lisp, an assoc is an * array of key-value pairs, which maps directly to an object, * as such: * [["a", "b"], ["c", "d"]] -> { a: "b", c: "d" } * * @param {[Array]} assoc * @... {string} 0 - Key * @... 1 - Value */ toObject: function toObject(assoc) { let obj = {}; assoc.forEach(function ([k, v]) { if (v instanceof Class.Property) Object.defineProperty(obj, k, v.init(k, obj) || v); else obj[k] = v; }); return obj; }, /** * Compacts an array, removing all elements that are null or undefined: * ["foo", null, "bar", undefined] -> ["foo", "bar"] * * @param {Array} ary * @returns {Array} */ compact(ary) { return ary.filter(item => item != null) }, /** * Returns true if each element of ary1 is equal to the * corresponding element in ary2. * * @param {Array} ary1 * @param {Array} ary2 * @returns {boolean} */ equals(ary1, ary2) { return (ary1.length === ary2.length && Array.every(ary1, (e, i) => e === ary2[i])); }, /** * Flattens an array, such that all elements of the array are * joined into a single array: * [["foo", ["bar"]], ["baz"], "quux"] -> ["foo", ["bar"], "baz", "quux"] * * @param {Array} ary * @returns {Array} */ flatten(ary) { if (ary.length) return [].concat(...ary); return []; }, /** * Returns an Iterator for an array's values. * * @param {Array} ary * @returns {Iterator(Object)} */ iterValues: deprecated("Array#values", function* iterValues(ary) { for (let i = 0; i < ary.length; i++) yield ary[i]; }), /** * Returns an Iterator for an array's indices and values. * * @param {Array} ary * @returns {Iterator([{number}, {Object}])} */ iterItems: deprecated("Array#entries", function* iterItems(ary) { let length = ary.length; for (let i = 0; i < length; i++) yield [i, ary[i]]; }), /** * Returns the nth member of the given array that matches the * given predicate. */ nth: function nth(ary, pred, n, self) { for (let elem of ary) if (pred.call(self, elem) && n-- === 0) return elem; return undefined; }, /** * Filters out all duplicates from an array. If *unsorted* is false, the * array is sorted before duplicates are removed. * * @param {Array} ary * @param {boolean} unsorted * @returns {Array} */ uniq: function uniq(ary, unsorted) { let res = []; if (unsorted) { for (let item of ary) if (res.indexOf(item) == -1) res.push(item); } else { for (let item of ary.sort()) { if (item != last || !res.length) res.push(item); var last = item; } } return res; }, /** * Zips the contents of two arrays. The resulting array is the length of * ary1, with any shortcomings of ary2 replaced with null strings. * * @param {Array} ary1 * @param {Array} ary2 * @returns {Array} */ zip: function zip(ary1, ary2) { let res = []; for (let [i, item] of iter(ary1)) res.push([item, i in ary2 ? ary2[i] : ""]); return res; } }); let iterProto = Iter.prototype; Object.keys(iter).forEach(function (k) { iterProto[k] = function (...args) { let res = iter[k](this, ...args); if (k == "toArray") return res; if (isObject(res) && Symbol.iterator in res) return Iter(res[Symbol.iterator]()); return res; }; }); Object.keys(Ary).forEach(function (k) { if (!(k in iterProto)) iterProto[k] = function (...args) { let res = Ary[k]([...this], ...args); if (isArray(res)) return Ary(res); if (isObject(res) && Symbol.iterator in res) return Iter(res[Symbol.iterator]()); return res; }; }); Object.getOwnPropertyNames(Array.prototype).forEach(function (k) { if (!(k in iterProto) && callable(Array.prototype[k])) iterProto[k] = function (...args) { let res = [...this][k](...args); if (isArray(res)) return Ary(res); return res; }; }); Object.defineProperty(Class.prototype, "closure", deprecated("bound", { get: function closure() { return this.bound; } })); if (false) var array = Class("array", Ary, { init: deprecated("Ary", function init() { init.superapply(arguments); }) }); else array = Ary; endModule(); // catch(e){dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack);} // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/bookmarkcache.jsm000066400000000000000000000226501264147376100223170ustar00rootroot00000000000000// Copyright ©2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; defineModule("bookmarkcache", { exports: ["Bookmark", "BookmarkCache", "Keyword", "bookmarkcache"], require: ["services", "util"] }); this.lazyRequire("storage", ["storage"]); function newURI(url, charset, base) { try { return services.io.newURI(url, charset, base); } catch (e) { throw Error(e); } } var Bookmark = Struct("url", "title", "icon", "post", "keyword", "tags", "charset", "id"); var Keyword = Struct("keyword", "title", "icon", "url"); Bookmark.defaultValue("icon", function () { return BookmarkCache.getFavicon(this.url); }); update(Bookmark.prototype, { get extra() { return [ ["keyword", this.keyword, "Keyword"], ["tags", this.tags.join(", "), "Tag"] ].filter(item => item[1]); }, get uri() { return newURI(this.url); }, set uri(uri) { let tags = this.tags; this.tags = null; services.bookmarks.changeBookmarkURI(this.id, uri); this.tags = tags; }, encodeURIComponent: function _encodeURIComponent(str) { if (!this.charset || this.charset === "UTF-8") return encodeURIComponent(str); let conv = services.CharsetConv(this.charset); return escape(conv.ConvertFromUnicode(str) + conv.Finish()).replace(/\+/g, encodeURIComponent); }, get folder() { let res = []; res.toString = function () { return this.join("/"); }; let id = this.id, title; while ((id = services.bookmarks.getFolderIdForItem(id)) && (title = services.bookmarks.getItemTitle(id))) res.push(title); return res.reverse(); } }); Bookmark.prototype.members.uri = Bookmark.prototype.members.url; Bookmark.setter = function (key, func) { return this.prototype.__defineSetter__(key, func); }; Bookmark.setter("url", function (val) { this.uri = isString(val) ? newURI(val) : val; }); Bookmark.setter("title", function (val) { services.bookmarks.setItemTitle(this.id, val); }); Bookmark.setter("post", function (val) { bookmarkcache.annotate(this.id, bookmarkcache.POST, val); }); Bookmark.setter("charset", function (val) { bookmarkcache.annotate(this.id, bookmarkcache.CHARSET, val); }); Bookmark.setter("keyword", function (val) { services.bookmarks.setKeywordForBookmark(this.id, val); }); Bookmark.setter("tags", function (val) { services.tagging.untagURI(this.uri, null); if (val) services.tagging.tagURI(this.uri, val); }); var name = "bookmark-cache"; var BookmarkCache = Module("BookmarkCache", XPCOM(Ci.nsINavBookmarkObserver), { POST: "bookmarkProperties/POSTData", CHARSET: "dactyl/charset", init: function init() { services.bookmarks.addObserver(this, false); }, cleanup: function cleanup() { services.bookmarks.removeObserver(this); }, "@@iterator": function () { return values(bookmarkcache.bookmarks); }, bookmarks: Class.Memoize(function () { return this.load(); }), keywords: Class.Memoize(function () { let res = {}; for (let bookmark of this) if (bookmark.keyword) res[bookmark.keyword] = bookmark; return res; }), rootFolders: ["toolbarFolder", "bookmarksMenuFolder", "unfiledBookmarksFolder"] .map(s => services.bookmarks[s]), _deleteBookmark: function deleteBookmark(id) { let result = this.bookmarks[id] || null; delete this.bookmarks[id]; return result; }, _loadBookmark: function loadBookmark(node) { if (node.uri == null) // How does this happen? return false; let uri = newURI(node.uri); let keyword = services.bookmarks.getKeywordForBookmark(node.itemId); let tags = "tags" in node ? (node.tags ? node.tags.split(/, /g) : []) : services.tagging.getTagsForURI(uri, {}) || []; let post = BookmarkCache.getAnnotation(node.itemId, this.POST); let charset = BookmarkCache.getAnnotation(node.itemId, this.CHARSET); return Bookmark(node.uri, node.title, node.icon, post, keyword, tags, charset, node.itemId); }, annotate: function (id, key, val, timespan) { if (val) services.annotation.setItemAnnotation(id, key, val, 0, timespan || services.annotation.EXPIRE_NEVER); else if (services.annotation.itemHasAnnotation(id, key)) services.annotation.removeItemAnnotation(id, key); }, get: function (url) { let ids = services.bookmarks.getBookmarkIdsForURI(newURI(url), {}); for (let id of ids) if (id in this.bookmarks) return this.bookmarks[id]; return null; }, readBookmark: function readBookmark(id) { return { itemId: id, uri: services.bookmarks.getBookmarkURI(id).spec, title: services.bookmarks.getItemTitle(id) }; }, findRoot: function findRoot(id) { do { var root = id; id = services.bookmarks.getFolderIdForItem(id); } while (id != services.bookmarks.placesRoot && id != root); return root; }, isBookmark: function (id) { return this.rootFolders.indexOf(this.findRoot(id)) >= 0; }, /** * Returns true if the given URL is bookmarked and that bookmark is * not a Live Bookmark. * * @param {nsIURI|string} url The URL of which to check the bookmarked * state. * @returns {boolean} */ isBookmarked: function isBookmarked(uri) { if (isString(uri)) uri = newURI(uri); try { return services.bookmarks .getBookmarkIdsForURI(uri, {}) .some(this.bound.isRegularBookmark); } catch (e) { return false; } }, isRegularBookmark: function isRegularBookmark(id) { do { var root = id; if (services.livemark && services.livemark.isLivemark(id)) return false; id = services.bookmarks.getFolderIdForItem(id); } while (id != services.bookmarks.placesRoot && id != root); return this.rootFolders.indexOf(root) >= 0; }, load: function load() { let bookmarks = {}; let query = services.history.getNewQuery(); let options = services.history.getNewQueryOptions(); options.queryType = options.QUERY_TYPE_BOOKMARKS; try { // https://bugzil.la/702639 options.excludeItemIfParentHasAnnotation = "livemark/feedURI"; } catch (e) {} let { root } = services.history.executeQuery(query, options); root.containerOpen = true; try { // iterate over the immediate children of this folder for (let i = 0; i < root.childCount; i++) { let node = root.getChild(i); if (node.type == node.RESULT_TYPE_URI) // bookmark bookmarks[node.itemId] = this._loadBookmark(node); } } finally { root.containerOpen = false; } return bookmarks; }, onItemAdded: function onItemAdded(itemId, folder, index) { if (services.bookmarks.getItemType(itemId) == services.bookmarks.TYPE_BOOKMARK) { if (this.isBookmark(itemId)) { let bmark = this._loadBookmark(this.readBookmark(itemId)); this.bookmarks[bmark.id] = bmark; storage.fireEvent(name, "add", bmark); delete this.keywords; } } }, onItemRemoved: function onItemRemoved(itemId, folder, index) { let result = this._deleteBookmark(itemId); delete this.keywords; if (result) storage.fireEvent(name, "remove", result); }, onItemChanged: function onItemChanged(itemId, property, isAnnotation, value) { if (isAnnotation) if (property === this.POST) [property, value] = ["post", BookmarkCache.getAnnotation(itemId, property)]; else if (property === this.CHARSET) [property, value] = ["charset", BookmarkCache.getAnnotation(itemId, property)]; else return; let bookmark = this.bookmarks[itemId]; if (bookmark) { if (property == "keyword") delete this.keywords; if (property == "tags") value = services.tagging.getTagsForURI(bookmark.uri, {}); if (property in bookmark) { bookmark[bookmark.members[property]] = value; storage.fireEvent(name, "change", { __proto__: bookmark, changed: property }); } } } }, { DEFAULT_FAVICON: "chrome://mozapps/skin/places/defaultFavicon.png", getAnnotation: function getAnnotation(item, anno) { return services.annotation.itemHasAnnotation(item, anno) ? services.annotation.getItemAnnotation(item, anno) : null; }, getFavicon: function getFavicon(uri) { try { return services.favicon.getFaviconImageForPage(newURI(uri)).spec; } catch (e) { return ""; } } }); endModule(); // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/bootstrap.jsm000066400000000000000000000016321264147376100215400ustar00rootroot00000000000000// Copyright (c) 2011-2014 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; var EXPORTED_SYMBOLS = ["require"]; function create(proto) { return Object.create(proto); } this["import"] = function import_(obj) { let res = {}; for (let key of Object.getOwnPropertyNames(obj)) Object.defineProperty(res, key, Object.getOwnPropertyDescriptor(obj, key)); return res; }; if (typeof TextEncoder == "undefined") Components.utils.importGlobalProperties(["TextEncoder", "TextDecoder"]); // Deal with subScriptLoader prepending crap to loaded URLs Components.utils.import("resource://gre/modules/Services.jsm"); function loadSubScript() { return Services.scriptloader.loadSubScript.apply(null, arguments); } // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/buffer.jsm000066400000000000000000003276411264147376100210070ustar00rootroot00000000000000// Copyright (c) 2006-2008 by Martin Stubenschrott // Copyright (c) 2007-2011 by Doug Kearns // Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; defineModule("buffer", { exports: ["Buffer", "buffer"], require: ["prefs", "services", "util"] }); lazyRequire("bookmarkcache", ["bookmarkcache"]); lazyRequire("contexts", ["Group"]); lazyRequire("downloads", ["Downloads"]); lazyRequire("io", ["io"]); lazyRequire("finder", ["RangeFind"]); lazyRequire("overlay", ["overlay"]); lazyRequire("promises", ["CancelablePromise", "Promise", "promises"]); lazyRequire("sanitizer", ["sanitizer"]); lazyRequire("storage", ["File", "storage"]); lazyRequire("template", ["template"]); let global = this; /** * A class to manage the primary web content buffer. The name comes * from Vim's term, 'buffer', which signifies instances of open * files. * @instance buffer */ var Buffer = Module("Buffer", { Local: function Local(dactyl, modules, window) { let gBrowser = window.gBrowser; return { get browser() { return gBrowser.mCurrentBrowser; }, }; }, init: function init(win, browser) { if (win) this.win = win; if (browser) this.browser = browser; }, get addPageInfoSection() { return Buffer.bound.addPageInfoSection; }, get pageInfo() { return Buffer.pageInfo; }, // called when the active document is scrolled _updateBufferPosition: function _updateBufferPosition() { this.modules.statusline.updateBufferPosition(); this.modules.commandline.clear(true); }, /** * @property {Array} The alternative style sheets for the current * buffer. Only returns style sheets for the 'screen' media type. */ get alternateStyleSheets() { let stylesheets = this.allFrames() .flatMap(w => w.document.styleSheets); return stylesheets.filter( s => /^(screen|all|)$/i.test(s.media.mediaText) && !/^\s*$/.test(s.title) ); }, /** * The load context of the window bound to this buffer. */ get loadContext() { return sanitizer.getContext(this.win, this.topWindow); }, /** * Content preference methods. */ prefs: Class.Memoize(function () { let self = this; return { /** * Returns a promise for the given preference name. * * @param {string} pref The name of the preference to return. * @returns {Promise<*>} */ get: function get(pref) { return new Promise((resolve, reject) => { let val = services.contentPrefs.getCachedByDomainAndName( self.uri.spec, pref, self.loadContext); let found = false; if (val) resolve(val.value); else services.contentPrefs.getByDomainAndName( self.uri.spec, pref, self.loadContext, { handleCompletion: () => { if (!found) resolve(undefined); }, handleResult: pref => { found = true; resolve(pref.value); }, handleError: reject }); }); }, /** * Sets a content preference for the given buffer. * * @param {string} pref The preference to set. * @param {string} value The value to store. */ set: function set(pref, value) { return new Promise((resolve, reject) => { services.contentPrefs.set( self.uri.spec, pref, value, self.loadContext, { handleCompletion: () => {}, handleResult: resolve, handleError: reject }); }); }, /** * Clear a content preference for the given buffer. * * @param {string} pref The preference to clear. */ clear: function clear(pref) { return new Promise((resolve, reject) => { services.contentPrefs.removeByDomainAndName( self.uri.spec, pref, self.loadContext, { handleCompletion: () => {}, handleResult: resolve, handleError: reject }); }); } }; }), /** * Gets a content preference for the given buffer. * * @param {string} pref The preference to get. * @param {function(string|number|boolean)} callback The callback to * call with the preference value. @optional * @returns {string|number|boolean} The value of the preference, if * callback is not provided. */ getPref: deprecated("prefs.get", function getPref(pref, callback) { services.contentPrefs.getPref(this.uri, pref, this.loadContext, callback); }), /** * Sets a content preference for the given buffer. * * @param {string} pref The preference to set. * @param {string} value The value to store. */ setPref: deprecated("prefs.set", function setPref(pref, value) { services.contentPrefs.setPref( this.uri, pref, value, this.loadContext); }), /** * Clear a content preference for the given buffer. * * @param {string} pref The preference to clear. */ clearPref: deprecated("prefs.clear", function clearPref(pref) { services.contentPrefs.removePref( this.uri, pref, this.loadContext); }), climbUrlPath: function climbUrlPath(count) { let { dactyl } = this.modules; let url = this.uri.clone(); dactyl.assert(url instanceof Ci.nsIURL); while (count-- && url.path != "/") url.path = url.path.replace(/[^\/]*\/*$/, ""); dactyl.assert(!url.equals(this.uri)); dactyl.open(url.spec); }, incrementURL: function incrementURL(count) { let { dactyl } = this.modules; let matches = this.uri.spec.match(/(.*?)(\d+)(\D*)$/); dactyl.assert(matches); let oldNum = matches[2]; // disallow negative numbers as trailing numbers are often proceeded by hyphens let newNum = String(Math.max(parseInt(oldNum, 10) + count, 0)); if (/^0/.test(oldNum)) while (newNum.length < oldNum.length) newNum = "0" + newNum; matches[2] = newNum; dactyl.open(matches.slice(1).join("")); }, /** * @property {number} True when the buffer is fully loaded. */ get loaded() { return apply(Math, "min", this.allFrames() .map(frame => ["loading", "interactive", "complete"] .indexOf(frame.document.readyState))); }, /** * @property {Object} The local state store for the currently selected * tab. */ get localStore() { let { doc } = this; let store = overlay.getData(doc, "buffer", null); if (!store || !this.localStorePrototype.isPrototypeOf(store)) store = overlay.setData(doc, "buffer", Object.create(this.localStorePrototype)); return store.instance = store; }, localStorePrototype: memoize({ instance: {}, get jumps() { return []; }, jumpsIndex: -1 }), /** * @property {Node} The last focused input field in the buffer. Used * by the "gi" key binding. */ get lastInputField() { let field = this.localStore.lastInputField && this.localStore.lastInputField.get(); let doc = field && field.ownerDocument; let win = doc && doc.defaultView; return win && doc === win.document ? field : null; }, set lastInputField(value) { this.localStore.lastInputField = util.weakReference(value); }, get win() { if (this.browser) return this.browser.contentWindow; return this._win; }, set win(value) { this._win = value; }, /** * @property {nsIURI} The current top-level document. */ get doc() { if (this.browser) return this.browser.contentDocument; return this.win.document; }, get docShell() { let docShell; if (this.browser) docShell = this.browser.docShell; if (!docShell && this.win && this.win.QueryInterface) docShell = util.docShell(this.win); return docShell; }, get webNav() { if (this.browser) return this.browser.webNavigation; return this.docShell.QueryInterface(Ci.nsIWebNavigation); }, get modules() { return this.topWindow.dactyl.modules; }, set modules(val) {}, topWindow: Class.Memoize(function () { if (this.browser) return this.browser.ownerDocument.defaultView; return util.topWindow(this.win); }), /** * @property {nsIURI} The current top-level document's URI. */ get uri() { if (this.browser) return this.browser.currentURI.clone(); return util.newURI(this.win.location.href); }, /** * @property {nsIURI} The current top-level document's URI, sans * fragment ID. */ get pageURI() { let uri = this.uri; if (!uri.ref.startsWith("!")) uri.ref = ""; return uri; }, /** * @property {nsIURI} The current top-level document's URI, sans any * fragment identifier. */ get documentURI() { if (this.browser) return this.browser.documentURI.clone(); return this.uri.cloneIgnoringRef(); }, /** * @property {string} The current top-level document's URL. */ get URL() { let uri = this.browser ? this.browser.currentURI : util.newURI(this.win.location.href); return update(new String(uri.spec), uri); }, /** * @property {number} The buffer's height in pixels. */ get pageHeight() { return this.win.innerHeight; }, get contentViewer() { if (!this.win || Cu.isCrossProcessWrapper(this.win) || !this.docShell) return null; // e10s return this.docShell.contentViewer .QueryInterface(Ci.nsIMarkupDocumentViewer || Ci.nsIContentViewer); }, /** * @property {number} The current browser's zoom level, as a * percentage with 100 as 'normal'. */ get zoomLevel() { let v = this.contentViewer; if (v == null) return this.ZoomManager.zoom * 100; return v[v.textZoom == 1 ? "fullZoom" : "textZoom"] * 100; }, set zoomLevel(value) { this.setZoom(value, this.fullZoom); }, /** * @property {boolean} Whether the current browser is using full * zoom, as opposed to text zoom. */ get fullZoom() { return this.ZoomManager.useFullZoom; }, set fullZoom(value) { this.setZoom(this.zoomLevel, value); }, get ZoomManager() { return this.topWindow.ZoomManager; }, /** * @property {string} The current document's title. */ get title() { if (this.browser) return this.browser.contentTitle; return this.doc.title; }, /** * @property {number} The buffer's horizontal scroll percentile. */ get scrollXPercent() { let elem = Buffer.Scrollable(this.findScrollable(0, true)); if (elem.scrollWidth - elem.clientWidth === 0) return 0; return elem.scrollLeft * 100 / (elem.scrollWidth - elem.clientWidth); }, /** * @property {number} The buffer's vertical scroll percentile. */ get scrollYPercent() { let elem = Buffer.Scrollable(this.findScrollable(0, false)); if (elem.scrollHeight - elem.clientHeight === 0) return 0; return elem.scrollTop * 100 / (elem.scrollHeight - elem.clientHeight); }, /** * @property {{ x: number, y: number }} The buffer's current scroll position * as reported by {@link Buffer.getScrollPosition}. */ get scrollPosition() { return Buffer.getScrollPosition(this.findScrollable(0, false)); }, /** * Returns a list of all frames in the given window or current buffer. */ allFrames: function allFrames(win=this.win, focusedFirst) { let frames = Array.from(util.iterFrames(win)); if (focusedFirst) { let focused = this.focusedFrame; return frames.sort((a, b) => (b === focused) - (a === focused)); } return frames; }, /** * @property {Window} Returns the currently focused frame. */ get focusedFrame() { try { if (Cu.isCrossProcessWrapper(this.win)) return this.win; } catch (e) { util.dump("WTF: " + e); util.dump(this.win, this.browser); return this.win; } let frame = this.localStore.focusedFrame; return frame && frame.get() || this.win; }, set focusedFrame(frame) { if (!Cu.isCrossProcessWrapper(this.win)) this.localStore.focusedFrame = util.weakReference(frame); }, /** * Returns the currently selected word. If the selection is * null, it tries to guess the word that the caret is * positioned in. * * @returns {string} */ get currentWord() { return Buffer.currentWord(this.focusedFrame); }, getCurrentWord: deprecated("buffer.currentWord", function getCurrentWord() { return Buffer.currentWord(this.focusedFrame, true); }), /** * Returns true if a scripts are allowed to focus the given input * element or input elements in the given window. * * @param {Node|Window} * @returns {boolean} */ focusAllowed: function focusAllowed(elem) { if (elem instanceof Ci.nsIDOMWindow && !DOM(elem).isEditable) return true; let { options } = this.modules; let doc = elem.ownerDocument || elem.document || elem; switch (options.get("strictfocus").getKey(doc.documentURIObject || util.newURI(doc.documentURI), "moderate")) { case "despotic": return overlay.getData(elem)["focus-allowed"] || elem.frameElement && overlay.getData(elem.frameElement)["focus-allowed"]; case "moderate": return overlay.getData(doc, "focus-allowed") || elem.frameElement && overlay.getData(elem.frameElement.ownerDocument)["focus-allowed"]; default: return true; } }, /** * Focuses the given element. In contrast to a simple * elem.focus() call, this function works for iframes and * image maps. * * @param {Node} elem The element to focus. */ focusElement: function focusElement(elem) { let win = elem.ownerDocument && elem.ownerDocument.defaultView || elem; overlay.setData(elem, "focus-allowed", true); overlay.setData(win.document, "focus-allowed", true); if (isinstance(elem, [Ci.nsIDOMHTMLFrameElement, Ci.nsIDOMHTMLIFrameElement])) elem = elem.contentWindow; if (elem.document) overlay.setData(elem.document, "focus-allowed", true); if (elem instanceof Ci.nsIDOMHTMLInputElement && elem.type == "file") { Buffer.openUploadPrompt(elem); this.lastInputField = elem; } else { if (isinstance(elem, [Ci.nsIDOMHTMLInputElement, Ci.nsIDOMXULTextBoxElement])) var flags = services.focus.FLAG_BYMOUSE; else flags = services.focus.FLAG_SHOWRING; // Hack to deal with current versions of Firefox misplacing // the caret if (!overlay.getData(elem, "had-focus", false) && elem.value && elem instanceof Ci.nsIDOMHTMLInputElement && DOM(elem).isEditable && elem.selectionStart != null && elem.selectionStart == elem.selectionEnd) elem.selectionStart = elem.selectionEnd = elem.value.length; DOM(elem).focus(flags); if (elem instanceof Ci.nsIDOMWindow) { let sel = elem.getSelection(); if (sel && !sel.rangeCount) sel.addRange(RangeFind.endpoint( RangeFind.nodeRange(elem.document.body || elem.document.documentElement), true)); } else { let range = RangeFind.nodeRange(elem); let sel = (elem.ownerDocument || elem).defaultView.getSelection(); if (!sel.rangeCount || !RangeFind.intersects(range, sel.getRangeAt(0))) { range.collapse(true); sel.removeAllRanges(); sel.addRange(range); } } // for imagemap if (elem instanceof Ci.nsIDOMHTMLAreaElement) { try { let [x, y] = elem.getAttribute("coords").split(",").map(parseFloat); DOM(elem).mouseover({ screenX: x, screenY: y }); } catch (e) {} } } }, /** * Find the *count*th last link on a page matching one of the given * regular expressions, or with a @rel or @rev attribute matching * the given relation. Each frame is searched beginning with the * last link and progressing to the first, once checking for * matching @rel or @rev properties, and then once for each given * regular expression. The first match is returned. All frames of * the page are searched, beginning with the currently focused. * * If follow is true, the link is followed. * * @param {string} rel The relationship to look for. * @param {[RegExp]} regexps The regular expressions to search for. * @param {number} count The nth matching link to follow. * @param {bool} follow Whether to follow the matching link. * @param {string} path The CSS to use for the search. @optional */ findLink: function findLink(rel, regexps, count, follow, path) { let { Hints, dactyl, options } = this.modules; let selector = path || options.get("hinttags").stringDefaultValue; let relRev = ["next", "prev"]; let rev = relRev[1 - relRev.indexOf(rel)]; function* followFrame(frame) { function* iter(elems) { for (let i = 0; i < elems.length; i++) if (elems[i].rel.toLowerCase() === rel || elems[i].rev.toLowerCase() === rev) yield elems[i]; } let elems = frame.document.getElementsByTagName("link"); for (let elem of iter(elems)) yield elem; function a(regexp, elem) { return regexp.test(elem.textContent) === regexp.result || Array.some(elem.childNodes, child => (regexp.test(child.alt) === regexp.result)); } function b(regexp, elem) { return regexp.test(elem.title) === regexp.result; } let res = Array.filter(frame.document.querySelectorAll(selector), Hints.isVisible); for (let test of [a, b]) for (let regexp of regexps) for (let i of util.range(res.length, 0, -1)) if (test(regexp, res[i])) yield res[i]; } for (let frame of this.allFrames(undefined, true)) for (let elem of followFrame(frame)) if (count-- === 0) { if (follow) this.followLink(elem, dactyl.CURRENT_TAB); return elem; } if (follow) dactyl.beep(); }, followDocumentRelationship: deprecated("buffer.findLink", function followDocumentRelationship(rel) { let { options } = this.modules; this.findLink(rel, options[rel + "pattern"], 0, true); }), /** * Fakes a click on a link. * * @param {Node} elem The element to click. * @param {number} where Where to open the link. See * {@link dactyl.open}. */ followLink: function followLink(elem, where) { let { dactyl } = this.modules; let doc = elem.ownerDocument; let win = doc.defaultView; let { left: offsetX, top: offsetY } = elem.getBoundingClientRect(); if (isinstance(elem, [Ci.nsIDOMHTMLFrameElement, Ci.nsIDOMHTMLIFrameElement])) return this.focusElement(elem); if (isinstance(elem, Ci.nsIDOMHTMLLinkElement)) return dactyl.open(elem.href, where); if (elem instanceof Ci.nsIDOMHTMLAreaElement) { // for imagemap let coords = elem.getAttribute("coords").split(","); offsetX = Number(coords[0]) + 1; offsetY = Number(coords[1]) + 1; } else if (elem instanceof Ci.nsIDOMHTMLInputElement && elem.type == "file") { Buffer.openUploadPrompt(elem); return; } let ctrlKey = false, shiftKey = false; let button = 0; switch (dactyl.forceTarget || where) { case dactyl.NEW_TAB: case dactyl.NEW_BACKGROUND_TAB: button = 1; shiftKey = dactyl.forceBackground != null ? dactyl.forceBackground : where != dactyl.NEW_BACKGROUND_TAB; break; case dactyl.NEW_WINDOW: shiftKey = true; break; case dactyl.CURRENT_TAB: break; } this.focusElement(elem); prefs.withContext(function () { prefs.set("browser.tabs.loadInBackground", true); let params = { button: button, screenX: offsetX, screenY: offsetY, ctrlKey: ctrlKey, shiftKey: shiftKey, metaKey: ctrlKey }; DOM(elem).mousedown(params).mouseup(params); let sel = util.selectionController(win); sel.getSelection(sel.SELECTION_FOCUS_REGION).collapseToStart(); }); }, /** * Resets the caret position so that it resides within the current * viewport. */ resetCaret: function resetCaret() { function visible(range) { return util.intersection(DOM(range).rect, viewport); } function getRanges(rect) { let nodes = win.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIDOMWindowUtils) .nodesFromRect(rect.x, rect.y, 0, rect.width, rect.height, 0, false, false); return Array.filter(nodes, n => n instanceof Ci.nsIDOMText) .map(RangeFind.nodeContents); } let win = this.focusedFrame; let doc = win.document; let sel = win.getSelection(); let { viewport } = DOM(win); if (sel.rangeCount) { var range = sel.getRangeAt(0); if (visible(range).height > 0) return; var { rect } = DOM(range); var reverse = rect.bottom > viewport.bottom; rect = { x: rect.left, y: 0, width: rect.width, height: win.innerHeight }; } else { let w = win.innerWidth; rect = { x: w / 3, y: 0, width: w / 3, height: win.innerHeight }; } var reduce = (a, b) => DOM(a).rect.top < DOM(b).rect.top ? a : b; var dir = "forward"; var y = 0; if (reverse) { reduce = (a, b) => DOM(b).rect.bottom > DOM(a).rect.bottom ? b : a; dir = "backward"; y = win.innerHeight - 1; } let ranges = getRanges(rect); if (!ranges.length) ranges = getRanges({ x: 0, y: y, width: win.innerWidth, height: 0 }); if (ranges.length) { range = ranges.reduce(reduce); if (range) { range.collapse(!reverse); sel.removeAllRanges(); sel.addRange(range); do { if (visible(range).height > 0) break; var { startContainer, startOffset } = range; sel.modify("move", dir, "line"); range = sel.getRangeAt(0); } while (startContainer != range.startContainer || startOffset != range.startOffset); sel.modify("move", reverse ? "forward" : "backward", "lineboundary"); } } if (!sel.rangeCount) sel.collapse(doc.body || doc.querySelector("body") || doc.documentElement, 0); }, /** * @property {nsISelection} The current document's normal selection. */ get selection() { return this.win.getSelection(); }, /** * @property {nsISelectionController} The current document's selection * controller. */ get selectionController() { return util.selectionController(this.focusedFrame); }, /** * @property {string|null} The canonical short URL for the current * document. */ get shortURL() { let { uri, doc } = this; function hashify(url) { let newURI = util.newURI(url); if (uri.hasRef && !newURI.hasRef) newURI.ref = uri.ref; return newURI.spec; } for (let shortener of Buffer.uriShorteners) try { let shortened = shortener(uri, doc); if (shortened) return hashify(shortened.spec); } catch (e) { util.reportError(e); } let sane = link => { let a = [link.href, this.pageURI.spec]; let b = overlay.getData(link, "link-check"); return !b || a[0] == b[0] && a[1] == b[1] || a[0] != b[0] && a[1] != b[1]; }; let link = DOM("link[href][rev=canonical], \ link[href][rel=shortlink]", doc) .filter(sane) .attr("href"); if (link) return hashify(link); return null; }, locationChanged: function locationChanged() { // Store current URL to detect tomfoolery. Might go awry if // links get updated before `history.pushState`, but better safe // than whatever. DOM("link[href][rev=canonical], \ link[href][rel=shortlink]", this.doc) .each(elem => { overlay.getData(elem, "link-check", () => [elem.href, this.pageURI.spec]); }); }, /** * Opens the appropriate context menu for *elem*. * * @param {Node} elem The context element. */ openContextMenu: deprecated("DOM#contextmenu", function openContextMenu(elem) { return DOM(elem).contextmenu(); }), /** * Saves a page link to disk. * * @param {HTMLAnchorElement} elem The page link to save. * @param {boolean} overwrite If true, overwrite any existing file. */ saveLink: function saveLink(elem, overwrite) { let { completion, dactyl, io } = this.modules; let self = this; let doc = elem.ownerDocument; let uri = util.newURI(elem.href || elem.src, null, util.newURI(elem.baseURI)); try { services.security.checkLoadURIWithPrincipal(doc.nodePrincipal, uri, services.security.STANDARD); io.CommandFileMode(_("buffer.prompt.saveLink") + " ", { onSubmit: function (path) { let file = io.File(path); if (file.exists() && file.isDirectory()) file.append(Buffer.getDefaultNames(elem)[0][0]); util.assert(!file.exists() || overwrite, _("io.existsNoOverride", file.path)); try { if (!file.exists()) file.create(File.NORMAL_FILE_TYPE, 0o644); } catch (e) { util.assert(false, _("save.invalidDestination", e.name)); } self.saveURI({ uri: uri, file: file, context: elem }); }, completer: function (context) { completion.savePage(context, elem); } }).open(); } catch (e) { dactyl.echoerr(e); } }, /** * Saves the contents of a URI to disk. * * @returns {Promise} */ saveURI: function saveURI(params) { if (params instanceof Ci.nsIURI) // Deprecated? params = { uri: arguments[0], file: arguments[1], callback: arguments[2], self: arguments[3] }; let promise = new CancelablePromise(promises.task(function* (resolve, reject, canceled) { if (params.isPrivate === undefined) { let privacy = sanitizer.getContext(params.context || this.win); params.isPrivate = privacy.usePrivateBrowsing; } let download = yield Downloads.createDownload({ source: { url: params.uri.spec, isPrivate: params.isPrivate, referrer: params.referrer, }, target: params.file, }); canceled.then(download.cancel); let list = yield Downloads.getList(Downloads.ALL); list.add(download); return download.start(); })); // Deprecated. if (params.callback) promise.then(() => { params.callback.call(params.self, params.uri, params.file); }); return promise; }, /** * Scrolls the currently active element horizontally. See * {@link Buffer.scrollHorizontal} for parameters. */ scrollHorizontal: function scrollHorizontal(increment, number) { return Buffer.scrollHorizontal(this.findScrollable(number, true), increment, number); }, /** * Scrolls the currently active element vertically. See * {@link Buffer.scrollVertical} for parameters. */ scrollVertical: function scrollVertical(increment, number) { return Buffer.scrollVertical(this.findScrollable(number, false), increment, number); }, /** * Scrolls the currently active element to the given horizontal and * vertical percentages. See {@link Buffer.scrollToPercent} for * parameters. */ scrollToPercent: function scrollToPercent(horizontal, vertical, dir) { return Buffer.scrollToPercent(this.findScrollable(dir || 0, vertical == null), horizontal, vertical); }, /** * Scrolls the currently active element to the given horizontal and * vertical positions. See {@link Buffer.scrollToPosition} for * parameters. */ scrollToPosition: function scrollToPosition(horizontal, vertical) { return Buffer.scrollToPosition(this.findScrollable(0, vertical == null), horizontal, vertical); }, _scrollByScrollSize: function _scrollByScrollSize(count, direction) { let { options } = this.modules; if (count > 0) options["scroll"] = count; this.scrollByScrollSize(direction); }, /** * Scrolls the buffer vertically 'scroll' lines. * * @param {boolean} direction The direction to scroll. If true then * scroll up and if false scroll down. */ scrollByScrollSize: function scrollByScrollSize(direction) { let { options } = this.modules; direction = direction ? 1 : -1; if (options["scroll"] > 0) this.scrollVertical("lines", options["scroll"] * direction); else this.scrollVertical("pages", direction / 2); }, /** * Find the best candidate scrollable element for the given * direction and orientation. * * @param {number} dir The direction in which the element must be * able to scroll. Negative numbers represent up or left, while * positive numbers represent down or right. * @param {boolean} horizontal If true, look for horizontally * scrollable elements, otherwise look for vertically scrollable * elements. */ findScrollable: function findScrollable(dir, horizontal) { function find(elem) { while (elem && !(elem instanceof Ci.nsIDOMElement) && elem.parentNode) elem = elem.parentNode; for (; elem instanceof Ci.nsIDOMElement; elem = elem.parentNode) if (Buffer.isScrollable(elem, dir, horizontal)) break; return elem; } try { var elem = this.focusedFrame.document.activeElement; if (elem == elem.ownerDocument.body) elem = null; } catch (e) {} try { var sel = this.focusedFrame.getSelection(); } catch (e) {} if (!elem && sel && sel.rangeCount) elem = sel.getRangeAt(0).startContainer; if (!elem) { let area = -1; for (let e of DOM(Buffer.SCROLLABLE_SEARCH_SELECTOR, this.focusedFrame.document)) { if (Buffer.isScrollable(e, dir, horizontal)) { let r = DOM(e).rect; let a = r.width * r.height; if (a > area) { area = a; elem = e; } } } if (elem) util.trapErrors("focus", elem); } if (elem) elem = find(elem); if (!(elem instanceof Ci.nsIDOMElement)) { let doc = this.findScrollableWindow().document; elem = find(doc.body || doc.getElementsByTagName("body")[0] || doc.documentElement); } let doc = this.focusedFrame.document; return util.assert(elem || doc.body || doc.documentElement); }, /** * Find the best candidate scrollable frame in the current buffer. */ findScrollableWindow: function findScrollableWindow() { let { document } = this.topWindow; let win = document.commandDispatcher.focusedWindow; if (win && (win.scrollMaxX > 0 || win.scrollMaxY > 0)) return win; win = this.focusedFrame; if (win && (win.scrollMaxX > 0 || win.scrollMaxY > 0)) return win; win = this.win; if (win.scrollMaxX > 0 || win.scrollMaxY > 0) return win; for (let frame of Ary.iterValues(win.frames)) if (frame.scrollMaxX > 0 || frame.scrollMaxY > 0) return frame; return win; }, /** * Finds the next visible element for the node path in 'jumptags' * for *arg*. * * @param {string} arg The element in 'jumptags' to use for the search. * @param {number} count The number of elements to jump. * @optional * @param {boolean} reverse If true, search backwards. @optional * @param {boolean} offScreen If true, include only off-screen elements. @optional */ findJump: function findJump(arg, count, reverse, offScreen) { let { marks, options } = this.modules; const FUDGE = 10; marks.push(); let path = options["jumptags"][arg]; util.assert(path, _("error.invalidArgument", arg)); let distance = reverse ? rect => -rect.top : rect => rect.top; let elems = Array.from(path.matcher(this.focusedFrame.document), elem => [e, distance(e.getBoundingClientRect())]) .filter(([elem, dist]) => dist > FUDGE) .sort((a, b) => a[1] - b[1]); if (offScreen && !reverse) elems = elems.filter(function (e) { return e[1] > this, this.topWindow.innerHeight; }); let idx = Math.min((count || 1) - 1, elems.length); util.assert(idx in elems); let elem = elems[idx][0]; elem.scrollIntoView(true); let sel = elem.ownerDocument.defaultView.getSelection(); sel.removeAllRanges(); sel.addRange(RangeFind.endpoint(RangeFind.nodeRange(elem), true)); }, // TODO: allow callback for filtering out unwanted frames? User defined? /** * Shifts the focus to another frame within the buffer. Each buffer * contains at least one frame. * * @param {number} count The number of frames to skip through. A negative * count skips backwards. */ shiftFrameFocus: function shiftFrameFocus(count) { if (!(this.doc instanceof Ci.nsIDOMHTMLDocument)) return; let frames = this.allFrames(); if (frames.length == 0) // currently top is always included return; // remove all hidden frames frames = frames.filter(frame => !(frame.document.body instanceof Ci.nsIDOMHTMLFrameSetElement)) .filter(frame => { if (!frame.frameElement) return false; let rect = frame.frameElement.getBoundingClientRect(); return rect.width && rect.height; }); // find the currently focused frame index let current = Math.max(0, frames.indexOf(this.focusedFrame)); // calculate the next frame to focus let next = current + count; if (next < 0 || next >= frames.length) util.dactyl.beep(); next = Math.constrain(next, 0, frames.length - 1); // focus next frame and scroll into view DOM(frames[next]).focus(); if (frames[next] != this.win) DOM(frames[next].frameElement).scrollIntoView(); // add the frame indicator let doc = frames[next].document; let indicator = DOM(["div", { highlight: "FrameIndicator" }], doc) .appendTo(doc.body || doc.documentElement || doc); util.timeout(function () { indicator.remove(); }, 500); // Doesn't unattach //doc.body.setAttributeNS(NS, "activeframe", "true"); //util.timeout(function () { doc.body.removeAttributeNS(NS, "activeframe"); }, 500); }, // similar to pageInfo // TODO: print more useful information, just like the DOM inspector /** * Displays information about the specified element. * * @param {Node} elem The element to query. */ showElementInfo: function showElementInfo(elem) { let { dactyl } = this.modules; dactyl.echo(["", /*L*/"Element:", ["br"], util.objectToString(elem, true)]); }, /** * Displays information about the current buffer. * * @param {boolean} verbose Display more verbose information. * @param {string} sections A string limiting the displayed sections. * @default The value of 'pageinfo'. */ showPageInfo: function showPageInfo(verbose, sections) { let { commandline, dactyl, options } = this.modules; // Ctrl-g single line output if (!verbose) { let file = this.win.location.pathname.split("/").pop() || _("buffer.noName"); let title = this.win.document.title || _("buffer.noTitle"); let info = template.map( (sections || options["pageinfo"]) .map(opt => Buffer.pageInfo[opt].action.call(this)), res => (res && iter(res).join(", ") || undefined), ", ").join(""); if (bookmarkcache.isBookmarked(this.URL)) info += ", " + _("buffer.bookmarked"); let pageInfoText = [JSON.stringify(file), " [", info, "] ", title].join(""); dactyl.echo(pageInfoText, commandline.FORCE_SINGLELINE); return; } let list = template.map(sections || options["pageinfo"], option => { let { action, title } = Buffer.pageInfo[option]; return template.table(title, action.call(this, true)); }, ["br"]); commandline.commandOutput(list); }, /** * Stops loading and animations in the current content. */ stop: function stop() { let { config } = this.modules; if (config.stop) config.stop(); else this.docShell.stop(this.docShell.STOP_ALL); }, /** * Opens a viewer to inspect the source of the currently selected * range. */ viewSelectionSource: function viewSelectionSource() { // copied (and tuned somewhat) from browser.jar -> nsContextMenu.js let { document, window } = this.topWindow; let win = document.commandDispatcher.focusedWindow; if (win == this.topWindow) win = this.focusedFrame; let charset = win ? "charset=" + win.document.characterSet : null; window.openDialog("chrome://global/content/viewPartialSource.xul", "_blank", "scrollbars,resizable,chrome,dialog=no", null, charset, win.getSelection(), "selection"); }, /** * Opens a viewer to inspect the source of the current buffer or the * specified *url*. Either the default viewer or the configured external * editor is used. * * @param {string|object|null} loc If a string, the URL of the source, * otherwise an object with some or all of the following properties: * * url: The URL to view. * doc: The document to view. * line: The line to select. * column: The column to select. * * If no URL is provided, the current document is used. * @default The current buffer. * @param {boolean} useExternalEditor View the source in the external editor. */ viewSource: function viewSource(loc, useExternalEditor) { let { dactyl, history, options } = this.modules; let window = this.topWindow; let doc = this.focusedFrame.document; if (isObject(loc)) { if (options.get("editor").has("line") || !loc.url) this.viewSourceExternally(loc.doc || loc.url || doc, loc); else window.openDialog("chrome://global/content/viewSource.xul", "_blank", "all,dialog=no", loc.url, null, null, loc.line); } else { if (useExternalEditor) this.viewSourceExternally(loc || doc); else { let url = loc || doc.location.href; const PREFIX = "view-source:"; if (url.startsWith(PREFIX)) url = url.substr(PREFIX.length); else url = PREFIX + url; let sh = history.session; if (sh[sh.index].URI.spec == url) this.docShell.gotoIndex(sh.index); else dactyl.open(url, { hide: true }); } } }, /** * Launches an editor to view the source of the given document. The * contents of the document are saved to a temporary local file and * removed when the editor returns. This function returns * immediately. * * @param {Document} doc The document to view. * @returns {Promise} */ viewSourceExternally: function viewSourceExternally(doc, loc) { return this.fetchSourceExternally(doc).then(([file, isTemp]) => { let { editor } = overlay.activeModules; editor.editFileExternally(update({ file: file.path }, loc)) .then(() => { if (isTemp) file.remove(false); }); }); }, fetchSourceExternally: function fetchSourceExternally(doc) { return new Promise((resolve, reject) => { if (isString(doc)) { var privacyContext = null; var uri = util.newURI(doc); } else { privacyContext = sanitizer.getContext(doc); uri = util.newURI(doc.location.href); } let ext = uri.fileExtension || "txt"; if (doc.contentType) try { ext = services.mime.getPrimaryExtension(doc.contentType, ext); } catch (e) {} if (!isString(doc)) { let file = io.createTempFile(); let encoder = services.HtmlEncoder(); encoder.init(doc, "text/unicode", encoder.OutputRaw|encoder.OutputPreformatted); OS.File.writeAtomic(file.path, encoder.encodeToString()) .then(() => { resolve([file, true]); }) .catch(reject); } else { let file = util.getFile(uri); if (file) resolve([file, false]); else { let file = io.createTempFile(); Downloads.fetch(uri, file.file).then(() => { resolve([file, true]); }).catch(reject); } } }); }, /** * Increases the zoom level of the current buffer. * * @param {number} steps The number of zoom levels to jump. * @param {boolean} fullZoom Whether to use full zoom or text zoom. */ zoomIn: function zoomIn(steps, fullZoom) { this.bumpZoomLevel(steps, fullZoom); }, /** * Decreases the zoom level of the current buffer. * * @param {number} steps The number of zoom levels to jump. * @param {boolean} fullZoom Whether to use full zoom or text zoom. */ zoomOut: function zoomOut(steps, fullZoom) { this.bumpZoomLevel(-steps, fullZoom); }, /** * Adjusts the page zoom of the current buffer to the given absolute * value. * * @param {number} value The new zoom value as a possibly fractional * percentage of the page's natural size. * @param {boolean} fullZoom If true, zoom all content of the page, * including raster images. If false, zoom only text. If omitted, * use the current zoom function. @optional * @throws {FailedAssertion} if the given *value* is not within the * closed range [Buffer.ZOOM_MIN, Buffer.ZOOM_MAX]. */ setZoom: function setZoom(value, fullZoom) { let { dactyl, statusline } = this.modules; let { ZoomManager } = this; if (fullZoom === undefined) fullZoom = ZoomManager.useFullZoom; else ZoomManager.useFullZoom = fullZoom; value /= 100; try { this.contentViewer.textZoom = fullZoom ? 1 : value; this.contentViewer.fullZoom = !fullZoom ? 1 : value; } catch (e if e == Cr.NS_ERROR_ILLEGAL_VALUE) { return dactyl.echoerr(_("zoom.illegal")); } if (prefs.get("browser.zoom.siteSpecific")) { if (value == 1) { this.prefs.clear("browser.content.full-zoom"); this.prefs.clear("dactyl.content.full-zoom"); } else { this.prefs.set("browser.content.full-zoom", value); this.prefs.set("dactyl.content.full-zoom", fullZoom); } } statusline.updateZoomLevel(); }, /** * Updates the zoom level of this buffer from a content preference. */ updateZoom: promises.task(function* updateZoom() { let uri = this.uri; if (prefs.get("browser.zoom.siteSpecific")) { let val = yield this.prefs.get("dactyl.content.full-zoom"); if (val != null && uri.equals(this.uri) && val != prefs.get("browser.zoom.full")) [this.contentViewer.textZoom, this.contentViewer.fullZoom] = [this.contentViewer.fullZoom, this.contentViewer.textZoom]; } }), /** * Adjusts the page zoom of the current buffer relative to the * current zoom level. * * @param {number} steps The integral number of natural fractions by which * to adjust the current page zoom. If positive, the zoom level is * increased, if negative it is decreased. * @param {boolean} fullZoom If true, zoom all content of the page, * including raster images. If false, zoom only text. If omitted, use * the current zoom function. @optional * @throws {FailedAssertion} if the buffer's zoom level is already at its * extreme in the given direction. */ bumpZoomLevel: function bumpZoomLevel(steps, fullZoom) { let { ZoomManager } = this; if (fullZoom === undefined) fullZoom = ZoomManager.useFullZoom; let values = ZoomManager.zoomValues; let cur = values.indexOf(ZoomManager.snap(this.zoomLevel / 100)); let i = Math.constrain(cur + steps, 0, values.length - 1); util.assert(i != cur || fullZoom != ZoomManager.useFullZoom); this.setZoom(Math.round(values[i] * 100), fullZoom); }, getAllFrames: deprecated("buffer.allFrames", "allFrames"), scrollTop: deprecated("buffer.scrollToPercent", function scrollTop() { return this.scrollToPercent(null, 0); }), scrollBottom: deprecated("buffer.scrollToPercent", function scrollBottom() { return this.scrollToPercent(null, 100); }), scrollStart: deprecated("buffer.scrollToPercent", function scrollStart() { return this.scrollToPercent(0, null); }), scrollEnd: deprecated("buffer.scrollToPercent", function scrollEnd() { return this.scrollToPercent(100, null); }), scrollColumns: deprecated("buffer.scrollHorizontal", function scrollColumns(cols) { return this.scrollHorizontal("columns", cols); }), scrollPages: deprecated("buffer.scrollHorizontal", function scrollPages(pages) { return this.scrollVertical("pages", pages); }), scrollTo: deprecated("Buffer.scrollTo", function scrollTo(x, y) { return this.win.scrollTo(x, y); }), textZoom: deprecated("buffer.zoomValue/buffer.fullZoom", function textZoom() { return this.contentViewer.markupDocumentViewer.textZoom * 100; }), }, { /** * The pattern used to search for a scrollable element when we have * no starting point. */ SCROLLABLE_SEARCH_SELECTOR: "html, body, div", PageInfo: Struct("PageInfo", "name", "title", "action") .localize("title"), pageInfo: {}, /** * Adds a new section to the page information output. * * @param {string} option The section's value in 'pageinfo'. * @param {string} title The heading for this section's * output. * @param {function} func The function to generate this * section's output. */ addPageInfoSection: function addPageInfoSection(option, title, func) { this.pageInfo[option] = Buffer.PageInfo(option, title, func); }, uriShorteners: [], /** * Adds a new URI shortener for documents matching the given filter. * * @param {string|function(URI, Document):boolean} filter A site filter * string or a function which accepts a URI and a document and * returns true if it can shorten the document's URI. * @param {function(URI, Document):URI} shortener Returns a shortened * URL for the given URI and document. */ addURIShortener: function addURIShortener(filter, shortener) { if (isString(filter)) filter = Group.compileFilter(filter); this.uriShorteners.push(function uriShortener(uri, doc) { if (filter(uri, doc)) return shortener(uri, doc); }); }, Scrollable: function Scrollable(elem) { if (elem instanceof Ci.nsIDOMElement) return elem; if (isinstance(elem, [Ci.nsIDOMWindow, Ci.nsIDOMDocument])) return { __proto__: elem.documentElement || elem.ownerDocument.documentElement, win: elem.defaultView || elem.ownerDocument.defaultView, get clientWidth() { return this.win.innerWidth; }, get clientHeight() { return this.win.innerHeight; }, get scrollWidth() { return this.win.scrollMaxX + this.win.innerWidth; }, get scrollHeight() { return this.win.scrollMaxY + this.win.innerHeight; }, get scrollLeftMax() { return this.win.scrollMaxX; }, get scrollRightMax() { return this.win.scrollMaxY; }, get scrollLeft() { return this.win.scrollX; }, set scrollLeft(val) { this.win.scrollTo(val, this.win.scrollY); }, get scrollTop() { return this.win.scrollY; }, set scrollTop(val) { this.win.scrollTo(this.win.scrollX, val); } }; return elem; }, get ZOOM_MIN() { return prefs.get("zoom.minPercent"); }, get ZOOM_MAX() { return prefs.get("zoom.maxPercent"); }, setZoom: deprecated("buffer.setZoom", function setZoom(...args) { return apply(overlay.activeModules.buffer, "setZoom", args); }), bumpZoomLevel: deprecated("buffer.bumpZoomLevel", function bumpZoomLevel(...args) { return apply(overlay.activeModules.buffer, "bumpZoomLevel", args); }), /** * Returns the currently selected word in *win*. If the selection is * null, it tries to guess the word that the caret is positioned in. * * @returns {string} */ currentWord: function currentWord(win, select) { let { Editor, options } = Buffer(win).modules; let selection = win.getSelection(); if (selection.rangeCount == 0) return ""; let range = selection.getRangeAt(0).cloneRange(); if (range.collapsed) { let re = options.get("iskeyword").regexp; Editor.extendRange(range, true, re, true); Editor.extendRange(range, false, re, true); } if (select) { selection.removeAllRanges(); selection.addRange(range); } return DOM.stringify(range); }, getDefaultNames: function getDefaultNames(node) { let url = node.href || node.src || node.documentURI; let currExt = url.replace(/^.*?(?:\.([a-z0-9]+))?$/i, "$1").toLowerCase(); let ext = ""; if (isinstance(node, [Ci.nsIDOMDocument, Ci.nsIDOMHTMLImageElement])) { let type = node.contentType || node.QueryInterface(Ci.nsIImageLoadingContent) .getRequest(0).mimeType; if (type === "text/plain") ext = "." + (currExt || "txt"); else try { ext = "." + services.mime.getPrimaryExtension(type, currExt); } catch (e) { ext = currExt ? "." + curExt : ""; } } else if (currExt) ext = "." + currExt; let re = ext ? RegExp("(\\." + currExt + ")?$", "i") : /$/; var names = []; if (node.title) names.push([node.title, _("buffer.save.pageName")]); if (node.alt) names.push([node.alt, _("buffer.save.altText")]); if (!isinstance(node, Ci.nsIDOMDocument) && node.textContent) names.push([node.textContent.trim(), _("buffer.save.linkText")]); names.push([decodeURIComponent(url.replace(/.*?([^\/]*)\/*$/, "$1")), _("buffer.save.filename")]); return names.filter(([leaf, title]) => leaf) .map(([leaf, title]) => [leaf.replace(config.OS.illegalCharacters, encodeURIComponent) .replace(re, ext), title]); }, findScrollableWindow: deprecated("buffer.findScrollableWindow", function findScrollableWindow() { return apply(overlay.activeModules, "findScrollableWindow", arguments); }), findScrollable: deprecated("buffer.findScrollable", function findScrollable() { return apply(overlay.activeModules, "findScrollable", arguments); }), isScrollable: function isScrollable(elem, dir, horizontal) { if (!DOM(elem).isScrollable(horizontal ? "horizontal" : "vertical")) return false; return this.canScroll(elem, dir, horizontal); }, canScroll: function canScroll(elem, dir, horizontal) { let pos = "scrollTop", size = "clientHeight", end = "scrollHeight", layoutSize = "offsetHeight", overflow = "overflowX", border1 = "borderTopWidth", border2 = "borderBottomWidth"; if (horizontal) pos = "scrollLeft", size = "clientWidth", end = "scrollWidth", layoutSize = "offsetWidth", overflow = "overflowX", border1 = "borderLeftWidth", border2 = "borderRightWidth"; if (dir < 0) return elem[pos] > 0; let max = pos + "Max"; if (max in elem) { if (elem[pos] < elem[max]) return true; if (dir > 0) return false; return elem[pos] > 0; } let style = DOM(elem).style; let borderSize = Math.round(parseFloat(style[border1]) + parseFloat(style[border2])); let realSize = elem[size]; // Stupid Gecko eccentricities. May fail for quirks mode documents. if (elem[size] + borderSize >= elem[end] || elem[size] == 0) // Stupid, fallible heuristic. return false; if (style[overflow] == "hidden") realSize += borderSize; return dir > 0 && elem[pos] + realSize < elem[end] || !dir && realSize < elem[end]; }, /** * Scroll the contents of the given element to the absolute *left* * and *top* pixel offsets. * * @param {Element} elem The element to scroll. * @param {number|null} left The left absolute pixel offset. If * null, to not alter the horizontal scroll offset. * @param {number|null} top The top absolute pixel offset. If * null, to not alter the vertical scroll offset. * @param {string} reason The reason for the scroll event. See * {@link marks.push}. @optional */ scrollTo: function scrollTo(elem, left, top, reason) { let doc = elem.ownerDocument || elem.document || elem; let { buffer, marks, options } = util.topWindow(doc.defaultView).dactyl.modules; if (~[elem, elem.document, elem.ownerDocument].indexOf(buffer.focusedFrame.document)) marks.push(reason); if (options["scrollsteps"] > 1) return this.smoothScrollTo(elem, left, top); elem = Buffer.Scrollable(elem); if (left != null) elem.scrollLeft = left; if (top != null) elem.scrollTop = top; }, /** * Like scrollTo, but scrolls more smoothly and does not update * marks. */ smoothScrollTo: new function () { let timers = new WeakMap; return function smoothScrollTo(node, x, y) { let { options } = overlay.activeModules; let time = options["scrolltime"]; let steps = options["scrollsteps"]; let elem = Buffer.Scrollable(node); if (timers.has(node)) timers.get(node).cancel(); if (x == null) x = elem.scrollLeft; if (y == null) y = elem.scrollTop; x = node.dactylScrollDestX = Math.min(x, elem.scrollWidth - elem.clientWidth); y = node.dactylScrollDestY = Math.min(y, elem.scrollHeight - elem.clientHeight); let [startX, startY] = [elem.scrollLeft, elem.scrollTop]; let n = 0; (function next() { if (n++ === steps) { elem.scrollLeft = x; elem.scrollTop = y; delete node.dactylScrollDestX; delete node.dactylScrollDestY; } else { elem.scrollLeft = startX + (x - startX) / steps * n; elem.scrollTop = startY + (y - startY) / steps * n; timers.set(node, util.timeout(next, time / steps)); } }).call(this); }; }, /** * Scrolls the currently given element horizontally. * * @param {Element} elem The element to scroll. * @param {string} unit The increment by which to scroll. * Possible values are: "columns", "pages" * @param {number} number The possibly fractional number of * increments to scroll. Positive values scroll to the right while * negative values scroll to the left. * @throws {FailedAssertion} if scrolling is not possible in the * given direction. */ scrollHorizontal: function scrollHorizontal(node, unit, number) { let fontSize = parseInt(DOM(node).style.fontSize); let elem = Buffer.Scrollable(node); let increment; if (unit == "columns") increment = fontSize; // Good enough, I suppose. else if (unit == "pages") increment = elem.clientWidth - fontSize; else throw Error(); util.assert(number < 0 ? elem.scrollLeft > 0 : elem.scrollLeft < elem.scrollWidth - elem.clientWidth); let left = node.dactylScrollDestX !== undefined ? node.dactylScrollDestX : elem.scrollLeft; node.dactylScrollDestX = undefined; Buffer.scrollTo(node, left + number * increment, null, "h-" + unit); }, /** * Scrolls the given element vertically. * * @param {Node} node The node to scroll. * @param {string} unit The increment by which to scroll. * Possible values are: "lines", "pages" * @param {number} number The possibly fractional number of * increments to scroll. Positive values scroll upward while * negative values scroll downward. * @throws {FailedAssertion} if scrolling is not possible in the * given direction. */ scrollVertical: function scrollVertical(node, unit, number) { let fontSize = parseInt(DOM(node).style.lineHeight); let elem = Buffer.Scrollable(node); let increment; if (unit == "lines") increment = fontSize; else if (unit == "pages") increment = elem.clientHeight - fontSize; else throw Error(); util.assert(number < 0 ? elem.scrollTop > 0 : elem.scrollTop < elem.scrollHeight - elem.clientHeight); let top = node.dactylScrollDestY !== undefined ? node.dactylScrollDestY : elem.scrollTop; node.dactylScrollDestY = undefined; Buffer.scrollTo(node, null, top + number * increment, "v-" + unit); }, /** * Scrolls the currently active element to the given horizontal and * vertical percentages. * * @param {Element} elem The element to scroll. * @param {number|null} horizontal The possibly fractional * percentage of the current viewport width to scroll to. If null, * do not scroll horizontally. * @param {number|null} vertical The possibly fractional percentage * of the current viewport height to scroll to. If null, do not * scroll vertically. */ scrollToPercent: function scrollToPercent(node, horizontal, vertical) { let elem = Buffer.Scrollable(node); Buffer.scrollTo(node, horizontal == null ? null : (elem.scrollWidth - elem.clientWidth) * (horizontal / 100), vertical == null ? null : (elem.scrollHeight - elem.clientHeight) * (vertical / 100)); }, /** * Scrolls the currently active element to the given horizontal and * vertical position. * * @param {Element} elem The element to scroll. * @param {number|null} horizontal The possibly fractional * line ordinal to scroll to. * @param {number|null} vertical The possibly fractional * column ordinal to scroll to. */ scrollToPosition: function scrollToPosition(elem, horizontal, vertical) { let style = DOM(elem.body || elem).style; Buffer.scrollTo(elem, horizontal == null ? null : horizontal == 0 ? 0 : this._exWidth(elem) * horizontal, vertical == null ? null : parseFloat(style.lineHeight) * vertical); }, /** * Returns the current scroll position as understood by * {@link #scrollToPosition}. * * @param {Element} elem The element to scroll. */ getScrollPosition: function getPosition(node) { let style = DOM(node.body || node).style; let elem = Buffer.Scrollable(node); return { x: elem.scrollLeft && elem.scrollLeft / this._exWidth(node), y: elem.scrollTop / parseFloat(style.lineHeight) }; }, _exWidth: function _exWidth(elem) { try { let div = DOM(["elem", { style: "width: 1ex !important; position: absolute !important; padding: 0 !important; display: block;" }], elem.ownerDocument).appendTo(elem.body || elem); try { return parseFloat(div.style.width); } finally { div.remove(); } } catch (e) { return parseFloat(DOM(elem).fontSize) / 1.618; } }, openUploadPrompt: function openUploadPrompt(elem) { let { io } = overlay.activeModules; io.CommandFileMode(_("buffer.prompt.uploadFile") + " ", { onSubmit: function onSubmit(path) { let file = io.File(path); util.assert(file.exists()); DOM(elem).val(file.path).change(); } }).open(elem.value); } }, { init: function init(dactyl, modules, window) { init.superapply(this, arguments); dactyl.commands["buffer.viewSource"] = event => { let elem = event.originalTarget; let obj = { url: elem.getAttribute("href"), line: Number(elem.getAttribute("line")) }; if (elem.hasAttribute("column")) obj.column = elem.getAttribute("column"); modules.buffer.viewSource(obj); }; }, commands: function initCommands(dactyl, modules, window) { let { buffer, commands, config, options } = modules; commands.add(["frameo[nly]"], "Show only the current frame's page", function () { dactyl.open(buffer.focusedFrame.location.href); }, { argCount: "0" }); commands.add(["ha[rdcopy]"], "Print current document", function (args) { let arg = args[0]; // FIXME: arg handling is a bit of a mess, check for filename dactyl.assert(!arg || arg[0] == ">", _("error.trailingCharacters")); let settings = services.printSettings.newPrintSettings; settings.printSilent = args.bang; if (arg) { settings.printToFile = true; settings.toFileName = io.File(arg.substr(1)).path; settings.outputFormat = settings.kOutputFormatPDF; dactyl.echomsg(_("print.toFile", arg.substr(1))); } else { dactyl.echomsg(_("print.sending")); } config.browser.contentWindow .QueryInterface(Ci.nsIInterfaceRequestor) .getInterface(Ci.nsIWebBrowserPrint).print(settings, null); dactyl.echomsg(_("print.sent")); }, { argCount: "?", bang: true, completer: function (context, args) { if (args.bang && /^>/.test(context.filter)) context.fork("file", 1, modules.completion, "file"); }, literal: 0 }); commands.add(["pa[geinfo]"], "Show various page information", function (args) { let arg = args[0]; let opt = options.get("pageinfo"); dactyl.assert(!arg || opt.validator(opt.parse(arg)), _("error.invalidArgument", arg)); buffer.showPageInfo(true, arg); }, { argCount: "?", completer: function (context) { modules.completion.optionValue(context, "pageinfo", "+", ""); context.title = ["Page Info"]; } }); commands.add(["pagest[yle]", "pas"], "Select the author style sheet to apply", function (args) { let arg = args[0] || ""; let titles = buffer.alternateStyleSheets.map(sheet => sheet.title); dactyl.assert(!arg || titles.indexOf(arg) >= 0, _("error.invalidArgument", arg)); if (options["usermode"]) options["usermode"] = false; window.stylesheetSwitchAll(buffer.focusedFrame, arg); }, { argCount: "?", completer: function (context) { modules.completion.alternateStyleSheet(context); }, literal: 0 }); commands.add(["re[load]"], "Reload the current web page", function (args) { modules.tabs.reload(config.browser.mCurrentTab, args.bang); }, { argCount: "0", bang: true }); // TODO: we're prompted if download.useDownloadDir isn't set and no arg specified - intentional? commands.add(["sav[eas]", "w[rite]"], "Save current document to disk", function (args) { let { commandline, io } = modules; let { doc, win } = buffer; let chosenData = null; let filename = args[0]; let command = commandline.command; if (filename) { if (filename[0] == "!") return buffer.fetchSourceExternally(buffer.focusedFrame.document) .then(([file, isTemp]) => { let output = io.system(filename.substr(1), file); if (isTemp) file.remove(false); commandline.command = command; commandline.commandOutput(["span", { highlight: "CmdOutput" }, output]); }); if (/^>>/.test(filename)) { let file = io.File(filename.replace(/^>>\s*/, "")); dactyl.assert(args.bang || file.exists() && file.isWritable(), _("io.notWriteable", JSON.stringify(file.path))); return buffer.fetchSourceExternally(buffer.focusedFrame.document) .then(([tmpFile, isTemp]) => { try { file.write(tmpFile, ">>"); } catch (e) { dactyl.echoerr(_("io.notWriteable", JSON.stringify(file.path))); } if (isTemp) tmpFile.remove(); }); } let file = io.File(filename); if (filename.substr(-1) === File.PATH_SEP || file.exists() && file.isDirectory()) file.append(Buffer.getDefaultNames(doc)[0][0]); dactyl.assert(args.bang || !file.exists(), _("io.exists")); chosenData = { file: file.file, uri: util.newURI(doc.location.href) }; } // if browser.download.useDownloadDir = false then the "Save As" // dialog is used with this as the default directory // TODO: if we're going to do this shouldn't it be done in setCWD or the value restored? prefs.set("browser.download.lastDir", io.cwd.path); try { var contentDisposition = win.QueryInterface(Ci.nsIInterfaceRequestor) .getInterface(Ci.nsIDOMWindowUtils) .getDocumentMetadata("content-disposition"); } catch (e) {} window.internalSave(doc.location.href, doc, null, contentDisposition, doc.contentType, false, null, chosenData, doc.referrer ? window.makeURI(doc.referrer) : null, doc, true); }, { argCount: "?", bang: true, completer: function (context) { let { buffer, completion } = modules; if (context.filter[0] == "!") return; if (/^>>/.test(context.filter)) context.advance(/^>>\s*/.exec(context.filter)[0].length); completion.savePage(context, buffer.doc); context.fork("file", 0, completion, "file"); }, literal: 0 }); commands.add(["st[op]"], "Stop loading the current web page", function () { buffer.stop(); }, { argCount: "0" }); commands.add(["vie[wsource]"], "View source code of current document", function (args) { buffer.viewSource(args[0], args.bang); }, { argCount: "?", bang: true, completer: function (context) { modules.completion.url(context, "bhf"); } }); commands.add(["zo[om]"], "Set zoom value of current web page", function (args) { let arg = args[0]; let level; if (!arg) level = 100; else if (/^\d+$/.test(arg)) level = parseInt(arg, 10); else if (/^[+-]\d+$/.test(arg)) level = Math.round(buffer.zoomLevel + parseInt(arg, 10)); else dactyl.assert(false, _("error.trailingCharacters")); buffer.setZoom(level, args.bang); }, { argCount: "?", bang: true }); }, completion: function initCompletion(dactyl, modules, window) { let { buffer, completion } = modules; completion.alternateStyleSheet = function alternateStylesheet(context) { context.title = ["Stylesheet", "Location"]; // unify split style sheets let styles = Ary.toObject(buffer.alternateStyleSheets .map(sheet => [sheet.title, []])); buffer.alternateStyleSheets.forEach(function (style) { styles[style.title].push(style.href || _("style.inline")); }); context.completions = Object.entries(styles) .map(([title, href]) => [title, href.join(", ")]); }; completion.savePage = function savePage(context, node) { context.fork("generated", context.filter.replace(/[^/]*$/, "").length, this, function (context) { context.generate = function () { this.incomplete = true; this.completions = Buffer.getDefaultNames(node); util.httpGet(node.href || node.src || node.documentURI, { method: "HEAD", callback: function callback(xhr) { context.incomplete = false; try { if (/filename="(.*?)"/.test(xhr.getResponseHeader("Content-Disposition"))) context.completions.push([decodeURIComponent(RegExp.$1), _("buffer.save.suggested")]); } finally { context.completions = context.completions.slice(); } }, notificationCallbacks: Class(XPCOM([Ci.nsIChannelEventSink, Ci.nsIInterfaceRequestor]), { getInterface: function getInterface(iid) { return this.QueryInterface(iid); }, asyncOnChannelRedirect: function (oldChannel, newChannel, flags, callback) { if (newChannel instanceof Ci.nsIHttpChannel) newChannel.requestMethod = "HEAD"; callback.onRedirectVerifyCallback(Cr.NS_OK); } })() }); }; }); }; }, events: function initEvents(dactyl, modules, window) { let { buffer, config, events } = modules; events.listen(config.browser, "scroll", buffer.bound._updateBufferPosition, false); }, mappings: function initMappings(dactyl, modules, window) { let { Editor, Events, buffer, editor, events, ex, mappings, modes, options, tabs } = modules; mappings.add([modes.NORMAL], ["y", ""], "Yank current location to the clipboard", function () { let { uri } = buffer; if (uri instanceof Ci.nsIURL && uri instanceof Ci.nsIMutable && uri.mutable) uri.query = uri.query.replace(/(?:^|&)utm_[^&]+/g, "") .replace(/^&/, ""); let url = options.get("yankshort").getKey(uri) && buffer.shortURL || uri.spec; dactyl.clipboardWrite(url, true); }); mappings.add([modes.NORMAL], ["", ""], "Increment last number in URL", function ({ count }) { buffer.incrementURL(Math.max(count, 1)); }, { count: true }); mappings.add([modes.NORMAL], ["", ""], "Decrement last number in URL", function ({ count }) { buffer.incrementURL(-Math.max(count, 1)); }, { count: true }); mappings.add([modes.NORMAL], ["gu", ""], "Go to parent directory", function ({ count }) { buffer.climbUrlPath(Math.max(count, 1)); }, { count: true }); mappings.add([modes.NORMAL], ["gU", ""], "Go to the root of the website", function () { buffer.climbUrlPath(-1); }); mappings.add([modes.COMMAND], [".", ""], "Repeat the last key event", function ({ count }) { if (mappings.repeat) { for (let i of util.interruptibleRange(0, Math.max(count, 1), 100)) mappings.repeat(); } }, { count: true }); mappings.add([modes.NORMAL], ["i", ""], "Start Caret mode", function () { modes.push(modes.CARET); }); mappings.add([modes.NORMAL], ["", ""], "Stop loading the current web page", function () { ex.stop(); }); // scrolling mappings.add([modes.NORMAL], ["j", "", "", ""], "Scroll document down", function ({ count }) { buffer.scrollVertical("lines", Math.max(count, 1)); }, { count: true }); mappings.add([modes.NORMAL], ["k", "", "", ""], "Scroll document up", function ({ count }) { buffer.scrollVertical("lines", -Math.max(count, 1)); }, { count: true }); mappings.add([modes.NORMAL], dactyl.has("mail") ? ["h", ""] : ["h", "", ""], "Scroll document to the left", function ({ count }) { buffer.scrollHorizontal("columns", -Math.max(count, 1)); }, { count: true }); mappings.add([modes.NORMAL], dactyl.has("mail") ? ["l", ""] : ["l", "", ""], "Scroll document to the right", function ({ count }) { buffer.scrollHorizontal("columns", Math.max(count, 1)); }, { count: true }); mappings.add([modes.NORMAL], ["0", "^", ""], "Scroll to the absolute left of the document", function () { buffer.scrollToPercent(0, null); }); mappings.add([modes.NORMAL], ["$", ""], "Scroll to the absolute right of the document", function () { buffer.scrollToPercent(100, null); }); mappings.add([modes.NORMAL], ["gg", "", ""], "Go to the top of the document", function ({ count }) { buffer.scrollToPercent(null, count != null ? count : 0, count != null ? 0 : -1); }, { count: true }); mappings.add([modes.NORMAL], ["G", "", ""], "Go to the end of the document", function ({ count }) { if (count) var elem = options.get("linenumbers") .getLine(buffer.focusedFrame.document, count); if (elem) elem.scrollIntoView(true); else if (count) buffer.scrollToPosition(null, count); else buffer.scrollToPercent(null, 100, 1); }, { count: true }); mappings.add([modes.NORMAL], ["%", ""], "Scroll to {count} percent of the document", function ({ count }) { dactyl.assert(count > 0 && count <= 100); buffer.scrollToPercent(null, count); }, { count: true }); mappings.add([modes.NORMAL], ["", ""], "Scroll window downwards in the buffer", function ({ count }) { buffer._scrollByScrollSize(count, true); }, { count: true }); mappings.add([modes.NORMAL], ["", ""], "Scroll window upwards in the buffer", function ({ count }) { buffer._scrollByScrollSize(count, false); }, { count: true }); mappings.add([modes.NORMAL], ["", "", "", ""], "Scroll up a full page", function ({ count }) { buffer.scrollVertical("pages", -Math.max(count, 1)); }, { count: true }); mappings.add([modes.NORMAL], [""], "Scroll down a full page", function ({ count }) { if (isinstance((services.focus.focusedWindow || buffer.win).document.activeElement, [Ci.nsIDOMHTMLInputElement, Ci.nsIDOMHTMLButtonElement, Ci.nsIDOMXULButtonElement])) return Events.PASS; buffer.scrollVertical("pages", Math.max(count, 1)); }, { count: true }); mappings.add([modes.NORMAL], ["", "", ""], "Scroll down a full page", function ({ count }) { buffer.scrollVertical("pages", Math.max(count, 1)); }, { count: true }); mappings.add([modes.NORMAL], ["]f", ""], "Focus next frame", function ({ count }) { buffer.shiftFrameFocus(Math.max(count, 1)); }, { count: true }); mappings.add([modes.NORMAL], ["[f", ""], "Focus previous frame", function ({ count }) { buffer.shiftFrameFocus(-Math.max(count, 1)); }, { count: true }); mappings.add([modes.NORMAL], ["["], "Jump to the previous element as defined by 'jumptags'", function ({ arg, count }) { buffer.findJump(arg, count, true); }, { arg: true, count: true }); mappings.add([modes.NORMAL], ["g]"], "Jump to the next off-screen element as defined by 'jumptags'", function ({ arg, count }) { buffer.findJump(arg, count, false, true); }, { arg: true, count: true }); mappings.add([modes.NORMAL], ["]"], "Jump to the next element as defined by 'jumptags'", function ({ arg, count }) { buffer.findJump(arg, count, false); }, { arg: true, count: true }); mappings.add([modes.NORMAL], ["{"], "Jump to the previous paragraph", function ({ count }) { buffer.findJump("p", count, true); }, { count: true }); mappings.add([modes.NORMAL], ["}"], "Jump to the next paragraph", function ({ count }) { buffer.findJump("p", count, false); }, { count: true }); mappings.add([modes.NORMAL], ["]]", ""], "Follow the link labeled 'next' or '>' if it exists", function ({ count }) { buffer.findLink("next", options["nextpattern"], (count || 1) - 1, true); }, { count: true }); mappings.add([modes.NORMAL], ["[[", ""], "Follow the link labeled 'prev', 'previous' or '<' if it exists", function ({ count }) { buffer.findLink("prev", options["previouspattern"], (count || 1) - 1, true); }, { count: true }); mappings.add([modes.NORMAL], ["gf", ""], "Toggle between rendered and source view", function () { buffer.viewSource(null, false); }); mappings.add([modes.NORMAL], ["gF", ""], "View source with an external editor", function () { buffer.viewSource(null, true); }); mappings.add([modes.NORMAL], ["gi", ""], "Focus last used input field", function ({ count }) { let elem = buffer.lastInputField; if (count >= 1 || !elem || !events.isContentNode(elem)) { let xpath = ["frame", "iframe", "input", "xul:textbox", "textarea[not(@disabled) and not(@readonly)]"]; let frames = buffer.allFrames(undefined, true); let elements = Array.from(frames) .flatMap(win => DOM.XPath(xpath, win.document)) .filter(elem => { if (isinstance(elem, [Ci.nsIDOMHTMLFrameElement, Ci.nsIDOMHTMLIFrameElement])) return Editor.getEditor(elem.contentWindow); elem = DOM(elem); if (elem[0].readOnly || elem[0].disabled || !DOM(elem).isEditable) return false; let style = elem.style; let rect = elem.rect; return elem.isVisible && (elem[0] instanceof Ci.nsIDOMXULTextBoxElement || style.MozUserFocus != "ignore") && rect.width && rect.height; }); dactyl.assert(elements.length > 0); elem = elements[Math.constrain(count, 1, elements.length) - 1]; } buffer.focusElement(elem); DOM(elem).scrollIntoView(); }, { count: true }); function url() { let url = dactyl.clipboardRead(); dactyl.assert(url, _("error.clipboardEmpty")); let proto = /^\s*([-\w]+):/.exec(url); if (proto && services.PROTOCOL + proto[1] in Cc && !RegExp(options["urlseparator"]).test(url)) return url.replace(/\s+/g, ""); return url; } mappings.add([modes.NORMAL], ["gP"], "Open (put) a URL based on the current clipboard contents in a new background buffer", function () { dactyl.open(url(), { from: "paste", where: dactyl.NEW_TAB, background: true }); }); mappings.add([modes.NORMAL], ["p", "", ""], "Open (put) a URL based on the current clipboard contents in the current buffer", function () { dactyl.open(url()); }); mappings.add([modes.NORMAL], ["P", ""], "Open (put) a URL based on the current clipboard contents in a new buffer", function () { dactyl.open(url(), { from: "paste", where: dactyl.NEW_TAB }); }); // reloading mappings.add([modes.NORMAL], ["r", ""], "Reload the current web page", function () { tabs.reload(tabs.getTab(), false); }); mappings.add([modes.NORMAL], ["R", ""], "Reload while skipping the cache", function () { tabs.reload(tabs.getTab(), true); }); // yanking mappings.add([modes.NORMAL], ["Y", ""], "Copy selected text or current word", function () { let sel = buffer.currentWord; dactyl.assert(sel); editor.setRegister(null, sel, true); }); // zooming mappings.add([modes.NORMAL], ["zi", "+", ""], "Enlarge text zoom of current web page", function ({ count }) { buffer.zoomIn(Math.max(count, 1), false); }, { count: true }); mappings.add([modes.NORMAL], ["zm", ""], "Enlarge text zoom of current web page by a larger amount", function ({ count }) { buffer.zoomIn(Math.max(count, 1) * 3, false); }, { count: true }); mappings.add([modes.NORMAL], ["zo", "-", ""], "Reduce text zoom of current web page", function ({ count }) { buffer.zoomOut(Math.max(count, 1), false); }, { count: true }); mappings.add([modes.NORMAL], ["zr", ""], "Reduce text zoom of current web page by a larger amount", function ({ count }) { buffer.zoomOut(Math.max(count, 1) * 3, false); }, { count: true }); mappings.add([modes.NORMAL], ["zz", ""], "Set text zoom value of current web page", function ({ count }) { buffer.setZoom(count > 1 ? count : 100, false); }, { count: true }); mappings.add([modes.NORMAL], ["ZI", "zI", ""], "Enlarge full zoom of current web page", function ({ count }) { buffer.zoomIn(Math.max(count, 1), true); }, { count: true }); mappings.add([modes.NORMAL], ["ZM", "zM", ""], "Enlarge full zoom of current web page by a larger amount", function ({ count }) { buffer.zoomIn(Math.max(count, 1) * 3, true); }, { count: true }); mappings.add([modes.NORMAL], ["ZO", "zO", ""], "Reduce full zoom of current web page", function ({ count }) { buffer.zoomOut(Math.max(count, 1), true); }, { count: true }); mappings.add([modes.NORMAL], ["ZR", "zR", ""], "Reduce full zoom of current web page by a larger amount", function ({ count }) { buffer.zoomOut(Math.max(count, 1) * 3, true); }, { count: true }); mappings.add([modes.NORMAL], ["zZ", ""], "Set full zoom value of current web page", function ({ count }) { buffer.setZoom(count > 1 ? count : 100, true); }, { count: true }); // page info mappings.add([modes.NORMAL], ["", ""], "Print the current file name", function () { buffer.showPageInfo(false); }); mappings.add([modes.NORMAL], ["g", ""], "Print file information", function () { buffer.showPageInfo(true); }); }, options: function initOptions(dactyl, modules, window) { let { Option, buffer, completion, options } = modules; options.add(["encoding", "enc"], "The current buffer's character encoding", "string", "UTF-8", { scope: Option.SCOPE_LOCAL, getter: function () { return buffer.docShell.QueryInterface(Ci.nsIDocCharset).charset; }, setter: function (val) { if (options["encoding"] == val) return val; // Stolen from browser.jar/content/browser/browser.js, more or less. Task.spawn(function* () { try { buffer.docShell.QueryInterface(Ci.nsIDocCharset).charset = val; yield window.PlacesUtils.setCharsetForURI(buffer.uri, val); buffer.docShell.reload(Ci.nsIWebNavigation.LOAD_FLAGS_CHARSET_CHANGE); } catch (e) { dactyl.reportError(e); } }); return null; }, completer: function (context) { completion.charset(context); } }); options.add(["iskeyword", "isk"], "Regular expression defining which characters constitute words", "string", '[^\\s.,!?:;/"\'^$%&?()[\\]{}<>#*+|=~_-]', { setter: function (value) { this.regexp = util.regexp(value); return value; }, validator: function (value) { return RegExp(value); } }); options.add(["jumptags", "jt"], "XPath or CSS selector strings of jumpable elements for extended hint modes", "stringmap", { "p": "p,table,ul,ol,blockquote", "h": "h1,h2,h3,h4,h5,h6" }, { keepQuotes: true, setter: function (vals) { for (let [k, v] of iter(vals)) vals[k] = update(new String(v), { matcher: DOM.compileMatcher(Option.splitList(v)) }); return vals; }, validator: function (value) { return DOM.validateMatcher.call(this, value) && Object.keys(value).every(v => v.length == 1); } }); options.add(["linenumbers", "ln"], "Patterns used to determine line numbers used by G", "sitemap", { // Make sure to update the docs when you change this. "view-source:*": 'body,[id^=line]', "code.google.com": '#nums [id^="nums_table"] a[href^="#"]', "github.com": '.line_numbers>*', "mxr.mozilla.org": 'a.l', "pastebin.com": '#code_frame>div>ol>li', "addons.mozilla.org": '.gutter>.line>a', "bugzilla.mozilla.org": ".bz_comment:not(.bz_first_comment):not(.ih_history)", "*": '/* Hgweb/Gitweb */ .completecodeline a.codeline, a.linenr' }, { getLine: function getLine(doc, line) { let uri = util.newURI(doc.documentURI); for (let filter of this.value) if (filter(uri, doc)) { if (/^func:/.test(filter.result)) var res = dactyl.userEval("(" + Option.dequote(filter.result.substr(5)) + ")")(doc, line); else res = iter.find(filter.matcher(doc), elem => ((elem.nodeValue || elem.textContent).trim() == line && DOM(elem).display != "none")) || iter.nth(filter.matcher(doc), identity, line - 1); if (res) break; } return res; }, keepQuotes: true, setter: function (vals) { for (let value of values(vals)) if (!/^func:/.test(value.result)) value.matcher = DOM.compileMatcher(Option.splitList(value.result)); return vals; }, validator: function validate(values) { return this.testValues(values, value => { if (/^func:/.test(value)) return callable(dactyl.userEval("(" + Option.dequote(value.substr(5)) + ")")); else return DOM.testMatcher(Option.dequote(value)); }); } }); options.add(["nextpattern"], "Patterns to use when guessing the next page in a document sequence", "regexplist", UTF8(/'^\s*Next Page\s*$','^\s*Next [>»]','\bnext\b',^>$,^(>>|»)$,^(>|»),(>|»)$,'\bmore\b'/.source), { regexpFlags: "i" }); options.add(["previouspattern"], "Patterns to use when guessing the previous page in a document sequence", "regexplist", UTF8(/'^\s*Prev(ious)? Page\s*$','[<«] Prev\s*$','\bprev(ious)?\b',^<$,^(<<|«)$,^(<|«),(<|«)$/.source), { regexpFlags: "i" }); options.add(["pageinfo", "pa"], "Define which sections are shown by the :pageinfo command", "charlist", "gesfm", { get values() { return values(Buffer.pageInfo).toObject(); }}); options.add(["scroll", "scr"], "Number of lines to scroll with and commands", "number", 0, { validator: function (value) { return value >= 0; } }); options.add(["showstatuslinks", "ssli"], "Where to show the destination of the link under the cursor", "string", "status", { values: { "": "Don't show link destinations", "status": "Show link destinations in the status line", "command": "Show link destinations in the command line" } }); options.add(["scrolltime", "sct"], "The time, in milliseconds, in which to smooth scroll to a new position", "number", 100); options.add(["scrollsteps", "scs"], "The number of steps in which to smooth scroll to a new position", "number", 5, { PREF: "general.smoothScroll", initValue: function () {}, getter: function getter(value) { return !prefs.get(this.PREF) ? 1 : value; }, setter: function setter(value) { prefs.set(this.PREF, value > 1); if (value > 1) return value; }, validator: function (value) { return value > 0; } }); options.add(["usermode", "um"], "Show current website without styling defined by the author", "boolean", false, { setter: function (value) { let { contentViewer } = buffer; if (contentViewer) return contentViewer.authorStyleDisabled = value; return false; }, getter: function () { let { contentViewer } = buffer; if (contentViewer) return contentViewer.authorStyleDisabled; return false; } }); options.add(["yankshort", "ys"], "Yank the canonical short URL of a web page where provided", "sitelist", ["youtube.com", "bugzilla.mozilla.org"]); } }); Buffer.addPageInfoSection("e", "Search Engines", function* (verbose) { let n = 1; let nEngines = 0; for (let { document: doc } of this.allFrames()) { let engines = DOM("link[href][rel=search][type='application/opensearchdescription+xml']", doc); nEngines += engines.length; if (verbose) for (let link of engines) yield [link.title || /*L*/ "Engine " + n++, ["a", { href: link.href, highlight: "URL", onclick: "if (event.button == 0) { window.external.AddSearchProvider(this.href); return false; }" }, link.href]]; } if (!verbose && nEngines) yield nEngines + /*L*/" engine" + (nEngines > 1 ? "s" : ""); }); Buffer.addPageInfoSection("f", "Feeds", function* (verbose) { const feedTypes = { "application/rss+xml": "RSS", "application/atom+xml": "Atom", "text/xml": "XML", "application/xml": "XML", "application/rdf+xml": "XML" }; function isValidFeed(data, principal, isFeed) { if (!data || !principal) return false; if (!isFeed) { var type = data.type && data.type.toLowerCase(); type = type.replace(/^\s+|\s*(?:;.*)?$/g, ""); isFeed = ["application/rss+xml", "application/atom+xml"].indexOf(type) >= 0 || // really slimy: general XML types with magic letters in the title type in feedTypes && /\brss\b/i.test(data.title); } if (isFeed) { try { services.security.checkLoadURIStrWithPrincipal(principal, data.href, services.security.DISALLOW_INHERIT_PRINCIPAL); } catch (e) { isFeed = false; } } if (type) data.type = type; return isFeed; } let nFeed = 0; for (let win of this.allFrames()) { let doc = win.document; for (let link of DOM("link[href][rel=feed], link[href][rel=alternate][type]", doc)) { let rel = link.rel.toLowerCase(); let feed = { title: link.title, href: link.href, type: link.type || "" }; if (isValidFeed(feed, doc.nodePrincipal, rel == "feed")) { nFeed++; let type = feedTypes[feed.type] || "RSS"; if (verbose) yield [feed.title, [template.highlightURL(feed.href, true), ["span", { class: "extra-info" }, " (" + type + ")"]]]; } } } if (!verbose && nFeed) yield nFeed + /*L*/" feed" + (nFeed > 1 ? "s" : ""); }); Buffer.addPageInfoSection("g", "General Info", function* (verbose) { let doc = this.focusedFrame.document; // get file size let { LoadContextInfo } = Cu.import("resource://gre/modules/LoadContextInfo.jsm", {}); let contextInfo = LoadContextInfo.fromLoadContext(sanitizer.getContext(doc), false); let storage = services.cache.diskCacheStorage(contextInfo, false); let pageSize = []; // [0] bytes; [1] kbytes storage.asyncOpenURI(util.createURI(doc.documentURI), "", Ci.nsICacheStorage.OPEN_READONLY, { onCacheEntryCheck: () => Ci.nsICacheEntryOpenCallback.ENTRY_WANTED, onCacheEntryAvailable: entry => { pageSize[0] = util.formatBytes(entry.dataSize, 0, false); pageSize[1] = util.formatBytes(entry.dataSize, 2, true); if (pageSize[1] == pageSize[0]) pageSize.length = 1; // don't output "xx Bytes" twice } }); let lastModVerbose = new Date(doc.lastModified).toLocaleString(); let lastMod = new Date(doc.lastModified).toLocaleFormat("%x %X"); if (lastModVerbose == "Invalid Date" || new Date(doc.lastModified).getFullYear() == 1970) lastModVerbose = lastMod = null; if (!verbose) { if (pageSize[0]) yield (pageSize[1] || pageSize[0]) + /*L*/" bytes"; yield lastMod; return; } yield ["Title", doc.title]; yield ["URL", template.highlightURL(doc.location.href, true)]; let { shortURL } = this; if (shortURL) yield ["Short URL", template.highlightURL(shortURL, true)]; let ref = "referrer" in doc && doc.referrer; if (ref) yield ["Referrer", template.highlightURL(ref, true)]; if (pageSize[0]) yield ["File Size", pageSize[1] ? pageSize[1] + " (" + pageSize[0] + ")" : pageSize[0]]; yield ["Mime-Type", doc.contentType]; yield ["Encoding", doc.characterSet]; yield ["Compatibility", doc.compatMode == "BackCompat" ? "Quirks Mode" : "Full/Almost Standards Mode"]; if (lastModVerbose) yield ["Last Modified", lastModVerbose]; }); Buffer.addPageInfoSection("m", "Meta Tags", function (verbose) { if (!verbose) return []; // get meta tag data, sort and put into pageMeta[] let metaNodes = this.focusedFrame.document.getElementsByTagName("meta"); return Array.map(metaNodes, node => [(node.name || node.httpEquiv), template.highlightURL(node.content)]) .sort((a, b) => util.compareIgnoreCase(a[0], b[0])); }); Buffer.addPageInfoSection("s", "Security", function* (verbose) { let { statusline } = this.modules; let identity = this.topWindow.gIdentityHandler; if (!verbose || !identity) return; // For now // Modified from Firefox function location(data) { return Ary.compact([data.city, data.state, data.country]) .join(", "); } switch (statusline.security) { case "secure": case "extended": var data = identity.getIdentityData(); yield ["Host", identity.getEffectiveHost()]; if (statusline.security === "extended") yield ["Owner", data.subjectOrg]; else yield ["Owner", _("pageinfo.s.ownerUnverified", data.subjectOrg)]; if (location(data).length) yield ["Location", location(data)]; yield ["Verified by", data.caOrg]; let { host, port } = config.haveGecko("43") ? identity._uri : identity._lastUri; if (port == -1) port = 443; if (identity._overrideService.hasMatchingOverride(host, port, data.cert, {}, {})) yield ["User exception", /*L*/"true"]; break; } }); // catch(e){ if (!e.stack) e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); } endModule(); // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/cache.jsm000066400000000000000000000223601264147376100205670ustar00rootroot00000000000000// Copyright (c) 2011-2014 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; defineModule("cache", { exports: ["Cache", "cache"], require: ["config", "services", "util"] }); lazyRequire("overlay", ["overlay"]); lazyRequire("storage", ["File", "storage"]); var Cache = Module("Cache", XPCOM(Ci.nsIRequestObserver), { init: function init() { this.queue = []; this.storage = storage.newMap("cache", { store: true }); this.providers = {}; this.globalProviders = this.providers; this.providing = new RealSet; this.localProviders = new RealSet; if (JSMLoader.cacheFlush) this.flush(); update(services["dactyl:"].providers, { "cache": (uri, path) => { let contentType = "text/plain"; try { contentType = services.mime.getTypeFromURI(uri); } catch (e) {} if (this.storage.has(path) || !this.cacheReader || !this.cacheReader.hasEntry(path)) return [contentType, this.force(path)]; let channel = services.StreamChannel(uri); try { channel.contentStream = this.cacheReader.getInputStream(path); } catch (e if e.result = Cr.NS_ERROR_FILE_CORRUPTED) { this.flushDiskCache(); throw e; } channel.contentType = contentType; channel.contentCharset = "UTF-8"; return channel; } }); }, Local: function Local(dactyl, modules, window) { return { init: function init() { delete this.instance; this.providers = {}; }, isLocal: true }; }, parse: function parse(str) { if ('{['.includes(str[0])) return JSON.parse(str); return str; }, stringify: function stringify(obj) { if (isString(obj)) return obj; return JSON.stringify(obj); }, compression: 9, cacheFile: Class.Memoize(function () { let dir = File(services.directory.get("ProfD", Ci.nsIFile)) .child("dactyl"); if (!dir.exists()) dir.create(dir.DIRECTORY_TYPE, 0o777); return dir.child("cache.zip"); }), get cacheReader() { if (!this._cacheReader && this.cacheFile.exists() && !this.inQueue) try { this._cacheReader = services.ZipReader(this.cacheFile.file); } catch (e if e.result == Cr.NS_ERROR_FILE_CORRUPTED) { util.reportError(e); this.flushDiskCache(); } return this._cacheReader; }, get inQueue() { return this._cacheWriter && this._cacheWriter.inQueue; }, getCacheWriter: function () { if (!this._cacheWriter) try { let mode = File.MODE_RDWR; if (!this.cacheFile.exists()) mode |= File.MODE_CREATE; cache._cacheWriter = services.ZipWriter(this.cacheFile.file, mode); } catch (e if e.result == Cr.NS_ERROR_FILE_CORRUPTED) { util.reportError(e); this.cacheFile.remove(false); mode |= File.MODE_CREATE; cache._cacheWriter = services.ZipWriter(this.cacheFile.file, mode); } return this._cacheWriter; }, closeReader: function closeReader() { if (cache._cacheReader) { this.cacheReader.close(); cache._cacheReader = null; } }, closeWriter: util.wrapCallback(function closeWriter() { this.closeReader(); if (this._cacheWriter) { this._cacheWriter.close(); cache._cacheWriter = null; // ZipWriter bug. if (this.cacheFile.fileSize <= 22) this.cacheFile.remove(false); } }), flush: function flush(filter) { if (filter) { this.storage.keys().filter(filter) .forEach(bind("remove", this.storage)); } else { this.storage.clear(); this.flushDiskCache(); } }, flushDiskCache: function flushDiskCache() { if (this.cacheFile.exists()) { this.closeWriter(); this.flushJAR(this.cacheFile); this.cacheFile.remove(false); } }, flushAll: function flushAll(file) { this.flushStartup(); this.flush(); }, flushEntry: function flushEntry(name, time) { if (this.cacheReader && this.cacheReader.hasEntry(name)) { if (time && this.cacheReader.getEntry(name).lastModifiedTime / 1000 >= time) return; this.queue.push([null, name]); cache.processQueue(); } this.storage.remove(name); }, flushJAR: function flushJAR(file) { services.observer.notifyObservers(File(file).file, "flush-cache-entry", ""); }, flushStartup: function flushStartup() { services.observer.notifyObservers(null, "startupcache-invalidate", ""); }, force: function force(name, localOnly) { if (this.storage.has(name)) return this.storage.get(name); util.waitFor(() => !this.inQueue); if (this.cacheReader && this.cacheReader.hasEntry(name)) { try { return this.parse(File.readStream( this.cacheReader.getInputStream(name))); } catch (e if e.result == Cr.NS_ERROR_FILE_CORRUPTED) { this.flushDiskCache(); } } if (this.localProviders.has(name) && !this.isLocal) { for (let { cache } of overlay.modules) if (cache._has(name)) return cache.force(name, true); } if (hasOwnProp(this.providers, name)) { util.assert(!this.providing.add(name), "Already generating cache for " + name, false); let [func, long] = this.providers[name]; try { var value = func.call(this, name); } finally { this.providing.delete(name); } if (!long) this.storage.set(name, value); else { cache.queue.push([Date.now(), name, value]); cache.processQueue(); } return value; } if (this.isLocal && !localOnly) return cache.force(name); }, get: function get(name, callback, long) { if (this.storage.has(name)) return this.storage.get(name); if (callback && !(hasOwnProp(this.providers, name) || this.localProviders.has(name))) this.register(name, callback, long); var result = this.force(name); util.assert(result !== undefined, "No such cache key", false); return result; }, _has: function _has(name) { return hasOwnProp(this.providers, name) || this.storage.has(name); }, has: function has(name) { return [this.globalProviders, this.localProviders] .some(obj => isinstance(obj, ["Set"]) ? obj.has(name) : hasOwnProp(obj, name)); }, register: function register(name, callback, long) { if (this.isLocal) this.localProviders.add(name); this.providers[name] = [callback, long]; }, processQueue: function processQueue() { this.closeReader(); this.closeWriter(); if (this.queue.length && !this.inQueue) { // removeEntry does not work properly with queues. let removed = 0; for (let entry of this.queue) if (this.getCacheWriter().hasEntry(entry)) { this.getCacheWriter().removeEntry(entry, false); removed++; } if (removed) { this.closeWriter(); util.flushCache(this.cacheFile); } this.queue.splice(0).forEach(function ([time, entry, value]) { if (time && value != null) { let stream = services.CharsetConv("UTF-8") .convertToInputStream(this.stringify(value)); this.getCacheWriter().addEntryStream(entry, time * 1000, this.compression, stream, true); } }, this); if (this._cacheWriter) this.getCacheWriter().processQueue(this, null); } }, onStopRequest: function onStopRequest() { this.processQueue(); } }); endModule(); // catch(e){ if (typeof e === "string") e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); } // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/commands.jsm000066400000000000000000002234351264147376100213330ustar00rootroot00000000000000// Copyright (c) 2006-2008 by Martin Stubenschrott // Copyright (c) 2007-2011 by Doug Kearns // Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; try { defineModule("commands", { exports: ["ArgType", "Command", "Commands", "CommandOption", "Ex", "commands"], require: ["contexts", "messages", "util"] }); lazyRequire("help", ["help"]); lazyRequire("options", ["Option"]); lazyRequire("template", ["template"]); /** * A structure representing the options available for a command. * * Do NOT create instances of this class yourself, use the helper method * {@see Commands#add} instead * * @property {[string]} names An array of option names. The first name * is the canonical option name. * @property {number} type The option's value type. This is one of: * (@link CommandOption.NOARG), * (@link CommandOption.STRING), * (@link CommandOption.STRINGMAP), * (@link CommandOption.BOOL), * (@link CommandOption.INT), * (@link CommandOption.FLOAT), * (@link CommandOption.LIST), * (@link CommandOption.ANY) * @property {function} validator A validator function * @property {function (CompletionContext, object)} completer A list of * completions, or a completion function which will be passed a * {@link CompletionContext} and an object like that returned by * {@link commands.parseArgs} with the following additional keys: * completeOpt - The name of the option currently being completed. * @property {boolean} multiple Whether this option can be specified multiple times * @property {string} description A description of the option * @property {object} default The option's default value */ var CommandOption = Struct("names", "type", "validator", "completer", "multiple", "description", "default"); CommandOption.defaultValue("description", () => ""); CommandOption.defaultValue("type", () => CommandOption.NOARG); CommandOption.defaultValue("multiple", () => false); var ArgType = Struct("description", "parse"); update(CommandOption, { /** * @property {object} The option argument is unspecified. Any argument * is accepted and caller is responsible for parsing the return * value. * @final */ ANY: 0, /** * @property {object} The option doesn't accept an argument. * @final */ NOARG: ArgType("no arg", arg => !arg || null), /** * @property {object} The option accepts a boolean argument. * @final */ BOOL: ArgType("boolean", function parseBoolArg(val) { return Commands.parseBool(val); }), /** * @property {object} The option accepts a string argument. * @final */ STRING: ArgType("string", val => val), /** * @property {object} The option accepts a stringmap argument. * @final */ STRINGMAP: ArgType("stringmap", (val, quoted) => Option.parse.stringmap(quoted)), /** * @property {object} The option accepts an integer argument. * @final */ INT: ArgType("int", function parseIntArg(val) { return parseInt(val); }), /** * @property {object} The option accepts a float argument. * @final */ FLOAT: ArgType("float", function parseFloatArg(val) { return parseFloat(val); }), /** * @property {object} The option accepts a string list argument. * E.g. "foo,bar" * @final */ LIST: ArgType("list", function parseListArg(arg, quoted) { return Option.splitList(quoted); }) }); /** * A class representing Ex commands. Instances are created by * the {@link Commands} class. * * @param {[string]} specs The names by which this command can be invoked. * These are specified in the form "com[mand]" where "com" is a unique * command name prefix. * @param {string} description A short one line description of the command. * @param {function} action The action invoked by this command when executed. * @param {Object} extra An optional extra configuration hash. The following * properties are supported. * always - see {@link Command#always} * argCount - see {@link Command#argCount} * bang - see {@link Command#bang} * completer - see {@link Command#completer} * count - see {@link Command#count} * domains - see {@link Command#domains} * heredoc - see {@link Command#heredoc} * literal - see {@link Command#literal} * options - see {@link Command#options} * privateData - see {@link Command#privateData} * serialize - see {@link Command#serialize} * subCommand - see {@link Command#subCommand} * @optional * @private */ var Command = Class("Command", { init: function init(specs, description, action, extra) { specs = Array.concat(specs); // XXX this.specs = specs; this.description = description; this.action = action; if (extra.options) this._options = extra.options; delete extra.options; if (extra) this.update(extra); }, get toStringParams() { return [this.name, this.hive.name]; }, get identifier() { return this.hive.prefix + this.name; }, get helpTag() { return ":" + this.name; }, get lastCommand() { return this._lastCommand || this.modules.commandline.command; }, set lastCommand(val) { this._lastCommand = val; }, /** * Execute this command. * * @param {Args} args The Args object passed to {@link #action}. * @param {Object} modifiers Any modifiers to be passed to {@link #action}. */ execute: function execute(args, modifiers={}) { const { dactyl } = this.modules; let context = args.context; if (this.deprecated) this.warn(context, "deprecated", _("warn.deprecated", ":" + this.name, this.deprecated)); if (args.count != null && !this.count) throw FailedAssertion(_("command.noCount")); if (args.bang && !this.bang) throw FailedAssertion(_("command.noBang")); args.doc = this.hive.group.lastDocument; return !dactyl.trapErrors(function exec() { let extra = this.hive.argsExtra(args); for (let k of properties(extra)) if (!(k in args)) Object.defineProperty(args, k, Object.getOwnPropertyDescriptor(extra, k)); if (this.always) this.always(args, modifiers); if (!context || !context.noExecute) this.action(args, modifiers); }, this); }, /** * Returns whether this command may be invoked via *name*. * * @param {string} name The candidate name. * @returns {boolean} */ hasName: function hasName(name) { return Command.hasName(this.parsedSpecs, name); }, /** * A helper function to parse an argument string. * * @param {string} args The argument string to parse. * @param {CompletionContext} complete A completion context. * Non-null when the arguments are being parsed for completion * purposes. * @param {Object} extra Extra keys to be spliced into the * returned Args object. * @returns {Args} * @see Commands#parseArgs */ parseArgs: function parseArgs(args, complete, extra) { return this.modules.commands.parseArgs(args, { __proto__: this, complete: complete, extra: extra }); }, complained: Class.Memoize(() => new RealSet), /** * @property {[string]} All of this command's name specs. e.g., "com[mand]" */ specs: null, parsedSpecs: Class.Memoize(function () { return Command.parseSpecs(this.specs); }), /** @property {[string]} All of this command's short names, e.g., "com" */ shortNames: Class.Memoize(function () { return Ary.compact(this.parsedSpecs.map(n => n[1])); }), /** * @property {[string]} All of this command's long names, e.g., "command" */ longNames: Class.Memoize(function () { return this.parsedSpecs.map(n => n[0]); }), /** @property {string} The command's canonical name. */ name: Class.Memoize(function () { return this.longNames[0]; }), /** @property {[string]} All of this command's long and short names. */ names: Class.Memoize(function () { return this.parsedSpecs.flatMap(); }), /** @property {string} This command's description, as shown in :listcommands */ description: Messages.Localized(""), /** @property {string|null} If set, the deprecation message for this command. */ deprecated: Messages.Localized(null), /** * @property {function (Args)} The function called to execute this command. */ action: null, /** * @property {function (Args)} A function which is called when this * command is encountered, even if we are ignoring commands. Used to * implement control structures. */ always: null, /** * @property {string} This command's argument count spec. * @see Commands#parseArguments */ argCount: 0, /** * @property {function (CompletionContext, Args)} This command's completer. * @see CompletionContext */ completer: null, /** @property {boolean} Whether this command accepts a here document. */ hereDoc: false, /** * @property {boolean} Whether this command may be called with a bang, * e.g., :com! */ bang: false, /** * @property {boolean} Whether this command may be called with a count, * e.g., :12bdel */ count: false, /** * @property {function(args)} A function which should return a list * of domains referenced in the given args. Used in determining * whether to purge the command from history when clearing * private data. */ domains: function (args) { return []; }, /** * @property {boolean} At what index this command's literal arguments * begin. For instance, with a value of 2, all arguments starting with * the third are parsed as a single string, with all quoting characters * passed literally. This is especially useful for commands which take * key mappings or Ex command lines as arguments. */ literal: null, /** * @property {Array} The options this command takes. * @see Commands@parseArguments */ options: Class.Memoize(function () { return this._options.map(function (opt) { let option = CommandOption.fromArray(opt); option.localeName = ["command", this.name, option.names[0]]; return option; }, this); }), _options: [], optionMap: Class.Memoize(function () { return Ary.toObject( Array.from(this.options) .flatMap(opt => opt.names.map(name => [name, opt]))); }), newArgs: function newArgs(base) { let res = []; update(res, base); res.__proto__ = this.argsPrototype; return res; }, argsPrototype: Class.Memoize(function argsPrototype() { let res = update([], { command: this, explicitOpts: Class.Memoize(() => ({})), has: function AP_has(opt) { return hasOwnProp(this.explicitOpts, opt) || typeof opt === "number" && hasOwnProp(this, opt); }, get literalArg() { let { literal } = this.command; return literal != null && this[literal] || ""; }, // TODO: string: Class.Memoize(function () { ... }), verify: function verify() { if (this.command.argCount) { util.assert((this.length > 0 || !/^[1+]$/.test(this.command.argCount)) && (this.literal == null || !/[1+]/.test(this.command.argCount) || /\S/.test(this.literalArg || "")), _("error.argumentRequired")); util.assert((this.length == 0 || this.command.argCount !== "0") && (this.length <= 1 || !/^[01?]$/.test(this.command.argCount)), _("error.trailingCharacters")); } } }); this.options.forEach(function (opt) { if (opt.default !== undefined) { let prop = Object.getOwnPropertyDescriptor(opt, "default") || { configurable: true, enumerable: true, get: function () { return opt.default; } }; if (prop.get && !prop.set) prop.set = function (val) { Class.replaceProperty(this, opt.names[0], val); }; Object.defineProperty(res, opt.names[0], prop); } }); return res; }), /** * @property {boolean|function(args)} When true, invocations of this * command may contain private data which should be purged from * saved histories when clearing private data. If a function, it * should return true if an invocation with the given args * contains private data */ privateData: true, /** * @property {function} Should return an array of *Object*s suitable to be * passed to {@link Commands#commandToString}, one for each past * invocation which should be restored on subsequent @dactyl startups. */ serialize: null, serialGroup: 50, /** * @property {number} If this command takes another ex command as an * argument, the index of that argument. Used in determining whether to * purge the command from history when clearing private data. */ subCommand: null, /** * @property {boolean} Specifies whether this is a user command. User * commands may be created by plugins, or directly by users, and, * unlike basic commands, may be overwritten. Users and plugin authors * should create only user commands. */ user: false, /** * @property {string} For commands defined via :command, contains the Ex * command line to be executed upon invocation. */ replacementText: null, /** * Warns of a misuse of this command once per warning type per file. * * @param {object} context The calling context. * @param {string} type The type of warning. * @param {string} warning The warning message. */ warn: function warn(context, type, message) { let loc = !context ? "" : [context.file, context.line, " "].join(":"); let key = type + ":" + (context ? context.file : "[Command Line]"); if (!this.complained.add(key)) this.modules.dactyl.warn(loc + message); } }, { hasName: function hasName(specs, name) { return specs.some(([long, short]) => name.indexOf(short) == 0 && long.indexOf(name) == 0); }, // TODO: do we really need more than longNames as a convenience anyway? /** * Converts command name abbreviation specs of the form * 'shortname[optional-tail]' to short and long versions: * ["abc[def]", "ghijkl"] -> [["abcdef", "abc"], ["ghijlk"]] * * @param {Array} specs An array of command name specs to parse. * @returns {Array} */ parseSpecs: function parseSpecs(specs) { return specs.map(spec => { let [, head, tail] = /([^[]+)(?:\[(.*)])?/.exec(spec); return tail ? [head + tail, head] : [head]; }); } }); // Prototype. var Ex = Module("Ex", { Local(dactyl, modules, window) { return { init() {}, get commands() { return modules.commands; }, get context() { return modules.contexts.context; } }; }, commands: null, init() { let proxy = new Proxy(this, { get(target, prop, receiver) { if (prop === "isProxy") return [true, receiver === proxy].join(","); if (prop in target || receiver === proxy) return target[prop]; return function (...args) { return this._run(prop)(...args); }; }, }); return proxy; }, _args(cmd, args) { args = Array.slice(args); let res = cmd.newArgs({ context: this.context }); if (isObject(args[0])) for (let [k, v] of Object.entries(args.shift())) if (k == "!") res.bang = v; else if (k == "#") res.count = v; else { let opt = cmd.optionMap["-" + k]; let val = opt.type && opt.type.parse(v); util.assert(val != null && (typeof val !== "number" || !isNaN(val)), _("option.noSuch", k)); Class.replaceProperty(res, opt.names[0], val); res.explicitOpts[opt.names[0]] = val; } for (let [i, val] of args.entries()) res[i] = String(val); return res; }, _complete(cmd) { return (context, func, obj, args) => { args = this._args(cmd, args); args.completeArg = args.length - 1; if (cmd.completer && args.length) return cmd.completer(context, args); }; }, _run(name) { const self = this; let cmd = this.commands.get(name); util.assert(cmd, _("command.noSuch")); return update(function exCommand(options) { let args = self._args(cmd, arguments); args.verify(); return cmd.execute(args); }, { dactylCompleter: self._complete(cmd) }); }, }); var CommandHive = Class("CommandHive", Contexts.Hive, { init: function init(group) { init.supercall(this, group); this._map = {}; this._list = []; this._specs = []; }, /** * Caches this command hive. */ cache: function cache() { let { cache } = this.modules; this.cached = true; let cached = cache.get(this.cacheKey, () => { this.cached = false; this.modules.moduleManager.initDependencies("commands"); let map = {}; for (let [name, cmd] of iter(this._map)) if (cmd.sourceModule) map[name] = { sourceModule: cmd.sourceModule, isPlaceholder: true }; let specs = []; for (let cmd of this._list) for (let spec of cmd.parsedSpecs) specs.push(spec.concat(cmd.name)); return { map: map, specs: specs }; }); cached = cache.get(this.cacheKey); if (this.cached) { this._specs = cached.specs; for (let [k, v] of iter(cached.map)) this._map[k] = v; } }, get cacheKey() { return "commands/hives/" + this.name + ".json"; }, /** @property {Iterator(Command)} @private */ "@@iterator": function __iterator__() { if (this.cached) this.modules.initDependencies("commands"); this.cached = false; return this._list.sort((a, b) => String.localeCompare(a.name, b.name)) .values(); }, /** @property {string} The last executed Ex command line. */ repeat: null, /** * Adds a new command to the builtin hive. Accessible only to core dactyl * code. Plugins should use group.commands.add instead. * * @param {[string]} specs The names by which this command can be invoked. * The first name specified is the command's canonical name. * @param {string} description A description of the command. * @param {function} action The action invoked by this command. * @param {Object} extra An optional extra configuration hash. * @optional * @param {boolean} replace Replace an existing command of the same name. * @optional */ add: function add(specs, description, action, extra={}, replace=false) { const { commands, contexts } = this.modules; if (!extra.definedAt) extra.definedAt = contexts.getCaller(Components.stack.caller); if (!extra.sourceModule) extra.sourceModule = commands.currentDependency; extra.hive = this; extra.parsedSpecs = Command.parseSpecs(specs); let names = extra.parsedSpecs.flatMap(); let name = names[0]; if (this.name != "builtin") { util.assert(!names.some(name => name in commands.builtin._map), _("command.cantReplace", name)); util.assert(replace || names.every(name => !(name in this._map)), _("command.wontReplace", name)); } for (let name of names) { if (false) // For some reason, the `this` object of the getter gets // mutilated if we do this in recent Firefox versions. // Just rely on the proxy for now. Object.defineProperty(ex, name, { configurable: true, enumerable: true, get() { return this._run(name); }, }); if (name in this._map && !this._map[name].isPlaceholder) this.remove(name); } let closure = () => this._map[name]; memoize(this._map, name, () => commands.Command(specs, description, action, extra)); if (!extra.hidden) memoize(this._list, this._list.length, closure); for (let alias of names.slice(1)) memoize(this._map, alias, closure); return name; }, _add: function _add(names, description, action, extra={}, replace=false) { const { contexts } = this.modules; extra.definedAt = contexts.getCaller(Components.stack.caller.caller); return apply(this, "add", arguments); }, /** * Clear all commands. * @returns {Command} */ clear: function clear() { util.assert(this.group.modifiable, _("command.cantDelete")); this._map = {}; this._list = []; }, /** * Returns the command with matching *name*. * * @param {string} name The name of the command to return. This can be * any of the command's names. * @param {boolean} full If true, only return a command if one of * its names matches *name* exactly. * @returns {Command} */ get: function get(name, full) { let cmd = this._map[name] || !full && this._list.find(cmd => cmd.hasName(name)) || null; if (!cmd && full) { // Hrm. This is wrong. -Kris let name = this._specs.find(spec => Command.hasName(spec, name)); return name && this.get(name); } if (cmd && cmd.isPlaceholder) { this.modules.moduleManager.initDependencies("commands", [cmd.sourceModule]); cmd = this._map[name]; } return cmd; }, /** * Remove the user-defined command with matching *name*. * * @param {string} name The name of the command to remove. This can be * any of the command's names. */ remove: function remove(name) { util.assert(this.group.modifiable, _("command.cantDelete")); let cmd = this.get(name); this._list = this._list.filter(c => c !== cmd); for (let name of cmd.names) delete this._map[name]; } }); /** * @instance commands */ var Commands = Module("commands", { lazyInit: true, lazyDepends: true, Local: function Local(dactyl, modules, window) { let { contexts } = modules; return { init: function init() { this.Command = Class("Command", Command, { modules: modules }); update(this, { hives: contexts.Hives("commands", Class("CommandHive", CommandHive, { modules: modules })), user: contexts.hives.commands.user, builtin: contexts.hives.commands.builtin }); }, reallyInit: function reallyInit() { if (false) this.builtin.cache(); else this.modules.moduleManager.initDependencies("commands"); }, get context() { return contexts.context; }, get readHeredoc() { return modules.io.readHeredoc; }, get allHives() { return contexts.allGroups.commands; }, get userHives() { return this.allHives.filter(h => h !== this.builtin); }, /** * Executes an Ex command script. * * @param {string} string A string containing the commands to execute. * @param {object} tokens An optional object containing tokens to be * interpolated into the command string. * @param {object} args Optional arguments object to be passed to * command actions. * @param {object} context An object containing information about * the file that is being or has been sourced to obtain the * command string. */ execute: function execute(string, tokens, silent, args, context) { contexts.withContext(context || this.context || { file: "[Command Line]", line: 1 }, function (context) { modules.io.withSavedValues(["readHeredoc"], function () { this.readHeredoc = function readHeredoc(end) { let res = []; contexts.context.line++; while (++i < lines.length) { if (lines[i] === end) return res.join("\n"); res.push(lines[i]); } util.assert(false, _("command.eof", end)); }; args = update({}, args || {}); if (tokens && !callable(string)) string = util.compileMacro(string, true); if (callable(string)) string = string(tokens || {}); let lines = string.split(/\r\n|[\r\n]/); let startLine = context.line; for (var i = 0; i < lines.length && !context.finished; i++) { // Deal with editors from Silly OSs. let line = lines[i].replace(/\r$/, ""); context.line = startLine + i; // Process escaped new lines while (i < lines.length && /^\s*\\/.test(lines[i + 1])) line += "\n" + lines[++i].replace(/^\s*\\/, ""); try { dactyl.execute(line, args); } catch (e) { if (!silent) { e.message = context.file + ":" + context.line + ": " + e.message; dactyl.reportError(e, true); } } } }); }); }, /** * Lists all user-defined commands matching *filter* and optionally * *hives*. * * @param {string} filter Limits the list to those commands with a name * matching this anchored substring. * @param {[Hive]} hives List of hives. * @optional */ list: function list(filter, hives) { const { commandline, completion } = this.modules; function completerToString(completer) { if (completer) { for (let [key, val] of Object.entries(config.completers)) if (completion.bound(val) === completer) return key; return "custom"; } return ""; } // TODO: allow matching of aliases? function cmds(hive) { return hive._list.filter(cmd => cmd.name.startsWith(filter || "")); } hives = (hives || this.userHives).map(h => [h, cmds(h)]) .filter(([h, c]) => c.length); let list = ["table", {}, ["tr", { highlight: "Title" }, ["td"], ["td", { style: "padding-right: 1em;" }], ["td", { style: "padding-right: 1ex;" }, _("title.Name")], ["td", { style: "padding-right: 1ex;" }, _("title.Args")], ["td", { style: "padding-right: 1ex;" }, _("title.Range")], ["td", { style: "padding-right: 1ex;" }, _("title.Complete")], ["td", { style: "padding-right: 1ex;" }, _("title.Definition")]], ["col", { style: "min-width: 6em; padding-right: 1em;" }], hives.map(([hive, cmds]) => { let i = 0; return [ ["tr", { style: "height: .5ex;" }], cmds.map(cmd => ["tr", {}, ["td", { highlight: "Title" }, !i++ ? hive.name : ""], ["td", {}, cmd.bang ? "!" : " "], ["td", {}, cmd.name], ["td", {}, cmd.argCount], ["td", {}, cmd.count ? "0c" : ""], ["td", {}, completerToString(cmd.completer)], ["td", {}, cmd.replacementText || "function () { ... }"]]), ["tr", { style: "height: .5ex;" }]]; })]; // E4X-FIXME // if (list.*.length() === list.text().length() + 2) // dactyl.echomsg(_("command.none")); // else commandline.commandOutput(list); } }; }, /** * @property Indicates that no count was specified for this * command invocation. * @final */ COUNT_NONE: null, /** * @property {number} Indicates that the full buffer range (1,$) was * specified for this command invocation. * @final */ // FIXME: this isn't a count at all COUNT_ALL: -2, // :%... /** @property {Iterator(Command)} @private */ iterator: function iterator() { return iter.apply(null, this.hives.array) .sort((a, b) => (a.serialGroup - b.serialGroup || a.name > b.name)) .iterValues(); }, /** @property {string} The last executed Ex command line. */ repeat: null, add: function add(names, description, action, extra={}, replace=false) { let { caller } = Components.stack; let group = this.builtin; if (!util.isDactyl(caller)) { deprecated.warn(add, "commands.add", "group.commands.add"); group = this.user; } const { contexts } = this.modules; extra.definedAt = contexts.getCaller(caller); return apply(group, "add", arguments); }, addUserCommand: deprecated("group.commands.add", { get: function addUserCommand() { return this.user.bound._add } }), getUserCommands: deprecated("iter(group.commands)", function getUserCommands() { return iter(this.user).toArray(); }), removeUserCommand: deprecated("group.commands.remove", { get: function removeUserCommand() { return this.user.bound.remove; } }), /** * Returns the specified command invocation object serialized to * an executable Ex command string. * * @param {Object} args The command invocation object. * @returns {string} */ commandToString: function commandToString(args) { let res = [args.command + (args.bang ? "!" : "")]; let defaults = {}; if (args.ignoreDefaults) defaults = Ary.toObject(Array.from(this.options, opt => [opt.names[0], opt.default])); for (let [opt, val] of Object.entries(args.options || {})) { if (val === undefined) continue; if (val != null && defaults[opt] === val) continue; let chr = /^-.$/.test(opt) ? " " : "="; if (isArray(val)) opt += chr + Option.stringify.stringlist(val); else if (val != null) opt += chr + Commands.quote(val); res.push(opt); } for (let arg of (args.arguments || [])) res.push(Commands.quote(arg)); let str = args.literalArg; if (str) res.push(!/\n/.test(str) ? str : this.serializeHereDoc ? "< hive.get(name, full)) .find(identity); }, /** * Returns true if a command invocation contains a URL referring to the * domain *host*. * * @param {string} command * @param {string} host * @returns {boolean} */ hasDomain: function hasDomain(command, host) { try { for (let [cmd, args] of this.subCommands(command)) if (Array.concat(cmd.domains(args)).some(domain => util.isSubdomain(domain, host))) return true; } catch (e) { util.reportError(e); } return false; }, /** * Returns true if a command invocation contains private data which should * be cleared when purging private data. * * @param {string} command * @returns {boolean} */ hasPrivateData: function hasPrivateData(command) { for (let [cmd, args] of this.subCommands(command)) if (cmd.privateData) return !callable(cmd.privateData) ? cmd.privateData : cmd.privateData(args); return false; }, // TODO: should it handle comments? // : it might be nice to be able to specify that certain quoting // should be disabled E.g. backslash without having to resort to // using literal etc. // : error messages should be configurable or else we can ditch // Vim compatibility but it actually gives useful messages // sometimes rather than just "Invalid arg" // : I'm not sure documenting the returned object here, and // elsewhere, as type Args rather than simply Object makes sense, // especially since it is further augmented for use in // Command#action etc. /** * Parses *str* for options and plain arguments. * * The returned *Args* object is an augmented array of arguments. * Any key/value pairs of *extra* will be available and the * following additional properties: * -opt - the value of the option -opt if specified * string - the original argument string *str* * literalArg - any trailing literal argument * * Quoting rules: * '-quoted strings - only ' and \ itself are escaped * "-quoted strings - also ", \n and \t are translated * non-quoted strings - everything is taken literally apart from "\ * " and "\\" * * @param {string} str The Ex command-line string to parse. E.g. * "-x=foo -opt=bar arg1 arg2" * @param {[CommandOption]} options The options accepted. These are specified * as an array of {@link CommandOption} structures. * @param {string} argCount The number of arguments accepted. * "0": no arguments * "1": exactly one argument * "+": one or more arguments * "*": zero or more arguments (default if unspecified) * "?": zero or one arguments * @param {boolean} allowUnknownOptions Whether unspecified options * should cause an error. * @param {number} literal The index at which any literal arg begins. * See {@link Command#literal}. * @param {CompletionContext} complete The relevant completion context * when the args are being parsed for completion. * @param {Object} extra Extra keys to be spliced into the returned * Args object. * @returns {Args} */ parseArgs: function parseArgs(str, params={}) { const self = this; function getNextArg(str, _keepQuotes=keepQuotes) { if (str.substr(0, 2) === "<<" && hereDoc) { let arg = /^<<(\S*)/.exec(str)[1]; let count = arg.length + 2; if (complete) return [count, "", ""]; return [count, self.readHeredoc(arg), ""]; } let [count, arg, quote] = Commands.parseArg(str, null, _keepQuotes); if (quote == "\\" && !complete) return [, , , _("error.trailingCharacters", "\\")]; if (quote && !complete) return [, , , _("error.missingQuote", quote)]; return [count, arg, quote]; } try { let count, arg, quote, error; var { allowUnknownOptions, argCount, complete, extra, hereDoc, literal, options, keepQuotes } = params; if (!options) options = []; if (!argCount) argCount = "*"; var args = params.newArgs ? params.newArgs() : []; args.string = str; // for access to the unparsed string // FIXME! for (let [k, v] of iter(extra || {})) args[k] = v; // FIXME: best way to specify these requirements? var onlyArgumentsRemaining = allowUnknownOptions || options.length == 0; // after a -- has been found arg = null; var i = 0; var completeOpts; // XXX let matchOpts = function matchOpts(arg) { // Push possible option matches into completions if (complete && !onlyArgumentsRemaining) completeOpts = options.filter(opt => (opt.multiple || !hasOwnProp(args, opt.names[0]))); }; let resetCompletions = function resetCompletions() { completeOpts = null; args.completeArg = null; args.completeOpt = null; args.completeFilter = null; args.completeStart = i; args.quote = Commands.complQuote[""]; }; if (complete) { resetCompletions(); matchOpts(""); args.completeArg = 0; } let fail = function fail(error) { if (complete) complete.message = error; else util.assert(false, error); }; outer: while (i < str.length || complete) { var argStart = i; let re = /\s*/gy; re.lastIndex = i; i += re.exec(str)[0].length; if (str[i] == "|") { args.string = str.slice(0, i); args.trailing = str.slice(i + 1); break; } if (i == str.length && !complete) break; if (complete) resetCompletions(); var sub = str.substr(i); if ((!onlyArgumentsRemaining) && /^--(\s|$)/.test(sub)) { onlyArgumentsRemaining = true; i += 2; continue; } var optname = ""; if (!onlyArgumentsRemaining) { for (let opt of options) { for (let optname of opt.names) { if (sub.startsWith(optname)) { let count = 0; let invalid = false; let arg, quote, quoted; let sep = sub[optname.length]; let argString = sub.substr(optname.length + 1); if (sep == "=" || /\s/.test(sep) && opt.type != CommandOption.NOARG) { [count, quoted, quote, error] = getNextArg(argString, true); arg = Option.dequote(quoted); util.assert(!error, error); // if we add the argument to an option after a space, it MUST not be empty if (sep != "=" && !quote && arg.length == 0 && !complete) arg = null; count++; // to compensate the "=" character } else if (!/\s/.test(sep) && sep != undefined) // this isn't really an option as it has trailing characters, parse it as an argument invalid = true; let context = null; if (!complete && quote) fail(_("command.invalidOptArg", optname, argString)); if (!invalid) { if (complete && !/[\s=]/.test(sep)) matchOpts(sub); if (complete && count > 0) { args.completeStart += optname.length + 1; args.completeOpt = opt; args.completeFilter = arg; args.quote = Commands.complQuote[quote] || Commands.complQuote[""]; } if (!complete || arg != null) { if (opt.type) { let orig = arg; arg = opt.type.parse(arg, quoted); if (complete && isArray(arg)) { args.completeFilter = arg[arg.length - 1] || ""; args.completeStart += orig.length - args.completeFilter.length; } if (arg == null || (typeof arg == "number" && isNaN(arg))) { if (!complete || orig != "" || args.completeStart != str.length) fail(_("command.invalidOptTypeArg", opt.type.description, optname, quoted)); if (complete) complete.highlight(args.completeStart, count - 1, "SPELLCHECK"); } } // we have a validator function if (typeof opt.validator == "function") { if (opt.validator(arg, quoted) == false && (arg || !complete)) { fail(_("command.invalidOptArg", optname, quoted)); if (complete) // Always true. complete.highlight(args.completeStart, count - 1, "SPELLCHECK"); } } } if (arg != null || opt.type == CommandOption.NOARG) { // option allowed multiple times if (opt.multiple) args[opt.names[0]] = (args[opt.names[0]] || []).concat(arg); else Class.replaceProperty(args, opt.names[0], opt.type == CommandOption.NOARG || arg); args.explicitOpts[opt.names[0]] = args[opt.names[0]]; } i += optname.length + count; if (i == str.length) break outer; continue outer; } // if it is invalid, just fall through and try the next argument } } } } matchOpts(sub); if (complete) if (argCount == "0" || args.length > 0 && (/[1?]/.test(argCount))) complete.highlight(i, sub.length, "SPELLCHECK"); if (args.length === literal) { if (complete) args.completeArg = args.length; let re = /(?:\s*(?=\n)|\s*)([^]*)/gy; re.lastIndex = argStart || 0; sub = re.exec(str)[1]; // Hack. if (sub.substr(0, 2) === "<<" && hereDoc) { let [count, arg] = getNextArg(sub); sub = arg + sub.substr(count); } args.push(sub); args.quote = null; break; } // if not an option, treat this token as an argument [count, arg, quote, error] = getNextArg(sub); util.assert(!error, error); if (complete) { args.quote = Commands.complQuote[quote] || Commands.complQuote[""]; args.completeFilter = arg || ""; } else if (count == -1) fail(_("command.parsing", arg)); else if (!onlyArgumentsRemaining && sub[0] === "-") fail(_("command.invalidOpt", arg)); if (arg != null) args.push(arg); if (complete) args.completeArg = args.length - 1; i += count; if (count <= 0 || i == str.length) break; } if (complete && args.trailing == null) { if (args.completeOpt) { let opt = args.completeOpt; let context = complete.fork(opt.names[0], args.completeStart); let arg = args.explicitOpts[opt.names[0]]; context.filter = args.completeFilter; if (isArray(arg)) context.filters.push(item => arg.indexOf(item.text) === -1); if (typeof opt.completer == "function") var compl = opt.completer(context, args); else compl = opt.completer || []; context.title = [opt.names[0]]; context.quote = args.quote; if (compl) context.completions = compl; } complete.advance(args.completeStart); complete.keys = { text: "names", description: function (opt) { return messages.get(["command", params.name, "options", opt.names[0], "description"].join("."), opt.description); } }; complete.title = ["Options"]; if (completeOpts) complete.completions = completeOpts; } if (args.verify) args.verify(); return args; } catch (e if complete && e instanceof FailedAssertion) { complete.message = e; return args; } }, nameRegexp: util.regexp(String.raw` [^ 0-9 ] [^ ]* `, "gx", { forbid: util.regexp(String.replace(String.raw` U0000-U002c // U002d - U002e-U002f U003a-U0040 // U0041-U005a a-z U005b-U0060 // U0061-U007a A-Z U007b-U00bf U02b0-U02ff // Spacing Modifier Letters U0300-U036f // Combining Diacritical Marks U1dc0-U1dff // Combining Diacritical Marks Supplement U2000-U206f // General Punctuation U20a0-U20cf // Currency Symbols U20d0-U20ff // Combining Diacritical Marks for Symbols U2400-U243f // Control Pictures U2440-U245f // Optical Character Recognition U2500-U257f // Box Drawing U2580-U259f // Block Elements U2700-U27bf // Dingbats Ufe20-Ufe2f // Combining Half Marks Ufe30-Ufe4f // CJK Compatibility Forms Ufe50-Ufe6f // Small Form Variants Ufe70-Ufeff // Arabic Presentation Forms-B Uff00-Uffef // Halfwidth and Fullwidth Forms Ufff0-Uffff // Specials `, /U/g, "\\u"), "x") }), validName: Class.Memoize(function validName() { return util.regexp("^" + this.nameRegexp.source + "$"); }), commandRegexp: Class.Memoize(function commandRegexp() { return util.regexp(String.raw` ^ (?P (?P [:\s]*) (?P (?:\d+ | %)? ) (?P (?: (?P ) : )? (?P (?:-? [()] | | !)? )) (?P !?) (?P \s*) ) (?P (?:. | \n)*? )? $ `, "x", { name: this.nameRegexp }); }), /** * Parses a complete Ex command. * * The parsed string is returned as an Array like * [count, command, bang, args]: * count - any count specified * command - the Ex command name * bang - whether the special "bang" version was called * args - the commands full argument string * E.g. ":2foo! bar" -> [2, "foo", true, "bar"] * * @param {string} str The Ex command line string. * @returns {Array} */ // FIXME: why does this return an Array rather than Object? parseCommand: function parseCommand(str) { // remove comments str.replace(/\s*".*$/, ""); let matches = this.commandRegexp.exec(str); if (!matches) return []; let { spec, count, group, cmd, bang, space, args } = matches; if (!cmd && bang) [cmd, bang] = [bang, cmd]; if (!cmd || args && args[0] != "|" && !(space || cmd == "!")) return []; // parse count if (count) count = count == "%" ? this.COUNT_ALL : parseInt(count, 10); else count = this.COUNT_NONE; return [count, cmd, !!bang, args || "", spec.length, group]; }, parseCommands: function* parseCommands(str, complete) { const { contexts } = this.modules; do { let [count, cmd, bang, args, len, group] = commands.parseCommand(str); if (!group) var command = this.get(cmd || ""); else if (group = contexts.getGroup(group, "commands")) command = group.get(cmd || ""); if (command == null) { yield [null, { commandString: str }]; return; } if (complete) var context = complete.fork(command.name).fork("opts", len); if (!complete || /(\w|^)[!\s]/.test(str)) args = command.parseArgs(args, context, { count: count, bang: bang }); else args = this.parseArgs(args, { extra: { count: count, bang: bang } }); args.context = this.context; args.commandName = cmd; args.commandString = str.substr(0, len) + args.string; str = args.trailing; yield [command, args]; if (args.break) break; } while (str); }, subCommands: function* subCommands(command) { let commands = [command]; while (command = commands.shift()) try { for (let [command, args] of this.parseCommands(command)) { if (command) { yield [command, args]; if (command.subCommand && args[command.subCommand]) commands.push(args[command.subCommand]); } } } catch (e) {} }, /** @property */ get complQuote() { return Commands.complQuote; }, /** @property */ get quoteArg() { return Commands.quoteArg; } // XXX: better somewhere else? }, { // returns [count, parsed_argument] parseArg: function parseArg(str, sep, keepQuotes) { let arg = ""; let quote = null; let len = str.length; function fixEscapes(str) { return str.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4}|(.))/g, (m, n1) => n1 || m); } // Fix me. if (isString(sep)) sep = RegExp(sep); sep = (sep != null ? sep : /\s/).source; if (sep == "(?:)") sep = ""; if (sep == "" || sep == "(?:)") var re1 = /^(?!)/; else re1 = RegExp("^" + sep); let re2 = RegExp(/^()((?:[^\\S"']|\\.)+)((?:\\$)?)/.source.replace("S", sep)); while (str.length && !re1.test(str)) { let res; if ((res = re2.exec(str))) arg += keepQuotes ? res[0] : res[2].replace(/\\(.)/g, "$1"); else if ((res = /^(")((?:[^\\"]|\\.)*)("?)/.exec(str))) arg += keepQuotes ? res[0] : JSON.parse(fixEscapes(res[0]) + (res[3] ? "" : '"')); else if ((res = /^(')((?:[^']|'')*)('?)/.exec(str))) arg += keepQuotes ? res[0] : res[2].replace(/''/g, "'"); else break; if (!res[3]) quote = res[1]; if (!res[1]) quote = res[3]; str = str.substr(res[0].length); } return [len - str.length, arg, quote]; }, quote: function quote(str) { return Commands.quoteArg[ /[\b\f\n\r\t]/.test(str) ? '"' : /[\s"'\\]|^$|^-/.test(str) ? "'" : ""](str); } }, { completion: function initCompletion(dactyl, modules, window) { const { completion, contexts } = modules; completion.command = function command(context, group) { context.title = ["Command"]; context.keys = { text: "longNames", description: "description" }; if (group) context.generate = () => group._list; else context.generate = () => modules.commands.hives.map(h => h._list).flatten(); }; // provides completions for ex commands, including their arguments completion.ex = function ex(context) { const { commands } = modules; // if there is no space between the command name and the cursor // then get completions of the command name for (var [command, args] of commands.parseCommands(context.filter, context)) if (args.trailing) context.advance(args.commandString.length + 1); if (!args) args = { commandString: context.filter }; let match = commands.commandRegexp.exec(args.commandString); if (!match) return; if (match.group) context.advance(match.group.length + 1); context.advance(match.prespace.length + match.count.length); if (!(match.bang || match.space)) { context.fork("", 0, this, "command", match.group && contexts.getGroup(match.group, "commands")); return; } // dynamically get completions as specified with the command's completer function context.highlight(); if (!command) { context.message = _("command.noSuch", match.cmd); context.highlight(0, match.cmd.length, "SPELLCHECK"); return; } let cmdContext = context.fork(command.name + "/args", match.fullCmd.length + match.bang.length + match.space.length); try { if (!cmdContext.waitingForTab) { if (!args.completeOpt && command.completer && args.completeStart != null) { cmdContext.advance(args.completeStart); cmdContext.quote = args.quote; cmdContext.filter = args.completeFilter; command.completer.call(command, cmdContext, args); } } } catch (e) { util.reportError(e); cmdContext.message = _("error.error", e); } }; completion.exMacro = function exMacro(context, args, cmd) { if (!cmd.action.macro) return; let { macro } = cmd.action; let start = "«%-d-]'", end = "'[-d-%»"; let n = /^\d+$/.test(cmd.argCount) ? parseInt(cmd.argCount) : 12; for (let i = args.completeArg; i < n; i++) args[i] = start + i + end; let params = { args: { __proto__: args, toString: function () { return this.join(" "); } }, bang: args.bang ? "!" : "", count: args.count }; if (!macro.valid(params)) return; let str = macro(params); let idx = str.indexOf(start); if (!~idx || !/^(')?(\d+)'/.test(str.substr(idx + start.length)) || RegExp.$2 != args.completeArg) return; let quote = RegExp.$2; context.quote = null; context.offset -= idx; context.filter = str.substr(0, idx) + (quote ? Option.quote : identity)(context.filter); context.fork("ex", 0, completion, "ex"); }; completion.userCommand = function userCommand(context, group) { context.title = ["User Command", "Definition"]; context.keys = { text: "name", description: "replacementText" }; context.completions = group || modules.commands.user; }; }, commands: function initCommands(dactyl, modules, window) { const { commands, contexts } = modules; commands.add(["(", "-("], "", function () { dactyl.echoerr(_("dactyl.cheerUp")); }, { hidden: true }); commands.add([")", "-)"], "", function () { dactyl.echoerr(_("dactyl.somberDown")); }, { hidden: true }); commands.add(["com[mand]"], "List or define commands", function (args) { let cmd = args[0]; util.assert(!cmd || cmd.split(",").every(commands.validName.bound.test), _("command.invalidName", cmd)); if (args.length <= 1) commands.list(cmd, args.explicitOpts["-group"] ? [args["-group"]] : null); else { util.assert(args["-group"].modifiable, _("group.cantChangeBuiltin", _("command.commands"))); let completer = args["-complete"]; let completerFunc = function (context, args) { return modules.completion.exMacro(context, args, this); }; if (completer) { if (/^custom,/.test(completer)) { completer = completer.substr(7); if (contexts.context) var ctxt = update({}, contexts.context || {}); completerFunc = function (context) { var result = contexts.withSavedValues(["context"], function () { contexts.context = ctxt; return dactyl.userEval(completer); }); if (callable(result)) return result.apply(this, arguments); else return context.completions = result; }; } else completerFunc = context => modules.completion.bound[config.completers[completer]](context); } let added = args["-group"].add(cmd.split(","), args["-description"], contexts.bindMacro(args, "-ex", function makeParams(args, modifiers) { return { args: { __proto__: args, toString: function () { return this.string; } }, bang: this.bang && args.bang ? "!" : "", count: this.count && args.count }; }), { argCount: args["-nargs"], bang: args["-bang"], count: args["-count"], completer: completerFunc, literal: args["-literal"], persist: !args["-nopersist"], replacementText: args.literalArg, context: contexts.context && update({}, contexts.context) }, args.bang); if (!added) dactyl.echoerr(_("command.exists")); } }, { bang: true, completer: function (context, args) { const { completion } = modules; if (args.completeArg == 0) completion.userCommand(context, args["-group"]); else args["-javascript"] ? completion.javascript(context) : completion.ex(context); }, hereDoc: true, options: [ { names: ["-bang", "-b"], description: "Command may be followed by a !" }, { names: ["-count", "-c"], description: "Command may be preceded by a count" }, { // TODO: "E180: invalid complete value: " + arg names: ["-complete", "-C"], description: "The argument completion function", completer: function (context) { return Object.entries(config.completers) .map(([k, v]) => [k, ""]); }, type: CommandOption.STRING, validator: function (arg) { return arg in config.completers || /^custom,/.test(arg); } }, { names: ["-description", "-desc", "-d"], description: "A user-visible description of the command", default: "User-defined command", type: CommandOption.STRING }, contexts.GroupFlag("commands"), { names: ["-javascript", "-js", "-j"], description: "Execute the definition as JavaScript rather than Ex commands" }, { names: ["-literal", "-l"], description: "Process the specified argument ignoring any quoting or meta characters", type: CommandOption.INT }, { names: ["-nargs", "-a"], description: "The allowed number of arguments", completer: [["0", "No arguments are allowed (default)"], ["1", "One argument is allowed"], ["*", "Zero or more arguments are allowed"], ["?", "Zero or one argument is allowed"], ["+", "One or more arguments are allowed"]], default: "0", type: CommandOption.STRING, validator: bind("test", /^[01*?+]$/) }, { names: ["-nopersist", "-n"], description: "Do not save this command to an auto-generated RC file" } ], literal: 1, serialize: function () { return commands.userHives .filter(h => h.persist) .flatMap(hive => Array.from(hive) .filter(cmd => cmd.persist) .map(cmd => ({ command: this.name, bang: true, options: Ary.toObject( Object.entries({ argCount: "-nargs", bang: "-bang", count: "-count", description: "-description", }) .filter(([k, v]) => cmd[k]) .map(([k, v]) => [ v, typeof cmd[k] == "boolean" ? null : cmd[k] ])), arguments: [cmd.name], literalArg: cmd.action, ignoreDefaults: true })) ); } }); commands.add(["delc[ommand]"], "Delete the specified user-defined command", function (args) { util.assert(args.bang ^ !!args[0], _("error.argumentOrBang")); let name = args[0]; if (args.bang) args["-group"].clear(); else if (args["-group"].get(name)) args["-group"].remove(name); else dactyl.echoerr(_("command.noSuchUser", name)); }, { argCount: "?", bang: true, completer: function (context, args) { modules.completion.userCommand(context, args["-group"]); }, options: [contexts.GroupFlag("commands")] }); commands.add(["comp[letions]"], "List the completion results for a given command substring", function (args) { modules.completion.listCompleter("ex", args[0]); }, { argCount: "1", completer: function (context) { modules.completion.ex(context); }, literal: 0 }); dactyl.addUsageCommand({ name: ["listc[ommands]", "lc"], description: "List all Ex commands along with their short descriptions", index: "ex-cmd", iterate: function (args) { return commands.iterator().map(cmd => ({ __proto__: cmd, columns: [ cmd.hive == commands.builtin ? "" : ["span", { highlight: "Object", style: "padding-right: 1em;" }, cmd.hive.name] ] })); }, iterateIndex: function (args) { let tags = help.tags; return this.iterate(args).filter(cmd => (cmd.hive === commands.builtin || hasOwnProp(tags, cmd.helpTag))); }, format: { headings: ["Command", "Group", "Description"], description: function (cmd) { return template.linkifyHelp(cmd.description + (cmd.replacementText ? ": " + cmd.action : "")); }, help: function (cmd) { return ":" + cmd.name; } } }); commands.add(["y[ank]"], "Yank the output of the given command to the clipboard", function (args) { let cmd = /^:/.test(args[0]) ? args[0] : ":echo " + args[0]; let res = modules.commandline.withOutputToString(commands.execute, commands, cmd); dactyl.clipboardWrite(res); let lines = res.split("\n").length; dactyl.echomsg(_("command.yank.yankedLine" + (lines == 1 ? "" : "s"), lines)); }, { argCount: "1", completer: function (context) { modules.completion[/^:/.test(context.filter) ? "ex" : "javascript"](context); }, literal: 0 }); }, javascript: function initJavascript(dactyl, modules, window) { const { setCompleter } = modules.JavaScript; setCompleter([CommandHive.prototype.get, CommandHive.prototype.remove], [function () { return Array.from(this, cmd => [c.names, c.description]); }]); setCompleter([Commands.prototype.get], [function () { return Array.from(this.iterator(), cmd => [c.names, c.description]); }]); }, mappings: function initMappings(dactyl, modules, window) { const { commands, mappings, modes } = modules; mappings.add([modes.COMMAND], ["@:"], "Repeat the last Ex command", function ({ count }) { if (commands.repeat) { for (let i of util.interruptibleRange(0, Math.max(count, 1), 100)) dactyl.execute(commands.repeat); } else dactyl.echoerr(_("command.noPrevious")); }, { count: true }); } }); let quote = function quote(q, list, map=Commands.quoteMap) { let re = RegExp("[" + list + "]", "g"); function quote(str) { return (q + String.replace(str, re, $0 => ($0 in map ? map[$0] : ("\\" + $0))) + q); } quote.list = list; return quote; }; Commands.quoteMap = { "\n": "\\n", "\t": "\\t" }; Commands.quoteArg = { '"': quote('"', '\n\t"\\\\'), "'": quote("'", "'", { "'": "''" }), "": quote("", "|\\\\\\s'\"") }; Commands.complQuote = { '"': ['"', quote("", Commands.quoteArg['"'].list), '"'], "'": ["'", quote("", Commands.quoteArg["'"].list), "'"], "": ["", Commands.quoteArg[""], ""] }; Commands.parseBool = arg => { if (/^(true|1|on)$/i.test(arg)) return true; if (/^(false|0|off)$/i.test(arg)) return false; return NaN; }; endModule(); } catch(e){ if (!e.stack) e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); } // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/completion.jsm000066400000000000000000001447471264147376100217130ustar00rootroot00000000000000// Copyright (c) 2006-2008 by Martin Stubenschrott // Copyright (c) 2007-2011 by Doug Kearns // Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; defineModule("completion", { exports: ["CompletionContext", "Completion", "completion"] }, this); lazyRequire("dom", ["DOM"]); lazyRequire("messages", ["_", "messages"]); lazyRequire("template", ["template"]); /** * Creates a new completion context. * * @class A class to provide contexts for command completion. * Manages the filtering and formatting of completions, and keeps * track of the positions and quoting of replacement text. Allows for * the creation of sub-contexts with different headers and quoting * rules. * * @param {nsIEditor} editor The editor for which completion is * intended. May be a {CompletionContext} when forking a context, * or a {string} when creating a new one. * @param {string} name The name of this context. Used when the * context is forked. * @param {number} offset The offset from the parent context. * @author Kris Maglione * @constructor */ var CompletionContext = Class("CompletionContext", { init: function cc_init(editor, name="", offset=0) { let self = this; if (editor instanceof this.constructor) { let parent = editor; name = parent.name + "/" + name; if (this.options) { this.autoComplete = this.options.get("autocomplete").getKey(name); this.sortResults = this.options.get("wildsort").getKey(name); this.wildcase = this.options.get("wildcase").getKey(name); } this.contexts = parent.contexts; if (name in this.contexts) self = this.contexts[name]; else self.contexts[name] = this; /** * @property {CompletionContext} This context's parent. {null} when * this is a top-level context. */ self.parent = parent; ["filters", "keys", "process", "title", "quote"] .forEach(key => self[key] = parent[key] && util.cloneObject(parent[key])); ["anchored", "compare", "editor", "_filter", "filterFunc", "forceAnchored", "top"] .forEach(key => self[key] = parent[key]); self.__defineGetter__("value", function get_value() { return this.top.value; }); self.offset = parent.offset; self.advance(offset); /** * @property {boolean} Specifies that this context is not finished * generating results. * @default false */ self.incomplete = false; self.message = null; /** * @property {boolean} Specifies that this context is waiting for the * user to press . Useful when fetching completions could be * dangerous or slow, and the user has enabled autocomplete. */ self.waitingForTab = false; self.hasItems = null; delete self._generate; delete self.ignoreCase; if (self != this) return self; ["_caret", "contextList", "maxItems", "onUpdate", "selectionTypes", "tabPressed", "updateAsync", "value"].forEach(function fe(key) { self.__defineGetter__(key, function () { return this.top[key]; }); self.__defineSetter__(key, function (val) { this.top[key] = val; }); }); } else { if (typeof editor == "string") this._value = editor; else this.editor = editor; /** * @property {boolean} Specifies whether this context results must * match the filter at the beginning of the string. * @default true */ this.anchored = true; this.forceAnchored = null; this.compare = function compare(a, b) { return String.localeCompare(a.text, b.text); }; /** * @property {function} This function is called when we close * a completion window with Esc or Ctrl-c. Usually this callback * is only needed for long, asynchronous completions */ this.cancel = null; /** * @property {[CompletionContext]} A list of active * completion contexts, in the order in which they were * instantiated. */ this.contextList = []; /** * @property {Object} A map of all contexts, keyed on their names. * Names are assigned when a context is forked, with its specified * name appended, after a '/', to its parent's name. May * contain inactive contexts. For active contexts, see * {@link #contextList}. */ this.contexts = { "": this }; /** * @property {function} The function used to filter the results. * @default Selects all results which match every predicate in the * {@link #filters} array. */ this.filterFunc = function filterFunc(items) { return this.filters .reduce((res, filter) => res.filter(item => filter.call(this, item)), items); }; /** * @property {Array} An array of predicates on which to filter the * results. */ this.filters = [CompletionContext.Filter.text]; /** * @property {Object} A mapping of keys, for {@link #getKey}. Given * { key: value }, getKey(item, key) will return values as such: * if value is a string, it will return item.item[value]. If it's a * function, it will return value(item.item). */ this.keys = { text: 0, description: 1, icon: "icon" }; /** * @property {number} This context's offset from the beginning of * {@link #editor}'s value. */ this.offset = offset; /** * @property {function} A function which is called when any subcontext * changes its completion list. Only called when * {@link #updateAsync} is true. */ this.onUpdate = function onUpdate() { return true; }; this.runCount = 0; /** * @property {CompletionContext} The top-level completion context. */ this.top = this; this.__defineGetter__("incomplete", function get_incomplete() { return this._incomplete || this.contextList.some(c => c.parent && c.incomplete); }); this.__defineGetter__("waitingForTab", function get_waitingForTab() { return this._waitingForTab || this.contextList.some(c => c.parent && c.waitingForTab); }); this.__defineSetter__("incomplete", function get_incomplete(val) { this._incomplete = val; }); this.__defineSetter__("waitingForTab", function get_waitingForTab(val) { this._waitingForTab = val; }); this.reset(); } /** * @property {Object} A general-purpose store for functions which need to * cache data between calls. */ this.cache = {}; this._cache = {}; /** * @private * @property {Object} A cache for return values of {@link #generate}. */ this.itemCache = {}; /** * @property {string} A key detailing when the cached value of * {@link #generate} may be used. Every call to * {@link #generate} stores its result in {@link #itemCache}. * When itemCache[key] exists, its value is returned, and * {@link #generate} is not called again. */ this.key = ""; /** * @property {string} A message to be shown before any results. */ this.message = null; this.name = name || ""; /** @private */ this._completions = []; // FIXME /** * Returns a key, as detailed in {@link #keys}. * @function */ this.getKey = function getKey(item, key) { if (typeof self.keys[key] == "function") return self.keys[key].call(this, item.item); if (key in self.keys) return item.item[self.keys[key]]; return item.item[key]; }; return this; }, __title: Class.Memoize(function __title() { return this._title.map(s => typeof s == "string" ? messages.get("completion.title." + s, s) : s); }), set title(val) { delete this.__title; return this._title = val; }, get title() { return this.__title; }, get activeContexts() { return this.contextList.filter(function f(c) { return c.items.length; }); }, // Temporary /** * @property {Object} * * An object describing the results from all sub-contexts. Results are * adjusted so that all have the same starting offset. * * @deprecated */ get allItems() { let self = this; try { let allItems = this.contextList.map(function m(context) { return context.hasItems && context.items.length; }); if (this.cache.allItems && Ary.equals(this.cache.allItems, allItems)) return this.cache.allItemsResult; this.cache.allItems = allItems; let minStart = apply(Math, "min", this.activeContexts.map(function m(c) { return c.offset; })); if (minStart == Infinity) minStart = 0; this.cache.allItemsResult = memoize({ start: minStart, get longestSubstring() { return self.longestAllSubstring; }, get items() { return self.activeContexts.flatMap(context => { let prefix = self.value.substring(minStart, context.offset); return context.items.map(item => { return { text: prefix + item.text, result: prefix + item.result, __proto__: item }; }); }); } }); return this.cache.allItemsResult; } catch (e) { util.reportError(e); return { start: 0, items: [], longestAllSubstring: "" }; } }, // Temporary get allSubstrings() { let contexts = this.activeContexts; let minStart = apply(Math, "min", contexts.map(function m(c) { return c.offset; })); let lists = contexts.map(function m(context) { let prefix = context.value.substring(minStart, context.offset); return context.substrings.map(function m(s) { return prefix + s; }); }); /* TODO: Deal with sub-substrings for multiple contexts again. * Possibly. */ let substrings = lists.reduce( (res, list) => { return res.filter(str => { return list.some(s => s.substr(0, str.length) == str); }); }, lists.pop()); if (!substrings) // FIXME: How is this undefined? return []; return Ary.uniq(Array.slice(substrings)); }, // Temporary get longestAllSubstring() { return this.allSubstrings.reduce(function r(a, b) { return a.length > b.length ? a : b; }, ""); }, get caret() { return this._caret - this.offset; }, set caret(val) { this._caret = val + this.offset; }, get compare() { return this._compare || function compare() { return 0; }; }, set compare(val) { this._compare = val; }, get completions() { return this._completions || []; }, set completions(items) { if (items && isArray(items.array)) items = items.array; // Accept a generator if (!isArray(items)) items = Array.from(items || []); if (this._completions !== items) { delete this.cache.filtered; delete this.cache.filter; this.cache.rows = []; this._completions = items; this.itemCache[this.key] = items; } if (this._completions) this.hasItems = this._completions.length > 0; if (this.updateAsync && !this.noUpdate) util.trapErrors("onUpdate", this); }, get createRow() { return this._createRow || template.completionRow; }, // XXX set createRow(createRow) { return this._createRow = createRow; }, get filterFunc() { return this._filterFunc || identity; }, set filterFunc(val) { this._filterFunc = val; }, get filter() { return this._filter != null ? this._filter : this.value.substr(this.offset, this.caret); }, set filter(val) { delete this.ignoreCase; return this._filter = val; }, get format() { return { anchored: this.anchored, title: this.title, keys: this.keys, process: this.process }; }, set format(format) { this.anchored = format.anchored, this.title = format.title || this.title; this.keys = format.keys || this.keys; this.process = format.process || this.process; }, /** * @property {string | xml | null} * The message displayed at the head of the completions for the * current context. */ get message() { return this._message || (this.waitingForTab && this.hasItems !== false ? _("completion.waitingFor", "") : null); }, set message(val) { this._message = val; }, /** * The prototype object for items returned by {@link items}. */ get itemPrototype() { let self = this; let res = { highlight: "" }; function* result(quote) { yield ["context", function p_context() { return self; }]; yield ["result", quote ? function p_result() { return quote[0] + util.trapErrors(1, quote, this.text) + quote[2]; } : function p_result() { return this.text; }]; yield ["texts", function p_texts() { return Array.concat(this.text); }]; }; for (let i of iter(this.keys, result(this.quote))) { let [k, v] = i; if (typeof v == "string" && /^[.[]/.test(v)) // This is only allowed to be a simple accessor, and shouldn't // reference any variables. Don't bother with eval context. v = Function("i", "return i" + v); if (typeof v == "function") res.__defineGetter__(k, function p_gf() { return Class.replaceProperty(this, k, v.call(this, this.item, self)); }); else res.__defineGetter__(k, function p_gp() { return Class.replaceProperty(this, k, this.item[v]); }); res.__defineSetter__(k, function p_s(val) { Class.replaceProperty(this, k, val); }); } return res; }, /** * Returns true when the completions generated by {@link #generate} * must be regenerated. May be set to true to invalidate the current * completions. */ get regenerate() { return this._generate && (!this.completions || !this.itemCache[this.key] || this._cache.offset != this.offset); }, set regenerate(val) { if (val) delete this.itemCache[this.key]; }, /** * A property which may be set to a function to generate the value * of {@link completions} only when necessary. The generated * completions are linked to the value in {@link #key} and may be * invalidated by setting the {@link #regenerate} property. */ get generate() { return this._generate || null; }, set generate(arg) { this.hasItems = true; this._generate = arg; }, /** * Generates the item list in {@link #completions} via the * {@link #generate} method if the previously generated value is no * longer valid. */ generateCompletions: function generateCompletions() { if (this.offset != this._cache.offset || this.lastActivated != this.top.runCount) { this.itemCache = {}; this._cache.offset = this.offset; this.lastActivated = this.top.runCount; } if (!this.itemCache[this.key] && !this.waitingForTab) { try { let res = this._generate(); if (res != null) this.itemCache[this.key] = res; } catch (e) { util.reportError(e); this.message = _("error.error", e); } } // XXX this.noUpdate = true; this.completions = this.itemCache[this.key]; this.noUpdate = false; }, ignoreCase: Class.Memoize(function M() { let mode = this.wildcase; if (mode == "match") return false; else if (mode == "ignore") return true; else return !/[A-Z]/.test(this.filter); }), /** * Returns a list of all completion items which match the current * filter. The items returned are objects containing one property * for each corresponding property in {@link keys}. The returned * list is generated on-demand from the item list in {@link completions} * or generated by {@link generate}, and is cached as long as no * properties which would invalidate the result are changed. */ get items() { // Don't return any items if completions or generator haven't // been set during this completion cycle. if (!this.hasItems) return []; // Regenerate completions if we must if (this.generate) this.generateCompletions(); let items = this.completions; // Check for cache miss if (this._cache.completions !== this.completions) { this._cache.completions = this.completions; this._cache.constructed = null; this.cache.filtered = null; } if (this.cache.filtered && this.cache.filter == this.filter) return this.cache.filtered; this.cache.rows = []; this.cache.filter = this.filter; if (items == null) return null; let self = this; delete this._substrings; if (!this.forceAnchored && this.options) this.anchored = this.options.get("wildanchor").getKey(this.name, this.anchored); // Item matchers if (this.ignoreCase) this.matchString = this.anchored ? function matchString(filter, str) { return String.toLowerCase(str).indexOf(filter.toLowerCase()) == 0; } : function matchString(filter, str) { return String.toLowerCase(str).indexOf(filter.toLowerCase()) >= 0; }; else this.matchString = this.anchored ? function matchString(filter, str) { return String.indexOf(str, filter) == 0; } : function matchString(filter, str) { return String.indexOf(str, filter) >= 0; }; // Item formatters this.processor = Array.slice(this.process); if (!this.anchored) this.processor[0] = function processor_0(item, text) { return self.process[0].call( self, item, template.highlightFilter(item.text, self.filter, null, item.isURI)); }; try { // Item prototypes if (!this._cache.constructed) { let proto = this.itemPrototype; this._cache.constructed = items.map(function m(item) { return { __proto__: proto, item: item }; }); } // Filters let filtered = this.filterFunc(this._cache.constructed); if (this.maxItems) filtered = filtered.slice(0, this.maxItems); // Sorting if (this.sortResults && this.compare) { filtered.sort(this.compare); if (!this.anchored) { let filter = this.filter; filtered.sort(function s(a, b) { return b.text.startsWith(filter) - a.text.startsWith(filter); }); } } return this.cache.filtered = filtered; } catch (e) { this.message = _("error.error", e); util.reportError(e); return []; } }, /** * Returns a list of all substrings common to all items which * include the current filter. */ get substrings() { let items = this.items; if (items.length == 0 || !this.hasItems) return []; if (this._substrings) return this._substrings; let fixCase = this.ignoreCase ? String.toLowerCase : identity; let text = fixCase(items[0].text); let filter = fixCase(this.filter); // Exceedingly long substrings cause Gecko to go into convulsions if (text.length > 100) text = text.substr(0, 100); if (this.anchored) { var compare = function compare(text, s) { return text.substr(0, s.length) == s; }; var substrings = [text]; } else { var compare = function compare(text, s) { return text.includes(s); }; var substrings = []; let start = 0; let idx; let length = filter.length; while ((idx = text.indexOf(filter, start)) > -1 && idx < text.length) { substrings.push(text.substring(idx)); start = idx + 1; } } substrings = items.reduce(function r(res, item) { return res.map(function m(substring) { // A simple binary search to find the longest substring // of the given string which also matches the current // item's text. let len = substring.length; let i = 0, n = len + 1; let result = n && fixCase(item.result); while (n) { let m = Math.floor(n / 2); let keep = compare(result, substring.substring(0, i + m)); if (!keep) len = i + m - 1; if (!keep || m == 0) n = m; else { i += m; n = n - m; } } return len == substring.length ? substring : substring.substr(0, Math.max(len, 0)); }); }, substrings); let quote = this.quote; if (quote) substrings = substrings.map(function m(str) { return quote[0] + quote[1](str); }); return this._substrings = substrings; }, /** * Advances the context *count* characters. {@link #filter} is advanced to * match. If {@link #quote} is non-null, its prefix and suffix are set to * the null-string. * * This function is still imperfect for quoted strings. When * {@link #quote} is non-null, it adjusts the count based on the quoted * size of the *count*-character substring of the filter, which is accurate * so long as unquoting and quoting a string will always map to the * original quoted string, which is often not the case. * * @param {number} count The number of characters to advance the context. */ advance: function advance(count) { delete this.ignoreCase; let advance = count; if (this.quote && count) { advance = this.quote[1](this.filter.substr(0, count)).length; count = this.quote[0].length + advance; this.quote[0] = ""; this.quote[2] = ""; } this.offset += count; if (this._filter) this._filter = this._filter.substr(arguments[0] || 0); }, /** * Calls the {@link #cancel} method of all currently active * sub-contexts. */ cancelAll: function cancelAll() { for (let context of this.contextList) { if (context.cancel) context.cancel(); } }, /** * Gets a key from {@link #cache}, setting it to *defVal* if it doesn't * already exists. * * @param {string} key * @param defVal */ getCache: function getCache(key, defVal) { if (!(key in this.cache)) this.cache[key] = defVal(); return this.cache[key]; }, getItems: function getItems(start, end) { let items = this.items; let step = start > end ? -1 : 1; start = Math.max(0, start || 0); end = Math.min(items.length, end ? end : items.length); return iter.map(util.range(start, end, step), function m(i) { return items[i]; }); }, getRow: function getRow(idx, doc) { let cache = this.cache.rows; if (cache) { if (idx in this.items && !(idx in this.cache.rows)) try { cache[idx] = DOM.fromJSON(this.createRow(this.items[idx]), doc || this.doc); } catch (e) { util.reportError(e); try { util.dump(util.prettifyJSON(this.createRow(this.items[idx]), null, true)); } catch (e) {} cache[idx] = DOM.fromJSON( ["div", { highlight: "CompItem", style: "white-space: nowrap" }, ["li", { highlight: "CompResult" }, this.text + "\u00a0"], ["li", { highlight: "CompDesc ErrorMsg" }, e + "\u00a0"]], doc || this.doc); } return cache[idx]; } }, getRows: function* getRows(start, end, doc) { let items = this.items; let cache = this.cache.rows; let step = start > end ? -1 : 1; start = Math.max(0, start || 0); end = Math.min(items.length, end != null ? end : items.length); this.doc = doc; for (let i of util.range(start, end, step)) yield [i, this.getRow(i)]; }, /** * Forks this completion context to create a new sub-context named * as {this.name}/{name}. The new context is automatically advanced * *offset* characters. If *completer* is provided, it is called * with *self* as its 'this' object, the new context as its first * argument, and any subsequent arguments after *completer* as its * following arguments. * * If *completer* is provided, this function returns its return * value, otherwise it returns the new completion context. * * @param {string} name The name of the new context. * @param {number} offset The offset of the new context relative to * the current context's offset. * @param {object} self *completer*'s 'this' object. @optional * @param {function|string} completer A completer function to call * for the new context. If a string is provided, it is * interpreted as a method to access on *self*. */ fork: function fork(name, offset, self, completer, ...args) { return this.forkapply(name, offset, self, completer, args); }, forkapply: function forkapply(name, offset, self, completer, args) { if (isString(completer)) completer = self[completer]; let context = this.constructor(this, name, offset); if (this.contextList.indexOf(context) < 0) this.contextList.push(context); if (!context.autoComplete && !context.tabPressed && context.editor) context.waitingForTab = true; else if (completer) { let res = completer.apply(self || this, [context].concat(args)); if (res && !isArray(res) && !isArray(res.__proto__)) res = Array.from(res); if (res) context.completions = res; return res; } if (completer) return null; return context; }, split: function split(name, obj, fn, ...args) { let context = this.fork(name); let alias = prop => { context.__defineGetter__(prop, () => this[prop]); context.__defineSetter__(prop, val => this[prop] = val); }; alias("_cache"); alias("_completions"); alias("_generate"); alias("_regenerate"); alias("itemCache"); alias("lastActivated"); context.hasItems = true; this.hasItems = false; if (fn) return fn.apply(obj || this, [context].concat(args)); return context; }, /** * Highlights text in the nsIEditor associated with this completion * context. *length* characters are highlighted from the position * *start*, relative to the current context's offset, with the * selection type *type* as defined in nsISelectionController. * * When called with no arguments, all highlights are removed. When * called with a 0 length, all highlights of type *type* are * removed. * * @param {number} start The position at which to start * highlighting. * @param {number} length The length of the substring to highlight. * @param {string} type The selection type to highlight with. */ highlight: function highlight(start, length, type) { if (arguments.length == 0) { for (let type in this.selectionTypes) this.highlight(0, 0, type); this.selectionTypes = {}; } try { // Requires Gecko >= 1.9.1 this.selectionTypes[type] = true; const selType = Ci.nsISelectionController["SELECTION_" + type]; let sel = this.editor.selectionController.getSelection(selType); if (length == 0) sel.removeAllRanges(); else { let range = this.editor.selection.getRangeAt(0).cloneRange(); range.setStart(range.startContainer, this.offset + start); range.setEnd(range.startContainer, this.offset + start + length); sel.addRange(range); } } catch (e) {} }, /** * Tests the given string for a match against the current filter, * taking into account anchoring and case sensitivity rules. * * @param {string} str The string to match. * @returns {boolean} True if the string matches, false otherwise. */ match: function match(str) { return this.matchString(this.filter, str); }, /** * Pushes a new output processor onto the processor chain of * {@link #process}. The provided function is called with the item * and text to process along with a reference to the processor * previously installed in the given *index* of {@link #process}. * * @param {number} index The index into {@link #process}. * @param {function(object, string, function)} func The new * processor. */ pushProcessor: function pushProcess(index, func) { let next = this.process[index]; this.process[index] = function process_(item, text) { return func(item, text, next); }; }, /** * Resets this completion context and all sub-contexts for use in a * new completion cycle. May only be called on the top-level * context. */ reset: function reset() { if (this.parent) throw Error(); this.offset = 0; this.process = [template.icon, function process_1(item, k) { return k; }]; this.filters = [CompletionContext.Filter.text]; this.tabPressed = false; this.title = ["Completions"]; this.updateAsync = false; this.cancelAll(); if (this.editor) { this.value = this.editor.selection.focusNode.textContent; this._caret = this.editor.selection.focusOffset; } else { this.value = this._value; this._caret = this.value.length; } //for (let key in (k for ([k, v] in Iterator(this.contexts)) if (v.offset > this.caret))) // delete this.contexts[key]; for (let context of values(this.contexts)) { context.hasItems = false; context.incomplete = false; } this.waitingForTab = false; this.runCount++; for (let context of this.contextList) context.lastActivated = this.runCount; this.contextList = []; }, /** * Wait for all subcontexts to complete. * * @param {number} timeout The maximum time, in milliseconds, to wait. * If 0 or null, wait indefinitely. * @param {boolean} interruptible When true, the call may be interrupted * via , in which case, "Interrupted" may be thrown. */ wait: function wait(timeout, interruptable) { this.allItems; return util.waitFor(function wf() { return !this.incomplete; }, this, timeout, interruptable); } }, { Sort: { number: function S_number(a, b) { return parseInt(a.text) - parseInt(b.text) || String.localeCompare(a.text, b.text); }, unsorted: null }, Filter: { text: function F_text(item) { let text = item.texts; for (let [i, str] of iter(text)) { if (this.match(String(str))) { item.text = String(text[i]); return true; } } return false; }, textDescription: function F_textDescription(item) { return CompletionContext.Filter.text.call(this, item) || this.match(item.description); } } }); /** * @instance completion */ var Completion = Module("completion", { init: function init() { }, get setFunctionCompleter() { return JavaScript.setCompleter; }, // Backward compatibility Local: function Local(dactyl, modules, window) { return { urlCompleters: {}, get modules() { return modules; }, get options() { return modules.options; }, // FIXME _runCompleter: function _runCompleter(name, filter, maxItems, ...args) { let context = modules.CompletionContext(filter); context.maxItems = maxItems; let res = apply(context, "fork", ["run", 0, this, name].concat(args)); if (res) { if (Components.stack.caller.name === "runCompleter") // FIXME return { items: res.map(function m(i) { return { item: i }; }) }; context.contexts["/run"].completions = res; } context.wait(null, true); return context.allItems; }, runCompleter: function runCompleter(name, filter, maxItems) { return apply(this, "_runCompleter", arguments) .items.map(function m(i) { return i.item; }); }, listCompleter: function listCompleter(name, filter, maxItems, ...args) { let context = modules.CompletionContext(filter || ""); context.maxItems = maxItems; apply(context, "fork", ["list", 0, this, name].concat(args)); context = context.contexts["/list"]; context.wait(null, true); let contexts = context.activeContexts; if (!contexts.length) contexts = context.contextList .filter(function f(c) { return c.hasItems; }) .slice(0, 1); if (!contexts.length) contexts = context.contextList.slice(-1); modules.commandline.commandOutput( ["div", { highlight: "Completions" }, template.map(contexts, function m(context) { return [template.completionRow(context.title, "CompTitle"), template.map(context.items, function m(item) { return context.createRow(item); }, null, 100)]; })]); } }; }, //////////////////////////////////////////////////////////////////////////////// ////////////////////// COMPLETION TYPES //////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////{{{ // filter a list of urls // // may consist of search engines, filenames, bookmarks and history, // depending on the 'complete' option // if the 'complete' argument is passed like "h", it temporarily overrides the complete option url: function url(context, complete) { if (/^jar:[^!]*$/.test(context.filter)) { context.advance(4); context.quote = context.quote || ["", identity, ""]; let quote = context.quote[1]; context.quote[1] = function quote_1(str) { return quote(str.replace(/!/g, escape)); }; } if (this.options["urlseparator"]) var skip = util.regexp("^.*" + this.options["urlseparator"] + "\\s*") .exec(context.filter); if (skip) context.advance(skip[0].length); if (/^about:/.test(context.filter)) context.fork("about", 6, this, function fork_(context) { context.title = ["about:"]; context.generate = function generate_() { return Object.keys(Cc).filter(k => k.startsWith(services.ABOUT)) .map(k => [k.substr(services.ABOUT.length), ""]); }; }); if (complete == null) complete = this.options["complete"]; // Will, and should, throw an error if !(c in opts) Array.forEach(complete, function fe(c) { let completer = this.urlCompleters[c] || { args: [], completer: this.autocomplete(c.replace(/^native:/, "")) }; context.forkapply(c, 0, this, completer.completer, completer.args); }, this); }, addUrlCompleter: function addUrlCompleter(name, description, completer, ...args) { completer = Completion.UrlCompleter(name, description, completer); completer.args = args; this.urlCompleters[name] = completer; }, autocomplete: curry(function autocomplete(provider, context) { let running = context.getCache("autocomplete-search-running", Object); let name = "autocomplete:" + provider; if (!services.has(name)) services.add(name, services.AUTOCOMPLETE + provider, "nsIAutoCompleteSearch"); let service = services[name]; util.assert(service, _("autocomplete.noSuchProvider", provider), false); if (running[provider]) { this.completions = this.completions; this.cancel(); } context.anchored = false; context.compare = CompletionContext.Sort.unsorted; context.filterFunc = null; let words = context.filter.toLowerCase().split(/\s+/g); context.hasItems = true; context.completions = context.completions .filter(function f({ url, title }) { return words.every(function e(w) { return (url + " " + title) .toLowerCase().indexOf(w) >= 0; }) }); context.format = this.modules.bookmarks.format; context.keys.extra = function k_extra(item) { try { return bookmarkcache.get(item.url).extra; } catch (e) {} return null; }; context.title = [_("autocomplete.title", provider)]; context.cancel = function cancel_() { this.incomplete = false; if (running[provider]) service.stopSearch(); running[provider] = false; }; if (!context.waitingForTab) { context.incomplete = true; service.startSearch(context.filter, "", context.result, { onSearchResult: util.wrapCallback(function onSearchResult(search, result) { if (result.searchResult <= result.RESULT_SUCCESS) running[provider] = null; context.incomplete = result.searchResult >= result.RESULT_NOMATCH_ONGOING; context.completions = Array.from( util.range(0, result.matchCount), i => ({ url: result.getValueAt(i), title: result.getCommentAt(i), icon: result.getImageAt(i) })); }), get onUpdateSearchResult() { return this.onSearchResult; } }); running[provider] = true; } }), urls: function urls(context, tags) { let compare = String.localeCompare; let contains = String.indexOf; if (context.ignoreCase) { compare = util.compareIgnoreCase; contains = function contains_(a, b) { return a && a.toLowerCase().includes(b.toLowerCase()); }; } if (tags) context.filters.push(function filter_(item) { return tags.every(function e(tag) { return (item.tags || []).some(function s(t) { return !compare(tag, t); }); }); }); context.anchored = false; if (!context.title) context.title = ["URL", "Title"]; context.fork("additional", 0, this, function fork_(context) { context.title[0] += " " + _("completion.additional"); context.filter = context.parent.filter; // FIXME context.completions = context.parent.completions; // For items whose URL doesn't exactly match the filter, // accept them if all tokens match either the URL or the title. // Filter out all directly matching strings. let match = context.filters[0]; context.filters[0] = function filters_0(item) { !match.call(this, item); }; // and all that don't match the tokens. let tokens = context.filter.split(/\s+/); context.filters.push(function filter_(item) { return tokens.every(function e(tok) { return contains(item.url, tok) || contains(item.title, tok); }); }); let re = RegExp(tokens.filter(identity).map(util.regexp.escape).join("|"), "g"); function highlight(item, text, i) { return process[i].call(this, item, template.highlightRegexp(text, re)); } let process = context.process; context.process = [ function process_0(item, text) { return highlight.call(this, item, item.text, 0); }, function process_1(item, text) { return highlight.call(this, item, text, 1); } ]; }); } //}}} }, { UrlCompleter: Struct("name", "description", "completer") }, { init: function init(dactyl, modules, window) { init.superapply(this, arguments); modules.CompletionContext = Class("CompletionContext", CompletionContext, { init: function init() { this.modules = modules; return init.superapply(this, arguments); }, get options() { return this.modules.options; } }); }, commands: function initCommands(dactyl, modules, window) { const { commands, completion } = modules; commands.add(["contexts"], "List the completion contexts used during completion of an Ex command", function () { modules.commandline.commandOutput( ["div", { highlight: "Completions" }, template.completionRow(["Context", "Title"], "CompTitle"), template.map(completion.contextList || [], function m(item) { return template.completionRow(item, "CompItem"); })]); }, { argCount: "*", completer: function (context) { let PREFIX = "/ex/contexts"; context.fork("ex", 0, completion, "ex"); completion.contextList = ( Object.entries(context.contexts) .filter(([k]) => k.substr(0, PREFIX.length) == PREFIX) .map(([k, v]) => [k.substr(PREFIX.length), v.title[0]])); }, literal: 0 }); }, options: function initOptions(dactyl, modules, window) { const { completion, options } = modules; let wildmode = { values: { // Why do we need ""? // Because its description is useful during completion. --Kris "": "Complete only the first match", "full": "Complete the next full match", "longest": "Complete the longest common string", "list": "If more than one match, list all matches", "list:full": "List all and complete first match", "list:longest": "List all and complete the longest common string" }, checkHas: function (value, val) { let [first, second] = value.split(":", 2); return first == val || second == val; }, has: function () { let test = function test(val) { return this.value.some(function s(value) { return this.checkHas(value, val) }, this); }; return Array.some(arguments, test, this); } }; options.add(["altwildmode", "awim"], "Define the behavior of the c_ key in command-line completion", "stringlist", "list:full", wildmode); options.add(["autocomplete", "au"], "Automatically update the completion list on any key press", "regexplist", ".*"); options.add(["complete", "cpt"], "Items which are completed at the :open prompts", "stringlist", "slf", { valueMap: { S: "suggestion", b: "bookmark", f: "file", h: "history", l: "location", s: "search" }, get values() { let builtin = Object.keys(Cc) .filter(k => k.startsWith(services.AUTOCOMPLETE)) .map(key => { let name = key.substr(services.AUTOCOMPLETE.length); return ["native:" + name, _("autocomplete.description", name)]; }); return values(completion.urlCompleters).toArray().concat(builtin); }, setter: function setter(values) { if (values.length == 1 && !hasOwnProp(values[0], this.values) && Array.every(values[0], v => hasOwnProp(this.valueMap, v))) return Array.map(values[0], v => this.valueMap[v]); return values; }, validator: function validator(values) { return validator.supercall(this, this.setter(values)); } }); options.add(["wildanchor", "wia"], "Define which completion groups only match at the beginning of their text", "regexplist", "!/ex/(back|buffer|ext|forward|help|undo)"); options.add(["wildcase", "wic"], "Completion case matching mode", "regexpmap", ".?:smart", { values: { "smart": "Case is significant when capital letters are typed", "match": "Case is always significant", "ignore": "Case is never significant" } }); options.add(["wildmode", "wim"], "Define the behavior of the c_ key in command-line completion", "stringlist", "list:full", wildmode); options.add(["wildsort", "wis"], "Define which completion groups are sorted", "regexplist", ".*"); } }); endModule(); // catch(e){ if (!e.stack) e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); } // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/config.jsm000066400000000000000000000573601264147376100210010ustar00rootroot00000000000000// Copyright (c) 2006-2008 by Martin Stubenschrott // Copyright (c) 2007-2011 by Doug Kearns // Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; let global = this; defineModule("config", { exports: ["ConfigBase", "Config", "config"], require: ["io", "protocol", "services"] }); lazyRequire("addons", ["AddonManager"]); lazyRequire("cache", ["cache"]); lazyRequire("dom", ["DOM"]); lazyRequire("highlight", ["highlight"]); lazyRequire("messages", ["_"]); lazyRequire("overlay", ["overlay"]); lazyRequire("prefs", ["localPrefs", "prefs"]); lazyRequire("storage", ["storage", "File"]); lazyRequire("styles", ["Styles"]); lazyRequire("template", ["template"]); lazyRequire("util", ["util"]); function AboutHandler() {} AboutHandler.prototype = { get classDescription() { return "About " + config.appName + " Page"; }, classID: Components.ID("81495d80-89ee-4c36-a88d-ea7c4e5ac63f"), get contractID() { return services.ABOUT + config.name; }, QueryInterface: XPCOMUtils.generateQI([Ci.nsIAboutModule]), newChannel: function (uri) { let channel = Cc["@mozilla.org/network/io-service;1"].getService(Ci.nsIIOService) .newChannel("dactyl://content/about.xul", null, null); channel.originalURI = uri; return channel; }, getURIFlags: function (uri) { return Ci.nsIAboutModule.ALLOW_SCRIPT; } }; var ConfigBase = Class("ConfigBase", { /** * Called on dactyl startup to allow for any arbitrary application-specific * initialization code. Must call superclass's init function. */ init: function init() { this.loadConfig(); util.trapErrors(() => { JSMLoader.registerFactory(JSMLoader.Factory(AboutHandler)); }); util.withProperErrors(() => { JSMLoader.registerFactory(JSMLoader.Factory( Protocol("dactyl", "{9c8f2530-51c8-4d41-b356-319e0b155c44}", "resource://dactyl-content/"))); }); if (this.VCSPath) { this.branch = new Promise(resolve => { this.timeout(() => { io.system(["hg", "-R", this.VCSPath, "branch"], "", true) .then(result => { resolve(result.output); }); }, 1000); }); this._version = new Promise(resolve => { this.timeout(() => { io.system(["hg", "-R", this.VCSPath, "log", "-r.", "--template=hg{rev}-{branch}"], "", true) .then(result => { this.version = result.output; resolve(this.version); }); }, 1000); }); } else { this.branch = Promise.resolve((/pre-hg\d+-(\S*)/.exec(this.version) || [])[1]); this._version = null; } this.protocolLoaded = true; this.timeout(function () { cache.register("config.dtd", () => util.makeDTD(config.dtd), true); }); // FIXME: May not be ready before first window opens. AddonManager.getAddonByID("{972ce4c6-7e08-4474-a285-3208198ce6fd}", a => { if (!a.isActive) config.features.delete("default-theme"); }); services["dactyl:"].pages["dtd"] = () => [null, cache.get("config.dtd")]; update(services["dactyl:"].providers, { "locale": function (uri, path) { return LocaleChannel("dactyl-locale", config.locale, path, uri); }, "locale-local": function (uri, path) { return LocaleChannel("dactyl-local-locale", config.locale, path, uri); } }); }, get prefs() { return localPrefs; }, has: function (feature) { return this.features.has(feature); }, configFiles: [ "resource://dactyl-common/config.json", "resource://dactyl-local/config.json" ], configs: Class.Memoize(function () { return this.configFiles.map(url => JSON.parse(File.readURL(url))); }), loadConfig: function loadConfig(documentURL) { for (let config of this.configs) { if (documentURL) config = config.overlays && config.overlays[documentURL] || {}; for (let [name, value] of iter(config)) { let prop = util.camelCase(name); if (isArray(this[prop])) this[prop] = [].concat(this[prop], value); else if (isinstance(this[prop], ["Set"])) for (let key of value) this[prop].add(key); else if (isObject(this[prop])) { if (isArray(value)) value = Set(value); let overrides = {}; for (let [key, val] of Object.entries(value)) overrides[util.camelCase(key)] = val; this[prop] = update({}, this[prop], overrides); } else this[prop] = value; } } }, modules: { global: ["addons", "base", "io", ["bookmarkcache", "bookmarkcache"], "buffer", "cache", "commands", "completion", "config", "contexts", "dom", "downloads", "finder", "help", "highlight", "javascript", "main", "messages", "options", "overlay", "prefs", ["promises", "CancelablePromise", "Promise", "Task", "promises"], "protocol", "sanitizer", "services", "storage", "styles", "template", "util"], window: ["dactyl", "modes", "commandline", "abbreviations", "autocommands", "editor", "events", "hints", "key-processors", "mappings", "marks", "mow", "statusline"] }, loadStyles: function loadStyles(force) { highlight.styleableChrome = this.styleableChrome; highlight.loadCSS(this.CSS.replace(/__MSG_(.*?)__/g, (m0, m1) => _(m1))); highlight.loadCSS(this.helpCSS.replace(/__MSG_(.*?)__/g, (m0, m1) => _(m1))); let hl = highlight.set("Find", ""); hl.onChange = function () { function hex(val) { return ("#" + util.regexp.iterate(/\d+/g, val) .map(num => ("0" + Number(num).toString(16)).slice(-2)) .join("") ).slice(0, 7); } let elem = services.appShell.hiddenDOMWindow.document.createElement("div"); elem.style.cssText = this.cssText; let keys = iter(Styles.propertyIter(this.cssText)).map(p => p.name).toArray(); let bg = keys.some(bind("test", /^background/)); let fg = keys.indexOf("color") >= 0; let style = DOM(elem).style; prefs[bg ? "safeSet" : "safeReset"]("ui.textHighlightBackground", hex(style.backgroundColor)); prefs[fg ? "safeSet" : "safeReset"]("ui.textHighlightForeground", hex(style.color)); }; }, get addonID() { return this.name + "@dactyl.googlecode.com"; }, addon: Class.Memoize(function () { return (JSMLoader.bootstrap || {}).addon; }), addonData: Class.Memoize(function () { return (JSMLoader.bootstrap || {}).addonData; }), basePath: Class.Memoize(function () { return (JSMLoader.bootstrap || {}).basePath; }), resourceURI: Class.Memoize(function () { return this.addonData.resourceURI; }), get styleableChrome() { return Object.keys(this.overlays); }, /** * The current application locale. */ appLocale: Class.Memoize(() => services.chromeRegistry.getSelectedLocale("global")), /** * The current dactyl locale. */ locale: Class.Memoize(function () { return this.bestLocale(this.locales); }), /** * The current application locale. */ locales: Class.Memoize(function () { // TODO: Merge with completion.file code. function getDir(str) { return str.match(/^(?:.*[\/\\])?/)[0]; } let uri = "resource://dactyl-locale/"; let jar = io.isJarURL(uri); let res; if (jar) { let prefix = getDir(jar.JAREntry); res = Array.from(io.listJar(jar.JARFile, prefix), s => s.slice(prefix.length).replace(/\/.*/, "")); } else { res = Array.from(util.getFile(uri).readDirectory()) .filter(f => f.isDirectory()) .map(f => f.leafName); } let exists = pkg => { return services["resource:"].hasSubstitution("dactyl-locale-" + pkg); }; return Ary.uniq([this.appLocale, this.appLocale.replace(/-.*/, "")] .filter(exists) .concat(res)); }), /** * Returns the best locale match to the current locale from a list * of available locales. * * @param {[string]} list A list of available locales * @returns {string} */ bestLocale: function (list) { let candidates = [this.appLocale, this.appLocale.replace(/-.*/, ""), "en", "en-US", list[0]]; list = new RealSet(list); return candidates.find(locale => list.has(locale)); }, /** * A list of all known registered chrome and resource packages. */ get chromePackages() { // Horrible hack. let res = {}; function process(manifest) { for (let line of manifest.split(/\n+/)) { let match = /^\s*(content|skin|locale|resource)\s+([^\s#]+)\s/.exec(line); if (match) res[match[2]] = true; } } function processJar(file) { let jar = services.ZipReader(file.file); if (jar) try { if (jar.hasEntry("chrome.manifest")) process(File.readStream(jar.getInputStream("chrome.manifest"))); } finally { jar.close(); } } for (let dir of ["UChrm", "AChrom"]) { dir = File(services.directory.get(dir, Ci.nsIFile)); if (dir.exists() && dir.isDirectory()) for (let file of dir.iterDirectory()) if (/\.manifest$/.test(file.leafName)) process(file.read()); dir = File(dir.parent); if (dir.exists() && dir.isDirectory()) for (let file of dir.iterDirectory()) if (/\.jar$/.test(file.leafName)) processJar(file); dir = dir.child("extensions"); if (dir.exists() && dir.isDirectory()) for (let ext of dir.iterDirectory()) { if (/\.xpi$/.test(ext.leafName)) processJar(ext); else { if (ext.isFile()) ext = File(ext.read().replace(/\n*$/, "")); let mf = ext.child("chrome.manifest"); if (mf.exists()) process(mf.read()); } } } return Object.keys(res).sort(); }, /** * Returns true if the current Gecko runtime is of the given version * or greater. * * @param {string} min The minimum required version. @optional * @param {string} max The maximum required version. @optional * @returns {boolean} */ haveGecko: function (min, max) { let { compare } = services.versionCompare; let { platformVersion } = services.runtime; return (min == null || compare(platformVersion, min) >= 0) && (max == null || compare(platformVersion, max) < 0); }, /** Dactyl's notion of the current operating system platform. */ OS: memoize({ _arch: services.runtime.OS, /** * @property {string} The normalised name of the OS. This is one of * "Windows", "Mac OS X" or "Unix". */ get name() { return this.isWindows ? "Windows" : this.isMacOSX ? "Mac OS X" : "Unix"; }, /** @property {boolean} True if the OS is Windows. */ get isWindows() { return this._arch == "WINNT"; }, /** @property {boolean} True if the OS is Mac OS X. */ get isMacOSX() { return this._arch == "Darwin"; }, /** @property {boolean} True if the OS is some other *nix variant. */ get isUnix() { return !this.isWindows; }, /** @property {RegExp} A RegExp which matches illegal characters in path components. */ get illegalCharacters() { return this.isWindows ? /[<>:"/\\|?*\x00-\x1f]/g : /[\/\x00]/g; }, get pathListSep() { return this.isWindows ? ";" : ":"; } }), /** * @property {string} The pathname of the VCS repository clone's root * directory if the application is running from one via an extension * proxy file. */ VCSPath: Class.Memoize(function () { if (/pre$/.test(this.addonData.version)) { // XXX: Sync. let uri = util.newURI("../.hg", null, this.resourceURI); if (uri instanceof Ci.nsIFileURL && uri.file.exists() && io.pathSearch("hg")) return uri.file.parent.path; } return null; }), /** @property {string} The name of the current user profile. */ profileName: Class.Memoize(function () { // NOTE: services.profile.selectedProfile.name doesn't return // what you might expect. It returns the last _actively_ selected // profile (i.e. via the Profile Manager or -P option) rather than the // current profile. These will differ if the current process was run // without explicitly selecting a profile. let dir = services.directory.get("ProfD", Ci.nsIFile); for (let prof of iter(services.profile.profiles)) if (prof.QueryInterface(Ci.nsIToolkitProfile).rootDir.path === dir.path) return prof.name; return "unknown"; }), /** @property {string} The Dactyl version string. */ version: Class.Memoize(function () { return this.addon.version; }), buildDate: Class.Memoize(function () { if (this.VCSPath) return io.system(["hg", "-R", this.VCSPath, "log", "-r.", "--template={date|isodate}"]).output; if ("@DATE@" !== "@" + "DATE@") return _("dactyl.created", "@DATE@"); }), get fileExt() { return this.name.slice(0, -6); }, dtd: Class.Memoize(function () { return Ary.toObject([ ...Object.entries(this.dtdExtra), ...Object.entries(config.dtdDactyl) .map(([k, v]) => ["dactyl." + k, v]), ...config.dtdStrings .map(str => ["dactyl." + str, config[str]]), ]); }), dtdDactyl: memoize({ get name() { return config.name; }, get home() { return "http://5digits.org/"; }, get apphome() { return this.home + this.name; }, code: "http://code.google.com/p/dactyl/", get issues() { return this.home + "bug/" + this.name; }, get plugins() { return "http://5digits.org/" + this.name + "/plugins"; }, get faq() { return this.home + this.name + "/faq"; }, "list.mailto": Class.Memoize(() => config.name + "@googlegroups.com"), "list.href": Class.Memoize(() => "http://groups.google.com/group/" + config.name), "hg.latest": Class.Memoize(function () { return this.code + "source/browse/"; // XXX }), "irc": "irc://irc.oftc.net/#pentadactyl" }), dtdExtra: { "xmlns.dactyl": "http://vimperator.org/namespaces/liberator", "xmlns.html": "http://www.w3.org/1999/xhtml", "xmlns.xul": "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul", "tag.command-line": ["link", { xmlns: "dactyl", topic: "command-line" }, "command line"], "tag.status-line": ["link", { xmlns: "dactyl", topic: "status-line" }, "status line"], "mode.command-line": ["link", { xmlns: "dactyl", topic: "command-line-mode" }, "Command Line"] }, dtdStrings: [ "appName", "fileExt", "host", "hostbin", "idName", "name", "version" ], helpStyles: /^(Help|StatusLine|REPL)|^(Boolean|Dense|Indicator|MoreMsg|Number|Object|Logo|Key(word)?|String)$/, styleHelp: function styleHelp() { if (!this.helpStyled) { for (let k of keys(highlight.loaded)) if (this.helpStyles.test(k)) highlight.loaded[k] = true; } this.helpStyled = true; }, Local: function Local(dactyl, modules, { document, window }) { return { init: function init() { this.loadConfig(document.documentURI); let append = [ ["menupopup", { id: "viewSidebarMenu", xmlns: "xul" }], ["broadcasterset", { id: "mainBroadcasterSet", xmlns: "xul" }]]; for (let [id, [name, key, uri]] of iter(this.sidebars)) { append[0].push( ["menuitem", { observes: "pentadactyl-" + id + "Sidebar", label: name, accesskey: key }]); append[1].push( ["broadcaster", { id: "pentadactyl-" + id + "Sidebar", autoCheck: "false", type: "checkbox", group: "sidebar", sidebartitle: name, sidebarurl: uri, oncommand: "toggleSidebar(this.id || this.observes);" }]); } overlay.overlayWindow(window, { append: append }); }, get window() { return window; }, get document() { return document; }, ids: Class.Update({ get commandContainer() { return document.documentElement.id; } }), browser: Class.Memoize(() => window.gBrowser), tabbrowser: Class.Memoize(() => window.gBrowser), get browserModes() { return [modules.modes.NORMAL]; }, /** * @property {string} The ID of the application's main XUL window. */ mainWindowId: document.documentElement.id, /** * @property {number} The height (px) that is available to the output * window. */ get outputHeight() { return this.browser.mPanelContainer.boxObject.height; }, tabStrip: Class.Memoize(function () { return document.getElementById("TabsToolbar") || this.tabbrowser.mTabContainer; }) }; }, /** * @property {Object} A mapping of names and descriptions * of the autocommands available in this application. Primarily used * for completion results. */ autocommands: {}, /** * @property {Object} A map of :command-complete option values to completer * function names. */ completers: {}, /** * @property {Object} Application specific defaults for option values. The * property names must be the options' canonical names, and the values * must be strings as entered via :set. */ optionDefaults: {}, cleanups: {}, /** * @property {Object} A map of dialogs available via the * :dialog command. Property names map dialog names to an array * with the following elements: * [0] description - A description of the dialog, used in * command completion results for :dialog. * [1] action - The function executed by :dialog. * [2] test - Function which returns true if the dialog is available in * the current window. @optional */ dialogs: {}, /** * @property {set} A list of features available in this * application. Used extensively in feature test macros. Use * dactyl.has(feature) to check for a feature's presence * in this array. */ features: new RealSet(["default-theme"]), /** * @property {string} The file extension used for command script files. * This is the name string sans "dactyl". */ get fileExtension() { return this.name.slice(0, -6); }, guioptions: {}, /** * @property {string} The name of the application that hosts the * extension. E.g., "Firefox" or "XULRunner". */ host: null, /** * @property {string} The name of the extension. * Required. */ name: null, /** * @property {[string]} A list of extra scripts in the dactyl or * application namespaces which should be loaded before dactyl * initialization. */ scripts: [], sidebars: {}, toolbars: [], /** * @constant * @property {string} The default highlighting rules. * See {@link Highlights#loadCSS} for details. */ CSS: Class.Memoize(() => File.readURL("resource://dactyl-skin/global-styles.css")), helpCSS: Class.Memoize(() => File.readURL("resource://dactyl-skin/help-styles.css")) }, { }); JSMLoader.loadSubScript("resource://dactyl-local-content/config.js", this); config.INIT = update(Object.create(config.INIT), config.INIT, { init: function init(dactyl, modules, window) { init.superapply(this, arguments); let img = new window.Image; img.src = this.logo || "resource://dactyl-local-content/logo.png"; img.onload = util.wrapCallback(function () { highlight.loadCSS(` !Logo { display: inline-block; background: url(${img.src}); width: ${img.width}px; height: ${img.height}px; } `); img = null; }); }, load: function load(dactyl, modules, window) { load.superapply(this, arguments); this.timeout(() => { let list = modules.yes_i_know_i_should_not_report_errors_in_these_branches_thanks; this.branch.then(branch => { if (branch && branch !== "default" && !list.includes(branch)) dactyl.warn(_("warn.notDefaultBranch", config.appName, branch)); }); }, 1000); } }); endModule(); // catch(e){ if (typeof e === "string") e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); } // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/contexts.jsm000066400000000000000000000753511264147376100214030ustar00rootroot00000000000000// Copyright (c) 2010-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; defineModule("contexts", { exports: ["Contexts", "Group", "contexts"], require: ["services", "util"] }); lazyRequire("commands", ["ArgType", "CommandOption", "commands"]); lazyRequire("options", ["Option"]); lazyRequire("overlay", ["overlay"]); lazyRequire("storage", ["File"]); lazyRequire("template", ["template"]); var Const = function Const(val) { return Class.Property({ enumerable: true, value: val }); }; var Group = Class("Group", { init: function init(name, description, filter, persist) { this.name = name; this.description = description; this.filter = filter || this.constructor.defaultFilter; this.persist = persist || false; this.hives = []; this.children = []; }, get contexts() { return this.modules.contexts; }, set lastDocument(val) { this._lastDocument = util.weakReference(val); }, get lastDocument() { return this._lastDocument && this._lastDocument.get(); }, modifiable: true, cleanup: function cleanup(reason) { for (let hive of this.hives) util.trapErrors("cleanup", hive); this.hives = []; for (let hive of keys(this.hiveMap)) delete this[hive]; if (reason != "shutdown") this.children.splice(0).forEach(this.contexts.bound.removeGroup); }, destroy: function destroy(reason) { for (let hive of this.hives) util.trapErrors("destroy", hive); if (reason != "shutdown") this.children.splice(0).forEach(this.contexts.bound.removeGroup); }, argsExtra: function argsExtra() { return {}; }, makeArgs: function makeArgs(doc, context, args) { let res = update({ doc: doc, context: context }, args); return update(res, this.argsExtra(res), args); }, get toStringParams() { return [this.name]; }, get builtin() { return this.modules.contexts.builtinGroups.indexOf(this) >= 0; } }, { compileFilter: function (patterns, default_=false) { function siteFilter(uri) { let match = siteFilter.filters.find(f => f(uri)); return match ? match.result : default_; } return update(siteFilter, { toString: function () { return this.filters.join(","); }, toJSONXML: function (modules) { let uri = modules && modules.buffer.uri; return template.map( this.filters, f => ["span", { highlight: uri && f(uri) ? "Filter" : "" }, ("toJSONXML" in f ? f.toJSONXML() : String(f))], ","); }, filters: Option.parse.sitelist(patterns) }); }, defaultFilter: Class.Memoize(function () { return this.compileFilter(["*"]); }) }); var Contexts = Module("contexts", { init: function () { this.pluginModules = {}; }, cleanup: function () { for (let module of values(this.pluginModules)) util.trapErrors("unload", module); this.pluginModules = {}; }, Local: function Local(dactyl, modules, window) { return { init: function () { const contexts = this; this.modules = modules; Object.defineProperty(modules.plugins, "contexts", Const({})); this.groupList = []; this.groupMap = {}; this.groupsProto = {}; this.hives = {}; this.hiveProto = {}; this.builtin = this.addGroup("builtin", "Builtin items"); this.user = this.addGroup("user", "User-defined items", null, true); this.builtinGroups = [this.builtin, this.user]; this.builtin.modifiable = false; this.GroupFlag = Class("GroupFlag", CommandOption, { init: function (name) { this.name = name; this.type = ArgType("group", group => { return isString(group) ? contexts.getGroup(group, name) : group[name]; }); }, get toStringParams() { return [this.name]; }, names: ["-group", "-g"], description: "Group to which to add", get default() { return (contexts.context && contexts.context.group || contexts.user)[this.name]; }, completer: function (context) { modules.completion.group(context); } }); memoize(modules, "userContext", () => contexts.Context(modules.io.getRCFile("~", true), contexts.user, [modules, false])); memoize(modules, "_userContext", () => modules.userContext); }, cleanup: function () { for (let hive of this.groupList.slice()) util.trapErrors("cleanup", hive, "shutdown"); }, destroy: function () { for (let hive of this.groupList.slice()) util.trapErrors("destroy", hive, "shutdown"); for (let plugin of values(this.modules.plugins.contexts)) { if (plugin && "onUnload" in plugin && callable(plugin.onUnload)) util.trapErrors("onUnload", plugin); if (isinstance(plugin, ["Sandbox"])) util.trapErrors("nukeSandbox", Cu, plugin); } }, signals: { "browser.locationChange": function (webProgress, request, uri) { this.flush(); } }, Group: Class("Group", Group, { modules: modules, get hiveMap() { return modules.contexts.hives; }}), Hives: Class("Hives", Class.Property, { init: function init(name, constructor) { const { contexts } = modules; if (this.Hive) return { enumerable: true, get: () => Ary(contexts.groups[this.name]) }; this.Hive = constructor; this.name = name; memoize(contexts.Group.prototype, name, function () { let group = constructor(this); this.hives.push(group); contexts.flush(); return group; }); memoize(contexts.hives, name, () => Object.create( Object.create(contexts.hiveProto, { _hive: { value: name } }))); memoize(contexts.groupsProto, name, function () { return this.groups.filter(group => hasOwnProp(group, name)) .map(group => group[name]); }); }, get toStringParams() { return [this.name, this.Hive]; } }) }; }, Context: function Context(file, group, args) { const { contexts, io, newContext, plugins, userContext } = this.modules; let isPlugin = io.getRuntimeDirectories("plugins") .find(dir => dir.contains(file, true)); let isRuntime = io.getRuntimeDirectories("") .find(dir => dir.contains(file, true)); let name = isPlugin ? file.getRelativeDescriptor(isPlugin).replace(File.PATH_SEP, "-") : file.leafName; let id = util.camelCase(name.replace(/\.[^.]*$/, "")); let contextPath = file.path; let self = hasOwnProp(plugins, contextPath) && plugins.contexts[contextPath]; if (!self && isPlugin && false) self = hasOwnProp(plugins, id) && plugins[id]; if (self) { if (hasOwnProp(self, "onUnload")) util.trapErrors("onUnload", self); } else { let params = Array.slice(args || [userContext]); params[2] = params[2] || File(file).URI.spec; self = args && !isArray(args) ? args : newContext.apply(null, params); update(self, { NAME: Const(id), PATH: Const(file.path), CONTEXT: Const(self), set isGlobalModule(val) { // Hack. if (val) throw Contexts; }, unload: Const(function unload() { if (plugins[this.NAME] === this || plugins[this.PATH] === this) if (this.onUnload) util.trapErrors("onUnload", this); if (plugins[this.NAME] === this) delete plugins[this.NAME]; if (plugins[this.PATH] === this) delete plugins[this.PATH]; if (plugins.contexts[contextPath] === this) delete plugins.contexts[contextPath]; if (!this.GROUP.builtin) contexts.removeGroup(this.GROUP); }) }); if (group !== this.user) Class.replaceProperty(plugins, file.path, self); // This belongs elsewhere if (isPlugin) Object.defineProperty(plugins, self.NAME, { configurable: true, enumerable: true, get: function () { return self; }, set: function (val) { util.dactyl(val).reportError(FailedAssertion(_("plugin.notReplacingContext", self.NAME), 3, false), true); } }); } let path = isRuntime ? file.getRelativeDescriptor(isRuntime) : file.path; name = isRuntime ? path.replace(/^(plugin|color)s([\\\/])/, "$1$2") : "script-" + path; if (!group) group = this.addGroup(commands.nameRegexp .iterate(name.replace(/\.[^.]*$/, "")) .join("-").replace(/--+/g, "-"), _("context.scriptGroup", file.path), null, false); Class.replaceProperty(self, "GROUP", group); Class.replaceProperty(self, "group", group); return plugins.contexts[contextPath] = self; }, Script: function Script(file, group) { return this.Context(file, group, [this.modules.userContext, true]); }, Module: function Module(uri, isPlugin) { const { io, plugins } = this.modules; let canonical = uri.spec; if (uri.scheme == "resource") canonical = services["resource:"].resolveURI(uri); if (uri instanceof Ci.nsIFileURL) var file = File(uri.file); isPlugin = io.getRuntimeDirectories("plugins") .find(dir => dir.contains(file, true)); let name = isPlugin && file && file.getRelativeDescriptor(isPlugin) .replace(File.PATH_SEP, "-"); let id = util.camelCase(name.replace(/\.[^.]*$/, "")); let self = hasOwnProp(this.pluginModules, canonical) && this.pluginModules[canonical]; if (!self) { self = Object.create(jsmodules); update(self, { NAME: Const(id), PATH: Const(file && file.path), CONTEXT: Const(self), get isGlobalModule() { return true; }, set isGlobalModule(val) { util.assert(val, "Loading non-global module as global", false); }, unload: Const(function unload() { if (contexts.pluginModules[canonical] == this) { if (this.onUnload) util.trapErrors("onUnload", this); delete contexts.pluginModules[canonical]; } for (let { plugins } of overlay.modules) if (plugins[this.NAME] == this) delete plugins[this.name]; }) }); JSMLoader.loadSubScript(uri.spec, self, File.defaultEncoding); this.pluginModules[canonical] = self; } // This belongs elsewhere if (isPlugin) Object.defineProperty(plugins, self.NAME, { configurable: true, enumerable: true, get: function () { return self; }, set: function (val) { util.dactyl(val).reportError(FailedAssertion(_("plugin.notReplacingContext", self.NAME), 3, false), true); } }); return self; }, context: null, /** * Returns a frame object describing the currently executing * command, if applicable, otherwise returns the passed frame. * * @param {nsIStackFrame} frame */ getCaller: function getCaller(frame) { if (this.context && this.context.file) return { __proto__: frame, filename: this.context.file[0] == "[" ? this.context.file : File(this.context.file).URI.spec, lineNumber: this.context.line }; return frame; }, groups: Class.Memoize(function () { return this.matchingGroups(); }), allGroups: Class.Memoize(function () { return Object.create(this.groupsProto, { groups: { value: this.initializedGroups() } }); }), matchingGroups: function (uri) { return Object.create(this.groupsProto, { groups: { value: this.activeGroups(uri) } }); }, activeGroups: function (uri) { if (uri instanceof Ci.nsIDOMDocument) var [doc, uri] = [uri, uri.documentURIObject || util.newURI(uri.documentURI)]; if (!uri) var { uri, doc } = this.modules.buffer; return this.initializedGroups().filter(function (g) { let res = uri && g.filter(uri, doc); if (doc) g.lastDocument = res && doc; return res; }); }, flush: function flush() { delete this.groups; delete this.allGroups; }, initializedGroups: function (hive) { let need = hive ? [hive] : Object.keys(this.hives); return this.groupList.filter(group => need.some(hasOwnProp.bind(null, group))); }, addGroup: function addGroup(name, description, filter, persist, replace) { let group = this.getGroup(name); if (group) name = group.name; if (!group) { group = this.Group(name, description, filter, persist); this.groupList.unshift(group); this.groupMap[name] = group; this.hiveProto.__defineGetter__(name, function () { return group[this._hive]; }); } if (replace) { util.trapErrors("cleanup", group); if (description) group.description = description; if (filter) group.filter = filter; group.persist = persist; } this.flush(); return group; }, removeGroup: function removeGroup(name) { if (isObject(name)) { if (this.groupList.indexOf(name) === -1) return; name = name.name; } let group = this.getGroup(name); util.assert(!group || !group.builtin, _("group.cantRemoveBuiltin")); if (group) { name = group.name; this.groupList.splice(this.groupList.indexOf(group), 1); util.trapErrors("destroy", group); } if (this.context && this.context.group === group) this.context.group = null; delete this.groupMap[name]; delete this.hiveProto[name]; this.flush(); return group; }, getGroup: function getGroup(name, hive) { if (name === "default") var group = this.context && this.context.context && this.context.context.GROUP; else if (hasOwnProp(this.groupMap, name)) group = this.groupMap[name]; if (group && hive) return group[hive]; return group; }, getDocs: function getDocs(context) { try { if (DOM.isJSONXML(context.INFO)) return context.INFO; } catch (e) {} return null; }, bindMacro: function (args, default_, params) { const { dactyl, events, modules } = this.modules; function Proxy(obj, key) { return Class.Property({ configurable: true, enumerable: true, get: function Proxy_get() { return process(obj[key]); }, set: function Proxy_set(val) { obj[key] = val; } }); } let process = identity; if (callable(params)) var makeParams = function makeParams(self, args) { let obj = params.apply(self, args); return iter.toObject([k, Proxy(obj, k)] for (k of properties(obj))); }; else if (params) makeParams = function makeParams(self, args) { return iter.toObject([name, process(args[i])] for ([i, name] of iter(params))); }; let rhs = args.literalArg; let type = ["-builtin", "-ex", "-javascript", "-keys"].reduce((a, b) => args[b] ? b : a, default_); let noremap = false; switch (type) { case "-builtin": noremap = true; /* fallthrough */ case "-keys": let silent = args["-silent"]; rhs = DOM.Event.canonicalKeys(rhs, true); var action = function action() { events.feedkeys(action.macro(makeParams(this, arguments)), noremap, silent); }; action.macro = util.compileMacro(rhs, true); break; case "-ex": action = function action() { return modules.commands .execute(action.macro, makeParams(this, arguments), false, null, action.context); }; action.macro = util.compileMacro(rhs, true); action.context = this.context && update({}, this.context); break; case "-javascript": if (callable(params)) action = dactyl.userEval("(function action() { with (action.makeParams(this, arguments)) {" + args.literalArg + "} })"); else action = apply(dactyl, "userFunc", params.concat(args.literalArg)); process = param => isObject(param) && param.valueOf ? param.valueOf() : param; action.params = params; action.makeParams = makeParams; break; } action.toString = function toString() { return (type === default_ ? "" : type + " ") + rhs; }; args = null; return action; }, withContext: function withContext(defaults, callback, self) { return this.withSavedValues(["context"], function () { this.context = defaults && update({}, defaults); return callback.call(self, this.context); }); } }, { Hive: Class("Hive", { init: function init(group) { this.group = group; }, cleanup: function cleanup() {}, destroy: function destroy() {}, get modifiable() { return this.group.modifiable; }, get argsExtra() { return this.group.argsExtra; }, get makeArgs() { return this.group.makeArgs; }, get builtin() { return this.group.builtin; }, get name() { return this.group.name; }, set name(val) { this.group.name = val; }, get description() { return this.group.description; }, set description(val) { this.group.description = val; }, get filter() { return this.group.filter; }, set filter(val) { this.group.filter = val; }, get persist() { return this.group.persist; }, set persist(val) { this.group.persist = val; }, prefix: Class.Memoize(function () { return this.name === "builtin" ? "" : this.name + ":"; }), get toStringParams() { return [this.name]; } }) }, { commands: function initCommands(dactyl, modules, window) { const { commands, contexts } = modules; commands.add(["gr[oup]"], "Create or select a group", function (args) { if (args.length > 0) { var name = Option.dequote(args[0]); util.assert(name !== "builtin", _("group.cantModifyBuiltin")); util.assert(commands.validName.test(name), _("group.invalidName", name)); var group = contexts.getGroup(name); } else if (args.bang) var group = args.context && args.context.group; else return void modules.completion.listCompleter("group", "", null, null); util.assert(group || name, _("group.noCurrent")); let filter = Group.compileFilter(args["-locations"]); if (!group || args.bang) group = contexts.addGroup(name, args["-description"], filter, !args["-nopersist"], args.bang); else if (!group.builtin) { if (args.has("-locations")) group.filter = filter; if (args.has("-description")) group.description = args["-description"]; if (args.has("-nopersist")) group.persist = !args["-nopersist"]; } if (!group.builtin && args.has("-args")) { group.argsExtra = contexts.bindMacro({ literalArg: "return " + args["-args"] }, "-javascript", identity); group.args = args["-args"]; } if (args.context) { args.context.group = group; if (args.context.context) { args.context.context.group = group; let parent = args.context.context.GROUP; if (parent && parent != group) { group.parent = parent; if (!~parent.children.indexOf(group)) parent.children.push(group); } } } util.assert(!group.builtin || !["-description", "-locations", "-nopersist"] .some(prop => hasOwnProp(args.explicitOpts, prop)), _("group.cantModifyBuiltin")); }, { argCount: "?", bang: true, completer: function (context, args) { if (args.length == 1) modules.completion.group(context); }, keepQuotes: true, options: [ { names: ["-args", "-a"], description: "JavaScript Object which augments the arguments passed to commands, mappings, and autocommands", type: CommandOption.STRING }, { names: ["-description", "-desc", "-d"], description: "A description of this group", default: "User-defined group", type: CommandOption.STRING }, { names: ["-locations", "-locs", "-loc", "-l"], description: "The URLs for which this group should be active", default: ["*"], type: CommandOption.LIST }, { names: ["-nopersist", "-n"], description: "Do not save this group to an auto-generated RC file" } ], serialGroup: 20, serialize: function () { return contexts.initializedGroups() .filter(group => !group.builtin && group.persist) .map(group => ({ command: this.name, bang: true, options: Ary.toObject( Object.entries({ args: "-args", description: "-description", filter: "-locations" }) .filter(([k]) => group[k]) .map(([k, v]) => [v, typeof group[k] == "boolean" ? null : group[k]]) ), arguments: [group.name], ignoreDefaults: true })) .concat([{ command: this.name, arguments: ["user"] }]); } }); commands.add(["delg[roup]"], "Delete a group", function (args) { util.assert(args.bang ^ !!args[0], _("error.argumentOrBang")); if (args.bang) contexts.groupList = contexts.groupList.filter(g => g.builtin); else { util.assert(contexts.getGroup(args[0]), _("group.noSuch", args[0])); contexts.removeGroup(args[0]); } }, { argCount: "?", bang: true, completer: function (context, args) { if (args.bang) return; context.filters.push(({ item }) => !item.builtin); modules.completion.group(context); } }); commands.add(["fini[sh]"], "Stop sourcing a script file", function (args) { util.assert(args.context, _("command.finish.illegal")); args.context.finished = true; }, { argCount: "0" }); function checkStack(cmd) { util.assert(contexts.context && contexts.context.stack && contexts.context.stack[cmd] && contexts.context.stack[cmd].length, _("command.conditional.illegal")); } function pop(cmd) { checkStack(cmd); return contexts.context.stack[cmd].pop(); } function push(cmd, value) { util.assert(contexts.context, _("command.conditional.illegal")); if (arguments.length < 2) value = contexts.context.noExecute; contexts.context.stack = contexts.context.stack || {}; contexts.context.stack[cmd] = (contexts.context.stack[cmd] || []).concat([value]); } commands.add(["if"], "Execute commands until the next :elseif, :else, or :endif only if the argument returns true", function (args) { args.context.noExecute = !dactyl.userEval(args[0]); }, { always: function (args) { push("if"); }, argCount: "1", literal: 0 }); commands.add(["elsei[f]", "elif"], "Execute commands until the next :elseif, :else, or :endif only if the argument returns true", function () {}, { always: function (args) { checkStack("if"); args.context.noExecute = args.context.stack.if.slice(-1)[0] || !args.context.noExecute || !dactyl.userEval(args[0]); }, argCount: "1", literal: 0 }); commands.add(["el[se]"], "Execute commands until the next :endif only if the previous conditionals were not executed", function () {}, { always: function (args) { checkStack("if"); args.context.noExecute = args.context.stack.if.slice(-1)[0] || !args.context.noExecute; }, argCount: "0" }); commands.add(["en[dif]", "fi"], "End a string of :if/:elseif/:else conditionals", function () {}, { always: function (args) { args.context.noExecute = pop("if"); }, argCount: "0" }); }, completion: function initCompletion(dactyl, modules, window) { const { completion, contexts } = modules; completion.group = function group(context, active) { context.title = ["Group"]; let uri = modules.buffer.uri; context.keys = { active: group => group.filter(uri), text: "name", description: g => ["", g.filter.toJSONXML ? g.filter.toJSONXML(modules).concat("\u00a0") : "", g.description || ""], }; context.completions = (active === undefined ? contexts.groupList : contexts.initializedGroups(active)) .slice(0, -1); iter({ Active: true, Inactive: false }).forEach(function ([name, active]) { context.split(name, null, context => { context.title[0] = name + " Groups"; context.filters.push(({ item }) => !!item.filter(modules.buffer.uri) == active); }); }); }; } }); endModule(); // catch(e){ if (!e.stack) e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); } // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/dom.jsm000066400000000000000000002160341264147376100203060ustar00rootroot00000000000000// Copyright (c) 2007-2011 by Doug Kearns // Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; defineModule("dom", { exports: ["$", "DOM", "NS", "XBL", "XHTML", "XUL"] }); lazyRequire("highlight", ["highlight"]); lazyRequire("messages", ["_"]); lazyRequire("overlay", ["overlay"]); lazyRequire("prefs", ["prefs"]); lazyRequire("template", ["template"]); var XBL = "http://www.mozilla.org/xbl"; var XHTML = "http://www.w3.org/1999/xhtml"; var XUL = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"; var NS = "http://vimperator.org/namespaces/liberator"; function BooleanAttribute(attr) { return { get: function (elem) { return elem.getAttribute(attr) == "true"; }, set: function (elem, val) { if (val === "false" || !val) elem.removeAttribute(attr); else elem.setAttribute(attr, true); } }; } /** * @class * * A jQuery-inspired DOM utility framework. * * Please note that while this currently implements an Array-like * interface, this is *not a defined interface* and is very likely to * change in the near future. */ var DOM = Class("DOM", { init: function init(val, context, nodes) { let self; let length = 0; if (nodes) this.nodes = nodes; if (context instanceof Ci.nsIDOMDocument) this.document = context; if (typeof val == "string") val = context.querySelectorAll(val); if (val == null) ; else if (DOM.isJSONXML(val)) { if (context instanceof Ci.nsIDOMDocument) this[length++] = DOM.fromJSON(val, context, this.nodes); else this[length++] = val; } else if (val instanceof Ci.nsIDOMNode || val instanceof Ci.nsIDOMWindow) this[length++] = val; else if (Symbol.iterator in val) for (let elem of val) this[length++] = elem; else if (isinstance(val, ["Iterator", "Generator"])) for (let elem in val) this[length++] = elem; else if ("length" in val) for (let i = 0; i < val.length; i++) this[length++] = val[i]; else this[length++] = val; this.length = length; return self || this; }, "@@iterator": function* __iterator__() { for (let i = 0; i < this.length; i++) yield this[i]; }, Empty: function Empty() { return this.constructor(null, this.document); }, nodes: Class.Memoize(() => ({})), get items() { return function* () { for (let i = 0; i < this.length; i++) /* FIXME: Symbols */ yield this.eq(i); }.call(this); }, get document() { return this._document || this[0] && (this[0].ownerDocument || this[0].document || this[0]); }, set document(val) { this._document = val; }, attrHooks: { "": { href: { get: elem => elem.href || elem.getAttribute("href") }, src: { get: elem => elem.src || elem.getAttribute("src") }, checked: { get: elem => elem.hasAttribute("checked") ? elem.getAttribute("checked") == "true" : elem.checked, set: (elem, val) => { elem.setAttribute("checked", !!val); elem.checked = val; } }, collapsed: BooleanAttribute("collapsed"), disabled: BooleanAttribute("disabled"), hidden: BooleanAttribute("hidden"), readonly: BooleanAttribute("readonly") } }, matcher: function matcher(sel) { return elem => (elem.mozMatchesSelector && elem.mozMatchesSelector(sel)); }, each: function each(fn, self) { let obj = self || this.Empty(); for (let i = 0; i < this.length; i++) fn.call(self || update(obj, [this[i]]), this[i], i); return this; }, eachDOM: function eachDOM(val, fn, self) { let dom = this; function munge(val, container, idx) { if (val instanceof Ci.nsIDOMRange) return val.extractContents(); if (val instanceof Ci.nsIDOMNode) return val; if (DOM.isJSONXML(val)) { val = dom.constructor(val, dom.document); if (container) container[idx] = val[0]; } if (isObject(val) && "length" in val) { let frag = dom.document.createDocumentFragment(); for (let i = 0; i < val.length; i++) frag.appendChild(munge(val[i], val, i)); return frag; } return val; } if (DOM.isJSONXML(val)) val = (function () { return this; }).bind(val); if (callable(val)) return this.each(function (elem, i) { util.withProperErrors(fn, this, munge(val.call(this, elem, i)), elem, i); }, self || this); if (this.length) util.withProperErrors(fn, self || this, munge(val), this[0], 0); return this; }, eq: function eq(idx) { return this.constructor(this[idx >= 0 ? idx : this.length + idx]); }, find: function find(val) { return this.map(elem => elem.querySelectorAll(val)); }, findAnon: function findAnon(attr, val) { return this.map(elem => elem.ownerDocument.getAnonymousElementByAttribute(elem, attr, val)); }, filter: function filter(val, self) { let res = this.Empty(); if (!callable(val)) val = this.matcher(val); this.constructor(Array.filter(this, val, self || this)); let obj = self || this.Empty(); for (let i = 0; i < this.length; i++) if (val.call(self || update(obj, [this[i]]), this[i], i)) res[res.length++] = this[i]; return res; }, is: function is(val) { return this.some(this.matcher(val)); }, reverse: function reverse() { Array.reverse(this); return this; }, all: function all(fn, self) { let res = this.Empty(); this.each(function (elem) { while (true) { elem = fn.call(this, elem); if (elem instanceof Ci.nsIDOMNode) res[res.length++] = elem; else if (elem && "length" in elem) for (let i = 0; i < elem.length; i++) res[res.length++] = elem[j]; else break; } }, self || this); return res; }, map: function map(fn, self) { let res = this.Empty(); let obj = self || this.Empty(); for (let i = 0; i < this.length; i++) { let tmp = fn.call(self || update(obj, [this[i]]), this[i], i); if (isObject(tmp) && !(tmp instanceof Ci.nsIDOMNode) && "length" in tmp) for (let j = 0; j < tmp.length; j++) res[res.length++] = tmp[j]; else if (tmp != null) res[res.length++] = tmp; } return res; }, slice: function eq(start, end) { return this.constructor(Array.slice(this, start, end)); }, some: function some(fn, self) { for (let i = 0; i < this.length; i++) if (fn.call(self || this, this[i], i)) return true; return false; }, get parent() { return this.map(elem => elem.parentNode, this); }, get offsetParent() { return this.map(function (elem) { do { var parent = elem.offsetParent; if (parent instanceof Ci.nsIDOMElement && DOM(parent).position != "static") return parent; } while (parent); }, this); }, get ancestors() { return this.all(elem => elem.parentNode); }, get children() { return this.map( elem => Array.filter(elem.childNodes, e => e instanceof Ci.nsIDOMElement), this); }, get contents() { return this.map(elem => elem.childNodes, this); }, get siblings() { return this.map( elem => Array.filter(elem.parentNode.childNodes, e => e != elem && e instanceof Ci.nsIDOMElement), this); }, get siblingsBefore() { return this.all(elem => elem.previousElementSibling); }, get siblingsAfter() { return this.all(elem => elem.nextElementSibling); }, get allSiblingsBefore() { return this.all(elem => elem.previousSibling); }, get allSiblingsAfter() { return this.all(elem => elem.nextSibling); }, get class() { let self = this; return { toString: function () { return self[0].className; }, get list() { return Array.slice(self[0].classList); }, set list(val) { self.attr("class", val.join(" ")); }, each: function each(meth, arg) { return self.each(function (elem) { elem.classList[meth](arg); }); }, add: function add(cls) { return this.each("add", cls); }, remove: function remove(cls) { return this.each("remove", cls); }, toggle: function toggle(cls, val, thisObj) { if (callable(val)) return self.each(function (elem, i) { this.class.toggle(cls, val.call(thisObj || this, elem, i)); }); return this.each(val == null ? "toggle" : val ? "add" : "remove", cls); }, has: function has(cls) { return this[0].classList.has(cls); } }; }, get highlight() { let self = this; return { toString: function () { return self.attrNS(NS, "highlight") || ""; }, get list() { let s = this.toString().trim(); return s ? s.split(/\s+/) : []; }, set list(val) { let str = Ary.uniq(val).join(" ").trim(); self.attrNS(NS, "highlight", str || null); }, has: function has(hl) { return ~this.list.indexOf(hl); }, add: function add(hl) { self.each(function () { highlight.loaded[hl] = true; this.highlight.list = this.highlight.list.concat(hl); }); }, remove: function remove(hl) { self.each(function () { this.highlight.list = this.highlight.list.filter(h => h != hl); }); }, toggle: function toggle(hl, val, thisObj) { self.each(function (elem, i) { let { highlight } = this; let v = callable(val) ? val.call(thisObj || this, elem, i) : val; highlight[(v == null ? highlight.has(hl) : !v) ? "remove" : "add"](hl); }); } }; }, get rect() { return this[0] instanceof Ci.nsIDOMWindow ? { width: this[0].scrollMaxX + this[0].innerWidth, height: this[0].scrollMaxY + this[0].innerHeight, get right() { return this.width + this.left; }, get bottom() { return this.height + this.top; }, top: -this[0].scrollY, left: -this[0].scrollX } : this[0] ? this[0].getBoundingClientRect() : {}; }, get viewport() { let node = this[0]; if (node instanceof Ci.nsIDOMDocument) node = node.defaultView; if (node instanceof Ci.nsIDOMWindow) return { get width() { return this.right - this.left; }, get height() { return this.bottom - this.top; }, bottom: node.innerHeight, right: node.innerWidth, top: 0, left: 0 }; let r = this.rect; return { width: node.clientWidth, height: node.clientHeight, top: r.top + node.clientTop, get bottom() { return this.top + this.height; }, left: r.left + node.clientLeft, get right() { return this.left + this.width; } }; }, scrollPos: function scrollPos(left, top) { if (arguments.length == 0) { if (this[0] instanceof Ci.nsIDOMElement) return { top: this[0].scrollTop, left: this[0].scrollLeft, height: this[0].scrollHeight, width: this[0].scrollWidth, innerHeight: this[0].clientHeight, innerWidth: this[0].innerWidth }; if (this[0] instanceof Ci.nsIDOMWindow) return { top: this[0].scrollY, left: this[0].scrollX, height: this[0].scrollMaxY + this[0].innerHeight, width: this[0].scrollMaxX + this[0].innerWidth, innerHeight: this[0].innerHeight, innerWidth: this[0].innerWidth }; return null; } let func = callable(left) && left; return this.each(function (elem, i) { if (func) ({ left, top } = func.call(this, elem, i)); if (elem instanceof Ci.nsIDOMWindow) elem.scrollTo(left == null ? elem.scrollX : left, top == null ? elem.scrollY : top); else { if (left != null) elem.scrollLeft = left; if (top != null) elem.scrollTop = top; } }); }, /** * Returns true if the given DOM node is currently visible. * @returns {boolean} */ get isVisible() { let style = this[0] && this.style; return style && style.visibility == "visible" && style.display != "none"; }, get editor() { if (!this.length) return; this[0] instanceof Ci.nsIDOMNSEditableElement; try { if (this[0].editor instanceof Ci.nsIEditor) var editor = this[0].editor; } catch (e) { util.reportError(e); } try { if (!editor) editor = this[0].QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIWebNavigation) .QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIEditingSession) .getEditorForWindow(this[0]); } catch (e) {} editor instanceof Ci.nsIPlaintextEditor; editor instanceof Ci.nsIHTMLEditor; return editor; }, get isEditable() { return !!this.editor || this[0] instanceof Ci.nsIDOMElement && this.style.MozUserModify == "read-write"; }, get isInput() { return isinstance(this[0], [Ci.nsIDOMHTMLInputElement, Ci.nsIDOMHTMLTextAreaElement, Ci.nsIDOMXULTextBoxElement]) && this.isEditable; }, /** * Returns an object representing a Node's computed CSS style. * @returns {Object} */ get style() { let node = this[0]; if (node instanceof Ci.nsIDOMWindow) node = node.document; if (node instanceof Ci.nsIDOMDocument) node = node.documentElement; while (node && !(node instanceof Ci.nsIDOMElement) && node.parentNode) node = node.parentNode; try { var res = node.ownerDocument.defaultView.getComputedStyle(node, null); } catch (e) { util.reportError(e); } if (res == null) { util.dumpStack(_("error.nullComputedStyle", node)); Cu.reportError(Error(_("error.nullComputedStyle", node))); return {}; } return res; }, /** * Parses the fields of a form and returns a URL/POST-data pair * that is the equivalent of submitting the form. * * @returns {object} An object with the following elements: * url: The URL the form points to. * postData: A string containing URL-encoded post data, if this * form is to be POSTed * charset: The character set of the GET or POST data. * elements: The key=value pairs used to generate query information. */ // Nuances gleaned from browser.jar/content/browser/browser.js get formData() { function encode(name, value, param) { param = param ? "%s" : ""; if (post) return name + "=" + encodeComponent(value + param); return encodeComponent(name) + "=" + encodeComponent(value) + param; } let field = this[0]; let form = field.form; let doc = form.ownerDocument; let charset = doc.characterSet; let converter = services.CharsetConv(charset); for (let cs of form.acceptCharset.split(/\s*,\s*|\s+/)) { let c = cs && services.CharsetConv(cs); if (c) { converter = services.CharsetConv(cs); charset = cs; } } let uri = util.newURI(doc.baseURI.replace(/\?.*/, ""), charset); let url = util.newURI(form.action, charset, uri).spec; let post = form.method.toUpperCase() == "POST"; let encodeComponent = encodeURIComponent; if (charset !== "UTF-8") encodeComponent = function encodeComponent(str) { return escape(converter.ConvertFromUnicode(str) + converter.Finish()); }; let elems = []; if (field instanceof Ci.nsIDOMHTMLInputElement && field.type == "submit") elems.push(encode(field.name, field.value)); for (let elem of form.elements) if (elem.name && !elem.disabled) { if (DOM(elem).isInput || /^(?:hidden|textarea)$/.test(elem.type) || elem.type == "submit" && elem == field || elem.checked && /^(?:checkbox|radio)$/.test(elem.type)) { if (elem !== field) elems.push(encode(elem.name, elem.value)); else if (overlay.getData(elem, "had-focus")) elems.push(encode(elem.name, elem.value, true)); else elems.push(encode(elem.name, "", true)); } else if (elem instanceof Ci.nsIDOMHTMLSelectElement) { for (let opt of elem.options) if (opt.selected) elems.push(encode(elem.name, opt.value)); } } if (post) return { url: url, postData: elems.join('&'), charset: charset, elements: elems }; return { url: url + "?" + elems.join('&'), postData: null, charset: charset, elements: elems }; }, /** * Generates an XPath expression for the given element. * * @returns {string} */ get xpath() { function quote(val) { return "'" + val.replace(/[\\']/g, "\\$&") + "'"; } if (!(this[0] instanceof Ci.nsIDOMElement)) return null; let res = []; let doc = this.document; for (let elem = this[0];; elem = elem.parentNode) { if (!(elem instanceof Ci.nsIDOMElement)) res.push(""); else if (elem.id) res.push("id(" + quote(elem.id) + ")"); else { let name = elem.localName; if (elem.namespaceURI && (elem.namespaceURI != XHTML || doc.xmlVersion)) if (elem.namespaceURI in DOM.namespaceNames) name = DOM.namespaceNames[elem.namespaceURI] + ":" + name; else name = "*[local-name()=" + quote(name) + " and namespace-uri()=" + quote(elem.namespaceURI) + "]"; res.push(name + "[" + (1 + iter(DOM.XPath("./" + name, elem.parentNode)).indexOf(elem)) + "]"); continue; } break; } return res.reverse().join("/"); }, /** * Returns a string or XML representation of this node. * * @param {boolean} color If true, return a colored, XML * representation of this node. */ repr: function repr(color) { function namespaced(node) { var ns = DOM.namespaceNames[node.namespaceURI] || /^(?:(.*?):)?/.exec(node.name)[1]; if (!ns) return node.localName; if (color) return [["span", { highlight: "HelpXMLNamespace" }, ns], node.localName]; return ns + ":" + node.localName; } let res = []; this.each(function (elem) { try { let hasChildren = elem.firstChild && (!/^\s*$/.test(elem.firstChild) || elem.firstChild.nextSibling); if (color) res.push(["span", { highlight: "HelpXML" }, ["span", { highlight: "HelpXMLTagStart" }, "<", namespaced(elem), " ", template.map(elem.attributes, attr => [ ["span", { highlight: "HelpXMLAttribute" }, namespaced(attr)], ["span", { highlight: "HelpXMLString" }, attr.value] ], " "), !hasChildren ? "/>" : ">", ], !hasChildren ? "" : ["", "...", ["span", { highlight: "HtmlTagEnd" }, "<", namespaced(elem), ">"]] ]); else { let escape = val => val.replace(/["<]/g, DOM.escapeHTML); let tag = "<" + [ namespaced(elem), ...Array.from(elem.attributes, attr => `${namespaced(attr)}="${escape(attr.value)}"`), ].join(" "); res.push(tag + (!hasChildren ? "/>" : ">...")); } } catch (e) { res.push({}.toString.call(elem)); } }, this); res = template.map(res, identity, ","); return color ? res : res.join(""); }, attr: function attr(key, val) { return this.attrNS("", key, val); }, attrNS: function attrNS(ns, key, val) { if (val !== undefined) key = Ary.toObject([[key, val]]); let hooks = this.attrHooks[ns] || {}; if (isObject(key)) return this.each(function (elem, i) { for (let [k, v] of iter(key)) { if (callable(v)) v = v.call(this, elem, i); if (hasOwnProp(hooks, k) && hooks[k].set) hooks[k].set.call(this, elem, v, k); else if (v == null) elem.removeAttributeNS(ns, k); else elem.setAttributeNS(ns, k, v); } }); if (!this.length) return null; if (hasOwnProp(hooks, key) && hooks[key].get) return hooks[key].get.call(this, this[0], key); if (!this[0].hasAttributeNS(ns, key)) return null; return this[0].getAttributeNS(ns, key); }, css: update(function css(props, val = undefined) { if (val !== undefined) props = { [props]: val }; if (isObject(props)) return this.each(elem => { for (let [k, v] of Object.entries(props)) elem.style[css.property(k)] = v; }); return this[0].style[css.property(props)]; }, { name: function (property) { return property.replace(/[A-Z]/g, m0 => "-" + m0.toLowerCase()); }, property: function (name) { return name.replace(/-(.)/g, (m0, m1) => m1.toUpperCase()); } }), append: function append(val) { return this.eachDOM(val, function (elem, target) { target.appendChild(elem); }); }, prepend: function prepend(val) { return this.eachDOM(val, function (elem, target) { target.insertBefore(elem, target.firstChild); }); }, before: function before(val) { return this.eachDOM(val, function (elem, target) { target.parentNode.insertBefore(elem, target); }); }, after: function after(val) { return this.eachDOM(val, function (elem, target) { target.parentNode.insertBefore(elem, target.nextSibling); }); }, appendTo: function appendTo(elem) { if (!(elem instanceof this.constructor)) elem = this.constructor(elem, this.document); elem.append(this); return this; }, prependTo: function prependTo(elem) { if (!(elem instanceof this.constructor)) elem = this.constructor(elem, this.document); elem.prepend(this); return this; }, insertBefore: function insertBefore(elem) { if (!(elem instanceof this.constructor)) elem = this.constructor(elem, this.document); elem.before(this); return this; }, insertAfter: function insertAfter(elem) { if (!(elem instanceof this.constructor)) elem = this.constructor(elem, this.document); elem.after(this); return this; }, remove: function remove() { return this.each(function (elem) { if (elem.parentNode) elem.parentNode.removeChild(elem); }, this); }, empty: function empty() { return this.each(function (elem) { while (elem.firstChild) elem.removeChild(elem.firstChild); }, this); }, fragment: function fragment() { let frag = this.document.createDocumentFragment(); this.appendTo(frag); return this; }, clone: function clone(deep) { return this.map(elem => elem.cloneNode(deep)); }, toggle: function toggle(val, self) { if (callable(val)) return this.each(function (elem, i) { this[val.call(self || this, elem, i) ? "show" : "hide"](); }); if (arguments.length) return this[val ? "show" : "hide"](); let hidden = this.map(elem => elem.style.display == "none"); return this.each(function (elem, i) { this[hidden[i] ? "show" : "hide"](); }); }, hide: function hide() { return this.each(function (elem) { elem.style.display = "none"; }, this); }, show: function show() { for (let i = 0; i < this.length; i++) if (!this[i].dactylDefaultDisplay && this[i].style.display) this[i].style.display = ""; this.each(function (elem) { if (!elem.dactylDefaultDisplay) elem.dactylDefaultDisplay = this.style.display; }); return this.each(function (elem) { elem.style.display = elem.dactylDefaultDisplay == "none" ? "block" : ""; }, this); }, createContents: function createContents() { return this.each(DOM.createContents, this); }, isScrollable: function isScrollable(direction) { return this.length && DOM.isScrollable(this[0], direction); }, getSet: function getSet(args, get, set) { if (!args.length) return this[0] && get.call(this, this[0]); let [fn, self] = args; if (!callable(fn)) fn = () => args[0]; return this.each(function (elem, i) { set.call(this, elem, fn.call(self || this, elem, i)); }, this); }, html: function html(...args) { return this.getSet(args, elem => elem.innerHTML, util.wrapCallback((elem, val) => { elem.innerHTML = val; })); }, text: function text(...args) { return this.getSet(args, elem => elem.textContent, (elem, val) => { elem.textContent = val; }); }, val: function val(...args) { return this.getSet(args, elem => elem.value, (elem, val) => { elem.value = val == null ? "" : val; }); }, listen: function listen(event, listener, capture) { if (isObject(event)) capture = listener; else event = { [event]: listener }; for (let [evt, callback] of Object.entries(event)) event[evt] = util.wrapCallback(callback, true); return this.each(elem => { for (let [evt, callback] of Object.entries(event)) elem.addEventListener(evt, callback, capture); }); }, unlisten: function unlisten(event, listener, capture) { if (isObject(event)) capture = listener; else event = { [event]: listener }; return this.each(elem => { for (let [event, callback] of Object.entries(event)) elem.removeEventListener(event, callback.wrapper || v, capture); }); }, once: function once(event, listener, capture) { if (isObject(event)) capture = listener; else event = { [event]: listener }; for (let pair of iter(event)) { let [evt, callback] = pair; event[evt] = util.wrapCallback(function wrapper(event) { this.removeEventListener(evt, wrapper.wrapper, capture); return callback.apply(this, arguments); }, true); } return this.each(elem => { for (let [event, callback] of Object.entries(event)) elem.addEventListener(event, callback, capture); }); }, dispatch: function dispatch(event, params, extraProps) { this.canceled = false; return this.each(function (elem) { let evt = DOM.Event(this.document, event, params, elem); if (!DOM.Event.dispatch(elem, evt, extraProps)) this.canceled = true; }, this); }, focus: function focus(arg, extra) { if (callable(arg)) return this.listen("focus", arg, extra); let elem = this[0]; let flags = arg || services.focus.FLAG_BYMOUSE; try { if (elem instanceof Ci.nsIDOMDocument) elem = elem.defaultView; if (Cu.isCrossProcessWrapper(elem)) { elem.focus(); } else { if (elem instanceof Ci.nsIDOMElement) services.focus.setFocus(elem, flags); else if (elem instanceof Ci.nsIDOMWindow) { services.focus.focusedWindow = elem; if (services.focus.focusedWindow != elem) services.focus.clearFocus(elem); } } } catch (e) { util.dump(elem); util.reportError(e); } return this; }, blur: function blur(arg, extra) { if (callable(arg)) return this.listen("blur", arg, extra); return this.each(function (elem) { elem.blur(); }, this); }, /** * Scrolls an element into view if and only if it's not already * fully visible. */ scrollIntoView: function scrollIntoView(alignWithTop) { return this.each(function (elem) { function getAlignment(viewport) { if (alignWithTop !== undefined) return alignWithTop; if (rect.bottom < viewport.top) return true; if (rect.top > viewport.bottom) return false; return Math.abs(rect.top) < Math.abs(viewport.bottom - rect.bottom); } let rect; function fix(parent) { if (!(parent[0] instanceof Ci.nsIDOMWindow) && parent.style.overflow == "visible") return; ({ rect } = DOM(elem)); let { viewport } = parent; let isect = util.intersection(rect, viewport); if (isect.height < Math.min(viewport.height, rect.height)) { let { top } = parent.scrollPos(); if (getAlignment(viewport)) parent.scrollPos(null, top - (viewport.top - rect.top)); else parent.scrollPos(null, top - (viewport.bottom - rect.bottom)); } } for (let parent of this.ancestors.items) fix(parent); fix(DOM(this.document.defaultView)); }); } }, { /** * Creates an actual event from a pseudo-event object. * * The pseudo-event object (such as may be retrieved from * DOM.Event.parse) should have any properties you want the event to * have. * * @param {Document} doc The DOM document to associate this event with * @param {Type} type The type of event (keypress, click, etc.) * @param {Object} opts The pseudo-event. @optional */ Event: Class("Event", { init: function Event(doc, type, opts, target) { const DEFAULTS = { HTML: { type: type, bubbles: true, cancelable: false }, Key: { type: type, bubbles: true, cancelable: true, view: doc.defaultView, ctrlKey: false, altKey: false, shiftKey: false, metaKey: false, keyCode: 0, charCode: 0 }, Mouse: { type: type, bubbles: true, cancelable: true, view: doc.defaultView, detail: 1, get screenX() { return this.view.mozInnerScreenX + Math.max(0, this.clientX + (DOM(target || opts.target).rect.left || 0)); }, get screenY() { return this.view.mozInnerScreenY + Math.max(0, this.clientY + (DOM(target || opts.target).rect.top || 0)); }, clientX: 0, clientY: 0, ctrlKey: false, altKey: false, shiftKey: false, metaKey: false, button: 0, relatedTarget: null } }; opts = opts || {}; var t = this.constructor.types[type] || ""; var evt = doc.createEvent(t + "Events"); let params = DEFAULTS[t || "HTML"]; let args = Object.keys(params); let props = {}; // FIXME for (let p in opts) if (p in params) props[p] = opts[p]; update(params, this.constructor.defaults[type], props); apply(evt, "init" + t + "Event", args.map(arg => params[arg])); return evt; } }, { init: function init() { // NOTE: the order of ["Esc", "Escape"] or ["Escape", "Esc"] // matters, so use that string as the first item, that you // want to refer to within dactyl's source code for // comparisons like if (key == "") { ... } this.keyTable = { add: ["+", "Plus", "Add"], back_quote: ["`"], back_slash: ["\\"], back_space: ["BS"], comma: [","], count: ["count"], close_bracket: ["]"], delete: ["Del"], equals: ["="], escape: ["Esc", "Escape"], insert: ["Insert", "Ins"], leader: ["Leader"], left_shift: ["LT", "<"], nop: ["Nop"], open_bracket: ["["], pass: ["Pass"], period: ["."], quote: ["'"], return: ["Return", "CR", "Enter"], right_shift: [">"], semicolon: [";"], slash: ["/"], space: ["Space", " "], subtract: ["-", "Minus", "Subtract"] }; this.key_key = {}; this.code_key = {}; this.key_code = {}; this.code_nativeKey = {}; for (let list of values(this.keyTable)) for (let v of list) { if (v.length == 1) v = v.toLowerCase(); this.key_key[v.toLowerCase()] = v; } for (let [k, v] of iter(Ci.nsIDOMKeyEvent)) { if (!/^DOM_VK_/.test(k)) continue; this.code_nativeKey[v] = k.substr(4); k = k.substr(7).toLowerCase(); let names = [k.replace(/(^|_)(.)/g, (m, n1, n2) => n2.toUpperCase()) .replace(/^NUMPAD/, "k")]; if (names[0].length == 1) names[0] = names[0].toLowerCase(); if (k in this.keyTable) names = this.keyTable[k]; this.code_key[v] = names[0]; for (let name of names) { this.key_key[name.toLowerCase()] = name; this.key_code[name.toLowerCase()] = v; } } // HACK: as Gecko does not include an event for <, we must add this in manually. if (!("<" in this.key_code)) { this.key_code["<"] = 60; this.key_code["lt"] = 60; this.code_key[60] = "lt"; } return this; }, code_key: Class.Memoize(function (prop) { return this.init()[prop]; }), code_nativeKey: Class.Memoize(function (prop) { return this.init()[prop]; }), keyTable: Class.Memoize(function (prop) { return this.init()[prop]; }), key_code: Class.Memoize(function (prop) { return this.init()[prop]; }), key_key: Class.Memoize(function (prop) { return this.init()[prop]; }), pseudoKeys: new RealSet(["count", "leader", "nop", "pass"]), /** * Converts a user-input string of keys into a canonical * representation. * * maps to , maps to * maps to , maps to A * << maps to * * is preserved, as in Vim, to allow untypeable key-combinations * in macros. * * canonicalKeys(canonicalKeys(x)) == canonicalKeys(x) for all values * of x. * * @param {string} keys Messy form. * @param {boolean} unknownOk Whether unknown keys are passed * through rather than being converted to keyname>. * @default true * @returns {string} Canonical form. */ canonicalKeys: function canonicalKeys(keys, unknownOk=true) { return this.parse(keys, unknownOk).map(this.bound.stringify).join(""); }, iterKeys: function iterKeys(keys) { return iter(function* () { let match, re = /<.*?>?>|[^<]/g; while (match = re.exec(keys)) yield match[0]; }()); }, /** * Converts an event string into an array of pseudo-event objects. * * These objects can be used as arguments to {@link #stringify} or * {@link DOM.Event}, though they are unlikely to be much use for other * purposes. They have many of the properties you'd expect to find on a * real event, but none of the methods. * * Also may contain two "special" parameters, .dactylString and * .dactylShift these are set for characters that can never by * typed, but may appear in mappings, for example is passed as * dactylString, and dactylShift is set when a user specifies * where @ is a non-case-changeable, non-space character. * * @param {string} keys The string to parse. * @param {boolean} unknownOk Whether unknown keys are passed * through rather than being converted to keyname>. * @default true * @returns {Array[Object]} */ parse: function parse(input, unknownOk=true) { if (isArray(input)) return input.flatMap(k => this.parse(k, unknownOk)); let out = []; for (let match of util.regexp.iterate(/<.*?>?>|[^<]|<(?!.*>)/g, input)) { let evt_str = match[0]; let evt_obj = { ctrlKey: false, shiftKey: false, altKey: false, metaKey: false, keyCode: 0, charCode: 0, type: "keypress" }; if (evt_str.length == 1) { evt_obj.charCode = evt_str.charCodeAt(0); evt_obj._keyCode = this.key_code[evt_str[0].toLowerCase()]; evt_obj.shiftKey = evt_str !== evt_str.toLowerCase(); } else { let [match, modifier, keyname] = evt_str.match(/^<((?:[*12CASM⌘]-)*)(.+?)>$/i) || [false, '', '']; modifier = new RealSet(modifier.toUpperCase()); keyname = keyname.toLowerCase(); evt_obj.dactylKeyname = keyname; if (/^u[0-9a-f]+$/.test(keyname)) keyname = String.fromCharCode(parseInt(keyname.substr(1), 16)); if (keyname && (unknownOk || keyname.length == 1 || /mouse$/.test(keyname) || this.key_code[keyname] || this.pseudoKeys.has(keyname))) { evt_obj.globKey = modifier.has("*"); evt_obj.ctrlKey = modifier.has("C"); evt_obj.altKey = modifier.has("A"); evt_obj.shiftKey = modifier.has("S"); evt_obj.metaKey = modifier.has("M") || modifier.has("⌘"); evt_obj.dactylShift = evt_obj.shiftKey; if (keyname.length == 1) { // normal characters if (evt_obj.shiftKey) keyname = keyname.toUpperCase(); evt_obj.dactylShift = evt_obj.shiftKey && keyname.toUpperCase() == keyname.toLowerCase(); evt_obj.charCode = keyname.charCodeAt(0); evt_obj.keyCode = this.key_code[keyname.toLowerCase()]; } else if (this.pseudoKeys.has(keyname)) { evt_obj.dactylString = "<" + this.key_key[keyname] + ">"; } else if (/mouse$/.test(keyname)) { // mouse events evt_obj.type = (modifier.has("2") ? "dblclick" : "click"); evt_obj.button = ["leftmouse", "middlemouse", "rightmouse"].indexOf(keyname); delete evt_obj.keyCode; delete evt_obj.charCode; } else { // spaces, control characters, and < evt_obj.keyCode = this.key_code[keyname]; evt_obj.charCode = 0; } } else { // an invalid sequence starting with <, treat as a literal out = out.concat(this.parse("" + evt_str.substr(1))); continue; } } // TODO: make a list of characters that need keyCode and charCode somewhere if (evt_obj.keyCode == 32 || evt_obj.charCode == 32) evt_obj.charCode = evt_obj.keyCode = 32; // if (evt_obj.keyCode == 60 || evt_obj.charCode == 60) evt_obj.charCode = evt_obj.keyCode = 60; // evt_obj.modifiers = (evt_obj.ctrlKey && Ci.nsIDOMNSEvent.CONTROL_MASK) | (evt_obj.altKey && Ci.nsIDOMNSEvent.ALT_MASK) | (evt_obj.shiftKey && Ci.nsIDOMNSEvent.SHIFT_MASK) | (evt_obj.metaKey && Ci.nsIDOMNSEvent.META_MASK); out.push(evt_obj); } return out; }, /** * Converts the specified event to a string in dactyl key-code * notation. Returns null for an unknown event. * * @param {Event} event * @returns {string} */ stringify: function stringify(event) { if (isArray(event)) return event.map(e => this.stringify(e)).join(""); if (event.dactylString) return event.dactylString; let key = null; let modifier = ""; if (event.globKey) modifier += "*-"; if (event.ctrlKey) modifier += "C-"; if (event.altKey) modifier += "A-"; if (event.metaKey) modifier += "M-"; if (/^key/.test(event.type)) { let charCode = event.type == "keyup" ? 0 : event.charCode; // Why? --Kris if (charCode == 0) { if (event.keyCode in this.code_key) { key = this.code_key[event.keyCode]; if (event.shiftKey && (key.length > 1 || key.toUpperCase() == key.toLowerCase() || event.ctrlKey || event.altKey || event.metaKey) || event.dactylShift) modifier += "S-"; else if (!modifier && key.length === 1) if (event.shiftKey) key = key.toUpperCase(); else key = key.toLowerCase(); if (!modifier && key.length == 1) return key; } } // [Ctrl-Bug] special handling of mysterious , , , , bugs (OS/X) // (i.e., cntrl codes 27--31) // --- // For more information, see: // [*] Referenced mailing list msg: http://www.mozdev.org/pipermail/pentadactyl/2008-May/001548.html // [*] Mozilla bug 416227: event.charCode in keypress handler has unexpected values on Mac for Ctrl with chars in "[ ] _ \" // https://bugzilla.mozilla.org/show_bug.cgi?id=416227 // [*] Mozilla bug 432951: Ctrl+'foo' doesn't seem same charCode as Meta+'foo' on Cocoa // https://bugzilla.mozilla.org/show_bug.cgi?id=432951 // --- // // The following fixes are only activated if config.OS.isMacOSX. // Technically, they prevent mappings from (and // if your fancy keyboard permits such things), but // these mappings are probably pathological ( // certainly is on Windows), and so it is probably // harmless to remove the config.OS.isMacOSX if desired. // else if (config.OS.isMacOSX && event.ctrlKey && charCode >= 27 && charCode <= 31) { if (charCode == 27) { // [Ctrl-Bug 1/5] the bug key = "Esc"; modifier = modifier.replace("C-", ""); } else // [Ctrl-Bug 2,3,4,5/5] the , , , bugs key = String.fromCharCode(charCode + 64); } // a normal key like a, b, c, 0, etc. else if (charCode) { key = String.fromCharCode(charCode); if (!/^[^<\s]$/i.test(key) && key in this.key_code) { // a named charCode key ( and ) space can be shifted, must be forced if ((key.match(/^\s$/) && event.shiftKey) || event.dactylShift) modifier += "S-"; key = this.code_key[this.key_code[key]]; } else { // a shift modifier is only allowed if the key is alphabetical and used in a C-A-M- mapping in the uppercase, // or if the shift has been forced for a non-alphabetical character by the user while :map-ping if (key !== key.toLowerCase() && (event.ctrlKey || event.altKey || event.metaKey) || event.dactylShift) modifier += "S-"; if (/^\s$/.test(key)) { let s = charCode.toString(16); key = "U" + "0000".substr(4 - s.length) + s; } else if (modifier.length == 0) return key; } } if (key == null) { if (event.shiftKey) modifier += "S-"; key = this.key_key[event.dactylKeyname] || event.dactylKeyname; } if (key == null) return null; } else if (event.type == "click" || event.type == "dblclick") { if (event.shiftKey) modifier += "S-"; if (event.type == "dblclick") modifier += "2-"; // TODO: triple and quadruple click switch (event.button) { case 0: key = "LeftMouse"; break; case 1: key = "MiddleMouse"; break; case 2: key = "RightMouse"; break; } } if (key == null) return null; return "<" + modifier + key + ">"; }, defaults: { load: { bubbles: false }, submit: { cancelable: true } }, types: Class.Memoize(() => { return iter( { Mouse: "click mousedown mouseout mouseover mouseup dblclick " + "hover " + "popupshowing popupshown popuphiding popuphidden " + "contextmenu", Key: "keydown keypress keyup", "": "change command dactyl-input input submit " + "load unload pageshow pagehide DOMContentLoaded " + "resize scroll" } ).map(([k, v]) => v.split(" ").map(v => [v, k])) .flatten() .toObject(); }), /** * Dispatches an event to an element as if it were a native event. * * @param {Node} target The DOM node to which to dispatch the event. * @param {Event} event The event to dispatch. */ dispatch: function dispatch(target, event, extra) { try { this.feedingEvent = extra; if (target instanceof Ci.nsIDOMElement) return (target.ownerDocument || target.document || target).defaultView .QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIDOMWindowUtils) .dispatchDOMEventViaPresShell(target, event, true); else { target.dispatchEvent(event); return !event.defaultPrevented; } } catch (e) { util.reportError(e); } finally { this.feedingEvent = null; } } }), createContents: Class.Memoize(() => services.has("dactyl") && services.dactyl.createContents || (elem => {})), isScrollable: Class.Memoize(() => services.has("dactyl") && services.dactyl.getScrollable ? (elem, dir) => services.dactyl.getScrollable(elem) & (dir ? services.dactyl["DIRECTION_" + dir.toUpperCase()] : ~0) : (elem, dir) => true), isJSONXML: function isJSONXML(val) { return isArray(val) && isinstance(val[0], ["String", "Array", "XML", DOM.DOMString]) || isObject(val) && "toDOM" in val; }, DOMString: function DOMString(val) { return { __proto__: DOMString.prototype, toDOM: function toDOM(doc) { return doc.createTextNode(val); }, toString: function () { return val; } }; }, /** * The set of input element type attribute values that mark the element as * an editable field. */ editableInputs: new RealSet(["date", "datetime", "datetime-local", "email", "file", "month", "number", "password", "range", "search", "tel", "text", "time", "url", "week"]), /** * Converts a given DOM Node, Range, or Selection to a string. If * *html* is true, the output is HTML, otherwise it is presentation * text. * * @param {nsIDOMNode | nsIDOMRange | nsISelection} node The node to * stringify. * @param {boolean} html Whether the output should be HTML rather * than presentation text. */ stringify: function stringify(node, html) { if (node instanceof Ci.nsISelection && node.isCollapsed) return ""; if (node instanceof Ci.nsIDOMNode) { let range = node.ownerDocument.createRange(); range.selectNode(node); node = range; } let doc = (node.getRangeAt ? node.getRangeAt(0) : node).startContainer; doc = doc.ownerDocument || doc; let encoder = services.HtmlEncoder(); encoder.init(doc, "text/unicode", encoder.OutputRaw|encoder.OutputPreformatted); if (node instanceof Ci.nsISelection) encoder.setSelection(node); else if (node instanceof Ci.nsIDOMRange) encoder.setRange(node); let str = services.String(encoder.encodeToString()); if (html) return str.data; let [result, length] = [{}, {}]; services.HtmlConverter().convert("text/html", str, str.data.length*2, "text/unicode", result, length); return result.value.QueryInterface(Ci.nsISupportsString).data; }, /** * Compiles a CSS spec and XPath pattern matcher based on the given * list. List elements prefixed with "xpath:" are parsed as XPath * patterns, while other elements are parsed as CSS specs. The * returned function will, given a node, return an iterator of all * descendants of that node which match the given specs. * * @param {[string]} list The list of patterns to match. * @returns {function(Node)} */ compileMatcher: function compileMatcher(list) { let xpath = [], css = []; for (let elem of list) if (/^xpath:/.test(elem)) xpath.push(elem.substr(6)); else css.push(elem); return update( function* matcher(node) { if (matcher.xpath) for (let elem of DOM.XPath(matcher.xpath, node)) yield elem; if (matcher.css) for (let elem of util.withProperErrors("querySelectorAll", node, matcher.css)) yield elem; }, { css: css.join(", "), xpath: xpath.join(" | ") }); }, /** * Validates a list as input for {@link #compileMatcher}. Returns * true if and only if every element of the list is a valid XPath or * CSS selector. * * @param {[string]} list The list of patterns to test * @returns {boolean} True when the patterns are all valid. */ validateMatcher: function validateMatcher(list) { return this.testValues(list, DOM.bound.testMatcher); }, testMatcher: function testMatcher(value) { let evaluator = services.XPathEvaluator(); let node = services.XMLDocument(); if (/^xpath:/.test(value)) util.withProperErrors("createExpression", evaluator, value.substr(6), DOM.XPath.resolver); else util.withProperErrors("querySelector", node, value); return true; }, /** * Converts HTML special characters in *str* to the equivalent HTML * entities. * * @param {string} str * @param {boolean} simple If true, only escape for the simple case * of text nodes. * @returns {string} */ escapeHTML: function escapeHTML(str, simple) { let map = { "'": "'", '"': """, "%": "%", "&": "&", "<": "<", ">": ">" }; let regexp = simple ? /[<>]/g : /['"&<>]/g; return str.replace(regexp, m => map[m]); }, fromJSON: update(function fromJSON(xml, doc, nodes, namespaces) { if (!doc) doc = document; function tag(args, namespaces) { let _namespaces = namespaces; // Deal with common error case if (args == null) { util.reportError(Error("Unexpected null when processing XML.")); args = ["html:i", {}, "[NULL]"]; } if (isinstance(args, ["String", "Number", "Boolean", _])) return doc.createTextNode(args); if (isObject(args) && "toDOM" in args) return args.toDOM(doc, namespaces, nodes); if (args instanceof Ci.nsIDOMNode) return args; if (args instanceof DOM) return args.fragment(); if ("toJSONXML" in args) args = args.toJSONXML(); let [name, attr] = args; if (!isString(name) || args.length == 0 || name === "") { var frag = doc.createDocumentFragment(); Array.forEach(args, arg => { if (!isArray(arg[0])) arg = [arg]; arg.forEach(arg => { frag.appendChild(tag(arg, namespaces)); }); }); return frag; } attr = attr || {}; function parseNamespace(name) { return DOM.parseNamespace(name, namespaces); } // FIXME: Surely we can do better. for (let key in attr) { if (/^xmlns(?:$|:)/.test(key)) { if (_namespaces === namespaces) namespaces = Object.create(namespaces); namespaces[key.substr(6)] = namespaces[attr[key]] || attr[key]; }} var args = Array.slice(args, 2); var vals = parseNamespace(name); var elem = doc.createElementNS(vals[0] || namespaces[""], name); for (let key in attr) if (!/^xmlns(?:$|:)/.test(key)) { var val = attr[key]; if (nodes && key == "key") nodes[val] = elem; vals = parseNamespace(key); if (key == "highlight") ; else if (typeof val == "function") elem.addEventListener(key.replace(/^on/, ""), val, false); else elem.setAttributeNS(vals[0] || "", key, val); } args.forEach(function (e) { elem.appendChild(tag(e, namespaces)); }); if ("highlight" in attr) highlight.highlightNode(elem, attr.highlight, nodes || true); return elem; } if (namespaces) namespaces = update({}, fromJSON.namespaces, namespaces); else namespaces = fromJSON.namespaces; return tag(xml, namespaces); }, { namespaces: { "": "http://www.w3.org/1999/xhtml", dactyl: String(NS), html: "http://www.w3.org/1999/xhtml", xmlns: "http://www.w3.org/2000/xmlns/", xul: "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" } }), toXML: function toXML(xml) { // Meh. For now. let doc = services.XMLDocument(); let node = this.fromJSON(xml, doc); return services.XMLSerializer() .serializeToString(node); }, toPrettyXML: function toPrettyXML(xml, asXML, indent, namespaces) { const INDENT = indent || " "; const EMPTY = new RealSet("area base basefont br col frame hr img input isindex link meta param" .split(" ")); function namespaced(namespaces, namespace, localName) { for (let [k, v] of iter(namespaces)) if (v == namespace) return (k ? k + ":" + localName : localName); throw Error("No such namespace"); } function isFragment(args) { return !isString(args[0]) || args.length == 0 || args[0] === ""; } function hasString(args) { return args.some(a => (isString(a) || isFragment(a) && hasString(a))); } const STRING_TYPES = ["String", "Number", "Boolean", _, DOM.DOMString]; function isStrings(args) { if (!isArray(args)) return util.dump("ARGS: " + {}.toString.call(args) + " " + args), false; return args.every(a => (isinstance(a, STRING_TYPES) || isFragment(a) && isStrings(a))); } function tag(args, namespaces, indent) { let _namespaces = namespaces; if (args == "") return ""; if (isinstance(args, STRING_TYPES)) return indent + DOM.escapeHTML(String(args), true); if (isObject(args) && "toDOM" in args) return indent + services.XMLSerializer() .serializeToString(args.toDOM(services.XMLDocument())) .replace(/^/m, indent); if (args instanceof Ci.nsIDOMNode) return indent + services.XMLSerializer() .serializeToString(args) .replace(/^/m, indent); if ("toJSONXML" in args) args = args.toJSONXML(); // Deal with common error case if (args == null) { util.reportError(Error("Unexpected null when processing XML.")); return "[NULL]"; } let [name, attr] = args; if (isFragment(args)) { let res = []; let join = isArray(args) && isStrings(args) ? "" : "\n"; Array.forEach(args, arg => { if (!isArray(arg[0])) arg = [arg]; let contents = []; arg.forEach(arg => { let string = tag(arg, namespaces, indent); if (string) contents.push(string); }); if (contents.length) res.push(contents.join("\n"), join); }); if (res[res.length - 1] == join) res.pop(); return res.join(""); } attr = attr || {}; function parseNamespace(name) { var m = /^(?:(.*):)?(.*)$/.exec(name); return [namespaces[m[1]], m[2]]; } // FIXME: Surely we can do better. let skipAttr = {}; for (let key in attr) { if (/^xmlns(?:$|:)/.test(key)) { if (_namespaces === namespaces) namespaces = update({}, namespaces); let ns = namespaces[attr[key]] || attr[key]; if (ns == namespaces[key.substr(6)]) skipAttr[key] = true; attr[key] = namespaces[key.substr(6)] = ns; }} var args = Array.slice(args, 2); var vals = parseNamespace(name); let res = [indent, "<", name]; for (let [key, val] of iter(attr)) { if (hasOwnProp(skipAttr, key)) continue; let vals = parseNamespace(key); if (typeof val == "function") { key = key.replace(/^(?:on)?/, "on"); val = val.toSource() + "(event)"; } if (key != "highlight" || vals[0] == String(NS)) res.push(" ", key, '="', DOM.escapeHTML(val), '"'); else res.push(" ", namespaced(namespaces, String(NS), "highlight"), '="', DOM.escapeHTML(val), '"'); } if ((vals[0] || namespaces[""]) == String(XHTML) && EMPTY.has(vals[1]) || asXML && !args.length) res.push("/>"); else { res.push(">"); if (isStrings(args)) res.push(args.map(e => tag(e, namespaces, "")).join(""), ""); else { let contents = []; args.forEach(function (e) { let string = tag(e, namespaces, indent + INDENT); if (string) contents.push(string); }); res.push("\n", contents.join("\n"), "\n", indent, ""); } } return res.join(""); } if (namespaces) namespaces = update({}, DOM.fromJSON.namespaces, namespaces); else namespaces = DOM.fromJSON.namespaces; return tag(xml, namespaces, ""); }, parseNamespace: function parseNamespace(name, namespaces) { if (name == "xmlns") return [DOM.fromJSON.namespaces.xmlns, "xmlns"]; var m = /^(?:(.*):)?(.*)$/.exec(name); return [(namespaces || DOM.fromJSON.namespaces)[m[1]], m[2]]; }, /** * Evaluates an XPath expression in the current or provided * document. It provides the xhtml, xhtml2 and dactyl XML * namespaces. The result may be used as an iterator. * * @param {string} expression The XPath expression to evaluate. * @param {Node} elem The context element. * @param {boolean} asIterator Whether to return the results as an * XPath iterator. * @param {object} namespaces Additional namespaces to recognize. * @optional * @returns {Object} Iterable result of the evaluation. */ XPath: update( function XPath(expression, elem, asIterator, namespaces) { try { let doc = elem.ownerDocument || elem; if (isArray(expression)) expression = DOM.makeXPath(expression); let resolver = XPath.resolver; if (namespaces) { namespaces = update({}, DOM.namespaces, namespaces); resolver = prefix => namespaces[prefix] || null; } let result = doc.evaluate(expression, elem, resolver, asIterator ? Ci.nsIDOMXPathResult.ORDERED_NODE_ITERATOR_TYPE : Ci.nsIDOMXPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null ); let res = { iterateNext: function () { return result.iterateNext(); }, get resultType() { return result.resultType; }, get snapshotLength() { return result.snapshotLength; }, snapshotItem: function (i) { return result.snapshotItem(i); } }; if (asIterator) res[Symbol.iterator] = function* () { let elem; while ((elem = this.iterateNext())) yield elem; }; else res[Symbol.iterator] = function* () { for (let i = 0; i < this.snapshotLength; i++) yield this.snapshotItem(i); }; return res; } catch (e) { throw e.stack ? e : Error(e); } }, { resolver: function lookupNamespaceURI(prefix) { return DOM.namespaces[prefix] || null; } }), /** * Returns an XPath union expression constructed from the specified node * tests. An expression is built with node tests for both the null and * XHTML namespaces. See {@link DOM.XPath}. * * @param nodes {Array(string)} * @returns {string} */ makeXPath: function makeXPath(nodes) { return nodes.flatMap(util.debrace) .flatMap(node => /^[a-z]+:/.test(node) ? node : [node, "xhtml:" + node]) .map(node => "//" + node) .join(" | "); }, namespaces: { xul: XUL, xhtml: XHTML, html: XHTML, xhtml2: "http://www.w3.org/2002/06/xhtml2", dactyl: NS }, namespaceNames: Class.Memoize(function () { return iter(this.namespaces).map(([k, v]) => ([v, k])) .toObject(); }) }); Object.keys(DOM.Event.types).forEach(function (event) { let name = event.replace(/-(.)/g, (m, m1) => m1.toUpperCase()); if (!hasOwnProp(DOM.prototype, name)) DOM.prototype[name] = function _event(arg, extra) { return this[callable(arg) ? "listen" : "dispatch"](event, arg, extra); }; }); var $ = DOM; endModule(); // catch(e){ if (!e.stack) e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); } // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/downloads.jsm000066400000000000000000000525411264147376100215220ustar00rootroot00000000000000// Copyright (c) 2011-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; defineModule("downloads", { exports: ["Download", "Downloads", "downloads"], require: ["util"] }); lazyRequire("overlay", ["overlay"]); lazyRequire("promises", ["Task", "promises"]); lazyRequire("resource://gre/modules/Downloads.jsm", ["Downloads"]); lazyRequire("resource://gre/modules/DownloadUtils.jsm", ["DownloadUtils"]); var MAX_LOAD_TIME = 10 * 1000; let prefix = "DOWNLOAD_"; var states = Ary.toObject( Object.entries(Ci.nsIDownloadManager).filter(([key]) => key.startsWith(prefix)) .map(([key, val]) => [val, key.slice(prefix.length).toLowerCase()])); var Download = Class("Download", { init: function init(download, list) { this.download = download; this.list = list; this.nodes = { commandTarget: this }; DOM.fromJSON( ["tr", { highlight: "Download", key: "row" }, ["td", { highlight: "DownloadTitle" }, ["span", { highlight: "Link" }, ["a", { key: "launch", href: this.target.spec, path: this.targetFile.path }, this.displayName], ["span", { highlight: "LinkInfo" }, this.targetFile.path]]], ["td", { highlight: "DownloadState", key: "state" }], ["td", { highlight: "DownloadButtons Buttons" }, ["a", { highlight: "Button", href: "javascript:0", key: "stop" }, _("download.action.Stop")], ["a", { highlight: "Button", href: "javascript:0", key: "remove" }, _("download.action.Remove")], ["a", { highlight: "Button", href: "javascript:0", key: "resume" }, _("download.action.Resume")], ["a", { highlight: "Button", href: "javascript:0", key: "delete" }, _("download.action.Delete")]], ["td", { highlight: "DownloadProgress", key: "progress" }, ["span", { highlight: "DownloadProgressHave", key: "progressHave" }], "/", ["span", { highlight: "DownloadProgressTotal", key: "progressTotal" }]],, ["td", { highlight: "DownloadPercent", key: "percent" }], ["td", { highlight: "DownloadSpeed", key: "speed" }], ["td", { highlight: "DownloadTime", key: "time" }], ["td", {}, ["a", { highlight: "DownloadSource", key: "source", href: this.source.url }, this.source.url]]], this.list.document, this.nodes); this.nodes.launch.addEventListener("click", event => { if (event.button == 0) { event.preventDefault(); this.command("launch"); } }, false); this.updateStatus(); return this; }, get active() { return !this.stopped; }, get targetFile() { return File(this.download.target.path); }, get displayName() { return this.targetFile.leafName; }, get status() { return states[this.state]; }, inState: function inState(states) { return states.indexOf(this.status) >= 0; }, allowedCommands: Class.Memoize(function () { let self = this; return { get delete() { return !self.active && (self.targetFile.exists() || self.hasPartialData); }, get launch() { return self.targetFile.exists() && self.succeeded; }, get stop() { return self.active; }, get remove() { return !self.active; }, get resume() { return self.canceled; } }; }), command: function command(name) { util.assert(hasOwnProp(this.allowedCommands, name), _("download.unknownCommand")); util.assert(this.allowedCommands[name], _("download.commandNotAllowed")); if (hasOwnProp(this.commands, name)) this.commands[name].call(this); }, commands: { delete: promises.task(function* delete_() { if (this.hasPartialData) yield this.removePartialData(); else if (this.targetFile.exists()) this.targetFile.remove(false); this.updateStatus(); }), launch: function launch() { // Behavior mimics that of the builtin Download Manager. function action() { try { if (this.MIMEInfo && this.MIMEInfo.preferredAction == this.MIMEInfo.useHelperApp) this.MIMEInfo.launchWithFile(file.file); else file.launch(); } catch (e) { services.externalProtocol.loadUrl(this.target); } } let file = io.File(this.targetFile); if (file.isExecutable() && prefs.get("browser.download.manager.alertOnEXEOpen", true)) this.list.modules.commandline.input(_("download.prompt.launchExecutable") + " ", resp => { if (/^a(lways)$/i.test(resp)) { prefs.set("browser.download.manager.alertOnEXEOpen", false); resp = "yes"; } if (/^y(es)?$/i.test(resp)) action.call(this); }); else action.call(this); }, resume: function resume() { this.download.start(); }, remove: promises.task(function* remove() { yield this.list.list.remove(this.download); yield this.download.finalize(true); }), stop: function stop() { this.download.cancel(); }, }, _compare: { active: (a, b) => a.active - b.active, complete: (a, b) => a.percentComplete - b.percentComplete, date: (a, b) => a.startTime - b.startTime, filename: (a, b) => String.localeCompare(a.targetFile.leafName, b.targetFile.leafName), size: (a, b) => a.totalBytes - b.totalBytes, speed: (a, b) => a.speed - b.speed, time: (a, b) => a.timeRemaining - b.timeRemaining, url: (a, b) => String.localeCompare(a.source.url, b.source.url) }, compare: function compare(other) { return values(this.list.sortOrder).map(function (order) { let val = this._compare[order.substr(1)](this, other); return (order[0] == "-") ? -val : val; }, this).find(identity) || 0; }, timeRemaining: Infinity, updateProgress: function updateProgress() { let self = this.__proto__; if (!this.active) { this.nodes.speed.textContent = ""; this.nodes.time.textContent = ""; } else { this.nodes.speed.textContent = util.formatBytes(this.speed, 1, true) + "/s"; if (this.speed == 0 || !this.hasProgress) this.nodes.time.textContent = _("download.unknown"); else { let seconds = (this.totalBytes - this.currentBytes) / this.speed; [, self.timeRemaining] = DownloadUtils.getTimeLeft(seconds, this.timeRemaining); if (this.timeRemaining) this.nodes.time.textContent = util.formatSeconds(this.timeRemaining); else this.nodes.time.textContent = _("download.almostDone"); } } let total = this.nodes.progressTotal.textContent = this.hasProgress && (this.totalBytes || !this.nActive) ? util.formatBytes(this.totalBytes, 1, true) : _("download.unknown"); let suffix = RegExp(/( [a-z]+)?$/i.exec(total)[0] + "$"); this.nodes.progressHave.textContent = util.formatBytes(this.currentBytes, 1, true).replace(suffix, ""); this.nodes.percent.textContent = this.hasProgress ? this.progress + "%" : ""; }, updateStatus: function updateStatus() { this.nodes.row[this.active ? "setAttribute" : "removeAttribute"]("active", "true"); this.nodes.row.setAttribute("status", this.status); this.nodes.state.textContent = util.capitalize(this.status); for (let node of values(this.nodes)) if (node.update) node.update(); this.updateProgress(); } }); var DownloadList = Class("DownloadList", XPCOM([Ci.nsIDownloadProgressListener, Ci.nsIObserver, Ci.nsISupportsWeakReference]), { init: function init(modules, filter, sort) { this.sortOrder = sort; this.modules = modules; this.filter = filter && filter.toLowerCase(); this.nodes = { commandTarget: this }; this.downloads = new Map(); }, cleanup: function cleanup() { if (this.list) this.list.removeView(this); this.dead = true; }, message: Class.Memoize(function () { DOM.fromJSON(["table", { highlight: "Downloads", key: "list" }, ["tr", { highlight: "DownloadHead", key: "head" }, ["span", {}, _("title.Title")], ["span", {}, _("title.Status")], ["span"], ["span", {}, _("title.Progress")], ["span"], ["span", {}, _("title.Speed")], ["span", {}, _("title.Time remaining")], ["span", {}, _("title.Source")]], ["tr", { highlight: "Download" }, ["span", {}, ["div", { style: "min-height: 1ex; /* FIXME */" }]]], ["tr", { highlight: "Download", key: "totals", active: "true" }, ["td", {}, ["span", { highlight: "Title" }, _("title.Totals") + ":"], " ", ["span", { key: "total" }]], ["td"], ["td", { highlight: "DownloadButtons" }, ["a", { highlight: "Button", href: "javascript:0", key: "clear" }, _("download.action.Clear")]], ["td", { highlight: "DownloadProgress", key: "progress" }, ["span", { highlight: "DownloadProgressHave", key: "progressHave" }], "/", ["span", { highlight: "DownloadProgressTotal", key: "progressTotal" }]], ["td", { highlight: "DownloadPercent", key: "percent" }], ["td", { highlight: "DownloadSpeed", key: "speed" }], ["td", { highlight: "DownloadTime", key: "time" }], ["td"]]], this.document, this.nodes); this.index = Array.indexOf(this.nodes.list.childNodes, this.nodes.head); Task.spawn(function* () { this.list = yield Downloads.getList(Downloads.ALL); let start = Date.now(); for (let download of yield this.list.getAll()) { if (Date.now() - start > MAX_LOAD_TIME) { util.dactyl.warn(_("download.givingUpAfter", (Date.now() - start) / 1000)); break; } this.addDownload(download); } this.update(); if (!this.dead) this.list.addView(this); }.bind(this)); return this.nodes.list; }), addDownload: function addDownload(download) { if (!this.downloads.has(download)) { download = Download(download, this); if (this.filter && !download.displayName.includes(this.filter)) return; this.downloads.set(download.download, download); let index = values(this.downloads).toArray() .sort((a, b) => a.compare(b)) .indexOf(download); this.nodes.list.insertBefore(download.nodes.row, this.nodes.list.childNodes[index + this.index + 1]); } }, removeDownload: function removeDownload(download) { if (this.downloads.has(download)) { this.nodes.list.removeChild(this.downloads.get(download).nodes.row); delete this.downloads.delete(download); } }, leave: function leave(stack) { if (stack.pop) this.cleanup(); }, allowedCommands: Class.Memoize(function () { let self = this; return { get clear() { return iter(self.downloads.values()).some(dl => dl.allowedCommands.remove); } }; }), commands: { clear: function () { this.list.removeFinished(); } }, sort: function sort() { let list = iter(this.downloads.values()).sort((a, b) => a.compare(b)); for (let [i, download] of iter(list)) if (this.nodes.list.childNodes[i + 1] != download.nodes.row) this.nodes.list.insertBefore(download.nodes.row, this.nodes.list.childNodes[i + 1]); }, shouldSort: function shouldSort() { return Array.some(arguments, val => this.sortOrder.some(v => v.substr(1) == val)); }, update: function update() { for (let node of values(this.nodes)) if (node.update && node.update != update) node.update(); this.updateProgress(); let event = this.document.createEvent("Events"); event.initEvent("dactyl-commandupdate", true, false); this.document.dispatchEvent(event); }, timeRemaining: Infinity, updateProgress: function updateProgress() { let downloads = iter(this.downloads.values()).toArray(); let active = downloads.filter(d => d.active); let self = Object.create(this); for (let prop of ["currentBytes", "totalBytes", "speed", "timeRemaining"]) this[prop] = active.reduce((acc, dl) => dl[prop] + acc, 0); this.hasProgress = active.every(d => d.hasProgress); this.progress = Math.round((this.currentBytes / this.totalBytes) * 100); this.nActive = active.length; Download.prototype.updateProgress.call(self); if (active.length) this.nodes.total.textContent = _("download.nActive", active.length); else for (let key of ["total", "percent", "speed", "time"]) this.nodes[key].textContent = ""; if (this.shouldSort("complete", "size", "speed", "time")) this.sort(); }, onDownloadAdded: function onDownloadAdded(download) { this.addDownload(download); this.modules.mow.resize(false); this.nodes.list.scrollIntoView(false); }, onDownloadRemoved: function onDownloadRemoved(download) { this.removeDownload(download); }, onDownloadChanged: function onDownloadChanged(download) { if (this.downloads.has(download)) { download = this.downloads.get(download); download.updateStatus(); download.updateProgress(); this.update(); if (this.shouldSort("active")) this.sort(); } } }); ["canceled", "contentType", "currentBytes", "error", "hasPartialData", "hasProgress", "launchWhenSucceeded", "launcherPath", "progress", "saver", "source", "speed", "startTime", "stopped", "succeeded", "target", "totalBytes", "tryToKeepPartialData"].forEach(key => { if (!(key in Download.prototype)) Object.defineProperty(Download.prototype, key, { get: function get() { return this.download[key]; }, set: function set(val) { this.download[key] = val; }, configurable: true }); }); var Downloads_ = Module("downloads", XPCOM(Ci.nsIDownloadProgressListener), { init: function () { Downloads.getList(Downloads.ALL).then(list => { this.list = list; if (!this.dead) this.list.addView(this); }); }, cleanup: function destroy() { if (this.list) this.list.removeView(this); this.dead = true; }, onDownloadAdded: function onDownloadAdded(download) { }, onDownloadRemoved: function onDownloadRemoved(download) { }, onDownloadChanged: function onDownloadChanged(download) { if (download.succeeded) { let target = File(download.target.path); let url = download.source.url; let title = target.leafName; let file = target.path; let size = download.totalBytes; overlay.modules.forEach(function (modules) { modules.dactyl.echomsg({ domains: [util.getHost(url)], message: _("io.downloadFinished", title, file) }, 1, modules.commandline.ACTIVE_WINDOW); modules.autocommands.trigger("DownloadPost", { url: url, title: title, file: file, size: size }); }); } } }, { }, { commands: function initCommands(dactyl, modules, window) { const { commands, CommandOption } = modules; commands.add(["downl[oads]", "dl"], "Display the downloads list", function (args) { let downloads = DownloadList(modules, args[0], args["-sort"]); modules.commandline.echo(downloads); }, { argCount: "?", options: [ { names: ["-sort", "-s"], description: "Sort order (see 'downloadsort')", type: CommandOption.LIST, get default() { return modules.options["downloadsort"]; }, completer: function (context, args) { modules.options.get("downloadsort").completer(context, { values: args["-sort"] }); }, validator: function (value) { return modules.options.get("downloadsort").validator(value); } } ] }); commands.add(["dlc[lear]"], "Clear completed downloads", function (args) { downloads.list.removeFinished(); }); }, options: function initOptions(dactyl, modules, window) { const { options } = modules; if (false) options.add(["downloadcolumns", "dlc"], "The columns to show in the download manager", "stringlist", "filename,state,buttons,progress,percent,time,url", { values: { buttons: "Control buttons", filename: "Target filename", percent: "Percent complete", size: "File size", speed: "Download speed", state: "The download's state", time: "Time remaining", url: "Source URL" } }); options.add(["downloadsort", "dlsort", "dls"], ":downloads sort order", "stringlist", "-active,+filename", { values: { active: "Whether download is active", complete: "Percent complete", date: "Date and time the download began", filename: "Target filename", size: "File size", speed: "Download speed", time: "Time remaining", url: "Source URL" }, completer: function (context, extra) { let seen = new RealSet(extra.values.map(val => val.substr(1))); context.completions = iter(this.values).filter(([k, v]) => !seen.has(k)) .map(([k, v]) => [["+" + k, [v, " (", _("sort.ascending"), ")"].join("")], ["-" + k, [v, " (", _("sort.descending"), ")"].join("")]]) .flatten().array; }, has: function () { return Array.some(arguments, val => this.value.some(v => v.substr(1) == val)); }, validator: function (value) { let seen = new RealSet(); return value.every(val => /^[+-]/.test(val) && hasOwnProp(this.values, val.substr(1)) && !seen.add(val.substr(1))) && value.length; } }); } }); endModule(); // catch(e){ if (isString(e)) e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); } // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/finder.jsm000066400000000000000000000743441264147376100210040ustar00rootroot00000000000000// Copyright (c) 2008-2014 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; defineModule("finder", { exports: ["RangeFind", "RangeFinder", "rangefinder"], require: ["prefs", "util"] }); lazyRequire("buffer", ["Buffer"]); lazyRequire("overlay", ["overlay"]); function id(w) { return w.QueryInterface(Ci.nsIInterfaceRequestor) .getInterface(Ci.nsIDOMWindowUtils) .outerWindowID; } function equals(a, b) { return id(a) == id(b); } /** @instance rangefinder */ var RangeFinder = Module("rangefinder", { Local: function (dactyl, modules, window) { return { init: function () { this.dactyl = dactyl; this.modules = modules; this.window = window; this.lastFindPattern = ""; }, get content() { let { window } = this.modes.getStack(0).params; return window || this.window.content; }, get rangeFind() { let find = overlay.getData(this.content.document, "range-find", null); if (!isinstance(find, RangeFind) || find.stale) return this.rangeFind = null; return find; }, set rangeFind(val) { overlay.setData(this.content.document, "range-find", val); } }; }, init: function init() { prefs.safeSet("accessibility.typeaheadfind.autostart", false); // The above should be sufficient, but: http://bugzil.la/348187 prefs.safeSet("accessibility.typeaheadfind", false); }, cleanup: function cleanup() { for (let doc of util.iterDocuments()) { let find = overlay.getData(doc, "range-find", null); if (find) find.highlight(true); overlay.setData(doc, "range-find", null); } }, get commandline() { return this.modules.commandline; }, get modes() { return this.modules.modes; }, get options() { return this.modules.options; }, openPrompt: function openPrompt(mode) { this.modules.marks.push(); this.commandline; this.CommandMode(mode, this.content).open(); Buffer(this.content).resetCaret(); if (this.rangeFind && equals(this.rangeFind.window.get(), this.window)) this.rangeFind.reset(); this.find("", mode == this.modes.FIND_BACKWARD); }, bootstrap: function bootstrap(str, backward=this.rangeFind && this.rangeFind.reverse) { let highlighted = this.rangeFind && this.rangeFind.highlighted; let selections = this.rangeFind && this.rangeFind.selections; let linksOnly = false; let regexp = false; let matchCase = this.options["findcase"] === "smart" ? /[A-Z]/.test(str) : this.options["findcase"] === "ignore" ? false : true; function replacer(m, n1) { if (n1 == "c") matchCase = false; else if (n1 == "C") matchCase = true; else if (n1 == "l") linksOnly = true; else if (n1 == "L") linksOnly = false; else if (n1 == "r") regexp = true; else if (n1 == "R") regexp = false; else return m; return ""; } this.options["findflags"].forEach(f => replacer(f, f)); let pattern = str.replace(/\\(.|$)/g, replacer); if (str) this.lastFindPattern = str; // It's possible, with :tabdetach for instance, for the rangeFind to // actually move from one window to another, which breaks things. if (!this.rangeFind || !equals(this.rangeFind.window.get(), this.window) || linksOnly != !!this.rangeFind.elementPath || regexp != this.rangeFind.regexp || matchCase != this.rangeFind.matchCase || !!backward != this.rangeFind.reverse) { if (this.rangeFind) this.rangeFind.cancel(); this.rangeFind = null; this.rangeFind = RangeFind(this.window, this.content, matchCase, backward, linksOnly && this.options.get("hinttags").matcher, regexp); this.rangeFind.highlighted = highlighted; this.rangeFind.selections = selections; } this.rangeFind.pattern = str; return pattern; }, find: function find(pattern, backwards) { this.modules.marks.push(); let str = this.bootstrap(pattern, backwards); this.backward = this.rangeFind.reverse; if (!this.rangeFind.find(str)) this.dactyl.echoerr(_("finder.notFound", pattern), this.commandline.FORCE_SINGLELINE); return this.rangeFind.found; }, findAgain: function findAgain(reverse) { this.modules.marks.push(); if (!this.rangeFind) this.find(this.lastFindPattern); else if (!this.rangeFind.find(null, reverse)) this.dactyl.echoerr(_("finder.notFound", this.lastFindPattern), this.commandline.FORCE_SINGLELINE); else if (this.rangeFind.wrapped) { let msg = this.rangeFind.backward ? _("finder.atTop") : _("finder.atBottom"); this.commandline.echo(msg, "WarningMsg", this.commandline.APPEND_TO_MESSAGES | this.commandline.FORCE_SINGLELINE); } else this.commandline.echo((this.rangeFind.backward ? "?" : "/") + this.rangeFind.pattern, "Normal", this.commandline.FORCE_SINGLELINE); if (this.options["hlfind"]) this.highlight(); this.rangeFind.focus(); }, onCancel: function onCancel() { if (this.rangeFind) this.rangeFind.cancel(); }, onChange: function onChange(command) { if (this.options["incfind"]) { command = this.bootstrap(command); this.rangeFind.find(command); } }, onHistory: function onHistory() { this.rangeFind.found = false; }, onSubmit: function onSubmit(command) { if (!command && this.lastFindPattern) { this.find(this.lastFindPattern, this.backward); this.findAgain(); return; } if (!this.options["incfind"] || !this.rangeFind || !this.rangeFind.found) { this.clear(); this.find(command || this.lastFindPattern, this.backward); } if (this.options["hlfind"]) this.highlight(); this.rangeFind.focus(); }, /** * Highlights all occurrences of the last sought for string in the * current buffer. */ highlight: function highlight() { if (this.rangeFind) this.rangeFind.highlight(); }, /** * Clears all find highlighting. */ clear: function clear() { if (this.rangeFind) this.rangeFind.highlight(true); } }, { }, { modes: function initModes(dactyl, modules, window) { initModes.require("commandline"); const { modes } = modules; modes.addMode("FIND", { description: "Find mode, active when typing search input", bases: [modes.COMMAND_LINE] }); modes.addMode("FIND_FORWARD", { description: "Forward Find mode, active when typing search input", bases: [modes.FIND] }); modes.addMode("FIND_BACKWARD", { description: "Backward Find mode, active when typing search input", bases: [modes.FIND] }); }, commands: function initCommands(dactyl, modules, window) { const { commands, rangefinder } = modules; commands.add(["noh[lfind]"], "Remove the find highlighting", function () { rangefinder.clear(); }, { argCount: "0" }); }, commandline: function initCommandline(dactyl, modules, window) { const { rangefinder } = modules; rangefinder.CommandMode = Class("CommandFindMode", modules.CommandMode, { init: function init(mode, window) { this.mode = mode; this.window = window; init.supercall(this); }, historyKey: "find", get prompt() { return this.mode === modules.modes.FIND_BACKWARD ? "?" : "/"; }, get onCancel() { return modules.rangefinder.bound.onCancel; }, get onChange() { return modules.rangefinder.bound.onChange; }, get onHistory() { return modules.rangefinder.bound.onHistory; }, get onSubmit() { return modules.rangefinder.bound.onSubmit; } }); }, mappings: function initMappings(dactyl, modules, window) { const { Buffer, buffer, config, mappings, modes, rangefinder } = modules; var myModes = config.browserModes.concat([modes.CARET]); mappings.add(myModes, ["/", ""], "Find a pattern starting at the current caret position", function () { rangefinder.openPrompt(modes.FIND_FORWARD); }); mappings.add(myModes, ["?", "", ""], "Find a pattern backward of the current caret position", function () { rangefinder.openPrompt(modes.FIND_BACKWARD); }); mappings.add(myModes, ["n", ""], "Find next", function () { rangefinder.findAgain(false); }); mappings.add(myModes, ["N", ""], "Find previous", function () { rangefinder.findAgain(true); }); mappings.add(myModes.concat([modes.CARET, modes.TEXT_EDIT]), ["*", ""], "Find word under cursor", function () { rangefinder.find(Buffer.currentWord(buffer.focusedFrame, true), false); rangefinder.findAgain(); }); mappings.add(myModes.concat([modes.CARET, modes.TEXT_EDIT]), ["#", ""], "Find word under cursor backwards", function () { rangefinder.find(Buffer.currentWord(buffer.focusedFrame, true), true); rangefinder.findAgain(); }); }, options: function initOptions(dactyl, modules, window) { const { options, rangefinder } = modules; options.add(["hlfind", "hlf"], "Highlight all /find pattern matches on the current page after submission", "boolean", false, { setter: function (value) { rangefinder[value ? "highlight" : "clear"](); return value; } }); options.add(["findcase", "fc"], "Find case matching mode", "string", "smart", { values: { "smart": "Case is significant when capital letters are typed", "match": "Case is always significant", "ignore": "Case is never significant" } }); options.add(["findflags", "ff"], "Default flags for find invocations", "charlist", "", { values: { "c": "Ignore case", "C": "Match case", "r": "Perform a regular expression search", "R": "Perform a plain string search", "l": "Search only in links", "L": "Search all text" } }); options.add(["incfind", "if"], "Find a pattern incrementally as it is typed rather than awaiting c_", "boolean", true); } }); /** * @class RangeFind * * A fairly sophisticated typeahead-find replacement. It supports * incremental find very much as the builtin component. * Additionally, it supports several features impossible to * implement using the standard component. Incremental finding * works both forwards and backwards. Erasing characters during an * incremental find moves the selection back to the first * available match for the shorter term. The selection and viewport * are restored when the find is canceled. * * Also, in addition to full support for frames and iframes, this * implementation will begin finding from the position of the * caret in the last active frame. This is contrary to the behavior * of the builtin component, which always starts a find from the * beginning of the first frame in the case of frameset documents, * and cycles through all frames from beginning to end. This makes it * impossible to choose the starting point of a find for such * documents, and represents a major detriment to productivity where * large amounts of data are concerned (e.g., for API documents). */ var RangeFind = Class("RangeFind", { init: function init(window, content, matchCase, backward, elementPath, regexp) { this.window = util.weakReference(window); this.content = content; this.baseDocument = util.weakReference(this.content.document); this.elementPath = elementPath || null; this.reverse = Boolean(backward); this.finder = services.Find(); this.matchCase = Boolean(matchCase); this.regexp = Boolean(regexp); this.reset(); this.highlighted = null; this.selections = []; this.lastString = ""; }, get store() { return overlay.getData(this.content.document, "buffer", Object); }, get backward() { return this.finder.findBackwards; }, set backward(val) { this.finder.findBackwards = val; }, get matchCase() { return this.finder.caseSensitive; }, set matchCase(val) { this.finder.caseSensitive = Boolean(val); }, get findString() { return this.lastString; }, get flags() { return this.matchCase ? "" : "i"; }, get selectedRange() { let win = this.store.focusedFrame && this.store.focusedFrame.get() || this.content; let selection = win.getSelection(); return (selection.rangeCount ? selection.getRangeAt(0) : this.ranges[0].range).cloneRange(); }, set selectedRange(range) { this.range.selection.removeAllRanges(); this.range.selection.addRange(range); this.range.selectionController.scrollSelectionIntoView( this.range.selectionController.SELECTION_NORMAL, 0, false); this.store.focusedFrame = util.weakReference(range.startContainer.ownerDocument.defaultView); }, cancel: function cancel() { this.purgeListeners(); if (this.range) { this.range.deselect(); this.range.descroll(); } }, compareRanges: function compareRanges(r1, r2) { try { return this.backward ? r1.compareBoundaryPoints(r1.END_TO_START, r2) : -r1.compareBoundaryPoints(r1.START_TO_END, r2); } catch (e) { util.reportError(e); return 0; } }, findRange: function findRange(range) { let doc = range.startContainer.ownerDocument; let win = doc.defaultView; let ranges = this.ranges.filter(r => r.window === win && RangeFind.sameDocument(r.range, range) && RangeFind.contains(r.range, range)); if (this.backward) return ranges[ranges.length - 1]; return ranges[0]; }, findSubRanges: function* findSubRanges(range) { let doc = range.startContainer.ownerDocument; for (let elem of this.elementPath(doc)) { let r = RangeFind.nodeRange(elem); if (RangeFind.contains(range, r)) yield r; } }, focus: function focus() { if (this.lastRange) var node = DOM.XPath(RangeFind.selectNodePath, this.lastRange.commonAncestorContainer).snapshotItem(0); if (node) { node.focus(); // Re-highlight collapsed selection this.selectedRange = this.lastRange; } }, highlight: function highlight(clear) { if (!clear && (!this.lastString || this.lastString == this.highlighted)) return; if (clear && !this.highlighted) return; if (!clear && this.highlighted) this.highlight(true); if (clear) { this.selections.forEach(function (selection) { selection.removeAllRanges(); }); this.selections = []; this.highlighted = null; } else { this.selections = []; let string = this.lastString; for (let r of this.iter(string)) { let controller = this.range.selectionController; for (let node = r.startContainer; node; node = node.parentNode) if (node instanceof Ci.nsIDOMNSEditableElement) { controller = node.editor.selectionController; break; } let sel = controller.getSelection(Ci.nsISelectionController.SELECTION_FIND); sel.addRange(r); if (this.selections.indexOf(sel) < 0) this.selections.push(sel); } this.highlighted = this.lastString; if (this.lastRange) this.selectedRange = this.lastRange; this.addListeners(); } }, indexIter: function* indexIter(private_) { let idx = this.range.index; if (this.backward) var groups = [util.range(idx + 1, 0, -1), util.range(this.ranges.length, idx, -1)]; else var groups = [util.range(idx, this.ranges.length), util.range(0, idx + 1)]; for (let i of groups[0]) yield i; if (!private_) { this.wrapped = true; this.lastRange = null; for (let i of groups[1]) yield i; } }, iter: function* iter(word) { let saved = ["lastRange", "lastString", "range", "regexp"].map(s => [s, this[s]]); let res; try { let regexp = this.regexp && word != util.regexp.escape(word); this.lastRange = null; this.regexp = false; if (regexp) { let re = RegExp(word, "gm" + this.flags); for (this.range of this.ranges) { for (let match of util.regexp.iterate(re, DOM.stringify(this.range.range, true))) { let lastRange = this.lastRange; if (res = this.find(null, this.reverse, true)) yield res; else this.lastRange = lastRange; } } } else { this.range = this.ranges[0]; this.lastString = word; while (res = this.find(null, this.reverse, true)) yield res; } } finally { saved.forEach(([k, v]) => { this[k] = v; }); } }, makeFrameList: function makeFrameList(win) { const self = this; win = win.top; let frames = []; let backup = null; function pushRange(start, end) { function push(r) { if (r = RangeFind.Range(r, frames.length)) frames.push(r); } let doc = start.startContainer.ownerDocument; let range = doc.createRange(); range.setStart(start.startContainer, start.startOffset); range.setEnd(end.startContainer, end.startOffset); if (!self.elementPath) push(range); else for (let r of self.findSubRanges(range)) push(r); } function rec(win) { let doc = win.document; let pageRange = RangeFind[doc.body ? "nodeRange" : "nodeContents"](doc.body || doc.documentElement); backup = backup || pageRange; let pageStart = RangeFind.endpoint(pageRange, true); let pageEnd = RangeFind.endpoint(pageRange, false); for (let frame of Ary.iterValues(win.frames)) { let range = doc.createRange(); if (DOM(frame.frameElement).style.visibility == "visible") { range.selectNode(frame.frameElement); pushRange(pageStart, RangeFind.endpoint(range, true)); pageStart = RangeFind.endpoint(range, false); rec(frame); } } pushRange(pageStart, pageEnd); let anonNodes = doc.getAnonymousNodes(doc.documentElement); if (anonNodes) { for (let elem of anonNodes) { let range = RangeFind.nodeContents(elem); pushRange(RangeFind.endpoint(range, true), RangeFind.endpoint(range, false)); } } } rec(win); if (frames.length == 0) frames[0] = RangeFind.Range(RangeFind.endpoint(backup, true), 0); return frames; }, reset: function reset() { this.ranges = this.makeFrameList(this.content); this.startRange = this.selectedRange; this.startRange.collapse(!this.reverse); this.lastRange = this.selectedRange; this.range = this.findRange(this.startRange) || this.ranges[0]; util.assert(this.range, "Null range", false); this.ranges.first = this.range; this.ranges.forEach(range => { range.save(); }); this.forward = null; this.found = false; }, find: function find(pattern, reverse, private_) { if (!private_ && this.lastRange && !RangeFind.equal(this.selectedRange, this.lastRange)) this.reset(); this.wrapped = false; this.backward = reverse ? !this.reverse : this.reverse; let again = pattern == null; if (again) pattern = this.lastString; if (!this.matchCase) pattern = pattern.toLowerCase(); if (!again && (pattern === "" || !pattern.startsWith(this.lastString) || this.backward)) { if (!private_) this.range.deselect(); if (pattern === "") this.range.descroll(); this.lastRange = this.startRange; this.range = this.ranges.first; } let word = pattern; let regexp = this.regexp && word != util.regexp.escape(word); if (regexp) try { RegExp(pattern); } catch (e) { pattern = ""; } if (pattern == "") var range = this.startRange; else for (let i of this.indexIter(private_)) { if (!private_ && this.range.window != this.ranges[i].window && this.range.window != this.ranges[i].window.parent) { this.range.descroll(); this.range.deselect(); } this.range = this.ranges[i]; let start = RangeFind.sameDocument(this.lastRange, this.range.range) && this.range.intersects(this.lastRange) ? RangeFind.endpoint(this.lastRange, !(again ^ this.backward)) : RangeFind.endpoint(this.range.range, !this.backward); if (this.backward && !again) start = RangeFind.endpoint(this.startRange, false); if (regexp) { let range = this.range.range.cloneRange(); range[this.backward ? "setEnd" : "setStart"]( start.startContainer, start.startOffset); range = DOM.stringify(range); if (!this.backward) var match = RegExp(pattern, "m" + this.flags).exec(range); else { match = RegExp("[^]*(?:" + pattern + ")", "m" + this.flags).exec(range); if (match) match = RegExp(pattern + "$", this.flags).exec(match[0]); } if (!(match && match[0])) continue; word = match[0]; } var range = this.finder.Find(word, this.range.range, start, this.range.range); if (range && DOM(range.commonAncestorContainer).isVisible) break; } if (range) this.lastRange = range.cloneRange(); if (!private_) { this.lastString = pattern; if (range == null) { this.cancel(); this.found = false; return null; } this.found = true; } if (range && (!private_ || private_ < 0)) this.selectedRange = range; return range; }, get stale() { return this._stale || this.baseDocument.get() != this.content.document; }, set stale(val) { this._stale = val; }, addListeners: function addListeners() { for (let range of this.ranges) range.window.addEventListener("unload", this.bound.onUnload, true); }, purgeListeners: function purgeListeners() { for (let range of this.ranges) try { range.window.removeEventListener("unload", this.bound.onUnload, true); } catch (e if e.result === Cr.NS_ERROR_FAILURE) {} }, onUnload: function onUnload(event) { this.purgeListeners(); if (this.highlighted) this.highlight(true); this.stale = true; } }, { Range: Class("RangeFind.Range", { init: function init(range, index) { this.index = index; this.range = range; this.document = range.startContainer.ownerDocument; this.window = this.document.defaultView; if (this.selection == null) return false; this.save(); }, docShell: Class.Memoize(function () { return util.docShell(this.window); }), intersects: function (range) { return RangeFind.intersects(this.range, range); }, save: function save() { this.scroll = Point(this.window.pageXOffset, this.window.pageYOffset); this.initialSelection = null; if (this.selection.rangeCount) this.initialSelection = this.selection.getRangeAt(0); }, descroll: function descroll() { this.window.scrollTo(this.scroll.x, this.scroll.y); }, deselect: function deselect() { if (this.selection) { this.selection.removeAllRanges(); if (this.initialSelection) this.selection.addRange(this.initialSelection); } }, get selectionController() { return this.docShell .QueryInterface(Ci.nsIInterfaceRequestor) .getInterface(Ci.nsISelectionDisplay) .QueryInterface(Ci.nsISelectionController); }, get selection() { try { return this.selectionController.getSelection(Ci.nsISelectionController.SELECTION_NORMAL); } catch (e) { return null; } } }), contains: function contains(range, r, quiet) { try { return range.compareBoundaryPoints(range.START_TO_END, r) >= 0 && range.compareBoundaryPoints(range.END_TO_START, r) <= 0; } catch (e) { if (e.result != Cr.NS_ERROR_DOM_WRONG_DOCUMENT_ERR && !quiet) util.reportError(e, true); return false; } }, containsNode: function containsNode(range, n, quiet) { return n.ownerDocument && this.contains(range, RangeFind.nodeRange(n), quiet); }, intersects: function intersects(range, r) { try { return r.compareBoundaryPoints(range.START_TO_END, range) >= 0 && r.compareBoundaryPoints(range.END_TO_START, range) <= 0; } catch (e) { util.reportError(e, true); return false; } }, endpoint: function endpoint(range, before) { range = range.cloneRange(); range.collapse(before); return range; }, equal: function equal(r1, r2) { try { return !r1.compareBoundaryPoints(r1.START_TO_START, r2) && !r1.compareBoundaryPoints(r1.END_TO_END, r2); } catch (e) { return false; } }, nodeContents: function nodeContents(node) { let range = node.ownerDocument.createRange(); try { range.selectNodeContents(node); } catch (e) {} return range; }, nodeRange: function nodeRange(node) { let range = node.ownerDocument.createRange(); try { range.selectNode(node); } catch (e) {} return range; }, sameDocument: function sameDocument(r1, r2) { if (!(r1 && r2 && r1.endContainer.ownerDocument == r2.endContainer.ownerDocument)) return false; try { r1.compareBoundaryPoints(r1.START_TO_START, r2); } catch (e if e.result == 0x80530004 /* NS_ERROR_DOM_WRONG_DOCUMENT_ERR */) { return false; } return true; }, selectNodePath: ["a", "xhtml:a", "*[@onclick]"].map(p => "ancestor-or-self::" + p).join(" | "), union: function union(a, b) { let start = a.compareBoundaryPoints(a.START_TO_START, b) < 0 ? a : b; let end = a.compareBoundaryPoints(a.END_TO_END, b) > 0 ? a : b; let res = start.cloneRange(); res.setEnd(end.endContainer, end.endOffset); return res; } }); // catch(e){ if (typeof e === "string") e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); } endModule(); // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/help.jsm000066400000000000000000000455541264147376100204660ustar00rootroot00000000000000// Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; defineModule("help", { exports: ["help"], require: ["cache", "dom", "protocol", "services", "util"] }); lazyRequire("completion", ["completion"]); lazyRequire("overlay", ["overlay"]); lazyRequire("template", ["template"]); var HelpBuilder = Class("HelpBuilder", { init: function init() { try { // The versions munger will need to access the tag map // during this process and without this we'll get an // infinite loop. help._data = this; this.files = {}; this.tags = {}; this.overlays = {}; // Scrape the list of help files from all.xml this.tags["all"] = this.tags["all.xml"] = "all"; let files = this.findHelpFile("all").flatMap( doc => Array.from(DOM.XPath("//dactyl:include/@href", doc), f => f.value)); // Scrape the tags from the rest of the help files. for (let file of files) { this.tags[file + ".xml"] = file; for (let doc of this.findHelpFile(file)) this.addTags(file, doc); } } finally { delete help._data; } }, toJSON: function toJSON() { return { files: this.files, overlays: this.overlays, tags: this.tags }; }, // Find the tags in the document. addTags: function addTags(file, doc) { for (let elem of DOM.XPath("//@tag|//dactyl:tags/text()|//dactyl:tag/text()", doc)) for (let tag of (elem.value || elem.textContent).split(/\s+/)) this.tags[tag] = file; }, bases: ["dactyl://locale-local/", "dactyl://locale/", "dactyl://cache/help/"], // Find help and overlay files with the given name. findHelpFile: function findHelpFile(file) { let result = []; for (let base of this.bases) { let url = [base, file, ".xml"].join(""); let res = util.httpGet(url, { quiet: true }); if (res) { if (res.responseXML.documentElement.localName == "document") this.files[file] = url; if (res.responseXML.documentElement.localName == "overlay") this.overlays[file] = url; result.push(res.responseXML); } } return result; } }); var Help = Module("Help", { init: function init() { this.initialized = false; function Loop(fn) { return function (uri, path) { if (!help.initialized) return RedirectChannel(uri.spec, uri, 2, "Initializing. Please wait..."); return fn.apply(this, arguments); }; } update(services["dactyl:"].providers, { "help": Loop((uri, path) => help.files[path]), "help-overlay": Loop((uri, path) => help.overlays[path]), "help-tag": Loop((uri, path) => { let tag = decodeURIComponent(path); if (tag in help.files) return RedirectChannel("dactyl://help/" + tag, uri); if (tag in help.tags) return RedirectChannel("dactyl://help/" + help.tags[tag] + "#" + tag.replace(/#/g, encodeURIComponent), uri); }) }); cache.register("help.json", HelpBuilder); cache.register("help/versions.xml", () => { let NEWS = util.httpGet(config.addon.getResourceURI("NEWS").spec, { mimeType: "text/plain;charset=UTF-8" }) .responseText; let re = util.regexp(UTF8(String.raw` ^ (?P \s* # .*\n) | ^ (?P \s*) (?P [-•*+]) \ // (?P .*\n (?: ${"\\2" /* This is incorrectly interpreted as an octal literal otherwise */}\ \ .*\n | \s*\n)* ) | (?P (?: ^ [^\S\n]* (?:[^-•*+\s] | [-•*+]\S) .*\n )+ ) | (?: ^ [^\S\n]* \n) + `), "gmxy"); let matchBetas = util.regexp(/\[((?:b|rc)\d)\]/, "gx"); let betas = Array.from(matchBetas.iterate(NEWS), match => match[1]); let beta = betas.sort().pop(); function rec(text, level, li) { let res = []; let list, i = 0; for (let match of re.iterate(text)) { if (match.comment) continue; else if (match.char) { if (!list) res.push(list = ["ul", {}]); let li = ["li", {}]; li.push(rec(match.content .replace(RegExp("^" + match.space, "gm"), ""), level + 1, li)); list.push(li); } else if (match.par) { let [, par, tags] = /([^]*?)\s*((?:\[[^\]]+\])*)\n*$/.exec(match.par); let t = tags; tags = Array.from(matchBetas.iterate(tags), match => match[1]); let group = !tags.length ? "" : !tags.some(t => t == beta) ? "HelpNewsOld" : "HelpNewsNew"; if (i === 0 && li) { li[1]["dactyl:highlight"] = group; group = ""; } list = null; if (level == 0 && /^.*:\n$/.test(match.par)) { let text = par.slice(0, -1); res.push(["h2", { tag: "news-" + text }, template.linkifyHelp(text, true)]); } else { let [, a, b] = /^(IMPORTANT:?)?([^]*)/.exec(par); res.push(["p", { "dactyl:highlight": group + " HelpNews" }, !tags.length ? "" : ["hl", { key: "HelpNewsTag" }, tags.join(" ")], a ? ["hl", { key: "HelpWarning" }, a] : "", template.linkifyHelp(b, true)]); } } i++; } return res; } let body = rec(NEWS, 0); // E4X-FIXME // for each (let li in body..li) { // let list = li..li.(@NS::highlight == "HelpNewsOld"); // if (list.length() && list.length() == li..li.(@NS::highlight != "").length()) { // for each (let li in list) // li.@NS::highlight = ""; // li.@NS::highlight = "HelpNewsOld"; // } // } return '\n' + '\n' + DOM.toXML(["document", { xmlns: "dactyl", name: "versions", title: config.appName + " Versions" }, ["h1", { tag: "versions news NEWS" }, config.appName + " Versions"], ["toc", { start: "2" }], body]); }, true); }, initialize: function initialize() { help.initialized = true; }, flush: function flush(entries, time) { cache.flushEntry("help.json", time); for (let entry of Array.concat(entries || [])) cache.flushEntry(entry, time); }, get data() { return this._data || cache.get("help.json"); }, get files() { return this.data.files; }, get overlays() { return this.data.overlays; }, get tags() { return this.data.tags; }, Local: function Local(dactyl, modules, window) { return { init: function init() { dactyl.commands["dactyl.help"] = event => { let elem = event.originalTarget; modules.help.help(elem.getAttribute("tag") || elem.textContent); }; }, /** * Returns the URL of the specified help *topic* if it exists. * * @param {string} topic The help topic to look up. * @param {boolean} consolidated Whether to search the consolidated help page. * @returns {string} */ findHelp: function (topic, consolidated) { if (!consolidated && hasOwnProp(help.files, topic)) return topic; let items = modules.completion._runCompleter("help", topic, null, !!consolidated).items; let partialMatch = null; function format(item) { return item.description + "#" + encodeURIComponent(item.text); } for (let item of items) { if (item.text == topic) return format(item); else if (!partialMatch && topic) partialMatch = item; } if (partialMatch) return format(partialMatch); return null; }, /** * Opens the help page containing the specified *topic* if it exists. * * @param {string} topic The help topic to open. * @param {boolean} consolidated Whether to use the consolidated help page. */ help: function (topic, consolidated) { dactyl.initHelp(); if (!topic) { let helpFile = consolidated ? "all" : modules.options["helpfile"]; if (hasOwnProp(help.files, helpFile)) dactyl.open("dactyl://help/" + helpFile, { from: "help" }); else dactyl.echomsg(_("help.noFile", JSON.stringify(helpFile))); return; } let page = this.findHelp(topic, consolidated); dactyl.assert(page != null, _("help.noTopic", topic)); dactyl.open("dactyl://help/" + page, { from: "help" }); }, exportHelp: function (path) { const FILE = io.File(path); const PATH = FILE.leafName.replace(/\..*/, "") + "/"; const TIME = Date.now(); if (!FILE.exists() && (/\/$/.test(path) && !/\./.test(FILE.leafName))) FILE.create(FILE.DIRECTORY_TYPE, 0o755); dactyl.initHelp(); if (FILE.isDirectory()) { var addDataEntry = (file, data) => { FILE.child(file).write(data); }; var addURIEntry = (file, uri) => { addDataEntry(file, util.httpGet(uri).responseText); }; } else { var zip = services.ZipWriter(FILE.file, File.MODE_CREATE | File.MODE_WRONLY | File.MODE_TRUNCATE); addURIEntry = (file, uri) => { zip.addEntryChannel(PATH + file, TIME, 9, services.io.newChannel(uri, null, null), false); }; addDataEntry = (file, data) => {// Unideal to an extreme. addURIEntry(file, "data:text/plain;charset=UTF-8," + encodeURI(data)); }; } let empty = new RealSet("area base basefont br col frame hr img input isindex link meta param" .split(" ")); function fix(node) { switch (node.nodeType) { case Ci.nsIDOMNode.ELEMENT_NODE: if (isinstance(node, [Ci.nsIDOMHTMLBaseElement])) return; data.push("<", node.localName); if (node instanceof Ci.nsIDOMHTMLHtmlElement) data.push(" xmlns=" + JSON.stringify(XHTML), " xmlns:dactyl=" + JSON.stringify(NS)); for (let { name, value } of node.attributes) { if (name == "dactyl:highlight") { styles.add(value); name = "class"; value = "hl-" + value; } if (name == "href") { value = node.href || value; if (value.startsWith("dactyl://help-tag/")) { try { let uri = services.io.newChannel(value, null, null).originalURI; value = uri.spec == value ? "javascript:;" : uri.path.substr(1); } catch (e) { util.dump("Magical tag thingy failure for: " + value); dactyl.reportError(e); } } if (!/^#|[\/](#|$)|^[a-z]+:/.test(value)) value = value.replace(/(#|$)/, ".xhtml$1"); } if (name == "src" && value.indexOf(":") > 0) { chromeFiles[value] = value.replace(/.*\//, ""); value = value.replace(/.*\//, ""); } data.push(" ", name, '="', DOM.escapeHTML(value), '"'); } if (empty.has(node.localName)) data.push(" />"); else { data.push(">"); if (node instanceof Ci.nsIDOMHTMLHeadElement) data.push(''); Array.map(node.childNodes, fix); data.push(""); } break; case Ci.nsIDOMNode.TEXT_NODE: data.push(DOM.escapeHTML(node.textContent, true)); } } let { buffer, content, events } = modules; let chromeFiles = {}; let styles = new RealSet; for (let [file, ] of iter(help.files)) { let url = "dactyl://help/" + file; dactyl.open(url); util.waitFor(() => (content.location.href == url && buffer.loaded && content.document.documentElement instanceof Ci.nsIDOMHTMLHtmlElement), 15000); events.waitForPageLoad(); var data = [ '\n', '\n' ]; fix(content.document.documentElement); addDataEntry(file + ".xhtml", data.join("")); } data = Array.from(highlight) .filter(h => styles.has(h.class) || /^Help/.test(h.class)) .map(h => (h.selector .replace(/^\[.*?=(.*?)\]/, ".hl-$1") .replace(/html\|/g, "") + "\t" + "{" + h.cssText + "}")) .join("\n"); addDataEntry("help.css", data.replace(/chrome:[^ ")]+\//g, "")); addDataEntry("tag-map.json", JSON.stringify(help.tags)); let m, re = /(chrome:[^ ");]+\/)([^ ");]+)/g; while ((m = re.exec(data))) chromeFiles[m[0]] = m[2]; for (let [uri, leaf] of iter(chromeFiles)) addURIEntry(leaf, uri); if (zip) zip.close(); } }; } }, { }, { commands: function initCommands(dactyl, modules, window) { const { commands, completion, help } = modules; [ { name: ["h[elp]", "halp"], description: "Open the introductory help page" }, { name: "helpa[ll]", description: "Open the single consolidated help page" } ].forEach(function (command) { let consolidated = command.name == "helpa[ll]"; commands.add([command.name], command.description, function (args) { dactyl.assert(!args.bang, _("help.dontPanic")); help.help(args.literalArg, consolidated); }, { argCount: "?", bang: true, completer: function (context) { completion.help(context, consolidated); }, literal: 0 }); }); }, completion: function initCompletion(dactyl, modules, window) { const { completion } = modules; completion.help = function completion_help(context, consolidated) { dactyl.initHelp(); context.title = ["Help"]; context.anchored = false; context.completions = help.tags; if (consolidated) context.keys = { text: 0, description: function () { return "all"; } }; }; }, javascript: function initJavascript(dactyl, modules, window) { modules.JavaScript.setCompleter([modules.help.exportHelp], [(context, args) => overlay.activeModules.completion.file(context)]); }, options: function initOptions(dactyl, modules, window) { const { options } = modules; options.add(["helpfile", "hf"], "Name of the main help file", "string", "intro"); } }); endModule(); // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/highlight.jsm000066400000000000000000000434101264147376100214720ustar00rootroot00000000000000// Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; defineModule("highlight", { exports: ["Highlight", "Highlights", "highlight"], require: ["services", "util"] }); lazyRequire("styles", ["Styles", "styles"]); lazyRequire("template", ["template"]); var Highlight = Struct("class", "selector", "sites", "defaultExtends", "defaultValue", "value", "extends", "agent", "base", "baseClass", "style"); Highlight.liveProperty = function (name, prop) { this.prototype.__defineGetter__(name, function () { return this.get(name); }); this.prototype.__defineSetter__(name, function (val) { if (isObject(val) && name !== "style") { if (isArray(val)) val = Array.slice(val); else val = update({}, val); Object.freeze(val); } this.set(name, val); if (name === "value" || name === "extends") for (let h of highlight) if (h.extends.indexOf(this.class) >= 0) h.style.css = h.css; this.style[prop || name] = this[prop || name]; if (this.onChange) this.onChange(); }); }; Highlight.liveProperty("agent"); Highlight.liveProperty("extends", "css"); Highlight.liveProperty("value", "css"); Highlight.liveProperty("selector", "css"); Highlight.liveProperty("sites"); Highlight.liveProperty("style", "css"); Highlight.defaultValue("baseClass", function () { return /^(\w*)/.exec(this.class)[0]; }); Highlight.defaultValue("selector", function () { return highlight.selector(this.class); }); Highlight.defaultValue("sites", function () { return this.base ? this.base.sites : ["resource://dactyl*", "dactyl:*", "file://*"] .concat(highlight.styleableChrome); }); Highlight.defaultValue("style", function () { return styles.system.add("highlight:" + this.class, this.sites, this.css, this.agent, true); }); Highlight.defaultValue("defaultExtends", () => []); Highlight.defaultValue("defaultValue", () => ""); Highlight.defaultValue("extends", function () { return this.defaultExtends; }); Highlight.defaultValue("value", function () { return this.defaultValue; }); update(Highlight.prototype, { get base() { return this.baseClass != this.class && highlight.highlight[this.baseClass] || null; }, get bases() { return Ary.compact(this.extends.map(name => highlight.get(name))); }, get inheritedCSS() { if (this.gettingCSS) return ""; try { this.gettingCSS = true; return this.bases.map(b => b.cssText.replace(/;?\s*$/, "; ")).join(""); } finally { this.gettingCSS = false; } }, get css() { return this.selector + "{" + this.cssText + "}"; }, get cssText() { return this.inheritedCSS + this.value; }, toString: function () { return "Highlight(" + this.class + ")\n\t" + Array.from(this, ([k, v]) => `${k}: ${JSON.stringify(String(v))}`) .join("\n\t") } }); /** * A class to manage highlighting rules. * * @author Kris Maglione */ var Highlights = Module("Highlight", { init: function () { this.highlight = {}; this.loaded = {}; }, keys: function keys() { return Object.keys(this.highlight).sort(); }, "@@iterator": function () { return values(this.highlight) .sort((a, b) => String.localeCompare(a.class, b.class)) .iterValues(); }, _create: function _create(agent, args) { let obj = Highlight.apply(Highlight, args); if (!isArray(obj.sites)) obj.set("sites", obj.sites.split(",")); if (!isArray(obj.defaultExtends)) obj.set("defaultExtends", obj.defaultExtends.split(",")); obj.set("agent", agent); obj.set("defaultValue", Styles.append("", obj.get("defaultValue"))); let old = this.highlight[obj.class]; this.highlight[obj.class] = obj; // This *must* come before any other property changes. if (old) { obj.selector = old.selector; obj.style = old.style; } if (/^[[>+: ]/.test(args[1])) obj.selector = this.selector(obj.class) + args[1]; else if (args[1]) obj.selector = this.selector(args[1].replace(/^,/, "")); if (old && old.value != old.defaultValue) obj.value = old.value; if (!old && obj.base && obj.base.style.enabled) obj.style.enabled = true; else this.loaded.__defineSetter__(obj.class, function () { Object.defineProperty(this, obj.class, { value: true, configurable: true, enumerable: true, writable: true }); if (obj.class === obj.baseClass) for (let h of highlight) if (h.baseClass === obj.class) this[h.class] = true; obj.style.enabled = true; }); return obj; }, get: function get(k) { return this.highlight[k]; }, set: function set(key, newStyle, force, append, extend) { let highlight = this.highlight[key] || this._create(false, [key]); let bases = extend || highlight.extends; if (append) { newStyle = Styles.append(highlight.value || "", newStyle); bases = highlight.extends.concat(bases); } if (/^\s*$/.test(newStyle)) newStyle = null; if (newStyle == null && extend == null) { if (highlight.defaultValue == null && highight.defaultExtends.length == 0) { highlight.style.enabled = false; delete this.loaded[highlight.class]; delete this.highlight[highlight.class]; return null; } newStyle = highlight.defaultValue; bases = highlight.defaultExtends; } highlight.set("value", newStyle || ""); highlight.extends = Ary.uniq(bases, true); if (force) highlight.style.enabled = true; this.highlight[highlight.class] = highlight; return highlight; }, /** * Clears all highlighting rules. Rules with default values are * reset. */ clear: function clear() { for (let [k, v] of iter(this.highlight)) this.set(k, null, true); }, /** * Highlights a node with the given group, and ensures that said * group is loaded. * * @param {Node} node * @param {string} group */ highlightNode: function highlightNode(node, group, applyBindings) { node.setAttributeNS(NS, "highlight", group); let groups = group.split(" "); for (let group of groups) this.loaded[group] = true; if (applyBindings) for (let group of groups) { if (applyBindings.bindings && group in applyBindings.bindings) applyBindings.bindings[group](node, applyBindings); else if (group in template.bindings) template.bindings[group](node, applyBindings); } }, /** * Gets a CSS selector given a highlight group. * * @param {string} class */ selector: function selector(class_) { return class_.replace(/(^|[>\s])([A-Z][\w-]+)\b/g, (m, n1, hl) => { if (this.highlight[hl] && this.highlight[hl].class != class_) return n1 + this.highlight[hl].selector; return n1 + "[dactyl|highlight~=" + hl + "]"; }); }, groupRegexp: util.regexp(String.raw` ^ (\s* (?:\S|\s\S)+ \s+) \{ ([^}]*) \} \s* $ `, "gmx"), sheetRegexp: util.regexp(String.raw` ^\s* !? \*? (?P (?:[^;\s]|\s[^;\s])+ ) (?:; (?P (?:[^;\s]|\s[^;\s])+ )? )? (?:; (?P (?:[^;\s]|\s[^;\s])+ )? )? (?:; (?P (?:[^;\s]|\s[^;\s])+ )? )? \s* (?P .*) $ `, "x"), // /** * Bulk loads new CSS rules, in the format of, * * Rules ::= Rule | Rule "\n" Rule * Rule ::= Bang? Star? MatchSpec Space Space+ Css * | Comment * Comment ::= Space* "//" * * Bang ::= "!" * Star ::= "*" * MatchSpec ::= Class * | Class ";" Selector * | Class ";" Selector ";" Sites * | Class ";" Selector ";" Sites ";" Extends * CSS ::= CSSLine | "{" CSSLines "}" * CSSLines ::= CSSLine | CSSLine "\n" CSSLines * * Where Class is the name of the sheet, Selector is the CSS * selector for the style, Sites is the comma-separated list of site * filters to apply the style to. * * If Selector is not provided, it defaults to [dactyl|highlight~={Class}]. * If it is provided and begins with any of "+", ">" or " ", it is * appended to the default. * * If Sites is not provided, it defaults to the chrome documents of * the main application window, dactyl help files, and any other * dactyl-specific documents. * * If Star is provided, the style is applied as an agent sheet. * * The new styles are lazily activated unless Bang or *eager* is * provided. * * @param {string} css The rules to load. See {@link Highlights#css}. * @param {boolean} eager When true, load all provided rules immediately. */ loadCSS: function loadCSS(css, eager) { String.replace(css, /\\\n/g, "") .replace(this.groupRegexp, (m, m1, m2) => (m1 + " " + m2.replace(/\n\s*/g, " "))) .split("\n").filter(s => (/\S/.test(s) && !/^\s*\/\//.test(s))) .forEach(function (highlight) { let bang = eager || /^\s*!/.test(highlight); let star = /^\s*!?\*/.test(highlight); highlight = this._create(star, this.sheetRegexp.exec(highlight).slice(1)); if (bang) highlight.style.enabled = true; }, this); for (let h of this) h.style.css = h.css; } }, { }, { commands: function initCommands(dactyl, modules) { const { autocommands, commands, completion, CommandOption, config, io } = modules; let lastScheme; commands.add(["colo[rscheme]"], "Load a color scheme", function (args) { let scheme = args[0]; if (lastScheme) lastScheme.unload(); if (scheme == "default") highlight.clear(); else { lastScheme = io.sourceFromRuntimePath(["colors/" + scheme + "." + config.fileExtension]); dactyl.assert(lastScheme, _("command.colorscheme.notFound", scheme)); } autocommands.trigger("ColorScheme", { name: scheme }); }, { argCount: "1", completer: function (context) { completion.colorScheme(context); } }); commands.add(["hi[ghlight]"], "Set the style of certain display elements", function (args) { let style = ` ; display: inline-block !important; position: static !important; margin: 0px !important; padding: 0px !important; width: 3em !important; min-width: 3em !important; max-width: 3em !important; height: 1em !important; min-height: 1em !important; max-height: 1em !important; overflow: hidden !important; `; let clear = args[0] == "clear"; if (clear) args.shift(); let [key, css] = args; let modify = css || clear || args["-append"] || args["-link"]; if (!modify && /&$/.test(key)) [clear, modify, key] = [true, true, key.replace(/&$/, "")]; dactyl.assert(!(clear && css), _("error.trailingCharacters")); if (!modify) modules.commandline.commandOutput( template.tabular(["Key", "Sample", "Link", "CSS"], ["padding: 0 1em 0 0; vertical-align: top; max-width: 16em; overflow: hidden;", "text-align: center"], ([h.class, ["span", { style: "text-align: center; line-height: 1em;" + h.value + style }, "XXX"], template.map(h.extends, s => template.highlight(s), ","), template.highlightRegexp(h.value, /\b[-\w]+(?=:)|\/\*.*?\*\//g, match => ["span", { highlight: match[0] == "/" ? "Comment" : "Key" }, match]) ] for (h of highlight) if (!key || h.class.indexOf(key) > -1)))); else if (!key && clear) highlight.clear(); else if (key) highlight.set(key, css, clear, "-append" in args, args["-link"]); else util.assert(false, _("error.invalidArgument")); }, { // TODO: add this as a standard highlight completion function? completer: function (context, args) { // Complete a highlight group on :hi clear ... if (args.completeArg > 0 && args[0] == "clear") args.completeArg = args.completeArg > 1 ? -1 : 0; if (args.completeArg == 0) completion.highlightGroup(context); else if (args.completeArg == 1) { let hl = highlight.get(args[0]); if (hl) context.completions = [ [hl.value, _("option.currentValue")], [hl.defaultValue || "", _("option.defaultValue")] ]; context.fork("css", 0, completion, "css"); } }, hereDoc: true, literal: 1, options: [ { names: ["-append", "-a"], description: "Append new CSS to the existing value" }, { names: ["-link", "-l"], description: "Link this group to another", type: CommandOption.LIST, completer: function (context, args) { let group = args[0] && highlight.get(args[0]); if (group) context.fork("extra", 0, this, context => [ [String(group.extends), _("option.currentValue")], [String(group.defaultExtends) || "", _("option.defaultValue")] ]); context.fork("groups", 0, completion, "highlightGroup"); } } ], serialize: function () { return Array.from(highlight) .filter(v => v.value != v.defaultValue) .map(v => ({ command: this.name, arguments: [v.class], literalArg: v.value, options: { "-link": v.extends.length ? v.extends : undefined } })); } }); }, completion: function initCompletion(dactyl, modules) { const { completion, config, io } = modules; completion.colorScheme = function colorScheme(context) { let extRe = RegExp("\\." + config.fileExtension + "$"); context.title = ["Color Scheme", "Runtime Path"]; context.keys = { text: f => f.leafName.replace(extRe, ""), description: ".parent.path" }; context.completions = io.getRuntimeDirectories("colors") .flatMap(dir => dir.readDirectory() .filter(file => extRe.test(file.leafName))) .concat([ { leafName: "default", parent: { path: /*L*/"Revert to builtin colorscheme" } } ]); }; completion.highlightGroup = function highlightGroup(context) { context.title = ["Highlight Group", "Value"]; context.completions = Array.from(highlight, v => [v.class, v.value]); }; }, javascript: function initJavascript(dactyl, modules, window) { modules.JavaScript.setCompleter(["get", "set"].map(m => highlight[m]), [ (context, obj, args) => iter(highlight.highlight) ]); modules.JavaScript.setCompleter(["highlightNode"].map(m => highlight[m]), [ null, (context, obj, args) => iter(highlight.highlight) ]); } }); // catch(e){dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack);} endModule(); // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/io.jsm000066400000000000000000001371421264147376100201400ustar00rootroot00000000000000// Copyright (c) 2006-2008 by Martin Stubenschrott // Copyright (c) 2007-2012 by Doug Kearns // Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; try { defineModule("io", { exports: ["IO", "io"], require: ["services"] }); lazyRequire("config", ["config"]); lazyRequire("contexts", ["Contexts", "contexts"]); lazyRequire("promises", ["Promise"]); lazyRequire("storage", ["File", "storage"]); lazyRequire("styles", ["styles"]); lazyRequire("template", ["template"]); // TODO: why are we passing around strings rather than file objects? /** * Provides a basic interface to common system I/O operations. * @instance io */ var IO = Module("io", { init: function init() { this._processDir = services.directory.get("CurWorkD", Ci.nsIFile); this._cwd = this._processDir.path; this._oldcwd = null; lazyRequire("config", ["config"], this); }, Local: function Local(dactyl, modules, window) { let { io } = modules; return { init: function init() { this.config = modules.config; this._processDir = services.directory.get("CurWorkD", Ci.nsIFile); this._cwd = this._processDir.path; this._oldcwd = null; this._lastRunCommand = ""; // updated whenever the users runs a command with :! this._scriptNames = new RealSet; }, CommandFileMode: Class("CommandFileMode", modules.CommandMode, { init: function init(prompt, params) { init.supercall(this); this.prompt = isArray(prompt) ? prompt : ["Question", prompt]; update(this, params); }, historyKey: "file", get mode() { return modules.modes.FILE_INPUT; }, complete: function (context) { if (this.completer) this.completer(context); context = context.fork("files", 0); modules.completion.file(context); context.filters = context.filters.concat(this.filters || []); } }), /** * Returns all directories named *name* in 'runtimepath'. * * @param {string} name * @returns {nsIFile[] */ getRuntimeDirectories: function getRuntimeDirectories(name) { return modules.options.get("runtimepath").files .map(dir => dir.child(name)) .filter(dir => (dir.exists() && dir.isDirectory() && dir.isReadable())); }, // FIXME: multiple paths? /** * Sources files found in 'runtimepath'. For each relative path in *paths* * each directory in 'runtimepath' is searched and if a matching file is * found it is sourced. Only the first file found (per specified path) is * sourced unless *all* is specified, then all found files are sourced. * * @param {[string]} paths An array of relative paths to source. * @param {boolean} all Whether all found files should be sourced. */ sourceFromRuntimePath: function sourceFromRuntimePath(paths, all) { let dirs = modules.options.get("runtimepath").files; let found = null; dactyl.echomsg(_("io.searchingFor", JSON.stringify(paths.join(" ")), modules.options.get("runtimepath").stringValue), 2); outer: for (let dir of dirs) { for (let path of paths) { let file = dir.child(path); dactyl.echomsg(_("io.searchingFor", JSON.stringify(file.path)), 3); if (file.exists() && file.isFile() && file.isReadable()) { found = io.source(file.path, false) || true; if (!all) break outer; } } } if (!found) dactyl.echomsg(_("io.notInRTP", JSON.stringify(paths.join(" "))), 1); return found; }, /** * Reads Ex commands, JavaScript or CSS from *filename*. * * @param {string} filename The name of the file to source. * @param {object} params Extra parameters: * group: The group in which to execute commands. * silent: Whether errors should not be reported. */ source: function source(filename, params) { const { contexts } = modules; defineModule.loadLog.push("sourcing " + filename); if (!isObject(params)) params = { silent: params }; let time = Date.now(); return contexts.withContext(null, function () { try { var file = util.getFile(filename) || io.File(filename); if (!file.exists() || !file.isReadable() || file.isDirectory()) { if (!params.silent) dactyl.echoerr(_("io.notReadable", JSON.stringify(filename))); return; } dactyl.echomsg(_("io.sourcing", JSON.stringify(filename)), 2); let uri = file.URI; let sourceJSM = function sourceJSM() { context = contexts.Module(uri); dactyl.triggerObserver("io.source", context, file, file.lastModifiedTime); }; if (/\.jsm$/.test(filename)) sourceJSM(); else if (/\.js$/.test(filename)) { try { var context = contexts.Script(file, params.group); if (this._scriptNames.has(file.path)) util.flushCache(); dactyl.loadScript(uri.spec, context); dactyl.triggerObserver("io.source", context, file, file.lastModifiedTime); } catch (e) { if (e == Contexts) { // Hack; context.unload(); sourceJSM(); } else { if (e instanceof Finished) return; if (e.fileName && !(e instanceof FailedAssertion)) try { e.fileName = util.fixURI(e.fileName); if (e.fileName == uri.spec) e.fileName = filename; e.echoerr = [e.fileName, ":", e.lineNumber, ": ", e].join(""); } catch (e) {} throw e; } } } else if (/\.css$/.test(filename)) styles.registerSheet(uri.spec, false, true); else { context = contexts.Context(file, params.group); modules.commands.execute(file.read(), null, params.silent, null, { context: context, file: file.path, group: context.GROUP, line: 1 }); dactyl.triggerObserver("io.source", context, file, file.lastModifiedTime); } this._scriptNames.add(file.path); dactyl.echomsg(_("io.sourcingEnd", JSON.stringify(filename)), 2); dactyl.log(_("dactyl.sourced", filename), 3); return context; } catch (e) { util.reportError(e); let message = _("io.sourcingError", e.echoerr || (file ? file.path : filename) + ": " + e); if (!params.silent) dactyl.echoerr(message); } finally { defineModule.loadLog.push("done sourcing " + filename + ": " + (Date.now() - time) + "ms"); } }, this); } }; }, shell: Class.Memoize(() => { if (config.OS.isWindows) return "cmd.exe"; else return services.environment.get("SHELL") || "sh"; }), shellcmdflag: Class.Memoize(() => { if (config.OS.isWindows) return "/c"; else return "-c"; }), charsets: Class.Memoize(function () { const BASE = "@mozilla.org/intl/unicode/decoder;1?charset="; return Object.keys(Cc).filter(k.startsWith(BASE)) .map(k => k.slice(BASE.length)); }), charsetBundle: Class.Memoize( () => services.stringBundle.createBundle("chrome://global/locale/charsetTitles.properties")), charsetTitle: function charsetTitle(charset, default_=charset) { try { return this.charsetBundle.GetStringFromName(charset + ".title"); } catch (e) {} return default_; }, validateCharset: function validateCharset(charset) { try { new TextDecoder(charset); return true; } catch (e) { return false; } }, // TODO: there seems to be no way, short of a new component, to change // the process's CWD - see https://bugzilla.mozilla.org/show_bug.cgi?id=280953 /** * Returns the current working directory. * * It's not possible to change the real CWD of the process so this * state is maintained internally. External commands run via * {@link #system} are executed in this directory. * * @returns {nsIFile} */ get cwd() { let dir = File(this._cwd); // NOTE: the directory could have been deleted underneath us so // fallback to the process's CWD if (dir.exists() && dir.isDirectory()) return dir; else return this._processDir.clone(); }, /** * Sets the current working directory. * * @param {File|string} newDir The new CWD. This may be a relative or * absolute path and is expanded by {@link #expandPath}. * @optional * @default = "~" */ set cwd(newDir = "~") { newDir = newDir.path || newDir; if (newDir == "-") { util.assert(this._oldcwd != null, _("io.noPrevDir")); [this._cwd, this._oldcwd] = [this._oldcwd, this.cwd]; } else { let dir = io.File(newDir); util.assert(dir.exists() && dir.isDirectory(), _("io.noSuchDir", JSON.stringify(dir.path))); dir.normalize(); [this._cwd, this._oldcwd] = [dir.path, this.cwd]; } return this.cwd; }, /** * @property {function} File class. * @final */ File: Class.Memoize(function () { let io = this; return Class("File", File, { init: function init(path, checkCWD=true) { return init.supercall(this, path, checkCWD && io.cwd); } }); }), /** * @property {Object} The current file sourcing context. As a file is * being sourced the 'file' and 'line' properties of this context * object are updated appropriately. */ sourcing: null, expandPath: deprecated("File.expandPath", function expandPath() { return apply(File, "expandPath", arguments); }), /** * Returns the first user RC file found in *dir*. * * @param {File|string} dir The directory to search. * @param {boolean} always When true, return a path whether * the file exists or not. * @default $HOME. * @returns {nsIFile} The RC file or null if none is found. */ getRCFile: function getRCFile(dir, always) { dir = this.File(dir || "~"); let rcFile1 = dir.child("." + config.name + "rc"); let rcFile2 = dir.child("_" + config.name + "rc"); if (config.OS.isWindows) [rcFile1, rcFile2] = [rcFile2, rcFile1]; if (rcFile1.exists() && rcFile1.isFile()) return rcFile1; else if (rcFile2.exists() && rcFile2.isFile()) return rcFile2; else if (always) return rcFile1; return null; }, /** * Returns a temporary file. * * @param {string} ext The filename extension. * @default "txt" * @param {string} label A metadata string appended to the filename. Useful * for identifying the file, beyond its extension, to external * applications. * @default "" * @returns {File} */ createTempFile: function createTempFile(ext="txt", label="") { let file = services.directory.get("TmpD", Ci.nsIFile); file.append(config.name + label + "." + ext); file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, 0o666); services.externalApp.deleteTemporaryFileOnExit(file); return File(file); }, /** * Determines whether the given URL string resolves to a JAR URL and * returns the matching nsIJARURI object if it does. * * @param {string} url The URL to check. * @returns {nsIJARURI|null} */ isJarURL: function isJarURL(url) { try { let uri = util.newURI(url); if (uri instanceof Ci.nsIJARURI) return uri; let channel = services.io.newChannelFromURI(uri); try { channel.cancel(Cr.NS_BINDING_ABORTED); } catch (e) {} if (channel instanceof Ci.nsIJARChannel) return channel.URI.QueryInterface(Ci.nsIJARURI); } catch (e) {} return null; }, /** * Returns a list of the contents of the given JAR file which are * children of the given path. * * @param {nsIURI|string} file The URI of the JAR file to list. * @param {string} path The prefix path to search. */ listJar: function* listJar(file, path) { file = util.getFile(file); if (file && file.exists() && file.isFile() && file.isReadable()) { // let jar = services.zipReader.getZip(file); Crashes. let jar = services.ZipReader(file.file); try { let filter = RegExp("^" + util.regexp.escape(decodeURI(path)) + "[^/]*/?$"); for (let entry of iter(jar.findEntries("*"))) if (filter.test(entry)) yield entry; } finally { if (jar) jar.close(); } } }, readHeredoc: function readHeredoc(end) { return ""; }, /** * Searches for the given executable file in the system executable * file paths as specified by the PATH environment variable. * * On Windows, if the unadorned filename cannot be found, the * extensions in the semicolon-separated list in the PATHSEP * environment variable are successively appended to the original * name and searched for in turn. * * @param {string} bin The name of the executable to find. * @returns {File|null} */ pathSearch: function pathSearch(bin) { if (bin instanceof File || File.isAbsolutePath(bin)) return this.File(bin); let dirs = services.environment.get("PATH") .split(config.OS.pathListSep); // Windows tries the CWD first TODO: desirable? if (config.OS.isWindows) dirs = [io.cwd].concat(dirs); for (let dir of dirs) try { dir = this.File(dir, true); let file = dir.child(bin); if (file.exists() && file.isFile() && file.isExecutable()) return file; // TODO: couldn't we just palm this off to the start command? // automatically try to add the executable path extensions on windows if (config.OS.isWindows) { let extensions = services.environment.get("PATHEXT").split(";"); for (let extension of extensions) { file = dir.child(bin + extension); if (file.exists()) return file; } } } catch (e) {} return null; }, /** * Runs an external program. * * @param {File|string} program The program to run. * @param {[string]} args An array of arguments to pass to *program*. */ run: function run(program, args, blocking, self) { args = args || []; let file = this.pathSearch(program); if (!file || !file.exists()) { util.dactyl.echoerr(_("io.noCommand", program)); if (callable(blocking)) util.trapErrors(blocking); return -1; } let process = services.Process(file.file); process.run(false, args.map(String), args.length); let deferred = Promise.defer(); if (callable(blocking)) // Deprecated. deferred.promise.then(blocking); else if (blocking) { // Deprecated? while (process.isRunning) util.threadYield(false, true); return process.exitValue; } let timer = services.Timer( () => { if (!process.isRunning) { timer.cancel(); deferred.resolve(process.exitValue); } }, 100, services.Timer.TYPE_REPEATING_SLACK); return deferred.promise; }, /** * Runs *command* in a subshell and returns the output. The shell used is * that specified by the 'shell' option. * * @param {string|[string]} command The command to run. This can be a shell * command string or an array of strings (a command and arguments) * which will be escaped and concatenated. * @param {string} input Any input to be provided to the command on stdin. * @param {function(object) | boolean} async A callback to be called when * the command completes, or a boolean indicating that a * promise should be returned. @optional * @returns {object|null} */ system: function system(command, input = "", async = false) { if (loaded.overlay) util.dactyl.echomsg(_("io.callingShell", command), 4); let { shellEscape } = util.bound; return this.withTempFiles(function (stdin, stdout, cmd) { if (input instanceof File) stdin = input; else if (input) stdin.write(input); function result(status, output) { return new Proxy( { valueOf: function () { return this.output; }, output: output.replace(/^(.*)\n$/, "$1"), returnValue: status, toString: function () { return this.output; }, }, { get(target, prop) { if (prop in target) return target[prop]; return target.output[prop]; }, }); } let deferred; let promise = new Promise((resolve, reject) => { deferred = { resolve, reject }; }); if (callable(async)) promise.then(async); function handleResult(status) { stdout.async.read().then(output => { deferred.resolve(result(status, output)); }); } if (!storage["options"]) var { shell, shellcmdflag } = this; else { shell = storage["options"].get("shell").value; shellcmdflag = storage["options"].get("shellcmdflag").value; } shell = io.pathSearch(shell); util.assert(shell, _("error.invalid", "'shell'")); if (isArray(command)) command = command.map(shellEscape).join(" "); // TODO: implement 'shellredir' if (config.OS.isWindows && !/sh/.test(shell.leafName)) { command = "cd /D " + this.cwd.path + " && " + command + " > " + stdout.path + " 2>&1" + " < " + stdin.path; var res = this.run(shell, shellcmdflag.split(/\s+/).concat(command), async ? handleResult : true); } else { cmd.write("cd " + shellEscape(this.cwd.path) + "\n" + ["exec", ">" + shellEscape(stdout.path), "2>&1", "<" + shellEscape(stdin.path), shellEscape(shell.path), shellcmdflag, shellEscape(command)].join(" ")); res = this.run("/bin/sh", ["-e", cmd.path], async ? handleResult : true); } if (async) return promise; return result(res, stdout.read()); }, this, true); }, /** * Creates a temporary file context for executing external commands. * *func* is called with a temp file, created with {@link #createTempFile}, * for each explicit argument. Ensures that all files are removed when * *func* returns. * * @param {function} func The function to execute. * @param {Object} self The 'this' object used when executing func. * @returns {boolean} false if temp files couldn't be created, * otherwise, the return value of *func*. */ withTempFiles: function withTempFiles(func, self, checked, ext, label) { let args = Array.from(util.range(0, func.length), () => this.createTempFile(ext, label)); function cleanup() { // XXX: Sync. args.forEach(f => { f.remove(false); }); } try { if (!args.every(identity)) return false; var res = func.apply(self || this, args); } finally { if (res && typeof res === "object" && "then" in res && callable(res.then)) res.then(cleanup, cleanup); else if (!checked || res !== true) cleanup(); } return res; } }, { /** * @property {string} The value of the $PENTADACTYL_RUNTIME environment * variable. */ get runtimePath() { const rtpvar = config.idName + "_RUNTIME"; let rtp = services.environment.get(rtpvar); if (!rtp) { rtp = "~/" + (config.OS.isWindows ? "" : ".") + config.name; services.environment.set(rtpvar, rtp); } return rtp; }, /** * @property {string} The current platform's path separator. */ PATH_SEP: deprecated("File.PATH_SEP", { get: function PATH_SEP() { return File.PATH_SEP; } }) }, { commands: function initCommands(dactyl, modules, window) { const { commands, completion, io } = modules; commands.add(["cd", "chd[ir]"], "Change the current directory", function (args) { let arg = args[0]; if (!arg) arg = "~"; arg = File.expandPath(arg); // go directly to an absolute path or look for a relative path // match in 'cdpath' if (File.isAbsolutePath(arg)) { io.cwd = arg; dactyl.echomsg(io.cwd.path); } else { let dirs = modules.options.get("cdpath").files; for (let dir of dirs) { dir = dir.child(arg); if (dir.exists() && dir.isDirectory() && dir.isReadable()) { io.cwd = dir; dactyl.echomsg(io.cwd.path); return; } } dactyl.echoerr(_("io.noSuchDir", JSON.stringify(arg))); dactyl.echoerr(_("io.commandFailed")); } }, { argCount: "?", completer: function (context) { completion.directory(context, true); }, literal: 0 }); commands.add(["pw[d]"], "Print the current directory name", function () { dactyl.echomsg(io.cwd.path); }, { argCount: "0" }); commands.add([config.name.replace(/(.)(.*)/, "mk$1[$2rc]")], "Write current key mappings and changed options to the config file", function (args) { dactyl.assert(args.length <= 1, _("io.oneFileAllowed")); let file = io.File(args[0] || io.getRCFile(null, true)); dactyl.assert(!file.exists() || args.bang, _("io.exists", JSON.stringify(file.path))); // TODO: Use a set/specifiable list here: let lines = Array.from(commands.iterator()) .filter(cmd => cmd.serialize) .flatMap(cmd => cmd.serialize() .map(commands.commandToString, cmd)); lines.unshift('"' + config.version + "\n"); lines.push("\n\" vim: set ft=" + config.name + ":"); try { file.write(lines.join("\n").concat("\n")); dactyl.echomsg(_("io.writing", JSON.stringify(file.path)), 2); } catch (e) { dactyl.echoerr(_("io.notWriteable", JSON.stringify(file.path))); dactyl.log(_("error.notWriteable", file.path, e.message)); // XXX } }, { argCount: "*", // FIXME: should be "?" but kludged for proper error message bang: true, completer: function (context) { completion.file(context, true); } }); commands.add(["mkv[imruntime]"], "Create and install Vim runtime files for " + config.appName, function (args) { dactyl.assert(args.length <= 1, _("io.oneFileAllowed")); if (args.length) { var rtDir = io.File(args[0]); dactyl.assert(rtDir.exists(), _("io.noSuchDir", JSON.stringify(rtDir.path))); } else rtDir = io.File(config.OS.isWindows ? "~/vimfiles/" : "~/.vim/"); dactyl.assert(!rtDir.exists() || rtDir.isDirectory(), _("io.eNotDir", JSON.stringify(rtDir.path))); let rtItems = { ftdetect: {}, ftplugin: {}, syntax: {} }; // require bang if any of the paths exist for (let [type, item] of iter(rtItems)) { let file = io.File(rtDir).child(type, config.name + ".vim"); dactyl.assert(!file.exists() || args.bang, _("io.exists", JSON.stringify(file.path))); item.file = file; } rtItems.ftdetect.template = //{{{ String.raw`" Vim filetype detection file
      au BufNewFile,BufRead *rc*,*. set filetype= `;//}}} rtItems.ftplugin.template = //{{{ String.raw`" Vim filetype plugin file
      if exists("b:did_ftplugin") finish endif let b:did_ftplugin = 1 let s:cpo_save = &cpo set cpo&vim let b:undo_ftplugin = "setl com< cms< fo< ofu< | unlet! b:browsefilter" setlocal comments=:\" setlocal commentstring=\"%s setlocal formatoptions-=t formatoptions+=croql setlocal omnifunc=syntaxcomplete#Complete if has("gui_win32") && !exists("b:browsefilter") let b:browsefilter = " Config Files (*.)\t*.\n" . \ "All Files (*.*)\t*.*\n" endif let &cpo = s:cpo_save unlet s:cpo_save `; //}}} rtItems.syntax.template = //{{{ String.raw`" Vim syntax file
      if exists("b:current_syntax") finish endif let s:cpo_save = &cpo set cpo&vim syn include @javascriptTop syntax/javascript.vim unlet b:current_syntax syn include @cssTop syntax/css.vim unlet b:current_syntax syn match CommandStart "\%(^\s*:\=\)\@<=" nextgroup=Command,AutoCmd \ contained syn match Command "!" contained syn keyword AutoCmd au[tocmd] contained nextgroup=AutoEventList skipwhite \ contained syn match AutoEventList "\(\a\+,\)*\a\+" contained contains=AutoEvent syn region Set matchgroup=Command start="\%(^\s*:\=\)\@<=\<\%(setl\%[ocal]\|setg\%[lobal]\|set\=\)\=\>" \ end="$" keepend oneline contains=Option,String \ contained nextgroup=pentadactylSetMod execute 'syn match Option "\<\%(no\|inv\)\=\%(' . \ join(s:toggleOptions, '\|') . \ '\)\>!\=" contained nextgroup=SetMod' syn match SetMod "\%(\<[a-z_]\+\)\@<=&" contained syn region JavaScript start="\%(^\s*\%(javascript\|js\)\s\+\)\@<=" end="$" contains=@javascriptTop keepend oneline syn region JavaScript matchgroup=JavaScriptDelimiter \ start="\%(^\s*\%(javascript\|js\)\s\+\)\@<=<<\s*\z(\h\w*\)"hs=s+2 end="^\z1$" contains=@javascriptTop fold let s:cssRegionStart = '\%(^\s*sty\%[le]!\=\s\+\%(-\%(n\|name\)\%(\s\+\|=\)\S\+\s\+\)\=[^-]\S\+\s\+\)\@<=' execute 'syn region Css start="' . s:cssRegionStart . '" end="$" contains=@cssTop keepend oneline' execute 'syn region Css matchgroup=CssDelimiter' \ 'start="' . s:cssRegionStart . '<<\s*\z(\h\w*\)"hs=s+2 end="^\z1$" contains=@cssTop fold' syn match Notation "<[0-9A-Za-z-]\+>" syn keyword Todo FIXME NOTE TODO XXX contained syn region String start="\z(["']\)" end="\z1" skip="\\\\\|\\\z1" oneline syn match Comment +^\s*".*$+ contains=Todo,@Spell " NOTE: match vim.vim highlighting group names hi def link AutoCmd Command hi def link AutoEvent Type hi def link Command Statement hi def link JavaScriptDelimiter Delimiter hi def link CssDelimiter Delimiter hi def link Notation Special hi def link Comment Comment hi def link Option PreProc hi def link SetMod Option hi def link String String hi def link Todo Todo let b:current_syntax = "" let &cpo = s:cpo_save unlet s:cpo_save " vim: tw=130 et ts=8 sts=4 sw=4: `;//}}} " const { options } = modules; const WIDTH = 80; function wrap(prefix, items, sep) {//{{{ sep = sep || " "; let width = 0; let lines = []; lines.__defineGetter__("last", function () { return this[this.length - 1]; }); for (let item of values(items.array || items)) { if (item.length > width && (!lines.length || lines.last.length > 1)) { lines.push([prefix]); width = WIDTH - prefix.length; prefix = " \\ "; } width -= item.length + sep.length; lines.last.push(item, sep); } lines.last.pop(); return lines.map(l => l.join("")) .join("\n") .replace(/\s+\n/gm, "\n"); }//}}} let params = { //{{{ header: ['" Language: ' + config.appName + ' configuration file', '" Maintainer: Doug Kearns ', '" Version: ' + config.version].join("\n"), name: config.name, appname: config.appName, fileext: config.fileExtension, maintainer: "Doug Kearns ", autocommands: wrap("syn keyword " + config.name + "AutoEvent ", Object.keys(config.autocommands)), commands: wrap("syn keyword " + config.name + "Command ", Array.from(commands.iterator()).flatMap(cmd => cmd.specs)), options: wrap("syn keyword " + config.name + "Option ", Array.from(options).filter(opt => opt.type != "boolean") .flatMap(opt => opt.names)), toggleoptions: wrap("let s:toggleOptions = [", Array.from(options).filter(opt => opt.type == "boolean") .flatMap(opt => opt.realNames) .map(JSON.stringify), ", ") + "]" }; //}}} for (let { file, template } of values(rtItems)) { try { file.write(util.compileMacro(template, true)(params)); dactyl.echomsg(_("io.writing", JSON.stringify(file.path)), 2); } catch (e) { dactyl.echoerr(_("io.notWriteable", JSON.stringify(file.path))); dactyl.log(_("error.notWriteable", file.path, e.message)); } } }, { argCount: "?", bang: true, completer: function (context) { completion.directory(context, true); }, literal: 1 }); commands.add(["runt[ime]"], "Source the specified file from each directory in 'runtimepath'", function (args) { io.sourceFromRuntimePath(args, args.bang); }, { argCount: "+", bang: true, completer: function (context) { completion.runtime(context); } } ); commands.add(["scrip[tnames]"], "List all sourced script names", function () { let names = Array.from(io._scriptNames); if (!names.length) dactyl.echomsg(_("command.scriptnames.none")); else modules.commandline.commandOutput( template.tabular(["", "Filename"], ["text-align: right; padding-right: 1em;"], Array.from(names.entries(), ([i, file]) => [i + 1, file]))); }, { argCount: "0" }); commands.add(["so[urce]"], "Read Ex commands, JavaScript or CSS from a file", function (args) { if (args.length > 1) dactyl.echoerr(_("io.oneFileAllowed")); else io.source(args[0], { silent: args.bang }); }, { argCount: "+", // FIXME: should be "1" but kludged for proper error message bang: true, completer: function (context) { completion.file(context, true); } }); commands.add(["!", "run"], "Run a command", function (args) { let arg = args[0] || ""; // :!! needs to be treated specially as the command parser sets the // bang flag but removes the ! from arg if (args.bang) arg = "!" + arg; // This is an asinine and irritating "feature" when we have searchable // command-line history. --Kris if (modules.options["banghist"]) { // NOTE: Vim doesn't replace ! preceded by 2 or more backslashes and documents it - desirable? // pass through a raw bang when escaped or substitute the last command // replaceable bang and no previous command? dactyl.assert(!/((^|[^\\])(\\\\)*)!/.test(arg) || io._lastRunCommand, _("command.run.noPrevious")); arg = arg.replace(/(\\)*!/g, m => (/^\\(\\\\)*!$/.test(m) ? m.replace("\\!", "!") : m.replace("!", io._lastRunCommand))); } io._lastRunCommand = arg; let result = io.system(arg); if (result.returnValue != 0) result.output += "\n" + _("io.shellReturn", result.returnValue); modules.commandline.command = args.commandName.replace("run", "$& ") + arg; modules.commandline.commandOutput(["span", { highlight: "CmdOutput" }, result.output]); modules.autocommands.trigger("ShellCmdPost", {}); }, { argCount: "?", bang: true, // This is abominably slow. //completer: function (context) { // completion.shellCommand(context); //}, literal: 0 }); }, completion: function initCompletion(dactyl, modules, window) { const { completion, io } = modules; completion.charset = context => { context.anchored = false; context.keys = { text: identity, description: charset => io.charsetTitle(charset) }; context.completions = io.charsets; }; completion.directory = function directory(context, full) { this.file(context, full); context.filters.push(item => item.isdir); }; completion.environment = function environment(context) { context.title = ["Environment Variable", "Value"]; context.generate = () => io.system(config.OS.isWindows ? "set" : "env") .output.split("\n") .filter(line => line.indexOf("=") > 0) .map(line => line.match(/([^=]+)=(.*)/).slice(1)); }; completion.file = function file(context, full, dir) { if (/^jar:[^!]*$/.test(context.filter)) context.advance(4); // dir == "" is expanded inside readDirectory to the current dir function getDir(str) { return str.match(/^(?:.*[\/\\])?/)[0]; } dir = getDir(dir || context.filter); let file = util.getFile(dir); if (file && (!file.exists() || !file.isDirectory())) file = file.parent; if (!full) context.advance(dir.length); context.title = [full ? "Path" : "Filename", "Type"]; context.keys = { text: !full ? "leafName" : function (f) { return this.path }, path(f) { return dir + f.leafName; }, description(f) { return this.isdir ? "Directory" : "File"; }, isdir(f) { return f.isDirectory(); }, icon(f) { if (this.isdir) return "resource://gre/res/html/folder.png"; return "moz-icon://" + f.leafName; }, }; context.compare = (a, b) => b.isdir - a.isdir || String.localeCompare(a.text, b.text); if (modules.options["wildignore"]) context.filters.push(item => !modules.options.get("wildignore").getKey(item.path)); // context.background = true; context.key = dir; let uri = io.isJarURL(dir); if (uri) context.generate = function generate_jar() { return Array.from(io.listJar(uri.JARFile, getDir(uri.JAREntry)), path => ({ isDirectory: () => path.substr(-1) == "/", leafName: /([^\/]*)\/?$/.exec(s)[1] })); }; else context.generate = function generate_file() { try { return io.File(file || dir).readDirectory(); } catch (e) { return []; } }; }; completion.runtime = function (context) { for (let dir of modules.options["runtimepath"]) context.fork(dir, 0, this, function (context) { dir = dir.replace("/+$", "") + "/"; completion.file(context, true, dir + context.filter); context.title[0] = dir; context.keys.text = function (f) { return this.path.substr(dir.length); }; }); }; completion.shellCommand = function shellCommand(context) { context.title = ["Shell Command", "Path"]; context.generate = () => { let dirNames = services.environment.get("PATH").split(config.OS.pathListSep); return dirNames.flatMap(dirName => { let dir = io.File(dirName); if (dir.exists() && dir.isDirectory()) return Array.from(dir.directoryEntries) .filter(file => file.isFile() && file.isExecutable()) .map(file => [file.leafName, dir.path]) }); }; }; completion.addUrlCompleter("file", "Local files", function (context, full) { let match = util.regexp(String.raw` ^ (?P (?P (?P chrome|resource) :\/\/ ) [^\/]* ) (?P \/[^\/]* )? $ `, "x").exec(context.filter); if (match) { if (!match.path) { context.key = match.proto; context.advance(match.proto.length); context.generate = () => config.chromePackages.map(p => [p, match.proto + p + "/"]); } else if (match.scheme === "chrome") { context.key = match.prefix; context.advance(match.prefix.length + 1); context.generate = () => iter({ content: /*L*/"Chrome content", locale: /*L*/"Locale-specific content", skin: /*L*/"Theme-specific content" }); } } if (!match || match.scheme === "resource" && match.path) if (/^(\.{0,2}|~)\/|^file:/.test(context.filter) || config.OS.isWindows && /^[a-z]:/i.test(context.filter) || util.getFile(context.filter) || io.isJarURL(context.filter)) completion.file(context, full); }); }, javascript: function initJavascript(dactyl, modules, window) { modules.JavaScript.setCompleter([File, File.expandPath], [function (context, obj, args) { context.quote[2] = ""; modules.completion.file(context, true); }]); }, modes: function initModes(dactyl, modules, window) { initModes.require("commandline"); const { modes } = modules; modes.addMode("FILE_INPUT", { extended: true, description: "Active when selecting a file", bases: [modes.COMMAND_LINE], input: true }); }, options: function initOptions(dactyl, modules, window) { const { completion, options } = modules; let { shell, shellcmdflag } = io; options.add(["banghist", "bh"], "Replace occurrences of ! with the previous command when executing external commands", "boolean", false); options.add(["fileencoding", "fenc"], "The character encoding used when reading and writing files", "string", "UTF-8", { completer: function (context) { completion.charset(context); }, getter: function () { return File.defaultEncoding; }, setter: function (value) { return File.defaultEncoding = value; } }); options.add(["cdpath", "cd"], "List of directories searched when executing :cd", "stringlist", ["."].concat(services.environment.get("CDPATH").split(/[:;]/).filter(identity)).join(","), { get files() { return this.value.map(path => File(path, modules.io.cwd)) .filter(dir => dir.exists()); }, setter: function (value) { return File.expandPathList(value); } }); options.add(["runtimepath", "rtp"], "List of directories searched for runtime files", "stringlist", IO.runtimePath, { get files() { return this.value.map(path => File(path, modules.io.cwd)) .filter(dir => dir.exists()); } }); options.add(["shell", "sh"], "Shell to use for executing external commands with :! and :run", "string", shell, { validator: function (val) { return io.pathSearch(val); } }); options.add(["shellcmdflag", "shcf"], "Flag passed to shell when executing external commands with :! and :run", "string", shellcmdflag, { getter: function (value) { if (this.hasChanged || !config.OS.isWindows) return value; return /sh/.test(options["shell"]) ? "-c" : "/c"; } }); options["shell"]; // Make sure it's loaded into global storage. options["shellcmdflag"]; options.add(["wildignore", "wig"], "List of path name patterns to ignore when completing files and directories", "regexplist", ""); } }); endModule(); } catch(e){ if (isString(e)) e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); } // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/javascript.jsm000066400000000000000000001027731264147376100217010ustar00rootroot00000000000000// Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; try { defineModule("javascript", { exports: ["JavaScript", "javascript"], require: ["util"] }); lazyRequire("template", ["template"]); let isPrototypeOf = Object.prototype.isPrototypeOf; // TODO: Clean this up. var JavaScript = Module("javascript", { init: function () { this._stack = []; this._functions = []; this._top = {}; // The element on the top of the stack. this._last = ""; // The last opening char pushed onto the stack. this._lastNonwhite = ""; // Last non-whitespace character we saw. this._lastChar = ""; // Last character we saw, used for \ escaping quotes. this._str = ""; this._lastIdx = 0; this._cacheKey = null; this._nullSandbox = Cu.Sandbox("about:blank"); }, Local: function (dactyl, modules, window) { return { init: function init() { this.modules = modules; this.window = window; init.supercall(this); } }; }, globals: Class.Memoize(function () { return [ [this.modules.userContext, /*L*/"Global Variables"], [this.modules, "modules"], [this.window, "window"] ]; }), toplevel: Class.Memoize(function () { return this.modules.jsmodules; }), lazyInit: true, newContext: function () { return this.modules.newContext(this.modules.userContext, false, "Dactyl JS Temp Context"); }, completers: Class.Memoize(() => Object.create(JavaScript.completers)), // Some object members are only accessible as function calls getKey: function (obj, key) { try { return obj[key]; } catch (e) {} return undefined; }, iter: function* iter_(obj, toplevel) { if (obj == null) return; let seen = new RealSet(isinstance(obj, ["Sandbox"]) ? JavaScript.magicalNames : []); let globals = values(toplevel && this.window === obj ? this.globalNames : []); if (toplevel && isObject(obj) && "wrappedJSObject" in obj) if (!seen.add("wrappedJSObject")) yield "wrappedJSObject"; for (let key of iter(globals, properties(obj, !toplevel))) if (!seen.add(key)) yield key; // Properties aren't visible in an XPCNativeWrapper until // they're accessed. for (let key of properties(this.getKey(obj, "wrappedJSObject"), !toplevel)) try { if (key in obj && !seen.has(key)) yield key; } catch (e) {} }, objectKeys: function objectKeys(obj, toplevel) { // Things we can dereference if (!obj || ["object", "string", "function"].indexOf(typeof obj) === -1) return []; if (isinstance(obj, ["Sandbox"]) && !toplevel) // Temporary hack. return []; if (isPrototypeOf.call(this.toplevel, obj) && !toplevel) return []; let completions = Array.from(this.iter(obj, toplevel)); if (obj === this.modules) // Hack. completions = [...new RealSet([...completions, ...this.iter(this.modules.jsmodules, toplevel)])]; return completions; }, evalled: function evalled(arg, key, tmp) { let cache = this.context.cache.evalled; let context = this.context.cache.evalContext; if (!key) key = arg; if (key in cache) return cache[key]; context[JavaScript.EVAL_TMP] = tmp; try { cache[key] = this.modules.dactyl.userEval(arg, context, /*L*/"[Command Line Completion]", 1); return cache[key]; } catch (e) { util.reportError(e); this.context.message = _("error.error", e); return null; } finally { delete context[JavaScript.EVAL_TMP]; } }, // Get an element from the stack. If @frame is negative, // count from the top of the stack, otherwise, the bottom. // If @nth is provided, return the @mth value of element @type // of the stack entry at @frame. _get: function (frame, nth, type) { let a = this._stack[frame >= 0 ? frame : this._stack.length + frame]; if (type != null) a = a[type]; if (nth == null) return a; return a[a.length - nth - 1]; }, // Push and pop the stack, maintaining references to 'top' and 'last'. _push: function push(arg) { this._top = { offset: this._i, char: arg, statements: [this._i], dots: [], fullStatements: [], comma: [], functions: [] }; this._last = this._top.char; this._stack.push(this._top); }, _pop: function pop(arg) { if (this._i == this.context.caret - 1) this.context.highlight(this._top.offset, 1, "FIND"); if (this._top.char != arg) { this.context.highlight(this._top.offset, this._i - this._top.offset, "SPELLCHECK"); throw Error(/*L*/"Invalid JS"); } // The closing character of this stack frame will have pushed a new // statement, leaving us with an empty statement. This doesn't matter, // now, as we simply throw away the frame when we pop it, but it may later. if (this._top.statements[this._top.statements.length - 1] == this._i) this._top.statements.pop(); this._top = this._get(-2); this._last = this._top.char; return this._stack.pop(); }, _buildStack: function (filter) { // Todo: Fix these one-letter variable names. this._i = 0; this._c = ""; // Current index and character, respectively. // Reuse the old stack. if (this._str && filter.substr(0, this._str.length) == this._str) { this.context.highlight(0, 0, "FIND"); this._i = this._str.length; if (this.popStatement) this._top.statements.pop(); } else { this.context.highlight(); this._stack = []; this._functions = []; this._push("#root"); } // Build a parse stack, discarding entries as opening characters // match closing characters. The stack is walked from the top entry // and down as many levels as it takes us to figure out what it is // that we're completing. this._str = filter; let length = this._str.length; for (; this._i < length; this._lastChar = this._c, this._i++) { this._c = this._str[this._i]; if (/['"\/]/.test(this._last)) { if (this._lastChar == "\\") { // Escape. Skip the next char, whatever it may be. this._c = ""; this._i++; } else if (this._c == this._last) this._pop(this._c); } else { // A word character following a non-word character, or simply a non-word // character. Start a new statement. if (/[a-zA-Z_$]/.test(this._c) && !/[\w$]/.test(this._lastChar) || !/[\w\s$]/.test(this._c)) this._top.statements.push(this._i); // A "." or a "[" dereferences the last "statement" and effectively // joins it to this logical statement. if ((this._c == "." || this._c == "[") && /[\w$\])"']/.test(this._lastNonwhite) || this._lastNonwhite == "." && /[a-zA-Z_$]/.test(this._c)) this._top.statements.pop(); switch (this._c) { case "(": // Function call, or if/while/for/... if (/[\w$]/.test(this._lastNonwhite)) { this._functions.push(this._i); this._top.functions.push(this._i); this._top.statements.pop(); } case '"': case "'": case "/": case "{": case "[": this._push(this._c); break; case ".": this._top.dots.push(this._i); break; case ")": this._pop("("); break; case "]": this._pop("["); break; case "}": this._pop("{"); // Fallthrough case ";": this._top.fullStatements.push(this._i); break; case ",": this._top.comma.push(this._i); break; } if (/\S/.test(this._c)) this._lastNonwhite = this._c; } } this.popStatement = false; if (!/[\w$]/.test(this._lastChar) && this._lastNonwhite != ".") { this.popStatement = true; this._top.statements.push(this._i); } this._lastIdx = this._i; }, // Don't eval any function calls unless the user presses tab. _checkFunction: function (start, end, key) { let res = this._functions.some(idx => (idx >= start && idx < end)); if (!res || this.context.tabPressed || key in this.cache.evalled) return false; this.context.waitingForTab = true; return true; }, // For each DOT in a statement, prefix it with TMP, eval it, // and save the result back to TMP. The point of this is to // cache the entire path through an object chain, mainly in // the presence of function calls. There are drawbacks. For // instance, if the value of a variable changes in the course // of inputting a command (let foo=bar; frob(foo); foo=foo.bar; ...), // we'll still use the old value. But, it's worth it. _getObj: function (frame, stop) { let statement = this._get(frame, 0, "statements") || 0; // Current statement. let prev = statement; let obj = this.window; let cacheKey; for (let dot of this._get(frame).dots.concat(stop)) { if (dot < statement) continue; if (dot > stop || dot <= prev) break; let s = this._str.substring(prev, dot); if (prev != statement) s = JavaScript.EVAL_TMP + "." + s; cacheKey = this._str.substring(statement, dot); if (this._checkFunction(prev, dot, cacheKey)) return []; if (prev != statement && obj == null) { this.context.message = /*L*/"Error: " + JSON.stringify(cacheKey) + " is " + String(obj); return []; } prev = dot + 1; obj = this.evalled(s, cacheKey, obj); } return [[obj, cacheKey]]; }, _getObjKey: function (frame) { let dot = this._get(frame, 0, "dots") || -1; // Last dot in frame. let statement = this._get(frame, 0, "statements") || 0; // Current statement. let end = (frame == -1 ? this._lastIdx : this._get(frame + 1).offset); this._cacheKey = null; let obj = [[this.cache.evalContext, /*L*/"Local Variables"]].concat(this.globals); // Is this an object dereference? if (dot < statement) // No. dot = statement - 1; else // Yes. Set the object to the string before the dot. obj = this._getObj(frame, dot); let [, space, key] = this._str.substring(dot + 1, end).match(/^(\s*)(.*)/); return [dot + 1 + space.length, obj, key]; }, _complete: function (objects, key, compl, string, last) { const self = this; let base = this.context.fork("js", this._top.offset); base.forceAnchored = true; base.filter = last == null ? key : string; let prefix = last != null ? key : ""; if (last == null) // We're not looking for a quoted string, so filter out anything that's not a valid identifier base.filters.push(item => /^[a-zA-Z_$][\w$]*$/.test(item.text)); else { base.quote = [last, text => util.escapeString(text, ""), last]; if (prefix) base.filters.push(item => item.item.startsWith(prefix)); } if (!compl) { base.process[1] = function highlight(item, v) { return template.highlight(typeof v == "xml" ? new String(v.toXMLString()) : v, true, 200); }; // Sort in a logical fashion for object keys: // Numbers are sorted as numbers, rather than strings, and appear first. // Constants are unsorted, and appear before other non-null strings. // Other strings are sorted in the default manner. let isnan = function isnan(item) { return item != '' && isNaN(item); }; let compare = base.compare; base.compare = function (a, b) { if (!isnan(a.key) && !isnan(b.key)) return a.key - b.key; return isnan(b.key) - isnan(a.key) || compare(a, b); }; base.keys = { text: prefix ? text => text.substr(prefix.length) : text => text, description: function (item) { return self.getKey(this.obj, item); }, key: function (item) { if (!isNaN(key)) return parseInt(key); if (/^[A-Z_][A-Z0-9_]*$/.test(key)) return ""; return item; } }; } // We've already listed anchored matches, so don't list them again here. function unanchored(item) { return util.compareIgnoreCase(item.text.substr(0, this.filter.length), this.filter); } objects.forEach(function (obj) { let context = base.fork(obj[1]); context.title = [obj[1]]; context.keys.obj = () => obj[0]; context.key = obj[1] + last; if (obj[0] == this.cache.evalContext) context.regenerate = true; obj.ctxt_t = context.fork("toplevel"); if (!compl) { obj.ctxt_p = context.fork("prototypes"); obj.ctxt_t.generate = () => self.objectKeys(obj[0], true); obj.ctxt_p.generate = () => self.objectKeys(obj[0], false); } }, this); // TODO: Make this a generic completion helper function. objects.forEach(function (obj) { obj.ctxt_t.split(obj[1] + "/anchored", this, context => { context.anchored = true; if (compl) compl(context, obj[0]); }); }); if (compl) return; objects.forEach(function (obj) { obj.ctxt_p.split(obj[1] + "/anchored", this, context => { context.anchored = true; context.title[0] += /*L*/" (prototypes)"; }); }); objects.forEach(function (obj) { obj.ctxt_t.split(obj[1] + "/unanchored", this, context => { context.anchored = false; context.title[0] += /*L*/" (substrings)"; context.filters.push(unanchored); }); }); objects.forEach(function (obj) { obj.ctxt_p.split(obj[1] + "/unanchored", this, context => { context.anchored = false; context.title[0] += /*L*/" (prototype substrings)"; context.filters.push(unanchored); }); }); }, _getKey: function () { if (this._last == "") return ""; // After the opening [ upto the opening ", plus '' to take care of any operators before it let key = this._str.substring(this._get(-2, null, "offset") + 1, this._get(-1, null, "offset")) + "''"; // Now eval the key, to process any referenced variables. return this.evalled(key); }, get cache() { return this.context.cache; }, complete: function _complete(context) { const self = this; this.context = context; try { this._buildStack.call(this, context.filter); } catch (e) { this._lastIdx = 0; util.assert(!e.message, e.message); return null; } this.context.getCache("evalled", Object); this.context.getCache("evalContext", this.bound.newContext); // Okay, have parse stack. Figure out what we're completing. // Find any complete statements that we can eval before we eval our object. // This allows for things like: // let doc = content.document; let elem = doc.createEle ... let prev = 0; for (let v of this._get(0).fullStatements) { let key = this._str.substring(prev, v + 1); if (this._checkFunction(prev, v, key)) return null; this.evalled(key); prev = v + 1; } // If this is a function argument, try to get the function's // prototype and show it. try { let i = (this._get(-2) && this._get(-2).char == "(") ? -2 : -1; if (this._get(i).char == "(") { let [offset, obj, funcName] = this._getObjKey(i - 1); if (obj.length) { let func = obj[0][0][funcName]; if (callable(func)) { let [, prefix, args] = /^(function .*?)\((.*?)\)/.exec(Function.prototype.toString.call(func)); let n = this._get(i).comma.length; args = template.map(args.split(", ").entries(), ([i, arg]) => ["span", { highlight: i == n ? "Filter" : "" }, arg], ",\u00a0"); this.context.message = ["", prefix + "(", args, ")"]; } } } } catch (e) {} // In a string. Check if we're dereferencing an object or // completing a function argument. Otherwise, do nothing. if (this._last == "'" || this._last == '"') { // str = "foo[bar + 'baz" // obj = "foo" // key = "bar + ''" // The top of the stack is the sting we're completing. // Wrap it in its delimiters and eval it to process escape sequences. let string = this._str.substring(this._get(-1).offset + 1, this._lastIdx).replace(/((?:\\\\)*)\\/, "$1"); string = Cu.evalInSandbox(this._last + string + this._last, this._nullSandbox); // Is this an object accessor? if (this._get(-2).char == "[") { // Are we inside of []? // Stack: // [-1]: "... // [-2]: [... // [-3]: base statement // Yes. If the [ starts at the beginning of a logical // statement, we're in an array literal, and we're done. if (this._get(-3, 0, "statements") == this._get(-2).offset) return null; // Beginning of the statement upto the opening [ let obj = this._getObj(-3, this._get(-2).offset); return this._complete(obj, this._getKey(), null, string, this._last); } // Is this a function call? if (this._get(-2).char == "(") { // Stack: // [-1]: "... // [-2]: (... // [-3]: base statement // Does the opening "(" mark a function call? if (this._get(-3, 0, "functions") != this._get(-2).offset) return null; // No. We're done. let [offset, obj, funcName] = this._getObjKey(-3); if (!obj.length) return null; obj = obj.slice(0, 1); try { let func = obj[0][0][funcName]; var completer = func.dactylCompleter; } catch (e) {} if (!completer) completer = this.completers[funcName]; if (!completer) return null; // Split up the arguments let prev = this._get(-2).offset; let args = []; for (let [i, idx] of iter(this._get(-2).comma)) { let arg = this._str.substring(prev + 1, idx); prev = idx; memoize(args, i, () => self.evalled(arg)); } let key = this._getKey(); args.push(key + string); let compl = function (context, obj) { let res = completer.call(self, context, funcName, obj, args); if (res) context.completions = res; }; obj[0][1] += "." + funcName + "(... [" + args.length + "]"; return this._complete(obj, key, compl, string, this._last); } // In a string that's not an obj key or a function arg. // Nothing to do. return null; } // str = "foo.bar.baz" // obj = "foo.bar" // key = "baz" // // str = "foo" // obj = [modules, window] // key = "foo" let [offset, obj, key] = this._getObjKey(-1); // Wait for a keypress before completing when there's no key if (!this.context.tabPressed && key == "" && obj.length > 1) { let message = this.context.message || ""; this.context.waitingForTab = true; this.context.message = ["", message, "\n", _("completion.waitingForKeyPress")]; return null; } if (!/^(?:[a-zA-Z_$][\w$]*)?$/.test(key)) return null; // Not a word. Forget it. Can this even happen? try { // FIXME var o = this._top.offset; this._top.offset = offset; return this._complete(obj, key); } finally { this._top.offset = o; } return null; }, magicalNames: Class.Memoize(function () { return Object.getOwnPropertyNames(Cu.Sandbox(this.window), true) .sort(); }), /** * A list of properties of the global object which are not * enumerable by any standard method. */ globalNames: Class.Memoize(function () { let interfaces = Object.keys(Ci); let names = new RealSet([ "Array", "ArrayBuffer", "AttributeName", "Audio", "Boolean", "Components", "CSSFontFaceStyleDecl", "CSSGroupRuleRuleList", "CSSNameSpaceRule", "CSSRGBColor", "CSSRect", "ComputedCSSStyleDeclaration", "Date", "Error", "EvalError", "File", "Float32Array", "Float64Array", "Function", "HTMLDelElement", "HTMLInsElement", "HTMLSpanElement", "Infinity", "InnerModalContentWindow", "InnerWindow", "Int16Array", "Int32Array", "Int8Array", "InternalError", "Iterator", "JSON", "KeyboardEvent", "Math", "NaN", "Namespace", "Number", "Object", "Proxy", "QName", "ROCSSPrimitiveValue", "RangeError", "ReferenceError", "RegExp", "StopIteration", "String", "SyntaxError", "TypeError", "URIError", "Uint16Array", "Uint32Array", "Uint8Array", "XML", "XMLHttpProgressEvent", "XMLList", "XMLSerializer", "XPCNativeWrapper", "XULControllers", "constructor", "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent", "escape", "eval", "isFinite", "isNaN", "isXMLName", "parseFloat", "parseInt", "undefined", "unescape", "uneval", ...interfaces.filter(key => /^nsIDOM/.test(key)).map(key => key.substr(6)), ...interfaces.filter(key => /^nsI/.test(key)).map(key => key.substr(3)), ...this.magicalNames, ]); return [...names].filter(key => key in this.window); }) }, { EVAL_TMP: "__dactyl_eval_tmp", /** * A map of argument completion functions for named methods. The * signature and specification of the completion function * are fairly complex and yet undocumented. * * @see JavaScript.setCompleter */ completers: {}, /** * Installs argument string completers for a set of functions. * The second argument is an array of functions (or null * values), each corresponding the argument of the same index. * Each provided completion function receives as arguments a * CompletionContext, the 'this' object of the method, and an * array of values for the preceding arguments. * * It is important to note that values in the arguments array * provided to the completers are lazily evaluated the first * time they are accessed, so they should be accessed * judiciously. * * @param {function|[function]} funcs The functions for which to * install the completers. * @param {[function]} completers An array of completer * functions. */ setCompleter: function (funcs, completers) { funcs = Array.concat(funcs); for (let func of funcs) { func.dactylCompleter = function (context, func, obj, args) { let completer = completers[args.length - 1]; if (!completer) return []; return completer.call(obj, context, obj, args); }; func.dactylCompleter.completers = completers; } return arguments[0]; } }, { init: function init(dactyl, modules, window) { init.superapply(this, arguments); modules.JavaScript = Class("JavaScript", JavaScript, { modules: modules, window: window }); }, completion: function (dactyl, modules, window) { update(modules.completion, { get javascript() { return modules.javascript.bound.complete; }, javascriptCompleter: JavaScript // Backwards compatibility }); }, modes: function initModes(dactyl, modules, window) { initModes.require("commandline"); const { modes } = modules; modes.addMode("REPL", { description: "JavaScript Read Eval Print Loop", bases: [modes.COMMAND_LINE], displayName: Class.Memoize(function () { return this.name; }) }); }, commandline: function initCommandLine(dactyl, modules, window) { const { Buffer, modes } = modules; var REPL = Class("REPL", { init: function init(context) { this.context = context; this.results = []; return new Proxy(this, { get(target, prop) { if (prop in target) return target[prop]; if (prop in Buffer) return Buffer[prop].bind(Buffer, target.rootNode); }, }); }, addOutput: function addOutput(js) { this.count++; try { var result = dactyl.userEval(js, this.context); var xml = result === undefined ? "" : util.objectToString(result, true); } catch (e) { util.reportError(e); result = e; if (e.fileName) e = util.fixURI(e.fileName) + ":" + e.lineNumber + ": " + e; xml = ["span", { highlight: "ErrorMsg" }, e]; } let prompt = "js" + this.count; Class.replaceProperty(this.context, prompt, result); let nodes = {}; this.rootNode.appendChild( DOM.fromJSON( [["div", { highlight: "REPL-E", key: "e" }, ["span", { highlight: "REPL-R" }, prompt, ">"], " ", js], ["div", { highlight: "REPL-P", key: "p" }, xml]], this.document, nodes)); this.rootNode.scrollTop += nodes.e.getBoundingClientRect().top - this.rootNode.getBoundingClientRect().top; }, count: 0, message: Class.Memoize(function () { DOM.fromJSON(["div", { highlight: "REPL", key: "rootNode" }], this.document, this); return this.rootNode; }), }); modules.CommandREPLMode = Class("CommandREPLMode", modules.CommandMode, { init: function init(context) { init.supercall(this); let sandbox = true || isinstance(context, ["Sandbox"]); this.context = modules.newContext(context, !sandbox, "Dactyl REPL Context"); this.js = modules.JavaScript(); this.js.replContext = this.context; this.js.newContext = () => modules.newContext(this.context, !sandbox, "Dactyl REPL Temp Context"); this.js.globals = [ [this.context, /*L*/"REPL Variables"], [context, /*L*/"REPL Global"] ].concat(this.js.globals.filter(([global]) => isPrototypeOf.call(global, context))); if (!isPrototypeOf.call(modules.jsmodules, context)) this.js.toplevel = context; if (!isPrototypeOf.call(window, context)) this.js.window = context; if (this.js.globals.slice(2).some(([global]) => global === context)) this.js.globals.splice(1); this.repl = REPL(this.context); }, open: function open(context) { modules.mow.echo(this.repl); this.widgets.message = null; open.superapply(this, arguments); this.updatePrompt(); }, complete: function complete(context) { context.fork("js", 0, this.js, "complete"); }, historyKey: "javascript", mode: modes.REPL, get completionList() { return this.widgets.statusbar.commandline.id; }, accept: function accept() { dactyl.trapErrors(function () { this.repl.addOutput(this.command); }, this); this.completions.cleanup(); this.history.save(); this.history.reset(); this.updatePrompt(); modules.mow.resize(); }, leave: function leave(params) { leave.superapply(this, arguments); if (!params.push) { modes.delay(function () { modes.pop(); }); Cu.nukeSandbox(this.context); } }, updatePrompt: function updatePrompt() { this.command = ""; this.prompt = ["REPL-R", "js" + (this.repl.count + 1) + "> "]; } }); }, commands: function initCommands(dactyl, modules, window) { const { commands } = modules; commands.add(["javas[cript]", "js"], "Evaluate a JavaScript string", function (args) { if (args[0] && !args.bang) dactyl.userEval(args[0]); else { modules.commandline; modules.CommandREPLMode(args[0] ? dactyl.userEval(args[0]) : modules.userContext) .open(); } }, { argCount: "?", bang: true, completer: function (context) { modules.completion.javascript(context); }, hereDoc: true, literal: 0 }); }, mappings: function initMappings(dactyl, modules, window) { const { mappings, modes } = modules; function bind(...args) { return apply(mappings, "add", [[modes.REPL]].concat(args)); } bind([""], "Accept the current input", function ({ self }) { self.accept(); }); bind([""], "Scroll down one line", function ({ self }) { self.repl.scrollVertical("lines", 1); }); bind([""], "Scroll up one line", function ({ self }) { self.repl.scrollVertical("lines", -1); }); bind([""], "Scroll down half a page", function ({ self }) { self.repl.scrollVertical("pages", .5); }); bind(["", ""], "Scroll down one page", function ({ self }) { self.repl.scrollVertical("pages", 1); }); bind([""], "Scroll up half a page", function ({ self }) { self.repl.scrollVertical("pages", -.5); }); bind(["", ""], "Scroll up half a page", function ({ self }) { self.repl.scrollVertical("pages", -1); }); } }); endModule(); } catch(e){ if (!e.stack) e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); } // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/main.jsm000066400000000000000000000332321264147376100204500ustar00rootroot00000000000000// Copyright (c) 2009-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; try { defineModule("main", { exports: ["ModuleBase"], require: ["config", "overlay", "services", "util"] }); var BASE = "resource://dactyl-content/"; var global = this; /** * @class ModuleBase * The base class for all modules. */ var ModuleBase = Class("ModuleBase", { /** * @property {[string]} A list of module prerequisites which * must be initialized before this module is loaded. */ requires: [], toString: function () { return "[module " + this.constructor.className + "]"; } }); var _id = 0; var Modules = function Modules(window) { /** * @constructor Module * * Constructs a new ModuleBase class and makes arrangements for its * initialization. Arguments marked as optional must be either * entirely elided, or they must have the exact type specified. * Loading semantics are as follows: * * - A module is guaranteed not to be initialized before any of its * prerequisites as listed in its {@see ModuleBase#requires} member. * - A module is considered initialized once it's been instantiated, * its {@see Class#init} method has been called, and its * instance has been installed into the top-level {@see modules} * object. * - Once the module has been initialized, its module-dependent * initialization functions will be called as described hereafter. * @param {string} name The module's name as it will appear in the * top-level {@see modules} object. * @param {ModuleBase} base The base class for this module. * @optional * @param {Object} prototype The prototype for instances of this * object. The object itself is copied and not used as a prototype * directly. * @param {Object} classProperties The class properties for the new * module constructor. * @optional * @param {Object} moduleInit The module initialization functions * for the new module. Each function is called as soon as the * named module has been initialized. The constructors are * guaranteed to be called in the same order that the dependent * modules were initialized. * @optional * * @returns {function} The constructor for the resulting module. */ function Module(name, ...args) { var base = ModuleBase; if (callable(args[0])) base = args.shift(); let [prototype, classProperties, moduleInit] = args; prototype._metaInit_ = function () { delete module.prototype._metaInit_; Class.replaceProperty(modules, module.className, this); }; const module = Class(name, base, prototype, classProperties); module.INIT = moduleInit || {}; module.modules = modules; module.prototype.INIT = module.INIT; module.requires = prototype.requires || []; Module.list.push(module); Module.constructors[name] = module; return module; } Module.list = []; Module.constructors = {}; function newContext(proto, normal, name) { if (normal) return create(proto); let sandbox = Components.utils.Sandbox(Cu.getObjectPrincipal(global), { sandboxPrototype: proto || modules, sandboxName: name || ("Dactyl Sandbox " + ++_id), addonId: config.addon.id, wantXrays: true, metadata: { addonID: config.addon.id } }); loadPolyfill(sandbox); // Hack: // sandbox.Object = jsmodules.Object; sandbox.File = global.File; sandbox.Math = global.Math; sandbox.Set = global.Set; return sandbox; }; const BASES = [BASE, "resource://dactyl-local-content/"]; let proxyCache = {}; var proxy = new Proxy(window, { get: function window_get(target, prop) { // `in`, not `hasOwnProperty`, because we want to return // unbound methods in `Object.prototype` if (prop in proxyCache) return proxyCache[prop]; let p = target[prop]; if (callable(p)) return proxyCache[prop] = p.bind(target); return p; }, set: function window_set(target, prop, val, receiver) { if (receiver !== target) Object.defineProperty(receiver, prop, { value: val, enumerable: true, configurable: true, writable: true }); else target[prop] = val; return true; } }); var jsmodules = newContext(proxy, false, "Dactyl `jsmodules`"); jsmodules.NAME = "jsmodules"; const create = bind("create", jsmodules.Object); const modules = update(create(jsmodules), { Symbol: Symbol, yes_i_know_i_should_not_report_errors_in_these_branches_thanks: [], jsmodules: jsmodules, Module: Module, load: function load(script) { for (let base of BASES) { try { JSMLoader.loadSubScript(base + script + ".js", modules, "UTF-8"); return; } catch (e) { if (typeof e !== "string") { util.dump("Trying: " + (base + script + ".js") + ":"); util.reportError(e); } } } try { require(script, jsmodules); } catch (e) { util.dump("Loading script " + script + ":"); util.reportError(e); } }, newContext: newContext, get ownPropertyValues() { return Ary.compact( Object.getOwnPropertyNames(this) .map(name => Object.getOwnPropertyDescriptor(this, name).value)); }, get moduleList() { return this.ownPropertyValues.filter(mod => (mod instanceof this.ModuleBase || mod.isLocalModule)); } }); modules.plugins = create(modules); modules.modules = modules; return modules; }; config.loadStyles(); overlay.overlayWindow(Object.keys(config.overlays), function _overlay(window) { return { ready: function onInit(document) { const modules = Modules(window); modules.moduleManager = this; this.modules = modules; this.jsmodules = modules.jsmodules; window.dactyl = { modules: modules }; defineModule.time("load", null, function _load() { config.modules.global .forEach(function (name) { if (!isArray(name)) defineModule.time("load", name, require, null, name, modules.jsmodules); else lazyRequire(name[0], name.slice(1), modules.jsmodules); }); config.modules.window .forEach(name => { defineModule.time("load", name, modules.load, modules, name); }); }, this); }, load: function onLoad(document) { let self = this; var { modules } = this.modules; delete window.dactyl; this.startTime = Date.now(); this.deferredInit = { load: {} }; this.seen = new RealSet; this.loaded = new RealSet; modules.loaded = this.loaded; this.modules = modules; this.scanModules(); this.initDependencies("init"); modules.config.scripts.forEach(modules.load); this.scanModules(); defineModule.modules.forEach(function defModule({ lazyInit, constructor: { className } }) { if (!lazyInit) { Class.replaceProperty(modules, className, modules[className]); this.initDependencies(className); } else modules.__defineGetter__(className, () => { let module = modules.jsmodules[className]; Class.replaceProperty(modules, className, module); if (module.reallyInit) module.reallyInit(); // :( if (!module.lazyDepends) self.initDependencies(className); return module; }); }, this); }, cleanup: function cleanup(window) { overlay.windows.delete(window); JSMLoader.atexit(() => { Cu.nukeSandbox(this.jsmodules); }); }, unload: function unload(window) { for (let mod of this.modules.moduleList.reverse()) { mod.stale = true; if ("destroy" in mod) util.trapErrors("destroy", mod); } }, visible: function visible(window) { // Module.list.forEach(load); this.initDependencies("load"); this.modules.times = update({}, defineModule.times); defineModule.loadLog.push("Loaded in " + (Date.now() - this.startTime) + "ms"); overlay.windows.add(window); }, loadModule: function loadModule(module, prereq, frame) { let { loaded, seen } = this; let { Module, modules } = this.modules; if (isString(module)) { if (!Module.constructors.hasOwnProperty(module)) modules.load(module); module = Module.constructors[module]; } try { if (loaded.has(module.className)) return; if (seen.add(module.className)) throw Error("Module dependency loop."); for (let dep of module.requires) this.loadModule(Module.constructors[dep], module.className); defineModule.loadLog.push( "Load" + (isString(prereq) ? " " + prereq + " dependency: " : ": ") + module.className); if (frame && frame.filename) defineModule.loadLog.push(" from: " + util.fixURI(frame.filename) + ":" + frame.lineNumber); let obj = defineModule.time(module.className, "init", module); Class.replaceProperty(modules, module.className, obj); loaded.add(module.className); if (loaded.has("dactyl") && obj.signals) modules.dactyl.registerObservers(obj); if (!module.lazyDepends) this.initDependencies(module.className); } catch (e) { util.dump("Loading " + (module && module.className) + ":"); util.reportError(e); } return modules[module.className]; }, deferInit: function deferInit(name, INIT, mod) { let { modules } = this.modules; let init = this.deferredInit[name] || {}; this.deferredInit[name] = init; let className = mod.className || mod.constructor.className; if (!hasOwnProp(init, className)) { init[className] = function callee() { function finish() { this.currentDependency = className; defineModule.time(className, name, INIT[name], mod, modules.dactyl, modules, window); } if (!callee.frobbed) { callee.frobbed = true; if (modules[name] instanceof Class) modules[name].withSavedValues(["currentDependency"], finish); else finish.call({}); } }; INIT[name].require = name => { init[name](); }; } }, scanModules: function scanModules() { let { Module, modules } = this.modules; defineModule.modules.forEach(mod => { let names = new RealSet(Object.keys(mod.INIT)); if ("init" in mod.INIT) names.add("init"); for (let name of names) this.deferInit(name, mod.INIT, mod); }); Module.list.forEach(mod => { if (!mod.frobbed) { modules.__defineGetter__(mod.className, () => { delete modules[mod.className]; return this.loadModule(mod.className, null, Components.stack.caller); }); Object.keys(mod.prototype.INIT) .forEach(name => { this.deferInit(name, mod.prototype.INIT, mod); }); } mod.frobbed = true; }); }, initDependencies: function initDependencies(name, parents) { for (let [k, v] of iter(this.deferredInit[name] || {})) if (!parents || ~parents.indexOf(k)) util.trapErrors(v); } }; }); endModule(); } catch(e){ if (!e.stack) e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); } // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/messages.jsm000066400000000000000000000213111264147376100213260ustar00rootroot00000000000000// Copyright (c) 2011-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; defineModule("messages", { exports: ["Messages", "messages", "_"], require: ["services", "util"] }); var Messages = Module("messages", { init: function init(name="messages") { let self = this; this.name = name; this._ = Class("_", String, { init: function _(message) { this.args = arguments; }, instance: {}, message: Class.Memoize(function () { let message = this.args[0]; if (this.args.length > 1) { let args = Array.slice(this.args, 1); return self.format(message + "-" + args.length, args, null) || self.format(message, args); } return self.get(message); }), valueOf: function valueOf() { return this.message; }, toString: function toString() { return this.message; }, toJSON: function toJSON() { return this.message; } }); }, cleanup: function cleanup() { services.stringBundle.flushBundles(); }, bundles: Class.Memoize(function () { let urls = new RealSet([ JSMLoader.getTarget("dactyl://locale/"), JSMLoader.getTarget("dactyl://locale-local/"), "resource://dactyl-locale/en-US/", "resource://dactyl-locale-local/en-US/" ].map(url => url + this.name + ".properties")); return Array.from(urls, services.stringBundle.createBundle) .filter(bundle => { try { bundle.getSimpleEnumeration(); return true; } catch (e) { return false; } }); }), iterate: function* () { let seen = new RealSet; for (let bundle of this.bundles) for (let { key, value } of iter(bundle.getSimpleEnumeration(), Ci.nsIPropertyElement)) if (!seen.add(key)) yield [key, value]; }, get: function get(value, default_) { for (let bundle of this.bundles) try { let res = bundle.GetStringFromName(value); if (res.slice(0, 2) == "+ ") return res.slice(2).replace(/\s+/g, " "); return res; } catch (e) {} // Report error so tests fail, but don't throw if (arguments.length < 2) // Do *not* localize these strings util.reportError(Error("Invalid locale string: " + value)); return arguments.length > 1 ? default_ : value; }, format: function format(value, args, default_) { for (let bundle of this.bundles) try { let res = bundle.formatStringFromName(value, args, args.length); if (res.slice(0, 2) == "+ ") return res.slice(2).replace(/\s+/g, " "); return res; } catch (e) {} // Report error so tests fail, but don't throw if (arguments.length < 3) // Do *not* localize these strings util.reportError(Error("Invalid locale string: " + value)); return arguments.length > 2 ? default_ : value; }, /** * Exports known localizable strings to a properties file. * * @param {string|nsIFile} {file} The file to which to export * the strings. */ export: function export_(file) { let { Buffer, commands, hints, io, mappings, modes, options, sanitizer } = overlay.activeModules; file = io.File(file); function properties(base, iter_, prop="description") { return Array.from(function* _properties() { function key(...args) { return [base, obj.identifier || obj.name, ...args] .join(".") .replace(/[\\:=]/g, "\\$&"); } for (let obj of iter_) { if (!obj.hive || obj.hive.name !== "user") { yield key(prop) + " = " + obj[prop]; if (iter_.values) { let iter_ = isArray(obj.values) ? obj.values : iter(obj.values); for (let [k, v] of iter_) yield key("values", k) + " = " + v; } for (let opt of values(obj.options)) yield key("options", opt.names[0]) + " = " + opt.description; if (obj.deprecated) yield key("deprecated") + " = " + obj.deprecated; } } }()); } let allMessages = [ ...commands.allHives.map(h => properties("command", h)), ...modes.all.flatMap(m => properties("map", values(mappings.builtin.getStack(m) .filter(map => map.modes[0] == m)))), ...properties("mode", values(modes.all.filter(m => !m.hidden))), ...properties("option", options), ...properties("hintmode", values(hints.modes), "prompt"), ...properties("pageinfo", values(Buffer.pageInfo), "title"), ...properties("sanitizeitem", values(sanitizer.itemMap)), ]; file.write(allMessages.join("\n")); } }, { Localized: Class("Localized", Class.Property, { init: function init(prop, obj) { let _prop = "unlocalized_" + prop; if (this.initialized) { /* if (config.locale === "en-US") return { configurable: true, enumerable: true, value: this.default, writable: true }; */ if (!hasOwnProp(obj, "localizedProperties")) obj.localizedProperties = new RealSet(obj.localizedProperties); obj.localizedProperties.add(prop); obj[_prop] = this.default; return { get: function get() { let value = this[_prop]; function getter(key, default_) { return function getter() { return messages.get([name, key].join("."), default_); }; } if (value != null) { var name = [this.constructor.className.toLowerCase(), this.identifier || this.name, prop].join("."); if (!isObject(value)) value = messages.get(name, value); else if (isArray(value)) // Deprecated iter(value).forEach(function ([k, v]) { if (isArray(v)) memoize(v, 1, getter(v[0], v[1])); else memoize(value, k, getter(k, v)); }); else iter(value).forEach(function ([k, v]) { memoize(value, k, () => messages.get([name, k].join("."), v)); }); } return Class.replaceProperty(this, prop, value); }, set: function set(val) { this[_prop] = val; } }; } this.default = prop; this.initialized = true; } }) }, { javascript: function initJavascript(dactyl, modules, window) { let { JavaScript } = modules; JavaScript.setCompleter([this._, this.get, this.format], [context => messages.iterate()]); JavaScript.setCompleter([this.export], [function (context, obj, args) { context.quote[2] = ""; modules.completion.file(context, true); }]); } }); var { _ } = messages; endModule(); // catch(e){ if (!e.stack) e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); } // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/options.jsm000066400000000000000000001706341264147376100212270ustar00rootroot00000000000000// Copyright (c) 2006-2008 by Martin Stubenschrott // Copyright (c) 2007-2011 by Doug Kearns // Copyright (c) 2008-2015 by Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; try { defineModule("options", { exports: ["Option", "Options", "ValueError", "options"], require: ["contexts", "messages", "storage"] }); lazyRequire("cache", ["cache"]); lazyRequire("config", ["config"]); lazyRequire("commands", ["Commands"]); lazyRequire("completion", ["CompletionContext"]); lazyRequire("prefs", ["prefs"]); lazyRequire("styles", ["Styles"]); lazyRequire("template", ["template"]); /** @scope modules */ let ValueError = Class("ValueError", ErrorBase); // do NOT create instances of this class yourself, use the helper method // options.add() instead /** * A class representing configuration options. Instances are created by the * {@link Options} class. * * @param {[string]} names The names by which this option is identified. * @param {string} description A short one line description of the option. * @param {string} type The option's value data type (see {@link Option#type}). * @param {string} defaultValue The default value for this option. * @param {Object} extra An optional extra configuration hash. The following * properties are supported. * completer - see {@link Option#completer} * domains - see {@link Option#domains} * getter - see {@link Option#getter} * initialValue - Initial value is loaded from getter * persist - see {@link Option#persist} * privateData - see {@link Option#privateData} * scope - see {@link Option#scope} * setter - see {@link Option#setter} * validator - see {@link Option#validator} * @optional * @private */ var Option = Class("Option", { init: function init(modules, names, description, defaultValue, extra) { this.modules = modules; this.name = names[0]; this.realNames = names; this.description = description; if (extra) this.update(extra); this._defaultValue = defaultValue; if (this.globalValue == undefined && !this.initialValue) this.globalValue = this.defaultValue; }, magicalProperties: new RealSet(["cleanupValue"]), /** * @property {string} This option's description, as shown in :listoptions. */ description: Messages.Localized(""), get helpTag() { return "'" + this.name + "'"; }, initValue: function initValue() { util.trapErrors(() => { this.value = this.value; }); }, get isDefault() { return this.stringValue === this.stringDefaultValue; }, /** @property {value} The value to reset this option to at cleanup time. */ get cleanupValue() { return options.cleanupPrefs.get(this.name); }, set cleanupValue(value) { if (options.cleanupPrefs.get(this.name) == null) options.cleanupPrefs.set(this.name, value); }, /** @property {value} The option's global value. @see #scope */ get globalValue() { let val = options.store.get(this.name, {}).value; if (val != null) return val; return this.globalValue = this.defaultValue; }, set globalValue(val) { options.store.set(this.name, { value: this.parse(this.stringify(val)), time: Date.now() }); }, /** * Returns *value* as an array of parsed values if the option type is * "charlist" or "stringlist" or else unchanged. * * @param {value} value The option value. * @returns {value|[string]} */ parse: function parse(value) { return Option.dequote(value); }, parseKey: function parseKey(value) { return value; }, /** * Returns *values* packed in the appropriate format for the option type. * * @param {value|[string]} values The option value. * @returns {value} */ stringify: function stringify(vals) { return Commands.quote(vals); }, /** * Returns the option's value as an array of parsed values if the option * type is "charlist" or "stringlist" or else the simple value. * * @param {number} scope The scope to return these values from (see * {@link Option#scope}). * @returns {value|[string]} */ get: function get(scope) { if (scope) { if ((scope & this.scope) == 0) // option doesn't exist in this scope return null; } else scope = this.scope; let values; /* if (config.has("tabs") && (scope & Option.SCOPE_LOCAL)) values = tabs.options[this.name]; */ if ((scope & Option.SCOPE_GLOBAL) && (values == undefined)) values = this.globalValue; if (hasOwnProp(this, "_value")) values = this._value; if (this.getter) return util.trapErrors(this.getter, this, values); return values; }, /** * Sets the option's value from an array of values if the option type is * "charlist" or "stringlist" or else the simple value. * * @param {number} scope The scope to apply these values to (see * {@link Option#scope}). */ set: function set(newValues, scope, skipGlobal) { scope = scope || this.scope; if ((scope & this.scope) == 0) // option doesn't exist in this scope return; if (this.setter) newValues = this.setter(newValues); if (newValues === undefined) return; /* if (config.has("tabs") && (scope & Option.SCOPE_LOCAL)) tabs.options[this.name] = newValues; */ if ((scope & Option.SCOPE_GLOBAL) && !skipGlobal) this.globalValue = newValues; this._value = newValues; this.hasChanged = true; this.setFrom = null; // dactyl.triggerObserver("options." + this.name, newValues); }, getValues: deprecated("Option#get", "get"), setValues: deprecated("Option#set", "set"), joinValues: deprecated("Option#stringify", "stringify"), parseValues: deprecated("Option#parse", "parse"), /** * @property {value} The option's current value. The option's local value, * or if no local value is set, this is equal to the * (@link #globalValue). */ get value() { return this.get(); }, set value(val) { this.set(val); }, get stringValue() { return this.stringify(this.value); }, set stringValue(value) { this.value = this.parse(value); }, get stringDefaultValue() { return this.stringify(this.defaultValue); }, set stringDefaultValue(val) { this.defaultValue = this.parse(val); }, getKey: function getKey(key) { return undefined; }, /** * Returns whether the option value contains one or more of the specified * arguments. * * @returns {boolean} */ has: function has() { return Array.some(arguments, val => this.value.indexOf(val) >= 0); }, /** * Returns whether this option is identified by *name*. * * @param {string} name * @returns {boolean} */ hasName: function hasName(name) { return this.names.indexOf(name) >= 0; }, /** * Returns whether the specified *values* are valid for this option. * @see Option#validator */ isValidValue: function isValidValue(values) { return this.validator(values); }, invalidArgument: function invalidArgument(arg, op) { return _("error.invalidArgument", this.name + (op || "").replace(/=?$/, "=") + arg); }, /** * Resets the option to its default value. */ reset: function reset() { this.value = this.defaultValue; }, /** * Sets the option's value using the specified set *operator*. * * @param {string} operator The set operator. * @param {value|[string]} values The value (or values) to apply. * @param {number} scope The scope to apply this value to (see * {@link #scope}). * @param {boolean} invert Whether this is an invert boolean operation. */ op: function op(operator, values, scope, invert, str) { try { var newValues = this._op(operator, values, scope, invert); if (newValues == null) return _("option.operatorNotSupported", operator, this.type); if (!this.isValidValue(newValues)) return this.invalidArgument(str || this.stringify(values), operator); this.set(newValues, scope); } catch (e) { if (!(e instanceof ValueError)) util.reportError(e); return this.invalidArgument(str || this.stringify(values), operator) + ": " + e.message; } return null; }, // Properties {{{ /** @property {string} The option's canonical name. */ name: null, /** @property {[string]} All names by which this option is identified. */ names: Class.Memoize(function () { return this.realNames; }), /** * @property {string} The option's data type. One of: * "boolean" - Boolean, e.g., true * "number" - Integer, e.g., 1 * "string" - String, e.g., "Pentadactyl" * "charlist" - Character list, e.g., "rb" * "regexplist" - Regexp list, e.g., "^foo,bar$" * "stringmap" - String map, e.g., "key:v,foo:bar" * "regexpmap" - Regexp map, e.g., "^key:v,foo$:bar" */ type: null, /** * @property {number} The scope of the option. This can be local, global, * or both. * @see Option#SCOPE_LOCAL * @see Option#SCOPE_GLOBAL * @see Option#SCOPE_BOTH */ scope: 1, // Option.SCOPE_GLOBAL // XXX set to BOTH by default someday? - kstep /** * @property {function(CompletionContext, Args)} This option's completer. * @see CompletionContext */ completer: function completer(context, extra) { if (/map$/.test(this.type) && extra.value == null) return; if (this.values) context.completions = this.values; }, /** * @property {[[string, string]]} This option's possible values. * @see CompletionContext */ values: Messages.Localized(null), /** * @property {function(host, values)} A function which should return a list * of domains referenced in the given values. Used in determining whether * to purge the command from history when clearing private data. * @see Command#domains */ domains: null, /** * @property {function(host, values)} A function which should strip * references to a given domain from the given values. */ filterDomain: function filterDomain(host, values) { return Array.filter(values, val => !this.domains([val]).some(val => util.isSubdomain(val, host))); }, /** * @property {value} The option's default value. This value will be used * unless the option is explicitly set either interactively or in an RC * file or plugin. */ defaultValue: Class.Memoize(function () { let defaultValue = this._defaultValue; delete this._defaultValue; if (hasOwnProp(this.modules.config.optionDefaults, this.name)) defaultValue = this.modules.config.optionDefaults[this.name]; if (defaultValue == null && this.getter) defaultValue = this.getter(); if (defaultValue == undefined) return null; if (this.type === "string") defaultValue = Commands.quote(defaultValue); if (isArray(defaultValue)) defaultValue = defaultValue.map(Option.quote).join(","); else if (isObject(defaultValue)) defaultValue = iter(defaultValue).map(val => val.map(v => Option.quote(v, /:/)) .join(":")) .join(","); if (isArray(defaultValue)) defaultValue = defaultValue.map(Option.quote).join(","); return this.parse(defaultValue); }), /** * @property {function} The function called when the option value is read. */ getter: null, /** * @property {boolean} When true, this options values will be saved * when generating a configuration file. * @default true */ persist: true, /** * @property {boolean|function(values)} When true, values of this * option may contain private data which should be purged from * saved histories when clearing private data. If a function, it * should return true if an invocation with the given values * contains private data */ privateData: false, /** * @property {function} The function called when the option value is set. */ setter: null, testValues: function testValues(values, validator) { return validator(values); }, /** * @property {function} The function called to validate the option's value * when set. */ validator: function validator() { if (this.values || this.completer !== Option.prototype.completer) return Option.validateCompleter.apply(this, arguments); return true; }, /** * @property {boolean} Set to true whenever the option is first set. This * is useful to see whether it was changed from its default value * interactively or by some RC file. */ hasChanged: false, /** * @property {number} Returns the timestamp when the option's value was * last changed. */ get lastSet() { return options.store.get(this.name).time; }, set lastSet(val) { options.store.set(this.name, { value: this.globalValue, time: Date.now() }); }, /** * @property {nsIFile} The script in which this option was last set. null * implies an interactive command. */ setFrom: null //}}} }, { /** * @property {number} Global option scope. * @final */ SCOPE_GLOBAL: 1, /** * @property {number} Local option scope. Options in this scope only * apply to the current tab/buffer. * @final */ SCOPE_LOCAL: 2, /** * @property {number} Both local and global option scope. * @final */ SCOPE_BOTH: 3, has: { toggleAll: function toggleAll() { return toggleAll.supercall(this, "all") ^ !!toggleAll.superapply(this, arguments); } }, parseRegexp: function parseRegexp(value, result, flags) { let keepQuotes = this && this.keepQuotes; if (isArray(flags)) // Called by Array.map result = flags = undefined; if (flags == null) flags = this && this.regexpFlags || ""; let [, bang, val] = /^(!?)(.*)/.exec(value); let re = util.regexp(Option.dequote(val), flags); re.bang = bang; re.result = result !== undefined ? result : !bang; re.key = re.bang + Option.quote(util.regexp.getSource(re), /^!|:/); re.toString = function () { return Option.unparseRegexp(this, keepQuotes); }; return re; }, unparseRegexp: function unparseRegexp(re, quoted) { return re.bang + Option.quote(util.regexp.getSource(re), /^!|:/) + (typeof re.result === "boolean" ? "" : ":" + (quoted ? re.result : Option.quote(re.result, /:/))); }, parseSite: function parseSite(pattern, result, rest) { if (isArray(rest)) // Called by Array.map result = undefined; let [, bang, filter] = /^(!?)(.*)/.exec(pattern); filter = Option.dequote(filter).trim(); let quote = this.keepQuotes ? v => v : v => Option.quote(v, /:/); return update(Styles.matchFilter(filter), { bang: bang, filter: filter, result: result !== undefined ? result : !bang, toString: function toString() { return this.bang + Option.quote(this.filter, /:/) + (typeof this.result === "boolean" ? "" : ":" + quote(this.result)); } }); }, getKey: { stringlist: function stringlist(k) { return this.value.indexOf(k) >= 0; }, get charlist() { return this.stringlist; }, regexplist: function regexplist(k, default_=null) { for (let re of this.value) if ((re.test || re).call(re, k)) return re.result; return default_; }, get regexpmap() { return this.regexplist; }, get sitelist() { return this.regexplist; }, get sitemap() { return this.regexplist; } }, domains: { sitelist: function (vals) { return Ary.compact(vals.map(site => util.getHost(site.filter))); }, get sitemap() { return this.sitelist; } }, stringify: { charlist: function (vals) { return Commands.quote(vals.join("")); }, stringlist: function (vals) { return vals.map(Option.quote).join(","); }, stringmap: function (vals) { return [Option.quote(k, /:/) + ":" + Option.quote(v, /:/) for ([k, v] of iter(vals))].join(","); }, regexplist: vals => vals.join(","), get regexpmap() { return this.regexplist; }, get sitelist() { return this.regexplist; }, get sitemap() { return this.regexplist; } }, parse: { number: function (value) { let val = Option.dequote(value); return (Option.validIf(Number(val) % 1 == 0, _("option.intRequired")) && parseInt(val)); }, boolean: function boolean(value) { return Option.dequote(value) == "true" || value == true ? true : false; }, charlist: function charlist(value) { return Array.slice(Option.dequote(value)); }, stringlist: function stringlist(value) { return (value === "") ? [] : Option.splitList(value); }, regexplist: function regexplist(value) { if (value === "") return []; else return Option.splitList(value, true) .map(re => Option.parseRegexp(re, undefined, this.regexpFlags)); }, sitelist: function sitelist(value) { if (value === "") return []; if (!isArray(value)) value = Option.splitList(value, true); return value.map(Option.parseSite, this); }, stringmap: function stringmap(value) { return Ary.toObject(Option.splitList(value, true).map(v => { let [count, key, quote] = Commands.parseArg(v, /:/); return [key, Option.dequote(v.substr(count + 1))]; })); }, regexpmap: function regexpmap(value) { return Option.parse.list.call(this, value, Option.parseRegexp); }, sitemap: function sitemap(value) { return Option.parse.list.call(this, value, Option.parseSite); }, list: function list(value, parse) { let prev = null; return Ary.compact(Option.splitList(value, true) .map(v => { let [count, filter, quote] = Commands.parseArg(v, /:/, true); let val = v.substr(count + 1); if (!this.keepQuotes) val = Option.dequote(val); if (v.length > count) return prev = parse.call(this, filter, val); else { util.assert(prev, _("error.syntaxError"), false); prev.result += "," + v; } })); }, }, parseKey: { number: Number, boolean: function boolean(value) { return value == "true" || value == true ? true : false; } }, testValues: { regexpmap: function regexpmap(vals, validator) { return vals.every(re => validator(re.result)); }, get sitemap() { return this.regexpmap; }, stringlist: function stringlist(vals, validator) { return vals.every(validator, this); }, stringmap: function stringmap(vals, validator) { return values(vals).every(validator, this); } }, dequote: function dequote(value) { let arg; [, arg, Option._quote] = Commands.parseArg(String(value), ""); Option._splitAt = 0; return arg; }, splitList: function splitList(value, keepQuotes) { let res = []; Option._splitAt = 0; while (value.length) { if (count !== undefined) value = value.slice(1); var [count, arg, quote] = Commands.parseArg(value, /,/, keepQuotes); Option._quote = quote; // FIXME res.push(arg); if (value.length > count) Option._splitAt += count + 1; value = value.slice(count); } return res; }, // XXX quote: function quote(str, re) { return isArray(str) ? str.map(s => quote(s, re)).join(",") : Commands.quoteArg[/[\s|"'\\,]|^$/.test(str) || re && re.test && re.test(str) ? (/[\b\f\n\r\t]/.test(str) ? '"' : "'") : ""](str, re); }, ops: { boolean: function boolean(operator, values, scope, invert) { if (operator != "=") return null; if (invert) return !this.value; return values; }, number: function number(operator, values, scope, invert) { if (invert) values = values[(values.indexOf(String(this.value)) + 1) % values.length]; let value = parseInt(values); util.assert(Number(values) % 1 == 0, _("command.set.numberRequired", this.name, values)); switch (operator) { case "+": return this.value + value; case "-": return this.value - value; case "^": return this.value * value; case "=": return value; } return null; }, string: function string(operator, values, scope, invert) { if (invert) return values[(values.indexOf(this.value) + 1) % values.length]; switch (operator) { case "+": return this.value + values; case "-": return this.value.replace(values, ""); case "^": return values + this.value; case "=": return values; } return null; }, stringmap: function stringmap(operator, values, scope, invert) { let res = update({}, this.value); switch (operator) { // The result is the same. case "+": case "^": return update(res, values); case "-": for (let [k, v] of iter(values)) if (v === res[k]) delete res[k]; return res; case "=": if (invert) { for (let [k, v] of iter(values)) if (v === res[k]) delete res[k]; else res[k] = v; return res; } return values; } return null; }, stringlist: function stringlist(operator, values, scope, invert) { values = Array.concat(values); function uniq(ary) { let seen = new RealSet; return ary.filter(elem => !seen.add(elem)); } switch (operator) { case "+": return uniq(Array.concat(this.value, values), true); case "^": // NOTE: Vim doesn't prepend if there's a match in the current value return uniq(Array.concat(values, this.value), true); case "-": return this.value.filter(function (item) { return !this.has(item); }, new RealSet(values)); case "=": if (invert) { let old = this.value.map(String); let new_ = values.map(String); let map = Ary(this.value).concat(values).map(val => [String(val), val]).toObject(); let keepValues = old.filter(function (item) { return !this.has(item); }, new RealSet(new_)); let addValues = new_.filter(function (item) { return !this.has(item); }, new RealSet(old)); return addValues.concat(keepValues).map(s => map[s]); } return values; } return null; }, get charlist() { return this.stringlist; }, get regexplist() { return this.stringlist; }, get regexpmap() { return this.stringlist; }, get sitelist() { return this.stringlist; }, get sitemap() { return this.stringlist; } }, validIf: function validIf(test, error) { if (test) return true; throw ValueError(error); }, /** * Validates the specified *values* against values generated by the * option's completer function. * * @param {value|[string]} values The value or array of values to validate. * @returns {boolean} */ validateCompleter: function validateCompleter(vals) { function completions(extra) { let context = CompletionContext(""); return context.fork("", 0, this, this.completer, extra) || context.allItems.items.map(item => [item.text]); }; if (isObject(vals) && !isArray(vals)) { let k = values(completions.call(this, { values: {} })).toObject(); let v = values(completions.call(this, { value: "" })).toObject(); return Object.keys(vals).every(hasOwnProp.bind(null, k)) && values(vals).every(hasOwnProp.bind(null, v)); } if (this.values) var acceptable = this.values.array || this.values; else acceptable = completions.call(this); if (isArray(acceptable)) acceptable = new RealSet(acceptable.map(v => v[0])); else acceptable = new RealSet(Object.keys(acceptable).map(k => this.parseKey(k))); if (this.type === "regexpmap" || this.type === "sitemap") return Array.concat(vals).every(re => acceptable.has(re.result)); return Array.concat(vals).every(v => acceptable.has(v)); }, types: {} }); ["Boolean", "Charlist", "Number", "RegexpList", "RegexpMap", "SiteList", "SiteMap", "String", "StringList", "StringMap"].forEach(function (name) { let type = name.toLowerCase(); let class_ = Class(name + "Option", Option, { type: type, _op: Option.ops[type] }); if (type in Option.getKey) class_.prototype.getKey = Option.getKey[type]; if (type in Option.parse) class_.prototype.parse = Option.parse[type]; if (type in Option.parseKey) class_.prototype.parseKey = Option.parse[type]; if (type in Option.stringify) class_.prototype.stringify = Option.stringify[type]; if (type in Option.domains) class_.prototype.domains = Option.domains[type]; if (type in Option.testValues) class_.prototype.testValues = Option.testValues[type]; Option.types[type] = class_; this[class_.className] = class_; EXPORTED_SYMBOLS.push(class_.className); }, this); update(BooleanOption.prototype, { names: Class.Memoize(function () { return this.realNames.flatMap(name => [name, "no" + name]); }) }); var OptionHive = Class("OptionHive", Contexts.Hive, { init: function init(group) { init.supercall(this, group); this.values = {}; this.has = v => hasOwnProp(this.values, v); }, add: function add(names, description, type, defaultValue, extra) { return this.modules.options.add(names, description, type, defaultValue, extra); } }); /** * @instance options */ var Options = Module("options", { Local: function Local(dactyl, modules, window) { let { contexts } = modules; return { init: function init() { const self = this; update(this, { hives: contexts.Hives("options", Class("OptionHive", OptionHive, { modules: modules })), user: contexts.hives.options.user }); this.needInit = []; this._options = []; this._optionMap = {}; storage.newMap("options", { store: false }); storage.addObserver("options", function optionObserver(key, event, option) { // Trigger any setters. let opt = self.get(option); if (event == "change" && opt) opt.set(opt.globalValue, Option.SCOPE_GLOBAL, true); }, window); modules.cache.register("options.dtd", () => util.makeDTD( iter(([["option", o.name, "default"].join("."), o.type === "string" ? o.defaultValue.replace(/'/g, "''") : o.defaultValue === true ? "on" : o.defaultValue === false ? "off" : o.stringDefaultValue] for (o of self)), ([["option", o.name, "type"].join("."), o.type] for (o of self)), config.dtd)), true); }, signals: { "io.source": function ioSource(context, file, modTime) { cache.flushEntry("options.dtd", modTime); } }, dactyl: dactyl, /** * Lists all options in *scope* or only those with changed values if * *onlyNonDefault* is specified. * * @param {function(Option)} filter Limit the list * @param {number} scope Only list options in this scope (see * {@link Option#scope}). */ list: function list(filter, scope) { if (!scope) scope = Option.SCOPE_BOTH; function* opts(opt) { for (let opt of this) { if (filter && !filter(opt)) continue; if (!(opt.scope & scope)) continue; let option = { __proto__: opt, isDefault: opt.isDefault, default: opt.stringDefaultValue, pre: "\u00a0\u00a0", // Unicode nonbreaking space. value: [] }; if (opt.type == "boolean") { if (!opt.value) option.pre = "no"; option.default = (opt.defaultValue ? "" : "no") + opt.name; } else if (isArray(opt.value) && opt.type != "charlist") option.value = ["", "=", template.map(opt.value, v => template.highlight(String(v)), ["", ",", ["span", { style: "width: 0; display: inline-block" }, " "]])]; else option.value = ["", "=", template.highlight(opt.stringValue)]; yield option; } }; modules.commandline.commandOutput( template.options("Options", opts.call(this), this["verbose"] > 0)); }, cleanup: function cleanup() { for (let opt of this) if (opt.cleanupValue != null) opt.stringValue = opt.cleanupValue; }, /** * Adds a new option. * * @param {[string]} names All names for the option. * @param {string} description A description of the option. * @param {string} type The option type (see {@link Option#type}). * @param {value} defaultValue The option's default value. * @param {Object} extra An optional extra configuration hash (see * {@link Map#extra}). * @optional */ add: function add(names, description, type, defaultValue, extra) { if (!util.isDactyl(Components.stack.caller)) deprecated.warn(add, "options.add", "group.options.add"); util.assert(type in Option.types, _("option.noSuchType", type), false); if (!extra) extra = {}; extra.definedAt = contexts.getCaller(Components.stack.caller); let name = names[0]; if (name in this._optionMap) { this.dactyl.log(_("option.replaceExisting", JSON.stringify(name)), 1); this.remove(name); } let closure = () => this._optionMap[name]; memoize(this._optionMap, name, () => Option.types[type](modules, names, description, defaultValue, extra)); for (let alias of names.slice(1)) memoize(this._optionMap, alias, closure); if (extra.setter && (!extra.scope || extra.scope & Option.SCOPE_GLOBAL)) if (this.dactyl.initialized) closure().initValue(); else memoize(this.needInit, this.needInit.length, closure); this._floptions = (this._floptions || []).concat(name); memoize(this._options, this._options.length, closure); // quickly access options with options["wildmode"]: this.__defineGetter__(name, function () { return this._optionMap[name].value; }); this.__defineSetter__(name, function (value) { this._optionMap[name].value = value; }); } }; }, /** @property {Iterator(Option)} @private */ "@@iterator": function __iterator__() { return values(this._options.sort((a, b) => String.localeCompare(a.name, b.name))); }, allPrefs: deprecated("prefs.getNames", function allPrefs() { return apply(prefs, "getNames", arguments); }), getPref: deprecated("prefs.get", function getPref() { return apply(prefs, "get", arguments); }), invertPref: deprecated("prefs.invert", function invertPref() { return apply(prefs, "invert", arguments); }), listPrefs: deprecated("prefs.list", function listPrefs() { this.modules.commandline.commandOutput(apply(prefs, "list", arguments)); }), observePref: deprecated("prefs.observe", function observePref() { return apply(prefs, "observe", arguments); }), popContext: deprecated("prefs.popContext", function popContext() { return apply(prefs, "popContext", arguments); }), pushContext: deprecated("prefs.pushContext", function pushContext() { return apply(prefs, "pushContext", arguments); }), resetPref: deprecated("prefs.reset", function resetPref() { return apply(prefs, "reset", arguments); }), safeResetPref: deprecated("prefs.safeReset", function safeResetPref() { return apply(prefs, "safeReset", arguments); }), safeSetPref: deprecated("prefs.safeSet", function safeSetPref() { return apply(prefs, "safeSet", arguments); }), setPref: deprecated("prefs.set", function setPref() { return apply(prefs, "set", arguments); }), withContext: deprecated("prefs.withContext", function withContext() { return apply(prefs, "withContext", arguments); }), cleanupPrefs: Class.Memoize(() => config.prefs.Branch("cleanup.option.")), cleanup: function cleanup(reason) { if (~["disable", "uninstall"].indexOf(reason)) this.cleanupPrefs.resetBranch(); }, /** * Returns the option with *name* in the specified *scope*. * * @param {string} name The option's name. * @param {number} scope The option's scope (see {@link Option#scope}). * @optional * @returns {Option} The matching option. */ get: function get(name, scope) { if (!scope) scope = Option.SCOPE_BOTH; if (this._optionMap[name] && (this._optionMap[name].scope & scope)) return this._optionMap[name]; return null; }, /** * Parses a :set command's argument string. * * @param {string} args The :set command's argument string. * @param {Object} modifiers A hash of parsing modifiers. These are: * scope - see {@link Option#scope} * @optional * @returns {Object} The parsed command object. */ parseOpt: function parseOpt(args, modifiers) { let res = {}; let matches, prefix, postfix; [matches, prefix, res.name, postfix, res.valueGiven, res.operator, res.value] = args.match(/^\s*(no|inv)?([^=]+?)([?&!])?\s*(([-+^]?)=(.*))?\s*$/) || []; res.args = args; res.onlyNonDefault = false; // used for :set to print non-default options if (!args) { res.name = "all"; res.onlyNonDefault = true; } if (matches) { if (res.option = this.get(res.name, res.scope)) { if (prefix === "no" && res.option.type !== "boolean") res.option = null; } else if (res.option = this.get(prefix + res.name, res.scope)) { res.name = prefix + res.name; prefix = ""; } } res.prefix = prefix; res.postfix = postfix; res.all = (res.name == "all"); res.get = (res.all || postfix == "?" || (res.option && res.option.type != "boolean" && !res.valueGiven)); res.invert = (prefix == "inv" || postfix == "!"); res.reset = (postfix == "&"); res.unsetBoolean = (prefix == "no"); res.scope = modifiers && modifiers.scope; if (!res.option) return res; if (res.value === undefined) res.value = ""; res.optionValue = res.option.get(res.scope); try { if (!res.invert || res.option.type != "number") // Hack. res.values = res.option.parse(res.value); } catch (e) { res.error = e; } return res; }, /** * Remove the option with matching *name*. * * @param {string} name The name of the option to remove. This can be * any of the option's names. */ remove: function remove(name) { let opt = this.get(name); this._options = this._options.filter(o => o != opt); for (let name of opt.names) delete this._optionMap[name]; }, /** @property {Object} The options store. */ get store() { return storage.options; } }, { }, { commands: function initCommands(dactyl, modules, window) { const { commands, contexts, options } = modules; dactyl.addUsageCommand({ name: ["listo[ptions]", "lo"], description: "List all options along with their short descriptions", index: "option", iterate: function (args) { return options; }, format: { description: function (opt) { return [ opt.scope == Option.SCOPE_LOCAL ? ["span", { highlight: "URLExtra" }, "(" + _("option.bufferLocal") + ")"] : "", template.linkifyHelp(opt.description) ]; }, help: function (opt) { return "'" + opt.name + "'"; } } }); function setAction(args, modifiers) { let bang = args.bang; if (!args.length) args[0] = ""; let list = []; function flushList() { let names = new RealSet(list.map(opt => opt.option ? opt.option.name : "")); if (list.length) if (list.some(opt => opt.all)) options.list(opt => !(list[0].onlyNonDefault && opt.isDefault), list[0].scope); else options.list(opt => names.has(opt.name), list[0].scope); list = []; } for (let arg of args) { if (bang) { let onlyNonDefault = false; let reset = false; let invertBoolean = false; if (args[0] == "") { var name = "all"; onlyNonDefault = true; } else { var [matches, name, postfix, valueGiven, operator, value] = arg.match(/^\s*?((?:[^=\\']|\\.|'[^']*')+?)([?&!])?\s*(([-+^]?)=(.*))?\s*$/); reset = (postfix == "&"); invertBoolean = (postfix == "!"); } name = Option.dequote(name); if (name == "all" && reset) modules.commandline.input(_("pref.prompt.resetAll", config.host) + " ", resp => { if (resp == "yes") for (let pref of prefs.getNames()) prefs.reset(pref); }, { promptHighlight: "WarningMsg" }); else if (name == "all") modules.commandline.commandOutput(prefs.list(onlyNonDefault, "")); else if (reset) prefs.reset(name); else if (invertBoolean) prefs.toggle(name); else if (valueGiven) { if (value == undefined) value = ""; else if (value == "true") value = true; else if (value == "false") value = false; else if (Number(value) % 1 == 0) value = parseInt(value); else value = Option.dequote(value); if (operator) value = Option.ops[typeof value].call({ value: prefs.get(name) }, operator, value); prefs.set(name, value); } else modules.commandline.commandOutput(prefs.list(onlyNonDefault, name)); return; } let opt = modules.options.parseOpt(arg, modifiers); util.assert(opt, _("command.set.errorParsing", arg)); util.assert(!opt.error, _("command.set.errorParsing", opt.error)); let option = opt.option; util.assert(option != null || opt.all, _("command.set.unknownOption", opt.name)); // reset a variable to its default value if (opt.reset) { flushList(); if (opt.all) { for (let option of modules.options) option.reset(); } else { option.reset(); } } // read access else if (opt.get) list.push(opt); // write access else { flushList(); if (opt.option.type === "boolean") { util.assert(!opt.valueGiven, _("error.invalidArgument", arg)); opt.values = !opt.unsetBoolean; } else if (/^(string|number)$/.test(opt.option.type) && opt.invert) opt.values = Option.splitList(opt.value); try { var res = opt.option.op(opt.operator || "=", opt.values, opt.scope, opt.invert, opt.value); } catch (e) { res = e; } if (res) dactyl.echoerr(res); option.setFrom = contexts.getCaller(null); } } flushList(); } function setCompleter(context, args, modifiers) { const { completion } = modules; let filter = context.filter; if (args.bang) { // list completions for about:config entries if (filter[filter.length - 1] == "=") { context.advance(filter.length); filter = filter.substr(0, filter.length - 1); context.pushProcessor(0, (item, text, next) => next(item, text.substr(0, 100))); context.completions = [ [prefs.get(filter), _("option.currentValue")], [prefs.defaults.get(filter), _("option.defaultValue")] ].filter(k => k[0] != null); return null; } return completion.preference(context); } let opt = modules.options.parseOpt(filter, modifiers); let prefix = opt.prefix; context.highlight(); if (context.filter.indexOf("=") == -1) { if (false && prefix) context.filters.push(({ item }) => (item.type == "boolean" || prefix == "inv" && isArray(item.values))); return completion.option(context, opt.scope, opt.name == "inv" ? opt.name : prefix); } function error(length, message) { context.message = message; context.highlight(0, length, "SPELLCHECK"); } let option = opt.option; if (!option) return error(opt.name.length, _("option.noSuch", opt.name)); context.advance(context.filter.indexOf("=")); if (option.type == "boolean") return error(context.filter.length, _("error.trailingCharacters")); context.advance(1); if (opt.error) return error(context.filter.length, opt.error); if (opt.get || opt.reset || !option || prefix) return null; if (!opt.value && !opt.operator && !opt.invert) { context.fork("default", 0, this, context => { context.title = ["Extra Completions"]; context.pushProcessor(0, (item, text, next) => next(item, text.substr(0, 100))); context.completions = [ [option.stringValue, _("option.currentValue")], [option.stringDefaultValue, _("option.defaultValue")] ].filter(f => f[0] !== ""); context.quote = ["", identity, ""]; }); } let optcontext = context.fork("values"); modules.completion.optionValue(optcontext, opt.name, opt.operator); // Fill in the current values if we're removing if (opt.operator == "-" && isArray(opt.values)) { let have = new RealSet(i.text for (i of context.allItems.items)); context = context.fork("current-values", 0); context.anchored = optcontext.anchored; context.maxItems = optcontext.maxItems; context.filters.push(i => !have.has(i.text)); modules.completion.optionValue(context, opt.name, opt.operator, null, context => { context.generate = () => option.value.map(o => [o, ""]); }); context.title = ["Current values"]; } } // TODO: deprecated. This needs to support "g:"-prefixed globals at a // minimum for now. The coderepos plugins make extensive use of global // variables. commands.add(["let"], "Set or list a variable", function (args) { let globalVariables = dactyl._globalVariables; args = (args[0] || "").trim(); function fmt(value) { return (typeof value == "number" ? "#" : typeof value == "function" ? "*" : " ") + value; } util.assert(!(!args || args == "g:")); let matches = args.match(/^([a-z]:)?([\w]+)(?:\s*([-+.])?=\s*(.*)?)?$/); if (matches) { let [, scope, name, op, expr] = matches; let fullName = (scope || "") + name; util.assert(scope == "g:" || scope == null, _("command.let.illegalVar", scope + name)); util.assert(hasOwnProp(globalVariables, name) || (expr && !op), _("command.let.undefinedVar", fullName)); if (!expr) dactyl.echo(fullName + "\t\t" + fmt(globalVariables[name])); else { try { var newValue = dactyl.userEval(expr); } catch (e) {} util.assert(newValue !== undefined, _("command.let.invalidExpression", expr)); let value = newValue; if (op) { value = globalVariables[name]; if (op == "+") value += newValue; else if (op == "-") value -= newValue; else if (op == ".") value += String(newValue); } globalVariables[name] = value; } } else dactyl.echoerr(_("command.let.unexpectedChar")); }, { deprecated: "the options system", literal: 0 } ); [ { names: ["setl[ocal]"], description: "Set local option", modifiers: { scope: Option.SCOPE_LOCAL } }, { names: ["setg[lobal]"], description: "Set global option", modifiers: { scope: Option.SCOPE_GLOBAL } }, { names: ["se[t]"], description: "Set an option", modifiers: {}, extra: { serialize: function () { return Array.from(modules.options) .filter(opt => (!opt.getter && !opt.isDefault && (opt.scope & Option.SCOPE_GLOBAL))) .map( opt => ({ command: this.name, literalArg: [opt.type == "boolean" ? (opt.value ? "" : "no") + opt.name : opt.name + "=" + opt.stringValue] })); } } } ].forEach(function (params) { commands.add(params.names, params.description, function (args, modifiers) { setAction(args, update(modifiers, params.modifiers)); }, update({ bang: true, completer: setCompleter, domains: function domains(args) { return args.flatMap(spec => { try { let opt = modules.options.parseOpt(spec); if (opt.option && opt.option.domains) return opt.option.domains(opt.values); } catch (e) { util.reportError(e); } return []; }); }, keepQuotes: true, privateData: args => args.some(spec => { let opt = modules.options.parseOpt(spec); return (opt.option && opt.option.privateData && (!callable(opt.option.privateData) || opt.option.privateData(opt.values))); }), }, params.extra || {})); }); // TODO: deprecated. This needs to support "g:"-prefixed globals at a // minimum for now. commands.add(["unl[et]"], "Delete a variable", function (args) { for (let name of args) { name = name.replace(/^g:/, ""); // throw away the scope prefix if (!hasOwnProp(dactyl._globalVariables, name)) { if (!args.bang) dactyl.echoerr(_("command.let.noSuch", name)); return; } delete dactyl._globalVariables[name]; } }, { argCount: "+", bang: true, deprecated: "the options system" }); }, completion: function initCompletion(dactyl, modules, window) { const { completion } = modules; completion.option = function option(context, scope, prefix) { context.title = ["Option"]; context.keys = { text: "names", description: "description" }; context.anchored = false; context.completions = modules.options; if (prefix == "inv") context.keys.text = opt => opt.type == "boolean" || isArray(opt.value) ? opt.names.map(n => "inv" + n) : opt.names; if (scope) context.filters.push(({ item }) => item.scope & scope); }; completion.optionValue = function (context, name, op, curValue, completer) { let opt = modules.options.get(name); completer = completer || opt.completer; if (!completer || !opt) return; try { var curValues = curValue != null ? opt.parse(curValue) : opt.value; var newValues = opt.parse(context.filter); } catch (e) { context.message = _("error.error", e); context.completions = []; return; } let extra = {}; switch (opt.type) { case "boolean": return; case "sitelist": case "regexplist": newValues = Option.splitList(context.filter); // Fallthrough case "stringlist": break; case "charlist": Option._splitAt = newValues.length; break; case "stringmap": case "sitemap": case "regexpmap": let vals = Option.splitList(context.filter); let target = vals.pop() || ""; let [count, key, quote] = Commands.parseArg(target, /:/, true); let split = Option._splitAt; extra.key = Option.dequote(key); extra.value = count < target.length ? Option.dequote(target.substr(count + 1)) : null; extra.values = opt.parse(vals.join(",")); Option._splitAt = split + (extra.value == null ? 0 : count + 1); break; } // TODO: Highlight when invalid context.advance(Option._splitAt); context.filter = Option.dequote(context.filter); function val(obj) { if (isArray(opt.defaultValue)) { let val = [].find.call(obj, re => (re.key == extra.key)); return val && val.result; } if (hasOwnProp(opt.defaultValue, extra.key)) return obj[extra.key]; } if (extra.key && extra.value != null) { context.fork("default", 0, this, context => { context.completions = [ [val(opt.value), _("option.currentValue")], [val(opt.defaultValue), _("option.defaultValue")] ].filter(f => (f[0] !== "" && f[0] != null)); }); context = context.fork("stuff", 0); } context.title = ["Option Value"]; context.quote = Commands.complQuote[Option._quote] || Commands.complQuote[""]; // Not Vim compatible, but is a significant enough improvement // that it's worth breaking compatibility. if (isArray(newValues)) { context.filters.push(i => newValues.indexOf(i.text) == -1); if (op == "+") context.filters.push(i => curValues.indexOf(i.text) == -1); if (op == "-") context.filters.push(i => curValues.indexOf(i.text) > -1); memoize(extra, "values", () => { if (op == "+") return curValues.concat(newValues); if (op == "-") return curValues.filter(v => newValues.indexOf(val) == -1); return newValues; }); } let res = completer.call(opt, context, extra); if (res) context.completions = res; }; }, javascript: function initJavascript(dactyl, modules, window) { const { options, JavaScript } = modules; JavaScript.setCompleter(Options.prototype.get, [() => Array.from(options, opt => [opt.name, opt.description])]); }, sanitizer: function initSanitizer(dactyl, modules, window) { const { sanitizer } = modules; sanitizer.addItem("options", { description: "Options containing hostname data", action: function sanitize_action(timespan, host) { if (host) for (let opt of modules.options._options) if (timespan.contains(opt.lastSet * 1000) && opt.domains) try { opt.value = opt.filterDomain(host, opt.value); } catch (e) { dactyl.reportError(e); } }, }); } }); endModule(); } catch(e){ if (!e.stack) e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); } // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/overlay.jsm000066400000000000000000000443411264147376100212100ustar00rootroot00000000000000// Copyright (c) 2009-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; try { defineModule("overlay", { exports: ["overlay"], require: ["util"] }); lazyRequire("highlight", ["highlight"]); var getAttr = function getAttr(elem, ns, name) { return elem.hasAttributeNS(ns, name) ? elem.getAttributeNS(ns, name) : null; }; var setAttr = function setAttr(elem, ns, name, val) { if (val == null) elem.removeAttributeNS(ns, name); else elem.setAttributeNS(ns, name, val); }; var Overlay = Class("Overlay", { init: function init(window) { this.window = window; }, cleanups: Class.Memoize(() => []), objects: Class.Memoize(() => ({})), get doc() { return this.window.document; }, get win() { return this.window; }, $: function $(sel, node) { return DOM(sel, node || this.doc); }, cleanup: function cleanup(window, reason) { for (let fn of this.cleanups) util.trapErrors(fn, this, window, reason); } }); var Overlay = Module("Overlay", XPCOM([Ci.nsIObserver, Ci.nsISupportsWeakReference]), { init: function init() { util.addObserver(this); this.overlays = {}; this.overlayMatchers = []; this.weakMap = new WeakMap; this.onWindowVisible = []; }, id: Class.Memoize(() => config.addon.id), /** * Adds an event listener for this session and removes it on * dactyl shutdown. * * @param {Element} target The element on which to listen. * @param {string} event The event to listen for. * @param {function} callback The function to call when the event is received. * @param {boolean} capture When true, listen during the capture * phase, otherwise during the bubbling phase. * @param {boolean} allowUntrusted When true, allow capturing of * untrusted events. */ listen: function (target, event, callback, capture, allowUntrusted) { let doc = target.ownerDocument || target.document || target; let listeners = this.getData(doc, "listeners"); if (isObject(event)) var [self, events] = [event, event[callback || "events"]]; else [self, events] = [null, { [event]: callback }]; for (let [event, callback] of iter(events)) { let args = [Cu.getWeakReference(target), event, util.wrapCallback(callback, self), capture, allowUntrusted]; apply(target, "addEventListener", args.slice(1)); listeners.push(args); } }, /** * Remove an event listener. * * @param {Element} target The element on which to listen. * @param {string} event The event to listen for. * @param {function} callback The function to call when the event is received. * @param {boolean} capture When true, listen during the capture * phase, otherwise during the bubbling phase. */ unlisten: function (target, event, callback, capture) { let doc = target.ownerDocument || target.document || target; let listeners = this.getData(doc, "listeners"); if (event === true) target = null; this.setData(doc, "listeners", listeners.filter(args => { let elem = args[0].get(); if (target == null || elem == target && args[1] == event && args[2].wrapped == callback && args[3] == capture) { apply(elem, "removeEventListener", args.slice(1)); return false; } return elem; })); }, cleanup: function cleanup(reason) { for (let doc of util.iterDocuments()) { for (let callback of this.getData(doc, "cleanup")) util.trapErrors(callback, doc, reason); for (let elem of this.getData(doc, "overlayElements")) if (elem.parentNode) elem.parentNode.removeChild(elem); for (let [elem, ns, name, orig, value] of this.getData(doc, "overlayAttributes")) if (getAttr(elem, ns, name) === value) setAttr(elem, ns, name, orig); this.unlisten(doc, true); delete doc[this.id]; delete doc.defaultView[this.id]; } }, observers: { "toplevel-window-ready": function (window, data) { let listener = util.wrapCallback(function listener(event) { if (event.originalTarget === window.document) { window.removeEventListener("DOMContentLoaded", listener.wrapper, true); window.removeEventListener("load", listener.wrapper, true); overlay._loadOverlays(window); } }); window.addEventListener("DOMContentLoaded", listener, true); window.addEventListener("load", listener, true); }, "chrome-document-global-created": function (window, uri) { this.observe(window, "toplevel-window-ready", null); }, "content-document-global-created": function (window, uri) { this.observe(window, "toplevel-window-ready", null); }, "xul-window-visible": function () { if (this.onWindowVisible) this.onWindowVisible.forEach(f => { f.call(this); }); this.onWindowVisible = null; } }, getData: function getData(obj, key, constructor) { if (!this.weakMap.has(obj)) try { this.weakMap.set(obj, {}); } catch (e if e instanceof TypeError) { // util.dump("Bad WeakMap key: " + obj + " " + Components.stack.caller); let { id } = this; if (!(id in obj && obj[id])) obj[id] = {}; var data = obj[id]; } data = data || this.weakMap.get(obj); if (arguments.length == 1) return data; if (data[key] === undefined) if (constructor === undefined || callable(constructor)) data[key] = (constructor || Array)(); else data[key] = constructor; return data[key]; }, setData: function setData(obj, key, val) { let data = this.getData(obj); if (val !== undefined) return data[key] = val; delete data[key]; }, /** * A curried function which determines which host names match a * given stylesheet filter. When presented with one argument, * returns a matcher function which, given one nsIURI argument, * returns true if that argument matches the given filter. When * given two arguments, returns true if the second argument matches * the given filter. * * @param {string|function(nsIURI):boolean} filter The URI filter to match against. * @param {nsIURI} uri The location to test. * @returns {nsIURI -> boolean} */ matchFilter: function matchFilter(filter) { if (typeof filter == "function") var test = filter; else { filter = filter.trim(); if (filter === "*") var test = function test(uri) { return true; }; else if (!/^(?:[a-z-]+:|[a-z-.]+$)/.test(filter)) { let re = util.regexp(filter); test = function test(uri) { return re.test(uri.spec); }; } else if (/[*]$/.test(filter)) { let re = RegExp("^" + util.regexp.escape(filter.substr(0, filter.length - 1))); test = function test(uri) { return re.test(uri.spec); }; test.re = re; } else if (/[\/:]/.test(filter)) { test = function test(uri) { return uri.spec === filter; }; test.exact = true; } else test = function test(uri) { try { return util.isSubdomain(uri.host, filter); } catch (e) { return false; } }; test.toString = function toString() { return filter; }; test.key = filter; } if (arguments.length < 2) return test; return test(arguments[1]); }, overlayWindow: function overlayWindow(url, fn) { if (url instanceof Ci.nsIDOMWindow) overlay._loadOverlay(url, fn); else { Array.concat(url).forEach(function (url) { let matcher = this.matchFilter(url); if (!matcher.exact) this.overlayMatchers.push([matcher, fn]); else { if (!this.overlays[url]) this.overlays[url] = []; this.overlays[url].push(fn); } }, this); for (let doc of util.iterDocuments()) if (~["interactive", "complete"].indexOf(doc.readyState)) { this.observe(doc.defaultView, "xul-window-visible"); this._loadOverlays(doc.defaultView); } else { if (!this.onWindowVisible) this.onWindowVisible = []; this.observe(doc.defaultView, "toplevel-window-ready"); } } }, getOverlays: function* getOverlays(window) { for (let overlay of this.overlays[window.document.documentURI] || []) yield overlay; for (let [matcher, overlay] of this.overlayMatchers) if (matcher(window.document.documentURIObject)) yield overlay; }, _loadOverlays: function _loadOverlays(window) { let overlays = this.getData(window.document, "overlays"); for (let obj of this.getOverlays(window)) { if (~overlays.indexOf(obj)) continue; overlays.push(obj); this._loadOverlay(window, obj(window)); } }, _loadOverlay: function _loadOverlay(window, obj) { let doc = window.document; let savedElems = this.getData(doc, "overlayElements"); let savedAttrs = this.getData(doc, "overlayAttributes"); function insert(key, fn) { if (obj[key]) { let iterator = iter(obj[key]); if (isArray(obj[key])) iterator = obj[key].map(elem => [elem[1].id, elem.slice(2), elem[1]]); for (let [elem, xml, attrs] of iterator) { if (elem = doc.getElementById(String(elem))) { // Urgh. Hack. let namespaces; if (attrs) namespaces = iter([k.slice(6), DOM.fromJSON.namespaces[v] || v] for ([k, v] of iter(attrs)) if (/^xmlns(?:$|:)/.test(k))).toObject(); let node = DOM.fromJSON(xml, doc, obj.objects, namespaces); if (!(node instanceof Ci.nsIDOMDocumentFragment)) savedElems.push(node); else for (let n of node.childNodes) savedElems.push(n); fn(elem, node); for (let [attr, val] of iter(attrs || {})) { let [ns, localName] = DOM.parseNamespace(attr); let name = attr; savedAttrs.push([elem, ns, name, getAttr(elem, ns, name), val]); if (name === "highlight") highlight.highlightNode(elem, val); else elem.setAttributeNS(ns || "", name, val); } } } } } insert("before", (elem, dom) => elem.parentNode.insertBefore(dom, elem)); insert("after", (elem, dom) => elem.parentNode.insertBefore(dom, elem.nextSibling)); insert("append", (elem, dom) => elem.appendChild(dom)); insert("prepend", (elem, dom) => elem.insertBefore(dom, elem.firstChild)); if (obj.ready) util.trapErrors("ready", obj, window); function load(event) { util.trapErrors("load", obj, window, event); if (obj.visible) if (!event || !overlay.onWindowVisible || window != util.topWindow(window)) util.trapErrors("visible", obj, window); else overlay.onWindowVisible.push(function () { obj.visible(window); }); } if (obj.load) if (doc.readyState === "complete") load(); else window.addEventListener("load", util.wrapCallback(function onLoad(event) { if (event.originalTarget === doc) { window.removeEventListener("load", onLoad.wrapper, true); load(event); } }), true); if (obj.unload || obj.cleanup) this.listen(window, "unload", function unload(event) { if (event.originalTarget === doc) { overlay.unlisten(window, "unload", unload); if (obj.unload) util.trapErrors("unload", obj, window, event); if (obj.cleanup) util.trapErrors("cleanup", obj, window, "unload", event); } }); if (obj.cleanup) this.getData(doc, "cleanup").push(bind("cleanup", obj, window)); }, /** * Overlays an object with the given property overrides. Each * property in *overrides* is added to *object*, replacing any * original value. Functions in *overrides* are augmented with the * new properties *super*, *supercall*, and *superapply*, in the * same manner as class methods, so that they may call their * overridden counterparts. * * @param {object} object The object to overlay. * @param {object} overrides An object containing properties to * override. * @returns {function} A function which, when called, will remove * the overlay. */ overlayObject: function (object, overrides) { let original = Object.create(object); overrides = update(Object.create(original), overrides); Object.getOwnPropertyNames(overrides).forEach(function (k) { let desc = Object.getOwnPropertyDescriptor(overrides, k); if (desc.value instanceof Class.Property) desc = desc.value.init(k) || desc.value; if (k in object) { for (let obj = object; obj && !orig; obj = Object.getPrototypeOf(obj)) { var orig = Object.getOwnPropertyDescriptor(obj, k); if (orig) Object.defineProperty(original, k, orig); } if (!orig) { orig = Object.getPropertyDescriptor(object, k); if (orig) Object.defineProperty(original, k, orig); } } // Guard against horrible add-ons that use eval-based monkey // patching. let value = desc.value; if (callable(desc.value)) { delete desc.value; delete desc.writable; desc.get = function get() { return value; } desc.set = function set(val) { if (!callable(val) || !Function.prototype.toString(val).includes(sentinel)) Class.replaceProperty(this, k, val); else { let package_ = util.newURI(Components.stack.caller.filename).host; util.reportError(Error(_("error.monkeyPatchOverlay", package_))); util.dactyl.echoerr(_("error.monkeyPatchOverlay", package_)); } }; } try { Object.defineProperty(object, k, desc); if (callable(value)) { var sentinel = "(function DactylOverlay() {}())"; value.toString = function toString() { return toString.toString.call(this) .replace(/\}?$/, sentinel + "; $&"); }; value.toSource = function toSource() { return toSource.toSource.call(this) .replace(/\}?$/, sentinel + "; $&"); }; } } catch (e) { try { if (value) { object[k] = value; return; } } catch (f) {} util.reportError(e); } }, this); return function unwrap() { for (let k of Object.getOwnPropertyNames(original)) if (Object.getOwnPropertyDescriptor(object, k).configurable) Object.defineProperty(object, k, Object.getOwnPropertyDescriptor(original, k)); else { try { object[k] = original[k]; } catch (e) {} } }; }, get activeModules() { return this.activeWindow && this.activeWindow.dactyl.modules; }, get modules() { return Array.from(this.windows, win => win.dactyl.modules) }, /** * The most recently active dactyl window. */ get activeWindow() { let win = this._activeWindow && this._activeWindow.get(); return this.windows.has(win) && win; }, set activeWindow(win) { this._activeWindow = util.weakReference(win); if (win.dactyl) util.flushLateMethods(win.dactyl); }, /** * A list of extant dactyl windows. */ windows: Class.Memoize(() => new RealSet) }); endModule(); } catch(e){ if (!e.stack) e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); } // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/polyfill.jsm000066400000000000000000000046001264147376100213530ustar00rootroot00000000000000// Copyright (c) 2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; // Implementations for some ES6 and ES7 features that aren't in Firefox // mainline yet. { // This is similar to the same-named function in self-hosted JS, but // somewhat less efficient. // // It helps dodge some of the pitfalls of using the `call` method of the // function you're intending to call, which might have been replaced, // and can fail for other reasons (on CPOWs, most notably). let callFunction = Function.call.bind(Function.call); let identity = x => x; if (!Object.entries) Object.entries = function (obj) { let result = []; for (let key of Object.keys(obj)) { // The check is necessary, since keys may be removed during // iteration. if (key in obj) result.push([key, obj[key]]); } return result; }; if (!Object.values) Object.values = function (obj) { let result = []; for (let key of Object.keys(obj)) { // The check is necessary, since keys may be removed during // iteration. if (key in obj) result.push(obj[key]); } return result; }; if (!Array.prototype.flatMap) Array.prototype.flatMap = function (fn = identity, self = null) { let result = []; for (let [i, value] of Array.prototype.entries.call(this)) { let res = callFunction(fn, self, value, i); if (isObject(res) && Symbol.iterator in res) result.push(...res); else if (res !== undefined) result.push(res); } return result; }; // < FF43 if (!Array.prototype.includes) Array.prototype.includes = function (...args) { return this.indexOf(...args) != -1; }; if (!Array.prototype.values) Array.prototype.values = function* () { for (let [i, value] of this.entries()) yield value; }; // < FF40 if (!String.prototype.includes) String.prototype.includes = String.prototype.contains; } dactyl-1.2~r20151231/common/modules/prefs.jsm000066400000000000000000000356631264147376100206550ustar00rootroot00000000000000// Copyright (c) 2006-2008 by Martin Stubenschrott // Copyright (c) 2007-2011 by Doug Kearns // Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; try { defineModule("prefs", { exports: ["Prefs", "localPrefs", "prefs"], require: ["services", "util"] }); lazyRequire("messages", ["_"]); lazyRequire("template", ["template"]); var Prefs = Module("prefs", XPCOM([Ci.nsIObserver, Ci.nsISupportsWeakReference]), { ORIGINAL: "extensions.dactyl.original.", RESTORE: "extensions.dactyl.restore.", SAVED: "extensions.dactyl.saved.", INIT: {}, init: function init(branch, defaults) { this._prefContexts = []; this.branch = services.pref[defaults ? "getDefaultBranch" : "getBranch"](branch || ""); if ("nsIPrefBranch2" in Ci) this.branch instanceof Ci.nsIPrefBranch2; this.defaults = defaults ? this : this.constructor(branch, true); this.branches = memoize({ __proto__: this, get original() { return this.constructor(this.ORIGINAL + this.root); }, get restore() { return this.constructor(this.RESTORE + this.root); }, get saved() { return this.constructor(this.SAVED + this.root); } }); if (!defaults) this.restore(); this._observers = {}; }, cleanup: function cleanup(reason) { if (this.defaults != this) this.defaults.cleanup(reason); this._observers = {}; if (this.observe) { this.branch.removeObserver("", this); this.observe.unregister(); delete this.observe; } if (this == prefs) { if (~["uninstall", "disable"].indexOf(reason)) { for (let name of this.branches.saved.getNames()) this.safeReset(name, null, true); this.branches.original.resetBranch(); this.branches.saved.resetBranch(); } if (reason == "uninstall") localPrefs.resetBranch(); } }, /** * Returns a new Prefs instance for the sub-branch *branch* of this * branch. * * @param {string} branch The sub-branch to branch to. * @returns {Prefs} */ Branch: function Branch(branch) { return Prefs(this.root + branch); }, /** * Clears the entire branch. * * @param {string} name The name of the preference branch to delete. */ clear: function clear(branch) { this.branch.deleteBranch(branch || ""); }, /** * Returns the full name of this object's preference branch. */ get root() { return this.branch.root; }, /** * Returns the value of the preference *name*, or *defaultValue* if * the preference does not exist. * * @param {string} name The name of the preference to return. * @param {*} defaultValue The value to return if the preference has no value. * @optional */ get: function get(name, defaultValue) { if (defaultValue == null) defaultValue = null; if (isArray(name)) name = name.join("."); let type = this.branch.getPrefType(name); try { switch (type) { case Ci.nsIPrefBranch.PREF_STRING: let value = this.branch.getComplexValue(name, Ci.nsISupportsString).data; try { if (/^[a-z0-9-]+:/i.test(value)) value = this.branch.getComplexValue(name, Ci.nsIPrefLocalizedString).data; } catch (e) {} return value; case Ci.nsIPrefBranch.PREF_INT: return this.branch.getIntPref(name); case Ci.nsIPrefBranch.PREF_BOOL: return this.branch.getBoolPref(name); default: return defaultValue; } } catch (e) { return defaultValue; } }, getDefault: deprecated("Prefs#defaults.get", function getDefault(name, defaultValue) { return this.defaults.get(name, defaultValue); }), /** * Returns an array of all preference names in this branch or the * given sub-branch. * * @param {string} branch The sub-branch for which to return preferences. * @optional */ getNames: function getNames(branch) { return this.branch.getChildList(branch || "", { value: 0 }); }, /** * Returns true if the given preference exists in this branch. * * @param {string} name The name of the preference to check. */ has: function has(name) { return this.branch.getPrefType(name) !== 0; }, /** * Returns true if the given preference is set to its default value. * * @param {string} name The name of the preference to check. */ isDefault: function isDefault(name) { return !this.branch.prefHasUserValue(name); }, _checkSafe: function _checkSafe(name, message, value) { let curval = this.get(name, null); if (this.branches.original.get(name) == null && !this.branches.saved.has(name)) this.branches.original.set(name, curval, true); if (arguments.length > 2 && curval === value) return; let defval = this.defaults.get(name, null); let saved = this.branches.saved.get(name); if (saved == null && curval != defval || saved != null && curval != saved) { let msg = _("pref.safeSet.warnChanged", name); if (message) msg = template.linkifyHelp(msg + " " + message); util.dactyl.warn(msg); } }, /** * Resets the preference *name* to *value* but warns the user if the value * is changed from its default. * * @param {string} name The preference name. * @param {value} value The new preference value. * @param {boolean} silent Ignore errors. */ safeReset: function safeReset(name, message, silent) { this._checkSafe(name, message); this.set(name, this.branches.original.get(name), silent); this.branches.original.reset(name); this.branches.saved.reset(name); }, /** * Sets the preference *name* to *value* but warns the user if the value is * changed from its default. * * @param {string} name The preference name. * @param {value} value The new preference value. */ safeSet: function safeSet(name, value, message, skipSave) { this._checkSafe(name, message, value); this.set(name, value); this.branches.saved[skipSave ? "reset" : "set"](name, value); }, /** * Sets the preference *name* to *value*. If the preference already * exists, it must have the same type as the given value. * * @param {name} name The name of the preference to change. * @param {string|number|boolean} value The value to set. * @param {boolean} silent Ignore errors. */ set: function set(name, value, silent) { if (this._prefContexts.length) this._prefContexts[this._prefContexts.length - 1][name] = this.get(name, null); function assertType(needType) { return util.assert(type === Ci.nsIPrefBranch.PREF_INVALID || type === needType, type === Ci.nsIPrefBranch.PREF_INT ? /*L*/"E521: Number required after =: " + name + "=" + value : /*L*/"E474: Invalid argument: " + name + "=" + value); } let type = this.branch.getPrefType(name); try { switch (typeof value) { case "string": assertType(Ci.nsIPrefBranch.PREF_STRING); this.branch.setComplexValue(name, Ci.nsISupportsString, services.String(value)); break; case "number": assertType(Ci.nsIPrefBranch.PREF_INT); this.branch.setIntPref(name, value); break; case "boolean": assertType(Ci.nsIPrefBranch.PREF_BOOL); this.branch.setBoolPref(name, value); break; default: if (value == null && this != this.defaults) this.reset(name); else throw FailedAssertion("Unknown preference type: " + typeof value + " (" + name + "=" + value + ")"); } } catch (e if silent) {} return value; }, /** * Saves the current value of a preference to be restored at next * startup. * * @param {string} name The preference to save. */ save: function save(name) { let val = this.get(name); this.set(this.RESTORE + name, val); this.safeSet(name, val); }, /** * Restores saved preferences in the given branch. * * @param {string} branch The branch from which to restore * preferences. @optional */ restore: function restore(branch) { this.getNames(this.RESTORE + (branch || "")).forEach(function (pref) { this.safeSet(pref.substr(this.RESTORE.length), this.get(pref), null, true); this.reset(pref); }, this); }, /** * Resets the preference *name* to its default value. * * @param {string} name The name of the preference to reset. */ reset: function reset(name) { if (this.branch.prefHasUserValue(name)) this.branch.clearUserPref(name); }, /** * Resets the preference branch *branch* to its default value. * * @param {string} branch The preference name. @optional */ resetBranch: function resetBranch(branch) { this.getNames(branch).forEach(this.bound.reset); }, /** * Toggles the value of the boolean preference *name*. * * @param {string} name The preference name. */ toggle: function toggle(name) { util.assert(this.branch.getPrefType(name) === Ci.nsIPrefBranch.PREF_BOOL, _("error.trailingCharacters", name + "!")); this.set(name, !this.get(name)); }, /** * Pushes a new preference context onto the context stack. * * @see #withContext */ pushContext: function pushContext() { this._prefContexts.push({}); }, /** * Pops the top preference context from the stack. * * @see #withContext */ popContext: function popContext() { for (let [k, v] of iter(this._prefContexts.pop())) this.set(k, v); }, /** * Executes *func* with a new preference context. When *func* returns, the * context is popped and any preferences set via {@link #setPref} or * {@link #invertPref} are restored to their previous values. * * @param {function} func The function to call. * @param {Object} func The 'this' object with which to call *func* * @see #pushContext * @see #popContext */ withContext: function withContext(func, self) { try { this.pushContext(); return func.call(self); } finally { this.popContext(); } }, observe: null, observers: { "nsPref:changed": function (subject, data) { let observers = this._observers[data]; if (observers) { let value = this.get(data, false); this._observers[data] = observers.filter(function (callback) { callback = callback.get(); if (!callback) return false; util.trapErrors(callback, null, value); return true; }); } } }, /** * Adds a new preference observer for the given preference. * * @param {string} pref The preference to observe. * @param {function(object)} callback The callback, called with the * new value of the preference whenever it changes. */ watch: function watch(pref, callback, strong) { if (!this.observe) { util.addObserver(this); this.branch.addObserver("", this, false); } if (!this._observers[pref]) this._observers[pref] = []; this._observers[pref].push(!strong ? util.weakReference(callback) : { get: function () { return callback; } }); }, /** * Lists all preferences matching *filter* or only those with changed * values if *onlyNonDefault* is specified. * * @param {boolean} onlyNonDefault Limit the list to prefs with a * non-default value. * @param {string} filter The list filter. A null filter lists all * prefs. * @optional */ list: function list(onlyNonDefault, filter) { if (!filter) filter = ""; let prefArray = this.getNames(); prefArray.sort(); function* prefs() { for (let pref of prefArray) { let userValue = services.pref.prefHasUserValue(pref); if (onlyNonDefault && !userValue || !pref.includes(filter)) continue; let value = this.get(pref); let option = { isDefault: !userValue, default: this.defaults.get(pref, null), value: ["", "=", template.highlight(value, true, 100)], name: pref, pre: "\u00a0\u00a0" // Unicode nonbreaking space. }; yield option; } } return template.options(_("pref.hostPreferences", config.host), prefs.call(this)); } }, { }, { completion: function init_completion(dactyl, modules) { modules.completion.preference = function preference(context) { context.anchored = false; context.title = [config.host + " Preference", "Value"]; context.keys = { text: function (item) { return item; }, description: function (item) { return prefs.get(item); } }; context.completions = prefs.getNames(); }; }, javascript: function init_javascript(dactyl, modules) { const { setCompleter } = modules.JavaScript; setCompleter([this.get, this.safeSet, this.set, this.reset, this.toggle], [function (context) { context.anchored=false; return this.getNames().map(pref => [pref, ""]); }]); } }); var localPrefs = Prefs("extensions.dactyl."); defineModule.modules.push(localPrefs); endModule(); } catch(e){ if (!e.stack) e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); } // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/promises.jsm000066400000000000000000000112141264147376100213610ustar00rootroot00000000000000// Copyright (c) 2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; defineModule("promises", { exports: ["CancelablePromise", "Promise", "Task", "promises"], require: [] }); lazyRequire("services", ["services"]); lazyRequire("resource://gre/modules/Promise.jsm", ["Promise"]); lazyRequire("resource://gre/modules/Task.jsm", ["Task"]); function withCallbacks(fn) { return function wrapper(...args) { let deferred = Promise.defer(); function resolve(arg) { deferred.resolve(arg); } function reject(arg) { deferred.reject(arg); } fn.apply(this, [[resolve, reject, deferred]].concat(args)); return deferred.promise; }; } function CancelablePromise(executor, oncancel) { let deferred = Promise.defer(); let canceled = new Promise((accept, reject) => { promises.oncancel(deferred, accept); }); try { executor(deferred.resolve, deferred.reject, canceled); } catch (e) { deferred.reject(e); } return Object.freeze(Object.create(deferred.promise, { cancel: { value: thing => promises.cancel(deferred.promise, thing) } })); } var Promises = Module("Promises", { _cancel: new WeakMap, /** * Allows promises to be canceled. * * @param {Promise} promise The promise to cancel. * @param {*} arg Argument to be passed to the cancellation * function. */ cancel: function cancel(promise, reason) { let cleanup = this._cancel.get(promise); if (cleanup) { cleanup[0](promise); cleanup[1](reason); } this._cancel.delete(promise); }, /** * Registers a cleanup function for the given deferred promise. * * @param {Deferred} promise The promise to cancel. * @param {function} fn The cleanup function. */ oncancel: function oncancel(deferred, fn) { this._cancel.set(deferred.promise, [fn, deferred.reject]); }, /** * Returns a promise which resolves after a brief delay. */ delay: function delay([accept]) { return new Promise(resolve => { let { mainThread } = services.threading; mainThread.dispatch(resolve, mainThread.DISPATCH_NORMAL); }); }, /** * Returns true if the passed object is a promise. */ isPromise: function isPromise(obj) { return isObject(obj) && typeof obj.then === "function"; }, /** * Returns a promise which resolves after the given number of * milliseconds. * * @param {number} delay The number of milliseconds to wait. */ sleep: function sleep(delay) { return new Promise(resolve => { this.timeout(resolve, delay); }); }, /** * Wraps the given function so that each call spawns a Task. * * @param {function} fn The function to wrap. * @returns {function} */ task: function task(fn) { return function task_(...args) { return Task.spawn(fn.bind.apply(fn, [this].concat(args))); }; }, /** * Returns a promise which resolves when the function *test* returns * true, or *timeout* milliseconds have expired. * * @param {function} test The predicate on which to wait. * @param {Number} timeout The maximum number of milliseconds to * wait. * @optional * @param {number} pollInterval The poll interval, in milliseconds. * @default 10 */ waitFor: function waitFor(test, timeout=null, pollInterval=10) { return new Promise((resolve, reject) => { let end = timeout && Date.now() + timeout, result; let timer = services.Timer( () => { try { var result = test(); } catch (e) { timer.cancel(); reject(e); } if (result) { timer.cancel(); resolve(result); } }, pollInterval, services.Timer.TYPE_REPEATING_SLACK); }); }, /** * Wraps the given function so that its first argument is an array * of success and failure callbacks which, when called, resolve the * returned promise. * * @param {function} fn The function to wrap. * @returns {Promise} */ withCallbacks: withCallbacks }); endModule(); // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/protocol.jsm000066400000000000000000000200271264147376100213630ustar00rootroot00000000000000// Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; defineModule("protocol", { exports: ["LocaleChannel", "Protocol", "RedirectChannel", "StringChannel", "XMLChannel"], require: ["services", "util"] }); var systemPrincipal = Cc["@mozilla.org/systemprincipal;1"].getService(Ci.nsIPrincipal); function Channel(url, orig, noErrorChannel, unprivileged) { try { if (url == null) return noErrorChannel ? null : NetError(orig); if (url instanceof Ci.nsIChannel) return url; if (typeof url === "function") { let [type, data] = url(orig); return StringChannel(data, type, orig); } if (isArray(url)) { let [type, data] = url; return StringChannel(data, type, orig); } let uri = services.io.newURI(url, null, null); return (new XMLChannel(uri, null, noErrorChannel)).channel; } catch (e) { util.reportError(e); util.dump(url); throw e; } } function NetError(orig, error) { return services.InterfacePointer({ QueryInterface: XPCOMUtils.generateQI([Ci.nsIChannel]), name: orig.spec, URI: orig, originalURI: orig, asyncOpen: function () { throw error || Cr.NS_ERROR_FILE_NOT_FOUND; }, open: function () { throw error || Cr.NS_ERROR_FILE_NOT_FOUND; } }).data.QueryInterface(Ci.nsIChannel); } function RedirectChannel(to, orig, time, message) { let html = DOM.toXML( ["html", {}, ["head", {}, ["meta", { "http-equiv": "Refresh", content: (time || 0) + ";" + to }]], ["body", {}, ["h2", { style: "text-align: center" }, message || ""]]]); return StringChannel(html, "text/html", services.io.newURI(to, null, null)); } function Protocol(scheme, classID, contentBase) { function Protocol() { ProtocolBase.call(this); } Protocol.prototype = { __proto__: ProtocolBase.prototype, classID: Components.ID(classID), scheme: scheme, contentBase: contentBase, _xpcom_factory: JSMLoader.Factory(Protocol) }; return Protocol; } function ProtocolBase() { this.wrappedJSObject = this; this.pages = {}; this.providers = { __proto__: null, "content": function (uri, path) { return this.pages[path] || this.contentBase + path; }, "data": function (uri) { var channel = services.io.newChannel(uri.path.replace(/^\/(.*)(?:#.*)?/, "data:$1"), null, null); channel.contentCharset = "UTF-8"; channel.owner = systemPrincipal; channel.originalURI = uri; return channel; }, }; } ProtocolBase.prototype = { get contractID() { return services.PROTOCOL + this.scheme; }, get classDescription() { return this.scheme + " utility protocol"; }, QueryInterface: XPCOMUtils.generateQI([Ci.nsIProtocolHandler]), purge: function purge() { for (let doc of util.iterDocuments()) try { if (doc.documentURIObject.scheme == this.scheme) doc.defaultView.close(); } catch (e) { util.reportError(e); } }, defaultPort: -1, allowPort: function (port, scheme) { return false; }, protocolFlags: 0 | Ci.nsIProtocolHandler.URI_IS_UI_RESOURCE | Ci.nsIProtocolHandler.URI_IS_LOCAL_RESOURCE, newURI: function newURI(spec, charset, baseURI) { if (baseURI && (!(baseURI instanceof Ci.nsIURL) || baseURI.host === "data")) baseURI = null; return services.URL(services.URL.URLTYPE_AUTHORITY, this.defaultPort, spec, charset, baseURI); }, newChannel: function newChannel(uri) { try { uri.QueryInterface(Ci.nsIURL); let path = decodeURIComponent(uri.filePath.substr(1)); if (uri.host in this.providers) return Channel(this.providers[uri.host].call(this, uri, path), uri); return NetError(uri); } catch (e) { util.reportError(e); throw e; } } }; function LocaleChannel(pkg, locale, path, orig) { for (let locale of [locale, "en-US"]) for (let sep of "-/") { var channel = Channel(["resource:/", pkg + sep + locale, path].join("/"), orig, true, true); if (channel) return channel; } return NetError(orig); } function StringChannel(data, contentType, uri) { let channel = services.StreamChannel(uri); channel.contentStream = services.CharsetConv("UTF-8").convertToInputStream(data); if (contentType) channel.contentType = contentType; channel.contentCharset = "UTF-8"; channel.owner = systemPrincipal; if (uri) channel.originalURI = uri; return channel; } function XMLChannel(uri, contentType, noErrorChannel, unprivileged) { try { var channel = services.io.newChannelFromURI(uri); var channelStream = channel.open(); } catch (e) { this.channel = noErrorChannel ? null : NetError(uri); return; } this.uri = uri; this.sourceChannel = services.io.newChannelFromURI(uri); this.pipe = services.Pipe(true, true, 0, 0, null); this.writes = []; this.channel = services.StreamChannel(uri); this.channel.contentStream = this.pipe.inputStream; this.channel.contentType = contentType || channel.contentType; this.channel.contentCharset = "UTF-8"; if (!unprivileged) this.channel.owner = systemPrincipal; let type = this.channel.contentType; if (/^text\/|[\/+]xml$/.test(type)) { let stream = services.InputStream(channelStream); let [, pre, doctype, url, extra, open, post] = util.regexp(String.raw` ^ ([^]*?) (?: (\s]|\s[^[])*)) (\s+ \[)? ([^]*) )? $ `, "x").exec(stream.read(4096)); this.writes.push(pre); if (doctype) { this.writes.push(doctype + (extra || "") + " [\n"); if (url) this.addChannel(url); if (!open) this.writes.push("\n]"); for (let [, pre, url] of util.regexp.iterate(/([^]*?)(?:%include\s+"([^"]*)";|$)/gy, post)) { this.writes.push(pre); if (url) this.addChannel(url); } } } this.writes.push(channelStream); this.writeNext(); } XMLChannel.prototype = { QueryInterface: XPCOMUtils.generateQI([Ci.nsIRequestObserver]), addChannel: function addChannel(url) { try { this.writes.push(services.io.newChannel(url, null, this.uri).open()); } catch (e) { util.dump("addChannel('" + url + "'):"); util.reportError(e); } }, writeNext: function () { try { if (!this.writes.length) this.pipe.outputStream.close(); else { let stream = this.writes.shift(); if (isString(stream)) stream = services.StringStream(stream); services.StreamCopier(stream, this.pipe.outputStream, null, false, true, 4096, true, false) .asyncCopy(this, null); } } catch (e) { util.reportError(e); } }, onStartRequest: function (request, context) {}, onStopRequest: function (request, context, statusCode) { this.writeNext(); } }; endModule(); // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/sanitizer.jsm000066400000000000000000001015461264147376100215400ustar00rootroot00000000000000// Copyright (c) 2009 by Doug Kearns // Copyright (c) 2009-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; // TODO: // - fix Sanitize autocommand // - add warning for TIMESPAN_EVERYTHING? // FIXME: // - finish 1.9.0 support if we're going to support sanitizing in Melodactyl defineModule("sanitizer", { exports: ["Range", "Sanitizer", "sanitizer"], require: ["config", "prefs", "services", "util"] }); lazyRequire("messages", ["_"]); lazyRequire("overlay", ["overlay"]); lazyRequire("storage", ["storage"]); lazyRequire("template", ["template"]); let tmp = Object.create(this); JSMLoader.loadSubScript("chrome://browser/content/sanitize.js", tmp); tmp.Sanitizer.prototype.__proto__ = Class.prototype; var Range = Struct("min", "max"); update(Range.prototype, { contains: function (date) { if (date != null) return ((this.min == null || date >= this.min) && (this.max == null || date <= this.max)); return false; }, get isEternity() { return this.max == null && this.min == null; }, get isSession() { return this.max == null && this.min == sanitizer.sessionStart; }, get native() { return this.isEternity ? null : [this.min || 0, this.max == null ? Number.MAX_VALUE : this.max]; } }); var Item = Class("SanitizeItem", { init: function (name, params) { this.name = name; this.description = params.description; }, // Hack for completion: "0": Class.Property({ get: function () { return this.name; } }), "1": Class.Property({ get: function () { return this.description; } }), description: Messages.Localized(""), get cpdPref() { return (this.builtin ? "" : Item.PREFIX) + Item.BRANCH + Sanitizer.argToPref(this.name); }, get shutdownPref() { return (this.builtin ? "" : Item.PREFIX) + Item.SHUTDOWN_BRANCH + Sanitizer.argToPref(this.name); }, get cpd() { return prefs.get(this.cpdPref); }, get shutdown() { return prefs.get(this.shutdownPref); }, shouldSanitize: function (shutdown) { return (!shutdown || this.builtin || this.persistent) && prefs.get(shutdown ? this.shutdownPref : this.pref); } }, { PREFIX: config.prefs.branch.root, BRANCH: "privacy.cpd.", SHUTDOWN_BRANCH: "privacy.clearOnShutdown." }); var Sanitizer = Module("sanitizer", XPCOM([Ci.nsIObserver, Ci.nsISupportsWeakReference], tmp.Sanitizer), { sessionStart: Date.now() * 1000, init: function () { const self = this; util.addObserver(this); services.add("cookies", "@mozilla.org/cookiemanager;1", [Ci.nsICookieManager, Ci.nsICookieManager2, Ci.nsICookieService]); services.add("loginManager", "@mozilla.org/login-manager;1", Ci.nsILoginManager); services.add("permissions", "@mozilla.org/permissionmanager;1", Ci.nsIPermissionManager); this.itemMap = {}; this.addItem("all", { description: "Sanitize all items", shouldSanitize: function () { return false; } }); // Builtin items this.addItem("cache", { builtin: true, description: "Cache" }); this.addItem("downloads", { builtin: true, description: "Download history" }); this.addItem("formdata", { builtin: true, description: "Saved form and search history" }); this.addItem("offlineapps", { builtin: true, description: "Offline website data" }); this.addItem("passwords", { builtin: true, description: "Saved passwords" }); this.addItem("sessions", { builtin: true, description: "Authenticated sessions" }); // These builtin methods don't support hosts or otherwise have // insufficient granularity this.addItem("cookies", { builtin: true, description: "Cookies", persistent: true, action: function (range, host) { for (let c of Sanitizer.iterCookies(host)) if (range.contains(c.creationTime) || timespan.isSession && c.isSession) services.cookies.remove(c.host, c.name, c.path, false); }, override: true }); this.addItem("history", { builtin: true, description: "Browsing history", persistent: true, sessionHistory: true, action: function (range, host) { if (host) services.history.removePagesFromHost(host, true); else { if (range.isEternity) services.history.removeAllPages(); else services.history.removeVisitsByTimeframe(range.native[0], Math.min(Date.now() * 1000, range.native[1])); // XXX services.observer.notifyObservers(null, "browser:purge-session-history", ""); } if (!host || util.isDomainURL(prefs.get("general.open_location.last_url"), host)) prefs.reset("general.open_location.last_url"); }, override: true }); try { var { ForgetAboutSite } = Cu.import("resource://gre/modules/ForgetAboutSite.jsm", {}); } catch (e) {} if (ForgetAboutSite) this.addItem("host", { description: "All data from the given host", action: function (range, host) { if (host) ForgetAboutSite.removeDataFromDomain(host); } }); this.addItem("sitesettings", { builtin: true, description: "Site preferences", persistent: true, action: function (range, host) { if (range.isSession) return; if (host) { for (let p of Sanitizer.iterPermissions(host)) { let uri = util.createURI(p); services.permissions.remove(uri, p.type); services.permissions.add(uri, p.type, 0); } for (let p of iter(services.contentPrefs.getPrefs(util.createURI(host)))) services.contentPrefs.removePref(util.createURI(host), p.QueryInterface(Ci.nsIProperty).name); } else { // "Allow this site to open popups" ... services.permissions.removeAll(); // Zoom level, ... services.contentPrefs.removeAllDomains(null); } // "Never remember passwords" ... for (let domain of services.loginManager.getAllDisabledHosts()) if (!host || util.isSubdomain(domain, host)) services.loginManager.setLoginSavingEnabled(host, true); }, override: true }); function ourItems(persistent) { return Object.values(self.itemMap) .filter(item => (!item.builtin && (!persistent || item.persistent) && item.name !== "all")); } function prefOverlay(branch, persistent, local) { return update(Object.create(local), { before: [ ["preferences", { id: branch.substr(Item.PREFIX.length) + "history", xmlns: "xul" }, template.map(ourItems(persistent), item => ["preference", { type: "bool", id: branch + item.name, name: branch + item.name }])] ], init: function init(win) { let pane = win.document.getElementById("SanitizeDialogPane"); for (let pref of pane.preferences) pref.updateElements(); init.superapply(this, arguments); } }); } util.timeout(function () { // Load order issue... { let branch = Item.PREFIX + Item.SHUTDOWN_BRANCH; overlay.overlayWindow("chrome://browser/content/preferences/sanitize.xul", win => { let items = ourItems(true); return prefOverlay(branch, true, { append: { SanitizeDialogPane: ["groupbox", { orient: "horizontal", xmlns: "xul" }, ["caption", { label: config.appName + /*L*/" (see :help privacy)" }], ["grid", { flex: "1" }, ["columns", {}, ["column", { flex: "1" }], ["column", { flex: "1" }]], ["rows", {}, template.map(util.range(0, Math.ceil(items.length / 2)), i => ["row", {}, template.map(items.slice(i * 2, i * 2 + 2), item => ["checkbox", { xmlns: XUL, label: item.description, preference: branch + item.name }])])]]] } }); }); } { let branch = Item.PREFIX + Item.BRANCH; overlay.overlayWindow("chrome://browser/content/sanitize.xul", function (win) { return prefOverlay(branch, false, { append: { itemList: [ ["listitem", { xmlns: "xul", label: /*L*/"See :help privacy for the following:", disabled: "true", style: "font-style: italic; font-weight: bold;" }], template.map(ourItems(), ([item, desc]) => ["listitem", { xmlns: "xul", preference: branch + item, type: "checkbox", label: config.appName + ", " + desc, onsyncfrompreference: "return gSanitizePromptDialog.onReadGeneric();" }]) ] }, ready: function ready(win) { let elem = win.document.getElementById("itemList"); elem.setAttribute("rows", elem.itemCount); win.Sanitizer = Class("Sanitizer", win.Sanitizer, { sanitize: function sanitize() { self.withSavedValues(["sanitizing"], () => { self.sanitizing = true; sanitize.superapply(this, arguments); sanitizer.sanitizeItems( Object.values(self.itemMap) .filter(item => item.shouldSanitize(false)) .map(item => item.name), Range.fromArray(this.range || [])); }); } }); } }); }); } }); }, firstRun: 0, addItem: function addItem(name, params) { let item = this.itemMap[name] || Item(name, params); this.itemMap[name] = item; for (let [k, prop] of iterOwnProperties(params)) if (!("value" in prop) || !callable(prop.value) && !(k in item)) Object.defineProperty(item, k, prop); function getWindow(obj) { obj = Class.objectGlobal(obj); return obj.window || obj; } let names = new RealSet([name].concat(params.contains || []).map(e => "clear-" + e)); if (params.action) storage.addObserver("sanitizer", function (key, event, arg) { if (names.has(event)) apply(params, "action", arg); }, getWindow(params.action)); }, observers: { "browser:purge-domain-data": function (subject, host) { storage.fireEvent("sanitize", "domain", host); // If we're sanitizing, our own sanitization functions will already // be called, and with much greater granularity. Only process this // event if it's triggered externally. if (!this.sanitizing) this.sanitizeItems(null, Range(), data); }, "browser:purge-session-history": function (subject, data) { // See above. if (!this.sanitizing) this.sanitizeItems(null, Range(this.sessionStart), null, "sessionHistory"); }, "quit-application-granted": function (subject, data) { if (this.runAtShutdown && !this.sanitizeItems(null, Range(), null, "shutdown")) this.ranAtShutdown = true; } }, /** * Returns a load context for the given thing, to be used with * interfaces needing one for per-window private browsing support. * * @param {Window|Document|Node} thing The thing for which to return * a load context. */ getContext: function getContext(thing, global = null) { if (!Ci.nsILoadContext) return null; if (Cu.isCrossProcessWrapper(thing) && global) thing = global; if (thing instanceof Ci.nsIDOMNode && thing.ownerDocument) thing = thing.ownerDocument; if (thing instanceof Ci.nsIDOMDocument) thing = thing.defaultView; if (thing instanceof Ci.nsIInterfaceRequestor) thing = thing.getInterface(Ci.nsIWebNavigation); return thing.QueryInterface(Ci.nsILoadContext); }, get ranAtShutdown() { return config.prefs.get("didSanitizeOnShutdown"); }, set ranAtShutdown(val) { config.prefs.set("didSanitizeOnShutdown", Boolean(val)); }, get runAtShutdown() { return prefs.get("privacy.sanitize.sanitizeOnShutdown"); }, set runAtShutdown(val) { prefs.set("privacy.sanitize.sanitizeOnShutdown", Boolean(val)); }, sanitize: function sanitize(items, range) { return this.withSavedValues(["sanitizing"], function () { this.sanitizing = true; let errors = this.sanitizeItems(items, range, null); for (let itemName of values(items)) { try { let item = this.items[Sanitizer.argToPref(itemName)]; if (item && !this.itemMap[itemName].override) { item.range = range.native; if ("clear" in item && item.canClear) item.clear(); } } catch (e) { errors = errors || {}; errors[itemName] = e; util.dump("Error sanitizing " + itemName); util.reportError(e); } } return errors; }); }, sanitizeItems: function sanitizeItems(items, range, host, key) { return this.withSavedValues(["sanitizing"], function () { this.sanitizing = true; if (items == null) items = Object.keys(this.itemMap); let errors; for (let itemName of values(items)) try { if (!key || this.itemMap[itemName][key]) storage.fireEvent("sanitizer", "clear-" + itemName, [range, host]); } catch (e) { errors = errors || {}; errors[itemName] = e; util.dump("Error sanitizing " + itemName); util.reportError(e); } return errors; }); } }, { PERMS: { unset: 0, allow: 1, deny: 2, session: 8 }, UNPERMS: Class.Memoize(function () { return iter(this.PERMS).map(Array.reverse).toObject(); }), COMMANDS: { "unset": /*L*/"Unset", "allow": /*L*/"Allowed", "deny": /*L*/"Denied", "session": /*L*/"Allowed for the current session", "list": /*L*/"List all cookies for domain", "clear": /*L*/"Clear all cookies for domain", "clear-persistent": /*L*/"Clear all persistent cookies for domain", "clear-session": /*L*/"Clear all session cookies for domain" }, argPrefMap: { offlineapps: "offlineApps", sitesettings: "siteSettings" }, argToPref: function (arg) { return Sanitizer.argPrefMap[arg] || arg; }, prefToArg: function (pref) { return pref.replace(/.*\./, "").toLowerCase(); }, iterCookies: function* iterCookies(host) { for (let c of iter(services.cookies, Ci.nsICookie2)) if (!host || util.isSubdomain(c.rawHost, host) || c.host[0] == "." && c.host.length < host.length && host.endsWith(c.host)) yield c; }, iterPermissions: function* iterPermissions(host) { for (let p of iter(services.permissions, Ci.nsIPermission)) if (!host || util.isSubdomain(p.host, host)) yield p; } }, { load: function initLoad(dactyl, modules, window) { if (!sanitizer.firstRun++ && sanitizer.runAtShutdown && !sanitizer.ranAtShutdown) sanitizer.sanitizeItems(null, Range(), null, "shutdown"); sanitizer.ranAtShutdown = false; }, autocommands: function initAutocommands(dactyl, modules, window) { const { autocommands } = modules; storage.addObserver("sanitizer", function (key, event, value) { if (event == "domain") autocommands.trigger("SanitizeDomain", { domain: value }); else if (!value[1]) autocommands.trigger("Sanitize", { name: event.substr("clear-".length), domain: value[1] }); }, window); }, commands: function initCommands(dactyl, modules, window) { const { commands } = modules; commands.add(["sa[nitize]"], "Clear private data", function (args) { if (args["-host"] && !args.length && !args.bang) args[0] = "all"; let timespan = args["-timespan"] || modules.options["sanitizetimespan"]; let range = Range(); let [match, num, unit] = /^(\d+)([mhdw])$/.exec(timespan) || []; range[args["-older"] ? "max" : "min"] = match ? 1000 * (Date.now() - 1000 * parseInt(num, 10) * { m: 60, h: 3600, d: 3600 * 24, w: 3600 * 24 * 7 }[unit]) : (timespan[0] == "s" ? sanitizer.sessionStart : null); let opt = modules.options.get("sanitizeitems"); if (args.bang) dactyl.assert(args.length == 0, _("error.trailingCharacters")); else { dactyl.assert(args.length, _("error.argumentRequired")); dactyl.assert(opt.validator(args), _("error.invalidArgument")); opt = { __proto__: opt, value: args.slice() }; } let items = Object.keys(sanitizer.itemMap) .slice(1) .filter(opt.has, opt); function sanitize(items) { sanitizer.range = range.native; sanitizer.ignoreTimespan = range.min == null; sanitizer.sanitizing = true; if (args["-host"]) { args["-host"].forEach(function (host) { sanitizer.sanitizing = true; sanitizer.sanitizeItems(items, range, host); }); } else sanitizer.sanitize(items, range); } if ("all" == opt.value.find(i => (i == "all" || /^!/.test(i))) && !args["-host"]) modules.commandline.input(_("sanitize.prompt.deleteAll") + " ", resp => { if (resp.match(/^y(es)?$/i)) { sanitize(items); dactyl.echomsg(_("command.sanitize.allDeleted")); } else dactyl.echo(_("command.sanitize.noneDeleted")); }); else sanitize(items); }, { argCount: "*", // FIXME: should be + and 0 bang: true, completer: function (context) { context.title = ["Privacy Item", "Description"]; context.completions = modules.options.get("sanitizeitems").values; }, domains: function (args) { return args["-host"] || []; }, options: [ { names: ["-host", "-h"], description: "Only sanitize items referring to listed host or hosts", completer: function (context, args) { context.filters.push(item => !args["-host"].some(host => util.isSubdomain(item.text, host))); modules.completion.domain(context); }, type: modules.CommandOption.LIST }, { names: ["-older", "-o"], description: "Sanitize items older than timespan", type: modules.CommandOption.NOARG }, { names: ["-timespan", "-t"], description: "Timespan for which to sanitize items", completer: function (context) { modules.options.get("sanitizetimespan").completer(context); }, type: modules.CommandOption.STRING, validator: function (arg) { return modules.options.get("sanitizetimespan").validator(arg); } } ], privateData: true }); function getPerms(host) { let uri = util.createURI(host); if (uri) return Sanitizer.UNPERMS[services.permissions.testPermission(uri, "cookie")]; return "unset"; } function setPerms(host, perm) { let uri = util.createURI(host); services.permissions.remove(uri, "cookie"); services.permissions.add(uri, "cookie", Sanitizer.PERMS[perm]); } commands.add(["cookies", "ck"], "Change cookie permissions for sites", function (args) { let host = args.shift(); let session = true; if (!args.length) args = modules.options["cookies"]; for (let cmd of args) switch (cmd) { case "clear": for (let c of Sanitizer.iterCookies(host)) services.cookies.remove(c.host, c.name, c.path, false); break; case "clear-persistent": session = false; case "clear-session": for (let c of Sanitizer.iterCookies(host)) if (c.isSession == session) services.cookies.remove(c.host, c.name, c.path, false); return; case "list": modules.commandline.commandOutput(template.tabular( ["Host", "Expiry (UTC)", "Path", "Name", "Value"], ["padding-right: 1em", "padding-right: 1em", "padding-right: 1em", "max-width: 12em; overflow: hidden;", "padding-left: 1ex;"], Array.from(Sanitizer.iterCookies(host), c => [ c.host, c.isSession ? ["span", { highlight: "Enabled" }, "session"] : (new Date(c.expiry * 1000).toJSON() || "Never").replace(/:\d\d\.000Z/, "").replace("T", " ").replace(/-/g, "/"), c.path, c.name, c.value, ]))); return; default: util.assert(cmd in Sanitizer.PERMS, _("error.invalidArgument")); setPerms(host, cmd); } }, { argCount: "+", completer: function (context, args) { switch (args.completeArg) { case 0: modules.completion.visibleHosts(context); context.title[1] = "Current Permissions"; context.keys.description = function desc(host) { let count = [0, 0]; for (let c of Sanitizer.iterCookies(host)) count[c.isSession + 0]++; return [Sanitizer.COMMANDS[getPerms(host)], " (session: ", count[1], " persistent: ", count[0], ")"].join(""); }; break; case 1: context.completions = Sanitizer.COMMANDS; break; } } }); }, completion: function initCompletion(dactyl, modules, window) { modules.completion.visibleHosts = function completeHosts(context) { let res = util.visibleHosts(window.content); if (context.filter && !res.some(host => host.includes(context.filter))) res.push(context.filter); context.title = ["Domain"]; context.anchored = false; context.compare = modules.CompletionContext.Sort.unsorted; context.keys = { text: identity, description: identity }; context.completions = res; }; }, options: function initOptions(dactyl, modules) { const options = modules.options; options.add(["sanitizeitems", "si"], "The default list of private items to sanitize", "stringlist", "all", { get values() { return values(sanitizer.itemMap).toArray(); }, completer: function completer(context, extra) { if (context.filter[0] == "!") context.advance(1); return completer.superapply(this, arguments); }, has: function has(val) { let res = this.value.find(v => (v == "all" || v.replace(/^!/, "") == val)); return res && !/^!/.test(res); }, validator: function (values) { return values.length && values.every(val => (val === "all" || hasOwnProp(sanitizer.itemMap, val.replace(/^!/, "")))); } }); options.add(["sanitizeshutdown", "ss"], "The items to sanitize automatically at shutdown", "stringlist", "", { initialValue: true, get values() { return Object.values(sanitizer.itemMap) .filter(i => i.persistent || i.builtin); }, getter: function () { if (!sanitizer.runAtShutdown) return []; else return Object.values(sanitizer.itemMap) .filter(item => item.shouldSanitize(true)) .map(item => item.name); }, setter: function (value) { if (value.length === 0) sanitizer.runAtShutdown = false; else { sanitizer.runAtShutdown = true; let have = new RealSet(value); for (let item of values(sanitizer.itemMap)) prefs.set(item.shutdownPref, Boolean(have.has(item.name) ^ have.has("all"))); } return value; } }); options.add(["sanitizetimespan", "sts"], "The default sanitizer time span", "string", "all", { completer: function (context) { context.compare = context.constructor.Sort.Unsorted; context.completions = this.values; }, values: { "all": "Everything", "session": "The current session", "10m": "Last ten minutes", "1h": "Past hour", "1d": "Past day", "1w": "Past week" }, validator: bind("test", /^(a(ll)?|s(ession)|\d+[mhdw])$/) }); options.add(["cookies", "ck"], "The default mode for newly added cookie permissions", "stringlist", "session", { get values() { return Sanitizer.COMMANDS; }}); options.add(["cookieaccept", "ca"], "When to accept cookies", "string", "all", { PREF: "network.cookie.cookieBehavior", values: [ ["all", "Accept all cookies"], ["samesite", "Accept all non-third-party cookies"], ["none", "Accept no cookies"], ["visited", "Accept cookies from visited sites"] ], getter: function () { return (this.values[prefs.get(this.PREF)] || ["all"])[0]; }, setter: function (val) { prefs.set(this.PREF, this.values.map(i => i[0]).indexOf(val)); return val; }, initialValue: true, persist: false }); options.add(["cookielifetime", "cl"], "The lifetime for which to accept cookies", "string", "default", { PREF: "network.cookie.lifetimePolicy", PREF_DAYS: "network.cookie.lifetime.days", values: [ ["default", "The lifetime requested by the setter"], ["prompt", "Always prompt for a lifetime"], ["session", "The current session"] ], getter: function () { return (this.values[prefs.get(this.PREF)] || [prefs.get(this.PREF_DAYS)])[0]; }, setter: function (value) { let val = this.values.map(i => i[0]).indexOf(value); if (val > -1) prefs.set(this.PREF, val); else { prefs.set(this.PREF, 3); prefs.set(this.PREF_DAYS, parseInt(value)); } }, initialValue: true, persist: false, validator: function validator(val) { return parseInt(val) == val || validator.superapply(this, arguments); } }); } }); endModule(); // catch(e){dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack);} // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/services.jsm000066400000000000000000000340671264147376100213560ustar00rootroot00000000000000// Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; try { var global = this; defineModule("services", { exports: ["PrivateBrowsingUtils", "services"] }); try { var { PrivateBrowsingUtils } = Cu.import("resource://gre/modules/PrivateBrowsingUtils.jsm"); } catch (e) {} /** * A lazily-instantiated XPCOM class and service cache. */ var Services = Module("Services", { ABOUT: "@mozilla.org/network/protocol/about;1?what=", AUTOCOMPLETE: "@mozilla.org/autocomplete/search;1?name=", PROTOCOL: "@mozilla.org/network/protocol;1?name=", init: function () { this.services = {}; this.add("annotation", "@mozilla.org/browser/annotation-service;1", "nsIAnnotationService"); this.add("appShell", "@mozilla.org/appshell/appShellService;1", "nsIAppShellService"); this.add("appStartup", "@mozilla.org/toolkit/app-startup;1", "nsIAppStartup"); this.add("bookmarks", "@mozilla.org/browser/nav-bookmarks-service;1", "nsINavBookmarksService"); this.add("browserSearch", "@mozilla.org/browser/search-service;1", "nsIBrowserSearchService"); this.add("cache", "@mozilla.org/netwerk/cache-storage-service;1", "nsICacheStorageService"); this.add("chromeRegistry", "@mozilla.org/chrome/chrome-registry;1", "nsIXULChromeRegistry"); this.add("clipboard", "@mozilla.org/widget/clipboard;1", "nsIClipboard"); this.add("clipboardHelper", "@mozilla.org/widget/clipboardhelper;1", "nsIClipboardHelper"); this.add("commandLineHandler", "@mozilla.org/commandlinehandler/general-startup;1?type=dactyl"); this.add("console", "@mozilla.org/consoleservice;1", "nsIConsoleService"); this.add("contentPrefs", "@mozilla.org/content-pref/service;1", ["nsIContentPrefService", "nsIContentPrefService2"]); this.add("dactyl", "@dactyl.googlecode.com/extra/utils", "dactylIUtils"); this.add("dactyl:", this.PROTOCOL + "dactyl"); this.add("directory", "@mozilla.org/file/directory_service;1", "nsIProperties"); this.add("downloadManager", "@mozilla.org/download-manager;1", "nsIDownloadManager"); this.add("environment", "@mozilla.org/process/environment;1", "nsIEnvironment"); this.add("extensionManager", "@mozilla.org/extensions/manager;1", "nsIExtensionManager"); this.add("externalApp", "@mozilla.org/uriloader/external-helper-app-service;1", "nsPIExternalAppLauncher"); this.add("externalProtocol", "@mozilla.org/uriloader/external-protocol-service;1", "nsIExternalProtocolService"); this.add("favicon", "@mozilla.org/browser/favicon-service;1", "nsIFaviconService"); this.add("file:", this.PROTOCOL + "file", "nsIFileProtocolHandler"); this.add("focus", "@mozilla.org/focus-manager;1", "nsIFocusManager"); this.add("history", "@mozilla.org/browser/nav-history-service;1", ["nsIBrowserHistory", "nsINavHistoryService", "nsPIPlacesDatabase"]); this.add("io", "@mozilla.org/network/io-service;1", "nsIIOService"); this.add("json", "@mozilla.org/dom/json;1", "nsIJSON", "createInstance"); this.add("listeners", "@mozilla.org/eventlistenerservice;1", "nsIEventListenerService"); this.add("livemark", "@mozilla.org/browser/livemark-service;2", "nsILivemarkService"); this.add("messages", "@mozilla.org/globalmessagemanager;1", "nsIChromeFrameMessageManager"); this.add("mime", "@mozilla.org/mime;1", "nsIMIMEService"); this.add("observer", "@mozilla.org/observer-service;1", "nsIObserverService"); this.add("pref", "@mozilla.org/preferences-service;1", ["nsIPrefBranch2", "nsIPrefService"]); this.add("printSettings", "@mozilla.org/gfx/printsettings-service;1", "nsIPrintSettingsService"); this.add("profile", "@mozilla.org/toolkit/profile-service;1", "nsIToolkitProfileService"); this.add("resource:", this.PROTOCOL + "resource", ["nsIProtocolHandler", "nsIResProtocolHandler"]); this.add("runtime", "@mozilla.org/xre/runtime;1", ["nsIXULAppInfo", "nsIXULRuntime"]); this.add("rdf", "@mozilla.org/rdf/rdf-service;1", "nsIRDFService"); this.add("security", "@mozilla.org/scriptsecuritymanager;1", "nsIScriptSecurityManager"); this.add("sessionStore", "@mozilla.org/browser/sessionstore;1", "nsISessionStore"); this.add("spell", "@mozilla.org/spellchecker/engine;1", "mozISpellCheckingEngine"); this.add("stringBundle", "@mozilla.org/intl/stringbundle;1", "nsIStringBundleService"); this.add("stylesheet", "@mozilla.org/content/style-sheet-service;1", "nsIStyleSheetService"); this.add("subscriptLoader", "@mozilla.org/moz/jssubscript-loader;1", "mozIJSSubScriptLoader"); this.add("tagging", "@mozilla.org/browser/tagging-service;1", "nsITaggingService"); this.add("tld", "@mozilla.org/network/effective-tld-service;1", "nsIEffectiveTLDService"); this.add("threading", "@mozilla.org/thread-manager;1", "nsIThreadManager"); this.add("urifixup", "@mozilla.org/docshell/urifixup;1", "nsIURIFixup"); this.add("versionCompare", "@mozilla.org/xpcom/version-comparator;1", "nsIVersionComparator"); this.add("windowMediator", "@mozilla.org/appshell/window-mediator;1", "nsIWindowMediator"); this.add("windowWatcher", "@mozilla.org/embedcomp/window-watcher;1", "nsIWindowWatcher"); this.add("zipReader", "@mozilla.org/libjar/zip-reader-cache;1", "nsIZipReaderCache"); this.addClass("CharsetConv", "@mozilla.org/intl/scriptableunicodeconverter", "nsIScriptableUnicodeConverter", "charset"); this.addClass("CharsetStream","@mozilla.org/intl/converter-input-stream;1", ["nsIConverterInputStream", "nsIUnicharLineInputStream"], "init"); this.addClass("ConvOutStream","@mozilla.org/intl/converter-output-stream;1", "nsIConverterOutputStream", "init", false); this.addClass("File", "@mozilla.org/file/local;1", "nsILocalFile"); this.addClass("FileInStream", "@mozilla.org/network/file-input-stream;1", "nsIFileInputStream", "init", false); this.addClass("FileOutStream","@mozilla.org/network/file-output-stream;1", "nsIFileOutputStream", "init", false); this.addClass("Find", "@mozilla.org/embedcomp/rangefind;1", "nsIFind"); this.addClass("FormData", "@mozilla.org/files/formdata;1", "nsIDOMFormData"); this.addClass("HtmlConverter","@mozilla.org/widget/htmlformatconverter;1", "nsIFormatConverter"); this.addClass("HtmlEncoder", "@mozilla.org/layout/htmlCopyEncoder;1", "nsIDocumentEncoder"); this.addClass("InterfacePointer", "@mozilla.org/supports-interface-pointer;1", "nsISupportsInterfacePointer", "data"); this.addClass("InputStream", "@mozilla.org/scriptableinputstream;1", "nsIScriptableInputStream", "init"); this.addClass("MIMEStream", "@mozilla.org/network/mime-input-stream;1", "nsIMIMEInputStream", "setData"); this.addClass("Persist", "@mozilla.org/embedding/browser/nsWebBrowserPersist;1", "nsIWebBrowserPersist"); this.addClass("Pipe", "@mozilla.org/pipe;1", "nsIPipe", "init"); this.addClass("Process", "@mozilla.org/process/util;1", "nsIProcess", "init"); this.addClass("Pump", "@mozilla.org/network/input-stream-pump;1", "nsIInputStreamPump", "init"); this.addClass("StreamChannel","@mozilla.org/network/input-stream-channel;1", ["nsIInputStreamChannel", "nsIChannel"], "setURI"); this.addClass("StreamCopier", "@mozilla.org/network/async-stream-copier;1","nsIAsyncStreamCopier", "init"); this.addClass("String", "@mozilla.org/supports-string;1", "nsISupportsString", "data"); this.addClass("StringStream", "@mozilla.org/io/string-input-stream;1", "nsIStringInputStream", "data"); this.addClass("Transfer", "@mozilla.org/transfer;1", "nsITransfer", "init"); this.addClass("Transferable", "@mozilla.org/widget/transferable;1", "nsITransferable"); this.addClass("Timer", "@mozilla.org/timer;1", "nsITimer", "initWithCallback"); this.addClass("URL", "@mozilla.org/network/standard-url;1", ["nsIStandardURL", "nsIURL"], "init"); this.addClass("Xmlhttp", "@mozilla.org/xmlextras/xmlhttprequest;1", [], "open"); this.addClass("XPathEvaluator", "@mozilla.org/dom/xpath-evaluator;1", "nsIDOMXPathEvaluator"); this.addClass("XMLDocument", "@mozilla.org/xml/xml-document;1", "nsIDOMXMLDocument"); this.addClass("XMLSerializer","@mozilla.org/xmlextras/xmlserializer;1", ["nsIDOMSerializer"]); this.addClass("ZipReader", "@mozilla.org/libjar/zip-reader;1", "nsIZipReader", "open", false); this.addClass("ZipWriter", "@mozilla.org/zipwriter;1", "nsIZipWriter", "open", false); }, reinit: function () {}, _create: function _create(name, args) { try { var service = this.services[name]; let res = Cc[service.class][service.method || "getService"](); if (!service.interfaces.length) return res.wrappedJSObject || res; service.interfaces.forEach(iface => { res instanceof Ci[iface]; }); if (service.init && args.length) { if (service.callable) apply(res, service.init, args); else res[service.init] = args[0]; } return res; } catch (e) { if (service.quiet === false) throw e.stack ? e : Error(e); if (typeof util !== "undefined" && util != null) util.reportError(e); else dump("dactyl: Service creation failed for '" + service.class + "': " + e + "\n" + (e.stack || Error(e).stack)); return null; } }, /** * Adds a new XPCOM service to the cache. * * @param {string} name The service's cache key. * @param {string} class The class's contract ID. * @param {string|[string]} ifaces The interface or array of * interfaces implemented by this service. * @param {string} meth The name of the function used to instantiate * the service. */ add: function add(name, class_, ifaces, meth) { const self = this; this.services[name] = { method: meth, class: class_, interfaces: Array.concat(ifaces || []) }; if (name in this && ifaces && !this.__lookupGetter__(name) && !(this[name] instanceof Ci.nsISupports)) throw TypeError(); memoize(this, name, () => self._create(name)); }, /** * Adds a new XPCOM class to the cache. * * @param {string} name The class's cache key. * @param {string} class_ The class's contract ID. * @param {string|[string]} ifaces The interface or array of * interfaces implemented by this class. * @param {string} init Name of a property or method used to initialize the * class. */ addClass: function addClass(name, class_, ifaces, init = null, quiet = true) { this.services[name] = { class: class_, interfaces: Array.concat(ifaces || []), method: "createInstance", init: init, quiet: quiet }; if (init) memoize(this.services[name], "callable", function () { return callable(XPCOMShim(this.interfaces)[this.init]); }); this[name] = (...args) => this._create(name, args); update(this[name], ...Array.concat(ifaces).map(iface => Ci[iface])); return this[name]; }, /** * Returns a new instance of the cached class with the specified name. * * @param {string} name The class's cache key. */ create: deprecated("services.*name*()", function create(name) { return this[util.capitalize(name)](); }), /** * Returns the cached service with the specified name. * * @param {string} name The service's cache key. */ get: deprecated("services.*name*", function get(name) { return this[name]; }), /** * Returns true if the given service is available. * * @param {string} name The service's cache key. */ has: function has(name) { return hasOwnProp(this.services, name) && this.services[name].class in Cc && this.services[name].interfaces.every(iface => iface in Ci); } }); endModule(); } catch(e){dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack);} // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/storage.jsm000066400000000000000000000720001264147376100211640ustar00rootroot00000000000000// Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; defineModule("storage", { exports: ["AsyncFile", "File", "Storage", "storage"], require: ["promises", "services", "util"] }); lazyRequire("config", ["config"]); lazyRequire("io", ["IO"]); lazyRequire("overlay", ["overlay"]); lazyRequire("resource://gre/modules/osfile.jsm", ["OS"]); var win32 = /^win(32|nt)$/i.test(services.runtime.OS); var myObject = JSON.parse("{}").constructor; var global = Cu.getGlobalForObject(this); var StoreBase = Class("StoreBase", { OPTIONS: ["privateData", "replacer"], fireEvent: function (event, arg) { storage.fireEvent(this.name, event, arg); }, get serial() { return JSON.stringify(this._object, this.replacer); }, init: function init(name, store, load, options) { this._load = load; this._options = options; this.__defineGetter__("store", () => store); this.__defineGetter__("name", () => name); for (let [k, v] of iter(options)) if (this.OPTIONS.indexOf(k) >= 0) this[k] = v; this.reload(); }, clone: function clone(storage) { let store = storage.privateMode ? false : this.store; let res = this.constructor(this.name, store, this._load, this._options); res.storage = storage; return res; }, makeOwn: function makeOwn(val) { if (typeof val != "object") return val; if (Cu.getGlobalForObject(val) == global) return val; return JSON.parse(JSON.stringify(val, this.replacer)); }, changed: function () { this.timer && this.timer.tell(); }, reload: function reload() { this._object = this._load() || this._constructor(); this.fireEvent("change", null); }, delete: function delete_() { delete storage.keys[this.name]; delete storage[this.name]; return OS.File.remove( storage.infoPath.child(this.name).path); }, save: function () { (this.storage || storage)._saveData(this); }, "@@iterator": function () { return iter(this._object); }, }); var ArrayStore = Class("ArrayStore", StoreBase, { _constructor: Array, get length() { return this._object.length; }, set: function set(index, value, quiet) { var orig = this._object[index]; this._object[index] = this.makeOwn(value); if (!quiet) this.fireEvent("change", index); return orig; }, push: function push(value) { this._object.push(this.makeOwn(value)); this.fireEvent("push", this._object.length); }, pop: function pop(value, ord) { if (ord == null) var res = this._object.pop(); else res = this._object.splice(ord, 1)[0]; this.fireEvent("pop", this._object.length, ord); return res; }, shift: function shift(value) { var res = this._object.shift(); this.fireEvent("shift", this._object.length); return res; }, insert: function insert(value, ord) { value = this.makeOwn(value); if (ord == 0) this._object.unshift(value); else this._object = this._object.slice(0, ord) .concat([value]) .concat(this._object.slice(ord)); this.fireEvent("insert", this._object.length, ord); }, truncate: function truncate(length, fromEnd) { var res = this._object.length; if (this._object.length > length) { if (fromEnd) this._object.splice(0, this._object.length - length); this._object.length = length; this.fireEvent("truncate", length); } return res; }, // XXX: Awkward. mutate: function mutate(funcName) { var _funcName = funcName; arguments[0] = this._object; this._object = apply(Array, _funcName, arguments) .map(this.makeOwn.bind(this)); this.fireEvent("change", null); }, get: function get(index) { return index >= 0 ? this._object[index] : this._object[this._object.length + index]; } }); var ObjectStore = Class("ObjectStore", StoreBase, { _constructor: myObject, clear: function () { this._object = {}; this.fireEvent("clear"); }, get: function get(key, default_) { return this.has(key) ? this._object[key] : arguments.length > 1 ? this.set(key, default_) : undefined; }, has: function has(key) { return hasOwnProp(this._object, key); }, keys: function keys() { return Object.keys(this._object); }, remove: function remove(key) { var res = this._object[key]; delete this._object[key]; this.fireEvent("remove", key); return res; }, set: function set(key, val) { var defined = key in this._object; var orig = this._object[key]; this._object[key] = this.makeOwn(val); if (!defined) this.fireEvent("add", key); else if (orig != val) this.fireEvent("change", key); return val; } }); var sessionGlobal = Cu.import("resource://gre/modules/Services.jsm", {}); var Storage = Module("Storage", { Local: function Local(dactyl, modules, window) { return { init: function init() { this.privateMode = PrivateBrowsingUtils.isWindowPrivate(window); } }; }, alwaysReload: {}, init: function init() { this.cleanup(); let { Services } = Cu.import("resource://gre/modules/Services.jsm", {}); if (!Services.dactylSession) Services.dactylSession = Cu.createObjectIn(sessionGlobal); this.session = Services.dactylSession; }, cleanup: function () { if (this.keys) { this.saveAll(); for (let key of keys(this.keys)) { if (this[key].timer) this[key].timer.flush(); delete this[key]; } } this.keys = {}; this.observers = {}; }, _loadData: function loadData(name, store, type) { try { let file = storage.infoPath.child(name); if (file.exists()) { let data = file.read(); let result = JSON.parse(data); if (result instanceof type) return result; } } catch (e) { util.reportError(e); } }, _saveData: promises.task(function* saveData(obj) { if (obj.privateData && this.privateMode) return; if (obj.store && storage.infoPath) { var { path } = storage.infoPath.child(obj.name); yield AsyncFile(storage.infoPath.path).mkdir(); yield AsyncFile(path).write(obj.serial, { tmpPath: path + ".part" }); } }), storeForSession: function storeForSession(key, val) { if (val) this.session[key] = sessionGlobal.JSON.parse(JSON.stringify(val)); else delete this.dactylSession[key]; }, infoPath: Class.Memoize(function () { return File(IO.runtimePath.split(",")[0]) .child("info").child(config.profileName); }), exists: function exists(key) { return this.infoPath.child(key).exists(); }, remove: function remove(key) { if (this.exists(key)) { if (this[key] && this[key].timer) this[key].timer.flush(); delete this[key]; delete this.keys[key]; return OS.File.remove( this.infoPath.child(key).path); } }, newObject: function newObject(key, constructor, params={}) { if (params == null || !isObject(params)) throw Error("Invalid argument type"); if (this.isLocalModule) { apply(this.globalInstance, "newObject", arguments); if (!(key in this.keys) && this.privateMode && key in this.globalInstance.keys) { let obj = this.globalInstance.keys[key]; this.keys[key] = this._privatize(obj); } return this.keys[key]; } let reload = params.reload || this.alwaysReload[key]; if (!(key in this.keys) || reload) { if (key in this && !reload) throw Error("Cannot add storage key with that name."); let load = () => this._loadData(key, params.store, params.type || myObject); this.keys[key] = new constructor(key, params.store, load, params); this.keys[key].timer = new Timer(1000, 10000, () => this.save(key)); this.__defineGetter__(key, function () { return this.keys[key]; }); } return this.keys[key]; }, newMap: function newMap(key, options={}) { return this.newObject(key, ObjectStore, options); }, newArray: function newArray(key, options={}) { return this.newObject(key, ArrayStore, update({ type: Array }, options)); }, get observerMaps() { return function *() { /* FIXME: Symbols */ yield this.observers; for (let window of overlay.windows) yield overlay.getData(window, "storage-observers", Object); }.call(this); }, addObserver: function addObserver(key, callback, window) { var { observers } = this; if (window instanceof Ci.nsIDOMWindow) observers = overlay.getData(window, "storage-observers", Object); if (!hasOwnProp(observers, key)) observers[key] = new RealSet; observers[key].add(callback); }, removeObserver: function (key, callback) { for (let observers of this.observerMaps) if (key in observers) observers[key].remove(callback); }, fireEvent: function fireEvent(key, event, arg) { for (let observers of this.observerMaps) for (let observer of observers[key] || []) observer(key, event, arg); if (key in this.keys && this.keys[key].timer) this[key].timer.tell(); }, load: function load(key) { if (this[key].store && this[key].reload) this[key].reload(); }, save: function save(key) { if (this[key]) this._saveData(this.keys[key]); }, saveAll: function saveAll() { for (let obj of values(this.keys)) this._saveData(obj); }, _privateMode: false, get privateMode() { return this._privateMode; }, set privateMode(enabled) { this._privateMode = Boolean(enabled); if (this.isLocalModule) { this.saveAll(); if (!enabled) delete this.keys; else { let { keys } = this; this.keys = {}; for (let [k, v] of iter(keys)) this.keys[k] = this._privatize(v); } } return this._privateMode; }, _privatize: function privatize(obj) { if (obj.privateData && obj.clone) return obj.clone(this); return obj; } }, { Replacer: { skipXpcom: function skipXpcom(key, val) { return val instanceof Ci.nsISupports ? null : val; } } }, { cleanup: function (dactyl, modules, window) { overlay.setData(window, "storage-callbacks", undefined); } }); /** * @class File A class to wrap nsIFile objects and simplify operations * thereon. * * @param {nsIFile|string} path Expanded according to {@link IO#expandPath} * @param {boolean} checkPWD Whether to allow expansion relative to the * current directory. @default true * @param {string} charset The charset of the file. @default File.defaultEncoding */ var File = Class("File", { init: function init(path, checkPWD, charset) { if (charset) this.charset = charset; if (isString(path)) path = File.expandPath(path); this._path = path; this._checkPWD = checkPWD; return this; }, get path() { if (!this.fileified && isString(this._path) && File.isAbsolutePath(this._path)) return this._path; return this.file.path; }, set path(path) { return this.file.path = path; }, file: Class.Memoize(function () { let path = this._path; let file = services.File(); if (path instanceof Ci.nsIFileURL) path = path.file; if (path instanceof Ci.nsIFile || path instanceof File) file = path.clone(); else if (path.startsWith("file://")) file = services["file:"].getFileFromURLSpec(path); else { try { let checkPWD = this._checkPWD; if (!File.isAbsolutePath(path) && !(checkPWD instanceof Ci.nsIFile)) checkPWD = File(services.directory.get("CurWorkD", Ci.nsIFile)); if (!File.isAbsolutePath(path)) file = checkPWD.child(path); else file.initWithPath(path); } catch (e) { util.reportError(e); return File.DoesNotExist(path, e); } } this.fileified = true; return file.QueryInterface(Ci.nsILocalFile); }), get async() { return AsyncFile(this); }, charset: Class.Memoize(() => File.defaultEncoding), /** * @property {nsIFileURL} Returns the nsIFileURL object for this file. */ URI: Class.Memoize(function () { let uri = services.io.newFileURI(this.file) .QueryInterface(Ci.nsIFileURL); uri.QueryInterface(Ci.nsIMutable).mutable = false; return uri; }), /** * Iterates over the objects in this directory. */ iterDirectory: function* iterDirectory() { if (!this.exists()) throw Error(_("io.noSuchFile")); if (!this.isDirectory()) throw Error(_("io.eNotDir")); for (let file of iter(this.directoryEntries)) yield this.constructor(file); }, /** * Returns a new file for the given child of this directory entry. */ child: function child(...args) { let path = this.path; args = args.map(p => p.replace(File.pathSplit, File.PATH_SEP)); util.assert(!args.some(File.isAbsolutePath), "Absolute paths not allowed", false); let newPath = OS.Path.join.apply(OS.Path, [this.path].concat(args)); return this.constructor(newPath, null, this.charset); }, get fileName() { return OS.Path.basename(this.path); }, get parent() { return this.constructor(OS.Path.dirname(this.path), null, this.charset); }, /** * Returns an iterator for all lines in a file. */ get lines() { return File.readLines(services.FileInStream(this.file, -1, 0, 0), this.charset); }, /** * Reads this file's entire contents in "text" mode and returns the * content as a string. * * @param {string} encoding The encoding from which to decode the file. * @default #charset * @returns {string} */ read: function read(encoding) { let ifstream = services.FileInStream(this.file, -1, 0, 0); return File.readStream(ifstream, encoding || this.charset); }, /** * Returns the list of files in this directory. * * @param {boolean} sort Whether to sort the returned directory * entries. * @returns {[nsIFile]} */ readDirectory: function readDirectory(sort) { if (!this.isDirectory()) throw Error(_("io.eNotDir")); let array = Array.from(this.iterDirectory()); if (sort) array.sort((a, b) => (b.isDirectory() - a.isDirectory() || String.localeCompare(a.path, b.path))); return array; }, /** * Returns a new nsIFileURL object for this file. * * @returns {nsIFileURL} */ toURI: deprecated("#URI", function toURI() { return services.io.newFileURI(this.file); }), /** * Writes the string *buf* to this file. * * @param {string} buf The file content. * @param {string|number} mode The file access mode, a bitwise OR of * the following flags: * {@link #MODE_RDONLY}: 0x01 * {@link #MODE_WRONLY}: 0x02 * {@link #MODE_RDWR}: 0x04 * {@link #MODE_CREATE}: 0x08 * {@link #MODE_APPEND}: 0x10 * {@link #MODE_TRUNCATE}: 0x20 * {@link #MODE_SYNC}: 0x40 * Alternatively, the following abbreviations may be used: * ">" is equivalent to {@link #MODE_WRONLY} | {@link #MODE_CREATE} | {@link #MODE_TRUNCATE} * ">>" is equivalent to {@link #MODE_WRONLY} | {@link #MODE_CREATE} | {@link #MODE_APPEND} * @default ">" * @param {number} perms The file mode bits of the created file. This * is only used when creating a new file and does not change * permissions if the file exists. * @default 0644 * @param {string} encoding The encoding to used to write the file. * @default #charset */ write: function write(buf, mode, perms, encoding) { function getStream(defaultChar) { return services.ConvOutStream(ofstream, encoding, 0, defaultChar); } if (buf instanceof File) buf = buf.read(); if (!encoding) encoding = this.charset; if (mode == ">>") mode = File.MODE_WRONLY | File.MODE_CREATE | File.MODE_APPEND; else if (!mode || mode == ">") mode = File.MODE_WRONLY | File.MODE_CREATE | File.MODE_TRUNCATE; if (!perms) perms = 0o644; if (!this.exists()) // OCREAT won't create the directory this.create(this.NORMAL_FILE_TYPE, perms); let ofstream = services.FileOutStream(this.file, mode, perms, 0); try { var ocstream = getStream(0); ocstream.writeString(buf); } catch (e if e.result == Cr.NS_ERROR_LOSS_OF_SIGNIFICANT_DATA) { ocstream.close(); ocstream = getStream("?".charCodeAt(0)); ocstream.writeString(buf); return false; } finally { try { ocstream.close(); } catch (e) {} ofstream.close(); } return true; }, // Wrapped native methods: copyTo: function copyTo(dir, name) { return this.file.copyTo(this.constructor(dir).file, name); }, copyToFollowingLinks: function copyToFollowingLinks(dir, name) { return this.file.copyToFollowingLinks(this.constructor(dir).file, name); }, moveTo: function moveTo(dir, name) { return this.file.moveTo(this.constructor(dir).file, name); }, equals: function equals(file) { return this.file.equals(this.constructor(file).file); }, contains: function contains(dir, recur) { return this.file.contains(this.constructor(dir).file, recur); }, getRelativeDescriptor: function getRelativeDescriptor(file) { return this.file.getRelativeDescriptor(this.constructor(file).file); }, setRelativeDescriptor: function setRelativeDescriptor(file, path) { this.file.setRelativeDescriptor(this.constructor(file).file, path); } }, { /** * @property {number} Open for reading only. * @final */ MODE_RDONLY: 0x01, /** * @property {number} Open for writing only. * @final */ MODE_WRONLY: 0x02, /** * @property {number} Open for reading and writing. * @final */ MODE_RDWR: 0x04, /** * @property {number} If the file does not exist, the file is created. * If the file exists, this flag has no effect. * @final */ MODE_CREATE: 0x08, /** * @property {number} The file pointer is set to the end of the file * prior to each write. * @final */ MODE_APPEND: 0x10, /** * @property {number} If the file exists, its length is truncated to 0. * @final */ MODE_TRUNCATE: 0x20, /** * @property {number} If set, each write will wait for both the file * data and file status to be physically updated. * @final */ MODE_SYNC: 0x40, /** * @property {number} With MODE_CREATE, if the file does not exist, the * file is created. If the file already exists, no action and NULL * is returned. * @final */ MODE_EXCL: 0x80, /** * @property {string} The current platform's path separator. */ PATH_SEP: Class.Memoize(() => /foo(.)bar/.exec(OS.Path.join("foo", "bar"))[1]), pathSplit: Class.Memoize(function () { return util.regexp("[/" + util.regexp.escape(this.PATH_SEP) + "]", "g"); }), DoesNotExist: function DoesNotExist(path, error) { return new Proxy({ __proto__: DoesNotExist.prototype, path: path, exists: function () { return false; }, }, { get(target, prop) { if (prop in target) return target[prop]; return () => { error || Error("Does not exist")}; } }); }, defaultEncoding: "UTF-8", /** * Expands "~" and environment variables in *path*. * * "~" is expanded to to the value of $HOME. On Windows if this is not * set then the following are tried in order: * $USERPROFILE * ${HOMDRIVE}$HOMEPATH * * The variable notation is $VAR (terminated by a non-word character) * or ${VAR}. %VAR% is also supported on Windows. * * @param {string} path The unexpanded path string. * @param {boolean} relative Whether the path is relative or absolute. * @returns {string} */ expandPath: function expandPath(path, relative) { function getenv(name) { return services.environment.get(name); } // expand any $ENV vars - this is naive but so is Vim and we like to be compatible // TODO: Vim does not expand variables set to an empty string (and documents it). // Kris reckons we shouldn't replicate this 'bug'. --djk // TODO: should we be doing this for all paths? // No. function expand(path) { return path.replace( win32 ? /\$(\w+)\b|\${(\w+)}|%(\w+)%/g : /\$(\w+)\b|\${(\w+)}/g, (m, n1, n2, n3) => (getenv(n1 || n2 || n3) || m)); } path = expand(path); // expand ~ if (!relative && RegExp("~(?:$|[/" + util.regexp.escape(File.PATH_SEP) + "])").test(path)) path = OS.Path.join(OS.Constants.Path.homeDir, path.substr(2)); return OS.Path.normalize(path.replace(/\//g, File.PATH_SEP)); }, expandPathList: function (list) { return list.map(this.expandPath); }, readURL: function readURL(url, encoding) { let channel = services.io.newChannel(url, null, null); channel.contentType = "text/plain"; return this.readStream(channel.open(), encoding); }, readStream: function readStream(ifstream, encoding) { try { var icstream = services.CharsetStream( ifstream, encoding || File.defaultEncoding, 4096, // buffer size services.CharsetStream.DEFAULT_REPLACEMENT_CHARACTER); let buffer = []; let str = {}; while (icstream.readString(4096, str) != 0) buffer.push(str.value); return buffer.join(""); } finally { icstream.close(); ifstream.close(); } }, readLines: function* readLines(ifstream, encoding) { try { var icstream = services.CharsetStream( ifstream, encoding || File.defaultEncoding, 4096, // buffer size services.CharsetStream.DEFAULT_REPLACEMENT_CHARACTER); var value = {}; while (icstream.readLine(value)) yield value.value; } finally { icstream.close(); ifstream.close(); } }, isAbsolutePath: function isAbsolutePath(path) { try { return OS.Path.split(path).absolute; } catch (e) { return false; } }, replacePathSep: function replacePathSep(path) { return path.split("/").join(File.PATH_SEP); }, joinPaths: function joinPaths(head, tail, cwd) { let path = this(head, cwd); try { // FIXME: should only expand environment vars and normalize path separators path.appendRelativePath(this.expandPath(tail, true)); } catch (e) { return File.DoesNotExist(e); } return path; } }); { let file = services.File(); Object.keys(file).forEach(function (prop) { if (!(prop in File.prototype)) { let isFunction; try { isFunction = callable(file[prop]); } catch (e) {} if (isFunction) File.prototype[prop] = util.wrapCallback(function wrapper() { return apply(this.file, prop, arguments); }); else Object.defineProperty(File.prototype, prop, { configurable: true, get: function wrap_get() { return this.file[prop]; }, set: function wrap_set(val) { this.file[prop] = val; } }); } }); file = null; } var AsyncFile = Class("AsyncFile", File, { get async() { return this; }, /* * Creates a new directory, along with any parent directories which * do not currently exist. * * @param {object} options Options for directory creation. As in * `OS.File.makeDir` * @returns {Promise} */ // TODO: Is there a reason not to merge this with makeDir? mkdir: promises.task(function* mkdir(options) { let split = OS.Path.split(this.path); util.assert(split.absolute); let file = File(split.winDrive ? split.winDrive + File.PATH_SEP : File.PATH_SEP); for (let component of split.components) { let f = file.child(component); try { var stat = yield OS.File.stat(f.path); } catch (e) { // Does not exist, or other error. break; } if (!stat.isDir) throw new Error("Component in path is not a directory"); file = f; } options = update({}, options || {}, { ignoreExisting: true, from: file.path }); yield OS.File.makeDir(this.path, options); }), _setEncoding: function _setEncoding(options) { if (this.charset != null && !("encoding" in options)) options = update({}, options, { encoding: this.charset }); return options; }, /** * Reads this file's entire contents in "text" mode and returns the * content as a string. */ read: function read(options={}) { return OS.File.read(this.path, this._setEncoding(options)); }, /** * Returns the list of files in this directory. */ readDirectory: function readDirectory(callback) { let iter = new OS.File.DirectoryIterator(dir); let close = () => { iter.close(); }; return iter.forEach(callback) .then(close, close); }, /** * Writes the string *buf* to this file. */ write: function write(buf, options={}) { return OS.File.writeAtomic(this.path, buf, this._setEncoding(options)); }, copyTo: function copyTo(path, options) { return OS.File.copy(this.path, path, options); }, moveTo: function moveTo(path, options) { return OS.File.move(this.path, path, options); } }); for (let m of ["makeDir", "stat", "remove", "removeDir", "removeEmptyDir"]) { let method = m; AsyncFile.prototype[method] = function (options) { return OS.File[method](this.path, options); }; } endModule(); // catch(e){ dump(e + "\n" + (e.stack || Error().stack)); Components.utils.reportError(e) } // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/styles.jsm000066400000000000000000000762401264147376100210550ustar00rootroot00000000000000// Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; defineModule("styles", { exports: ["Style", "Styles", "styles"], require: ["services", "util"] }); lazyRequire("contexts", ["Contexts"]); lazyRequire("template", ["template"]); var namespace = "@namespace html " + JSON.stringify(XHTML) + ";\n" + "@namespace xul " + JSON.stringify(XUL) + ";\n" + "@namespace dactyl " + JSON.stringify(NS) + ";\n"; var Sheet = Struct("name", "id", "sites", "css", "hive", "agent"); Sheet.liveProperty = function (name) { let i = this.prototype.members[name]; this.prototype.__defineGetter__(name, function () { return this[i]; }); this.prototype.__defineSetter__(name, function (val) { if (isArray(val)) val = Array.slice(val); if (isArray(val)) Object.freeze(val); this[i] = val; this.enabled = this.enabled; }); }; Sheet.liveProperty("agent"); Sheet.liveProperty("css"); Sheet.liveProperty("sites"); update(Sheet.prototype, { formatSites: function (uris) { return template.map(this.sites, filter => ["span", { highlight: uris.some(Styles.matchFilter(filter)) ? "Filter" : "" }, filter], ","); }, remove: function () { this.hive.remove(this); }, get uri() { return "dactyl://style/" + this.id + "/" + this.hive.name + "/" + (this.name || ""); }, get enabled() { return this._enabled; }, set enabled(on) { if (on != this._enabled || this.fullCSS != this._fullCSS) { if (on) this.enabled = false; else if (!this._fullCSS) return; let meth = on ? "registerSheet" : "unregisterSheet"; styles[meth](this.uri, on ? this.agent : this._agent); this._agent = this.agent; this._enabled = Boolean(on); this._fullCSS = this.fullCSS; } }, match: function (uri) { if (isString(uri)) uri = util.newURI(uri); return this.sites.some(site => Styles.matchFilter(site, uri)); }, get fullCSS() { let filter = this.sites; let css = this.css; let preamble = "/* " + this.uri + (this.agent ? " (agent)" : "") + " */\n\n" + namespace + "\n"; if (filter[0] == "*") return preamble + css; let selectors = filter.map(part => !/^(?:[a-z-]+[:*]|[a-z-.]+$)/i.test(part) ? "regexp(" + Styles.quote(".*(?:" + part + ").*") + ")" : (/[*]$/.test(part) ? "url-prefix" : /[\/:]/.test(part) ? "url" : "domain") + '(' + Styles.quote(part.replace(/\*$/, "")) + ')') .join(",\n "); return preamble + "@-moz-document " + selectors + " {\n\n" + css + "\n\n}\n"; } }); var Hive = Class("Hive", { init: function (name, persist) { this.name = name; this.sheets = []; this.names = {}; this.refs = []; this.persist = persist; }, get modifiable() { return this.name !== "system"; }, addRef: function (obj) { this.refs.push(util.weakReference(obj)); this.dropRef(null); }, dropRef: function (obj) { this.refs = this.refs.filter(ref => (ref.get() && ref.get() !== obj)); if (!this.refs.length) { this.cleanup(); styles.hives = styles.hives.filter(h => h !== this); } }, cleanup: function cleanup() { for (let sheet of this.sheets) util.trapErrors(() => { sheet.enabled = false; }); }, "@@iterator": function () { return iter(this.sheets); }, get sites() { let sites = this.sheets.flatMap(s => s.sites); return [...new RealSet(sites)]; }, /** * Add a new style sheet. * * @param {string} name The name given to the style sheet by * which it may be later referenced. * @param {string} filter The sites to which this sheet will * apply. Can be a domain name or a URL. Any URL ending in * "*" is matched as a prefix. * @param {string} css The CSS to be applied. * @param {boolean} agent If true, the sheet is installed as an * agent sheet. * @param {boolean} lazy If true, the sheet is not initially enabled. * @returns {Sheet} */ add: function add(name, filter, css, agent, lazy) { if (isArray(filter)) // Need an array from the same compartment. filter = Array.slice(filter); else filter = filter.split(","); if (name && name in this.names) { var sheet = this.names[name]; sheet.agent = agent; sheet.css = String(css); sheet.sites = filter; } else { sheet = Sheet(name, styles._id++, filter.filter(identity), String(css), this, agent); this.sheets.push(sheet); } styles.allSheets[sheet.id] = sheet; if (!lazy) sheet.enabled = true; if (name) this.names[name] = sheet; return sheet; }, /** * Get a sheet with a given name or index. * * @param {string or number} sheet The sheet to retrieve. Strings indicate * sheet names, while numbers indicate indices. */ get: function get(sheet) { if (typeof sheet === "number") return this.sheets[sheet]; return this.names[sheet]; }, /** * Find sheets matching the parameters. See {@link #addSheet} * for parameters. * * @param {string} name * @param {string} filter * @param {string} css * @param {number} index */ find: function find(name, filter, css, index) { // Grossly inefficient. let matches = Object.keys(this.sheets); if (index) matches = String(index).split(",").filter(i => i in this.sheets); if (name) matches = matches.filter(i => this.sheets[i].name == name); if (css) matches = matches.filter(i => this.sheets[i].css == css); if (filter) matches = matches.filter(i => this.sheets[i].sites.indexOf(filter) >= 0); return matches.map(i => this.sheets[i]); }, /** * Remove a style sheet. See {@link #addSheet} for parameters. * In cases where *filter* is supplied, the given filters are removed from * matching sheets. If any remain, the sheet is left in place. * * @param {string} name * @param {string} filter * @param {string} css * @param {number} index */ remove: function remove(name, filter, css, index) { if (arguments.length == 1) { var matches = [name]; name = null; } if (filter && filter.includes(",")) return filter.split(",").reduce( (n, f) => n + this.removeSheet(name, f, index), 0); if (filter == undefined) filter = ""; if (!matches) matches = this.findSheets(name, filter, css, index); if (matches.length == 0) return null; for (let sheet of matches.reverse()) { if (filter) { let sites = sheet.sites.filter(f => f != filter); if (sites.length) { sheet.sites = sites; continue; } } sheet.enabled = false; if (sheet.name) delete this.names[sheet.name]; delete styles.allSheets[sheet.id]; } this.sheets = this.sheets.filter(s => matches.indexOf(s) == -1); return matches.length; } }); /** * Manages named and unnamed user style sheets, which apply to both * chrome and content pages. * * @author Kris Maglione */ var Styles = Module("Styles", { Local: function (dactyl, modules, window) { return { cleanup: function () {} }; }, init: function () { this._id = 0; this.cleanup(); this.allSheets = {}; update(services["dactyl:"].providers, { "style": function styleProvider(uri, path) { let id = parseInt(path); if (hasOwnProp(styles.allSheets, id)) return ["text/css", styles.allSheets[id].fullCSS]; return null; } }); }, cleanup: function cleanup() { for (let hive of this.hives || []) util.trapErrors("cleanup", hive); this.hives = []; this.user = this.addHive("user", this, true); this.system = this.addHive("system", this, false); }, addHive: function addHive(name, ref, persist) { let hive = this.hives.find(h => h.name === name); if (!hive) { hive = Hive(name, persist); this.hives.push(hive); } hive.persist = persist; if (ref) hive.addRef(ref); return hive; }, "@@iterator": function () { return iter(this.user.sheets.concat(this.system.sheets)); }, _proxy: function (name, args) { let obj = this[args[0] ? "system" : "user"]; return apply(obj, name, Array.slice(args, 1)); }, addSheet: deprecated("Styles#{user,system}.add", function addSheet() { return this._proxy("add", arguments); }), findSheets: deprecated("Styles#{user,system}.find", function findSheets() { return this._proxy("find", arguments); }), get: deprecated("Styles#{user,system}.get", function get() { return this._proxy("get", arguments); }), removeSheet: deprecated("Styles#{user,system}.remove", function removeSheet() { return this._proxy("remove", arguments); }), userSheets: Class.Property({ get: deprecated("Styles#user.sheets", function userSheets() { return this.user.sheets; }) }), systemSheets: Class.Property({ get: deprecated("Styles#system.sheets", function systemSheets() { return this.system.sheets; }) }), userNames: Class.Property({ get: deprecated("Styles#user.names", function userNames() { return this.user.names; }) }), systemNames: Class.Property({ get: deprecated("Styles#system.names", function systemNames() { return this.system.names; }) }), sites: Class.Property({ get: deprecated("Styles#user.sites", function sites() { return this.user.sites; }) }), list: function list(content, sites, name, hives) { const { commandline, dactyl } = this.modules; hives = hives || styles.hives.filter(h => (h.modifiable && h.sheets.length)); function sheets(group) { return group.sheets.slice() .filter(sheet => ((!name || sheet.name === name) && (!sites || sites.every(s => sheet.sites.indexOf(s) >= 0)))) .sort((a, b) => (a.name && b.name ? String.localeCompare(a.name, b.name) : !!b.name - !!a.name || a.id - b.id)); } let uris = util.visibleURIs(content); let list = ["table", {}, ["tr", { highlight: "Title" }, ["td"], ["td"], ["td", { style: "padding-right: 1em;" }, _("title.Name")], ["td", { style: "padding-right: 1em;" }, _("title.Filter")], ["td", { style: "padding-right: 1em;" }, _("title.CSS")]], ["col", { style: "min-width: 4em; padding-right: 1em;" }], ["col", { style: "min-width: 1em; text-align: center; color: red; font-weight: bold;" }], ["col", { style: "padding: 0 1em 0 1ex; vertical-align: top;" }], ["col", { style: "padding: 0 1em 0 0; vertical-align: top;" }], template.map(hives, hive => { let i = 0; return [ ["tr", { style: "height: .5ex;" }], template.map(sheets(hive), sheet => ["tr", {}, ["td", { highlight: "Title" }, !i++ ? hive.name : ""], ["td", {}, sheet.enabled ? "" : UTF8("×")], ["td", {}, sheet.name || hive.sheets.indexOf(sheet)], ["td", {}, sheet.formatSites(uris)], ["td", {}, sheet.css]]), ["tr", { style: "height: .5ex;" }]]; })]; // E4X-FIXME // // TODO: Move this to an ItemList to show this automatically // if (list.*.length() === list.text().length() + 5) // dactyl.echomsg(_("style.none")); // else commandline.commandOutput(list); }, registerSheet: function registerSheet(url, agent, reload) { let uri = services.io.newURI(url, null, null); if (reload) this.unregisterSheet(url, agent); let type = services.stylesheet[agent ? "AGENT_SHEET" : "USER_SHEET"]; if (reload || !services.stylesheet.sheetRegistered(uri, type)) { services.stylesheet.loadAndRegisterSheet(uri, type); } }, unregisterSheet: function unregisterSheet(url, agent) { let uri = services.io.newURI(url, null, null); let type = services.stylesheet[agent ? "AGENT_SHEET" : "USER_SHEET"]; if (services.stylesheet.sheetRegistered(uri, type)) services.stylesheet.unregisterSheet(uri, type); } }, { append: function (dest, src, sort) { let props = {}; for (let str of [dest, src]) for (let prop of Styles.propertyIter(str)) props[prop.name] = prop.value; let val = Object.keys(props)[sort ? "sort" : "slice"]() .map(prop => prop + ": " + props[prop] + ";") .join(" "); if (/^\s*(\/\*.*?\*\/)/.exec(src)) val = RegExp.$1 + " " + val; return val; }, completeSite: function (context, content, group=styles.user) { context.anchored = false; try { context.fork("current", 0, this, context => { context.title = ["Current Site"]; context.completions = [ [content.location.host, /*L*/"Current Host"], [content.location.href, /*L*/"Current URL"] ]; }); } catch (e) {} let uris = util.visibleURIs(content); context.generate = () => values(group.sites); context.keys.text = identity; context.keys.description = function (site) { return this.sheets.length + /*L*/" sheet" + (this.sheets.length == 1 ? "" : "s") + ": " + Ary.compact(this.sheets.map(s => s.name)).join(", "); }; context.keys.sheets = site => group.sheets.filter(s => s.sites.indexOf(site) >= 0); context.keys.active = site => uris.some(Styles.matchFilter(site)); Styles.splitContext(context, "Sites"); }, /** * A curried function which determines which host names match a * given stylesheet filter. When presented with one argument, * returns a matcher function which, given one nsIURI argument, * returns true if that argument matches the given filter. When * given two arguments, returns true if the second argument matches * the given filter. * * @param {string} filter The URI filter to match against. * @param {nsIURI} uri The location to test. * @returns {nsIURI -> boolean} */ matchFilter: function (filter) { filter = filter.trim(); if (filter === "*") var test = function test(uri) { return true; }; else if (!/^(?:[a-z-]+:|[a-z-.]+$)/.test(filter)) { let re = util.regexp(filter); test = function test(uri) { return re.test(uri.spec); }; } else if (/[*]$/.test(filter)) { let re = RegExp("^" + util.regexp.escape(filter.substr(0, filter.length - 1))); test = function test(uri) { return re.test(uri.spec); }; } else if (/[\/:]/.test(filter)) test = function test(uri) { return uri.spec === filter; }; else test = function test(uri) { try { return util.isSubdomain(uri.host, filter); } catch (e) { return false; } }; test.toString = function toString() { return filter; } test.key = filter; if (arguments.length < 2) return test; return test(arguments[1]); }, splitContext: function splitContext(context, title) { for (let item of iter({ Active: true, Inactive: false })) { let [name, active] = item; context.split(name, null, context => { context.title[0] = /*L*/name + " " + (title || "Sheets"); context.filters.push(item => !!item.active == active); }); } }, propertyIter: function* (str, always) { let i = 0; let x = /The status bar/.test(str); for (let match of this.propertyPattern.iterate(str)) { if (match.value || always && match.name || match.wholeMatch === match.preSpace && always && !i++) yield match; if (!/;/.test(match.postSpace)) break; } }, propertyPattern: util.regexp(String.raw` (?: (?P *) (?P [-a-z]*) (?: * : \s* (?P (?: [-\w]+ (?: \s* \( \s* (?: | [^)]* ) \s* (?: \) | $) )? \s* | \s* \s* | * | [^;}]* )* ) )? ) (?P * (?: ; | $) ) `, "gix", { space: /(?: \s | \/\* .*? \*\/ )/, string: /(?:" (?:[^\\"]|\\.)* (?:"|$) | '(?:[^\\']|\\.)* (?:'|$) )/ }), patterns: memoize({ get property() { return util.regexp(String.raw` (?: (?P *) (?P [-a-z]*) (?: * : \s* (?P * ) )? ) (?P * (?: ; | $) ) `, "gix", this); }, get function() { return util.regexp(String.raw` (?P \s* \( \s* (?: | [^)]* ) \s* (?: \) | $) ) `, "gx", this); }, space: /(?: \s | \/\* .*? \*\/ )/, get string() { return util.regexp(String.raw` (?P " (?:[^\\"]|\\.)* (?:"|$) | ' (?:[^\\']|\\.)* (?:'|$) ) `, "gx", this); // " Vim. }, get token() { return util.regexp(String.raw` (?P (?P [-\w]+) ? \s* | (?P !important\b) | \s* \s* | + | [^;}\s]+ ) `, "gix", this); } }), /** * Quotes a string for use in CSS stylesheets. * * @param {string} str * @returns {string} */ quote: function quote(str) { return '"' + str.replace(/([\\"])/g, "\\$1").replace(/\n/g, "\\00000a") + '"'; } }, { commands: function initCommands(dactyl, modules, window) { const { commands, contexts, styles } = modules; function sheets(context, args, filter) { let uris = util.visibleURIs(window.content); context.compare = modules.CompletionContext.Sort.number; context.generate = () => args["-group"].sheets; context.keys.active = sheet => uris.some(sheet.bound.match); context.keys.description = sheet => [sheet.formatSites(uris), ": ", sheet.css.replace("\n", "\\n")]; if (filter) context.filters.push(({ item }) => filter(item)); Styles.splitContext(context); } function nameFlag(filter) { return { names: ["-name", "-n"], description: "The name of this stylesheet", type: modules.CommandOption.STRING, completer: function (context, args) { context.keys.text = sheet => sheet.name; context.filters.unshift(({ item }) => item.name); sheets(context, args, filter); } }; } commands.add(["sty[le]"], "Add or list user styles", function (args) { let [filter, css] = args; if (!css) styles.list(window.content, filter ? filter.split(",") : null, args["-name"], args.explicitOpts["-group"] ? [args["-group"]] : null); else { util.assert(args["-group"].modifiable && args["-group"].hive.modifiable, _("group.cantChangeBuiltin", _("style.styles"))); if (args["-append"]) { let sheet = args["-group"].get(args["-name"]); if (sheet) { filter = Ary(sheet.sites).concat(filter).uniq().join(","); css = sheet.css + " " + css; } } let style = args["-group"].add(args["-name"], filter, css, args["-agent"]); if (args["-nopersist"] || !args["-append"] || style.persist === undefined) style.persist = !args["-nopersist"]; } }, { completer: function (context, args) { let sheet = args["-group"].get(args["-name"]); if (args.completeArg == 0) { if (sheet) context.completions = [[sheet.sites.join(","), _("option.currentValue")]]; context.fork("sites", 0, Styles, "completeSite", window.content, args["-group"]); } else if (args.completeArg == 1) { if (sheet) context.completions = [ [sheet.css, _("option.currentValue")] ]; context.fork("css", 0, modules.completion, "css"); } }, hereDoc: true, literal: 1, options: [ { names: ["-agent", "-A"], description: "Apply style as an Agent sheet" }, { names: ["-append", "-a"], description: "Append site filter and css to an existing, matching sheet" }, contexts.GroupFlag("styles"), nameFlag(), { names: ["-nopersist", "-N"], description: "Do not save this style to an auto-generated RC file" } ], serialize: function () { return styles.hives .filter(hive => hive.persist) .flatMap(hive => hive.sheets.filter(style => style.persist) .sort((a, b) => String.localeCompare(a.name || "", b.name || "")) .map(style => ({ command: "style", arguments: [style.sites.join(",")], literalArg: style.css, options: { "-group": hive.name == "user" ? undefined : hive.name, "-name": style.name || undefined } }))); } }); [ { name: ["stylee[nable]", "stye[nable]"], desc: "Enable a user style sheet", action: function (sheet) { sheet.enabled = true; }, filter: function (sheet) { return !sheet.enabled; } }, { name: ["styled[isable]", "styd[isable]"], desc: "Disable a user style sheet", action: function (sheet) { sheet.enabled = false; }, filter: function (sheet) { return sheet.enabled; } }, { name: ["stylet[oggle]", "styt[oggle]"], desc: "Toggle a user style sheet", action: function (sheet) { sheet.enabled = !sheet.enabled; } }, { name: ["dels[tyle]"], desc: "Remove a user style sheet", action: function (sheet) { sheet.remove(); } } ].forEach(function (cmd) { commands.add(cmd.name, cmd.desc, function (args) { dactyl.assert(args.bang ^ !!(args[0] || args[1] || args["-name"] || args["-index"]), _("error.argumentOrBang")); args["-group"].find(args["-name"], args[0], args.literalArg, args["-index"]) .forEach(cmd.action); }, { bang: true, completer: function (context, args) { Styles.completeSite(context, window.content, args["-group"]); if (cmd.filter) context.filters.push(({ sheets }) => sheets.some(cmd.filter)); }, literal: 1, options: [ contexts.GroupFlag("styles"), { names: ["-index", "-i"], type: modules.CommandOption.INT, completer: function (context, args) { context.keys.text = sheet => args["-group"].sheets.indexOf(sheet); sheets(context, args, cmd.filter); } }, nameFlag(cmd.filter) ] }); }); }, contexts: function initContexts(dactyl, modules, window) { modules.contexts.Hives("styles", Class("LocalHive", Contexts.Hive, { init: function init(group) { init.superapply(this, arguments); this.hive = styles.addHive(group.name, this, this.persist); return new Proxy(this, { get(target, prop) { if (prop in target) return target[prop]; return target.hive[prop]; }, }); }, get names() { return this.hive.names; }, get sheets() { return this.hive.sheets; }, get sites() { return this.hive.sites; }, destroy: function () { this.hive.dropRef(this); } })); }, completion: function initCompletion(dactyl, modules, window) { const names = Array.slice(DOM(["div"], window.document).style); modules.completion.css = context => { context.title = ["CSS Property"]; context.keys = { text: function (p) { return p + ":"; }, description: function () { return ""; } }; for (let match of Styles.propertyIter(context.filter, true)) var lastMatch = match; if (lastMatch != null && !lastMatch.value && !lastMatch.postSpace) { context.advance(lastMatch.index + lastMatch.preSpace.length); context.completions = names; } }; }, javascript: function initJavascript(dactyl, modules, window) { modules.JavaScript.setCompleter(["get", "add", "remove", "find"].map(m => Hive.prototype[m]), [ // Prototype: (name, filter, css, index) function (context, obj, args) { return this.names; }, (context, obj, args) => Styles.completeSite(context, window.content), null, function (context, obj, args) { return this.sheets; } ]); }, template: function initTemplate() { let patterns = Styles.patterns; template.highlightCSS = function highlightCSS(css) { return this.highlightRegexp(css, patterns.property, match => { if (!match.length) return []; return ["", match.preSpace, template.filter(match.name), ": ", template.highlightRegexp(match.value, patterns.token, match => { if (match.function) return ["", template.filter(match.word), template.highlightRegexp(match.function, patterns.string, match => ["span", { highlight: "String" }, match.string]) ]; if (match.important == "!important") return ["span", { highlight: "String" }, match.important]; if (match.string) return ["span", { highlight: "String" }, match.string]; return template._highlightRegexp(match.wholeMatch, /^(\d+)(em|ex|px|in|cm|mm|pt|pc)?/g, (m, n, u) => [ ["span", { highlight: "Number" }, n], ["span", { highlight: "Object" }, u || ""] ]); }), match.postSpace ]; }); }; } }); endModule(); // catch(e){dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack);} // vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript: dactyl-1.2~r20151231/common/modules/template.jsm000066400000000000000000000457071264147376100213510ustar00rootroot00000000000000// Copyright (c) 2008-2015 Kris Maglione // // This work is licensed for reuse under an MIT license. Details are // given in the LICENSE.txt file included with this file. "use strict"; let global = this; defineModule("template", { exports: ["Binding", "Template", "template"], require: ["util"] }); lazyRequire("help", ["help"]); var Binding = Class("Binding", { init: function (node, nodes) { this.node = node; this.nodes = nodes; Object.defineProperties(node, this.constructor.properties); for (let [event, handler] of this.constructor.events) node.addEventListener(event, util.wrapCallback(handler, true), false); let proxy = new Proxy(this, { get(target, prop) { if (prop in target) return target[prop]; let { node } = target; let value = node[prop]; if (callable(value)) return value.bind(node); return value; }, }); node.dactylBinding = proxy; return proxy; }, set collapsed(collapsed) { if (collapsed) this.setAttribute("collapsed", "true"); else this.removeAttribute("collapsed"); }, get collapsed() { return !!this.getAttribute("collapsed"); }, }, { get bindings() { return function* () { let bindingProto = Object.getPrototypeOf(Binding.prototype); for (let obj = this.prototype; obj !== bindingProto; obj = Object.getPrototypeOf(obj)) /* FIXME: Symbols */ yield obj; }.call(this); }, bind: function bind(func) { return function bound() { try { return func.apply(this.dactylBinding, arguments); } catch (e) { util.reportError(e); throw e; } }; }, events: Class.Memoize(function () { let res = []; for (let obj of this.bindings) if (Object.getOwnPropertyDescriptor(obj, "events")) for (let [event, handler] of iter(obj.events)) res.push([event, this.bind(handler)]); return res; }), properties: Class.Memoize(function () { let res = {}; for (let obj of this.bindings) for (let prop of properties(obj)) { let desc = Object.getOwnPropertyDescriptor(obj, prop); if (desc.enumerable) { for (let k of ["get", "set", "value"]) if (typeof desc[k] === "function") desc[k] = this.bind(desc[k]); res[prop] = desc; } } return res; }) }); ["appendChild", "getAttribute", "insertBefore", "setAttribute"].forEach(function (key) { Object.defineProperty(Binding.prototype, key, { configurable: true, enumerable: false, value: function () { return apply(this.node, key, arguments); }, writable: true }); }); var Template = Module("Template", { bindings: { Button: Class("Button", Binding, { init: function init(node, params) { init.supercall(this, node); this.target = params.commandTarget; }, get command() { return this.getAttribute("command") || this.getAttribute("key"); }, events: { "click": function onClick(event) { event.preventDefault(); if (this.commandAllowed) { if (hasOwnProp(this.target.commands || {}, this.command)) this.target.commands[this.command].call(this.target); else this.target.command(this.command); } } }, get commandAllowed() { if (hasOwnProp(this.target.allowedCommands || {}, this.command)) return this.target.allowedCommands[this.command]; if ("commandAllowed" in this.target) return this.target.commandAllowed(this.command); return true; }, update: function update() { let collapsed = this.collapsed; this.collapsed = !this.commandAllowed; if (collapsed == this.commandAllowed) { let event = this.node.ownerDocument.createEvent("Events"); event.initEvent("dactyl-commandupdate", true, false); this.node.ownerDocument.dispatchEvent(event); } } }), Events: Class("Events", Binding, { init: function init(node, params) { init.supercall(this, node); let obj = params.eventTarget; let events = obj[this.getAttribute("events") || "events"]; if (hasOwnProp(events, "input")) events["dactyl-input"] = events["input"]; for (let [event, handler] of iter(events)) node.addEventListener(event, util.wrapCallback(handler.bind(obj), true), false); } }) }, map: function map(iter_, func, sep, interruptable) { if (typeof iter_.length == "number") // FIXME: Kludge? iter_ = Ary.iterValues(iter_); let res = []; let n = 0; for (let i of iter_) { let val = func(i, n); if (val == undefined) continue; if (n++ && sep) res.push(sep); if (interruptable && n % interruptable == 0) util.threadYield(true, true); res.push(val); } return res; }, bookmarkDescription: function (item, text) { return [ !(item.extra && item.extra.length) ? [] : ["span", { highlight: "URLExtra" }, " (", template.map(item.extra, e => ["", e[0], ": ", ["span", { highlight: e[2] }, e[1]]], "\u00a0"), ")\u00a0"], ["a", { identifier: item.id == null ? "" : item.id, "dactyl:command": item.command || "", href: item.item.url, highlight: "URL" }, text || ""] ]; }, filter: function (str) { return ["span", { highlight: "Filter" }, str]; }, completionRow: function completionRow(item, highlightGroup) { if (typeof icon == "function") icon = icon(); if (highlightGroup) { var text = item[0] || ""; var desc = item[1] || ""; } else { var text = this.processor[0].call(this, item, item.result); var desc = this.processor[1].call(this, item, item.description); } return ["div", { highlight: highlightGroup || "CompItem", style: "white-space: nowrap" }, /* The non-breaking spaces prevent empty elements * from pushing the baseline down and enlarging * the row. */ ["li", { highlight: "CompResult " + item.highlight }, text, "\u00a0"], ["li", { highlight: "CompDesc" }, desc, "\u00a0"]]; }, helpLink: function (token, text, type) { if (!help.initialized) util.dactyl.initHelp(); let topic = token; // FIXME: Evil duplication! if (/^\[.*\]$/.test(topic)) topic = topic.slice(1, -1); else if (/^n_/.test(topic)) topic = topic.slice(2); if (help.initialized && !hasOwnProp(help.tags, topic)) return ["span", { highlight: type || ""}, text || token]; type = type || (/^'.*'$/.test(token) ? "HelpOpt" : /^\[.*\]$|^E\d{3}$/.test(token) ? "HelpTopic" : /^:\w/.test(token) ? "HelpEx" : "HelpKey"); return ["a", { highlight: "InlineHelpLink " + type, tag: topic, href: "dactyl://help-tag/" + topic, "dactyl:command": "dactyl.help" }, text || topic]; }, HelpLink: function (token) { if (!help.initialized) util.dactyl.initHelp(); let topic = token; // FIXME: Evil duplication! if (/^\[.*\]$/.test(topic)) topic = topic.slice(1, -1); else if (/^n_/.test(topic)) topic = topic.slice(2); if (help.initialized && !hasOwnProp(help.tags, topic)) return token; let tag = (/^'.*'$/.test(token) ? "o" : /^\[.*\]$|^E\d{3}$/.test(token) ? "t" : /^:\w/.test(token) ? "ex" : "k"); topic = topic.replace(/^'(.*)'$/, "$1"); return [tag, { xmlns: "dactyl" }, topic]; }, linkifyHelp: function linkifyHelp(str, help) { let re = util.regexp(String.raw` (?P
       [/\s]|^)
            (?P '[\w-]+' | :(?:[\w-]+!?|!) | (?:._)?<[\w-]+>\w* | \b[a-zA-Z]_(?:[\w[\]]+|.) | \[[\w-;]+\] | E\d{3} )
            (?=      [[\)!,:;./\s]|$)
        `, "gx");
        return this.highlightSubstrings(str, (function* () {
            for (let res of re.iterate(str))
                yield [res.index + res.pre.length, res.tag.length];
        })(), this[help ? "HelpLink" : "helpLink"]);
    },

    // if "processStrings" is true, any passed strings will be surrounded by " and
    // any line breaks are displayed as \n
    highlight: function highlight(arg, processStrings, clip, bw) {
        // some objects like window.JSON or getBrowsers()._browsers need the try/catch
        try {
            let str = String(arg);
            if (clip)
                str = util.clip(str, clip);
            switch (arg == null ? "undefined" : typeof arg) {
            case "number":
                return ["span", { highlight: "Number" }, str];
            case "string":
                if (processStrings)
                    str = JSON.stringify(str);
                return ["span", { highlight: "String" }, str];
            case "symbol":
                return ["span", { highlight: "Symbol" }, str];
            case "boolean":
                return ["span", { highlight: "Boolean" }, str];
            case "function":
                // See: https://bugzil.la/268945
                if (arg instanceof Ci.nsIDOMElement)
                    return util.objectToString(arg, !bw);

                str = str.replace("/* use strict */ \n", "/* use strict */ ");
                if (processStrings)
                    return ["span", { highlight: "Function" },
                                str.replace(/\{(.|\n)*(?:)/g, "{ ... }")];
                arg = String(arg).replace("/* use strict */ \n", "/* use strict */ ");
                return arg;
            case "undefined":
                return ["span", { highlight: "Null" }, "undefined"];
            case "object":
                if (arg instanceof Ci.nsIDOMElement)
                    return util.objectToString(arg, !bw);
                if (arg instanceof util.Magic)
                    return String(arg);

                if (processStrings && false)
                    str = template._highlightFilter(str, "\n",
                                                    () => ["span",
                                                           { highlight: "NonText" },
                                                           "^J"]);
                return ["span", { highlight: "Object" }, str];
            default:
                return "";
            }
        }
        catch (e) {
            return "";
        }
    },

    highlightFilter: function highlightFilter(str, filter, highlight, isURI) {
        if (isURI)
            str = util.losslessDecodeURI(str);

        return this.highlightSubstrings(str, (function* () {
            if (filter.length == 0)
                return;

            let lcstr = String.toLowerCase(str);
            let lcfilter = filter.toLowerCase();
            let start = 0;
            while ((start = lcstr.indexOf(lcfilter, start)) > -1) {
                yield [start, filter.length];
                start += filter.length;
            }
        })(), highlight || template.filter);
    },

    highlightRegexp: function highlightRegexp(str, re, highlight) {
        return this.highlightSubstrings(str, (function* () {
            for (let res of util.regexp.iterate(re, str))
                yield [res.index, res[0].length, res.wholeMatch ? [res] : res];
        })(), highlight || template.filter);
    },

    highlightSubstrings: function highlightSubstrings(str, iter_, highlight) {
        if (!isString(str))
            return str;

        if (str == "")
            return DOM.DOMString(str);

        let s = [""];
        let start = 0;
        let _i; // XXX
        for (let [i, length, args] of iter_) {
            if (i == _i || i < _i)
                break;
            _i = i;

            s.push(str.substring(start, i),
                   highlight.apply(this, Array.concat(args || str.substr(i, length))));
            start = i + length;
        }
        s.push(str.substr(start));
        return s;
    },

    highlightURL: function highlightURL(str, force) {
        if (force || /^[a-zA-Z]+:\/\//.test(str))
            return ["a", { highlight: "URL", href: str },
                        util.losslessDecodeURI(str)];
        else
            return str;
    },

    icon: function (item, text) {
        return [
            ["span", { highlight: "CompIcon" },
                item.icon ? ["img", { src: item.icon }] : []],
            ["span", { class: "td-strut" }],
            text
        ];
    },

    jumps: function jumps(index, elems) {
        return ["table", {},
                ["tr", { style: "text-align: left;", highlight: "Title" },
                    ["th", { colspan: "2" }, _("title.Jump")],
                    ["th", {}, _("title.HPos")],
                    ["th", {}, _("title.VPos")],
                    ["th", {}, _("title.Title")],
                    ["th", {}, _("title.URI")]],
                this.map(Iterator(elems), ([idx, val]) =>
                    ["tr", {},
                        ["td", { class: "indicator" }, idx == index ? ">" : ""],
                        ["td", {}, Math.abs(idx - index)],
                        ["td", {}, val.offset ? val.offset.x : ""],
                        ["td", {}, val.offset ? val.offset.y : ""],
                        ["td", { style: "width: 250px; max-width: 500px; overflow: hidden;" }, val.title],
                        ["td", {},
                            ["a", { href: val.URI.spec, highlight: "URL jump-list" },
                                util.losslessDecodeURI(val.URI.spec)]]])];
    },

    options: function options(title, opts, verbose) {
        return ["table", {},
                ["tr", { highlight: "Title", align: "left" },
                    ["th", {}, "--- " + title + " ---"]],
                this.map(opts, opt =>
                    ["tr", {},
                        ["td", {},
                            ["div", { highlight: "Message" },
                                ["span", { style: opt.isDefault ? "" : "font-weight: bold" },
                                    opt.pre, opt.name],
                                ["span", {}, opt.value],
                                opt.isDefault || opt.default == null ? "" : ["span", { class: "extra-info" }, " (default: ", opt.default, ")"]],
                            verbose && opt.setFrom ? ["div", { highlight: "Message" },
                                                         "       Last set from ",
                                                         template.sourceLink(opt.setFrom)] : ""]])];
    },

    sourceLink: function (frame) {
        let url = util.fixURI(frame.filename || "unknown");
        let path = util.urlPath(url);

        return ["a", { "dactyl:command": "buffer.viewSource",
                        href: url, path: path, line: frame.lineNumber,
                        highlight: "URL" },
            path + ":" + frame.lineNumber];
    },

    table: function table(title, data, indent) {
        let table = ["table", {},
            ["tr", { highlight: "Title", align: "left" },
                ["th", { colspan: "2" }, title]],
            this.map(data, datum =>
                ["tr", {},
                    ["td", { style: "font-weight: bold; min-width: 150px; padding-left: " + (indent || "2ex") }, datum[0]],
                    ["td", {}, datum[1]]])];

        if (table[3].length)
            return table;
    },

    tabular: function tabular(headings, style, iter) {
        // TODO: This might be mind-bogglingly slow. We'll see.
        return ["table", {},
            ["tr", { highlight: "Title", align: "left" },
                this.map(headings, h =>
                    ["th", {}, h])],
            this.map(iter, row =>
                ["tr", {},
                    this.map(Iterator(row), ([i, d]) =>
                        ["td", { style: style[i] || "" }, d])])];
    },

    usage: function usage(iter, format={}) {
        let desc = format.description || (item => this.linkifyHelp(item.description));
        let help = format.help || (item => item.name);
        let sourceLink = frame => {
            let source = this.sourceLink(frame);
            source[1]["dactyl:hint"] = source[2];
            return source;
        };
        return ["table", {},
            format.headings ?
                ["thead", { highlight: "UsageHead" },
                    ["tr", { highlight: "Title", align: "left" },
                        this.map(format.headings, h => ["th", {}, h])]] :
                [],
            format.columns ?
                ["colgroup", {},
                    this.map(format.columns, c => ["col", { style: c }])] :
                [],
            ["tbody", { highlight: "UsageBody" },
                this.map(iter, item => {
                    // Urgh.
                    let name = item.name || item.names[0];
                    let frame = item.definedAt;

                    return ["tr", { highlight: "UsageItem" },
                               ["td", { style: "padding-right: 2em;" },
                                   ["span", { highlight: "Usage Link" },
                                       !frame ? name :
                                           [this.helpLink(help(item), name, "Title"),
                                            ["span", { highlight: "LinkInfo" },
                                               _("io.definedAt"), " ",
                                               sourceLink(frame)]]]],
                               item.columns ? this.map(item.columns, c => ["td", {}, c]) : [],
                               ["td", {}, desc(item)]];
                })]];
    }
});

endModule();

// vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript:
dactyl-1.2~r20151231/common/modules/util.jsm000066400000000000000000002022351264147376100205020ustar00rootroot00000000000000// Copyright (c) 2006-2008 by Martin Stubenschrott 
// Copyright (c) 2007-2011 Doug Kearns 
// Copyright (c) 2008-2015 Kris Maglione 
//
// This work is licensed for reuse under an MIT license. Details are
// given in the LICENSE.txt file included with this file.
"use strict";

try {

defineModule("util", {
    exports: ["DOM", "$", "FailedAssertion", "Math", "NS", "Point", "Util", "XBL", "XHTML", "XUL", "util"],
    require: ["dom", "promises", "services"]
});

lazyRequire("overlay", ["overlay"]);
lazyRequire("storage", ["File", "storage"]);
lazyRequire("template", ["template"]);

var Magic = Class("Magic", {
    init: function init(str) {
        this.str = str;
    },

    get message() { return this.str; },

    toString: function () { return this.str; }
});

var FailedAssertion = Class("FailedAssertion", ErrorBase, {
    init: function init(message, level, noTrace) {
        if (noTrace !== undefined)
            this.noTrace = noTrace;
        init.supercall(this, message, level);
    },

    level: 3,

    noTrace: true
});

var Point = Struct("Point", "x", "y");

var wrapCallback = function wrapCallback(fn, isEvent) {
    if (!fn.wrapper)
        fn.wrapper = function wrappedCallback() {
            try {
                let res = fn.apply(this, arguments);
                if (isEvent && res === false) {
                    arguments[0].preventDefault();
                    arguments[0].stopPropagation();
                }
                return res;
            }
            catch (e) {
                util.reportError(e);
                return undefined;
            }
        };
    fn.wrapper.wrapped = fn;
    return fn.wrapper;
};

let anythingObjectHack = new Proxy({}, {
    get(target, prop) {
        util.dump("Attempt to access UI method before UI ready: " + prop);
        return function(...args) {
            util.dump(`Attempt to use UI method before UI ready: ${prop}(${args})`);

            util.lateDactylMethods.push([prop, args]);
        };
    },
});

var Util = Module("Util", XPCOM([Ci.nsIObserver, Ci.nsISupportsWeakReference]), {
    Magic: Magic,

    init: function init() {
        this.Array = Ary;

        this.addObserver(this);
        this.windows = [];
        this.lateDactylMethods = [];
    },

    activeWindow: deprecated("overlay.activeWindow", { get: function activeWindow() { return overlay.activeWindow; } }),
    overlayObject: deprecated("overlay.overlayObject", { get: function overlayObject() { return overlay.bound.overlayObject; } }),
    overlayWindow: deprecated("overlay.overlayWindow", { get: function overlayWindow() { return overlay.bound.overlayWindow; } }),

    compileMatcher: deprecated("DOM.compileMatcher", { get: function compileMatcher() { return DOM.compileMatcher; } }),
    computedStyle: deprecated("DOM#style", function computedStyle(elem) { return DOM(elem).style; }),
    domToString: deprecated("DOM.stringify", { get: function domToString() { return DOM.stringify; } }),
    editableInputs: deprecated("DOM.editableInputs", { get: function editableInputs(elem) { return DOM.editableInputs; } }),
    escapeHTML: deprecated("DOM.escapeHTML", { get: function escapeHTML(elem) { return DOM.escapeHTML; } }),

    evaluateXPath: deprecated("DOM.XPath",
                              function evaluateXPath(path, elem, asIterator) {
                                  return DOM.XPath(path, elem || util.activeWindow.content.document, asIterator);
                              }),

    isVisible: deprecated("DOM#isVisible", function isVisible(elem) { return DOM(elem).isVisible; }),
    makeXPath: deprecated("DOM.makeXPath", { get: function makeXPath(elem) { return DOM.makeXPath; } }),
    namespaces: deprecated("DOM.namespaces", { get: function namespaces(elem) { return DOM.namespaces; } }),
    namespaceNames: deprecated("DOM.namespaceNames", { get: function namespaceNames(elem) { return DOM.namespaceNames; } }),
    parseForm: deprecated("DOM#formData", function parseForm(elem) { return values(DOM(elem).formData).toArray(); }),
    scrollIntoView: deprecated("DOM#scrollIntoView", function scrollIntoView(elem, alignWithTop) { return DOM(elem).scrollIntoView(alignWithTop); }),
    validateMatcher: deprecated("DOM.validateMatcher", { get: function validateMatcher() { return DOM.validateMatcher; } }),

    map: deprecated("iter.map", function map(obj, fn, self) { return iter(obj).map(fn, self).toArray(); }),
    writeToClipboard: deprecated("dactyl.clipboardWrite", function writeToClipboard(str, verbose) { return util.dactyl.clipboardWrite(str, verbose); }),
    readFromClipboard: deprecated("dactyl.clipboardRead", function readFromClipboard() { return util.dactyl.clipboardRead(false); }),

    chromePackages: deprecated("config.chromePackages", { get: function chromePackages() { return config.chromePackages; } }),
    haveGecko: deprecated("config.haveGecko", { get: function haveGecko() { return config.bound.haveGecko; } }),
    OS: deprecated("config.OS", { get: function OS() { return config.OS; } }),

    identity: deprecated("identity", { get: function identity() { return global.identity; } }),

    dactyl: new Proxy(function (obj) {
        let global;
        if (obj)
            global = Class.objectGlobal(obj);

        return (global && global.dactyl ||
                loaded.overlay && overlay.activeWindow && overlay.activeWindow.dactyl ||
                anythingObjectHack);
    }, {
        get(target, prop) {
            if (prop in target)
                return target[prop];

            return target()[prop];
        },
    }),

    flushLateMethods(dactyl) {
        while (this.lateDactylMethods.length) {
            let [meth, args] = this.lateDactylMethods.shift();

            this.trapErrors(meth, dactyl, ...args);
        }
    },

    /**
     * Registers a obj as a new observer with the observer service. obj.observe
     * must be an object where each key is the name of a target to observe and
     * each value is a function(subject, data) to be called when the given
     * target is broadcast. obj.observe will be replaced with a new opaque
     * function. The observer is automatically unregistered on application
     * shutdown.
     *
     * @param {object} obj
     */
    addObserver: update(function addObserver(obj) {
        if (!obj.observers)
            obj.observers = obj.observe;

        let cleanup = ["dactyl-cleanup-modules", "quit-application"];

        function register(meth) {
            for (let target of new RealSet(cleanup.concat(Object.keys(obj.observers))))
                try {
                    services.observer[meth](obj, target, true);
                }
                catch (e) {}
        }

        Class.replaceProperty(obj, "observe",
            function (subject, target, data) {
                try {
                    if (~cleanup.indexOf(target))
                        register("removeObserver");
                    if (obj.observers[target])
                        obj.observers[target].call(obj, subject, data);
                }
                catch (e) {
                    if (typeof util === "undefined")
                        addObserver.dump("dactyl: error: " + e + "\n" + (e.stack || addObserver.Error().stack).replace(/^/gm, "dactyl:    "));
                    else
                        util.reportError(e);
                }
            });

        obj.observe.unregister = () => register("removeObserver");
        register("addObserver");
    }, { dump: dump, Error: Error }),

    /*
     * Tests a condition and throws a FailedAssertion error on
     * failure.
     *
     * @param {boolean} condition The condition to test.
     * @param {string} message The message to present to the
     *     user on failure.
     */
    assert: function assert(condition, message, quiet) {
        if (!condition)
            throw FailedAssertion(message, 1, quiet === undefined ? true : quiet);
        return condition;
    },

    /**
     * CamelCases a -non-camel-cased identifier name.
     *
     * @param {string} name The name to mangle.
     * @returns {string} The mangled name.
     */
    camelCase: function camelCase(name) {
        return String.replace(name, /-(.)/g, (m, m1) => m1.toUpperCase());
    },

    /**
     * Capitalizes the first character of the given string.
     * @param {string} str The string to capitalize
     * @returns {string}
     */
    capitalize: function capitalize(str) {
        return str && str[0].toUpperCase() + str.slice(1).toLowerCase();
    },

    /**
     * Returns a RegExp object that matches characters specified in the range
     * expression *list*, or signals an appropriate error if *list* is invalid.
     *
     * @param {string} list Character list, e.g., "a b d-xA-Z" produces /[abd-xA-Z]/.
     * @param {string} accepted Character range(s) to accept, e.g. "a-zA-Z" for
     *     ASCII letters. Used to validate *list*.
     * @returns {RegExp}
     */
    charListToRegexp: function charListToRegexp(list, accepted) {
        list = list.replace(/\s+/g, "");

        // check for chars not in the accepted range
        this.assert(RegExp("^[" + accepted + "-]+$").test(list),
                    _("error.charactersOutsideRange", JSON.stringify(accepted)));

        // check for illegal ranges
        for (let [match] of this.regexp.iterate(/.-./g, list))
            this.assert(match.charCodeAt(0) <= match.charCodeAt(2),
                        _("error.invalidCharacterRange", list.slice(list.indexOf(match))));

        return RegExp("[" + util.regexp.escape(list) + "]");
    },

    /**
     * Returns a shallow copy of *obj*.
     *
     * @param {Object} obj
     * @returns {Object}
     */
    cloneObject: function cloneObject(obj) {
        if (isArray(obj))
            return obj.slice();
        let newObj = {};
        for (let [k, v] of iter(obj))
            newObj[k] = v;
        return newObj;
    },

    /**
     * Clips a string to a given length. If the input string is longer
     * than *length*, an ellipsis is appended.
     *
     * @param {string} str The string to truncate.
     * @param {number} length The length of the returned string.
     * @returns {string}
     */
    clip: function clip(str, length) {
        return str.length <= length ? str : str.substr(0, length - 3) + "...";
    },

    /**
     * Compares two strings, case insensitively. Return values are as
     * in String#localeCompare.
     *
     * @param {string} a
     * @param {string} b
     * @returns {number}
     */
    compareIgnoreCase: function compareIgnoreCase(a, b) {
        return String.localeCompare(a.toLowerCase(), b.toLowerCase());
    },

    compileFormat: function compileFormat(format) {
        let stack = [frame()];
        stack.__defineGetter__("top", function () {
            return this[this.length - 1];
        });

        function frame() {
            return update(function _frame(obj) {
                return _frame === stack.top || _frame.valid(obj)
                            ? _frame.elements.map(e => callable(e) ? e(obj) : e)
                                            .join("")
                            : "";
            }, {
                elements: [],
                seen: new RealSet,
                valid: function valid(obj) {
                    return this.elements.every(e => !e.test || e.test(obj));
                }
            });
        }

        let end = 0;
        for (let match of util.regexp.iterate(/(.*?)%(.)/gy, format)) {

            let [, prefix, char] = match;
            end += match[0].length;

            if (prefix)
                stack.top.elements.push(prefix);
            if (char === "%")
                stack.top.elements.push("%");
            else if (char === "[") {
                let f = frame();
                stack.top.elements.push(f);
                stack.push(f);
            }
            else if (char === "]") {
                stack.pop();
                util.assert(stack.length, /*L*/"Unmatched %] in format");
            }
            else {
                let quote = function quote(obj, char) { return obj[char]; };
                if (char !== char.toLowerCase())
                    quote = function quote(obj, char) { return Commands.quote(obj[char]); };
                char = char.toLowerCase();

                stack.top.elements.push(update(
                    obj => obj[char] != null ? quote(obj, char)
                                             : "",
                    { test: function test(obj) { return obj[char] != null; } }));

                for (let elem of stack)
                    elem.seen[char] = true;
            }
        }
        if (end < format.length)
            stack.top.elements.push(format.substr(end));

        util.assert(stack.length === 1, /*L*/"Unmatched %[ in format");
        return stack.top;
    },

    /**
     * Compiles a macro string into a function which generates a string
     * result based on the input *macro* and its parameters. The
     * definitive documentation for macro strings resides in :help
     * macro-string.
     *
     * Macro parameters may have any of the following flags:
     *     e: The parameter is only tested for existence. Its
     *        interpolation is always empty.
     *     q: The result is quoted such that it is parsed as a single
     *        argument by the Ex argument parser.
     *
     * The returned function has the following additional properties:
     *
     *     seen {set}: The set of parameters used in this macro.
     *
     *     valid {function(object)}: Returns true if every parameter of
     *          this macro is provided by the passed object.
     *
     * @param {string} macro The macro string to compile.
     * @param {boolean} keepUnknown If true, unknown macro parameters
     *      are left untouched. Otherwise, they are replaced with the null
     *      string.
     * @returns {function}
     */
    compileMacro: function compileMacro(macro, keepUnknown) {
        let stack = [frame()];
        stack.__defineGetter__("top", function () {
            return this[this.length - 1];
        });

        let unknown = identity;
        if (!keepUnknown)
            unknown = () => "";

        // FIXME: duplicated in compileFormat
        function frame() {
            return update(function _frame(obj) {
                return _frame === stack.top || _frame.valid(obj)
                            ? _frame.elements.map(e => callable(e) ? e(obj) : e)
                                            .join("")
                            : "";
            }, {
                elements: [],
                seen: new RealSet,
                valid: function valid(obj) {
                    return this.elements.every(e => !e.test || e.test(obj));
                }
            });
        }

        let defaults = { lt: "<", gt: ">" };

        let re = util.regexp(String.raw`
            ([^]*?) // 1
            (?:
                (<\{) | // 2
                (< ((?:[a-z]-)?[a-z-]+?) (?:\[([0-9]+)\])? >) | // 3 4 5
                (\}>) // 6
            )
        `, "gixy");

        macro = String(macro);
        let end = 0;
        for (let match of re.iterate(macro)) {
            let [, prefix, open, full, macro, idx, close] = match;
            end += match[0].length;

            if (prefix)
                stack.top.elements.push(prefix);
            if (open) {
                let f = frame();
                stack.top.elements.push(f);
                stack.push(f);
            }
            else if (close) {
                stack.pop();
                util.assert(stack.length, /*L*/"Unmatched }> in macro");
            }
            else {
                let [, flags, name] = /^((?:[a-z]-)*)(.*)/.exec(macro);
                flags = new RealSet(flags);

                let quote = identity;
                if (flags.has("q"))
                    quote = function quote(obj) {
                        return typeof obj === "number" ? obj : JSON.stringify(obj);
                    };
                if (flags.has("e"))
                    quote = function quote(obj) { return ""; };

                if (hasOwnProp(defaults, name))
                    stack.top.elements.push(quote(defaults[name]));
                else {
                    let index = idx;
                    if (idx) {
                        idx = Number(idx) - 1;
                        stack.top.elements.push(update(
                            obj => obj[name] != null && idx in obj[name] ? quote(obj[name][idx])
                                                                         : hasOwnProp(obj, name) ? "" : unknown(full),
                            {
                                test: function test(obj) {
                                    return obj[name] != null &&
                                           idx in obj[name] &&
                                           obj[name][idx] !== false &&
                                           (!flags.e || obj[name][idx] != "");
                                }
                            }));
                    }
                    else {
                        stack.top.elements.push(update(
                            obj => obj[name] != null ? quote(obj[name])
                                                     : hasOwnProp(obj, name) ? "" : unknown(full),
                            {
                                test: function test(obj) {
                                    return obj[name] != null &&
                                           obj[name] !== false &&
                                           (!flags.e || obj[name] != "");
                                }
                            }));
                    }

                    for (let elem of stack)
                        elem.seen.add(name);
                }
            }
        }
        if (end < macro.length)
            stack.top.elements.push(macro.substr(end));

        util.assert(stack.length === 1, /*L*/"Unmatched <{ in macro");
        return stack.top;
    },

    /**
     * Converts any arbitrary string into an URI object. Returns null on
     * failure.
     *
     * @param {string} str
     * @returns {nsIURI|null}
     */
    createURI: function createURI(str) {
        try {
            let uri = services.urifixup.createFixupURI(str, services.urifixup.FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP);
            uri instanceof Ci.nsIURL;
            return uri;
        }
        catch (e) {
            return null;
        }
    },

    /**
     * Expands brace globbing patterns in a string.
     *
     * Example:
     *     "a{b,c}d" => ["abd", "acd"]
     *
     * @param {string|[string|Array]} pattern The pattern to deglob.
     * @returns [string] The resulting strings.
     */
    debrace: function debrace(pattern) {
        try {
            if (isArray(pattern)) {
                // Jägermonkey hates us.
                let obj = ({
                    res: [],
                    rec: function rec(acc) {
                        let vals;

                        while (isString(vals = pattern[acc.length]))
                            acc.push(vals);

                        if (acc.length == pattern.length)
                            this.res.push(acc.join(""));
                        else
                            for (let val of values(vals))
                                this.rec(acc.concat(val));
                    }
                });
                obj.rec([]);
                return obj.res;
            }

            if (!pattern.includes("{"))
                return [pattern];

            let res = [];

            let split = function split(pattern, re, fn, dequote) {
                let end = 0, match, res = [];
                while (match = re.exec(pattern)) {
                    end = match.index + match[0].length;
                    res.push(match[1]);
                    if (fn)
                        fn(match);
                }
                res.push(pattern.substr(end));
                return res.map(s => util.dequote(s, dequote));
            };

            let patterns = [];
            let substrings = split(pattern, /((?:[^\\{]|\\.)*)\{((?:[^\\}]|\\.)*)\}/gy,
                match => {
                    patterns.push(split(match[2], /((?:[^\\,]|\\.)*),/gy,
                        null, ",{}"));
                }, "{}");

            let rec = function rec(acc) {
                if (acc.length == patterns.length)
                    res.push(Ary(substrings).zip(acc).flatten().join(""));
                else
                    for (let pattern of patterns[acc.length])
                        rec(acc.concat(pattern));
            };
            rec([]);
            return res;
        }
        catch (e if e.message && e.message.includes("res is undefined")) {
            // prefs.safeSet() would be reset on :rehash
            prefs.set("javascript.options.methodjit.chrome", false);
            util.dactyl.warn(_(UTF8("error.damnYouJägermonkey")));
            return [];
        }
    },

    /**
     * Briefly delay the execution of the passed function.
     *
     * @param {function} callback The function to delay.
     */
    delay: function delay(callback) {
        let { mainThread } = services.threading;
        mainThread.dispatch(callback,
                            mainThread.DISPATCH_NORMAL);
    },

    /**
     * Removes certain backslash-quoted characters while leaving other
     * backslash-quoting sequences untouched.
     *
     * @param {string} pattern The string to unquote.
     * @param {string} chars The characters to unquote.
     * @returns {string}
     */
    dequote: function dequote(pattern, chars) {
        return pattern.replace(/\\(.)/,
                               (m0, m1) => chars.includes(m1) ? m1 : m0);
    },

    /**
     * Returns the nsIDocShell for the given window.
     *
     * @param {Window} win The window for which to get the docShell.
     * @returns {nsIDocShell}
     */

     docShell: function docShell(win) {
         return win.QueryInterface(Ci.nsIInterfaceRequestor)
                   .getInterface(Ci.nsIWebNavigation)
                   .QueryInterface(Ci.nsIDocShell);
     },

    /**
     * Prints a message to the console. If *msg* is an object it is pretty
     * printed.
     *
     * @param {string|Object} msg The message to print.
     */
    dump: defineModule.dump,

    /**
     * Returns a list of reformatted stack frames from
     * {@see Error#stack}.
     *
     * @param {string} stack The stack trace from an Error.
     * @returns {[string]} The stack frames.
     */
    stackLines: function stackLines(stack) {
        let lines = [];
        let match, re = /([^]*?)@([^@\n]*)(?:\n|$)/g;
        while (match = re.exec(stack))
            lines.push(match[1].replace(/\n/g, "\\n").substr(0, 80) + "@" +
                       util.fixURI(match[2]));
        return lines;
    },

    /**
     * Dumps a stack trace to the console.
     *
     * @param {string} msg The trace message.
     * @param {number} frames The number of frames to print.
     */
    dumpStack: function dumpStack(msg="Stack", frames=null) {
        let stack = util.stackLines(Error().stack);
        stack = stack.slice(1, 1 + (frames || stack.length)).join("\n").replace(/^/gm, "    ");
        util.dump(msg + "\n" + stack + "\n");
    },

    /**
     * Escapes quotes, newline and tab characters in *str*. The returned string
     * is delimited by *delimiter* or " if *delimiter* is not specified.
     *
     * @param {string} str
     * @param {string} delimiter
     * @returns {string}
     */
    escapeString: function escapeString(str, delimiter) {
        if (delimiter == undefined)
            delimiter = '"';
        return delimiter + str.replace(/([\\'"])/g, "\\$1").replace(/\n/g, "\\n").replace(/\t/g, "\\t") + delimiter;
    },

    /**
     * Converts *bytes* to a pretty printed data size string.
     *
     * @param {number} bytes The number of bytes.
     * @param {string} decimalPlaces The number of decimal places to use if
     *     *humanReadable* is true.
     * @param {boolean} humanReadable Use byte multiples.
     * @returns {string}
     */
    formatBytes: function formatBytes(bytes, decimalPlaces, humanReadable) {
        const unitVal = ["Bytes", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"];
        let unitIndex = 0;
        let tmpNum = parseInt(bytes, 10) || 0;
        let strNum = [tmpNum + ""];

        if (humanReadable) {
            while (tmpNum >= 1024) {
                tmpNum /= 1024;
                if (++unitIndex > (unitVal.length - 1))
                    break;
            }

            let decPower = Math.pow(10, decimalPlaces);
            strNum = ((Math.round(tmpNum * decPower) / decPower) + "").split(".", 2);

            if (!strNum[1])
                strNum[1] = "";

            while (strNum[1].length < decimalPlaces) // pad with "0" to the desired decimalPlaces)
                strNum[1] += "0";
        }

        for (let u = strNum[0].length - 3; u > 0; u -= 3) // make a 10000 a 10,000
            strNum[0] = strNum[0].substr(0, u) + "," + strNum[0].substr(u);

        if (unitIndex) // decimalPlaces only when > Bytes
            strNum[0] += "." + strNum[1];

        return strNum[0] + " " + unitVal[unitIndex];
    },

    /**
     * Converts *seconds* into a human readable time string.
     *
     * @param {number} seconds
     * @returns {string}
     */
    formatSeconds: function formatSeconds(seconds) {
        function pad(n, val) {
            return ("0000000" + val).substr(-Math.max(n, String(val).length));
        }
        function div(num, denom) {
            return [Math.floor(num / denom), Math.round(num % denom)];
        }
        let days, hours, minutes;

        [minutes, seconds] = div(Math.round(seconds), 60);
        [hours, minutes]   = div(minutes, 60);
        [days, hours]      = div(hours,   24);
        if (days)
            return /*L*/days + " days " + hours + " hours";
        if (hours)
            return /*L*/hours + "h " + minutes + "m";
        if (minutes)
            return /*L*/minutes + ":" + pad(2, seconds);
        return /*L*/seconds + "s";
    },

    /**
     * Returns the file which backs a given URL, if available.
     *
     * @param {nsIURI} uri The URI for which to find a file.
     * @returns {File|null}
     */
    getFile: function getFile(uri) {
        try {
            if (isString(uri))
                uri = util.newURI(uri);

            if (uri instanceof Ci.nsIFileURL)
                return File(uri.file);

            if (uri instanceof Ci.nsIFile)
                return File(uri);

            let channel = services.io.newChannelFromURI(uri);
            try { channel.cancel(Cr.NS_BINDING_ABORTED); } catch (e) {}
            if (channel instanceof Ci.nsIFileChannel)
                return File(channel.file);
        }
        catch (e) {}
        return null;
    },

    /**
     * Returns the host for the given URL, or null if invalid.
     *
     * @param {string} url
     * @returns {string|null}
     */
    getHost: function getHost(url) {
        try {
            return util.createURI(url).host;
        }
        catch (e) {}
        return null;
    },

    /**
     * Sends a synchronous or asynchronous HTTP request to *url* and returns
     * the XMLHttpRequest object. If *callback* is specified the request is
     * asynchronous and the *callback* is invoked with the object as its
     * argument.
     *
     * @param {string} url
     * @param {object} params Optional parameters for this request:
     *    method: {string} The request method. @default "GET"
     *
     *    params: {object} Parameters to append to *url*'s query string.
     *    data: {*} POST data to send to the server. Ordinary objects
     *              are converted to FormData objects, with one datum
     *              for each property/value pair.
     *
     *    onload:   {function(XMLHttpRequest, Event)} The request's load event handler.
     *    onerror:  {function(XMLHttpRequest, Event)} The request's error event handler.
     *    callback: {function(XMLHttpRequest, Event)} An event handler
     *              called for either error or load events.
     *
     *    background: {boolean} Whether to perform the request in the
     *                background. @default true
     *
     *    mimeType: {string} Override the response mime type with the
     *              given value.
     *    responseType: {string} Override the type of the "response"
     *                  property.
     *
     *    headers: {objects} Extra request headers.
     *
     *    user: {string} The user name to send via HTTP Authentication.
     *    pass: {string} The password to send via HTTP Authentication.
     *
     *    quiet: {boolean} If true, don't report errors.
     *
     * @returns {XMLHttpRequest}
     */
    httpGet: function httpGet(url, params={}, self=null) {
        if (callable(params))
            // Deprecated.
            params = { callback: params.bind(self) };

        try {
            let xmlhttp = services.Xmlhttp();
            xmlhttp.mozBackgroundRequest = hasOwnProp(params, "background") ? params.background : true;

            let async = params.callback || params.onload || params.onerror;
            if (async) {
                xmlhttp.addEventListener("load",  event => { util.trapErrors(params.onload  || params.callback, params, xmlhttp, event); }, false);
                xmlhttp.addEventListener("error", event => { util.trapErrors(params.onerror || params.callback, params, xmlhttp, event); }, false);
            }

            if (isObject(params.params)) {
                let encode = ([key, val]) => `${encodeURIComponent(key)}=${encodeURIComponent(val)}`;
                let data = Object.entries(params).map(encode);

                let uri = util.newURI(url);
                uri.query += (uri.query ? "&" : "") + data.join("&");

                url = uri.spec;
            }

            if (isObject(params.data) && !(params.data instanceof Ci.nsISupports)) {
                let data = services.FormData();
                for (let [k, v] of iter(params.data))
                    data.append(k, v);
                params.data = data;
            }

            if (params.mimeType)
                xmlhttp.overrideMimeType(params.mimeType);

            if (params.method == "HEAD" && !params.notificationCallbacks)
                params.notificationCallbacks = Class(XPCOM([Ci.nsIChannelEventSink, Ci.nsIInterfaceRequestor]), {
                    getInterface: function getInterface(iid) {
                        return this.QueryInterface(iid);
                    },

                    asyncOnChannelRedirect: function (oldChannel, newChannel, flags, callback) {
                        if (newChannel instanceof Ci.nsIHttpChannel)
                            newChannel.requestMethod = "HEAD";
                        callback.onRedirectVerifyCallback(Cr.NS_OK);
                    }
                })();

            let args = [params.method || "GET", url, async];
            if (params.user != null || params.pass != null)
                args.push(params.user);
            if (params.pass != null)
                args.push(params.pass);

            apply(xmlhttp, "open", args);

            for (let [header, val] of iter(params.headers || {}))
                xmlhttp.setRequestHeader(header, val);

            if (params.responseType)
                xmlhttp.responseType = params.responseType;

            if (params.notificationCallbacks)
                xmlhttp.channel.notificationCallbacks = params.notificationCallbacks;

            xmlhttp.send(params.data);
            return xmlhttp;
        }
        catch (e) {
            if (!params.quiet)
                util.reportError(e);
            return null;
        }
    },

    /**
     * Like #httpGet, but returns a promise rather than accepting
     * callbacks.
     *
     * @param {string} url The URL to fetch.
     * @param {object} params Parameter object, as in #httpGet.
     */
    fetchUrl: function fetchUrl(url, params) {
        return new CancelablePromise((accept, reject, canceled) => {
            params = update({}, params);
            params.onload = accept;
            params.onerror = reject;

            let req = this.httpGet(url, params);
            canceled.then(req.cancel);
        });
    },

    /**
     * Returns the intersection of two rectangles.
     *
     * @param {Object} r1
     * @param {Object} r2
     * @returns {Object}
     */
    intersection: function intersection(r1, r2) {
        return {
            get width()  { return this.right  - this.left; },
            get height() { return this.bottom - this.top; },
            left: Math.max(r1.left, r2.left),
            right: Math.min(r1.right, r2.right),
            top: Math.max(r1.top, r2.top),
            bottom: Math.min(r1.bottom, r2.bottom)
        };
    },

    /**
     * Returns true if the given stack frame resides in Dactyl code.
     *
     * @param {nsIStackFrame} frame
     * @returns {boolean}
     */
    isDactyl: Class.Memoize(function () {
        let base = util.regexp.escape(Components.stack.filename.replace(/[^\/]+$/, ""));
        let re = RegExp("^(?:.* -> )?(?:resource://dactyl(?!-content/eval.js)|" + base + ")\\S+$");
        return function isDactyl(frame) { return re.test(frame.filename); };
    }),

    /**
     * Returns true if *url* is in the domain *domain*.
     *
     * @param {string} url
     * @param {string} domain
     * @returns {boolean}
     */
    isDomainURL: function isDomainURL(url, domain) {
        return util.isSubdomain(util.getHost(url), domain);
    },

    /**
     * Returns true if *host* is a subdomain of *domain*.
     *
     * @param {string} host The host to check.
     * @param {string} domain The base domain to check the host against.
     * @returns {boolean}
     */
    isSubdomain: function isSubdomain(host, domain) {
        if (host == null)
            return false;
        let idx = host.lastIndexOf(domain);
        return idx > -1 && idx + domain.length == host.length && (idx == 0 || host[idx - 1] == ".");
    },

    /**
     * Iterates over all currently open documents, including all
     * top-level window and sub-frames thereof.
     */
    iterDocuments: function* iterDocuments(types) {
        types = types ? types.map(s => "type" + util.capitalize(s))
                      : ["typeChrome", "typeContent"];

        let windows = services.windowMediator.getXULWindowEnumerator(null);
        while (windows.hasMoreElements()) {
            let window = windows.getNext().QueryInterface(Ci.nsIXULWindow);
            for (let type of types) {
                let docShells = window.docShell.getDocShellEnumerator(Ci.nsIDocShellTreeItem[type],
                                                                      Ci.nsIDocShell.ENUMERATE_FORWARDS);
                while (docShells.hasMoreElements()) {
                    let viewer = docShells.getNext().QueryInterface(Ci.nsIDocShell).contentViewer;
                    if (viewer)
                        yield viewer.DOMDocument;
                }
            }
        }
    },

    // ripped from Firefox; modified
    unsafeURI: Class.Memoize(() => {
        return util.regexp(
            String.raw`
                [
                    \s
                    // Invisible characters (bug 452979)
                    U001C U001D U001E U001F // file/group/record/unit separator
                    U00AD // Soft hyphen
                    UFEFF // BOM
                    U2060 // Word joiner
                    U2062 U2063 // Invisible times/separator
                    U200B UFFFC // Zero-width space/no-break space

                    // Bidi formatting characters. (RFC 3987 sections 3.2 and 4.1 paragraph 6)
                    U200E U200F U202A U202B U202C U202D U202E
                ]
            `.replace(/U/g, "\\u"),
            "gx");
    }),

    losslessDecodeURI: function losslessDecodeURI(url) {
        return url.split("%25").map(function (url) {
                // Non-UTF-8 compliant URLs cause "malformed URI sequence" errors.
                try {
                    return decodeURI(url).replace(this.unsafeURI, encodeURIComponent);
                }
                catch (e) {
                    return url;
                }
            }, this).join("%25").replace(/[\s.,>)]$/, encodeURIComponent);
    },

    /**
     * Creates a DTD fragment from the given object. Each property of
     * the object is converted to an ENTITY declaration. SGML special
     * characters other than ' and % are left intact.
     *
     * @param {object} obj The object to convert.
     * @returns {string} The DTD fragment containing entity declaration
     *      for *obj*.
     */
    makeDTD: function makeDTD(obj) {
        let map = {
            "'": "'", '"': """, "%": "%",
            "&": "&",  "<": "<",   ">": ">"
        };

        function escape(val) {
           let isDOM = DOM.isJSONXML(val);
           return String.replace(val == null ? "null" :
                                 isDOM       ? DOM.toXML(val)
                                             : val,
                                 isDOM ? /['%]/g
                                       : /['"%&<>]/g,
                                 m => map[m]);
        }

        return iter(obj).map(([k, v]) =>
                             [""].join(""))
                        .join("\n");
    },

    /**
     * Converts a URI string into a URI object.
     *
     * @param {string} uri
     * @returns {nsIURI}
     */
    newURI: function newURI(uri, charset, base) {
        if (uri instanceof Ci.nsIURI)
            var res = uri.clone();
        else {
            let idx = uri.lastIndexOf(" -> ");
            if (~idx)
                uri = uri.slice(idx + 4);

            res = this.withProperErrors("newURI", services.io, uri, charset, base);
        }
        res instanceof Ci.nsIURL;
        return res;
    },

    /**
     * Removes leading garbage prepended to URIs by the subscript
     * loader.
     */
    fixURI: function fixURI(url) {
        return String.replace(url, /.* -> /, "");
    },

    /**
     * Pretty print a JavaScript object. Use HTML markup to color certain items
     * if *color* is true.
     *
     * @param {Object} object The object to pretty print.
     * @param {boolean} color Whether the output should be colored.
     * @returns {string}
     */
    objectToString: function objectToString(object, color) {
        if (object == null)
            return object + "\n";

        if (!isObject(object))
            return String(object);

        if (object instanceof Ci.nsIDOMElement || object instanceof DOM) {
            let elem = object;
            if (elem.nodeType == elem.TEXT_NODE)
                return elem.data;

            return DOM(elem).repr(color);
        }

        try { // for window.JSON
            var obj = String(object);
        }
        catch (e) {
            obj = Object.prototype.toString.call(obj);
        }

        if (color) {
            obj = template.highlightFilter(util.clip(obj, 150), "\n",
                                           () => ["span", { highlight: "NonText" },
                                                      "^J"]);

            var head = ["span", { highlight: "Title Object" }, obj, "::\n"];
        }
        else
            head = util.clip(obj, 150).replace(/\n/g, "^J") + "::\n";

        let keys_ = [];

        // window.content often does not want to be queried with "var i in object"
        try {
            if (isArray(object))
                object = iter(object);

            let hasValue = !(Symbol.iterator in object || isinstance(object, ["Generator", "Iterator", Iter]));
            let keyIter = hasValue ? keys(object) : object;

            if (object.dactyl && object.modules && object.modules.modules == object.modules) {
                object = Iterator(object);
                hasValue = false;
            }

            for (let i of keyIter) {
                let value = Magic("");
                try {
                    value = object[i];
                }
                catch (e) {}

                if (!hasValue) {
                    if (isArray(i) && i.length == 2)
                        [i, value] = i;
                    else {
                        var noVal = true;
                        value = i;
                    }
                }

                let key = i;
                if (!isNaN(i))
                    i = parseInt(i);
                else if (/^[A-Z_]+$/.test(i))
                    i = "";

                if (color)
                    value = template.highlight(value, true, 150, !color);
                else if (value instanceof Magic)
                    value = String(value);
                else
                    value = util.clip(String(value).replace(/\n/g, "^J"), 150);

                if (noVal)
                    var val = value;
                else if (color)
                    val = [["span", { highlight: "Key" }, key], ": ", value];
                else
                    val = key + ": " + value;

                keys_.push([i, val]);
            }
        }
        catch (e) {
            util.reportError(e);
        }

        function compare(a, b) {
            if (!isNaN(a[0]) && !isNaN(b[0]))
                return a[0] - b[0];
            return String.localeCompare(String(a[0]),
                                        String(b[0]));
        }

        let vals = template.map(keys_.sort(compare), f => f[1],
                                "\n");

        if (color) {
            return ["div", { style: "white-space: pre-wrap" }, head, vals];
        }
        return head + vals.join("");
    },

    prettifyJSON: function prettifyJSON(data, indent, invalidOK) {
        const INDENT = indent || "    ";

        function rec(data, level, seen) {
            if (isObject(data)) {
                seen = new RealSet(seen);
                if (seen.add(data))
                    throw Error("Recursive object passed");
            }

            let prefix = level + INDENT;

            if (data === undefined)
                data = null;

            if (~["boolean", "number"].indexOf(typeof data) || data === null)
                res.push(String(data));
            else if (isinstance(data, ["String", _]))
                res.push(JSON.stringify(data));
            else if (isArray(data)) {
                if (data.length == 0)
                    res.push("[]");
                else {
                    res.push("[\n");
                    for (let [i, val] of iter(data)) {
                        if (i)
                            res.push(",\n");
                        res.push(prefix);
                        rec(val, prefix, seen);
                    }
                    res.push("\n", level, "]");
                }
            }
            else if (isObject(data)) {
                res.push("{\n");

                let i = 0;
                for (let [key, val] of iter(data)) {
                    if (i++)
                        res.push(",\n");
                    res.push(prefix, JSON.stringify(key), ": ");
                    rec(val, prefix, seen);
                }
                if (i > 0)
                    res.push("\n", level, "}");
                else
                    res[res.length - 1] = "{}";
            }
            else if (invalidOK)
                res.push({}.toString.call(data));
            else
                throw Error("Invalid JSON object");
        }

        let res = [];
        rec(data, "", new RealSet);
        return res.join("");
    },

    observers: {
        "dactyl-cleanup-modules": function cleanupModules(subject, reason) {
            defineModule.loadLog.push("dactyl: util: observe: dactyl-cleanup-modules " + reason);

            for (let module of defineModule.modules)
                if (module.cleanup) {
                    util.dump("cleanup: " + module.constructor.className);
                    util.trapErrors(module.cleanup, module, reason);
                }
        }
    },

    /**
     * A generator that returns the values between *start* and *end*, in *step*
     * increments.
     *
     * @param {number} start The interval's start value.
     * @param {number} end The interval's end value.
     * @param {number} step The value to step the range by. May be negative.
     *     @default 1
     * @returns {Generator(number)}
     */
    range: function* range(start, end, step=1) {
        if (step > 0) {
            for (; start < end; start += step)
                yield start;
        }
        else {
            while (start > end)
                yield start += step;
        }
    },

    /**
     * An interruptible generator that returns all values between *start* and
     * *end*. The thread yields every *time* milliseconds.
     *
     * @param {number} start The interval's start value.
     * @param {number} end The interval's end value.
     * @param {number} time The time in milliseconds between thread yields.
     * @returns {Iterator(Object)}
     */
    interruptibleRange: function* interruptibleRange(start, end, time) {
        let endTime = Date.now() + time;
        while (start < end) {
            if (Date.now() > endTime) {
                util.threadYield(true, true);
                endTime = Date.now() + time;
            }
            yield start++;
        }
    },

    /**
     * Creates a new RegExp object based on the value of expr stripped
     * of all white space and interpolated with the values from tokens.
     * If tokens, any string in the form of  in expr is replaced
     * with the value of the property, 'key', from tokens, if that
     * property exists. If the property value is itself a RegExp, its
     * source is substituted rather than its string value.
     *
     * Additionally, expr is stripped of all JavaScript comments.
     *
     * This is similar to Perl's extended regular expression format.
     *
     * @param {string} expr The expression to compile into a RegExp.
     * @param {string} flags Flags to apply to the new RegExp.
     * @param {object} tokens The tokens to substitute. @optional
     * @returns {RegExp} A custom regexp object.
     */
    regexp: update(function (expr, flags, tokens) {
        if (!flags)
            flags = Object.entries({ g: "global",
                                     i: "ignorecase",
                                     m: "multiline",
                                     y: "sticky" })
                          .filter(([short, full]) => expr[full])
                          .map(([short]) => short)
                          .join("");

        if (isinstance(expr, ["RegExp"]))
            expr = expr.source;

        expr = String.replace(expr, /\\(.)/, function (m, m1) {
            if (m1 === "c")
                flags = flags.replace(/i/g, "") + "i";
            else if (m1 === "C")
                flags = flags.replace(/i/g, "");
            else
                return m;
            return "";
        });

        // Replace replacement .
        if (tokens)
            expr = String.replace(expr, /(\(?P)?<(\w+)>/g,
                                  (m, n1, n2) => !n1 && hasOwnProp(tokens, n2) ?    tokens[n2].dactylSource
                                                                                 || tokens[n2].source
                                                                                 || tokens[n2]
                                                                               : m);

        // Strip comments and white space.
        if (/x/.test(flags))
            expr = String.replace(expr, /(\\.)|\/\/[^\n]*|\/\*[^]*?\*\/|\s+/gm,
                                  (m, m1) => m1 || "");

        // Replace (?P parameters)
        if (/\(\?P]+)>|(\?))?/gy,
                function (m0, m1, m2, m3) {
                    if (!m3)
                        groups.push(m2 || "-group-" + groups.length);
                    return m1 + "(" + (m3 || "");
                });
            var struct = Struct.apply(null, groups);
        }

        let res = update(RegExp(expr, flags.replace("x", "")), {
            bound: Class.Property(Object.getOwnPropertyDescriptor(Class.prototype, "bound")),
            closure: Class.Property(Object.getOwnPropertyDescriptor(Class.prototype, "bound")),
            dactylPropertyNames: ["exec", "match", "test", "toSource", "toString", "global", "ignoreCase", "lastIndex", "multiLine", "source", "sticky"],
            iterate: function iterate(str, idx) {
                return util.regexp.iterate(this, str, idx);
            }
        });

        // Return a struct with properties for named parameters if we
        // have them.
        if (struct)
            update(res, {
                exec: function exec() {
                    let match = exec.superapply(this, arguments);

                    return match && struct.fromArray(match);
                },
                dactylSource: source,
                struct: struct
            });
        return res;
    }, {
        /**
         * Escapes Regular Expression special characters in *str*.
         *
         * @param {string} str
         * @returns {string}
         */
        escape: function regexp_escape(str) {
            return str.replace(/([\\{}()[\]^$.?*+|])/g, "\\$1");
        },

        /**
         * Given a RegExp, returns its source in the form showable to the user.
         *
         * @param {RegExp} re The regexp showable source of which is to be returned.
         * @returns {string}
         */
        getSource: function regexp_getSource(re) {
            return re.source.replace(/\\(.)/g,
                                     (m0, m1) => m1 === "/" ? m1
                                                            : m0);
        },

        /**
         * Iterates over all matches of the given regexp in the given
         * string.
         *
         * @param {RegExp} regexp The regular expression to execute.
         * @param {string} string The string to search.
         * @param {number} lastIndex The index at which to begin searching. @optional
         */
        iterate: function iterate(regexp, string, lastIndex) {
            return iter(function* () {
                regexp.lastIndex = lastIndex = lastIndex || 0;
                let match;
                while (match = regexp.exec(string)) {
                    lastIndex = regexp.lastIndex;
                    yield match;
                    regexp.lastIndex = lastIndex;
                    if (match[0].length == 0 || !regexp.global)
                        break;
                }
            }());
        }
    }),

    /**
     * Flushes the startup or jar cache.
     */
    flushCache: function flushCache(file) {
        if (file)
            services.observer.notifyObservers(file, "flush-cache-entry", "");
        else
            services.observer.notifyObservers(null, "startupcache-invalidate", "");
    },

    /**
     * Reloads dactyl in entirety by disabling the add-on and
     * re-enabling it.
     */
    rehash: function rehash(args) {
        storage.storeForSession("commandlineArgs", args);
        this.timeout(function () {
            this.flushCache();
            cache.flush(bind("test", /^literal:/));
            let addon = config.addon;
            addon.userDisabled = true;
            addon.userDisabled = false;
        });
    },

    errorCount: 0,
    errors: Class.Memoize(() => []),
    maxErrors: 15,
    /**
     * Reports an error to the Error Console and the standard output,
     * along with a stack trace and other relevant information. The
     * error is appended to {@see #errors}.
     */
    reportError: function reportError(error) {
        if (error.noTrace)
            return;

        if (isString(error))
            error = Error(error);

        Cu.reportError(error);

        try {
            this.errorCount++;

            let obj = update({}, error, {
                toString: function () { return String(error); },
                stack: Magic(util.stackLines(String(error.stack || Error().stack)).join("\n").replace(/^/mg, "\t"))
            });

            services.console.logStringMessage(obj.stack);

            this.errors.push([new Date, obj + "\n" + obj.stack]);
            this.errors = this.errors.slice(-this.maxErrors);
            this.errors.toString = function () {
                return this.map(([name, stack]) => `${name}\n${stack}\n`)
                           .join("\n");
            };

            this.dump(String(error));
            this.dump(obj);
            this.dump("");
        }
        catch (e) {
            try {
                this.dump(String(error));
                this.dump(util.stackLines(error.stack).join("\n"));
            }
            catch (e) { dump(e + "\n"); }
            dump("Stack: " + Error().stack + "\n");
        }

        // ctypes.open("libc.so.6").declare("kill", ctypes.default_abi, ctypes.void_t, ctypes.int, ctypes.int)(
        //     ctypes.open("libc.so.6").declare("getpid", ctypes.default_abi, ctypes.int)(), 2)
    },

    /**
     * Given a domain, returns an array of all non-toplevel subdomains
     * of that domain.
     *
     * @param {string} host The host for which to find subdomains.
     * @returns {[string]}
     */
    subdomains: function subdomains(host) {
        if (/(^|\.)\d+$|:.*:/.test(host))
            // IP address or similar
            return [host];

        let base = host.replace(/.*\.(.+?\..+?)$/, "$1");
        try {
            base = services.tld.getBaseDomainFromHost(host);
        }
        catch (e) {}

        let parts = host.split(".");

        return Array.from(util.range(parts.length, 0, -1),
                          i => parts.slice(i).join("."))
                    .filter(host => host.length >= base.length);
    },

    /**
     * Returns the selection controller for the given window.
     *
     * @param {Window} window
     * @returns {nsISelectionController}
     */
    selectionController: function selectionController(win) {
        return win.QueryInterface(Ci.nsIInterfaceRequestor)
                  .getInterface(Ci.nsIWebNavigation)
                  .QueryInterface(Ci.nsIInterfaceRequestor)
                  .getInterface(Ci.nsISelectionDisplay)
                  .QueryInterface(Ci.nsISelectionController);
    },

    /**
     * Escapes a string against shell meta-characters and argument
     * separators.
     */
    shellEscape: function shellEscape(str) {
        // Pass through simple strings without escaping.
        if (/^[-+\w/.,/:]+$/.test(str))
            return str;

        return '"' + String.replace(str, /[\\"$`]/g, "\\$&") + '"';
    },

    /**
     * Suspend execution for at least *delay* milliseconds. Functions by
     * yielding execution to the next item in the main event queue, and
     * so may lead to unexpected call graphs, and long delays if another
     * handler yields execution while waiting.
     *
     * @param {number} delay The time period for which to sleep in milliseconds.
     */
    sleep: function sleep(delay) {
        let mainThread = services.threading.mainThread;

        let end = Date.now() + delay;
        while (Date.now() < end)
            mainThread.processNextEvent(true);
        return true;
    },

    /**
     * Behaves like String.split, except that when *limit* is reached,
     * the trailing element contains the entire trailing portion of the
     * string.
     *
     *     util.split("a, b, c, d, e", /, /, 3) -> ["a", "b", "c, d, e"]
     *
     * @param {string} str The string to split.
     * @param {RegExp|string} re The regular expression on which to split the string.
     * @param {number} limit The maximum number of elements to return.
     * @returns {[string]}
     */
    split: function split(str, re, limit) {
        re.lastIndex = 0;
        if (!re.global)
            re = RegExp(re.source || re, "g");
        let match, start = 0, res = [];
        while (--limit && (match = re.exec(str)) && match[0].length) {
            res.push(str.substring(start, match.index));
            start = match.index + match[0].length;
        }
        res.push(str.substring(start));
        return res;
    },

    /**
     * Split a string on literal occurrences of a marker.
     *
     * Specifically this ignores occurrences preceded by a backslash, or
     * contained within 'single' or "double" quotes.
     *
     * It assumes backslash escaping on strings, and will thus not count quotes
     * that are preceded by a backslash or within other quotes as starting or
     * ending quoted sections of the string.
     *
     * @param {string} str
     * @param {RegExp} marker
     * @returns {[string]}
     */
    splitLiteral: function splitLiteral(str, marker) {
        let results = [];
        let resep = RegExp(/^(([^\\'"]|\\.|'([^\\']|\\.)*'|"([^\\"]|\\.)*")*?)/.source + marker.source);
        let cont = true;

        while (cont) {
            cont = false;
            str = str.replace(resep, function (match, before) {
                results.push(before);
                cont = match !== "";
                return "";
            });
        }

        results.push(str);
        return results;
    },

    yielders: 0,
    /**
     * Yields execution to the next event in the current thread's event
     * queue. This is a potentially dangerous operation, since any
     * yielders higher in the event stack will prevent execution from
     * returning to the caller until they have finished their wait. The
     * potential for deadlock is high.
     *
     * @param {boolean} flush If true, flush all events in the event
     *      queue before returning. Otherwise, wait for an event to
     *      process before proceeding.
     * @param {boolean} interruptable If true, this yield may be
     *      interrupted by pressing , in which case,
     *      Error("Interrupted") will be thrown.
     */
    threadYield: function threadYield(flush, interruptable) {
        this.yielders++;
        try {
            let mainThread = services.threading.mainThread;
            /* FIXME */
            util.interrupted = false;
            do {
                mainThread.processNextEvent(!flush);
                if (util.interrupted)
                    throw Error("Interrupted");
            }
            while (flush === true && mainThread.hasPendingEvents());
        }
        finally {
            this.yielders--;
        }
    },

    /**
     * Waits for the function *test* to return true, or *timeout*
     * milliseconds to expire.
     *
     * @param {function|Promise} test The predicate on which to wait.
     * @param {object} self The 'this' object for *test*.
     * @param {Number} timeout The maximum number of milliseconds to
     *      wait.
     *      @optional
     * @param {boolean} interruptable If true, may be interrupted by
     *      pressing , in which case, Error("Interrupted") will be
     *      thrown.
     */
    waitFor: function waitFor(test, self, timeout, interruptable) {
        if (!callable(test)) {
            let done = false;
            var promise = test,
                retVal;
            promise.then(arg => { retVal = arg; done = true; },
                         arg => { retVal = arg; done = true; });
            test = () => done;
        }

        let end = timeout && Date.now() + timeout, result;

        let timer = services.Timer(function () {}, 10, services.Timer.TYPE_REPEATING_SLACK);
        try {
            while (!(result = test.call(self)) && (!end || Date.now() < end))
                this.threadYield(false, interruptable);
        }
        finally {
            timer.cancel();
        }
        return promise ? retVal: result;
    },

    /**
     * Makes the passed function yieldable. Each time the function calls
     * yield, execution is suspended for the yielded number of
     * milliseconds.
     *
     * Example:
     *      let func = yieldable(function () {
     *          util.dump(Date.now()); // 0
     *          yield 1500;
     *          util.dump(Date.now()); // 1500
     *      });
     *      func();
     *
     * @param {function} func The function to mangle.
     * @returns {function} A new function which may not execute
     *      synchronously.
     */
    yieldable: deprecated("Task.spawn", function yieldable(func) {
        return function magic() {
            let gen = func.apply(this, arguments);
            (function next() {
                try {
                    util.timeout(next, gen.next());
                }
                catch (e if e instanceof StopIteration) {};
            })();
        };
    }),

    /**
     * Wraps a callback function such that its errors are not lost. This
     * is useful for DOM event listeners, which ordinarily eat errors.
     * The passed function has the property *wrapper* set to the new
     * wrapper function, while the wrapper has the property *wrapped*
     * set to the original callback.
     *
     * @param {function} callback The callback to wrap.
     * @returns {function}
     */
    wrapCallback: wrapCallback,

    /**
     * Returns the top-level chrome window for the given window.
     *
     * @param {Window} win The child window.
     * @returns {Window} The top-level parent window.
     */
    topWindow: function topWindow(win) {
        let docShell =  win.QueryInterface(Ci.nsIInterfaceRequestor)
                           .getInterface(Ci.nsIDocShell);
        let { rootTreeItem } = docShell;
        if (rootTreeItem)
            return rootTreeItem.QueryInterface(Ci.nsIInterfaceRequestor)
                               .getInterface(Ci.nsIDOMWindow);
    },

    /**
     * Traps errors in the called function, possibly reporting them.
     *
     * @param {function} func The function to call
     * @param {object} self The 'this' object for the function.
     */
    trapErrors: function trapErrors(func, self, ...args) {
        try {
            return apply(self || this, func, args);
        }
        catch (e) {
            this.reportError(e);
            return undefined;
        }
    },

    /**
     * Returns the file path of a given *url*, for debugging purposes.
     * If *url* points to a file (even if indirectly), the native
     * filesystem path is returned. Otherwise, the URL itself is
     * returned.
     *
     * @param {string} url The URL to mangle.
     * @returns {string} The path to the file.
     */
    urlPath: function urlPath(url) {
        try {
            return util.getFile(url).path;
        }
        catch (e) {
            return url;
        }
    },

    /**
     * Iterates, depth-first, over the given window and all of its descendant
     * frames.
     *
     * @param {nsIDOMWindow} win The root window.
     * @returns {Generator(nsIDOMWindow)}
     */
    iterFrames: function* iterFrames(win) {
        yield win;
        for (let i = 0; i < win.frames.length; i++)
            yield* iterFrames(win.frames[i]);
    },

    /**
     * Returns a list of all domains and subdomains of documents in the
     * given window and all of its descendant frames.
     *
     * @param {nsIDOMWindow} win The window for which to find domains.
     * @returns {[string]} The visible domains.
     */
    visibleHosts: function visibleHosts(win) {
        let res = [], seen = new RealSet;
        for (let frame of this.iterFrames(win)) {
            try {
                if (frame.location.hostname)
                    res = res.concat(util.subdomains(frame.location.hostname));
            }
            catch (e) {}
        }
        return res.filter(h => !seen.add(h));
    },

    /**
     * Returns a list of URIs of documents in the given window and all
     * of its descendant frames.
     *
     * @param {nsIDOMWindow} win The window for which to find URIs.
     * @returns {[nsIURI]} The visible URIs.
     */
    visibleURIs: function visibleURIs(win) {
        let res = [], seen = new RealSet;
        for (let frame of this.iterFrames(win)) {
            try {
                res.push(util.newURI(frame.location.href));
            }
            catch (e) {}
        }
        return res.filter(h => !seen.add(h.spec));
    },

    /**
     * Like Cu.getWeakReference, but won't crash if you pass null.
     */
    weakReference: function weakReference(jsval) {
        if (jsval == null)
            return { get: function get() { return null; } };
        return Cu.getWeakReference(jsval);
    },

    /**
     * Wraps native exceptions thrown by the called function so that a
     * proper stack trace may be retrieved from them.
     *
     * @param {function|string} meth The method to call.
     * @param {object} self The 'this' object of the method.
     * @param ... Arguments to pass to *meth*.
     */
    withProperErrors: function withProperErrors(meth, self, ...args) {
        try {
            return (callable(meth) ? meth : self[meth]).apply(self, args);
        }
        catch (e) {
            throw e.stack ? e : Error(e);
        }
    }
}, {
    Array: Ary
});

/**
 * Math utility methods.
 * @singleton
 */
var GlobalMath = Math;
this.Math = update(Object.create(GlobalMath), {
    /**
     * Returns the specified *value* constrained to the range *min* - *max*.
     *
     * @param {number} value The value to constrain.
     * @param {number} min The minimum constraint.
     * @param {number} max The maximum constraint.
     * @returns {number}
     */
    constrain: function constrain(value, min, max) {
        return Math.min(Math.max(min, value), max);
    }
});

endModule();

} catch(e){ if (!e.stack) e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); }

// vim: set fdm=marker sw=4 sts=4 ts=8 et ft=javascript:
dactyl-1.2~r20151231/common/process_config.awk000066400000000000000000000006201264147376100210430ustar00rootroot00000000000000BEGIN {
    chrome = "chrome"
    if (suffix)
        chrome = suffix
}
/^    \}/              { on = 0 }

on && $NF ~ /^"([a-z]|\.\/)/ {
    $NF = "\"/" name "/" substr($NF, 2)
}
/./ && on {
    sub(/^"\.\./, "\"", $NF);
    $NF = "\"" chrome substr($NF, 2)
}
/./ && on {
    gsub(/\/\.\//, "/")
    sub(/^\"\.\.\/common\//, "\"", $NF)
    $0 = "        " $0
}
//

/^    "resources": \{/ { on = 1 }
dactyl-1.2~r20151231/common/process_manifest.awk000066400000000000000000000006511264147376100214100ustar00rootroot00000000000000BEGIN {
    chrome = "chrome"
    if (suffix)
        chrome = suffix
}

{ content = $1 ~ /^(content|skin|locale|resource)$/ }

content && $NF ~ /^([a-z]|\.\/)/ {
    $NF = "/" name "/" $NF
}
content {
    sub(/^\.\./, "", $NF);
    if (isjar)
	    $NF = "jar:chrome/" name ".jar!" $NF
    else
	    $NF = chrome $NF
}
{
    gsub(/\/\.\//, "/")
    sub("^\\.\\./common/", "", $NF)
    print
}

# vim:se sts=4 sw=4 et ft=awk:
dactyl-1.2~r20151231/common/skin/000077500000000000000000000000001264147376100163025ustar00rootroot00000000000000dactyl-1.2~r20151231/common/skin/dactyl.css000066400000000000000000000144331264147376100203010ustar00rootroot00000000000000@namespace dactyl url("http://vimperator.org/namespaces/liberator");
@namespace html url("http://www.w3.org/1999/xhtml");
@namespace xul url("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul");

/* Applied to all content */
[dactyl|activeframe] {
    -moz-binding: url(resource://dactyl-content/bindings.xml#frame) !important;
}

[dactyl|modifiable][dactyl|modifiable] {
    -moz-user-input: enabled !important;
}

[dactyl|highlight~=hints] {
    -moz-binding: url(resource://dactyl-content/bindings.xml#hints) !important;
    position: static !important;
}

[dactyl|highlight~=HintImage],
[dactyl|highlight~=Hint] {
    z-index: 50000;
    position: absolute !important;
}
input[type=file][dactyl|highlight~=HintActive],
input[type=file][dactyl|highlight~=HintElem] {
    opacity: 1 !important;
}

@-moz-document
    url-prefix(dactyl:) {

[dactyl|highlight~=HelpDefault] {
    -moz-binding: url(resource://dactyl-content/bindings.xml#compitem-td);
}
[dactyl|highlight~=HelpDefault] > .td-span {
    width: auto;
}

}

/* Applied only to completion buffer and MOW */
@-moz-document
    url-prefix(dactyl:),
    url-prefix(resource://dactyl) {

*:-moz-loading, *:-moz-broken { display: none !important; }

[dactyl|highlight~=Completions] {
    width: 100%;
    display: table;
}
[dactyl|highlight~=CompItem],
[dactyl|highlight~=CompTitle] {
    display: table-row;
}
[dactyl|highlight~=Completions] > ul {
    display: table-row;
}
[dactyl|highlight~=CompItem] > *,
[dactyl|highlight~=CompTitle] > * {
    -moz-binding: url(resource://dactyl-content/bindings.xml#compitem-td);
    display: table-cell;
    vertical-align: middle;
}

[dactyl|highlight~=CompMsg] {
    height: 1.5em;
    line-height: 1.5em !important;
}

.completion-items-container {
    overflow: hidden;
}

.td-span {
    display: inline-block;
    overflow: visible;
    width: 0px;
    height: 1.5em;
    line-height: 1.5em !important;
}
.td-strut {
    display: inline-block;
    vertical-align: middle;
    height: 16px;
    width: 0px;
}

.times-executed, .time-average { color: green; }
.time-total { color: red; }

}

@-moz-document
    url-prefix(dactyl:),
    url-prefix(resource://dactyl) {

*:-moz-any-link {
    color: green;
}
*:-moz-any-link:hover {
    text-decoration: underline;
}
}

/* Applied to completion buffer, MOW, browser window */
@-moz-document
    url-prefix(chrome:),
    url-prefix(dactyl:),
    url-prefix(resource:) {

#TabsToolbar .tab-icon-image, .tab-throbber { -moz-box-ordinal-group: 10; }
[dactyl|highlight~=tab-number]              { -moz-box-ordinal-group: 20; }
.tab-text, .tab-label, .tab-close-button    { -moz-box-ordinal-group: 50; }

[dactyl|highlight~=Bell] {
    -moz-appearance: none !important;
}
window[dactyl|highlight~=Bell] > * {
    opacity: 0 !important;
}

[dactyl|highlight~=CmdLine] {
    color: inherit !important;
}

.dactyl-status-field-url {
    color: inherit !important;
}

[dactyl|highlight~=CmdLine],
[dactyl|highlight~=CmdLine] > [dactyl|highlight~=CmdLine] {
    padding: 0px !important;
}

label[collapsed=true] {
    height: 0px;
    width: 0px;
}

.dactyl-container > * {
    font-family: inherit;
}

.dactyl-completions {
    -moz-user-focus: ignore;
    border-width: 0px !important;
    border-top: 1px solid black !important;
}

/* fixes the min-height: 22px from firefox */
statusbarpanel {
    -moz-appearance: none !important;
    border: 0 !important;
	min-height: 18px !important;
    background: transparent;
    text-shadow: inherit !important;
}

/* no longer at the window's bottom right corner */
.statusbar-resizerpanel {
    display: none;
}
#statusbar-display,
#statusbar-progresspanel,
#status-bar > #statusTextBox > #statusText {
    display: none;
    visibility: collapse;
}

#brower-bottombox > #addon-bar .toolbarbutton-1 > xul|dropmarker,
#dactyl-addon-bar .toolbarbutton-1 > xul|dropmarker {
    margin-left: 0 !important;
    margin-right: 0 !important;
}

#dactyl-addon-bar .toolbarbutton-1 > xul|dropmarker::after {
    content: "▾";
    color: white;
    font-size: 18px;
    line-height: 18px;
}

#nav-bar {
    padding-top: 0px !important;
    padding-bottom: 0px !important;
}

.dactyl-commandline-prompt {
    /* background-color: inherit; */
    margin: 0px;
    padding: 0px;
}
.dactyl-commandline-command {
    /* background-color: inherit !important; */
    color: inherit !important;
    margin: 0px;
}
.dactyl-commandline-command html|*:focus {
    outline-width: 0px !important
}
.dactyl-commandline-command .textbox-search-icons {
    visibility: collapse !important;
}
#dactyl-message {
    margin: 0px;
}

#sidebar {
    max-width: 90% !important;
    min-width: 10% !important;
}

/* MOW */

#dactyl-commandline-prompt *,
#dactyl-commandline-command {
    font: inherit;
}

/* for Teledactyl's composer */
#content-frame, #appcontent {
    border: 0px;
}

}

@-moz-document url(chrome://browser/content/browser.xul) {

/* Fix ginormous Australis tabs. */
[dactyl-australis=true] :-moz-any(xul|tab.tabbrowser-tab, .tabs-newtab-button)
        .tab-background > * {
    min-height: 24px !important;
    max-height: 24px !important;
}

[dactyl-australis=true] :-moz-any(xul|tab.tabbrowser-tab, .tabs-newtab-button)
    .tab-background > :-moz-any(.tab-background-start, .tab-background-end)::after {
    background-size: 30px 24px !important;
    max-height: 24px !important;
    min-height: 24px !important;
}

[dactyl-australis=true] .tabbrowser-tabs {
    min-height: 0 !important;
    max-height: 24px !important;
}

/* Fix stupid line... */
[dactyl-australis=true] #navigator-toolbox::after {
    height: 0 !important;
}

#nav-bar-customization-target > .toolbarbutton-1 {
    margin-top: -5px !important;
    margin-bottom: -5px !important;
}

/*
#PanelUI-button,
#PanelUI-menu-button,
#nav-bar-customization-target > .toolbarbutton-1,
#nav-bar-customization-target > .toolbarbutton-1 > xul|toolbarbutton {
    padding: 0 !important;
}

#nav-bar-customization-target > xul|toolbaritem > .toolbarbutton-1 {
    padding-top: 0 !important;
    padding-bottom: 0 !important;
}

#nav-bar-customization-target > .toolbarbutton-1,
#nav-bar-customization-target > .toolbarbutton-1 > xul|dropmarker > xul|image {
    margin-top: 0 !important;
    margin-bottom: 0 !important;
    max-height: 24px !important;
}

#nav-bar-customization-target #urlbar {
    margin-bottom: 0 !important;
}
*/

}

/* vim: set fdm=marker sw=4 ts=4 et: */
dactyl-1.2~r20151231/common/skin/global-styles.css000066400000000000000000000404041264147376100215770ustar00rootroot00000000000000Boolean      /* JavaScript booleans */       color: red;
Function     /* JavaScript functions */      color: navy;
Null         /* JavaScript null values */    color: blue;
Number       /* JavaScript numbers */        color: blue;
Object       /* JavaScript objects */        color: maroon;
String       /* String values */             color: green; white-space: pre;
Symbol       /* JavaScript symbols */        color: darkcyan;
Comment      /* JavaScriptor CSS comments */ color: gray;

Key          /* Keywords */                  font-weight: bold;

Enabled      /* Enabled item indicator text */  color: blue;
Disabled     /* Disabled item indicator text */ color: red;

FontFixed           /* The font used for fixed-width text */ \
                    font-family: monospace !important;
FontCode            /* The font used for code listings */ \
                    font-size: 9pt;  font-family: monospace !important;
FontProportional    /* The font used for proportionally spaced text */ \
                    font-size: 10pt; font-family: "Droid Sans", "Helvetica LT Std", Helvetica, "DejaVu Sans", Verdana, sans-serif !important;

    // Hack to give these groups slightly higher precedence
    // than their unadorned variants.
    CmdCmdLine;[dactyl|highlight]>*
    CmdErrorMsg;[dactyl|highlight]
    CmdInfoMsg;[dactyl|highlight]
    CmdModeMsg;[dactyl|highlight]
    CmdMoreMsg;[dactyl|highlight]
    CmdNormal;[dactyl|highlight]
    CmdQuestion;[dactyl|highlight]
    CmdWarningMsg;[dactyl|highlight]

    StatusCmdLine;[dactyl|highlight]>*
    StatusErrorMsg;[dactyl|highlight]
    StatusInfoMsg;[dactyl|highlight]
    StatusModeMsg;[dactyl|highlight]
    StatusMoreMsg;[dactyl|highlight]
    StatusNormal;[dactyl|highlight]
    StatusQuestion;[dactyl|highlight]
    StatusWarningMsg;[dactyl|highlight]

Normal            /* Normal text */ \
                  color: black   !important; background: white       !important; font-weight: normal !important;
StatusNormal      /* Normal text in the status line */ \
                  color: inherit !important; background: transparent !important;
ErrorMsg          /* Error messages */ \
                  color: white   !important; background: red         !important; font-weight: bold !important;
InfoMsg           /* Information messages */ \
                  color: black   !important; background: white       !important;
StatusInfoMsg     /* Information messages in the status line */ \
                  color: inherit !important; background: transparent !important;
LineNr            /* The line number of an error */ \
                  color: orange  !important; background: white       !important;
ModeMsg           /* The mode indicator */ \
                  color: black   !important; background: white       !important;
StatusModeMsg     /* The mode indicator in the status line */ \
                  color: inherit !important; background: transparent !important; padding-right: 1em;
MoreMsg           /* The indicator that there is more text to view */ \
                  color: green   !important; background: white       !important;
StatusMoreMsg                                background: transparent !important;
Message           /* A message as displayed in :messages */ \
                  white-space: pre-wrap !important; min-width: 100%; width: 100%; padding-left: 4em; text-indent: -4em; display: block;
Message String    /* A message as displayed in :messages */ \
                  white-space: pre-wrap;
NonText           /* The ~ indicators which mark blank lines in the completion list */ \
                  color: blue; background: transparent !important;
*Preview          /* The completion preview displayed in the &tag.command-line; */ \
                  color: gray;
Question          /* A prompt for a decision */ \
                  color: green   !important; background: white       !important; font-weight: bold !important;
StatusQuestion    /* A prompt for a decision in the status line */ \
                  color: green   !important; background: transparent !important;
WarningMsg        /* A warning message */ \
                  color: red     !important; background: white       !important;
StatusWarningMsg  /* A warning message in the status line */ \
                  color: red     !important; background: transparent !important;
Disabled          /* Disabled items */ \
                  color: gray    !important;

!Private;xul|window[privatebrowsingmode]  /* A private browsing window */

Private StatusLine::before  /* From the default theme: */ \
                            display: -moz-box; \
                            content: ""; \
                            background: url("chrome://browser/skin/privatebrowsing-mask.png") center no-repeat; \
                            width: 30px;

CmdLine;>*;;FontFixed   /* The command line */ \
                        padding: 1px !important;
CmdPrompt;.dactyl-commandline-prompt  /* The default styling form the command prompt */
CmdInput;.dactyl-commandline-command
CmdOutput         /* The output of commands executed by :run */ \
                  white-space: pre;

MOW;;;FontFixed,Normal         /* The Multiline Output Window */ \
                               margin: 0; white-space: pre;

MOW table                      white-space: inherit; border-spacing: 0px;
MOW :-moz-any(td, th)          padding: 0px 2px;

Comp;;;FontFixed,Normal        /* The completion window */ \
                               margin: 0; border-top: 1px solid black;

CompGroup                      /* Item group in completion output */
CompGroup:not(:first-of-type)  margin-top: .5em;
CompGroup:last-of-type         padding-bottom: 1.5ex;

CompTitle            /* Completion row titles */ \
                     color: magenta; background: white; font-weight: bold;
CompTitle>*          padding: 0 .5ex;
CompTitleSep         /* The element which separates the completion title from its results */ \
                     height: 1px; background: magenta; background: -moz-linear-gradient(60deg, magenta, white);

CompMsg              /* The message which may appear at the top of a group of completion results */ \
                     font-style: italic; margin-left: 16px;

CompItem             /* A single row of output in the completion list */
CompItem:nth-child(2n+1)    background: rgba(0, 0, 0, .04);
CompItem[selected]   /* A selected row of completion list */ \
                     background: yellow;
CompItem>*           padding: 0 .5ex;

CompIcon             /* The favicon of a completion row */ \
                     width: 16px; min-width: 16px; display: inline-block; margin-right: .5ex;
CompIcon>img         max-width: 16px; max-height: 16px; vertical-align: middle;

CompResult           /* The result column of the completion list */ \
                     width: 36%; padding-right: 1%; overflow: hidden;
CompDesc             /* The description column of the completion list */ \
                     color: gray; width: 62%; padding-left: 1em;

CompLess             /* The indicator shown when completions may be scrolled up */ \
                     text-align: center; height: 0;    line-height: .5ex; padding-top: 1ex;
CompLess::after      /* The character of indicator shown when completions may be scrolled up */ \
                     content: "⌃";

CompMore             /* The indicator shown when completions may be scrolled down */ \
                     text-align: center; height: .5ex; line-height: .5ex; margin-bottom: -.5ex;
CompMore::after      /* The character of indicator shown when completions may be scrolled down */ \
                     content: "⌄";

Dense              /* Arbitrary elements which should be packed densely together */\
                   margin-top: 0; margin-bottom: 0;

EditorEditing;;*   /* Text fields for which an external editor is open */ \
                   -moz-user-input: none !important; -moz-user-modify: read-only !important; \
                   background-color: #bbb !important;
*EditorEditing>*;;*  background-color: #bbb !important;
EditorError;;*     /* Text fields briefly after an error has occurred running the external editor */ \
                   background: red !important;
EditorBlink1;;*    /* Text fields briefly after successfully running the external editor, alternated with EditorBlink2 */ \
                   background: yellow !important;
EditorBlink2;;*    /* Text fields briefly after successfully running the external editor, alternated with EditorBlink1 */

REPL                /* Read-Eval-Print-Loop output */ \
                    overflow: auto; max-height: 40em;
REPL-R;;;Question   /* Prompts in REPL mode */
REPL-E              /* Evaled input in REPL mode */ \
                    white-space: pre-wrap;
REPL-P              /* Evaled output in REPL mode */ \
                    white-space: pre-wrap; margin-bottom: 1em;

Usage               /* Output from the :*usage commands */ \
                    width: 100%;
UsageHead           /* Headings in output from the :*usage commands */
UsageBody           /* The body of listings in output from the :*usage commands */
UsageItem           /* Individual items in output from the :*usage commands */
UsageItem:nth-of-type(2n)    background: rgba(0, 0, 0, .04);

Indicator   /* The # and  % in the :buffers list */ \
            color: blue; width: 1.5em; text-align: center;
Filter      /* The matching text in a completion list */ \
            font-weight: bold;

Keyword     /* A bookmark keyword for a URL */ \
            color: red;
Tag         /* A bookmark tag for a URL */ \
            color: blue;

Link                        /* A link with additional information shown on hover */ \
                            position: relative; padding-right: 2em;
Link:not(:hover)>LinkInfo   opacity: 0; left: 0; width: 1px; height: 1px; overflow: hidden;
LinkInfo                    {
    /* Information shown when hovering over a link */
    color: black;
    position: absolute;
    left: 100%;
    padding: 1ex;
    margin: -1ex -1em;
    background: rgba(255, 255, 255, .8);
    border-radius: 1ex;
}

StatusLine;;;FontFixed  {
    /* The status bar */
    -moz-appearance: none !important;
    font-weight: bold;
    background: transparent !important;
    border: 0px !important;
    padding-right: 0px !important;
    min-height: 18px !important;
    text-shadow: none !important;
}
StatusLineNormal;[dactyl|highlight]    /* The status bar for an ordinary web page */ \
                                       color: white !important; background: black   !important;
StatusLineBroken;[dactyl|highlight]    /* The status bar for a broken web page */ \
                                       color: black !important; background: #FFa0a0 !important; /* light-red */
StatusLineSecure;[dactyl|highlight]    /* The status bar for a secure web page */ \
                                       color: black !important; background: #a0a0FF !important; /* light-blue */
StatusLineExtended;[dactyl|highlight]  /* The status bar for a secure web page with an Extended Validation (EV) certificate */ \
                                       color: black !important; background: #a0FFa0 !important; /* light-green */

!TabClose;.tab-close-button            /* The close button of a browser tab */ \
                                       /* The close button of a browser tab */
!TabIcon;.tab-icon,.tab-icon-image     /* The icon of a browser tab */ \
                                       /* The icon of a browser tab */
!TabText;.tab-text                     /* The text of a browser tab */
TabNumber                              /* The number of a browser tab, next to its icon */ \
                                       font-weight: bold; margin: 0px; padding-right: .8ex; cursor: default;
TabIconNumber  {
    /* The number of a browser tab, over its icon */
    cursor: default;
    width: 16px;
    margin: 0 2px 0 -18px !important;
    font-weight: bold;
    color: white;
    text-align: center;
    text-shadow: black -1px 0 1px, black 0 1px 1px, black 1px 0 1px, black 0 -1px 1px;
}

Title       /* The title of a listing, including :pageinfo, :jumps */ \
            color: magenta; font-weight: bold;
URL         /* A URL */ \
            text-decoration: none; color: green; background: inherit;
URL:hover   text-decoration: underline; cursor: pointer;
URLExtra    /* Extra information about a URL */ \
            color: gray;

FrameIndicator;;* {
    /* The styling applied to briefly indicate the active frame */
    background-color: red;
    opacity: 0.5;
    z-index: 999999;
    position: fixed;
    top:      0;
    bottom:   0;
    left:     0;
    right:    0;
}

Bell          /* &dactyl.appName;’s visual bell */ \
              background-color: black !important;

Hinting;;*  /* A document which is currently being hinted */
Hint;;* {
    /* A hint indicator. See :help hints */
    font:        bold 10px "Droid Sans Mono", monospace !important;
    margin:      -.2ex;
    padding:     0 0 0 1px;
    outline:     1px solid rgba(0, 0, 0, .5);
    background:  rgba(255, 248, 231, .8);
    color:       black;
}
Hint[active];;*  background: rgba(255, 253, 208, .8);
Hint::after;;*   content: attr(text) !important;
HintElem;;*      /* The hintable element */ \
                 background-color: yellow  !important; color: black !important;
HintActive;;*    /* The hint element of link which will be followed by  */ \
                 background-color: #88FF00 !important; color: black !important;
HintImage;;*     /* The indicator which floats above hinted images */ \
                 opacity: .5 !important;

Button                  /* A button widget */ \
                        display: inline-block; font-weight: bold; cursor: pointer; color: black; text-decoration: none;
Button:hover            text-decoration: underline;
Button[collapsed]       visibility: collapse; width: 0;
Button::before          content: "["; color: gray; text-decoration: none !important;
Button::after           content: "]"; color: gray; text-decoration: none !important;
Button:not([collapsed]) ~ Button:not([collapsed])::before  content: "/[";

Buttons                 /* A group of buttons */

DownloadCell                    /* A table cell in the :downloads manager */ \
                                display: table-cell; padding: 0 1ex;

Downloads                       /* The :downloads manager */ \
                                display: table; margin: 0; padding: 0;
DownloadHead;;;CompTitle        /* A heading in the :downloads manager */ \
                                display: table-row;
DownloadHead>*;;;DownloadCell

Download                        /* A download in the :downloads manager */ \
                                display: table-row;
Download:not([active])          color: gray;
Download:nth-child(2n+1)        background: rgba(0, 0, 0, .04);

Download>*;;;DownloadCell
DownloadButtons                 /* A button group in the :downloads manager */
DownloadPercent                 /* The percentage column for a download */
DownloadProgress                /* The progress column for a download */
DownloadProgressHave            /* The completed portion of the progress column */
DownloadProgressTotal           /* The remaining portion of the progress column */
DownloadSource                  /* The download source column for a download */
DownloadState                   /* The download state column for a download */
DownloadTime                    /* The time remaining column for a download */
DownloadTitle                   /* The title column for a download */
DownloadTitle>Link>a         max-width: 48ex; overflow: hidden; display: inline-block;

AddonCell                    /* A cell in tell :addons manager */ \
                             display: table-cell; padding: 0 1ex;

Addons                       /* The :addons manager */ \
                             display: table; margin: 0; padding: 0;
AddonHead;;;CompTitle        /* A heading in the :addons manager */ \
                             display: table-row;
AddonHead>*;;;AddonCell

Addon                        /* An add-on in the :addons manager */ \
                             display: table-row;
Addon:not([active])          color: #888;
Addon:nth-child(2n+1)        background: rgba(0, 0, 0, .04);

Addon>*;;;AddonCell
AddonButtons
AddonDescription
AddonName                    max-width: 48ex; overflow: hidden;
AddonStatus
AddonVersion

// vim:se sts=4 sw=4 et ft=css:
dactyl-1.2~r20151231/common/skin/help-styles.css000066400000000000000000000270131264147376100212700ustar00rootroot00000000000000
InlineHelpLink                              /* A help link shown in the command line or multi-line output area */ \
                                            font-size: inherit !important; font-family: inherit !important;

Help;;;FontProportional                     /* A help page */ \
                                            line-height: 1.4em;

HelpInclude                                 /* A help page included in the consolidated help listing */ \
                                            margin: 2em 0;

HelpArg;;;FontCode                          /* A required command argument indicator */ \
                                            color: #6A97D4;
HelpOptionalArg;;;FontCode                  /* An optional command argument indicator */ \
                                            color: #6A97D4;

HelpBody                                    /* The body of a help page */ \
                                            display: block; margin: 1em auto; max-width: 100ex; padding-bottom: 1em; margin-bottom: 4em; border-bottom-width: 1px;
HelpBorder;*;dactyl://help/*                /* The styling of bordered elements */ \
                                            border-color: silver; border-width: 0px; border-style: solid;
HelpCode;;;FontCode                         /* Code listings */ \
                                            display: block; white-space: pre; margin-left: 2em;
HelpTT;html|tt;dactyl://help/*;FontCode     /* Teletype text */

HelpDefault;;;FontCode                      /* The default value of a help item */ \
                                            display: inline-block; margin: -1px 1ex 0 0; white-space: pre; vertical-align: text-top;

HelpDescription                             /* The description of a help item */ \
                                            display: block; clear: right;
HelpDescription[short]                      clear: none;
HelpEm;html|em;dactyl://help/*              /* Emphasized text */ \
                                            font-weight: bold; font-style: normal;

HelpEx;;;FontCode                           /* An Ex command */ \
                                            display: inline-block; color: #527BBD;

HelpExample                                 /* An example */ \
                                            display: block; margin: 1em 0;
HelpExample::before                         content: "__MSG_help.Example__: "; font-weight: bold;

HelpInfo                                    /* Arbitrary information about a help item */ \
                                            display: block; width: 20em; margin-left: auto;
HelpInfoLabel                               /* The label for a HelpInfo item */ \
                                            display: inline-block; width: 6em;  color: magenta; font-weight: bold; vertical-align: text-top;
HelpInfoValue                               /* The details for a HelpInfo item */ \
                                            display: inline-block; width: 14em; text-decoration: none;             vertical-align: text-top;

HelpItem                                    /* A help item */ \
                                            display: block; margin: 1em 1em 1em 10em; clear: both;

HelpKey;;;FontCode                          /* A keyboard key specification */ \
                                            color: #102663;
HelpKeyword                                 /* A keyword */ \
                                            font-weight: bold; color: navy;

HelpLink;html|a;dactyl://help/*             /* A hyperlink */ \
                                            text-decoration: none !important;
HelpLink[href]:hover                        text-decoration: underline !important;
HelpLink[href^="mailto:"]::after            content: "✉"; padding-left: .2em;
HelpLink[rel=external] {
    /* A hyperlink to an external resource */
    /* Thanks, Wikipedia */
    background: transparent url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAMAAAC67D+PAAAAFVBMVEVmmcwzmcyZzP8AZswAZv////////9E6giVAAAAB3RSTlP///////8AGksDRgAAADhJREFUGFcly0ESAEAEA0Ei6/9P3sEcVB8kmrwFyni0bOeyyDpy9JTLEaOhQq7Ongf5FeMhHS/4AVnsAZubxDVmAAAAAElFTkSuQmCC) no-repeat scroll right center;
    padding-right: 13px;
}

ErrorMsg HelpEx       color: inherit; background: inherit; text-decoration: underline;
ErrorMsg HelpKey      color: inherit; background: inherit; text-decoration: underline;
ErrorMsg HelpOption   color: inherit; background: inherit; text-decoration: underline;
ErrorMsg HelpTopic    color: inherit; background: inherit; text-decoration: underline;

HelpTOC               /* The Table of Contents for a help page */
HelpTOC>ol ol         margin-left: -1em;

HelpOrderedList;ol;dactyl://help/*                          /* Any ordered list */ \
                                                            margin: 1em 0;
HelpOrderedList1;ol[level="1"],ol;dactyl://help/*           /* A first-level ordered list */ \
                                                            list-style: outside decimal; display: block;
HelpOrderedList2;ol[level="2"],ol ol;dactyl://help/*        /* A second-level ordered list */ \
                                                            list-style: outside upper-alpha;
HelpOrderedList3;ol[level="3"],ol ol ol;dactyl://help/*     /* A third-level ordered list */ \
                                                            list-style: outside lower-roman;
HelpOrderedList4;ol[level="4"],ol ol ol ol;dactyl://help/*  /* A fourth-level ordered list */ \
                                                            list-style: outside decimal;

HelpList;html|ul;dactyl://help/*      /* An unordered list */ \
                                      display: block; list-style-position: outside; margin: 1em 0;
HelpListItem;html|li;dactyl://help/*  /* A list item, ordered or unordered */ \
                                      display: list-item;

HelpNote                                    /* The indicator for a note */ \
                                            color: red; font-weight: bold;

HelpOpt;;;FontCode                          /* An option name */ \
                                            color: #106326;
HelpOptInfo;;;FontCode                      /* Information about the type and default values for an option entry */ \
                                            display: block; margin-bottom: 1ex; padding-left: 4em;

HelpParagraph;html|p;dactyl://help/*        /* An ordinary paragraph */ \
                                            display: block; margin: 1em 0em;
HelpParagraph:first-child                   margin-top: 0;
HelpParagraph:last-child                    margin-bottom: 0;
HelpSpec;;;FontCode                         /* The specification for a help entry */ \
                                            display: block; margin-left: -10em; float: left; clear: left; color: #527BBD; margin-right: 1em;

HelpString;;;FontCode                       /* A quoted string */ \
                                            color: green; font-weight: normal;
HelpString::before                          content: '"';
HelpString::after                           content: '"';
HelpString[delim]::before                   content: attr(delim);
HelpString[delim]::after                    content: attr(delim);

HelpNews        /* A news item */           position: relative;
HelpNewsOld     /* An old news item */      opacity: .7;
HelpNewsNew     /* A new news item */       font-style: italic;
HelpNewsTag     /* The version tag for a news item */ \
                font-style: normal; position: absolute; left: 100%; padding-left: 1em; color: #527BBD; opacity: .6; white-space: pre;

HelpHead;html|h1,html|h2,html|h3,html|h4;dactyl://help/* {
    /* Any help heading */
    font-weight: bold;
    color: #527BBD;
    clear: both;
}
HelpHead1;html|h1;dactyl://help/* {
    /* A first-level help heading */
    margin: 2em 0 1em;
    padding-bottom: .2ex;
    border-bottom-width: 1px;
    font-size: 2em;
}
HelpHead2;html|h2;dactyl://help/* {
    /* A second-level help heading */
    margin: 2em 0 1em;
    padding-bottom: .2ex;
    border-bottom-width: 1px;
    font-size: 1.2em;
}
HelpHead3;html|h3;dactyl://help/* {
    /* A third-level help heading */
    margin: 1em 0;
    padding-bottom: .2ex;
    font-size: 1.1em;
}
HelpHead4;html|h4;dactyl://help/* {
    /* A fourth-level help heading */
}

HelpTab;html|dl;dactyl://help/* {
    /* A description table */
    display: table;
    width: 100%;
    margin: 1em 0;
    border-bottom-width: 1px;
    border-top-width: 1px;
    padding: .5ex 0;
    table-layout: fixed;
}
HelpTabColumn;html|column;dactyl://help/*   display: table-column;
HelpTabColumn:first-child                   width: 25%;
HelpTabTitle;html|dt;dactyl://help/*;FontCode  /* The title column of description tables */ \
                                            display: table-cell; padding: .1ex 1ex; font-weight: bold;
HelpTabDescription;html|dd;dactyl://help/*  /* The description column of description tables */ \
                                            display: table-cell; padding: .3ex 1em; text-indent: -1em; border-width: 0px;
HelpTabDescription>*;;dactyl://help/*       text-indent: 0;
HelpTabRow;html|dl>html|tr;dactyl://help/*  /* Entire rows in description tables */ \
                                            display: table-row;

HelpTag;;;FontCode                          /* A help tag */ \
                                            display: inline-block; color: #527BBD; margin-left: 1ex; font-weight: normal;
HelpTags                                    /* A group of help tags */ \
                                            display: block; float: right; clear: right;
HelpTopic;;;FontCode                        /* A link to a help topic */ \
                                            color: #102663;
HelpType;;;FontCode                         /* An option type */ \
                                            color: #102663 !important; margin-right: 2ex;

HelpWarning                                 /* The indicator for a warning */ \
                                            color: red; font-weight: bold;

HelpXMLBase;;;FontCode  {
    white-space: pre;
    color: #C5F779;
    background-color: #444444;
    font-family: Terminus, Fixed, monospace;
}
HelpXML;;;HelpXMLBase  {
    /* Highlighted XML */
    display: inline-block;
    border: 1px dashed #aaaaaa;
}
HelpXMLBlock;;;HelpXMLBase {
    display: block;
    margin-left: 2em;
    border: 1px dashed #aaaaaa;
}
HelpXMLAttribute                            color: #C5F779;
HelpXMLAttribute::after                     color: #E5E5E5; content: "=";
HelpXMLComment                              color: #444444;
HelpXMLComment::before                      content: "";
HelpXMLProcessing                           color: #C5F779;
HelpXMLProcessing::before                   color: #444444; content: "";
HelpXMLString                               color: #C5F779; white-space: pre;
HelpXMLString::before                       content: '"';
HelpXMLString::after                        content: '"';
HelpXMLNamespace                            color: #FFF796;
HelpXMLNamespace::after                     color: #777777; content: ":";
HelpXMLTagStart                             color: #FFF796; white-space: normal; display: inline-block; text-indent: -1.5em; padding-left: 1.5em;
HelpXMLTagEnd                               color: #71BEBE;
HelpXMLText                                 color: #E5E5E5;

CompItem HelpXMLTagStart                    white-space: pre;

// vim:se sts=4 sw=4 et ft=css:
dactyl-1.2~r20151231/common/tests/000077500000000000000000000000001264147376100165005ustar00rootroot00000000000000dactyl-1.2~r20151231/common/tests/functional/000077500000000000000000000000001264147376100206425ustar00rootroot00000000000000dactyl-1.2~r20151231/common/tests/functional/dactyl.jsm000066400000000000000000000460111264147376100226370ustar00rootroot00000000000000var utils = {}; Components.utils.import(/([^ ]+\/)[^\/]+$/.exec(Components.stack.filename)[1] + "utils.jsm", utils);

var EXPORTED_SYMBOLS = ["Controller"];

const { module, NS } = utils;

var elementslib = module("resource://mozmill/modules/elementslib.js");
var frame = module("resource://mozmill/modules/frame.js");
var jumlib = module("resource://mozmill/modules/jum.js");

function wrapAssertNoErrors(func, message) {
    return function wrapped(arg) this.assertNoErrors(func, this, arguments, message || arg);
}

function assertMessage(funcName, want, got, message) {
    if (typeof want === "string")
        return utils.assertEqual(funcName, want, got, message);
    else if (typeof want === "function") {
        var res = want(got);
        if (res === undefined)
            return true;
        return utils.test(res, {
            function: funcName,
            want: want, got: got,
            comment: message
        });
    }
    else
        return utils.test(want.test(got), {
            function: funcName,
            want: want, got: got,
            comment: message
        });
}

/**
 * A controller for simulating Dactyl related user actions and for making
 * assertions about the expected outcomes of such actions.
 *
 * @param {MozMillController} controller The browser's MozMill controller.
 */
function Controller(controller) {
    this.controller = controller;

    /**
     * @property {object} The dactyl modules namespace, to be used
     * sparingly in tests.
     */
    this.modules = controller.window.dactyl.modules;

    this.errorCount = 0;

    this._countBeep = () => {
        this.beepCount++;
    };
    this.errors = [];
    this._countError = (message, highlight) => {
        if (/\b(Error|Warning)Msg\b/.test(highlight))
            this.errors.push(String(message));
    };
    this.modules.dactyl.registerObserver("beep", this._countBeep);
    this.modules.dactyl.registerObserver("echoLine", this._countError);
    this.modules.dactyl.registerObserver("echoMultiline", this._countError);

    this.resetErrorCount();
}

Controller.prototype = {

    teardown: function () {
        this.modules.dactyl.unregisterObserver("beep", this._countBeep);
        this.modules.dactyl.unregisterObserver("echoLine", this._countError);
        this.modules.dactyl.unregisterObserver("echoMultiline", this._countError);
    },

    beepCount: 0,
    errorCount: 0,

    /**
     * Asserts that an error message is displayed during the execution
     * of *func*.
     *
     * @param {function} func A function to call during before the
     *      assertion takes place.
     * @param {object} self The 'this' object to be used during the call
     *      of *func*. @optional
     * @param {Array} args Arguments to be passed to *func*. @optional
     * @param {string} message The message to display upon assertion failure. @optional
     */
    assertMessageError: function (func, self, args, message) {
        let errorCount = this.errors.length;
        this.assertNoErrors(func, self, args, message);
        // dump("assertMessageError " + errorCount + " " + this.errorMessageCount + "\n");
        return utils.assert('dactyl.assertMessageError', this.errors.length > errorCount,
                            "Expected error but got none" + (message ? ": " + message : ""));
    },

    /**
     * Asserts that any output message text content matches *text*.
     *
     * @param {string|RegExp|function} want The expected text of the expected message line.
     * @param {string} message The message to display upon assertion failure.
     */
    assertMessage: function (want, message) {
        return assertMessage('dactyl.assertMessage', want,
                             this.readMessageWindow() || this.readMessageLine(),
                             message);
    },

    /**
     * Asserts that the output message line text content matches *text*.
     *
     * @param {string|RegExp|function} want The expected text of the expected message line.
     * @param {string} message The message to display upon assertion failure.
     */
    assertMessageLine: function (want, message) {
        return assertMessage('dactyl.assertMessageLine', want,
                             this.readMessageLine(),
                             message);
    },

    /**
     * Asserts that the output message window text content matches *text*.
     *
     * @param {string|RegExp|function} want The expected text of the message window.
     * @param {string} message The message to display upon assertion failure.
     */
    assertMessageWindow: function (want, message) {
        return assertMessage('dactyl.assertMessageWindow', want,
                             this.readMessageWindow(),
                             message);
    },

    /**
     * Asserts that the output message line text is an error and content matches *text*.
     *
     * @param {string|RegExp|function} want The expected text of the expected message line.
     * @param {string} message The message to display upon assertion failure.
     */
    assertErrorMessage: function (want, message) {
        return assertMessage('dactyl.assertMessageError', want,
                             this.readMessageLine(),
                             message) &&
               assertMessage('dactyl.assertMessageError', /\bErrorMsg\b/,
                             this.elements.message.getAttributeNS(NS, "highlight"),
                             message);
    },

    /**
     * Asserts that the multi-line output window is in the given state.
     *
     * @param {boolean} open True if the window is expected to be open.
     * @param {string} message The message to display upon assertion failure. @optional
     */
    assertMessageWindowOpen: function (open, message) {
        return utils.assertEqual('dactyl.assertMessageWindowOpen', open,
                                 !this.elements.multilineContainer.collapsed,
                                 message || "Multi-line output not in the expected state");
    },

    /**
     * Asserts that the no errors have been reported since the last call
     * to resetErrorCount.
     *
     * @param {function} func A function to call during before the
     *      assertion takes place. When present, the current error count
     *      is reset before execution.
     *      @optional
     * @param {object} self The 'this' object to be used during the call
     *      of *func*. @optional
     * @param {Array} args Arguments to be passed to *func*. @optional
     * @param {string} message The message to display upon assertion failure. @optional
     */
    assertNoErrors: function (func, self, args, message) {
        let msg = message ? ": " + message : "";

        let beepCount = this.beepCount;
        let errorCount = this.errorCount;
        if (func) {
            errorCount = this.modules.util.errorCount;

            try {
                var returnVal = func.apply(self || this, args || []);
            }
            catch (e) {
                this.modules.util.reportError(e);
            }
        }

        if (this.beepCount > beepCount)
            frame.log({
                function: "dactyl.beepMonitor",
                want: beepCount, got: this.beepCount,
                comment: "Got " + (this.beepCount - beepCount) + " beeps during execution" + msg
            });

        if (errorCount != this.modules.util.errorCount)
            var errors = this.modules.util.errors.slice(errorCount - this.modules.util.errorCount)
                             .join("\n");

        var res = utils.assertEqual('dactyl.assertNoErrors',
                                    errorCount, this.modules.util.errorCount,
                                    "Errors were reported during the execution of this test" + msg + "\n" + errors);

        return returnVal === undefined ? res : returnVal;
    },

    /**
     * Asserts that the no error messages are reported during the call
     * of *func*.
     *
     * @param {function} func A function to call during before the
     *      assertion takes place. When present, the current error count
     *      is reset before execution.
     *      @optional
     * @param {object} self The 'this' object to be used during the call
     *      of *func*. @optional
     * @param {Array} args Arguments to be passed to *func*. @optional
     * @param {string} message The message to display upon assertion failure. @optional
     */
    assertNoErrorMessages: function (func, self, args, message) {
        let msg = message ? ": " + message : "";
        let count = this.errors.length;

        try {
            func.apply(self || this, args || []);
        }
        catch (e) {
            this.modules.util.reportError(e);
        }

        return utils.assertEqual('dactyl.assertNoErrorMessages', count, this.errors.length,
                                 "Error messsages were reported" + msg + ":\n\t" +
                                 this.errors.slice(count).join("\n\t"));
    },

    /**
     * Resets the error count used to determine whether new errors were
     * reported during the execution of a test.
     */
    resetErrorCount: function () {
        this.errorCount = this.modules.util.errorCount;
    },

    /**
     * Wraps the given function such that any errors triggered during
     * its execution will trigger a failed assertion.
     *
     * @param {function} func The function to wrap.
     * @param {string} message The message to display upon assertion failure. @optional
     */
    wrapAssertNoErrors: function (func, message) {
        return () => this.assertNoErrors(func, this, arguments, message);
    },

    /**
     * Asserts that the current window selection matches *text*.
     *
     * @param {string|RegExp|function} text The expected text of the current selection.
     * @param {string} message The message to display upon assertion failure.
     */
    assertSelection: function (want, message) {
        return assertMessage('dactyl.assertSelection', want,
                             String(this.controller.window.content.getSelection()),
                             message);
    },

    /**
     * @property {string} The name of dactyl's current key handling
     * mode.
     */
    get currentMode() this.modules.modes.main.name,

    /**
     * @property {object} A map of dactyl widgets to be used sparingly
     * for focus assertions.
     */
    get elements() let (self = this) ({
        /**
         * @property {HTMLInputElement} The command line's command input box
         */
        get commandInput() self.modules.commandline.widgets.active.command.inputField,
        /**
         * @property {Node|null} The currently focused node.
         */
        get focused() self.controller.window.document.commandDispatcher.focusedElement,
        /**
         * @property {HTMLInputElement} The message bar's command input box
         */
        get message() self.modules.commandline.widgets.active.message,
        /**
         * @property {Node} The multi-line output window.
         */
        get multiline() self.modules.commandline.widgets.multilineOutput,
        /**
         * @property {Node} The multi-line output container.
         */
        get multilineContainer() self.modules.commandline.widgets.mowContainer,
    }),

    /**
     * Returns dactyl to Normal mode.
     */
    setNormalMode: wrapAssertNoErrors(function () {
        // XXX: Normal mode test
        for (let i = 0; i < 15 && this.modules.modes.stack.length > 1; i++)
            this.controller.keypress(null, "VK_ESCAPE", {});

        this.controller.keypress(null, "l", { ctrlKey: true });

        utils.assert("dactyl.setNormalMode", this.modules.modes.stack.length == 1,
                     "Failed to return to Normal mode");

        this.assertMessageWindowOpen(false, "Returning to Normal mode: Multi-line output not closed");
        this.assertMessageLine(function (msg) !msg, "Returning to Normal mode: Message not cleared");
    }, "Returning to Normal mode"),

    /**
     * Returns dactyl to Ex mode.
     */
    setExMode: wrapAssertNoErrors(function () {
        if (this.currentMode !== "EX") {
            this.setNormalMode();
            this.controller.keypress(null, ":", {});
        }
        else {
            this.elements.commandInput.value = "";
        }
    }),

    /**
     * Runs a Vi command.
     *
     * @param {string|Array} keys Either a string of simple keys suitable for
     *     {@link MozMillController#type} or an array of keysym - modifier
     *     pairs suitable for {@link MozMillController#keypress}.
     */
    runViCommand: wrapAssertNoErrors(function (keys) {
        if (typeof keys == "string")
            keys = [[k] for each (k in keys)];
        keys.forEach(function ([key, modifiers]) { this.controller.keypress(null, key, modifiers || {}); }, this);
    }),

    /**
     * Runs an Ex command.
     *
     * @param {string} cmd The Ex command string as entered on the command
     *     line.
     * @param {object} args An args object by means of which to execute
     *     the command. If absent *cmd* is parsed as a complete
     *     arguments string. @optional
     */
    // TODO: Use execution code from commandline.js to catch more
    // possible errors without being insanely inefficient after the
    // merge.
    runExCommand: wrapAssertNoErrors(function (cmd, args) {
        this.setNormalMode();
        try {
            // Force async commands to wait for their output to be ready
            // before returning.
            this.modules.commandline.savingOutput = true;
            if (args)
                this.modules.ex[cmd](args);
            else if (true)
                this.modules.commands.execute(cmd, null, false, null,
                                             { file: "[Command Line]", line: 1 });
            else {
                var doc = this.controller.window.document;
                var event = doc.createEvent("Events");
                event.initEvent("dactyl.execute", false, false);
                doc.documentElement.setAttribute("dactyl-execute", cmd);
                doc.documentElement.dispatchEvent(event);
            }
        }
        finally {
            this.modules.commandline.savingOutput = false;
        }
    }),

    /**
     * Triggers a completion function with the given arguments an
     * ensures that no errors have occurred during the process.
     *
     * @param {object} self The 'this' object for which to trigger the
     *     completer.
     * @param {function|string} func The method or method name to call.
     * @param {string} string The method or method name to call. @optional
     * @param {string} message The message to display upon assertion failure. @optional
     * @param {...} Extra arguments are passed to the completion
     *     function directly.
     */
    testCompleter: wrapAssertNoErrors(function testCompleter(self, func, string, message, ...args) {
        var context = this.modules.CompletionContext(string || "");
        context.tabPressed = true;
        context.forkapply("completions", 0, self, func, args);

        utils.assert("dactyl.runCompletions", context.wait(5000),
                     message || "Completion failed: " + self + "." + func);

        for (var [, ctxt] in Iterator(context.contextList))
            for (var [, item] in Iterator(ctxt.items))
                ctxt.createRow(item);

        return context;
    }),

    /**
     * Triggers Ex completion for the given command string and ensures
     * that no errors have occurred during the process.
     *
     * @param {string} cmd The Ex command string as entered on the command
     *     line.
     * @param {boolean} longWay Whether to test the completion by
     *     entering it into the command line and dispatching a  key
     *     press.
     */
    runExCompletion: wrapAssertNoErrors(function (cmd, longWay) {
        // dump("runExCompletion " + cmd + "\n");
        if (!longWay) {
            var context = this.modules.CompletionContext(cmd);
            context.tabPressed = true;
            context.fork("ex", 0, this.modules.completion, "ex");

            utils.assert("dactyl.runCompletions", context.wait(5000),
                         "Completion failed: " + cmd.quote());

            for (var [, ctxt] in Iterator(context.contextList))
                for (var [, item] in Iterator(ctxt.items))
                    ctxt.createRow(item);

            return context;
        }
        else {
            this.setExMode();

            utils.assertEqual("dactyl.assertCommandLineFocused",
                              this.elements.commandInput,
                              this.elements.focused,
                              "Running Ex Completion: The command line is not focused");

            if (true) {
                let input = this.elements.commandInput;
                input.value = cmd;

                var event = input.ownerDocument.createEvent("Events");
                event.initEvent("change", true, false);
                input.dispatchEvent(event);
            }
            else {
                this.controller.type(null, cmd);

                utils.assertEqual("dactyl.runExCompletion", cmd,
                                  this.elements.commandInput.editor.rootElement.firstChild.textContent,
                                  "Command line does not have the expected value: " + cmd);
            }

            this.controller.keypress(null, "VK_TAB", {});

            // XXX
            if (this.modules.commandline._tabTimer)
                this.modules.commandline._tabTimer.flush();
            else if (this.modules.commandline.commandSession && this.modules.commandline.commandSession.completions)
                this.modules.commandline.commandSession.completions.tabTimer.flush();
        }
    }),

    /**
     * Returns the text content of the output message line.
     *
     * @returns {string} The message line text content.
     */
    readMessageLine: function () {
        return this.elements.message.value;
    },

    /**
     * Returns the text content of the output message window.
     *
     * @returns {string} The message window text content.
     */
    readMessageWindow: function () {
        if (!this.elements.multilineContainer.collapsed)
            return this.elements.multiline.contentDocument.body.textContent;
        return "";
    },

    /**
     * Opens the output message window by echoing a single newline character.
     */
    openMessageWindow: wrapAssertNoErrors(function () {
        this.modules.dactyl.echo("\n");
    }, "Opening message window"),

    /**
     * Clears the current message.
     */
    clearMessage: function () {
        this.elements.message.value = ""; // XXX
    },

    /**
     * Closes the output message window if open.
     */
    closeMessageWindow: wrapAssertNoErrors(function () {
        for (let i = 0; i < 15 && !this.elements.multilineContainer.collapsed; i++)
            this.controller.keypress(null, "VK_ESCAPE", {});
        this.assertMessageWindowOpen(false, "Clearing message window failed");
    }, "Clearing message window"),

    /**
     * @property {string} The specific Dactyl application. Eg. Pentadactyl
     */
    get applicationName() this.modules.config.appName // XXX
};

// vim: sw=4 ts=8 et ft=javascript:
dactyl-1.2~r20151231/common/tests/functional/data/000077500000000000000000000000001264147376100215535ustar00rootroot00000000000000dactyl-1.2~r20151231/common/tests/functional/data/find.html000066400000000000000000000021461264147376100233640ustar00rootroot00000000000000Test Find Commands


      
A (play /ˈeɪ/; named a, plural aes) is the first letter and a vowel in the basic modern Latin alphabet. It is similar to the Ancient Greek letter Alpha, from which it derives.

      


      
Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

      


      
π (sometimes written pi) is a mathematical constant whose value is the ratio of any circle's circumference to its diameter in the Euclidean plane; this is the same value as the ratio of a circle's area to the square of its radius. It is approximately equal to 3.14159265 in the usual decimal notation. Many formulae from mathematics, science, and engineering involve π, which makes it one of the most important mathematical constants.

      
dactyl-1.2~r20151231/common/tests/functional/shared-modules/000077500000000000000000000000001264147376100235565ustar00rootroot00000000000000dactyl-1.2~r20151231/common/tests/functional/shared-modules/addons.js000066400000000000000000001206161264147376100253720ustar00rootroot00000000000000/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is MozMill Test code.
 *
 * The Initial Developer of the Original Code is the Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2009
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Henrik Skupin 
 *   Geo Mealer 
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

// Include required modules
var domUtils = require("dom-utils");
var prefs = require("prefs");
var tabs = require("tabs");
var utils = require("utils");


const TIMEOUT = 5000;
const TIMEOUT_DOWNLOAD = 15000;
const TIMEOUT_SEARCH = 30000;

var pm = Cc["@mozilla.org/permissionmanager;1"].
         getService(Ci.nsIPermissionManager);

// AMO Preview site
const AMO_PREVIEW_DOMAIN = "addons.allizom.org";
const AMO_PREVIEW_SITE = "https://" + AMO_PREVIEW_DOMAIN;

// Available search filters
const SEARCH_FILTER = [
  "local",
  "remote"
];

// Preferences which have to be changed to make sure we do not interact with the
// official AMO page but the preview site instead
const AMO_PREFERENCES = [
  {name: "extensions.getAddons.browseAddons", old: "addons.mozilla.org", new: AMO_PREVIEW_DOMAIN},
  {name: "extensions.getAddons.recommended.browseURL", old: "addons.mozilla.org", new: AMO_PREVIEW_DOMAIN},
  {name: "extensions.getAddons.recommended.url", old: "services.addons.mozilla.org", new: AMO_PREVIEW_DOMAIN},
  {name: "extensions.getAddons.search.browseURL", old: "addons.mozilla.org", new: AMO_PREVIEW_DOMAIN},
  {name: "extensions.getAddons.search.url", old: "services.addons.mozilla.org", new: AMO_PREVIEW_DOMAIN},
  {name: "extensions.getMoreThemesURL", old: "addons.mozilla.org", new: AMO_PREVIEW_DOMAIN}
];

/**
 * Constructor
 */
function addonsManager(aController) {
  this._controller = aController;
  this._tabBrowser = new tabs.tabBrowser(this._controller);
}

/**
 * Addons Manager class
 */
addonsManager.prototype = {

  ///////////////////////////////
  // Global section
  ///////////////////////////////

  /**
   * Get the controller of the window
   *
   * @returns Mozmill Controller
   * @type {MozMillController}
   */
  get controller() {
    return this._controller;
  },

  /**
   * Gets all the needed external DTD urls as an array
   *
   * @returns URL's of external DTD files
   * @type {array of string}
   */
  get dtds() {
    var dtds = [
      "chrome://mozapps/locale/extensions/extensions.dtd",
      "chrome://browser/locale/browser.dtd"
    ];

    return dtds;
  },

  /**
   * Open the Add-ons Manager
   *
   * @param {object} aSpec
   *        Information how to open the Add-ons Manager
   *        Elements: type    - Event, can be menu, or shortcut
   *                            [optional - default: menu]
   *                  waitFor - Wait until the Add-ons Manager has been opened
   *                            [optional - default: true]
   *
   *
   * @returns Reference the tab with the Add-ons Manager open
   * @type {object}
   *       Elements: controller - Mozmill Controller of the window
   *                 index - Index of the tab
   */
  open : function addonsManager_open(aSpec) {
    var spec = aSpec || { };
    var type = (spec.type == undefined) ? "menu" : spec.type;
    var waitFor = (spec.waitFor == undefined) ? true : spec.waitFor;

    switch (type) {
      case "menu":
        var menuItem = new elementslib.Elem(this._controller.
                                            menus["tools-menu"].menu_openAddons);
        this._controller.click(menuItem);
        break;
      case "shortcut":
        var cmdKey = utils.getEntity(this.dtds, "addons.commandkey");
        this._controller.keypress(null, cmdKey, {accelKey: true, shiftKey: true});
        break;
      default:
        throw new Error(arguments.callee.name + ": Unknown event type - " +
                        event.type);
    }

    return waitFor ? this.waitForOpened() : null;
  },

  /**
   * Check if the Add-ons Manager is open
   *
   * @returns True if the Add-ons Manager is open
   * @type {boolean}
   */
  get isOpen() {
    return (this.getTabs().length > 0);
  },

  /**
   * Waits until the Addons Manager has been opened and returns its controller
   *
   * @param {object} aSpec
   *        Object with parameters for customization
   *        Elements: timeout - Duration to wait for the target state
   *                            [optional - default: 5s]
   *
   * @returns Currently selected tab
   */
  waitForOpened : function addonsManager_waitforOpened(aSpec) {
    var spec = aSpec || { };
    var timeout = (spec.timeout == undefined) ? TIMEOUT : spec.timeout;

    // TODO: restore after 1.5.1 has landed
    // var self = this;
    //
    // mozmill.utils.waitFor(function() {
    //   return self.isOpen;
    // }, timeout, 100, "Add-ons Manager has been opened");

    mozmill.utils.waitForEval("subject.isOpen", timeout, 100, this);

    // The first tab found will be the selected one
    var tab = this.getTabs()[0];
    tab.controller.waitForPageLoad();

    return tab;
  },

  /**
   * Close the Addons Manager
   *
   * @param {object} aSpec
   *        Information about the event to send
   *        Elements: type - Event type (closeButton, menu, middleClick, shortcut)
   */
  close : function addonsManager_close(aSpec) {
    this._tabBrowser.closeTab(aSpec);
  },

  /**
   * Retrieves the list of open add-ons manager tabs
   *
   * @returns List of open tabs
   * @type {array of object}
   *       Elements: controller - MozMillController
   *                 index      - Index of the tab
   */
  getTabs : function addonsManager_getTabs() {
    return tabs.getTabsWithURL("about:addons");
  },

  /**
   * Opens the utils button menu and clicks the specified menu entry
   *
   * @param {object} aSpec
   *        Information about the menu
   *        Elements: item - menu item to click (updateNow, viewUpdates,
   *                         installFromFile, autoUpdateDefault,
   *                         resetAddonUpdatesToAutomatic,
   *                         resetAddonUpdatesToManual)
   */
  handleUtilsButton : function addonsManager_handleUtilsButton(aSpec) {
    var spec = aSpec || { };
    var item = spec.item;

    if (!item)
      throw new Error(arguments.callee.name + ": Menu item not specified.");

    var button = this.getElement({type: "utilsButton"});
    var menu = this.getElement({type: "utilsButton_menu"});

    try {
      this._controller.click(button);

      // Click the button and wait until menu has been opened

      // TODO: restore after 1.5.1 has landed
      // mozmill.utils.waitFor(function() {
      //   return menu.getNode() && menu.getNode().state == "open";
      // }, TIMEOUT, 100, "Menu of utils button has been opened.");

      mozmill.utils.waitForEval("subject && subject.state == 'open'",
                                TIMEOUT, 100, menu.getNode());

      // Click the given menu entry and make sure the
      var menuItem = this.getElement({
        type: "utilsButton_menuItem",
        value: "#utils-" + item
      });

      this._controller.click(menuItem);
    } finally {
      // Make sure the menu has been closed
      this._controller.keypress(menu, "VK_ESCAPE", {});

      // TODO: restore after 1.5.1 has landed
      // mozmill.utils.waitFor(function() {
      //   return menu.getNode() && menu.getNode().state == "closed";
      // }, TIMEOUT, 100, "Menu of utils button has been closed.");

      mozmill.utils.waitForEval("subject && subject.state == 'closed'",
                                TIMEOUT, 100, menu.getNode());
    }
  },


  ///////////////////////////////
  // Add-on section
  ///////////////////////////////

  /**
   * Check if the specified add-on is compatible
   *
   * @param {object} aSpec
   *        Information on which add-on to operate on
   *        Elements: addon - Add-on element
   *
   * @returns True if the add-on is compatible
   * @type {ElemBase}
   */
  isAddonCompatible : function addonsManager_isAddonCompatible(aSpec) {
    var spec = aSpec || { };
    var addon = spec.addon;

    if (!addon)
      throw new Error(arguments.callee.name + ": Add-on not specified.");

    // XXX: Bug 599702 doens't give enough information which type of notification
    return addon.getNode().getAttribute("notification") != "warning";
  },

  /**
   * Check if the specified add-on is enabled
   *
   * @param {object} aSpec
   *        Information on which add-on to operate on
   *        Elements: addon - Add-on element
   *
   * @returns True if the add-on is enabled
   * @type {ElemBase}
   */
  isAddonEnabled : function addonsManager_isAddonEnabled(aSpec) {
    var spec = aSpec || { };
    var addon = spec.addon;

    if (!addon)
      throw new Error(arguments.callee.name + ": Add-on not specified.");

    return addon.getNode().getAttribute("active") == "true";
  },

  /**
   * Check if the specified add-on is installed
   *
   * @param {object} aSpec
   *        Information on which add-on to operate on
   *        Elements: addon - Add-on element
   *
   * @returns True if the add-on is installed
   * @type {ElemBase}
   */
  isAddonInstalled : function addonsManager_isAddonInstalled(aSpec) {
    var spec = aSpec || { };
    var addon = spec.addon;

    if (!addon)
      throw new Error(arguments.callee.name + ": Add-on not specified.");

    // Bug 600502 : Add-ons in search view are not initialized correctly
    return addon.getNode().getAttribute("remote") == "false" &&
           addon.getNode().getAttribute("status") == "installed";
  },

  /**
   * Enables the specified add-on
   *
   * @param {object} aSpec
   *        Information on which add-on to operate on
   *        Elements: addon - Add-on element
   */
  enableAddon : function addonsManager_enableAddon(aSpec) {
    var spec = aSpec || { };
    spec.button = "enable";

    var button = this.getAddonButton(spec);
    this._controller.click(button);
  },

  /**
   * Disables the specified add-on
   *
   * @param {object} aSpec
   *        Information on which add-on to operate on
   *        Elements: addon - Add-on element
   */
  disableAddon : function addonsManager_disableAddon(aSpec) {
    var spec = aSpec || { };
    spec.button = "disable";

    var button = this.getAddonButton(spec);
    this._controller.click(button);
  },

  /**
   * Installs the specified add-on
   *
   * @param {object} aSpec
   *        Information on which add-on to operate on
   *        Elements: addon   - Add-on element
   *                  waitFor - Wait until the category has been selected
   *                            [optional - default: true]
   *                  timeout - Duration to wait for the download
   *                            [optional - default: 15s]
   */
  installAddon : function addonsManager_installAddon(aSpec) {
    var spec = aSpec || { };
    var addon = spec.addon;
    var timeout = spec.timeout;
    var button = "install";
    var waitFor = (spec.waitFor == undefined) ? true : spec.waitFor;

    var button = this.getAddonButton({addon: addon, button: button});
    this._controller.click(button);

    if (waitFor)
      this.waitForDownloaded({addon: addon, timeout: timeout});
  },

  /**
   * Removes the specified add-on
   *
   * @param {object} aSpec
   *        Information on which add-on to operate on
   *        Elements: addon - Add-on element
   */
  removeAddon : function addonsManager_removeAddon(aSpec) {
    var spec = aSpec || { };
    spec.button = "remove";

    var button = this.getAddonButton(spec);
    this._controller.click(button);
  },

  /**
   * Undo the last action performed for the given add-on
   *
   * @param {object} aSpec
   *        Information on which add-on to operate on
   *        Elements: addon - Add-on element
   */
  undo : function addonsManager_undo(aSpec) {
    var spec = aSpec || { };
    spec.link = "undo";

    var link = this.getAddonLink(spec);
    this._controller.click(link);
  },

  /**
   * Returns the addons from the currently selected view which match the
   * filter criteria
   *
   * @param {object} aSpec
   *        Information about the filter to apply
   *        Elements: attribute - DOM attribute of the wanted addon
   *                              [optional - default: ""]
   *                  value     - Value of the DOM attribute
   *                              [optional - default: ""]
   *
   * @returns List of addons
   * @type {array of ElemBase}
   */
  getAddons : function addonsManager_addons(aSpec) {
    var spec = aSpec || {};

    return this.getElements({
      type: "addons",
      subtype: spec.attribute,
      value: spec.value,
      parent: this.selectedView
    });
  },

  /**
   * Returns the element of the specified add-ons button
   *
   * @param {object} aSpec
   *        Information on which add-on to operate on
   *        Elements: addon  - Add-on element
   *                  button - Button (disable, enable, preferences, remove)
   *
   * @returns Add-on button
   * @type {ElemBase}
   */
  getAddonButton : function addonsManager_getAddonButton(aSpec) {
    var spec = aSpec || { };
    var addon = spec.addon;
    var button = spec.button;

    if (!button)
      throw new Error(arguments.callee.name + ": Button not specified.");

    return this.getAddonChildElement({addon: addon, type: button + "Button"});
  },

  /**
   * Returns the element of the specified add-ons link
   *
   * @param {object} aSpec
   *        Information on which add-on to operate on
   *        Elements: addon - Add-on element
   *                  link  - Link
   *                            List view (more, restart, undo)
   *                            Detail view (findUpdates, restart, undo)
   *
   * @return Add-on link
   * @type {ElemBase}
   */
  getAddonLink : function addonsManager_getAddonLink(aSpec) {
    var spec = aSpec || { };
    var addon = spec.addon;
    var link = spec.link;

    if (!link)
      throw new Error(arguments.callee.name + ": Link not specified.");

    return this.getAddonChildElement({addon: addon, type: link + "Link"});
  },

  /**
   * Returns the element of the specified add-ons radio group
   *
   * @param {object} aSpec
   *        Information on which add-on to operate on
   *        Elements: addon      - Add-on element
   *                  radiogroup - Radiogroup
   *                                 Detail View (autoUpdate)
   *
   * @returns Add-on radiogroup
   * @type {ElemBase}
   */
  getAddonRadiogroup : function addonsManager_getAddonRadiogroup(aSpec) {
    var spec = aSpec || { };
    var addon = spec.addon;
    var radiogroup = spec.radiogroup;

    if (!radiogroup)
      throw new Error(arguments.callee.name + ": Radiogroup not specified.");

    return this.getAddonChildElement({addon: addon, type: radiogroup + "Radiogroup"});
  },

  /**
   * Retrieve the given child element of the specified add-on
   *
   * @param {object} aSpec
   *        Information for getting the add-ons child node
   *        Elements: addon     - Add-on element
   *                  type      - Type of the element
   *                              [optional - default: use attribute/value]
   *                  attribute - DOM attribute of the node
   *                  value     - Value of the DOM attribute
   *
   * @returns Element
   * @type {ElemBase}
   */
  getAddonChildElement : function addonsManager_getAddonChildElement(aSpec) {
    var spec = aSpec || { };
    var addon = spec.addon;
    var attribute = spec.attribute;
    var value = spec.value;
    var type = spec.type;

    if (!addon)
      throw new Error(arguments.callee.name + ": Add-on not specified.");

    // If no type has been set retrieve a general element which needs an
    // attribute and value
    if (!type) {
      type = "element";

      if (!attribute)
        throw new Error(arguments.callee.name + ": DOM attribute not specified.");
      if (!value)
        throw new Error(arguments.callee.name + ": Value not specified.");
    }

    // For the details view the elements don't have anonymous nodes
    if (this.selectedView.getNode().id == "detail-view") {
      return this.getElement({
        type: "detailView_" + type,
        subtype: attribute,
        value: value
      });
    } else {
      return this.getElement({
        type: "listView_" + type,
        subtype: attribute,
        value: value,
        parent: addon
      });
    }
  },

  /**
   * Wait until the specified add-on has been downloaded
   *
   * @param {object} aSpec
   *        Object with parameters for customization
   *        Elements: addon   - Add-on element to wait for being downloaded
   *                  timeout - Duration to wait for the target state
   *                            [optional - default: 15s]
   */
  waitForDownloaded : function addonsManager_waitForDownloaded(aSpec) {
    var spec = aSpec || { };
    var addon = spec.addon;
    var timeout = (spec.timeout == undefined) ? TIMEOUT_DOWNLOAD : spec.timeout;

    if (!addon)
      throw new Error(arguments.callee.name + ": Add-on not specified.");

    var self = this;
    var node = addon.getNode();

    // TODO: restore after 1.5.1 has landed
    // mozmill.utils.waitFor(function () {
    //   return node.getAttribute("pending") == "install" &&
    //          node.getAttribute("status") != "installing";
    // }, timeout, 100, "'" + node.getAttribute("name") + "' has been downloaded");

    mozmill.utils.waitForEval("subject.getAttribute('pending') == 'install' &&" +
                              "subject.getAttribute('status') != 'installing'",
                              timeout, 100, node);
  },


  ///////////////////////////////
  // Category section
  ///////////////////////////////

  /**
   * Retrieve the currently selected category
   *
   * @returns Element which represents the currently selected category
   * @type {ElemBase}
   */
  get selectedCategory() {
    return this.getCategories({attribute: "selected", value: "true"})[0];
  },

  /**
   * Returns the categories which match the filter criteria
   *
   * @param {object} aSpec
   *        Information about the filter to apply
   *        Elements: attribute - DOM attribute of the wanted category
   *                              [optional - default: ""]
   *                  value     - Value of the DOM attribute
   *                              [optional - default: ""]
   *
   * @returns List of categories
   * @type {array of ElemBase}
   */
  getCategories : function addonsManager_categories(aSpec) {
    var spec = aSpec || { };

    var categories = this.getElements({
      type: "categories",
      subtype: spec.attribute,
      value: spec.value
    });

    if (categories.length == 0)
      throw new Error(arguments.callee.name + ": Categories could not be found.");

    return categories;
  },

  /**
   * Get the category element for the specified id
   *
   * @param {object} aSpec
   *        Information for getting a category
   *        Elements: id - Category id (search, discover, languages,
   *                       searchengines, extensions, themes, plugins,
   *                       availableUpdates, recentUpdates)
   *
   * @returns Category
   * @type {ElemBase}
   */
  getCategoryById : function addonsManager_getCategoryById(aSpec) {
    var spec = aSpec || { };
    var id = spec.id;

    if (!id)
      throw new Error(arguments.callee.name + ": Category ID not specified.");

    return this.getCategories({
      attribute: "id",
      value: "category-" + id
    })[0];
  },

  /**
   * Get the ID of the given category element
   *
   * @param {object} aSpec
   *        Information for getting a category
   *        Elements: category - Category to get the id from
   *
   * @returns Category Id
   * @type {string}
   */
  getCategoryId : function addonsManager_getCategoryId(aSpec) {
    var spec = aSpec || { };
    var category = spec.category;

    if (!category)
      throw new Error(arguments.callee.name + ": Category not specified.");

    return category.getNode().id;
  },

  /**
   * Select the given category
   *
   * @param {object} aSpec
   *        Information for selecting a category
   *        Elements: category - Category element
   *                  waitFor  - Wait until the category has been selected
   *                             [optional - default: true]
   */
  setCategory : function addonsManager_setCategory(aSpec) {
    var spec = aSpec || { };
    var category = spec.category;
    var waitFor = (spec.waitFor == undefined) ? true : spec.waitFor;

    if (!category)
      throw new Error(arguments.callee.name + ": Category not specified.");

    this._controller.click(category);

    if (waitFor)
      this.waitForCategory({category: category});
  },

  /**
   * Select the category with the given id
   *
   * @param {object} aSpec
   *        Information for selecting a category
   *        Elements: id      - Category id (search, discover, languages,
   *                            searchengines, extensions, themes, plugins,
   *                            availableUpdates, recentUpdates)
   *                  waitFor - Wait until the category has been selected
   *                            [optional - default: true]
   */
  setCategoryById : function addonsManager_setCategoryById(aSpec) {
    var spec = aSpec || { };
    var id = spec.id;
    var waitFor = (spec.waitFor == undefined) ? true : spec.waitFor;

    if (!id)
      throw new Error(arguments.callee.name + ": Category ID not specified.");

    // Retrieve the category and set it as active
    var category = this.getCategoryById({id: id});
    if (category)
      this.setCategory({category: category, waitFor: waitFor});
    else
      throw new Error(arguments.callee.name + ": Category '" + id + " not found.");
  },

  /**
   * Wait until the specified category has been selected
   *
   * @param {object} aSpec
   *        Object with parameters for customization
   *        Elements: category - Category element to wait for
   *                  timeout - Duration to wait for the target state
   *                            [optional - default: 5s]
   */
  waitForCategory : function addonsManager_waitForCategory(aSpec) {
    var spec = aSpec || { };
    var category = spec.category;
    var timeout = (spec.timeout == undefined) ? TIMEOUT : spec.timeout;

    if (!category)
      throw new Error(arguments.callee.name + ": Category not specified.");

    // TODO: restore after 1.5.1 has landed
    // var self = this;
    // mozmill.utils.waitFor(function () {
    //   return self.selectedCategory.getNode() == category.getNode();
    // }, timeout, 100, "Category '" + category.getNode().id + "' has been set");

    mozmill.utils.waitForEval("subject.self.selectedCategory.getNode() == subject.aCategory.getNode()",
                               timeout, 100,
                               {self: this, aCategory: category});
  },

  ///////////////////////////////
  // Search section
  ///////////////////////////////

  /**
   * Clear the search field
   */
  clearSearchField : function addonsManager_clearSearchField() {
    var textbox = this.getElement({type: "search_textbox"});
    var cmdKey = utils.getEntity(this.dtds, "selectAllCmd.key");

    this._controller.keypress(textbox, cmdKey, {accelKey: true});
    this._controller.keypress(textbox, 'VK_DELETE', {});
  },

  /**
   * Search for a specified add-on
   *
   * @param {object} aSpec
   *        Information to execute the search
   *        Elements: value   - Search term
   *                  timeout - Duration to wait for search results
   *                            [optional - default: 30s]
   *                  waitFor - Wait until the search has been finished
   *                            [optional - default: true]
   */
  search : function addonsManager_search(aSpec) {
    var spec = aSpec || { };
    var value = spec.value;
    var timeout = (spec.timeout == undefined) ? TIMEOUT_SEARCH : spec.timeout;
    var waitFor = (spec.waitFor == undefined) ? true : spec.waitFor;

    if (!value)
      throw new Error(arguments.callee.name + ": Search term not specified.");

    var textbox = this.getElement({type: "search_textbox"});

    this.clearSearchField();
    this._controller.type(textbox, value);
    this._controller.keypress(textbox, "VK_RETURN", {});

    if (waitFor)
      this.waitForSearchFinished();
  },

  /**
   * Check if a search is active
   *
   * @returns State of the search
   * @type {boolean}
   */
  get isSearching() {
    var throbber = this.getElement({type: "search_throbber"});
    return throbber.getNode().hasAttribute("active");
  },

  /**
   * Retrieve the currently selected search filter
   *
   * @returns Element which represents the currently selected search filter
   * @type {ElemBase}
   */
  get selectedSearchFilter() {
    var filter = this.getSearchFilter({attribute: "selected", value: "true"});

    return (filter.length > 0) ? filter[0] : undefined;
  },

  /**
   * Set the currently selected search filter status
   *
   * @param {string} aValue
   *        Filter for the search results (local, remote)
   */
  set selectedSearchFilter(aValue) {
    var filter = this.getSearchFilter({attribute: "value", value: aValue});

    if (SEARCH_FILTER.indexOf(aValue) == -1)
      throw new Error(arguments.callee.name + ": '" + aValue +
                      "' is not a valid search filter");

    if (filter.length > 0) {
      this._controller.click(filter[0]);
      this.waitForSearchFilter({filter: filter[0]});
    }
  },

  /**
   * Returns the available search filters which match the filter criteria
   *
   * @param {object} aSpec
   *        Information about the filter to apply
   *        Elements: attribute - DOM attribute of the wanted filter
   *                              [optional - default: ""]
   *                  value     - Value of the DOM attribute
   *                              [optional - default: ""]
   *
   * @returns List of search filters
   * @type {array of ElemBase}
   */
  getSearchFilter : function addonsManager_getSearchFilter(aSpec) {
    var spec = aSpec || { };

    return this.getElements({
      type: "search_filterRadioButtons",
      subtype: spec.attribute,
      value: spec.value
    });
  },

  /**
   * Get the search filter element for the specified value
   *
   * @param {string} aValue
   *        Search filter value (local, remote)
   *
   * @returns Search filter element
   * @type {ElemBase}
   */
  getSearchFilterByValue : function addonsManager_getSearchFilterByValue(aValue) {
    if (!aValue)
      throw new Error(arguments.callee.name + ": Search filter value not specified.");

    return this.getElement({
      type: "search_filterRadioGroup",
      subtype: "value",
      value: aValue
    });
  },

  /**
   * Get the value of the given search filter element
   *
   * @param {object} aSpec
   *        Information for getting the views matched by the criteria
   *        Elements: filter - Filter element
   *
   * @returns Value of the search filter
   * @type {string}
   */
  getSearchFilterValue : function addonsManager_getSearchFilterValue(aSpec) {
    var spec = aSpec || { };
    var filter = spec.filter;

    if (!filter)
      throw new Error(arguments.callee.name + ": Search filter not specified.");

    return filter.getNode().value;
  },

  /**
   * Waits until the specified search filter has been selected
   *
   * @param {object} aSpec
   *        Object with parameters for customization
   *        Elements: filter  - Filter element to wait for
   *                  timeout - Duration to wait for the target state
   *                            [optional - default: 5s]
   */
  waitForSearchFilter : function addonsManager_waitForSearchFilter(aSpec) {
    var spec = aSpec || { };
    var filter = spec.filter;
    var timeout = (spec.timeout == undefined) ? TIMEOUT : spec.timeout;

    if (!filter)
      throw new Error(arguments.callee.name + ": Search filter not specified.");

    // TODO: restore after 1.5.1 has landed
    // var self = this;
    //
    // mozmill.utils.waitFor(function () {
    //   return self.selectedSearchFilter.getNode() == filter.getNode();
    // }, timeout, 100, "Search filter '" + filter.getNode().value + "' has been set");

    mozmill.utils.waitForEval("subject.self.selectedSearchFilter.getNode() == subject.aFilter.getNode()",
                              timeout, 100,
                              {self: this, aFilter: filter});
  },

  /**
   * Returns the list of add-ons found by the selected filter
   *
   * @returns List of add-ons
   * @type {ElemBase}
   */
  getSearchResults : function addonsManager_getSearchResults() {
    var filterValue = this.getSearchFilterValue({
      filter: this.selectedSearchFilter
    });

    switch (filterValue) {
      case "local":
        return this.getAddons({attribute: "status", value: "installed"});
      case "remote":
        return this.getAddons({attribute: "remote", value: "true"});
      default:
        throw new Error(arguments.callee.name + ": Unknown search filter '" +
                        filterValue + "' selected");
    }
  },

  /**
   * Waits until the active search has been finished
   *
   * @param {object} aSpec
   *        Object with parameters for customization
   *        Elements: timeout - Duration to wait for the target state
   */
  waitForSearchFinished : function addonsManager_waitForSearchFinished(aSpec) {
    var spec = aSpec || { };
    var timeout = (spec.timeout == undefined) ? TIMEOUT_SEARCH : spec.timeout;

    // TODO: restore after 1.5.1 has landed
    // var self = this;
    //
    // mozmill.utils.waitFor(function () {
    //   return self.isSearching == false;
    // }, timeout, 100, "Search has been finished");

    mozmill.utils.waitForEval("subject.isSearching == false",
                              timeout, 100, this);
  },

  ///////////////////////////////
  // View section
  ///////////////////////////////

  /**
   * Returns the views which match the filter criteria
   *
   * @param {object} aSpec
   *        Information for getting the views matched by the criteria
   *        Elements: attribute - DOM attribute of the node
   *                              [optional - default: ""]
   *                  value     - Value of the DOM attribute
   *                              [optional - default: ""]
   *
   * @returns Filtered list of views
   * @type {array of ElemBase}
   */
  getViews : function addonsManager_getViews(aSpec) {
    var spec = aSpec || { };
    var attribute = spec.attribute;
    var value = spec.value;

    return this.getElements({type: "views", subtype: attribute, value: value});
  },

  /**
   * Check if the details view is active
   *
   * @returns True if the default view is selected
   * @type {boolean}
   */
  get isDetailViewActive() {
    return (this.selectedView.getNode().id == "detail-view");
  },

  /**
   * Retrieve the currently used view
   *
   * @returns Element which represents the currently selected view
   * @type {ElemBase}
   */
  get selectedView() {
    var viewDeck = this.getElement({type: "viewDeck"});
    var views = this.getViews();

    return views[viewDeck.getNode().selectedIndex];
  },


  ///////////////////////////////
  // UI Elements section
  ///////////////////////////////

  /**
   * Retrieve an UI element based on the given specification
   *
   * @param {object} aSpec
   *        Information of the UI elements which should be retrieved
   *        Elements: type     - Identifier of the element
   *                  subtype  - Attribute of the element to filter
   *                             [optional - default: ""]
   *                  value    - Value of the attribute to filter
   *                             [optional - default: ""]
   *                  parent   - Parent of the to find element
   *                             [optional - default: document]
   *
   * @returns Element which has been found
   * @type {ElemBase}
   */
  getElement : function addonsManager_getElement(aSpec) {
    var elements = this.getElements(aSpec);

    return (elements.length > 0) ? elements[0] : undefined;
  },

  /**
   * Retrieve list of UI elements based on the given specification
   *
   * @param {object} aSpec
   *        Information of the UI elements which should be retrieved
   *        Elements: type     - Identifier of the element
   *                  subtype  - Attribute of the element to filter
   *                             [optional - default: ""]
   *                  value    - Value of the attribute to filter
   *                             [optional - default: ""]
   *                  parent   - Parent of the to find element
   *                             [optional - default: document]
   *
   * @returns Elements which have been found
   * @type {array of ElemBase}
   */
  getElements : function addonsManager_getElements(aSpec) {
    var spec = aSpec || { };
    var type = spec.type;
    var subtype = spec.subtype;
    var value = spec.value;
    var parent = spec.parent;

    var root = parent ? parent.getNode() : this._controller.tabs.activeTab;
    var nodeCollector = new domUtils.nodeCollector(root);

    switch (type) {
      // Add-ons
      case "addons":
        nodeCollector.queryNodes(".addon").filterByDOMProperty(subtype, value);
        break;
      case "addonsList":
        nodeCollector.queryNodes("#addon-list");
        break;
      // Categories
      case "categoriesList":
        nodeCollector.queryNodes("#categories");
        break;
      case "categories":
        nodeCollector.queryNodes(".category").filterByDOMProperty(subtype, value);
        break;
      // Detail view
      case "detailView_element":
        nodeCollector.queryNodes(value);
        break;
      case "detailView_disableButton":
        nodeCollector.queryNodes("#detail-disable");
        break;
      case "detailView_enableButton":
        nodeCollector.queryNodes("#detail-enable");
        break;
      case "detailView_installButton":
        nodeCollector.queryNodes("#detail-install");
        break;
      case "detailView_preferencesButton":
        nodeCollector.queryNodes("#detail-prefs");
        break;
      case "detailView_removeButton":
        nodeCollector.queryNodes("#detail-uninstall");
        break;
      case "detailView_findUpdatesLink":
        nodeCollector.queryNodes("#detail-findUpdates");
        break;
      // Bug 599771 - button-link's are missing id or anonid
      //case "detailView_restartLink":
      //  nodeCollector.queryNodes("#detail-restart");
      //  break;
      case "detailView_undoLink":
        nodeCollector.queryNodes("#detail-undo");
        break;
      case "detailView_findUpdatesRadiogroup":
        nodeCollector.queryNodes("#detail-findUpdates");
        break;
      // List view
      case "listView_element":
        nodeCollector.queryAnonymousNodes(subtype, value);
        break;
      case "listView_disableButton":
        nodeCollector.queryAnonymousNodes("anonid", "disable-btn");
        break;
      case "listView_enableButton":
        nodeCollector.queryAnonymousNodes("anonid", "enable-btn");
        break;
      case "listView_installButton":
        // There is another binding we will have to skip
        nodeCollector.queryAnonymousNodes("anonid", "install-status");
        nodeCollector.root = nodeCollector.nodes[0];
        nodeCollector.queryAnonymousNodes("anonid", "install-remote");
        break;
      case "listView_preferencesButton":
        nodeCollector.queryAnonymousNodes("anonid", "preferences-btn");
        break;
      case "listView_removeButton":
        nodeCollector.queryAnonymousNodes("anonid", "remove-btn");
        break;
      case "listView_moreLink":
        // Bug 599771 - button-link's are missing id or anonid
        nodeCollector.queryAnonymousNodes("class", "details button-link");
        break;
      // Bug 599771 - button-link's are missing id or anonid
      //case "listView_restartLink":
      //  nodeCollector.queryAnonymousNodes("anonid", "restart");
      //  break;
      case "listView_undoLink":
        nodeCollector.queryAnonymousNodes("anonid", "undo");
        break;
      case "listView_cancelDownload":
        // There is another binding we will have to skip
        nodeCollector.queryAnonymousNodes("anonid", "install-status");
        nodeCollector.root = nodeCollector.nodes[0];
        nodeCollector.queryAnonymousNodes("anonid", "cancel");
        break;
      case "listView_pauseDownload":
        // There is another binding we will have to skip
        nodeCollector.queryAnonymousNodes("anonid", "install-status");
        nodeCollector.root = nodeCollector.nodes[0];
        nodeCollector.queryAnonymousNodes("anonid", "pause");
        break;
      case "listView_progressDownload":
        // There is another binding we will have to skip
        nodeCollector.queryAnonymousNodes("anonid", "install-status");
        nodeCollector.root = nodeCollector.nodes[0];
        nodeCollector.queryAnonymousNodes("anonid", "progress");
        break;
      // Search
      // Bug 599775 - Controller needs to handle radio groups correctly
      // Means for now we have to use the radio buttons
      case "search_filterRadioButtons":
        nodeCollector.queryNodes(".search-filter-radio").filterByDOMProperty(subtype, value);
        break;
      case "search_filterRadioGroup":
        nodeCollector.queryNodes("#search-filter-radiogroup");
        break;
      case "search_textbox":
        nodeCollector.queryNodes("#header-search");
        break;
      case "search_throbber":
        nodeCollector.queryNodes("#header-searching");
        break;
      // Utils
      case "utilsButton":
        nodeCollector.queryNodes("#header-utils-btn");
        break;
      case "utilsButton_menu":
        nodeCollector.queryNodes("#utils-menu");
        break;
      case "utilsButton_menuItem":
        nodeCollector.queryNodes(value);
        break;
      // Views
      case "viewDeck":
        nodeCollector.queryNodes("#view-port");
        break;
      case "views":
        nodeCollector.queryNodes(".view-pane").filterByDOMProperty(subtype, value);
        break;
      default:
        throw new Error(arguments.callee.name + ": Unknown element type - " + spec.type);
    }

    return nodeCollector.elements;
  }
};

/**
 * Whitelist permission for the specified domain
 * @param {string} aDomain
 *        The domain to add the permission for
 */
function addToWhiteList(aDomain) {
  pm.add(utils.createURI(aDomain),
         "install",
         Ci.nsIPermissionManager.ALLOW_ACTION);
}

/**
 * Remove whitelist permission for the specified host
 * @param {string} aHost
 *        The host whose permission will be removed
 */
function removeFromWhiteList(aHost) {
  pm.remove(aHost, "install");
}

/**
 * Reset all preferences which point to the preview sub domain
 */
function resetAmoPreviewUrls() {
  var prefSrv = prefs.preferences;

  for each (var preference in AMO_PREFERENCES) {
    prefSrv.clearUserPref(preference.name);
  }
}

/**
 *  Updates all necessary preferences to the preview sub domain
 */
function useAmoPreviewUrls() {
  var prefSrv = prefs.preferences;

  for each (var preference in AMO_PREFERENCES) {
    var pref = prefSrv.getPref(preference.name, "");
    prefSrv.setPref(preference.name,
                    pref.replace(preference.old, preference.new));
  }
}

// Export of variables
exports.AMO_PREVIEW_DOMAIN = AMO_PREVIEW_DOMAIN;
exports.AMO_PREVIEW_SITE = AMO_PREVIEW_SITE;

// Export of functions
exports.addToWhiteList = addToWhiteList;
exports.removeFromWhiteList = removeFromWhiteList;
exports.resetAmoPreviewUrls = resetAmoPreviewUrls;
exports.useAmoPreviewUrls = useAmoPreviewUrls;

// Export of classes
exports.addonsManager = addonsManager;
dactyl-1.2~r20151231/common/tests/functional/shared-modules/dom-utils.js000066400000000000000000000563471264147376100260500ustar00rootroot00000000000000/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is MozMill Test code.
 *
 * The Initial Developer of the Original Code is the Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2010
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Henrik Skupin 
 *   Adrian Kalla 
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

// Include required modules
var modalDialog = require("modal-dialog");
var utils = require("utils");


/**
 * Unwraps a node which is wrapped into a XPCNativeWrapper or XrayWrapper
 *
 * @param {DOMnode} Wrapped DOM node
 * @returns {DOMNode} Unwrapped DOM node
 */
function unwrapNode(aNode) {
  var node = aNode;

  if (node) {
    // unwrap is not available on older branches (3.5 and 3.6) - Bug 533596
    if ("unwrap" in XPCNativeWrapper) {
      node = XPCNativeWrapper.unwrap(node);
    }
    else if ("wrappedJSObject" in node) {
      node = node.wrappedJSObject;
    }
  }

  return node;
}


/**
 * DOMWalker Constructor
 *
 * @param {MozMillController} controller
 *        MozMill controller of the window to operate on.
 * @param {Function} callbackFilter
 *        callback-method to filter nodes
 * @param {Function} callbackNodeTest
 *        callback-method to test accepted nodes
 * @param {Function} callbackResults
 *        callback-method to process the results
 *        [optional - default: undefined]
 */
function DOMWalker(controller, callbackFilter, callbackNodeTest,
                   callbackResults) {

  this._controller = controller;
  this._callbackFilter = callbackFilter;
  this._callbackNodeTest = callbackNodeTest;
  this._callbackResults = callbackResults;
}

DOMWalker.FILTER_ACCEPT = 1;
DOMWalker.FILTER_REJECT = 2;
DOMWalker.FILTER_SKIP = 3;

DOMWalker.GET_BY_ID = "id";
DOMWalker.GET_BY_SELECTOR = "selector";

DOMWalker.WINDOW_CURRENT = 1;
DOMWalker.WINDOW_MODAL = 2;
DOMWalker.WINDOW_NEW = 4;

DOMWalker.prototype = {
  /**
   * Returns the filter-callback
   *
   * @returns Function
   */
  get callbackFilter() {
    return this._callbackFilter;
  },

  /**
   * Returns the node-testing-callback
   *
   * @returns Function
   */
  get callbackNodeTest() {
    return this._callbackNodeTest;
  },

  /**
   * Returns the results-callback
   *
   * @returns Function
   */
  get callbackResults() {
    return this._callbackResults;
  },

  /**
   * Returns the MozMill controller
   *
   * @returns Mozmill controller
   * @type {MozMillController}
   */
  get controller() {
    return this._controller;
  },

  /**
   * The main DOMWalker function.
   *
   * It start's the _walk-method for a given window or other dialog, runs
   * a callback to process the results for that window/dialog.
   * After that switches to provided new windows/dialogs.
   *
   * @param {array of objects} ids
   *        Contains informations on the elements to open while
   *        Object-elements:  getBy         - attribute-name of the attribute
   *                                          containing the identification
   *                                          information for the opener-element
   *                          subContent    - array of ids of the opener-elements
   *                                          in the window with the value of
   *                                          the above getBy-attribute
   *                          target        - information, where the new
   *                                          elements will be opened
   *                                          [1|2|4]
   *                          title         - title of the opened dialog/window
   *                          waitFunction  - The function used as an argument
   *                                          for MozmillController.waitFor to
   *                                          wait before starting the walk.
   *                                          [optional - default: no waiting]
   *                          windowHandler - Window instance
   *                                          [only needed for some tests]
   *
   * @param {Node} root
   *        Node to start testing from
   *        [optional - default: this._controller.window.document.documentElement]
   * @param {Function} waitFunction
   *        The function used as an argument for MozmillController.waitFor to
   *        wait before starting the walk.
   *        [optional - default: no waiting]
   */
  walk : function DOMWalker_walk(ids, root, waitFunction) {
    if (typeof waitFunction == 'function')
      this._controller.waitFor(waitFunction());

    if (!root)
      root = this._controller.window.document.documentElement;

    var resultsArray = this._walk(root);

    if (typeof this._callbackResults == 'function')
      this._callbackResults(this._controller, resultsArray);

    if (ids)
      this._prepareTargetWindows(ids);
  },

  /**
   * DOMWalker_filter filters a given node by submitting it to the
   * this._callbackFilter method to decide, if it should be submitted to
   * a provided this._callbackNodeTest method for testing (that hapens in case
   * of FILTER_ACCEPT).
   * In case of FILTER_ACCEPT and FILTER_SKIP, the children of such a node
   * will be filtered recursively.
   * Nodes with the nodeStatus "FILTER_REJECT" and their descendants will be
   * completetly ignored.
   *
   * @param {Node} node
   *        Node to filter
   * @param {array of elements} collectedResults
   *        An array with gathered all results from testing a given element
   * @returns An array with gathered all results from testing a given element
   * @type {array of elements}
   */
  _filter : function DOMWalker_filter(node, collectedResults) {
    var nodeStatus = this._callbackFilter(node);

    var nodeTestResults = [];

    switch (nodeStatus) {
      case DOMWalker.FILTER_ACCEPT:
        nodeTestResults = this._callbackNodeTest(node);
        collectedResults = collectedResults.concat(nodeTestResults);
        // no break here as we have to perform the _walk below too
      case DOMWalker.FILTER_SKIP:
        nodeTestResults = this._walk(node);
        break;
      default:
        break;
    }

    collectedResults = collectedResults.concat(nodeTestResults);

    return collectedResults;
  },

  /**
   * Retrieves and returns a wanted node based on the provided identification
   * set.
   *
   * @param {array of objects} idSet
   *        Contains informations on the elements to open while
   *        Object-elements:  getBy         - attribute-name of the attribute
   *                                          containing the identification
   *                                          information for the opener-element
   *                          subContent    - array of ids of the opener-elements
   *                                          in the window with the value of
   *                                          the above getBy-attribute
   *                          target        - information, where the new
   *                                          elements will be opened
   *                                          [1|2|4]
   *                          title         - title of the opened dialog/window
   *                          waitFunction  - The function used as an argument
   *                                          for MozmillController.waitFor to
   *                                          wait before starting the walk.
   *                                          [optional - default: no waiting]
   *                          windowHandler - Window instance
   *                                          [only needed for some tests]
   *
   * @returns Node
   * @type {Node}
   */
  _getNode : function DOMWalker_getNode(idSet) {
    var doc = this._controller.window.document;

    // QuerySelector seems to be unusuale for id's in this case:
    // https://developer.mozilla.org/En/Code_snippets/QuerySelector
    switch (idSet.getBy) {
      case DOMWalker.GET_BY_ID:
        return doc.getElementById(idSet[idSet.getBy]);
      case DOMWalker.GET_BY_SELECTOR:
        return doc.querySelector(idSet[idSet.getBy]);
      default:
        throw new Error("Not supported getBy-attribute: " + idSet.getBy);
    }
  },

  /**
   * Main entry point to open new elements like windows, tabpanels, prefpanes,
   * dialogs
   *
   * @param {array of objects} ids
   *        Contains informations on the elements to open while
   *        Object-elements:  getBy         - attribute-name of the attribute
   *                                          containing the identification
   *                                          information for the opener-element
   *                          subContent    - array of ids of the opener-elements
   *                                          in the window with the value of
   *                                          the above getBy-attribute
   *                          target        - information, where the new
   *                                          elements will be opened
   *                                          [1|2|4]
   *                          title         - title of the opened dialog/window
   *                          waitFunction  - The function used as an argument
   *                                          for MozmillController.waitFor to
   *                                          wait before starting the walk.
   *                                          [optional - default: no waiting]
   *                          windowHandler - Window instance
   *                                          [only needed for some tests]
   */
  _prepareTargetWindows : function DOMWalker_prepareTargetWindows(ids) {
    var doc = this._controller.window.document;

    // Go through all the provided ids
    for (var i = 0; i < ids.length; i++) {
      var node = this._getNode(ids[i]);

      // Go further only, if the needed element exists
      if (node) {
        var idSet = ids[i];

        // Decide if what we want to open is a new normal/modal window or if it
        // will be opened in the current window.
        switch (idSet.target) {
          case DOMWalker.WINDOW_CURRENT:
            this._processNode(node, idSet);
            break;
          case DOMWalker.WINDOW_MODAL:
            // Modal windows have to be able to access that informations
            var modalInfos = {ids : idSet.subContent,
                              callbackFilter :  this._callbackFilter,
                              callbackNodeTest : this._callbackNodeTest,
                              callbackResults : this._callbackResults,
                              waitFunction : idSet.waitFunction}
            persisted.modalInfos = modalInfos;

            var md = new modalDialog.modalDialog(this._controller.window);
            md.start(this._modalWindowHelper);

            this._processNode(node, idSet);
            md.waitForDialog();
            break;
          case DOMWalker.WINDOW_NEW:
            this._processNode(node, idSet);

            // Get the new non-modal window controller
            var controller = utils.handleWindow('title', idSet.title,
                                                undefined, false);

            // Start a new DOMWalker instance
            let domWalker = new DOMWalker(controller, this._callbackFilter,
                                          this._callbackNodeTest,
                                          this._callbackResults);
            domWalker.walk(idSet.subContent,
                           controller.window.document.documentElement,
                           idSet.waitFunction);

            // Close the window
            controller.window.close();
            break;
          default:
            throw new Error("Node does not exist: " + ids[i][ids[i].getBy]);
        }
      }
    }
  },

  /**
   * Opens new windows/dialog and starts the DOMWalker.walk() in case of dialogs
   * in existing windows.
   *
   * @param {Node} activeNode
   *        Node that holds the information which way
   *        to open the new window/dialog
   * @param {object} idSet
   *        ID set for the element to open
   */
  _processNode: function DOMWalker_processNode(activeNode, idSet) {
    var doc = this._controller.window.document;
    var nodeToProcess = this._getNode(idSet);

    // Opens a new window/dialog through a menulist and runs DOMWalker.walk()
    // for it.
    // If the wanted window/dialog is already selected, just run this function
    // recursively for it's descendants.
    if (activeNode.localName == "menulist") {
      if (nodeToProcess.value != idSet.value) {
        var dropDown = new elementslib.Elem(nodeToProcess);
        this._controller.waitForElement(dropDown);

        this._controller.select(dropDown, null, null, idSet.value);

        this._controller.waitFor(function() {
          return nodeToProcess.value == idSet.value;
        }, "The menu item did not load in time: " + idSet.value);

        // If the target is a new modal/non-modal window, this.walk() has to be
        // started by the method opening that window. If not, we do it here.
        if (idSet.target == DOMWalker.WINDOW_CURRENT)
          this.walk(idSet.subContent, null, idSet.waitFunction);
      } else if (nodeToProcess.selected && idSet.subContent &&
                 idSet.subContent.length > 0) {
        this._prepareTargetWindows(idSet.subContent);
      }
    }

    // Opens a new prefpane using a provided windowHandler object
    // and runs DOMWalker.walk() for it.
    // If the wanted prefpane is already selected, just run this function
    // recursively for it's descendants.
    else if (activeNode.localName == "prefpane") {
      var windowHandler = idSet.windowHandler;

      if (windowHandler.paneId != idSet.id) {
        windowHandler.paneId = idSet.id;

        // Wait for the pane's content to load and to be fully displayed
        this._controller.waitFor(function() {
          return (nodeToProcess.loaded &&
                  (!mozmill.isMac ||
                   nodeToProcess.style.opacity == 1 ||
                   nodeToProcess.style.opacity == null));
        }, "The pane did not load in time: " + idSet.id);

        // If the target is a new modal/non-modal window, this.walk() has to be
        // started by the method opening that window. If not, we do it here.
        if (idSet.target == DOMWalker.WINDOW_CURRENT)
          this.walk(idSet.subContent, null, idSet.waitFunction);
      } else if (windowHandler.paneId == idSet.id && idSet.subContent &&
                 idSet.subContent.length > 0) {
        this._prepareTargetWindows(idSet.subContent);
      }
    }

    // Switches to another tab and runs DOMWalker.walk() for it.
    // If the wanted tabpanel is already selected, just run this function
    // recursively for it's descendants.
    else if (activeNode.localName == "tab") {
      if (nodeToProcess.selected != true) {
        this._controller.click(new elementslib.Elem(nodeToProcess));

        // If the target is a new modal/non-modal window, this.walk() has to be
        // started by the method opening that window. If not, we do it here.
        if (idSet.target == DOMWalker.WINDOW_CURRENT)
          this.walk(idSet.subContent, null, idSet.waitFunction);
      } else if (nodeToProcess.selected && idSet.subContent
                 && idSet.subContent.length > 0) {
        this._prepareTargetWindows(idSet.subContent);
      }
    }

    // Opens a new dialog/window by clicking on an object and runs
    // DOMWalker.walk() for it.
    else {
      this._controller.click(new elementslib.Elem(nodeToProcess));

      // If the target is a new modal/non-modal window, this.walk() has to be
      // started by the method opening that window. If not, we do it here.
      if (idSet.target == DOMWalker.WINDOW_CURRENT)
        this.walk(idSet.subContent, null, idSet.waitFunction);
    }
  },

  /**
   * DOMWalker_walk goes recursively through the DOM, starting with a provided
   * root-node and filters the nodes using the this._filter method.
   *
   * @param {Node} root
   *        Node to start testing from
   *        [optional - default: this._controller.window.document.documentElement]
   * @returns An array with gathered all results from testing a given element
   * @type {array of elements}
   */
  _walk : function DOMWalker__walk(root) {
    if (!root.childNodes)
      throw new Error("root.childNodes does not exist");

    var collectedResults = [];

    // There seems to be no other way to get to the nodes hidden in the
    // "_buttons" object (see Bug 614949)
    if (root._buttons) {
      for each (button in root._buttons) {
        collectedResults = this._filter(button, collectedResults);
      }
    }

    for (var i = 0; i < root.childNodes.length; i++) {
      collectedResults = this._filter(root.childNodes[i], collectedResults);
    }

    return collectedResults;
  },

  /**
   * Callback function to handle new windows
   *
   * @param {MozMillController} controller
   *        MozMill controller of the new window to operate on.
   */
  _modalWindowHelper: function DOMWalker_modalWindowHelper(controller) {
    let domWalker = new DOMWalker(controller,
                                  persisted.modalInfos.callbackFilter,
                                  persisted.modalInfos.callbackNodeTest,
                                  persisted.modalInfos.callbackResults);
    domWalker.walk(persisted.modalInfos.ids,
                   controller.window.document.documentElement,
                   persisted.modalInfos.waitFunction);

    delete persisted.modalInfos;

    controller.window.close();
  }
}

/**
 * Default constructor
 *
 * @param {object} aRoot
 *        Root node in the DOM to use as parent
 */
function nodeCollector(aRoot) {
  this._root = aRoot.wrappedJSObject ? aRoot.wrappedJSObject : aRoot;
  this._document = this._root.ownerDocument ? this._root.ownerDocument : this._root;
  this._nodes = [ ];
}

/**
 * Node collector class
 */
nodeCollector.prototype = {
  /**
   * Converts current nodes to elements
   *
   * @returns List of elements
   * @type {array of ElemBase}
   */
  get elements() {
    var elements = [ ];

    Array.forEach(this._nodes, function(element) {
      elements.push(new elementslib.Elem(element));
    });

    return elements;
  },

  /**
   * Get the current list of DOM nodes
   *
   * @returns List of nodes
   * @type {array of object}
   */
  get nodes() {
    return this._nodes;
  },

  /**
   * Sets current nodes to entries from the node list
   *
   * @param {array of objects} aNodeList
   *        List of DOM nodes to set
   */
  set nodes(aNodeList) {
    if (aNodeList) {
      this._nodes = [ ];

      Array.forEach(aNodeList, function(node) {
        this._nodes.push(node);
      }, this);
    }
  },

  /**
   * Get the root node used as parent for a node collection
   *
   * @returns Current root node
   * @type {object}
   */
  get root() {
    return this._root;
  },

  /**
   * Sets root node to the specified DOM node
   *
   * @param {object} aRoot
   *        DOM node to use as root for node collection
   */
  set root(aRoot) {
    if (aRoot) {
      this._root = aRoot;
      this._nodes = [ ];
    }
  },

  /**
   * Filter nodes given by the specified callback function
   *
   * @param {function} aCallback
   *        Function to test each element of the array.
   *        Elements: node, index (optional) , array (optional)
   * @param {object} aThisObject
   *        Object to use as 'this' when executing callback.
   *        [optional - default: function scope]
   *
   * @returns The class instance
   * @type {object}
   */
  filter : function nodeCollector_filter(aCallback, aThisObject) {
    if (!aCallback)
      throw new Error(arguments.callee.name + ": No callback specified");

    this.nodes = Array.filter(this.nodes, aCallback, aThisObject);

    return this;
  },

  /**
   * Filter nodes by DOM property and its value
   *
   * @param {string} aProperty
   *        Property to filter for
   * @param {string} aValue
   *        Expected value of the DOM property
   *        [optional - default: n/a]
   *
   * @returns The class instance
   * @type {object}
   */
  filterByDOMProperty : function nodeCollector_filterByDOMProperty(aProperty, aValue) {
    return this.filter(function(node) {
      if (aProperty && aValue)
        return node.getAttribute(aProperty) == aValue;
      else if (aProperty)
        return node.hasAttribute(aProperty);
      else
        return true;
    });
  },

  /**
   * Filter nodes by JS property and its value
   *
   * @param {string} aProperty
   *        Property to filter for
   * @param {string} aValue
   *        Expected value of the JS property
   *        [optional - default: n/a]
   *
   * @returns The class instance
   * @type {object}
   */
  filterByJSProperty : function nodeCollector_filterByJSProperty(aProperty, aValue) {
    return this.filter(function(node) {
      if (aProperty && aValue)
        return node.aProperty == aValue;
      else if (aProperty)
        return node.aProperty !== undefined;
      else
        return true;
    });
  },

  /**
   * Find anonymouse nodes with the specified attribute and value
   *
   * @param {string} aAttribute
   *        DOM attribute of the wanted node
   * @param {string} aValue
   *        Value of the DOM attribute
   *
   * @returns The class instance
   * @type {object}
   */
  queryAnonymousNodes : function nodeCollector_queryAnonymousNodes(aAttribute, aValue) {
    var node = this._document.getAnonymousElementByAttribute(this._root,
                                                             aAttribute,
                                                             aValue);
    this.nodes = node ? [node] : [ ];

    return this;
  },

  /**
   * Find nodes with the specified selector
   *
   * @param {string} aSelector
   *        jQuery like element selector string
   *
   * @returns The class instance
   * @type {object}
   */
  queryNodes : function nodeCollector_queryNodes(aSelector) {
    this.nodes = this._root.querySelectorAll(aSelector);

    return this;
  }
}

// Exports of functions
exports.unwrapNode = unwrapNode;

// Exports of classes
exports.DOMWalker = DOMWalker;
exports.nodeCollector = nodeCollector;
dactyl-1.2~r20151231/common/tests/functional/shared-modules/downloads.js000066400000000000000000000327051264147376100261150ustar00rootroot00000000000000/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is MozMill Test code.
 *
 * The Initial Developer of the Original Code is Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2009
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Henrik Skupin 
 *   Anthony Hughes 
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

/**
 * @fileoverview
 * The DownloadsAPI adds support for download related functions. It also gives
 * access to the Download Manager.
 *
 * @version 1.0.1
 */

// Include required modules
var utils = require("utils");

const gTimeout = 5000;

/**
 * List of available download states
 */
const downloadState = {
  notStarted      : -1,
  downloading     : 0,
  finished        : 1,
  failed          : 2,
  canceled        : 3,
  paused          : 4,
  queued          : 5,
  blockedParental : 6,
  scanning        : 7,
  dirty           : 8,
  blockedPolicy   : 9
}

/**
 * Constructor
 */
function downloadManager() {
  this._controller = null;
  this.downloadState = downloadState;

  this._dms = Cc["@mozilla.org/download-manager;1"].
              getService(Ci.nsIDownloadManager);
}

/**
 * Download Manager class
 */
downloadManager.prototype = {
  /**
   * Returns the controller of the current window
   *
   * @returns Mozmill Controller
   * @type {MozMillController}
   */
  get controller() {
    return this._controller;
  },

  /**
   * Returns the number of currently active downloads
   *
   * @returns Number of active downloads
   * @type {number}
   */
  get activeDownloadCount() {
    return this._dms.activeDownloadCount;
  },

  /**
   * Cancel all active downloads
   */
  cancelActiveDownloads : function downloadManager_cancelActiveDownloads() {
    // Get a list of all active downloads (nsISimpleEnumerator)
    var downloads = this._dms.activeDownloads;

    // Iterate through each active download and cancel it
    while (downloads.hasMoreElements()) {
      var download = downloads.getNext().QueryInterface(Ci.nsIDownload);
      this._dms.cancelDownload(download.id);
    }
  },

  /**
   * Remove all downloads from the database
   */
  cleanUp : function downloadManager_cleanUp()
  {
    this._dms.cleanUp();
  },

  /**
   * Cancel any active downloads, remove the files, and clean
   * up the Download Manager database
   *
   * @param {Array of download} downloads
   *        Downloaded files which should be deleted (optional)
   */
  cleanAll : function downloadManager_cleanAll(downloads) {
    // Cancel any active downloads
    this.cancelActiveDownloads();

    // If no downloads have been specified retrieve the list from the database
    if (downloads === undefined || downloads.length == 0)
      downloads = this.getAllDownloads();
    else
      downloads = downloads.concat(this.getAllDownloads());

    // Delete all files referred to in the Download Manager
    this.deleteDownloadedFiles(downloads);

    // Clean any entries from the Download Manager database
    this.cleanUp();
  },

  /**
   * Close the download manager
   *
   * @param {boolean} force
   *        Force the closing of the DM window
   */
  close : function downloadManager_close(force) {
    var windowCount = mozmill.utils.getWindows().length;

    if (this._controller) {
      // Check if we should force the closing of the DM window
      if (force) {
        this._controller.window.close();
      } else {
        var cmdKey = utils.getEntity(this.getDtds(), "cmd.close.commandKey");
        this._controller.keypress(null, cmdKey, {accelKey: true});
      }

      this._controller.waitForEval("subject.getWindows().length == " + (windowCount - 1),
                                   gTimeout, 100, mozmill.utils);
      this._controller = null;
    }
  },

  /**
   * Delete all downloads from the local drive
   *
   * @param {download} downloads
   *        List of downloaded files
   */
  deleteDownloadedFiles : function downloadManager_deleteDownloadedFiles(downloads) {
    downloads.forEach(function(download) {
      try {
        var file = getLocalFileFromNativePathOrUrl(download.target);
        file.remove(false);
      } catch (ex) {
      }
    });
  },

  /**
   * Get the list of all downloaded files in the database
   *
   * @returns List of downloads
   * @type {Array of download}
   */
  getAllDownloads : function downloadManager_getAllDownloads() {
    var dbConn = this._dms.DBConnection;
    var stmt = null;

    if (dbConn.schemaVersion < 3)
      return new Array();

    // Run a SQL query and iterate through all results which have been found
    var downloads = [];
    stmt = dbConn.createStatement("SELECT * FROM moz_downloads");
    while (stmt.executeStep()) {
      downloads.push({
        id: stmt.row.id, name: stmt.row.name, target: stmt.row.target,
        tempPath: stmt.row.tempPath, startTime: stmt.row.startTime,
        endTime: stmt.row.endTime, state: stmt.row.state,
        referrer: stmt.row.referrer, entityID: stmt.row.entityID,
        currBytes: stmt.row.currBytes, maxBytes: stmt.row.maxBytes,
        mimeType : stmt.row.mimeType, autoResume: stmt.row.autoResume,
        preferredApplication: stmt.row.preferredApplication,
        preferredAction: stmt.row.preferredAction
      });
    };
    stmt.reset();

    return downloads;
  },

  /**
   * Gets the download state of the given download
   *
   * @param {ElemBase} download
   *        Download which state should be checked
   */
  getDownloadState : function downloadManager_getDownloadState(download) {
    return download.getNode().getAttribute('state');
  },

  /**
   * Gets all the needed external DTD urls as an array
   *
   * @returns Array of external DTD urls
   * @type [string]
   */
  getDtds : function downloadManager_getDtds() {
    var dtds = ["chrome://browser/locale/browser.dtd",
                "chrome://mozapps/locale/downloads/downloads.dtd"];
    return dtds;
  },

  /**
   * Retrieve an UI element based on the given spec
   *
   * @param {object} spec
   *        Information of the UI element which should be retrieved
   *        type: General type information
   *        subtype: Specific element or property
   *        value: Value of the element or property
   * @returns Element which has been created
   * @type {ElemBase}
   */
  getElement : function downloadManager_getElement(spec) {
    var elem = null;

    switch(spec.type) {
      /**
       * subtype: subtype of property to match
       * value: value of property to match
       */
      case "download":
        // Use a temporary lookup to get the download item
        var download = new elementslib.Lookup(this._controller.window.document,
                                              '/id("downloadManager")/id("downloadView")/' +
                                              '{"' + spec.subtype + '":"' + spec.value + '"}');
        this._controller.waitForElement(download, gTimeout);

        // Use its download id to construct the real lookup expression
        elem = new elementslib.Lookup(this._controller.window.document,
                                      '/id("downloadManager")/id("downloadView")/' +
                                      'id("' + download.getNode().getAttribute('id') + '")');
        break;

      /**
       * subtype: Identifier of the specified download button (cancel, pause, resume, retry)
       * value: Entry (download) of the download list
       */
      case "download_button":
        // XXX: Bug 555347 - There are outstanding events to process
        this._controller.sleep(0);

        elem = new elementslib.Lookup(this._controller.window.document, spec.value.expression +
                                      '/anon({"flex":"1"})/[1]/[1]/{"cmd":"cmd_' + spec.subtype + '"}');
        break;
      default:
        throw new Error(arguments.callee.name + ": Unknown element type - " + spec.type);
    }

    return elem;
  },

  /**
   * Open the Download Manager
   *
   * @param {MozMillController} controller
   *        MozMillController of the window to operate on
   * @param {boolean} shortcut
   *        If true the keyboard shortcut is used
   */
  open : function downloadManager_open(controller, shortcut) {
    if (shortcut) {
      if (mozmill.isLinux) {
        var cmdKey = utils.getEntity(this.getDtds(), "downloadsUnix.commandkey");
        controller.keypress(null, cmdKey, {ctrlKey: true, shiftKey: true});
      } else {
        var cmdKey = utils.getEntity(this.getDtds(), "downloads.commandkey");
        controller.keypress(null, cmdKey, {accelKey: true});
      }
    } else {
      controller.click(new elementslib.Elem(controller.menus["tools-menu"].menu_openDownloads));
    }

    controller.sleep(500);
    this.waitForOpened(controller);
  },

  /**
   * Wait for the given download state
   *
   * @param {MozMillController} controller
   *        MozMillController of the window to operate on
   * @param {downloadState} state
   *        Expected state of the download
   * @param {number} timeout
   *        Timeout for waiting for the download state (optional)
   */
  waitForDownloadState : function downloadManager_waitForDownloadState(download, state, timeout) {
    this._controller.waitForEval("subject.manager.getDownloadState(subject.download) == subject.state", timeout, 100,
                                 {manager: this, download: download, state: state});
  },

  /**
   * Wait until the Download Manager has been opened
   *
   * @param {MozMillController} controller
   *        MozMillController of the window to operate on
   */
  waitForOpened : function downloadManager_waitForOpened(controller) {
    this._controller = utils.handleWindow("type", "Download:Manager",
                                          undefined, false);
  }
};

/**
 * Download the file of unkown type from the given location by saving it
 * automatically to disk
 *
 * @param {MozMillController} controller
 *        MozMillController of the browser window
 * @param {string} url
 *        URL of the file which has to be downloaded
 */
var downloadFileOfUnknownType = function(controller, url) {
  controller.open(url);

  // Wait until the unknown content type dialog has been opened
  controller.waitForEval("subject.getMostRecentWindow('').document.documentElement.id == 'unknownContentType'",
                         gTimeout, 100, mozmill.wm);

  utils.handleWindow("type", "", function (controller) {
    // Select to save the file directly
    var saveFile = new elementslib.ID(controller.window.document, "save");
    controller.waitThenClick(saveFile, gTimeout);
    controller.waitForEval("subject.selected == true", gTimeout, 100,
                           saveFile.getNode());

    // Wait until the OK button has been enabled and click on it
    var button = new elementslib.Lookup(controller.window.document,
                                        '/id("unknownContentType")/anon({"anonid":"buttons"})/{"dlgtype":"accept"}');
    controller.waitForElement(button, gTimeout);
    controller.waitForEval("subject.okButton.hasAttribute('disabled') == false", gTimeout, 100,
                           {okButton: button.getNode()});
    controller.click(button);
  });
}

/**
 * Get a local file from a native path or URL
 *
 * @param {string} aPathOrUrl
 *        Native path or URL of the file
 * @see http://mxr.mozilla.org/mozilla-central/source/toolkit/mozapps/downloads/content/downloads.js#1309
 */
function getLocalFileFromNativePathOrUrl(aPathOrUrl) {
  if (aPathOrUrl.substring(0,7) == "file://") {
    // if this is a URL, get the file from that
    let ioSvc = Cc["@mozilla.org/network/io-service;1"]
                   .getService(Ci.nsIIOService);

    // XXX it's possible that using a null char-set here is bad
    const fileUrl = ioSvc.newURI(aPathOrUrl, null, null)
                         .QueryInterface(Ci.nsIFileURL);
    return fileUrl.file.clone().QueryInterface(Ci.nsILocalFile);
  } else {
    // if it's a pathname, create the nsILocalFile directly
    var f = new nsLocalFile(aPathOrUrl);
    return f;
  }
}

// Export of variables
exports.downloadState = downloadState;

// Export of functions
exports.downloadFileOfUnknownType = downloadFileOfUnknownType;
exports.getLocalFileFromNativePathOrUrl = getLocalFileFromNativePathOrUrl;

// Export of classes
exports.downloadManager = downloadManager;
dactyl-1.2~r20151231/common/tests/functional/shared-modules/localization.js000066400000000000000000000251301264147376100266050ustar00rootroot00000000000000/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is MozMill Test code.
 *
 * The Initial Developer of the Original Code is the Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2010
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Adrian Kalla 
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

// Include required modules
var domUtils = require("dom-utils");
var screenshot = require("screenshot");
var utils = require("utils");

const jumlib = {};
Components.utils.import("resource://mozmill/modules/jum.js", jumlib);

/**
 * Callback function for parsing the results of testing for duplicated
 * access keys.
 *
 * This function processes the access keys found in one access keys scope
 * looking for access keys that are listed more than one time.
 * At the end, it calls the screenshot.create to create a screenshot with the
 * elements containing the broken access keys highlighted.
 *
 * @param {array of array of object} accessKeysSet
 * @param {MozmillController} controller
 */
function checkAccessKeysResults(controller, accessKeysSet) {
  // Sort the access keys to have them in a A->Z order
  var accessKeysList = accessKeysSet.sort();

  // List of access keys
  var aKeysList = [];

  // List of values to identify the access keys
  var valueList = [];

  // List of rectangles of nodes containing access keys
  var rects = [];

  // List of rectangles of nodes with broken access keys
  var badRects = [];

  // Makes lists of all access keys and the values the access keys are in
  for (var i = 0; i < accessKeysList.length; i++) {
    var accessKey = accessKeysList[i][0];
    var node = accessKeysList[i][1];

    // Set the id and label to be shown in the console
    var id = node.id || "(id is undefined)";
    var label = node.label || "(label is undefined)";

    var box = node.boxObject;

    var innerIds = [];
    var innerRects = [];

    // if the access key is already in our list, take it out to replace it
    // later
    if (accessKey == aKeysList[aKeysList.length-1]) {
      innerIds = valueList.pop();
      innerRects = rects.pop();
    } else {
      aKeysList.push([accessKey]);
    }
    innerIds.push("[id: " + id + ", label: " + label + "]");
    valueList.push(innerIds);
    innerRects.push([box.x, box.y, box.width, box.height]);
    rects.push(innerRects);
  }

  // Go through all access keys and find the duplicated ones
  for (var i = 0; i < valueList.length; i++) {
    // Only access keys contained in more than one node are the ones we are
    // looking for
    if (valueList[i].length > 1) {
      for (var j = 0; j < rects[i].length; j++) {
        badRects.push(rects[i][j]);
      }
      jumlib.assert(false, 'accessKey: ' + aKeysList[i] +
                    ' found in string\'s: ' + valueList[i].join(", "));
    }
  }

  // If we have found broken access keys, make a screenshot
  if (badRects.length > 0) {
    screenshot.create(controller, badRects);
  }
}

/**
 * Callback function for testing for cropped elements.
 *
 * Checks if the XUL boxObject has screen coordinates outside of
 * the screen coordinates of its parent. If there's no parent, return.
 *
 * @param {node} child
 * @returns List of boxes that can be highlighted on a screenshot
 * @type {array of array of int}
 */
function checkDimensions(child) {
  if (!child.boxObject)
    return [];
  var childBox = child.boxObject;
  var parent = childBox.parentBox;

  // toplevel element or hidden elements, like script tags
  if (!parent || parent == child.element || !parent.boxObject) {
    return [];
  }
  var parentBox = parent.boxObject;

  var badRects = [];

  // check width
  if (childBox.height && childBox.screenX < parentBox.screenX) {
    badRects.push([childBox.x, childBox.y, parentBox.x - childBox.x,
                   childBox.height]);
    jumlib.assert(false, 'Node is cut off at the left: ' +
                  _reportNode(child) + '. Parent node: ' + _reportNode(parent));
  }
  if (childBox.height && childBox.screenX + childBox.width >
      parentBox.screenX + parentBox.width) {
    badRects.push([parentBox.x + parentBox.width, childBox.y,
                   childBox.x + childBox.width - parentBox.x - parentBox.width,
                   childBox.height]);
    jumlib.assert(false, 'Node is cut off at the right: ' +
                  _reportNode(child) + '. Parent node: ' + _reportNode(parent));
  }

  // check height
  // We don't want to test menupopup's, as they always report the full height
  // of all items in the popup
  if (child.nodeName != 'menupopup' && parent.nodeName != 'menupopup') {
    if (childBox.width && childBox.screenY < parentBox.screenY) {
      badRects.push([childBox.x, childBox.y, parentBox.y - childBox.y,
                     childBox.width]);
      jumlib.assert(false, 'Node is cut off at the top: ' +
                    _reportNode(child) + '. Parent node: ' + _reportNode(parent));
    }
    if (childBox.width && childBox.screenY + childBox.height >
        parentBox.screenY + parentBox.height) {
      badRects.push([childBox.x, parentBox.y + parentBox.height,
                     childBox.width,
                     childBox.y + childBox.height - parentBox.y - parentBox.height]);
      jumlib.assert(false, 'Node is cut off at the bottom: ' +
                    _reportNode(child) + '. Parent node: ' + _reportNode(parent));
    }
  }

  return badRects;
}

/**
 * Filters out nodes which should not be tested because they are not in the
 * current access key scope.
 *
 * @param {node} node
 * @returns Filter status of the given node
 * @type {array of array of int}
 */
function filterAccessKeys(node) {
  // Menus will need a separate filter set
  var notAllowedLocalNames = ["menu", "menubar", "menupopup", "popupset"];

  if (!node.disabled && !node.collapsed && !node.hidden &&
      notAllowedLocalNames.indexOf(node.localName) == -1) {
    // Code specific to the preferences panes to reject out not visible nodes
    // in the panes.
    if (node.parentNode && (node.parentNode.localName == "prefwindow" &&
                            node.parentNode.currentPane.id != node.id) ||
        ((node.parentNode.localName == "tabpanels" ||
          node.parentNode.localName == "deck") &&
          node.parentNode.selectedPanel.id != node.id)) {
      return domUtils.DOMWalker.FILTER_REJECT;
      // end of the specific code
    } else if (node.accessKey) {
      return domUtils.DOMWalker.FILTER_ACCEPT;
    } else {
      return domUtils.DOMWalker.FILTER_SKIP;
    }
  } else {
    // we don't want to test not visible elements
    return domUtils.DOMWalker.FILTER_REJECT;
  }
}

/**
 * Filters out nodes which should not be tested because they are not visible
 *
 * @param {node} node
 * @returns Filter status of the given node
 * @type {array of array of int}
 */
function filterCroppedNodes(node) {
  if (!node.boxObject) {
    return domUtils.DOMWalker.FILTER_SKIP;
  } else {
    if (!node.disabled && !node.collapsed && !node.hidden) {
      // Code specific to the preferences panes to reject out not visible nodes
      // in the panes.
      if (node.parentNode && (node.parentNode.localName == "prefwindow" &&
                              node.parentNode.currentPane.id != node.id) ||
          ((node.parentNode.localName == "tabpanels" ||
            node.parentNode.localName == "deck") &&
           node.parentNode.selectedPanel.id != node.id)) {
        return domUtils.DOMWalker.FILTER_REJECT;
        // end of the specific code
      } else {
        return domUtils.DOMWalker.FILTER_ACCEPT;
      }
    } else {
      // we don't want to test not visible elements
      return domUtils.DOMWalker.FILTER_REJECT;
    }
  }
}

/**
 * Callback function for testing access keys. To be used with the DOMWalker.
 *
 * It packs a submitted node and its access key into a double array
 *
 * @param {node} node Node containing the access key
 * @returns lower-cased access key and its node in a nested array
 * @type {array of array}
 */
function prepareAccessKey(node) {
  return [[node.accessKey.toLowerCase(), node]];
}

/**
 * Callback function for parsing the results of testing for cropped elements.
 *
 * This function calls the screenshot.create method if there is at least one
 * box.
 *
 * @param {array of array of int} boxes
 * @param {MozmillController} controller
 */
function processDimensionsResults(controller, boxes) {
  if (boxes && boxes.length > 0) {
    screenshot.create(controller, boxes);
  }
}

/**
 * Tries to return a useful string identificator of the given node
 *
 * @param {node} node
 * @returns Identificator of the node
 * @type {String}
 */
function _reportNode(node) {
  if (node.id) {
    return "id: " + node.id;
  } else if (node.label) {
    return "label: " + node.label;
  } else if (node.value) {
    return "value: " + node.value;
  } else if (node.hasAttributes()) {
    var attrs = "node attributes: ";
    for (var i = node.attributes.length - 1; i >= 0; i--) {
      attrs += node.attributes[i].name + "->" + node.attributes[i].value + ";";
    }
    return attrs;
  } else {
    return "anonymous node";
  }
}

// Export of functions
exports.checkAccessKeysResults = checkAccessKeysResults;
exports.checkDimensions = checkDimensions;
exports.filterAccessKeys = filterAccessKeys;
exports.filterCroppedNodes = filterCroppedNodes;
exports.prepareAccessKey = prepareAccessKey;
exports.processDimensionsResults = processDimensionsResults;
dactyl-1.2~r20151231/common/tests/functional/shared-modules/modal-dialog.js000066400000000000000000000161361264147376100264540ustar00rootroot00000000000000/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is MozMill Test code.
 *
 * The Initial Developer of the Original Code is Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2009
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Clint Talbert 
 *   Henrik Skupin 
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

// Include required modules
var domUtils = require("dom-utils");

const TIMEOUT_MODAL_DIALOG = 5000;
const DELAY_CHECK = 100;

/**
 * Observer object to find the modal dialog spawned by a controller
 *
 * @constructor
 * @class Observer used to find a modal dialog
 *
 * @param {object} aOpener
 *        Window which is the opener of the modal dialog
 * @param {function} aCallback
 *        The callback handler to use to interact with the modal dialog
 */
function mdObserver(aOpener, aCallback) {
  this._opener = aOpener;
  this._callback = aCallback;
  this._timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
}

mdObserver.prototype = {

  /**
   * Set our default values for our internal properties
   */
  _opener : null,
  _callback: null,
  _timer: null,
  exception: null,
  finished: false,

  /**
   * Check if the modal dialog has been opened
   *
   * @returns {object} The modal dialog window found, or null.
   */
  findWindow : function mdObserver_findWindow() {
    // If a window has been opened from content, it has to be unwrapped.
    var window = domUtils.unwrapNode(mozmill.wm.getMostRecentWindow(''));

    // Get the WebBrowserChrome and check if it's a modal window
    var chrome = window.QueryInterface(Ci.nsIInterfaceRequestor).
                 getInterface(Ci.nsIWebNavigation).
                 QueryInterface(Ci.nsIDocShellTreeItem).
                 treeOwner.
                 QueryInterface(Ci.nsIInterfaceRequestor).
                 getInterface(Ci.nsIWebBrowserChrome);
    if (!chrome.isWindowModal()) {
      return null;
    }

    // Opening a modal dialog from a modal dialog would fail, if we wouldn't
    // check for the opener of the modal dialog
    var found = false;
    if (window.opener) {
      // XXX Bug 614757 - an already unwrapped node returns a wrapped node
      var opener = domUtils.unwrapNode(window.opener);
      found = (mozmill.utils.getChromeWindow(opener) == this._opener);
    }
    else {
      // Also note that it could happen that dialogs don't have an opener
      // (i.e. clear recent history). In such a case make sure that the most
      // recent window is not the passed in reference opener
      found = (window != this._opener);
    }

    return (found ? window : null);
  },

  /**
   * Called by the timer in the given interval to check if the modal dialog has
   * been opened. Once it has been found the callback gets executed
   *
   * @param {object} aSubject Not used.
   * @param {string} aTopic Not used.
   * @param {string} aData Not used.
   */
  observe : function mdObserver_observe(aSubject, aTopic, aData) {
    // Once the window has been found and loaded we can execute the callback
    var window = this.findWindow();
    if (window && ("documentLoaded" in window)) {
      try {
        this._callback(new mozmill.controller.MozMillController(window));
      }
      catch (ex) {
        // Store the exception, so it can be forwarded if a modal dialog has
        // been opened by another modal dialog
        this.exception = ex;
      }

      if (window) {
        window.close();
      }

      this.finished = true;
      this.stop();
    }
    else {
      // otherwise try again in a bit
      this._timer.init(this, DELAY_CHECK, Ci.nsITimer.TYPE_ONE_SHOT);
    }
  },

  /**
   * Stop the timer which checks for new modal dialogs
   */
  stop : function mdObserver_stop() {
    delete this._timer;
  }
};


/**
 * Creates a new instance of modalDialog.
 *
 * @constructor
 * @class Handler for modal dialogs
 *
 * @param {object} aWindow [optional - default: null]
 *        Window which is the opener of the modal dialog
 */
function modalDialog(aWindow) {
  this._window = aWindow || null;
}

modalDialog.prototype = {

  /**
   * Simply checks if the modal dialog has been processed
   *
   * @returns {boolean} True, if the dialog has been processed
   */
  get finished() {
    return (!this._observer || this._observer.finished);
  },

  /**
   * Start timer to wait for the modal dialog.
   *
   * @param {function} aCallback
   *        The callback handler to use to interact with the modal dialog
   */
  start : function modalDialog_start(aCallback) {
    if (!aCallback)
      throw new Error(arguments.callee.name + ": Callback not specified.");

    this._observer = new mdObserver(this._window, aCallback);

    this._timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
    this._timer.init(this._observer, DELAY_CHECK, Ci.nsITimer.TYPE_ONE_SHOT);
  },

  /**
   * Stop the timer which checks for new modal dialogs
   */
  stop : function modalDialog_stop() {
    delete this._timer;

    if (this._observer) {
      this._observer.stop();
      this._observer = null;
    }
  },

  /**
   * Wait until the modal dialog has been processed.
   *
   * @param {Number} aTimeout (optional - default 5s)
   *        Duration to wait
   */
  waitForDialog : function modalDialog_waitForDialog(aTimeout) {
    var timeout = aTimeout || TIMEOUT_MODAL_DIALOG;

    if (!this._observer) {
      return;
    }

    try {
      mozmill.utils.waitFor(function () {
        return this.finished;
      }, "Modal dialog has been found and processed", timeout, undefined, this);

      // Forward the raised exception so we can detect failures in modal dialogs
      if (this._observer.exception) {
        throw this._observer.exception;
      }
    }
    finally {
      this.stop();
    }
  }
}


// Export of classes
exports.modalDialog = modalDialog;
dactyl-1.2~r20151231/common/tests/functional/shared-modules/performance.js000066400000000000000000000142731264147376100264240ustar00rootroot00000000000000/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is MozMill Test code.
 *
 * The Initial Developer of the Original Code is the Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2010
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Geo Mealer 
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

// Paths for mapped memory and allocated memory, respectively.  Use as
// keys to access the appropriate memory reporters.
const PATH_MAPPED = "malloc/mapped";
const PATH_ALLOCATED = "malloc/allocated";

// Returning this as a numeric constant to simplify memory calculations
// Neither allocated nor mapped should be 0 in real life.
const MEMORY_UNAVAILABLE = "0";

// INITIALIZE MEMORY REPORTERS

// gMemReporters will be a dictionary, key=path and val=reporter
// See initMemReporters() for how it's used.
var gMemReporters = {};

/**
 * Initialize the static memory reporters
 *
 * Called during module initialization, below.
 * See also aboutMemory.js in Firefox code
 */
function initMemReporters() {
  var memMgr = Cc["@mozilla.org/memory-reporter-manager;1"].
               getService(Ci.nsIMemoryReporterManager);

  // Grab all the memory reporters, load into gMemReporters as a dictionary
  var e = memMgr.enumerateReporters();
  while (e.hasMoreElements()) {
    var memReporter = e.getNext().QueryInterface(Ci.nsIMemoryReporter);
    gMemReporters[memReporter.path] = memReporter;
  }
}

initMemReporters();

/**
 * PERFORMANCE TRACER
 *
 * Keeps a trace log of both actions and performance statistics
 * throughout a test run.
 *
 * Performance stats currently include mapped and allocated memory.
 * More stats will be added as methods to read them are discovered.
 *
 * Usage:
 *   Before test, create a new PerfTracer named after the test.
 *     Ex: var perf = new performance.PerfTracer("MyTestFunc");
 *
 *   During test, after notable actions call PerfTracer.addCheckpoint(label)
 *     Ex: perf.addCheckpoint("Opened preferences dialog");
 *
 *   After test, call PerfTracer.finish()
 *     Ex: perf.finish();
 */

/**
 * PerfTracer constructor
 *
 * @param {string} name
 *        Name of the tracer, currently used in the output title
 */
function PerfTracer(name) {
  if (!name) {
    throw new Error(arguments.callee.name + ": name not supplied.");
  }

  this.clearLog();
  this._name = name;
}

PerfTracer.prototype = {
  // UTILITY METHODS

  /**
   * Format a single result for printing
   *
   * @param {object} result
   *        Result as created by addCheckpoint()
   *        Elements: timestamp {Date}   - date/time
   *                  allocated {number} - allocated memory
   *                  mapped {number}    - mapped memory
   *                  label {string}     - label for result
   *
   * @returns Result string formatted for output
   * @type {string}
   */
  _formatResult : function PerfTracer_formatResult(result) {
    var resultString = result.timestamp.toUTCString() + " | " +
                       result.allocated + " | " +
                       result.mapped + " | " +
                       result.label + "\n";

    return resultString;
  },

  // PUBLIC INTERFACE

  /**
   * Get a memory value from a reporter
   *
   * @param {string} path
   *        Path of memory reporter (e.g. PATH_MAPPED)
   * @returns Memory value from requested reporter, MEMORY_UNAVAILABLE if
   *          not found
   * @type {number}
   */
  getMemory : function PerfTracer_getMemory(path) {
    var val = MEMORY_UNAVAILABLE;
    if (path in gMemReporters) {
      val = gMemReporters[path].memoryUsed;
    }

    return val;
  },

  /**
   * Clears the tracker log and starts over
   */
  clearLog : function PerfTracer_clearLog() {
    this._log = new Array();
  },

  /**
   * Adds a checkpoint to the tracker log, with time and performance info
   *
   * @param {string} aLabel
   *        Label attached to performance results. Typically should be
   *        whatever the test just did.
   */
  addCheckpoint : function PerfTracer_addCheckpoint(aLabel) {
    var result = {
      label:     aLabel,
      timestamp: new Date(),
      mapped:    this.getMemory(PATH_MAPPED),
      allocated: this.getMemory(PATH_ALLOCATED)
    };

    this._log.push(result);
  },

  /**
   * Prints all results to console.
   * XXX: make this work with output files
   */
  finish : function PerfTracer_finish() {
    // Title
    var title = "Performance Trace (" + this._name + ")";

    // Separator
    var sep = "";
    for(var i = 0; i < title.length; i++) {
      sep += "=";
    }

    dump(sep + "\n");
    dump(title + "\n");
    dump(sep + "\n");

    // Log
    for(i = 0; i < this._log.length; i++) {
      dump(this._formatResult(this._log[i]));
    }
  }
}

// Exported constants
exports.PATH_MAPPED = PATH_MAPPED;
exports.PATH_ALLOCATED = PATH_ALLOCATED;
exports.MEMORY_UNAVAILABLE = MEMORY_UNAVAILABLE;

// Exported class
exports.PerfTracer = PerfTracer;
dactyl-1.2~r20151231/common/tests/functional/shared-modules/places.js000066400000000000000000000153351264147376100253720ustar00rootroot00000000000000/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is MozMill Test code.
 *
 * The Initial Developer of the Original Code is Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2009
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Henrik Skupin 
 *   Geo Mealer 
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

/**
 * @fileoverview
 * The ModalDialogAPI adds support for handling modal dialogs. It
 * has to be used e.g. for alert boxes and other commonDialog instances.
 *
 * @version 1.0.2
 */

// Include required modules
var utils = require("utils");

const gTimeout = 5000;

// Default bookmarks.html file lives in omni.jar, get via resource URI
const BOOKMARKS_RESOURCE = "resource:///defaults/profile/bookmarks.html";

// Bookmarks can take up to ten seconds to restore
const BOOKMARKS_TIMEOUT = 10000;

// Observer topics we need to watch to know whether we're finished
const TOPIC_BOOKMARKS_RESTORE_SUCCESS = "bookmarks-restore-success";

/**
 * Instance of the bookmark service to gain access to the bookmark API.
 *
 * @see http://mxr.mozilla.org/mozilla-central (nsINavBookmarksService.idl)
 */
var bookmarksService = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
                       getService(Ci.nsINavBookmarksService);

/**
 * Instance of the history service to gain access to the history API.
 *
 * @see http://mxr.mozilla.org/mozilla-central (nsINavHistoryService.idl)
 */
var historyService = Cc["@mozilla.org/browser/nav-history-service;1"].
                     getService(Ci.nsINavHistoryService);

/**
 * Instance of the livemark service to gain access to the livemark API
 *
 * @see http://mxr.mozilla.org/mozilla-central (nsILivemarkService.idl)
 */
var livemarkService = Cc["@mozilla.org/browser/livemark-service;2"].
                      getService(Ci.nsILivemarkService);

/**
 * Instance of the browser history interface to gain access to
 * browser-specific history API
 *
 * @see http://mxr.mozilla.org/mozilla-central (nsIBrowserHistory.idl)
 */
var browserHistory = Cc["@mozilla.org/browser/nav-history-service;1"].
                     getService(Ci.nsIBrowserHistory);

/**
 * Instance of the observer service to gain access to the observer API
 *
 * @see http://mxr.mozilla.org/mozilla-central (nsIObserverService.idl)
 */
var observerService = Cc["@mozilla.org/observer-service;1"].
                      getService(Ci.nsIObserverService);

/**
 * Check if an URI is bookmarked within the specified folder
 *
 * @param (nsIURI) uri
 *        URI of the bookmark
 * @param {String} folderId
 *        Folder in which the search has to take place
 * @return Returns if the URI exists in the given folder
 * @type Boolean
 */
function isBookmarkInFolder(uri, folderId)
{
  var ids = bookmarksService.getBookmarkIdsForURI(uri, {});
  for (let i = 0; i < ids.length; i++) {
    if (bookmarksService.getFolderIdForItem(ids[i]) == folderId)
      return true;
  }

  return false;
}

/**
 * Restore the default bookmarks for the current profile
 */
function restoreDefaultBookmarks() {
  // Set up the observer -- we're only checking for success here, so we'll simply
  // time out and throw on failure. It makes the code much clearer than handling
  // finished state and success state separately.
  var importSuccessful = false;
  var importObserver = {
    observe: function (aSubject, aTopic, aData) {
      if (aTopic == TOPIC_BOOKMARKS_RESTORE_SUCCESS) {
        importSuccessful = true;
      }
    }
  }
  observerService.addObserver(importObserver, TOPIC_BOOKMARKS_RESTORE_SUCCESS, false);

  try {
    // Fire off the import
    var bookmarksURI = utils.createURI(BOOKMARKS_RESOURCE);
    var importer = Cc["@mozilla.org/browser/places/import-export-service;1"].
                   getService(Ci.nsIPlacesImportExportService);
    importer.importHTMLFromURI(bookmarksURI, true);

    // Wait for it to be finished--the observer above will flip this flag
    mozmill.utils.waitFor(function () {
      return importSuccessful;
    }, "Default bookmarks have finished importing", BOOKMARKS_TIMEOUT);
  }
  finally {
    // Whatever happens, remove the observer afterwards
    observerService.removeObserver(importObserver, TOPIC_BOOKMARKS_RESTORE_SUCCESS);
  }
}

/**
 * Synchronous wrapper around browserHistory.removeAllPages()
 * Removes history and blocks until done
 */
function removeAllHistory() {
  const TOPIC_EXPIRATION_FINISHED = "places-expiration-finished";

  // Create flag visible to both the eval and the observer object
  var finishedFlag = {
    state: false
  }

  // Set up an observer so we get notified when remove completes
  let observer = {
    observe: function(aSubject, aTopic, aData) {
      observerService.removeObserver(this, TOPIC_EXPIRATION_FINISHED);
      finishedFlag.state = true;
    }
  }
  observerService.addObserver(observer, TOPIC_EXPIRATION_FINISHED, false);

  // Remove the pages, then block until we're done or until timeout is reached
  browserHistory.removeAllPages();
  mozmill.controller.waitForEval("subject.state == true", gTimeout, 100, finishedFlag);
}

// Export of variables
exports.bookmarksService = bookmarksService;
exports.historyService = historyService;
exports.livemarkService = livemarkService;
exports.browserHistory = browserHistory;

// Export of functions
exports.isBookmarkInFolder = isBookmarkInFolder;
exports.restoreDefaultBookmarks = restoreDefaultBookmarks;
exports.removeAllHistory = removeAllHistory;
dactyl-1.2~r20151231/common/tests/functional/shared-modules/prefs.js000066400000000000000000000275231264147376100252440ustar00rootroot00000000000000/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is MozMill Test code.
 *
 * The Initial Developer of the Original Code is Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2009
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Henrik Skupin 
 *   Clint Talbert 
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

/**
 * @fileoverview
 * The PrefsAPI adds support for preferences related functions. It gives access
 * to the preferences system and allows to handle the preferences dialog
 *
 * @version 1.0.1
 */

// Include required modules
var modalDialog = require("modal-dialog");
var utils = require("utils");


const gTimeout = 5000;

// Preferences dialog element templates
const PREF_DIALOG_BUTTONS  = '/{"type":"prefwindow"}/anon({"anonid":"dlg-buttons"})';
const PREF_DIALOG_DECK     = '/{"type":"prefwindow"}/anon({"class":"paneDeckContainer"})/anon({"anonid":"paneDeck"})';
const PREF_DIALOG_SELECTOR = '/{"type":"prefwindow"}/anon({"orient":"vertical"})/anon({"anonid":"selector"})';


/**
 * Constructor
 *
 * @param {MozMillController} controller
 *        MozMill controller of the browser window to operate on.
 */
function preferencesDialog(controller) {
  this._controller = controller;
}

/**
 * Preferences dialog object to simplify the access to this dialog
 */
preferencesDialog.prototype = {
  /**
   * Returns the MozMill controller
   *
   * @returns Mozmill controller
   * @type {MozMillController}
   */
  get controller() {
    return this._controller;
  },

  /**
   * Retrieve the currently selected panel
   *
   * @returns The panel element
   * @type {ElemBase}
   */
  get selectedPane() {
    return this.getElement({type: "deck_pane"});
  },

  /**
   * Get the given pane id
   */
  get paneId() {
    // Check if the selector and the pane are consistent
    var selector = this.getElement({type: "selector"});

    this._controller.waitForEval("subject.selector.getAttribute('pane') == subject.dlg.selectedPane.getNode().id", gTimeout, 100,
                                 {selector: selector.getNode().selectedItem, dlg: this});

    return this.selectedPane.getNode().id;
  },

  /**
   * Set the given pane by id
   *
   * @param {string} id of the pane
   */
  set paneId(id) {
    var button = this.getElement({type: "selector_button", value: id});
    this._controller.waitThenClick(button, gTimeout);

    // Check if the correct selector is selected
    var selector = this.getElement({type: "selector"});
    this._controller.waitForEval("subject.selector.getAttribute('pane') == subject.newPane", gTimeout, 100,
                                 {selector: selector.getNode().selectedItem, newPane: id});
    return this.paneId;
  },

  /**
   * Close the preferences dialog
   *
   * @param {MozMillController} controller
   *        MozMillController of the window to operate on
   * @param {boolean} saveChanges
   *        (Optional) If true the OK button is clicked on Windows which saves
   *        the changes. On OS X and Linux changes are applied immediately
   */
  close : function preferencesDialog_close(saveChanges) {
    saveChanges = (saveChanges == undefined) ? false : saveChanges;

    if (mozmill.isWindows) {
      var button = this.getElement({type: "button", subtype: (saveChanges ? "accept" : "cancel")});
      this._controller.click(button);
    } else {
      this._controller.keypress(null, 'w', {accelKey: true});
    }
  },

  /**
   * Gets all the needed external DTD urls as an array
   *
   * @returns Array of external DTD urls
   * @type [string]
   */
  getDtds : function preferencesDialog_getDtds() {
    return null;
  },

  /**
   * Retrieve an UI element based on the given spec
   *
   * @param {object} spec
   *        Information of the UI element which should be retrieved
   *        type: General type information
   *        subtype: Specific element or property
   *        value: Value of the element or property
   * @returns Element which has been created
   * @type {ElemBase}
   */
  getElement : function aboutSessionRestore_getElement(spec) {
    var elem = null;

    switch(spec.type) {
      case "button":
        elem = new elementslib.Lookup(this._controller.window.document, PREF_DIALOG_BUTTONS +
                                      '/{"dlgtype":"' + spec.subtype + '"}');
        break;
      case "deck":
        elem = new elementslib.Lookup(this._controller.window.document, PREF_DIALOG_DECK);
        break;
      case "deck_pane":
        var deck = this.getElement({type: "deck"}).getNode();

        // XXX: Bug 390724 - selectedPane is broken. So iterate through all elements
        var panel = deck.boxObject.firstChild;
        for (var ii = 0; ii < deck.selectedIndex; ii++)
          panel = panel.nextSibling;

        elem = new elementslib.Elem(panel);
        break;
      case "selector":
        elem = new elementslib.Lookup(this._controller.window.document, PREF_DIALOG_SELECTOR);
        break;
      case "selector_button":
        elem = new elementslib.Lookup(this._controller.window.document, PREF_DIALOG_SELECTOR +
                                      '/{"pane":"' + spec.value + '"}');
        break;
      default:
        throw new Error(arguments.callee.name + ": Unknown element type - " + spec.type);
    }

    return elem;
  }
};

/**
 * Preferences object to simplify the access to the nsIPrefBranch.
 */
var preferences = {
  _prefService : Cc["@mozilla.org/preferences-service;1"].
                 getService(Ci.nsIPrefService),

  /**
   * Use branch to access low level functions of nsIPrefBranch
   *
   * @return Instance of the preferences branch
   * @type nsIPrefBranch
   */
  get prefBranch() {
    return this._prefService.QueryInterface(Ci.nsIPrefBranch);
  },

  /**
   * Use defaultPrefBranch to access low level functions of the default branch
   *
   * @return Instance of the preferences branch
   * @type nsIPrefBranch
   */
  get defaultPrefBranch() {
    return this._prefService.getDefaultBranch("");
  },

  /**
   * Use prefService to access low level functions of nsIPrefService
   *
   * @return Instance of the pref service
   * @type nsIPrefService
   */
  get prefService() {
    return this._prefService;
  },

  /**
   * Clear a user set preference
   *
   * @param {string} prefName
   *        The user-set preference to clear
   * @return False if the preference had the default value
   * @type boolean
   **/
  clearUserPref : function preferences_clearUserPref(prefName) {
    try {
      this.prefBranch.clearUserPref(prefName);
      return true;
    } catch (e) {
      return false;
    }
  },

  /**
   * Retrieve the value of an individual preference.
   *
   * @param {string} prefName
   *        The preference to get the value of.
   * @param {boolean/number/string} defaultValue
   *        The default value if preference cannot be found.
   * @param {boolean/number/string} defaultBranch
   *        If true the value will be read from the default branch (optional)
   * @param {string} interfaceType
   *        Interface to use for the complex value (optional)
   *        (nsILocalFile, nsISupportsString, nsIPrefLocalizedString)
   *
   * @return The value of the requested preference
   * @type boolean/int/string/complex
   */
  getPref : function preferences_getPref(prefName, defaultValue, defaultBranch,
                                         interfaceType) {
    try {
      branch = defaultBranch ? this.defaultPrefBranch : this.prefBranch;

      // If interfaceType has been set, handle it differently
      if (interfaceType != undefined) {
        return branch.getComplexValue(prefName, interfaceType);
      }

      switch (typeof defaultValue) {
        case ('boolean'):
          return branch.getBoolPref(prefName);
        case ('string'):
          return branch.getCharPref(prefName);
        case ('number'):
          return branch.getIntPref(prefName);
        default:
          return undefined;
      }
    } catch(e) {
      return defaultValue;
    }
  },

  /**
   * Set the value of an individual preference.
   *
   * @param {string} prefName
   *        The preference to set the value of.
   * @param {boolean/number/string/complex} value
   *        The value to set the preference to.
   * @param {string} interfaceType
   *        Interface to use for the complex value
   *        (nsILocalFile, nsISupportsString, nsIPrefLocalizedString)
   *
   * @return Returns if the value was successfully set.
   * @type boolean
   */
  setPref : function preferences_setPref(prefName, value, interfaceType) {
    try {
      switch (typeof value) {
        case ('boolean'):
          this.prefBranch.setBoolPref(prefName, value);
          break;
        case ('string'):
          this.prefBranch.setCharPref(prefName, value);
          break;
        case ('number'):
          this.prefBranch.setIntPref(prefName, value);
          break;
        default:
          this.prefBranch.setComplexValue(prefName, interfaceType, value);
      }
    } catch(e) {
      return false;
    }

    return true;
  }
};

/**
 * Open the preferences dialog and call the given handler
 *
 * @param {MozMillController} controller
 *        MozMillController which is the opener of the preferences dialog
 * @param {function} callback
 *        The callback handler to use to interact with the preference dialog
 * @param {function} launcher
 *        (Optional) A callback handler to launch the preference dialog
 */
function openPreferencesDialog(controller, callback, launcher) {
  if (!controller)
    throw new Error("No controller given for Preferences Dialog");
  if (typeof callback != "function")
    throw new Error("No callback given for Preferences Dialog");

  if (mozmill.isWindows) {
    // Preference dialog is modal on windows, set up our callback
    var prefModal = new modalDialog.modalDialog(controller.window);
    prefModal.start(callback);
  }

  // Launch the preference dialog
  if (launcher) {
    launcher();
  } else {
    mozmill.getPreferencesController();
  }

  if (mozmill.isWindows) {
    prefModal.waitForDialog();
  } else {
    // Get the window type of the preferences window depending on the application
    var prefWindowType = null;
    switch (mozmill.Application) {
      case "Thunderbird":
        prefWindowType = "Mail:Preferences";
        break;
      default:
        prefWindowType = "Browser:Preferences";
    }

    utils.handleWindow("type", prefWindowType, callback);
  }
}

// Export of variables
exports.preferences = preferences;

// Export of functions
exports.openPreferencesDialog = openPreferencesDialog;

// Export of classes
exports.preferencesDialog = preferencesDialog;
dactyl-1.2~r20151231/common/tests/functional/shared-modules/private-browsing.js000066400000000000000000000157121264147376100274240ustar00rootroot00000000000000/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is MozMill Test code.
 *
 * The Initial Developer of the Original Code is Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2009
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Henrik Skupin 
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

/**
 * @fileoverview
 * The PrivateBrowsingAPI adds support for handling the private browsing mode.
 *
 * @version 1.0.0
 */

// Include required modules
var modalDialog = require("modal-dialog");
var prefs = require("prefs");
var utils = require("utils");

// Preference for confirmation dialog when entering Private Browsing mode
const PB_NO_PROMPT_PREF = 'browser.privatebrowsing.dont_prompt_on_enter';

const gTimeout = 5000;

/**
 * Create a new privateBrowsing instance.
 *
 * @class This class adds support for the Private Browsing mode
 * @param {MozMillController} controller
 *        MozMillController to use for the modal entry dialog
 */
function privateBrowsing(controller) {
  this._controller = controller;
  this._handler = null;

  /**
   * Menu item in the main menu to enter/leave Private Browsing mode
   * @private
   */
  this._pbMenuItem = new elementslib.Elem(this._controller.menus['tools-menu'].privateBrowsingItem);
  this._pbTransitionItem = new elementslib.ID(this._controller.window.document, "Tools:PrivateBrowsing");

  this.__defineGetter__('_pbs', function() {
    delete this._pbs;
    return this._pbs = Cc["@mozilla.org/privatebrowsing;1"].
                       getService(Ci.nsIPrivateBrowsingService);
  });
}

/**
 * Prototype definition of the privateBrowsing class
 */
privateBrowsing.prototype = {
  /**
   * Returns the controller of the current window
   *
   * @returns Mozmill Controller
   * @type {MozMillController}
   */
  get controller() {
    return this._controller;
  },

  /**
   * Checks the state of the Private Browsing mode
   *
   * @returns Enabled state
   * @type {boolean}
   */
  get enabled() {
    return this._pbs.privateBrowsingEnabled;
  },

  /**
   * Sets the state of the Private Browsing mode
   *
   * @param {boolean} value
   *        New state of the Private Browsing mode
   */
  set enabled(value) {
    this._pbs.privateBrowsingEnabled = value;
  },

  /**
   * Sets the callback handler for the confirmation dialog
   *
   * @param {function} callback
   *        Callback handler for the confirmation dialog
   */
  set handler(callback) {
    this._handler = callback;
  },

  /**
   * Gets the enabled state of the confirmation dialog
   *
   * @returns Enabled state
   * @type {boolean}
   */
  get showPrompt() {
    return !prefs.preferences.getPref(PB_NO_PROMPT_PREF, true);
  },

  /**
   * Sets the enabled state of the confirmation dialog
   *
   * @param {boolean} value
   *        New enabled state of the confirmation dialog
   */
  set showPrompt(value){
    prefs.preferences.setPref(PB_NO_PROMPT_PREF, !value);
  },

  /**
   * Gets all the needed external DTD urls as an array
   *
   * @returns Array of external DTD urls
   * @type [string]
   */
  getDtds : function downloadManager_getDtds() {
    var dtds = ["chrome://branding/locale/brand.dtd",
                "chrome://browser/locale/browser.dtd",
                "chrome://browser/locale/aboutPrivateBrowsing.dtd"];
    return dtds;
  },

  /**
   * Turn off Private Browsing mode and reset all changes
   */
  reset : function privateBrowsing_reset() {
    try {
      this.stop(true);
    } catch (ex) {
      // Do a hard reset
      this.enabled = false;
    }

    this.showPrompt = true;
  },

  /**
   * Start the Private Browsing mode
   *
   * @param {boolean} useShortcut
   *        Use the keyboard shortcut if true otherwise the menu entry is used
   */
  start: function privateBrowsing_start(useShortcut) {
    var dialog = null;

    if (this.enabled)
      return;

    if (this.showPrompt) {
      dialog = new modalDialog.modalDialog(this._controller.window);
      dialog.start(this._handler);
    }

    if (useShortcut) {
      var cmdKey = utils.getEntity(this.getDtds(), "privateBrowsingCmd.commandkey");
      this._controller.keypress(null, cmdKey, {accelKey: true, shiftKey: true});
    } else {
      this._controller.click(this._pbMenuItem);
    }

    if (dialog) {
      dialog.waitForDialog();
    }
    this.waitForTransistionComplete(true);
  },

  /**
   * Stop the Private Browsing mode
   *
   * @param {boolean} useShortcut
   *        Use the keyboard shortcut if true otherwise the menu entry is used
   */
  stop: function privateBrowsing_stop(useShortcut)
  {
    if (!this.enabled)
      return;

    if (useShortcut) {
      var privateBrowsingCmdKey = utils.getEntity(this.getDtds(), "privateBrowsingCmd.commandkey");
      this._controller.keypress(null, privateBrowsingCmdKey, {accelKey: true, shiftKey: true});
    } else {
      this._controller.click(this._pbMenuItem);
    }

    this.waitForTransistionComplete(false);
  },

  /**
   * Waits until the transistion into or out of the Private Browsing mode happened
   *
   * @param {boolean} state
   *        Expected target state of the Private Browsing mode
   */
  waitForTransistionComplete : function privateBrowsing_waitForTransitionComplete(state) {
    // We have to wait until the transition has been finished
    this._controller.waitForEval("subject.hasAttribute('disabled') == false", gTimeout, 100,
                                 this._pbTransitionItem.getNode());
    this._controller.waitForEval("subject.privateBrowsing.enabled == subject.state", gTimeout, 100,
                                 {privateBrowsing: this, state: state});
  }
}

// Export of classes
exports.privateBrowsing = privateBrowsing;
dactyl-1.2~r20151231/common/tests/functional/shared-modules/readme.txt000066400000000000000000000010161264147376100255520ustar00rootroot00000000000000# Shared Modules #

Many common elements are referenced across the Mozmill tests. To make it easier
to work with these elements and execute common actions, shared modules have been
implemented. These modules contain helper classes and helper functions with a
focus on user interface. Some of these shared modules are unique to Firefox,
while others can also be used in other applications based on the Gecko platform.

For more information on Shared Modules visit:
https://developer.mozilla.org/en/Mozmill_Tests/Shared_Modules
dactyl-1.2~r20151231/common/tests/functional/shared-modules/screenshot.js000066400000000000000000000120161264147376100262710ustar00rootroot00000000000000/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is MozMill Test code.
 *
 * The Initial Developer of the Original Code is the Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2010
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Adrian Kalla 
 *   Axel Hecht 
 *   Henrik Skupin 
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

// Include the required modules
var utils = require("utils");

/**
 * This function creates a screenshot of the window provided in the given
 * controller and highlights elements from the coordinates provided in the
 * given boxes-array.
 *
 * @param {array of array of int} boxes
 * @param {MozmillController} controller
 */
function create(controller, boxes) {
  var doc = controller.window.document;
  var maxWidth = doc.documentElement.boxObject.width;
  var maxHeight = doc.documentElement.boxObject.height;
  var rect = [];
  for (var i = 0, j = boxes.length; i < j; ++i) {
    rect = boxes[i];
    if (rect[0] + rect[2] > maxWidth) maxWidth = rect[0] + rect[2];
    if (rect[1] + rect[3] > maxHeight) maxHeight = rect[1] + rect[3];
  }
  var canvas = doc.createElementNS("http://www.w3.org/1999/xhtml", "canvas");
  var width = doc.documentElement.boxObject.width;
  var height = doc.documentElement.boxObject.height;
  canvas.width = maxWidth;
  canvas.height = maxHeight;
  var ctx = canvas.getContext("2d");
  ctx.clearRect(0,0, canvas.width, canvas.height);
  ctx.save();
  ctx.drawWindow(controller.window, 0, 0, width, height, "rgb(0,0,0)");
  ctx.restore();
  ctx.save();
  ctx.fillStyle = "rgba(255,0,0,0.4)";
  for (var i = 0, j = boxes.length; i < j; ++i) {
    rect = boxes[i];
    ctx.fillRect(rect[0], rect[1], rect[2], rect[3]);
  }
  ctx.restore();

  _saveCanvas(canvas);
}

/**
 * Saves a given Canvas object to a file.
 * The path to save the file under should be given on the command line. If not,
 * it will be saved in the temporary folder of the system.
 *
 * @param {canvas} canvas
 */
function _saveCanvas(canvas) {
  // Use the path given on the command line and saved under
  // persisted.screenshotPath, if available. If not, use the path to the
  // temporary folder as a fallback.
  var file = null;
  if ("screenshotPath" in persisted) {
    file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsILocalFile);
    file.initWithPath(persisted.screenshotPath);
  }
  else {
    file = Cc["@mozilla.org/file/directory_service;1"].
           getService(Ci.nsIProperties).
           get("TmpD", Ci.nsIFile);
  }

  var fileName = utils.appInfo.name + "-" +
                 utils.appInfo.locale + "." +
                 utils.appInfo.version + "." +
                 utils.appInfo.buildID + "." +
                 utils.appInfo.os + ".png";
  file.append(fileName);

  // if a file already exists, don't overwrite it and create a new name
  file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, parseInt("0666", 8));

  // create a data url from the canvas and then create URIs of the source
  // and targets
  var io = Cc["@mozilla.org/network/io-service;1"].getService(Ci.nsIIOService);
  var source = io.newURI(canvas.toDataURL("image/png", ""), "UTF8", null);
  var target = io.newFileURI(file)

  // prepare to save the canvas data
  var wbPersist = Cc["@mozilla.org/embedding/browser/nsWebBrowserPersist;1"].
                  createInstance(Ci.nsIWebBrowserPersist);

  wbPersist.persistFlags = Ci.nsIWebBrowserPersist.PERSIST_FLAGS_REPLACE_EXISTING_FILES;
  wbPersist.persistFlags |= Ci.nsIWebBrowserPersist.PERSIST_FLAGS_AUTODETECT_APPLY_CONVERSION;

  // save the canvas data to the file
  wbPersist.saveURI(source, null, null, null, null, file);
}

// Export of functions
exports.create = create;
dactyl-1.2~r20151231/common/tests/functional/shared-modules/search.js000066400000000000000000000647431264147376100253770ustar00rootroot00000000000000/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is MozMill Test code.
 *
 * The Initial Developer of the Original Code is Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2009
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Henrik Skupin 
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

/**
 * @fileoverview
 * The SearchAPI adds support for search related functions like the search bar.
 */

// Include required modules
var modalDialog = require("modal-dialog");
var utils = require("utils");
var widgets = require("widgets");

const TIMEOUT = 5000;
const TIMEOUT_REQUEST_SUGGESTIONS = 750;

// Helper lookup constants for the engine manager elements
const MANAGER_BUTTONS   = '/id("engineManager")/anon({"anonid":"buttons"})';

// Helper lookup constants for the search bar elements
const NAV_BAR             = '/id("main-window")/id("tab-view-deck")/{"flex":"1"}' +
                            '/id("navigator-toolbox")/id("nav-bar")';
const SEARCH_BAR          = NAV_BAR + '/id("search-container")/id("searchbar")';
const SEARCH_TEXTBOX      = SEARCH_BAR      + '/anon({"anonid":"searchbar-textbox"})';
const SEARCH_DROPDOWN     = SEARCH_TEXTBOX  + '/[0]/anon({"anonid":"searchbar-engine-button"})';
const SEARCH_POPUP        = SEARCH_DROPDOWN + '/anon({"anonid":"searchbar-popup"})';
const SEARCH_INPUT        = SEARCH_TEXTBOX  + '/anon({"class":"autocomplete-textbox-container"})' +
                                              '/anon({"anonid":"textbox-input-box"})' +
                                              '/anon({"anonid":"input"})';
const SEARCH_CONTEXT      = SEARCH_TEXTBOX  + '/anon({"anonid":"textbox-input-box"})' +
                                              '/anon({"anonid":"input-box-contextmenu"})';
const SEARCH_GO_BUTTON    = SEARCH_TEXTBOX  + '/anon({"class":"search-go-container"})' +
                                              '/anon({"class":"search-go-button"})';
const SEARCH_AUTOCOMPLETE =  '/id("main-window")/id("mainPopupSet")/id("PopupAutoComplete")';

/**
 * Constructor
 *
 * @param {MozMillController} controller
 *        MozMillController of the engine manager
 */
function engineManager(controller)
{
  this._controller = controller;
}

/**
 * Search Manager class
 */
engineManager.prototype = {
  /**
   * Get the controller of the associated engine manager dialog
   *
   * @returns Controller of the browser window
   * @type MozMillController
   */
  get controller()
  {
    return this._controller;
  },

  /**
   * Gets the list of search engines
   *
   * @returns List of engines
   * @type object
   */
  get engines() {
    var engines = [ ];
    var tree = this.getElement({type: "engine_list"}).getNode();

    for (var ii = 0; ii < tree.view.rowCount; ii ++) {
      engines.push({name: tree.view.getCellText(ii, tree.columns.getColumnAt(0)),
                    keyword: tree.view.getCellText(ii, tree.columns.getColumnAt(1))});
    }

    return engines;
  },

  /**
   * Gets the name of the selected search engine
   *
   * @returns Name of the selected search engine
   * @type string
   */
  get selectedEngine() {
    var treeNode = this.getElement({type: "engine_list"}).getNode();

    if(this.selectedIndex != -1) {
      return treeNode.view.getCellText(this.selectedIndex,
                                       treeNode.columns.getColumnAt(0));
    } else {
      return null;
    }
  },

  /**
   * Select the engine with the given name
   *
   * @param {string} name
   *        Name of the search engine to select
   */
  set selectedEngine(name) {
    var treeNode = this.getElement({type: "engine_list"}).getNode();

    for (var ii = 0; ii < treeNode.view.rowCount; ii ++) {
      if (name == treeNode.view.getCellText(ii, treeNode.columns.getColumnAt(0))) {
        this.selectedIndex = ii;
        break;
      }
    }
  },

  /**
   * Gets the index of the selected search engine
   *
   * @returns Index of the selected search engine
   * @type number
   */
  get selectedIndex() {
    var tree = this.getElement({type: "engine_list"});
    var treeNode = tree.getNode();

    return treeNode.view.selection.currentIndex;
  },

  /**
   * Select the engine with the given index
   *
   * @param {number} index
   *        Index of the search engine to select
   */
  set selectedIndex(index) {
    var tree = this.getElement({type: "engine_list"});
    var treeNode = tree.getNode();

    if (index < treeNode.view.rowCount) {
      widgets.clickTreeCell(this._controller, tree, index, 0, {});
    }

    this._controller.waitForEval("subject.manager.selectedIndex == subject.newIndex", TIMEOUT, 100,
                                 {manager: this, newIndex: index});
  },

  /**
   * Gets the suggestions enabled state
   */
  get suggestionsEnabled() {
    var checkbox = this.getElement({type: "suggest"});

    return checkbox.getNode().checked;
  },

  /**
   * Sets the suggestions enabled state
   */
  set suggestionsEnabled(state) {
    var checkbox = this.getElement({type: "suggest"});
    this._controller.check(checkbox, state);
  },

  /**
   * Close the engine manager
   *
   * @param {MozMillController} controller
   *        MozMillController of the window to operate on
   * @param {boolean} saveChanges
   *        (Optional) If true the OK button is clicked otherwise Cancel
   */
  close : function preferencesDialog_close(saveChanges) {
    saveChanges = (saveChanges == undefined) ? false : saveChanges;

    var button = this.getElement({type: "button", subtype: (saveChanges ? "accept" : "cancel")});
    this._controller.click(button);
  },

  /**
   * Edit the keyword associated to a search engine
   *
   * @param {string} name
   *        Name of the engine to remove
   * @param {function} handler
   *        Callback function for Engine Manager
   */
  editKeyword : function engineManager_editKeyword(name, handler)
  {
    // Select the search engine
    this.selectedEngine = name;

    // Setup the modal dialog handler
    md = new modalDialog.modalDialog(this._controller.window);
    md.start(handler);

    var button = this.getElement({type: "engine_button", subtype: "edit"});
    this._controller.click(button);
    md.waitForDialog();
  },

  /**
   * Gets all the needed external DTD urls as an array
   *
   * @returns Array of external DTD urls
   * @type [string]
   */
  getDtds : function engineManager_getDtds() {
    var dtds = ["chrome://browser/locale/engineManager.dtd"];
    return dtds;
  },

  /**
   * Retrieve an UI element based on the given spec
   *
   * @param {object} spec
   *        Information of the UI element which should be retrieved
   *        type: General type information
   *        subtype: Specific element or property
   *        value: Value of the element or property
   * @returns Element which has been created
   * @type ElemBase
   */
  getElement : function engineManager_getElement(spec) {
    var elem = null;

    switch(spec.type) {
      /**
       * subtype: subtype to match
       * value: value to match
       */
      case "more_engines":
        elem = new elementslib.ID(this._controller.window.document, "addEngines");
        break;
      case "button":
        elem = new elementslib.Lookup(this._controller.window.document, MANAGER_BUTTONS +
                                      '/{"dlgtype":"' + spec.subtype + '"}');
        break;
      case "engine_button":
        switch(spec.subtype) {
          case "down":
            elem = new elementslib.ID(this._controller.window.document, "dn");
            break;
          case "edit":
            elem = new elementslib.ID(this._controller.window.document, "edit");
            break;
          case "remove":
            elem = new elementslib.ID(this._controller.window.document, "remove");
            break;
          case "up":
            elem = new elementslib.ID(this._controller.window.document, "up");
            break;
        }
        break;
      case "engine_list":
        elem = new elementslib.ID(this._controller.window.document, "engineList");
        break;
      case "suggest":
        elem = new elementslib.ID(this._controller.window.document, "enableSuggest");
        break;
      default:
        throw new Error(arguments.callee.name + ": Unknown element type - " + spec.type);
    }

    return elem;
  },

  /**
   * Clicks the "Get more search engines..." link
   */
  getMoreSearchEngines : function engineManager_getMoreSearchEngines() {
    var link = this.getElement({type: "more_engines"});
    this._controller.click(link);
  },

  /**
   * Move down the engine with the given name
   *
   * @param {string} name
   *        Name of the engine to remove
   */
  moveDownEngine : function engineManager_moveDownEngine(name) {
    this.selectedEngine = name;
    var index = this.selectedIndex;

    var button = this.getElement({type: "engine_button", subtype: "down"});
    this._controller.click(button);

    this._controller.waitForEval("subject.manager.selectedIndex == subject.oldIndex + 1", TIMEOUT, 100,
                                 {manager: this, oldIndex: index});
  },

  /**
   * Move up the engine with the given name
   *
   * @param {string} name
   *        Name of the engine to remove
   */
  moveUpEngine : function engineManager_moveUpEngine(name) {
    this.selectedEngine = name;
    var index = this.selectedIndex;

    var button = this.getElement({type: "engine_button", subtype: "up"});
    this._controller.click(button);

    this._controller.waitForEval("subject.manager.selectedIndex == subject.oldIndex - 1", TIMEOUT, 100,
                                 {manager: this, oldIndex: index});
  },

  /**
   * Remove the engine with the given name
   *
   * @param {string} name
   *        Name of the engine to remove
   */
  removeEngine : function engineManager_removeEngine(name) {
    this.selectedEngine = name;

    var button = this.getElement({type: "engine_button", subtype: "remove"});
    this._controller.click(button);

    this._controller.waitForEval("subject.manager.selectedEngine != subject.removedEngine", TIMEOUT, 100,
                                 {manager: this, removedEngine: name});
  },

  /**
   * Restores the defaults for search engines
   */
  restoreDefaults : function engineManager_restoreDefaults() {
    var button = this.getElement({type: "button", subtype: "extra2"});
    this._controller.click(button);
  }
};

/**
 * Constructor
 *
 * @param {MozMillController} controller
 *        MozMillController of the browser window to operate on
 */
function searchBar(controller)
{
  this._controller = controller;
  this._bss = Cc["@mozilla.org/browser/search-service;1"]
                 .getService(Ci.nsIBrowserSearchService);
}

/**
 * Search Manager class
 */
searchBar.prototype = {
  /**
   * Get the controller of the associated browser window
   *
   * @returns Controller of the browser window
   * @type MozMillController
   */
  get controller()
  {
    return this._controller;
  },

  /**
   * Get the names of all installed engines
   */
  get engines()
  {
    var engines = [ ];
    var popup = this.getElement({type: "searchBar_dropDownPopup"});

    for (var ii = 0; ii < popup.getNode().childNodes.length; ii++) {
      var entry = popup.getNode().childNodes[ii];
      if (entry.className.indexOf("searchbar-engine") != -1) {
        engines.push({name: entry.id,
                      selected: entry.selected,
                      tooltipText: entry.getAttribute('tooltiptext')
                    });
      }
    }

    return engines;
  },

  /**
   * Get the search engines drop down open state
   */
  get enginesDropDownOpen()
  {
    var popup = this.getElement({type: "searchBar_dropDownPopup"});
    return popup.getNode().state != "closed";
  },

  /**
   * Set the search engines drop down open state
   */
  set enginesDropDownOpen(newState)
  {
    if (this.enginesDropDownOpen != newState) {
      var button = this.getElement({type: "searchBar_dropDown"});
      this._controller.click(button);

      this._controller.waitForEval("subject.searchBar.enginesDropDownOpen == subject.newState", TIMEOUT, 100,
                                   {searchBar: this, newState: newState });
      this._controller.sleep(0);
    }
  },

  /**
   * Get the names of all installable engines
   */
  get installableEngines()
  {
    var engines = [ ];
    var popup = this.getElement({type: "searchBar_dropDownPopup"});

    for (var ii = 0; ii < popup.getNode().childNodes.length; ii++) {
      var entry = popup.getNode().childNodes[ii];
      if (entry.className.indexOf("addengine-item") != -1) {
        engines.push({name: entry.getAttribute('title'),
                      selected: entry.selected,
                      tooltipText: entry.getAttribute('tooltiptext')
                    });
      }
    }

    return engines;
  },

  /**
   * Returns the currently selected search engine
   *
   * @return Name of the currently selected engine
   * @type string
   */
  get selectedEngine()
  {
    // Open drop down which updates the list of search engines
    var state = this.enginesDropDownOpen;
    this.enginesDropDownOpen = true;

    var engine = this.getElement({type: "engine", subtype: "selected", value: "true"});
    this._controller.waitForElement(engine, TIMEOUT);

    this.enginesDropDownOpen = state;

    return engine.getNode().id;
  },

  /**
   * Select the search engine with the given name
   *
   * @param {string} name
   *        Name of the search engine to select
   */
  set selectedEngine(name) {
    // Open drop down and click on search engine
    this.enginesDropDownOpen = true;

    var engine = this.getElement({type: "engine", subtype: "id", value: name});
    this._controller.waitThenClick(engine, TIMEOUT);

    // Wait until the drop down has been closed
    this._controller.waitForEval("subject.searchBar.enginesDropDownOpen == false", TIMEOUT, 100,
                                 {searchBar: this});

    this._controller.waitForEval("subject.searchBar.selectedEngine == subject.newEngine", TIMEOUT, 100,
                                 {searchBar: this, newEngine: name});
  },

  /**
   * Returns all the visible search engines (API call)
   */
  get visibleEngines()
  {
    return this._bss.getVisibleEngines({});
  },

  /**
   * Checks if the correct target URL has been opened for the search
   *
   * @param {string} searchTerm
   *        Text which should be checked for
   */
  checkSearchResultPage : function searchBar_checkSearchResultPage(searchTerm) {
    // Retrieve the URL which is used for the currently selected search engine
    var targetUrl = this._bss.currentEngine.getSubmission(searchTerm, null).uri;
    var currentUrl = this._controller.tabs.activeTabWindow.document.location;

    var domainRegex = /[^\.]+\.([^\.]+)\..+$/gi;
    var targetDomainName = targetUrl.host.replace(domainRegex, "$1");
    var currentDomainName = currentUrl.host.replace(domainRegex, "$1");

    this._controller.assert(function () {
      return currentDomainName === targetDomainName;
    }, "Current domain name matches target domain name - got '" +
      currentDomainName + "', expected '" + targetDomainName + "'");

    // Check if search term is listed in URL
    this._controller.assert(function () {
      return currentUrl.href.toLowerCase().indexOf(searchTerm.toLowerCase()) != -1;
    }, "Current URL contains the search term - got '" +
      currentUrl.href.toLowerCase() + "', expected '" + searchTerm.toLowerCase() + "'");

  },

  /**
   * Clear the search field
   */
  clear : function searchBar_clear()
  {
    var activeElement = this._controller.window.document.activeElement;

    var searchInput = this.getElement({type: "searchBar_input"});
    var cmdKey = utils.getEntity(this.getDtds(), "selectAllCmd.key");
    this._controller.keypress(searchInput, cmdKey, {accelKey: true});
    this._controller.keypress(searchInput, 'VK_DELETE', {});

    if (activeElement)
      activeElement.focus();
  },

  /**
   * Focus the search bar text field
   *
   * @param {object} event
   *        Specifies the event which has to be used to focus the search bar
   */
  focus : function searchBar_focus(event)
  {
    var input = this.getElement({type: "searchBar_input"});

    switch (event.type) {
      case "click":
        this._controller.click(input);
        break;
      case "shortcut":
        if (mozmill.isLinux) {
          var cmdKey = utils.getEntity(this.getDtds(), "searchFocusUnix.commandkey");
        } else {
          var cmdKey = utils.getEntity(this.getDtds(), "searchFocus.commandkey");
        }
        this._controller.keypress(null, cmdKey, {accelKey: true});
        break;
      default:
        throw new Error(arguments.callee.name + ": Unknown element type - " + event.type);
    }

    // Check if the search bar has the focus
    var activeElement = this._controller.window.document.activeElement;
    this._controller.assertJS("subject.isFocused == true",
                              {isFocused: input.getNode() == activeElement});
  },

  /**
   * Gets all the needed external DTD urls as an array
   *
   * @returns Array of external DTD urls
   * @type [string]
   */
  getDtds : function searchBar_getDtds() {
    var dtds = ["chrome://browser/locale/browser.dtd"];
    return dtds;
  },

  /**
   * Retrieve an UI element based on the given spec
   *
   * @param {object} spec
   *        Information of the UI element which should be retrieved
   *        type: General type information
   *        subtype: Specific element or property
   *        value: Value of the element or property
   * @returns Element which has been created
   * @type ElemBase
   */
  getElement : function searchBar_getElement(spec) {
    var elem = null;

    switch(spec.type) {
      /**
       * subtype: subtype to match
       * value: value to match
       */
      case "engine":
        // XXX: bug 555938 - Mozmill can't fetch the element via a lookup here.
        // That means we have to grab it temporarily by iterating through all childs.
        var popup = this.getElement({type: "searchBar_dropDownPopup"}).getNode();
        for (var ii = 0; ii < popup.childNodes.length; ii++) {
          var entry = popup.childNodes[ii];
          if (entry.getAttribute(spec.subtype) == spec.value) {
            elem = new elementslib.Elem(entry);
            break;
          }
        }
        //elem = new elementslib.Lookup(this._controller.window.document, SEARCH_POPUP +
        //                              '/anon({"' + spec.subtype + '":"' + spec.value + '"})');
        break;
      case "engine_manager":
        // XXX: bug 555938 - Mozmill can't fetch the element via a lookup here.
        // That means we have to grab it temporarily by iterating through all childs.
        var popup = this.getElement({type: "searchBar_dropDownPopup"}).getNode();
        for (var ii = popup.childNodes.length - 1; ii >= 0; ii--) {
          var entry = popup.childNodes[ii];
          if (entry.className == "open-engine-manager") {
            elem = new elementslib.Elem(entry);
            break;
          }
        }
        //elem = new elementslib.Lookup(this._controller.window.document, SEARCH_POPUP +
        //                              '/anon({"anonid":"open-engine-manager"})');
        break;
      case "searchBar":
        elem = new elementslib.Lookup(this._controller.window.document, SEARCH_BAR);
        break;
      case "searchBar_autoCompletePopup":
        elem = new elementslib.Lookup(this._controller.window.document, SEARCH_AUTOCOMPLETE);
        break;
      case "searchBar_contextMenu":
        elem = new elementslib.Lookup(this._controller.window.document, SEARCH_CONTEXT);
        break;
      case "searchBar_dropDown":
        elem = new elementslib.Lookup(this._controller.window.document, SEARCH_DROPDOWN);
        break;
      case "searchBar_dropDownPopup":
        elem = new elementslib.Lookup(this._controller.window.document, SEARCH_POPUP);
        break;
      case "searchBar_goButton":
        elem = new elementslib.Lookup(this._controller.window.document, SEARCH_GO_BUTTON);
        break;
      case "searchBar_input":
        elem = new elementslib.Lookup(this._controller.window.document, SEARCH_INPUT);
        break;
      case "searchBar_suggestions":
        elem = new elementslib.Lookup(this._controller.window.document, SEARCH_AUTOCOMPLETE +
                                      '/anon({"anonid":"tree"})');
         break;
      case "searchBar_textBox":
        elem = new elementslib.Lookup(this._controller.window.document, SEARCH_TEXTBOX);
        break;
      default:
        throw new Error(arguments.callee.name + ": Unknown element type - " + spec.type);
    }

    return elem;
  },

  /**
   * Returns the search suggestions for the search term
   */
  getSuggestions : function(searchTerm) {
    var suggestions = [ ];
    var popup = this.getElement({type: "searchBar_autoCompletePopup"});
    var treeElem = this.getElement({type: "searchBar_suggestions"});

    // XXX Bug 542990, Bug 392633
    // Typing too fast can cause several issue like the suggestions not to appear.
    // Lets type the letters one by one and wait for the popup or the timeout
    for (var i = 0; i < searchTerm.length; i++) {
      try {
        this.type(searchTerm[i]);
        this._controller.waitFor(function () {
          return popup.getNode().state === 'open';
        }, "", TIMEOUT_REQUEST_SUGGESTIONS);
      }
      catch (e) {
        // We are not interested in handling the timeout for now
      }
    }

    // After entering the search term the suggestions have to be visible
    this._controller.assert(function () {
      return popup.getNode().state === 'open';
    }, "Search suggestions are visible");
    this._controller.waitForElement(treeElem, TIMEOUT);

    // Get all suggestions
    var tree = treeElem.getNode();
    this._controller.waitForEval("subject.tree.view != null", TIMEOUT, 100,
                                 {tree: tree});
    for (var i = 0; i < tree.view.rowCount; i ++) {
      suggestions.push(tree.view.getCellText(i, tree.columns.getColumnAt(0)));
    }

    // Close auto-complete popup
    this._controller.keypress(popup, "VK_ESCAPE", {});
    this._controller.waitForEval("subject.popup.state == 'closed'", TIMEOUT, 100,
                                 {popup: popup.getNode()});

    return suggestions;
  },

  /**
   * Check if a search engine is installed (API call)
   *
   * @param {string} name
   *        Name of the search engine to check
   */
  isEngineInstalled : function searchBar_isEngineInstalled(name)
  {
    var engine = this._bss.getEngineByName(name);
    return (engine != null);
  },

  /**
   * Open the Engine Manager
   *
   * @param {function} handler
   *        Callback function for Engine Manager
   */
  openEngineManager : function searchBar_openEngineManager(handler)
  {
    this.enginesDropDownOpen = true;
    var engineManager = this.getElement({type: "engine_manager"});

    // Setup the modal dialog handler
    md = new modalDialog.modalDialog(this._controller.window);
    md.start(handler);

    // XXX: Bug 555347 - Process any outstanding events before clicking the entry
    this._controller.sleep(0);
    this._controller.click(engineManager);
    md.waitForDialog();

    this._controller.assert(function () {
      return this.enginesDropDownOpen == false;
    }, "The search engine drop down menu has been closed", this);
  },

  /**
   * Remove the search engine with the given name (API call)
   *
   * @param {string} name
   *        Name of the search engine to remove
   */
  removeEngine : function searchBar_removeEngine(name)
  {
    if (this.isEngineInstalled(name)) {
      var engine = this._bss.getEngineByName(name);
      this._bss.removeEngine(engine);
    }
  },

  /**
   * Restore the default set of search engines (API call)
   */
  restoreDefaultEngines : function searchBar_restoreDefaults()
  {
    // XXX: Bug 556477 - Restore default sorting
    this.openEngineManager(function(controller) {
      var manager = new engineManager(controller);

      // We have to do any action so the restore button gets enabled
      manager.moveDownEngine(manager.engines[0].name);
      manager.restoreDefaults();
      manager.close(true);
    });

    // Update the visibility status for each engine and reset the default engine
    this._bss.restoreDefaultEngines();
    this._bss.currentEngine = this._bss.defaultEngine;

    // Clear any entered search term
    this.clear();
  },

  /**
   * Start a search with the given search term and check if the resulting URL
   * contains the search term.
   *
   * @param {object} data
   *        Object which contains the search term and the action type
   */
  search : function searchBar_search(data)
  {
    var searchBar = this.getElement({type: "searchBar"});
    this.type(data.text);

    switch (data.action) {
      case "returnKey":
        this._controller.keypress(searchBar, 'VK_RETURN', {});
        break;
      case "goButton":
      default:
        this._controller.click(this.getElement({type: "searchBar_goButton"}));
        break;
    }

    this._controller.waitForPageLoad();
    this.checkSearchResultPage(data.text);
  },

  /**
   * Enter a search term into the search bar
   *
   * @param {string} searchTerm
   *        Text which should be searched for
   */
  type : function searchBar_type(searchTerm) {
    var searchBar = this.getElement({type: "searchBar"});
    this._controller.type(searchBar, searchTerm);
  }
};

// Export of classes
exports.engineManager = engineManager;
exports.searchBar = searchBar;
dactyl-1.2~r20151231/common/tests/functional/shared-modules/sessionstore.js000066400000000000000000000236151264147376100266630ustar00rootroot00000000000000/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is MozMill Test code.
 *
 * The Initial Developer of the Original Code is Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2010
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Henrik Skupin 
 *   Aaron Train 
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

/**
 * @fileoverview
 * The SessionStoreAPI adds support for accessing session related elements and features
 *
 * @version 1.0.0
 */

// Include required modules
var prefs = require("prefs");
var utils = require("utils");
var widgets = require("widgets");

// Session Store service
var sessionStoreService = Cc["@mozilla.org/browser/sessionstore;1"]
                             .getService(Ci.nsISessionStore);

// Preference for indicating the amount of restorable tabs
const SESSIONSTORE_MAXTABS_PREF = 'browser.sessionstore.max_tabs_undo';

const gTimeout = 5000;

/**
 * Constructor
 *
 * @param {MozMillController} controller
 *        MozMill controller of the browser window to operate on.
 */
function aboutSessionRestore(controller)
{
  this._controller = controller;
}

/**
 * This class handles the about:sessionrestore page.
 */
aboutSessionRestore.prototype = {
  /**
   * Returns the MozMill controller
   *
   * @returns Mozmill controller
   * @type {MozMillController}
   */
  get controller() {
    return this._controller;
  },

  /**
   * Returns the tree which contains the windows and tabs
   *
   * @returns Tree with windows and tabs to restore
   * @type {ElemBase}
   */
  get tabList() {
    return this.getElement({type: "tabList"});
  },

  /**
   * Gets all the needed external DTD urls as an array
   *
   * @returns Array of external DTD urls
   * @type [string]
   */
  getDtds : function aboutSessionRestore_getDtds() {
    var dtds = ["chrome://browser/locale/browser.dtd",
                "chrome://browser/locale/aboutSessionRestore.dtd"];
    return dtds;
  },

  /**
   * Retrieve an UI element based on the given spec
   *
   * @param {object} spec
   *        Information of the UI element which should be retrieved
   *        type: General type information
   *        subtype: Specific element or property
   *        value: Value of the element or property
   * @returns Element which has been created
   * @type {ElemBase}
   */
  getElement : function aboutSessionRestore_getElement(spec) {
    var elem = null;

    switch(spec.type) {
      case "button_restoreSession":
        elem = new elementslib.ID(this._controller.tabs.activeTab, "errorTryAgain");
        break;
      case "error_longDesc":
        elem = new elementslib.ID(this._controller.tabs.activeTab, "errorLongDesc");
        break;
      case "error_pageContainer":
        elem = new elementslib.ID(this._controller.tabs.activeTab, "errorPageContainer");
        break;
      case "error_shortDesc":
        elem = new elementslib.ID(this._controller.tabs.activeTab, "errorShortDescText");
        break;
      case "error_title":
        elem = new elementslib.ID(this._controller.tabs.activeTab, "errorTitleText");
        break;
      case "tabList":
        elem = new elementslib.ID(this._controller.window.document, "tabList");
        break;
      default:
        throw new Error(arguments.callee.name + ": Unknown element type - " + spec.type);
    }

    return elem;
  },

  /**
   * Returns the current restore state of the given element
   *
   * @param {object} element
   *        Element which restore state should be retrieved
   * @returns True if the element should be restored
   * @type {boolean}
   *
   */
  getRestoreState : function aboutSessionRestore_getRestoreState(element) {
    var tree = this.tabList.getNode();

    return tree.view.getCellValue(element.listIndex, tree.columns.getColumnAt(0));
  },

  /**
   * Get restorable tabs under the given window
   *
   * @param {object} window
   *        Window inside the tree
   * @returns List of tabs
   * @type {array of object}
   */
  getTabs : function aboutSessionRestore_getTabs(window) {
    var tabs = [ ];
    var tree = this.tabList.getNode();

    // Add entries when they are tabs (no container)
    var ii = window.listIndex + 1;
    while (ii < tree.view.rowCount && !tree.view.isContainer(ii)) {
      tabs.push({
                 index: tabs.length,
                 listIndex : ii,
                 restore: tree.view.getCellValue(ii, tree.columns.getColumnAt(0)),
                 title: tree.view.getCellText(ii, tree.columns.getColumnAt(2))
                });
      ii++;
    }

    return tabs;
  },

  /**
   * Get restorable windows
   *
   * @returns List of windows
   * @type {array of object}
   */
  getWindows : function aboutSessionRestore_getWindows() {
    var windows = [ ];
    var tree = this.tabList.getNode();

    for (var ii = 0; ii < tree.view.rowCount; ii++) {
      if (tree.view.isContainer(ii)) {
        windows.push({
                      index: windows.length,
                      listIndex : ii,
                      open: tree.view.isContainerOpen(ii),
                      restore: tree.view.getCellValue(ii, tree.columns.getColumnAt(0)),
                      title: tree.view.getCellText(ii, tree.columns.getColumnAt(2))
                     });
      }
    }

    return windows;
  },

  /**
   * Toggles the restore state for the element
   *
   * @param {object} element
   *        Specifies the element which restore state should be toggled
   */
  toggleRestoreState : function aboutSessionRestore_toggleRestoreState(element) {
    var state = this.getRestoreState(element);

    widgets.clickTreeCell(this._controller, this.tabList, element.listIndex, 0, {});
    this._controller.sleep(0);

    this._controller.assertJS("subject.newState != subject.oldState",
                              {newState : this.getRestoreState(element), oldState : state});
  }
}

/**
 * Resets the list of recently closed tabs by setting and clearing the user preference
 */
function resetRecentlyClosedTabs()
{
  prefs.preferences.setPref(SESSIONSTORE_MAXTABS_PREF, 0);
  prefs.preferences.clearUserPref(SESSIONSTORE_MAXTABS_PREF);
}

/**
 * Returns the number of restorable tabs for a given window
 *
 * @param {MozMillController} controller
 *        MozMillController of the window to operate on
 * @returns The number of restorable tabs in the window
 */
function getClosedTabCount(controller)
{
  return sessionStoreService.getClosedTabCount(controller.window);
}

/**
 * Restores the tab which has been recently closed
 *
 * @param {MozMillController} controller
 *        MozMillController of the window to operate on
 * @param {object} event
 *        Specifies the event to use to execute the command
 */
function undoClosedTab(controller, event)
{
  var count = sessionStoreService.getClosedTabCount(controller.window);

  switch (event.type) {
    case "menu":
      throw new Error("Menu gets build dynamically and cannot be accessed.");
      break;
    case "shortcut":
      var cmdKey = utils.getEntity(this.getDtds(), "tabCmd.commandkey");
      controller.keypress(null, cmdKey, {accelKey: true, shiftKey: true});
      break;
  }

  if (count > 0)
    controller.assertJS("subject.newTabCount < subject.oldTabCount",
                        {
                         newTabCount : sessionStoreService.getClosedTabCount(controller.window),
                         oldTabCount : count
                        });
}

/**
 * Restores the window which has been recently closed
 *
 * @param {MozMillController} controller
 *        MozMillController of the window to operate on
 * @param {object} event
 *        Specifies the event to use to execute the command
 */
function undoClosedWindow(controller, event)
{
  var count = sessionStoreService.getClosedWindowCount(controller.window);

  switch (event.type) {
    case "menu":
      throw new Error("Menu gets build dynamically and cannot be accessed.");
      break;
    case "shortcut":
      var cmdKey = utils.getEntity(this.getDtds(), "newNavigatorCmd.key");
      controller.keypress(null, cmdKey, {accelKey: true, shiftKey: true});
      break;
  }

  if (count > 0)
    controller.assertJS("subject.newWindowCount < subject.oldWindowCount",
                        {
                         newWindowCount : sessionStoreService.getClosedWindowCount(controller.window),
                         oldWindowCount : count
                        });
}

// Export of functions
exports.getClosedTabCount = getClosedTabCount;
exports.resetRecentlyClosedTabs = resetRecentlyClosedTabs;
exports.undoClosedTab = undoClosedTab;
exports.undoClosedWindow = undoClosedWindow;

// Export of classes
exports.aboutSessionRestore = aboutSessionRestore;
dactyl-1.2~r20151231/common/tests/functional/shared-modules/software-update.js000066400000000000000000000431451264147376100272350ustar00rootroot00000000000000/* * ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is MozMill Test code.
 *
 * The Initial Developer of the Original Code is Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2009
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Henrik Skupin 
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * **** END LICENSE BLOCK ***** */

/**
 * @fileoverview
 * The SoftwareUpdateAPI adds support for an easy access to the update process.
 */

// Include required modules
var prefs = require("prefs");
var utils = require("utils");

const gTimeoutUpdateCheck     = 10000;
const gTimeoutUpdateDownload  = 360000;

const PREF_DISABLED_ADDONS = "extensions.disabledAddons";

// Helper lookup constants for elements of the software update dialog
const WIZARD = '/id("updates")';
const WIZARD_BUTTONS = WIZARD + '/anon({"anonid":"Buttons"})';
const WIZARD_DECK = WIZARD  + '/anon({"anonid":"Deck"})';

const WIZARD_PAGES = {
  dummy: 'dummy',
  checking: 'checking',
  pluginUpdatesFound: 'pluginupdatesfound',
  noUpdatesFound: 'noupdatesfound',
  manualUpdate: 'manualUpdate',
  incompatibleCheck: 'incompatibleCheck',
  updatesFoundBasic: 'updatesfoundbasic',
  updatesFoundBillboard: 'updatesfoundbillboard',
  license: 'license',
  incompatibleList: 'incompatibleList',
  downloading: 'downloading',
  errors: 'errors',
  errorPatching: 'errorpatching',
  finished: 'finished',
  finishedBackground: 'finishedBackground',
  installed: 'installed'
}

// On Mac there is another DOM structure used as on Windows and Linux
if (mozmill.isMac) {
  var WIZARD_BUTTONS_BOX = WIZARD_BUTTONS +
                             '/anon({"flex":"1"})/{"class":"wizard-buttons-btm"}/';
  var WIZARD_BUTTON = {
          back: '{"dlgtype":"back"}',
          next: '{"dlgtype":"next"}',
          cancel: '{"dlgtype":"cancel"}',
          finish: '{"dlgtype":"finish"}',
          extra1: '{"dlgtype":"extra1"}',
          extra2: '{"dlgtype":"extra2"}'
        }
} else {
  var WIZARD_BUTTONS_BOX = WIZARD_BUTTONS +
                       '/anon({"flex":"1"})/{"class":"wizard-buttons-box-2"}/';
  var WIZARD_BUTTON = {
    back: '{"dlgtype":"back"}',
    next: 'anon({"anonid":"WizardButtonDeck"})/[1]/{"dlgtype":"next"}',
    cancel: '{"dlgtype":"cancel"}',
    finish: 'anon({"anonid":"WizardButtonDeck"})/[0]/{"dlgtype":"finish"}',
    extra1: '{"dlgtype":"extra1"}',
    extra2: '{"dlgtype":"extra2"}'
  }
}

/**
 * Constructor for software update class
 */
function softwareUpdate() {
  this._controller = null;
  this._wizard = null;
  this._downloadDuration = -1;

  this._aus = Cc["@mozilla.org/updates/update-service;1"].
              getService(Ci.nsIApplicationUpdateService);
  this._ums = Cc["@mozilla.org/updates/update-manager;1"].
              getService(Ci.nsIUpdateManager);
  this._vc = Cc["@mozilla.org/xpcom/version-comparator;1"].
             getService(Ci.nsIVersionComparator);
}

/**
 * Class for software updates
 */
softwareUpdate.prototype = {
  /**
   * Returns the active update
   *
   * @returns The currently selected update
   * @type nsIUpdate
   */
  get activeUpdate() {
    return this._ums.activeUpdate;
  },

  /**
   * Check if the user has permissions to run the software update
   *
   * @returns Status if the user has the permissions.
   * @type {boolean}
   */
  get allowed() {
    return this._aus.canCheckForUpdates && this._aus.canApplyUpdates;
  },

  /**
   * Returns information of the current build version
   */
  get buildInfo() {
    return {
      buildid : utils.appInfo.buildID,
      disabled_addons : prefs.preferences.getPref(PREF_DISABLED_ADDONS, ''),
      locale : utils.appInfo.locale,
      user_agent : utils.appInfo.userAgent,
      version : utils.appInfo.version
    };
  },

  /**
   * Returns the current update channel
   */
  get channel() {
    return prefs.preferences.getPref('app.update.channel', '');
  },

  /**
   * Get the controller of the associated engine manager dialog
   *
   * @returns Controller of the browser window
   * @type MozMillController
   */
  get controller() {
    return this._controller;
  },

  /**
   * Returns the current step of the software update dialog wizard
   */
  get currentPage() {
    return this._wizard.getNode().getAttribute('currentpageid');
  },

  /**
   * Returns true if the offered update is a complete update
   */
  get isCompleteUpdate() {
    // Throw when isCompleteUpdate is called without an update. This should
    // never happen except if the test is incorrectly written.
    if (!this.activeUpdate)
      throw new Error(arguments.callee.name + ": isCompleteUpdate called " +
                      "when activeUpdate is null!");

    var patchCount = this.activeUpdate.patchCount;
    if ((patchCount < 1) || (patchCount > 2)) {
      throw new Error("An update must have one or two patches included.");
    }

    // XXX: After Firefox 4 has been released and we do not have to test any
    // beta release anymore uncomment out the following code
//    if (this.activeUpdate.patchCount == 2) {
//      var patch0URL = this.activeUpdate.getPatchAt(0).URL;
//      var patch1URL = this.activeUpdate.getPatchAt(1).URL;
       // Test that the update snippet created by releng doesn't have the same
       // url for both patches (bug 514040).
//      controller.assertJS("subject.patch0URL != subject.patch1URL",
//                          {patch0URL: patch0URL, patch1URL: patch1URL});
//    }

    return (this.activeUpdate.selectedPatch.type  == "complete");
  },

   /**
   * Returns information of the active update in the queue.
   */
  get patchInfo() {
    this._controller.assert(function() {
      return !!this.activeUpdate;
    }, "An active update is in the queue.", this);

    return {
      buildid : this.activeUpdate.buildID,
      channel : this.channel,
      is_complete : this.isCompleteUpdate,
      size : this.activeUpdate.selectedPatch.size,
      type : this.activeUpdate.type,
      url : this.activeUpdate.selectedPatch.finalURL || "n/a",
      download_duration : this._downloadDuration,
      version : this.activeUpdate.version
    };
  },

  /**
   * Returns the update type (minor or major)
   *
   * @returns The update type
   */
  get updateType() {
    return this.activeUpdate.type;
  },

  /**
   * Check if updates have been found
   */
  get updatesFound() {
    return this.currentPage.indexOf("updatesfound") == 0;
  },

  /**
   * Checks if an update has been applied correctly
   *
   * @param {object} updateData
   *        All the data collected during the update process
   */
  assertUpdateApplied : function softwareUpdate_assertUpdateApplied(updateData) {
    // Get the information from the last update
    var info = updateData.updates[updateData.updateIndex];

    // The upgraded version should be identical with the version given by
    // the update and we shouldn't have run a downgrade
    var check = this._vc.compare(info.build_post.version, info.build_pre.version);
    this._controller.assert(function () {
      return check >= 0;
    }, "The version number of the upgraded build is higher or equal.");

    // The build id should be identical with the one from the update
    this._controller.assert(function () {
      return info.build_post.buildid === info.patch.buildid;
    }, "The build id is equal to the build id of the update.");

    // If a target build id has been given, check if it matches the updated build
    info.target_buildid = updateData.targetBuildID;
    if (info.target_buildid) {
      this._controller.assert(function () {
        return info.build_post.buildid === info.target_buildid;
      }, "Target build id matches id of updated build.");
    }

    // An upgrade should not change the builds locale
    this._controller.assert(function () {
      return info.build_post.locale === info.build_pre.locale;
    }, "The locale of the updated build is identical to the original locale.");

    // Check that no application-wide add-ons have been disabled
    this._controller.assert(function () {
      return info.build_post.disabled_addons === info.build_pre.disabled_addons;
    }, "No application-wide add-ons have been disabled by the update.");
  },

  /**
   * Close the software update dialog
   */
  closeDialog: function softwareUpdate_closeDialog() {
    if (this._controller) {
      this._controller.keypress(null, "VK_ESCAPE", {});
      this._controller.sleep(500);
      this._controller = null;
      this._wizard = null;
    }
  },

  /**
   * Download the update of the given channel and type
   * @param {string} channel
   *        Update channel to use
   * @param {boolean} waitForFinish
   *        Sets if the function should wait until the download has been finished
   * @param {number} timeout
   *        Timeout the download has to stop
   */
  download : function softwareUpdate_download(channel, waitForFinish, timeout) {
    waitForFinish = waitForFinish ? waitForFinish : true;

    // Check that the correct channel has been set
    this._controller.assert(function() {
      return channel == this.channel;
    }, "The current update channel is identical to the specified one.", this);

    // Retrieve the timestamp, so we can measure the duration of the download
    var startTime = Date.now();

    // Click the next button
    var next = this.getElement({type: "button", subtype: "next"});
    this._controller.click(next);

    // Wait for the download page - if it fails the update was already cached
    try {
      this.waitForWizardPage(WIZARD_PAGES.downloading);

      if (waitForFinish)
        this.waitforDownloadFinished(timeout);
    } catch (ex) {
      this.waitForWizardPage(WIZARD_PAGES.finished);
    }

    // Calculate the duration in ms
    this._downloadDuration = Date.now() - startTime;
  },

  /**
   * Update the update.status file and set the status to 'failed:6'
   */
  forceFallback : function softwareUpdate_forceFallback() {
    var dirService = Cc["@mozilla.org/file/directory_service;1"].
                     getService(Ci.nsIProperties);

    var updateDir;
    var updateStatus;

    // Check the global update folder first
    try {
      updateDir = dirService.get("UpdRootD", Ci.nsIFile);
      updateDir.append("updates");
      updateDir.append("0");

      updateStatus = updateDir.clone();
      updateStatus.append("update.status");
    } catch (ex) {
    }

    if (updateStatus == undefined || !updateStatus.exists()) {
      updateDir = dirService.get("XCurProcD", Ci.nsIFile);
      updateDir.append("updates");
      updateDir.append("0");

      updateStatus = updateDir.clone();
      updateStatus.append("update.status");
    }

    var foStream = Cc["@mozilla.org/network/file-output-stream;1"].
                   createInstance(Ci.nsIFileOutputStream);
    var status = "failed: 6\n";
    foStream.init(updateStatus, 0x02 | 0x08 | 0x20, -1, 0);
    foStream.write(status, status.length);
    foStream.close();
  },

  /**
   * Gets all the needed external DTD urls as an array
   *
   * @returns Array of external DTD urls
   * @type [string]
   */
  getDtds : function softwareUpdate_getDtds() {
    var dtds = ["chrome://mozapps/locale/update/history.dtd",
                "chrome://mozapps/locale/update/updates.dtd"]
    return dtds;
  },

  /**
   * Retrieve an UI element based on the given spec
   *
   * @param {object} spec
   *        Information of the UI element which should be retrieved
   *        type: General type information
   *        subtype: Specific element or property
   *        value: Value of the element or property
   * @returns Element which has been created
   * @type {ElemBase}
   */
  getElement : function softwareUpdate_getElement(spec) {
    var elem = null;

    switch(spec.type) {
      /**
       * subtype: subtype to match
       * value: value to match
       */
      case "button":
        elem = new elementslib.Lookup(this._controller.window.document,
                                      WIZARD_BUTTONS_BOX + WIZARD_BUTTON[spec.subtype]);
        break;
      case "wizard":
        elem = new elementslib.Lookup(this._controller.window.document, WIZARD);
        break;
      case "wizard_page":
        elem = new elementslib.Lookup(this._controller.window.document, WIZARD_DECK +
                                      '/id(' + spec.subtype + ')');
        break;
      case "download_progress":
        elem = new elementslib.ID(this._controller.window.document, "downloadProgress");
        break;
      default:
        throw new Error(arguments.callee.name + ": Unknown element type - " + spec.type);
    }

    return elem;
  },

  /**
   * Open software update dialog
   *
   * @param {MozMillController} browserController
   *        Mozmill controller of the browser window
   */
  openDialog: function softwareUpdate_openDialog(browserController) {
    // XXX: After Firefox 4 has been released and we do not have to test any
    // beta release anymore uncomment out the following code

    // With version >= 4.0b7pre the update dialog is reachable from within the
    // about window now.
    var appVersion = utils.appInfo.version;

    if (this._vc.compare(appVersion, "4.0b7pre") >= 0) {
      // XXX: We can't open the about window, otherwise a parallel download of
      // the update will let us fallback to a complete one all the time

      // Open the about window and check the update button
      //var aboutItem = new elementslib.Elem(browserController.menus.helpMenu.aboutName);
      //browserController.click(aboutItem);
      //
      //utils.handleWindow("type", "Browser:About", function(controller) {
      //  // XXX: Bug 599290 - Check for updates has been completely relocated
      //  // into the about window. We can't check the in-about ui yet.
      //  var updateButton = new elementslib.ID(controller.window.document,
      //                                        "checkForUpdatesButton");
      //  //controller.click(updateButton);
      //  controller.waitForElement(updateButton, gTimeout);
      //});

      // For now just call the old ui until we have support for the about window.
      var updatePrompt = Cc["@mozilla.org/updates/update-prompt;1"].
                         createInstance(Ci.nsIUpdatePrompt);
      updatePrompt.checkForUpdates();
    } else {
      // For builds <4.0b7pre
      updateItem = new elementslib.Elem(browserController.menus.helpMenu.checkForUpdates);
      browserController.click(updateItem);
    }

    this.waitForDialogOpen(browserController);
  },

  /**
   * Wait that check for updates has been finished
   * @param {number} timeout
   */
  waitForCheckFinished : function softwareUpdate_waitForCheckFinished(timeout) {
    timeout = timeout ? timeout : gTimeoutUpdateCheck;

    this._controller.waitFor(function() {
      return this.currentPage != WIZARD_PAGES.checking;
    }, "Check for updates has been completed.", timeout, null, this);
  },

  /**
   * Wait for the software update dialog
   *
   * @param {MozMillController} browserController
   *        Mozmill controller of the browser window
   */
  waitForDialogOpen : function softwareUpdate_waitForDialogOpen(browserController) {
    this._controller = utils.handleWindow("type", "Update:Wizard",
                                          undefined, false);
    this._wizard = this.getElement({type: "wizard"});

    this._controller.waitFor(function () {
      return this.currentPage !== WIZARD_PAGES.dummy;
    }, "Dummy wizard page has been made invisible - got " + this.currentPage,
      undefined, undefined, this);

    this._controller.window.focus();
  },

  /**
   * Wait until the download has been finished
   *
   * @param {number} timeout
   *        Timeout the download has to stop
   */
  waitforDownloadFinished: function softwareUpdate_waitForDownloadFinished(timeout) {
    timeout = timeout ? timeout : gTimeoutUpdateDownload;

    var progress =  this.getElement({type: "download_progress"});
    this._controller.waitFor(function () {
      return progress.getNode().value === '100';
    }, "Update has been finished downloading.", timeout);

    this.waitForWizardPage(WIZARD_PAGES.finished);
  },

  /**
   * Waits for the given page of the update dialog wizard
   */
  waitForWizardPage : function softwareUpdate_waitForWizardPage(step) {
    this._controller.waitFor(function () {
      return this.currentPage === step;
    }, "New wizard page has been selected - got " + this.currentPage +
      ", expected " + step, undefined, undefined, this);
  }
}

// Export of variables
exports.WIZARD_PAGES = WIZARD_PAGES;

// Export of classes
exports.softwareUpdate = softwareUpdate;
dactyl-1.2~r20151231/common/tests/functional/shared-modules/tabs.js000066400000000000000000000415441264147376100250550ustar00rootroot00000000000000/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is MozMill Test code.
 *
 * The Initial Developer of the Original Code is Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2009
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Henrik Skupin 
 *   Anthony Hughes 
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

/**
 * @fileoverview
 * The TabbedBrowsingAPI adds support for accessing and interacting with tab elements
 *
 * @version 1.0.0
 */

// Include required modules
var utils = require("utils");
var prefs = require("prefs");

const TIMEOUT = 5000;

const PREF_TABS_ANIMATE = "browser.tabs.animate";

const TABS_VIEW = '/id("main-window")/id("tab-view-deck")/{"flex":"1"}';
const TABS_BROWSER = TABS_VIEW + '/id("browser")/id("appcontent")/id("content")';
const TABS_TOOLBAR = TABS_VIEW + '/id("navigator-toolbox")/id("TabsToolbar")';
const TABS_TABS = TABS_TOOLBAR + '/id("tabbrowser-tabs")';
const TABS_ARROW_SCROLLBOX = TABS_TABS + '/anon({"anonid":"arrowscrollbox"})';
const TABS_STRIP = TABS_ARROW_SCROLLBOX + '/anon({"anonid":"scrollbox"})/anon({"flex":"1"})';

/**
 * Close all tabs and open about:blank
 *
 * @param {MozMillController} controller
 *        MozMillController of the window to operate on
 */
function closeAllTabs(controller)
{
  var browser = new tabBrowser(controller);
  browser.closeAllTabs();
}

/**
 * Check and return all open tabs with the specified URL
 *
 * @param {string} aUrl
 *        URL to check for
 *
 * @returns Array of tabs
 */
function getTabsWithURL(aUrl) {
  var tabs = [ ];

  var uri = utils.createURI(aUrl, null, null);

  var wm = Cc["@mozilla.org/appshell/window-mediator;1"].
           getService(Ci.nsIWindowMediator);
  var winEnum = wm.getEnumerator("navigator:browser");

  // Iterate through all windows
  while (winEnum.hasMoreElements()) {
    var window = winEnum.getNext();

    // Don't check windows which are about to close or don't have gBrowser set
    if (window.closed || !("gBrowser" in window))
      continue;

    // Iterate through all tabs in the current window
    var browsers = window.gBrowser.browsers;
    for (var i = 0; i < browsers.length; i++) {
      var browser = browsers[i];
      if (browser.currentURI.equals(uri)) {
        tabs.push({
          controller : new mozmill.controller.MozMillController(window),
          index : i
        });
      }
    }
  }

  return tabs;
}

/**
 * Constructor
 *
 * @param {MozMillController} controller
 *        MozMill controller of the window to operate on
 */
function tabBrowser(controller)
{
  this._controller = controller;
  this._tabs = this.getElement({type: "tabs"});
}

/**
 * Tabbed Browser class
 */
tabBrowser.prototype = {
  /**
   * Returns the MozMill controller
   *
   * @returns Mozmill controller
   * @type {MozMillController}
   */
  get controller() {
    return this._controller;
  },

  /**
   * Get the amount of open tabs
   *
   * @returns Number of tabs
   * @type {number}
   */
  get length() {
    return this._tabs.getNode().itemCount;
  },

  /**
   * Get the currently selected tab index
   *
   * @returns Index of currently selected tab
   * @type {number}
   */
  get selectedIndex() {
    return this._tabs.getNode().selectedIndex;
  },

  /**
   * Select the tab with the given index
   *
   * @param {number} index
   *        Index of the tab which should be selected
   */
  set selectedIndex(index) {
    this._controller.click(this.getTab(index));
  },

  /**
   * Close all tabs of the window except the last one and open a blank page.
   */
  closeAllTabs : function tabBrowser_closeAllTabs()
  {
    while (this._controller.tabs.length > 1) {
      this.closeTab({type: "menu"});
    }

    this._controller.open("about:blank");
    this._controller.waitForPageLoad();
  },

  /**
   * Close an open tab
   *
   * @param {object} aEvent
   *        The event specifies how to close a tab
   *        Elements: type - Type of event (closeButton, menu, middleClick, shortcut)
   *                         [optional - default: menu]
   */
  closeTab : function tabBrowser_closeTab(aEvent) {
    var event = aEvent || { };
    var type = (event.type == undefined) ? "menu" : event.type;

    // Disable tab closing animation for default behavior
    prefs.preferences.setPref(PREF_TABS_ANIMATE, false);

    // Add event listener to wait until the tab has been closed
    var self = { closed: false };
    function checkTabClosed() { self.closed = true; }
    this._controller.window.addEventListener("TabClose", checkTabClosed, false);

    switch (type) {
      case "closeButton":
        var button = this.getElement({type: "tabs_tabCloseButton",
                                     subtype: "tab", value: this.getTab()});
        this._controller.click(button);
        break;
      case "menu":
        var menuitem = new elementslib.Elem(this._controller.menus['file-menu'].menu_close);
        this._controller.click(menuitem);
        break;
      case "middleClick":
        var tab = this.getTab(event.index);
        this._controller.middleClick(tab);
        break;
      case "shortcut":
        var cmdKey = utils.getEntity(this.getDtds(), "closeCmd.key");
        this._controller.keypress(null, cmdKey, {accelKey: true});
        break;
      default:
        throw new Error(arguments.callee.name + ": Unknown event type - " + type);
    }

    try {
      this._controller.waitForEval("subject.tab.closed == true", TIMEOUT, 100,
                                   {tab: self});
    } finally {
      this._controller.window.removeEventListener("TabClose", checkTabClosed, false);
      prefs.preferences.clearUserPref(PREF_TABS_ANIMATE);
    }
  },

  /**
   * Gets all the needed external DTD urls as an array
   *
   * @returns Array of external DTD urls
   * @type [string]
   */
  getDtds : function tabBrowser_getDtds() {
    var dtds = ["chrome://browser/locale/browser.dtd",
                "chrome://browser/locale/tabbrowser.dtd",
                "chrome://global/locale/global.dtd"];
    return dtds;
  },

  /**
   * Retrieve an UI element based on the given spec
   *
   * @param {object} spec
   *        Information of the UI element which should be retrieved
   *        type: General type information
   *        subtype: Specific element or property
   *        value: Value of the element or property
   * @returns Element which has been created
   * @type {ElemBase}
   */
  getElement : function tabBrowser_getElement(spec) {
    var document = this._controller.window.document;
    var elem = null;

    switch(spec.type) {
      /**
       * subtype: subtype to match
       * value: value to match
       */
      case "tabs":
        elem = new elementslib.Lookup(this._controller.window.document,
                                      TABS_TABS);
        break;
      case "tabs_allTabsButton":
        elem = new elementslib.Lookup(this._controller.window.document,
                                      TABS_TOOLBAR + '/id("alltabs-button")');
        break;
      case "tabs_allTabsPopup":
        elem = new elementslib.Lookup(this._controller.window.document, TABS_TOOLBAR +
                                      '/id("alltabs-button")/id("alltabs-popup")');
        break;
      case "tabs_newTabButton":
        elem = new elementslib.Lookup(this._controller.window.document,
                                      TABS_ARROW_SCROLLBOX + '/anon({"class":"tabs-newtab-button"})');
        break;
      case "tabs_scrollButton":
        elem = new elementslib.Lookup(this._controller.window.document,
                                      TABS_ARROW_SCROLLBOX +
                                      '/anon({"anonid":"scrollbutton-' + spec.subtype + '"})');
        break;
      case "tabs_strip":
        elem = new elementslib.Lookup(this._controller.window.document, TABS_STRIP);
        break;
      case "tabs_tab":
        switch (spec.subtype) {
          case "index":
            elem = new elementslib.Elem(this._tabs.getNode().getItemAtIndex(spec.value));
            break;
        }
        break;
      case "tabs_tabCloseButton":
        var node = document.getAnonymousElementByAttribute(
                     spec.value.getNode(),
                     "anonid",
                     "close-button"
                   );
        elem = new elementslib.Elem(node);
        break;
      case "tabs_tabFavicon":
        var node = document.getAnonymousElementByAttribute(
                     spec.value.getNode(),
                     "class",
                     "tab-icon-image"
                   );

        elem = new elementslib.Elem(node);
        break;
      case "tabs_tabPanel":
        var panelId = spec.value.getNode().getAttribute("linkedpanel");
        elem = new elementslib.Lookup(this._controller.window.document, TABS_BROWSER +
                                      '/anon({"anonid":"tabbox"})/anon({"anonid":"panelcontainer"})' +
                                      '/{"id":"' + panelId + '"}');
        break;
      default:
        throw new Error(arguments.callee.name + ": Unknown element type - " + spec.type);
    }

    return elem;
  },

  /**
   * Get the tab at the specified index
   *
   * @param {number} index
   *        Index of the tab
   * @returns The requested tab
   * @type {ElemBase}
   */
  getTab : function tabBrowser_getTab(index) {
    if (index === undefined)
      index = this.selectedIndex;

    return this.getElement({type: "tabs_tab", subtype: "index", value: index});
  },

  /**
   * Creates the child element of the tab's notification bar
   *
   * @param {number} tabIndex
   *        (Optional) Index of the tab to check
   * @param {string} elemString
   *        (Optional) Lookup string of the notification bar's child element
   * @return The created child element
   * @type {ElemBase}
   */
  getTabPanelElement : function tabBrowser_getTabPanelElement(tabIndex, elemString)
  {
    var index = tabIndex ? tabIndex : this.selectedIndex;
    var elemStr = elemString ? elemString : "";

    // Get the tab panel and check if an element has to be fetched
    var panel = this.getElement({type: "tabs_tabPanel", subtype: "tab", value: this.getTab(index)});
    var elem = new elementslib.Lookup(this._controller.window.document, panel.expression + elemStr);

    return elem;
  },

  /**
   * Open element (link) in a new tab
   *
   * @param {object} aEvent
   *        The event specifies how to open the element in a new tab
   *        Elements: type   - Type of event (contextMenu, middleClick)
   *                           [optional - default: middleClick]
   *                  target - Element to click on
   *                           [optional - default: -]
   */
  openInNewTab : function tabBrowser_openInNewTab(aEvent) {
    var event = aEvent || { };
    var type = (event.type == undefined) ? "middleClick" : event.type;
    var target = event.target;

    // Disable tab closing animation for default behavior
    prefs.preferences.setPref(PREF_TABS_ANIMATE, false);

    // Add event listener to wait until the tab has been opened
    var self = { opened: false };
    function checkTabOpened() { self.opened = true; }
    this._controller.window.addEventListener("TabOpen", checkTabOpened, false);

    switch (type) {
      case "contextMenu":
        var contextMenuItem = new elementslib.ID(this._controller.window.document,
                                                 "context-openlinkintab");
        this._controller.rightClick(target);
        this._controller.click(contextMenuItem);
        utils.closeContentAreaContextMenu(this._controller);
        break;
      case "middleClick":
        this._controller.middleClick(target);
        break;
      default:
        throw new Error(arguments.callee.name + ": Unknown event type - " + type);
    }

    try {
      this._controller.waitForEval("subject.tab.opened == true", TIMEOUT, 100,
                                   {tab: self});
    } finally {
      this._controller.window.removeEventListener("TabOpen", checkTabOpened, false);
      prefs.preferences.clearUserPref(PREF_TABS_ANIMATE);
    }
  },

  /**
   * Open a new tab
   *
   * @param {object} aEvent
   *        The event specifies how to open a new tab (menu, shortcut,
   *        Elements: type - Type of event (menu, newTabButton, shortcut, tabStrip)
   *                         [optional - default: menu]
   */
  openTab : function tabBrowser_openTab(aEvent) {
    var event = aEvent || { };
    var type = (event.type == undefined) ? "menu" : event.type;

    // Disable tab closing animation for default behavior
    prefs.preferences.setPref(PREF_TABS_ANIMATE, false);

    // Add event listener to wait until the tab has been opened
    var self = { opened: false };
    function checkTabOpened() { self.opened = true; }
    this._controller.window.addEventListener("TabOpen", checkTabOpened, false);

    switch (type) {
      case "menu":
        var menuitem = new elementslib.Elem(this._controller.menus['file-menu'].menu_newNavigatorTab);
        this._controller.click(menuitem);
        break;
      case "shortcut":
        var cmdKey = utils.getEntity(this.getDtds(), "tabCmd.commandkey");
        this._controller.keypress(null, cmdKey, {accelKey: true});
        break;
      case "newTabButton":
        var newTabButton = this.getElement({type: "tabs_newTabButton"});
        this._controller.click(newTabButton);
        break;
      case "tabStrip":
        var tabStrip = this.getElement({type: "tabs_strip"});

        // RTL-locales need to be treated separately
        if (utils.getEntity(this.getDtds(), "locale.dir") == "rtl") {
          // XXX: Workaround until bug 537968 has been fixed
          this._controller.click(tabStrip, 100, 3);
          // Todo: Calculate the correct x position
          this._controller.doubleClick(tabStrip, 100, 3);
        } else {
          // XXX: Workaround until bug 537968 has been fixed
          this._controller.click(tabStrip, tabStrip.getNode().clientWidth - 100, 3);
          // Todo: Calculate the correct x position
          this._controller.doubleClick(tabStrip, tabStrip.getNode().clientWidth - 100, 3);
        }
        break;
      default:
        throw new Error(arguments.callee.name + ": Unknown event type - " + type);
    }

    try {
      this._controller.waitForEval("subject.tab.opened == true", TIMEOUT, 100,
                                   {tab: self});
    } finally {
      this._controller.window.removeEventListener("TabOpen", checkTabOpened, false);
      prefs.preferences.clearUserPref(PREF_TABS_ANIMATE);
    }
  },

  /**
   * Waits for a particular tab panel element to display and stop animating
   *
   * @param {number} tabIndex
   *        Index of the tab to check
   * @param {string} elemString
   *        Lookup string of the tab panel element
   */
  waitForTabPanel: function tabBrowser_waitForTabPanel(tabIndex, elemString) {
    // Get the specified tab panel element
    var tabPanel = this.getTabPanelElement(tabIndex, elemString);

    // Get the style information for the tab panel element
    var style = this._controller.window.getComputedStyle(tabPanel.getNode(), null);

    // Wait for the top margin to be 0px - ie. has stopped animating
    // XXX: A notification bar starts at a negative pixel margin and drops down
    //      to 0px.  This creates a race condition where a test may click
    //      before the notification bar appears at it's anticipated screen location
    this._controller.waitFor(function () {
      return style.marginTop == '0px';
    }, "Expected notification bar to be visible: '" + elemString + "' ");
  }
}

// Export of functions
exports.closeAllTabs = closeAllTabs;
exports.getTabsWithURL = getTabsWithURL;

// Export of classes
exports.tabBrowser = tabBrowser;
dactyl-1.2~r20151231/common/tests/functional/shared-modules/tabview.js000066400000000000000000000433351264147376100255650ustar00rootroot00000000000000/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is MozMill Test code.
 *
 * The Initial Developer of the Original Code is Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2010
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Henrik Skupin 
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

// Include required modules
var domUtils = require("dom-utils");
var tabs = require("tabs");
var utils = require("utils");

const TIMEOUT = 5000;

/**
 * Constructor
 */
function tabView(aController) {
  this._controller = aController;
  this._tabView = null;
  this._tabViewDoc = this._controller.window.document;
  this._tabViewObject = this._controller.window.TabView;
}

/**
 * Tab View class
 */
tabView.prototype = {

  ///////////////////////////////
  // Global section
  ///////////////////////////////

  /**
   * Returns the MozMill controller
   *
   * @returns Mozmill controller
   * @type {MozMillController}
   */
  get controller() {
    return this._controller;
  },

  /**
   * Check if the Tab View is open
   *
   * @returns True if the Tab View is open
   * @type {boolean}
   */
  get isOpen() {
    var deck = this.getElement({type: "deck"});
    return deck.getNode().getAttribute("selectedIndex") == "1";
  },

  /**
   * Open the Tab View
   */
  open : function tabView_open() {
    var menuitem = new elementslib.Elem(this._controller.menus['view-menu'].menu_tabview);
    this._controller.click(menuitem);
    this.waitForOpened();

    this._tabView = this.getElement({type: "tabView"});
    this._tabViewDoc = this._tabView.getNode().webNavigation.document;
  },

  /**
   * Reset the Tab View settings for the current window
   */
  reset : function tabView_reset() {
    // Make sure to close TabView before resetting its ui
    if (this.isOpen) {
      this.close();
    }

    var self = this;
    this._tabViewObject._initFrame(function () {
      var contentWindow = self._tabViewObject._window;
      contentWindow.UI.reset();
    });

    // Make sure all tabs will be shown
    Array.forEach(this._controller.window.gBrowser.tabs, function (tab) {
      this._controller.window.gBrowser.showTab(tab);
    }, this);
  },

  /**
   * Wait until the Tab View has been opened
   */
  waitForOpened : function tabView_waitForOpened() {
    // Add event listener to wait until the tabview has been opened
    var self = { opened: false };
    function checkOpened() { self.opened = true; }
    this._controller.window.addEventListener("tabviewshown", checkOpened, false);

    try {
      mozmill.utils.waitFor(function () {
        return self.opened == true;
      }, "TabView is not open.");

      this._groupItemsObject = this._tabViewObject._window.GroupItems;
      this._tabItemsObject = this._tabViewObject._window.TabItems;
    }
    finally {
      this._controller.window.removeEventListener("tabviewshown", checkOpened, false);
    }
  },

  /**
   * Close the Tab View
   */
  close : function tabView_close() {
    var menuitem = new elementslib.Elem(this._controller.menus['view-menu'].menu_tabview);
    this._controller.click(menuitem);
    this.waitForClosed();

    this._tabView = null;
    this._tabViewDoc = this._controller.window.document;
  },

  /**
   * Wait until the Tab View has been closed
   */
  waitForClosed : function tabView_waitForClosed() {
    // Add event listener to wait until the tabview has been closed
    var self = { closed: false };
    function checkClosed() { self.closed = true; }
    this._controller.window.addEventListener("tabviewhidden", checkClosed, false);

    try {
      mozmill.utils.waitFor(function () {
        return self.closed == true;
      }, "TabView is still open.");
    } finally {
      this._controller.window.removeEventListener("tabviewhidden", checkClosed, false);
    }

    this._groupItemsObject = null;
    this._tabItemsObject = null;
  },


  ///////////////////////////////
  // Groups section
  ///////////////////////////////

  /**
   * Returns the tab groups which match the filter criteria
   *
   * @param {object} aSpec
   *        Information about the filter to apply
   *        Elements: filter - Type of filter to apply
   *                           (active, title)
   *                           [optional - default: ""]
   *                  value  - Value of the element
   *                           [optional - default: ""]
   *
   * @returns List of groups
   * @type {array of ElemBase}
   */
  getGroups : function tabView_getGroups(aSpec) {
    var spec = aSpec || {};

    return this.getElements({
      type: "groups",
      subtype: spec.filter,
      value: spec.value
    });
  },

  /**
   * Retrieve the group's title box
   *
   * @param {object} aSpec
   *        Information on which group to operate on
   *        Elements: group - Group element
   *
   * @returns Group title box
   * @type {ElemBase}
   */
  getGroupTitleBox : function tabView_getGroupTitleBox(aSpec) {
    var spec = aSpec || {};
    var group = spec.group;

    if (!group) {
      throw new Error(arguments.callee.name + ": Group not specified.");
    }

    return this.getElement({
      type: "group_titleBox",
      parent: group
    });
  },

  /**
   * Close the specified tab group
   *
   * @param {object} aSpec
   *        Information on which group to operate on
   *        Elements: group - Group
   */
  closeGroup : function tabView_closeGroup(aSpec) {
    var spec = aSpec || {};
    var group = spec.group;

    if (!group) {
      throw new Error(arguments.callee.name + ": Group not specified.");
    }

    var button = this.getElement({
      type: "group_closeButton",
      parent: group
    });
    this._controller.click(button);

    this.waitForGroupClosed({group: group});
  },

  /**
   * Wait until the specified tab group has been closed
   *
   * @param {object} aSpec
   *        Information on which group to operate on
   *        Elements: group - Group
   */
  waitForGroupClosed : function tabView_waitForGroupClosed(aSpec) {
    var spec = aSpec || {};
    var group = spec.group;
    var groupObj = null;

    var self = { closed: false };
    function checkClosed() { self.closed = true; }

    if (!group) {
      throw new Error(arguments.callee.name + ": Group not specified.");
    }

    this._groupItemsObject.groupItems.forEach(function (node) {
      if (node.container == group.getNode()) {
        groupObj = node;
      }
    });

    if (!groupObj) {
      throw new Error(arguments.callee.name + ": Group not found.");
    }

    try {
      groupObj.addSubscriber(groupObj, "groupHidden", checkClosed);
      mozmill.utils.waitFor(function () {
        return self.closed;
      }, "Tab Group has not been closed.");
    }
    finally {
      groupObj.removeSubscriber(groupObj, "groupHidden");
    }
  },

  /**
   * Undo the closing of the specified tab group
   *
   * @param {object} aSpec
   *        Information on which group to operate on
   *        Elements: group - Group
   */
  undoCloseGroup : function tabView_undoCloseGroup(aSpec) {
    var spec = aSpec || {};
    var group = spec.group;

    if (!group) {
      throw new Error(arguments.callee.name + ": Group not specified.");
    }

    var undo = this.getElement({
      type: "group_undoButton",
      parent: group
    });
    this._controller.waitThenClick(undo);

    this.waitForGroupUndo({group: group});
  },

  /**
   * Wait until the specified tab group has been reopened
   *
   * @param {object} aSpec
   *        Information on which group to operate on
   *        Elements: group - Group
   */
  waitForGroupUndo : function tabView_waitForGroupUndo(aSpec) {
    var spec = aSpec || {};
    var group = spec.group;
    var groupObj = null;

    var self = { reopened: false };
    function checkClosed() { self.reopened = true; }

    if (!group) {
      throw new Error(arguments.callee.name + ": Group not specified.");
    }

    var groupObj = null;
    this._groupItemsObject.groupItems.forEach(function(node) {
      if (node.container == group.getNode()) {
        groupObj = node;
      }
    });

    if (!groupObj) {
      throw new Error(arguments.callee.name + ": Group not found.");
    }

    try {
      groupObj.addSubscriber(groupObj, "groupShown", checkClosed);
      mozmill.utils.waitFor(function () {
        return self.reopened;
      }, "Tab Group has not been reopened.");
    }
    finally {
      groupObj.removeSubscriber(groupObj, "groupShown");
    }
  },


  ///////////////////////////////
  // Tabs section
  ///////////////////////////////

  /**
   * Returns the tabs which match the filter criteria
   *
   * @param {object} aSpec
   *        Information about the filter to apply
   *        Elements: filter - Type of filter to apply
   *                           (active, title)
   *                           [optional - default: ""]
   *                  value  - Value of the element
   *                           [optional - default: ""]
   *
   * @returns List of tabs
   * @type {array of ElemBase}
   */
  getTabs : function tabView_getTabs(aSpec) {
    var spec = aSpec || {};

    return this.getElements({
      type: "tabs",
      subtype: spec.filter,
      value: spec.value
    });
  },

  /**
   * Close a tab
   *
   * @param {object} aSpec
   *        Information about the element to operate on
   *        Elements: tab - Tab to close
   */
  closeTab : function tabView_closeTab(aSpec) {
    var spec = aSpec || {};
    var tab = spec.tab;

    if (!tab) {
      throw new Error(arguments.callee.name + ": Tab not specified.");
    }

    var button = this.getElement({
      type: "tab_closeButton",
      value: tab}
    );
    this._controller.click(button);
  },

  /**
   * Retrieve the tab's title box
   *
   * @param {object} aSpec
   *        Information on which tab to operate on
   *        Elements: tab - Tab
   *
   * @returns Tab title box
   * @type {ElemBase}
   */
  getTabTitleBox : function tabView_getTabTitleBox(aSpec) {
    var spec = aSpec || {};
    var tab = spec.tab;

    if (!tab) {
      throw new Error(arguments.callee.name + ": Tab not specified.");
    }

    return this.getElement({
      type: "tab_titleBox",
      parent: spec.tab
    });
  },

  /**
   * Open a new tab in the specified group
   *
   * @param {object} aSpec
   *        Information about the element to operate on
   *        Elements: group - Group to create a new tab in
   */
  openTab : function tabView_openTab(aSpec) {
    var spec = aSpec || {};
    var group = spec.group;

    if (!group) {
      throw new Error(arguments.callee.name + ": Group not specified.");
    }

    var button = this.getElement({
      type: "group_newTabButton",
      parent: group
    });

    this._controller.click(button);
    this.waitForClosed();
  },


  ///////////////////////////////
  // UI Elements section
  ///////////////////////////////

  /**
   * Retrieve an UI element based on the given specification
   *
   * @param {object} aSpec
   *        Information of the UI elements which should be retrieved
   *        Elements: type     - Identifier of the element
   *                  subtype  - Attribute of the element to filter
   *                             [optional - default: ""]
   *                  value    - Value of the attribute to filter
   *                             [optional - default: ""]
   *                  parent   - Parent of the to find element
   *                             [optional - default: document]
   *
   * @returns Element which has been found
   * @type {ElemBase}
   */
  getElement : function tabView_getElement(aSpec) {
    var elements = this.getElements(aSpec);

    return (elements.length > 0) ? elements[0] : undefined;
  },

  /**
   * Retrieve list of UI elements based on the given specification
   *
   * @param {object} aSpec
   *        Information of the UI elements which should be retrieved
   *        Elements: type     - Identifier of the element
   *                  subtype  - Attribute of the element to filter
   *                             [optional - default: ""]
   *                  value    - Value of the attribute to filter
   *                             [optional - default: ""]
   *                  parent   - Parent of the to find element
   *                             [optional - default: document]
   *
   * @returns Elements which have been found
   * @type {array of ElemBase}
   */
  getElements : function tabView_getElement(aSpec) {
    var spec = aSpec || { };
    var type = spec.type;
    var subtype = spec.subtype;
    var value = spec.value;
    var parent = spec.parent;

    var root = parent ? parent.getNode() : this._tabViewDoc;
    var nodeCollector = new domUtils.nodeCollector(root);

    switch(type) {
      // Top level elements
      case "tabView":
        nodeCollector.root = this._controller.window.document;
        nodeCollector.queryNodes("#tab-view");
        break;
      case "contentArea":
        nodeCollector.queryNodes("#content");
        break;
      case "deck":
        nodeCollector.root = this._controller.window.document;
        nodeCollector.queryNodes("#tab-view-deck");
        break;
      case "exitButton":
        nodeCollector.queryNodes("#exit-button");
        break;

      // Group elements
      case "group_appTabs":
        nodeCollector.queryNodes(".appTabIcon");
        break;
      case "group_closeButton":
        nodeCollector.queryNodes(".close");
        break;
      case "group_newTabButton":
        nodeCollector.queryNodes(".newTabButton");
        break;
      case "group_resizer":
        nodeCollector.queryNodes(".iq-resizable-handle");
        break;
      case "group_stackExpander":
        nodeCollector.queryNodes(".stackExpander");
        break;
      case "group_titleBox":
        nodeCollector.queryNodes(".name");
        break;
      case "group_undoButton":
        // Bug 596504 - No reference to the undo button
        nodeCollector.root = this._tabViewDoc;
        nodeCollector.queryNodes(".undo").filter(function (node) {
          var groups = this._groupItemsObject.groupItems;
          for (var i = 0; i < groups.length; i++) {
            var group = groups[i];
            if (group.container == parent.getNode() &&
                group.$undoContainer.length == 1) {
              return true;
            }
          }
          return false;
        }, this);
        break;
      case "groups":
        nodeCollector.queryNodes(".groupItem").filter(function (node) {
          switch(subtype) {
            case "active":
              return node.className.indexOf("activeGroup") != -1;
            case "title":
              // If no title is given the default name is used
              if (!value) {
                value = utils.getProperty("chrome://browser/locale/tabview.properties",
                                          "tabview.groupItem.defaultName");
              }
              var title = node.querySelector(".name");
              return (value == title.value);
            default:
              return true;
          }
        }, this);
        break;

      // Search elements
      case "search_box":
        nodeCollector.queryNodes("#searchbox");
        break;
      case "search_button":
        nodeCollector.queryNodes("#searchbutton");
        break;

      // Tab elements
      case "tab_closeButton":
        nodeCollector.queryNodes(".tab .close");
        break;
      case "tab_favicon":
        nodeCollector.queryNodes(".tab .favicon");
        break;
      case "tab_titleBox":
        nodeCollector.queryNodes(".tab .tab-title");
        break;
      case "tabs":
        nodeCollector.queryNodes(".tab").filter(function (node) {
          switch (subtype) {
            case "active":
              return (node.className.indexOf("focus") != -1);
            case "group":
              var group = value ? value.getNode() : null;
              if (group) {
                var tabs = this._tabItemsObject.getItems();
                for (var i = 0; i < tabs.length; i++) {
                  var tab = tabs[i];
                  if (tab.parent && tab.parent.container == group) {
                    return true;
                  }
                }
                return false;
              }
              else {
                return (node.className.indexOf("tabInGroupItem") == -1);
              }
            default:
              return true;
          }
        }, this);
        break;
      default:
        throw new Error(arguments.callee.name + ": Unknown element type - " +
                        aSpec.type);
    }

    return nodeCollector.elements;
  }
}

// Export of classes
exports.tabView = tabView;
dactyl-1.2~r20151231/common/tests/functional/shared-modules/toolbars.js000066400000000000000000000355011264147376100257450ustar00rootroot00000000000000/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is MozMill Test code.
 *
 * The Initial Developer of the Original Code is Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2009
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Henrik Skupin 
 *   Aaron Train 
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

/**
 * @fileoverview
 * The ToolbarAPI adds support for accessing and interacting with toolbar elements
 *
 * @version 1.0.0
 */

// Include required modules
var utils = require("utils");

const TIMEOUT = 5000;

const AUTOCOMPLETE_POPUP = '/id("main-window")/id("mainPopupSet")/id("PopupAutoCompleteRichResult")';
const NOTIFICATION_POPUP = '/id("main-window")/id("mainPopupSet")/id("notification-popup")';
const URLBAR_CONTAINER = '/id("main-window")/id("tab-view-deck")/{"flex":"1"}' +
                         '/id("navigator-toolbox")/id("nav-bar")/id("urlbar-container")';
const URLBAR_INPUTBOX = URLBAR_CONTAINER + '/id("urlbar")/anon({"anonid":"stack"})' + 
                                           '/anon({"anonid":"textbox-container"})' + 
                                           '/anon({"anonid":"textbox-input-box"})';
const CONTEXT_MENU = URLBAR_INPUTBOX + '/anon({"anonid":"input-box-contextmenu"})';

/**
 * Constructor
 * 
 * @param {MozmillController} controller
 *        MozMillController of the window to operate on
 */
function autoCompleteResults(controller) {
  this._controller = controller;
  this._popup = this.getElement({type: "popup"});
  this._results = this.getElement({type: "results"});
}

/**
 * AutoComplete Result class
 */
autoCompleteResults.prototype = {
  /**
   * Returns all autocomplete results
   *
   * @returns Autocomplete results
   * @type {Array of ElemBase}
   */
  get allResults() {
    var results = [];
    for (ii = 0; ii < this.length; ii++) {
      results.push(this.getResult(ii));
    }
    return results;
  },

  /**
   * Returns the controller of the current window
   *
   * @returns Mozmill Controller
   * @type MozMillController
   */
  get controller() {
    return this._controller;
  },

  /**
   * Check if the autocomplete popup is open
   *
   * @returns True if the panel is open
   * @type {boolean}
   */
  get isOpened() {
    return (this._popup.getNode().state == 'open');
  },

  /**
   * Return the amount of autocomplete entries
   *
   * @returns Number of all entries
   * @type {number}
   */
  get length() {
    return this._results.getNode().itemCount;
  },

  /**
   * Returns the currently selected index
   *
   * @returns Selected index
   * @type {number}
   */
  get selectedIndex() {
    return this._results.getNode().selectedIndex;
  },

  /**
   * Returns the visible autocomplete results
   *
   * @returns Results
   * @type {Array of ElemBase}
   */
  get visibleResults() {
    var results = [];
    for (ii = 0; ii < this.length; ii++) {
      var result = this.getResult(ii);
      if (!result.getNode().hasAttribute("collapsed"))
        results.push(result);
    }
    return results;
  },

  /**
   * Returns the underlined text of all results from the text or URL
   *
   * @param {ElemBase} result
   *        Autocomplete result which has to be checked
   * @param {string} type
   *        Type of element to check (text or url)
   *
   * @returns An array of substrings which are underlined
   * @type {Array of string}
   */
  getUnderlinedText : function autoCompleteResults_getUnderlinedText(result, type) {
    this._controller.assertJS("subject.resultNode != null",
                              {resultNode: result.getNode()});

    // Get the description element of the given title or url
    var description = null;
    switch (type) {
      case "title":
        description = result.getNode().boxObject.firstChild.childNodes[1].childNodes[0];
        break;
      case "url":
        description = result.getNode().boxObject.lastChild.childNodes[2].childNodes[0];
        break;
      default:
        throw new Error(arguments.callee.name + ": Type unknown - " + type);
    }

    let values = [ ];
    for each (node in description.childNodes) {
      if (node.nodeName == 'span') {
        // Only add underlined text to the results
        values.push(node.innerHTML);
      }
    }

    return values;
  },

  /**
   * Gets all the needed external DTD urls as an array
   *
   * @returns Array of external DTD urls
   * @type [string]
   */
  getDtds : function autoCompleteResults_getDtds() {
    return null;
  },

  /**
   * Retrieve an UI element based on the given spec
   *
   * @param {object} spec
   *        Information of the UI element which should be retrieved
   *        type: General type information
   *        subtype: Specific element or property
   *        value: Value of the element or property
   * @returns Element which has been created
   * @type {ElemBase}
   */
  getElement : function autoCompleteResults_getElement(spec) {
    var elem = null;

    switch (spec.type) {
      /**
       * subtype: subtype to match
       * value: value to match
       */
      case "popup":
        elem = new elementslib.Lookup(this._controller.window.document, AUTOCOMPLETE_POPUP);
        break;
      case "results":
        elem = new elementslib.Lookup(this._controller.window.document,
                                      AUTOCOMPLETE_POPUP + '/anon({"anonid":"richlistbox"})');
        break;
      case "result":
        elem = new elementslib.Elem(this._results.getNode().getItemAtIndex(spec.value));
        break;
      default:
        throw new Error(arguments.callee.name + ": Unknown element type - " + spec.type);
    }

    return elem;
  },

  /**
   * Returns the autocomplete result element of the given index
   *
   * @param {number} index
   *        Index of the result to return
   * @returns Autocomplete result element
   * @type {ElemBase}
   */
  getResult : function autoCompleteResults_getResult(index) {
    return this.getElement({type: "result", value: index});
  },
  
  /**
   * Close the autocomplete popup
   * 
   * @param {boolean} force
   *        Force the closing of the autocomplete popup
   */
  close : function autoCompleteResults_close(force) {
    if (this.isOpened) {
      if (force) {
        this._popup.getNode().hidePopup();
      } else {
        this._controller.keypress(locationBar.urlbar, "VK_ESCAPE", {});
      }
      this._controller.waitFor(function () {
          return !this.isOpened;
      }, "Autocomplete list should not be open.");
    }
  }
}

/**
 * Constructor
 * 
 * @param {MozmillController} controller
 *        MozMillController of the window to operate on
 */
function locationBar(controller)
{
  this._controller = controller;
  this._autoCompleteResults = new autoCompleteResults(controller);
}

/**
 * Location Bar class
 */
locationBar.prototype = {
  /**
   * Returns the autocomplete object
   *
   * @returns Autocomplete object
   * @type {object}
   */
  get autoCompleteResults() {
    return this._autoCompleteResults;
  },

  /**
   * Returns the controller of the current window
   *
   * @returns Mozmill controller
   * @type {MozMillController}
   */
  get controller() {
    return this._controller;
  },

  /**
   * Returns the urlbar element
   *
   * @returns URL bar
   * @type {ElemBase}
   */
  get urlbar() {
    return this.getElement({type: "urlbar"});
  },

  /**
   * Returns the currently shown URL
   *
   * @returns Text inside the location bar
   * @type {string}
   */
  get value() {
    return this.urlbar.getNode().value;
  },

  /**
   * Clear the location bar
   */
  clear : function locationBar_clear() {
    this.focus({type: "shortcut"});
    this._controller.keypress(this.urlbar, "VK_DELETE", {});
    this._controller.waitForEval("subject.value == ''",
                                 TIMEOUT, 100, this.urlbar.getNode());
  },

  /**
   * Close the context menu of the urlbar input field
   */
  closeContextMenu : function locationBar_closeContextMenu() {
    var menu = this.getElement({type: "contextMenu"});
    this._controller.keypress(menu, "VK_ESCAPE", {});
  },

  /**
   * Check if the location bar contains the given text
   *
   * @param {string} text
   *        Text which should be checked against
   */
  contains : function locationBar_contains(text) {
    return this.urlbar.getNode().value.indexOf(text) != -1;
  },

  /**
   * Focus the location bar
   *
   * @param {object} event
   *        Focus the location bar with the given event (click or shortcut)
   */
  focus : function locationBar_focus(event) {
    switch (event.type) {
      case "click":
        this._controller.click(this.urlbar);
        break;
      case "shortcut":
        var cmdKey = utils.getEntity(this.getDtds(), "openCmd.commandkey");
        this._controller.keypress(null, cmdKey, {accelKey: true});
        break;
      default:
        throw new Error(arguments.callee.name + ": Unkown event type - " + event.type);
    }

    // Wait until the location bar has been focused
    this._controller.waitForEval("subject.getAttribute('focused') == 'true'",
                                 TIMEOUT, 100, this.urlbar.getNode());
  },

  /**
   * Gets all the needed external DTD urls as an array
   *
   * @returns Array of external DTD urls
   * @type [string]
   */
  getDtds : function locationBar_getDtds() {
    var dtds = ["chrome://branding/locale/brand.dtd",
                "chrome://browser/locale/browser.dtd"];
    return dtds;
  },

  /**
   * Retrieve an UI element based on the given spec
   *
   * @param {object} spec
   *        Information of the UI element which should be retrieved
   *        type: General type information
   *        subtype: Specific element or property
   *        value: Value of the element or property
   * @returns Element which has been created
   * @type ElemBase
   */
  getElement : function locationBar_getElement(spec) {
    var elem = null;

    switch(spec.type) {
      /**
       * subtype: subtype to match
       * value: value to match
       */
      case "contextMenu":
        elem = new elementslib.Lookup(this._controller.window.document, CONTEXT_MENU);
        break;
      case "contextMenu_entry":
        elem = new elementslib.Lookup(this._controller.window.document, CONTEXT_MENU +
                                      '/{"cmd":"cmd_' + spec.subtype + '"}');
        break;
      case "favicon":
        elem = new elementslib.ID(this._controller.window.document, "page-proxy-favicon");
        break;
      case "feedButton":
        elem = new elementslib.ID(this._controller.window.document, "feed-button");
        break;
      case "goButton":
        elem = new elementslib.ID(this._controller.window.document, "urlbar-go-button");
        break;
      case "historyDropMarker":
        elem = new elementslib.Lookup(this._controller.window.document,
                                      URLBAR_CONTAINER + '/id("urlbar")/anon({"anonid":"historydropmarker"})');
        break;
      case "identityBox":
        elem = new elementslib.ID(this._controller.window.document, "identity-box");
        break;
      case "notification_element":
        elem = new elementslib.Lookup(this._controller.window.document, NOTIFICATION_POPUP +
                                      spec.subtype);
        break;
      case "notification_popup":
        elem = new elementslib.Lookup(this._controller.window.document, NOTIFICATION_POPUP);
        break;
      case "starButton":
        elem = new elementslib.ID(this._controller.window.document, "star-button");
        break;
      case "stopButton":
        elem = new elementslib.ID(this._controller.window.document, "urlbar-stop-button");
        break;
      case "urlbar":
        elem = new elementslib.ID(this._controller.window.document, "urlbar");
        break;
      case "urlbar_input":
        elem = new elementslib.Lookup(this._controller.window.document, URLBAR_INPUTBOX +
                                      '/anon({"anonid":"input"})');
        break;
      default:
        throw new Error(arguments.callee.name + ": Unknown element type - " + spec.type);
    }

    return elem;
  },

  /**
   * Retrieves the notification popup
   * 
   * @return The notification popup element
   * @type {ElemBase}
   */
  getNotification : function locationBar_getNotification() { 
    return this.getElement({type: "notification_popup"});
  },

  /**
   * Retrieves the specified element of the door hanger notification bar
   *
   * @param {string} aType
   *        Type of the notification bar to look for
   * @param {string} aLookupString
   *        Lookup string of the notification bar's child element
   *        [optional - default: ""]
   *
   * @return The created element
   * @type {ElemBase}
   */
  getNotificationElement : function locationBar_getNotificationElement(aType, aLookupString)
  {
    var lookup = '/id("' + aType + '")';
    lookup = aLookupString ? lookup + aLookupString : lookup;

    // Get the notification and fetch the child element if wanted
    return this.getElement({type: "notification_element", subtype: lookup});
  },

  /**
   * Load the given URL
   *
   * @param {string} url
   *        URL of web page to load
   */
  loadURL : function locationBar_loadURL(url) {
    this.focus({type: "shortcut"});
    this.type(url);
    this._controller.keypress(this.urlbar, "VK_RETURN", {});
  },

  /**
   * Type the given text into the location bar
   *
   * @param {string} text
   *        Text to enter into the location bar
   */
  type : function locationBar_type(text) {
    this._controller.type(this.urlbar, text);
    this.contains(text);
  }
}

// Export of classes
exports.locationBar = locationBar;
exports.autoCompleteResults = autoCompleteResults;

dactyl-1.2~r20151231/common/tests/functional/shared-modules/utils.js000066400000000000000000000313411264147376100252560ustar00rootroot00000000000000/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is MozMill Test code.
 *
 * The Initial Developer of the Original Code is the Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2009
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Henrik Skupin 
 *   Anthony Hughes 
 *   M.-A. Darche 
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

/**
 * @fileoverview
 * The UtilsAPI offers various helper functions for any other API which is
 * not already covered by another shared module.
 *
 * @version 1.0.3
 */

// Include required modules
var prefs = require("prefs");

const gTimeout = 5000;

/**
 * Get application specific informations
 * @see http://mxr.mozilla.org/mozilla-central/source/xpcom/system/nsIXULAppInfo.idl
 */
var appInfo = {
  _service: null,

  /**
   * Get the application info service
   * @returns XUL runtime object
   * @type nsiXULRuntime
   */
  get appInfo() {
    if (!this._appInfo) {
      this._service = Cc["@mozilla.org/xre/app-info;1"]
                        .getService(Ci.nsIXULAppInfo)
                        .QueryInterface(Ci.nsIXULRuntime);
    }
    return this._service;
  },

  /**
   * Get the build id
   * @returns Build id
   * @type string
   */
  get buildID() this.appInfo.appBuildID,

  /**
   * Get the application id
   * @returns Application id
   * @type string
   */
  get ID() this.appInfo.ID,

  /**
   * Get the application name
   * @returns Application name
   * @type string
   */
  get name() this.appInfo.name,

  /**
   * Get the operation system
   * @returns Operation system name
   * @type string
   */
  get os() this.appInfo.OS,

  /**
   * Get the product vendor
   * @returns Vendor name
   * @type string
   */
  get vendor() this.appInfo.vendor,

  /**
   * Get the application version
   * @returns Application version
   * @type string
   */
  get version() this.appInfo.version,

  /**
   * Get the build id of the Gecko platform
   * @returns Platform build id
   * @type string
   */
  get platformBuildID() this.appInfo.platformBuildID,

  /**
   * Get the version of the Gecko platform
   * @returns Platform version
   * @type string
   */
  get platformVersion() this.appInfo.platformVersion,

  /**
   * Get the currently used locale
   * @returns Current locale
   * @type string
   */
  get locale() {
    var registry = Cc["@mozilla.org/chrome/chrome-registry;1"]
                     .getService(Ci.nsIXULChromeRegistry);
    return registry.getSelectedLocale("global");
  },

  /**
   * Get the user agent string
   * @returns User agent
   * @type string
   */
  get userAgent() {
    var window = mozmill.wm.getMostRecentWindow("navigator:browser");
    if (window)
      return window.navigator.userAgent;
    return "";
  }
};

/**
 * Checks the visibility of an element.
 * XXX: Mozmill doesn't check if an element is visible and also operates on
 * elements which are invisible. (Bug 490548)
 *
 * @param {MozmillController} controller
 *        MozMillController of the window to operate on
 * @param {ElemBase} elem
 *        Element to check its visibility
 * @param {boolean} expectedVisibility
 *        Expected visibility state of the element
 */
function assertElementVisible(controller, elem, expectedVisibility) {
  var element = elem.getNode();
  var visible;

  switch (element.nodeName) {
    case 'panel':
      visible = (element.state == 'open');
      break;
    default:
      var style = controller.window.getComputedStyle(element, '');
      var state = style.getPropertyValue('visibility');
      visible = (state == 'visible');
  }

  controller.assertJS('subject.visible == subject.expectedVisibility', {
    visible: visible,
    expectedVisibility: expectedVisibility
  });
}

/**
 * Assert if the current URL is identical to the target URL.
 * With this function also redirects can be tested.
 *
 * @param {MozmillController} controller
 *        MozMillController of the window to operate on
 * @param {string} targetURL
 *        URL to check
 */
function assertLoadedUrlEqual(controller, targetUrl) {
  var locationBar = new elementslib.ID(controller.window.document, "urlbar");
  var currentURL = locationBar.getNode().value;

  // Load the target URL
  controller.open(targetUrl);
  controller.waitForPageLoad();

  // Check the same web page has been opened
  controller.waitFor(function () { 
    return locationBar.getNode().value === currentURL;
  }, "Current URL should be identical to the target URL - got " +
     locationBar.getNode().value + ", expected " + currentURL);
}

/**
 * Close the context menu inside the content area of the currently open tab
 *
 * @param {MozmillController} controller
 *        MozMillController of the window to operate on
 */
function closeContentAreaContextMenu(controller) {
  var contextMenu = new elementslib.ID(controller.window.document, "contentAreaContextMenu");
  controller.keypress(contextMenu, "VK_ESCAPE", {});
}

/**
 * Run tests against a given search form
 *
 * @param {MozMillController} controller
 *        MozMillController of the window to operate on
 * @param {ElemBase} searchField
 *        The HTML input form element to test
 * @param {string} searchTerm
 *        The search term for the test
 * @param {ElemBase} submitButton
 *        (Optional) The forms submit button
 * @param {number} timeout
 *        The timeout value for the single tests
 */
function checkSearchField(controller, searchField,
                                                     searchTerm, submitButton,
                                                     timeout) {
  controller.waitThenClick(searchField, timeout);
  controller.type(searchField, searchTerm);

  if (submitButton != undefined) {
    controller.waitThenClick(submitButton, timeout);
  }
}

/**
 * Create a new URI
 *
 * @param {string} spec
 *        The URI string in UTF-8 encoding.
 * @param {string} originCharset
 *        The charset of the document from which this URI string originated.
 * @param {string} baseURI
 *        If null, spec must specify an absolute URI. Otherwise, spec may be
 *        resolved relative to baseURI, depending on the protocol.
 * @return A URI object
 * @type nsIURI
 */
function createURI(spec, originCharset, baseURI)
{
  let iosvc = Cc["@mozilla.org/network/io-service;1"].
              getService(Ci.nsIIOService);

  return iosvc.newURI(spec, originCharset, baseURI);
}

/**
 * Empty the clipboard by assigning an empty string
 */
function emptyClipboard() {
  var clipboard = Cc["@mozilla.org/widget/clipboardhelper;1"].
                  getService(Ci.nsIClipboardHelper);
  clipboard.copyString("");
}

/**
 * Format a URL by replacing all placeholders
 *
 * @param {string} prefName
 *        The preference name which contains the URL
 * @return The formatted URL
 * @type string
 */
function formatUrlPref(prefName) {
  var formatter = Cc["@mozilla.org/toolkit/URLFormatterService;1"]
                     .getService(Ci.nsIURLFormatter);

  return formatter.formatURLPref(prefName);
}

/**
 * Returns the default home page
 *
 * @return The URL of the default homepage
 * @type string
 */
function getDefaultHomepage() {
  var preferences = prefs.preferences;

  var prefValue = preferences.getPref("browser.startup.homepage", "",
                                      true, Ci.nsIPrefLocalizedString);
  return prefValue.data;
}

/**
 * Returns the value of an individual entity in a DTD file.
 *
 * @param [string] urls
 *        Array of DTD urls.
 * @param {string} entityId
 *        The ID of the entity to get the value of.
 *
 * @return The value of the requested entity
 * @type string
 */
function getEntity(urls, entityId) {
  // Add xhtml11.dtd to prevent missing entity errors with XHTML files
  urls.push("resource:///res/dtd/xhtml11.dtd");

  // Build a string of external entities
  var extEntities = "";
  for (i = 0; i < urls.length; i++) {
    extEntities += '%dtd' + i + ';';
  }

  var parser = Cc["@mozilla.org/xmlextras/domparser;1"]
                  .createInstance(Ci.nsIDOMParser);
  var header = '';
  var elem = '&' + entityId + ';';
  var doc = parser.parseFromString(header + elem, 'text/xml');
  var elemNode = doc.querySelector('elem[id="elementID"]');

  if (elemNode == null)
    throw new Error(arguments.callee.name + ": Unknown entity - " + entityId);

  return elemNode.textContent;
}

/**
 * Returns the value of an individual property.
 *
 * @param {string} url
 *        URL of the string bundle.
 * @param {string} prefName
 *        The property to get the value of.
 *
 * @return The value of the requested property
 * @type string
 */
function getProperty(url, prefName) {
  var sbs = Cc["@mozilla.org/intl/stringbundle;1"]
            .getService(Ci.nsIStringBundleService);
  var bundle = sbs.createBundle(url);

  try {
    return bundle.GetStringFromName(prefName);
  } catch (ex) {
    throw new Error(arguments.callee.name + ": Unknown property - " + prefName);
  }
}

/**
 * Function to handle non-modal windows
 *
 * @param {string} type
 *        Specifies how to check for the new window (possible values: type or title)
 * @param {string} text
 *        The window type of title string to search for
 * @param {function} callback (optional)
 *        Callback function to call for window specific tests
 * @param {boolean} close (optional - default: true)
 *        Make sure the window is closed after the return from the callback handler
 * @returns The MozMillController of the window (if the window hasn't been closed)
 */
function handleWindow(type, text, callback, close) {
  // Set the window opener function to use depending on the type
  var func_ptr = null;
  switch (type) {
    case "type":
      func_ptr = mozmill.utils.getWindowByType;
      break;
    case "title":
      func_ptr = mozmill.utils.getWindowByTitle;
      break;
    default:
      throw new Error(arguments.callee.name + ": Unknown opener type - " + type);
  }

  var window = null;
  var controller = null;

  try {
    // Wait until the window has been opened
    mozmill.utils.waitFor(function () {
      window = func_ptr(text);
      return window != null;
    }, "Window has been found.");

    // XXX: We still have to find a reliable way to wait until the new window
    // content has been finished loading. Let's wait for now.
    controller = new mozmill.controller.MozMillController(window);
    controller.sleep(200);

    if (callback) {
      callback(controller);
    }

    // Check if we have to close the window
    if (close === undefined)
      close = true;

    if (close && window) {
      controller.window.close();
      mozmill.utils.waitFor(function () {
        return func_ptr(text) != window;
      }, "Window has been closed.");

      window = null;
      controller = null;
    }

    return controller;
  } catch (ex) {
    if (window)
      window.close();

    throw ex;
  }
}

// Export of variables
exports.appInfo = appInfo;

// Export of functions
exports.assertElementVisible = assertElementVisible;
exports.assertLoadedUrlEqual = assertLoadedUrlEqual;
exports.closeContentAreaContextMenu = closeContentAreaContextMenu;
exports.checkSearchField = checkSearchField;
exports.createURI = createURI;
exports.formatUrlPref = formatUrlPref;
exports.emptyClipboard = emptyClipboard;
exports.getDefaultHomepage = getDefaultHomepage;
exports.getEntity = getEntity;
exports.getProperty = getProperty;
exports.handleWindow = handleWindow;
dactyl-1.2~r20151231/common/tests/functional/shared-modules/widgets.js000066400000000000000000000057601264147376100255720ustar00rootroot00000000000000/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is MozMill Test code.
 *
 * The Initial Developer of the Original Code is Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2009
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Henrik Skupin 
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

/**
 * @fileoverview
 * The WidgetsAPI adds support for handling objects like trees.
 */

var EventUtils = {};
Components.utils.import('resource://mozmill/stdlib/EventUtils.js', EventUtils);

const gTimeout = 5000;

/**
 * Click the specified tree cell
 *
 * @param {MozMillController} controller
 *        MozMillController of the browser window to operate on
 * @param {tree} tree
 *        Tree to operate on
 * @param {number } rowIndex
 *        Index of the row
 * @param {number} columnIndex
 *        Index of the column
 * @param {object} eventDetails
 *        Details about the mouse event
 */
function clickTreeCell(controller, tree, rowIndex, columnIndex, eventDetails)
{
  tree = tree.getNode();

  var selection = tree.view.selection;
  selection.select(rowIndex);
  tree.treeBoxObject.ensureRowIsVisible(rowIndex);

  // get cell coordinates
  var x = {}, y = {}, width = {}, height = {};
  var column = tree.columns[columnIndex];
  tree.treeBoxObject.getCoordsForCellItem(rowIndex, column, "text",
                                           x, y, width, height);

  controller.sleep(0);
  EventUtils.synthesizeMouse(tree.body, x.value + 4, y.value + 4,
                             eventDetails, tree.ownerDocument.defaultView);
  controller.sleep(0);
}

// Export of functions
exports.clickTreeCell = clickTreeCell;
dactyl-1.2~r20151231/common/tests/functional/testAboutPage.js000066400000000000000000000011431264147376100237460ustar00rootroot00000000000000var setupModule = function (module) {
    controller = mozmill.getBrowserController();
};

var testAboutPage_WhenOpened_PageIsLoadedWithExpectedTitle = function () {
    const ABOUT_PAGE_URL = "about:pentadactyl";
    const EXPECTED_TITLE = "About Pentadactyl";
    const BLANK_PAGE_URL = "about:blank";

    controller.open(BLANK_PAGE_URL);
    controller.waitForPageLoad(controller.tabs.activeTab);
    controller.open(ABOUT_PAGE_URL);
    controller.waitForPageLoad(controller.tabs.activeTab);

    controller.assert(function () controller.tabs.activeTab.title === EXPECTED_TITLE);
};

// vim: sw=4 ts=8 et:
dactyl-1.2~r20151231/common/tests/functional/testCommands.js000066400000000000000000000763731264147376100236610ustar00rootroot00000000000000// Runs a slew of generic command tests

var utils = require("utils");
const { module } = utils;
var dactyllib = module("dactyl");
var jumlib = module("resource://mozmill/modules/jum.js");

var setupModule = function (module) {
    controller = mozmill.getBrowserController();
    dactyl = new dactyllib.Controller(controller);

    dactyl.modules.options["autocomplete"] = [];
    dactyl.modules.options["wildmode"] = ["list"];

    dactyl.modules.prefs.set("browser.tabs.closeWindowWithLastTab", false);
    dactyl.elements.multilineContainer.setAttribute("moz-collapsed", "true");
};
var teardownModule = function (module) {
    dactyl.elements.multilineContainer.removeAttribute("moz-collapsed");
    dactyl.teardown();
}

function $(selector) controller.window.document.querySelector(selector);

function hasNItems(nItems)
    function hasNItems(context) {
        utils.assertEqual("testCommand.hasNItems", nItems, context.allItems.items.length);
    };

function hasItems(context) context.allItems.items.length;

function hasntNullItems(context) hasItems(context) &&
    !context.allItems.items.some(function ({ text, description }) [text, description].some(function (text) /^\[object/.test(text)));

function sidebarState(state)
    function sidebarState() {
        utils.assertEqual("testCommand.sidebarState", state,
                          typeof state == "string" ? $("#sidebar-title").value
                                                   : !$("#sidebar-box").hidden);
    };
function toolbarState(selector, state)
    function toolbarState() {
        utils.assertEqual("testCommand.toolbarState", state, !$(selector).collapsed)
    };

var tests = {
    "!": {
        multiOutput: ["echo foo"]
    },
    get Clistkeys() this.listcommands,
    Cmap: {},
    Cnoremap: {},
    Cunmap: {},
    get Ilistkeys() this.listcommands,
    Imap: {},
    Inoremap: {},
    Iunmap: {},
    abbreviate: {
        error: ["!"],
        someOutput: ["", "abc"],
        noOutput: ["abc def", "-js abc def"],
        completions: ["", "abc ", "-js abc "]
    },
    addons: {
        error: ["!"],
        multiOutput: ["", "dactyl", "-type=extension", "-type=extension dactyl"],
        completions: [
            "",
            ["-types=", hasItems]
        ]
    },
    autocmd: {
        multiOutput: ["", "DOMLoad", "DOMLoad foo"],
        noOutput: ["DOMLoad foo bar", "-js DOMLoad foo bar"],
        completions: [
            ["", hasntNullItems],
            "DOMLoad foo ",
            "-js DOMLoad foo "
        ]
    },
    back: { noOutput: [""] },
    bdelete: {
        init: ["tabopen about:pentadactyl", "tabopen about:pentadactyl"],
        noOutput: [""],
        anyOutput: ["about:pentadactyl"],
        completions: [["", hasItems]]
    },
    get blistkeys() this.listcommands,
    bmap: {},
    bmark: {
        singleOutput: ["", "-tags=foo -title=bar -keyword=baz -charset=UTF-8 -post=quux about:pentadactyl"],
        error: ["-tags=foo -title=bar -keyword=baz -charset=nonExistentCharset -post=quux about:pentadactyl"],
        completions: [
            "-max=1 -keyword=",
            "-max=1 -keyword=foo -tags=",
            "-max=1 -keyword=foo -tags=bar -title=",
            ["-max=1 -keyword=foo -tags=bar -title=baz -charset=", hasItems],
            "-max=1 -keyword=foo -tags=bar -title=baz -charset= about:"
        ]
    },
    bmarks: {
        multiOutput: ["-max=1", "-max=1 -keyword=foo -tags=bar -title=baz about:pentadactyl"],
        completions: [
            "-max=1 -keyword=",
            "-max=1 -keyword=foo -tags=",
            "-max=1 -keyword=foo -tags=bar -title=",
            "-max=1 -keyword=foo -tags=bar -title=baz about:"
        ]
    },
    bnoremap: {},
    buffer: {
        anyOutput: ["", "1"],
        noOutput: ["!", "! 1"],
        completions: [
            ["", hasItems],
            ["1", hasItems]
        ]
    },
    buffers: {
        error: ["!"],
        multiOutput: ["", "1"],
        completions: ["", "1"]
    },
    bunmap: {},
    cd: {
        error: ["!"],
        singleOutput: ["", "~/"],
        completions: ["", "~/"]
    },
    get clistkeys() this.listcommands,
    cmap: {},
    cnoremap: {},
    colorscheme: {
        error: ["!", "", "some-nonexistent-scheme"]
    },
    command: {
        init: ["delc!"],
        singleOutput: ["", "foobar"],
        noOutput: ["foo bar", "-js bar baz"],
        multiOutput: [""],
        error: [
            "foo bar",
            "-js bar baz",
            "-group=builtin baz quux",
            "! -group=builtin baz quux",
        ],
        completions: [
            ["", hasItems],
            ["-group=", hasItems],
            ["-group=user ", hasItems]
        ]
    },
    completions: {
        error: ["!", ""]
    },
    contexts: { // Not testable in this manner
        error: ["!"]
    },
    cookies: {
        anyOutput: ["5digits.org", "5digits.org list"],
        error: ["!", ""],
        completions: [
            "",
            ["5digits.org ", hasItems]
        ]
    },
    cunabbreviate: {},
    cunmap: {},
    delbmarks: { anyOutput: ["", "about:pentadactyl"] },
    delcommand: [
        {
            init: ["delcommand!", "command foo bar"],
            error: [""],
            completions: [
                ["", hasItems],
                ["-group=", hasItems],
                ["-group=user ", hasItems]
            ],
            noOutput: ["foo", "! "]
        },
        {
            init: ["delcommand!"],
            error: ["foo"]
        }
    ],
    delgroup: {
        error: ["", "! foo", "builtin"],
        completions: [""]
    },
    delmacros: {
        error: ["", "! foo"],
        noOutput: ["x"],
        completions: ["", "x"]
    },
    get delmarks() this.delmacros,
    get delqmarks() this.delmacros,
    delstyle: {
        completions: ["", "-name=", "-name=foo ", "-index=", "-index="]
    },
    dialog: {
        error: ["!", ""],
        // Skip implementation for now
        completions: [
            ["", hasntNullItems]
        ]
    },
    dlclear: {
        error: ["!"]
    },
    doautoall: {
        error: ["!"]
    },
    doautocmd: {
        error: ["!"]
    },
    downloads: {
        error: ["!"],
        multiOutput: ["", "dactyl", "dactyl"]
    },
    echo: {
        error: ["!"],
        singleOutput: [
            ["' - '", " - "]
        ],
        multiOutput: [
            ["'\\n'", /\n/],
            ["window", /\[object\sChromeWindow\]/]
        ],
        completions: [
            "",
            "window",
            "window.",
            "window['",
            "commands.get('"
        ]
    },
    get echoerr() ({
        errorsOk: true,
        __proto__: this.echo,
    }),
    get echomsg() this.echo,
    else: {
        error: ["!", "foo"]
    },
    elseif: {
        error: ["!", ""]
    },
    emenu: {
        noOutput: ["View.Zoom.Zoom In", "View.Zoom.Zoom Out"],
        error: ["!", ""],
        completions: [
            ["", hasItems],
            ["View.", hasItems]
        ]
    },
    endif: {
        error: ["!", "foo"]
    },
    execute: {
        error: ["!"],
        noOutput: ["", "'js " + "".quote() + "'"],
        someOutput: ["'ls'"],
        completions: [["", hasItems]]
    },
    exit: {
        error: ["foo"]
    },
    extadd: {
        completions: [["", hasItems]],
        error: ["!", ""]
    },
    extdelete: {
        completions: [["", hasItems]],
        error: [""]
    },
    get extdisable() this.extdelete,
    extenable: {
        completions: [""],
        error: [""]
    },
    extoptions: {
        completions: [""],
        error: [""]
    },
    get extrehash() this.extdelete,
    get exttoggle() this.extdelete,
    get extupdate() this.extdelete,
    feedkeys: {
        noOutput: [""],
        error: [""]
    },
    finish: {
        error: ["!", "foo"],
        noOutput: [""]
    },
    forward: { noOutput: [""] },
    frameonly: {
        error: ["!", "foo"],
        noOutput: [""]
    },
    group: {
        multiOutput: [""],
        noOutput: [
            "foo -d='foo group' -nopersist -l 'bar.com','http://bar/*','http://bar','^http:'",
            "! foo -d='foo group' -nopersist -l 'bar.com','http://bar/*','http://bar','^http:'",
            "foo",
            "user"
        ],
        error: ["builtin"],
        completions: [
            "",
            "foo "
        ],
        cleanup: ["delmapgroup foo"]
    },
    hardcopy: {}, // Skip for now
    help: {
        error: ["!"],
        noOutput: ["", "intro"],
        cleanup: ["tabdelete", "tabdelete"],
        completions: [
            ["", hasItems],
            ["'wild", hasItems]
        ]
    },
    get helpall() this.help,
    highlight: {
        error: ["!"],
        multiOutput: ["", "Help"],
        noOutput: [
            "Help foo: bar;",
            "Help -group=FontCode",
            "Help -group=FontCode foo: bar;"
        ],
        completions: [
            ["", hasItems],
            ["Help", hasItems],
            ["Help ", hasItems],
            ["Help -group=", hasItems],
            ["Help -group=FontCode ", hasItems],
            ["Help foo: bar; -moz", hasItems]
        ]
    },
    history: {
        init: ["open about:pentadactyl"],
        anyOutput: ["-max=1", "-max=1 -sort=+date", "-max=1 dactyl"],
        completions: [
            ["", hasItems],
            "about:",
            ["-sort=+", hasItems],
            ["-sort=-", hasItems],
            ["-sort=+date ", hasItems],
            "-sort=+date about:"
        ]
    },
    if: {
        error: ["!", ""],
    },
    iabbreviate: {},
    get ilistkeys() this.listcommands,
    imap: {},
    inoremap: {},
    iunabbreviate: {},
    iunmap: {},
    javascript: {
        noOutput: ["''", "'\\n'", "
      foo bar
      ", "window", "< "
        ],
        multiOutput: ["", "i"],
        error: [
            "-mode=some-nonexistent-mode  ",
            "-group=some-nonexistent-group  ",
            "-group=builtin  "
        ],
        completions: [
            ["", hasItems],
            ["-", hasItems],
            ["-mode=ex ", hasItems],
            ["-mode=", hasItems],
            ["-group=", hasItems],
            ["-builtin i ", hasItems],
            ["-ex i ", hasItems],
            ["-javascript i ", hasItems]
        ]
    },
    mark: {
        error: ["!", "", "#", "xy"],
        noOutput: ["y"],
        completions: [""]
    },
    marks: {
        init: ["delmarks q"],
        multiOutput: ["", "y"],
        error: ["!", "q", "#"],
        completions: [""]
    },
    messages: {
        error: ["!", "foo"],
        anyOutput: ["messages"]
    },
    messclear: {
        error: ["!", "foo"],
        noOutput: [""]
    },
    mkpentadactylrc: {
        noOutput: [
            "some-nonexistent-rc.penta",
            "! some-nonexistent-rc.penta"
        ],
        error: ["some-nonexistent-rc.penta"],
        completions: [""],
        cleanup: ["silent !rm some-nonexistent-rc.penta"]
    },
    mkvimruntime: {
        error: [
            "some-nonexistent-pentadactyl-dir/"
        ],
        completions: [
            ["", hasItems]
        ]
    },
    get mlistkeys() this.listcommands,
    mmap: {},
    mnoremap: {},
    munmap: {},
    get nlistkeys() this.listcommands,
    nmap: {},
    nnoremap: {},
    nohlfind: {
        error: ["!", "foo"]
    },
    noremap: {},
    normal: {
        error: [""],
        noOutput: [""],
        singleOutput: [""],
        multiOutput: ["g"]
    },
    nunmap: {},
    open: {
        error: ["!"],
        noOutput: ["about:blank | about:home"],
        completions: [
            ["", hasItems],
            ["./", hasItems],
            ["./ | ", hasItems], // FIXME: broken feature
            ["chrome://", hasItems],
            ["chrome://browser/", hasItems],
            ["chrome://browser/content/", hasItems],
            ["about:", hasItems],
            ["resource://", hasItems],
            ["resource://dactyl/", hasItems]
        ]
    },
    pageinfo: {
        multiOutput: ["", "fgm"],
        completions: [["", hasItems]],
        error: ["!", "abcdefghijklmnopqrstuvwxyz", "f g m"]
    },
    pagestyle: {
        error: ["!"],
        completions: [""]
    },
    pintab: {},
    preferences: {
        error: ["foo"]
    },
    pwd: {
        error: ["!", "foo"],
        singleOutput: [""]
    },
    qmark: {
        singleOutput: [
            "m",
            "m foo bar"
        ],
        error: ["!", "", "#"],
        completions: [
            ["", hasItems],
            ["m ", hasItems]
        ]
    },
    qmarks: [
        {
            error: ["!"]
        },
        {
            init: ["delqmarks a-zA-Z0-9"],
            error: ["", "x"],
        },
        {
            init: ["qmark x"],
            multiOutput: ["", "m", "x"],
            completions: [["", hasItems]]
        }
    ],
    quit: {
        error: ["foo"]
    },
    quitall: {
        error: ["!", "foo"]
    },
    redraw: {
        error: ["!", "foo"],
        noOutput: [""]
    },
    rehash: {
        error: ["!"]
    },
    reload: {
        error: ["foo"],
        noOutput: [""]
    },
    reloadall: {
        error: ["foo"],
        noOutput: [""]
    },
    restart: {
        error: ["!", "foo"]
    },
    runtime: {
        init: [
            "js File('~/.pentadactyl/some-nonexistent/good.css').write('')",
            "js File('~/.pentadactyl/some-nonexistent/good.js').write('')",
            "js File('~/.pentadactyl/some-nonexistent/bad.js').write('dactyl.echoerr(\"error\")')",
            "js File('~/.pentadactyl/some-nonexistent/good.penta').write('')",
            "js File('~/.pentadactyl/some-nonexistent/bad.penta').write('echoerr \"error\"')",
        ],
        cleanup: ["js File('~/.pentadactyl/some-nonexistent').remove(true)"],
        noOutput: [
            "some-nonexistent/good.css",
            "some-nonexistent/good.js",
            "some-nonexistent/good.penta"
        ],
        error: [
            "",
            "some-nonexistent/bad.js",
            "some-nonexistent/bad.penta"
        ],
        singleOutput: ["some-nonexistent-file.js"],
        completions: [
            ["", hasItems],
            ["some-nonexistent/", hasItems],
            ["info/", hasItems]
        ]
    },
    sanitize: {
        // Skip details for now.
        completions: [
            ["", function (context) ["all",
                                     "cache",
                                     "downloads",
                                     "formdata",
                                     "offlineapps",
                                     "passwords",
                                     "sessions",
                                     "cookies",
                                     "history",
                                     "host",
                                     "sitesettings",
                                     "commandline",
                                     "messages",
                                     "macros",
                                     "marks",
                                     "options"
                ].every(function (item) context.allItems.items.some(function ({ text }) item == text))
            ],
            "-",
            "-host=",
            "-timespan="
        ]
    },
    saveas: {},
    sbclose: {
        error: ["!", "foo"],
        noOutput: [""]
    },
    scriptnames: {
        error: ["!", "foo"]
    },
    set: {
        multiOutput: [
            "vb?", "cpt?", "messages?", "titlestring?", "au?", "eht?",
            "cpt", "messages", "titlestring", "au", "eht", "! "
        ],
        noOutput: ["vb", "novb"],
        completions: [
            ["", hasItems],
            ["c", hasItems],
            ["cpt=", hasItems],
            ["cpt=l", hasItems],
            ["cpt+=", hasItems],
            ["cpt+=f", hasItems],
            ["activate=", hasItems],
            ["activate=links,", hasItems],
            ["activate+=", hasItems],
            ["activate+=links,", hasItems],
            ["activate^=", hasItems],
            ["activate^=links,", hasItems],
            ["activate-=", hasItems],
            ["activate-=links,", hasItems],
            ["activate!=", hasItems],
            ["activate!=links,", hasItems]
        ]
    },
    get setglobal() this.set,
    get setlocal() this.set,
    sidebar: {
        error: ["!", ""],
        test: function (name) [
            ["! " + name, sidebarState(name)],
            [name, sidebarState(name)],
            ["! " + name, sidebarState(false)]
        ],
        get noOutput()
            Array.concat.apply([],
                ["Add-ons", // Final "! Add-ons" currently failing
                 "Bookmarks",
                 "Downloads",
                 "Console",
                 "History",
                 "Preferences"]
            .map(this.test))
            .concat([
                ["Preferences", sidebarState("Preferences")],
                ["!", sidebarState(false)]
            ]),
        completions: [
            ["", hasntNullItems],
            "! "
        ]
    },
    silent: {
        error: ["!"],
        noOutput: [
            "echo 'foo'",
            "echo " + "foo\nbar".quote(),
            "echoerr 'foo'",
            "echoerr " + "foo\nbar".quote()
        ],
        completions: [["", hasItems]]
    },
    get source() ({
        init: this.runtime.init,
        cleanup: this.runtime.cleanup,
        noOutput: [
            "! .pentadactyl/some-nonexistent/really-nonexistent.js",
            ".pentadactyl/some-nonexistent/good.css",
            ".pentadactyl/some-nonexistent/good.js",
            ".pentadactyl/some-nonexistent/good.penta"
        ],
        error: [
            "",
            ".pentadactyl/some-nonexistent/really-nonexistent.js",
            "~/.pentadactyl/some-nonexistent/bad.js",
            "~/.pentadactyl/some-nonexistent/bad.penta",
            "./.pentadactyl/some-nonexistent/bad.js",
            "./.pentadactyl/some-nonexistent/bad.penta",
            ".pentadactyl/some-nonexistent/bad.js",
            ".pentadactyl/some-nonexistent/bad.penta",
            ".pentadactyl/some-nonexistent-file.js"
        ],
        completions: [
            ["", hasItems],
            [".pentadactyl/some-nonexistent/", hasItems],
            ["chrome://browser/content/", hasItems],
            ["resource://dactyl/", hasItems]
        ]
    }),
    stop: {
        error: ["!", "foo"],
        noOutput: [""]
    },
    stopall: {
        error: ["!", "foo"],
        noOutput: [""]
    },
    style: {
        error: ["!"],
        cleanup: ["delstyle -n foo"],
        noOutput: [
            "-name=foo http://does.not.exist/* div { display: inline; }",
            "-name=foo -append http://does.not.exist/* span { display: block; }"
        ],
        multiOutput: [
            "",
            "-name=foo"
        ],
        completions: [
            ["", hasItems],
            ["-name=", hasItems],
            ["http:* div { -moz", hasItems],
            ["http:* div { foo: bar; -moz", hasItems],
            ["http:* div { foo: bar; } span { -moz", hasItems],
            ["http:* div { foo: bar; } span { foo: bar; -moz", hasItems]
        ]
    },
    styledisable: {
        init: ["style -n foo http:* div {}", "style -n bar ftp:* div", "styledisable -n bar"],
        cleanup: ["delstyle -n foo", "delstyle -n bar"],
        completions: [
            ["", hasItems],
            ["-name=", hasNItems(1)],
            ["-index=", hasNItems(1)]
        ],
        noOutput: ["-name=foo", "-name=bar"]
    },
    get styleenable() this.styledisable,
    styletoggle: {
        init: ["style -n foo http:* div {}", "style -n bar ftp:* div", "styledisable -n bar"],
        cleanup: ["delstyle -n foo", "delstyle -n bar"],
        noOutput: ["-name=foo"],
        completions: [
            ["", hasItems],
            ["-name=", hasNItems(2)],
            ["-index=", hasNItems(2)]
        ]
    },
    tab: {
        error: ["!", "", "some-nonexistent-command"],
        noOutput: ["js ''"],
        anyOutput: ["echo 'foo'"],
        completions: [["", hasItems]]
    },
    tabattach: {
        error: ["!", ""]
    },
    tabdetach: {
        error: ["!", "foo"]
    },
    tabdo: {
        error: ["!", "", "some-nonexistent-command"],
        noOutput: ["js ''"],
        anyOutput: ["echo 'foo'"],
        completions: [["", hasItems]]
    },
    tabduplicate: {
        error: ["foo"]
    },
    tablast: {
        error: ["!", "foo"]
    },
    tabmove: {
        error: [""],
        noOutput: ["1", "$", "999", "-1", "+1", "! +1", "! -1", "-999", "+999", "! +999", "! -999"],
        completions: [
            ["", hasItems],
            ["1", hasItems]
        ]
    },
    tabnext: {
        error: ["!", "foo"]
    },
    tabonly: {
        error: ["!", "foo"]
    },
    tabopen: {},
    tabprevious: {
        error: ["!", "foo"]
    },
    tabrewind: {
        error: ["!", "foo"]
    },
    time: {
        error: ["", ":some-nonexistent-command"/*, "some_nonexistent_reference"*/], // FIXME
        singleOutput: [":js null", "null"]
    },
    get tlistkeys() this.listcommands,
    tmap: {},
    tnoremap: {},
    toolbarhide: {
        init: [
            ["tbs Navigation Toolbar", toolbarState("#nav-bar", true)],
            ["tbs Bookmarks Toolbar", toolbarState("#PersonalToolbar", true)]
        ],
        completions: [["", hasItems]],
        noOutput: [
            ["Navigation Toolbar", toolbarState("#nav-bar", false)],
            ["Bookmarks Toolbar", toolbarState("#PersonalToolbar", false)]
        ],
        error: ["!", "", "foo"]
    },
    toolbarshow: {
        completions: [["", hasItems]],
        noOutput: [
            ["Navigation Toolbar", toolbarState("#nav-bar", true)],
            ["Bookmarks Toolbar", toolbarState("#PersonalToolbar", true)]
        ],
        error: ["!", "", "foo"]
    },
    toolbartoggle: {
        completions: [["", hasItems]],
        noOutput: [
            ["Navigation Toolbar", toolbarState("#nav-bar", false)],
            ["Bookmarks Toolbar", toolbarState("#PersonalToolbar", false)],
            ["Navigation Toolbar", toolbarState("#nav-bar", true)],
            ["Bookmarks Toolbar", toolbarState("#PersonalToolbar", true)],
            ["Navigation Toolbar", toolbarState("#nav-bar", false)],
            ["Bookmarks Toolbar", toolbarState("#PersonalToolbar", false)]
        ],
        error: ["!", "", "foo"]
    },
    tunmap: {},
    unabbreviate: {
        noOutput: ["abc", "! "],
        error: [""]
    },
    undo: {
        error: ["!"]
    },
    undoall: {
        error: ["!", "foo"]
    },
    unpintab: {
        error: ["!"]
    },
    unlet: {
        error: [""],
    },
    unmap: {
        noOutput: [
            "i",
            "! "
        ],
        error: [
            "i",
            "-group=builtin k",
            "! -group=builtin"
        ],
        completions: [
            "",
            "-group="
        ]
    },
    verbose: {
        error: ["!", ""]
    },
    version: {
        error: ["foo"],
        multiOutput: [
            ["", function (msg) {
                var res = /(\w+dactyl) (\S+) \(([\^)]+)\) running on:\nMozilla/.exec(msg);
                return res && res[2] != "null" && res[3] != "null";
            }]
        ]
    },
    viewsource: {},
    get vlistkeys() this.listcommands,
    vmap: {},
    vnoremap: {},
    vunmap: {},
    winclose: {
        error: ["!", "foo"]
    },
    window: {
        error: ["!", ""]
    },
    winonly: {
        error: ["!", "foo"]
    },
    winopen: {
        error: ["!"]
    },
    wqall: {
        error: ["!", "foo"]
    },
    yank: {
        multiOutput: [
            ["foo".quote(), /foo/],
            [":echo " + "bar".quote(), /bar/],
            [":addons", /Pentadactyl/]
        ],
        error: [
            "!", "",
            ":echoerr " + "foo".quote()
        ],
        completions: [
            ["", hasItems],
            [":", hasItems]
        ]
    },
    zoom: {}
};

var global = this;
function addTest(cmdName, testName, func) {
    global["testCommand_" + cmdName + "_" + testName] = func;
}

function runCommands(cmdName, testName, commands, test, forbidErrors) {
    addTest(cmdName, testName, function () {
        commands.forEach(function (val) {
            var [cmd, testVal] = Array.concat(val);

            dump("CMD: " + testName + " " + cmdName + " " + cmd + "\n");
            dactyl.clearMessage();
            dactyl.closeMessageWindow();

            cmd = cmdName + cmd.replace(/^(!?) ?/, "$1 ");
            if (forbidErrors)
                dactyl.assertNoErrorMessages(function () { dactyl.runExCommand(cmd) },
                                             null, [], cmd);
            else
                dactyl.runExCommand(cmd);
            controller.waitForPageLoad(controller.tabs.activeTab);

            test(cmd, testVal);
        });
    });
}
function _runCommands(cmdName, testName, commands) {
    addTest(cmdName, testName, function () {
        commands.forEach(function (value) {
            var [cmd, test] = Array.concat(value);

            dump("CMD: " + testName + " " + cmdName + " " + cmd + "\n");
            var res = dactyl.runExCommand(cmd);
            controller.waitForPageLoad(controller.tabs.activeTab);
            runTest("Initializing for " + cmdName + " tests failed: " + cmd.quote() + " " + test,
                    test);
        });
    });
}

function runTest(message, test, ...args) {
    if (test)
        var res = test.apply(null, args);
    if (res !== undefined)
        jumlib.assert(res, message);
}

for (var val in Iterator(tests)) (function ([command, paramsList]) {
    Array.concat(paramsList).forEach(function (params, i) {
        if (params.init)
            _runCommands(command, "init" + (i || ""), params.init);

        // Goddamn stupid fucking MozMill and its stupid fucking sandboxes with their ancient fucking JS versions.
        for (var val in Iterator(params)) (function ([test, commands]) {
            var testName = test + (i || "");

            switch (test) {
            case "noOutput":
                runCommands(command, testName, commands, function (cmd, test) {
                    var res = dactyl.assertMessage(function (msg) !msg, "Unexpected command output: " + cmd);
                    if (res && test)
                        dactyl.assertMessage(test, "Running " + testName + " tests failed: " + cmd.quote() + " " + test.toSource());
                });
                break;
            case "anyOutput":
                runCommands(command, testName, commands, function (cmd, test) {
                    if (test)
                        dactyl.assertMessage(test, "Running " + testName + " tests failed: " + cmd.quote() + " " + test.toSource());
                });
                break;
            case "someOutput":
                runCommands(command, testName, commands, function (cmd, test) {
                    var res = dactyl.assertMessage(/./, "Expected command output: " + cmd);
                    if (res && test != null)
                        dactyl.assertMessage(test, "Running " + testName + " tests failed: " + cmd.quote() + " " + test.toSource());
                });
                break;
            case "singleOutput":
                runCommands(command, testName, commands, function (cmd, test) {
                    var res = dactyl.assertMessageLine(/./, "Expected command output: " + cmd);
                    if (res && test != null)
                        dactyl.assertMessageLine(test, "Running " + testName + " tests failed: " + cmd.quote() + " " + test.toSource());
                }, !params.errorsOk);
                break;
            case "multiOutput":
                runCommands(command, testName, commands, function (cmd, test) {
                    var res = dactyl.assertMessageWindowOpen(true, "Expected command output: " + cmd);
                    if (res && test != null)
                        dactyl.assertMessageWindow(test, "Running " + testName + " tests failed: " + cmd.quote() + " " + test.toSource());
                }, !params.errorsOk);
                break;
            case "error":
                addTest(command, testName, function () {
                    commands.forEach(function (val) {
                        var [cmd, test] = Array.concat(val);
                        cmd = command + cmd.replace(/^(!?) ?/, "$1 ");

                        var res = dactyl.assertMessageError(function () {
                            dactyl.runExCommand(cmd);
                            controller.waitForPageLoad(controller.tabs.activeTab);
                        }, null, [], cmd);

                        if (res && test != null)
                            dactyl.assertMessage(test, "Running " + testName + " tests failed: " + cmd.quote() + " " + test.toSource());
                    });
                });
                break;
            case "completions":
                addTest(command, testName, function () {
                    commands.forEach(function (val) {
                        var [cmd, test] = Array.concat(val);
                        cmd = command + cmd.replace(/^(!?) ?/, "$1 ");

                        dactyl.assertNoErrorMessages(function () {
                            dump("COMPL: " + cmd + "\n");
                            var context = dactyl.runExCompletion(cmd);
                            if (context)
                                runTest("Completion tests failed: " + cmd.quote() + " " + test,
                                        test, context);
                        });
                    });
                });
                break;
            }
        })(val);

        if (params.cleanup)
            _runCommands(command, "cleanup" + (i || ""), params.cleanup);
    });
})(val);

// vim: sw=4 ts=8 et:
dactyl-1.2~r20151231/common/tests/functional/testDOMEvents.js000066400000000000000000000045661264147376100237170ustar00rootroot00000000000000"use strict";

var utils = require("utils");
const { module } = utils;

var { interfaces: Ci } = Components;
var { nsIDOMKeyEvent: KeyEvent } = Ci;

var controller, dactyl;
var dactyllib = module("dactyl");
var jumlib = module("resource://mozmill/modules/jum.js");

var setupModule = function (module) {
    controller = mozmill.getBrowserController();
    dactyl = new dactyllib.Controller(controller);
};
var teardownModule = function (module) {
    dactyl.teardown();
}

var keyDefaults = {
    keyCode: 0,
    charCode: 0,
    altKey: false,
    ctrlKey: false,
    metaKey: false,
    shiftKey: false
};

var keyMap = {
    "a": {
        charCode: "a".charCodeAt(0)
    },
    "A": {
        charCode: "A".charCodeAt(0),
        shiftKey: true
    },
    "": {
        aliases: [""],
        charCode: "a".charCodeAt(0),
        ctrlKey: true,
    },
    "": {
        aliases: [""],
        charCode: "A".charCodeAt(0),
        ctrlKey: true,
        shiftKey: true,
    },
    "": {
        aliases: [""],
        keyCode: KeyEvent.DOM_VK_RETURN
    },
    "": {
        aliases: [""],
        keyCode: KeyEvent.DOM_VK_RETURN,
        shiftKey: true
    },
    "": {
        aliases: [" ", "< >"],
        charCode: " ".charCodeAt(0)
    }
};

function testKeys() {
    let { DOM, update } = dactyl.modules;

    for (let [name, object] in Iterator(keyMap)) {
        for each (let key in (object.aliases || []).concat(name)) {
            dactyl.assertNoErrors(function () {
                let result = DOM.Event.parse(key);
                jumlib.assertEquals(result.length, 1);

                for (let [k, v] in Iterator(keyDefaults))
                    if (k != "keyCode" || "keyCode" in object || result.keyCode == 0) // TODO
                        jumlib.assertEquals(result[0][k],
                                            k in object ? object[k] : v,
                                            name + ":" + key + ":" + k);

                jumlib.assertEquals(DOM.Event.stringify(result[0]),
                                    name);
            });
        }

        jumlib.assertEquals(name,
                            DOM.Event.stringify(
                                update({ type: "keypress" },
                                       keyDefaults,
                                       object)));
    }
}

// vim: sw=4 ts=8 et:
dactyl-1.2~r20151231/common/tests/functional/testEchoCommands.js000066400000000000000000000041311264147376100244370ustar00rootroot00000000000000var dactyllib = require("utils").module("dactyl");

var setupModule = function (module) {
    controller = mozmill.getBrowserController();
    dactyl = new dactyllib.Controller(controller);
};

var teardownModule = function (module) {
    dactyl.teardown();
}

var teardownTest = function (test) {
    dactyl.closeMessageWindow();
};

var testEchoCommand_SingleLineMessageAndClosedMOW_MessageDisplayedInMessageLine = function () {
    const output = "foobar";

    assertEchoGeneratesLineOutput({
        ECHO_COMMAND: "echo " + output.quote(),
        EXPECTED_OUTPUT: output
    });
};

var testEchoCommand_SingleLineMessageAndOpenMOW_MessageAppendedToMOW = function () {
    const output = "foobar";

    dactyl.openMessageWindow();

    assertEchoGeneratesWindowOutput({
        ECHO_COMMAND: "echo " + output.quote(),
        EXPECTED_OUTPUT: RegExp(output)
    });
};

var testEchoCommand_MultilineMessageAndClosedMOW_MessageDisplayedInMOW = function () {
    const output = "foo\nbar";

    assertEchoGeneratesWindowOutput({
        ECHO_COMMAND: "echo " + output.quote(),
        EXPECTED_OUTPUT: output
    });
};

var testEchoCommand_MultilineMessageAndOpenMOW_MessageAppendedToMOW = function () {
    const output = "foo\nbar";

    dactyl.openMessageWindow();

    assertEchoGeneratesWindowOutput({
        ECHO_COMMAND: "echo " + output.quote(),
        EXPECTED_OUTPUT: RegExp(output)
    });
};

var testEchoCommand_ObjectArgumentAndClosedMOW_MessageDisplayedInMOW = function () {
    assertEchoGeneratesWindowOutput({
        ECHO_COMMAND: "echo var obj = { x: 1, y: 2 }; obj;",
        EXPECTED_OUTPUT: "[object\u00A0Object]::\nx: 1\ny: 2\n"
    });
};

function executeCommand(command) {
    dactyl.runViCommand(":" + command);
    dactyl.runViCommand([["VK_RETURN"]]);
}

function assertEchoGeneratesWindowOutput({ ECHO_COMMAND, EXPECTED_OUTPUT }) {
    executeCommand(ECHO_COMMAND);
    dactyl.assertMessageWindow(EXPECTED_OUTPUT);
}

function assertEchoGeneratesLineOutput({ ECHO_COMMAND, EXPECTED_OUTPUT }) {
    executeCommand(ECHO_COMMAND);
    dactyl.assertMessageLine(EXPECTED_OUTPUT);
}

// vim: sw=4 ts=8 et:
dactyl-1.2~r20151231/common/tests/functional/testFindCommands.js000066400000000000000000000024301264147376100244410ustar00rootroot00000000000000var dactyllib = require("utils").module("dactyl");

const FIND_TEST_PAGE = collector.addHttpResource("./data/") + "find.html";

var setupModule = function (module) {
    controller = mozmill.getBrowserController();
    dactyl = new dactyllib.Controller(controller);
};

var teardownModule = function (module) {
    dactyl.teardown();
}

var setupTest = function (test) {
    controller.open(FIND_TEST_PAGE);
    controller.waitForPageLoad(controller.tabs.activeTab);
    controller.sleep(1000);
};

var testFindCommand_PresentAlphabeticText_TextSelected = function () {
    assertTextFoundInPage("letter")
};

var testFindCommand_PresentNumericText_TextSelected = function () {
    assertTextFoundInPage("3.141")
};

var testFindCommand_MissingText_ErrorMessageDisplayed = function () {
    const MISSING_TEXT = "8c307545a017f60add90ef08955e148e";
    const PATTERN_NOT_FOUND_ERROR = "E486: Pattern not found: " + MISSING_TEXT;

    runTextSearchCommand(MISSING_TEXT);

    dactyl.assertErrorMessage(PATTERN_NOT_FOUND_ERROR);
};

function runTextSearchCommand(str) {
    dactyl.runViCommand("/" + str);
    dactyl.runViCommand([["VK_RETURN"]]);

    controller.sleep(0);
}

function assertTextFoundInPage(text) {
    runTextSearchCommand(text);
    dactyl.assertSelection(text);
}

// vim: sw=4 ts=8 et:
dactyl-1.2~r20151231/common/tests/functional/testHelpCommands.js000066400000000000000000000057561264147376100244670ustar00rootroot00000000000000const utils = require("utils");
const { module } = utils;

var jumlib = module("resource://mozmill/modules/jum.js");
var dactyllib = module("dactyl");

const { Services } = module("resource://gre/modules/Services.jsm");

var setupModule = function (module) {
    controller = mozmill.getBrowserController();
    dactyl = new dactyllib.Controller(controller);
};

var teardownModule = function (module) {
    dactyl.teardown();
}

var setupTest = function (test) {
    dactyl.runViCommand([["VK_ESCAPE"]]);
};

function urlTarget(url) Services.io.newChannel(url, null, null).name;

function urlExists(url) {
    try {
        let chan = Services.io.newChannel(url);
        chan.open();
        try { chan.cancel(Cr.NS_BINDING_ABORTED) } catch (e) {}
        return true;
    }
    catch (e) {
        return false;
    }
}

const HELP_FILES = ["all", "tutorial", "intro", "starting", "browsing",
    "buffer", "cmdline", "editing", "options", "pattern", "tabs", "hints",
    "map", "eval", "marks", "repeat", "autocommands", "print", "gui",
    "styling", "message", "privacy", "developer", "various", "plugins", "faq",
    "versions", "index"];

var testViHelpCommand_OpensIntroHelpPage = function () {
    assertHelpOpensPageWithTag({
        HELP_COMMAND: function () { dactyl.runViCommand([["VK_F1"]]); },
        EXPECTED_HELP_TAG: "intro.xml"
    });
};

var testViHelpAllCommand_OpensAllHelpPage = function () {
    assertHelpOpensPageWithTag({
        HELP_COMMAND: function () { dactyl.runViCommand([["VK_F1", { altKey: true }]]); },
        EXPECTED_HELP_TAG: "all.xml"
    });
};

var testExHelpCommand_NoArgs_OpensIntroHelpPage = function () {
    assertHelpOpensPageWithTag({
        HELP_COMMAND: function () { dactyl.runExCommand("help"); },
        EXPECTED_HELP_TAG: "intro.xml"
    });
};

var testExHelpAllCommand_NoArgs_OpensAllHelpPage = function () {
    assertHelpOpensPageWithTag({
        HELP_COMMAND: function () { dactyl.runExCommand("helpall"); },
        EXPECTED_HELP_TAG: "all.xml"
    });
};

var testExHelpCommand_PageTagArg_OpensHelpPageContainingTag = function () {
    for (let [, file] in Iterator(HELP_FILES)) {
        let tag = file + ".xml";
        assertHelpOpensPageWithTag({
            HELP_COMMAND: function () { dactyl.runExCommand("help " + tag); },
            EXPECTED_HELP_TAG: tag
        });

        let links = controller.tabs.activeTab.querySelectorAll("a[href^='dactyl:']");

        let missing = Array.filter(links, function (link) urlExists(link.href))
                           .map(function (link) link.textContent + " -> " + link.href);

        utils.assertEqual("testHelpCommands.assertNoDeadLinks", 0, missing.length,
                          "Found dead links in " + tag + ": " + missing.join(", "));
    }
};

function assertHelpOpensPageWithTag({ HELP_COMMAND, EXPECTED_HELP_TAG }) {
    HELP_COMMAND();
    controller.waitForPageLoad(controller.tabs.activeTab);
    controller.assertNode(new elementslib.ID(controller.tabs.activeTab, EXPECTED_HELP_TAG));
}

// vim: sw=4 ts=8 et:
dactyl-1.2~r20151231/common/tests/functional/testOptions.js000066400000000000000000000025661264147376100235440ustar00rootroot00000000000000// Runs a slew of generic option tests

var utils = require("utils");
const { module } = utils;

var dactyllib = module("dactyl");
var jumlib = module("resource://mozmill/modules/jum.js");

var setupModule = function (module) {
    controller = mozmill.getBrowserController();
    dactyl = new dactyllib.Controller(controller);
};
var teardownModule = function (module) {
    dactyl.teardown();
}

function $(selector) controller.window.document.querySelector(selector);

function testDefaultValidators() {
    for (var option in dactyl.modules.options)
        dactyl.assertNoErrors(function () {
            dactyl.assertNoErrorMessages(function () {
                dump("OPT VAL " + option.name + "\n");
                utils.assert("testOptions.testValidators", option.validator(option.value),
                             "Option '" + option.name + "' validator failed");
            });
        });
}

var options = {};

function testCompleters() {
    for (var option in dactyl.modules.options)
        for (var [, value] in Iterator([""].concat(options[option.name] || []))) {
            dump("OPT COMP " + option.name + " " + value + "\n");
            dactyl.testCompleter(dactyl.modules.completion, "optionValue", value,
                                 "Option '" + option.name + "' completer failed",
                                 option.name);
        }
}

// vim: sw=4 ts=8 et:
dactyl-1.2~r20151231/common/tests/functional/testShellCommands.js000066400000000000000000000017071264147376100246360ustar00rootroot00000000000000var dactyllib = require("utils").module("dactyl");

var setupModule = function (module) {
    controller = mozmill.getBrowserController();
    dactyl = new dactyllib.Controller(controller);
};

var teardownModule = function (module) {
    dactyl.teardown();
}

var teardownTest = function (test) {
    dactyl.closeMessageWindow();
};

var testRunCommand_ExecutingOutputCommand_OutputDisplayed = function () {
    const EXPECTED_OUTPUT = "foobar";
    const COMMAND = "run echo " + EXPECTED_OUTPUT;

    dactyl.runExCommand(COMMAND);

    dactyl.assertMessageWindow(RegExp(EXPECTED_OUTPUT));
};

var testRunCommand_RepeatArg_LastCommandRepeated = function () {
    const EXPECTED_OUTPUT = /foobar$/; // XXX
    const COMMAND = "run echo 'foobar'";
    const REPEAT_COMMAND = "run!";

    dactyl.runExCommand(COMMAND);
    dactyl.closeMessageWindow();
    dactyl.runExCommand(REPEAT_COMMAND);

    dactyl.assertMessageWindow(EXPECTED_OUTPUT);
};

// vim: sw=4 ts=8 et:
dactyl-1.2~r20151231/common/tests/functional/testVersionCommand.js000066400000000000000000000022251264147376100250250ustar00rootroot00000000000000var dactyllib = require("utils").module("dactyl");

var setupModule = function (module) {
    controller = mozmill.getBrowserController();
    dactyl = new dactyllib.Controller(controller);
};

var teardownModule = function (module) {
    dactyl.teardown();
}

var setupTest = function (test) {
    dactyl.closeMessageWindow();
};

var testVersionCommand_NoArg_VersionStringDisplayed = function () {
    const EXPECTED_OUTPUT = RegExp(dactyl.applicationName + ".+ (.+) running on:.+"); // XXX

    dactyl.runExCommand("version");

    dactyl.assertMessageWindow(EXPECTED_OUTPUT);
};

var testVersionCommand_BangArg_HostAppVersionPageDisplayed = function () {
    const EXPECTED_URL = "about:";
    const EXPECTED_TITLE = "About:";
    const BLANK_PAGE_URL = "about:blank";

    controller.open(BLANK_PAGE_URL);
    controller.waitForPageLoad(controller.tabs.activeTab);
    dactyl.runExCommand("version!");
    controller.waitForPageLoad(controller.tabs.activeTab);

    controller.assert(function () controller.tabs.activeTab.location.href === EXPECTED_URL);
    controller.assert(function () controller.tabs.activeTab.title === EXPECTED_TITLE);
};

// vim: sw=4 ts=8 et:
dactyl-1.2~r20151231/common/tests/functional/utils.js000066400000000000000000000002571264147376100223440ustar00rootroot00000000000000
// Work around these horrendous Sandbox issues.
Components.utils.import(/([^ ]+\/)[^\/]+$/.exec(Components.stack.filename)[1] + "utils.jsm", exports);

// vim: sw=4 ts=8 et:
dactyl-1.2~r20151231/common/tests/functional/utils.jsm000066400000000000000000000024421264147376100225170ustar00rootroot00000000000000
var EXPORTED_SYMBOLS = ["NS", "assert", "assertEqual", "module", "test", "toJSON"];

const Ci = Components.interfaces;

function module(uri) {
    if (!/^[a-z-]+:/.exec(uri))
        uri = /([^ ]+\/)[^\/]+$/.exec(Components.stack.caller.filename)[1] + uri + ".jsm";

    let obj = {};
    Components.utils.import(uri, obj);
    return obj;
}

var elementslib = module("resource://mozmill/modules/elementslib.js");
var frame = module("resource://mozmill/modules/frame.js");
var jumlib = module("resource://mozmill/modules/jum.js");

function toJSON(val) {
    if (typeof val == "function")
        return val.toSource();
    if (val instanceof Ci.nsIDOMNode || val instanceof Ci.nsIDOMWindow)
        return { DOMNode: String(val) };
    return val;
}

function test(val, params) {
    frame.events[val ? "pass" : "fail"](params);
    return val;
}

var NS = Namespace("dactyl", "http://vimperator.org/namespaces/liberator");

function assert(funcName, value, comment)
    test(value, {
        function: funcName,
        value: toJSON(value),
        comment: toJSON(comment)
    });

function assertEqual(funcName, want, got, comment)
    test(want == got, {
        function: funcName,
        want: toJSON(want), got: toJSON(got),
        comment: toJSON(comment)
    });

// vim: sw=4 ts=8 et ft=javascript:
dactyl-1.2~r20151231/melodactyl/000077500000000000000000000000001264147376100162035ustar00rootroot00000000000000dactyl-1.2~r20151231/melodactyl/AUTHORS000066400000000000000000000002731264147376100172550ustar00rootroot00000000000000Main developer/Project founder:
  * Prathyush Thota 

Developers:
  * Martin Stubenschrott (stubenschrott@vimperator.org)
  * Doug Kearns (dougkearns@gmail.com)
dactyl-1.2~r20151231/melodactyl/Makefile000066400000000000000000000003361264147376100176450ustar00rootroot00000000000000#### configuration

NAME          = melodactyl

SONGBIRD     ?= songbird
HOSTAPP      ?= $(SONGBIRD)
PROFILEPATHS ?= "$$HOME/.songbird2" \
		"$$HOME/Library/Songbird2" \
		"$$APPDATA/Songbird2"

include ../common/Makefile
dactyl-1.2~r20151231/melodactyl/NEWS000077500000000000000000000014511264147376100167060ustar00rootroot000000000000000.1a1pre:
    * :playerprev and :playernext and equivalent mappings now accept a count.
    * :displaypane arguments changed to "leftservice", "bottomservice",
      "bottomcontent" or "rightsidebar"
    * asciidoc is no longer required to build Melodactyl
    * The help system is newly modularized
    * add :silent
    * add $MY_MELODACTYLRC
    * add ' and " local marks
    * add w and W Normal mode mappings for symmetry with o/O and t/T
    * add :messclear
    * add 'maxitems'
    * :dialog {subscribe|newsmartplaylist}
    * add :displaypane and :dpclose
    * rename :filter to :queue and :Filter to :filter
    * add 'repeat' and 'shuffle'
    * add 'jsdebugger' option - switch on/off javascript debugger service
    * add "addons", "downloads", "extoptions" and "help" to the 'activate' option.
dactyl-1.2~r20151231/melodactyl/TODO000066400000000000000000000016721264147376100167010ustar00rootroot00000000000000Priority list:
1-9 as in Vim (9 = required for next release, 5 = would be nice, 1 = probably not)

BUGS:
- broken commands:
  - :tabduplicate
  - :open songbird-internal-search searchString (broken because SB intercepts queries to this engine)
  -  only works between browser tabs not the media tab
  - numbered tabs

FEATURES:
9 Clean up NEWS
9 Bookmarks are now only supported in SB via an addon.
9 '?' - Reusing '/'.
8 Merge with SongBird's sanitizer implementation.
8 Playlist/SmartPlaylist operations & meta-data operations.
8 Sort-View commands.
7 Queue view.
7 j/k - for browsing through the visible view.
7 extended hint mode for opening links in FF.
6 :tqueue, :lqueue etc.
5 make Player mode commands work in the Mini-Player.
5 Check for default extensions and add commands for them. Ex. Last.fm, Seeqpod e.t.c
    Wouldn't these be provided as Melodactyl plugins like Pentadactyl does? --djk
5 tagging tracks for manipulation by commands
dactyl-1.2~r20151231/melodactyl/chrome.manifest000077700000000000000000000000001264147376100257132../common/chrome.manifestustar00rootroot00000000000000dactyl-1.2~r20151231/melodactyl/components/000077500000000000000000000000001264147376100203705ustar00rootroot00000000000000dactyl-1.2~r20151231/melodactyl/components/commandline-handler.js000077700000000000000000000000001264147376100351642../../common/components/commandline-handler.jsustar00rootroot00000000000000dactyl-1.2~r20151231/melodactyl/content/000077500000000000000000000000001264147376100176555ustar00rootroot00000000000000dactyl-1.2~r20151231/melodactyl/content/config.js000066400000000000000000000325411264147376100214650ustar00rootroot00000000000000// Copyright (c) 2009 by Martin Stubenschrott 
// Copyright (c) 2009 by Prathyush Thota 
// Copyright (c) 2009-2011 by Doug Kearns 
// Copyright (c) 2009-2011 by Kris Maglione 
//
// This work is licensed for reuse under an MIT license. Details are
// given in the LICENSE.txt file included with this file.
"use strict";

Components.utils.import("resource://gre/modules/utils.js"); // XXX: PlacesUtils

const Config = Module("config", ConfigBase, {
    name: "melodactyl",
    appName: "Melodactyl",
    idName: "MELODACTYL",
    host: "Songbird",
    hostbin: "songbird",

    commandContainer: "mainplayer",

    Local: function Local(dactyl, modules, window) let ({ config } = modules, { document } = window) {
        init: function init() {
            init.supercall(this);

            // TODO: mention this to SB devs, they seem keen to provide these
            // functions to make porting from FF as simple as possible.
            window.toJavaScriptConsole = () => {
                toOpenWindowByType("global:console", "chrome://global/content/console.xul");
            };
        },

        // FIXME: unless I'm seeing double in in the wee small hours gBrowser is
        // first set from getBrowser which they've deprecated in FF.
        get browser() { return window.getBrowser(); },
        get tabbrowser() { return window.getBrowser(); },

        dialogs: {
            about: ["About Songbird",
                () => { window.openDialog("chrome://songbird/content/xul/about.xul", "_blank", "chrome,dialog,modal,centerscreen"); }],
            addons: ["Manage Add-ons",
                () => { window.SBOpenPreferences("paneAddons"); }],
            checkupdates: ["Check for updates",
                () => { window.checkForUpdates(); }],
            cookies: ["List your cookies",
                () => { window.toOpenWindowByType("Browser:Cookies", "chrome://browser/content/preferences/cookies.xul", "chrome,dialog=no,resizable"); }],
            console: ["JavaScript console",
                () => { window.toJavaScriptConsole(); }],
            dominspector: ["DOM Inspector",
                () => { window.inspectDOMDocument(window.content.document); },
                () => "inspectDOMDocument" in window],
            downloads: ["Manage Downloads",
                () => { window.toOpenWindowByType("Download:Manager", "chrome://mozapps/content/downloads/downloads.xul", "chrome,dialog=no,resizable"); }],
            newsmartplaylist: ["Open the file selector dialog",
                () => { window.SBNewSmartPlaylist(); }],
            openfile: ["Open the file selector dialog",
                () => { window.SBFileOpen(); }],
            pagesource: ["View page source",
                () => { window.BrowserViewSourceOfDocument(window.content.document); }],
            preferences: ["Show Songbird preferences dialog",
                () => { window.openPreferences(); }],
            printsetup: ["Setup the page size and orientation before printing",
                () => { window.PrintUtils.showPageSetup(); }],
            print: ["Show print dialog",
                () => { window.PrintUtils.print(); }],
            saveframe: ["Save frame to disk",
                () => { window.saveFrameDocument(); }],
            savepage: ["Save page to disk",
                () => { window.saveDocument(window.content.document); }],
            searchengines: ["Manage installed search engines",
                () => { window.openDialog("chrome://browser/content/search/engineManager.xul", "_blank", "chrome,dialog,modal,centerscreen"); }],
            selectionsource: ["View selection source",
                () => { modules.buffer.viewSelectionSource(); }],
            subscribe: ["Add a new subscription",
                () => { window.SBSubscribe(); }]
        },

        // TODO: clean this up
        focusChange: function (win) {
            const { modes } = modules;

            // Switch to -- PLAYER -- mode for Songbird Media Player.
            if (this.isPlayerWindow)
                modes.set(modes.PLAYER);
            else
                if (modes.main == modes.PLAYER)
                    modes.pop();
        },

        get isPlayerWindow() {
            let browser = window.SBGetBrowser();
            return browser.mCurrentTab == browser.mediaTab;
        },

        /**
         * Shows or hides the main service pane.
         *
         * @param {boolean} value Show the service pane if true, hide it if false.
         */
        showServicePane: function (value) {
            const key = "splitter.servicepane_splitter.was_collapsed";
            window.gServicePane.open = value;
            window.SBDataSetBoolValue(key, window.gServicePane.open);
        },

        /**
         * Opens the display panel with the specified *id*.
         *
         * @param {string} id The ID of the display pane.
         */
        openDisplayPane: function (id) {
            if (id == "servicepane")
                this.showServicePane(true);
            else {
                let pane = document.getElementById(id);
                let manager = services.displayPaneManager;
                let paneinfo = manager.getPaneInfo(pane._lastURL.stringValue);

                if (!paneinfo)
                    paneinfo = manager.defaultPaneInfo;

                pane.loadContent(paneinfo);
            }
        },

        /**
         * Closes the display panel with the specified *id*
         *
         * @param {string} id The ID of the display pane.
         */
        closeDisplayPane: function (id) {
            if (id == "servicepane")
                this.showServicePane(false);
            else
                document.getElementById(id).hide();
        }
    },

    /*** optional options, there are checked for existence and a fallback provided  ***/
    features: Set(["bookmarks", "hints", "marks", "history", "quickmarks", "session", "tabs", "player"]),

    defaults: {
        guioptions: "bCmprs",
        showtabline: 2,
        get titlestring() { return config.name; }
    },

    guioptions: {
        m: ["Menubar",         ["main-menubar"]],
        T: ["Toolbar",         ["nav-bar"]],
        p: ["Player controls", ["player_wrapper"]]
    },

    overlayChrome: ["chrome://purplerain/content/xul/mainplayer.xul"],

    styleableChrome: ["chrome://purplerain/content/xul/mainplayer.xul"],

    autocommands: {
        BookmarkAdd: "Triggered after a page is bookmarked",
        ColorScheme: "Triggered after a color scheme has been loaded",
        DOMLoad: "Triggered when a page's DOM content has fully loaded",
        DownloadPost: "Triggered when a download has completed",
        Fullscreen: "Triggered when the browser's fullscreen state changes",
        LocationChange: "Triggered when changing tabs or when navigation to a new location",
        PageLoadPre: "Triggered after a page load is initiated",
        PageLoad: "Triggered when a page gets (re)loaded/opened",
        ShellCmdPost: "Triggered after executing a shell command with :!cmd",
        TrackChangePre: "Triggered before a playing track is changed",
        TrackChange: "Triggered after a playing track has changed",
        ViewChangePre: "Triggered before a sequencer view is changed",
        ViewChange: "Triggered after a sequencer view is changed",
        StreamStart: "Triggered after a stream has started",
        StreamPause: "Triggered after a stream has paused",
        StreamEnd: "Triggered after a stream has ended",
        StreamStop: "Triggered after a stream has stopped",
        Enter: "Triggered after Songbird starts",
        LeavePre: "Triggered before exiting Songbird, just before destroying each module",
        Leave: "Triggered before exiting Songbird"
    },

    completers: Class.memoize(function () {
        return update({
            displaypane: "displayPane",
            playlist: "playlist",
            mediaview: "mediaView",
            mediasort: "mediaListSort",
            song: "song"
        }, this.__proto__.completers);
    }),

    removeTab: function (tab) {
        if (config.tabbrowser.mTabs.length > 1)
            config.tabbrowser.removeTab(tab);
        else {
            if (buffer.URL != "about:blank" || window.getWebNavigation().sessionHistory.count > 0) {
                dactyl.open("about:blank", dactyl.NEW_BACKGROUND_TAB);
                config.tabbrowser.removeTab(tab);
            }
            else
                dactyl.beep();
        }
    },

    scripts: [
        "browser",
        "bookmarks",
        "history",
        "quickmarks",
        "tabs",
        "player",
        "library"
    ],

    sidebars: {
        viewAddons:      ["Add-ons",     "A", "chrome://mozapps/content/extensions/extensions.xul"],
        viewConsole:     ["Console",     "C", "chrome://global/content/console.xul"],
        viewDownloads:   ["Downloads",   "D", "chrome://mozapps/content/downloads/downloads.xul"],
        viewPreferences: ["Preferences", "P", "about:config"]
    },

    // FIXME: tab arg and media tab exception?
    stop: function (tab) {
        window.SBGetBrowser().mCurrentBrowser.stop();
    }
}, {
    /**
     * @property {object} A map of display pane command argument strings to
     *     panel element IDs.
     */
    displayPanes: {
        "leftservice"  : "servicepane",
        "bottomcontent": "displaypane_contentpane_bottom",
        "bottomservice": "displaypane_servicepane_bottom",
        "rightsidebar" : "displaypane_right_sidebar"
    }
}, {
    commands: function initCommands(dactyl, modules, window) {
        const { commands, completion, options } = modules;

        commands.add(["dpcl[ose]"],
            "Close a display pane",
            function (args) {
                let arg = args.literalArg;
                dactyl.assert(arg in Config.displayPanes, _("error.invalidArgument", arg));
                config.closeDisplayPane(Config.displayPanes[arg]);
            }, {
                argCount: "1",
                completer: function (context) {
                    completion.displayPane(context);
                },
                literal: 0
            });

        // TODO: this should accept a second arg to specify content
        commands.add(["displayp[ane]", "dp[ane]", "dpope[n]"],
            "Open a display pane",
            function (args) {
                let arg = args.literalArg;
                dactyl.assert(arg in Config.displayPanes, _("error.invalidArgument", arg));
                // TODO: focus when we have better key handling of these extended modes
                config.openDisplayPane(Config.displayPanes[arg]);
            }, {
                argCount: "1",
                completer: function (context) {
                    completion.displayPane(context);
                },
                literal: 0
            });

        commands.add(["pref[erences]", "prefs"],
            "Show " + config.host + " preferences",
            function (args) {
                if (args.bang) { // open Songbird settings GUI dialog
                    dactyl.open("about:config",
                        (options["newtab"] && options.get("newtab").has("all", "prefs"))
                                ? dactyl.NEW_TAB : dactyl.CURRENT_TAB);
                }
                else
                    window.openPreferences();
            },
            {
                argCount: "0",
                bang: true
            });
    },
    completion: function initCompletion(dactyl, modules, window) {
        const completion = require("completion");

        completion.displayPane = context => {
            context.title = ["Display Pane"];
            context.completions = Config.displayPanes; // FIXME: useful description etc
        };
    },
    modes: function initModes(dactyl, modules, window) {
        const { modes } = modules;

        this.ignoreKeys = {
            "": modes.NORMAL | modes.INSERT,
            "": modes.NORMAL | modes.INSERT,
            "": modes.NORMAL | modes.INSERT,
            "": modes.NORMAL | modes.INSERT
        };

        modes.addMode("PLAYER", {
            char: "p"
        });
    },
    options: function initOptions(dactyl, modules, window) {
        const { options } = modules;

        // TODO: SB doesn't explicitly support an offline mode. Should we? --djk
        options.add(["online"],
            "Set the 'work offline' option",
            "boolean", true,
            {
                setter: function (value) {
                    const ioService = services.io;
                    ioService.offline = !value;
                    prefs.set("browser.offline", ioService.offline);
                    return value;
                },
                getter: function () { return !services.io.offline; }
            });
    },
    services: function initServices(dactyl, modules, window) {
        services.add("displayPaneManager",      "@songbirdnest.com/Songbird/DisplayPane/Manager;1",         Ci.sbIDisplayPaneManager);
        services.add("mediaPageManager",        "@songbirdnest.com/Songbird/MediaPageManager;1",            Ci.sbIMediaPageManager);
        services.add("propertyManager",         "@songbirdnest.com/Songbird/Properties/PropertyManager;1",  Ci.sbIPropertyManager);

        services.addClass("mutablePropertyArray", "@songbirdnest.com/Songbird/Properties/MutablePropertyArray;1",
                          Ci.sbIMutablePropertyArray);
    }
});

// vim: set fdm=marker sw=4 sts=4 ts=8 et:
dactyl-1.2~r20151231/melodactyl/content/library.js000066400000000000000000000042541264147376100216640ustar00rootroot00000000000000// Copyright (c) 2009 by Prathyush Thota 
// Copyright (c) 2009 by Doug Kearns 
//
// This work is licensed for reuse under an MIT license. Details are
// given in the LICENSE.txt file included with this file.
"use strict";

// TODO: flesh this out
const Library = Module("library", {
    init: function () {
        this.MAIN_LIBRARY = LibraryUtils.mainLibrary;
    },

    /**
     * Converts an XPCOM enumerator to a JavaScript array.
     *
     * @param {nsISimpleEnumerator|nsIStringEnumerator|nsIArray} enum The enumerator to convert.
     * @returns {Array}
     */
    _toJSArray: function _toJSArray(enum) ArrayConverter.JSArray(enum),

    /**
     * Returns an array of all the artist names in the main library.
     *
     * @returns {[string]}
     */
    getArtists: function getArtists() this._toJSArray(this.MAIN_LIBRARY.getDistinctValuesForProperty(SBProperties.artistName)),

    // FIXME: Prathyush do we really want to remove duplicates? If so, why not tracks too? --djk
    /**
     * Returns an array of all the album names for *artist* in the main
     * library.
     *
     * @param {string} artist The artist's name.
     * @returns {[string]}
     */
    getAlbums: function getAlbums(artist) {
        let albums = this._toJSArray(this.MAIN_LIBRARY.getItemsByProperty(SBProperties.artistName, artist))
                         .map(track => track.getProperty(SBProperties.albumName));
        return array.uniq(albums);
    },

    /**
     * Returns an array of all the track names for *artist* and *album* in the
     * main library.
     *
     * @param {string} artist The artist's name.
     * @param {string} album The album's name.
     * @returns {[string]}
     */
    getTracks: function getTracks(artist, album) {
        let properties = services.MutablePropertyArray();

        properties.appendProperty(SBProperties.artistName, artist);
        properties.appendProperty(SBProperties.albumName, album);

        return this._toJSArray(this.MAIN_LIBRARY.getItemsByProperties(properties))
                   .map(track => track.getProperty(SBProperties.trackName));
    }
}, {
}, {
});

// vim: set fdm=marker sw=4 sts=4 ts=8 et:
dactyl-1.2~r20151231/melodactyl/content/logo.png000066400000000000000000000020721264147376100213240ustar00rootroot00000000000000PNG


IHDR(}! cHRMz&u0`:pQ<gAMA|QsRGBbKGD	pHYs+IDATxYHQǥi
{I#0}h"{(Њꡢ}^E3CBJ($H‡Vwߥa{]sg3ߙ!z&V] D3Oݠ3
DvLٰ
~%OÅA[H`{>`/x.NŰR}pLamW
q93˵l=z
\Em(y3]ca_
v?S~ ~
+!7z8E:Anp/f)3VM1
l,,0Yؕ^em8Ʋ5gY}
f9NK=(VM.Le(l+Ȳ}aiƟ
]_zFy[οe<Wӷg*@4TV8K9LwӸl	KϏqt\a hx&qILTFq,Kw*1b2BCH{6&'ԷPmԷ[	h.Vh	ģ0kY&p~0jXNidy^y2%U_/-It .ck9=I,I횀:gXˮ$EͭIvé	K{8xWZ=}uz"f]2,f<gp>t8,M]OZ9XYV@LzKIh9p34L},lwsʌi]i_\%B!Dx轹ӱix<!B!B!?c$߯7t`kkVcX.uMe.PX ^ro^lÉd%Ӆ:!")޼IENDB`dactyl-1.2~r20151231/melodactyl/content/player.js000066400000000000000000000750471264147376100215240ustar00rootroot00000000000000// Copyright (c) 2009 by Prathyush Thota 
// Copyright (c) 2009 by Doug Kearns 
//
// This work is licensed for reuse under an MIT license. Details are
// given in the LICENSE.txt file included with this file.
"use strict";

const Player = Module("player", {
    init: function init() {
        this._lastSearchString = "";
        this._lastSearchIndex = 0;
        this._lastSearchView = this._currentView; //XXX

        // Get the focus to the visible playlist first
        //window._SBShowMainLibrary();

        gMM.addListener(this._mediaCoreListener);
    },

    destroy: function destroy() {
        gMM.removeListener(this._mediaCoreListener);
    },

    /**
     * Moves the track position *interval* milliseconds forwards or backwards.
     *
     * @param {number} interval The time interval (ms) to move the track
     *     position.
     * @param {boolean} direction The direction in which to move the track
     *     position, forward if true otherwise backwards.
     * @private
     */
    _seek: function _seek(interval, direction) {
        let position = gMM.playbackControl ? gMM.playbackControl.position : 0;
        player.seekTo(position + (direction ? interval : -interval));
    },

    /**
     * Listens for media core events and in response dispatches the appropriate
     * autocommand events.
     * @private
     */
    _mediaCoreListener: {
        onMediacoreEvent: function (event) {
            switch (event.type) {
            case Ci.sbIMediacoreEvent.BEFORE_TRACK_CHANGE:
                dactyl.log(_("player.preTrackChange", event.data));
                autocommands.trigger("TrackChangePre", { track: event.data });
                break;
            case Ci.sbIMediacoreEvent.TRACK_CHANGE:
                dactyl.log(_("player.trackChanged", event.data));
                autocommands.trigger("TrackChange", { track: event.data });
                break;
            case Ci.sbIMediacoreEvent.BEFORE_VIEW_CHANGE:
                dactyl.log(_("player.preViewChange", event.data));
                autocommands.trigger("ViewChangePre", { view: event.data });
                break;
            case Ci.sbIMediacoreEvent.VIEW_CHANGE:
                dactyl.log(_("player.viewChange", event.data));
                autocommands.trigger("ViewChange", { view: event.data });
                break;
            case Ci.sbIMediacoreEvent.STREAM_START:
                dactyl.log(_("player.trackStart", gMM.sequencer.currentItem));
                autocommands.trigger("StreamStart", { track: gMM.sequencer.currentItem });
                break;
            case Ci.sbIMediacoreEvent.STREAM_PAUSE:
                dactyl.log(_("player.trackPause", gMM.sequencer.currentItem));
                autocommands.trigger("StreamPause", { track: gMM.sequencer.currentItem });
                break;
            case Ci.sbIMediacoreEvent.STREAM_END:
                dactyl.log(_("player.trackEnd", gMM.sequencer.currentItem));
                autocommands.trigger("StreamEnd", { track: gMM.sequencer.currentItem });
                break;
            case Ci.sbIMediacoreEvent.STREAM_STOP:
                dactyl.log(_("player.trackStop", gMM.sequencer.currentItem));
                autocommands.trigger("StreamStop", { track: gMM.sequencer.currentItem });
                break;
            }
        }
    },

    /** @property {sbIMediaListView} The current media list view. @private */
    get _currentView() { return SBGetBrowser().currentMediaListView; },

    /**
     * @property {number} The player volume in the range 0.0-1.0.
     */
    get volume() { return gMM.volumeControl.volume; },
    set volume(value) {
        gMM.volumeControl.volume = value;
    },

    /**
     * Focuses the specified media item in the current media list view.
     *
     * @param {sbIMediaItem} mediaItem The media item to focus.
     */
    focusTrack: function focusTrack(mediaItem) {
        SBGetBrowser().mediaTab.mediaPage.highlightItem(this._currentView.getIndexForItem(mediaItem));
    },

    /**
     * Plays the currently selected media item. If no item is selected the
     * first item in the current media view is played.
     */
    play: function play() {
        // Check if there is any selection in place, else play first item of the visible view.
        // TODO: this approach, or similar, should be generalised for all commands, PT? --djk
        if (this._currentView.selection.count != 0)
            gMM.sequencer.playView(this._currentView,
                    this._currentView.getIndexForItem(this._currentView.selection.currentMediaItem));
        else
            gMM.sequencer.playView(SBGetBrowser().currentMediaListView, 0);

        this.focusTrack(gMM.sequencer.currentItem);
    },

    /**
     * Stops playback of the currently playing media item.
     */
    stop: function stop() {
        gMM.sequencer.stop();
    },

    /**
     * Plays the *count*th next media item in the current media view.
     *
     * @param {number} count
     */
    next: function next(count) {
        for (let i = 0; i < count; i++)
            gSongbirdWindowController.doCommand("cmd_control_next");
        gSongbirdWindowController.doCommand("cmd_find_current_track");
    },

    /**
     * Plays the *count*th previous media item in the current media view.
     *
     * @param {number} count
     */
    previous: function previous(count) {
        for (let i = 0; i < count; i++)
            gSongbirdWindowController.doCommand("cmd_control_previous");
        gSongbirdWindowController.doCommand("cmd_find_current_track");
    },

    /**
     * Toggles the play/pause status of the current media item.
     */
    togglePlayPause: function togglePlayPause() {
        ["cmd_control_playpause", "cmd_find_current_track"].forEach(gSongbirdWindowController.doCommand);
    },

    /**
     * Toggles the shuffle status of the sequencer.
     */
    toggleShuffle: function toggleShuffle() {
        if (gMM.sequencer.mode != gMM.sequencer.MODE_SHUFFLE)
            gMM.sequencer.mode = gMM.sequencer.MODE_SHUFFLE;
        else
            gMM.sequencer.mode = gMM.sequencer.MODE_FORWARD;
    },

    // FIXME: not really toggling (depending on your definition) - good enough for now.
    /**
     * Toggles between the sequencer's three repeat modes: Repeat-One,
     * Repeat-All and Repeat-None.
     */
    toggleRepeat: function toggleRepeat() {
        switch (gMM.sequencer.repeatMode) {
        case gMM.sequencer.MODE_REPEAT_NONE:
            gMM.sequencer.repeatMode = gMM.sequencer.MODE_REPEAT_ONE;
            break;
        case gMM.sequencer.MODE_REPEAT_ONE:
            gMM.sequencer.repeatMode = gMM.sequencer.MODE_REPEAT_ALL;
            break;
        case gMM.sequencer.MODE_REPEAT_ALL:
            gMM.sequencer.repeatMode = gMM.sequencer.MODE_REPEAT_NONE;
            break;
        default:
            gMM.sequencer.repeatMode = gMM.sequencer.MODE_REPEAT_NONE;
            break;
        }
    },

    /**
     * Seeks forward *interval* milliseconds in the currently playing track.
     *
     * @param {number} interval The time interval (ms) to advance the
     *     current track.
     */
    seekForward: function seekForward(interval) {
        this._seek(interval, true);
    },

    /**
     * Seeks backwards *interval* milliseconds in the currently playing track.
     *
     * @param {number} interval The time interval (ms) to rewind the
     *     current track.
     */
    seekBackward: function seekBackward(interval) {
        this._seek(interval, false);
    },

    /**
     * Seeks to a specific position in the currently playing track.
     *
     * @param {number} The new position (ms) in the track.
     */
    seekTo: function seekTo(position) {
        // FIXME: if not playing
        if (!gMM.playbackControl)
            this.play();

        let min = 0;
        let max = gMM.playbackControl.duration - 5000; // TODO: 5s buffer like cmus desirable?

        gMM.playbackControl.position = Math.constrain(position, min, max);
    },

    /**
     * Increases the volume by 5% of the maximum volume.
     */
    increaseVolume: function increaseVolume() {
        this.volume = Math.constrain(this.volume + 0.05, 0, 1);
    },

    /**
     * Decreases the volume by 5% of the maximum volume.
     */
    decreaseVolume: function decreaseVolume() {
        this.volume = Math.constrain(this.volume - 0.05, 0, 1);
    },

    // TODO: Document what this buys us over and above cmd_find_current_track
    /**
     * Focuses the currently playing track.
     */
    focusPlayingTrack: function focusPlayingTrack() {
        this.focusTrack(gMM.sequencer.currentItem);
    },

    /**
     * Searches the current media view for *str*
     *
     * @param {string} str The search string.
     */
    searchView: function searchView(str) {
        let search = _getSearchString(this._currentView);
        let searchString = "";

        if (search != "") // XXX
            searchString = str + " " + search;
        else
            searchString = str;

        this._lastSearchString = searchString;

        let searchView = LibraryUtils.createStandardMediaListView(this._currentView.mediaList, searchString);

        if (searchView.length) {
            this._lastSearchView = searchView;
            this._lastSearchIndex = 0;
            this.focusTrack(searchView.getItemByIndex(this._lastSearchIndex));
        }
        else
            dactyl.echoerr(_("finder.notFound", searchString), commandline.FORCE_SINGLELINE);
    },

    /**
     * Repeats the previous view search.
     *
     * @param {boolean} reverse Search in the reverse direction to the previous
     *     search.
     */
    searchViewAgain: function searchViewAgain(reverse) {
        function echo(str) {
            this.timeout(function () {
                commandline.echo(str, commandline.HL_WARNINGMSG, commandline.APPEND_TO_MESSAGES | commandline.FORCE_SINGLELINE);
            }, 0);
        }

        if (reverse) {
            if (this._lastSearchIndex == 0) {
                this._lastSearchIndex = this._lastSearchView.length - 1;
                echo(_("finder.atTop"));
            }
            else
                this._lastSearchIndex = this._lastSearchIndex - 1;
        }
        else {
            if (this._lastSearchIndex == (this._lastSearchView.length - 1)) {
                this._lastSearchIndex = 0;
                echo(_("finder.atBottom"));
            }
            else
                this._lastSearchIndex = this._lastSearchIndex + 1;
        }

        // TODO: Implement for "?" --ken
        commandline.echo("/" + this._lastSearchString, null, commandline.FORCE_SINGLELINE);
        this.focusTrack(this._lastSearchView.getItemByIndex(this._lastSearchIndex));

    },

    /**
     * The search dialog keypress callback.
     *
     * @param {string} str The contents of the search dialog.
     */
    onSearchKeyPress: function onSearchKeyPress(str) {
        if (options["incsearch"])
            this.searchView(str);
    },

    /**
     * The search dialog submit callback.
     *
     * @param {string} str The contents of the search dialog.
     */
    onSearchSubmit: function onSearchSubmit(str) {
        this.searchView(str);
    },

    /**
     * The search dialog cancel callback.
     */
    onSearchCancel: function onSearchCancel() {
        // TODO: restore the view state if altered by an 'incsearch' search
    },

    /**
     * Returns an array of all available playlists.
     *
     * @returns {[sbIMediaList]}
     */
    getPlaylists: function getPlaylists() {
        let mainLibrary = LibraryUtils.mainLibrary;
        let playlists = [mainLibrary];
        let listener = {
            onEnumerationBegin: function () { },
            onEnumerationEnd: function () { },
            onEnumeratedItem: function (list, item) {
                // FIXME: why are there null items and duplicates?
                if (!playlists.some(list => list.name == item.name) && item.name != null)
                    playlists.push(item);
                return Ci.sbIMediaListEnumerationListener.CONTINUE;
            }
        };

        mainLibrary.enumerateItemsByProperty("http://songbirdnest.com/data/1.0#isList", "1", listener);

        return playlists;
    },

    /**
     * Plays the media item at *index* in *playlist*.
     *
     * @param {sbIMediaList} playlist
     * @param {number} index
     */
    playPlaylist: function playPlaylist(playlist, index) {
        gMM.sequencer.playView(playlist.createView(), index);
    },

    /**
     * Returns an array of all available media pages.
     *
     * @returns {[sbIMediaPageInfo]}
     */
    getMediaPages: function getMediaPages() {
        let list = SBGetBrowser().currentMediaPage.mediaListView.mediaList;
        let pages = services.mediaPageManager.getAvailablePages(list);
        return ArrayConverter.JSArray(pages).map(page => page.QueryInterface(Ci.sbIMediaPageInfo));
    },

    /**
     * Loads the specified media page into *view* with the given *list* of
     * media items.
     *
     * @param {sbIMediaPage} page
     * @param {sbIMediaList} list
     * @param {sbIMediaView} view
     */
    loadMediaPage: function loadMediaPage(page, list, view) {
        services.mediaPageManager.setPage(list, page);
        SBGetBrowser().loadMediaList(list, null, null, view, null);
    },

    /**
     * Applys the specified *rating* to *mediaItem*.
     *
     * @param {sbIMediaItem} mediaItem The media item to rate.
     * @param {number} rating The star rating (1-5).
     */
    rateMediaItem: function rateMediaItem(mediaItem, rating) {
        mediaItem.setProperty(SBProperties.rating, rating);
    },

    // TODO: add more fields, and generate the list dynamically. PT should the
    // available fields reflect only the visible view fields or offer others? --djk
    /**
     * Sorts the current media view by *field* in the order specified by
     * *ascending*.
     *
     * @param {string} field The sort field.
     * @param {boolean} ascending If true sort in ascending order, otherwise in
     *     descending order.
     */
    sortBy: function sortBy(field, ascending) {
        let order = ascending ? "a" : "d";
        let properties = services.MutablePropertyArray();
        properties.strict = false;

        switch (field) {
        case "title":
            properties.appendProperty(SBProperties.trackName, order);
            break;
        case "time":
            properties.appendProperty(SBProperties.duration, order);
            break;
        case "artist":
            properties.appendProperty(SBProperties.artistName, order);
            break;
        case "album":
            properties.appendProperty(SBProperties.albumName, order);
            break;
        case "genre":
            properties.appendProperty(SBProperties.genre, order);
            break;
        case "rating":
            properties.appendProperty(SBProperties.rating, order);
            break;
        default:
            properties.appendProperty(SBProperties.trackName, order);
            break;
        }

        this._currentView.setSort(properties);
    }
}, {
}, {
    modes: function initModes(dactyl, modules, window) {
        modes.addMode("SEARCH_VIEW", {
            description: "Search View mode",
            bases: [modes.COMMAND_LINE],
        });
        modes.addMode("SEARCH_VIEW_FORWARD", {
            description: "Forward Search View mode",
            bases: [modes.SEARCH_VIEW]
        });
        modes.addMode("SEARCH_VIEW_BACKWARD", {
            description: "Backward Search View mode",
            bases: [modes.SEARCH_VIEW]
        });

    },
    commandline: function initCommandline() {
        player.CommandMode = Class("CommandSearchViewMode", modules.CommandMode, {
            init: function init(mode) {
                this.mode = mode;
                init.supercall(this);
            },

            historyKey: "search-view",

            get prompt() {
                return this.mode === modules.modes.SEARCH_VIEW_BACKWARD ? "?" : "/";
            },

            get onCancel() { return player.closure.onSearchCancel; },
            get onChange() { return player.closure.onSearchKeyPress; },
            get onSubmit() { return player.closure.onSearchSubmit; }
        });
    },
    commands: function initCommands() {
        commands.add(["f[ilter]"],
                "Filter tracks based on keywords {genre/artist/album/track}",
                function (args) {
                    let view = LibraryUtils.createStandardMediaListView(LibraryUtils.mainLibrary, args.literalArg);

                    dactyl.assert(view.length, "No matching tracks");

                    SBGetBrowser().loadMediaList(LibraryUtils.mainLibrary, null, null, view,
                                                     "chrome://songbird/content/mediapages/filtersPage.xul");
                    // TODO: make this player.focusTrack work ?
                    player.focusTrack(view.getItemByIndex(0));
                }, {
                    argCount: "1",
                    literal: 0
                    //completer: function (context, args) {
                    //    completion.tracks(context, args);
                    //}
                });

        commands.add(["load"],
            "Load a playlist",
            function (args) {
                let arg = args.literalArg;

                if (arg) {
                    // load the selected playlist/smart playlist
                    for ([, playlist] in Iterator(player.getPlaylists())) {
                        if (util.compareIgnoreCase(arg, playlist.name) == 0) {
                            SBGetBrowser().loadMediaList(playlist);
                            player.focusTrack(player._currentView.getItemByIndex(0));
                            return;
                        }
                    }
                    dactyl.echoerr(_("error.invalidArgument", arg));
                }
                else {
                    // load main library if there are no args
                    _SBShowMainLibrary();
                }
            }, {
                argCount: "?",
                completer: function (context) {
                    completion.playlist(context);
                },
                literal: 0
            });

        // TODO: better off as a single command (:player play) or cmus compatible (:player-play)? --djk
        commands.add(["playerp[lay]"],
            "Play track",
            function () { player.play(); });

        commands.add(["playerpa[use]"],
            "Pause/unpause track",
            function () { player.togglePlayPause(); });

        commands.add(["playern[ext]"],
            "Play next track",
            function (args) { player.next(Math.max(args.count, 1)); },
            { count: true });

        commands.add(["playerpr[ev]"],
            "Play previous track",
            function (args) { player.previous(Math.max(args.count, 1)); },
            { count: true });

        commands.add(["players[top]"],
            "Stop track",
            function () { player.stop(); });

        commands.add(["see[k]"],
            "Seek to a track position",
            function (args) {
                let arg = args[0];

                // intentionally supports 999:99:99
                dactyl.assert(/^[+-]?(\d+[smh]?|(\d+:\d\d:|\d+:)?\d{2})$/.test(arg),
                    _("error.invalidArgument", arg));

                function ms(t, m) {
                    return Math.abs(parseInt(t, 10) * { s: 1000, m: 60000, h: 3600000 }[m]);
                }

                if (/:/.test(arg)) {
                    let [seconds, minutes, hours] = arg.split(":").reverse();
                    hours = hours || 0;
                    var value = ms(seconds, "s") + ms(minutes, "m") + ms(hours, "h");
                }
                else {
                    if (!/[smh]/.test(arg.substr(-1)))
                        arg += "s"; // default to seconds

                    value = ms(arg.substring(arg, arg.length - 1), arg.substr(-1));
                }

                if (/^[-+]/.test(arg))
                    arg[0] == "-" ? player.seekBackward(value) : player.seekForward(value);
                else
                    player.seekTo(value);

            },
            { argCount: "1" });

        commands.add(["mediav[iew]"],
            "Change the current media view",
            function (args) {
                // FIXME: is this a SB restriction? --djk
                dactyl.assert(SBGetBrowser().currentMediaPage,
                    "Exxx: Can only set the media view from the media tab"); // XXX

                let arg = args[0];

                if (arg) {
                    for ([, page] in Iterator(player.getMediaPages())) {
                        if (util.compareIgnoreCase(arg, page.contentTitle) == 0) {
                            player.loadMediaPage(page, SBGetBrowser().currentMediaListView.mediaList,
                                    SBGetBrowser().currentMediaListView);
                            return;
                        }
                    }
                    dactyl.echoerr(_("error.invalidArgument", arg));
                }
            }, {
                argCount: "1",
                completer: function (context) {
                    completion.mediaView(context);
                },
                literal: 0
            });

        commands.add(["sort[view]"],
                "Sort the current media view",
                function (args) {
                    player.sortBy(args[0], args["-order"] == "up");
                }, {
                    argCount: "1",
                    completer: function (context) {
                        completion.mediaListSort(context);
                    },
                    options: [
                        {
                            names: ["-order", "-o"], type: CommandOption.STRING,
                            default: "up",
                            description: "Specify the sorting order of the given field",
                            validator: function (arg) {
                                return /^(up|down)$/.test(arg);
                            },
                            completer: function () {
                                return [["up", "Sort in ascending order"], ["down", "Sort in descending order"]];
                            }
                        }
                    ]
                });

        // FIXME: use :add -q like cmus? (not very vim-like are it's multi-option commands) --djk
        commands.add(["qu[eue]"],
            "Queue tracks by artist/album/track",
            function (args) {
                let properties = services.MutablePropertyArray();

                // args
                switch (args.length) {
                case 3:
                    properties.appendProperty(SBProperties.trackName, args[2]);
                case 2:
                    properties.appendProperty(SBProperties.albumName, args[1]);
                case 1:
                    properties.appendProperty(SBProperties.artistName, args[0]);
                    break;
                default:
                    break;
                }

                let library = LibraryUtils.mainLibrary;
                let mainView = library.createView();
                gMM.sequencer.playView(mainView,
                        mainView.getIndexForItem(library.getItemsByProperties(properties).queryElementAt(0, Ci.sbIMediaItem)));
                player.focusPlayingTrack();
            }, {
                argCount: "+",
                completer: function (context, args) {
                    if (args.completeArg == 0)
                        completion.artist(context);
                    else if (args.completeArg == 1)
                        completion.album(context, args[0]);
                    else if (args.completeArg == 2)
                        completion.song(context, args[0], args[1]);
                }
            });

        // TODO: maybe :vol! could toggle mute on/off? --djk
        commands.add(["vol[ume]"],
            "Set the volume",
            function (args) {
                let arg = args[0];

                dactyl.assert(arg, _("error.argumentRequired"));
                dactyl.assert(/^[+-]?\d+$/.test(arg), _("error.trailingCharacters"));

                let level = parseInt(arg, 10) / 100;

                if (/^[+-]/.test(arg))
                    level = player.volume + level;

                player.volume = Math.constrain(level, 0, 1);
            },
            { argCount: "1" });
    },
    completion: function initCompletion() {
        completion.album = function album(context, artist) {
            context.title = ["Album"];
            context.completions = [[v, ""] for ([, v] in Iterator(library.getAlbums(artist)))];
        };

        completion.artist = function artist(context) {
            context.title = ["Artist"];
            context.completions = [[v, ""] for ([, v] in Iterator(library.getArtists()))];
        };

        completion.playlist = function playlist(context) {
            context.title = ["Playlist", "Type"];
            context.keys = { text: "name", description: "type" };
            context.completions = player.getPlaylists();
        };

        completion.mediaView = function mediaView(context) {
            context.title = ["Media View", "URL"];
            context.anchored = false;
            context.keys = { text: "contentTitle", description: "contentUrl" };
            context.completions = player.getMediaPages();
        };

        completion.mediaListSort = function mediaListSort(context) {
            context.title = ["Media List Sort Field", "Description"];
            context.anchored = false;
            context.completions = [["title", "Track name"], ["time", "Duration"], ["artist", "Artist name"],
                ["album", "Album name"], ["genre", "Genre"], ["rating", "Rating"]]; // FIXME: generate this list dynamically - see #sortBy
        };

        completion.song = function album(context, artist, album) {
            context.title = ["Song"];
            context.completions = [[v, ""] for ([, v] in Iterator(library.getTracks(artist, album)))];
        };
    },
    mappings: function initMappings() {
        mappings.add([modes.PLAYER],
            ["x"], "Play track",
            function () { ex.playerplay(); });

        mappings.add([modes.PLAYER],
            ["z"], "Previous track",
            function ({ count }) { ex.playerprev({ "#": count }); },
            { count: true });

        mappings.add([modes.PLAYER],
            ["c"], "Pause/unpause track",
            function () { ex.playerpause(); });

        mappings.add([modes.PLAYER],
            ["b"], "Next track",
            function ({ count }) { ex.playernext({ "#": count }); },
            { count: true });

        mappings.add([modes.PLAYER],
            ["v"], "Stop track",
            function () { ex.playerstop(); });

        mappings.add([modes.PLAYER],
            ["Q"], "Queue tracks by artist/album/track",
            function () { commandline.open(":", "queue ", modes.EX); });

        mappings.add([modes.PLAYER],
            ["f"], "Loads current view filtered by the keywords",
            function () { commandline.open(":", "filter ", modes.EX); });

        mappings.add([modes.PLAYER],
            ["i"], "Select current track",
            function () { gSongbirdWindowController.doCommand("cmd_find_current_track"); });

        mappings.add([modes.PLAYER],
            ["s"], "Toggle shuffle",
            function () { player.toggleShuffle(); });

        mappings.add([modes.PLAYER],
            ["r"], "Toggle repeat",
            function () { player.toggleRepeat(); });

        mappings.add([modes.PLAYER],
            ["h", ""], "Seek -10s",
            function ({ count} ) { player.seekBackward(Math.max(1, count) * 10000); },
            { count: true });

        mappings.add([modes.PLAYER],
            ["l", ""], "Seek +10s",
            function ({ count} ) { player.seekForward(Math.max(1, count) * 10000); },
            { count: true });

        mappings.add([modes.PLAYER],
            ["H", ""], "Seek -1m",
            function ({ count }) { player.seekBackward(Math.max(1, count) * 60000); },
            { count: true });

        mappings.add([modes.PLAYER],
            ["L", ""], "Seek +1m",
            function ({ count }) { player.seekForward(Math.max(1, count) * 60000); },
            { count: true });

        mappings.add([modes.PLAYER],
             ["=", "+"], "Increase volume by 5% of the maximum",
             function () { player.increaseVolume(); });

        mappings.add([modes.PLAYER],
             ["-"], "Decrease volume by 5% of the maximum",
             function () { player.decreaseVolume(); });

        mappings.add([modes.PLAYER],
             ["/"], "Search forward for a track",
             function () { player.CommandMode(modes.SEARCH_VIEW_FORWARD).open(); });

        mappings.add([modes.PLAYER],
             ["n"], "Find the next track",
             function () { player.searchViewAgain(false); });

        mappings.add([modes.PLAYER],
             ["N"], "Find the previous track",
             function () { player.searchViewAgain(true); });

        for (let i in util.range(0, 6)) {
            let (rating = i) {
                mappings.add([modes.PLAYER],
                     [""], "Rate the current media item " + rating,
                     function () {
                         let item = gMM.sequencer.currentItem || this._currentView.selection.currentMediaItem; // XXX: a bit too magic
                         if (item)
                             player.rateMediaItem(item, rating);
                         else
                             dactyl.beep();
                     }
                );
            };
        }
    },
    options: function initOptions() {
        options.add(["repeat"],
            "Set the playback repeat mode",
            "number", 0,
            {
                setter: function (value) {
                    return gMM.sequencer.repeatMode = value;
                },
                getter: function () { return gMM.sequencer.repeatMode; },
                completer: function () {
                    return [
                        ["0", "Repeat none"],
                        ["1", "Repeat one"],
                        ["2", "Repeat all"]
                    ];
                }
            });

        options.add(["shuffle"],
            "Play tracks in shuffled order",
            "boolean", false,
            {
                setter: function (value) {
                    return gMM.sequencer.mode = value ? gMM.sequencer.MODE_SHUFFLE : gMM.sequencer.MODE_FORWARD;
                },
                getter: function () {
                    return gMM.sequencer.mode == gMM.sequencer.MODE_SHUFFLE;
                }
            });
    }
});

// vim: set fdm=marker sw=4 sts=4 ts=8 et:
dactyl-1.2~r20151231/melodactyl/defaults/000077500000000000000000000000001264147376100200125ustar00rootroot00000000000000dactyl-1.2~r20151231/melodactyl/defaults/preferences/000077500000000000000000000000001264147376100223135ustar00rootroot00000000000000dactyl-1.2~r20151231/melodactyl/defaults/preferences/dactyl.js000066400000000000000000000004251264147376100241320ustar00rootroot00000000000000pref("extensions.dactyl.name", "melodactyl");
pref("extensions.dactyl.appName", "Melodactyl");
pref("extensions.dactyl.idName", "MELODACTYL");
pref("extensions.dactyl.fileExt", "melo");
pref("extensions.dactyl.host", "Songbird");
pref("extensions.dactyl.hostbin", "songbird");
dactyl-1.2~r20151231/melodactyl/install.rdf000066400000000000000000000017671264147376100203610ustar00rootroot00000000000000

    
        
            
                songbird@songbirdnest.com
                1.8.0
                1.9.*
            
        
    



dactyl-1.2~r20151231/melodactyl/locale/000077500000000000000000000000001264147376100174425ustar00rootroot00000000000000dactyl-1.2~r20151231/melodactyl/locale/en-US/000077500000000000000000000000001264147376100203715ustar00rootroot00000000000000dactyl-1.2~r20151231/melodactyl/locale/en-US/all.xml000066400000000000000000000005221264147376100216620ustar00rootroot00000000000000











dactyl-1.2~r20151231/melodactyl/locale/en-US/autocommands.xml000066400000000000000000000065111264147376100236100ustar00rootroot00000000000000







      
    
      BookmarkAdd
         
      Triggered after a page is bookmarked
      
    
      ColorScheme
         
      Triggered after a color scheme has been loaded
      
    
      DOMLoad
             
      Triggered when a page's DOM content has fully loaded
      
    
      DownloadPost
        
      Triggered when a download has completed
      
    
      Fullscreen
          
      Triggered when the player's fullscreen state changes
      
    
      LocationChange
      Triggered when changing tabs or when navigating to a new location
      
    
      PageLoadPre
         
      Triggered after a page load is initiated
      
    
      PageLoad
            
      Triggered when a page gets (re)loaded/opened
      
    
      ShellCmdPost
        
      Triggered after executing a shell command with :!#{cmd}
      
    
      TrackChangePre
      Triggered before a playing track is changed
      
    
      TrackChange
         
      Triggered after a playing track has changed
      
    
      ViewChangePre
       
      Triggered before a sequencer view is changed
      
    
      ViewChange
          
      Triggered after a sequencer view is changed
      
    
      StreamStart
         
      Triggered after a stream has started
      
    
      StreamPause
         
      Triggered after a stream has paused
      
    
      StreamEnd
           
      Triggered after a stream has ended
      
    
      StreamStop
          
      Triggered after a stream has stopped
      
    
      Enter
               
      Triggered after Songbird starts
      
    
      LeavePre
            
      Triggered before exiting Songbird, just before destroying each module
      
    
      Leave
               
      Triggered before exiting Songbird
      

      


      
    
      <url>
          
      The URL against which the event was selected.
      
    
      <title>
        
      The page, bookmark or download title.
      
    
      <doc>
          
      The document for which the event occurred. Only for DOMLoad, PageLoad and PageLoadPre.
      
    
      <tab>
          
      The tab in which the event occurred. Only for DOMLoad, PageLoad and PageLoadPre.
      
    
      <tags>
         
      The tags applied to <url>. Only for BookmarkAdd.
      
    
      <keyword>
      The keywords applied to the bookmark. Only for BookmarkAdd.
      
    
      <icon>
         
      The icon associated with <url>. Only for BookmarkAdd.
      
    
      <size>
         
      The size of a downloaded file. Only for DownloadPost.
      
    
      <file>
         
      The target destination of a download. Only for DownloadPost.
      
    
      <state>
        
      The new fullscreen state. Only for Fullscreen.
      
    
      <name>
         
      The color scheme name. Only for ColorScheme.
      
    
      <view>
         
      The new sequencer view. Only for ViewChangePre and ViewChange.
      
    
      <track>
        
      The new media track. Only for TrackChangePre, TrackChange and Stream.
      

      

      


dactyl-1.2~r20151231/melodactyl/locale/en-US/browsing.xml000066400000000000000000000005451264147376100227510ustar00rootroot00000000000000














dactyl-1.2~r20151231/melodactyl/locale/en-US/gui.xml000066400000000000000000000014571264147376100217060ustar00rootroot00000000000000







    :dpcl :dpclose
    :dpclose pane
    
        
      Close the specified display pane.
      
          
      


    :dpope :dpopen :dp :dpane :displayp :displaypane
    :displaypane pane
    
        
      
            Open the specified display pane. pane is any of
            "leftservice", "bottomservice", "bottomcontent" or "rightsidebar".
        
      
          
      

      


dactyl-1.2~r20151231/melodactyl/locale/en-US/intro.xml000066400000000000000000000122471264147376100222540ustar00rootroot00000000000000







      
    &dactyl.appName;
    is a free media player add-on for &dactyl.host;, which combines the best
    features of the CMus music
    player and the Vim text editor.

      



        
    
    
      1. 
        Starting &dactyl.appName;:
        How &dactyl.appName; starts up, where it reads the config file, etc.
    
        2. 
    
      2. 
        Player mode:
        Interacting with the media player.
    
        3. 
    
      3. 
        Browsing:
        Basic key mappings and commands needed for a browsing
        session (how to open a web page, go back in history, etc.)
    
        4. 
    
      4. 
        Buffer:
        Operations on the current document (scrolling, copying text,
        etc.)
    
        5. 
    
      5. 
        Command Line mode:
        Command-line editing.
    
        6. 
    
      6. 
        Editing text:
        Text area and input field editing.
    
        7. 
    
      7. 
        Options:
        A description of all options.
    
        8. 
    
      8. 
        Text search commands:
        Searching for text in the current buffer.
    
        9. 
    
      9. 
        Tabs:
        Managing your tabbed browsing session.
    
        10. 
    
      10. 
        Hints:
        Selecting hyperlinks and other page elements.
    
        11. 
    
      11. 
        Keyboard shortcuts and commands:
        Defining new key mappings, abbreviations and user commands.
    
        12. 
    
      12. 
        Expression evaluation:
        Executing JavaScript.
    
        13. 
    
      13. 
        Marks:
        Using bookmarks, QuickMarks, history and local marks.
    
        14. 
    
      14. 
        Repeating commands:
        Using macros to repeat recurring workflows.
    
        15. 
    
      15. 
        Automatic commands:
        Automatically executing code on certain events.
    
        16. 
    
      16. 
        Printing:
        Printing pages.
    
        17. 
    
      17. 
        &dactyl.appName;'s GUI:
        Accessing &dactyl.host; menus, dialogs and the display panels.
    
        18. 
    
      18. 
        Styling the GUI and web pages:
        Changing the styling of content pages and &dactyl.appName; itself.
    
        19. 
    
      19. 
        Error and informational messages:
        A description of informational and error messages.
    
        20. 
    
      20. 
        Developer information:
        How to write plugins and documentation.
    
        21. 
    
      21. 
        Various commands:
        Other help which doesn't readily fit into any other category.
    
        22. 
    
      22. 
        Plugins:
        Documentation for any plugins you have installed.
    
        23. 
    
      23. 
        Index:
        An index of all commands and options.
    
        24. 

      



        
    
      • Vim-like keybindings (h, j, gg, ZZ, , etc.)
        • 
    
      • Ex commands (:quit, :open www.foo.com, …)
        • 
    
      • Tab completion for all commands, highly configurable via wildmode, autocomplete, …
        • 
    
      • Hit-a-hint like navigation of links (start with f to follow a link)
        • 
    
      • Advanced completion of bookmark and history URLs
        • 
    
      • Vim-like status line with a Wget-like progress bar
        • 
    
      • Minimal GUI (easily hide superfluous menubar and toolbar with )
        • 
    
      • Ability to :source JavaScript, CSS, and &dactyl.appName; command files
        • 
    
      • Easy quick searches (see :open)
        • 
    
      • Count supported for many commands (3 will go back 3 pages)
        • 
    
      • Visual bell for errors (visualbell)
        • 
    
      • Marks support (ma to set mark a, 'a to jump to it)
        • 
    
      • QuickMark support
        • 
    
      • :map, :command, :normal, and macros
        • 
    
      • Editing of text fields with an external editor
        • 
    
      • AutoCommands to execute actions on certain events
        • 
    
      • A comprehensive help system, explaining all commands, mappings, options, and plugins
        • 

      

      


dactyl-1.2~r20151231/melodactyl/locale/en-US/map.xml000066400000000000000000000041641264147376100216750ustar00rootroot00000000000000







      
    
      abbreviation
       
      abbreviations
      
    
      altstyle
           
      alternate author style sheets
      
    
      bookmark
           
      bookmarks
      
    
      buffer
             
      buffers
      
    
      charset
            
      character sets
      
    
      color
              
      color schemes
      
    
      command
            
      Ex commands
      
    
      dialog
             
      &dactyl.host; dialogs
      
    
      displaypane
        
      display panes
      
    
      dir
                
      directories
      
    
      environment
        
      environment variables
      
    
      event
              
      autocommand events
      
    
      extension
          
      installed extensions
      
    
      file
               
      files
      
    
      help
               
      help tags
      
    
      highlight
          
      highlight groups
      
    
      history
            
      browsing history
      
    
      javascript
         
      JavaScript expressions
      
    
      macro
              
      named macros
      
    
      mapping
            
      user mappings
      
    
      mark
               
      local page marks
      
    
      mediaview
          
      media views
      
    
      mediasort
          
      media sort fields
      
    
      menu
               
      menu items
      
    
      option
             
      &dactyl.appName; options
      
    
      playlist
           
      play lists
      
    
      preference
         
      &dactyl.host; preferences
      
    
      qmark
              
      quick marks
      
    
      runtime
            
      runtime paths
      
    
      search
             
      search engines and keywords
      
    
      shellcmd
           
      shell commands
      
    
      song
               
      songs
      
    
      toolbar
            
      toolbars
      
    
      url
                
      URLs
      
    
      usercommand
        
      user commands
      
    
      custom,thing
      custom completion, provided by thing
      

      

      


dactyl-1.2~r20151231/melodactyl/locale/en-US/messages.properties000066400000000000000000000005651264147376100243240ustar00rootroot00000000000000player.preTrackChange-1 = Before track changed: %S
player.postTrackChange-1 = Track changed: %S
player.preViewChange-1 = Before view changed: %S
player.postViewChange-1 = View changed: %S
player.trackStart-1 = Track started: %S
player.trackPause-1 = Track paused: %S
player.trackEnd-1 = Track ended: %S
player.trackStop-1 = Track stopped: %S

# vim:se ft=jproperties tw=0:
dactyl-1.2~r20151231/melodactyl/locale/en-US/player.xml000066400000000000000000000165561264147376100224240ustar00rootroot00000000000000







      Player mode
      



      
    The following features apply to Player mode which is activated when the
    media tab has focus.

      


      Playing tracks
      


    p_x :playerp :playerplay
    :countplayerplay
    countx
    
        
      
            Play the current track.
        
      
          
      


    p_z :playerpr :playerprev
    :countplayerprev
    countz
    
        
      
            Play the previous track.
        
      
          
      


    p_b :playern :playernext
    :playernext
    b
    
        
      
            Play the next track.
        
      
          
      


    p_c :playerpa :playerpause
    :playerpause
    c
    
        
      
            Pause/unpause the current track.
        
      
          
      


    p_v :playerps :playerstop
    :playerpstop
    v
    
        
      
            Stop playing the current track.
        
      
          
      


    p_s
    s
    
        
      
            Toggle shuffle mode.
        
      
          
      


    p_r
    r
    
        
      
            Toggle repeat mode.
        
      
          
      


    p_i
    i
    
        
      
            Select the currently playing track.
        
      
          
      


      Queueing tracks
      


    p_Q :qu :queue
    :queue artist album track
    Q
    
        
      
            Queue tracks by artist/album/track. If only artist is
            specified then all tracks for that artist are played in album
            order. If album is also specified then all tracks for that
            album are played. A specific track can be specified with
            track.
        
      
          
      


      Filtering the library
      


    p_f :f :filter
    :filter keywords
    f
    
        
      
            Filter and show the tracks as a view. The tracks are filtered by
            the keywords provided as arguments. This text search applies
            over the default filter properties, namely: Genre, Artist, Album
            and Track.
        
      
          
      


      Seeking to a track position
      


     p_h]]>
    counth
    
        
      
            Seek +10s.
        
      
          
      


     p_l]]>
    countl
    
        
      
            Seek -10s.
        
      
          
      


     p_H]]>
    countH
    
        
      
            Seek +1m.
        
      
          
      


     p_L]]>
    countL
    
        
      
            Seek -1m.
        
      
          
      


    :see :seek
    :seek [HH:]MM:SS]
    :seek +time[hms] | -time[hms]
    
        
      
            Seek to an absolute or relative position in a track. The position
            can be given in seconds (s), minutes (m), or hours (h). If the unit
            is not specified then seconds is assumed. The position is absolute
            unless the value is prefixed with "-" or "+".
        
      
        
      
            Positions may also be specified in [HH:]MM:SS format.
        
      
          
      


      Adjusting the volume
      


    p_+ p_=
    +
    =
    
        
      
            Increase volume by 5% of the maximum.
        
      
          
      


    p_-
    -
    
        
      
            Decrease volume by 5% of the maximum.
        
      
          
      


    :vol :volume
    vol[ume] value
    vol[ume] +value | -value
    
        
      
            Set the player volume. value can be an absolute value
            between 0 and 100% or a relative value if prefixed with "-" or "+".
        
      
          
      


      Managing playlists
      


    :load
    :load playlist
    
        
      
            Load playlist. If no playlist is specified then the main
            library view is loaded.
        
      
          
      


      Changing media views
      


    :mediav :mediaview
    :mediavew view
    
        
      
            Change the media view to view. This can only be run when the
            media tab is the current tab.
        
      
          
      


      Search commands
      


    p_/
    /pattern
    
        
      
            Search forward for a track matching pattern in the visible
            media view.
        
      
          
      




    p_n
    n
    
        
      
            Find the next track. Repeats the last search. If the search hits
            BOTTOM of the view, it continues from TOP.
        
      
          
      


    p_N
    N
    
        
      
            Find the previous track. Repeats the last search in the opposite
            direction. If the search hits TOP of the view, it continues from
            BOTTTOM.
        
      
          
      


      Rating tracks
      


     p_ p_ p_ p_ p_]]>
    ]]>
    ]]>
    ]]>
    ]]>
    ]]>
    ]]>
    
        
      
            Rate the current track with N stars.
        
      
          
      

      


dactyl-1.2~r20151231/melodactyl/locale/en-US/tabs.xml000066400000000000000000000005261264147376100220470ustar00rootroot00000000000000













dactyl-1.2~r20151231/melodactyl/skin/000077500000000000000000000000001264147376100171475ustar00rootroot00000000000000dactyl-1.2~r20151231/melodactyl/skin/icon.png000066400000000000000000000007211264147376100206050ustar00rootroot00000000000000PNG


IHDR  szzsRGBbKGD	pHYs

B(xtIME:@QIDATXֱKQb@"eBb1D$bo!hac+D4I)`W(qcEjʶvLK`=b80M8[ܦD<~ֳ)|lDy3>JJJNATSj

Contributers:
  * Štěpán Němec

Inactive/former developers:
  * Viktor Kojouharov (Виктор Кожухаров)
  * Marco Candrian 
  * Daniel Bainton 
  * Konstantin Stepanov 
  * Tim Hammerquist 
  * Ted Pavlic 
  * janus_wel 
  * Martin Stubenschrott 
  * Conrad Irwin
  * anekos 
  * teramako 

Patches (in no special order):
  * Ruud Grosmann ('followhints' option)
  * Xie&Tian (multibyte support for hints, doc fixes)
  * Juergen Descher
  * Kazuo (count support for ctrl-^)
  * Daniel Schaffrath (;b support)
  * Dominik Meister (:b# support and other buffer related commands)
  * Lukas Mai
  * Guido Van Hoecke
  * Daniel Trstenjak (various things with hints)
  * M.Terada (suggest engines)
  * Muthu Kannan (ctrl-v support)
  * Lars Kindler (:buffer(s) functionality)
  * Lee Hinman (:open ./.. support)
  * Bart Trojanowski (Makefile)
  * Hannes Rist (:set titlestring support)
  * Nikolai Weibull ($PENTADACTYL_HOME)
  * Joseph Xu (supporting multiple top level windows better)
  * Raimon Grau Cuscó (document relationship navigation - ]], [[)
  * Ryan Zheng (ctrl-x/a support)
  * Dan Boger (:set online support)
  * Štěpán Němec (help copy-editing and favicon support)
  * Jarkko Oranen ('maxitems' option)
  * Gary Katsevman ('private' option)
  * Srinath Krishna (disable password field editing)
dactyl-1.2~r20151231/pentadactyl/Donors000066400000000000000000000050001264147376100175400ustar00rootroot000000000000002009:
* Francois-Xavier Gsell
* Ken Takano
* Daniel Bainton (web hosting for about a year - thanks a lot!)
* 渡邉 丈洋 (takehiro78)
* Tony Rein
* Daniel Bentsur
* Ganesh Hegde
* Elbert Hannah
* Oliver Schaefer (2nd donation this year, and largest one in 2009! - Thanks!)
* James Davis
* Gregg Archer
* James Henderson
* Hiroshi Okada
* Imron Alston
* Luke Wagner
* Deepan Gandhi
* Guilherme Freitas
* Robert Johnston
* Jim Aragon
* Norio Sugimoto
* Catatonic Recording
* Wataru Inoue (first one donating via addons.mozilla.org)
* Krishnakumar Subramanian
* Natan Zohar
* Frederic Hebert
* kursad karatas
* Thomas Svensen (the first donor who donated 3 times! (once every year))
* Máté Nagy
* Jessica Pavlin
* David Wolfe
* Sigurdur Finnsson
* Pixel G
* Joel Rosario
* Alvaro Novo
* Robert Heckel
* Daniel Collin
* Lucien Grondin
* Christoph Petzold
* Bjoern Steinbrink
* Erlend Hamberg
* Fabien Benetou
* Arvin Moezzi
* Calogero Lo Leggio
* Sapan Bhatia
* Gavin Sinclair
* Stephen Borchert
* Convolution
* Brian Hall
* Daniel Hahler
* Per-Henrik Lundblom
* David C Foor
* Oliver Schaefer
* Paul Moss
* Yongji Zhang
* Brian Peiris
* Peleg Michaeli ("Every hand revealed" from my amazon.de wishlist)
* InspireFocus
* Michael Fremont
* Kamil Dworakowski
* Jonathan Austin
* Steven Romanow

2008:
* John Baber
* Mark Orr
* George Lowell (biggest donor so far!)
* Keith Waclena
* Christopher Glazner
* Mats Vestin
* Berni Joss
* Peter Rufer
* Yann Le Du
* Wilson Bilkovich
* Galen Taylor
* Ben Hoffstein
* Luc St-Louis
* Robert Meerman
* Silvio Di Stefano
* Lance Feagan
* Alexander Klink
* Chaz McGarvey
* Jesse Hathaway
* Takayuki Tsukitani
* Victor Nemkov
* John Lusth
* Thomas Svensen
* Ryan McBride
* Brian Clark
* Gavin Gilmour
* Sivaraj Doddannan
* Michael Hrabanek
* Nigel McNie
* Ben Damm
* Anton Kovalenko
* Paulo Tanimoto
* Paul Sobey
* Olivier Guéry
* Dotan Cohen
* Daniel Schaffrath
* Sam Griffin
* Ivan Pantuyev
* Spike Spiegal
* Mark Hashimoto
* Anirudh Sanjeev
* Ted Pavlic
* Jacqueline Wegscheid
* Kashyap Paidimarri
* Gabriel Gellner
* Marco Candrian
* Ovidiu Curcan
* Ivo-Jose Jimenez-Ramos (2x)
* Andrew Pantyukhin
* Kurtis Rader

2007:
* Richard Terrell
* Benjamin Sergeant
* Frank Schiebel
* Cillian de Roiste (2x)
* David Thompson
* Christian Walther
* Ivo-Jose Jimenez-Ramos
* Robert Heckel
* Ramana Kumar
* Thomas Svensen
* Ian Taylor
* Albert Menkveld
* Nathan Saper
* Paulo Tanimoto
* Nigel McNie
* Richard Dooling
* Giuseppe Guida
* Stefan Krauth
* Robert Heckel
* Miron Tewfik
* Sjoerd Siebinga
* Ben Klemens
* Andrew Pantyukhin
dactyl-1.2~r20151231/pentadactyl/Makefile000066400000000000000000000004551264147376100200220ustar00rootroot00000000000000#### configuration

NAME          = pentadactyl

FIREFOX      ?= firefox
HOSTAPP      ?= $(FIREFOX)
PROFILEPATHS ?= "$$HOME/.mozilla/firefox" \
		"$$HOME/Library/Application Support/Firefox" \
		"$$APPDATA/Mozilla/Firefox/Profiles" \
		"$$AppData/Mozilla/Firefox/Profiles"

include ../common/Makefile
dactyl-1.2~r20151231/pentadactyl/NEWS000066400000000000000000000361541264147376100170660ustar00rootroot000000000000001.2pre:
    • Removed defunct 'PrivateMode' autocommand.
    • Removed 'jsdebugger' option.
    • Removed "venkman" from :dialog.

1.1:
    • Vim runtime files:
      - renamed :mksyntax to :mkvimruntime which now generates
        all Vim related files.
      - Vimball packages are no longer available.
    • Removed  and  mappings.
    • Added :private command.
    • Better per-window private browsing support.
    • Removed 'private' option.

1.0:
    • Extensive Firefox 4 support, including:
      - Fully restartless. Can now be installed, uninstalled,
        enabled, disabled, and upgraded without restarting Firefox.
        [b4]
      - Tabs in :buffer completions and listings are grouped
        by panorama groups. [b1]
      - Only visible tabs are considered in tab numbering,
        n_gt, n_gn, etc. [b1]
    • Performance improvements:
      - Improved startup time by a factor of 7. [b1]
      - Further improved startup time. [b6]
      - Significant completion speed improvements, especially for
        JavaScript. [b1]
    • Added site-local and script-local groups: [b6]
      - Added the :group command to define and select groups.
      - Added the -group flag to :abbreviate, :autocmd, :command,
        :map, :style, and friends.
      - Mappings and commands can now be bound to groups which
        execute only for certain websites.
      - Autocommands, commands, mappings, and styles are now
        automatically added to per-script groups so that most traces
        of a script can be easily purged.
    • Greatly improved private mode support and :sanitize command.
      - Full integration with Firefox data clearing dialogs. [b3]
      - Support for sanitizing items at shutdown. [b3]
      - Fine-grained control over what data is sanitized and for
        what timespan. [b1]
      - Support for sanitizing reference to particular hosts,
        everywhere from command-line and message history to option
        values and cookies. [b1]
    • New and much more powerful incremental search implementation.
      Improvements over the standard Firefox find include:
      - Starts at the cursor position in the currently selected
        frame, unlike Firefox, which always starts at the start of
        the first frame. [b1]
      - Returns the cursor and viewport to their original position
        on cancel. [b1]
      - Backtracks to the first successful match after pressing
        backspace. [b1]
      - Supports reverse incremental search. [b1]
      - Input boxes are not focused when matches are highlighted. [b1]
      - Crude regular expression search is supported. [b8]
      - New searches now start within the current viewport where possible. [b8]
    • Text editing improvements, including:
      - Added t_gu, t_gU, and v_o mappings. [b8]
      - Added t_ and t_ mappings. [b8]
      - Added o_c, o_d, and o_y mappings. [b8]
      - Added register and basic kill ring support, t_" and
        I_/I_ mappings, and :registers command. [b8]
      - Added operator modes and proper first class motion maps. [b8]
      - Improved undo support for most mappings. [b8]
    • General completion improvements
      - Greatly improved completion rendering performance, especially
        while scrolling. [b8]
      - Added c_, c_, c_, and c_ for scrolling
        the completion list in increments larger than one line. [b8]
      - Improved handling of asynchronous completions, including: [b8]
        + Pressing  after tabbing past the end of already received
          completions will execute the command after the desired result has
          arrived.
        + Tabbing past the end of available completions more reliably selects
          the desired completion when it is available.
        + Late arriving completion results no longer interfere with typing.
        + It is now possible to skip past the end of incomplete completion
          groups via the c_ and c_ keys.
      - JavaScript completion improvements, including: [b2]
        + The prototype of the function whose arguments are currently
          being typed is displayed during completion.
        + Non-enumerable global properties are now completed for the
          global object, including XMLHttpRequest and encodeURI.
      - The concept of completion contexts is now exposed to the user
        (see :contexts), allowing for powerful and fine-grained
        completion system customization. [b1]
    • Ex command parsing improvements, including:
      - Multiple Ex commands may now be separated by | [b1]
      - Commands can continue over multiple lines in RC files by
        prefixing the continuation lines with a \ [b3]
      - The \ character is no longer treated specially within single
        quotes, i.e., 'fo\o''bar' ⇒ fo\o'bar [b1]
    • IMPORTANT: Command script files now use the *.penta file extension. [b2]
    • IMPORTANT: Plugins are now loaded from the 'plugins/'
      directory in 'runtimepath' rather than 'plugin/'. [b1]
    • The command line is now hidden by default. Added c, C, and M to
      'guioptions'. [b4]
    • Hints mode improvements, including:
      - Added [;A] extended hint mode. [rc2]
      - Added [g;] continued extended hints mode, which allows
        selecting multiple hints. Removed ;F. [b1]
      - Hints are now updated after scrolling and window resizing. [b3]
      - [;s] now prompts for a filename on the command-line rather
        than in a dialog. [b5]
      - Added [;a] and [;S] modes for creating bookmarks and search keywords. [b4][b3]
      - Added 'hintkeys' option. [b2]
      - Added "transliterated" option to 'hintmatching'. [b1]
    • The external editor can now be configured to open to a given
      line number and column, used for opening source links and
      editing input fields with i_. See :h 'editor'. [b4]
    • Improved [macro-string] support, including automatic elision
      of optional elements, and array subscripts. [b4][b7]
    • Added -pentadactyl-remote command-line option. [b8]
    • Moved the smooth-scroll plugin to the core. [b8]
    • Improvements to marks:
      - Marks are now stored as line and column ordinals rather than percentages. [b8]
      - Marks now store the marked element and ensure its visibility when followed. [b8]
    • Mapping changes:
      - It's now possible to map keys in many more modes, including
        Hint, Multi-line Output, and Menu. [b4]
      -  and  now behave more like Vim. [b8]
      - n_G now uses 'linenumbers' to determine destination if possible. [b8]
      - Added n_s and n_S. [b8]
      - Added Operator mode for motion maps, per Vim. [b8]
      - Added site-specific mapping groups and related command
        changes. [b6]
      - Added 'timeout' and 'timeoutlen' options. [b6]
      - Added n_{, n_}, n_[ and n_] mappings. [b7]
      - Added n_g], n_[d and n_]d. [b8]
      - Added  to open the next mapping in a new tab. [b8]
      - Added  to execute a builtin mapping. [b6]
      - Added l and s to aid in the construction of
        macros. [b6]
      - Added  pseudo-key. [b6]
      - Removed the implicit page load delays during macro playback. [b6]
      - Added the base modes Base, Main, and Command which other
        modes inherit key bindings from. [b6]
    • Command changes:
      - :viusage, :optionusage and :exusage were replaced with :listkeys,
        :listoptions and :listcommands, providing more powerful and
        consistent interactive help facility (improvements include
        listing keys for modes other than Normal, filtering the output,
        and linking to source code definitions). [b4]
      - :downloads now opens a download list in the multi-line output
        buffer. Added -sort flag. [b6][b7]
      - :style now supports regexp site-filters on Firefox 6+. [b7]
      - :qa closes only the current window, per Vim. [b7]
      - Added :background command. [b8]
      - Removed :bwipeout and :bunload aliases. Changed :bdelete and
        :tabclose semantics slightly. The latter now only operates on
        visible tabs. [b8]
      - Added -id flag to :bmark command and changed updating semantics. [b8]
      - Added :exit command. [b7]
      - Added :dlclear command. [b7]
      - :extensions has been replaced with a more powerful :addons. [b6]
      - :javascript! now opens a Read Eval Print Loop. [b6]
      - Added -arg flag to :map. [b6]
      - Added -literal flag to :command. [b6]
      - Added :completions command. [b6]
      - Added :cookies command. [b3]
      - :extadd now supports remote URLs as well as local files on Firefox 4. [b2]
      - Added :if/:elseif/:else/:endif conditionals. [b3]
      - Added -charset and -post to :bmark. [b5]
      - Added -keyword, -tags, -title to :delbmarks. [b2]
      - Added :extrehash, :exttoggle, :extupdate, and :rehash commands. [b5]
      - :abclear, :comclear and :mapclear have been substituted by a bang now
        accepted by :unabbreviate, :delcommand and :unmap, respectively. [b6]
      - Added :feedkeys command. [b4]
      - Added -sort option to :history. [b4]
      - Added several new options, including -javascript, to :abbreviate and
        :map. [b2]
      - Added :mksyntax command to auto-generate Vim syntax files. [b4]
      - Added 's' and 'e' flags to :pageinfo command. [b7]
      - Added :pintab and :unpintab commands. [b7]
      - Extension manipulation commands, including :extenable, :extdisable,
        and :exttoggle, now accept a -types argument. [b7]
      - :tabmove now moves to the position of tab N, not after it.
        Without arguments it no longer moves the tab to the end of
        the list. [b7]
      - :open now only opens files beginning with /, ./, ../, or ~/ [b1]
      - :saveas now provides completions for default file names, and
        automatically chooses a filename when the save target is a
        directory. [b4]
      - :sidebar now accepts a ! flag to toggle the sidebar rather
        than open it unconditionally. [b6]
      - Added :write !cmd and :write >>file. [b3]
      - Added :yank command. [b3]
      - :delmarks, :marks and :qmarks now also accept ranges, same as
        :delqmarks. [b4]
      - :command now accepts comma-separated alternative command names. [b4]
      - :command -complete custom now also accepts a completions array, see
        :h :command-completion-custom. [b4]
      - Removed :beep. [b2]
      - Removed :edit, :tabedit, and :winedit aliases. [b2]
      - Removed :play. [b2]
    • Improvements to :style and :highlight:
      - Added -link flag to :highlight. [b4]
      - Added -agent flag to :style. [b2]
      - The -append flag now updates existing properties rather than
        simply appending its arguments to the previous value. [b4]
      - Active filters are now highlighted in :style listings. [b4]
      - :style-related commands now divide their completions between
        those active and inactive for the current site. [b4]
      - CSS property name completion is now available. [b4]
      - :delstyle, :styleenable, :styledisable and :styletoggle accept a !
        to operate on all styles. [b6]
      - Added Find highlighting group. [b7]
    • IMPORTANT option changes:
      - Option value quoting has changed. List options will
        no longer be split at quoted commas and the option name,
        operators, and = sign may no longer be quoted. This will
        break certain automatically-generated configuration files.
        See :help [stringlist]. [b2]
      - Boolean options no longer accept an argument. [b4]
      - 'cdpath' and 'runtimepath' no longer treat ",,"
        specially. Use "." instead. [b2]
      - 'complete' is now a [stringlist] rather than a [charlist]
        and supports native autocomplete providers. [b8]
      - 'extendedhinttags' is now a [regexpmap] rather than a
        string. [b2]
      - 'guioptions' default value has changed. [b4][b7]
      - 'hinttags' and 'extendedhinttags' now treat their values as
        CSS selectors by default. [b6]
      - 'incsearch', 'hlsearch', 'ignorecase', and 'smartcase' have
        been replaced with 'incfind', 'hlfind', and 'findcase'. [b4]
      - 'laststatus' has been replaced with the "s" flag in
        'guioptions'. [b4]
      - 'linksearch' has been removed.  The \l search modifier can
        still be used for this purpose. [b4]
      - 'loadplugins' is now a [regexplist] option rather than
        a boolean. [b2]
      - Made 'mapleader' an option rather than a :let variable. [b4]
      - Removed the 'mapleader' option. [rc2]
      - 'passkeys' is now a [sitemap] with key chain support rather
        than a [regexpmap]. [b6]
      - The precise format of 'sanitizeitems' has changed slightly. [b8]
      - 'showmode' is now a [regexplist]. [b6]
      - 'showstatuslinks' and 'showtabline' are now [string] options. [b4]
    • Other option changes:
      - Added [stringmap], [regexplist], and [regexpmap] option
        types. [b1]
      - Added [sitelist] and [sitemap] option types. [b6]
      - Added "bookmarks", "diverted", and "links" to 'activate'
        option. [b2]
      - Added 'altwildmode' and c_ command-line key binding. [b2]
      - Added 'autocomplete' option for specifying which completion
        groups should be auto-completed. [b2]
      - Added 'banghist' option. [b1]
      - Added 'cookies', 'cookieaccept', and 'cookielifetime' options. [b3]
      - Added 'downloadsort' option. [b7]
      - Added 'findflags' option. [b8]
      - Replaced 'focuscontent' with 'strictfocus'. [b1]
      - Made 'strictfocus' a [sitemap]. [b7]
      - 'complete' now defaults to "slf" but file completion only
        triggers when the URL begins as above. [b1]
      - Added 'jumptags' option. [b7]
      - Added 'linenumbers' option. [b8]
      - Added 's' flag to 'pageinfo' and changed default value. [b7]
      - Added 'passkeys' option. [b3]
      - Added 'passunknown' option. [b7]
      - Changed 'urlseparator' default value to "|". [b3]
      - Added "passwords", and "venkman" dialogs to :dialog. [b2][b8]
      - Added 'scrollsteps' and 'scrolltime' options. [b8]
      - Added 'spelllang' option. [b8]
      - Make 'showmode' a [stringlist] option. [b7]
      - Added 'wildanchor' option. [b2]
      - Added 'yankshort' option. [b8]
    • Added BookmarkChange, BookmarkRemove autocommands. [b2]
    • Removed the :source line at the end of files generated by
      :mkpentadactylrc. [b2]
    • n_gf now toggles between source and content view.
      The | key binding has been removed. [b1]
    • Page zoom information is now shown in the status bar, and
      change in zoom status no longer appears in :messages. [b1]
    • Added n_ZO, n_ZI, n_ZM, and n_ZR as aliases for n_zO, n_zI,
      n_zM, and n_zR. [b1]
    • Completion list now behaves better when the multi-line output
      window is displayed. [b1]
    • Major help system improvements:
      - Plugins may now provide full-fledged :help documentation. [b1]
      - Add basic plugin authorship documentation. [b1]
      - The help system is newly modularized and features significant
        updates, rewrites, and formatting improvements. [b1]
      - Added  to open the single, consolidated help page. [b5]

# vim:set ft=conf sts=2 sw=2 et fo=tcn2 tw=68:
dactyl-1.2~r20151231/pentadactyl/TODO000066400000000000000000000035211264147376100170470ustar00rootroot00000000000000Priority list:
1-9 as in Vim (9 = required for next release, 5 = would be nice, 1 = probably not)

ARCHITECTURE:
- Host docs on the website - is there even a documentation tool that
  can parse our source sensibly?

- unify the disgusting hodge podge of contract specification styles

BUGS:
- ;s saves the page rather than the image
- RC file is sourced once per window

FEATURES:
9 Add more tests.
9 clean up error message codes and document
9 option groups
9 global, window-local, tab-local, buffer-local, script-local groups
9 add [count] support to :b* and :tab* commands where missing
8 wherever possible: get rid of dialogs and ask console-like dialog questions
  or write error prompts directly on the webpage or with :echo()
8 add support for filename special characters such as %
8 :redir and 'verbosefile'
8 Add information to dactyl/HACKING file about testing and optimization
7 handle Print Preview 'mode' properly
7 describe-key command (prompt for a key and display its binding with documentation)
7 use ctrl-n/p in insert mode for word completion
7 make an option to disable session saving by default when you close Firefox
7 :grep support (needs location list)
6 :mksession
6 check/correct spellings in insert mode with some mappings
6 add more autocommands (TabClose, TabOpen, TabChanged etc)
6 Use ctrl-w+j/k/w to switch between sidebar, content, preview window
6 ;? should show more information
5 when looking at a zoomed out image (because it's large), zi should zoom in
  maybe with this? : http://mxr.mozilla.org/seamonkey/source/content/html/document/public/nsIImageDocument.idl
3 A format for 'guitablabel' and 'statusline'
3 add a command-line window (:help cmdline-window in Vim).
3 Splitting Windows with [:sp :vsp ctrl-w,s ctrl-w,v] and closing with [ctrl-w,q], moving with [ctrl-w,w or tab]
  have a look into the split browser extension
dactyl-1.2~r20151231/pentadactyl/bootstrap.js000077700000000000000000000000001264147376100250022../common/bootstrap.jsustar00rootroot00000000000000dactyl-1.2~r20151231/pentadactyl/chrome.manifest000077700000000000000000000000001264147376100260662../common/chrome.manifestustar00rootroot00000000000000dactyl-1.2~r20151231/pentadactyl/components/000077500000000000000000000000001264147376100205435ustar00rootroot00000000000000dactyl-1.2~r20151231/pentadactyl/components/commandline-handler.js000077700000000000000000000000001264147376100353372../../common/components/commandline-handler.jsustar00rootroot00000000000000dactyl-1.2~r20151231/pentadactyl/config.json000066400000000000000000000073261264147376100205260ustar00rootroot00000000000000{
    "name": "pentadactyl",
    "appName": "Pentadactyl",
    "idName": "PENTADACTYL",
    "host": "Firefox",
    "hostbin": "firefox",

    "module-paths": [
        "resource://dactyl/"
    ],

    "resources": {
        "dactyl":             "../common/modules/",
        "dactyl-common":      "../common/",
        "dactyl-content":     "../common/content/",
        "dactyl-skin":        "../common/skin/",
        "dactyl-locale":      "../common/locale/",

        "dactyl-local":         "./",
        "dactyl-local-content": "content/",
        "dactyl-local-skin":    "skin/",
        "dactyl-local-locale":  "locale/"
    },

    "components": {
        "{16dc34f7-6d22-4aa4-a67f-2921fb5dcb69}": {
            "path": "components/commandline-handler.js",
            "contract": "@mozilla.org/commandlinehandler/general-startup;1?type=dactyl",
            "categories": {
                "command-line-handler": "m-dactyl"
            }
        }
    },

    "autocommands": {
        "BookmarkAdd":      "Triggered after a page is bookmarked",
        "BookmarkChange":   "Triggered after a page's bookmark is changed",
        "BookmarkRemove":   "Triggered after a page's bookmark is removed",
        "ColorScheme":      "Triggered after a color scheme has been loaded",
        "DOMLoad":          "Triggered when a page's DOM content has fully loaded",
        "DownloadPost":     "Triggered when a download has completed",
        "Fullscreen":       "Triggered when the browser's fullscreen state changes",
        "LocationChange":   "Triggered when changing tabs or when navigation to a new location",
        "PageLoadPre":      "Triggered after a page load is initiated",
        "PageLoad":         "Triggered when a page gets (re)loaded/opened",
        "Sanitize":         "Triggered when a sanitizeable item is cleared",
        "ShellCmdPost":     "Triggered after executing a shell command with :!cmd",
        "Enter":            "Triggered after Firefox starts",
        "LeavePre":         "Triggered before exiting Firefox, just before destroying each module",
        "Leave":            "Triggered before exiting Firefox"
    },

    "option-defaults": {
        "complete":     "search,location,file",
        "guioptions":   "bCrs",
        "showtabline":  "always",
        "titlestring":  "Pentadactyl"
    },

    "features": [
        "sanitizer",
        "windows"
    ],

    "guioptions": {
        "m": ["Menubar",      ["toolbar-menubar"]],
        "T": ["Toolbar",      ["nav-bar"]],
        "B": ["Bookmark bar", ["PersonalToolbar"]]
    },

    "overlays": {
        "chrome://browser/content/browser.xul": {
            "completers": {
                "sidebar": "sidebar",
                "window": "window"
            },

            "features": [
                "bookmarks",
                "hints",
                "history",
                "marks",
                "quickmarks",
                "session",
                "tabbrowser",
                "tabs",
                "tabs_undo"
            ],

            "ids": {
                "command-container": "browser-bottombox"
            },

            "scripts": [
                "browser",
                "bookmarkcache",
                "bookmarks",
                "history",
                "quickmarks",
                "sanitizer",
                "tabs"
            ]
        }
    },

    "sidebars": {
        "viewAddons":       ["Add-ons",     "A", "chrome://mozapps/content/extensions/extensions.xul"],
        "viewConsole":      ["Console",     "C", "chrome://global/content/console.xul"],
        "viewDownloads":    ["Downloads",   "D", "chrome://mozapps/content/downloads/downloads.xul"],
        "viewPreferences":  ["Preferences", "P", "about:config"]
    }
}
dactyl-1.2~r20151231/pentadactyl/content/000077500000000000000000000000001264147376100200305ustar00rootroot00000000000000dactyl-1.2~r20151231/pentadactyl/content/config.js000066400000000000000000000260431264147376100216400ustar00rootroot00000000000000// Copyright (c) 2006-2009 by Martin Stubenschrott 
// Copyright (c) 2007-2011 by Doug Kearns 
// Copyright (c) 2008-2015 by Kris Maglione 
//
// This work is licensed for reuse under an MIT license. Details are
// given in the LICENSE.txt file included with this file.
"use strict";

var Config = Module("config", ConfigBase, {
    Local: function Local(dactyl, modules, window) {
        return {

            dialogs: {
                about: ["About Firefox",
                    () => { window.openDialog("chrome://browser/content/aboutDialog.xul", "_blank", "chrome,dialog,modal,centerscreen"); }],
                addbookmark: ["Add bookmark for the current page",
                    () => { window.PlacesCommandHook.bookmarkCurrentPage(true, window.PlacesUtils.bookmarksRootId); }],
                addons: ["Manage Add-ons",
                    () => { window.BrowserOpenAddonsMgr(); }],
                bookmarks: ["List your bookmarks",
                    () => { window.openDialog("chrome://browser/content/bookmarks/bookmarksPanel.xul", "Bookmarks", "dialog,centerscreen,width=600,height=600"); }],
                checkupdates: ["Check for updates",
                    () => { window.checkForUpdates(); },
                    () => "checkForUpdates" in window],
                cookies: ["List your cookies",
                    () => { window.toOpenWindowByType("Browser:Cookies", "chrome://browser/content/preferences/cookies.xul", "chrome,dialog=no,resizable"); }],
                console: ["Browser console",
                    () => { window.HUDService.toggleBrowserConsole(); }],
                customizetoolbar: ["Customize the Toolbar",
                    () => { window.BrowserCustomizeToolbar(); }],
                dominspector: ["DOM Inspector",
                    () => { window.inspectDOMDocument(window.content.document); },
                    () => "inspectDOMDocument" in window],
                downloads: ["Manage Downloads",
                    () => { window.BrowserDownloadsUI(); }],
                history: ["List your history",
                    () => { window.openDialog("chrome://browser/content/history/history-panel.xul", "History", "dialog,centerscreen,width=600,height=600"); }],
                openfile: ["Open the file selector dialog",
                    () => { window.BrowserOpenFileWindow(); }],
                pageinfo: ["Show information about the current page",
                    () => { window.BrowserPageInfo(); }],
                pagesource: ["View page source",
                    () => { window.BrowserViewSourceOfDocument(window.content.document); }],
                passwords: ["Passwords dialog",
                    () => { window.openDialog("chrome://passwordmgr/content/passwordManager.xul"); }],
                places: ["Places Organizer: Manage your bookmarks and history",
                    () => { window.PlacesCommandHook.showPlacesOrganizer(window.ORGANIZER_ROOT_BOOKMARKS); }],
                preferences: ["Show Firefox preferences dialog",
                    () => { window.openPreferences(); }],
                printpreview: ["Preview the page before printing",
                    () => { window.PrintUtils.printPreview(window.PrintPreviewListener || window.onEnterPrintPreview, window.onExitPrintPreview); }],
                printsetup: ["Setup the page size and orientation before printing",
                    () => { window.PrintUtils.showPageSetup(); }],
                print: ["Show print dialog",
                    () => { window.PrintUtils.print(); }],
                saveframe: ["Save frame to disk",
                    () => { window.saveFrameDocument(); }],
                savepage: ["Save page to disk",
                    () => { window.saveDocument(window.content.document); }],
                searchengines: ["Manage installed search engines",
                    () => { window.openDialog("chrome://browser/content/search/engineManager.xul", "_blank", "chrome,dialog,modal,centerscreen"); }],
                selectionsource: ["View selection source",
                    () => { modules.buffer.viewSelectionSource(); }]
            },

            get toolbars() {
                let navbar = window.document.getElementById("nav-bar");
                return window.getTogglableToolbars().concat(navbar);
            },

            removeTab: function removeTab(tab) {
                if (window.gInPrintPreviewMode)
                    window.PrintUtils.exitPrintPreview();
                else if (this.tabbrowser.mTabs.length > 1)
                    this.tabbrowser.removeTab(tab);
                else {
                    if (modules.buffer.uri.spec !== "about:blank" || window.getWebNavigation().sessionHistory.count > 0) {
                        dactyl.open("about:blank", dactyl.NEW_BACKGROUND_TAB);
                        this.tabbrowser.removeTab(tab);
                    }
                    else
                        dactyl.beep();
                }
            }
        };
    }
}, {
}, {
    commands: function initCommands(dactyl, modules, window) {
        const { commands, completion, config } = modules;
        const { document } = window;

        commands.add(["winon[ly]"],
            "Close all other windows",
            function () {
                dactyl.windows.forEach(function (win) {
                    if (win != window)
                        win.close();
                });
            },
            { argCount: "0" });

        commands.add(["pref[erences]", "prefs"],
            "Show " + config.host + " preferences",
            function (args) {
                if (args.bang) // open Firefox settings GUI dialog
                    dactyl.open("about:config", { from: "prefs" });
                else
                    window.openPreferences();
            },
            {
                argCount: "0",
                bang: true
            });

        commands.add(["sbcl[ose]"],
            "Close the sidebar window",
            function () {
                if (!document.getElementById("sidebar-box").hidden)
                    window.toggleSidebar();
            },
            { argCount: "0" });

        commands.add(["sideb[ar]", "sb[ar]", "sbop[en]"],
            "Open the sidebar window",
            function (args) {
                function compare(a, b) {
                    return util.compareIgnoreCase(a, b) == 0;
                }
                let title = document.getElementById("sidebar-title");

                dactyl.assert(args.length || title.value || args.bang && config.lastSidebar,
                              _("error.argumentRequired"));

                if (!args.length)
                    return window.toggleSidebar(title.value ? null : config.lastSidebar);

                // focus if the requested sidebar is already open
                if (compare(title.value, args[0])) {
                    if (args.bang)
                        return window.toggleSidebar();
                    return dactyl.focus(document.getElementById("sidebar-box"));
                }

                let menu = document.getElementById("viewSidebarMenu");

                for (let panel of menu.childNodes)
                    if (compare(panel.getAttribute("label"), args[0])) {
                        let elem = document.getElementById(panel.observes);
                        if (elem)
                            elem.doCommand();
                        return;
                    }

                return dactyl.echoerr(_("error.invalidArgument", args[0]));
            }, {
                argCount: "?",
                bang: true,
                completer: function (context) {
                    context.ignoreCase = true;
                    completion.sidebar(context);
                },
                literal: 0
            });

        commands.add(["wind[ow]"],
            "Execute a command and tell it to output in a new window",
            function (args) {
                dactyl.withSavedValues(["forceTarget"], function () {
                    this.forceTarget = dactyl.NEW_WINDOW;
                    this.execute(args[0], null, true);
                });
            }, {
                argCount: "1",
                completer: function (context) { completion.ex(context); },
                literal: 0,
                subCommand: 0
            });

        commands.add(["winc[lose]", "wc[lose]"],
            "Close window",
            function () { window.close(); },
            { argCount: "0" });

        commands.add(["wino[pen]", "wo[pen]"],
            "Open one or more URLs in a new window",
            function (args) {
                if (args[0])
                    dactyl.open(args[0], dactyl.NEW_WINDOW);
                else
                    dactyl.open("about:blank", dactyl.NEW_WINDOW);
            }, {
                completer: function (context) { completion.url(context); },
                domains: function (args) {
                    return commands.get("open").domains(args);
                },
                literal: 0,
                privateData: true
            });
    },
    completion: function initCompletion(dactyl, modules, window) {
        const { completion } = modules;
        const { document } = window;

        completion.location = function location(context) {
            completion.autocomplete("history", context);
            context.title = ["Smart Completions"];
        };

        completion.addUrlCompleter("location",
            "Firefox location bar entries (bookmarks and history sorted in an intelligent way)",
            completion.location);

        completion.sidebar = function sidebar(context) {
            let menu = document.getElementById("viewSidebarMenu");
            context.title = ["Sidebar Panel"];
            context.completions = Array.filter(menu.childNodes, n => n.hasAttribute("label"))
                                       .map(n => [n.getAttribute("label"), ""]);
        };
    },
    events: function initEvents(dactyl, modules, window) {
        modules.events.listen(window, "SidebarFocused", event => {
            modules.config.lastSidebar = window.document.getElementById("sidebar-box")
                                               .getAttribute("sidebarcommand");
        }, false);
    },
    mappings: function initMappings(dactyl, modules, window) {
        const { Events, mappings, modes } = modules;
        mappings.add([modes.NORMAL],
                     ["", "", ""],
                     "Handled by " + config.host,
                     () => Events.PASS_THROUGH);
    },
    options: function initOptions(dactyl, modules, window) {
        modules.options.add(["online"],
            "Enables or disables offline mode",
            "boolean", true,
            {
                setter: function (value) {
                    if (services.io.offline == value)
                        window.BrowserOffline.toggleOfflineStatus();
                    return value;
                },
                getter: function () { return !services.io.offline; }
            });
    }
});

// vim: set fdm=marker sw=4 sts=4 ts=8 et:
dactyl-1.2~r20151231/pentadactyl/content/logo.png000066400000000000000000000071131264147376100215000ustar00rootroot00000000000000PNG


IHDRYLsRGB	pHYs	(tIME	
5
IDATx{US˜(k 2$#TaŒW1yiLyEF^c$Ɣ|"Gz%%=~kq{g|޻k^WTH "r4(Bu>dH=p-@}Wկ<7Dq|uNFT 
-2ܿx'AUȱ@%΁vs	!Fj?J&D1ىJ
XkR}c7í{Ɋ6
x2UBmdz`pY=@k`m\fGAC,ʈ|)TDQQEbrB
=`\p|vt0m!oMTK1"TnI666jc~Wŝ…3(MpΦ6دWlM;g!y~CB
γVtN8MB8Caȓ1@;Ni{#]uZ6="|3jtA`~EBduZTA8_DZ6fMլIMbfȇ&ih
."=|ntu x0L7-'	A3.O3,swӴ,)4C* 7:UhvWٮSh4}t+SC!_XFwEߟXf,-F=+11lSGSD2ɴ|NZ>MU;ך$b{28_Vi])xƾ.E$gvg" "M)E8iTN7˵[kUuu.`
ýΓ?p^xXD
4'g	ꀐ^E9U""dך-ߪǪ:AU6`iC⤳
E`WUꗪz=&-hsOwϡIQU<+"
+T(s=[LS0Ej#N6lqN	`)0[D:9!&p
E,t3TuYx}lM!^M:$3m|Ѽ8\-rx06&qo&uH6vJ[dp\{u/ȡOdrM/R끭
ʀihYa΁VW/\}BA{ۨtzݞ9Svk"p\qͼ_쯪_xeIkUu\JsEd?,zU]UJM'pO;a4SC^om#%ًp^]ֻAJU,+$y<|c3lRfa
c,{
[8^amP{"uoXQC."ұcG'yY^\pWկJE7`׳u4T8ےs$P0x}Ui.T=Tuy+Uо+^E{
NvV[o?jRIxcӆ7xELKJݧj\EѾͧ1hlgj!0]U'-O	fޠn_Je㋻JDNKUJ[`"|iDX3J}_XWb:̇'$6yN6mb_[T
׌Os{w)ǖ7.‚bLE4%^\cKm[0?8'MC`T}{ӹǬz.ͮsxVr%Ω6	6t}DžFe#p\CRKGztxusLP3.gtAޫ|E˭K,"=DdlzӺ¤&]EdLu/=Vg	ծ8#ťU}ړ5}-_@w2M)לp+)&g$;Ŧs"ͨ8{{H 'UV58g6c
Qq
mpٕlak"arIǝz
z!OCq~U;|h,8݄22Ao+gө5"GDfF	o
ɦzNGJ?ٕ?̳,uj(wD\pp.)wD)2ԯOC)7PcS7kHrЩc,<+]D:W0pyOG&@,+.FM[8@DP\^goQ`ASn{ywBf1Pa
8>-"'~.&"2
R͂!.ljCjp9pDZ^V"04_eĺ<27zf\&N[i9l9ED6ksƼC>K,X?\MK(Fk	we=/MwCi~rڣ鮹t4mЦCs5yXy4:qGS~E5$*g]qH NxAWa48ߖAk{z(11;V;*'}nua
7	?h4xMb5#|A4iѩUZ`g<]8.zM斸>,$b_Mtaw\EC!X5 0&P؈Bzx34bԗ@
>ł&qql1|3b|I/Re/JM
ȩ|ݬOҔMAtAM4Y?_L}ȦED9c:+v-륵#\R_'Ch7:y j|g	O#0ə4F;2?zVf?6ڑESb4VG+%؀t,,{|ȱؼAx=-
NsrYNF{z?$*m	dԂq˩ܶS-atqQB!PThSJG3SL^Eph21/=~}IENDB`dactyl-1.2~r20151231/pentadactyl/icon16.png000066400000000000000000000007201264147376100201620ustar00rootroot00000000000000PNG


IHDRasRGBbKGD	pHYsuu-xutIME	
3iPIDAT8˕ϋaWLrŔŊ)EK1,VvVv6d7;K%	5I,̍e0_żWw4O:缧y^In;D_Mn4[ꫛҏ=TځK8[Ttj$y4;v(N~ jUm$_\UD͖"3~cmUuxT
p`/W߮VUڞxUq
%Wˣu8CtS_}S",'%Ymx:>tl8@`Gva.IA2¨puVJZOְЧēMc*lIENDB`dactyl-1.2~r20151231/pentadactyl/icon64.png000066400000000000000000000025231264147376100201700ustar00rootroot00000000000000PNG


IHDR@@iqsRGBbKGD	pHYs11#itIME	&IDATx]UU߹3e&	RYTeWQD`=Z}(I_Eaf6YfS#|oΝ{3;8w^{kbrc_[m6PQseYlJxW_6[ MvNa\l6 S
IIYCTNC"ҨvQv8 @Օ>T.OK0])ٓ)fUaLaD	c0؇OzqV=Gč}(޸­ßc'М&=޵ڃE"mc#3$hp(J00~/̌:`mt`$nMmPxuG"=S@?Wh'W/P a6&d)L$Ђ8gƔ
`KLݥBS6
pFYn(2|HƔ
.%.FWŔ-G>B&
c_%Yt	HM\ne-06M|:/b}{q]7!?!np(nyWyg9-@c	fPg"S͏kX^N$0^߆nU\8
h]5<*NgvrNi5,s6i32gKÅ9HZ`-cҼ9XTwfzBz$c+B#[B0G	n"w5ؚ Eg2h1yhdvL|G
hg{;@JItE^X.sG7TU3ÑŖ'=܋Qe"#
$5hCg&rer[բ:2*tZ]vbO0CNEֶlc	E	W@w[oߩS)y|GiPG/B1y.|PUj̵M~2$32l	ƚ'Pcw9QӇ"xLXQΤEEnݗ͡3tg	.] UrMshT9զNh(iC@=4;qQ%U6f`Zܮv(,ׯ	Ӓ@v'

    

        Kris Maglione, Doug Kearns
        Kris Maglione
        Doug Kearns

        anekos
        teramako
        Viktor Kojouharov (Виктор Кожухаров)
        Marco Candrian
        Daniel Bainton
        Konstantin Stepanov
        Tim Hammerquist
        Ted Pavlic
        janus_wel
        Martin Stubenschrott
        Conrad Irwin
        Štěpán Němec

        
            
        
    



dactyl-1.2~r20151231/pentadactyl/locale/000077500000000000000000000000001264147376100176155ustar00rootroot00000000000000dactyl-1.2~r20151231/pentadactyl/locale/en-US/000077500000000000000000000000001264147376100205445ustar00rootroot00000000000000dactyl-1.2~r20151231/pentadactyl/locale/en-US/all.xml000066400000000000000000000005251264147376100220400ustar00rootroot00000000000000











dactyl-1.2~r20151231/pentadactyl/locale/en-US/autocommands.xml000066400000000000000000000063351264147376100237670ustar00rootroot00000000000000







      
    
      BookmarkAdd
             
      Triggered after a page is bookmarked
      
    
      BookmarkChange
          
      Triggered after a page's bookmark is changed
      
    
      BookmarkRemove
          
      Triggered after a page's bookmark is removed
      
    
      ColorScheme
             
      Triggered after a color scheme has been loaded
      
    
      DOMLoad
                 
      Triggered when a page's DOM content has fully loaded
      
    
      DownloadPost
            
      Triggered when a download has completed
      
    
      Fullscreen
              
      Triggered when the browser's fullscreen state changes
      
    
      LocationChange
          
      Triggered when changing tabs or when navigating to a new location
      
    
      PageLoadPre
             
      Triggered after a page load is initiated
      
    
      PageLoad
                
      Triggered when a page gets (re)loaded/opened
      
    
      Sanitize
                
      Triggered when private data are sanitized
      
    
      ShellCmdPost
            
      Triggered after executing a shell command with :!cmd
      
    
      Enter
                   
      Triggered after &dactyl.host; starts
      
    
      LeavePre
                
      Triggered before exiting &dactyl.host;, just before destroying each module
      
    
      Leave
                   
      Triggered before exiting &dactyl.host;
      

      


      
    
      <bookmark>
        
      The JavaScript bookmark object. Only for Bookmark*.
      
    
      <changed>
         
      The name of the property that has changed. Only for BookmarkChange.
      
    
      <doc>
             
      The document for which the event occurred. Only for DOMLoad, PageLoad and PageLoadPre.
      
    
      <file>
            
      The target destination of a download. Only for DownloadPost.
      
    
      <icon>
            
      The icon associated with <url>. Only for Bookmark*.
      
    
      <keyword>
         
      The keywords applied to the bookmark. Only for BookmarkChange, BookmarkRemove.
      
    
      <name>
            
      The name of the item. Only for ColorScheme and Sanitize.
      
    
      <size>
            
      The size of a downloaded file. Only for DownloadPost.
      
    
      <state>
           
      The new state. Only for Fullscreen.
      
    
      <tab>
             
      The tab in which the event occurred. Only for DOMLoad, PageLoad and PageLoadPre.
      
    
      <tags>
            
      The tags applied to <url>. Only for Bookmark*.
      
    
      <title>
           
      The page, bookmark or download title.
      
    
      <url>
             
      The URL against which the event was selected.
      
    
      <win>
             
      The window for which the event occurred. Only for DOMLoad, PageLoad and PageLoadPre.
      

      

      


dactyl-1.2~r20151231/pentadactyl/locale/en-US/intro.xml000066400000000000000000000134711264147376100224270ustar00rootroot00000000000000







      
    &dactyl.appName; is a
    free browser add-on for &dactyl.host;, designed to make browsing more
    efficient and especially more keyboard accessible. Largely inspired by the
    Vim text editor, the appearance
    and finger feel should be familiar to Vim users.

      


        
    
      1. 
        Quick-start tutorial:
        A quick-start tutorial for new users.
    
        2. 
    
      2. 
        Starting &dactyl.appName;:
        How &dactyl.appName; starts up, where it reads the config file, etc.
    
        3. 
    
      3. 
        Browsing:
        Basic key mappings and commands needed for a browsing
        session (how to open a web page, go back in history, etc.)
    
        4. 
    
      4. 
        Buffer:
        Operations on the current document (scrolling, copying text,
        etc.)
    
        5. 
    
      5. 
        Command Line mode:
        Command-line editing.
    
        6. 
    
      6. 
        Editing text:
        Text area and input field editing.
    
        7. 
    
      7. 
        Options:
        A description of all options.
    
        8. 
    
      8. 
        Text search commands:
        Searching for text in the current buffer.
    
        9. 
    
      9. 
        Tabs:
        Managing your tabbed browsing session.
    
        10. 
    
      10. 
        Hints:
        Selecting hyperlinks and other page elements.
    
        11. 
    
      11. 
        Keyboard shortcuts and commands:
        Defining new key mappings, abbreviations and user commands.
    
        12. 
    
      12. 
        Expression evaluation:
        Executing JavaScript.
    
        13. 
    
      13. 
        Marks:
        Using bookmarks, QuickMarks, history and local marks.
    
        14. 
    
      14. 
        Repeating commands:
        Using macros to repeat recurring workflows.
    
        15. 
    
      15. 
        Automatic commands:
        Automatically executing code on certain events.
    
        16. 
    
      16. 
        Printing:
        Printing pages.
    
        17. 
    
      17. 
        &dactyl.appName;'s GUI:
        Accessing &dactyl.host; menus, dialogs and the sidebar.
    
        18. 
    
      18. 
        Styling the GUI and web pages:
        Changing the styling of content pages and &dactyl.appName; itself.
    
        19. 
    
      19. 
        Error and informational messages:
        A description of informational and error messages.
    
        20. 
    
      20. 
        Privacy and sensitive information:
        How to manage your private data while browsing.
    
        21. 
    
      21. 
        Developer information:
        How to write plugins and documentation.
    
        22. 
    
      22. 
        Various commands:
        Other help which doesn't readily fit into any other category.
    
        23. 
    
      23. 
        Plugins:
        Documentation for any plugins you have installed.
    
        24. 
    
      24. 
        FAQ:
        Frequently asked questions.
    
        25. 
    
      25. 
        Version information:
        A detailed list of differences between each of the released versions of
        &dactyl.appName;.
    
        26. 
    
      26. 
        Index:
        An index of all commands and options.
    
        27. 

      


        
    
      • Vim-like key bindings (h, j, gg, ZZ, , etc.)
        • 
    
      • Ex commands (:quit, :open www.foo.com, …)
        • 
    
      • Powerful tab completion for all commands and options
        • 
    
      • Powerful privacy features
        • 
    
      • Page search with many fixes for long-standing Firefox annoyances
        • 
    
      • Quick and powerful keyboard navigation for links, input fields, etc.
        • 
    
      • Vim-like status line
        • 
    
      • Keyboard macros, along with custom key mappings and commands
        • 
    
      • Minimal GUI, along with commands to hide and toggle toolbars and menus
        • 
    
      • Ability to :source JavaScript, CSS, and &dactyl.appName; command files
        • 
    
      • Ability to mark the current page position and return to it
        • 
    
      • Count support for many commands (3 will go back 3 pages)
        • 
    
      • Visual bell for errors (visualbell)
        • 
    
      • Marks support (mM to set mark M, 'M to jump to it)
        • 
    
      • QuickMark support
        • 
    
      • Editing of text fields with an external editor
        • 
    
      • AutoCommands to execute actions on certain events
        • 
    
      • A comprehensive help system, explaining all commands, mappings, options, and plugins
        • 

      
      


dactyl-1.2~r20151231/pentadactyl/locale/en-US/map.xml000066400000000000000000000040061264147376100220430ustar00rootroot00000000000000







      
    
      abbreviation
       
      abbreviations
      
    
      altstyle
           
      alternate author style sheets
      
    
      bookmark
           
      bookmarks
      
    
      buffer
             
      buffers
      
    
      charset
            
      character sets
      
    
      color
              
      color schemes
      
    
      command
            
      Ex commands
      
    
      dialog
             
      &dactyl.host; dialogs
      
    
      dir
                
      directories
      
    
      environment
        
      environment variables
      
    
      event
              
      autocommand events
      
    
      extension
          
      installed extensions
      
    
      file
               
      files
      
    
      help
               
      help tags
      
    
      highlight
          
      highlight groups
      
    
      history
            
      browsing history
      
    
      javascript
         
      JavaScript expressions
      
    
      macro
              
      named macros
      
    
      mapping
            
      user mappings
      
    
      mark
               
      local page marks
      
    
      menu
               
      menu items
      
    
      option
             
      &dactyl.appName; options
      
    
      preference
         
      &dactyl.host; preferences
      
    
      qmark
              
      quick marks
      
    
      runtime
            
      runtime paths
      
    
      search
             
      search engines and keywords
      
    
      shellcmd
           
      shell commands
      
    
      sidebar
            
      sidebar panels
      
    
      toolbar
            
      toolbars
      
    
      url
                
      URLs
      
    
      usercommand
        
      user commands
      
    
      window
             
      windows
      
    
      custom,thing
      custom completion, provided by thing
      

      

      


dactyl-1.2~r20151231/pentadactyl/locale/en-US/messages.properties000066400000000000000000000000371264147376100244710ustar00rootroot00000000000000
# vim:se ft=jproperties tw=0:
dactyl-1.2~r20151231/pentadactyl/locale/en-US/tutorial.xml000066400000000000000000000306761264147376100231450ustar00rootroot00000000000000







      Quick-start tutorial
      


    This is a quick-start tutorial to help new users get up and running
    in &dactyl.appName;. It is not intended as a full reference explaining all
    features.



      
    If you've started using &dactyl.appName; from scratch (i.e., without any
    customization), you should be looking at this help page in a relatively
    bare-looking window. The menubar, navigation bar, and bookmark bars are hidden.
    In case you missed the notice in the intro, you can
    regain these by issuing the command

      

mTB


      
    where  represents pressing the 
    or  key. If you're a veteran Vim user, this
    should look familiar.

      


      
    However, in this author's opinion, the best way to get familiar with
    &dactyl.appName; is to leave these disabled for now. (The above action can
    be reversed with ) You can have a
    look at the guioptions help entry for more information on this.

      


      &dactyl.appName;'s modal interface
      


      
    &dactyl.appName;'s power, like Vim's, comes from its modal interface. Keys have
    different meanings depending on which mode the browser is in. &dactyl.appName; has
    several modes, but the 2 most important are Normal mode and
    Command Line mode (see modes for the full picture).

      


      
    When &dactyl.appName; starts, it is in Normal mode by default. This is probably where
    you will spend the majority of your time.

      


      
    The other core mode of &dactyl.appName;, Command Line mode, can be entered from
    Normal mode by typing a : (colon). You will frequently see &dactyl.appName;
    commands start with a :, indicating that what follows is a command.

      


      
    To return to Normal mode from Command Line mode, type .
    Pressing  will also return you to Normal mode from most
    other &dactyl.appName; modes.

      


      Getting help
      


      
    Vim is a great editor but it's not much of a web browser. So even seasoned Vim
    users will probably have to look at &dactyl.appName;'s documentation sooner or later.
    Most of the documentation for &dactyl.appName;'s features are easily found using the
    :help command. For example, you can find help on the :help command
    by typing

      

:help :help


      
    Similarly, help on configurable options is available with
    :help 'option_name'. (Note the single quotes
    around the option name as in Vim.) Information on all available
    options is, predictably, :help options.

      


      
    And you can find out about the gt and gT mapping with

      


:help gt
:help gT



      
    Finally, in addition to the help system itself, :listcommands,
    :listkeys and :listoptions are useful quick-reference
    commands.

      


      Mouseless
      

— or how I learned to stop worrying and love the 80+ buttons I already have.


      
    The efficiency of &dactyl.appName;, as with the legendary editor it was inspired by,
    relies on the user being able to keep his fingers on the keyboard where they
    can do the most good. While there are some areas where the mouse is clearly
    superior at, such as GUI design or some games, &dactyl.appName; acts on the
    assumption that a web browser doesn't have to be one of those.

      


      
    Here are some areas where the mouse is typically considered indisposable, and
    how &dactyl.appName; challenges this preconception.

      


      Scrolling
      


      
    Scrolling the browser window is done with simple keystrokes:

      


      
    
      j/k
      
    
      
        scroll window down/up by one line, respectively
    
      
    
      h/l
      
    
      
        scroll window left/right
    
      
    
      /
      
    
      
        scroll down/up by one page
    
      
    
      /
      
    
      
        scroll down/up by 1/2 page
    
      

      


      
    Your standard buttons (///) will
    also work as expected.

      


      History and tabs
      


      
    History navigation (e.g., Back, Forward) is done similarly to
    scrolling.

      


      
    
      H/L
      
    
      
        move back/forward in the current tab's history
    
      
    
      /
      
    
      
        move back/forward in the current tab's jump list
    
      

      


      
    Move between tabs using these keystrokes which may also be familiar to
    tabbing Vimmers:

      


      
    
      gt/
      
    
      
        go to the next tab
    
      
    
      gT/
      
    
      
        go to the previous tab
    
      
    
      g0/g$
      
    
      
        go to the first/last tab
    
      
    
      d
      
    
      
        close the active tab (delete the buffer)
    
      

      


      
    To open a web page in a new tab, use :tabopen url. To open a URL in
    the current tab, use :open. The Normal mode mappings t and o,
    respectively, map to these commands, so the following pairs of sequences are
    equivalent:

      


:open my.webmail.com
omy.webmail.com

:tabopen google.com
tgoogle.com



      Some hints about surfing…
      


      
    So now you can navigate around in &dactyl.appName;. But wait… how do you open a
    page or tab linked in a web page? How do you click on all those links
    without your tailed friend?

      


      
    The answer is hints. Activating hints displays a number next to
    every link (or other element, depending on the mode) &dactyl.appName; can
    find. To act on the element (e.g., follow or save a link), simply type
    the number corresponding to the hint.

      


      
    For text links, there's an additional shortcut; you can type some text
    contained in the link and &dactyl.appName; will search all the links it can find and
    only hint the matching links, further narrowing down the list. If the text you
    type uniquely identifies any given link, &dactyl.appName; will follow that link
    immediately without any further user input.

      


      
    Whichever way you choose to indicate your target link, once &dactyl.appName; has
    highlighted the link you want, simply hit  to open it.

      


      
    To activate Hints mode, press either f or F. The lower-case
    f will open the resulting link in the current tab, while the
    upper-case F will open it in a new tab.

      


      
    Extended hint modes, started by ; or g;, provide a richer way
    to interact with various elements, not limited to following links.

      


      
    To test it, try this link: &dactyl.appName; Homepage.
    Activate Hints mode with f or F to highlight all currently
    visible links. Then start typing the text of the link. The link should be
    uniquely identified soon, and &dactyl.appName; will open it. Once you're
    done, remember to use H (History Back) or d
    (Delete Buffer) to return here, depending on which key you used to
    activate Hints mode.

      


      Saving for posterity—pentadactylrc
      


      
    Once you get &dactyl.appName; set up with your desired options, maps, and commands,
    you'll probably want them to be available the next time you open &dactyl.appName;.
    Continuing the Vim theme, this is done with a pentadactylrc file.

      


      
    To save your current settings and allow them to be loaded automatically
    next time you start &dactyl.appName;, issue the :mkp command.

      


      
    This will create the file $HOME/.pentadactylrc containing your settings.
    It is a simple text file, just like a vimrc file and can be easily
    edited to suit your preferences.

      


      Find the exit nearest you
      


      
    &dactyl.appName; supports all of Vim's classic methods of exiting.

      


      
    
      :xall
      
    
      
        quit and save the current browsing session for next time; the default
    
      
    
      :exit
      
    
      
        quit without saving the session
    
      
    
      ZZ
      
    
      
        Normal mode mapping equivalent to :xall
    
      
    
      ZQ
      
    
      
        Normal mode mapping equivalent to :exit
    
      

      


      Where did &dactyl.host; go?
      


      
    You might feel pretty disoriented now. Don't worry. This is still
    &dactyl.host; underneath. Here are some ways &dactyl.appName; allows
    &dactyl.host; to shine through (see the :help for these commands
    and mappings for more information on how to make the best use of them):

      


      
    
      :dialog
      
    
      
        To access some of &dactyl.host;'s many dialog windows, you can use the
        :dialog command. See :help :dialog.
    
      
    
      :bmarks
      
    
      
        &dactyl.appName; provides a new interface to bookmarks, but they're still your
        standard &dactyl.host; bookmarks under the hood. :bmark will add a new
        bookmark, while :bmarks will list the bookmarks currently defined.
    
      
    
      :history
      
    
      
        It's exactly what it sounds like. This command will display a colorized,
        scrollable and clickable list of the locations in &dactyl.appName;'s history.
    
      
    
      :emenu
      
    
      
        Access the &dactyl.host; menus through the &dactyl.appName; command line.
    
      

      


      
    Feel free to explore at this point. If you get hopelessly lost, just type
    :help and click the Quick-start tutorial
    link to return here.

      




      Get me out of here!
      


      
    If you've given it a fair shot and determined that &dactyl.appName; is not
    for you after all, you might want to disable it.

      


      
    The &dactyl.appName; way to do this is with the command :addons,
    which displays a list of all installed extensions. You can use hints or
    mouse to click on Off or Del to disable or remove
    &dactyl.appName;, respectively.

      


      
    Alternatively, you can do this the old-fashioned way: re-enable the menubar,
    as above, with m, and select Add-ons
    from the Tools menu. You can also use :dialog addons to
    get to the interface.

      


      I'm interested… but lost!
      


      
    &dactyl.appName; has an energetic and growing user base. If you've run into
    a problem that you can't seem to solve with &dactyl.appName;, or if you
    think you might have found a bug, please let us know! There is support
    available on the mailing list
    (mirrored on Gmane)
    or in the #pentadactyl IRC
    channel on OFTC. See also
    contact.

      


      
    If you have any feature requests or (even better) offers to help, we'd love to
    hear from you as well. Developers work on &dactyl.appName; whenever possible, but we
    are neither infinite nor omnipotent; please bear with us. If you can't wait for
    us to get around to it, rest assured patches are welcome! See the
    developer page for more information.

      

      


dactyl-1.2~r20151231/pentadactyl/skin/000077500000000000000000000000001264147376100173225ustar00rootroot00000000000000dactyl-1.2~r20151231/pentadactyl/skin/about.css000066400000000000000000000014311264147376100211450ustar00rootroot00000000000000/* Based on vimperator.org home page layout. */

#main-container {
    width: 775px;
    margin: 55px auto;
}

#img-container {
    display: table-cell;
    vertical-align: middle;
    width: 775px;
    height: 440px;
    border: 5px solid black;
    background-repeat: no-repeat;
    background-image: url(chrome://pentadactyl/content/about_background.png);
    background-color: green;
    border-spacing: 0px 10px;
    -moz-border-radius: 10px;
}

#text-container {
    float: right;
    border: solid black;
    white-space: pre-wrap;
    font-family: monospace;
    font-size: 13px;
    font-weight: bold;
    width: 500px;
    height: 275px;
    color: black;
    background-color: rgb(176, 196, 222);
    opacity: 0.75;
}

.key { color: blue; }

/* vim: set fdm=marker sw=4 ts=4 et: */
dactyl-1.2~r20151231/pentadactyl/skin/icon.png000066400000000000000000000007201264147376100207570ustar00rootroot00000000000000PNG


IHDRasRGBbKGD	pHYsuu-xutIME	
3iPIDAT8˕ϋaWLrŔŊ)EK1,VvVv6d7;K%	5I,̍e0_żWw4O:缧y^In;D_Mn4[ꫛҏ=TځK8[Ttj$y4;v(N~ jUm$_\UD͖"3~cmUuxT
p`/W߮VUڞxUq
%Wˣu8CtS_}S",'%Ymx:>tl8@`Gva.IA2¨puVJZOְЧēMc*lIENDB`dactyl-1.2~r20151231/plugins/000077500000000000000000000000001264147376100155275ustar00rootroot00000000000000dactyl-1.2~r20151231/plugins/aardvark.js000077500000000000000000001233501264147376100176670ustar00rootroot00000000000000/*
Aardvark is BSD licensed.  Use as you wish.  Gimme credit if you wanna.

Copyright (c) 2005-2008, Rob Brown

This work ‘as-is’ we provide.
No warranty, express or implied.
We’ve done our best,
to debug and test.
Liability for damages denied.

Permission is granted hereby,
to copy, share, and modify.
Use as is fit,
free or for profit.
On this notice these rights rely.
*/

/*
 * Copyright © 2011 Kris Maglione
 * Original portions available under the terms of the MIT license.
 */

"use strict";
var INFO =
["plugin", { name: "aardvark",
             version: "0.3",
             href: "http://dactyl.sf.net/pentadactyl/plugins#aardvark-plugin",
             summary: "Aardvark page editor",
             xmlns: "dactyl" },
    ["author", { email: "maglione.k@gmail.com" },
        "Kris Maglione"],
    ["author", {}, "Rob Brown"],
    ["license", {},
        "Some unnamed BSD variant"],
    ["project", { name: "Pentadactyl", "min-version": "1.0" }],
    ["p", {},
        "This plugin is a Pentadactyl port of the Aardvark Firefox add-on ",
        "and bookmarklet. The code is moderately horrendous, but it ",
        "generally works."],
    ["item", {},
        ["tags", {}, ":aardvark"],
        ["spec", {}, ["ex", {}, ":aardvark"]],
        ["description", { short: "true" },
            ["p", {}, "Start Aardvark mode."]]],

    ["item", {},
        ["tags", {}, "A_b"],
        ["spec", {}, "b"],
        ["description", { short: "true" },
            ["p", {}, "Decolorize element."]]],

    ["item", {},
        ["tags", {}, "A_c"],
        ["spec", {}, "c"],
        ["description", { short: "true" },
            ["p", {}, "Colorize element."]]],

    ["item", {},
        ["tags", {}, "A_d"],
        ["spec", {}, "d"],
        ["description", { short: "true" },
            ["p", {}, "Remove width-specifying styles."]]],

    ["item", {},
        ["tags", {}, "A_h"],
        ["spec", {}, "h"],
        ["description", { short: "true" },
            ["p", {}, "Show a list of available keys."]]],

    ["item", {},
        ["tags", {}, "A_i"],
        ["spec", {}, "i"],
        ["description", { short: "true" },
            ["p", {}, "Isolate element."]]],

    ["item", {},
        ["tags", {}, "A_j"],
        ["spec", {}, "j"],
        ["description", { short: "true" },
            ["p", {}, "Convert element to JavaScript source."]]],

    ["item", {},
        ["tags", {}, "A_k"],
        ["spec", {}, "k"],
        ["description", { short: "true" },
            ["p", {}, "Kill an element using the R.I.P. add-on."]]],

    ["item", {},
        ["tags", {}, "A_n"],
        ["spec", {}, "n"],
        ["description", { short: "true" },
            ["p", {}, "Select a lower element."]]],

    ["item", {},
        ["tags", {}, "A_p"],
        ["spec", {}, "p"],
        ["description", { short: "true" },
            ["p", {}, "Paste the last yanked element."]]],

    ["item", {},
        ["tags", {}, "A_r"],
        ["spec", {}, "r"],
        ["description", { short: "true" },
            ["p", {}, "Remove element."]]],

    ["item", {},
        ["tags", {}, "A_s"],
        ["spec", {}, "s"],
        ["description", { short: "true" },
            ["p", {}, "Select the given element or the contents of the frontmost display box."]]],

    ["item", {},
        ["tags", {}, "A_t"],
        ["spec", {}, "t"],
        ["description", { short: "true" },
            ["p", {}, "Thunk the element in a global variable."]]],

    ["item", {},
        ["tags", {}, "A_u"],
        ["spec", {}, "u"],
        ["description", { short: "true" },
            ["p", {}, "Undo the last operation."]]],

    ["item", {},
        ["tags", {}, "A_v"],
        ["spec", {}, "v"],
        ["description", { short: "true" },
            ["p", {}, "View element source."]]],

    ["item", {},
        ["tags", {}, "A_w"],
        ["spec", {}, "w"],
        ["description", { short: "true" },
            ["p", {}, "Select a higher element."]]],

    ["item", {},
        ["tags", {}, "A_x"],
        ["spec", {}, "x"],
        ["description", { short: "true" },
            ["p", {}, "Show the element's XPath."]]]];

highlight.loadCSS(String.raw`
    AardvarkDBox;;*  {
        padding: 0;
        border: 1px solid #000;
        background-color: #888;
        color: black;
        font-family: arial;
        font-size: 13px;
    }
    AardvarkDragger;;*  {
        font-size: 12px;
        text-align: left;
        color: #000;
        padding: 2px;
        height: 14px;
        margin: 0;
        cursor: move;
        background-color: #d8d7dc;
    }
    AardvarkClose;;*  {
        vertical-align: middle;
        width: 17px;
        height: 17px;
        margin: -2px 4px 0 0;
        cursor: pointer;
    }
    AardvarkSelect;;*  {
        float: right;
        font-size: 11px;
        color: #008;
        margin: 0;
        padding: 0;
        cursor: pointer;
    }
    AardvarkInner;;*  {
        float: left;
        margin: 0;
        border: 0;
        padding: 4px;
        font-size: 13px;
        color: #000;
        background: #fff;
    }

    Aardvark;;*  {
        border-color: black;
        border-width: 1px 2px 2px 1px;
        border-style: solid;
        font-family: arial;
        text-align: left;
        color: #000;
        font-size: 12px;
        position: absolute;
        padding: 2px 5px;
    }
    AardvarkLabel;;*;Aardvark  {
        border-top-width: 0;
        border-bottom-left-radius: 6px;
        border-bottom-right-radius: 6px;
        background-color: #fff0cc;
        z-index: 5005;
    }
    AardvarkKeybox;;*;Aardvark  {
        background-color: #dfd;
        z-index: 100006;
    }
    AardvarkBorder;;*  {
        position: absolute;
        z-index: 5001;
        border-color: #f00;
        border-style: solid;
    }

    AardvarkIsolated;;*  {
        float: none;
        position: static;
        padding: 5px;
        margin: 5px;
    }
    AardvarkIsolatedBody;;*  {
        width: 100%;
        background: none;
        background-color: white;
        background-image: none;
        text-align: left;
    }

    AardvarkBW;;*  {
        color: #000 !important;
        background-color: #fff !important;
        font-family: arial !important;
        font-size: 13px !important;
        text-align: left !important;
        background-image: none !important;
    }
    AardvarkBW:-moz-any-link;;*  {
        text-decoration: underline !important;
    }
    AardvarkDewidthified;;*  {
        width: auto !important;
    }
`);

group.styles.add("aardvark", "*", String.raw`
        [dactyl|highlight~=AardvarkDBox] div.vsblock {
            border: 1px solid #ccc;
            border-right: 0;
            margin: -1px 0 -1px 1em;
            padding: 0;
        }
        [dactyl|highlight~=AardvarkDBox] div.vsline {
            border-right: 0;
            margin: 0 0 0 .6em;
            text-indent: -.6em;
            padding: 0;
        }
        [dactyl|highlight~=AardvarkDBox] div.vsindent {
	    border-right: 0;
	    margin: 0 0 0 1.6em;
	    text-indent: -.6em;
	    padding: 0;
        }
        [dactyl|highlight~=AardvarkDBox] span.tag {
	    color: #c00;
	    font-weight:bold;
        }
        [dactyl|highlight~=AardvarkDBox] span.pname {
	    color: #080;
	    font-weight: bold;
        }
        [dactyl|highlight~=AardvarkDBox] span.pval {
	    color:#00a;
	    font-weight: bold;
        }
        [dactyl|highlight~=AardvarkDBox] span.aname {
	    color: #050;
	    font-style: italic;
	    font-weight: normal;
        }
        [dactyl|highlight~=AardvarkDBox] span.aval {
	    color:#007;
	    font-style: italic;
	    font-weight: normal;
        }

        [dactyl|highlight~=AardvarkDBox] a,
        [dactyl|highlight~=AardvarkDBox] a:visited {
	    color: #007;
	    text-decoration: underline;
        }
        [dactyl|highlight~=AardvarkDBox] a:hover {
	    color: #00f;
        }
    `);

let images = {
    close: `data:image/gif;base64,
        R0lGODlhEQARAMMPANuywOyNo+wnUfEENPN1kfFLbre0u/78/P7S28ZWcIdsdaJIXolVY7IyTpKS
        mP///yH5BAEAAA8ALAAAAAARABEAAARw8MkJQAAz5yCGHwKhTcVnglhWDqsnlIIxBV5wEC6CdMnU
        FYcgQYAIIjwywIcQbB52HsVDuXRCPQsD1eXEfbJbovP2Ycg64idTGJV4bdB1qeHweYbLlUImAXRO
        ZXUaCYANCoIjBgoLCwyHfCMTBpOREQA7
    `,
};

for (let k in images)
    images[k] = String(images[k].replace(/\s+/g, ""));

function nodeName(node) {
    if (node.nodeName == node.localName.toUpperCase())
        return node.localName;
    return node.nodeName;
}

var AardvarkDBox = Class("AardvarkDBox", {
    init: function (aardvark, params) {
        if (!("dragger" in params))
            params.dragger = true;

        this.aardvark = aardvark;

        this.bgColor = params.bgColor || "";
        this.position = params.position;
        this.id = aardvark.dBoxId++;

        var dims = aardvark.getWindowDimensions();
        dims.width -= 15;
        dims.height -= 15;
        this.dims = dims;

        let style = "position: absolute; z-index: 100000;" +
                    "top: " + dims.scrollY + "px;" +
                    "left: " + dims.scrollX + "px;" +
                    "max-width: " + (dims.width - 20) + "px;" +
                    "max-height: " + (dims.height - 20) + "px;"

        let outerDiv =
            ["div", { key: "outerContainer",
                      highlight: "AardvarkDBox",
                      style: style,
                      id: "aardvarkdbox-" + aardvark.dBoxId },
                !params.dragger ? [] :
                ["div", { command: "drag", key: "dragBar",
                          highlight: "AardvarkDragger" },
                    ["img", { src: images.close,
                              command: "kill",
                              highlight: "AardvarkClose",
                              alt: "close" }],
                    !params.selectLink ? [] :
                        ["a", { highlight: "AardvarkSelect", command: "select" },
                            "select all"],
                    params.title || ""],
                ["div", { key: "innerContainer", highlight: "AardvarkInner",
                          style: "overflow: " + (params.hideScrollbar ? "hidden" : "auto") },
                    content || ""]];

        outerDiv = DOM.fromJSON(outerDiv, aardvark.doc, this);
        outerDiv.isAardvark = true;
        outerDiv.dbox = this;
        DOM(outerDiv).mousedown(this.closure.onMouseDown)
                     .appendTo(aardvark.container);

        if (params.data)
            DOM(this.innerContainer).empty().append(params.data);

        aardvark.dBoxId++;
        return this;
    },

    onMouseDown: function onMouseDown(event) {
        let command = DOM(event.target).attr("command");
        if (command in this && event.button == 0) {
            this[command](event);
            event.preventDefault();
        }
    },

    kill: function kill() {
        if (!this.outerContainer.parentNode)
            return false;
        DOM(this.outerContainer).remove();
        return true;
    },

    select: function select() {
        this.aardvark.highlightText(this.innerContainer);
    },

    drag: function drag() {
        let elem = this.outerContainer;
        this.aardvark.dragElement = elem;
        this.aardvark.dragStartPos = this.aardvark.getPos(elem);
        this.aardvark.dragClickX = this.aardvark.mousePosX;
        this.aardvark.dragClickY = this.aardvark.mousePosY;
    },

    show: function show() {
        var dims = this.dims;
        var draggerHeight = 1;
        if (this.dragBar) {
            draggerHeight = 18;
        }
        var w = this.innerContainer.offsetWidth;
        if (!this.innerContainer.style.width || this.innerContainer.style.width != "")
            w += 25;

        if (this.dragBar)
            w = Math.max(w, this.dragBar.offsetWidth + 12);
        w = Math.min(w, dims.width - 20);

        this.outerContainer.style.width = w + "px";
        this.innerContainer.style.width = w + "px";

        var diff;
        if ((diff = this.innerContainer.offsetWidth - w) > 0)
            this.innerContainer.style.width = (w - diff) + "px";

        var h = Math.min(dims.height - 25,
                         this.innerContainer.offsetHeight);

        this.outerContainer.style.height = (h + draggerHeight) + "px";
        this.innerContainer.style.height = h + "px";
        if ((diff = this.innerContainer.offsetHeight - h) > 0)
            this.innerContainer.style.height = (h - diff) + "px";

        this.innerContainer.style.backgroundColor = this.bgColor;

        if (this.position) {
            var { x, y } = this.position;
        }
        else {
            x = dims.width / 2 - w / 2;
            y = dims.height / 2 - h / 2;
        }
        x += dims.scrollX;
        y += dims.scrollY;

        this.aardvark.moveElem(this.outerContainer, x, y);
    }
});

var Aardvark = Class("Aardvark", {
    init: function init(window) {
        this.window = window;
        this.doc = window.document;

        this.top = DOM(["div", { highlight: "hints" }], this.doc)
                        .appendTo(this.doc.body);
        this.top.style.height;
        this.top[0].isAardvark = true;

        this.container = this.top.findAnon("anonid", "hints") || this.container;

        modes.push(modes.AARDVARK, null, this.closure);

        this.undoStack = [];

        this.makeElems();
        this.selectedElem = null;
    },

    get mappingSelf() { return this; },

    enter: function enter() {
        group.events.listen(this.doc, this, "events");
    },

    leave: function leave(stack) {
        group.events.unlisten(this.doc, this, "events");
        if (!stack.push)
            this.top.remove();
    },

    closePanels: function closePanels() {
        let panels = this.container.children
                         .filter((elem) => DOM(elem).highlight.has("AardvarkDBox"));
        panels.remove();
        return panels.length;
    },

    rip: function rip(elem) {
        if (window.RemoveItPermanently)
            RemoveItPermanently.doRipNode(elem);
        else {
            var dbox = AardvarkDBox(this, { data: this.strings.ripHelp });
            dbox.show();
        }
        return true;
    },

    wider: function wider(elem) {
        if (elem && elem.parentNode) {
            var newElem = this.findValidElement(elem.parentNode);
            if (!newElem)
                return false;

            if (this.widerStack &&
                this.widerStack.length > 0 &&
                this.widerStack[this.widerStack.length - 1] == elem) {
                this.widerStack.push(newElem);
            }
            else {
                this.widerStack = [elem, newElem];
            }
            this.selectedElem = newElem;
            this.showBoxAndLabel(newElem, this.makeElementLabelString(newElem));
            this.didWider = true;
            return true;
        }
        return false;
    },

    narrower: function narrower(elem) {
        if (elem) {
            if (this.widerStack &&
                this.widerStack.length > 1 &&
                this.widerStack[this.widerStack.length - 1] == elem) {

                this.widerStack.pop();
                let newElem = this.widerStack[this.widerStack.length - 1];
                this.selectedElem = newElem;
                this.showBoxAndLabel(newElem, this.makeElementLabelString(newElem));
                this.didWider = true;
                return true;
            }
        }
        return false;
    },

    select: function select(elem) {
        let panels = this.container.children
                         .filter(elem => elem.dbox);
        if (panels.length)
            panels[panels.length - 1].dbox.select();
        else if (elem)
            this.highlightText(elem);
    },

    viewSource: function viewSource(elem) {
        var dbox = AardvarkDBox(this, {
            selectLink: true,
            title: this.strings.viewHtmlSource,
            data: this.getOuterHtmlFormatted(elem, 0)
        });
        dbox.show();
        return true;
    },

    colorize: function colorize(elem) {
        let val = () => Math.round(Math.random() * 16).toString(16);

        this.undoStack.push({
            styles: {
                backgroundColor: elem.style.backgroundColor,
                backgroundImage: elem.style.backgroundImage
            },
            undo: function undo() { DOM(elem).css(this.styles); }
        });

        DOM(elem).css({
            backgroundColor: "#" + val() + val() + val(),
            backgroundImage: ""
        });
        return true;
    },

    removeElement: function removeElement(elem) {
        if (elem.parentNode != null) {
            DOM(elem).hide();
            this.undoStack.push({
                mode: "R",
                elem: elem,
                undo: function () { DOM(this.elem).show() }
            });
            this.clearBox();
            return true;
        }
        return false;
    },

    paste: function paste(target) {
        if (target.parentNode != null) {
            if (this.undoStack.length && this.undoStack.slice(-1)[0].mode == "R") {
                let src = this.undoStack.pop().elem;

                if (src.localName == "tr" && target.localName != "tr") {
                    var t = DOM(["table", {}, ["tbody"]], this.doc)[0];
                    t.firstChild.appendChild(src);
                    DOM(src).show();
                    src = t;
                }
                else if (src.localName == "td" && target.localName != "td")
                    src = DOM(["div"], this.doc).append(DOM(src).contents()).append(src)[0];
                else {
                    src.parentNode.removeChild(src);
                    DOM(src).show();
                }

                if (target.localName == "td" && src.localName != "td")
                    target.insertBefore(src, target.firstChild);
                else if (target.localName == "tr" && src.localName != "tr")
                    target.insertBefore(src, target.firstChild.firstChild);
                else
                    target.parentNode.insertBefore(src, target);

                this.clearBox();
            }
        }
        return true;
    },

    global: function xpath(target) {
        commandline.input("Variable name: ", function (res) {
            if (res) {
                userContext[res] = target;
                DOM(target.ownerDocument.defaultView).unload(function () {
                    if (userContext[res] == target)
                        delete userContext[res];
                });
            }
        });
    },

    xpath: function xpath(target) {
        AardvarkDBox(this, {
            selectLink: true,
            title: this.strings.viewXPath,
            data: DOM(target).xpath
        }).show();
    },

    isolateElement: function isolateElement(elem) {
        let { body } = this.doc;
        if (elem.parentNode != null) {
            this.clearBox();
            var clone = elem.cloneNode(true);
            DOM(clone).highlight.add("AardvarkIsolated");

            if (clone.localName == "tr" || clone.localName == "td") {
                if (clone.localName == "td")
                    clone = DOM(["tr"], this.doc).append(clone)[0];

                t = DOM(["table", {}, ["tbody"]], this.doc)[0];
                t.firstChild.appendChild(clone);
                clone = t;
            }

            var undoData = Array.filter(this.doc.body.childNodes,
                                        e => !e.isAardvark);
            DOM(undoData).remove();
            undoData.mode = "I";
            undoData.isolated = DOM(body).highlight.has("AardvarkIsolatedBody");
            undoData.undo = function () {
                DOM(body.childNodes).filter(e => !e.isAardvark)
                    .remove();

                DOM(body).highlight.toggle("AardvarkIsolatedBody", this.isolated)
                         .prepend(this);
            };
            this.undoStack.push(undoData);

            DOM(this.doc.body).highlight.add("AardvarkIsolatedBody")
                              .append(clone);

            this.window.scroll(0, 0);
        }
        return true;
    },

    _undo: function _undo(group) {
        return function undo() {
            (function rec(node) {
                DOM(node).highlight.remove(group)
                         .children.each(rec);
            })(this.elem);
        };
    },

    deWidthify: function deWidthify(node) {
        if (node instanceof Element) {
            if (node.localName != "img") {
                DOM(node).highlight.add("AardvarkDewidthified")
                         .children.each(this.closure.deWidthify);

                if (arguments.length == 1) {
                    this.clearBox();
                    this.undoStack.push({ elem: node, undo: this._undo("AardvarkDewidthified") });
                }
            }
        }
        return true;
    },

    blackOnWhite: function blackOnWhite(node) {
        if (node instanceof Element) {
            if (node.localName != "img") {
                DOM(node).highlight.add("AardvarkBW")
                         .children.each(this.closure.blackOnWhite);

                if (arguments.length == 1)
                    this.undoStack.push({ elem: node, undo: this._undo("AardvarkBW") });
            }
        }
        return true;
    },

    getOuterHtmlFormatted: function getOuterHtmlFormatted(node, indent) {
        var res = [];
        switch (node.nodeType) {
        case Node.ELEMENT_NODE:
            if (node.style.display == "none")
                break;

            var isLeaf = node.childNodes.length == 0
                      && this.leafElems[node.localName];
            var isTbody = node.localName == "tbody" && node.attributes.length == 0;
            if (isTbody) {
                for (let node of node.childNodes)
                    res.push(this.getOuterHtmlFormatted(node, indent));
            }
            else {
                let inner = ["", "<",
                             ["span", { class: "tag" }, nodeName(node)]];
                Array.forEach(node.attributes, function (attr) {
                    if (attr.value != null) {
                        let value = ["span", { class: "pval" }, attr.value];
                        if (attr.localName == "style")
                            value = template.map(Styles.propertyIter(value),
                                ({ name, value }) =>
                                    [["span", { class: "aname" }, name],
                                     ": ",
                                     ["span", { class: "aval" }, value],
                                     ";"],
                                " ");

                        inner.push(" ",
                                   ["span", { class: "pname" }, nodeName(attr)],
                                   '="',
                                   value,
                                   '"');
                    }
                }, this)

                if (isLeaf)
                    res.push(["div", { class: "vsindent" },
                                inner,
                                "/>"]);
                else {
                    inner = [["div", { class: "vsline" },
                                inner]];

                    for (let node of node.childNodes)
                        inner.push(this.getOuterHtmlFormatted(node, indent + 1));

                    res.push(["div", { class: "vsline" },
                                ""]);

                    if (indent > 0)
                        res.push(["div", { class: "vsblock" }, inner]);
                    else
                        res.push(inner);
                }
            }
            break;
        case Node.TEXT_NODE:
            var v = DOM.escapeHTML(node.nodeValue).trim();
            if (v)
                res.push(["div", { class: "vsindent" },
                            v]);
            break;
        case Node.CDATA_SECTION_NODE:
            res.push(["div", { class: "vsindent" },
                        ""]);
            break;
        case Node.ENTITY_REFERENCE_NODE:
            res.push(["", "&", nodeName(node)], ["br"]);
            break;
        case Node.COMMENT_NODE:
            res.push(["div", { class: "vsindent" },
                        ""]);
            break;
        }
        return res;
    },

    camelCaseProps: {
    },

    domJavascript: function domJavascript(node, indent) {
        let FmtString = (str, color) => ["", '"',
                                         ["span", { style: "color:" + (color || "#00b") + "; font-weight: bold" },
                                             util.escapeString(str, "")],
                                         '"'];

        let self = this;
        var indentStr = "";
        for (var c = 0; c < indent; c++)
            indentStr += "  ";

        switch (node.nodeType) {
        case Node.ELEMENT_NODE:
            if (node.style.display == "none")
                break;

            var isLeaf = node.childNodes.length == 0
                      && this.leafElems[node.localName];
            var children = [];
            var numChildren = 0;
            if (!isLeaf) {
                numChildren = node.childNodes.length;
                children = template.map(node.childNodes,
                    node => ["", indentStr, "  ",
                             self.domJavascript(node, indent + 1)],
                    ["", ",", ["br"]]);
            }

            var properties = [];
            var styles = [];
            Array.forEach(node.attributes, function ({ nodeName, value }) {
                if (value != null) {
                    switch (nodeName) {
                    case "style":
                        for (let { name, value } of Styles.propertyIter(value))
                            styles.push(["", FmtString(util.camelCase(name), "#060"), ":",
                                             FmtString(value.trim(), "#008")]);
                        break;
                    default:
                        nodeName = this.camelCaseProps[n] || nodeName;

                        properties.push(["", FmtString(nodeName, "#080"), ":",
                                             FmtString(value, "#00b")]);
                        break;
                    }
                }
            }, this);

            if (styles.length) {
                styles = template.map(styles, util.identity, ", ");
                properties.unshift(["", FmtString("style", "080"), ":",
                                    "{", styles, "}"]);
            }

            let numProps = properties.length;
            properties = template.map(properties, util.identity, ", ");
            properties = ["", "{", properties, "}"];

            let xml = ["", "[", FmtString(nodeName(node), "red")];
            if (numChildren) {
                if (numProps)
                    return ["", xml, ", ", properties, ",\u000a;", children, "]"];
                else
                    return ["", xml, ",'\u000a", children, "]"];
            }
            else if (numProps)
                return ["", xml, ", ", properties, "]"];
            else
                return ["", xml, "]"];
            break;
        case Node.TEXT_NODE:
            var n = node.nodeValue;
            if (node.nodeValue != "")
                n = util.escapeString(n, "");

            n = n.trim();
            if (n.length > 0)
                return ["", '"', ["b", {}, n], '"'];
            break;
        case Node.CDATA_SECTION_NODE:
        case Node.ENTITY_REFERENCE_NODE:
        case Node.COMMENT_NODE:
            break;
        }
        return null;
    },

    makeJavascript: function makeJavascript(elem) {
        var dbox = AardvarkDBox(this, {
            selectLink: true,
            title: this.strings.javascriptDomCode,
            data: [
                ["pre", { style: "margin:0; width: 97%" },
                    this.domJavascript(elem, 0)],
                ["br"]
            ]
        });
        dbox.show();
        return true;
    },

    undo: function undo() {
        if (!this.undoStack.length)
            return false;

        this.clearBox();
        this.undoStack.pop().undo();
        return true;
    },

    showMenu: function showMenu() {
        if (this.helpBox && this.helpBox.kill()) {
            delete this.helpBox;
            return;
        }

        var s = ["table", { style: "margin:5px 10px 0 10px;" }];
        for (let map of mappings.iterate(modes.AARDVARK))
            if (map.name != "")
                s.push(["tr", {},
                    ["td", { style: "padding: 3px 7px; border: 1px solid black; font-family: courier; font-weight: bold; background-color: #fff" },
                        map.name],
                    ["td", { style: "padding: 3px 7px; font-size: .9em; text-align: left;" },
                        map.description]
                ]);

        var dbox = AardvarkDBox(this, {
            bgColor: "#fff2db",
            selectLink: true,
            position: { x: 20, y: 20 },
            title: this.strings.aardvarkKeystrokes,
            data: s
        });
        dbox.show();
        this.helpBox = dbox;
        return true;
    },

    highlightText: function highlightText(elem) {
        let s = this.window.getSelection();
        s.removeAllRanges();
        s.addRange(RangeFind.nodeRange(elem));
        dactyl.clipboardWrite(DOM.stringify(s), false, "selection");
    },

    strings: {
        aardvarkKeystrokes: 'Aardvark keystrokes',
        blackOnWhite: 'black on white',
        deWidthify: 'de-widthify',
        description: 'Utility for cleaning up a page prior to printing, and for analyzing a page.',
        help: 'toggle &help',
        javascriptDomCode: 'Javascript DOM code',
        ripHelp: ["center", {},
            "If you install the excellent ",
            "", ["a", { href: "http://addons.mozilla.org/addon/521/", target: "_blank" }, "R.I.P."], ["br"],
            "(Remove It Permanently), the K command will", ["br"],
            "permanently remove items from a page."],
        undo: 'undo',
        viewHtmlSource: 'View HTML source',
        viewSource: 'view source',
        viewXPath: 'View XPath'
    },

//-------------------------------------------------
// create the box and tag etc (done once and saved)
    makeElems: function makeElems() {
        this.borderElems = {};

        for (let side of ["top", "bottom", "left", "right"]) {
            this.borderElems[side] = DOM(["div", { style: "display: none; border-width: 0; border-" + side + "-width: 2px;",
                                                   highlight: "AardvarkBorder" }],
                                         this.doc).appendTo(this.container);
        }

        this.labelElem = DOM(["div", { style: "display: none;", highlight: "AardvarkLabel" }],
                             this.doc).appendTo(this.container)[0];

        this.keyboxElem = DOM(["div", { style: "display: none;", highlight: "AardvarkKeybox" }],
                              this.doc).appendTo(this.container);
    },

//-------------------------------------------------
// show the red box around the element, and display
// the string in the little tag
    showBoxAndLabel: function showBoxAndLabel(elem, label) {
        var pos = this.getPos(elem);
        var dims = this.getWindowDimensions();
        var y = pos.y;

        let width = parseFloat(this.borderElems.left.style.borderLeftWidth);
        DOM(values(this.borderElems).map(e => e[0])).css({
            left: pos.x - width + "px",
            top: pos.y - width + "px",
            width: elem.offsetWidth + 2 * width + "px",
            height: elem.offsetHeight + 2 * width + "px"
        }).show();

        this.borderElems.left.css({
            width: 0
        });
        this.borderElems.right.css({
            width: 0,
            left: (pos.x + elem.offsetWidth) + "px"
        });
        this.borderElems.top.css({
            height: 0
        });
        this.borderElems.bottom.css({
            height: 0,
            top: (pos.y + elem.offsetHeight) + "px"
        });

        y += elem.offsetHeight + 2;
        DOM(this.labelElem).empty().append(label).show();

        this.labelElem.style.borderTopWidth = "";
        this.labelElem.style.borderTopLeftRadius = "";
        this.labelElem.style.borderTopRightRadius = "";
        if ((y + this.labelElem.offsetHeight) >= dims.scrollY + dims.height) {
            this.labelElem.style.cssText += "border-top-width: 1px !important; \
                                             border-top-left-radius: 6px !important; \
                                             border-top-right-radius: 6px !important;";
            y = (dims.scrollY + dims.height) - this.labelElem.offsetHeight;
        }
        else if (this.labelElem.offsetWidth > elem.offsetWidth) {
            this.labelElem.style.cssText += "border-top-width: 1px !important; \
                                             border-top-right-radius: 6px !important;";
        }
        this.moveElem(this.labelElem, pos.x + 2, y);
    },

//-------------------------------------------------
// remove the red box and tag
    clearBox: function clearBox() {
        this.selectedElem = null;
        if (this.borderElems != null) {
            for (let elem of values(this.borderElems))
                elem.hide();
            DOM(this.labelElem).hide();
        }
    },

//-------------------------------------------------
    hideKeybox: function hideKeybox() {
        this.keyboxElem.hide();
        this.keyboxTimeout = null;
    },

//-------------------------------------------------
    showKeybox: function showKeybox(key){
        if (this.keyboxElem == null)
            return;

        this.keyboxElem.empty().append(
            template.highlightRegexp(key.aardvarkSpec || key.description, /&(.)/g,
                (m, m1) => ["b", { style: "font-size: 2em" }, m1]));

        var dims = this.getWindowDimensions();
        var y = Math.max(0, dims.scrollY + this.mousePosY + 10);
        if (y > (dims.scrollY + dims.height) - 30)
            y = (dims.scrollY + dims.height) - 60;

        var x = Math.max(0, this.mousePosX + 10);
        if (x > (dims.scrollX + dims.width) - 60)
            x = (dims.scrollX + dims.width) - 100;

        this.moveElem(this.keyboxElem, x, y);

        this.keyboxElem.show();
        if (this.keyboxTimeout)
            this.keyboxTimeout.cancel();
        this.keyboxTimeout = this.timeout(this.hideKeybox, 400);
    },

//-------------------------------------------------
    makeElementLabelString: function makeElementLabelString(elem) {
        var s = [["b", { style: "color:#000" }, nodeName(elem)]];
        if (elem.id != "")
            s.push(["b", {}, "#"], ["i", {}, elem.id]);

        if (elem.className != "")
            s.push(template.map(Array.slice(elem.classList),
                                clas => [["b", {}, "."], ["i", {}, clas]]));
        return s;
    },

    events: {
        mouseup: function onMouseUp(evt) {
            if (this.dragElement) {
                delete this.dragElement;
                delete this.dragClickX;
                delete this.dragClickY;
                delete this.dragStartPos;
            }
            return false;
        },

    // the following three functions are the main event handlers
    //-------------------------------------------------
        mousemove: function onMouseMove(evt) {
            if (this.mousePosX == evt.clientX &&
                this.mousePosY == evt.clientY) {
                this.moved = false;
                return;
            }
            this.mousePosX = evt.clientX;
            this.mousePosY = evt.clientY;
            if (this.dragElement) {
                this.moveElem(this.dragElement,
                    (this.mousePosX - this.dragClickX) + this.dragStartPos.x,
                    (this.mousePosY - this.dragClickY) + this.dragStartPos.y);
                this.moved = false;
            }
            else {
                this.moved = true;
            }
            evt.preventDefault();
        },

    //-------------------------------------------------
        mouseover: function onMouseOver(evt) {
            if (!this.moved)
                return;

            this.choose(evt.target);
        },

        click: function click(evt) {
            this.choose(evt.target);
        }
    },

    choose: function choose(elem) {
        if (elem == this.labelElem || ~values(this.borderElems).indexOf(elem))
            this.clearBox();

        if (elem.isAardvark || DOM(elem).ancestors.some(e => e.isAardvark))
            return;

        if (elem == null) {
            this.clearBox();
            return;
        }
        elem = this.findValidElement(elem);
        if (elem == null) {
            this.clearBox();
            return;
        }
        this.didWider = false;
        if (elem != this.selectedElem) {
            this.widerStack = null;
            this.selectedElem = elem;
            this.showBoxAndLabel(elem, this.makeElementLabelString(elem));
            this.innerItem = null;
            this.moved = false;
        }
    },

//-------------------------------------------------
// given an element, walk upwards to find the first
// valid selectable element
    findValidElement: function findValidElement(elem) {
        for (; elem; elem = elem.parentNode) {
            if (hasOwnProperty(this.alwaysValidElements, elem.localName))
                break;

            let { display } = DOM(elem).style;
            if (hasOwnProperty(this.validIfBlockElements, elem.localName) && display == "block")
                break;
            if (hasOwnProperty(this.validIfNotInlineElements, elem.localName) && display != "inline")
                break;
        }
        return elem;
    },

//-----------------------------------------------------
    getPos: function getPos(elem) {
        let body = this.doc.body || this.doc.documentElement;
        let style = DOM(body).style;

        if (~["absolute", "fixed", "relative"].indexOf(style.position)) {
            let rect = body.getClientRects()[0];
            var offsets =  [-rect.left, -rect.top];
        }
        else
            var offsets =  [this.doc.defaultView.scrollX, this.doc.defaultView.scrollY];

        let rect = DOM(elem).rect;
        var pos = {
            x: rect.left + offsets[0],
            y: rect.top + offsets[1]
        };
        return pos;
    },

//-----------------------------------------------------
// move a div (or whatever) to an x y location
    moveElem: function moveElem(elem, x, y) {
        DOM(elem).css({ left: x + "px", top: y + "px" });
    },

//-------------------------------------------------
    getWindowDimensions: function getWindowDimensions() {
        var out = {};
        out.scrollX = this.window.pageXOffset;
        out.scrollY = this.window.pageYOffset;
        if (this.doc.compatMode == "BackCompat") {
            out.width = this.doc.body.clientWidth;
            out.height = this.doc.body.clientHeight;
        }
        else {
            out.width = this.doc.documentElement.clientWidth;
            out.height = this.doc.documentElement.clientHeight;
        }
        return out;
    },

    dBoxId: 0,

    alwaysValidElements: Set(["applet", "blockquote", "div", "form",
                              "h1", "h2", "h3", "iframe", "img", "object",
                              "p", "table", "td", "th", "tr"]),

    validIfBlockElements: Set(["a", "span"]),

    validIfNotInlineElements: Set(["code", "li", "ol", "pre", "ul"]),

    leafElems: Set(["area", "base", "basefont", "br", "col", "frame", "hr",
                    "img", "input", "isindex", "link", "meta", "param"])
});

modes.addMode("AARDVARK", {
    char: "A",
    description: "Aardvark page editing mode",
    bases: [modes.COMMAND],
    ownsBuffer: true
});

let aardvark = Aardvark.prototype;
aardvark.commands = {};

// 0: name (member of aardvark.strings, or literal string)
// 1: function
// 2: needs element
// 3: 'true' for extension only
var commands = [
    ["wider",        "wider",          true],
    ["narrower",     "narrower",       true],
    ["undo",         "undo",           false],
    ["remove",       "removeElement",  true],
    ["kill",         "rip",            true],
    ["isolate",      "isolateElement", true],
    ["blackOnWhite", "blackOnWhite",   true],
    ["deWidthify",   "deWidthify",     true],
    ["colorize",     "colorize",       true],
    ["viewSource",   "viewSource",     true],
    ["javascript",   "makeJavascript", true],
    ["paste",        "paste",          true],
    ["select",       "select",         false],
    ["thunk",        "global",         true],
    ["xpath",        "xpath",          true],
    ["help",         "showMenu",       false],
];

commands.forEach(function([fullname, func, needsElement]) {
    if (aardvark.strings[fullname])
        fullname = aardvark.strings[fullname];

    let name = fullname.replace("&", "");
    if (!/&/.test(fullname))
        fullname = "&" + fullname;
    let key = /&(.)/.exec(fullname)[1];

    aardvark.commands[key] = {
        name: name,
        fullName: fullname,
        func: func,
        needsElement: needsElement,
    };

    group.mappings.add([modes.AARDVARK],
                       [key],
                       name,
        function({ self }) {
            if (needsElement) {
                if (self.selectedElem && self[func](self.selectedElem) == true)
                    self.showKeybox(this);
            }
            else {
                if (self[func](self.selectedElem) == true)
                    self.showKeybox(this);
            }
        }, {
            aardvarkSpec: fullname
        });
});

group.mappings.add([modes.AARDVARK],
    ["", ""],
    "Close open panels or leave Aardvark mode",
    function ({ self }) {
        if (!self.closePanels())
            modes.remove(modes.AARDVARK);
    });

group.commands.add(["aardvark"],
    "Aardvark page editor",
    function (args) {
        dactyl.assert(!modes.have(modes.AARDVARK))
        Aardvark(buffer.focusedFrame);
    },
    { argCount: 0 },
    true);

function onUnload() {
    modes.removeMode(modes.AARDVARK);
}

dactyl-1.2~r20151231/plugins/curl.js000077500000000000000000000037501264147376100170420ustar00rootroot00000000000000"use strict";
var INFO =
["plugin", { name: "curl",
             version: "0.4",
             href: "http://dactyl.sf.net/pentadactyl/plugins#curl-plugin",
             summary: "Curl command-line generator",
             xmlns: "dactyl" },
    ["author", { email: "maglione.k@gmail.com" },
        "Kris Maglione"],
    ["license", { href: "http://opensource.org/licenses/mit-license.php" },
        "MIT"],
    ["project", { name: "Pentadactyl", "min-version": "1.0" }],
    ["p", {},
        "This plugin provides a means to generate a ", ["tt", {}, "curl(1)"], " ",
        "command-line from the data in a given form."],
    ["item", {},
        ["tags", {}, ";C"],
        ["strut"],
        ["spec", {}, ";C"],
        ["description", {},
            ["p", {},
                "Generates a curl command-line from the data in the selected form. ",
                "The command includes the data from each form element, along with ",
                "the current User-Agent string and the cookies for the current ",
                "page."]]]];

hints.addMode('C', "Generate curl command for a form", function(elem) {
    let doc = elem.ownerDocument;
    let win = doc.defaultView;

    if (elem.form)
        var { url, postData, elements } = DOM(elem).formData;
    else
        var url = elem.getAttribute("href");

    if (!url || /^javascript:/.test(url))
        return;

    url = util.newURI(url, null, doc.documentURIObject).spec;

    if (!elements)
        elements = [];

    let paramLines = [
        ...elements.map(datum => ["--form-string", datum]),

        ["-H", "Cookie: " + doc.cookie],

        ["-A", win.navigator.userAgent],

        [url],
    ];

    if (postData != null && !elements.length)
        paramLines.unshift(["-d", postData]);


    let { shellEscape } = util.bound;
    let params = paramLines.map(params => params.map(shellEscape).join(" "))
                           .join(" \\\n     ");


    dactyl.clipboardWrite(`curl ${params}`, true);
});

/* vim:se sts=4 sw=4 et: */
dactyl-1.2~r20151231/plugins/flashblock.js000077500000000000000000000577231264147376100202160ustar00rootroot00000000000000"use strict";
var INFO =
["plugin", { name: "flashblock",
             version: "1.3",
             href: "http://dactyl.sf.net/pentadactyl/plugins#flashblock-plugin",
             summary: "Flash Blocker",
             xmlns: "dactyl" },
    ["author", { email: "maglione.k@gmail.com" },
        "Kris Maglione"],
    ["license", { href: "http://opensource.org/licenses/mit-license.php" },
        "MIT"],
    ["project", { name: "Pentadactyl", "min-version": "1.0" }],
    ["p", {},
        "This plugin provides the same features as the ever popular FlashBlock ",
        "Firefox add-on. Place holders are substituted for flash animations and ",
        "embedded videos. When clicked, the original embedded content is ",
        "restored. Additionally, this plugin provides options to control which ",
        "sites can play animations without restrictions and triggers to toggle ",
        "the playing of animations on the current page."],

    ["item", {},
        ["tags", {}, "'fb' 'flashblock'"],
        ["spec", {}, "'flashblock' 'fb'"],
        ["type", {}, "boolean"],
        ["default", {}, "true"],
        ["description", {},
            ["p", {},
                "Controls the blocking of flash animations. When true, place ",
                "holders are substituted for flash animations on untrusted sites."]]],

    ["item", {},
        ["tags", {}, "'fbw' 'fbwhitelist'"],
        ["spec", {}, "'fbwhitelist' 'fbw'"],
        ["type", {}, "sitelist"],
        ["default", {}, ""],
        ["description", {},
            ["p", {},
                "Controls which sites may play flash animations without user ",
                "intervention. See ", ["ex", {}, ":mk" + config.name.toLowerCase() + "rc"], "."]]],

    ["item", {},
        ["tags", {}, ":flashplay :flp"],
        ["strut"],
        ["spec", {}, ":flashplay"],
        ["description", {},
            ["p", {},
                "Plays any blocked flash animations on the current page."]]],

    ["item", {},
        ["tags", {}, ":flashstop :fls"],
        ["strut"],
        ["spec", {}, ":flashstop"],
        ["description", {},
            ["p", {},
                "Stops any currently playing flash animations on the current ",
                "page."]]],

    ["item", {},
        ["tags", {}, ":flashtoggle :flt"],
        ["strut"],
        ["spec", {}, ":flashtoggle"],
        ["description", {},
            ["p", {},
                "Toggles the playing of all animations on the current page. If ",
                "any flash animations are currently blocked, all may begin ",
                "playing. Otherwise, all animations are stopped."],

            ["example", {},
                ["ex", {}, ":map"], " -silent ",
                ["k", { name: "A-p", link: "false" }],
                " ", ["ex", {}, ":flashtoggle"],
                ["k", { name: "CR" }]]]]];

group.options.add(["flashblock", "fb"],
    "Enable blocking of flash animations",
    "boolean", true,
    { setter: reload });
group.options.add(["fbwhitelist", "fbw"],
    "Sites which may run flash animations without prompting",
    "sitelist", "",
    {
        completer: context => completion.visibleHosts(context),
        privateData: true,
        setter: reload,
        validator: () => true,
    });

["Play", "Stop"].forEach(action => {
    group.commands.add(["flash" + action, "fl" + action[0]].map(String.toLowerCase),
        action + " all flash animations on the current page",
        function () { postMessage(content, "flashblock" + action) },
        { argCount: "0" }, true);
});

group.commands.add(["flashtoggle", "flt"],
    "Toggle playing of flash animations on the current page",
    function () {
        if (buffer.allFrames().some(w => DOM("pseudoembed", w.document).length))
            commands.get("flashplay").action();
        else
            commands.get("flashstop").action();
    },
    { argCount: "0" }, true);

group.mappings.add([modes.NORMAL], ["fbwhitelist"],
    "Add the current site to the flash whitelist",
    function () { whitelist.op("+", whitelist.parse(content.location.hostname)) });
group.mappings.add([modes.NORMAL], ["fbWhitelist"],
    "Toggle the current site in the flash whitelist",
    function () {
        let host = content.location.hostname;
        if (!removeHost(host))
            whitelist.op("+", whitelist.parse(host));
    });

var enabled = options.get("flashblock");
var whitelist = options.get("fbwhitelist");
function postMessage(content, message) {
    buffer.allFrames(content).forEach(f => { f.postMessage(message, "*"); });
}
function reload(values) {
    //for (let [,t] in tabs.browsers)
    //    t.contentWindow.postMessage("flashblockReload", "*");
    postMessage(gBrowser.mCurrentBrowser.contentWindow, "flashblockReload");
    return values;
}

function removeHost(host) {
    let len = whitelist.value.length;
    let uri = util.createURI(host);
    whitelist.value = whitelist.value.filter(f => !f(uri));
    return whitelist.value.length != len;
}

function onUnload() {
    group.events.unlisten(null);
}
group.events.listen(window, "flashblockCheckLoad",
    function checkLoadFlash(event) {
        if(!enabled.value || whitelist.getKey(event.target.documentURIObject))
            event.preventDefault();
        event.stopPropagation();
    }, true, true);

var data = {
    bindings: "dactyl://data/text/xml," + encodeURIComponent('' +
      String.raw`
        

          
            
              
                ' +
                    //                         '' +
                    //         
                    //             
                    //             {new XML(parent.innerHTML)}
                    //         );
                ]]>
              
            
          
        
      `),
    flash: `data:image/png;base64,
        iVBORw0KGgoAAAANSUhEUgAAACoAAAAqCAYAAADFw8lbAAAABGdBTUEAALGOfPtRkwAAACBjSFJN
        AAB6JQAAgIMAAPn/AACA6AAAdTAAAOpgAAA6lwAAF2+XqZnUAAANkklEQVR4nGL8//8/w1AAAAHE
        QqF+ZiAWyKntl3/9/oPkp09fhIF8Rqjcfz4+njdiYhIvJtdl3gPyPwHxP3ItAgggRjJDVNw3qdTp
        7qNnHr/+/FXm4ODgFeDh4eBgY2NBdui7Tx9//wCC799/fubkZL+nLCe1ffO87j1AuTekWggQQKQ6
        VNrIJznv05evVhIiImLSEsL8fHwCHHx8fKw8XGxM7CxMTMiKf/759+/r50//Pn799fvz27ffbz19
        /un9+48vBQX5j53bMreHFAcDBBCxDmXxjCuOunH3YbK8lJicsoKigKSECIcgvwCLgCAfEx8XFyMb
        OzvYPDR9/3/9/Mnw6du3/x/ef/r3/uOHP/cePv9x497dd89ePH9kqqc9ExjCq4Hq/hJyAEAAEeNQ
        ERWHiKnA6NUx0NISV5AW5REXF2eVEBZk5OPjYmSHOJCBg4UVpwE//vxm+PrpO8O3nz/+gxz98uWL
        31duPPxy8MTZ55xcrJfvHFiRwQBJwzgBQAARcqiUtFnwHEU5SU1DPW1RBSkJDjlpCSYhfj5GDg5I
        LHMwMzMwszEzsDNgz5fffv2E+FaEj4GVhQ0Yuj8ZPnz89v/1q+d/D5y7+WPngcOv37x5de3FmW0J
        DHiSAkAA4XOoBNCR8zVV5LX1gY7UUpRgk5GRYYKFoAA3JAQ5gPmHnYkNqwE///1iEBcSYACmSYbr
        1x8yHD57huH8pZsM7z9+YxDk52Lwdnf4d/rq3Z+bdx14DUwKV4GOjcPlWIAAwlU8cShah8wCOlIL
        5EgDDWU2MVFBJh5ONmAIMjFw80AcC3IgExskWYJCCx0oCgsxfPz2l6Ft2lKGdZu3Mjx5/YHhByMb
        w29mdoZ/bOwMWnoGTJ52VuzADCd64vx1LWDAzH56am04UOsvdLMAAgibQxmBObsBGAoaQEeKAB3J
        LiUmCo5qbpBDoSGI7EBmVhYGNkbUmAGF4sOnLxhyKloY9h4/z8AmKMrALaHEIMLFC5b//u0zw6XH
        rxj8HI2YjA102f8zc4i++/BeE2h3PbBEqEZ3FEAAMaELAAtvQ2DR52xpaCAGjG6sjmTnYgc7kIOT
        CyjOAcxILAxMzKwMwLISjEGOBJYQDBGZ5WBHCqtqMogoajJwQh0JAh+//GR48uo12BxFaWkmLVUF
        didLE/GXrz44l7RO1UJ3F0AAoTuUdd/xMwUGWtpSykoKXBKiUkzYHAkCMAeyszHBMbBkAOOX7z4x
        lDZ0M5y4dptBUMOQgV1QAljAMYMxKCRfvHrDwMbBzsDFwwWODQFeFgYZCREmdXV1Ln0dTZkNuw83
        MkBqPTgACCCUqE8u7bYQEhDUU1WR5ZOVEGHm5uNkBKVJZEeCDIY5EARADkMH05ZsBIekjKoWUA8w
        FP9Aisl3nz4z6KpKM8Q5mDEYaykA9XIx/P7yFVhi/GUQ4eFk/CElwWKip8H/4NF9ldSqfvPZbYXH
        YGYCBBCyQ5nOX78RYqipISIiJMwOLCOZQGUjF1KaJMaRR89dZ1i6fCU4TXLxiwBFIGn39YcvDMH2
        JgyNSX4MnMDi7Ovnb2DxL79/Ac3nBNrzi4Gf7x+TvKwku6aGuujxcxfjgdLHYQYABBBy1EsCsYmM
        rAQPsDBnBudwYCwDMynYkaC0BMowTEDHw6IYG1i+fgfD3dfvGERklBj+MrGA8dMXb8GO7MoIZPgH
        rKlevvvA8BsYyCAMK9qADQVwkSciKMisqSjLA8wnoHQqDDMXIIDgDg3PqdeXEJMUgoYmI6ggBxXi
        IINgOZuFnQur42Dg7MVbDDv27GXgFxRjAOYcsNiLZy8ZgG0CcEgy/IaELg8rG7iMRQcg+3g42BmB
        NR8bsC0hFJXXZgSTAwgguENfv32jDjSQm4uTnRlYqIPLHlhogn0MjHJWpr8MvFy4q8qDx0/AQxME
        3gFD7tuHtww5PnZg/svPH8FRDQtJdMeCQpWbi4NRgIeLRVxCjPvF66caMDmAAIKlUZZfv344A1tB
        nMAGBhMr039ItQiNFlBoQgzCHt0g8OzlO4ZNe08APQeMLVZ2sCO/f/vEwM7HwzBlyyGG+SvWMvz/
        8ovh/9c3DH6BXgylBRkMT58/wzAHlNw42NmZJAV5Oe4/eKgKDcx/AAEEdygDIycnsKnGAmwFMcKK
        IxBATpsMf4D1Ngs7Vofevv+A4dT5iwycIjLg3A1yJFzu0lVgk+MTw//vvxgYv35kUDd/w8DLBmlD
        Y0sCXOwcjOzcfKzAtq4aNDB/AQQQzKEgV7Ows3EyAl3MCEubyAAU7QwsuEN0776jDN/fvGPgkFIG
        O/L3b0TLjYmfj4EBhEFB8/ETMMOIAFtUmG0MkJ3/wQ5hYgS1b0HWQt3GABBAyLmekQGzPcnw+88v
        cK2DD4Cqyumzl4DZzEzsKI5EBv++fweGzR+GX3//oDgOhtEAIxsLM9w9AAGEXI7+Z4AVesiG//rP
        8PX7D2DU8zLgCs+d+48yvHlwj4FR35bhxz9glLJyMPz79B7YDnoLjm4U8PUlw+e3xnjTO5J74H0s
        gACCORQk8BtE/2H4//8nwx9GDgaEDz99+czwE9iO/AysmUBVJzqYv2oTMGh4GZj4BCGGvXnFAMyV
        DFFxAQzADMrw4+s3hMd/fmYwMdZnAHZJsLoOaDfYkX9/g6szkC/B0QMQQDCH/mJj/f/129fPvxmw
        hCosWn5++QDECHEBXiGGY+fPMJzYdRjYxFaGCP7+wfD/5RuGCO8gBmDvEyz0/dMPFPN+/f0BLvRx
        tWN//PwL7Gf9+MnO9Oc0kAt2OUAAwUOUnZVj0/sPX/S/ff/y98dPfmZ+NmB6AlZtKADKB+VUsCWs
        jAz1E+aBxZjFxcCO/AcsRxkFBRgCPayBZS8jw5Nn77A6BlS/AxMthh1/f/1lAPaz/r598/6HgIDI
        XVjAAQQQPDMpSAhfffH+/edvP37/AfZx/v/4xcyADkAOBGFQzaKoKMnQP30Rw9n9wLJTSRuu5v/7
        DwwedsYMpoY6DC9fvwcX8OgYnNdADkRzJMjsH3//gvpVf1+9efMF6KbrMDmAAII7dHpX1d2P7z4A
        266ffgI7Yv+gaQVuAAiI8/IzSIqKMvAK8DPUtU1maO6axgBsn0GKH1BovHwFLIZ4GBJDvRn4udgY
        3n/7iRqK2HM3wpNAa758//UP2Pn78e7Tx7dAN92EyQEEEHKuf/vv/89ND569UJCSFOYW/snHxMH2
        C1w8gEIQBI5evsZw6/YdhtXb9jKcOHQK2GMTZGDkkYAUOyDw8QtDUlIQg5u1PsObV+/hjiMWADuC
        /z99+vbn2p2nn/k42bcxIPVMAQII2aH/1GWlD9198DRCTUmeX0jgCzMHOw8zqPCXUZZk2LzrCENS
        XCrDG2C+YOQRY2CUUmFgYEOUr/8fP2cwNlNkKM2KAfM/f/0FrruJBR9/fGP48PX3/8cv3vx48OjR
        SwtD7a0MSBkbIIBQWvjAoL7w4/v7VbfuPQSmgY9/vn7/9R+cBIBVJ9N/oAs5+RgYFTQZmGRl4NHN
        8Os32JFSylIMnbXVDBrAtPvs6WuSHPnjxy8GkF3vPn76fe7y9ffAwndzT3X2LWQ1AAGE3rn7baSj
        teXC1dt+kmKiPFycPPxAMWZgT5KRh18IrOA/sB7/C8SIoPjCYKCrwtDfU83gYKIB7haTAkDpHxTl
        Hz78+Hv55t3P127dfORjZbCUAW30BCCAMDp3QJ/c4Gf/M+HslWvPHj178e3Nh+9/n7/9yCAuKszA
        LyEKdhgjsDEsys3BYCAnwZCdFcawbn4Xg4OBItyRxIYmyJFfgZ08YJT/u/fs+dd9R048VRTlntBU
        lXsfXS1AAOEagOB0CM3KVVZQTDTQ15ZWkpLkUpYXYj50/AzD03ffGICNawZFSQEGbSVFcDEFqmVe
        vPhAkiNB0f3x5x9gLfPj34PnL76t3br/6fs3j5cd37SwgwFSS6IAgADCN1LCD3RsJtCxCUDHSoIc
        a2KgzAwsdhhBBTkIvH/3HdwYJgf8+PXnPzAk/959+BTkyOdAR64EOrILKPUVm3qAAMI3kPvxwOpp
        04GO/f/z7//YXz9+SgHFeKQl+ViAvUd4qwZWdIEArNEEK3eRiyZYTwEK/n/4/OfPucu3v2zbvf/Z
        1y9v1wAd2Y3LkSAAEEDEjObx+cbmBPxlFcg10laW0dZQ5tNUkmYTExJk5uXlZQS3U4kEP3/9+w9M
        739v3n/+69Cp859Onjn/WJCTYfLmxVPW4XMkCAAEELHjo6zZJbWG9159axIUEJZXUZIT1lVX5lZV
        EGNTlJYEllTwEMYYH4XRwK7Kv8t3Hv86dvbS19MXbr799PH5A31FqbqpPc3nGIgYHwUIIFJHnPlj
        Mkqs3n77X8TFxy8lJSYqqCAlwSUnLcEiJS7ADOzCICeL/x8+fvvz8t3Hv8DS4zewbP4OrEzeA8vp
        Z1L8nH1LZvSABheITuAAAUTOGD7IIXzAENb8+OV7+cdfjKC+NzcbFy/QnRzc7MyM4E4VMF3//P7r
        x9df3z5/+f7j71dgkfdWQpi/CxiCoIYGqGokyWKAACJ3sgEGQHUoqAPPX1zVIPzj198SKB8EvnGw
        Mff0tjWAxjtBFT+ohYJR7BALAAKIUofSDQAEEEbNNFgBQIABABWRKc05F+/jAAAAAElFTkSuQmCC
    `,
    play: `data:image/png;base64,
        iVBORw0KGgoAAAANSUhEUgAAACoAAAAqCAYAAADFw8lbAAAABGdBTUEAALGOfPtRkwAAACBjSFJN
        AAB6JQAAgIMAAPn/AACA6AAAdTAAAOpgAAA6lwAAF2+XqZnUAAANqUlEQVR4nGL8//8/w1AAAAHE
        QqF+RiAWzKnt13j9/oPKp09f5JEl+fh4HoqJSdyZXJd5Gcj9AsRkhwpAADGSGaJivkmlcXcfPcv+
        9eevAgcHB4MADw8DBxsbig/effrE8P3HD4Yf338wcHCyP1CWk5q6eV73PJAUqRYCBBCpDpU28kle
        9enLVysJEREGaQlhYKgJADEfAw8XGwM7CxPEUKArmRlZGH79+8vw9csXhvefvjN8fPea4eajFwzv
        339gEBTkP3Zuy1xfUhwMEEDEOpTJM664+sbdh03yUmIMygqKDJISIgyC/AIMAoJ8DHxcXAxs7OwI
        xUAHg9LUfyD8AQzRL19/MLz/+JXh9ds3DPcePmO4ce8uw7MXzxlM9bRLgSHcy0BEkgAIIGIcKqTi
        EPEEGL2cBlpaDArSogzi4uIMEsKCwJDkYmAHOhBkBjsbCwPjP6ADmRgZmIEB+xso9vvXH4Zff34z
        /Pz9B8z+DsTfvn5leP7yBcPVmw8YDpw8x8DJyfr9zoEVokB7vuJzBEAAEXKohLRZ8HNFOUkGQz1t
        BgUpCQY5aQkGIX4+Bg4OSDRzMDMzMLMxM7CDwhAY58zMjECHMzL8+fsH6MB/YIf++POX4dev30D2
        P4Yv374z/P79m4GN8R/D6et3GHYdOM7w+vWLv8/PbBNjwJMUAAIIn0PFgI58qakiz6APdKSWogSD
        jIwMOARBQICbFeJQYEiyMbAy/Pz5A+jI/wxsnDwMoJj8+wfkSKgDf/9l+AGkfwAd+PPbH4bPP78y
        /P75h4GR+R/Dg2cvGLbvOcLw4Onjv89ObcXpWIAAYsLhSFZF6xC4Iw00lMGO5OFkY+BlZWKQEORk
        YAOmQ34OLgZWVhaGN58/MszbcYjhy18Ghr///zJwcrAysLGxApMDMwMHOxs4WXAC+ZxAteycrAy8
        3BwMnNycwFjhZFBXVGBwd7BiUFdSYQbFHtBuZmwOAgggrOUoMGcfAOZMuCOlxETBUc0NdCgoBNmZ
        2BiYOBghUfKbkeHhy7cM01ZtZ/j48TNDSqAj0KGSwJAHJglgemViBIYcKK8wgsIZxP/NwAJ0ChvT
        X4bff/8y/GdiZtDTUAUni9cf3rMB7T4ELBGs0d0EEEAYIQosvK2AOdXK0tAAHN3YHMnOxc7AzALk
        c3IBxdkZfvz8Bda7dOcRhsnLtzM8e/4WGCxMwFAHpl1gDLACQ5ONlZWBi52FgQuonpuTm4GbC6SX
        E2ymIDDNG2goMDibGzO8fP3RqqR1qj66uwACCN2hzPuOn1lqoKXNoKykwCAhKoXVkSDAzcHGwMnC
        AnYMAyMina87eIZh5tptDE9evWb4BcxQrMBKgAOYTNg5gI7mACYBYEhzAR3PwQ5is4KTBDMrM4Og
        kACDiroag762JsOG3YePM0DqDDgACCAUhyaXdrsLCQgqqKrIMsgCy0luPk5wrkYJSWA64+bkAKc/
        djaghVwc4BBDBst2H2eYvmYHw+Onrxi+fv3OwAZMsxyskFBlB8YEKygDsjGBaVag+SxMTOBaTU5E
        jMFIVx3kec7Uqn5XZDMBAgjZoYznr9+oVleUZxAREgaXkRwswOhiY4ekSTZGsCM5gKEIciAIsAOr
        TiagJSyMmHly6Y6jDAu37WN4/OI1sKj6B44VdmDGYmVnAWcudlZQbADTKjB02YBpGZTR+IABI6cg
        xqCpoc5w/NzFKcjmAQQQsg1SQGwlIysBLsxBOZwDGMuMwOob5EhWYEiwAaOYCeh4UN0OwiAAjnSU
        SIKAf8Bib/H2owyrdh9jePjkJcPvf//ADmQDp1dgSIKSDTCEWYExwwKsIRiByYOHk5lBVFCIQVNR
        DlSjqQKNEYKZBxBAcIeG59Q7S4hJIkKTGVKIg0IT5EhQaLKwc8Ed8heYY/8C0yCwdAe6E4tLoY5d
        sO0gw5rdhxlevHzDACy9gMUZ0GGg0ASZB/Q0KwuIzwwMVVBSYmUQBWYwcUlgYAHbElF5bR4wswAC
        CO5QYD1sAmpkgHIlrFCHhSYIgKKcBVikcHOyABsaPxg+fv4CLOR/MfwBFub//+Gu3f4CQ3LGxgMM
        K7YdZnj46CnDlx/fwCEIwqysjEAa6EgWUAgD+cCGDDuwcSPEA3SshDjDi9dPLWDmAAQQrBxl+vXr
        Ry6oFQRqYLAy/YdUi0yQZhsoNEGBxgYMgV9Ax4GKo///gPU5UPg/sPz7C+LgASDHTlyzC1il/mbw
        tjUDtxfYubgZWIAh/g9avDP+BZaxLP8ZOIGhwwnMF5KCPAz3H/wwZoAkrP8AAQRzKDMDIye4qQZq
        BcGKIxBgBTqODegQJmAIgApoUHX4H8j//xdoCbCK/Afk//uH36Ewx87efIDhH1Cfv4MZg4ykODCd
        A0sRYEb8DyregIHzD2guI1Cekx1YqnDzgapgKwZITfUHIIDgIQoi2Nk4gamSEZ42QQDUFgCnQlCb
        ABjFwBoSzP4LEgU6FBS0oFAlBoDq/nnbDzEoARs2/AJ84Iz1HxobQGeCg44JVHsBkxso0KAAnPYA
        AohgV+Q/sPH7F+hwUCMDGFcQh/1jBDv6HzAk/gNbSH///SXKoSAgJsADzLD8wIwI8vQ/sMf/gTwN
        K+KQ/AyuTKAAIIAIOhRk4F+go0DRDjLjH7AJB8rN/8EOBUXpH3C0EgNE+bgZ8kPdGKTFRYE1GzvD
        n3//GOBlBoFmMUAAwRwKt+kPUMdPIMnBAI16oI9/Axu+/4C+Z2KChORfIBuUnpiBDWWQI//iyfUw
        IABsLRWEejDoqasyiAjwg0MLWxMTZDcI/P39ByYEdhtAAMEc+oeN9T+w9f0ZQyPIzwx/gM5nBOY3
        pv/g3A7S+u8/UAyYZSEOxR+ifMBqtiDMncFcX4tBVFgA2KpihgYg9vL3x8+/DB+B3Rd2pj9rQG4G
        iQEEEKwc/c/OylH3/sMXhm/fvwAVghzzHWLUf0ioggr4P0AD/oBoYEEPSrKgqAOFNsMf3CEKangU
        hLozWOpqMYgJC4EdCQf/f2Oo//sLWLL8/Mnw9s17BgEBkUswcYAAghf4ChLCh1+8f8/w7Qeo6wBq
        jYMM/A+G/xggUQ0s3sEOBnczoeA3MLT/4ChHQfV5pq8Dg4WOJoOYqDAk6SADRtTGzM9/wDIaaP6n
        b98YXr15A3YTTA4ggOAOnd5VdeXjuw8MH95/YvgK7N7+BEYtKNOACnOQQ0A0yJq/UEfDACszC9a0
        BqoaU73tGGwNdBnExIXBNREh8B/YrP3y/RfDS2Dn792njyA3nYXJAQQQsu63//7/nAzqw3z+Aaoe
        gT4ERjHISUygEGT8D8ntQAxy+L9/EDa0eEUBzMAWVZavE4OXtSmDtIwEuInHyIg9PSKDb79+Mnz6
        9I3h2p2nDHyc7LOAQvBMAxBAyA79ry4rve7ug6cMb99/Yfj87SuwQwbsRgAdyMICaeGwAh0A7JGB
        HQnqG4EwKFf8RwphkKfi3KwZfBwsGSSAxRAXOxsDMeAjsA3w4etvYLPwDcODR48YTAy0pyHLAwQQ
        SnwAg/rwj+/vJ9+4/4Dh7cdP4IGDP38gxRKopcMEapKxgBoSjOCQBgXkH2CGAKVFGIhwNGMIdbdl
        kBQTAreQiAE/fvxi+AqM8ndAO89dvg40+PvSnursS8hqAAIIPeH8NdLRmnvj2h2Gew9fMLz5CAzZ
        77/BuRvkLCZGUCMZGLXg1g+koP4L7PKyQ0Mt3suWIdTVlkGAh5coB4IAKAOBovzDhx8Ml2/eZbh2
        6yaDk7FBPQNaFQAQQBgpHOiTi3zsvzPPXr3K8Pj5G4bnrz8Ae5fAYhhYVYJCF5YeQY4FDd2ws7Iz
        8AC7vykBjgzhzlYMwoICDHzAZhqxjvz65Sc4yu89e86w78gJBkVR7vSmqty76GoBAgjXAAS7Q2j2
        BGV5hQx9YCGtKC0N7EPxAh0FKvSZwG1HsEOBbFAmAXkANGTzG1gGcnGwYzMPA4Ci++PPPwxfv/1g
        ePD8BcParfsZ3r95vOb4poURDNBCHhkABBCuRPTzwOqpZQ6hWaDGTNp/YBplZAR1nfkZuLlZIZ0z
        UPfhPxPD198/Ia18YNywAFs9oFAiBoCqSlB5jebIOGyOBAGAAMKX2j8fWD2tBOhYYDH1P+3P9x/A
        RKPEIC0GTKsMnAw/QdUgsEHCBS7EQQkX2F6FOQLqWFhTEQRgPQUY+PD5DzDj3GbYtns/MPrfwhz5
        HZdjAAKImNE8Xt/YnPS/rALdBtqqDDoaCgyaCjLA6lCAgRfYIwCNeBALfv76x/D87UeGm/efMxw6
        dZ7h5JnzDIKcDKWbF0+Zis+RIAAQQMSOjzJnl9Ra3Xv17ZCggDCDirIcg66aMoMqsGurKC3JwM/H
        RdCAZy/fMVy+85jh2NlLDKcv3GT49PE5g76ilN3UnuYjDESMjwIEEKkjzrwxGSUeb7/9X8XFxw8e
        7oENRUqJC0C6MBwIR3/4+I3h5buPDI+Atd2tew8ZQJUJsJxmkOLnDFsyo2cHA1LNQwgABBC5Y/i8
        wBA2+Pjl+6GPvyBpj42LF9gpA/Z1mCF8YLpm+P7rB8Ovb58Zvv/4y8DP/odBQpgfFIIXSHEgDAAE
        ELkOhQFQEwsUhPzFVQ1iP379PYssycHGbNzb1vAKyHwLxKAcRnyCRgMAAUSpQ+kGAAKIcNtrkACA
        AAMACHALg12qSjsAAAAASUVORK5CYII
    `,
};

var CSS =
    /*
     * Flash Click to View by Ted Mielczarek (luser_mozilla@perilith.com)
     * Original code by Jesse Ruderman (jruderman@hmc.edu)
     * taken from http://www.squarefree.com/userstyles/xbl.html
     *
     * Change XBL binding for  tags, click to view flash
     */
    String.raw`

    pseudoembed {
            display: inline-block;
            min-width: 32px !important;
            min-height: 32px !important;
            border: 1px solid #dfdfdf;
            cursor: pointer;
            overflow: hidden;
            -moz-box-sizing: border-box;
            background: url("${data.play}") no-repeat center;
    }
    pseudoembed:hover {
            background-image: url("${data.flash}");
    }

    video,
    object[classid*=":D27CDB6E-AE6D-11cf-96B8-444553540000"],
    object[codebase*="swflash.cab"],
    object[data*=".swf"],
    embed[type="application/x-shockwave-flash"],
    embed[src*=".swf"],
    object[type="application/x-shockwave-flash"],
    object[src*=".swf"] {
            -moz-binding: url("{bindings}") !important;
    }

    /// TODO: Could do better.
    /// NoScript is incredibly annoying. The binding can't execute JS on
    /// untrusted sites.
    video:not([flashblock]),
    object[classid*=":D27CDB6E-AE6D-11cf-96B8-444553540000"]:not([flashblock]),
    object[codebase*="swflash.cab"]:not([flashblock]),
    object[data*=".swf"]:not([flashblock]),
    embed[type="application/x-shockwave-flash"]:not([flashblock]),
    embed[src*=".swf"]:not([flashblock]),
    object[type="application/x-shockwave-flash"]:not([flashblock]),
    object[src*=".swf"]:not([flashblock]) {
        display: none !important;
    }

    /// Java identifiers.
    /// TODO: Make this work.
    /// applet,
    /// object[classid*=":8AD9C840-044E-11D1-B3E9-00805F499D93"],
    /// object[classid^="clsid:CAFEEFAC-"],
    /// object[classid^="java:"],
    /// object[type="application/x-java-applet"],
    /// embed[classid*=":8AD9C840-044E-11D1-B3E9-00805F499D93"],
    /// embed[classid^="clsid:CAFEEFAC-"],
    /// embed[classid^="java:"],
    /// embed[type="application/x-java-applet"]
    /// {
    ///      -moz-binding: url("{bindings}") !important;
    /// }
`.replace(/\/\/\/.*/gm, "");

styles.system.add("flashblock", "*", CSS);
data = null;
CSS = null;

/* vim:se sts=4 sw=4 et: */
dactyl-1.2~r20151231/plugins/http-headers.js000077500000000000000000000116741264147376100204710ustar00rootroot00000000000000"use strict";
isGlobalModule = true;

var INFO =
["plugin", { name: "http-headers",
             version: "0.7",
             href: "http://dactyl.sf.net/pentadactyl/plugins#http-headers-plugin",
             summary: "HTTP header info",
             xmlns: "dactyl" },
    ["author", { email: "maglione.k@gmail.com" },
        "Kris Maglione"],
    ["license", { href: "http://opensource.org/licenses/mit-license.php" },
        "MIT"],
    ["project", { name: "Pentadactyl", "min-version": "1.0" }],

    ["p", {},
        "Adds request and response headers to the :pageinfo ",
        "command, with the keys ", ["em", {}, "h"], " and ", ["em", {}, "H"], " respectively. ",
        "See also ", ["o", {}, "pageinfo"], "."],

    ["example", {}, ["ex", {}, ":pageinfo hH"]]];

var { Buffer } = require("buffer");

var Controller = Class("Controller", XPCOM(Ci.nsIController), {
    init: function (command, data) {
        this.command = command;
        this.update(data);
    },
    get wrappedJSObject() { return this; },
    supportsCommand: function (cmd) { return cmd === this.command; },
});

var winMap = new WeakMap();
var docMap = new WeakMap();

var HttpObserver = Class("HttpObserver",
    XPCOM([Ci.nsIObserver, Ci.nsISupportsWeakReference, Ci.nsIWebProgressListener]), {

    init: function init() {
        util.addObserver(this);
    },

    cleanup: function cleanup() {
        this.observe.unregister();
    },

    extractHeaders: function extractHeaders(request, type) {
        let major = {}, minor = {};
        request.QueryInterface(Ci.nsIHttpChannelInternal)["get" + type + "Version"](major, minor);

        let headers = [[type.toUpperCase(), "HTTP/" + major.value + "." + minor.value]];
        request["visit" + type + "Headers"]({
            visitHeader: function (header, value) {
                headers.push([header, value]);
            }
        });
        return headers;
    },

    getHeaders: function getHeaders(win, request) {
        request.QueryInterface(Ci.nsIChannel);

        let doc = win.document;

        let data = docMap.get(doc);
        let headers = data && data.headers || {};

        if ("response" in headers)
            return;

        if (win && /^https?$/.test(request.URI.scheme)) {
            if (request instanceof Ci.nsIHttpChannel)
                request.QueryInterface(Ci.nsIHttpChannel);
            else {
                request.QueryInterface(Ci.nsIMultiPartChannel);
                request.baseChannel.QueryInterface(Ci.nsIHttpChannel);
            }

            headers.request  = this.extractHeaders(request, "Request");
            headers.request[0][1] = request.requestMethod + " " +
                request.URI.path + " " + headers.request[0][1];

            try {
                headers.response = this.extractHeaders(request, "Response");
                headers.response[0][1] += " " + request.responseStatus + " " +
                    request.responseStatusText;
            }
            catch (e) {}

            let data = { headers: headers, url: doc.documentURI };
            winMap.set(win, data);
            docMap.set(doc, data);
        }
    },

    observers: {
        "http-on-examine-response": util.wrapCallback(function onExamineResponse(request, data) {
            request.QueryInterface(Ci.nsIChannel).QueryInterface(Ci.nsIHttpChannel).QueryInterface(Ci.nsIRequest);

            if (request.loadFlags & request.LOAD_DOCUMENT_URI) {
                try {
                    var win = request.notificationCallbacks.getInterface(Ci.nsIDOMWindow);
                }
                catch (e) {
                    return;
                }
                this.getHeaders(win, request);
                try {
                    webProgress.addProgressListener(this, Ci.nsIWebProgress.NOTIFY_STATE_DOCUMENT);
                }
                catch (e) {}
            }
        })
    },

    onStateChange: util.wrapCallback(function(webProgress, request, stateFlags, status) {
        if ((stateFlags & this.STATE_START) && (stateFlags & this.STATE_IS_DOCUMENT))
            this.getHeaders(webProgress.DOMWindow, request);
        else if ((stateFlags & this.STATE_STOP) && (stateFlags & this.STATE_IS_DOCUMENT)) {
            this.getHeaders(webProgress.DOMWindow, request);
            try {
                webProgress.removeProgressListener(this);
            } catch (e) {}
        }
    }),
});

let observer = HttpObserver();
let onUnload = observer.bound.cleanup;

function* iterHeaders(buffer, type) {
    let win = buffer.focusedFrame;
    let store = docMap.get(win.document);
    if (!store || !store.headers)
        store = winMap.get(win);

    if (store)
        for (let [k, v] of (store.headers[type] || []))
            yield [k, v];
}

iter({ h: "Request", H: "Response" }).forEach(function ([key, name]) {
    Buffer.addPageInfoSection(key, name + " Headers", function (verbose) {
        if (verbose)
            return iterHeaders(this, name.toLowerCase())
    });
});

/* vim:se sts=4 sw=4 et: */
dactyl-1.2~r20151231/plugins/jscompletion.js000077500000000000000000000123211264147376100205750ustar00rootroot00000000000000"use strict";
var INFO =
["plugin", { name: "jscompletion",
             version: "1.0.4",
             href: "http://dactyl.sf.net/pentadactyl/plugins#jscompletion-plugin",
             summary: "JavaScript completion enhancements",
             xmlns: "dactyl" },
    ["author", { email: "maglione.k@gmail.com" },
        "Kris Maglione"],
    ["license", { href: "http://people.freebsd.org/~phk/" },
        "BEER-WARE"],
    ["project", { name: "Pentadactyl", "min-version": "1.0" }],
    ["p", {},
        "This plugin provides advanced completion functions for ",
        "DOM functions, eval, and some other special functions. ",
        "For instance, ",
        "", ["ex", {}, ':js content.document.getElementById("',
               ["k", { name: "Tab", link: "c_" }], ], " ",
        "should provide you with a list of all element IDs ",
        "present on the current web page. Many other DOM ",
        "methods are provided, along with their namespaced variants."]];

function evalXPath(xpath, doc, namespace) {
    let res = doc.evaluate(xpath, doc,
        function getNamespace(prefix) {
            return {
                html:       "http://www.w3.org/1999/xhtml",
                dactyl:     NS,
                ns:         namespace
            }[prefix];
        },
        XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE,
        null
    );
    return function* () {
        for (let i = 0; i < res.snapshotLength; i++)
            yield res.snapshotItem(i);
    }();
}

let NAMESPACES = [
    ["http://purl.org/atom/ns#", "Atom 0.3"],
    ["http://www.w3.org/2005/Atom", "Atom 1.0"],
    [NS, "Dactyl"],
    ["http://www.w3.org/2005/Atom", "RSS"],
    ["http://www.w3.org/2000/svg", "SVG"],
    ["http://www.mozilla.org/xbl", "XBL"],
    ["http://www.w3.org/1999/xhtml", "XHTML 1.0"],
    ["http://www.w3.org/2002/06/xhtml2", "XHTML 2.0"],
    ["http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul", "XUL"]
];

function addCompleter(names, fn) {
    for (let name of util.debrace(names))
        javascript.completers[name] = fn;
}
function* uniq(iter) {
    let seen = new RealSet()
    for (let val of iter)
        if (!seen.add(val))
            yield val;
}

addCompleter("__lookup{Getter,Setter}__", function (context, func, obj, args) {
    if (args.length == 1)
        context.completions =
            [[k, obj[func](k)] for (k of properties(obj))].concat(
            [[k, obj[func](k)] for (k of properties(obj, true))]).filter(
                ([k, v]) => v);
});

addCompleter("eval", function (context, func, obj, args) {
    if (args.length > 1)
        return [];
    if (!context.cache.js) {
        context.cache.js = JavaScript();
        context.cache.context = CompletionContext("");
    }
    let ctxt = context.cache.context;
    context.keys = { text: "text", description: "description" };
    ctxt.filter = context.filter;
    context.cache.js.complete(ctxt);
    context.advance(ctxt.offset);
    context.completions = ctxt.allItems.items;
});

addCompleter("getOwnPropertyDescriptor", function (context, func, obj, args) {
    context.anchored = false;
    context.keys = { text: util.identity, description: () => "" };
    if (args.length == 2)
        return properties(args[0]);
});

addCompleter("getElementById", function (context, func, doc, args) {
    context.anchored = false;
    if (args.length == 1) {
        context.keys = { text: e => e.getAttribute("id"), description: util.objectToString };
        context.generate = () => evalXPath("//*[@id]", doc);
    }
});

function addCompleterNS(names, fn) {
    addCompleter(names + "{,NS}", function checkNS(context, func, obj, args) {
        context.anchored = false;
        context.keys = { text: util.identity, description: () => "" };
        let isNS = /NS$/.test(func);
        if (isNS && args.length == 1)
            return NAMESPACES;
        let prefix = isNS ? "ns:" : "";
        return fn(context, func, obj, args, prefix, isNS && args.shift());
    });
}

addCompleterNS("getElementsByClassName", function (context, func, doc, args, prefix, namespace) {
    if (args.length == 1) {
        let iter = evalXPath("//@" + prefix + "class", doc, namespace);
        return array(e.value.split(" ") for (e of iter)).flatten().uniq().array;
    }
});

addCompleterNS("{getElementsByTagName,createElement}", function (context, func, doc, args, prefix, namespace) {
    if (args.length == 1) {
        let iter = evalXPath("//" + prefix + "*", doc, namespace);
        return uniq(e.localName.toLowerCase() for (e of iter));
    }
});

addCompleterNS("getElementsByAttribute", function (context, func, doc, args, prefix, namespace) {
    switch (args.length) {
    case 1:
        let iter = evalXPath("//@" + prefix + "*", doc, namespace);
        return uniq(e.name for (e of iter));
    case 2:
        iter = evalXPath("//@" + prefix + args[0], doc, namespace);
        return uniq(e.value for (e of iter));
    }
});

addCompleterNS("{get,set,remove}Attribute", function (context, func, node, args, prefix, namespace) {
    context.keys = { text: 0, description: 1 };
    if (args.length == 1)
        return [[a.localName, a.value]
                for (a of array.iterValues(node.attributes))
                if (!namespace || a.namespaceURI == namespace)];
});

/* vim:se sts=4 sw=4 et: */
dactyl-1.2~r20151231/plugins/noscript.js000077500000000000000000000460541264147376100177420ustar00rootroot00000000000000/*
 * Copyright ©2010-2014 Kris Maglione 
 * Distributable under the terms of the MIT license.
 *
 * Documentation is at the tail of this file.
 */
"use strict";

if (!("noscriptOverlay" in window)) {
    if (!userContext.noscriptIgnoreMissing)
        dactyl.echoerr("This plugin requires the NoScript add-on.");
    throw Finished();
}

/*
 *  this.globalJS ? !this.alwaysBlockUntrustedContent || !this.untrustedSites.matches(s)
 *                : this.jsPolicySites.matches(s) && !this.untrustedSites.matches(s) && !this.isForbiddenByHttpsStatus(s));
 */

function getSites() {
    // This logic comes directly from NoScript. To my mind, it's insane.
    const ns     = services.noscript;
    const global = options["script"];
    const groups = { allowed: ns.jsPolicySites, temp: ns.tempSites, untrusted: ns.untrustedSites };
    const show   = new RealSet(options["noscript-list"]);
    const sites  = window.noscriptOverlay.getSites();

    const blockUntrusted = global && ns.alwaysBlockUntrustedContent;

    let res = [];
    for (let site of array.iterValues(Array.concat(sites.topSite, sites))) {
        let ary = [];

        let untrusted    = groups.untrusted.matches(site);
        let matchingSite = null;
        if (!untrusted)
            matchingSite = groups.allowed.matches(site) || blockUntrusted && site;

        let enabled = Boolean(matchingSite);
        if (site == sites.topSite && !ns.dom.getDocShellForWindow(content).allowJavascript)
            enabled = false;

        let hasPort = /:\d+$/.test(site);

        if (enabled && !global || untrusted) {
            if (!enabled || global)
                matchingSite = untrusted;

            if (hasPort && ns.ignorePorts)
                if (site = groups.allowed.matches(site.replace(/:\d+$/, "")))
                    matchingSite = site;
            ary.push(matchingSite);
        }
        else {
            if ((!hasPort || ns.ignorePorts) && (show.has("full") || show.has("base"))) {
                let domain = !ns.isForbiddenByHttpsStatus(site) && ns.getDomain(site);
                if (domain && ns.isJSEnabled(domain) == enabled) {
                    ary = util.subdomains(domain);
                    if (!show.has("base") && ary.length > 1)
                        ary = ary.slice(1);
                    if (!show.has("full"))
                        ary = ary.slice(0, 1);
                }
            }

            if (show.has("address") || ary.length == 0) {
                ary.push(site);

                if (hasPort && ns.ignorePorts) {
                    site = site.replace(/:\d+$/, "");
                    if (!groups.allowed.matches(site))
                        ary.push(site);
                }
            }
        }
        res = res.concat(ary);
    }

    let seen = new RealSet();
    return res.filter(function (h) {
        let res = !seen.has(h);
        seen.add(h);
        return res;
    });
}
function getObjects() {
    let sites = noscriptOverlay.getSites();
    let general = [], specific = [];
    for (let group of values(sites.pluginExtras))
        for (let obj of array.iterValues(group)) {
            if (!obj.placeholder && (ns.isAllowedObject(obj.url, obj.mime) || obj.tag))
                continue;
            specific.push(obj.mime + "@" + obj.url);
            general.push("*@" + obj.url);
            general.push("*@" + obj.site);
        }
    sites = buffer.allFrames().map(f => f.location.host);
    for (let filter of values(options["noscript-objects"])) {
        let host = util.getHost(util.split(filter, /@/, 2)[1]);
        if (sites.some(s => s == host))
            specific.push(filter);
    }
    let seen = new RealSet();
    return specific.concat(general).filter(function (site) {
        let res = !seen.has(site);
        seen.add(site);
        return res;
    });
}

var onUnload = overlay.overlayObject(gBrowser, {
    // Extend NoScript's bookmarklet handling hack to the command-line
    // Modified from NoScript's own wrapper.
    loadURIWithFlags: function loadURIWithFlags(url) {
        let args = arguments;
        let load = () => loadURIWithFlags.superapply(gBrowser, args);

        if (!commandline.command || !util.isDactyl(Components.stack.caller))
            return load();

        try {
            for (let [cmd, args] of commands.parseCommands(commandline.command))
                var origURL = args.literalArg;

            let isJS = url => /^(?:data|javascript):/i.test(url);
            let allowJS = prefs.get("noscript.allowURLBarJS", true);

            if (isJS(origURL) && allowJS) {
                if (services.noscript.executeJSURL(origURL, load))
                    return;
            }
            else if (url != origURL && isJS(url)) {
                if(services.noscript.handleBookmark(url, load))
                    return;
            }
        }
        catch (e) {
            util.reportError(e);
        }
        return load();
    }
});

highlight.loadCSS(String.raw`
    NoScriptAllowed         color: green;
    NoScriptBlocked         color: #444; font-style: italic;
    NoScriptTemp            color: blue;
    NoScriptUntrusted       color: #c00; font-style: italic;
`);

let groupProto = {};
["temp", "jsPolicy", "untrusted"].forEach(function (group) {
    memoize(groupProto, group,
            function () {
                return services.noscript[group + "Sites"].matches(this.site);
            });
});
let groupDesc = {
    NoScriptTemp:       "Temporarily allowed",
    NoScriptAllowed:    "Allowed permanently",
    NoScriptUntrusted:  "Untrusted",
    NoScriptBlocked:    "Blocked"
};

function splitContext(context, list) {
    for (let [name, title, filter] of values(list)) {
        let ctxt = context.split(name);
        ctxt.title = [title];
        ctxt.filters.push(filter);
    }
}

completion.noscriptObjects = function (context) {
    let whitelist = options.get("noscript-objects").set;
    context = context.fork();
    context.compare = CompletionContext.Sort.unsorted;
    context.generate = getObjects;
    context.keys = {
        text: util.identity,
        description: key => whitelist.has(key) ? "Allowed" : "Forbidden"
    };
    splitContext(context, getObjects, [
        ["forbidden", "Forbidden objects", item => !whitelist.has(item.item)],
        ["allowed",   "Allowed objects",   item => whitelist.has(item.item)]]);
};
completion.noscriptSites = function (context) {
    context.compare = CompletionContext.Sort.unsorted;
    context.generate = getSites;
    context.keys = {
        text: util.identity,
        description: site => groupDesc[this.highlight] +
            (this.groups.untrusted && this.highlight != "NoScriptUntrusted" ? " (untrusted)" : ""),

        highlight: function (site) {
            return this.groups.temp      ? "NoScriptTemp" :
                   this.groups.jsPolicy  ? "NoScriptAllowed" :
                   this.groups.untrusted ? "NoScriptUntrusted" :
                                           "NoScriptBlocked";
        },
        groups: site => ({ site: site, __proto__: groupProto })
    };
    splitContext(context, [
        ["normal",    "Active sites",    item => item.groups.jsPolicy || !item.groups.untrusted],
        ["untrusted", "Untrusted sites", item => !item.groups.jsPolicy && item.groups.untrusted]]);
    context.maxItems = 100;
}

services.add("noscript", "@maone.net/noscript-service;1");

var PrefBase = "noscript.";
var Pref = Struct("text", "pref", "description");
let prefs = {
    forbid: [
        ["bookmarklet", "forbidBookmarklets", "Forbid bookmarklets"],
        ["collapse",    "collapseObject",     "Collapse forbidden objects"],
        ["flash",       "forbidFlash",        "Block Adobe® Flash® animations"],
        ["fonts",       "forbidFonts",        "Forbid remote font loading"],
        ["frame",       "forbidFrames",       "Block foreign  elements"],
        ["iframe",      "forbidIFrames",      "Block foreign