Como configurar um widget de relógio no desktop

O relógio presente na barra de status do sistema operacional, comumente é muito pequeno (e passa despercebido) ou é removido por alguns usuários (por que preferem usar o espaço que ele ocupa para informações mais úteis.
Neste texto, vou mostrar como instalar e configurar o oclock e o xclock, dois aplicativos relógio, que podem funcionar como widgets no Ubuntu, no Debian ou qualquer outra distro Linux da sua preferência.
Os dois aplicativos já vêm instalados no Debian 8.0 e, provavelmente, estarão presentes em todas as outras distros com ambiente gráfico. Se não estiver presente na sua distro favorita, tente instalar a partir dos seus repositórios oficiais.
widget-oclock-relogio-01
Trata-se de aplicativos muito simples e que não possuem recursos visuais muito rebuscados. São voltados para usuários que querem um relógio com visual “razoavelmente configurável” e que consuma a menor quantidade possível de recursos do sistema.

Como configurar o oclock

Se quiser, basta executá-lo, da linha de comando e posicioná-lo com o mouse, onde você julgar melhor.
Contudo, há algumas opções de execução do aplicativo, sobre as quais eu gostaria de falar.
Ele pode ser configurado nas cores individuais dos ponteiros, da jóia, da borda e do fundo — o que pode ajudar a integrar melhor seu visual à área de trabalho.
Veja alguns exemplos de configuração:

oclock -bg darkgrey -fg black -bd black -geometry 150x150 -jewel white &

O comando acima irá executar o relógio com as seguintes características:

  • -bg darkgrey — ajusta a cor do fundo (background) do relógio (dentro do círculo) para cinza escuro.
  • -fg black — ajusta a cor de frente (foreground) do relógio (dos ponteiros) para preta.
  • -bd black — ajusta a cor da borda ou border circular para preta.
  • -geometry — ajusta as dimensões do relógio para 150 pixeis de largura x 150 pixeis de altura.
  • -jewel white — ajusta a cor da “jóia” (o ponto correspondete à 12h) para branco.

screenshot xclock UNIX and LINUX
O símbolo ‘&’, ao final da linha, envia a execução do comando para os bastidores, deixando o console livre para receber novos comandos.
Você pode usar a opção ‘-transparente’ para deixar o fundo circular do relógio transparente.
Se quiser ajustar os ponteiros para que tenham cores diferentes, substitua ‘-fg’ por ‘-minute’ e ‘-hour’. Veja um exemplo:

oclock -bg darkgrey -minute yellow -hour blue -bd black -geometry 150x150 -jewel white &

screenshot oclock clock widget
h2>Como configurar o xclock

O xclock já é um aplicativo UNIX tradicional e de longa data, com versões até para o VMS (DEC), que deu origem ao Windows NT.
Seu visual remonta, sem dúvida, o UNIX dos anos 80.
Tal como o oclock, pode ser executado direto na linha de comando, sem quaisquer parâmetros.
Mas ele vai ficar mais bonito com algumas cores — e, infelizmente, não há a opção de transparência para a interface deste programa.
Estas são as opções de cores para o xclock:

  1. -fg — cor de frente.
  2. -bg — cor de fundo.
  3. -hd ou -hands— cor dos ponteiros ou hands.
  4. -hl — cor do highlight.
  5. -bd — cor da borda dos ponteiros.

Veja um exemplo simplificado de um relógio com fundo preto, ponteiros amarelos e marcadores brancos:

xclock -norender -bg black -hands yellow -fg white &

screenshot xclock UNIX and LINUX
A opção ‘-norender’, no exemplo acima, pode ser necessária em alguns sistemas com renderização X.
O xclock pode exibir o relógio digital também:

xclock -digital -brief -bg black -fg cyan -padding 40 &

No exemplo, acrescentei a opção ‘-padding 40’, para afastar as bordas, em 40 pixels, do relógio — o que dá uma visibilidade maior à informação. Esta opção também pode ser usada no relógio analógico.
A opção ‘-brief’ exibe a informação resumida sobre as horas. Sem ela, o xclock publica também a data completa — faça a experiência!
Por fim, acrescente a opção ‘-chime’, para ser avisado (com um beep) a cada meia hora e a cada hora (com 2 beeps).
Espero que estas dicas te ajudem a nunca mais perder a hora!

Como manipular valores de data e hora como números no MySQL

Transformar strings contendo valores temporais (de data e/ou hora) pode ser útil quando se deseja realizar operações aritméticas, envolvendo-os. Os valores podem ser convertidos de volta para data e/ou hora, com relativa facilidade.
O processo consiste, basicamente em adicionar o valor zero ou usar o valor temporal em um contexto numérico — o MySQL irá entender que aquele valor é um número.
Veja um exemplo:

SELECT CURRENT_DATE() AS Hoje, CURRENT_DATE()+0 AS "Hoje, como núm.";
+------------+------------------+
| Hoje       | Hoje, como núm.  |
+------------+------------------+
| 2015-07-14 |         20150714 |
+------------+------------------+

CURRENT_DATE() é a função responsável por retornar a data atual. Como você pode ver, no exemplo acima, ao adicionar 0 (zero), o valor passou de data para número.
Na condição de valor numérico, é possível realizar todas as operações aritméticas e, em seguida, voltar (nem sempre…) a valor temporal.
Veja outro exemplo:

SELECT DATE(DataCadastroCliente) AS Cadastro, DATE(DataCadastroCliente)+0 AS "Número", YEAR(DataCadastroCliente)+1 AS "Ano +1" FROM CadastroClientes LIMIT 10;
+------------+----------+--------+
| Cadastro   | Número   | Ano +1 |
+------------+----------+--------+
| 2016-03-29 | 20160329 |   2017 |
| 2015-06-20 | 20150620 |   2016 |
| 2013-03-29 | 20130329 |   2014 |
| 2015-11-29 | 20151129 |   2016 |
| 2016-06-11 | 20160611 |   2017 |
| 2014-06-14 | 20140614 |   2015 |
| 2015-08-31 | 20150831 |   2016 |
| 2012-08-28 | 20120828 |   2013 |
| 2013-05-29 | 20130529 |   2014 |
| 2013-06-03 | 20130603 |   2014 |
+------------+----------+--------+

mysql-convert-datetime-to-number
Fique atento.
Ao adicionar 0 (ou qualquer outro valor numérico) a um valor temporal, este deixa de ter valor temporal e passa a ser uma simples string numérica.
Essencialmente, você deve esperar, como resultado, uma string sem os delimitadores de data.
Mas apenas o primeiro componente da data ou da hora será interpretado como numérico, durante a conversão. Veja por si só:

SELECT '2016-01-01'+0, '2016-01-01 15:45:25'+0, '15:45:25'+0;
+----------------+-------------------------+--------------+
| '2016-01-01'+0 | '2016-01-01 15:45:25'+0 | '15:45:25'+0 |
+----------------+-------------------------+--------------+
|           2016 |                    2016 |           15 |
+----------------+-------------------------+--------------+

Para resolver isto, use as funções SEC_TO_TIME() e TIME_TO_SEC().

Como calcular intervalos de tempo decorrido entre dois horários no MySQL

Se você tem dois valores temporais, um horário de saída e outro de chegada, e deseja saber qual foi o tempo decorrido entre os dois, use a função TIME_TO_SEC() e sua contraparte SEC_TO_TIME().
Ambas, presentes no MySQL (desde a versão 3.22), oferecem uma forma (entre outras) de fazer cálculos envolvendo valores temporais, como horários e datas inteiras.
Você pode ver outros exemplos de uso destas funções aqui.
Se você quer adicionar 3 horas a um horário 15:35:00, não é possível fazer isto apenas somando 15:35:00 + 3 — são unidades diferentes, afinal.

Captura de tela: MySQL calculos envolvendo horas no banco de dados.
Clique para ampliar.

É aí que entra a função TIME_TO_SEC() — ela converte os valores para segundos.
Quando todas as grandezas envolvidas na operação estão usando a mesma unidade, é possível realizar qualquer conta.

SET @HoraSaida='15:20:00';
SET @HoraChegada='17:20:00';
SELECT @HoraSaida, @HoraChegada, TIME_TO_SEC(@HoraChegada) - TIME_TO_SEC(@HoraSaida) AS "Tempo decorrido em segundos";
_
+------------+--------------+-----------------------------+
| @HoraSaida | @HoraChegada | Tempo decorrido em segundos |
+------------+--------------+-----------------------------+
| 15:20:00   | 17:20:00     |                        7200 |
+------------+--------------+-----------------------------+
1 row in set (0.00 sec)

Ao terminar de realizar as operações aritméticas, você converte de volta, usando SEC_TO_TIME() — e voilá (desculpe o clichê) você tem um resultado apresentável, no formato de horário.

SELECT @HoraSaida, @HoraChegada,  SEC_TO_TIME(TIME_TO_SEC(@HoraChegada) - TIME_TO_SEC(@HoraSaida)) AS "Tempo decorrido em horas";
_
+------------+--------------+--------------------------+
| @HoraSaida | @HoraChegada | Tempo decorrido em horas |
+------------+--------------+--------------------------+
| 15:20:00   | 17:20:00     | 02:00:00                 |
+------------+--------------+--------------------------+
1 row in set (0.00 sec)

Note que intervalos de tempo decorrido podem ser negativos — para isto basta que o primeiro valor de horário seja posterior ao segundo. Ou seja, se você saiu de casa às 7:00:00, pro trabalho, e chegou às 6:45:00, você terá gasto -15 minutos de deslocamento — uma verdadeira viagem no tempo.

Como adicionar mais tempo a outra variável de tempo no MySQL

Você já tem uma variável ou um campo com um valor de tempo, definido em horas, minutos e segundos. O que você quer é adicionar valores a esta variável temporal — alguns segundos, minutos, horas ou dias a mais.
Uma das formas de resolver este problema e usar as funções de conversão do MySQL: TIME_TO_SEC() e SEC_TO_TIME().
Nesta abordagem, vamos usar TIME_TO_SEC() para ter certeza de que todos os valores envolvidos estão em segundos. Então, fazemos as operações aritméticas, cujos resultados serão apresentados em unidades de segundos.
Enfim, vamos usar a função SEC_TO_TIME() para converter de volta a valores temporais (de hora).
Tomemos como exemplo que 3 horas são equivalentes a (3*60*60) 10800 segundos — cada hora, possui 3600 segundos.
Ao adicionar mais uma hora (3600 seg.) a este valor, temos 14400 segundos.
Para transformar o valor resultante em um horário legível, usamos a função SEC_TO_TIME().
No exemplo prático, abaixo, vou mostrar como somar 3 horas ao horário original, constante nos campos de uma tabela>

SELECT TIME(DataCadastroCliente) AS "Horário original",
    -> SEC_TO_TIME(TIME_TO_SEC(DataCadastroCliente)+10800) as "Horário +3 horas"
    -> FROM CadastroClientes LIMIT 5;
+-------------------+-------------------+
| Horário original  | Horário +3 horas  |
+-------------------+-------------------+
| 10:03:39          | 13:03:39          |
| 21:44:49          | 24:44:49          |
| 11:58:30          | 14:58:30          |
| 20:52:29          | 23:52:29          |
| 09:43:57          | 12:43:57          |
+-------------------+-------------------+
5 rows in set (0.00 sec)

Como somar dois valores expressos em horas no MySQL

Se você tem dois valores temporais expressos em horas, é necessário converter ambos para segundos, antes de somá-los.
Veja um exemplo:

SELECT HoraChegada, TempoPerm
    -> SEC_TO_TIME(TIME_TO_SEC(HoraChegada) + TIME_TO_SEC(TempoPerm)) AS 'Hora + Tempo'
    -> FROM CheckIn;
+-------------+-----------+--------------+
| HoraChegada | TempoPerm | Hora + Tempo |
+-------------+-----------+--------------+
|    15:00:00 |  15:00:00 |     30:00:00 |
|    05:01:30 |  02:30:20 |     07:31:50 |
|    12:30:20 |  17:30:45 |     30:01:05 |
+-------------+-----------+--------------+

Note que valores temporais no MySQL (MySQL TIME values) não representam os horários no dia. Na verdade, estes valores se referem a tempo decorrido — por isto não zeram após as 24 horas.
Use um operador de módulo para chegar ao resultado desejado, neste caso:

SELECT HoraChegada, TempoPerm
    -> SEC_TO_TIME(MOD(TIME_TO_SEC(HoraChegada) + TIME_TO_SEC(TempoPerm), 86400) AS 'Hora + Tempo'
    -> FROM CheckIn;

Note que o valor 86400, usado acima, é o número de segundos contido dentro das 24 horas de um dia. No meu caso, esta query vai retornar o seguinte resultado:

+-------------+-----------+--------------+
| HoraChegada | TempoPerm | Hora + Tempo |
+-------------+-----------+--------------+
|    15:00:00 |  15:00:00 |     06:00:00 |
|    05:01:30 |  02:30:20 |     07:31:50 |
|    12:30:20 |  17:30:45 |     06:01:05 |
+-------------+-----------+--------------+

No MySQL, os valores TIME se delimitam entre -838:59:59 e 838:59:59 — o que corresponde a -3020399 a
3020399 segundos.
Se você tentar armazenar valores fora desta faixa, o MySQL vai simplesmente cortar o que estiver ultrapassando os limites do permitido.

Como converter horas em segundos, minutos, dias e vice-versa no MySQL

Em alguns momentos pode ser importante estabelecer o tempo decorrido em um intervalo, de segundos, minutos, horas etc.
No MySQL, as funções TIME_TO_SEC e SEC_TO_TIME a fazer este cálculo.
Em um curto exemplo, veja como funciona a conversão de hora para segundos da função TIME_TO_SEC():

SELECT TIME_TO_SEC('00:00:36');
_

para tornar o resultado mais fácil de entender, usei um valor baixo e óbvio (trinta e seis segundos):

+-------------------------+
| TIME_TO_SEC('00:00:36') |
+-------------------------+
|                      36 |
+-------------------------+
1 row in set (0.00 sec)

A partir daí, é possível encontrar outros valores.
Por exemplo, dividir o valor por 60, resulta no tempo decorrido em minutos.
Se o valor for dividido novamente por 60, teremos o tempo decorrido em horas.
Para obter o tempo decorrido em dias, acrescente mais uma operação de divisão – por 24, desta vez.
Veja um exemplo destas operações:

SELECT TIME(DataCadastroCliente) AS "Valor Original",
    -> TIME_TO_SEC(DataCadastroCliente) AS "Segundos",
    -> TIME_TO_SEC(DataCadastroCliente)/60 AS "Minutos",
    -> TIME_TO_SEC(DataCadastroCliente)/60/60 AS "Horas",
    -> TIME_TO_SEC(DataCadastroCliente)/60/60/24 AS "Dias"
    -> FROM CadastroClientes
    -> ORDER BY TIME(DataCadastrocliente) ASC LIMIT 10;

Note que ’21:30′ e ’22:30′ são traduzidos como ’21 minutos e meio’ e ’22 minutos e meio’:

+----------------+----------+----------+------------+----------------+
| Valor Original | Segundos | Minutos  | Horas      | Dias           |
+----------------+----------+----------+------------+----------------+
| 00:21:30       |     1290 |  21.5000 | 0.35833333 | 0.014930555556 |
| 00:22:30       |     1350 |  22.5000 | 0.37500000 | 0.015625000000 |
| 00:36:10       |     2170 |  36.1667 | 0.60277778 | 0.025115740740 |
| 00:38:10       |     2290 |  38.1667 | 0.63611111 | 0.026504629629 |
| 00:47:04       |     2824 |  47.0667 | 0.78444444 | 0.032685185185 |
| 01:06:55       |     4015 |  66.9167 | 1.11527778 | 0.046469907407 |
| 01:32:53       |     5573 |  92.8833 | 1.54805556 | 0.064502314815 |
| 01:43:07       |     6187 | 103.1167 | 1.71861111 | 0.071608796296 |
| 01:45:34       |     6334 | 105.5667 | 1.75944444 | 0.073310185185 |
| 01:54:25       |     6865 | 114.4167 | 1.90694444 | 0.079456018518 |
+----------------+----------+----------+------------+----------------+
10 rows in set (0.00 sec)

Vamos melhorar a visualização deste resultado, com a função FLOOR()

A função FLOOR() retorna o maior valor inteiro, que não exceda o do argumento.
(Manual do MySQL).

É mais fácil entender com um exemplo:

SELECT TIME(DataCadastroCliente) AS "Valor Original",
    -> TIME_TO_SEC(DataCadastroCliente) AS "Segundos",
    -> FLOOR(TIME_TO_SEC(DataCadastroCliente)/60) AS "Minutos",
    -> FLOOR(TIME_TO_SEC(DataCadastroCliente))/(60*60) AS "Horas",
    -> FLOOR(TIME_TO_SEC(DataCadastroCliente))/(60*60*24) AS "Dias"
    -> FROM CadastroClientes ORDER BY TIME(DataCadastrocliente) ASC LIMIT 10;
+----------------+----------+---------+--------+--------+
| Valor Original | Segundos | Minutos | Horas  | Dias   |
+----------------+----------+---------+--------+--------+
| 00:21:30       |     1290 |      21 | 0.3583 | 0.0149 |
| 00:22:30       |     1350 |      22 | 0.3750 | 0.0156 |
| 00:36:10       |     2170 |      36 | 0.6028 | 0.0251 |
| 00:38:10       |     2290 |      38 | 0.6361 | 0.0265 |
| 00:47:04       |     2824 |      47 | 0.7844 | 0.0327 |
| 01:06:55       |     4015 |      66 | 1.1153 | 0.0465 |
| 01:32:53       |     5573 |      92 | 1.5481 | 0.0645 |
| 01:43:07       |     6187 |     103 | 1.7186 | 0.0716 |
| 01:45:34       |     6334 |     105 | 1.7594 | 0.0733 |
| 01:54:25       |     6865 |     114 | 1.9069 | 0.0795 |
+----------------+----------+---------+--------+--------+
10 rows in set (0.00 sec)