cc75aec8f0
Changes to MainViewCB
---------------------
This is a siginificant restructuring of the main controller in the
system and suggests a number of ideas and practices that should be
applied when refactoring the rest of the controllers or designing new
ones. UI code is inherently verbose; as such, the best we can do is to
structure a controller such as MainViewCB in a way that minimizes the
verbosity as much as possible and focuses on making what is happening as
clear as possible. That's why (as is described further below), almost
everything important now happens in the #initialize method. A major goal
of this change is that developers are able to look at MainViewCB and
read its #initialize method like a script. Indirections to other methods
are minimized as much as possible. The primary focus is on readability
(and therefore maintainability).
These changes began as an effort to substitute a mocked-out "backend",
i.e. bitcoin and p2p infrastructure, such that the application could
be run as quickly as possible, without the need for network
sychronization, bootstrapping, etc, for the purposes of UI development
and testing. Trying to make that change naturally evolved into this set
of refactorings. So at this point, MainViewCB is still "hard-wired" to
live bitcoin and tomp2p backends, but changing that, i.e. providing
mocked-out backends will be that much easier and clearer to accomplish
now.
Specifics:
- Use public vs. private contstructor. This allows for the possibility
of unit testing, avoids spurious warnings in the IDE, and generally
adheres to the principle of least surprise.
- Orchestrate creation and composition of components within the
#initialize method. This avoids the need for member fields almost
entirely.
- Extract and delegate to private methods from #initialize only where
it helps readibility. In general, this change assumes that initialize
should be "where the action is": if the layout of a particular view
is complex, then deal with that complexity directly within the
#initialize method. However, if the creation of a given component is
particularly verbose--for example the creation of the splash screen,
then extract a #createSplashScreen method that returns a VBox. The
same approach has been applied in extracting the
#createBankAccountComboBox, #applyPendingTradesInfoIcon and
#loadSelectedNavigation methods.
- Extract the NavButton member class to cleanly encapsulate what it
means to be a ToggleButton on the Bitsquare application navigation.
This approach is similar to the MenuItem class in
AccountSettingsViewCB.
- Use "double-brace initialization" syntax for JavaFX components
where appropriate, e.g.:
HBox rightNavPane =
new HBox(accountComboBox, settingsButton, accountButton) {{
setSpacing(10);
setRightAnchor(this, 10d);
setTopAnchor(this, 0d);
}};
This approach, while typically rarely used, is an especially
appropriate fit for JavaFX UI components, as the the allows for both
maximum concision and clarity. Most JavaFX components are configured
through a combination of constructor parameters and setter method
invocations, and this approach allows all of them to happen at
construction/initialization time.
- Remove class section comments. In general--and as @mkarrer and I have
discussed--these `////...` blocks shouldn't be necessary going
forward. The goal is classes that are as small and focused as they
can be, and they should be self-documenting to the greatest degree
possible.
- Remove empty lifecycle methods from the ViewCB superclass.
- Remove Profiler statements. These are fine for specific debugging
sessions, but should otherwise be removed for normal use.
Changes to Navigation.Item
--------------------------
These changes to the Navigation.Item enum were made in support of the
refactorings above, particularly in support of the newly extracted
NavButton class being as concise to construct as possible.
- Introduce Navigation.Item#getDisplayName
Push navigation button titles, such as "Overview" for HOME, "Buy BTC"
for BUY, etc. into the Navigation.Item enum itself. This can later be
refactored to support I18N, e.g. by embedding a message label instead
of the actual english word. Not all Navigation items have a display
name yet (and it may or may not make sense for them all to have one).
The default value is "NONE".
What is Bitsquare?
Bitsquare is a cross-platform desktop application that allows users to trade fiat money (dollars, euros, etc) for bitcoin without relying on centralized exchanges such as Coinbase, Bitstamp or (the former) Mt. Gox.
By running Bitsquare on their local machines, users form a peer-to-peer network. Offers to buy and sell bitcoin are broadcast to that network, and through the process of offering and accepting these trades via the Bitsquare UI, a market is established.
There are no central points of control or failure in the Bitsquare network. There are no trusted third parties. When two parties agree to trade fiat money for bitcoin, the bitcoin to be bought or sold is held in escrow using multisignature transaction capabilities native to the bitcoin protocol.
Because the fiat money portion of any trade must be transferred via traditional means such as a wire transfer, Bitsquare incorporates first-class support for human arbitration to resolve any errors or disputes.
You can read about all of this and more in the overview, whitepaper, arbitration and risk analysis documents. Several screencasts are available as well.
Status
Pre-alpha and under heavy development.
Building from source
- Install the latest JDK (8u20 or better)
- Clone this repository
- Build and launch the Bitsquare JavaFX client by running:
./gradlew run
Pass command line arguments to the app via the Gradle -Pargs property as follows:
./gradlew run -Pargs="--help"
Or, build an executable jar with the appJar task:
./gradlew appJar
Run the app as follows:
java -jar build/libs/bitsquare-<version>-app.jar
Pass the --help flag to see what options are available:
java -jar build/libs/bitsquare-<version>-app.jar --help
To build a headless bootstrap node jar, run the bootstrapNodeJar task:
./gradlew bootstrapNodeJar
Run the bootstrap node:
java -jar build/libs/bitsquare-<version>-bootstrapNode.jar
See doc/build.md for additional information.
Staying in Touch
Contact the team and keep up to date using any of the following:
- The Bitsquare Website
- The #bitsquare IRC channel on Freenode (logs)
- Our mailing list
- @bitsquare_ on Twitter
- Get in contact with us
- GitHub Issues
License
Bitsquare is free software, licensed under version 3 of the GNU Affero General Public License.
In short, this means you are free to fork this repository and do anything with it that you please. However, if you distribute your changes, i.e. create your own build of the software and make it available for others to use, you must:
- Publish your changes under the same license, so as to ensure the software remains free.
- Use a name and logo substantially different than "Bitsquare" and the Bitsquare logo seen here. This allows for competition without confusion.
See LICENSE for complete details.