OSDN Git Service

Update Document
authorFrank Li <lznuaa@gmail.com>
Mon, 23 Feb 2009 15:47:10 +0000 (23:47 +0800)
committerFrank Li <lznuaa@gmail.com>
Mon, 23 Feb 2009 15:47:10 +0000 (23:47 +0800)
doc/source/en/TortoiseGit/tsvn_dug/dug.xml
doc/source/en/TortoiseGit/tsvn_dug/dug_checkout.xml
doc/source/en/TortoiseGit/tsvn_dug/dug_commit.xml
doc/source/en/TortoiseGit/tsvn_dug/dug_general.xml
doc/source/en/TortoiseGit/tsvn_introduction.xml

index 0fd8a3f..1797616 100644 (file)
@@ -8,11 +8,11 @@
                <para>\r
                        This document describes day to day usage of the TortoiseGit client.\r
                        It is <emphasis>not</emphasis> an introduction to version control\r
-                       systems, and <emphasis>not</emphasis> an introduction to Git\r
-                       (SVN). It is more like a place you may turn to when you know\r
-                       approximately what you want to do, but don't quite remember how\r
-                       to do it.\r
+                       systems, and <emphasis>not</emphasis> an introduction to Git. It is \r
+                       more like a place you may turn to when you know approximately \r
+                       what you want to do, but don't quite remember how to do it.\r
                </para>\r
+               <!--\r
                <para>\r
                        If you need an introduction to version control with Git,\r
                        then we recommend you read the fantastic book:\r
@@ -20,6 +20,7 @@
 <citetitle>Version Control with Git</citetitle>\r
 </ulink>.\r
                </para>\r
+               -->\r
                <para>\r
                        This document is also a work in progress, just as TortoiseGit and\r
                        Git are. If you find any mistakes, please report them to\r
@@ -58,7 +59,9 @@
        <!-- ================================================================= -->\r
        <!-- include external entity refs -->\r
        <xi:include href="./dug_general.xml"/>\r
+       <!--\r
        <xi:include href="./dug_import.xml"/>\r
+       -->\r
        <xi:include href="./dug_checkout.xml"/>\r
        <xi:include href="./dug_commit.xml"/>\r
        <xi:include href="./dug_update.xml"/>\r
        <xi:include href="./dug_propertypage.xml"/>\r
        <xi:include href="./dug_branchtag.xml"/>\r
        <xi:include href="./dug_merge.xml"/>\r
+       <!--\r
        <xi:include href="./dug_locking.xml"/>\r
+       -->\r
        <xi:include href="./dug_patch.xml"/>\r
        <xi:include href="./dug_blame.xml"/>\r
+       <!--\r
        <xi:include href="./dug_repobrowser.xml"/>\r
+       -->\r
+       <!--\r
        <xi:include href="./dug_revgraph.xml"/>\r
+       -->\r
        <xi:include href="./dug_export.xml"/>\r
+       <!--\r
        <xi:include href="./dug_relocate.xml"/>\r
+       -->\r
        <xi:include href="./dug_bugtracker.xml"/>\r
+       <!--\r
        <xi:include href="./dug_repoviewer.xml"/>\r
+       -->\r
        <xi:include href="./dug_settings.xml"/>\r
        <sect1 id="tsvn-dug-donate">\r
                <title>Final Step</title>\r
index e154e3f..e347314 100644 (file)
@@ -1,34 +1,37 @@
 <?xml version="1.0" encoding="UTF-8"?>\r
 <!DOCTYPE sect1 SYSTEM "../../../dtd/dblite.dtd">\r
 <sect1 id="tsvn-dug-checkout">\r
-       <title>Checking Out A Working Copy</title>\r
+       <title>Checking Out A Working Copy(Switch to version)</title>\r
        <indexterm>\r
                <primary>checkout</primary>\r
        </indexterm>\r
        <indexterm>\r
+               <primary>Switch</primary>\r
+       </indexterm>\r
+       <indexterm>\r
                <primary>create working copy</primary>\r
        </indexterm>\r
        <?dbhh topicname="HIDD_CHECKOUT"?>\r
        <para>\r
-               To obtain a working copy you need to do a <firstterm>checkout</firstterm>\r
-               from a repository.\r
+               To obtain a special version working copy you need to do a <firstterm>checkout</firstterm>\r
+               from a local repository.\r
        </para>\r
        <para>\r
-               Select a directory in windows explorer where you want to place\r
-               your working copy. <action>Right click</action> to pop up the\r
+               Select a git repository directory in windows explorer\r
+               <action>Right click</action> to pop up the\r
                context menu and select the command\r
                <menuchoice>\r
                        <guimenu>TortoiseGit</guimenu>\r
-                       <guimenuitem>Checkout...</guimenuitem>\r
+                       <guimenuitem>Switch\Checkout...</guimenuitem>\r
                </menuchoice>,\r
                which brings up the following dialog box:\r
                <figure id="tsvn-dug-checkout-dia-1">\r
                        <title>The Checkout dialog</title>\r
                        <graphic fileref="../images/Checkout.png"/>\r
                </figure>\r
-               If you enter a folder name that does not yet exist, then a\r
-               directory with that name is created.\r
+               If you enter a branch name, new branch created and switch to new branchs.\r
        </para>\r
+       <!--\r
        <sect2 id="tsvn-dug-checkout-depth">\r
                <title>Checkout Depth</title>\r
                <para>\r
                        </para>\r
                </tip>\r
        </sect2>\r
+       -->\r
+       <--\r
        <para>\r
                If the project contains references to external projects which you do\r
                <emphasis>not</emphasis> want checked out at the same time, use the\r
                <guilabel>Omit externals</guilabel> checkbox.\r
        </para>\r
+       -->\r
        <important>\r
                <para>\r
                        If <guilabel>Omit externals</guilabel> is checked, or if you wish\r
index 762d9e2..c65aa55 100644 (file)
        <?dbhh topicname="HIDD_COMMITDLG"?>\r
        <para>\r
                Sending the changes you made to your working copy is known as\r
-               <firstterm>committing</firstterm> the changes. But before you\r
-               commit you have to make sure that your working copy is up to\r
-               date. You can either use\r
-               <menuchoice>\r
-                       <guimenu>TortoiseGit</guimenu>\r
-                       <guimenuitem>Update</guimenuitem>\r
-               </menuchoice>\r
-               directly. Or you can use\r
+               <firstterm>committing</firstterm> the changes. you can use\r
                <menuchoice>\r
                        <guimenu>TortoiseGit</guimenu>\r
                        <guimenuitem>Check for Modifications</guimenuitem>\r
                </menuchoice>\r
-               first, to see which files have changed locally or on the server.\r
+               first, to see which files have changed locally.\r
        </para>\r
        <sect2 id="tsvn-dug-commit-basics">\r
                <title>The Commit Dialog</title>\r
                <para>\r
-                       If your working copy is up to date and there are no conflicts,\r
+                       If there are no conflicts,\r
                        you are ready to commit your changes. Select any file\r
                        and/or folders you want to commit, then\r
                        <menuchoice>\r
@@ -56,6 +49,7 @@
                        switched something while working on a branch and forgotten to switch\r
                        back to trunk. This is your warning sign!\r
                </para>\r
+               <!--\r
                <tip>\r
                        <title>Commit files or folders?</title>\r
                        <para>\r
@@ -68,6 +62,8 @@
                                your life easier by doing more work for you.\r
                        </para>\r
                </tip>\r
+               -->\r
+               <--\r
                <para>\r
                        If you have modified files which have been included from a different\r
                        repository using <literal>svn:externals</literal>, those changes cannot\r
@@ -75,6 +71,7 @@
                        list tells you if this has happened, and the tooltip explains that\r
                        those external files have to be committed separately.\r
                </para>\r
+               -->\r
                <tip>\r
                        <title>Many unversioned files in the commit dialog</title>\r
                        <para>\r
                                                                <guimenu>TortoiseGit</guimenu>\r
                                                                <guimenuitem>Add to ignore list</guimenuitem>\r
                                                        </menuchoice>\r
+                                                       <!--\r
                                                        This will only affect the directory on\r
                                                        which you set the <literal>svn:ignore</literal> property.\r
                                                        Using the SVN Property Dialog, you can alter the\r
                                                        <literal>svn:ignore</literal> property for a directory.\r
+                                                       -->\r
                                                </para>\r
                                        </listitem>\r
                                </itemizedlist>\r
                                into the commit dialog, and they will be SVN added automatically.\r
                        </para>\r
                </tip>\r
+               <!--\r
                <tip>\r
                        <title>Repairing External Renames</title>\r
                        <para>\r
                                to pair the two files as a rename.\r
                        </para>\r
                </tip>\r
+               -->\r
        </sect2>\r
        <sect2 id="tsvn-dug-commit-changelists">\r
                <title>Change Lists</title>\r
                                <citetitle>http://www.regular-expressions.info/</citetitle>\r
                        </ulink>.\r
                </para>\r
+               <!--\r
                <para>\r
                        You can re-use previously entered log messages. Just click on\r
                        <guibutton>Recent messages</guibutton> to view a list of the last few\r
                        messages you entered for this working copy. The number of stored messages\r
                        can be customized in the TortoiseGit settings dialog.\r
                </para>\r
+               -->\r
                <para>\r
                        You can clear all stored commit messages from the <guilabel>Saved data</guilabel>\r
                        page of TortoiseGit's settings, or you can clear individual messages from\r
                        Another way to insert the paths into the log message is to simply\r
                        drag the files from the file list onto the edit control.\r
                </para>\r
+               <!--\r
                <tip>\r
                        <title>Special Folder Properties</title>\r
                        <para>\r
                                Read <xref linkend="tsvn-dug-propertypage"/> for further information.\r
                        </para>\r
                </tip>\r
+               -->\r
                <tip>\r
                        <title>Integration with Bug Tracking Tools</title>\r
                        <para>\r
                        </para>\r
                </tip>\r
        </sect2>\r
+       <!--\r
        <sect2 id="tsvn-dug-commit-progress">\r
                <title>Commit Progress</title>\r
                <para>\r
                        Read <xref linkend="tsvn-dug-settings-colours"/> for more information.\r
                </para>\r
        </sect2>\r
+       -->\r
 </sect1>\r
index 725ec8a..d922a05 100644 (file)
                        </variablelist>\r
                </para>\r
        </sect2>\r
+       <!--\r
        <sect2 id="tsvn-dug-general-auth">\r
                <title>Authentication</title>\r
                <indexterm>\r
@@ -201,6 +202,7 @@ rmdir /s /q "%APPDATA%\Git\auth"
                        <xref linkend="tsvn-serversetup"/>\r
                </para>\r
        </sect2>\r
+       -->\r
        <sect2 id="tsvn-dug-general-window-max">\r
                <title>Maximizing Windows</title>\r
                <indexterm>\r
index b689193..576b4c7 100644 (file)
@@ -25,8 +25,8 @@
                <para>\r
                        TortoiseGit is a free open-source client for the\r
                        <firstterm>Git</firstterm> version control system.\r
-                       That is, TortoiseGit manages files and directories over time.\r
-                       Files are stored in a central <firstterm>repository</firstterm>.\r
+                       That is, TortoiseGit manages files over time.\r
+                       Files are stored in a local <firstterm>repository</firstterm>.\r
                        The repository is much like an ordinary file server, except that it\r
                        remembers every change ever made to your files and directories.\r
                        This allows you to recover older versions of your files and examine\r
                        <emphasis>any</emphasis> collection of files, including\r
                        source code.\r
                </para>\r
+               <para>\r
+                       Git is an <emphasis>open source, distributed version control system</emphasis>\r
+                       designed to handle everything from small to very large projects with speed and \r
+                       efficiency. Every Git clone is a full-fledged repository with complete history \r
+                       and full revision tracking capabilities, not dependent on network access or \r
+                       a central server. Branching and merging are fast and easy to do.\r
+               </para>\r
        </sect1>\r
        <!-- ================================================================= -->\r
        <!-- ======================== SECTION 2 ============================== -->\r
        <sect1 id="tsvn-intro-history">\r
                <title>TortoiseGit's History</title>\r
                <para>\r
-                       In 2002, Tim Kemp found that Git was a very good version\r
+                       In 2008, Frank Li found that Git was a very good version\r
                        control system, but it lacked a good GUI client. The idea for a\r
                        Git client as a Windows shell integration was inspired by\r
-                       the similar client for CVS named TortoiseCVS.\r
+                       the similar client for SVN named TortoiseSVN.\r
                </para>\r
                <para>\r
-                       Tim studied the source code of TortoiseCVS and used it as a base for\r
-                       TortoiseGit. He then started the project, registered the domain\r
-                       <literal>TortoiseGit.org</literal> and put the source code online. During that time,\r
-                       Stefan Küng was looking for a good and free version control system\r
-                       and found Git and the source for TortoiseGit. Since TortoiseGit\r
-                       was still not ready for use then he joined the project and started\r
-                       programming. Soon he rewrote most of the existing code and started\r
-                       adding commands and features, up to a point where nothing of the\r
-                       original code remained.\r
+                       Frank studied the source code of TortoiseSVN and used it as a base for\r
+                       TortoiseGit. He then started the project, registered the project\r
+                       at code.google.com and put the source code online. \r
                </para>\r
                <para>\r
                        As Git became more stable it attracted more and more users\r
                        who also started using TortoiseGit as their Git client.\r
-                       The user base grew quickly (and is still growing every day).\r
-                       That's when Lübbe Onken offered to help out with some nice icons\r
-                       and a logo for TortoiseGit. And he takes care of the website\r
-                       and manages the translation.\r
                </para>\r
        </sect1>\r
        <!-- ================================================================= -->\r
                </para>\r
                <variablelist>\r
                        <varlistentry>\r
-                               <term>Directory versioning</term>\r
+                               <term>Distributed version control</term>\r
                                <listitem>\r
                                        <para>\r
-                                               CVS only tracks the history of individual files, but\r
-                                               Git implements a <quote>virtual</quote>\r
-                                               versioned filesystem that tracks changes to whole\r
-                                               directory trees over time.\r
-                                               Files <emphasis>and</emphasis> directories are\r
-                                               versioned. As a result, there are real client-side\r
-                                               <command>move</command> and <command>copy</command>\r
-                                               commands that operate on files and directories.\r
+                                                Like most other modern version control systems, Git \r
+                                                gives each developer a local copy of the entire development \r
+                                                history, and changes are copied from one such repository \r
+                                                to another. These changes are imported as additional \r
+                                                development branches, and can be merged in the same way \r
+                                                as a locally developed branch. Repositories can be easily \r
+                                                accessed via the efficient Git protocol (optionally wrapped \r
+                                                in ssh for authentication and security) or simply using \r
+                                                HTTP - you can publish your repository anywhere without \r
+                                                any special webserver configuration required.\r
                                        </para>\r
                                </listitem>\r
                        </varlistentry>\r
                                <listitem>\r
                                        <para>\r
                                                A commit either goes into the repository completely,\r
-                                               or not at all.  This allows developers to construct and\r
-                                               commit changes as logical chunks.\r
+                                               or not at all. \r
                                        </para>\r
                                </listitem>\r
                        </varlistentry>\r
                        <varlistentry>\r
-                               <term>Versioned metadata</term>\r
+                               <term>Strong support for non-linear development</term>\r
                                <listitem>\r
                                        <para>\r
-                                               Each file and directory has an invisible set of\r
-                                               <quote>properties</quote> attached. You can invent and\r
-                                               store any arbitrary key/value pairs you wish.\r
-                                               Properties are versioned over time, just like file\r
-                                               contents.\r
+                                               Git supports rapid and convenient branching and merging, \r
+                                               and includes powerful tools for visualizing and navigating \r
+                                               a non-linear development history.                                       \r
                                        </para>\r
                                </listitem>\r
                        </varlistentry>\r
                        <varlistentry>\r
-                               <term>Choice of network layers</term>\r
+                               <term>Efficient handling of large projects</term>\r
                                <listitem>\r
                                        <para>\r
-                                               Git has an abstracted notion of repository\r
-                                               access, making it easy for people to implement new\r
-                                               network mechanisms. Git's <quote>advanced</quote>\r
-                                               network server is a module for the Apache web server,\r
-                                               which speaks a variant of HTTP called WebDAV/DeltaV.\r
-                                               This gives Git a big advantage in stability and\r
-                                               interoperability, and provides various key features for\r
-                                               free: authentication, authorization, wire compression,\r
-                                               and repository browsing, for example. A smaller,\r
-                                               standalone Git server process is also available.\r
-                                               This server speaks a custom protocol which can be\r
-                                               easily tunneled over ssh.\r
+                                               Git is very fast and scales well even when working with \r
+                                               large projects and long histories. It is commonly an order \r
+                                               of magnitude faster than most other version control systems, \r
+                                               and several orders of magnitude faster on some operations. \r
+                                               It also uses an extremely efficient packed format for long-term \r
+                                               revision storage that currently tops any other open source \r
+                                               version control system.\r
                                        </para>\r
                                </listitem>\r
                        </varlistentry>\r
                        <varlistentry>\r
-                               <term>Consistent data handling</term>\r
+                               <term>Cryptographic authentication of history</term>\r
                                <listitem>\r
                                        <para>\r
-                                               Git expresses file differences using a binary\r
-                                               differencing algorithm, which works identically on both\r
-                                               text (human-readable) and binary (human-unreadable) files.\r
-                                               Both types of files are stored equally compressed in the\r
-                                               repository, and differences are transmitted in both\r
-                                               directions across the network.\r
+                                               The Git history is stored in such a way that the name of a \r
+                                               particular revision (a "commit" in Git terms) depends upon \r
+                                               the complete development history leading up to that commit. \r
+                                               Once it is published, it is not possible to change the old \r
+                                               versions without it being noticed. Also, tags can be \r
+                                               cryptographically signed. \r
                                        </para>\r
                                </listitem>\r
                        </varlistentry>\r
                                <listitem>\r
                                        <para>\r
                                                The cost of branching and tagging need not be\r
-                                               proportional to the project size. Git creates\r
-                                               branches and tags by simply copying the project, using\r
-                                               a mechanism similar to a hard-link.\r
-                                               Thus these operations take only a very small,\r
-                                               constant amount of time, and very little space in the repository.\r
+                                               proportional to the project size. Branch is just head of commits. \r
+                                               Tag is friend name of commit hash. \r
                                        </para>\r
                                </listitem>\r
                        </varlistentry>\r
                        <varlistentry>\r
-                               <term>Hackability</term>\r
+                               <term>Toolkit design.</term>\r
                                <listitem>\r
                                        <para>\r
-                                               Git has no historical baggage; it is implemented\r
-                                               as a collection of shared C libraries with well-defined\r
-                                               APIs. This makes Git extremely maintainable and\r
-                                               usable by other applications and languages.\r
+                                               Following the Unix tradition, Git is a collection of many small \r
+                                               tools written in C, and a number of scripts that provide convenient \r
+                                               wrappers. Git provides tools for both easy human usage and easy \r
+                                               scripting to perform new clever operations.\r
                                        </para>\r
                                </listitem>\r
                        </varlistentry>\r
                        <title>System requirements</title>\r
                        <para>\r
                                TortoiseGit runs on Windows 2000 SP2, Windows XP or higher.\r
-                               Windows 98, Windows ME and Windows NT4 are no longer supported\r
-                               since TortoiseGit 1.2.0, but you can still download\r
-                               the older versions if you really need them.\r
+                               Windows 98, Windows ME and Windows NT4 are no longer supported.\r
                        </para>\r
                        <para>\r
                                If you encounter any problems during or after installing\r
                        </important>\r
                </sect2>\r
                <sect2 id="tsvn-intro-install-lang">\r
-                       <title>Language Packs</title>\r
+                       <title>Language Packs(not start)</title>\r
                        <indexterm>\r
                                <primary>language packs</primary>\r
                        </indexterm>\r
                                Next time you restart, the translation will be available.\r
                        </para>\r
                </sect2>\r
-               <sect2 id="tsvn-intro-install-spell">\r
+               <sect2 id="tsvn-intro-instalsl-spell">\r
                        <title>Spellchecker</title>\r
                        <indexterm>\r
                                <primary>spellchecker</primary>\r