So, in the last couple of weeks I tried to look up material about Docbook.
I'm still not sure about how you people edit the help files, and I'd
obviously prefer a more wysiwg way of doing things, but for now I'll settle
for XML-aware editors. I downloaded the repository to my Linux volume but
I'm more comfortable working on Windows so I'm using Notepad++ for editing
and XMLnotepad to validate the XML.
Docbook seems straightforward enough but I do have some questions: what is
the significance of adding "acronym" and "quote" tags? what are they for?
they seem to have no influence on the final output.

Anyway here is my first change: I took the concepts page and added a
much-needed "Resolution" section. I know from experience this is a term that
many beginners find difficult to understand, especially when it comes to
understanding the resolution property of files coming from digital cameras.
I also removed the comparison of a multi-layer image to a book: it is a
confusing metaphor as it is nothing like a book in reality, so I changed it
to a stack of transparent sheets of paper.

Lastly, how important is the way these files are indented? I always use
tabs, and any editor I'm familiar with uses tabs to indent lines, while
these files seem to use spaces. Is is important to indent the XML in this

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
<!-- section history:
  2009-03-20 j.h: fixed bug #557343
  2008-06-03 prokoudine: yet another shot at Russian content
  2007-02-27 prokoudine: fixes to Russian translation
  2007-02-27 lexa: reorganized concepts
  2006-05-02 Dust: added Korean translation
  2006-02-27 kolbjørn: added norwegian
  2006-01-07 HdJ: Added quote and acronym tags, added english and dutch
             version of layers explanation
  2005-12-18 Lexa: reviewed and added de translation
<sect1 xmlns:xi=""; id="gimp-concepts-basic">
  <title>Basic Concepts</title>


    <title>Wilber, the GIMP mascot</title>
        <imagedata format="PNG" fileref="images/using/wilber.png" />
          The Wilber_Construction_Kit (in src/images/) allows you to give the
          mascot a different appearance. It is the work of Tuomas Kuosmanen
    This section provides a brief introduction to the basic concepts and
    terminology used in <acronym>GIMP</acronym>. The concepts presented here
    are explained in
    much greater depth elsewhere. With a few exceptions, we have avoided
    cluttering this section with a lot of links and cross-references:
    everything mentioned here is so high-level that you can easily
    locate it in the index.
			 Images are the basic entities used by <acronym>GIMP</acronym>. 
			Roughly speaking, an <quote>image</quote> corresponds to a single file, 
			such as a TIFF or JPEG file. You can also think of an image as 
			corresponding to a single display window (although in truth it is 
			possible to have multiple windows all displaying the same image). It is 
			not possible to have a single window display more than one image, 
			though, or for an image to have no window displaying it. 
			A <acronym>GIMP</acronym> image may be quite a complicated thing. 
			Instead of thinking of it as a sheet of paper with a 
			picture on it, think of it as more like a stack of sheets, called 
			<quote>layers</quote>. In addition to a stack of layers, a 
			<acronym>GIMP</acronym> image may contain a selection mask, a set of 
			channels, and a set of paths. In fact, <acronym>GIMP</acronym> provides 
			a mechanism for attaching arbitrary pieces of data, called 
			<quote>parasites</quote>, to an image. 
          In <acronym>GIMP</acronym>, it is possible to have many images open
          at the same time. Although large images may use many megabytes of
          memory, <acronym>GIMP</acronym> uses a sophisticated
          tile-based memory management system that allows
          <acronym>GIMP</acronym> to handle very large images gracefully.
          There are limits, however, and having more memory available
          may improve system performance.
		 If a simple image can be compared to a single sheet of paper, an image 
		with layers is likened to a sheaf of transparent papers stacked one on 
		top of the other. You can draw on each paper, but still see the contant 
		of the other sheets through the transparent areas. You can also move one 
		sheet in relation to the others. 
		Sophisticated <acronym>GIMP</acronym> users often deal with images 
		containing many layers, even dozens of them. Layers need not be opaque, 
		and they need not cover the entire extent of an image, so when you 
		look at an image's display, you may see more than just the top 
		layer: you may see elements of many layers. 

		Digital images comprise of a grid of square elements of varying colors, 
		called pixels. Each image has a pixel size, such as 900 pixels wide by 
		600 pixels high. But pixels don't have a set size in physical space. To 
		set up an image for printing, we use a value called resolution, defined 
		as the ratio between an image's size in pixels and its physical size 
		(usualy in inches) when it is printed on paper. Most file formats (but 
		not all) can save this value, which is expressed as ppi - pixels per 
		inch. When printing a file, the resolution value determines the size the 
		image will have on paper, and as a result, the physucal size of the 
		pixels. The same 900X600 pixel image may be printed as a small 2X3" card 
		with barely noticable pixels - or as a large poster with large, chunky 
		pixels. Images imported from cameras and mobile devices tend to have a 
		resolution value attached to the file. The value is usually 72 or 96ppi. 
		It is important to realize that this value is arbitrary and was chosen 
		for historic reasons. You can always change the resolution value inside 
		<acronym>GIMP</acronym> - this has no effect on the actual image pixels. 
		Furthermore, for uses such as displaying images on line, on mobile 
		devices, television or video games - in short, any use that is not print 
		- the reslution value is meaningless and is ignored, and instead the 
		image is usually displayed so that each image pixel conforms to one 
		screen pixel. 

   <varlistentry id="gimp-concepts-channels" xreflabel="Channels">
        <!--TRANSLATORS: this is the modified text from glossary.xml, so
        you should check po/LANG/glossary.po for an old translation-->
          A Channel is a single component of a pixel's color. For a colored
          pixel in <acronym>GIMP</acronym>, these components are usually Red,
          Green, Blue and sometimes transparency (Alpha). For a
          <link linkend="glossary-graylevel">Grayscale</link> image, they are
          Gray and Alpha and for an
          <link linkend="glossary-indexedcolors">Indexed</link> color image,
          they are Indexed and Alpha.
          The entire rectangular array of any one of the color components for
          all of the pixels in an image is also referred to as a Channel. You
          can see these color channels with the
          <link linkend="gimp-channel-dialog">Channels dialog</link>.
          When the image is displayed, <acronym>GIMP</acronym> puts these
          components together to form the pixel colors for the screen,
          printer, or other output device. Some output devices may use
          different channels from Red, Green and Blue. If they do,
          <acronym>GIMP</acronym>'s channels are converted into the
          appropriate ones for the device when the image is displayed.
          Channels can be useful when you are working on an image which needs
          adjustment in one particular color. For example, if you want to
          remove <quote>red eye</quote> from a photograph, you might work on
          the Red channel.
          You can look at channels as masks which allow or restrict the output
          of the color that the channel represents. By using Filters on the
          channel information, you can create many varied and subtle effects
          on an image. A simple example of using a Filter on the color
          channels is the
          <link linkend="plug-in-colors-channel-mixer">Channel Mixer</link>
          In addition to these channels, <acronym>GIMP</acronym> also allows
          you to create other channels (or more correctly, Channel Masks),
          which are displayed in the lower part of the Channels dialog. You
          can create a <link linkend="gimp-channel-new">New Channel</link> or
          save a <link linkend="gimp-selection-to-channel">selection to a
          channel (mask)</link>.
          See the glossary entry on
          <link linkend="glossary-masks">Masks</link> for more information
          about Channel Masks.
          Often when modify an image, you only want a part of the image
          to be affected. The <quote>selection</quote>
          mechanism makes this possible. Each image has its own selection,
          which you normally see as a moving dashed line separating the
          selected parts from the unselected parts (the so-called
          <quote>marching ants</quote> ). Actually this is a bit misleading:
          selection in <acronym>GIMP</acronym>
          is graded, not all-or-nothing, and really the selection is
          represented by a full-fledged grayscale channel. The dashed line
          that you normally see is simply a contour line at the 50%-selected
          level. At any time, though, you can visualize the selection channel
          in all its glorious detail by toggling the
          <link linkend="gimp-image-window-qmask-button">QuickMask</link>
          A large component of learning how to use <acronym>GIMP</acronym>
          effectively is acquiring the art of making good
          selections—selections that contain exactly what you need and nothing
          more. Because selection-handling is so centrally important,
          <acronym>GIMP</acronym> provides many tools for doing
          it: an assortment of selection-making tools, a menu of selection
          operations, and the ability to switch to Quick Mask mode, in which
          you can treat the selection channel as though it were a color
          channel, thereby <quote>painting the selection</quote>.
          When you make mistakes, you can undo them. Nearly everything you can
          do to an image is undoable. In fact, you can usually undo a
          substantial number of the most recent things you did, if you decide
          that they were misguided. <acronym>GIMP</acronym> makes this
          possible by keeping a history of your actions. This history consumes
          memory, though, so undoability is not infinite. Some actions use
          very little undo memory, so that you can do dozens of them before
          the earliest ones are deleted from this history; other types of
          actions require massive amounts of undo memory. You can configure
          the amount of memory <acronym>GIMP</acronym> allows for the undo
          history of each image, but in any situation, you should always be
          able to undo at least your 2-3 most recent actions. (The most
          important action that is not undoable is closing an image. For this
          reason, <acronym>GIMP</acronym> asks you to confirm that you really
          want to close the image if you have made any changes to it.)
          Many, probably most, of the things that you do to an image in
          <acronym>GIMP</acronym> are done by the <acronym>GIMP</acronym>
          application itself. However, <acronym>GIMP</acronym> also makes
          extensive use of <quote>plug-ins</quote>, which are external programs
          that interact very closely with <acronym>GIMP</acronym>, and are
          capable of manipulating images and other <acronym>GIMP</acronym>
          objects in very sophisticated ways. Many important plug-ins are
          bundled with <acronym>GIMP</acronym>, but there are also
          many available by other means. In fact, writing
          plug-ins (and scripts) is the easiest way for people not on the
          <acronym>GIMP</acronym> development team to add new capabilities to
          All of the commands in the Filters menu, and a substantial number of
          commands in other menus, are actually implemented as plug-ins.
          In addition to plug-ins, which are programs written in the C
          language, <acronym>GIMP</acronym> can also make use of scripts. The
          largest number of
          existing scripts are written in a language called Script-Fu, which
          is unique to <acronym>GIMP</acronym> (for those who care, it is a
          dialect of the
          Lisp-like language called Scheme). It is also possible to write
          scripts in Python or Perl. These languages are more flexible and
          powerful than Script-Fu; their disadvantage is that they depend on
          software that does not automatically come packaged with
          <acronym>GIMP</acronym>, so
          they are not guaranteed to work correctly in every
Gimp-docs mailing list

Reply via email to