Arquivo da categoria: Desenvolvimento

Exibindo boxes no Android com AlertDialog

Introdução

Uma caixa de diálogo é uma pequena janela que solicita ao usuário tomar uma decisão ou inserir informações adicionais. Um diálogo não preenche toda a tela e é normalmente utilizado para eventos modais, requerendo aos usuários uma interação antes de prosseguir.

Um AlertDialog pode mostrar um título, até três botões, uma lista de itens selecionáveis ou não, ou um layout personalizado. Vamos ver ao decorrer deste artigo todas essas opções.

Diálogo básico

Exemplo de um diálogo básico

Figura 1: Exemplo de um diálogo básico

No exemplo básico vamos criar um diálogo como a imagem acima, um título, mensagem e dois botões.

É importante sabermos que ao criarmos o diálogo utilizando os recursos padrões ele será automaticamente desfeita ao pressionar qualquer dos botões.

A criação é simples e em todos os exemplos vamos utilizar o mesmo recurso para a criação do objeto AlertDialog. Utilizaremos a classe AlertDialog.Builder, vamos instanciá-la e configurar o que será exibido (título, mensagem, botões, etc…) após isso vamos pegar o AlertDialog do Builder e mandar exibir o diálogo.

Listagem 1: Exemplo AlertDialog básico

    //atributo da classe.
    private AlertDialog alerta;

    private void exemplo_simples() {
        //Cria o gerador do AlertDialog
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        //define o titulo
        builder.setTitle("Titulo");
        //define a mensagem
        builder.setMessage("Qualifique este software");
        //define um botão como positivo
        builder.setPositiveButton("Positivo", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface arg0, int arg1) {
                Toast.makeText(MainActivity.this, "positivo=" + arg1, Toast.LENGTH_SHORT).show();
            }
        });
        //define um botão como negativo.
        builder.setNegativeButton("Negativo", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface arg0, int arg1) {
                Toast.makeText(MainActivity.this, "negativo=" + arg1, Toast.LENGTH_SHORT).show();
            }
        });
        //cria o AlertDialog
        alerta = builder.create();
        //Exibe
        alerta.show();
    }

Diálogo customizado

Exemplo de um diálogo customizado

Figura 2: Exemplo de um diálogo customizado

Seguindo os passos da criação de nosso diálogo básico, agora vamos criar um layout customizado, primeiramente será feita a construção do nosso arquivo XML chamado de ‘alerta.xml’, nele vamos inserir um ImageView e um Button dentro de um LinearLayout.

Listagem 2: Arquivo alerta.xml utilizado no diálogo customizado

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="fill_parent"
              android:layout_height="fill_parent"
>
    <ImageView
        android:layout_width="wrap_content" 
        android:layout_height="wrap_content" 
        android:layout_gravity="center"
        android:src="@drawable/imagem_teste"
/>
    <Button
        android:id="@+id/bt"  
        android:layout_width="fill_parent" 
        android:layout_height="wrap_content" 
        android:text="Dismiss"
/>
</LinearLayout>

Agora vamos inserir esse layout no diálogo e tratar a ação do botão. Lembre-se que o AlertDialog está como variável da classe, assim como no primeiro exemplo.

Listagem 3: Exemplo AlertDialog customizado

    private void exemplo_layout() {
        //LayoutInflater é utilizado para inflar nosso layout em uma view.
        //-pegamos nossa instancia da classe
        LayoutInflater li = getLayoutInflater();
        
        //inflamos o layout alerta.xml na view
        View view = li.inflate(R.layout.alerta, null);
        //definimos para o botão do layout um clickListener
        view.findViewById(R.id.bt).setOnClickListener(new View.OnClickListener() {
            public void onClick(View arg0) {
                //exibe um Toast informativo.
                Toast.makeText(MainActivity.this, "alerta.dismiss()", Toast.LENGTH_SHORT).show();
                //desfaz o alerta.
                alerta.dismiss();
            }
        });
        
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle("Titulo");
        builder.setView(view);
        alerta = builder.create();
        alerta.show();
    } 

Diálogos de lista de seleção simples

Também com base nos exemplos anteriores, fazer uma lista nada mais é do que você definir um vetor de informações e inseri-las no Builder do diálogo.

Diálogo de seleção simples

Figura 3: Diálogo de seleção simples

Neste exemplo foi utilizado um ListAdapter para gerar a lista, para isso foi criado um layout para os itens.

Listagem 4: Item que contem o TextView da lista

<?xml version="1.0" encoding="utf-8"?>
<TextView
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:textSize="20sp"
    android:textColor="#FF000000"
    android:padding="10sp"
/>

Como vimos, nosso item é só um TextView, veja na listagem abaixo como construir o adaptador e inserir no AlertDialog.

Listagem 5: Implementação do AlertDialog em lista

    private void exemplo_lista_single() {
        //Lista de itens
        ArrayList<String> itens = new ArrayList<String>();
        itens.add("Ruim");
        itens.add("Mediano");
        itens.add("Bom");
        itens.add("Ótimo");
        
        //adapter utilizando um layout customizado (TextView)
        ArrayAdapter adapter = new ArrayAdapter(this, R.layout.item_alerta, itens);

        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle("Qualifique este software:");
        //define o diálogo como uma lista, passa o adapter.
        builder.setSingleChoiceItems(adapter, 0, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface arg0, int arg1) {
                Toast.makeText(MainActivity.this, "posição selecionada=" + arg1, Toast.LENGTH_SHORT).show();
                alerta.dismiss();
            }
        });

        alerta = builder.create();
        alerta.show();
    } 

Diálogo de lista com várias seleções

Os itens da lista do diálogo de seleções múltiplas se resumem em um componente de texto e um CheckBox.

Diálogo de seleção múltipla

Figura 4: Diálogo de seleção múltipla

Neste exemplo, o que temos de diferente são dois vetores, um de CharSequence[] onde serão armazenados os textos, e um vetor de boolean[] onde ficarão armazenadas as informações de habilitado ou desabilitado de cada item. Por isso que é muito importante construir esse vetor de acordo com o tamanho do vetor do CharSequence[]. Na listagem abaixo será mostrado como implementar e utilizar essa lista.

Listagem 6: Implementação do AlertDialog em lista

    private void exemplo_lista_multi() {
        CharSequence[] charSequences = new CharSequence[]{"Filmes", "Dormir","Sair"};
        final boolean[] checados = new boolean[charSequences.length];

        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle("O que você gosta?");
        builder.setMultiChoiceItems(charSequences, checados, new DialogInterface.OnMultiChoiceClickListener() {
            public void onClick(DialogInterface arg0, int arg1, boolean arg2) {
                checados[arg1] = arg2;
            }
        });

        builder.setPositiveButton("Confirmar", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface arg0, int arg1) {
                StringBuilder texto = new StringBuilder("Checados: ");
                for (boolean ch : checados) {
                    texto.append(ch).append("; ");
                }
                Toast.makeText(MainActivity.this, texto.toString(), Toast.LENGTH_SHORT).show();
            }
        });

        alerta = builder.create();
        alerta.show();
    }

Observe que o listener do setMultiChoiceItems é diferente pois utilizamos a interface OnMultiChoiceClickListener() que nos retornara a posição e o estado do botão.

Conclusão

O AlertDialog é uma classe essencial no desenvolvimento de aplicações Android, permitindo ao usuário uma caixa simples para a seleção de opções.

Como todo componente do Android, o AlertDialog é totalmente customizável, permitindo o uso de um layout personalizado, com seus próprios botões e informações. Seu uso além de simples e viável deve ser estudado para atender ao usuário. Lembre-se sempre de pesquisar na documentação do Android como utilizar cada recurso da melhor maneira possível.

Fonte : http://www.devmedia.com.br/exibindo-caixas-de-dialogos-no-android-com-alertdialog/26749
Anúncios

Convertendo OpenCV Mat para QImage (vice-versa)

 

Conversão de OpenCV Mat para QImage

QImage ConvertMatToQImage(cv::Mat const& src) {
cv
::Mat temp; cvtColor(src, temp,CV_BGR2RGB);
          QImage dest((const uchar *) temp.data, temp.cols, temp.rows, temp.step, QImage::Format_RGB888);
dest
.bits();
          return dest;
}

 Conversão de QImage para OpenCV Mat

cv::Mat ConvertQImage2Mat(QImage const& src) {
cv
::Mat tmp(src.height(),src.width(),CV_8UC3,                      (uchar*)src.bits(),src.bytesPerLine());
cv
::Mat result; cvtColor(tmp, result,CV_BGR2RGB);
         return result;
}

Instalando o OpenBR no Debian

Hoje a vida moderna está rodeada de câmeras e sistemas de segurança, este fator mudou o cenário de TI atenuando o foco para esta área. Em meados da década de 80 vimos surgir a biometria facial, de retina e iris, além do reconhecimento de assinaturas.

O OpenBR (http://openbiometrics.org/) é uma framework baseada na plataforma OpenCV, desenvolvida em 1999 pela Intel para melhorar o uso intensivo de processamento. (Mais informações) Tem como pilar algoritmos de reconhecimento facial, estimativa de idade e estimativa de gênero. O OpenBR é compatível na plataforma Windows,Mac OS X e Debian Linux. O Projeto está sob a licença Apache 2.0.

Let’s play a game …

Vamos demonstrar uma instalação básica da framework e seus tutoriais se encontram aqui e está disponível vários itens como :

  • Treinamento
  • Reconhecimento Facial
  • Estimativa de Idade
  • Estimativa de Gênero
  • Bibliotecas
  • Etc…

Instalação

  • Vamos atualizar o sistema e instalar o GCC 4.9.2

$ sudo apt-get update
$ sudo apt-get install build-essential

O build-essential é um pacote para desenvolvimento contendo (gcc,g++ o make entre outros)

  • Instalar o CMake (CMake é um sistema multiplataforma para realizar geração automatizada)

$ sudo apt-get install cmake cmake-curses-gui

$ cd /tmp/
$ unzip opencv-2.4.11.zip
$ cd opencv-2.4.11
$ mkdir build
$ cd build
$ cmake –DCMAKE_BUILD_TYPE=Release ..
$ make -j4
$ sudo make install
$ cd ../..
$ rm -rf opencv-2.4.11*

  • Qt 5.4.1

$ sudo apt-get install qt5-default libqt5svg5-dev qtcreator

  • Agora, vamos instalar o OpenBR diretamente do repositório oficial no GitHub

$ git clone https://github.com/biometrics/openbr.git
$ cd openbr
$ git checkout master
$ git submodule init
$ git submodule update

  • Compilação !!!

$ mkdir build #Na raiz da instalação do OpenBR
$ cd build
$ cmake –DCMAKE_BUILD_TYPE=Release ..
$ make -j4
$ sudo make install

  • Os passos a seguir são opcionais, porém eu recomendo realizá-los ..

Baixando os Datasets (rede neural de treinamento da biometria) e testando o algorítimo

Obs : Este passo pode demorar um pouco pois serão baixados 13.5 Gb de dados.

$ cd openbr/scripts
$ ./downloadDatasets.sh
$ cd ../build
$ make test

  • Pacotes do OpenBR !!

$ cd openbr/build
$ sudo cpack –G TGZ

  • Documentação
  1. Compilar os documentos

$ pip install mkdocs
$ cd openbr/docs
$ sh build_docs.sh
$ mkdocs serve

  1. Abra o browser e digite : http://127.0.0.1:8000

Agora temos uma estrutura completa de reconhecimento facial instalada e para testar vamos utilizar o comando :

$ br -algorithm FaceRecognition -compare face1.jpg face2.jpg

Nos próximos artigos vamos falar um pouco mais sobre biometria facial, score, match e etc ..

See you soon …

Package Control do Sublime Text – o que é e como utilizar

Neste artigo vamos analisar o Package Control, que é um gerenciador de pacotes para o sublime text que auxilia na instalação, atualização ou remoção de pacotes do editor de texto. Esse recurso torna muito mais fácil a forma como gerenciamos os pacotes presentes no editor.

O que é o Package Control ?

Primeiro vamos entender o que é o Package Control: nada mais é que um gerenciador de pacotes, no caso “pacotes” são complementos que aprimoram a experiência do usuário no software (como plugins para o firefox, por exemplo). O próprio Package Control é um pacote do Sublime.

Instalando o Package Control no Sublime

Siga os passos abaixo para instalar o Package Control no Sublime Text 2+:

  1. Acesse o endereço https://sublime.wbond.net/installation e copie a linha de comando de instalação para versão do sublime que você possui.
  2. Abra o console do sublime pressionando as teclas Ctrl + ‘.
  3. Cole a linha de comando referente a sua versão do sublime como apresentada no primeiro passo.
  4. Pressione ENTER.
  5. Após o termino da instalação do PC (package control) basta reiniciar o Sublime Text para que ele inicie carregando este novo complemento.

Caso você não consiga instalar o PC através do console do Sublime, existe outra opção que é a instalação manual, conforme os passos a seguir:

  1. Clique no menu preferences > browse package… – o sistema vai abrir uma janela do windows explorer na pasta onde são salvos os pacotes do Sublime.
  2. na pasta que se abriu, vá até a pasta Installed Packages.
  3. Baixe o pacote do Package Control e copie o arquivo baixado para a pasta Installed Packages.
  4. Reinicie o Sublime Text.

Como utilizar

Com o sublime aberto pressione Crtl + Shitf + P para iniciar o command palette.

Digite Package Control para o command palette mostrar as propriedades do PC e escolha a opção Package Control: Install Package.

Após carregar a lista de pacotes, digite o pacote que deseja instalar. O sublime vai carregar o pacote e vai mostrar no rodapé do programa quando o processo for finalizado, pedindo a reinicialização do mesmo.

That’s It !!

Rotacionando imagens em PHP + Oracle (Base64/Resource)

Usando Oracle (LOB’s)

$stid = oci_parse($this->dbconn, ‘select * from IMAGENS’);
oci_execute($stid);

while ($row = oci_fetch_array($stid)) {

//Carrega a Imagem em Resource
$img = $row[‘IMAGEM’]->load();

//Angulo de Rotação
$degrees = 0;

for ($i = 0; $i < 5; $i++) {

echo “>>> Image : ” . $row[‘ID’] . ” Rotate Angle : ” . $degrees . “\n”;

//Converte a Imagem em Base64
$b64Src = base64_encode($img);
$rotate = imagerotate(imagecreatefromstring(base64_decode($b64Src)), $degrees, 0);

ob_start();
imagejpeg($rotate);
$contents = ob_get_contents();
ob_end_clean();

$b64Src = base64_encode($contents);

if ($this->check_base64_image($b64Src)) {

} else {

echo “\n\n !!! Não é uma imagem válida !!! \n\n “;

}

//Altera a angulação para + 90 graus
$degrees = $degrees + 90;

}

}

die();

Função para validar uma imagem :

function check_base64_image($base64) {

$img = imagecreatefromstring(base64_decode($base64));
if (!$img) {

return false;

}

imagepng($img, ‘tmp.jpg’);
$info = getimagesize(‘tmp.jpg’);

unlink(‘tmp.jpg’);

if ($info[0] > 0 && $info[1] > 0 && $info[‘mime’]) {

return true;

}

return false;

}

Usando Webcam com HTML5 Canvas (Com conversão em base64)

Sem dúvida, o elemento canvas no HTML5 é o recurso que a maioria dos desenvolvedores vai querer usar para desenvolver aplicativos Web realmente ricos – sem precisarem instalar plug-ins de navegador como Flash Player da Adobe. O Canvas nasceu em uma época em que a riqueza do cliente está no foco dos desenvolvedores. Navegadores modernos como o Chrome, Firefox e o Internet Explorer 9 e 10 o suportam. Mas o que exatamente é o elemento canvas em HTML5? Como você o usa para criar aplicativos Web ricos?

Se você não tiver familiaridade com HTML5, antes de se aprofundar neste artigo, deve ler Sim, você pode usar HTML5 hoje! e HTML5 e formas ainda mais extravagantes.

Para que serve o elemento canvas?

Oficialmente, o canvas é “uma tela de bitmap dependente de resolução que pode ser usada para a renderização de elementos gráficos ou outras imagens visuais rapidamente”. Em termos leigos, o canvas é um elemento novo em HTML5, que permite que se desenhem elementos gráficos usando JavaScript. Ele pode ser usado para renderizar texto, imagens, gráficos, linhas gradientes e outros efeitos dinamicamente. Desenhar na tela se dá através da API de tela 2D. Essa API contém uma variedade de funções que fornecem o poder de se desenhar praticamente o que se queira na tela. Atualmente, a tela suporta uma interface 2D, não 3D.

No exemplo de hoje vamos usar o canvas para abrir uma webcam e capturar uma foto e ainda ter o retorno em base64.

Let’s do it !!

Vamos usar dois arquivos ( index.php e webcam.js)

index.php

<!DOCTYPE html>
<html>
<head>
<meta charset=”utf-8″>
<title>eXagon WebCaM Stream</title>
<style>
#container {
width: 500px;
height: 375px;
border: 10px #333 solid;
}
#videoElement {
width: 500px;
height: 375px;
background-color: #666;
}
#canvas {
width: 500px;
height: 375px;
background-color: #CCC;
border: 10px #333 solid;
}
</style>
</head>

<body>
<input id=”fileselect” type=”file” accept=”image/*” capture=”camera”>

<canvas id=”canvas” width=”500″ height=”375″></canvas>
<input type=”button” value=”Capturar” id=”save” />

<br>
<br>

<!– Div onde será renderizada a base 64 –>

Base64

http://webcam.js

</body>
</html>

webcam.js

var video = document.querySelector(“#videoElement”);

navigator.getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia || navigator.oGetUserMedia;

if (navigator.getUserMedia) {
navigator.getUserMedia({video: true}, handleVideo, videoError);
}

function handleVideo(stream) {
video.src = window.URL.createObjectURL(stream);
}

function videoError(e) {
// Caso de erro no video
}
var v,canvas,context,w,h;
var imgtag = document.getElementById(‘imgtag’);
var sel = document.getElementById(‘fileselect’);

document.addEventListener(‘DOMContentLoaded’, function(){
v = document.getElementById(‘videoElement’);
canvas = document.getElementById(‘canvas’);
context = canvas.getContext(‘2d’);
w = canvas.width;
h = canvas.height;

},false);

function draw(v,c,w,h) {
if(v.paused || v.ended) return false;
context.drawImage(v,0,0,w,h);
var uri = canvas.toDataURL(“image/jpeg”);
var base64Div = document.getElementById(‘base’);
base64Div.innerText = uri;
imgtag.src = uri;
}

document.getElementById(‘save’).addEventListener(‘click’,function(e){
draw(v,context,w,h);
});

var fr;

sel.addEventListener(‘change’,function(e){
var f = sel.files[0];
fr = new FileReader();
fr.onload = receivedText;
fr.readAsDataURL(f);
})

function receivedText() {
imgtag.src = fr.result;
}

Convertendo imagens em base64 em 5 linguagens diferentes (PHP, C#, Java, Python,JavaScript)

Base64 é um método para codificação de dados para transferência na Internet (codificação MIME para transferência de conteúdo) . É utilizado frequentemente para transmitir dados binários por meios de transmissão que lidam apenas com texto, como por exemplo para enviar arquivos anexos por email.

É constituído por 64 caracteres ([A-Za-z0-9], “/” e “+”) que deram origem ao seu nome. O carácter “=” é utilizado como um sufixo especial e a especificação original (RFC 989) definiu que o símbolo “*” pode ser utilizado para delimitar dados convertidos, mas não criptografados, dentro de um stream.

Exemplo de codificação:

  • Texto original: hello world
  • Texto convertido para Base64: aGVsbG8gd29ybGQK

A codificação Base64 é frequentemente utilizada quando existe uma necessidade de transferência e armazenamento de dados binários para um dispositivo designado para trabalhar com dados textuais. Esta codificação é amplamente utilizada por aplicações em conjunto com a linguagem de marcação XML, possibilitando o armazenamento de dados binários em forma de texto.

Agora vamos converter uma imagem ou arquivo em diversas formas e linguagens :

Let’s do it !!


PHP :

<?php
    // Le a stream do Arquivo e retorna a imagem
    $imagem = file_get_contents('imagem.png');
    //converte a imagem em string base64
    echo base64_encode($imagem);
?>

C#

public string ImageToBase64(Image image, 
  System.Drawing.Imaging.ImageFormat format)
{
  using (MemoryStream ms = new MemoryStream())
  {
    // Convert Image to byte[]
    image.Save(ms, format);
    byte[] imageBytes = ms.ToArray();

    // Convert byte[] to Base64 String
    string base64String = Convert.ToBase64String(imageBytes);
    return base64String;
  }
}

Java

Base64.encode(FileUtils.readFileToByteArray(file));

Python

import base64
imgdata = base64.b64decode(imgstring)
filename = 'image.jpg'  # arquivo
with open(filename, 'wb') as f:
    f.write(imgdata)

JavaScript

function convertImgToBase64(url, callback, outputFormat){
    var canvas = document.createElement('CANVAS'),
        ctx = canvas.getContext('2d'),
        img = new Image;
    img.crossOrigin = 'Anonymous';
    img.onload = function(){
        var dataURL;
        canvas.height = img.height;
        canvas.width = img.width;
        ctx.drawImage(img, 0, 0);
        dataURL = canvas.toDataURL(outputFormat);
        callback.call(this, dataURL);
        canvas = null; 
    };
    img.src = url;
}

That’s it ! 

Até a próxima !

Registrando o Sublime Text 2

O Sublime Text é um editor de texto e código-fonte multiplataforma, escrito em linguagem C++. Inicialmente, o programa foi pensado para ser uma extensão do Vim. Este editor oferece recursos extraordinários e um desempenho simplesmente surpreendente. Hoje em dia muitos programadores (incluindo eu, rsrs) usam este excelente editor de texto para suas tarefas, por ser mais leve, dinâmico, sem muitas features que os IDE’s trazem para o nosso cotidiano de desenvolvimento, que talvez, nós nem utilizamos com frequência.

Pensando nisso, vamos tirar aquele (UNREGISTERED) que aparece na barra superior ? … Mas, lembrando que o sublime é uma ótima ferramenta e não custa ajudar , ele custa apenas $70.


But, LET’s GO !

ATENÇÃO

Para o sistema operacional Windows pode apenas copiar a chave de licença que encontra-se no final deste post.

A licença abaixo funciona em qualquer sistema operacional, mas no linux pode haver problemas para registrar precisando executar os procedimentos abaixo.

fixing sublime text 2 error license key

Abra a pasta onde o sublime foi descompactado /opt/sublime_text_2, dentro desta pasta existirá o executável sublime_text
execute o comando abaixo para editar o stream do binário pela expressão regular :

sudo sed 's/\x33\x42/\x32\x42/g' sublime_text > sublime_crack

Após este comando, o output irá gera um novo arquivo chamado sublime_crack, o qual permitirá você inserir a licença pelo aplicativo.
Execute o comando abaixo para remover o antigo sublime_text e renomear o arquivo sublime_crack :

sudo rm sublime_text && mv sublime_crack sublime_text

Execute o comando chmod abaixo, para torna-lo em um executável :

sudo chmod 777 sublime_text

Agora abra o sublime text e vá até o menu help->Enter License e adicione a licença abaixo:

incluindo o —–BEGIN LICENSE—– e o —–END LICENSE—–

-----BEGIN LICENSE-----
Patrick Carey
Unlimited User License
EA7E-18848
4982D83B6313800EBD801600D7E3CC13
F2CD59825E2B4C4A18490C5815DF68D6
A5EFCC8698CFE589E105EA829C5273C0
C5744F0857FAD2169C88620898C3845A
1F4521CFC160EEC7A9B382DE605C2E6D
DE84CD0160666D30AA8A0C5492D90BB2
75DEFB9FD0275389F74A59BB0CA2B4EF
EA91E646C7F2A688276BCF18E971E372
-----END LICENSE-----

That’s it !


Para usuários do Mac segue os passos para registrar o sublime (Dicas do Leandro Barbosa)

No Mac, acesse o terminal e faça o seguinte:

cd Applications/Sublime\ Text\ 2.app/Contents/MacOS/

sed ‘s/\x33\x42/\x32\x42/g’ Sublime\ Text\ 2 > sublime_crack

mv sublime_crack Sublime\ Text\ 2

Dica do dia : Como remover acentuação C#

Após muito tempo longe do blog (me desculpem) estou voltando aos poucos, esses dias estava em uma rotina para impressão em uma impressora térmica e me deparei com o seguinte problema : “Não aceita acentuação !! ” Porque ? Alguns aparelhos de impressão não possuem configurações para este tipo de trabalho fazendo com que altere o caractere para um encoder não especifico.

Sendo assim montei esse carinha aqui :

public string RemoveAccents(string text)
{
StringBuilder sbReturn = new StringBuilder();
var arrayText = text.Normalize(NormalizationForm.FormD).ToCharArray();

foreach (char letter in arrayText)
{
if (CharUnicodeInfo.GetUnicodeCategory(letter) != UnicodeCategory.NonSpacingMark)
sbReturn.Append(letter);
}
return sbReturn.ToString();
}

Espero que possa ajudar quem possa estar com algo parecido, ou use para outras rotinas …

Ainda estou um pouco “enferrujado” para escrita, mas com o tempo volto a escrever como antes …

Muito Obrigado pelas visitas e até a prox. !!

Gestão de Processos em metodologia Ágil (SCRUM)

 Andei um pouco afastado do Blog por falta de tempo (Profissão, Musica, etc…), mas vou voltando aos poucos… 😉 Esses últimos dias tive que recapitular algumas coisas sobre gestão de processos, e vou publicar aqui um descritivo sobre metodologia ágil (SCRUM)

A Metodologia SCRUM apenas estabelece conjuntos de regras e práticas de gestão que devem ser adotadas para garantir o sucesso de um projeto. Centrado no trabalho em equipe, melhora a comunicação e maximiza a cooperação, permitindo que cada um faça o seu melhor e se sinta bem com o que faz o que mais tarde se reflete num aumento de produtividade. Englobando processos de engenharia, este método não requer nem fornece qualquer técnica ou método específico para a fase de desenvolvimento de software. As principais características do SCRUM são:

  • é um processo ágil para gerenciar e controlar o desenvolvimento de projetos;
  • é um wrapper para outras práticas de engenharia de software;
  • é um processo que controla o caos resultante de necessidades e interesses conflitantes;
  • é uma forma de aumentar a comunicação e maximizar a cooperação;
  • é uma forma de detectar e remover qualquer impedimento que atrapalhe o desenvolvimento de um produto;
  • é escalável desde projetos pequenos até grandes projetos em toda empresa.

Comunidade Brasileira de Desenvolvedores