26 |
27 | ### Collaboratively edit
28 |
29 | 
30 |
31 | ### Share terminals
32 |
33 | 
34 |
35 | ---
36 |
37 | ## Configuration
38 |
39 | On first usage, the plugin will guide you through the setup process. If you don't already have a Floobits account, it will help you create one for free.
40 |
41 |
42 | ## Help
43 |
44 | If you have trouble setting up or using this plugin, please [contact us](https://floobits.com/help#support).
45 |
--------------------------------------------------------------------------------
/keymaps/floobits.cson:
--------------------------------------------------------------------------------
1 | # Keybindings require three things to be fully defined: A selector that is
2 | # matched against the focused element, the keystroke and the command to
3 | # execute.
4 | #
5 | # Below is a basic keybinding which registers on all platforms by applying to
6 | # the root workspace element.
7 |
8 | # For more detailed documentation see
9 | # https://atom.io/docs/latest/advanced/keymaps
10 |
11 | 'atom-workspace':
12 | # 'ctrl-alt-o': 'Floobits: Join Recent Workspace'
13 | 'ctrl-shift-j': 'Floobits: Join Workspace'
14 | 'ctrl-shift-alt-a': 'Floobits: Toggle Follow Mode'
15 | 'ctrl-shift-alt-s': 'Floobits: Summon'
16 |
17 |
18 | '.floobits-nativize webview':
19 | 'tab': 'native!'
20 | 'shift-tab': 'native!'
21 | 'click': 'native!'
22 | 'enter': 'native!'
23 | 'backspace': 'native!'
24 | 'shift-backspace': 'native!'
25 | 'delete': 'native!'
26 | 'up': 'native!'
27 | 'down': 'native!'
28 | 'shift-up': 'native!'
29 | 'shift-down': 'native!'
30 | 'alt-up': 'native!'
31 | 'alt-down': 'native!'
32 | 'alt-shift-up': 'native!'
33 | 'alt-shift-down': 'native!'
34 | 'cmd-up': 'native!'
35 | 'cmd-down': 'native!'
36 | 'cmd-shift-up': 'native!'
37 | 'cmd-shift-down': 'native!'
38 | 'ctrl-up': 'native!'
39 | 'ctrl-down': 'native!'
40 | 'ctrl-shift-up': 'native!'
41 | 'ctrl-shift-down': 'native!'
42 | 'left': 'native!'
43 | 'right': 'native!'
44 | 'shift-left': 'native!'
45 | 'shift-right': 'native!'
46 | 'alt-left': 'native!'
47 | 'alt-right': 'native!'
48 | 'alt-shift-left': 'native!'
49 | 'alt-shift-right': 'native!'
50 | 'cmd-left': 'native!'
51 | 'cmd-right': 'native!'
52 | 'cmd-shift-left': 'native!'
53 | 'cmd-shift-right': 'native!'
54 | 'ctrl-left': 'native!'
55 | 'ctrl-right': 'native!'
56 | 'ctrl-shift-left': 'native!'
57 | 'ctrl-shift-right': 'native!'
58 | 'ctrl-b': 'native!'
59 | 'ctrl-f': 'native!'
60 | 'ctrl-F': 'native!'
61 | 'ctrl-B': 'native!'
62 | 'ctrl-h': 'native!'
63 | 'ctrl-d': 'native!'
64 |
--------------------------------------------------------------------------------
/lib/atom_utils.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | const _ = require("lodash");
4 | const AtomRange = require("atom").Range;
5 | const wrapper = require("./react_wrapper");
6 |
7 | module.exports = {
8 | rangeFromEditor: function (editor) {
9 | const selections = editor.selections;
10 |
11 | if (selections.length <= 0) {
12 | return [0, 0];
13 | }
14 |
15 | return _.map(selections, function (selection) {
16 | const range = selection.getBufferRange();
17 | const start = editor.buffer.characterIndexForPosition(range.start);
18 | const end = editor.buffer.characterIndexForPosition(range.end);
19 | return [start, end];
20 | });
21 | },
22 |
23 | offsetToBufferRange: function (buffer, start, end) {
24 | if (!buffer) {
25 | return null;
26 | }
27 | if (!buffer.positionForCharacterIndex) {
28 | console.error("no buffer.positionForCharacterIndex()!");
29 | return null;
30 | }
31 | const startPoint = buffer.positionForCharacterIndex(start);
32 | const endPoint = buffer.positionForCharacterIndex(end);
33 | return new AtomRange(startPoint, endPoint);
34 | },
35 | addRightPanel: function (name, view, styles) {
36 | const DOMNode = wrapper.create_node(name, view, styles);
37 | const pane = atom.workspace.addRightPanel({item: DOMNode});
38 | DOMNode.onDestroy(pane);
39 | return pane;
40 | },
41 | addModalPanel: function (element_name, view) {
42 | const DOMNode = wrapper.create_node(element_name, view, {width: "100%", height: "100%", overflow: "auto"});
43 | const pane = atom.workspace.addModalPanel({item: DOMNode});
44 | DOMNode.onDestroy(pane);
45 | }
46 | };
47 |
--------------------------------------------------------------------------------
/lib/common/api.js:
--------------------------------------------------------------------------------
1 | /*global fl */
2 | "use strict";
3 | "use babel";
4 |
5 | const _ = require("lodash");
6 | const request = require("request");
7 | const floorc = require("./floorc");
8 | const utils = require("./utils");
9 |
10 | const USER_AGENT = `Floobits Plugin ${fl.PLUGIN_VERSION} Atom-${process.version} ${process.platform} node-${process.versions.node}`;
11 |
12 | let ERRORS_SENT = 0;
13 | let MAX_ERROR_REPORTS = 5;
14 | let ERROR_COUNT = 0;
15 |
16 | function api_request (host, path, data, method, cb, opts) {
17 | const creds = floorc.auth[host];
18 | const options = {
19 | headers: {
20 | "Accept": "application/json",
21 | "User-Agent": USER_AGENT,
22 | },
23 | strictSSL: false,
24 | };
25 |
26 | if (creds) {
27 | options.auth = {
28 | user: creds.api_key || creds.username,
29 | pass: creds.secret,
30 | sendImmediately: true
31 | };
32 | }
33 |
34 | if (data) {
35 | options.json = data;
36 | }
37 |
38 | if (opts) {
39 | _.merge(options, opts);
40 | }
41 |
42 | const url = "https://" + host + path;
43 | try {
44 | request[method](url, options, function (err, res, body) {
45 | if (err) {
46 | return cb(err, res, body);
47 | }
48 |
49 | if (res.statusCode >= 300) {
50 | let message;
51 | try {
52 | message = JSON.parse(body).detail;
53 | return cb(message, res);
54 | } catch (ignored) {
55 | return cb(res.statusMessage || res.statusCode, res);
56 | }
57 | }
58 | if (data) {
59 | return cb(null, res, body);
60 | }
61 | try {
62 | return cb(null, res, JSON.parse(body));
63 | } catch (e) {
64 | return cb(e, res, body);
65 | }
66 | });
67 | } catch (e) {
68 | return cb(e);
69 | }
70 | }
71 |
72 | module.exports = {
73 | post_code_review: function (host, owner, workspace, description, cb) {
74 | const path = `/api/workspace/${owner}/${workspace}/review`;
75 | return api_request(host, path, {description: description}, "post", cb);
76 | },
77 | get_credentials: function (host, username, password, cb) {
78 | return api_request(host, `/api/user/credentials/`, null, "get", cb, {
79 | auth: {
80 | user: username,
81 | pass: password
82 | }
83 | });
84 | },
85 | create_workspace: function (host, name, owner, perms, cb) {
86 | const path = `/api/workspace`;
87 | const post_data = {
88 | name: name,
89 | owner: owner,
90 | perms: perms
91 | };
92 | return api_request(host, path, post_data, "post", cb);
93 | },
94 | delete_workspace: function (host, owner, workspace, cb) {
95 | const path = `/api/workspace/${owner}/${workspace}`;
96 | return api_request(host, path, null, "DELETE", cb);
97 | },
98 | update_workspace: function (workspace_url, data, cb) {
99 | var result = utils.parse_url(workspace_url);
100 | const path = `/api/workspace/${result.owner}/${result.workspace}`;
101 | return api_request(result.host, path, data, "put", cb);
102 | },
103 | get_workspace_by_url: function (url, cb) {
104 | var result = utils.parse_url(url);
105 | const path = `/api/workspace/${result.owner}/${result.workspace}`;
106 | return api_request(result.host, path, null, "get", cb);
107 | },
108 | get_workspace: function (host, owner, workspace, cb) {
109 | const path = `/api/workspace/${owner}/${workspace}`;
110 | return api_request(host, path, null, "get", cb);
111 | },
112 | get_workspaces: function (host, cb) {
113 | const path = `/api/workspaces/can/view`;
114 | return api_request(host, path, null, "get", cb);
115 | },
116 | get_orgs: function (host, cb) {
117 | const path = `/api/orgs`;
118 | return api_request(host, path, null, "get", cb);
119 | },
120 | get_orgs_can_admin: function (host, cb) {
121 | const path = `/api/orgs/can/admin`;
122 | return api_request(host, path, null, "get", cb);
123 | },
124 | send_error: function (description, error) {
125 | ERROR_COUNT += 1;
126 | let data = {
127 | jsondump: {
128 | error_count: ERROR_COUNT
129 | },
130 | message: {},
131 | dir: fl.base_path,
132 | };
133 |
134 | let stack = "";
135 |
136 | if (error) {
137 | stack = error.stack;
138 | description = description || error.message;
139 | }
140 |
141 | data.message = {
142 | description: description,
143 | stack: stack
144 | };
145 |
146 | console.log("Floobits plugin error! Sending exception report: ", data.message);
147 | if (ERRORS_SENT >= MAX_ERROR_REPORTS) {
148 | console.warn("Already sent ", ERRORS_SENT, " errors this session. Not sending any more.\n", description, error, stack);
149 | return;
150 | }
151 |
152 | let floourl = require("../floobits").floourl;
153 |
154 | let host;
155 |
156 | if (floourl) {
157 | data.owner = floourl.owner;
158 | data.workspace = floourl.workspace;
159 | data.username = "????";
160 | host = floourl.host;
161 | } else {
162 | host = "floobits.com";
163 | }
164 |
165 | try {
166 | let api_url = `https://${host}/api/log`;
167 | ERRORS_SENT += 1;
168 | api_request(host, api_url, data, "get", function (err) {
169 | if (err) {
170 | console.error(err);
171 | }
172 | });
173 |
174 | } catch (e) {
175 | console.error(e);
176 | }
177 | }
178 | };
179 |
180 |
181 |
182 | // function send_errors (f) {
183 | // @wraps(f)
184 | // def wrapped(*args, **kwargs):
185 | // try:
186 | // return f(*args, **kwargs)
187 |
188 | // except Exception as e:
189 | // send_error(None, e)
190 | // raise
191 | // return wrapped
192 | // }
193 |
--------------------------------------------------------------------------------
/lib/common/buffer_action.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | var flux = require("flukes");
4 |
5 | const Actions = flux.createActions({
6 | changed: function (buf, constCharPointer, patches, username) {
7 | return [buf, constCharPointer || [buf.buf], patches, username];
8 | },
9 | deleted: function (buf, unlink) {
10 | return [buf, unlink];
11 | },
12 | saved: function (buf) {
13 | return buf;
14 | },
15 | rename: function (buf, oldPath, newPath) {
16 | return [buf, oldPath, newPath];
17 | },
18 | created: function (buf, username, connID) {
19 | return [buf, username, connID];
20 | },
21 | // pseudo event for on RI
22 | add: function (buf) {
23 | return buf;
24 | },
25 | });
26 |
27 | module.exports = new Actions();
28 |
--------------------------------------------------------------------------------
/lib/common/button_model.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | const flux = require("flukes");
4 |
5 | const ButtonModel = flux.createModel({
6 | modelName: "Button",
7 | fieldTypes: {
8 | name: flux.FieldTypes.string,
9 | action: flux.FieldTypes.func,
10 | classNames: flux.FieldTypes.arrayOf(flux.FieldTypes.string),
11 | },
12 | getDefaultFields: function () {
13 | return {
14 | action: function () { return; },
15 | classNames: [],
16 | };
17 | }
18 | });
19 |
20 | const Buttons = flux.createCollection({
21 | modelName: "Buttons",
22 | model: ButtonModel,
23 | });
24 |
25 |
26 | module.exports = {
27 | Button: ButtonModel,
28 | Buttons: Buttons,
29 | };
30 |
--------------------------------------------------------------------------------
/lib/common/constants.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | module.exports = {
4 | // HOST: "dev.fixtheco.de",
5 | HOST: "floobits.com",
6 | PORT: 3448,
7 | PLUGIN_VERSION: "0.0.1",
8 | VERSION: "0.11"
9 | };
10 |
--------------------------------------------------------------------------------
/lib/common/editor_action.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | const _ = require("lodash");
4 | const flux = require("flukes");
5 |
6 | const floop = require("./floop");
7 |
8 | const Actions = flux.createActions({
9 | clear_highlights: function () {
10 | return;
11 | },
12 | handle_conflicts: function (newFiles, different, missing, ignored, tooBig, justUpload) {
13 | return {
14 | newFiles: newFiles,
15 | different: different,
16 | missing: missing,
17 | ignored: ignored,
18 | tooBig: tooBig,
19 | justUpload: justUpload
20 | };
21 | },
22 | jump_to_user: function (username) {
23 | return username;
24 | },
25 | kick: function (connectionIDorUsername) {
26 | let msg;
27 | if (_.isNumber(connectionIDorUsername)) {
28 | msg = {user_id: connectionIDorUsername};
29 | } else {
30 | msg = {username: connectionIDorUsername};
31 | }
32 | floop.send_kick(msg);
33 | return connectionIDorUsername;
34 | },
35 | pref: function (name, value, force) {
36 | if (this.prefs[name] === value && !force) {
37 | return new Error("Preference " + name + " already has value " + value);
38 | }
39 | this.prefs[name] = value;
40 | // XXXX: hard-coded fl.editor_settings.prefs_path
41 | this.prefs.save("editor");
42 | return [this.prefs, name];
43 | },
44 | follow: function (username) {
45 | let following;
46 | if (username) {
47 | following = this.prefs.followUsers.toggle(username);
48 | } else {
49 | following = this.prefs.following = !this.prefs.following;
50 | }
51 | this.prefs.save("editor");
52 | if (this.prefs.isFollowing()) {
53 | this.jump_to_user(username);
54 | }
55 | return following;
56 | },
57 | });
58 |
59 | Actions.prototype.set = function (buffers, prefs) {
60 | this.buffers = buffers;
61 | this.prefs = prefs;
62 | };
63 |
64 | module.exports = new Actions();
65 |
--------------------------------------------------------------------------------
/lib/common/emitter.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | var _ = require("lodash");
4 |
5 | /**
6 | * @constructor
7 | */
8 | function Emitter () {
9 | /**
10 | * @type {number}
11 | * @private
12 | */
13 | this.count = 0;
14 | /**
15 | * @type {Object}
16 | * @private
17 | */
18 | this.on_ = {};
19 | /**
20 | * @type {Object}
21 | * @private
22 | */
23 | this.all_ = {};
24 | }
25 |
26 | /**
27 | * @param {string} opt_event
28 | * @param {Function} listener
29 | * @param {Object=} opt_thisArg
30 | */
31 | Emitter.prototype.on = function (opt_event, listener, opt_thisArg) {
32 | if (_.isFunction(opt_event)) {
33 | this.all_[++this.count] = listener ? opt_event.bind(listener) : opt_event;
34 | return this.count;
35 | }
36 |
37 | if (!_.has(this.on_, opt_event)) {
38 | this.on_[opt_event] = {};
39 | }
40 | this.on_[opt_event][++this.count] = opt_thisArg ? listener.bind(opt_thisArg) : listener;
41 | return this.count;
42 | };
43 |
44 | /**
45 | * @param {string} event
46 | */
47 | Emitter.prototype.emit = function (event) {
48 | var args;
49 |
50 | args = _.toArray(arguments);
51 |
52 | _.each(this.all_, (l) => {
53 | l.apply(null, args);
54 | });
55 |
56 | args.shift();
57 | _.each((this.on_[event] || {}), (l) => {
58 | l.apply(null, args);
59 | });
60 | };
61 |
62 | Emitter.prototype.emitAsync = function (cb, event, args) {
63 | var events = this.on_[event] || {}, async = _.size(events) + _.size(this.all_);
64 |
65 | args = [args].concat(function popAsync() {
66 | if (async === 0) {
67 | throw new Error("cb fired more than once");
68 | }
69 | async -= 1;
70 | if (async === 0) {
71 | return cb && cb();
72 | }
73 | });
74 |
75 | _.each(this.all_, (l) => {
76 | l.apply(null, args);
77 | });
78 |
79 | _.each(events, (l) => {
80 | l.apply(null, args);
81 | });
82 | };
83 |
84 | /**
85 | * @param {string} event
86 | * @param {number} id
87 | */
88 | Emitter.prototype.off = function (opt_event_or_id) {
89 | if (_.isNumber(opt_event_or_id)) {
90 | delete this.all_[opt_event_or_id];
91 | // TODO: I don't think this does what it's supposed to do --ggreer
92 | _.each(this.on_, function (events) {
93 | delete events[opt_event_or_id];
94 | });
95 | return;
96 | }
97 | if (_.isString(opt_event_or_id)) {
98 | delete this.on_[opt_event_or_id];
99 | return;
100 | }
101 | if (_.isUndefined(opt_event_or_id)) {
102 | this.all_ = {};
103 | this.on_ = {};
104 | return;
105 | }
106 | throw new Error("WTF is " + opt_event_or_id + " ?");
107 | };
108 |
109 |
110 | module.exports = Emitter;
111 |
--------------------------------------------------------------------------------
/lib/common/ext_messaging.js:
--------------------------------------------------------------------------------
1 | /*global fl */
2 | "use strict";
3 |
4 | const _ = require("lodash");
5 | const $ = require("atom-space-pen-views").$;
6 |
7 | const floop = require("./floop");
8 | const webrtcAction = require("./webrtc_action");
9 |
10 | var callback;
11 |
12 | /*
13 | * @param {Object} event
14 | */
15 | function handleMessage(event) {
16 | event = event.originalEvent;
17 | if (!event.data) {
18 | return;
19 | }
20 | switch(event.data.name) {
21 | case "flooScreenShareResponse":
22 | console.log("Got content script stuff", event);
23 | callback(event.data.id);
24 | break;
25 | case "flooScreenHasExtension":
26 | console.log("Website: user has extension");
27 | webrtcAction.can_share_screen(true);
28 | break;
29 | default:
30 | // no-op
31 | }
32 | }
33 |
34 | /**
35 | * @param {Function} cb
36 | */
37 | function getSharedScreenId(cb) {
38 | callback = cb;
39 | setTimeout(function () {
40 | console.log("Getting screen share id");
41 | window.postMessage({text: "flooScreenShare"}, "*");
42 | }, 1);
43 | }
44 |
45 | /**
46 | * Let's ask to see if we can share the screen.
47 | */
48 | function getCanShare() {
49 | setTimeout(function () {
50 | console.log("Checking to see if we have a chrome extension.");
51 | window.postMessage({text: "flooScreenDoWeHaveAnExtension"}, "*");
52 | }, 0);
53 | }
54 |
55 | function init() {
56 | console.log("Initing ext msg.");
57 | $(window).on("message", handleMessage);
58 |
59 | function changeListener (evt) {
60 | var evt_data,
61 | origin,
62 | parse_url;
63 |
64 | parse_url = function (url) {
65 | var a = document.createElement("a");
66 | a.href = url;
67 | return {
68 | hostname: a.hostname,
69 | port: a.port,
70 | protocol: a.protocol
71 | };
72 | };
73 | origin = parse_url(evt.origin);
74 | if (origin.protocol !== "https:" || !origin.hostname.match(/\.googleusercontent\.com$/)) {
75 | console.log("discarding because event origin is", origin);
76 | return;
77 | }
78 | console.log("got event", evt.data);
79 | try {
80 | evt_data = JSON.parse(evt.data);
81 | } catch (e) {
82 | console.log("Couldn't parse event json:", e);
83 | return;
84 | }
85 | if (evt_data.temp_data) {
86 | fl.editor_settings.temp_data = _.extend(fl.editor_settings.temp_data,
87 | evt_data.temp_data);
88 | try {
89 | floop.set_temp_data(evt_data.temp_data);
90 | } catch (e) {
91 | console.log(e);
92 | }
93 | }
94 | }
95 |
96 | if (window.parent) {
97 | if (window.addEventListener) {
98 | window.addEventListener("message", changeListener, false);
99 | } else if (window.attachEvent) {
100 | window.attachEvent("onmessage", changeListener);
101 | }
102 | window.parent.postMessage(JSON.stringify({
103 | owner: fl.editor_settings.room_owner,
104 | room: fl.editor_settings.room
105 | }),
106 | "*");
107 | }
108 | }
109 |
110 | module.exports = {
111 | getSharedScreenId: getSharedScreenId,
112 | getCanShare: getCanShare,
113 | init: init
114 | };
115 |
--------------------------------------------------------------------------------
/lib/common/extern/webrtc/gain_controller.js:
--------------------------------------------------------------------------------
1 | var webrtcsupport = require("./webrtc_support");
2 |
3 | function GainController(stream) {
4 | this.support = webrtcsupport.webAudio && webrtcsupport.mediaStream;
5 |
6 | // set our starting value
7 | this.gain = 1;
8 |
9 | if (this.support) {
10 | var context = this.context = new webrtcsupport.AudioContext();
11 | this.microphone = context.createMediaStreamSource(stream);
12 | this.gainFilter = context.createGain();
13 | this.destination = context.createMediaStreamDestination();
14 | this.outputStream = this.destination.stream;
15 | this.microphone.connect(this.gainFilter);
16 | this.gainFilter.connect(this.destination);
17 | stream.removeTrack(stream.getAudioTracks()[0]);
18 | stream.addTrack(this.outputStream.getAudioTracks()[0]);
19 | }
20 | this.stream = stream;
21 | }
22 |
23 | // setting
24 | GainController.prototype.setGain = function (val) {
25 | // check for support
26 | if (!this.support) return;
27 | this.gainFilter.gain.value = val;
28 | this.gain = val;
29 | };
30 |
31 | GainController.prototype.getGain = function () {
32 | return this.gain;
33 | };
34 |
35 | GainController.prototype.off = function () {
36 | return this.setGain(0);
37 | };
38 |
39 | GainController.prototype.on = function () {
40 | this.setGain(1);
41 | };
42 |
43 | module.exports = GainController;
--------------------------------------------------------------------------------
/lib/common/extern/webrtc/get_user_media.js:
--------------------------------------------------------------------------------
1 | // getUserMedia helper by @HenrikJoreteg
2 | //
3 |
4 | var func = (navigator.getUserMedia ||
5 | navigator.webkitGetUserMedia ||
6 | navigator.mozGetUserMedia ||
7 | navigator.msGetUserMedia);
8 |
9 |
10 | module.exports = function (constraints, cb) {
11 | var options;
12 | var haveOpts = arguments.length === 2;
13 | var defaultOpts = {video: true, audio: true};
14 | var error;
15 | var denied = 'PERMISSION_DENIED';
16 | var notSatified = 'CONSTRAINT_NOT_SATISFIED';
17 |
18 | // make constraints optional
19 | if (!haveOpts) {
20 | cb = constraints;
21 | constraints = defaultOpts;
22 | }
23 |
24 | // treat lack of browser support like an error
25 | if (!func) {
26 | // throw proper error per spec
27 | error = new Error('NavigatorUserMediaError');
28 | error.name = 'NOT_SUPPORTED_ERROR';
29 | return cb(error);
30 | }
31 |
32 | func.call(navigator, constraints, function (stream) {
33 | cb(null, stream);
34 | }, function (err) {
35 | var error;
36 | // coerce into an error object since FF gives us a string
37 | // there are only two valid names according to the spec
38 | // we coerce all non-denied to "constraint not satisfied".
39 | if (typeof err === 'string') {
40 | error = new Error('NavigatorUserMediaError');
41 | if (err === denied) {
42 | error.name = denied;
43 | } else {
44 | error.name = notSatified;
45 | }
46 | } else {
47 | // if we get an error object make sure '.name' property is set
48 | // according to spec: http://dev.w3.org/2011/webrtc/editor/getusermedia.html#navigatorusermediaerror-and-navigatorusermediaerrorcallback
49 | error = err;
50 | if (!error.name) {
51 | // this is likely chrome which
52 | // sets a property called "ERROR_DENIED" on the error object
53 | // if so we make sure to set a name
54 | if (error[denied]) {
55 | err.name = denied;
56 | } else {
57 | err.name = notSatified;
58 | }
59 | }
60 | }
61 |
62 | cb(error);
63 | });
64 | };
65 |
--------------------------------------------------------------------------------
/lib/common/extern/webrtc/hark.js:
--------------------------------------------------------------------------------
1 | var WildEmitter = require("./wild_emitter");
2 |
3 | function getMaxVolume (analyser, fftBins) {
4 | var maxVolume = -Infinity;
5 | analyser.getFloatFrequencyData(fftBins);
6 |
7 | for(var i=0, ii=fftBins.length; i < ii; i++) {
8 | if (fftBins[i] > maxVolume && fftBins[i] < 0) {
9 | maxVolume = fftBins[i];
10 | }
11 | };
12 |
13 | return maxVolume;
14 | }
15 |
16 |
17 | module.exports = function (stream, options) {
18 | var harker = new WildEmitter();
19 |
20 | var audioContextType = window.webkitAudioContext || window.AudioContext;
21 |
22 | // make it not break in non-supported browsers
23 | if (!audioContextType) return harker;
24 |
25 | //Config
26 | var options = options || {},
27 | smoothing = (options.smoothing || 0.5),
28 | interval = (options.interval || 100),
29 | threshold = options.threshold,
30 | play = options.play;
31 |
32 | //Setup Audio Context
33 | var audioContext = new audioContextType();
34 | var sourceNode, fftBins, analyser;
35 |
36 | analyser = audioContext.createAnalyser();
37 | analyser.fftSize = 512;
38 | analyser.smoothingTimeConstant = smoothing;
39 | fftBins = new Float32Array(analyser.fftSize);
40 |
41 | if (stream.jquery) stream = stream[0];
42 | if (stream instanceof HTMLAudioElement) {
43 | //Audio Tag
44 | sourceNode = audioContext.createMediaElementSource(stream);
45 | if (typeof play === 'undefined') play = true;
46 | threshold = threshold || -65;
47 | } else {
48 | //WebRTC Stream
49 | sourceNode = audioContext.createMediaStreamSource(stream);
50 | threshold = threshold || -45;
51 | }
52 |
53 | sourceNode.connect(analyser);
54 | if (play) analyser.connect(audioContext.destination);
55 |
56 | harker.speaking = false;
57 |
58 | harker.setThreshold = function (t) {
59 | threshold = t;
60 | };
61 |
62 | harker.setInterval = function (i) {
63 | interval = i;
64 | };
65 |
66 | // Poll the analyser node to determine if speaking
67 | // and emit events if changed
68 | var looper = function () {
69 | setTimeout(function () {
70 | var currentVolume = getMaxVolume(analyser, fftBins);
71 |
72 | harker.emit('volume_change', currentVolume, threshold);
73 |
74 | if (currentVolume > threshold) {
75 | if (!harker.speaking) {
76 | harker.speaking = true;
77 | harker.emit('speaking');
78 | }
79 | } else {
80 | if (harker.speaking) {
81 | harker.speaking = false;
82 | harker.emit('stopped_speaking');
83 | }
84 | }
85 |
86 | looper();
87 | }, interval);
88 | };
89 | looper();
90 |
91 |
92 | return harker;
93 | }
94 |
--------------------------------------------------------------------------------
/lib/common/extern/webrtc/peer_connection.js:
--------------------------------------------------------------------------------
1 | var webrtcsupport = require("./webrtc_support");
2 | var WildEmitter = require("./wild_emitter");
3 |
4 | function PeerConnection(config, constraints) {
5 | var item;
6 | this.pc = new webrtcsupport.PeerConnection(config, constraints);
7 | WildEmitter.call(this);
8 |
9 | // proxy some events directly
10 | this.pc.onremovestream = this.emit.bind(this, 'removeStream');
11 | this.pc.onnegotiationneeded = this.emit.bind(this, 'negotiationNeeded');
12 | this.pc.oniceconnectionstatechange = this.emit.bind(this, 'iceConnectionStateChange');
13 | this.pc.onsignalingstatechange = this.emit.bind(this, 'signalingStateChange');
14 |
15 | // handle incoming ice and data channel events
16 | this.pc.onaddstream = this._onAddStream.bind(this);
17 | this.pc.onicecandidate = this._onIce.bind(this);
18 | this.pc.ondatachannel = this._onDataChannel.bind(this);
19 |
20 | // whether to use SDP hack for faster data transfer
21 | this.config = {
22 | debug: false,
23 | sdpHack: true
24 | };
25 |
26 | // apply our config
27 | console.log("applying config", config);
28 | for (item in config) {
29 | console.log("item", item, config[item]);
30 | this.config[item] = config[item];
31 | }
32 |
33 | if (this.config.debug) {
34 | this.on('*', function (eventName, event) {
35 | var logger = config.logger || console;
36 | logger.log('PeerConnection event:', arguments);
37 | });
38 | }
39 | }
40 |
41 | PeerConnection.prototype = Object.create(WildEmitter.prototype, {
42 | constructor: {
43 | value: PeerConnection
44 | }
45 | });
46 |
47 | // Add a stream to the peer connection object
48 | PeerConnection.prototype.addStream = function (stream) {
49 | this.localStream = stream;
50 | this.pc.addStream(stream);
51 | };
52 |
53 |
54 | // Init and add ice candidate object with correct constructor
55 | PeerConnection.prototype.processIce = function (candidate) {
56 | this.pc.addIceCandidate(new webrtcsupport.IceCandidate(candidate));
57 | };
58 |
59 | // Generate and emit an offer with the given constraints
60 | PeerConnection.prototype.offer = function (constraints, cb) {
61 | var self = this;
62 | var hasConstraints = arguments.length === 2;
63 | var mediaConstraints = hasConstraints ? constraints : {
64 | mandatory: {
65 | OfferToReceiveAudio: true,
66 | OfferToReceiveVideo: true
67 | }
68 | };
69 | var callback = hasConstraints ? cb : constraints;
70 |
71 | // Actually generate the offer
72 | this.pc.createOffer(
73 | function (offer) {
74 | offer.sdp = self._applySdpHack(offer.sdp);
75 | self.pc.setLocalDescription(offer);
76 | self.emit('offer', offer);
77 | if (callback) callback(null, offer);
78 | },
79 | function (err) {
80 | self.emit('error', err);
81 | if (callback) callback(err);
82 | },
83 | mediaConstraints
84 | );
85 | };
86 |
87 | // Answer an offer with audio only
88 | PeerConnection.prototype.answerAudioOnly = function (offer, cb) {
89 | var mediaConstraints = {
90 | mandatory: {
91 | OfferToReceiveAudio: true,
92 | OfferToReceiveVideo: false
93 | }
94 | };
95 | this._answer(offer, mediaConstraints, cb);
96 | };
97 |
98 | // Answer an offer without offering to recieve
99 | PeerConnection.prototype.answerBroadcastOnly = function (offer, cb) {
100 | var mediaConstraints = {
101 | mandatory: {
102 | OfferToReceiveAudio: false,
103 | OfferToReceiveVideo: false
104 | }
105 | };
106 | this._answer(offer, mediaConstraints, cb);
107 | };
108 |
109 | // Answer an offer with given constraints default is audio/video
110 | PeerConnection.prototype.answer = function (offer, constraints, cb) {
111 | var self = this;
112 | var hasConstraints = arguments.length === 3;
113 | var callback = hasConstraints ? cb : constraints;
114 | var mediaConstraints = hasConstraints ? constraints : {
115 | mandatory: {
116 | OfferToReceiveAudio: true,
117 | OfferToReceiveVideo: true
118 | }
119 | };
120 |
121 | this._answer(offer, mediaConstraints, callback);
122 | };
123 |
124 | // Process an answer
125 | PeerConnection.prototype.handleAnswer = function (answer) {
126 | this.pc.setRemoteDescription(new webrtcsupport.SessionDescription(answer));
127 | };
128 |
129 | // Close the peer connection
130 | PeerConnection.prototype.close = function () {
131 | this.pc.close();
132 | this.emit('close');
133 | };
134 |
135 | // Internal code sharing for various types of answer methods
136 | PeerConnection.prototype._answer = function (offer, constraints, cb) {
137 | var self = this;
138 | this.pc.setRemoteDescription(new webrtcsupport.SessionDescription(offer),
139 | function () {
140 | self.pc.createAnswer(
141 | function (answer) {
142 | answer.sdp = self._applySdpHack(answer.sdp);
143 | self.pc.setLocalDescription(answer);
144 | self.emit('answer', answer);
145 | if (cb) cb(null, answer);
146 | }, function (err) {
147 | self.emit('error', err);
148 | if (cb) cb(err);
149 | },
150 | constraints
151 | );
152 | },
153 | function (err) {
154 | console.log("setRemoteDescription error", err);
155 | cb(err);
156 | }
157 | );
158 | };
159 |
160 | // Internal method for emitting ice candidates on our peer object
161 | PeerConnection.prototype._onIce = function (event) {
162 | if (event.candidate) {
163 | this.emit('ice', event.candidate);
164 | } else {
165 | this.emit('endOfCandidates');
166 | }
167 | };
168 |
169 | // Internal method for processing a new data channel being added by the
170 | // other peer.
171 | PeerConnection.prototype._onDataChannel = function (event) {
172 | this.emit('addChannel', event.channel);
173 | };
174 |
175 | // Internal handling of adding stream
176 | PeerConnection.prototype._onAddStream = function (event) {
177 | this.remoteStream = event.stream;
178 | this.emit('addStream', event);
179 | };
180 |
181 | // SDP hack for increasing AS (application specific) data transfer speed allowed in chrome
182 | PeerConnection.prototype._applySdpHack = function (sdp) {
183 | var i,
184 | limits = this.config.limits || {},
185 | line,
186 | sdp_lines;
187 |
188 |
189 | sdp_lines = sdp.split("\r\n"); // sdp lines have windows-style newlines
190 | console.log("sdp lines:", sdp_lines.join("\r\n"));
191 | if (!this.config.sdpHack) {
192 | console.log("sdp hack disabled.");
193 | return sdp;
194 | }
195 |
196 | for (i = 0; i < sdp_lines.length; i++) {
197 | line = sdp_lines[i];
198 | if (line.search("mid:audio") >= 0) {
199 | // Audio max is 50kbit/sec
200 | sdp_lines.splice(i + 1, 0, "b=AS:" + limits.audio || "50");
201 | console.log("set audio bandwidth");
202 | continue;
203 | }
204 | if (line.search("mid:video") >= 0) {
205 | // Max video bandwidth is 150kbit/sec because we use tiny resolution
206 | sdp_lines.splice(i + 1, 0, "b=AS:" + limits.video || "200");
207 | console.log("set video bandwidth");
208 | continue;
209 | }
210 | }
211 | console.log("sdp lines after:", sdp_lines.join("\r\n"));
212 | return sdp_lines.join("\r\n");
213 | };
214 |
215 | // Create a data channel spec reference:
216 | // http://dev.w3.org/2011/webrtc/editor/webrtc.html#idl-def-RTCDataChannelInit
217 | PeerConnection.prototype.createDataChannel = function (name, opts) {
218 | opts = opts || {};
219 | var reliable = !!opts.reliable;
220 | var protocol = opts.protocol || 'text/plain';
221 | var negotiated = !!(opts.negotiated || opts.preset);
222 | var settings;
223 | var channel;
224 | // firefox is a bit more finnicky
225 | if (webrtcsupport.prefix === 'moz') {
226 | if (reliable) {
227 | settings = {
228 | protocol: protocol,
229 | preset: negotiated,
230 | stream: name
231 | };
232 | } else {
233 | settings = {};
234 | }
235 | channel = this.pc.createDataChannel(name, settings);
236 | channel.binaryType = 'blob';
237 | } else {
238 | if (reliable) {
239 | settings = {
240 | reliable: true
241 | };
242 | } else {
243 | settings = {reliable: false};
244 | }
245 | channel = this.pc.createDataChannel(name, settings);
246 | }
247 | return channel;
248 | };
249 |
250 | module.exports = PeerConnection;
251 |
--------------------------------------------------------------------------------
/lib/common/extern/webrtc/webrtc_support.js:
--------------------------------------------------------------------------------
1 | // created by @HenrikJoreteg
2 |
3 | var prefix;
4 | var isChrome = false;
5 | var isFirefox = false;
6 | var ua = navigator.userAgent.toLowerCase();
7 |
8 | // basic sniffing
9 | if (ua.indexOf('firefox') !== -1) {
10 | prefix = 'moz';
11 | isFirefox = true;
12 | } else if (ua.indexOf('chrome') !== -1) {
13 | prefix = 'webkit';
14 | isChrome = true;
15 | }
16 |
17 | var PC = window.mozRTCPeerConnection || window.webkitRTCPeerConnection;
18 | var IceCandidate = window.mozRTCIceCandidate || window.RTCIceCandidate;
19 | var SessionDescription = window.mozRTCSessionDescription || window.RTCSessionDescription;
20 | var MediaStream = window.webkitMediaStream || window.MediaStream;
21 | var screenSharing = navigator.userAgent.match('Chrome') && parseInt(navigator.userAgent.match(/Chrome\/(.*) /)[1], 10) >= 26;
22 | var AudioContext = window.AudioContext || window.webkitAudioContext;
23 |
24 |
25 | // export support flags and constructors.prototype && PC
26 | module.exports = {
27 | support: !!PC,
28 | dataChannel: isChrome || isFirefox || (PC && PC.prototype && PC.prototype.createDataChannel),
29 | prefix: prefix,
30 | webAudio: !!(AudioContext && AudioContext.prototype.createMediaStreamSource),
31 | mediaStream: !!(MediaStream && MediaStream.prototype.removeTrack),
32 | screenSharing: !!screenSharing,
33 | AudioContext: AudioContext,
34 | PeerConnection: PC,
35 | SessionDescription: SessionDescription,
36 | IceCandidate: IceCandidate
37 | };
38 |
--------------------------------------------------------------------------------
/lib/common/extern/webrtc/wild_emitter.js:
--------------------------------------------------------------------------------
1 | /*
2 | WildEmitter.js is a slim little event emitter by @henrikjoreteg largely based
3 | on @visionmedia's Emitter from UI Kit.
4 |
5 | Why? I wanted it standalone.
6 |
7 | I also wanted support for wildcard emitters like this:
8 |
9 | emitter.on('*', function (eventName, other, event, payloads) {
10 |
11 | });
12 |
13 | emitter.on('somenamespace*', function (eventName, payloads) {
14 |
15 | });
16 |
17 | Please note that callbacks triggered by wildcard registered events also get
18 | the event name as the first argument.
19 | */
20 |
21 | function WildEmitter() {
22 | this.callbacks = {};
23 | }
24 |
25 | // Listen on the given `event` with `fn`. Store a group name if present.
26 | WildEmitter.prototype.on = function (event, groupName, fn) {
27 | var hasGroup = (arguments.length === 3),
28 | group = hasGroup ? arguments[1] : undefined,
29 | func = hasGroup ? arguments[2] : arguments[1];
30 | func._groupName = group;
31 | (this.callbacks[event] = this.callbacks[event] || []).push(func);
32 | return this;
33 | };
34 |
35 | // Adds an `event` listener that will be invoked a single
36 | // time then automatically removed.
37 | WildEmitter.prototype.once = function (event, groupName, fn) {
38 | var self = this,
39 | hasGroup = (arguments.length === 3),
40 | group = hasGroup ? arguments[1] : undefined,
41 | func = hasGroup ? arguments[2] : arguments[1];
42 | function on() {
43 | self.off(event, on);
44 | func.apply(this, arguments);
45 | }
46 | this.on(event, group, on);
47 | return this;
48 | };
49 |
50 | // Unbinds an entire group
51 | WildEmitter.prototype.releaseGroup = function (groupName) {
52 | var item, i, len, handlers;
53 | for (item in this.callbacks) {
54 | handlers = this.callbacks[item];
55 | for (i = 0, len = handlers.length; i < len; i++) {
56 | if (handlers[i]._groupName === groupName) {
57 | //console.log('removing');
58 | // remove it and shorten the array we're looping through
59 | handlers.splice(i, 1);
60 | i--;
61 | len--;
62 | }
63 | }
64 | }
65 | return this;
66 | };
67 |
68 | // Remove the given callback for `event` or all
69 | // registered callbacks.
70 | WildEmitter.prototype.off = function (event, fn) {
71 | var callbacks = this.callbacks[event],
72 | i;
73 |
74 | if (!callbacks) return this;
75 |
76 | // remove all handlers
77 | if (arguments.length === 1) {
78 | delete this.callbacks[event];
79 | return this;
80 | }
81 |
82 | // remove specific handler
83 | i = callbacks.indexOf(fn);
84 | callbacks.splice(i, 1);
85 | return this;
86 | };
87 |
88 | // Emit `event` with the given args.
89 | // also calls any `*` handlers
90 | WildEmitter.prototype.emit = function (event) {
91 | var args = [].slice.call(arguments, 1),
92 | callbacks = this.callbacks[event],
93 | specialCallbacks = this.getWildcardCallbacks(event),
94 | i,
95 | len,
96 | item;
97 |
98 | if (callbacks) {
99 | for (i = 0, len = callbacks.length; i < len; ++i) {
100 | if (callbacks[i]) {
101 | callbacks[i].apply(this, args);
102 | } else {
103 | break;
104 | }
105 | }
106 | }
107 |
108 | if (specialCallbacks) {
109 | for (i = 0, len = specialCallbacks.length; i < len; ++i) {
110 | if (specialCallbacks[i]) {
111 | specialCallbacks[i].apply(this, [event].concat(args));
112 | } else {
113 | break;
114 | }
115 | }
116 | }
117 |
118 | return this;
119 | };
120 |
121 | // Helper for for finding special wildcard event handlers that match the event
122 | WildEmitter.prototype.getWildcardCallbacks = function (eventName) {
123 | var item,
124 | split,
125 | result = [];
126 |
127 | for (item in this.callbacks) {
128 | split = item.split('*');
129 | if (item === '*' || (split.length === 2 && eventName.slice(0, split[1].length) === split[1])) {
130 | result = result.concat(this.callbacks[item]);
131 | }
132 | }
133 | return result;
134 | };
135 |
136 | module.exports = WildEmitter;
137 |
--------------------------------------------------------------------------------
/lib/common/filetree_model.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | var id = 0;
4 | const _ = require("lodash");
5 | const flux = require("flukes");
6 |
7 | /**
8 | * @extends {flux.DataModel}
9 | * @constructor
10 | */
11 | const Filetree = flux.createModel({
12 | modelName: "tree",
13 | fieldTypes: {
14 | id: flux.FieldTypes.number,
15 | tree: flux.FieldTypes.object,
16 | },
17 | getDefaultFields: function () {
18 | return {
19 | id: ++id,
20 | };
21 | },
22 | addBuf: function (buf) {
23 | var node = this.tree,
24 | paths = buf.path.split("/"),
25 | name = paths.pop();
26 |
27 | try {
28 | _.each(paths, function (p) {
29 | var n = node[p];
30 | if (!n) {
31 | n = {};
32 | node[p] = n;
33 | }
34 | node = n;
35 | });
36 | node[name] = buf.id;
37 | } catch (e) {
38 | console.error("Path conflict for", buf.path);
39 | return;
40 | }
41 |
42 | this.update();
43 | },
44 | removePath: function (bufPath) {
45 | var i, name,
46 | node = this.tree,
47 | paths = bufPath.split("/");
48 |
49 | name = paths.pop();
50 | for (i = 0; i < paths.length; i++) {
51 | node = node[paths[i]];
52 | if (!node) {
53 | console.error("Couldn't find filetree node for path", bufPath);
54 | return;
55 | }
56 | }
57 | delete node[name];
58 | if (!paths.length) {
59 | this.update();
60 | return;
61 | }
62 | if (_.size(node) === 0) {
63 | this.removePath(paths.join("/"));
64 | return;
65 | }
66 | this.update();
67 | }
68 | });
69 |
70 | Filetree.Event = {
71 | OPEN: "open"
72 | };
73 |
74 | module.exports = Filetree;
75 |
--------------------------------------------------------------------------------
/lib/common/floop.js:
--------------------------------------------------------------------------------
1 | /* global */
2 | "use strict";
3 |
4 | /**
5 | * @fileOverview Connects to floobits via something.
6 | */
7 |
8 | let authorized = false;
9 |
10 | const _ = require("lodash");
11 | const flux = require("flukes");
12 | const perms = require("./permission_model");
13 |
14 | var EVENTS, actions,
15 | // messageAction = require("./editor/message_action"),
16 | reqCallbacks = {};
17 |
18 | actions = {
19 | socket_: null,
20 | capturedEvents: null,
21 | captureEvents: null,
22 | requestId: 0,
23 | reconnectTimeout: null,
24 | engineIoURL: null
25 | };
26 |
27 | EVENTS = {
28 | IN: [
29 | "ack",
30 | "create_buf",
31 | "create_term",
32 | "datamsg",
33 | "delete_buf",
34 | "delete_temp_data",
35 | "delete_term",
36 | "error",
37 | "get_buf",
38 | "highlight",
39 | "join",
40 | "kick",
41 | "msg",
42 | "part",
43 | "patch",
44 | "perms",
45 | "ping",
46 | "pong",
47 | "rename_buf",
48 | "request_perms",
49 | "room_info",
50 | "saved",
51 | "set_temp_data",
52 | "solicit",
53 | "sync",
54 | "term_stdin",
55 | "term_stdout",
56 | "update_term",
57 | "user_info",
58 | "webrtc",
59 | // TODO: something better than all events for all connections
60 | "create_user"
61 | ],
62 | OUT: [
63 | "auth",
64 | "create_buf",
65 | "create_term",
66 | "datamsg",
67 | "delete_buf",
68 | "delete_term",
69 | "delete_temp_data",
70 | "get_buf",
71 | "highlight",
72 | "kick",
73 | "msg",
74 | "patch",
75 | "perms",
76 | "ping",
77 | "pong",
78 | "pull_repo",
79 | "rename_buf",
80 | "request_perms",
81 | "saved",
82 | "set_buf",
83 | "set_temp_data",
84 | "solicit",
85 | "term_stdin",
86 | "term_stdout",
87 | "update_term",
88 | "webrtc",
89 | ]
90 | };
91 |
92 | _.each(EVENTS.OUT, function (name) {
93 | actions["send_" + name] = function actionOut (data, on_write, on_response) {
94 | const err = this.send_(name, data, on_write, on_response);
95 | return err || data;
96 | };
97 | });
98 |
99 | function actionIn (data) {
100 | var id = data.res_id,
101 | f = reqCallbacks[id];
102 |
103 | if (!f) {
104 | return data;
105 | }
106 | delete reqCallbacks[id];
107 | if (data.name === "error") {
108 | console.error(data.msg);
109 | f(data);
110 | return data;
111 | }
112 | f(null, data);
113 | return data;
114 | }
115 |
116 | _.each(EVENTS.IN, function (name) {
117 | actions[name] = actionIn;
118 | });
119 |
120 | actions.auth = function (auth) {
121 | this.connected = true;
122 | return this.transport.write(null, auth);
123 | };
124 |
125 | actions.disconnect = function (msg) {
126 | authorized = false;
127 | if (!this.transport) {
128 | return msg;
129 | }
130 | try {
131 | this.transport.removeListener("connected", this.onConnected_);
132 | this.transport.removeListener("disconnected", this.onDisconnected_);
133 | this.transport.removeListener("messaged", this.onMessaged_);
134 | } catch (e) {
135 | // Unused
136 | }
137 |
138 | try {
139 | this.transport.disconnect();
140 | this.transport = null;
141 | } catch (e) {
142 | // Unused
143 | }
144 |
145 | return msg;
146 | };
147 |
148 | actions.connect = function (transport, auth_blob) {
149 | var that = this;
150 | this.transport = transport;
151 | transport.connect();
152 | that.onConnected_ = this.auth.bind(this, auth_blob);
153 | transport.on("connected", that.onConnected_);
154 | that.onDisconnected_ = function () {
155 | that.connected = false;
156 | authorized = false;
157 | };
158 | transport.on("disconnected", that.onDisconnected_);
159 | that.onMessaged_ = function (name, data) {
160 | if (name === "room_info") {
161 | console.log("Now authorized.");
162 | authorized = true;
163 | }
164 |
165 | const f = that[name];
166 | if (f) {
167 | f(data);
168 | }
169 | };
170 | transport.on("messaged", that.onMessaged_);
171 | };
172 |
173 | actions.ping = function () {
174 | if (!this.transport) {
175 | console.log("There is no socket to send with. We are currently disconnected.");
176 | return;
177 | }
178 | this.transport.write("pong", {});
179 | };
180 |
181 | actions.send_get_buf = function (id, on_response) {
182 | return this.send_("get_buf", {id: id}, null, on_response);
183 | };
184 |
185 | /**
186 | * @param {*} data
187 | * @param {Array.
36 |
47 | );
48 | });
49 | return (
50 |
37 |
46 | {msg.prettyTime}
38 |
39 |
40 |
41 | {msg.username}:
42 |
43 | {msg.data}
44 |
45 |
54 |
63 | );
64 | }
65 | });
66 |
--------------------------------------------------------------------------------
/templates/code_review.js:
--------------------------------------------------------------------------------
1 | /** @jsx React.DOM */
2 |
3 | "use strict";
4 |
5 | const React = require('react-atom-fork');
6 | const mixins = require("./mixins");
7 | const atomUtils = require("../atom_utils");
8 |
9 | const CodeReview = React.createClass({
10 | mixins: [mixins.ReactUnwrapper, mixins.FormMixin],
11 | onSubmit: function (state) {
12 | const cb = this.props.cb.bind({}, null, state, this.refs.description.getDOMNode().value);
13 | setTimeout(cb, 0);
14 | this.destroy();
15 | },
16 | componentDidMount: function () {
17 | this.refs.description.getDOMNode().focus();
18 | },
19 | render: function () {
20 | return (
21 |
42 | );
43 | }
44 | });
45 |
46 | module.exports = function (cb) {
47 | const view = CodeReview({cb: cb});
48 | atomUtils.addModalPanel('code-review', view);
49 | };
--------------------------------------------------------------------------------
/templates/conflicts.js:
--------------------------------------------------------------------------------
1 | /** @jsx React.DOM */
2 | /*global fl */
3 | "use strict";
4 | const fs = require("fs");
5 | const path = require("path");
6 |
7 | const _ = require("lodash");
8 | const $ = require('atom-space-pen-views').$;
9 | const React = require('react-atom-fork');
10 |
11 | const floop = require("../common/floop");
12 | const utils = require("../common/utils");
13 |
14 | module.exports = React.createClass({
15 | treeize_: function (obj) {
16 | let node = {};
17 | let tree = {};
18 | _.each(obj, function (p) {
19 | node = tree;
20 | p.split(path.sep).forEach(function (p) {
21 | if (p in node) {
22 | node = node[p];
23 | return;
24 | }
25 | node[p] = {};
26 | node = node[p];
27 | });
28 | });
29 | return tree;
30 | },
31 | getInitialState: function () {
32 | return {
33 | enabled: true,
34 | clicked: "",
35 | totalFiles: _.size(this.props.different) + _.size(this.props.newFiles) + _.size(this.props.missing),
36 | missing: new Set(),
37 | different: new Set(),
38 | newFiles: new Set(),
39 | };
40 | },
41 | componentDidMount: function () {
42 | if (this.props.justUpload) {
43 | const upload = this.remote_;
44 | setTimeout(function () {
45 | upload();
46 | }, 0);
47 | }
48 |
49 | const local = this.refs.local;
50 | if (!local) {
51 | return;
52 | }
53 | $(local.getDOMNode()).focus();
54 | },
55 | onClick: function (id) {
56 | console.log(id);
57 | },
58 | remote_: function () {
59 | this.setState({enabled: false});
60 | _.each(this.props.different, (b, id) => {
61 | let encoding = b.encoding || "utf8";
62 | floop.send_set_buf({
63 | id, encoding,
64 | buf: b.txt.toString(encoding),
65 | md5: b.md5,
66 | }, null, (err) => {
67 | if (!err) {
68 | this.setState({different: this.state.different.add(id)});
69 | floop.send_saved({id: id});
70 | }
71 | });
72 | });
73 |
74 | _.each(this.props.missing, (b, id) => {
75 | floop.send_delete_buf({id}, null, () => {
76 | // TODO: check err
77 | this.setState({missing: this.state.missing.add(id)});
78 | });
79 | });
80 |
81 | _.each(this.props.newFiles, (b, rel) => {
82 | fs.readFile(b.path, (err, data) => {
83 | if (err) {
84 | console.log(err);
85 | return;
86 | }
87 |
88 | const encoding = utils.is_binary(data, data.length) ? "base64" : "utf8";
89 | floop.send_create_buf({
90 | path: rel,
91 | buf: data.toString(encoding),
92 | encoding: encoding,
93 | md5: utils.md5(data),
94 | }, null, () => {
95 | this.setState({newFiles: this.state.newFiles.add(rel)});
96 | });
97 | });
98 | });
99 | this.props.onHandledConflicts({});
100 | },
101 | local_: function () {
102 | this.setState({
103 | enabled: false,
104 | newFiles: new Set(_.keys(this.props.newFiles)),
105 | });
106 | _.each(this.props.missing, (b, id) => {
107 | floop.send_get_buf(id, () => this.setState({missing: this.state.missing.add(id)}));
108 | });
109 | _.each(this.props.different, (b, id) => {
110 | floop.send_get_buf(id, () => this.setState({different: this.state.different.add(id)}));
111 | });
112 | const toFetch = _.merge({}, this.props.missing, this.props.different);
113 | this.props.onHandledConflicts(toFetch);
114 | },
115 | cancel_: function () {
116 | this.setState({enabled: false});
117 | require("../floobits").leave_workspace();
118 | },
119 | render_: function (title, name) {
120 | const items = this.props[name];
121 | const completed = this.state[name];
122 | if (!_.size(items)) {
123 | return "";
124 | }
125 | return (
126 |
55 |
58 |
59 |
60 | {msgs}
61 |
62 |
127 |
138 | );
139 | },
140 | render_progress: function () {
141 | if (this.state.enabled) {
142 | return false;
143 | }
144 | const state = this.state;
145 | const width = parseInt((state.different.size + state.newFiles.size + state.missing.size) / state.totalFiles * 100, 10);
146 | const progressWidth = `${width}%`;
147 | return (
148 | {title}
128 |-
129 | {
130 | _.map(items, (b, id) => {
131 | const path = b.path;
132 | const checked = completed.has(id) ? "✓" : "";
133 | return (
- {path} {checked} ); 134 | }) 135 | } 136 |
149 |
157 | );
158 | },
159 | render_created_workspace: function () {
160 | const newFiles = this.render_("Uploading:", "newFiles");
161 | const progress = this.render_progress();
162 | return (
150 | {progressWidth}
151 |
152 |
153 | 154 | All done syncing files! 155 |
156 |
163 |
);
167 | },
168 | render_conflicts: function () {
169 | const missing = this.render_("Missing", "missing");
170 | const different = this.render_("Different", "different");
171 | const newFiles = this.render_("New", "newFiles");
172 | const ignored = _.map(this.props.ignored, function (p) {
173 | return Created {fl.floourl ? fl.floourl.toString() : "the workspace"}
164 | { progress } 165 | { newFiles } 166 |
184 |
);
211 | },
212 | render: function () {
213 | const body = this.props.justUpload ? this.render_created_workspace() : this.render_conflicts();
214 | return (
215 | Your local files are different from the workspace.
185 | 186 | 187 | 188 | 189 | {progress} 190 | 191 | {missing} 192 | {different} 193 | {newFiles} 194 | {!this.props.ignored.length ? "" : 195 |
196 |
201 | }
202 | {!tooBig.length ? "" :
203 | Ignored
197 |-
198 | { ignored }
199 |
204 |
209 | }
210 | Too Big
205 |-
206 | { tooBig }
207 |
216 | {body}
217 |
218 | );
219 | }
220 | });
221 |
--------------------------------------------------------------------------------
/templates/handle_request_perm.js:
--------------------------------------------------------------------------------
1 | /** @jsx React.DOM */
2 |
3 | "use strict";
4 |
5 | const React = require('react-atom-fork');
6 | const floop = require("../common/floop");
7 | const permsEvent = {};
8 |
9 | const HandleRequestPermView = React.createClass({
10 | destroy: function () {
11 | this.getDOMNode().parentNode.destroy();
12 | },
13 | grant: function () {
14 | permsEvent.action = "add";
15 | this.send();
16 | },
17 | deny: function () {
18 | permsEvent.action = "reject";
19 | this.send();
20 | },
21 | send: function () {
22 | floop.send_perms(permsEvent);
23 | this.destroy();
24 | },
25 | render: function () {
26 | permsEvent.user_id = this.props.userId;
27 | permsEvent.perms = this.props.perms;
28 | return (
29 |
30 |
43 | );
44 | }
45 | });
46 |
47 | module.exports = HandleRequestPermView;
48 |
--------------------------------------------------------------------------------
/templates/join.js:
--------------------------------------------------------------------------------
1 | /** @jsx React.DOM */
2 |
3 | "use strict";
4 |
5 | const $ = require('atom-space-pen-views').$;
6 | const React = require('react-atom-fork');
7 | const utils = require("../common/utils");
8 | const mixins = require("./mixins");
9 |
10 | const JoinWorkspace = React.createClass({
11 | mixins: [mixins.ReactUnwrapper, mixins.FormMixin],
12 | getInitialState: function () {
13 | return {
14 | path: this.props.path,
15 | url: this.props.url,
16 | };
17 | },
18 | onSubmit: function (event) {
19 | if (event) {
20 | event.preventDefault();
21 | }
22 | setTimeout(function () {
23 | this.props.on_url(this.state.path, this.refs.url.getDOMNode().value);
24 | }.bind(this), 0);
25 | this.destroy();
26 | },
27 | onChange_: function (event) {
28 | const files = event.target.files;
29 | if (!files.length) {
30 | return;
31 | }
32 | const path = files[0].path;
33 | const state = {path: path};
34 | if (this.refs.url.getDOMNode().value === this.props.url) {
35 | const dotFloo = utils.load_floo(path);
36 | if (dotFloo.url && dotFloo.url.length) {
37 | state.url = dotFloo.url;
38 | }
39 | }
40 | this.setState(state);
41 | },
42 | onDidStuff: function () {
43 | if (this.state.path) {
44 | return;
45 | }
46 | $("#ultra-secret-hidden-file-input").attr("webkitdirectory", true);
47 | },
48 | componentDidUpdate: function () {
49 | this.onDidStuff();
50 | },
51 | componentDidMount: function () {
52 | this.onDidStuff();
53 |
54 | const that = this;
55 | setTimeout(function () {
56 | const url = that.refs.url.getDOMNode();
57 | const length = url.value.length;
58 | url.setSelectionRange(length, length);
59 | url.focus();
60 | }, 0);
61 |
62 | },
63 | onTyping: function (event) {
64 | const path = event.target.value;
65 | if (path === this.state.path) {
66 | return;
67 | }
68 | this.setState({path: path});
69 | },
70 | focusFileInput: function () {
71 | if (this.state.path) {
72 | return;
73 | }
74 | $("#ultra-secret-hidden-file-input").trigger('click');
75 | this.setState({showMessage: true});
76 | },
77 | updateURL: function (e) {
78 | this.setState({url: e.target.value});
79 | },
80 | render: function () {
81 | return (
82 |
31 |
33 | {this.props.username} wants to edit this workspace
32 |
34 |
42 |
35 |
41 |
36 |
37 |
38 |
39 |
40 |
83 |
126 | );
127 | }
128 | });
129 |
130 | module.exports = JoinWorkspace;
131 |
--------------------------------------------------------------------------------
/templates/messages_view.js:
--------------------------------------------------------------------------------
1 | /** @jsx React.DOM */
2 | "use strict";
3 |
4 | const flux = require("flukes");
5 | const React = require('react-atom-fork');
6 | const _ = require("lodash");
7 | const utils = require("../common/utils");
8 | const floop = require("../common/floop");
9 | const messageAction = require("../common/message_action");
10 |
11 |
12 | const LogMessageView = React.createClass({
13 | render: function () {
14 | const message = this.props.message;
15 | let repeatCountHTML = "";
16 | if (this.props.repeatCount > 0) {
17 | repeatCountHTML = (
18 | x{this.props.repeatCount + 1}
19 | );
20 | }
21 | return (
22 | Join Workspace
84 |
85 |
124 |
125 |
23 |
28 | );
29 | }
30 | });
31 |
32 | const UserMessageView = React.createClass({
33 | getInitialState: function () {
34 | return {
35 | ignoredURLs: [],
36 | };
37 | },
38 | ignoreURL: function (url, event) {
39 | if (event) {
40 | event.stopPropagation();
41 | event.preventDefault();
42 | }
43 | const ignoredURLs = this.state.ignoredURLs;
44 | ignoredURLs.push(url);
45 | this.setState({ignoredURLs: ignoredURLs});
46 | },
47 | render: function () {
48 | var message = this.props.message,
49 | urlRegexp = /https?:\/\/\S+/g,
50 | userColor = utils.user_color(message.username),
51 | result,
52 | msgTxt = [],
53 | before,
54 | after,
55 | key = 0,
56 | prevIndex = 0;
57 |
58 | while (true) {
59 | result = urlRegexp.exec(message.msg);
60 | if (!result) {
61 | msgTxt.push(message.msg.slice(prevIndex));
62 | break;
63 | }
64 | before = message.msg.slice(prevIndex, result.index);
65 | prevIndex = result.index + result[0].length;
66 | after = message.msg.slice(prevIndex, urlRegexp.lastIndex);
67 | let imgOrTxt = result[0];
68 | if (this.state.ignoredURLs.indexOf(imgOrTxt) === -1 && utils.image_mime_from_extension(imgOrTxt)) {
69 | imgOrTxt = (
70 |
24 | 
{message.msg} {repeatCountHTML}
26 |
27 | {message.prettyTime}
25 | {message.msg} {repeatCountHTML}
71 |
72 | 
73 |
);
74 | }
75 |
76 | msgTxt.push(
77 |
78 | {before}
79 | {imgOrTxt}
80 | {after}
81 |
82 | );
83 | }
84 |
85 | return (
86 |
87 |
98 | );
99 | }
100 | });
101 |
102 | const InteractiveMessageView = React.createClass({
103 | getInitialState: function () {
104 | return {
105 | clicked: null
106 | };
107 | },
108 | onClick: function (button) {
109 | if (this.state.clicked !== null) {
110 | return;
111 | }
112 | button.action();
113 | this.setState({clicked: button.id});
114 | },
115 | render: function () {
116 | var message = this.props.message,
117 | buttons = message.buttons || [];
118 |
119 | buttons = buttons.map(function (b) {
120 | var classes = "btn ",
121 | clicked = this.state.clicked;
122 |
123 | if (clicked === null || clicked === b.id) {
124 | classes += b.classNames.join(" ");
125 | }
126 | if (clicked === b.id) {
127 | classes += " dim";
128 | }
129 | return (
130 |
131 | );
132 | }, this);
133 |
134 | return (
135 |
88 |
97 | {message.prettyTime}
89 |
90 |
91 |
92 | {message.username || message.type}:
93 |
94 | {msgTxt}
95 |
96 |
136 |
146 | );
147 | }
148 | });
149 |
150 | const MessagesView = React.createClass({
151 | mixins: [flux.createAutoBinder(["messages"])],
152 | handleMessage_: function (event) {
153 | event.preventDefault();
154 | const input = this.refs.newMessage.getDOMNode();
155 | const value = input.value;
156 | let ret = floop.send_msg({data: value});
157 | if (ret) {
158 | ret = ret.message || ret.toString();
159 | messageAction.error(ret, false);
160 | return;
161 | }
162 | input.value = "";
163 | messageAction.user(this.props.username, value, Date.now() / 1000);
164 | },
165 | componentDidMount: function () {
166 | // focus in chat but not editor proxy :(
167 | if (this.props.focus && this.refs.newMessage) {
168 | this.focus();
169 | }
170 | },
171 | getMessages: function () {
172 | const messages = [];
173 | let prevLogMessage = null;
174 | this.props.messages.forEach(function (message) {
175 | if (message.type !== "log") {
176 | prevLogMessage = null;
177 | messages.push({message});
178 | return;
179 | }
180 | if (prevLogMessage === message.msg) {
181 | _.last(messages).repeatCount += 1;
182 | return;
183 | }
184 | messages.push({message, repeatCount: 0});
185 | prevLogMessage = message.msg;
186 | });
187 | return messages;
188 | },
189 | focus: function () {
190 | this.refs.newMessage.getDOMNode().focus();
191 | },
192 | render: function () {
193 | let chatInput = "";
194 | const nodes = this.getMessages().map(function (messageObj) {
195 | const message = messageObj.message;
196 | switch (message.type) {
197 | case "user":
198 | return
137 |
145 | {message.prettyTime}
138 |
139 | {message.msg}
140 | {buttons.length &&
141 |
144 | {buttons}
142 | }
143 |
211 |
214 |
215 | );
216 | }
217 |
218 | return (
219 |
223 |
230 | );
231 | }
232 | });
233 |
234 | module.exports = {
235 | InteractiveMessageView,
236 | LogMessageView,
237 | MessagesView,
238 | UserMessageView,
239 | };
240 |
--------------------------------------------------------------------------------
/templates/mixins.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | const ReactUnwrapper = {
4 | destroy: function (e) {
5 | if (e) {
6 | e.preventDefault();
7 | }
8 | if (!this.isMounted()) {
9 | return;
10 | }
11 | this.getDOMNode().parentNode.destroy();
12 | }
13 | };
14 |
15 | const $ = require('atom-space-pen-views').$;
16 |
17 | const FormMixin = {
18 | componentDidMount: function () {
19 | const that = this;
20 | $(this.getDOMNode()).keydown(function (k) {
21 | switch (k.keyCode) {
22 | case 27: // escape
23 | that.destroy(k);
24 | return;
25 | case 13: // enter
26 | that.onSubmit(k);
27 | return;
28 | default:
29 | break;
30 | }
31 | });
32 | },
33 | componentWillUnmount: function () {
34 | $(this.getDOMNode()).off("keydown");
35 | },
36 | };
37 |
38 | module.exports = {
39 | ReactUnwrapper: ReactUnwrapper,
40 | FormMixin: FormMixin,
41 | };
42 |
--------------------------------------------------------------------------------
/templates/pane.coffee:
--------------------------------------------------------------------------------
1 | {$, View} = require 'atom-space-pen-views'
2 |
3 | class PaneView extends View
4 | focus: -> @input.focus()
5 | initialize: (@pane) =>
6 | @pane.setView @
7 | this[0].appendChild(@pane.inner)
8 |
9 | detached: ->
10 | console.log "detached"
11 | @pane.onDetached?()
12 |
13 | @content: (params) ->
14 | @div 'style': "overflow: auto;", "class": "native-key-bindings"
15 |
16 | class Pane
17 | constructor: (@title, @iconName, @inner, @onDetached) ->
18 | getViewClass: -> PaneView
19 | getView: -> @view
20 | setView: (@view) ->
21 | getTitle: () =>
22 | @title
23 | getIconName: () =>
24 | @iconName
25 |
26 | module.exports = Pane
27 |
--------------------------------------------------------------------------------
/templates/permission_view.js:
--------------------------------------------------------------------------------
1 | /** @jsx React.DOM */
2 | "use strict";
3 |
4 | var React = require('react-atom-fork');
5 | var floop = require("../common/floop");
6 | var mixins = require("./mixins");
7 | var _ = require("lodash");
8 |
9 | var PermissionView = React.createClass({
10 | mixins: [mixins.ReactUnwrapper, mixins.FormMixin],
11 | getInitialState: function () {
12 | var permissions;
13 | permissions = this.props.user.permissions;
14 | return {
15 | admin_room: permissions.indexOf("kick") !== -1,
16 | view_room: permissions.indexOf("get_buf") !== -1,
17 | edit_room: permissions.indexOf("set_buf") !== -1,
18 | request_perms: permissions.indexOf("request_perms") !== -1,
19 | };
20 | },
21 | componentDidMount: function () {
22 | // TODO. this is a bootstrap-ism
23 | // this.props.user.on("change:connected", modal.killModal);
24 | return;
25 | },
26 | renderField: function (label, name, description) {
27 | return (
28 |
224 | {chatInput}
225 |
229 |
226 | {nodes}
227 |
228 |
29 |
30 |
31 |
35 | );
36 | },
37 | /**
38 | * @param {Event} event
39 | * @private
40 | */
41 | onSubmit: function (event) {
42 | var newPerms;
43 | event.preventDefault();
44 | newPerms = ["view_room", "edit_room", "request_perms", "admin_room"].filter(function (perm) {
45 | return this.state[perm];
46 | }, this);
47 | floop.send_perms({
48 | user_id: this.props.user.getConnectionID(),
49 | perms: newPerms,
50 | action: "set",
51 | });
52 | this.destroy();
53 | },
54 | /**
55 | * @param {string} type
56 | * @param {Object} event
57 | * @private
58 | */
59 | handleChange_: function (type, event) {
60 | var index, permissions, state, checked;
61 | permissions = ["view_room", "request_perms", "edit_room", "admin_room"];
62 | checked = event.target.checked;
63 | index = permissions.indexOf(type);
64 | state = {};
65 |
66 | permissions.forEach(function (perm, i) {
67 | if (i < index && checked) {
68 | state[perm] = checked;
69 | } else if (i > index && !checked) {
70 | state[perm] = checked;
71 | } else if (i === index) {
72 | state[perm] = checked;
73 | } else {
74 | state[perm] = this.state[perm];
75 | }
76 | }, this);
77 | this.setState(state);
78 | },
79 | render: function () {
80 | var fields = [
81 | ["View", "view_room", "view files and terminals in this workspace"],
82 | ["Request permissions", "request_perms", "ask admins for permission to edit files in this workspace"],
83 | ["Edit", "edit_room", "edit files in this workspace"],
84 | ["Administer", "admin_room", "set permissions and type in all terminals"],
85 | ].map(function (perm) {
86 | return this.renderField.apply(this, perm);
87 | }, this);
88 |
89 |
90 | return (
91 |
32 | {description}
33 |
34 |
92 |
107 | );
108 | }
109 | });
110 |
111 | module.exports = PermissionView;
112 |
113 |
--------------------------------------------------------------------------------
/templates/status_bar.js:
--------------------------------------------------------------------------------
1 | /** @jsx React.DOM */
2 | "use strict";
3 |
4 | const React = require("react-atom-fork");
5 | const flux = require("flukes");
6 | const prefs = require("../common/userPref_model");
7 |
8 | const floop = require("../common/floop");
9 |
10 | const StatusBarView = React.createClass({
11 | mixins: [flux.createAutoBinder(["me"], [prefs])],
12 | getInitialState: function () {
13 | return {
14 | conn_status: "Connecting...",
15 | };
16 | },
17 | componentWillMount: function () {
18 | const that = this;
19 | floop.onROOM_INFO(function () {
20 | that.setState({conn_status: "Connected."});
21 | });
22 | floop.onDISCONNECT(function () {
23 | that.setState({conn_status: "Disconnected."});
24 | });
25 | },
26 | render: function () {
27 | let workspace = `${this.props.floourl.owner}/${this.props.floourl.workspace}`;
28 | let following_status;
29 | if (prefs.following) {
30 | following_status = " Following changes.";
31 | } else if (prefs.followUsers.length) {
32 | following_status = `Following ${prefs.followUsers.join(", ")}`;
33 | }
34 | return (
35 | Permissions for {this.props.user.id}
93 | 94 | 99 | 100 |
101 |
106 |
102 |
103 |
104 |
105 |
36 | {this.props.me.id}@{workspace}: {this.state.conn_status} {following_status}
37 |
38 | );
39 | }
40 | });
41 |
42 | module.exports = StatusBarView;
43 |
--------------------------------------------------------------------------------
/templates/user_list_pane.js:
--------------------------------------------------------------------------------
1 | /** @jsx React.DOM */
2 | "use strict";
3 | "use babel";
4 |
5 | const React = require("react-atom-fork");
6 | const mixins = require("./mixins");
7 | const UserlistView = require("./user_view").UserlistView;
8 |
9 | const UserlistPane = React.createClass({
10 | mixins: [mixins.ReactUnwrapper],
11 | render: function () {
12 | return (
13 |
14 |
20 | );
21 | }
22 | });
23 |
24 | module.exports = UserlistPane;
25 |
--------------------------------------------------------------------------------
/templates/webview.js:
--------------------------------------------------------------------------------
1 | /*global HTMLElement: true */
2 |
3 | "use strict";
4 |
5 | const _ = require("lodash");
6 | const floorc = require("../common/floorc");
7 | const message_action = require("../common/message_action");
8 | const Pane = require("../../templates/pane");
9 |
10 | const Proto = Object.create(HTMLElement.prototype);
11 |
12 | Proto.createdCallback = function () {
13 | const frame = document.createElement("webview");
14 | frame.setAttribute("plugins", "on");
15 | frame.setAttribute("disablewebsecurity", "on");
16 | frame.setAttribute("allowPointerLock", 'on');
17 | frame.setAttribute("allowfileaccessfromfiles", 'on');
18 | frame.style.border = "0 none";
19 | frame.style.width = "100%";
20 | frame.style.height = "100%";
21 | frame.className = "native-key-bindings";
22 |
23 | frame.addEventListener("console-message",function (e) {
24 | let m = e.message;
25 | const prefix = "::atom-floobits-ipc::";
26 | if (!m.startsWith(prefix)) {
27 | return;
28 | }
29 | m = m.slice(prefix.length);
30 | console.log(m);
31 | try {
32 | m = JSON.parse(m);
33 | } catch (e) {
34 | return;
35 | }
36 | this.onCredentials(m.auth);
37 | return;
38 | }.bind(this));
39 | this.frame = frame;
40 | };
41 |
42 | Proto.onCredentials = function (blob) {
43 | if (!_.has(floorc, "auth")) {
44 | floorc.auth = {};
45 | }
46 |
47 | const host = _.keys(blob)[0];
48 | const auth_data = blob[host];
49 |
50 | if (!_.has(floorc.auth, host)) {
51 | floorc.auth[host] = {};
52 | }
53 |
54 | const floorc_auth = floorc.auth[host];
55 |
56 | floorc_auth.username = auth_data.username;
57 | floorc_auth.api_key = auth_data.api_key;
58 | floorc_auth.secret = auth_data.secret;
59 |
60 | try {
61 | floorc.__write();
62 | } catch (e) {
63 | return message_action.error(e);
64 | }
65 | };
66 |
67 | Proto.load = function (host) {
68 | this.host = host;
69 | this.pane = new Pane("Floobits", "", this);
70 | atom.workspace.getActivePane().activateItem(this.pane);
71 | this.frame.src = `https://${host}/signup/atom`;
72 | };
73 |
74 | Proto.attachedCallback = function () {
75 | this.className = "floobits-nativize";
76 | this.appendChild(this.frame);
77 | };
78 |
79 | Proto.detachedCallback = function () {
80 | this.destroy();
81 | };
82 |
83 | Proto.destroy = function () {
84 | if (!this.pane) {
85 | return;
86 | }
87 | try {
88 | this.pane.destroy();
89 | } catch (e) {
90 | console.warn(e);
91 | }
92 | this.pane = null;
93 | };
94 |
95 | module.exports = document.registerElement("floobits-welcome_web_view", {prototype: Proto});
96 |
--------------------------------------------------------------------------------
/templates/yes_no_cancel.js:
--------------------------------------------------------------------------------
1 | /** @jsx React.DOM */
2 |
3 | "use strict";
4 |
5 | const React = require('react-atom-fork');
6 | const mixins = require("./mixins");
7 | const atomUtils = require("../atom_utils");
8 |
9 | const YesNoCancel = React.createClass({
10 | mixins: [mixins.ReactUnwrapper, mixins.FormMixin],
11 | onSubmit: function (type) {
12 | if (!type) {
13 | type = "yes";
14 | } else if (type.target) {
15 | type = type.target.name;
16 | }
17 | const cb = this.props.cb.bind({}, null, type);
18 | setTimeout(cb, 0);
19 | this.destroy();
20 | },
21 | componentDidMount: function () {
22 | this.refs.yes.getDOMNode().focus();
23 | },
24 | render: function () {
25 | const yes = this.props.yes || "Yes";
26 | const no = this.props.no || "No";
27 | const cancel = this.props.cancel || "Cancel";
28 | return (
29 |
52 | );
53 | }
54 | });
55 |
56 | module.exports = function (title, body, opts, cb) {
57 | if (!cb) {
58 | cb = opts;
59 | opts = {};
60 | }
61 |
62 | opts.title = title;
63 | opts.body = body;
64 | opts.cb = cb;
65 |
66 | const view = YesNoCancel(opts);
67 | atomUtils.addModalPanel('yes-no-cancel', view);
68 | };
--------------------------------------------------------------------------------
15 | Floobits
16 |
17 |
18 | Floobits
16 |
17 |