Doubler
X
–
Menu
reset
GitControl
X
M
–
status
X
console
X
wip
X
log
X
doc
X
Basic info about committing changes using the Lively GitControl
X
M
–
All Lively installations, such as you might have on localhost, or such as the lively-kernel.org/core installation, are separate instances of the master installation on Git. The GitControl tool makes it easy to update an installation and to commit changes made in that installation up to the master on Git. General commit and update workflow As a general rule, prior to making a bunch of changes, it is good to use the GitControl to do a "pull", bringing your installation up to date so that the only changes you will have to deal with be those involved in your project. Suppose you have changed a method in Widgets.js. When you open the GitControl, this file will appear as an "unstaged change", or you may have several files listed there that you have changed. You can us the "diff" button to see the changes that will be committed. [this does not work for me but it should for you. The alternative is to go tot the console window and type "git diff" or "git diff " followed by the pathname of a specific file] Maybe we need some discussion about what to do if things appear in the diff that you do not want. The simplest answer here would go to go fix the file. In preparation to commit, you need all your local changes to be either "staged" (in preparatin to commit), "stashed" (set aside from the commit but not forgotten. perhaps as you have more to do before committing), or forgotten (the X), meaning the changes will be lost, though you may still have that file around. So do one of these three things to all your unstaged changes. Now you are ready to commit your (now) staged changes, and this is done by pressing the "commit" button. Here you will be asked for a short comment about what these changes are. This will appear in the log which can be seen under the "log" tab. Next you should press "pull". This may take a little while and should then print a few lines ending with a pair of version numbers on the master. [for some reason my system asks me for my name and password at this point which can be entered in the terminal window] The final step is to do a "push" which makes your changes visible on Git, and everyone who updates will see those changes. This should also display a few lines with version numbers, and you should then be able to see your change at the top of the log window. Adding new files The file or directory that you want to add should already exist (create it. e.g. with the System Code Browser). In order to add new files to be controlled by git go into the "status" tab. Your file / directory will appear in the "Untracked files" category. Hover over the line representing the file / directory and hit the "add" button. The file / directory will now be listed as a "staged change" that can now be committed.
Basic info about committing changes using the Lively GitControl
X
M
–
All Lively installations, such as you might have on localhost, or such as the lively-kernel.org/core installation, are separate instances of the master installation on Git. The GitControl tool makes it easy to update an installation and to commit changes made in that installation up to the master on Git. General commit and update workflow As a general rule, prior to making a bunch of changes, it is good to use the GitControl to do a "pull", bringing your installation up to date so that the only changes you will have to deal with be those involved in your project. Suppose you have changed a method in Widgets.js. When you open the GitControl, this file will appear as an "unstaged change", or you may have several files listed there that you have changed. You can us the "diff" button to see the changes that will be committed. [this does not work for me but it should for you. The alternative is to go tot the console window and type "git diff" or "git diff " followed by the pathname of a specific file] Maybe we need some discussion about what to do if things appear in the diff that you do not want. The simplest answer here would go to go fix the file. In preparation to commit, you need all your local changes to be either "staged" (in preparatin to commit), "stashed" (set aside from the commit but not forgotten. perhaps as you have more to do before committing), or forgotten (the X), meaning the changes will be lost, though you may still have that file around. So do one of these three things to all your unstaged changes. Now you are ready to commit your (now) staged changes, and this is done by pressing the "commit" button. Here you will be asked for a short comment about what these changes are. This will appear in the log which can be seen under the "log" tab. Next you should press "pull". This may take a little while and should then print a few lines ending with a pair of version numbers on the master. [for some reason my system asks me for my name and password at this point which can be entered in the terminal window] The final step is to do a "push" which makes your changes visible on Git, and everyone who updates will see those changes. This should also display a few lines with version numbers, and you should then be able to see your change at the top of the log window. Adding new files The file or directory that you want to add should already exist (create it. e.g. with the System Code Browser). In order to add new files to be controlled by git go into the "status" tab. Your file / directory will appear in the "Untracked files" category. Hover over the line representing the file / directory and hit the "add" button. The file / directory will now be listed as a "staged change" that can now be committed.
Basic info about committing changes using the Lively GitControl
X
M
–
The GitControl tool makes it easy to update an installation and to commit changes made in that installation up to the master on Git. General commit and update workflow As a general rule, prior to making a bunch of changes, it is good to use the GitControl to do a "pull", bringing your installation up to date so that the only changes you will have to deal with will be those from your project. Suppose you have changed a method in Widgets.js. When you open the GitControl, this file will appear as an "unstaged change", or you may have several files listed there that you have changed. You can push the "diff" button to see the changes that will be committed. [this does not work for me but it should for you. The alternative is to go to your browser's Javascript console and type "git diff" or "git diff " followed by the pathname of a specific file] Maybe we need some discussion about what to do if things appear in the diff that you do not want. The simplest answer would be to go fix the file. In preparation to commit, you need all your local changes to be either "staged" (in preparation to commit), "stashed" (set aside from the commit but not forgotten. perhaps as you have more to do before committing), or forgotten (the X), meaning the changes will be lost, though you may still have that file around. So do one of these three things to all your unstaged changes. Now you are ready to commit your (now) staged changes, and this is done by pressing the "commit" button. Here you will be asked for a short comment about what these changes are. This will appear in the log which can be seen under the "log" tab. Next you should press "pull". This may take a little while and should then print a few lines ending with a pair of version numbers on the master. [for some reason my system asks me for my name and password at this point which can be entered in the terminal window] The final step is to do a "push" which makes your changes visible on Git, and everyone who updates will see those changes. This should also display a few lines with version numbers, and you should then be able to see your change at the top of the log window. Adding new files The file or directory that you want to add should already exist (create it. e.g. with the System Code Browser). In order to add new files to be controlled by Git, go into the "status" tab. Your file / directory will appear in the "Untracked files" category. Hover over the line representing the file / directory and hit the "add" button. The file / directory will now be listed as a "staged change" that can now be committed.
Basic info about committing changes using the Lively GitControl
X
M
–
All Lively installations, such as you might have on localhost, or such as the lively-kernel.org/core installation, are separate instances of the master installation on Git. The GitControl tool makes it easy to update an installation and to commit changes made in that installation up to the master on Git. General commit and update workflow As a general rule, prior to making a bunch of changes, it is good to use the GitControl to do a "pull", bringing your installation up to date so that the only changes you will have to deal with be those involved in your project. Suppose you have changed a method in Widgets.js. When you open the GitControl, this file will appear as an "unstaged change", or you may have several files listed there that you have changed. You can us the "diff" button to see the changes that will be committed. [this does not work for me but it should for you. The alternative is to go tot the console window and type "git diff" or "git diff " followed by the pathname of a specific file] Maybe we need some discussion about what to do if things appear in the diff that you do not want. The simplest answer here would go to go fix the file. In preparation to commit, you need all your local changes to be either "staged" (in preparatin to commit), "stashed" (set aside from the commit but not forgotten. perhaps as you have more to do before committing), or forgotten (the X), meaning the changes will be lost, though you may still have that file around. So do one of these three things to all your unstaged changes. Now you are ready to commit your (now) staged changes, and this is done by pressing the "commit" button. Here you will be asked for a short comment about what these changes are. This will appear in the log which can be seen under the "log" tab. Next you should press "pull". This may take a little while and should then print a few lines ending with a pair of version numbers on the master. [for some reason my system asks me for my name and password at this point which can be entered in the terminal window] The final step is to do a "push" which makes your changes visible on Git, and everyone who updates will see those changes. This should also display a few lines with version numbers, and you should then be able to see your change at the top of the log window. Adding new files The file or directory that you want to add should already exist (create it. e.g. with the System Code Browser). In order to add new files to be controlled by git go into the "status" tab. Your file / directory will appear in the "Untracked files" category. Hover over the line representing the file / directory and hit the "add" button. The file / directory will now be listed as a "staged change" that can now be committed.
Basic info about committing changes using the Lively GitControl
X
M
–
All Lively installations, such as you might have on localhost, or such as the lively-kernel.org/core installation, are separate instances of the master installation on Git. The GitControl tool makes it easy to update an installation and to commit changes made in that installation up to the master on Git. General commit and update workflow As a general rule, prior to making a bunch of changes, it is good to use the GitControl to do a "pull", bringing your installation up to date so that the only changes you will have to deal with be those involved in your project. Suppose you have changed a method in Widgets.js. When you open the GitControl, this file will appear as an "unstaged change", or you may have several files listed there that you have changed. You can us the "diff" button to see the changes that will be committed. [this does not work for me but it should for you. The alternative is to go tot the console window and type "git diff" or "git diff " followed by the pathname of a specific file] Maybe we need some discussion about what to do if things appear in the diff that you do not want. The simplest answer here would go to go fix the file. In preparation to commit, you need all your local changes to be either "staged" (in preparatin to commit), "stashed" (set aside from the commit but not forgotten. perhaps as you have more to do before committing), or forgotten (the X), meaning the changes will be lost, though you may still have that file around. So do one of these three things to all your unstaged changes. Now you are ready to commit your (now) staged changes, and this is done by pressing the "commit" button. Here you will be asked for a short comment about what these changes are. This will appear in the log which can be seen under the "log" tab. Next you should press "pull". This may take a little while and should then print a few lines ending with a pair of version numbers on the master. [for some reason my system asks me for my name and password at this point which can be entered in the terminal window] The final step is to do a "push" which makes your changes visible on Git, and everyone who updates will see those changes. This should also display a few lines with version numbers, and you should then be able to see your change at the top of the log window. Adding new files The file or directory that you want to add should already exist (create it. e.g. with the System Code Browser). In order to add new files to be controlled by git go into the "status" tab. Your file / directory will appear in the "Untracked files" category. Hover over the line representing the file / directory and hit the "add" button. The file / directory will now be listed as a "staged change" that can now be committed.
Basic info about committing changes using the Lively GitControl
X
M
–
All Lively installations, such as you might have on localhost, or such as the lively-kernel.org/core installation, are separate instances of the master installation on Git. The GitControl tool makes it easy to update an installation and to commit changes made in that installation up to the master on Git. General commit and update workflow As a general rule, prior to making a bunch of changes, it is good to use the GitControl to do a "pull", bringing your installation up to date so that the only changes you will have to deal with be those involved in your project. Suppose you have changed a method in Widgets.js. When you open the GitControl, this file will appear as an "unstaged change", or you may have several files listed there that you have changed. You can us the "diff" button to see the changes that will be committed. [this does not work for me but it should for you. The alternative is to go tot the console window and type "git diff" or "git diff " followed by the pathname of a specific file] Maybe we need some discussion about what to do if things appear in the diff that you do not want. The simplest answer here would go to go fix the file. In preparation to commit, you need all your local changes to be either "staged" (in preparatin to commit), "stashed" (set aside from the commit but not forgotten. perhaps as you have more to do before committing), or forgotten (the X), meaning the changes will be lost, though you may still have that file around. So do one of these three things to all your unstaged changes. Now you are ready to commit your (now) staged changes, and this is done by pressing the "commit" button. Here you will be asked for a short comment about what these changes are. This will appear in the log which can be seen under the "log" tab. Next you should press "pull". This may take a little while and should then print a few lines ending with a pair of version numbers on the master. [for some reason my system asks me for my name and password at this point which can be entered in the terminal window] The final step is to do a "push" which makes your changes visible on Git, and everyone who updates will see those changes. This should also display a few lines with version numbers, and you should then be able to see your change at the top of the log window. Adding new files The file or directory that you want to add should already exist (create it. e.g. with the System Code Browser). In order to add new files to be controlled by git go into the "status" tab. Your file / directory will appear in the "Untracked files" category. Hover over the line representing the file / directory and hit the "add" button. The file / directory will now be listed as a "staged change" that can now be committed.
Basic info about committing changes using the Lively GitControl
X
M
–
All Lively installations, such as you might have on localhost, or such as the lively-kernel.org/core installation, are separate instances of the master installation on Git. The GitControl tool makes it easy to update an installation and to commit changes made in that installation up to the master on Git. General commit and update workflow As a general rule, prior to making a bunch of changes, it is good to use the GitControl to do a "pull", bringing your installation up to date so that the only changes you will have to deal with be those involved in your project. Suppose you have changed a method in Widgets.js. When you open the GitControl, this file will appear as an "unstaged change", or you may have several files listed there that you have changed. You can us the "diff" button to see the changes that will be committed. [this does not work for me but it should for you. The alternative is to go tot the console window and type "git diff" or "git diff " followed by the pathname of a specific file] Maybe we need some discussion about what to do if things appear in the diff that you do not want. The simplest answer here would go to go fix the file. In preparation to commit, you need all your local changes to be either "staged" (in preparatin to commit), "stashed" (set aside from the commit but not forgotten. perhaps as you have more to do before committing), or forgotten (the X), meaning the changes will be lost, though you may still have that file around. So do one of these three things to all your unstaged changes. Now you are ready to commit your (now) staged changes, and this is done by pressing the "commit" button. Here you will be asked for a short comment about what these changes are. This will appear in the log which can be seen under the "log" tab. Next you should press "pull". This may take a little while and should then print a few lines ending with a pair of version numbers on the master. [for some reason my system asks me for my name and password at this point which can be entered in the terminal window] The final step is to do a "push" which makes your changes visible on Git, and everyone who updates will see those changes. This should also display a few lines with version numbers, and you should then be able to see your change at the top of the log window. Adding new files The file or directory that you want to add should already exist (create it. e.g. with the System Code Browser). In order to add new files to be controlled by git go into the "status" tab. Your file / directory will appear in the "Untracked files" category. Hover over the line representing the file / directory and hit the "add" button. The file / directory will now be listed as a "staged change" that can now be committed.
Basic info about committing changes using the Lively GitControl
X
M
–
All Lively installations, such as you might have on localhost, or such as the lively-kernel.org/core installation, are separate instances of the master installation on Git. The GitControl tool makes it easy to update an installation and to commit changes made in that installation up to the master on Git. General commit and update workflow As a general rule, prior to making a bunch of changes, it is good to use the GitControl to do a "pull", bringing your installation up to date so that the only changes you will have to deal with be those involved in your project. Suppose you have changed a method in Widgets.js. When you open the GitControl, this file will appear as an "unstaged change", or you may have several files listed there that you have changed. You can us the "diff" button to see the changes that will be committed. [this does not work for me but it should for you. The alternative is to go tot the console window and type "git diff" or "git diff " followed by the pathname of a specific file] Maybe we need some discussion about what to do if things appear in the diff that you do not want. The simplest answer here would go to go fix the file. In preparation to commit, you need all your local changes to be either "staged" (in preparatin to commit), "stashed" (set aside from the commit but not forgotten. perhaps as you have more to do before committing), or forgotten (the X), meaning the changes will be lost, though you may still have that file around. So do one of these three things to all your unstaged changes. Now you are ready to commit your (now) staged changes, and this is done by pressing the "commit" button. Here you will be asked for a short comment about what these changes are. This will appear in the log which can be seen under the "log" tab. Next you should press "pull". This may take a little while and should then print a few lines ending with a pair of version numbers on the master. [for some reason my system asks me for my name and password at this point which can be entered in the terminal window] The final step is to do a "push" which makes your changes visible on Git, and everyone who updates will see those changes. This should also display a few lines with version numbers, and you should then be able to see your change at the top of the log window. Adding new files The file or directory that you want to add should already exist (create it. e.g. with the System Code Browser). In order to add new files to be controlled by git go into the "status" tab. Your file / directory will appear in the "Untracked files" category. Hover over the line representing the file / directory and hit the "add" button. The file / directory will now be listed as a "staged change" that can now be committed.
Basic info about committing changes using the Lively GitControl
X
M
–
All Lively installations, such as you might have on localhost, or such as the lively-kernel.org/core installation, are separate instances of the master installation on Git. The GitControl tool makes it easy to update an installation and to commit changes made in that installation up to the master on Git. General commit and update workflow As a general rule, prior to making a bunch of changes, it is good to use the GitControl to do a "pull", bringing your installation up to date so that the only changes you will have to deal with be those involved in your project. Suppose you have changed a method in Widgets.js. When you open the GitControl, this file will appear as an "unstaged change", or you may have several files listed there that you have changed. You can us the "diff" button to see the changes that will be committed. [this does not work for me but it should for you. The alternative is to go tot the console window and type "git diff" or "git diff " followed by the pathname of a specific file] Maybe we need some discussion about what to do if things appear in the diff that you do not want. The simplest answer here would go to go fix the file. In preparation to commit, you need all your local changes to be either "staged" (in preparatin to commit), "stashed" (set aside from the commit but not forgotten. perhaps as you have more to do before committing), or forgotten (the X), meaning the changes will be lost, though you may still have that file around. So do one of these three things to all your unstaged changes. Now you are ready to commit your (now) staged changes, and this is done by pressing the "commit" button. Here you will be asked for a short comment about what these changes are. This will appear in the log which can be seen under the "log" tab. Next you should press "pull". This may take a little while and should then print a few lines ending with a pair of version numbers on the master. [for some reason my system asks me for my name and password at this point which can be entered in the terminal window] The final step is to do a "push" which makes your changes visible on Git, and everyone who updates will see those changes. This should also display a few lines with version numbers, and you should then be able to see your change at the top of the log window. Adding new files The file or directory that you want to add should already exist (create it. e.g. with the System Code Browser). In order to add new files to be controlled by git go into the "status" tab. Your file / directory will appear in the "Untracked files" category. Hover over the line representing the file / directory and hit the "add" button. The file / directory will now be listed as a "staged change" that can now be committed.
Basic info about committing changes using the Lively GitControl
X
M
–
All Lively installations, such as you might have on localhost, or such as the lively-kernel.org/core installation, are separate instances of the master installation on Git. The GitControl tool makes it easy to update an installation and to commit changes made in that installation up to the master on Git. General commit and update workflow As a general rule, prior to making a bunch of changes, it is good to use the GitControl to do a "pull", bringing your installation up to date so that the only changes you will have to deal with be those involved in your project. Suppose you have changed a method in Widgets.js. When you open the GitControl, this file will appear as an "unstaged change", or you may have several files listed there that you have changed. You can us the "diff" button to see the changes that will be committed. [this does not work for me but it should for you. The alternative is to go tot the console window and type "git diff" or "git diff " followed by the pathname of a specific file] Maybe we need some discussion about what to do if things appear in the diff that you do not want. The simplest answer here would go to go fix the file. In preparation to commit, you need all your local changes to be either "staged" (in preparatin to commit), "stashed" (set aside from the commit but not forgotten. perhaps as you have more to do before committing), or forgotten (the X), meaning the changes will be lost, though you may still have that file around. So do one of these three things to all your unstaged changes. Now you are ready to commit your (now) staged changes, and this is done by pressing the "commit" button. Here you will be asked for a short comment about what these changes are. This will appear in the log which can be seen under the "log" tab. Next you should press "pull". This may take a little while and should then print a few lines ending with a pair of version numbers on the master. [for some reason my system asks me for my name and password at this point which can be entered in the terminal window] The final step is to do a "push" which makes your changes visible on Git, and everyone who updates will see those changes. This should also display a few lines with version numbers, and you should then be able to see your change at the top of the log window. Adding new files The file or directory that you want to add should already exist (create it. e.g. with the System Code Browser). In order to add new files to be controlled by git go into the "status" tab. Your file / directory will appear in the "Untracked files" category. Hover over the line representing the file / directory and hit the "add" button. The file / directory will now be listed as a "staged change" that can now be committed.
Basic info about committing changes using the Lively GitControl
X
M
–
All Lively installations, such as you might have on localhost, or such as the lively-kernel.org/core installation, are separate instances of the master installation on Git. The GitControl tool makes it easy to update an installation and to commit changes made in that installation up to the master on Git. General commit and update workflow As a general rule, prior to making a bunch of changes, it is good to use the GitControl to do a "pull", bringing your installation up to date so that the only changes you will have to deal with be those involved in your project. Suppose you have changed a method in Widgets.js. When you open the GitControl, this file will appear as an "unstaged change", or you may have several files listed there that you have changed. You can us the "diff" button to see the changes that will be committed. [this does not work for me but it should for you. The alternative is to go tot the console window and type "git diff" or "git diff " followed by the pathname of a specific file] Maybe we need some discussion about what to do if things appear in the diff that you do not want. The simplest answer here would go to go fix the file. In preparation to commit, you need all your local changes to be either "staged" (in preparatin to commit), "stashed" (set aside from the commit but not forgotten. perhaps as you have more to do before committing), or forgotten (the X), meaning the changes will be lost, though you may still have that file around. So do one of these three things to all your unstaged changes. Now you are ready to commit your (now) staged changes, and this is done by pressing the "commit" button. Here you will be asked for a short comment about what these changes are. This will appear in the log which can be seen under the "log" tab. Next you should press "pull". This may take a little while and should then print a few lines ending with a pair of version numbers on the master. [for some reason my system asks me for my name and password at this point which can be entered in the terminal window] The final step is to do a "push" which makes your changes visible on Git, and everyone who updates will see those changes. This should also display a few lines with version numbers, and you should then be able to see your change at the top of the log window. Adding new files The file or directory that you want to add should already exist (create it. e.g. with the System Code Browser). In order to add new files to be controlled by git go into the "status" tab. Your file / directory will appear in the "Untracked files" category. Hover over the line representing the file / directory and hit the "add" button. The file / directory will now be listed as a "staged change" that can now be committed.
Basic info about committing changes using the Lively GitControl
X
M
–
All Lively installations, such as you might have on localhost, or such as the lively-kernel.org/core installation, are separate instances of the master installation on Git. The GitControl tool makes it easy to update an installation and to commit changes made in that installation up to the master on Git. General commit and update workflow As a general rule, prior to making a bunch of changes, it is good to use the GitControl to do a "pull", bringing your installation up to date so that the only changes you will have to deal with be those involved in your project. Suppose you have changed a method in Widgets.js. When you open the GitControl, this file will appear as an "unstaged change", or you may have several files listed there that you have changed. You can us the "diff" button to see the changes that will be committed. [this does not work for me but it should for you. The alternative is to go tot the console window and type "git diff" or "git diff " followed by the pathname of a specific file] Maybe we need some discussion about what to do if things appear in the diff that you do not want. The simplest answer here would go to go fix the file. In preparation to commit, you need all your local changes to be either "staged" (in preparatin to commit), "stashed" (set aside from the commit but not forgotten. perhaps as you have more to do before committing), or forgotten (the X), meaning the changes will be lost, though you may still have that file around. So do one of these three things to all your unstaged changes. Now you are ready to commit your (now) staged changes, and this is done by pressing the "commit" button. Here you will be asked for a short comment about what these changes are. This will appear in the log which can be seen under the "log" tab. Next you should press "pull". This may take a little while and should then print a few lines ending with a pair of version numbers on the master. [for some reason my system asks me for my name and password at this point which can be entered in the terminal window] The final step is to do a "push" which makes your changes visible on Git, and everyone who updates will see those changes. This should also display a few lines with version numbers, and you should then be able to see your change at the top of the log window. Adding new files The file or directory that you want to add should already exist (create it. e.g. with the System Code Browser). In order to add new files to be controlled by git go into the "status" tab. Your file / directory will appear in the "Untracked files" category. Hover over the line representing the file / directory and hit the "add" button. The file / directory will now be listed as a "staged change" that can now be committed.
Basic info about committing changes using the Lively GitControl
X
M
–
All Lively installations, such as you might have on localhost, or such as the lively-kernel.org/core installation, are separate instances of the master installation on Git. The GitControl tool makes it easy to update an installation and to commit changes made in that installation up to the master on Git. General commit and update workflow As a general rule, prior to making a bunch of changes, it is good to use the GitControl to do a "pull", bringing your installation up to date so that the only changes you will have to deal with be those involved in your project. Suppose you have changed a method in Widgets.js. When you open the GitControl, this file will appear as an "unstaged change", or you may have several files listed there that you have changed. You can us the "diff" button to see the changes that will be committed. [this does not work for me but it should for you. The alternative is to go tot the console window and type "git diff" or "git diff " followed by the pathname of a specific file] Maybe we need some discussion about what to do if things appear in the diff that you do not want. The simplest answer here would go to go fix the file. In preparation to commit, you need all your local changes to be either "staged" (in preparatin to commit), "stashed" (set aside from the commit but not forgotten. perhaps as you have more to do before committing), or forgotten (the X), meaning the changes will be lost, though you may still have that file around. So do one of these three things to all your unstaged changes. Now you are ready to commit your (now) staged changes, and this is done by pressing the "commit" button. Here you will be asked for a short comment about what these changes are. This will appear in the log which can be seen under the "log" tab. Next you should press "pull". This may take a little while and should then print a few lines ending with a pair of version numbers on the master. [for some reason my system asks me for my name and password at this point which can be entered in the terminal window] The final step is to do a "push" which makes your changes visible on Git, and everyone who updates will see those changes. This should also display a few lines with version numbers, and you should then be able to see your change at the top of the log window. Adding new files The file or directory that you want to add should already exist (create it. e.g. with the System Code Browser). In order to add new files to be controlled by git go into the "status" tab. Your file / directory will appear in the "Untracked files" category. Hover over the line representing the file / directory and hit the "add" button. The file / directory will now be listed as a "staged change" that can now be committed.
Basic info about committing changes using the Lively GitControl
X
M
–
All Lively installations, such as you might have on localhost, or such as the lively-kernel.org/core installation, are separate instances of the master installation on Git. The GitControl tool makes it easy to update an installation and to commit changes made in that installation up to the master on Git. General commit and update workflow As a general rule, prior to making a bunch of changes, it is good to use the GitControl to do a "pull", bringing your installation up to date so that the only changes you will have to deal with be those involved in your project. Suppose you have changed a method in Widgets.js. When you open the GitControl, this file will appear as an "unstaged change", or you may have several files listed there that you have changed. You can us the "diff" button to see the changes that will be committed. [this does not work for me but it should for you. The alternative is to go tot the console window and type "git diff" or "git diff " followed by the pathname of a specific file] Maybe we need some discussion about what to do if things appear in the diff that you do not want. The simplest answer here would go to go fix the file. In preparation to commit, you need all your local changes to be either "staged" (in preparatin to commit), "stashed" (set aside from the commit but not forgotten. perhaps as you have more to do before committing), or forgotten (the X), meaning the changes will be lost, though you may still have that file around. So do one of these three things to all your unstaged changes. Now you are ready to commit your (now) staged changes, and this is done by pressing the "commit" button. Here you will be asked for a short comment about what these changes are. This will appear in the log which can be seen under the "log" tab. Next you should press "pull". This may take a little while and should then print a few lines ending with a pair of version numbers on the master. [for some reason my system asks me for my name and password at this point which can be entered in the terminal window] The final step is to do a "push" which makes your changes visible on Git, and everyone who updates will see those changes. This should also display a few lines with version numbers, and you should then be able to see your change at the top of the log window. Adding new files The file or directory that you want to add should already exist (create it. e.g. with the System Code Browser). In order to add new files to be controlled by git go into the "status" tab. Your file / directory will appear in the "Untracked files" category. Hover over the line representing the file / directory and hit the "add" button. The file / directory will now be listed as a "staged change" that can now be committed.
Basic info about committing changes using the Lively GitControl
X
M
–
All Lively installations, such as you might have on localhost, or such as the lively-kernel.org/core installation, are separate instances of the master installation on Git. The GitControl tool makes it easy to update an installation and to commit changes made in that installation up to the master on Git. General commit and update workflow As a general rule, prior to making a bunch of changes, it is good to use the GitControl to do a "pull", bringing your installation up to date so that the only changes you will have to deal with be those involved in your project. Suppose you have changed a method in Widgets.js. When you open the GitControl, this file will appear as an "unstaged change", or you may have several files listed there that you have changed. You can us the "diff" button to see the changes that will be committed. [this does not work for me but it should for you. The alternative is to go tot the console window and type "git diff" or "git diff " followed by the pathname of a specific file] Maybe we need some discussion about what to do if things appear in the diff that you do not want. The simplest answer here would go to go fix the file. In preparation to commit, you need all your local changes to be either "staged" (in preparatin to commit), "stashed" (set aside from the commit but not forgotten. perhaps as you have more to do before committing), or forgotten (the X), meaning the changes will be lost, though you may still have that file around. So do one of these three things to all your unstaged changes. Now you are ready to commit your (now) staged changes, and this is done by pressing the "commit" button. Here you will be asked for a short comment about what these changes are. This will appear in the log which can be seen under the "log" tab. Next you should press "pull". This may take a little while and should then print a few lines ending with a pair of version numbers on the master. [for some reason my system asks me for my name and password at this point which can be entered in the terminal window] The final step is to do a "push" which makes your changes visible on Git, and everyone who updates will see those changes. This should also display a few lines with version numbers, and you should then be able to see your change at the top of the log window. Adding new files The file or directory that you want to add should already exist (create it. e.g. with the System Code Browser). In order to add new files to be controlled by git go into the "status" tab. Your file / directory will appear in the "Untracked files" category. Hover over the line representing the file / directory and hit the "add" button. The file / directory will now be listed as a "staged change" that can now be committed.
Basic info about committing changes using the Lively GitControl
X
M
–
All Lively installations, such as you might have on localhost, or such as the lively-kernel.org/core installation, are separate instances of the master installation on Git. The GitControl tool makes it easy to update an installation and to commit changes made in that installation up to the master on Git. General commit and update workflow As a general rule, prior to making a bunch of changes, it is good to use the GitControl to do a "pull", bringing your installation up to date so that the only changes you will have to deal with be those involved in your project. Suppose you have changed a method in Widgets.js. When you open the GitControl, this file will appear as an "unstaged change", or you may have several files listed there that you have changed. You can us the "diff" button to see the changes that will be committed. [this does not work for me but it should for you. The alternative is to go tot the console window and type "git diff" or "git diff " followed by the pathname of a specific file] Maybe we need some discussion about what to do if things appear in the diff that you do not want. The simplest answer here would go to go fix the file. In preparation to commit, you need all your local changes to be either "staged" (in preparatin to commit), "stashed" (set aside from the commit but not forgotten. perhaps as you have more to do before committing), or forgotten (the X), meaning the changes will be lost, though you may still have that file around. So do one of these three things to all your unstaged changes. Now you are ready to commit your (now) staged changes, and this is done by pressing the "commit" button. Here you will be asked for a short comment about what these changes are. This will appear in the log which can be seen under the "log" tab. Next you should press "pull". This may take a little while and should then print a few lines ending with a pair of version numbers on the master. [for some reason my system asks me for my name and password at this point which can be entered in the terminal window] The final step is to do a "push" which makes your changes visible on Git, and everyone who updates will see those changes. This should also display a few lines with version numbers, and you should then be able to see your change at the top of the log window. Adding new files The file or directory that you want to add should already exist (create it. e.g. with the System Code Browser). In order to add new files to be controlled by git go into the "status" tab. Your file / directory will appear in the "Untracked files" category. Hover over the line representing the file / directory and hit the "add" button. The file / directory will now be listed as a "staged change" that can now be committed.
Basic info about committing changes using the Lively GitControl
X
M
–
All Lively installations, such as you might have on localhost, or such as the lively-kernel.org/core installation, are separate instances of the master installation on Git. The GitControl tool makes it easy to update an installation and to commit changes made in that installation up to the master on Git. General commit and update workflow As a general rule, prior to making a bunch of changes, it is good to use the GitControl to do a "pull", bringing your installation up to date so that the only changes you will have to deal with be those involved in your project. Suppose you have changed a method in Widgets.js. When you open the GitControl, this file will appear as an "unstaged change", or you may have several files listed there that you have changed. You can us the "diff" button to see the changes that will be committed. [this does not work for me but it should for you. The alternative is to go tot the console window and type "git diff" or "git diff " followed by the pathname of a specific file] Maybe we need some discussion about what to do if things appear in the diff that you do not want. The simplest answer here would go to go fix the file. In preparation to commit, you need all your local changes to be either "staged" (in preparatin to commit), "stashed" (set aside from the commit but not forgotten. perhaps as you have more to do before committing), or forgotten (the X), meaning the changes will be lost, though you may still have that file around. So do one of these three things to all your unstaged changes. Now you are ready to commit your (now) staged changes, and this is done by pressing the "commit" button. Here you will be asked for a short comment about what these changes are. This will appear in the log which can be seen under the "log" tab. Next you should press "pull". This may take a little while and should then print a few lines ending with a pair of version numbers on the master. [for some reason my system asks me for my name and password at this point which can be entered in the terminal window] The final step is to do a "push" which makes your changes visible on Git, and everyone who updates will see those changes. This should also display a few lines with version numbers, and you should then be able to see your change at the top of the log window. Adding new files The file or directory that you want to add should already exist (create it. e.g. with the System Code Browser). In order to add new files to be controlled by git go into the "status" tab. Your file / directory will appear in the "Untracked files" category. Hover over the line representing the file / directory and hit the "add" button. The file / directory will now be listed as a "staged change" that can now be committed.
Basic info about committing changes using the Lively GitControl
X
M
–
All Lively installations, such as you might have on localhost, or such as the lively-kernel.org/core installation, are separate instances of the master installation on Git. The GitControl tool makes it easy to update an installation and to commit changes made in that installation up to the master on Git. General commit and update workflow As a general rule, prior to making a bunch of changes, it is good to use the GitControl to do a "pull", bringing your installation up to date so that the only changes you will have to deal with be those involved in your project. Suppose you have changed a method in Widgets.js. When you open the GitControl, this file will appear as an "unstaged change", or you may have several files listed there that you have changed. You can us the "diff" button to see the changes that will be committed. [this does not work for me but it should for you. The alternative is to go tot the console window and type "git diff" or "git diff " followed by the pathname of a specific file] Maybe we need some discussion about what to do if things appear in the diff that you do not want. The simplest answer here would go to go fix the file. In preparation to commit, you need all your local changes to be either "staged" (in preparatin to commit), "stashed" (set aside from the commit but not forgotten. perhaps as you have more to do before committing), or forgotten (the X), meaning the changes will be lost, though you may still have that file around. So do one of these three things to all your unstaged changes. Now you are ready to commit your (now) staged changes, and this is done by pressing the "commit" button. Here you will be asked for a short comment about what these changes are. This will appear in the log which can be seen under the "log" tab. Next you should press "pull". This may take a little while and should then print a few lines ending with a pair of version numbers on the master. [for some reason my system asks me for my name and password at this point which can be entered in the terminal window] The final step is to do a "push" which makes your changes visible on Git, and everyone who updates will see those changes. This should also display a few lines with version numbers, and you should then be able to see your change at the top of the log window. Adding new files The file or directory that you want to add should already exist (create it. e.g. with the System Code Browser). In order to add new files to be controlled by git go into the "status" tab. Your file / directory will appear in the "Untracked files" category. Hover over the line representing the file / directory and hit the "add" button. The file / directory will now be listed as a "staged change" that can now be committed.
* 01c4876 - (HEAD, origin/master, origin/HEAD, master) merge master (Tim Felgentreff, 3 hours ago)
|\
| * 4e2b728 - added reactive to minifier (Stefan Lehmann, 3 days ago)
| * c3e0726 - Merge pull request #7 from babelsberg/linting (Tim Felgentreff, 5 days ago)
| |\
| | * 4d9c0cd - make lively a module (Tim Felgentreff, 5 days ago)
| | * 6b5424a - whitespace changes to test_harness (Tim Felgentreff, 5 days ago)
| | * f9b15d7 - make tests in lively work again (Tim Felgentreff, 5 days ago)
| | * 91a3354 - Merge remote-tracking branch 'origin/master' into linting (Tim Felgentreff, 5 days ago)
| | |\
| | |/
| |/|
| * | 0e6b252 - enable EmZ3 in standalone (Stefan Lehmann, 7 days ago)
| | * 0ca3dba - remove braces (Tim Felgentreff, 5 days ago)
| | * 21182a7 - fix remaining linting errors (Tim Felgentreff, 5 days ago)
| | * 4405a9b - linting fixes for less than 90 chars (Tim Felgentreff, 5 days ago)
| | * 4950cba - fix zombietest script (Tim Felgentreff, 5 days ago)
| | * d7cd1b6 - add package.json, make running different tests easier (Tim Felgentreff, 5 days ago)
| | * 6c3d93a - Merge remote-tracking branch 'origin/master' into linting (Tim Felgentreff, 10 days ago)
| | |\
| | |/
| |/|
| * | 92bc0aa - moved alertOK from test_harness to minilively (Stefan Lehmann, 10 days ago)
| * | a1486bd - removed stub of CodeEditor in minilively (Stefan Lehmann, 10 days ago)
| * | 03aab47 - Merge pull request #2 from babelsberg/experimental (Stefan Lehmann, 11 days ago)
| |\ \
| | | * e81739d - Merge branch 'experimental' into linting (Tim Felgentreff, 11 days ago)
| | | |\
| | | |/
| | |/|
| | * | 6645e4f - run electrical components tests also in lively (Tim Felgentreff, 11 days ago)
| | * | f644a6c - update and run yoshiki's circuit tests, too (Tim Felgentreff, 11 days ago)
| | * | 54d58ef - removed CouldNotSatisfyError and pass actual error as argument to onError instead (Stefan Lehmann, 11 days ago)
| | * | 70da111 - moved constraint.enable() to bbb.always (Stefan Lehmann, 12 days ago)
| | * | aea52dc - added enable and disable to RelaxNode (Stefan Lehmann, 12 days ago)
| | * | ac89eed - removed shouldBeSatisfiedWith from DeltaBlue (Stefan Lehmann, 12 days ago)
| | * | b9759c3 - replaced shouldBeSatisfiedWith in tests (Stefan Lehmann, 12 days ago)
| | * | c6d99e6 - removed shouldBeTrue method on Function.prototype (Stefan Lehmann, 12 days ago)
| | * | 298524e - replaced shouldBeTrue in tests (Stefan Lehmann, 12 days ago)
| | * | 2f4966e - refactored bbb.always (Stefan Lehmann, 13 days ago)
| | * | 1dea698 - tabs to spaces (1) (Stefan Lehmann, 13 days ago)
| | * | 2e906ce - remove duplicated error propagation (Stefan Lehmann, 13 days ago)
| | * | d5dce76 - $$isStoring as recursionGuard (Stefan Lehmann, 13 days ago)
| | * | 71805e3 - break if boolean (Stefan Lehmann, 13 days ago)
| | * | 6a9342a - use Function.wrap for refining layer activation (Stefan Lehmann, 13 days ago)
| | * | 46ccc9b - added removeAt to Array.prototype in minilively (Stefan Lehmann, 13 days ago)
| | * | a685475 - fixed modules (Stefan Lehmann, 2 weeks ago)
| | * | c8f7173 - fixed modules (Stefan Lehmann, 2 weeks ago)
| | * | 692d926 - added onError support to sutherlands relaxation algorithm (Stefan Lehmann, 2 weeks ago)
| | * | 7c6736d - Merge branch 'master' into experimental (Stefan Lehmann, 2 weeks ago)
| | |\ \
| | |/ /
| |/| |
| | * | a54e16d - support onError in CSP (Stefan Lehmann, 2 weeks ago)
| | * | a02c5d0 - no support for onError in DeltaBlue yet (Stefan Lehmann, 2 weeks ago)
| | * | 16fe7d8 - added onError option (Stefan Lehmann, 2 weeks ago)
| | * | f6e6676 - Cassowary throws CouldNotSatisfyErrors (Stefan Lehmann, 2 weeks ago)
| | * | 452178f - added CouldNotSatisfyError (Stefan Lehmann, 2 weeks ago)
| | * | 8280b2a - fixed module name (Stefan Lehmann, 2 weeks ago)
| | * | 44dd45b - refactored experimental to reactive (Stefan Lehmann, 2 weeks ago)
| | * | 5ff1647 - Merge branch 'experimental' of https://github.com/babelsberg/babelsberg-js into experimental (Stefan Lehmann, 2 weeks ago)
| | |\ \
| | | * | 14cee98 - make lively happy (Stefan Lehmann, 2 weeks ago)
| | * | | d8d6920 - refactoring to abstract ReactiveSolver (Stefan Lehmann, 2 weeks ago)
| | |/ /
| | * | 5b592bc - manually reconstrain variables after solving an assignment (Stefan Lehmann, 2 weeks ago)
| | * | cc69fb7 - use callback queue to enable to reset variable that caused a trigger (Stefan Lehmann, 2 weeks ago)
| | * | eb016fc - added callback functionality to Babelberg (Stefan Lehmann, 2 weeks ago)
| | * | 7b3c29c - reset trigger on false (Stefan Lehmann, 3 weeks ago)
| | * | 1b517d3 - tests for reset of a trigger (Stefan Lehmann, 3 weeks ago)
| | * | 2862087 - comment (Stefan Lehmann, 3 weeks ago)
| | * | 4f140e8 - added utility function recursiveGuard (Stefan Lehmann, 3 weeks ago)
| | * | 355a7c0 - isSuggestingValue is now a map to work as recursion guard (Stefan Lehmann, 3 weeks ago)
| | * | 922ccee - added guard to not create layers on Morph and CodeEditor if standalone (Stefan Lehmann, 3 weeks ago)
| | * | 5a06564 - (origin/experimental) set new flag allowFailing and attach test function to external constraint (Stefan Lehmann, 4 weeks ago)
| | * | 0ce7e4c - check for additional flag allowFailing (Stefan Lehmann, 4 weeks ago)
| | * | b313932 - adjusted tests to check for a more convenient api (Stefan Lehmann, 4 weeks ago)
| | * | 170dd3c - scoped assertions and triggers (Stefan Lehmann, 4 weeks ago)
| | * | 25eea7c - added tests for scoped assertions and triggers (Stefan Lehmann, 4 weeks ago)
| | * | 6015349 - added postponeEnabling flag to DeltaBlue (Stefan Lehmann, 4 weeks ago)
| | * | 8183f26 - added first implementation of scoped constraint (Stefan Lehmann, 4 weeks ago)
| | * | cfe9f53 - added tests for scoped constraints (Stefan Lehmann, 4 weeks ago)
| | * | 306cb32 - added postponeEnabling flag to cassowary (Stefan Lehmann, 4 weeks ago)
| | * | 94aec9b - added simple layer activation implementation (Stefan Lehmann, 4 weeks ago)
| | * | 90161d0 - added tests for layer activation (Stefan Lehmann, 4 weeks ago)
| | * | 01e5c42 - added TriggerSolver (Stefan Lehmann, 5 weeks ago)
| | * | 2dcdb28 - added tests for trigger mechanism (Stefan Lehmann, 5 weeks ago)
| | * | 2446c42 - test for multiple assertions on a single variable (Stefan Lehmann, 5 weeks ago)
| | * | 165065d - tests for assertions on complex object (Stefan Lehmann, 5 weeks ago)
| | * | 7925b00 - revert on invalid assignment (Stefan Lehmann, 5 weeks ago)
| | * | 1076a90 - include experimental_test in test suite (Stefan Lehmann, 5 weeks ago)
| | * | 5c706f7 - added basic implementation of continuous assertions (Stefan Lehmann, 5 weeks ago)
| | * | e32ff53 - added basic test for continuous assertions (Stefan Lehmann, 5 weeks ago)
| | * | 62656bd - do not create a new error (Stefan Lehmann, 5 weeks ago)
| | | * cfee7c9 - fix a syntax-error googles tool introduced (Tim Felgentreff, 12 days ago)
| | | * 352be92 - first stab at linting (Tim Felgentreff, 12 days ago)
| | |/
| |/|
| * | e180817 - unfinished flocking examples/flocking/configuration.js (Stefan Lehmann, 3 weeks ago)
| * | 8be03b7 - small typo (Stefan Lehmann, 3 weeks ago)
| * | d284f6c - documentation readonly example using BabelsbergScript syntax (Stefan Lehmann, 3 weeks ago)
* | | cd86749 - support || in sutherland (Tim Felgentreff, 3 hours ago)
* | | 5b6096e - add alans folder (Tim Felgentreff, 8 hours ago)
| | | * 1889400 - (origin/gh-pages) updated map coloring example (Stefan Lehmann, 10 days ago)
| | | * 0d169b5 - updated documentation (softvis, 3 weeks ago)
| | | * 56aea77 - updated documentation (softvis, 3 weeks ago)
| | | * 8eda4a8 - update the fabric example (Tim Felgentreff, 3 weeks ago)
| | | * 54d45e0 - Merge branch 'master' into gh-pages (Tim Felgentreff, 3 weeks ago)
| | | |\
| | |_|/
| |/| |
| * | | 3a4b219 - add all solvers to the fabric example, so we can play with them (Tim Felgentreff, 3 weeks ago)
|/ / /
* | | 9e5c002 - make zombietests throw errors when tests fail (Tim Felgentreff, 3 weeks ago)
* | | a473123 - only upload minified files for non-PR builds on master (Tim Felgentreff, 3 weeks ago)
* | | b804f8c - add inequalities to relaxation solver (Tim Felgentreff, 3 weeks ago)
* | | ce60e51 - only add layers in lively (Tim Felgentreff, 3 weeks ago)
* | | be32c2d - add missing file (Tim Felgentreff, 4 weeks ago)
* | | 57f8433 - compress and upload solvers and core separately as well (Tim Felgentreff, 4 weeks ago)
* | | 1d153c7 - add Babelsberg scaffold to EmZ3, so it can be used as a solver (Tim Felgentreff, 4 weeks ago)
| | * 0b50051 - typo (Stefan Lehmann, 4 weeks ago)
| | * c304258 - link to github-hosted documentation (Stefan Lehmann, 4 weeks ago)
| | * 6c6bf1d - workaround .md tutorial generator (softvis, 4 weeks ago)
save world
⟳
Some Text
Workspace
X
M
–
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
PRETTY FORMATS
If the commit is a merge, and if the pretty-format is not oneline,
email or raw, an additional line is inserted before the Author: line.
This line begins with "Merge: " and the sha1s of ancestral commits are
printed, separated by spaces. Note that the listed commits may not
necessarily be the list of the direct parent commits if you have
limited your view of history: for example, if you are only interested
in changes related to a certain directory or file.
There are several built-in formats, and you can define additional
formats by setting a pretty.<name> config option to either another
format name, or a format: string, as described below (see git-
config(1)). Here are the details of the built-in formats:
o    oneline
       <sha1> <title line>
   This is designed to be as compact as possible.
o    short
       commit <sha1>
       Author: <author>
       <title line>
o    medium
       commit <sha1>
       Author: <author>
       Date:   <author date>
       <title line>
       <full commit message>
o    full
       commit <sha1>
       Author: <author>
       Commit: <committer>
       <title line>
       <full commit message>
o    fuller
       commit <sha1>
X


+
implement command line
X
display branch stuff
X
display stash
X
display untracked/unstaged/staged stuff
X
show log
X
support rebase?
X
show conflicted
X
resolve conflicted?
X
commit changes
X
fetch
X
pull
X
stage patches
X
stage files
X
create branch
X
show log
X
diff log
X
cherry pick log item
X
apply/show/remove stash
X
change branch
X
TodoList
X
M
–
quick publish
Workspace
X
M
–
1
2
3
4
5
6
7
8
that.setPosition(pt(0,0))
this.owner.owner.addMorph(that)
this.owner.owner.getTabContainer().getTabBar().rearrangeTabs()
t = this.owner.owner.getTabContainer().getTabBar().tabs.pop()
t2 = this.owner.owner.getTabContainer().getTabBar().tabs.pop()
this.owner.owner.getTabContainer().getTabBar().getTabs
X
Onto master
remote: master/origin - https://github.com/babelsberg/babelsberg-js
local: master - null
head: da11e1d updated playground with some more tests, added a Doubler part to the bin
Stashes
Unstaged changes:
modfied: borning/PartsBin/Basic/Rectangle.html
modfied: borning/PartsBin/Basic/Rectangle.json
modfied: borning/PartsBin/Basic/Rectangle.metainfo
modfied: borning/babelsberg-js.html
Untracked files:
2014-09-16-demo.html
babelsberg-js2.html
bar.html
combinator.html
config.js
domconstrains/
domconstraints/
emz3.html
exmaple1.html
propagation.html
propagation_lively_engine.html
propagation_lively_engine2.html
propagation_lively_engine3.ht4l
propagation_lively_engine3.html
propagation_lively_engine4.html
propagation_lively_engine5.html
screencast.html
standalone/babelsberg.cassowary.js
standalone/babelsberg.core.js
standalone/babelsberg.csp.js
standalone/babelsberg.deltablue.js
standalone/babelsberg.mini.js
standalone/babelsberg.mini.prototype.js
standalone/babelsberg.sutherland.js
standalone/babelsberg.z3.js
strz3.html
z3/convert/
Pushing changes...
Push: fatal: Authentication failed
Pushing changes...
Push: To https://github.com/babelsberg/babelsberg-js 01c4876..da11e1d master -> master
edit .git/config
edit .gitignore
# On branch master
# Changes not staged for commit:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#   modified:   PartsBin/Basic/Rectangle.html
#   modified:   PartsBin/Basic/Rectangle.json
#   modified:   PartsBin/Basic/Rectangle.metainfo
#   modified:   babelsberg-js.html
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#   ../2014-09-16-demo.html
#   ../babelsberg-js2.html
#   ../bar.html
#   ../combinator.html
#   ../config.js
#   ../domconstrains/
#   ../domconstraints/
#   ../emz3.html
#   ../exmaple1.html
#   ../propagation.html
#   ../propagation_lively_engine.html
#   ../propagation_lively_engine2.html
#   ../propagation_lively_engine3.ht4l
#   ../propagation_lively_engine3.html
X
Git Console
X
M
–
X
SystemBrowser
X
–
Menu
N
users/borning/PartsBin/Basic/
...
../
1
-----
X
>
<