Java, C/C++, Python, C#, LISP, AutoLisp, AutoCAD e VBA
PHP, Python, C#, JavaScript, Laravel, Google Ads e SEO

Você está aqui: Cards de Ética e Legislação Profissional
Card 1 de 8
Noções de licitação pública

Modalidades da licitação:

Convite é a modalidade dirigida para interessados do ramo do objeto da licitação e é adequado para contratações de menor valor. Na Lei n.º 14.133/2021, essa modalidade foi extinta.

Leilão é a modalidade para a venda de bens móveis que não servem mais para a administração pública, a venda de produtos legalmente apreendidos ou penhorados e para a alienação de imóveis da administração pública.

Concurso é a modalidade indicada para a escolha de um trabalho técnico, artístico ou científico.

Pregão é a modalidade de licitação para aquisição de bens e serviços comuns. No artigo 1º, parágrafo único, da Lei n.º 10.520/2002, consta que bens e serviços comuns são "aqueles cujos padrões de desempenho e qualidade possam ser objetivamente definidos pelo edital, por meio de especificações usuais no mercado". Isso significa que são bens e serviços que não têm características técnicas especiais, sendo facilmente encontrados no mercado. O pregão também foi previsto na nova lei de licitações, no artigo 28, i.

Concorrência é a modalidade indicada para contratações de grandes valores, em que o interessado precisa comprovar a qualificação exigida no edital.

Filtrar Cards
Use esta opção para filtrar os cards pelos tópicos que mais lhe interessam.
Termos:
Aviso Importante: Nos esforçamos muito para que o conteúdo dos cards e dos testes e conhecimento seja o mais correto possível. No entanto, entendemos que erros podem ocorrer. Caso isso aconteça, pedimos desculpas e estamos à disposição para as devidas correções. Além disso, o conteúdo aqui apresentado é fruto de conhecimento nosso e de pesquisas na internet e livros. Caso você encontre algum conteúdo que não deveria estar aqui, por favor, nos comunique pelos e-mails exibidos nas opções de contato.
Link para compartilhar na Internet ou com seus amigos:

Delphi ::: Dicas & Truques ::: MIDI Musical Instrument Digital Interface, Mapeamento e sequenciamento MIDI, Entrada e saída MIDI

Como abrir e fechar um dispositivo de saída MIDI usando Delphi

Quantidade de visualizações: 11585 vezes
Quando queremos executar sons MIDI no Windows, a primeira tarefa a ser realizada é abrir o dispositivo de saída MIDI. Isso é feito com uma chamada à função midiOutOpen() da API do Windows. Veja sua assinatura (em C):

MMRESULT midiOutOpen(
  LPHMIDIOUT lphmo,              
  UINT_PTR   uDeviceID,          
  DWORD_PTR  dwCallback,         
  DWORD_PTR  dwCallbackInstance, 
  DWORD      dwFlags             
);

Esta função está traduzida na unit MMSystem.pas do Delphi da seguinte forma:

function midiOutOpen(lphMidiOut: PHMIDIOUT; uDeviceID: UINT;
  dwCallback, dwInstance, dwFlags: DWORD): MMRESULT; stdcall;

Antes de continuarmos, vamos entender os parâmetros desta função:

lphmo - Este é um ponteiro para um HMIDIOUT (que é simplemente um Integer). Este ponteiro é preenchido com um handle identificando o dispositivo de saída MIDI aberto. Este handle é usado para identificar o dispositivo nas demais chamadas de saída MIDI.

uDeviceID - Identificador do dispositivo de saída MIDI a ser aberto. O valor 0 aqui é seguro, visto que este identifica o primeiro dispositivo na lista de dispositivos de saída. Veja minha dica "Como obter uma lista dos dispositivos de saída MIDI no sistema" para mais informações.

dwCallback - Um ponteiro para uma função de callback, um handle de evento, um identificador de thread ou um handle para uma janela ou thread chamada durante o playback do MIDI para processar mensagens relacionadas ao processo de playback. Se não houver nada a ser processado, podemos definir o valor 0 para este parâmetro. Dê uma olhada na minha dica relacionada à função MidiOutProc().

dwCallbackInstance - Dados de instância do usuário passados para a função de callback. Este parâmetro não é usado em callbacks de janela e thread. É seguro manter seu valor como 0.

dwFlags - Flag de callback para abrir o dispositivo. Por enquanto vamos manter seu valor como CALLBACK_NULL. Veja minhas outras dicas sobre o assunto para aprofundar mais neste parâmetro.

Agora que aprendemos mais sobre os parâmetros da função midiOutOpen(), vamos ver como usá-la para abrir um dispositivo de saída MIDI e tocar a nota DÓ média (aquela no meio da escala de notas possíveis). Veja o código completo para a unit:

unit Unit2;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, MMSystem;

type
  TForm2 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
    dispositivo: HMIDIOUT; // dispositivo de saída MIDI
  public
    { Public declarations }
  end;

var
  Form2: TForm2;

implementation

{$R *.dfm}

procedure TForm2.Button1Click(Sender: TObject);
var
  erro: Word;
begin
  erro := midiOutOpen(@dispositivo, 0, 0, 0, CALLBACK_NULL);

  // houve erro na abertura do dispositivo de saída MIDI?
  if (erro <> 0) then
    begin
      ShowMessage('Não foi possível abrir o dispositivo MIDI. Erro: ' + IntToStr(erro));
    end
  else
    begin
      ShowMessage('Dispositivo MIDI aberto com sucesso.');

      // vamos tocar uma nota para nos certificarmos de que o dispositivo
      // realmente foi aberto e está funcionando

      // vamos tocar a nota DÓ média e com velocidade máxima
      midiOutShortMsg(dispositivo, rgb($90, 60, 127));
      // vamos deixar a nota soar um pouco
      sleep(1000);
      // vamos silenciar a nota
      midiOutShortMsg(dispositivo, rgb($80, 60, 0));

      // finalmente vamos fechar o dispositivo MIDI
      midiOutClose(dispositivo);
    end;
end;

end.

O primeiro passo foi declarar uma variável do tipo HMIDIOUT:

dispositivo: HMIDIOUT;

Este é o dispositivo de saída que será usado nas demais chamadas MIDI, incluindo a função midiOutClose(), usada para fechar o dispositivo:

midiOutClose(dispositivo);

Na API do Windows está função está declarada da seguinte forma:

MMRESULT midiOutClose(
  HMIDIOUT hmo  
);

Na unit MMSystem.pas do Delphi está função está traduzida da seguinte forma:

function midiOutClose(hMidiOut: HMIDIOUT): MMRESULT; stdcall;

Veja que só precisamos fornecer o nome da variável representando o dispositivo de saída MIDI aberto no momento para que a função se encarregue de fechá-lo.


Delphi ::: Data Controls (Controles de Dados) ::: TDBGrid

Como definir ou retornar a cor de fundo de uma determinada coluna do TDBGrid do Delphi

Quantidade de visualizações: 9614 vezes
Em algumas situações gostaríamos de definir a cor de fundo de uma determinada coluna do DBGrid. Isso pode ser feito por meio da propriedade Color da classe TColumn.

Em tempo de design a cor de fundo de um coluna pode ser definida clicando-se com o botão direito do DBGrid e escolhendo a opção Columns Editor. Em seguida clique na coluna desejada e ajuste sua propriedade Color no Object Inspector.

Em tempo de execução podemos definir a cor de fundo para uma coluna usando o seguinte trecho de código:

procedure TForm3.Button3Click(Sender: TObject);
begin
  // vamos definir a cor de fundo para a primeira coluna
  DBGrid1.Columns[0].Color := Graphics.clYellow;
end;

Veja que eu defini a cor de fundo como sendo uma das constantes definidas na unit Graphics. Lembre-se de que também podemos fornecer um valor RGB.

Veja agora um trecho de código que mostra como obter a cor de fundo da coluna:

procedure TForm3.Button3Click(Sender: TObject);
begin
  // vamos obter a cor de fundo da primeira coluna
  ShowMessage('A cor de fundo da coluna é: ' +
    ColorToString(DBGrid1.Columns[0].Color));
end;

Ao executarmos este código temos uma mensagem parecida com:

"A cor de fundo da coluna é: clSilver".

Esta dica foi escrita e testada no Delphi 2009.


Java ::: Dicas & Truques ::: Strings e Caracteres

Como transformar um StringBuffer em uma String usando o método toString() da classe StringBuffer

Quantidade de visualizações: 2 vezes
Como já vimos em dicas anteriores, um objeto da classe String é imutável, ou seja, quando modificamos o conteúdo de uma String, o interpretador cria um novo objeto, copiando o conteúdo da string anterior para o objeto recém-criado. Já a classe StringBuffer é mutável, ou seja, podemos modificar o seu conteúdo sem a necessidade da criação de um novo objeto.

Você ficará surpreso ao saber que não podemos atribuir uma variável do tipo StringBuffer em uma variável do tipo String e vice-versa. Ao tentarmos fazer isso, os seguintes erros de compilação são exibidos:

a) error: incompatible types: StringBuffer cannot be converted to String
b) error: incompatible types: String cannot be converted to StringBuffer

Assim, sempre que for necessário converter um StringBuffer em uma String, temos que usar o seu método toString(). Veja:

package arquivodecodigos;

// Este exemplo mostra como converter um
// StringBuffer em uma String

public class Estudos{
  public static void main(String[] args){
    StringBuffer frase = new StringBuffer("Programação Java");
    String resultado = frase.toString(); 
    System.out.println(resultado);
    
    System.exit(0);
  }
} 



JavaScript ::: Dicas & Truques ::: Operadores de Manipulação de Bits (Bitwise Operators)

JavaScript Avançado - Como usar o operador de bits & (E/AND sobre bits) da linguagem JavaScript

Quantidade de visualizações: 1400 vezes
O operador de bits & (E/AND sobre bits) da linguagem JavaScript é usado quando queremos comparar os bits individuais de dois valores integrais (inteiros) e produzir um terceiro resultado. Os bits no resultado serão configurados como 1 se os bits correspondentes nos dois outros valores foram 1. Em caso contrário os bits são configurados como 0.

Para quem gosta de Lógica Matemática, ou a Tabela Verdade da Lógica de Boole, vai se lembrar do conectivo "^", que diz que a proposição resultante da conjunção só será verdadeira quando as proposições simples individuais forem verdadeiras. O operador de bits & do JavaScript é similar ao conectivo "^" da Lógica Proposicional.

Vamos analisar os seguintes valores binários:

a) 0101 (5 decimal)
b) 0100 (4 decimal)

Quando aplicamos o operador & nestes dois valores teremos o seguinte resultado:

0101
0100
----
0100

Veja que o resultado é 0100, uma vez que apenas o segundo bit de cada valor está configurado como 1. Vamos ver isso em JavaScript agora. Observe o seguinte trecho de código:

<html>
<head>
  <title>Manipulação de Bits em JavaScript</title>
</head>
 
<body>

<script type="text/javascript">
  var a = 5;
  var b = 4;
  var c = a & b;
  
  // exibe o resultado (em binário e em decimal)
  document.writeln("a = " + obterBits(a) + " (" + a + ")");
  document.writeln("<br>b = " + obterBits(b) + " (" + b + ")");
  document.writeln("<br>a & b = " + obterBits(c) + " (" + c + ")");
  
  // função auxiliar que converte um decimal em sua representação em bits
  function obterBits(valor){
    var mascara = 1 << 31; // 10000000 00000000 00000000 00000000
    var buffer = ""; // um buffer para guardar os bits dos bytes
    
    for(var i = 1; i <= 32; i++){
      // compara os bits individuais dos dois valores inteiros
      if((valor & mascara) == 0){
    	buffer = buffer + "0";
      }
      else{
    	buffer = buffer + "1";
      }
      
      valor = valor << 1; // desloca uma posição para a esquerda
      // Cada troca à esquerda corresponde à multiplicação do
      // valor por 2
      
      if(i % 8 == 0){ // completou um byte?
        buffer = buffer + " ";
      }
    }
    
    return buffer;
  }
</script>

</body>
</html>


Ao executar este código teremos o seguinte resultado:

    a = 00000000 00000000 00000000 00000101 (5) 
    b = 00000000 00000000 00000000 00000100 (4)
a & b = 00000000 00000000 00000000 00000100 (4)



Delphi ::: VCL - Visual Component Library ::: TListBox

Como selecionar um item de uma ListBox do Delphi em tempo de execução usando a propriedade ItemIndex

Quantidade de visualizações: 15722 vezes
É possível selecionar, em tempo de execução, um dos itens de uma ListBox. Para isso, só precisamos definir um valor para a propriedade ItemIndex. Veja:

procedure TForm1.Button2Click(Sender: TObject);
begin
  // vamos selecionar o segundo item na ListBox
  ListBox1.ItemIndex := 1; // o índice do primeiro item é 0

  // note que este código não funciona para ListBoxes de
  // seleção múltipla
end;

Note que este código não se aplica às ListBoxes de seleção múltipla.

Para fins de compatibilidade, esta dica foi escrita usando Delphi 2009.


Desafios, Exercícios e Algoritmos Resolvidos de Delphi

Veja mais Dicas e truques de Delphi

Dicas e truques de outras linguagens

E-Books em PDF

E-Book 650 Dicas, Truques e Exercícios Resolvidos de Python - PDF com 1.200 páginas
Domine lógica de programação e a linguagem Python com o nosso E-Book 650 Dicas, Truques e Exercícios Exercícios de Python, para você estudar onde e quando quiser.

Este e-book contém dicas, truques e exercícios resolvidos abrangendo os tópicos: Python básico, matemática e estatística, banco de dados, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book
E-Book 350 Exercícios Resolvidos de Java - PDF com 500 páginas
Domine lógica de programação e a linguagem Java com o nosso E-Book 350 Exercícios Exercícios de Java, para você estudar onde e quando quiser.

Este e-book contém exercícios resolvidos abrangendo os tópicos: Java básico, matemática e estatística, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: C
6º lugar: Delphi
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby


E-Book 650 Dicas, Truques e Exercícios Resolvidos de Python - PDF com 1.200 páginas
Domine lógica de programação e a linguagem Python com o nosso E-Book 650 Dicas, Truques e Exercícios Exercícios de Python, para você estudar onde e quando quiser. Este e-book contém dicas, truques e exercícios resolvidos abrangendo os tópicos: Python básico, matemática e estatística, banco de dados, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book Apenas R$ 32,90

Planilha Web - Planilhas e Calculadoras online para estudantes e profissionais de Engenharia Civil, Engenharia Elétrica e Engenharia Mecânica.


© 2025 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 91 usuários muito felizes estudando em nosso site.