All File Changes
v311_preview to v311_preview2 (2015-01-12 to 2015-01-20) v311
- src/hg/hgAi/hgAi.c
- lines changed 336, context: html, text, full: html, text
New CGI hgAi (Annotation Integrator) that uses new ReactJS/ImmutableJS framework.hgAi.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- text output for queries on track data
hgAi.jsx is the React/JSX UI view code, compiled to bundle/reactHgAi.js.
hgAiModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- src/hg/hgAi/makefile
- lines changed 17, context: html, text, full: html, text
New CGI hgAi (Annotation Integrator) that uses new ReactJS/ImmutableJS framework.hgAi.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- text output for queries on track data
hgAi.jsx is the React/JSX UI view code, compiled to bundle/reactHgAi.js.
hgAiModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- src/hg/hgChooseDb/hgChooseDb.c
- lines changed 287, context: html, text, full: html, text
New toy CGI hgChooseDb based on PPT mockup and ideas from Ann and Matt: popular species icons and autocomplete search for species, as an alternative to hgGateway's menus. Uses the new ReactJS/ImmutableJS framework.
hgChooseDb.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- cart-based JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- no cart; fast JSON responses to species-search autocomplete requests
hgChooseDb.jsx is the React/JSX UI view code, compiled to bundle/reactHgChooseDb.js.
hgChooseDbModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- src/hg/hgChooseDb/makefile
- lines changed 15, context: html, text, full: html, text
New toy CGI hgChooseDb based on PPT mockup and ideas from Ann and Matt: popular species icons and autocomplete search for species, as an alternative to hgGateway's menus. Uses the new ReactJS/ImmutableJS framework.
hgChooseDb.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- cart-based JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- no cart; fast JSON responses to species-search autocomplete requests
hgChooseDb.jsx is the React/JSX UI view code, compiled to bundle/reactHgChooseDb.js.
hgChooseDbModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- src/hg/hgTracks/multiWig.c
- lines changed 4, context: html, text, full: html, text
fix stacked bar charts to draw in the order they appear on the trackUipage (via Kate)
- src/hg/htdocs/FAQ/FAQreleases.html
- lines changed 2, context: html, text, full: html, text
editing the GenBank update frequency statement to be more accurate
- src/hg/htdocs/goldenPath/help/genomeEuro.html
- lines changed 12, context: html, text, full: html, text
modified genomeEuro help page to reflect that the migration of Saved Sessions is in the past
- src/hg/htdocs/goldenPath/help/hgAiHelp.html
- lines changed 56, context: html, text, full: html, text
New CGI hgAi (Annotation Integrator) that uses new ReactJS/ImmutableJS framework.hgAi.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- text output for queries on track data
hgAi.jsx is the React/JSX UI view code, compiled to bundle/reactHgAi.js.
hgAiModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- src/hg/htdocs/goldenPath/newsarch.html
- lines changed 1, context: html, text, full: html, text
changed to correct spelling of Jonathan's name. thanks, Luvina!
- lines changed 37, context: html, text, full: html, text
added CPTAC and PeptideAtlas announcement
- lines changed 1, context: html, text, full: html, text
fixed heading for announcement
- src/hg/htdocs/indexNews.html
- lines changed 1, context: html, text, full: html, text
changed to correct spelling of Jonathan's name. thanks, Luvina!
- lines changed 37, context: html, text, full: html, text
added news announcement for CPTAC hub and PeptideAtlas track
- lines changed 39, context: html, text, full: html, text
made a few corrections to announcement and moved old item to archives section
- src/hg/htdocs/style/HGStyle.css
- lines changed 55, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- lines changed 68, context: html, text, full: html, text
Implementing Kate's suggestions from code review: use CSS classes instead of hardcoded styles in JSX; fix comment and proliferation of if's in annoFormatTab.refs #14649
- src/hg/htdocs/training/vids/index.html
- lines changed 0, context: html, text, full: html, text
Removing spaces found during code review. refs #14656
- src/hg/inc/encode/wgEncodeCell.h
- lines changed 75, context: html, text, full: html, text
Add ENCODE cell table (wgEncodeCell) support. This contains the more useful info from cv.ra, with additional curation (e.g. summary description)
- src/hg/inc/hCommon.h
- lines changed 3, context: html, text, full: html, text
New CGI hgAi (Annotation Integrator) that uses new ReactJS/ImmutableJS framework.hgAi.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- text output for queries on track data
hgAi.jsx is the React/JSX UI view code, compiled to bundle/reactHgAi.js.
hgAiModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- src/hg/inc/hui.h
- lines changed 10, context: html, text, full: html, text
Set default subtracks on (10 spread across color spectrum, emphasizing ENCODE tier1 and well-known. Additional support for subtrack color on UI. refs #14353
- src/hg/js/external/BackboneExtend.js
- lines changed 43, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- src/hg/js/external/es5-sham.4.0.3.min.js
- lines changed 6, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- src/hg/js/external/es5-shim.4.0.3.min.js
- lines changed 6, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- src/hg/js/external/immutable.3.2.1.min.js
- lines changed 34, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- src/hg/js/external/lodash.2.4.1.compat.min.js
- lines changed 61, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- src/hg/js/external/makefile
- lines changed 13, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- src/hg/js/install.mk
- lines changed 23, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- src/hg/js/makefile
- lines changed 26, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- src/hg/js/model/hgAi/hgAiModel.js
- lines changed 283, context: html, text, full: html, text
New CGI hgAi (Annotation Integrator) that uses new ReactJS/ImmutableJS framework.hgAi.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- text output for queries on track data
hgAi.jsx is the React/JSX UI view code, compiled to bundle/reactHgAi.js.
hgAiModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- src/hg/js/model/hgAi/makefile
- lines changed 6, context: html, text, full: html, text
New CGI hgAi (Annotation Integrator) that uses new ReactJS/ImmutableJS framework.hgAi.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- text output for queries on track data
hgAi.jsx is the React/JSX UI view code, compiled to bundle/reactHgAi.js.
hgAiModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- src/hg/js/model/hgChooseDb/hgChooseDbModel.js
- lines changed 64, context: html, text, full: html, text
New toy CGI hgChooseDb based on PPT mockup and ideas from Ann and Matt: popular species icons and autocomplete search for species, as an alternative to hgGateway's menus. Uses the new ReactJS/ImmutableJS framework.
hgChooseDb.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- cart-based JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- no cart; fast JSON responses to species-search autocomplete requests
hgChooseDb.jsx is the React/JSX UI view code, compiled to bundle/reactHgChooseDb.js.
hgChooseDbModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- src/hg/js/model/hgChooseDb/makefile
- lines changed 6, context: html, text, full: html, text
New toy CGI hgChooseDb based on PPT mockup and ideas from Ann and Matt: popular species icons and autocomplete search for species, as an alternative to hgGateway's menus. Uses the new ReactJS/ImmutableJS framework.
hgChooseDb.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- cart-based JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- no cart; fast JSON responses to species-search autocomplete requests
hgChooseDb.jsx is the React/JSX UI view code, compiled to bundle/reactHgChooseDb.js.
hgChooseDbModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- src/hg/js/model/lib/CladeOrgDbMixin.js
- lines changed 45, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- lines changed 2, context: html, text, full: html, text
Code review suggestions from Joe Thomas.
- lines changed 1, context: html, text, full: html, text
I don't know how I missed this in 151a615e9, but jshint complains aboutthe use of this inside plain old functions as opposed to methods.
In mixins, it's actually OK because these functions will be .call'd with this (the ImModel subclass).
- src/hg/js/model/lib/ImModel.js
- lines changed 265, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- lines changed 6, context: html, text, full: html, text
Code review suggestions from Joe Thomas.
- src/hg/js/model/lib/PositionSearchMixin.js
- lines changed 54, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- lines changed 2, context: html, text, full: html, text
Code review suggestions from Joe Thomas.
- lines changed 1, context: html, text, full: html, text
I don't know how I missed this in 151a615e9, but jshint complains aboutthe use of this inside plain old functions as opposed to methods.
In mixins, it's actually OK because these functions will be .call'd with this (the ImModel subclass).
- src/hg/js/model/lib/cart.js
- lines changed 75, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- lines changed 10, context: html, text, full: html, text
Code review suggestions from Joe Thomas.
- src/hg/js/model/lib/makefile
- lines changed 6, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- src/hg/js/model/makefile
- lines changed 6, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- lines changed 1, context: html, text, full: html, text
New toy CGI hgChooseDb based on PPT mockup and ideas from Ann and Matt: popular species icons and autocomplete search for species, as an alternative to hgGateway's menus. Uses the new ReactJS/ImmutableJS framework.
hgChooseDb.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- cart-based JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- no cart; fast JSON responses to species-search autocomplete requests
hgChooseDb.jsx is the React/JSX UI view code, compiled to bundle/reactHgChooseDb.js.
hgChooseDbModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- lines changed 1, context: html, text, full: html, text
New CGI hgAi (Annotation Integrator) that uses new ReactJS/ImmutableJS framework.hgAi.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- text output for queries on track data
hgAi.jsx is the React/JSX UI view code, compiled to bundle/reactHgAi.js.
hgAiModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- src/hg/js/react/bundle/reactHgAi.js
- lines changed 1, context: html, text, full: html, text
New CGI hgAi (Annotation Integrator) that uses new ReactJS/ImmutableJS framework.hgAi.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- text output for queries on track data
hgAi.jsx is the React/JSX UI view code, compiled to bundle/reactHgAi.js.
hgAiModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- lines changed 2, context: html, text, full: html, text
Implementing Kate's suggestions from code review: use CSS classes instead of hardcoded styles in JSX; fix comment and proliferation of if's in annoFormatTab.refs #14649
- src/hg/js/react/bundle/reactHgChooseDb.js
- lines changed 1, context: html, text, full: html, text
New toy CGI hgChooseDb based on PPT mockup and ideas from Ann and Matt: popular species icons and autocomplete search for species, as an alternative to hgGateway's menus. Uses the new ReactJS/ImmutableJS framework.
hgChooseDb.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- cart-based JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- no cart; fast JSON responses to species-search autocomplete requests
hgChooseDb.jsx is the React/JSX UI view code, compiled to bundle/reactHgChooseDb.js.
hgChooseDbModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- lines changed 2, context: html, text, full: html, text
Implementing Kate's suggestions from code review: use CSS classes instead of hardcoded styles in JSX; fix comment and proliferation of if's in annoFormatTab.refs #14649
- src/hg/js/react/bundle/reactLibBundle.js
- lines changed 1, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- lines changed 2, context: html, text, full: html, text
Implementing Kate's suggestions from code review: use CSS classes instead of hardcoded styles in JSX; fix comment and proliferation of if's in annoFormatTab.refs #14649
- src/hg/js/react/hgAi/hgAi.jsx
- lines changed 464, context: html, text, full: html, text
New CGI hgAi (Annotation Integrator) that uses new ReactJS/ImmutableJS framework.hgAi.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- text output for queries on track data
hgAi.jsx is the React/JSX UI view code, compiled to bundle/reactHgAi.js.
hgAiModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- lines changed 39, context: html, text, full: html, text
Implementing Kate's suggestions from code review: use CSS classes instead of hardcoded styles in JSX; fix comment and proliferation of if's in annoFormatTab.refs #14649
- src/hg/js/react/hgAi/makefile
- lines changed 11, context: html, text, full: html, text
New CGI hgAi (Annotation Integrator) that uses new ReactJS/ImmutableJS framework.hgAi.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- text output for queries on track data
hgAi.jsx is the React/JSX UI view code, compiled to bundle/reactHgAi.js.
hgAiModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- src/hg/js/react/hgChooseDb/hgChooseDb.jsx
- lines changed 187, context: html, text, full: html, text
New toy CGI hgChooseDb based on PPT mockup and ideas from Ann and Matt: popular species icons and autocomplete search for species, as an alternative to hgGateway's menus. Uses the new ReactJS/ImmutableJS framework.
hgChooseDb.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- cart-based JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- no cart; fast JSON responses to species-search autocomplete requests
hgChooseDb.jsx is the React/JSX UI view code, compiled to bundle/reactHgChooseDb.js.
hgChooseDbModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- lines changed 15, context: html, text, full: html, text
Implementing Kate's suggestions from code review: use CSS classes instead of hardcoded styles in JSX; fix comment and proliferation of if's in annoFormatTab.refs #14649
- src/hg/js/react/hgChooseDb/makefile
- lines changed 11, context: html, text, full: html, text
New toy CGI hgChooseDb based on PPT mockup and ideas from Ann and Matt: popular species icons and autocomplete search for species, as an alternative to hgGateway's menus. Uses the new ReactJS/ImmutableJS framework.
hgChooseDb.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- cart-based JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- no cart; fast JSON responses to species-search autocomplete requests
hgChooseDb.jsx is the React/JSX UI view code, compiled to bundle/reactHgChooseDb.js.
hgChooseDbModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- src/hg/js/react/lib/CheckboxLabel.jsx
- lines changed 38, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- lines changed 2, context: html, text, full: html, text
Implementing Kate's suggestions from code review: use CSS classes instead of hardcoded styles in JSX; fix comment and proliferation of if's in annoFormatTab.refs #14649
- src/hg/js/react/lib/CladeOrgDb.jsx
- lines changed 32, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- lines changed 3, context: html, text, full: html, text
Implementing Kate's suggestions from code review: use CSS classes instead of hardcoded styles in JSX; fix comment and proliferation of if's in annoFormatTab.refs #14649
- src/hg/js/react/lib/Icon.jsx
- lines changed 55, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- lines changed 3, context: html, text, full: html, text
Implementing Kate's suggestions from code review: use CSS classes instead of hardcoded styles in JSX; fix comment and proliferation of if's in annoFormatTab.refs #14649
- src/hg/js/react/lib/LabeledSelect.jsx
- lines changed 39, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- lines changed 6, context: html, text, full: html, text
Implementing Kate's suggestions from code review: use CSS classes instead of hardcoded styles in JSX; fix comment and proliferation of if's in annoFormatTab.refs #14649
- src/hg/js/react/lib/LoadingImage.jsx
- lines changed 30, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- lines changed 1, context: html, text, full: html, text
Implementing Kate's suggestions from code review: use CSS classes instead of hardcoded styles in JSX; fix comment and proliferation of if's in annoFormatTab.refs #14649
- src/hg/js/react/lib/Modal.jsx
- lines changed 55, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- lines changed 21, context: html, text, full: html, text
Implementing Kate's suggestions from code review: use CSS classes instead of hardcoded styles in JSX; fix comment and proliferation of if's in annoFormatTab.refs #14649
- src/hg/js/react/lib/PositionSearch.jsx
- lines changed 214, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- lines changed 8, context: html, text, full: html, text
Implementing Kate's suggestions from code review: use CSS classes instead of hardcoded styles in JSX; fix comment and proliferation of if's in annoFormatTab.refs #14649
- src/hg/js/react/lib/Section.jsx
- lines changed 22, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- src/hg/js/react/lib/SetClearButtons.jsx
- lines changed 27, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- src/hg/js/react/lib/Sortable.jsx
- lines changed 67, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- lines changed 6, context: html, text, full: html, text
Implementing Kate's suggestions from code review: use CSS classes instead of hardcoded styles in JSX; fix comment and proliferation of if's in annoFormatTab.refs #14649
- src/hg/js/react/lib/TextInput.jsx
- lines changed 59, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- lines changed 3, context: html, text, full: html, text
Implementing Kate's suggestions from code review: use CSS classes instead of hardcoded styles in JSX; fix comment and proliferation of if's in annoFormatTab.refs #14649
- src/hg/js/react/lib/makefile
- lines changed 13, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- src/hg/js/react/makefile
- lines changed 8, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- lines changed 1, context: html, text, full: html, text
New toy CGI hgChooseDb based on PPT mockup and ideas from Ann and Matt: popular species icons and autocomplete search for species, as an alternative to hgGateway's menus. Uses the new ReactJS/ImmutableJS framework.
hgChooseDb.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- cart-based JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- no cart; fast JSON responses to species-search autocomplete requests
hgChooseDb.jsx is the React/JSX UI view code, compiled to bundle/reactHgChooseDb.js.
hgChooseDbModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- lines changed 1, context: html, text, full: html, text
New CGI hgAi (Annotation Integrator) that uses new ReactJS/ImmutableJS framework.hgAi.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- text output for queries on track data
hgAi.jsx is the React/JSX UI view code, compiled to bundle/reactHgAi.js.
hgAiModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- src/hg/js/react/mixins/ImmutableUpdate.js
- lines changed 68, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- src/hg/js/react/mixins/PathUpdate.js
- lines changed 16, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- src/hg/js/react/mixins/PathUpdateOptional.js
- lines changed 19, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- src/hg/js/react/mixins/makefile
- lines changed 8, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- src/hg/js/react/react.mk
- lines changed 38, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- lines changed 1, context: html, text, full: html, text
jsx unfortunately writes log output to stderr. To keep top-level make > /dev/null quiet, redirect its stderr to stdout.
- src/hg/js/simple.mk
- lines changed 10, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- src/hg/js/subdirs.mk
- lines changed 22, context: html, text, full: html, text
New javascript UI framework using ReactJS and ImmutableJS libraries.Files live in three subdirectories of hg/js/:
- external/ has minified releases of MIT- or BSD-licensed, well-tested external libraries
that are not already hosted on sufficiently fast content delivery networks (CDNs).
We can use CDNs for ReactJS, JQuery and JQueryUI.
- model/ has code for the "brains" of a CGI's UI: it maintains a data structure that encodes
the state of the UI, sends ajax requests to the CGI when necessary to respond to user actions,
and updates the UI state data structure in response to user actions and ajax responses.
model has a lib/ subdirectory and will have one subdir per CGI.
model/lib/ has these modules:
- cart.js: functions for sending JSON-encoded ajax requests to CGI with hgsid
- ImModel.js: base class for UI model that uses ImmutableJS to efficiently maintain
a series of immutable data structures encoding the entire UI state. This enables
simpler reasoning about state changes, and as a bonus, easy undo/redo of user actions.
- CladeOrgDbMixin.js: this can be "mixed in" to a subclass of ImModel to handle
hgGateway-style clade, org/genome and db menus.
- PositionSearchMixin.js: this can be "mixed in" to a subclass of ImModel to handle
position search with autocomplete for genes (when a db has that info)
- react/ has code for the UI view, i.e. the elements that appear on the page and trigger
events when the user does something. The React library efficiently implements a virtual
top-down re-render of the entire UI state whenever something changes, making DOM calls
only for DOM elements that need to change. The use of ImmutableJS for the UI state
enables very efficient detection of changes.
The view modules are written in JSX, a superset of Javascript that adds HTML-like
syntax for instantiation of UI elements. Compiling JSX to JS requires the installation
of node, npm (node package manager) and the react-tools package. In order to avoid
that requirement for mirror installations, a bundle of compiled JSX files has been added
to git. Developers who change .JSX files must set the JSX environment variable to jsx
(or complete path to jsx), and should also set JSXHINT to jsxhint.
react/ has the following subdirs:
- bundle/ contains compiled and minified version of JSX code
- lib/ has UI components written in JSX, some very basic (Section.jsx, CheckboxLabel.jsx),
some more complex (PositionSearch.jsx)
- mixins/ has JS (not JSX) modules that add functionality to components; PathUpdate.js
checks for properties that must be passed down in order to work with ImModel,
ImmutableUpdate adds efficient change detection using ImmutableJS.
- each CGI will have a subdir for its JSX code
Many thanks to Brian Craft for pointing me at React and Immutable. Any flaws herein
are not Brian's fault!
- src/hg/lib/encode/wgEncodeCell.as
- lines changed 17, context: html, text, full: html, text
Add ENCODE cell table (wgEncodeCell) support. This contains the more useful info from cv.ra, with additional curation (e.g. summary description)
- src/hg/lib/encode/wgEncodeCell.c
- lines changed 210, context: html, text, full: html, text
Add ENCODE cell table (wgEncodeCell) support. This contains the more useful info from cv.ra, with additional curation (e.g. summary description)
- src/hg/lib/encode/wgEncodeCell.sql
- lines changed 23, context: html, text, full: html, text
Add ENCODE cell table (wgEncodeCell) support. This contains the more useful info from cv.ra, with additional curation (e.g. summary description)
- src/hg/lib/hCommon.c
- lines changed 7, context: html, text, full: html, text
New CGI hgAi (Annotation Integrator) that uses new ReactJS/ImmutableJS framework.hgAi.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- text output for queries on track data
hgAi.jsx is the React/JSX UI view code, compiled to bundle/reactHgAi.js.
hgAiModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- src/hg/lib/hui.c
- lines changed 297, context: html, text, full: html, text
Refactor subtrack table construction (500 line function)
- lines changed 13, context: html, text, full: html, text
Suppress annoying 'Top' link at start of subtrack list when matrix not present
- lines changed 18, context: html, text, full: html, text
Sortable subtrack list now includes color patch with header. Still needs sorting logic for the column
- lines changed 18, context: html, text, full: html, text
Add ability to sort subtracks by color to hgTrackUi. refs #14353.
- lines changed 14, context: html, text, full: html, text
Simplify color sorting code, and make trackDb settings more consistent. refs #14353
- lines changed 11, context: html, text, full: html, text
Set default subtracks on (10 spread across color spectrum, emphasizing ENCODE tier1 and well-known. Additional support for subtrack color on UI. refs #14353
- lines changed 41, context: html, text, full: html, text
Support for computing track priorities by subtrack color in hgTrackDb
- lines changed 18, context: html, text, full: html, text
Restore subtrack color feature when no sortable columns. refs #14353
- src/hg/lib/mafSnp160way.as
- lines changed 9, context: html, text, full: html, text
add AS file for mafSnp160way so table browser can give some minimal doc
- src/hg/lib/makefile
- lines changed 1, context: html, text, full: html, text
Add ENCODE cell table (wgEncodeCell) support. This contains the more useful info from cv.ra, with additional curation (e.g. summary description)
- src/hg/lib/trackHubCheck.c
- lines changed 8, context: html, text, full: html, text
hubCheck should make sure that the number on "type bigBed #" lines has anumber that's less than equal to the number of fields in the table.
- src/hg/lib/web.c
- lines changed 8, context: html, text, full: html, text
In hgc, hgGene, and hgTrackUi menu link to hgTables automatically selects the group track and table -- now fixed for containers
- src/hg/makeDb/doc/eboVir3/153.descriptions.txt
- lines changed 153, context: html, text, full: html, text
additional links to details on ebola species names, after email from auser.
- src/hg/makeDb/doc/hg38/gnfAtlas.txt
- lines changed 169, context: html, text, full: html, text
GNF Atlas and other microarray expression tracks
- src/hg/makeDb/doc/hg38/hg38Patch2.txt
- lines changed 145, context: html, text, full: html, text
working up patch2 into a 2bit and AGP file refs #14167
- lines changed 355, context: html, text, full: html, text
GRCh38 patch 2 almost ready to go refs #14167
- src/hg/makeDb/doc/hg38/reg.txt
- lines changed 22, context: html, text, full: html, text
Add ENCODE cell table (wgEncodeCell) support. This contains the more useful info from cv.ra, with additional curation (e.g. summary description)
- src/hg/makeDb/doc/hg38/regionScan.pl
- lines changed 70, context: html, text, full: html, text
working up patch2 into a 2bit and AGP file refs #14167
- src/hg/makeDb/doc/hg38/scanAssemblyReport.pl
- lines changed 21, context: html, text, full: html, text
working up patch2 into a 2bit and AGP file refs #14167
- src/hg/makeDb/doc/ucscGenes/hg38.ucscGenes15.csh
- lines changed 9, context: html, text, full: html, text
GNF Atlas and other microarray expression tracks
- src/hg/makeDb/hgTrackDb/hgTrackDb.c
- lines changed 1, context: html, text, full: html, text
Set default subtracks on (10 spread across color spectrum, emphasizing ENCODE tier1 and well-known. Additional support for subtrack color on UI. refs #14353
- src/hg/makeDb/outside/uwDnaseTrackHub/uwDnaseTrackHub.c
- lines changed 219, context: html, text, full: html, text
Add option to use cell descriptions in table to construct long labels
- src/hg/makeDb/schema/all.joiner
- lines changed 12, context: html, text, full: html, text
Added snp142 tables to all.joiner
- src/hg/makeDb/trackDb/ebola/eboVir3/cons160way.html
- lines changed 3, context: html, text, full: html, text
additional links to details on ebola species names, after email from auser.
- src/hg/makeDb/trackDb/gwipsvizRiboseq.html
- lines changed 18, context: html, text, full: html, text
Made a couple of reference changes based on comments from Audrey Michel; refs #14066
- lines changed 1, context: html, text, full: html, text
Corrected the date on an in-text citation; refs #14066
- src/hg/makeDb/trackDb/human/hg19/peptideAtlas.html
- lines changed 1, context: html, text, full: html, text
fixed link to downloads directory
- src/hg/makeDb/trackDb/human/hg19/trackDb.ra
- lines changed 1, context: html, text, full: html, text
changed peptideAtlas visbility settings, per #14054
- src/hg/makeDb/trackDb/human/hg38/hg38Patch2.html
- lines changed 65, context: html, text, full: html, text
GRCh38 patch 2 almost ready to go refs #14167
- lines changed 163, context: html, text, full: html, text
update to HTML contents for Patch 2 refs #14167
- src/hg/makeDb/trackDb/human/hg38/hg38Patch2.ra
- lines changed 72, context: html, text, full: html, text
GRCh38 patch 2 almost ready to go refs #14167
- lines changed 1, context: html, text, full: html, text
update to HTML contents for Patch 2 refs #14167
- lines changed 33, context: html, text, full: html, text
PSL table needs to start with altSeqLiftOverPsl to work in hgc clicks refs #14167
- src/hg/makeDb/trackDb/human/hg38/trackDb.ra
- lines changed 2, context: html, text, full: html, text
GRCh38 patch 2 almost ready to go refs #14167
- src/hg/makeDb/trackDb/human/hg38/uwDnase.ra
- lines changed 1165, context: html, text, full: html, text
Add ENCODE cell table (wgEncodeCell) support. This contains the more useful info from cv.ra, with additional curation (e.g. summary description)
- lines changed 4, context: html, text, full: html, text
Simplify color sorting code, and make trackDb settings more consistent. refs #14353
- lines changed 48, context: html, text, full: html, text
Set default subtracks on (10 spread across color spectrum, emphasizing ENCODE tier1 and well-known. Additional support for subtrack color on UI. refs #14353
- lines changed 1, context: html, text, full: html, text
Tweak order of UI subtrack columns. refs #14353
- src/hg/makeDb/trackDb/human/trackDb.ra
- lines changed 1, context: html, text, full: html, text
Moved GWIPS-viz Riboseq track from Mapping group to Expression group; refs #14066
- src/hg/makeDb/trackDb/mouse/mm10/wgEncodeGencodeVM4.ra
- lines changed 6, context: html, text, full: html, text
Changing VM3 to VM4, the correct version, refs #14529
- src/hg/makeDb/trackDb/trackDb.chainNet.ra
- lines changed 50, context: html, text, full: html, text
adding chain net hg38Patch2 refs #14167
- src/hg/utils/twoBitMask/twoBitMask.c
- lines changed 7, context: html, text, full: html, text
put out error message rather than crashing in twoBitMask if a bed regionis off the end of a chromosome #14669
- src/inc/common.h
- lines changed 3, context: html, text, full: html, text
New toy CGI hgChooseDb based on PPT mockup and ideas from Ann and Matt: popular species icons and autocomplete search for species, as an alternative to hgGateway's menus. Uses the new ReactJS/ImmutableJS framework.
hgChooseDb.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- cart-based JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- no cart; fast JSON responses to species-search autocomplete requests
hgChooseDb.jsx is the React/JSX UI view code, compiled to bundle/reactHgChooseDb.js.
hgChooseDbModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- src/lib/annoFormatTab.c
- lines changed 15, context: html, text, full: html, text
Implementing Kate's suggestions from code review: use CSS classes instead of hardcoded styles in JSX; fix comment and proliferation of if's in annoFormatTab.refs #14649
- src/lib/common.c
- lines changed 15, context: html, text, full: html, text
New toy CGI hgChooseDb based on PPT mockup and ideas from Ann and Matt: popular species icons and autocomplete search for species, as an alternative to hgGateway's menus. Uses the new ReactJS/ImmutableJS framework.
hgChooseDb.c has three modes of operation:
- HTML output for simple main page with a <div> container to be filled in by javascript
- cart-based JSON responses to ajax requests from javascript (using hg/lib/cartJson.c)
- no cart; fast JSON responses to species-search autocomplete requests
hgChooseDb.jsx is the React/JSX UI view code, compiled to bundle/reactHgChooseDb.js.
hgChooseDbModel.js is a subclass of js/model/lib/ImModel.js that gets initial state
from the server and then responds to user actions.
- lines changed 11, context: html, text, full: html, text
fixed output file corruption caused by by using setvbuf when mustOpen has been called with magic file name "stdout"
- src/utils/bigBedInfo/bigBedInfo.c
- lines changed 1, context: html, text, full: html, text
add fieldCount to output of bigBedInfo
- src/utils/qa/weeklybld/buildEnv.csh
- lines changed 3, context: html, text, full: html, text
v311 preview2 refs #14648
- lines changed: 7341
- files changed: 149