// Programa Principal
int main(void)
{
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize(350,300);
glutCreateWindow("Visualizacao 3D");
glutDisplayFunc(Desenha);
glutReshapeFunc(AlteraTamanhoJanela);
glutMouseFunc(GerenciaMouse);
Inicializa();
glutMainLoop();
}
//<<<<<<<<<<<<<<<<<<<<<<<< main >>>>>>>>>>>>>>>>>>>>>>
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowSize(640,480);
glutInitWindowPosition(100, 150);
glutCreateWindow("GL_FLAT");
Inicializa();
glutDisplayFunc(Dibuja);
glutMainLoop();
return 0;
}
// Programa Principal
int main(void)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(640,480);
glutInitWindowPosition(10,10);
glutCreateWindow("Transformações Geométricas em 2D");
glutDisplayFunc(Desenha);
Inicializa();
glutMainLoop();
}
int main(void)
{
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(1000,1000);
glutCreateWindow("1º Trabalho - Letra E");
glutDisplayFunc(Desenha);
glutReshapeFunc(AlteraTamanhoJanela);
glutKeyboardFunc(Keyboard);
glutMouseFunc(mouse);
Inicializa();
glutMainLoop();
}
// Programa Principal
int main(void)
{
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize(500,500);
glutCreateWindow("Trabalho G2");
glutDisplayFunc(Desenha);
glutReshapeFunc(Redimensiona);
glutMouseFunc(Mouse);
glutSpecialFunc(Teclado);
Inicializa();
glutMainLoop();
}
main(void)
{
int telaE, telaD, telaT, telaB; //esquerda direita topo base
telaE=500; telaD=0; telaT=500; telaB=0;
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize(telaE,telaT);
glMatrixMode(GL_PROJECTION);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glOrtho(telaE, telaD, telaT, telaB,-1,1);
// Indica que devem ser usados dois buffers para armazenamento da imagem e
// representacao de cores RGB
glutCreateWindow("OpenGL com Uso de Menus");
// Cria uma janela com o titulo especificado
int mainMenu; // Cria menu para escolher a cor corrente e o objeto a
// ser exibido
//added by wesz - begin
mainMenu = glutCreateMenu(TrataMenu);
glutAddMenuEntry("Rotacao",1);
glutAddMenuEntry("Translacao",2);
glutAddMenuEntry("Escala",3);
glutAddMenuEntry("Reduz Metade",13);
//added by wesz - end
glutAttachMenu(GLUT_RIGHT_BUTTON);
glutKeyboardFunc(Teclado);
// Especifica a funcao que vai tratar teclas comuns
glutSpecialFunc(TeclasEspeciais);
// Especifica a funcao que vai tratar teclas especiais
glutDisplayFunc(Display);
// Especifica para a OpenGL a funcao responsável pelo desenho
Inicializa();
// Executa a inicializacao de parametros de exibicao
InicializaObjeto();
// Inicializa as informacoes geometricas do objeto
glutMainLoop();
// Dispara a "maquina de estados" de OpenGL
}
// Programa Principal
int main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(400,350);
glutCreateWindow("Visualizacao 3D com Mapeamento de Textura");
glutDisplayFunc(Desenha);
glutReshapeFunc(AlteraTamanhoJanela);
glutMouseFunc(GerenciaMouse);
glutSpecialFunc(TeclasEspeciais);
Inicializa();
glutMainLoop();
}
// Programa Principal
int main(void)
{
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(900,800);
glutCreateWindow("simuçao de transito, computação grafica");
glutDisplayFunc(DesenhaPredio);
glutReshapeFunc(AlteraTamanhoJanela);
glutKeyboardFunc(Teclado);
iniciaObjeto();
glutSpecialFunc(TeclasEspeciais);
Inicializa();
glutMainLoop();
}
// Programa Principal
int main(void)
{
//glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(350,300);
glutCreateWindow("Visualizacao 3D");
glutDisplayFunc(Desenha);
glutReshapeFunc(Redimensiona);
glutMouseFunc(Mouse);
glutSpecialFunc(Teclado);
Inicializa();
glutMainLoop();
}
int main(void)
{
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(1000,1000);
glutCreateWindow("2º Trabalho - Desenho da esfera");
glutDisplayFunc(Desenha);
glutReshapeFunc(AlteraTamanhoJanela);
glutKeyboardFunc(Keyboard);
glutMouseFunc(mouse);
//glutPassiveMotionFunc(onMouseMove);
Inicializa();
glutMainLoop();
}
int main (void)
{
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowPosition(5,5);
glutInitWindowSize(800,600);
glutCreateWindow("Desenho distintos com Viewport");
glutDisplayFunc(RenderScene);
Inicializa();
glutMainLoop();
return 0;
}
// Programa Principal
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("Sistema Solar");
glutDisplayFunc(Desenha);
glutReshapeFunc(AlteraTamanhoJanela);
Inicializa();
glutKeyboardFunc(keyDown);
glutKeyboardUpFunc(keyUp);
glutMainLoop();
return a.exec();
}
// Programa Principal
int main(void)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA | GLUT_DEPTH);
// glutInitDisplayMode(GLUT_SINGLE);
glutInitWindowSize(640,480);
glutInitWindowPosition(10,10);
glutCreateWindow("Cilindro");
// luz();
// Inicializa();
glutDisplayFunc(Desenha);
Inicializa();
// luz();
glutMainLoop();
}
int main(int argc, char ** argv) {
int sizex, sizey;
sizex = 500;
sizey = 500;
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(sizex,sizey);
glutCreateWindow("Visualizacao 3D");
glutDisplayFunc(Desenha);
glutReshapeFunc(AlteraTamanhoJanela);
glutMouseFunc(GerenciaMouse);
Inicializa();
glutMainLoop();
return 0;
}
// Programa Principal
int main(int argc, char *argv[])
{
apresentaOpcoes();
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutInitWindowSize(750,600);
glutCreateWindow("Computador e seus componentes");
glutDisplayFunc(Desenha);
glutReshapeFunc(AlteraTamanhoJanela);
glutPassiveMotionFunc(MoveMouse);
glutMouseFunc(GerenciaMouse);
glutSpecialFunc(TeclasEspeciais);
glutKeyboardFunc(TeclasTeclado);
glutTimerFunc(200,timerFunc,0);
glutTimerFunc(200,controlaCoolerTimer,0);
Inicializa();
glutMainLoop();
}
int main(int argc, char ** argv) {
int sizex, sizey;
sizex = 500;
sizey = 500;
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(sizex,sizey);
glutInitWindowPosition(10,10);
glutCreateWindow("Círculo");
glutDisplayFunc(Desenha);
glutReshapeFunc(AlteraTamanhoJanela);
Inicializa();
glutMainLoop();
return 0;
}
int main(void)
{
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(400,400);
glutCreateWindow("Primeiro Programa");
glutDisplayFunc(Desenha);
glutKeyboardFunc(Teclado);
Inicializa();
glutMainLoop();
return 0;
}
int main(int argc,char ** argv){
glutInit(&argc,argv);
glutInitDisplayMode( GLUT_SINGLE | GLUT_RGB );
glutInitWindowSize( 800,800 );
glutCreateWindow("Primeiro Programa");
glutDisplayFunc(Desenha);
glutKeyboardFunc(Teclado);
Inicializa();
glutMainLoop();
return 0;
}
// Programa Principal
int main(void)
{
// Define o modo de operação da GLUT
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
// Especifica a posição inicial da janela GLUT
glutInitWindowPosition(5,5);
// Especifica o tamanho inicial em pixels da janela GLUT
glutInitWindowSize(800,600);
// Cria a janela passando como argumento o título da mesma
glutCreateWindow("Trabalho Final de Computação Gráfica");
// Registra a função callback de redesenho da janela de visualização
glutDisplayFunc(Desenha);
// Registra a função callback de redimensionamento da janela de visualização
glutReshapeFunc(AlteraTamanhoJanela);
// Registra a função callback para tratamento das teclas normais
glutKeyboardFunc (Teclado);
// Registra a função callback para tratamento das teclas especiais
glutSpecialFunc (TeclasEspeciais);
// Registra a função callback para eventos de botões do mouse
glutMouseFunc(GerenciaMouse);
// Registra a função callback para eventos de movimento do mouse
glutMotionFunc(GerenciaMovim);
// Chama a função responsável por fazer as inicializações
Inicializa();
// Inicia o processamento e aguarda interações do usuário
glutMainLoop();
return 0;
}
int main(void)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(5,5);
glutInitWindowSize(450,450);
glutCreateWindow("DESENHO DE LINHAS");
glutDisplayFunc(Desenha);
glutReshapeFunc(AlteraTamanhoJanela);
Inicializa();
glutMainLoop();
return 0;
}//fim doprincipal
// Programa Principal
int main(void){
int argc = 0;
char *argv[] = { (char *)"gl", 0 };
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(800,600);
glutCreateWindow("Trabalho II CGI");
glutDisplayFunc(Desenha);
glutReshapeFunc(AlteraTamanhoJanela);
glutMotionFunc(GerenciaMovim);
glutMouseFunc(GerenciaMouse);
glutKeyboardFunc(GerenciaTeclado);
glutSpecialFunc(GerenciaTecladoEspecial);
Timer(10);
Inicializa();
glutMainLoop();
return 0;
}
int main (int argc,char **argv)
{
glutInit(&argc,argv);
//glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowPosition(50,50);
glutInitWindowSize(width_window,height_window);
glutCreateWindow("Gabriel de Souza Rolim");
glutTimerFunc(time, TimerFunction, 1);
Inicializa();
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}
int main(int argc,char ** argv){
glutInit(&argc,argv);
glutInitDisplayMode( GLUT_SINGLE | GLUT_RGB );
glutInitWindowSize( 600,400 );
glutCreateWindow("Quinto Trabalho");
glutDisplayFunc(Desenha); //desenha a tela
glutKeyboardFunc(Teclado);
Inicializa();
CriaMenu();
glutMainLoop();
return 0;
}// fim do programa principal
// Programa Principal
int main(void)
{
// Define do modo de operação da GLUT
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
// Especifica a posição inicial da janela GLUT
glutInitWindowPosition(5,5);
// Especifica o tamanho inicial em pixels da janela GLUT
glutInitWindowSize(450,450);
// Cria a janela passando como argumento o título da mesma
glutCreateWindow("Exemplo com duas viewports");
// Registra a função callback de redesenho da janela de visualização
glutDisplayFunc(Desenha);
// Registra a função callback de redimensionamento da janela de visualização
glutReshapeFunc(AlteraTamanhoJanela);
// Registra a função callback para tratamento das teclas ASCII
glutKeyboardFunc (Teclado);
// Chama a função responsável por fazer as inicializações
Inicializa();
// Inicia o processamento e aguarda interações do usuário
glutMainLoop();
return 0;
}
int main(int argc, char** argv) {
int x;
//Exemplo de árvore binária
Arv* F = Cria_Arv(12,Inicializa(),Inicializa());
Arv* D = Cria_Arv(7,F,Inicializa());
Arv* E = Cria_Arv(5,Inicializa(),Inicializa());
Arv* B = Cria_Arv(2,D,E);
Arv* J = Cria_Arv(0,Inicializa(),Inicializa());
Arv* I = Cria_Arv(7,Inicializa(),J);
Arv* G = Cria_Arv(2,Inicializa(),Inicializa());
Arv* H = Cria_Arv(45,Inicializa(),I);
Arv* C = Cria_Arv(3,G,H);
Arv* A = Cria_Arv(4,B,C);
printf("Digite o valor a ser comparado: ");
scanf("%d",&x);
printf("Quantidade nos maiores que %d : %d ", x, maiores(A,x));
return (EXIT_SUCCESS);
}
//Chamada do main
int main(void)
{
//Inicia o som
FSOUND_SAMPLE *samp1 = 0; //cria um ponteiro para armazenar o som em memória
if (FSOUND_GetVersion() < FMOD_VERSION) // verificação da versão do fmod caso a versão do FSOUND for menor que a do FMOD retorna uma menssagem de erro
{
printf("Error : You are using the wrong DLL version! You should be using FMOD %.02f\n", FMOD_VERSION);
return 1;
}
// Seleciona a saída de audio
FSOUND_SetOutput(FSOUND_OUTPUT_DSOUND);
// Seleção do driver
FSOUND_GetOutput(); // indentifica o tipo de saida
FSOUND_GetMixer(); // indentifica o mixer
FSOUND_SetDriver(0); // seta o driver de som que vai ser usado
// Inicializando o FMOD
if (!FSOUND_Init(44100, 32, FSOUND_INIT_GLOBALFOCUS)) // se o valor do FSOUND_Init for 0 execute o tratamento de erro
{
printf("Error!\n");
printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
return 1;
}
// Carrengando o Sample
// PCM,44,100 Hz, 32 Bit, Mono ou uma mp3 ou outros formatos suportados pelo fmod
samp1 = FSOUND_Sample_Load(FSOUND_UNMANAGED, "topgear.ogg", FSOUND_NORMAL | FSOUND_HW2D, 0, 0);
if (!samp1)
{
printf("Error!\n");
printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
return 1;
}
// Aqui fala qual maneira o sample ira tocar caso falhe excute o tratamento de erro
if(!FSOUND_Sample_SetMode(samp1, FSOUND_LOOP_NORMAL))// o loop normal toca a musica continuamente ate o programa fechar
{
printf("Error!\n");
printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
}
// Aqui sera tocado o sample ,caso falhe, execute o tratamento de erro
if(!FSOUND_PlaySound(FSOUND_FREE, samp1))
{
printf("Error!\n");
printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
}
//Fim do codigo do som \\o \o/ o//\o/
//Sleep(10000); // executa o som durante 10 segundos (Essa funcao esta desativada no Street Frog)
printf ("Jogo desenvolvido como Projeto Final para a Disciplina de Computacao Grafica");
printf ("\nUFRN - CT - DCA");
printf ("\nPor Claudio Henrique | Paulo Bruno | Thaisa Ramos");
//printf ("\n");
//E por fim a chamada para o OpenGL
glutInitDisplayMode(GLUT_DOUBLE | GLUT_DEPTH | GLUT_RGB); //Modo para nao exibir rastros na tela
glutInitWindowSize (890, 550); //Tamanho da janela
glutInitWindowPosition (50, 50); //Localizacao inicial da janela
glutCreateWindow("Ajude o menino a chegar em casa"); //Nome da janela
glutKeyboardFunc(Teclado); //Chama as funcoes do teclado
glutSpecialFunc(Mover); //Chama as funcoes especias do teclado (setas de movimento)
Inicializa();
iniciaText();
glutDisplayFunc(Desenha); //Chama o desenho
glutReshapeFunc(AlteraTamanhoJanela); //Correcao de largura e altura para a janela
glutTimerFunc(10,movimentar,1); //Chamada de movimento do carro
glutTimerFunc(10,movimentacarro,1); //Chamada de movimento do carro
glutTimerFunc(10,movimentacarro2,1); //Chamada de movimento do carro
glutTimerFunc(10,movermad,1); //Chamada de movimento da madeira
glutTimerFunc(10,movermad1,1); //Chamada de movimento da madeira
glutTimerFunc(10,movermad2,1); //Chamada de movimento da madeira
glutMouseFunc(GerenciaMouse); //Ativa o botao direito
glutMainLoop();
//Final das funcoes do OpenGL
// limpando a memoria e fechando o fmod (Som)
FSOUND_Sample_Free(samp1); // limpa a memoria ultilizada pelo ponteiro do sample
FSOUND_Close(); // encerra a API FMOD
}
int main(int argc, char** argv) {
int x;
//Exemplo de árvore binária ex:2
Arv* i= Cria_Arv(12,Inicializa(),Inicializa());
Arv* j= Cria_Arv(7,Inicializa(),Inicializa());
Arv* g= Cria_Arv(5,i,Inicializa());
Arv* h= Cria_Arv(2,j,Inicializa());
Arv* e= Cria_Arv(0,g,Inicializa());
Arv* f = Cria_Arv(7,Inicializa(),h);
Arv* d= Cria_Arv(2,e,f);
Arv* c = Cria_Arv(45,d,Inicializa());
Arv* b= Cria_Arv(3,Inicializa(),c);
Arv* a = Cria_Arv(4,Inicializa(),b);
printf("Quantidade nos folhas e: %d ",folhas(a));
return (EXIT_SUCCESS);
}
/**********************************************************************************************************************************
* Nome da funcao: Le_Arquivo;
* Descricao: Le o arquivo de entrada e insere os tipos de informacoes nas respectivas listas.
* Assertivas de Entrada:
* FILE *fp != NULL (ponteiro para arquivo de entrada)
* Assertivas de Saida:
* Listas criadas:
* Listas->p_cidade != NULL;
* Listas->p_gerador != NULL;
* Listas->p_interc != NULL;
* Listas->p_adapter != NULL;
*************************************************************************************************************************************/
Listas *Le_Arquivo(FILE *fp){
Checa_Erro(fp != NULL);
Listas *sts = NULL;
Cidade *cidade = NULL;
Gerador *gerador = NULL;
Interc *interc = NULL;
Adapter *adapter = NULL;
char c;
sts = Inicializa();
while((c = getc(fp)) != EOF){
if(c == 'C'){
cidade = (Cidade *) malloc(sizeof(Cidade));
fscanf(fp, "%s", cidade->nome_cidade);
fscanf(fp, "%d", &(cidade->pos_x));
fscanf(fp, "%d", &(cidade->pos_y));
fscanf(fp, "%d", &(cidade->recurso_necessario));
Insere_Lista('C', sts, cidade);
}
else if(c == 'G'){
gerador = (Gerador *) malloc(sizeof(Gerador));
fscanf(fp, "%s", gerador->nome_gerador);
fscanf(fp, "%d", &(gerador->pos_x));
fscanf(fp, "%d", &(gerador->pos_y));
fscanf(fp, "%d", &(gerador->recurso_produzido));
fscanf(fp, "%d", &(gerador->custo_gerador));
Insere_Lista('G', sts, gerador);
}
else if(c == 'I'){
interc = (Interc *) malloc(sizeof(Interc));
fscanf(fp, "%s", interc->nome_interc);
fscanf(fp, "%d", &(interc->pos_inic_x));
fscanf(fp, "%d", &(interc->pos_inic_y));
fscanf(fp, "%d", &(interc->pos_final_x));
fscanf(fp, "%d", &(interc->pos_final_y));
fscanf(fp, "%d", &(interc->capacidade_max));
fscanf(fp, "%f", &(interc->chance_falha));
fscanf(fp, "%d", &(interc->tempo_conserto));
fscanf(fp, "%d", &(interc->custo_conserto));
Insere_Lista('I', sts, interc);
}
else if(c == 'A'){
adapter = (Adapter *) malloc(sizeof(Adapter));
fscanf(fp, "%s", adapter->nome_adapter);
fscanf(fp, "%d", &(adapter->pos_x));
fscanf(fp, "%d", &(adapter->pos_y));
Insere_Lista('A', sts, adapter);
}
}
return sts;
}
int main ()
{
int x,y,z,n;
Avl *raiz;
int valor;
raiz = Inicializa();
system ("clear");
do
{
printf ("================================================================================\n");
printf ("\t\t\tArvore AVL\n\n");
printf (" O [1] - Inserir Novo Elemento\n");
printf (" / \\ [2] - Mostrar a Estrutura da Arvore\n");
printf (" O O [3] - Buscar um Elemento\n");
printf (" / \\ \\ [4] - Remover um Elemento\n");
printf (" O O O [5] - Destruir a Arvore\n");
printf (" [6] - Caminhar na Arvore\n");
printf (" [7] - Altura da Arvore\n");
printf (" [8] - Verificar se a arvore esta vazia\n");
printf (" [0] - Finalizar programa\n");
printf ("================================================================================\n");
printf ("Escolha uma das opcoes acima: ");
scanf ("%d",&n);
getc (stdin);
printf ("================================================================================\n");
switch (n)
{
case 1:
printf (" Inserir: ");
scanf ("%d",&x);
Insere_Arvore_Avl (&raiz,x);
break;
case 2:
Mostra_Arvore_Avl (raiz,0);
break;
case 3:
printf ("buscar:");
scanf ("%d",&x);
y = Busca_Arvore_Avl (raiz,x);
if (y) printf (" encontrado\n");
else printf ("nao encontrado\n");
break;
case 4:
printf ("Elemento a ser removido: ");
scanf ("%d",&y);
Remove_Arvore_Avl (&raiz,y);
break;
case 5:
raiz = Destroi_Arvore_Avl (raiz);
printf ("Todos os elementos foram removidos\n");
break;
case 6:
do
{
printf ("================================================================================\n");
printf ("[1]-Pre-Ordem\n");
printf ("[2]-Em-Ordem\n");
printf ("[3]-Pos-Ordem\n");
printf ("================================================================================\n");
printf ("Escolha uma das opcoes acima: ");
scanf ("%d",&x);
getc (stdin);
if (x==1) Caminhamento_Pre_Ordem (raiz);
if (x==2) Caminhamento_Em_Ordem (raiz);
if (x==3) Caminhamento_Pos_Ordem (raiz);
} while (x<1 && x>3);
printf ("\n");
break;
case 7:
x = Altura_Arvore_Avl (raiz);
printf ("Altura da Arvore: %d\n",x);
break;
case 8:
x = Arvore_Vazia (raiz);
if (x) printf ("A arvore esta vazia\n");
else printf ("A arvore nao esta vazia\n");
}
}while (n!=0);
raiz = Destroi_Arvore_Avl (raiz);
printf ("\n");
}
//=========================FUNÇÃO PRINCIPAL===================================
int main(){
system("title Controle De Estoque 2011");
system("color 0f");
int op,z,d,i,k;
char resp,c;
TipoItem item;
TipoLista Lista;
ApontadorNo Arvore_cod;
IniciarLista(&Lista);
Inicializa(&Arvore_cod);
i=0;
do{
menu();
scanf("%d",&op);
system("cls");
if(op==1){
do{
printf("\t\tGERENCIAMENTO DE ESTOQUE\n\n\tINCLUSAO DE NOVO CADASTRO\n\n");
fflush(stdin);
printf("Digite o codigo do produto: ");
scanf("%d",&item.cod);
printf("\nDigite o nome do produto: ");
fflush(stdin);
gets(&item.nome[i]);
printf("\nDigite o valor: ");
fflush(stdin);
scanf("%f",&item.valor);
printf("\nDigite o fabricante: ");
fflush(stdin);
gets(&item.fabri[i]);
printf("\nDigite a quantidade: ");
fflush(stdin);
scanf("%d",&item.quantidade);
InserirCelula(&Lista,item);
printf("\n\tDeseja digita novamente? (S/N).:");
fflush(stdin);
Insere(item,&Arvore_cod);
scanf("%c",&resp);
system("cls");
}while(resp=='s');
system("cls");
}
if(op==2){
printf("\t\t\tESTOQUE\n");
ImprimeLista(Lista);
system("pause");
system("cls");
}
if(op==3){
if(TesteListaVazia(Lista)){
ImprimeLista(Lista);
system("pause");
system("cls");
}
else{
ImprimeLista(Lista);
do{
printf("\n\tQual deseja remover.:");
scanf("%d",&k);
if(Verificar(k,Lista)==1){
fflush(stdin);
RetiraL(k,&Lista,&item);
fflush(stdin);
Retira(item, &Arvore_cod);
fflush(stdin);
printf("\n\tDeseja Remover novamente? (S/N).:");
fflush(stdin);
scanf("%c",&resp);
}
}while(resp=='s');
system("pause");
system("cls");
}
}
if(op==4){
if(TesteListaVazia(Lista)){
ImprimeLista(Lista);
system("pause");
system("cls");
}
else{
printf("\t\tOrdenado por valor\n");
d=Tamanho(Lista);
QuickSortLista(&Lista,d);
ImprimeLista(Lista);
system("pause");
system("cls");
}
}
if(op==5){
if(TesteListaVazia(Lista)){
ImprimeLista(Lista);
system("pause");
system("cls");
}
else{
printf("\n\n\n Digite o codigo que deseja encontrar: ");
scanf("%d", &item.cod);
fflush(stdin);
Pesquisa(&item, &Arvore_cod, item.quantidade);
printf("\n");
system("pause");
}
system("cls");
}
if(op==6){
}
if(op==7){
}
if(op==8){
}
if(op==9){
}
if(op<1||op>10){
system("color 4f");
printf("\tOpcao Invalida\n");
system("pause");
system("cls");
system("color 0f");
}
else if(op==10){
exit(1);
}
}while(op>0||op<10);
}
