Um pequeno guia sobre como instalar novas fontes TrueType no Linux, usando o X. Primeiro temos que achar o diretório em que elas ficam, no ArchLinux é /usr/share/fonts/TTF/. Se você não souber a localização na sua distro, pelo menos a localização do xorg.conf você deve saber, provavelmente será /etc/X11/xorg.conf ou /etc/xorg.conf, então vamos procurar nele:
grep FontPath /etc/X11/xorg.conf
Já que isso varia de distribuição para distribuição, vamos criar uma variável com esse diretório para facilitar:
fontdir=/usr/share/fonts/TTF/
Movemos ou copiamos a(s) fonte(s) desejada(s) para o diretório, lembrando que os comandos devem ser executados como root:
cp fonte1.ttf fonte2.ttf fonte3.ttf $fontdir
Então iremos atualizar os arquivos do diretório:
cd $fontdir
mkfontscale
mkfontdir
E atualizar o cache de fontes do X:
fc-cache
Agora inicie um programa em GTK e veja se está tudo certo. Para aplicativos do KDE terem acesso a essas novas fontes, será necessário reiniciar o X.
Não muito tempo atrás, surgiu um novo algoritmo para modificar o tamanho de imagens. O vídeo abaixo ilustra bem o seu funcionamento; é interessante ver como mesmo fazendo mudanças radicais ao tamanho da imagem, ela não perde qualidade, ou se perde, é pouquíssima.
Saiba mais
Não há dúvida que computadores auxiliam em cálculos, afinal, foi para isso que eles foram feitos. Podemos com poucas linhas de código ter um programa que nos auxilie a encontrar a raíz de uma função do segundo grau, mas se então quiséssemos fazer mais alguma coisa com esse resultado, teríamos que escrever mais código. Dependendo do problema, mais algumas poucas linhas e o resolveríamos. No entanto alguns são mais complicados e parar o raciocínio para escrever código pode atrapalhar nossa concentração.
Saiba mais
Podemos pensar no screen como o mais primitivo gerenciador de janelas. Bom, na verdade nem gerenciador de janelas ele é, mas sim uma forma de ter inúmeros shells dentro de um único console.
Provavelmente já há um pacote pré-compilado para sua distribuição, então basta instalá-lo. Saiba mais
Vocês se lembram daqueles tópicos sobre ponteiros para funções? Eles me inspiraram a fazer um pequeno teste. Vocês já devem ter ouvido falar que a principal diferença entre structs e classes é que a primeira não pode ter funções dentro de si e que a segunda pode. Acabei de descobrir que é possível burlar essa limitação e com uma pequena gambiarra deixar o C uma linguagem mais voltada a objetos.
Se você ainda não leu os artigos sobre ponteiros para funções, dê uma lida pelo menos no primeiro, apenas para saber do que se trata. Depois de feita a leitura, vamos para um passo-a-passo do que foi feito. Primeiro, a definição de uma nova struct:
typedef struct {
void (*function)();
int i;
} class;
Você pode confirmar que estamos usando C e não C++, já que se fosse usado o segundo, ele daria um erro devido o mau uso da palavra class. O que foi feito aqui é bem simples: definimos uma estrutura com um ponteiro para uma função e um inteiro. Agora o segundo passo:
void fnc( class *this )
{
this->i++;
printf( "Function called %d time(s).\n", this->i );
}
Agora definimos a função que será usada pela estrutura a cima. Infelizmente, não temos um jeito de ter acesso ao this que teríamos no C++. Isso pode ser contornado colocando como argumento um ponteiro. Essa parte ainda será objeto de estudos.
A terceira parte é a criação de um constructor. Já que não estamos trabalhando de fato com uma classe, o ponteiro para a função começa vazio; temos então que ajustar tudo manualmente e para facilitar criamos uma função com esse propósito:
class Class()
{
class a;
a.i = 0;
a.function = &function;
printf( "Constructor called.\n" );
return a;
}
Agora quando estivermos dentro do main, criamos uma nova instância dessa estrutura/classe usando esse construtor. O único problema é a falta de um
this. Sem ele, não temos como acessar informações de dentro da struct sem passá
-la por referência, o que torna o esse método pouco prático. Talvez haja um jeito de
fazer o que eu quero usando macros.
O código todo:
#include
typedef struct {
void (*function)();
int i;
} class;
void function( class *this )
{
this->i++;
printf( “Function called %d time(s).\n”, this->i );
}
class Class()
{
class a;
a.i = 0;
a.function = &function;
printf( “Constructor called\n” );
return a;
}
int main( int argc, char* argv[] )
{
int count;
class test = Class();
for( count = 0; count < 10; count++ ) test.function( &test ); return 0; } [/sourcecode]
No artigo passado nós vimos o básico sobre a função format e as diretrizes de uso geral. Agora iremos nos aprofundar um pouco, vendo diretrizes mais específicas e seus parâmetros. Começaremos com a diretriz ~c.
Saiba mais
Quando o lisp surgiu, ele era uma linguagem de programação bastante avançada para a época. Tão avançada que foram necessárias máquinas especialmente projetadas para rodá-lo. O tempo foi passando e as máquinas evoluindo. Hoje podemos rodar lisp em qualquer máquina, em virtualmente qualquer sistema operacional.
Hoje em dia chamamos o interpretador lisp por uma linha de comando, que inclusive podemos passar argumentos através dessa linha de comando:
clisp source.lisp argumento1 argumento2 argumento3 ...
Mas na época que o lisp foi inventado, as linhas de comando eram o próprio lisp e por isso não havia motivo para criar um padrão de como acessar esses argumentos externos. Por esse motivo não há nenhuma norma de como deve ser feita a implementação do acesso a esses argumentos, chamados em C de argv[].
Justamente por não ser regulamentada, muitos tutoriais deixam isso de lado e eu passei um bom tempo me perguntando como acessar esses argumentos através de lisp. Na implementação que eu uso (clisp), é extremamente fácil. Salve esse script:
(print ext:*args*)
(print (first ext:*args*))
(print (second ext:*args*))
E rode-o com:
clisp args.lisp arg1 arg2 arg3 arg4
("arg1" "arg2" "arg3" "arg4")
"arg1"
"arg2"
Se você precisar de todos os argumentos passados, pode usar ext:argv também. Lembrando que isso vale para o clisp, outras implementações provavelmente funcionam de outra forma.
A função format pode parecer estranha à primeira vista. Quem nunca programou faz cara de que não entendeu e quem está acostumado com o printf do C fica procurando %s ou %g ou %d ou …
Saiba mais
No artigo anterior eu mostrei como se declara e como se usa um ponteiro de funções. Ficou faltando eu alertar para um detalhe extremamente importante. Sempre que você for declarar um ponteiro, declare-o apontando para NULL. Deixar de fazer isso pode trazer sérios riscos de segurança ao seu aplicativo.
int *ptr = NULL;
Antes de começarmos, crie um arquivo .h com o seguinte conteúdo (chameio de c-funcpointer.h):
Aletéia 