LinuxParty

When es un programa de calendario personal extremadamente sencillo, dirigido al geek de Unix que quiere algo minimalista. Se puede realizar un seguimiento de las cosas que hay que hacer en fechas concretas. Dispone de calendario y "Administrador de información personal", así que ¿Por qué no usar When?

• Es un programa muy corto y simple, por lo que fácilmente puede ponerse a jugar con él.
• No depende de ninguna biblioteca, así que es fácil de instalar. Usted debe ser capaz de instalarlo en cualquier sistema que tenga Perl disponible, incluso si usted no tiene los privilegios para la instalación de bibliotecas.
• Su formato de archivo es un archivo de texto simple, que se puede editar en su editor favorito.

instrucciones genéricas para la instalación de When

Código fuente: when.tar.gz

Si decide instalar:

sudo make install

Ejecutar:

when

Para probar (mientras decida no instalar)

Ejecutar (en el directorio de descarga):

./when

github

No se requieren bibliotecas. Descargar el código fuente, y luego haga lo siguiente:

 tar -zxvf when.tar.gz
  cd when_dist
  make install

Debian

genérico paquete debian

Ubuntu

Puede instalar el programa simplemente al activando el repositorio "universal" y luego hacer un "apt-get install when".

Paquete Gentoo

app-misc/when

FreeBSD puerto

deskutils/when

Zenwalk y Slackware

package

Red Hat

Cuando lo he probado en Fedora Core 3 (funciona en Fedora 17 y 18), funcionaba bien. Sin embargo, he tenido reportes de usuarios que lo ejecutan Red Hat 9.0 y no funciona en sus sistemas, dando el mensaje de "error de sintaxis en el calendario". Esto parece ser un problema con la forma en que Red Hat 9.0 y Perl 5.8.0 interactuan con respecto a UTF8 y la internacionalización, y probablemente puede ser resuelto mediante la actualización a una versión más reciente de Perl.

cómo ayudar

Cualquiera de las siguientes contribuciones se aceptó con agradecimiento:

• Traducir a otros idiomas.
• Pon a prueba mi solución sugerida (mejora Perl) para el problema con Red Hat 9.0.
• Escribir programas externos para convertir desde y hacia formatos iCalendar y vCalendar.

página de manual

ORIGINAL EN INGLÉS

glubba
WHEN(1)                           When 1.1.31                          WHEN(1)



NAME
       When - a minimalistic personal calendar program

SYNOPSIS
       when

       when [options] [commands]

       The basic idea is just to type `when' at the command line. The first
       time you run the program, it will prompt you for some setup
       information. To edit you calendar file in your favorite editor, do
       `when e'. The basic format of the calendar file is like this:

               2003 feb 3 , Fly to Stockholm to accept Nobel Prize.

       Once you have a calendar file, running the program as plain old `when'
       from the command line will print out the things on your calendar for
       the next two weeks.

COMMANDS
       i       Print upcoming items on your calendar. (This is the default
               command.)

       c       Print calendars (grids like on a wall calendar, not showing
               items) for last month, this month, and next month.

       e       Invoke your favorite editor to edit your calendar file.

       w,m,y   Print items for the coming week, month, or year, rather than
               for the default period of two weeks.

       j       Print the modified Julian day (useful for finding the time
               interval between two dates).

       d       Print nothing but the current date.

OPTIONS
       All of the following options, except --help, can be set in the
       preferences file. True/false options can be set on the command line as
       --option or --nooption, and in the preferences file by setting the
       option to 0 or 1.

       --help  Prints a brief help message.

       --version
               Prints a brief message, including a statement of what version
               of the software it is.

       --language=LANG
               Set the language to LANG. See the section below on
               internationalization.  This option is not normally needed,
               because the language is automatically detected.

       --future=DAYS
               How many days into the future the report extends. Default: 14

       --past=DAYS
               How many days into the past the report extends. Like the
               --future option, --past is interpreted as an offset relative to
               the present date, so normally you would want this to be a
               negative value. Default: -1

       --calendar=FILE
               Your calendar file. The default is to use the file pointed to
               by your preferences file, which is set up the first time you
               run When.

       --editor=COMMAND
               Command used to invoke your editor. Default: "emacs -nw"
               Example:  when --editor="vim"

       --wrap=COLUMNS
               Number of columns of text for the output (or 0 if you don't
               want wrapping at all). Default: 80

       --[no]wrap_auto
               Attempt to detect the width of the terminal, and set the width
               of the output accordingly. This applies only if the output is a
               tty, and is subject to any maximum set by --wrap_max. Overrides
               any value set by --wrap. Default: no

       --wrap_max=COLUMNS
               Maximum number of columns of text for the output (or -1 if you
               don't want any maximum). Useful in combination with --wrap_auto
               to preserve legibility on very large terminal windows. Default:
               -1

       --rows=COLUMNS
               Number of rows of text that will fit in the terminal window.
               When listing your calendar, output will be truncated to this
               length, unless that would result in listing less than three
               days into the future. This behavior is overridden (the maximum
               number of rows is set to infinity) if the --future option is
               given explicitly, or if the m or y command is used.  Default:
               40

       --[no]rows_auto
               Attempt to detect the height of the terminal, rather than using
               the value set in the --rows option. This applies only if the
               output is a tty.  Overrides any value set by --rows. Default:
               yes

       --[no]header
               Print headers at the top of the output of the i, c, w, m and y
               commands.  Default: yes

       --[no]paging
               When the output is longer than the value set by rows or
               rows_auto, use a pager to display the output. (The PAGER and
               LESS environment variables are respected. If PAGER isn't set,
               the default is "less.") Default: yes

       --paging_less_options
               Extra options if the pager is "less." Default: "-rXFE"

       --[no]filter_accents_on_output
               Whether to change accented characters to unaccented ones.
               Default: yes, unless the $TERM environment variable equals
               "mlterm" or "xterm".

       --[no]styled_output
               If the output is a terminal, should we use ANSI terminal codes
               for styling? Default: yes

       --[no]styled_output_if_not_tty
               Style the output even if it's not a terminal. Default: no

       --calendar_today_style=STYLE
       --items_today_style=STYLE
               The first of these says how to style today's date when doing
               the calendar (c) command.  The second says how to style the
               word ``today'' when doing the items (i) command.  Defaults:
               bold

               The styling of output can be specified using the following
               keywords: bold, underlined, flashing.  To change the color of
               the text, use these: fgblack, fgred, fggreen, fgyellow, fgblue,
               fgpurple, fgcyan, fgwhite.  To change the background color, use
               similar keywords, but with bg instead of fg. Example: when
               --calendar_today_style="bold,fgred,bgcyan" c

       --prefilter
               Pipe the calendar file through a program before reading it.
               Default: ""

       --now="Y M D"
               Pretend today is some other date.

       --[no]neighboring_months
               The default behavior of "when c" is to print out calendars for
               last month, this month, and next month. By choosing
               --noneighboring_months, you can avoid printing out months not
               included in the range set by --past and --future.

       --[no]monday_first
               Start the week from Monday, rather than Sunday. Default: no

       --[no]orthodox_easter
               Calculate Easter according to the Orthodox Eastern Church's
               calendar. Default: no

       --[no]ampm
               Display the time of day using 12-hour time, rather than 24-hour
               time. Also affects the parsing of input times.  Default: yes

       --auto_pm=x
               When times are input with hours that are less than x, and AM or
               PM is not explicitly specified, automatically assume that they
               are PM rather than AM. Default: 0

       --[no]literal_only
               Only display items that are given as literal dates, e.g., "2008
               jul 4". Don't display items that are defined by expressions,
               e.g., periodic items like "w=thu". Default: no

       --test_expression
       --bare_version
       --make_filter_regex
       --test_accent_filtering
               These options are used internally for building and testing.

DESCRIPTION
       When is an extremely simple personal calendar program, aimed at the
       Unix geek who wants something minimalistic. It can keep track of things
       you need to do on particular dates. There are a lot of calendar and
       ``personal information manager'' programs out there, so what reasons
       are there to use When?

       It's a very short and simple program, so you can easily tinker with it
       yourself.
       It doesn't depend on any libraries, so it's easy to install. You should
       be able to install it on any system where Perl is available, even if
       you don't have privileges for installing libraries.
       Its file format is a simple text file, which you can edit in your
       favorite editor.

       Although When should run on virtually any operating system where Perl
       is available, in this document I'll assume you're running some flavor
       of Unix.

INSTALLATION AND GETTING STARTED
       While logged in as root, execute the following command:

              make install

       Run When for the first time using this command:

              when

       You'll be prompted for some information needed to set up your calendar
       file.

USE
       If you run When again after the initial setup run, it should print out
       a single line of text, telling you the current date. It won't print out
       anything else, because your calendar file is empty, so you don't have
       any appointments coming up.

       Now you can start putting items in your calendar file. Each item is a
       line of text that looks like this:

               2003 feb 3 , Fly to Stockholm to accept Nobel Prize.

       A convenient way to edit your calendar file is with this command:

               when e

       This pops you into your favorite editor (the one you chose when you ran
       When for the first time).

       The date has to be in year-month-day format, but you can either spell
       the month or give it as a number. (Month names are case-insensitive,
       and it doesn't matter if you represent February as F, Fe, Feb, Februa,
       or whatever.  It just has to be a unique match. You can give a trailing
       ., which will be ignored. In Czech, "cer" can be used as an
       abbreviation for Cerven, and "cec" for Cervenec.) Extra whitespace is
       ignored until you get into the actual text after the comma. Blank lines
       and lines beginning with a # sign are ignored.

       If you now run When, it will print out a list of all the items in your
       calendar file that fall within a certain time interval. (The interval
       starts from yesterday. When tries to pick the end of the time interval
       so that its output fits on your terminal window, but it will always be
       at least three days, and no more than two weeks in the future.)  To see
       all your items for the next month, do ``when m'', and similarly for a
       year, y, or a single week, w.

       If you do ``when c'', When prints out calendars for last month, this
       month, and next month.

       You can combine these commands. For instance, ``when cw'' will print
       out calendars, and then show you your items for the next week.

       For events that occur once a year, such as birthdays and annivesaries,
       you can either use a * in place of the year,

               * dec 25 , Christmas

       or use a year with an asterisk:

               1920* aug 29 , Charlie Parker turns \a, born in \y

       In the second example, \a tells you how old Charlie Parker would be
       this year, and \y reproduces the year he was born, i.e., the output
       would be:

               today     2003 Aug 29 Charlie Parker turns 83, born in 1920

       For things you have to do every week, you can use an expression of the
       form w=xxx, where xxx is the first few letters of the name of the day
       of the week in your language. (You have to supply enough letters to
       eliminate ambiguity, e.g., in English, w=th or w=tu, not just w=t.)
       Example:

               w=sun , go to church, 10:00

       You can actually do fancier tests than this as well; for more
       information, see the section 'fancy tests' below.  Here's how to set up
       some common holidays:

               m=jan & w=mon & a=3 , Martin Luther King Day
               * feb 14 , Valentine's Day
               m=feb & w=mon & a=3 , Washington's Birthday observed
               m=may & w=sun & a=2 , Mother's Day
               m=may & w=mon & b=1 , Memorial Day
               m=jun & w=sun & a=3 , Father's Day
               * jul 4 , Independence Day
               m=sep & w=mon & a=1 , Labor Day
               m=oct & w=mon & a=2 , Columbus Day
               m=oct & w=mon & a=2 , Thanksgiving (Canada)
               * nov 11 , Armistice Day
               m=nov & w=thu & a=4 , Thanksgiving (U.S.)
               e=47 , Mardi Gras
               e=46 , Ash Wednesday
               e=7 , Palm Sunday
               e=0 , Easter Sunday
               e=0-49 , Pentecost (49 days after easter)

       In the U.S., when certain holidays fall on a weekend, federal workers,
       as well as many private employees, get a Monday or Friday off. The full
       list is given at
       http://www.opm.gov/operating_status_schedules/fedhol/2011.asp.  If you
       want a reminder of both the holiday and the day you get off from work,
       here's an example of how you would set that up:

               * jul 4 , Independence Day
               m=jul & c=4 , Independence Day (observed as a federal holiday)

INTERNATIONALIZATION
       When has at least partial support for Czech, Danish, Dutch, English,
       French, German, Greek, Hungarian, Italian, Polish, Romanian, and
       Spanish.  If When has not been translated into your language, or has
       only been partially translated, the text that hasn't been translated
       will be displayed in English.  When should automatically detect what
       language you use (via your $LANG environment variable), and if When has
       been translated into that language, that's what you'll get -- When's
       output will be in your language, and When will also expect you to use
       that language in your calendar file for the names of the months and the
       days of the week.

       Your calendar file must be in UTF-8 (or ASCII, which is a subset of
       UTF-8).  If your calendar file is in some other encoding, such as
       ISO-8859, When will typically be able to detect that, and will refuse
       to read it.  Command-line options can also contain UTF-8.

       Some terminal emulators (aterm, ...) display accented characters as
       garbage, but others (mlterm, xterm...) can display them correctly.
       When checks the $TERM environment variable, and if it equals "mlterm"
       or "xterm", then accented characters will be displayed. Otherwise, they
       are filtered out of the output.  You can override this by putting a
       line like

               filter_accents_on_output = 0

       or

               filter_accents_on_output = 1

       in your ~/.when/preferences file. I'd be interested in hearing from any
       users who can suggest a better mechanism for this than attempting to
       interpret the $TERM variable.

       On input, accents are allowed, but not required, e.g., in a French-
       language input file, the date 2005 Fev 17 could be given with an
       accented e or an unaccented one, and either will work. If an input
       month or day of the week does not match any of the ones for your
       language, then When will try to interpret it as English instead.

       You can put a line like

               language = fr

       in your preferences file to set your language, or supply the --language
       option on the command line, but that's not necessary if your $LANG
       environment variable is set correctly.

FORMAT OF THE PREFERENCES FILE
       Each line consists of something like this:

               variable = value

       Whitespace is ignored everywhere except inside the value. Variable
       names are case-insensitive. Blank lines are ignored.

MORE EXAMPLES
       A useful command to have your shell execute when you log in is this:

               when --past=0 --future=1

       To print out a calendar for a full year to come:

               when --past=0 --future=365 c

POPPING UP YOUR CALENDAR WHEN YOU LOG IN
       Your calendar doesn't do you any good if you forget to look at it every
       day. An easy way to make it pop up when you log in is to make your
       .xsession or .xinitrc file look like this:

               /usr/bin/when --past=0 --future=1 &>~/when.today
               emacs -geometry 70x25 -bg bisque ~/when.today &
               startkde

       The .xsession file is used if you have a graphical login manager set up
       on your machine, the .xinitrc if you don't. In this example, the first
       line outputs your calendar to a file. The complete path to the When
       program is given, because your shell's path variable will not yet be
       properly initialized when this runs. The second line pops up a GUI
       emacs window, which is distinctively colored so that it will catch your
       eye. The last line starts your window manager, KDE in this example.
       Whatever window manager you use, just make sure to retain the
       preexisting line in the file that starts it, and make sure that that
       line is the very last one in the file.

SORTING BY TIME OF DAY
       If you want the various items that lie on a single day to be printed
       out in a certain order, the simplest way to do it is to put them in
       that order in the input file. That method won't work, however, when
       some of the items lie on dates that are determined by expressions
       rather than given explicitly. The most common reason for wanting to do
       this kind of thing is that you have things you need to do at certain
       times during the day, and you want them sorted out by time. In this
       situation, you can give a time at the beginning of the item's text, and
       When will recognize that and sort the items by time. Times can be in
       h:mm or hh:mm format. If --ampm is set, then an optional suffix a or p
       can be used for AM or PM, e.g., 9:30a for 9:30 AM. If you use AM/PM
       time, then you can also, e.g., set --auto_pm=9 so that hours less than
       9 are automatically assumed to be PM. Here is an example:

               2010 apr 25 , 7:00 dinner at the anarcho-syndicalist commune
               w=sun , 10:00 church

       April 25, 2010 is a Sunday, so on that date both of these items will be
       displayed.  If --auto_pm is set to 8 or higher, then the 7:00 will
       automatically be interpreted as 7:00 PM, and the dinner date will be
       displayed below the morning church ceremony.

FANCY TESTS
       In addition to w, discussed above, there are a bunch of other variables
       you can test:

               w  -  day of the week
               m  -  month
               d  -  day of the month
               y  -  year
               j  -  modified Julian day number
               a  -  1 for the first 7 days of the month, 2 for the next 7, etc.
               b  -  1 for the last 7 days of the month, 2 for the previous 7, etc.
               c  -  on Monday or Friday, equals the day of the month of the nearest weekend day; otherwise -1
               e  -  days until this year's (Western) Easter
               z  -  day of the year (1 on New Year's day)

       You can specify months either as numbers, m=2, or as names in your
       language, m=feb.  You can also use the logical operators & (and) and |
       (or). The following example reminds you to pay your employees on the
       first and fifteenth day of every month:

               d=1 | d=15 , Pay employees.

       This example reminds you to rehearse with your band on the last
       Saturday of every month:

               w=sat & b=1 , Rehearse with band.

       The following two lines

               * dec 25 , Christmas
               m=dec & d=25 , Christmas

       both do exactly the same thing, but the first version is easier to
       understand and makes the program run faster. (When you do a test, When
       has to run through every day in the range of dates you asked for, and
       evaluate the test for each of those days. On my machine, if I print out
       a calendar for a whole year, using a file with 10 simple tests in it,
       it takes a few seconds.)  Parentheses can be used, too.

       Depending on your nationality and religion, you probably have a bunch
       of holidays that don't lie on fixed dates. In Christianity, many of
       these (the "movable feasts") are calculated relative to Easter Sunday,
       which is why the e variable is useful.

       There is a not operator, !:

               w=fri & !(m=dec & d=25) , poker game

       There is a modulo operator, %, and a subtraction operator, -.  Using
       these, along with the j variable, it is just barely possible for When's
       little parser to perform the following feat:

               !(j%14-1) , do something every other Wednesday

       The logic behind this silly little piece of wizardry goes like this.
       First, we determine, using the command `when j --now="2005 jan 26"',
       that the first Wednesday on which we want to do this has a Julian day
       that equals 1, modulo 14. Then we write this expression so that if it's
       a Wednesday whose Julian day equals 1, modulo 14, the quantity in
       parentheses will be zero, and taking its logical negation will yield a
       true value.

       The operators' associativity and order of priority (from highest to
       lowest) is like this:

               left    %
               left    -
               left    < > <= >=
               left    = !=
               right   !
               left    &
               left    |

INCLUDING FILES
       If your calendar file gets too large, you may prefer to split it up
       into smaller chunks -- perhaps one for birthdays, one for Tibetan
       holidays, etc.  An easy way of accomplishing this is to install the
       program m4, put the line

               prefilter = m4 -P

       in your preferences file, and then put lines in your calendar file like
       this:

               xyz(/home/yourname/.when/birthdays)

ENVIRONMENT
       $LANG to automatically detect the user's language

       $TERM to try to figure out if the terminal emulator can display
       accented characters

FILES
       $HOME/.when/calendar - The default location for the user's calendar
       (pointed to by the preferences file)

       $HOME/.when/preferences - The user's preferences.

OTHER INFORMATION
       When's web page is at

               http://www.lightandmatter.com/when/when.html   ,

       where you can always find the latest version of the software.  There is
       a page for When on Freshmeat, at

               http://freshmeat.net/projects/when/   ,

       where you can give comments, rate it, and subscribe to e-mail
       announcements of new releases.

AUTHOR
       When was written by Ben Crowell,
       http://www.lightandmatter.com/personal/.  Dimiter Trendafilov wrote the
       new and improved parser for date expressions.

COPYRIGHT AND LICENSE
       Copyright (C) 2003-2010 by Benjamin Crowell.

       When is free software; you can redistribute it and/or modify it under
       the terms of the GPL, or, optionally, Perl's license.



1.1.31                            2011-12-21                           WHEN(1)

SE RECOMIENDA LA INFO EN INGLÉS, ESTO ES SÓLO PARA MEJOR COMPRESIÓN

EN TRADUCCIÓN AUTOMÁTICA