C++ Tela cheia mas com barra de tarefas allegro c++

[Daniel Bittencourt]

Bom, eu precisava deixar a tela cheia, mas mostrando a barra de tarefas, por que sempre que pesquisou enche a tela inteira, e não deixa a barra de tarefas visível, tendo que fechar a janela para mudar de app.

[Benjamin Breeg]

No Allegro 5 você pode usar o "ALLEGRO_FULLSCREEN_WINDOW" para setar uma janela em tela cheia com a barra visível 

 

Aqui um exemplo aperta "M" para você ver o efeito, veja se é o que você quer.

 

#include "allegro5/allegro.h"
#include "allegro5/allegro_font.h"
#include "allegro5/allegro_ttf.h"

#include "allegro5/allegro_direct3d.h"


#include <cstdio>



class Display {
protected:
   ALLEGRO_DISPLAY* display;
   ALLEGRO_EVENT_QUEUE* queue;
   ALLEGRO_TIMER* timer;
   ALLEGRO_FONT* verdana20;
   int origw;
   int origh;
   int w;
   int h;
   int xpos;
   int ypos;
   int adapter;
   bool opengl;
   bool redraw;
   bool quit;
   bool fullscreen;

   
   
public :
   
   Display();
   
   int Init();
   
   bool Create(int width , int height , int adapter , bool use_opengl);
   void Destroy();
   void RefreshInfo();
   void DisplayInfo();
   void Register();

   void ToggleFullscreen();
   
   bool SetAdapter(int nadapter);
   bool UseOpenGL();
   bool UseDirect3D();

   void CheckInput();
   
   void Draw();
   
   void Run();
   
   bool Quit() {return quit;}
};



int main(int argc , char** argv) {
   
   
   
   Display d;
   int ret = d.Init();
   if (ret != 0) {return ret;}
   
   if (!d.Create(800 , 600 , 0 , true)) {
      return 1;
   }
   
   d.Run();
   
   
   
   return 0;
}



Display::Display() :
   display(0),
   queue(0),
   timer(0),
   verdana20(0),
   origw(0),
   origh(0),
   w(0),
   h(0),
   xpos(0),
   ypos(0),
   adapter(0),
   opengl(true),
   redraw(true),
   quit(false),
   fullscreen(false)
{}



int Display::Init() {
   
   if (!al_init()) {
      return -1;
   }
   if (!al_init_font_addon() || !al_init_ttf_addon()) {
      return -2;
   }
   
   if (!al_install_keyboard()) {
      return -3;
   }
   if (!al_install_mouse()) {
      return -4;
   }
   
   queue = al_create_event_queue();
   if (!queue) {
      return -6;
   }

   timer = al_create_timer(1.0/60.0);
   if (!timer) {
      return -7;
   }   

   al_register_event_source(queue , al_get_keyboard_event_source());
   al_register_event_source(queue , al_get_timer_event_source(timer));
   al_register_event_source(queue , al_get_mouse_event_source());
   
   
   verdana20 = al_load_ttf_font("Verdana.ttf" , -20 , 0);
   if (!verdana20) {
      return -10;
   }
   
   return 0;
}



bool Display::Create(int width , int height , int new_adapter , bool use_opengl) {
   Destroy();
   int ndflags = ALLEGRO_WINDOWED | ALLEGRO_RESIZABLE | (use_opengl?ALLEGRO_OPENGL:ALLEGRO_DIRECT3D);
   al_set_new_display_flags(ndflags);
   al_set_new_display_adapter(new_adapter);
   origw = width;
   origh = height;
   display = al_create_display(origw,origh);
   if (display) {
      opengl = use_opengl;
      adapter = new_adapter;
      Register();
      al_start_timer(timer);
   }
   redraw = true;
   return display;
}



void Display::Destroy() {
   if (display) {
      al_stop_timer(timer);
      al_destroy_display(display);
      display = 0;
   }
}



void Display::RefreshInfo() {
   al_get_window_position(display , &xpos , &ypos);
   w = al_get_display_width(display);
   h = al_get_display_height(display);
}



void Display::DisplayInfo() {
   RefreshInfo();
   al_draw_textf(verdana20 , al_map_rgb(255,255,255) , 10 , 10 , 0 , "Window position <%d , %d>" , xpos , ypos);
   al_draw_textf(verdana20 , al_map_rgb(255,255,255) , 10 , 40 , 0 , "Window dimensions <%d , %d>" , w , h);
   al_draw_textf(verdana20 , al_map_rgb(255,255,255) , 10 , 70 , 0 , "Adapter #%d" , adapter);
   al_draw_textf(verdana20 , al_map_rgb(255,255,255) , 10 , 100 , 0 , "%d Available adapters" , al_get_num_video_adapters());
   al_draw_textf(verdana20 , al_map_rgb(255,255,255) , 10 , 130 , 0 , "Using %s" , opengl?"OpenGL":"Direct3D");
}



void Display::Register() {
   al_register_event_source(queue , al_get_display_event_source(display));
}



void Display::ToggleFullscreen() {
   fullscreen = !fullscreen;
   al_set_display_flag(display , ALLEGRO_FULLSCREEN_WINDOW , fullscreen);
}



bool Display::SetAdapter(int nadapter) {
   return Create(w , h , nadapter , opengl);
}

bool Display::UseOpenGL() {
   return Create(w , h , adapter , true);
}
bool Display::UseDirect3D() {
   return Create(w , h , adapter , false);
}



void Display::CheckInput() {
   do {
      ALLEGRO_EVENT ev;
      al_wait_for_event(queue , &ev);
      if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE || (ev.type == ALLEGRO_EVENT_KEY_DOWN && ev.keyboard.keycode == ALLEGRO_KEY_ESCAPE)) {
         quit = true;
         break;
      }
      if (ev.type == ALLEGRO_EVENT_DISPLAY_RESIZE) {
         al_acknowledge_resize(display);
      }
      if (ev.type == ALLEGRO_EVENT_KEY_DOWN) {
         if (ev.keyboard.keycode == ALLEGRO_KEY_F) {
            ToggleFullscreen();
         }
         if (ev.keyboard.keycode == ALLEGRO_KEY_M) {
            al_set_display_flag(display , ALLEGRO_MAXIMIZED , true);
         }
         if (ev.keyboard.keycode == ALLEGRO_KEY_N) {
            al_set_display_flag(display , ALLEGRO_MAXIMIZED , false);
         }
         if (ev.keyboard.keycode == ALLEGRO_KEY_O) {
            if (!UseOpenGL()) {
               printf("Failed to create an opengl context.\n");
               quit = true;
               break;
            }
         }
         if (ev.keyboard.keycode == ALLEGRO_KEY_D) {
            if (!UseDirect3D()) {
               printf("Failed to create a Direct3D context.\n");
               quit = true;
               break;
            }
         }
         for (int i = 0 ; i < al_get_num_video_adapters() ; ++i) {
            if (ev.keyboard.keycode == ALLEGRO_KEY_1 + i) {
               if (!SetAdapter(i)) {
                  printf("Failed to set adapter %d.\n" , i);
                  quit = true;
                  break;
               }
            }
         }
      }
      if (ev.type == ALLEGRO_EVENT_TIMER) {
         redraw = true;
      }
         
   } while (!al_is_event_queue_empty(queue));
}




void Display::Draw() {
   if (redraw) {
      al_set_target_backbuffer(display);
      al_clear_to_color(al_map_rgb(0,0,0));
      
      DisplayInfo();
      
      al_flip_display();

      redraw = false;
   }
}



void Display::Run() {
   while (!quit) {
      Draw();
      CheckInput();
   }
}

 

[Daniel Bittencourt]

eu uso allegro 4.2.2 ;-;

[Benjamin Breeg]

13 minutos atrás, Daniel Bittencourt disse:

eu uso allegro 4.2.2 ;-;

Cara acho que o Allegro 4 não suporta resoluções definidas pelo usuário que seria o caso, você pode ter fullscreen e windowed mas não tenho certeza se realmente não aceita fullscreen window. So vendo mesmo.

[Daniel Bittencourt]

Eu tive uma ideia hoje para resolver esse problema: se eu criasse uma janela com a própria windows.h, que já vem no meu IDE, e então eu simplesmente uso algo parecido com:

BITMAP *imagem = load_bitmap("img.bmp",NULL);
for(int conta = 0; conta <=imagem->w;conta++){
for(int conta2 = 0; conta2<=imagem->h;conta2++){
int pixel =  getpixel ( cara, 0, 0 ) ;
int red = getr(pixel); 
int green = getg(pixel);
int blue = getb(pixel);
static COLOREFF color = RGB(red,green,blue);
setPixel(color,conta,conta2);
}
}

com setPixel escrevendo na janela criada com windows.h.

O problema é a janela de windows.h ativada com allegro eu fiz um teste e a janela saiu minúscula e eu não entendo dessa parte de criar janelas. Seria possível fazer o que eu estou pensando? eu acho que o arquivo foi excluido. 

[Benjamin Breeg]

Você esta dizendo criar a janela Win32 e fazer o Allegro usar esse contexto Win32? Em APIs como a SFML você consegue criar um contexto Win32 e usar funções da SFML livremente, o Allegro não da suporte a esse recurso nem na versão 5 creio eu. Poderia ser possível ne, na pratica o Allegro usa a Win32 por trás da cortina.

 

[arfneto]

Nos últimos anos, em especial a parti de 2015 com o Windows 10, a Microsoft foi incorporando coisas que eram comuns no linux desde os '90, incluindo coisas como a possibilidade de vários desktops, a linha do tempo, a visão de tarefas e coisas assim
 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

E a evolução do hardware deixou muito mais simples e comum ter 2 ou 3 ou muitos terminais, o que era possível nos '90 no Windows só que mais complicado.

 

Então é cada vez menos produtivo e esperto usar uma janela maximizada.

 

O botão iniciar evoluiu muito, agora se pode usar comandos de voz, A tela de início pode incluir ícones para os últimos programas e arquivos acessados, Alt-TAB e Windows-TAB circulam pelos aplicativos em uso em um terminal ou em todos em modo carrossel.

 

E como sempre tem o modo mais produtivo para os conservadores que é usar 
 

Ocultar automaticamente a barra de tarefas significa não sacrificar 5% ou muito mais da sua tela para mostrar coisas que eventualmente você pode precisar por alguns segundos, ao invés de sempre mostrar algo que não muda na maior parte em um único pixel...

 

 

 

 

 

 

De todo modo se quer realmente algo assim a ideia é 

• usar GetSystemMetrics() e outras chamadas da família e identificar o particular monitor se tiver mais de um e os tamanhos em uso.
• Se a barra de tarefas estiver fixa usar simples aritmética para saber o quanto sobra de tela e salvar esse par (X,Y)
• Simplesmente crie a janela de seu aplicativo posicionada em (0,0) e com esse tamanho (X,Y) e ela naturalmente vai ocupar a tela toda, sem ser de fato maximizada, o que traria outros problemas

 

Uma janela maximizada é um desastre em termos de produtividade. O sistema se chama Windows, no plural, e a possibilidade de ter mais de uma janela é um recurso importante de produtividade, em especial em atividades comuns como gerenciamento de arquivos. Se fosse para usar uma por vez o system se chamaria Microsoft Window  

 

E imaginar uma máquina moderna com 3 terminais com janelas maximizadas, por exemplo, é algo curioso de usar. E chato pra c@c3t3... E impordutivo...

 

 

 

[Daniel Bittencourt]

@Benjamin Breeg  

Em 12/03/2021 às 19:04, Benjamin Breeg disse:

Você esta dizendo criar a janela Win32 e fazer o Allegro usar esse contexto Win32?

basicamente o que eu quis dizer foi usar allegro para abrir uma imagem e saber a cor e posição de cada pixel dela. a parte de por a imagem na tela, eu deixo na WinApi32. Não vejo muita possibilidade de conflito, por que no código que eu quero por a tela cheia uso WinApi32 e Allegro 4 sem nenhum erro e com as duas bibliotecas funcionando bonitinhas. Se o conflito for as funções de bitmap da windows.h, já está resolvido, mudei de struct BITMAP da winapi32 para BiTMAP sempre que é dito.

Em 12/03/2021 às 19:04, Benjamin Breeg disse:

na pratica o Allegro usa a Win32 por trás da cortina.

tirou as palavras da minha boca.

 

 

Eu vou tentar arrumar um jeito de fazer o código funcionar

Em 13/03/2021 às 11:14, arfneto disse:

• usar GetSystemMetrics() e outras chamadas da família e identificar o particular monitor se tiver mais de um e os tamanhos em uso.
• Se a barra de tarefas estiver fixa usar simples aritmética para saber o quanto sobra de tela e salvar esse par (X,Y)
• Simplesmente crie a janela de seu aplicativo posicionada em (0,0) e com esse tamanho (X,Y) e ela naturalmente vai ocupar a tela toda, sem ser de fato maximizada, o que traria outros problemas

Bom, provavelmente o motivo de ter gerado a janela pequena, bom não foi de eu ter deixado as medidas pequenas ou não definidas. Bem digamos que eu misturei o codigo que já vem pronto quando cria um projeto com allegro com o da janela. E eu tirei a parte de iniciar o gfx, mas... não tirei a parte que olhava se a variavel de retorno do gfx era igual a 0 para saber se ocorreu erro.. e nessa hora que olha o valor dela abria uma pequena messagebox e não deixava o programa prosseguir, por isso achei que a janela estava pequena. Basicamente fiz isso:

//	res = set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);
	if (res != 0) {
		allegro_message(allegro_error);
		exit(-1);
	}

refiz o codigo( porque havia excluido), vi isso e concertei. Agora o programa pos o objetivo que era a linha na janela. Mas não uma, nem duas, nem três e sim muitas janelas. Porque gera isso, não sei, mas sei que se alguém testar o código basta clicar com o botão direito na janela na barra de tarefas, clicar em fechar todas, dar cntrl.+ shift + esc e descer tudo no gerenciador de tarefas e fechar a janela na primeira linha das janelas iguais assim:

 

  

depois, cliquem em cancelar na janela de erro.

por fim, o código:

#include <allegro.h>
#include <windows.h>
void init();
void deinit();
static HWND sHwnd;
static COLORREF blue=RGB(0,0,255);
void SetWindowHandle(HWND hwnd)
{
	sHwnd=hwnd;
}
void setPixel(int x,int y,COLORREF& color=blue)
{
	if(sHwnd==NULL) {
		MessageBox(NULL,"sHwnd was not initialized !","Error",MB_OK|MB_ICONERROR);
		exit(0);
	}

	HDC hdc=GetDC(sHwnd);
	SetPixel(hdc,x,y,color);
	ReleaseDC(sHwnd,hdc);
	return;

// NEVERREACH //
}

void drawLineBresenham(int xa, int ya, int xb, int yb)
{
	int dx = abs(xa - xb), dy = abs(ya - yb);
	int p = 2 * dy - dx;
	int twoDy = 2 * dy, twoDyDx = 2 * (dy - dx);
	int x, y, xEnd;

	if (xa > xb) {
		x = xb;
		y = yb;
		xEnd = xa;
	} else {
		x = xa;
		y = ya;
		xEnd = xb;
	}

	setPixel(x, y);

	while(x < xEnd) {
		x++;
		if(p < 0)
			p += twoDy;
		else {
			y++;
			p += twoDyDx;
		}

		setPixel(x, y);
	}
}
void init() {
	int depth, res;
	allegro_init();
	depth = desktop_color_depth();
	if (depth == 0) depth = 32;
	set_color_depth(depth);
	install_timer();
	install_keyboard();
	install_mouse();
	/* add other initializations here */
}

void deinit() {
	clear_keybuf();
	/* add other deinitializations here */
}
LRESULT CALLBACK WndProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam)
{
			init();
			SetWindowHandle(hwnd);
drawLineBresenham(20,30,90,50);

deinit();
	return DefWindowProc(hwnd,message,wParam,lParam);

}
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int iCmdShow)
{
	static TCHAR szAppName[] = TEXT("Straight Line");
	WNDCLASS wndclass;
	wndclass.style         = CS_HREDRAW|CS_VREDRAW ;
	wndclass.lpfnWndProc   = WndProc ;
	wndclass.cbClsExtra    = 0 ;
	wndclass.cbWndExtra    = 0 ;
	wndclass.hInstance     = hInstance ;
	wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
	wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
	wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ;
	wndclass.lpszMenuName  = NULL ;
	wndclass.lpszClassName = szAppName ;

	// Register the window //

	if(!RegisterClass(&wndclass)) {
		MessageBox(NULL,"Registering the class failled","Error",MB_OK|MB_ICONERROR);
		exit(0);
	}

	// CreateWindow //

	HWND hwnd=CreateWindow(szAppName,"Bresenham's Algorithm - Programming Techniques",
	                       WS_OVERLAPPEDWINDOW,
	                       CW_USEDEFAULT,
	                       CW_USEDEFAULT,
	                       CW_USEDEFAULT,
	                       CW_USEDEFAULT,
	                       NULL,
	                       NULL,
	                       hInstance,
	                       NULL);

	if(!hwnd) {
		MessageBox(NULL,"Window Creation Failed!","Error",MB_OK);
		exit(0);
	}

	// ShowWindow and UpdateWindow //
	ShowWindow(hwnd,iCmdShow);
	UpdateWindow(hwnd);

	// Message Loop //
	MSG msg;

	while(GetMessage(&msg,NULL,0,0)) {
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	/* return no error to the operating system */
	return 0;
}

 

[Benjamin Breeg]

O grande problema é que a versão 4 só aceita resoluções pré-definidas, não digo que você não consiga fazer funcionar mesclando win32 ou outras peripécias técnicas mas vai ser uma gambiarra daquelas.

 

Eu vi aqui que em 2019 lançaram uma versão nova do Allegro 4.. a versão 4.4.3, pelo que diz o post do dev fizeram muitos bugfixes e parece que mexeram em coisas relacionadas a problemas no modo full screen. Se você não quer de jeito nenhum migrar para a versão 5 pode ser um bom ponto de partida dar uma olhada.

 

https://www.allegro.cc/forums/thread/617731

 

http://members.allegro.cc/EdgarReynaldo/BuildA4.html

 

testei aqui o o MinGW i686-8.1.0-release-posix-dwarf-rt_v6-rev0 e funcionou perfeitamente.

 

 

[arfneto]

3 horas atrás, Daniel Bittencourt disse:

Bom, provavelmente o motivo de ter gerado a janela pequena, bom não foi de eu ter deixado as medidas pequenas ou não definidas. Bem digamos que eu misturei o codigo que já vem pronto quando cria um projeto com allegro com o da janela

 

Sim. Use o Windows para descobrir o tamanho certo da janela e a configuração atual de tudo, como obviamente o fato da barra de tarefas estar configurada para ocultar automaticamente, o mais esperto e o que  afinal parece estar ficando comum. Identificado  o tamanho crie a janela do tamanho ideal.

 

Isso tudo é não-invasivo e em nada interfere com o framework, Allegro ou qualquer outro.

 

Procure usar as versões mais recentes dessas coisas. Se faz isso pode instalar com um click, mas nem sempre se tem accesso a versões antigas via gerenciador de pacotes e aí é um p0rr3 instalar

[Daniel Bittencourt]

@Benjamin Breeg tem razão... eu acho melhor não arrumar uma gambiarra dessas, não tem necessidade... vou tentar instalar o 5 de uma vez