Olá a todos, quero fazer aqui uma série de receitas prontas exemplificando diversos recursos úteis da lib win que faz parte do conjunto nativo de bibliotecas de funções de Prisma.
Nela vamos encontrar algumas funções realmente importantes, como obter Pasta e nome do usuário, pasta system32, data, eventos como pressionar de tecla, fechar ou ocultar janelas abertas, mensagem box entre outros recursos.
Pretendo aqui enumerá-los em ordem um a um e explicando como usar, não ficará terminada, sempre estará
em constante mudanças para acrescentar novas funções:
Mãos à obra:
Pausar a execução do programa:
win.Durma (tempo) ; //ou win.Aguarde (tempo ) ; //onde tempo é em milisegundos:
1 2 3 4 |
inclua'win' win.Durma( 1000 ); //para o programa por 1 segundo ( ou mil milisegundos); win.Aguarde ( 1000 ); // mesma função só mudou o nome! |
Obtendo o Nome do Usuário:
win.ObtNomeUsuario ( ) ; //retorna o nome do usuário do sistema em uma string.
ex.:
1 2 |
inclua'win' imprima ("O usuario deste computador e " .. win.ObtNomeUsuario ( ) ); //a saída é o nome do usuário logado. |
Obtendo a pasta Temp:
win.ObtPastaTemp() ; //retorna a pasta temp do sistema;
ex.:
1 2 |
inclua'win' imprima ( "O local Temp deste computador fica em " .. win.ObtPastaTemp ( ) ); //imprima o diretório Temp do computador. |
Obtendo a pasta System:
win.ObtPastaSystem ( ); //retorna uma string do endereço da pasta system do Windows
ex.:
1 2 |
inclua'win' imprima ( "A pasta system deste computador fica em " .. win.ObtPastaSystem( ) ); |
Obtendo o Tempo Local:
win.ObtTempoLocal ( ); // retorna uma tabela contendo os campos Hora, Minuto , Segundo , Milisegundos, Dia , Mes , Ano,
DiaDaSemana ;
ex.:
1 2 3 4 5 6 7 8 9 10 |
inclua'win' tempo = win.ObtTempLocal ( ); //atribuindo a tabela //usando a tabela: imprima( tempo.Dia .. "/" .. tempo.Mes .. "/" .. tempo.Ano .. "nn"); imprima ( tempo.Hora .. ":" .. tempo.Minuto .. ":" .. tempo.Segundo .. "nn"); // as saídas serão: dia/mes/ano e hora:minuto:segundo locais; |
Obtendo Pasta Windows:
win.ObtPastaWindows ( ); //retorna o local da pasta WINDOWS;
ex.:
1 2 3 4 |
inclua'win' pastawin = win.ObtPastaWindows ( ); //colocando numa variável; imprima ( pastawin ); //imprimindo o resultado; |
Copiar Aquivo:
win.CopieArquivo( ) : função muito importante, com ela você copia um arquivo, não importa o formato, a cópia é igual ao
arquivo original. Ex.:
1 2 |
inclua'win' win.CopieArquivo('arquivo.txt' , 'arquivo_copia.txt'); //( original , destino ) |
Mover Arquivo:
win.MovaArquivo ( “origem” , “destino”); //move um arquivo origem para destino;
ex:
1 2 |
inclua'win' win.MovaArquivo( "teste.txt" , "pasta/teste_movido.txt" ); //arquivo teste.txt movido para pasta/teste_movido.txt; |
Deletar arquivo:
win.DeleteArquivo (nome_arquivo ): Muito útil para apagar arquivos, tome cuidado o processo é irreversível, o arquivo não vai para a lixeira, ele é apagado definitivamente.
Ex.:
1 2 |
inclua'win' win.DeleteArquivo('arquivo.txt'); |
Dica: use o asterisco para apagar vários arquivos de mesma extensão, ex. “caminho_pasta/*.ext” neste caso apagará todos os
arquivos .ext dentro da pasta “caminho_pasta/”;
Capturando o identificador de uma janela pelo título
1 2 |
inclua'win' id_janela = win.ProcureJanela ( 0 , "titulo_da_janela"); |
Esta função serve para pegar o id (hwnd em windows.h) de uma janela através do texto da barra de título.
Isto é muito útil para manipular uma janela externa ao programa por meio de seu id.
Ativando e desativando uma janela
win.AtiveJanela ( id_janela , valor ); // onde valor é falso para desativar e verdadeiro para ativar a janela.
Ex.: (antes de executar este exemplo abra a calculadora do Windows );
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
//pegando o id da janela da calculadora pelo título: inclua'win' id_janela = win.ProcureJanela ( 0 , "Calculadora" ); imprima "nnA calculadora ira travar, aperte Enter para continuar:nn"; leia(); win.AtiveJanela( id_janela , falso ); //desativa a janela da calculadora pois o segundo parâmetro é o 'falso'; imprima "A calculadora ja esta travada, tente fecha-la ou move-la, para ativa-la pressione enter...nn"; leia(); win.AtiveJanela ( id_janela , verdadeiro ); //ativa a janela da calculadora; imprima "Calculadora ativada, pode fecha-la agora.nn" |
Testando se uma tecla foi ativada ou desativada
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
// obtendo o estado de uma tecla inclua'win' tecla = 20 ; //numero da tecla capslock no teclado enquanto 1 inicio //laço infinito, para fechar o programa clique no x da janela cmd win.Durma ( 200 ); //parando o programa por 200 milisegundos sis.execute( "cls"); //executa um comando do sistema operacional, 'cls' limpa tela ret = win.ObtEstadoTecla ( tecla ); se ret == 0 entao imprima 'Capslock desativado' fim se ret == 1 entao imprima 'Capslock ativado' fim fim //observe que mesmo a janela do programa estando sem foco, o comando funciona blz, //Util para fazer key loggers. //engraçado que no xp a mensagem ativado so aparece se clicar em outra tecla. No win8 nao acontecia isso |
Capturando as teclas digitadas, mesmo se o programa estiver em segundo plano
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
//funcoes da biblioteca win para se fazer um key logger inclua'win' sis.execute("cls"); imprima('Pressione Esc para sair'); enquanto 1 inicio //inicia um laço infinito //para usar este exemplo com o igprisma(interface 'igbr') use um temporizador //com 1 milisegundo de tempo no lugar do enquanto. win.Durma( 1 ) ; //para a execução durante 1 milisegundo para x = 1 , 255 inicio ret = win.CaptureTecla ( x ); se ret == win_tecla_pressionada entao //testa de 1 a 255 sis.execute("cls"); imprima ( "Pressione Esc para sair"); //imprimindo o número da tecla pressionada e uma possível conversão para caractere. imprima ('o n' .. string.car( 163) .. 'mero ' .. x .. ' ' .. string.car(130) .. ' ' .. string.car( x ) ); se x == 27 entao saindo = 'x' quebre fim // 27 é o número da tecla ESC fim //fim do se fim //fim do para se saindo == 'x' entao quebre fim fim //fim do enquanto sis.execute('cls'); //lembre-se se estiver usando linux no lugar de cls é clear ok! poe'Esc pressionado .... saindo do programa ...\n\n' win.Durma( 2000 ); //espera 2 segundos e sai do programa //apos a mensagem saindo do programa ... //usei um loop (laço) 'para' imprimindo os 255 numeros em forma de caractere com a função car para i = 1 , 255 inicio imprima ( i .. ' = ' .. car ( i ) ); fim leia(); |
1 |
Obtendo o Título da janela do cmd e o ambiente de execução do programa ( pasta atual ):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
//por Adalberto //obtendo titulo da janela de console( cmd ) , e a pasta corrente. (atual). inclua'win' titulo = win.ObtTituloConsole ( 299 ) ; // obtendo o titulo (em C uma string de no maximo 299 caracteres; pasta_atual = win.ObtPastaAtual ( ) ; //sem o parametro tamanho, o padrão é 255; win.CaixaMensagem ( nulo , titulo , 'exemplo' , win_mb_Ok ); win.Msg ( nulo , pasta_atual , "meu diretorio atual" , win_mb_OkCancelar ); leia( ); |
Definindo a pasta atual:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
//por Adalberto -- definindo a pasta atual ( current directory ) inclua'win' pasta = win.ObtPastaAtual (); //retorna string da pasta atual imprima ('nnPasta Atual: ' .. pasta); poe 'Pressione ENTER para continuarn' ; leia ( ); mude_dir = win.DefPastaAtual ( pasta .. '/exemplos/Win/' ); //define outra pasta atual pasta = win.ObtPastaAtual (); //novamente retornando o endereco da pasta atual (já mudada) se mude_dir == 1 entao imprima ( 'O novo diretorio atual :n ' .. pasta ) senaose mude_dir == 0 entao imprima 'O diretorio atual nao foi modificado' fim executearquivo( 'win_usuario.prisma'); //aproveitando para demonstrar como executar um arquivo prisma leia( ); //aguarda o usuário digitar algo e apertar enter, ou simplesmente pressionar enter. //diretorio ou pasta atual é o local padrão quando você, por exemplo, não quiser passar um //caminho completo de um arquivo, automaticamente será o caminho da pasta atual. |
Definindo o título do console do Windows (cmd):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
//por Adalberto - Definindo o titulo da janela de console: inclua'win' enquanto 1 inicio imprima'digite alguma palavra e aperte enter'; titulo = leia( ); x = win.DefConsoleTitulo ( titulo ); //a funçao que muda o titulo é esta se x == 1 entao imprima 'titulo do console foi mudadonn' senao imprima 'titulo nao foi mudadon' ; fim fim leia ( ); |
No exemplo acima compliquei um pouquinho fazendo um laço enquanto e atribuindo o texto digitado pelo usuário
como título do console, mas a função é simples como você pode ver: win.DefConsoleTitulo ( “string titulo” );
o retorno pode ser 1 ou 0. Se for zero significa que não deu certo a operação, se for 1 teve sucesso na operação.
Obtendo a posição x e y do cursor na tela do computador:
1 2 3 4 5 6 7 8 9 10 |
//obtendo a posicao do cursor em relacao a tela do pc inclua'win' pos = win.ObtPosCursor( ); imprima( pos.x , pos.y ); poe('Pressione Enter para continuar...'); leia(); |
Como fui fiel ao windows.h, o x é a coluna e o y é a linha;
Caso você queira obter apenas a linha use o seguinte modo:
linha = win.ObtenhaPosCursor( ).y ; //observe o ponto e o y no fim da função, se chama acesso direto a um campo de retorno.
para a coluna:
colunaMouse = win.ObtenhaPosCursor( ).x ;
//isso pode ser feito com qualquer função que retorna uma tabela, inclusive com a função que retorna data e hora!
Definindo a posição do cursor na tela:
1 2 |
inclua'win' win.DefPosCursor(2 , 12 ); |
Obtendo o id da janela em foco:
1 2 |
inclua'win' jan_id = win.ObtJanelaEmFoco(); //pega o id da propria janela se estiver ativada |
Obtendo o título da janela:
1 2 3 4 |
inclua'win' jan_id = win.ObtJanelaEmFoco(); //pega o id da propria janela se estiver ativada titulo = win.ObtJanelaTexto(jan_id); //obtem o titulo da janela obtida pelo id imprima(titulo); //imprime na tela do dos o resultado; |
Definindo o título da janela:
1 2 3 |
inclua'win' jan = win.ObtJanelaEmFoco(); win.DefJanelaTexto( jan , 'novo titulo' ); |
Fechando a janela:
1 2 3 |
inclua'win' id = win.ObtJanelaEmFoco(); //obtem o id da propria janela do programa win.FecheJanela( id ); |
Tocando sons do sistema e wav’s:
baixe o beat.wav aqui, ou use outro de sua preferência.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
inclua'win' caminho_som = 'som/beat.wav' ; x = win.PlaySom( caminho_som ); //quando so informado o nome do arquivo // o padrão é em modo playback // isto significa que o programa continua //enquanto a musica é tocada em fundo se x entao imprima'som tocando com sucesso!' senao imprima'erro não foi possível tocar o som' fim sis.execute('pause'); //tocando um som do sistema imprima'\n\ntocando o som de inicializacao do sistema' win.PlaySom( "SystemStart", SOM_ALIAS); // toca o som de abertura do windows. //tocando um som de evento do win.ini keys imprima'\n\ntocando o sons de evento do win' imprima'\nHand:'; win.PlaySom( "SystemHand", SOM_NODEFAULT); imprima'\nExit:'; win.PlaySom("SystemExit", SOM_NODEFAULT); imprima'\nExclamation:'; win.PlaySom( "SystemExclamation", SOM_NODEFAULT); imprima'\nAsterisk:\n\n'; win.PlaySom( "SystemAsterisk", SOM_NODEFAULT); sis.execute('pause'); |
Caixa de mensagem:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 |
// by Adalberto // example of message box inclua'win' repita //comando repita , repete os comandos que estao entre ele e a condicao 'ate' //simples ret = win.CaixaMensagem( nulo , 'o texto da mensagem aqui', 'o titulo', win_mb_Ok ); se ret == win_mb_ret_Ok entao imprima('foi pressionado o botao ok') senao imprima'fechar' fim //with more buttons ret = win.CaixaMensagem( nulo , 'o texto da mensagem aqui', 'o titulo', win_mb_OkCancelar ); se ret == win_mb_ret_Ok entao imprima 'ok' senaose ret == win_mb_ret_Cancelar entao imprima 'cancelar' senao imprima'fechar' fim //mais botoes e icones ret = win.CaixaMensagem( nulo , 'o texto da mensagem aqui', 'o titulo', bit32.bor( win_mb_SimNaoCancelar , win_mb_IconeQuestao ) //quando é mais de um botao devemos usar a funcao bit or para aceitar varios botoes ou icones de uma so vez ); se ret == win_mb_ret_Sim entao imprima 'sim'; senaose ret == win_mb_ret_Nao entao imprima 'Nao' ; senaose ret == win_mb_ret_Cancelar entao imprima 'cancelar' fim //mais botoes e icones ret = win.CaixaMensagem ( nulo , 'o texto da mensagem aqui', 'o titulo', bit32.bor ( win_mb_AnularRepetirIgnorar , //botao abortar, Tentar Novamente e Ignorar win_mb_IconeAsterisco ) ); se ret == win_mb_ret_Anular entao //em alguns casos o botao aparecera com o label 'anular' ao inves de 'abortar', o resultado é o mesmo! imprima 'Anulado' senaose ret == win_mb_ret_Repetir entao imprima 'Repetir' senaose ret == win_mb_ret_Ignorar entao imprima 'ignorado' fim ate ret == win_mb_ret_Anular ; //repete ate que ret seja o retorno de um botao abortar da mensagem es.leia(); ///aguarda uma tecla ser pressionada pelo usuario |
Veja outros argumentos que você pode usar:
/**
alguns botoes de mensagem:
win_mb_Ok
win_mb_OkCancelar
win_mb_AnularRepetirIgnorar
win_mb_Applmodal
win_mb_Combinar
win_mb_cur_max
win_mb_SimNao
win_mb_SimNaoCancelar
Alguns icones:
win_mb_IconeInformacao
win_mb_IconeAsterisco
win_mb_IconeErro
win_mb_IconeExclamacao
win_mb_IconeMao
win_mb_IconeMascara
win_mb_IconeQuestao
win_mb_IconePare
win_mb_IconeAdvertencia
Alguns retornos de botoes:
são variaveis de numeros, bastando descobrir o numero nem
precisa usar o nome do retorno, exemplo: Anular = 3;
win_mb_ret_Sim
win_mb_ret_Nao
win_mb_ret_Ok
win_mb_ret_Cancelar
win_mb_ret_Abortar = Anular
win_mb_ret_Anular
win_mb_ret_TentarNovamente = Repetir
win_mb_ret_Repetir
win_mb_ret_Ignorar
**
Resolução da tela:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
inclua'win' x = win.DefResolucao( 1024 , 768) //muda a resolucao da tela se x == 1 entao imprima '\n\nResolucao alterada com sucesso\nAguardando 3 segundos para voltar ao normal\n\n' senao imprima ( 'Houve um erro Resolucao nao alterada') se x == -1 entao imprima '\nconfiguracao do display indisponivel\n' senaose x== -2 entao imprima '\nResolucao invalida para este monitor\n' fim fim win.Durma( 3000 ) ; //aguarda 3 segundos win.DefResolucaoPadrao (); // volta ao normal a tela sis.execute ( 'pause'); // tente aprimorar este programa fazendo uma interface grafica para ele // pode usar botoes para cada resolucao ... ou um combo |
Obtendo a resolução (altura e largura) da tela:
Passando o parâmetro que especifica se é altura ou largura (res_altura / res_largura):
1 2 3 4 5 6 |
inclua'win' altura = win.ObtResolucao(res_altura); largura = win.ObtResolucao( res_largura); imprima( "sua tela = " , largura .. " x " .. altura ) |
Sem especificar altura ou largura ( o retorno é duplo):
1 2 3 4 |
inclua'win' alt , larg = win.ObtResolucao(); imprima( alt , larg ); |
(baixe prisma versão 1.0.9 ) aqui
Minimizando, maximizando, ocultando e mostrando uma janela:
comando: win.MostreJanela ( id_da_janela , sw_modo );
1 2 3 4 5 6 7 8 9 10 |
inclua'win' //abra a calculadora do windows antes de executar id = win.ProcureJanela(0,"Calculadora") ; //pegando o id da calculadora pelo titulo. //ocultando imprima'calculadora ocultada, pressione enter para aparecer'; win.MostreJanela( id , sw_oculte ); leia(); //aguarda pressionar enter; win.MostreJanela( id , sw_mostrenormal ); //e a calculadora reaparece |
veja outros modos:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
"sw_oculte /// (oculta a janela) sw_mostre ///(mostra a janela /nao funciona apos minimizar) sw_maximize ///(maximiza) sw_minimize ///(minimiza) sw_forceminimize; ///minimiza forçado, deve ser utilizado sempre com janela em outro processo. sw_restaure ; /// restaura ativando a janela em tamanho original sw_mostrepadrao ; /// Define o estado mostra com base no valor SW_ especificado na estrutura STARTUPINFO passado para a função CreateProcess pelo programa que iniciou o aplicativo. sw_mostremaximizado // ativa a janela e mostra maximizado sw_mostreminimizado; ///ativa a janela e mostra minimizado; sw_mostreminnaoativo ///mostra minimizado nao ativado sw_mostrena ///mostra a janela no modo atual anterior mas nao ativado sw_mostrenaoativo ///mostra a janela no tamanho e posição mais recente, porém não ativada sw_mostrenormal; /// ativa e mostra a janela na posição padrão dela. |
(Novidades! A partir daqui baixe Prisma: 12/10/2015 ou mais recente.)
A partir desta versão é necessário incluir a biblioteca win. Veja:
1 |
inclua'win'; //só isso! |
win.Execute(…);
Executa programas ou arquivos a partir de seu programa Prisma:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 |
inclua'win'; // a partir da versão Prisma-1.0.94 win é separada de prisma //sendo necessário incluí-la. //chamando a calculadora no diretório C:\: win.poe(conv_w'Vamos abrir a calculadora a partir do diretório C:\\\n\n clique ok'); win.Execute(nulo , 'open' , 'calc' , '' , 'C:\\' ); //note que foi omitido o último parâmetro, o padrão é sw_mostre(mostra a janela normal); win.poe(conv_w[[Abrindo a pasta C:\Prisma\1.0\bin\: clique ok]]); //abrindo a pasta C:\Prisma\1.0\bin\: win.Execute(nulo,'explore' , 'C:\\Prisma\\1.0\\bin\\', '' , '', sw_maximize ); win.poe(conv_w[[abrindo um site com navegador padrão: clique ok]]); //abrindo um site com navegador padrão: win.Execute(nulo,nulo,'www.linguagemprisma.br4.biz/blog' , '', '' , sw_maximize ); //note que o segundo parâmetro foi omitido, nulo no lugar de algum valor, o padrão é 'open' (abrir); win.poe(conv_w[[ executando um programa com parâmetros: clique ok]]); //executando um programa com parametros: win.Execute(nulo, //hwnd de uma janela '' , //modo; aqui foi omitido com aspas vazias, o padrão é abrir o alvo. 'C:\\Prisma\\1.0\\bin\\prismacod.pbrexe' , //arquivo ou programa a ser aberto(alvo) 'teste.prisma' , //parametros '.' , //diretório de execução (ponto indica a pasta atual) sw_maximize // visual => maximizado ); win.poe(conv_w[[ abrindo o wordpad com pedido de permissão de privilégios clique ok]]); //abrindo o wordpad com pedido de permissão de privilégios win.Execute( nulo , 'runas', 'wordpad' , '' , '.' , sw_maximize ); win.poe(conv_w[[ P R I S M A .............FIM................. Clique ok para sair! ]]); |
DETALHES:
Sintaxe: win.Execute( id , modo, alvo , param , diretorio , visual ); em que:
id = nulo ou o hwnd de uma janela.
modo – é uma string que indica a forma de chamar o alvo. Veja abaixo as opções de modos:
- “” ou nulo – string vazia ou nulo – apenas chama o alvo.
- “edit” – chama um arquivo de texto para ser editado em seu programa padrão, ex. *.prisma abre com prismacod
- “open” – chama qualquer documento e o abre com seu programa padrão. Menos os da modalidade “edit”
- “runas” – executa um programa *.exe pedindo permissão de privilégio administrador.
- “explore” – abre o explorador de arquivos, na pasta indicada em alvo.
- “find” – abre uma página de pesquisa de arquivos na pasta indicada em alvo.
- “print” – imprime o arquivo indicado em alvo.
alvo = é o arquivo, endereço, ou diretório a ser executado. (Lembre-se que “.” significa diretório atual)
param = são os parâmetros passados para o alvo. Deixe espaço entre os parâmetros. Ex.: ” -o file.out file.in -std=c99 ”
diretorio = string que indica a pasta onde será o ambiente de execução. Geralmente na mesma pasta do arquivo a ser aberto.
visual = Variável predefinida em win que indica se o arquivo ou programa será aberto minimizado, maximizado, normal, oculto etc. Sempre inicia com sw_ (Show_Window); Eis algumas delas a seguir:
- sw_minimize , sw_mostre , sw_maximize , sw_oculte;
win.poe(string)
Emite uma mensagem de alerta com botão ok. Sintaxe: win.poe(“string”). Muito simples não possui título a mensagem.
(Pensei em dar o nome do comando win.Alerte, mas, por questão de simplicidade e menos letras, escolhi win.poe mesmo. Acho que um dos únicos comandos com inicial minúscula da biblioteca win. // poe vem de põe, ou seja, coloque o resultado na tela, exiba etc.)
O parâmetro string pode ser qualquer string válida. Ex.:
1 2 3 |
inclua 'win' win.poe("Clique em OK para continuar"); |
win.CriePasta(‘string’)
Cria um diretório vazio. O argumento deve ser uma string válida.
Você pode passar um caminho completo como: “C:\\Caminho\\nomePasta”
ou o nome da pasta apenas: “NomePasta”. Neste caso o destino será a pasta atual do programa sendo executado.
1 2 3 |
inclua'win' win.CriePasta("ZZ_PASTA"); win.poe( win.ObtErroMsg() ); |
win.ObtErroMsg( )
Retorna uma string com a mensagem do último erro ou sucesso até o momento de sua chamada. A saída vai ser de acordo com o idioma definido pelo usuário. Ex.:
1 2 3 |
inclua 'win' win.CopieArquivo('xxx' , 'yyyy'); win.poe( win.ObtErroMsg() ); //será o erro de arquivo não encontrado. |
Obs. que a mensagem já vem codificada para conv_w, mostra acentos no modo gráfico win32, e não para conv_c que mostra acentos no modo console (cmd/dos).
Caso você queira imprimir no cmd com acentos terá que reverter a string e depois converter para conv_c assim:
1 2 |
s = desconv_w( win.ObtErroMsg() ); //reverte a string do modo conv_w para o modo normal imprima( conv_c(s) ); //converte do modo normal para o modo console(conv_c), mostra acentos no cmd(tela preta) |
string_c = conv_c ( “string”)
Faz com que uma string seja mostrada com acento no cmd, tela preta de comandos.
Exemplo:
1 2 3 4 5 6 |
inclua'win' str = "Olá mundo em Prisma, céu, você, maçã etc."; imprima( "Sem converter:", str ); imprima( "Convertido:" , conv_c(str) ); win.poe"terminado, clique em ok"; |
Note que apesar dessa função não iniciar com win. é necessário incluir a biblioteca win onde ela está declarada.
Obs. Caso queira reverter o processo, use str = desconv_c( str_c );
Saída:
str_w = conv_w(‘str’)
Faz com que strings com acentos sejam exibidas normalmente no modo gráfico (_w = win32); Em mensagens, títulos de janela etc. Somente em funções da lib win, o ig não precisa pois o gtk já é preparado para utf8.
ex.:
1 2 3 4 |
inclua'win'; str = 'é olá você maçã etc' win.poe(str); //a letra com acento sai errada win.poe( conv_w(str) ); //sai com acento. |
1: 2:
Caso você obtenha uma str no modo conv_w e queira reverter para o modo normal use:str = desconv_w(str_w);
Continua… (funções do registro em breve)
linguagemprisma@gmail.com
Att. Adalberto