Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
TkCVS(1)		    General Commands Manual		      TkCVS(1)

NAME
       TkCVS - a Tk/Tcl	Graphical Interface to CVS and Subversion

SYNOPSIS
       tkcvs  [-dir  directory]	 [-root	 cvsroot]  [-win workdir|module|merge]
       [-log file]

DESCRIPTION
       TkCVS is	a Tcl/Tk-based graphical interface to the CVS  and  Subversion
       configuration  management  systems. It displays the status of the files
       in the current working directory, and provides buttons and menus	to ex-
       ecute configuration-management commands on the selected files.  Limited
       RCS  functionality is also present. Git functionality is	new in version
       9.

       TkDiff is bundled in for	browsing and merging your changes.

       TkCVS also aids in browsing the repository. For Subversion, the reposi-
       tory tree is browsed like an ordinary file tree.	  For  CVS,  the  CVS-
       ROOT/modules  file is read.  TkCVS extends CVS with a method to produce
       a browsable, "user friendly" listing of modules.	This requires  special
       comments	 in  the CVSROOT/modules file. See "CVS	Modules	File" for more
       guidance.

OPTIONS
       TkCVS accepts the following options.

       -dir directory
	      Start TkCVS in the specified directory.

       -help  Print a usage message.

       -log file
	      Invoke a log browser for the specified file. -log	and  -win  are
	      mutually exclusive.

       -root cvsroot
	      Set $CVSROOT to the specified repository.

       -win workdir|module|merge
	      Start  by	 displaying  the  directory browser (the default), the
	      module browser, or the directory-merge tool. -win	and  -log  are
	      mutually exclusive.

Examples
	      %	tkcvs -win module -root	/jaz/repository
       Browse the modules located in CVSROOT /jaz/repository
	      %	tkcvs -log tstheap.c
       View the	log of the file	tstheap.c

Working	Directory Browser
       The  working  directory	browser	 shows the files in your local working
       copy, or	"sandbox."  It shows the status	of the files at	a  glance  and
       provides	tools to help with most	of the common CVS, SVN,	and RCS	opera-
       tions you might do.

       At the top of the browser you will find:

       *   The	name  of  the current directory. You can change	directories by
       typing in this field. Recently visited directories  are	saved  in  the
       picklist.

       *   The relative	path of	the current directory in the repository. If it
       is not contained	in the repository you may import it using the menu  or
       toolbar button.

       *   A  Directory	Tag name, if the directory is contained	in the reposi-
       tory and	it has been checked out	against	a particular  branch  or  tag.
       In  Subversion, the branch or tag is inferred from the URL based	on the
       conventional trunk-branches-tags	repository organization.

       *  The CVSROOT of the current directory if it's under CVS  control,  or
       the  URL	of the Subversion repository if	it's under Subversion control.
       If neither is true, it may default to the value of the  $CVSROOT	 envi-
       ronment variable.

       The  main  part of the working directory	browser	is a list of the files
       in the current directory	with an	icon next to each showing its  status.
       You  select  a  file by clicking	on its name or icon once with the left
       mouse button. Holding the Control key while clicking will add the  file
       to  the	group  of  those already selected. You can select a contiguous
       group of	files by holding the Shift key while clicking.	You  can  also
       select  a group of files	by dragging the	mouse with the middle or right
       button pressed to select	an area. Selecting an item that's already  se-
       lected  de-selects  that	 item.	To  unselect all files,	click the left
       mouse button in an empty	area of	the file list.

       *  The Date column (can be hidden) shows	the modification time  of  the
       file  is	 shown.	 The  format  of the date column may be	specified with
       cvscfg(dateformat). The default format was chosen because it sorts  the
       same way	alphabetically as chronologically.

       If  the	directory  belongs  to	a  revision  system, other columns are
       present.

       * The revision column shows which revision of the file is checked  out,
       and whether it's	on the trunk or	on a branch.

       *   The	status	column	(can be	hidden)	shows the revision of the file
       spelled out in text.  This information is mostly	redundant to the  icon
       in the file column.

       *   The Editor/Author/Locker column (can	be hidden) varies according to
       revision	system.	In Subversion, the author of the most  recent  checkin
       is  shown.  In CVS, it shows a list of people editing the files if your
       site uses "cvs watch" and/or "cvs edit".	Otherwise, it will  be	empty.
       In RCS, it shows	who, if	anyone,	has the	file locked.

       The optional columns can	be displayed or	hidden using the Options menu.

       You can move into a directory by	double-clicking	on it.

       Double  clicking	on a file will load the	file into a suitable editor so
       you can change it. A different editor can be used  for  different  file
       types (see Configuration	Files).

   File	Status
       When  you are in	a directory that is under CVS, Subversion, or Git con-
       trol, the file status will be shown by  an  icon	 next  to  each	 file.
       Checking	 the  "Status Column" option causes the	status to be displayed
       in text in its own column. Some possible	statuses are:

       Up-to-date
	      The file is up to	date with respect to the repository.

       Locally Modified
	      The file has been	modified in the	current	directory since	 being
	      checked out of the repository.

       Locally Added
	      The file has been	added to the repository. This file will	become
	      permanent	in the repository once a commit	is made.

       Locally Removed
	      You  have	 removed  the  file with remove, and not yet committed
	      your changes.

       Needs Checkout
	      Someone else has committed a newer revision to  the  repository.
	      The  name	is slightly misleading;	you will ordinarily use	update
	      rather than checkout to get that newer revision.

       Needs Patch
	      Like Needs Checkout, but the CVS server will send	a patch	rather
	      than the entire file. Sending a patch or sending an entire  file
	      accomplishes the same thing.

       Needs Merge
	      Someone  else  has committed a newer revision to the repository,
	      and you have also	made modifications to the file.

       Unresolved Conflict
	      This is like Locally Modified, except  that  a  previous	update
	      command gave a conflict. You need	to resolve the conflict	before
	      checking in.

       ?      The file is not contained	in the repository. You may need	to add
	      the file to the repository by pressing the "Add" button.

       [directory:CVS]
	      A	directory which	has been checked out from a CVS	repository.

       [directory:SVN]
	      A	directory which	has been checked out from a Subversion reposi-
	      tory.   In  Subversion, directories are themselves versioned ob-
	      jects.

       [directory:RCS]
	      A	directory which	contains an RCS	sub-directory  or  some	 files
	      with  the	 ,v  suffix, presumably	containing some	files that are
	      under RCS	revision control.

       [directory:GIT]
	      A	directory which	has been cloned	from a Git repository.

       [directory]
	      A	directory not controlled by one	of the supported revision con-
	      trol systems

   File	Filters
       You can specify file matching patterns to instruct  TkCVS  which	 files
       you  wish  to see. You can also specify patterns	telling	it which files
       to remove when you press	the "Clean" button or select the File->Cleanup
       menu item.

       "Hide" works exactly the	way a  .cvsignore  file	 works.	 That  is,  it
       causes  non-CVS	files  with  the pattern to be ignored.	It's meant for
       hiding .o files and such. Any file under	CVS  control  will  be	listed
       anyway.

       "Show" is the inverse. It hides non-CVS files except for	those with the
       pattern.

   Buttons
       Module Browser:
	      The  big	button	at  the	 upper right opens the module browser.
	      Opens a module browser window which will enable you  to  explore
	      items  in	 the  repository  even if they're not checked out.  In
	      CVS, this	requires that there be entries in the  CVSROOT/modules
	      file.  Browsing can be improved by using TkCVS-specific comments
	      in CVSROOT/modules.

       Go Up: The  button  to the left of the entry that shows the current di-
	      rectory. Press it	and you	go up one level.

       There are a number of buttons at	the bottom of the window. Pressing  on
       one of these causes the following actions:

       Delete:
	      Press  this  button to delete the	selected files.	The files will
	      not be removed from the repository. To remove the	files from the
	      repository as well as delete them, press the "Remove" button in-
	      stead.

       Edit:  Press this button	to load	the selected files in to an  appropri-
	      ate editor.

       View:  Press  this  button to view the selected files in	a Tk text win-
	      dow. This	can be a lot faster then Edit, in case your  preferred
	      editor is	xemacs or something of that magnitude.

       Refresh:
	      Press  this button to re-read the	current	directory, in case the
	      status of	some files may have changed.

       Status Check:
	      Shows, in	a searchable text window, the status of	all the	files.
	      By default, it is	recursive and lists unknown (?)	 files.	 These
	      can be changed in	the Options menu.

       Directory Branch	Browse:
	      For  merging  the	 entire	directory. In Subversion, it opens the
	      Branch Browser for "."  In CVS, it  chooses  a  "representative"
	      file in the current directory and	opens a	graphical tool for di-
	      rectory merges.

       Log (Branch) Browse:
	      This button will bring up	the log	browser	window for each	of the
	      selected files in	the window. See	the Log	Browser	section.

       Annotate:
	      This  displays a window in which the selected file is shown with
	      the lines	highlighted according to when and by  whom  they  were
	      last revised.  In	Subversion, it's also called "blame."

       Diff:  This  compares  the  selected files with the equivalent files in
	      the repository. A	separate program called	 "TkDiff"  (also  sup-
	      plied  with  TkCVS)  is used to do this. For more	information on
	      TkDiff, see TkDiff's help	menu.

       Merge Conflict:
	      If a file's status says "Needs Merge", "Conflict", or is	marked
	      with  a "C" in CVS Check,	there was a difference which CVS needs
	      help to reconcile. This button invokes TkDiff with the -conflict
	      option, opening a	merge window to	help  you  merge  the  differ-
	      ences.

       Check In:
	      This  button  commits  your  changes to the repository. This in-
	      cludes adding new	files and removing  deleted  files.  When  you
	      press  this button, a dialog will	appear asking you for the ver-
	      sion number of the files you want	to commit, and a comment.  You
	      need  only enter a version number	if you want to bring the files
	      in the repository	up to the next major version number. For exam-
	      ple, if a	file is	version	1.10, and you do not enter  a  version
	      number,  it will be checked in as	version	1.11. If you enter the
	      version number 3,	then it	will be	checked	in as version 3.0  in-
	      stead.   It is usually better to use symbolic tags for that pur-
	      pose.  If	you use	rcsinfo	to supply a template for the  comment,
	      you  must	 use an	external editor.  Set cvscfg(use_cvseditor) to
	      do this. For checking in to RCS, an externel  editor  is	always
	      used.

       Update:
	      This  updates  your sandbox directory with any changes committed
	      to the repository	by other developers.

       Update with Options:
	      Allows you to update from	a different branch, with a  tag,  with
	      empty directories, and so	on.

       Add Files:
	      Press  this button when you want to add new files	to the reposi-
	      tory. You	must create the	file before adding it to  the  reposi-
	      tory.  To	 add  some  files, select them and press the Add Files
	      button. The files	that you have added to the repository will  be
	      committed	next time you press the	Check In button. It is not re-
	      cursive. Use the menu CVS	-> Add Recursively for that.

       Remove Files:
	      This  button will	remove files. To remove	files, select them and
	      press the	Remove button. The files will disappear	from  the  di-
	      rectory,	and  will be removed from the repository next time you
	      press the	Check In button. It is not recursive. Use the menu CVS
	      -> Remove	Recursively for	that.

       Tag:   This button will tag the selected	files. In CVS, the -F  (force)
	      option will move the tag if it already exists on the file.

       Branch Tag:
	      This  button  will tag the selected files, creating a branch. In
	      CVS, the -F (force) option will move the tag if it  already  ex-
	      ists on the file.

       Lock (CVS and RCS):
	      Lock an RCS file for editing.  If	cvscfg(cvslock)	is set,	lock a
	      CVS  file.  Use of locking is philosophically discouraged	in CVS
	      since it's against the "concurrent" part of Concurrent  Version-
	      ing  System,  but	 locking  policy  is nevertheless used at some
	      sites.  One size doesn't fit all.

       Unlock (CVS and RCS):
	      Unlock an	RCS file.  If cvscfg(cvslock) is  set,	unlock	a  CVS
	      file.

       Set Edit	Flag (CVS):
	      This  button  sets the edit flag on the selected files, enabling
	      other developers to see that you	are  currently	editing	 those
	      files (See "cvs edit" in the CVS documentation).

       Reset Edit Flag (CVS):
	      This button resets the edit flag on the selected files, enabling
	      other  developers	 to  see  that you are no longer editing those
	      files (See "cvs edit" in the CVS documentation). As the  current
	      version  of  cvs	waits  on a prompt for "cvs unedit" if changes
	      have been	made to	the file in question (to ask if	 you  want  to
	      revert  the changes to the current revision), the	current	action
	      of tkcvs is to abort the unedit (by piping in nothing to stdin).
	      Therefore, to lose the changes and revert	to the	current	 revi-
	      sion,  it	is necessary to	delete the file	and do an update (this
	      will also	clear the edit flag). To keep the changes, make	a copy
	      of the file, delete the original,	 update,  and  then  move  the
	      saved copy back to the original filename.

       Close: Press  this button to close the Working Directory	Browser. If no
	      other windows are	open, TkCVS exits.

Log (Branch) Browser
       The TkCVS Log Browser window enables you	to view	a graphical display of
       the revision log	of a file, including all  previous  versions  and  any
       branched	versions.

       You can get to the log browser window in	three ways, either by invoking
       it  directly with "tkcvs	[-log] <filename>", by selecting a file	within
       the main	window of TkCVS	and pressing the Log Browse button, or by  se-
       lecting	a  file	in a list invoked from the module browser and pressing
       the Log Browse button.

       If the Log Browser is examining a checked-out  file,  the  buttons  for
       performing merge	operations are enabled.

   Log Browser Window
       The  log	 browser  window has three components. These are the file name
       and version information section at the top, the log display in the mid-
       dle, and	a row of buttons along the bottom.

   Log Display
       The main	log display is fairly self explanatory.	It shows  a  group  of
       boxes connected by lines	indicating the main trunk of the file develop-
       ment  (on the left hand side) and any branches that the file has	(which
       spread out to the right of the main trunk).

       Each box	contains the version number, author of the version, and	 other
       information determined by the menu View -> Revision Layout.

       Constructing  the branch	diagram	from Subversion	is inefficient,	so the
       Log Browser counts the tags when	doing a	Subversion diagram and pops up
       a dialog	giving you a chance to skip the	tag step if there are too many
       tags (where "many" arbitrarily equals 10.)

   Version Numbers
       Once a file is loaded into the log browser, one or two version  numbers
       may  be	selected.  The	primary	 version  (Selection A)	is selected by
       clicking	the left mouse button on a version box in the  main  log  dis-
       play.

       The  secondary  version (Selection B) is	selected by clicking the right
       mouse button on a version box in	the main log display.

       Operations such as "View" and "Annotate"	operate	only  on  the  primary
       version selected.

       Operations  such	 as  "Diff" and	"Merge Changes to Current" require two
       versions	to be selected.

   Searching the Diagram
       You can search the canvas for tags, revisions, authors, and dates.

       The following special characters	are used in the	search pattern:

	 *	Matches	any sequence of	characters in string, including	a null
       string.

	 ?	Matches	any single character in	string.

	 [chars] Matches any character in the set given	by  chars.  If	a  se-
       quence  of  the form x-y	appears	in chars, then any character between x
       and y, inclusive, will match.

	      Matches the single character x. This provides a way of  avoiding
       the special interpretation of the characters *?[] in pattern.

       If you only enter "FOO" (without	the

   Log Browser Buttons
       The log browser contains	the following buttons:

       Refresh:
	      Re-reads the revision history of the file.

       View:  Pressing	this  button  displays a Tk text window	containing the
	      version of the file at Selection A.

       Annotate:
	      This displays a window in	which the file is shown	with its lines
	      highlighted according to when and	by whom	 they  were  last  re-
	      vised.  In Subversion, it's also called "blame."

       Diff:  Pressing	this  button  runs the "tkdiff"	program	to display the
	      differences between version A and	version	B.

       Merge: To use this button, select a branch version of the  file,	 other
	      than  the	 branch	 you  are currently on,	as the primary version
	      (Selection A). The changes made along the	branch up to that ver-
	      sion will	be merged into the current version, and	stored in  the
	      current directory. Optionally, select another version (Selection
	      B)  and the changes will be from that point rather than from the
	      base of the branch.  The version of the file in the current  di-
	      rectory  will be merged, but no commit will occur.  Then you in-
	      spect the	merged files, correct any conflicts which  may	occur,
	      and  commit  when	you are	satisfied.  Optionally,	TkCVS will tag
	      the version that the merge is from.  It suggests a  tag  of  the
	      form "mergefrom_<rev>_date."  If you use this auto-tagging func-
	      tion,  another dialog containing a suggested tag for the merged-
	      to version will appear.  It's suggested to leave the  dialog  up
	      until  you  are  finished, then copy-and-paste the suggested tag
	      into the "Tag" dialog.  It is always a good practice to tag when
	      doing merges, and	if you use tags	of  the	 suggested  form,  the
	      Branch  Browser  can  diagram  them. (Auto-tagging is not	imple-
	      mented in	Subversion because, despite the	 fact  that  tags  are
	      "cheap,"	it's  somewhat	impractical  to	auto-tag single	files.
	      You can do the tagging manually, however.)

       View Tags:
	      This button lists	all the	tags applied to	the file in a  search-
	      able text	window.

       Close: This  button  closes  the	 Log  Browser. If no other windows are
	      open, TkCVS exits.

   The View Options Menu
       The View	Menu allows you	to control what	you see	in the branch diagram.
       You can choose how much information to show in the  boxes,  whether  to
       show  empty  revisions, and whether to show tags.  You can even control
       the size	of the boxes.  If you are using	Subversion, you	 may  wish  to
       turn  the  display of tags off.	If they	aren't asked for they won't be
       read from the repository, which can save	a lot of time.

Merge Tool for CVS
       The Merge Tool chooses a	"representative" file in the current directory
       and diagrams the	branch tags. It	tries to pick the "bushiest" file,  or
       failing	that,  the most-revised	file. If you disagree with its choice,
       you can type the	name of	another	file in	the top	entry and press	Return
       to diagram that file instead.

       The main	purpose	of this	tool is	to do merges (cvs update  -j  rev  [-j
       rev])  on  the  whole  directory.  For  merging one file	at a time, you
       should use the Log Browser. You can only	merge to the  line  (trunk  or
       branch)	that  you  are	currently on. Select a branch to merge from by
       clicking	on it. Then press either the "Merge" or	"Merge	Changes"  but-
       ton.  The  version  of  the file	in the current directory will be over-
       written,	but it will not	be committed to	the repository.	 You  do  that
       after  you've  reconciled conflicts and decided if it's what you	really
       want.

       Merge Branch to Current:
	      The changes made on the  branch  since  its  beginning  will  be
	      merged into the current version.

       Merge Changes to	Current:
	      Instead  of  merging  from  the  base of the branch, this	button
	      merges the changes that were made	since a	particular version  on
	      the  branch.  It	pops up	a dialog in which you fill in the ver-
	      sion. It should usually be the version that was last merged.

Module Browser
       Operations that are  performed  on  the	repository  instead  of	 in  a
       checked-out  working  directory	are done with the Module Browser.  The
       most common of these operations is checking out or exporting  from  the
       repository.   The  Module  Browser can be started from the command line
       (tkcvs -win module) or started from the main window by pressing the big
       button.

       Subversion repositories can be browsed like a file tree,	 and  that  is
       what  you  will see in the Module Browser.  CVS repositories aren't di-
       rectly browsable, but if	the CVSROOT/modules file is maintained	appro-
       priately,  TkCVS	 can  display the modules and infer tree structures if
       they are	present. See the "CVS Modules File" section.

       Using the module	browser	window,	you can	select a module	to check  out.
       When  you check out a module, a new directory is	created	in the current
       working directory with the same name as the module.

   Tagging and Branching (cvs rtag)
       You can tag particular versions of a module or file in the  repository,
       with plain or branch tags, without having the module checked out.

   Exporting
       Once  a software	release	has been tagged, you can use a special type of
       checkout	called an export. This allows you to cleanly check  out	 files
       from  the  repository,  without all of the administrivia	that CVS needs
       to have while working on	the files. It is  useful  for  delivery	 of  a
       software	release	to a customer.

   Importing
       TkCVS contains a	special	dialog to allow	users to import	new files into
       the  repository.	 In CVS, new modules can be assigned places within the
       repository, as well as descriptive names	(so  that  other  people  know
       what they are for).

       When  the Module	Browser	displays a CVS repository, the first column is
       a tree showing the module codes and directory names of all of the items
       in the repository. The icon shows  whether  the	item  is  a  directory
       (which  may  contain  other directories or modules), or whether it is a
       module (which may be checked out	from TkCVS). It	 is  possible  for  an
       item  to	 be both a module and a	directory. If it has a red ball	on it,
       you can check it	out. If	it shows a plain folder	icon, you have to open
       the folder to get to the	items that you can check out.

       To select a module, click on it with the	left mouse button.  The	 right
       mouse button will perform a secondary selection,	which is used only for
       Subversion  diff	 and  patch. To	clear the selection, click on the item
       again or	click in an empty area of the module column. There can only be
       one primary and one secondary selection.

   Repository Browser Buttons
       The module browser contains the following buttons:

       Who:   Shows which modules are checked out by whom.

       Import:
	      This item	will import the	contents of the	current	directory (the
	      one shown	in the Working Directory Display) into the  repository
	      as  a module. See	the section titled Importing for more informa-
	      tion.

       File Browse:
	      Displays a list of the selected module's files.  From  the  file
	      list, you	can view the file, browse its revision history,	or see
	      a	list of	its tags.

       Check Out:
	      Checks  out the current version of a module. A dialog allows you
	      to specify a tag,	change the destination,	and so on.

       Export:
	      Exports the current version of a module. A dialog	allows you  to
	      specify a	tag, change the	destination, and so on.	Export is sim-
	      ilar  to	check-out,  except exported directories	do not contain
	      the CVS or administrative	directories, and are therefore cleaner
	      (but cannot be used for checking files back in  to  the  reposi-
	      tory).  You must supply a	tag name when you are exporting	a mod-
	      ule to make sure you can reproduce the exported files at a later
	      date.

       Tag:   This button tags an entire module.

       Branch Tag:
	      This creates a branch of a module	by giving it a branch tag.

       Patch Summary:
	      This item	displays a short summary of  the  differences  between
	      two versions of a	module.

       Create Patch File:
	      This  item creates a Larry Wall format patch(1) file of the mod-
	      ule selected.

       Close: This button closes the Repository	Browser. If no	other  windows
	      are open,	TkCVS exits.

Importing New Modules
       Before  importing  a new	module,	first check to make sure that you have
       write permission	to the repository. Also	you'll have to make  sure  the
       module name is not already in use.

       To  import  a module you	first need a directory where the module	is lo-
       cated. Make sure	that there is nothing in  this	directory  except  the
       files that you want to import.

       Press  the big "Repository Browser" button in the top part of the tkcvs
       UI, or use CVS -> Import	WD into	Repository from	the menu bar.

       In the module browser, press the	Import button on the bottom,  the  one
       that shows a folder and an up arrow.

       In the dialog that pops up, fill	in a descriptive title for the module.
       This will be what you see in the	right side of the module browser.

       OK  the dialog.	Several	things happen now.  The	directory is imported,
       the CVSROOT/module file is updated, your	original directory is saved as
       directory.orig, and the newly created module is checked out.

       When it finishes,  you  should  find  the  original  Working  Directory
       Browser showing the files in the	newly created, checked out module.

       Here is a more detailed description of the fields in the	Import Dialog.

       Module Name:
	      A	 name for the module.  This name must not already exist	in the
	      repository. Your organization could settle on a single unambigu-
	      ous code for modules. One	possibility is something like:

		  [project code]-[subsystem code]-[module code]

       Module Path:
	      The location in the repository tree where	your new  module  will
	      go.

       Descriptive Title:
	      A	one-line descriptive title for your module.  This will be dis-
	      played in	the right-hand column of the browser.

       Version Number:
	      The  current version number of the module. This should be	a num-
	      ber of the form X.Y.Z where .Y and  .Z  are  optional.  You  can
	      leave this blank,	in which case 1	will be	used as	the first ver-
	      sion number.

       Importing  a  directory	into  Subversion is similar but	not so compli-
       cated.  You use the SVN -> Import CWD into Repository menu.   You  need
       supply  only the	path in	the repository where you want the directory to
       go.  The	repository must	be prepared and	the path must exist, however.

Importing to an	Existing Module	(CVS)
       Before importing	to an existing module, first check to make  sure  that
       you have	write permission to the	repository.

       To  import  to  an existing module you first need a directory where the
       code is located.	Make sure that there is	nothing	in this	directory (in-
       cluding no CVS directory) except	the files that you want	to import.

       Open up the Repository Browser by selecting  File/Browse	 Modules  from
       the menu	bar.

       In  the	Repository  Browser,  select File/Import To An Existing	Module
       from the	menu bar.

       In the dialog that pops up, press the Browse button and select the name
       of an existing module. Press the	OK to close this dialog	box. Enter the
       version number of the code to be	imported.

       OK the dialog.  Several things happen now.  The directory is  imported,
       your  original directory	is saved as directory.orig, and	the newly cre-
       ated module is checked out.

       When it finishes, you will find the original Working Directory  Browser
       showing the original code. If you press the "Re-read the	current	direc-
       tory" button you	will see the results of	the checked out	code.

       Here is a more detailed description of the fields in the	Import Dialog.

       Module Name:
	      A	 name for the existing module. Filled in by the	use of the the
	      Browse button

       Module Path:
	      The location in the repository tree where	 the  existing	module
	      is. Filled in by the use of the Browse button.

       Version Number:
	      The  current  version  number of the module to be	imported. This
	      should be	a number of the	form X.Y.Z where .Y  and  .Z  are  op-
	      tional.  You  can	leave this blank, in which case	1 will be used
	      as the first version number.

Vendor Merge (CVS)
       Software	development is sometimes based on source distribution  from  a
       vendor  or  third-party	distributor. After building a local version of
       this distribution, merging or tracking the vendor's future release into
       the local version of the	distribution can be done with the vendor merge
       command.

       The vendor merge	command	assumes	that a	separate  module  has  already
       been defined for	the vendor or third-party distribution with the	use of
       the  "Import  To	 A New Module" and "Import To An Existing Module" com-
       mands. It also assumes that a separate module has already been  defined
       for  the	 local	code for which the vendor merge	operation is to	be ap-
       plied to.

       Start from an empty directory and invoke	tkcvs. Open up the  Repository
       Browser by selecting File/Browse	Modules	from the menu bar.

       Checkout	 the  module  of the local code	to be merged with changes from
       the vendor module. (Use the red icon with the down arrow)

       In the Repository Browser, after	verifying that the  Module  entry  box
       still  has  the	name  the module of the	local code to which the	vendor
       code is to be merged into, select File/Vendor Merge from	the menu bar.

       In the Module Level Merge With Vendor Code  window,  press  the	Browse
       button to select	the module to be used as the vendor module.

       OK  the	dialog.	 All revisions from the	vendor module will be shown in
       the two scroll lists. Fill in the From and To entry boxes  by  clicking
       in the appropriate scroll lists.	 Ok the	dialog.	Several	things happens
       now.  Several  screens will appear showing the output from cvs commands
       for (1)checking out temp	files, (2)cvs merge, and (3)cvs	rdiff.	Infor-
       mation  in  these  screens  will	tell you what routines will have merge
       conflicts and what files	are new	or deleted. After perusing the	files,
       close  each screen. .TP (In the preceeding dialog box, there was	an op-
       tion to save outputs from the merge and rdiff operations	to files  CVS-
       merge.out and CVSrdiff.out.)

       The  checked  out  local	code will now contain changes from a merge be-
       tween two revisions of the  vendor  modules.  This  code	 will  not  be
       checked	into  the  repository. You can do that after you've reconciled
       conflicts and decide if that is what you	really want.

       A detailed example on how to use	the vendor merge operation is provided
       in the PDF file vendor5readme.pdf.

Configuration Files
       There are two configuration files for TkCVS. The	first is stored	in the
       directory in which the *.tcl files for TkCVS  are  installed.  This  is
       called tkcvs_def.tcl. You can put a file	called site_def	in that	direc-
       tory,  too.  That's  a  good  place  for	site-specific things like tag-
       colours.	Unlike tkcvs_def.tcl, it will not be overwritten when you  in-
       stall a newer version of	TkCVS.

       Values  in  the site configuration files	can be over-ridden at the user
       level by	placing	a .tkcvs file in your home directory. Commands in  ei-
       ther  of	 these	files  should use Tcl syntax. In other words, to set a
       variable	name, you should have the following  command  in  your	.tkcvs
       file:

		  set variablename value

       for example:

		  set cvscfg(editor) "gvim"

       The following variables are supported by	TkCVS:

   Startup
       cvscfg(startwindow)
	      Which window you want to see on startup. (workdir	or module)

   CVS
       cvscfg(cvsroot)
	      If set, it overrides the CVSROOT environment variable.

   Subversion
       If  your	SVN repository has a structure similar to trunk, branches, and
       tags but	with different names, you can tell TkCVS about it  by  setting
       variables in tkcvs_def.tcl:
	   set cvscfg(svn_trunkdir) "elephants"
	   set cvscfg(svn_branchdir) "dogs"
	   set	cvscfg(svn_tagdir)  "ducklings"	 The branch browser depends on
       the convention of having	a trunk, branches, and tags structure to  draw
       the diagram.  These variables may give you a little more	flexibility.

   GIT
       cvscfg(gitdetail)
	      Set  to true or false. If	it's false (off) an individual git log
	      call to each file	will be	suppressed to save time. You won't see
	      the hashtag or committer in that case.

       cvscfg(gitmaxhist)
	      For the branch visualizer. Tells how far back into  the  history
	      to go. Default is	250 commits.

   GUI
       Most  colors and	fonts can be customized	by using the options database.
       For example, you	can add	lines like these to your .tkcvs	file:

		 option	add *Canvas.background #c3c3c3
		 option	add *Menu.background #c3c3c3
		 option	add *selectColor #ffec8b
		 option	add *Text.background gray92
		 option	add *Entry.background gray92
		 option	add *Listbox.background	gray92
		 option	add *ToolTip.background	LightGoldenrod1
		 option	add *ToolTip.foreground	black

       cvscfg(picklist_items)
	      Maximum number of	visited	directories and	repositories  to  save
	      in the picklist history

   Log browser
       cvscfg(colourA) cvscfg(colourB)
	      Hilight colours for revision-log boxes

       cvscfg(tagdepth)
	      Number  of tags you want to see for each revision	on the branch-
	      ing diagram before it says "more..." and offers a	pop-up to show
	      the rest

       cvscfg(toomany_tags)
	      Number of	tags in	a Subversion repository	that's "too many", ie.
	      will take	longer to proecess for the branch diagram than	you're
	      willing  to  wait.  (Building a branch diagram for Subversion is
	      very inefficient.) If  there  are	 more  than  that  number  and
	      cvscfg(confirm_prompt)  is  true,	 a  dialog  will appear	asking
	      whether to process the tags or to	draw the diagram without them.

       cvscfg(tagcolour,tagstring)
	      Colors for marking tags. For example:
		  set cvscfg(tagcolour,tkcvs_r6) Purple

   Module browser
       cvscfg(aliasfolder)
	      In the CVS module	browser, if true this  will  cause  the	 alias
	      modules  to be grouped in	one folder. Cleans up clutter if there
	      are a lot	of aliases.

   User	preferences
       cvscfg(allfiles)
	      Set this to false	to see normal  files  only  in	the  directory
	      browser. Set it to true to see all files including hidden	files.

       cvscfg(auto_status)
	      Set the default for automatic status-refresh of a	CVS controlled
	      directory.  Automatic  updates  are done when a directory	is en-
	      tered and	after some operations.

       cvscfg(auto_tag)
	      Whether to tag the merged-from  revision	when  using  TkCVS  to
	      merge  different	revisions of files by default.	A dialog still
	      lets you change your mind, regardless of the default.

       cvscfg(confirm_prompt)
	      Ask for confirmation  before  performing	an  operation(true  or
	      false)

       cvscfg(dateformat)
	      Format for the date string shown in the "Date" column, for exam-
	      ple "%Y/%m/%d %H:%M"

       cvscfg(cvslock)
	      Set to true to turn on the ability to use	cvs-admin locking from
	      the GUI.

       cvscfg(econtrol)
	      Set  this	 to  true  to  turn on the ability to use CVS Edit and
	      Unedit, if your site is configured to allow the feature.

       cvscfg(editor)
	      Preferred	default	editor

       cvscfg(editors)
	      String pairs giving the editor-command and string-match-pattern,
	      for deciding which editor	to use

       cvscfg(editorargs)
	      Command-line arguments to	send to	the default editing program.

       cvscfg(mergetoformat)

       cvscfg(mergefromformat)
	      Format for mergeto- and mergefrom- tags.	The _BRANCH_ part must
	      be left as-is, but you can change	the prefix and the  date  for-
	      mat,  for	example	"mergeto_BRANCH_%d%b%y".  The date format must
	      be the same for both.  CVS rule: a  tag  must  not  contain  the
	      characters `$,.:;@'

       cvscfg(recurse)
	      Whether reports are recursive (true or false)

       cvscfg(savelines)
	      How many lines to	keep in	the trace window

       cvscfg(status_filter)
	      Filter out unknown files (status "?") from CVS Check and CVS Up-
	      date reports.

       cvscfg(use_cvseditor)
	      Let  CVS	invoke	an  editor for commit log messages rather than
	      having tkcvs use its own input box.  By doing this, your	site's
	      commit template (rcsinfo)	can be used.

   File	filters
       cvscfg(show_file_filter)
	      Pattern  for  which files	to list. Empty string is equivalent to
	      the entire directory (minus hidden files)

       cvscfg(ignore_file_filter)
	      Pattern used in the workdir filter for files to be ignored

       cvscfg(clean_these)
	      Pattern to be used for cleaning a	directory  (removing  unwanted
	      files)

   System
       cvscfg(print_cmd)
	      System command used for printing.	lpr, enscript -Ghr, etc)

       cvscfg(shell)
	      What you want to happen when you ask for a shell

       cvscfg(terminal)
	      Command prefix to	use to run something in	a terminal window

   Portability
       cvscfg(aster)
	      File mask	for all	files (* for Unix, *.* for windows)

       cvscfg(null)
	      The null device. /dev/null for Unix, nul for windows

       cvscfg(tkdiff)
	      How to start tkdiff. Example sh /usr/local/bin/tkdiff

       cvscfg(tmpdir)
	      Directory	 in  which  to do behind-the-scenes checkouts. Usually
	      /tmp or /var/tmp)

   Debugging
       cvscfg(log_classes)
	      For debugging: C=CVS commands, E=CVS stderr output, F=File  cre-
	      ation/deletion, T=Function entry/exit tracing, D=Debugging

       cvscfg(logging)
	      Logging (debugging) on or	off

Environment Variables
       You  should have	the CVSROOT environment	variable pointing to the loca-
       tion of your CVS	repository before you run TkCVS. It will  still	 allow
       you to work with	different repositories within the same session.

       If  you	wish TkCVS to point to a Subversion repository by default, you
       can set the environment variable	SVNROOT.  This has no meaning to  Sub-
       version	itself,	 but  it will clue TkCVS if it's started in an un-ver-
       sioned directory.

User Configurable Menu Extensions
       It is possible to extend	the TkCVS menu by  inserting  additional  com-
       mands  into  the	.tkcvs or tkcvs_def.tcl	files. These extensions	appear
       on an extra menu	to the right of	the TkCVS Options menu.

       To create new menu entries on the user-defined menu, set	the  following
       variables:

   cvsmenu(command)
       Setting	a variable with	this name to a value like "commandname"	causes
       the CVS command "cvs commandname" to be run when	this  menu  option  is
       selected. For example, the following line:

		  set cvsmenu(update_A)	"update	-A"

       Causes  a new menu option titled	"update_A" to be added to the user de-
       fined menu that will run	the command "cvs update	-A"  on	 the  selected
       files when it is	activated.

       (This  example  command,	for versions of	CVS later than 1.3, will force
       an update to the	head version of	a file,	ignoring any  sticky  tags  or
       versions	attached to the	file).

   usermenu(command)
       Setting	a variable with	this name to a value like "commandname"	causes
       the command "commandname" to be run when	this menu option is  selected.
       For example, the	following line:

		  set usermenu(view) "cat"

       Causes  a new menu option titled	"view" to be added to the User defined
       menu that will run the command "cat" on the selected files when	it  is
       activated.

       Any  user-defined  commands  will be passed a list of file names	corre-
       sponding	to the files selected on the directory	listing	 on  the  main
       menu as arguments.

       The  output  of the user	defined	commands will be displayed in a	window
       when the	command	is finished.

CVS Modules File
       If you haven't put anything in your CVSROOT/modules file, please	do so.
       See the "Administrative Files" section of the CVS manual. Then, you can
       add comments which TkCVS	can use	to title the modules  and  to  display
       them in a tree structure.

       The  simplest  use of TkCVS's "#D" directive is to display a meaningful
       title for the module:

	      #D      softproj	      Software Development Projects
	      softproj softproj

       A fancier use is	to organize the	modules	into a tree which  will	 mimic
       their  directory	nesting	in the repository when they appear in the mod-
       ule browser. For	example, suppose we have a  directory  called  "choco-
       late" which is organized	like this:

	      chocolate/
		  truffle/
		      cocoa3/
			  biter/
			  sniffer/
			  snuffler/

       To  display its hierarchy, as well as make the deepest directories more
       accessible by giving them module	names, we could	put this in  the  mod-
       ules file:

	      #D   chocolate Top Chocolate
	      #D   chocolate/truffle   Cocoa Level 2
	      #D   chocolate/truffle/cocoa3 Cocoa Level	3
	      #D   sniffer   Chocolate Sniffer
	      sniffer	chocolate/truffle/cocoa3/sniffer
	      #D   snuff     Chocolate Snuffler
	      snuff	chocolate/truffle/cocoa3/snuffler
	      #D   biter     Chocolate Biter
	      biter	chocolate/truffle/cocoa3/biter

       When  you  are  installing  TkCVS, you may like to add these additional
       lines to	the modules file (remember to check  out  the  modules	module
       from  the  repository,  and then	commit it again	when you have finished
       the edits).

       These extension lines commence with a "#" character, so CVS  interprets
       them  as	 comments. They	can be safely left in the file whether you are
       using TkCVS or not.

       "#M" is equivalent to "#D". The two had different functions in previous
       versions	of TkCVS, but now both are parsed the same way.

SEE ALSO
       cvs(1), svn(1)

AUTHOR
       Del  (del@babel.babel.com.au):  Maintenance  and	 Subversion   support:
       Dorothy Robinson

9.3.3				    Release			      TkCVS(1)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=tkcvs&sektion=1&manpath=FreeBSD+Ports+15.0>

home | help