☰

Posso executar um programa como papel de parede do Win10? (Semelhante aos papéis de parede animados do Android)

tag-icon • tag-icon windows-10 desktop-customization
Posso executar um programa como papel de parede do Win10? (Semelhante aos papéis de parede animados do Android)

Existe alguma maneira de executar um programa como papel de parede? Basta executar um exe persistentemente em segundo plano. Seria essencialmente meu próprio 'aplicativo de papel de parede'.

Responder1

Não, isso não é possível. No Vista a Microsoft criouCena dos Sonhosque era apenas um vídeo reproduzido na área de trabalho. Isso foi removido no Windows 7 e a Microsoft nunca mais adicionou algo assim.

Agora existe uma ferramenta de terceiros chamadaPapel de parede animado que afirma que pode executar aplicativos/jogos como plano de fundo

Responder2

Sim, dependendo do EXE e da sua habilidade, é possível executar um aplicativo como plano de fundo da área de trabalho.

  1. A melhor opção é escrever um programa ou script que crie o tipo certo de janela. Isto não é fácil, mas é possível. Existem scripts Python que demonstram isso em apenas algumas centenas de linhas de código. Isso oferece maior flexibilidade e eficiência e menor custo.

  2. Existe um programa gratuito de código aberto chamado Lively que facilita a adição de muitas coisas (imagem, vídeo, página da web, jogo/aplicativo Unity Engine, etc.) como plano de fundo da área de trabalho. Seus recursos não são tão amplos quanto alguns programas pagos e não são tão eficientes.

  3. Existe um programa barato (US$ 4 a US$ 5) chamado Wallpaper Engine que oferece mais recursos e melhor desempenho do que o Lively.

Existem outros programas de papel de parede pagos também. Você precisará experimentar cada opção para descobrir qual delas se adapta aos seus propósitos específicos.

Responder3

se você deseja uma maneira direta de obter controle total e ter flexibilidade máxima com um EXE como papel de parede, então você mesmo terá que fazer o programa, configurá-lo para ser executado na inicialização e certificar-se de que não é um consumidor de recursos.

em resumo, você poderia usar o mecanismo de papel de parede. mas eu não recomendaria isso se você não quiser gastar 5 dólares e puder programar.

se você escolheu programar do zero, eu recomendaria usar C e a biblioteca <windows.h> e qualquer outra coisa que você precisar. windows.h oferece uma infinidade de funções e tipos para usar para criar uma JANELA e controlá-la, e para gerenciar E/S em um nível muito inferior. por exemplo:

    #include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "v/Vec.h"
#include <windows.h>


#define PI 3.14159265358979323846
#define SECONDS_ANGLE  PI/60*2
#define MINUTES_ANGLE  PI/60/60*2
#define HOURS_ANGLE  PI/60/60/12*2
#define SECONDS_HAND_LENGTH 135*3
#define MINUTES_HAND_LENGTH 140*3
#define HOURS_HAND_LENGTH 90*3
#define PIXEL_RATIO_X 2.0
#define PIXEL_RATIO_Y 5.0
#define nScreenWidth  (1920.0)/PIXEL_RATIO_X        // Console Screen Size X (columns)
#define nScreenHeight (1080.0)/PIXEL_RATIO_Y        // Console Screen Size Y (rows)

typedef struct Circle{
    Vector center;
    float radius;
} Circle,*PCircle;

void scrprint(wchar_t* scrn, Vector center, Vector b, char L){
    //Vector a = VaddR(c,VratioScale(b,(Vector){1,1}));
    Vector a = VaddR(center,b);
    scrn[(int)((int)a.y*nScreenWidth + a.x)] = L;
}

void mlerp (wchar_t* scrn, Vector c, Vector b, double count,char L){
    double inc = 1/count;
    
    for (double i = 0; i <1 ; i+=inc)
    {
        scrprint(scrn, c, VscaleR(b,i), L);
    }
    
}

void DrawCircle(wchar_t* scrn, Circle C, double definition){
    Vector pointer = {0, -1,1};
    double angle = 2*PI/definition;
    for (double i = 0; i<2*PI; i+=angle){
        scrprint(scrn,C.center,VratioScale(VscaleR(pointer,C.radius),(Vector){1/PIXEL_RATIO_X,1/PIXEL_RATIO_Y}),'0');
        Vrotate(&pointer,angle);
    }
}

// #define _WIN32_WINNT 0x0601
// #include<windows.h>
// typedef struct _CONSOLE_FONT_INFOEX
// {
//     ULONG cbSize;
//     DWORD nFont;
//     COORD dwFontSize;
//     UINT  FontFamily;
//     UINT  FontWeight;
//     WCHAR FaceName[LF_FACESIZE];
// }CONSOLE_FONT_INFOEX, *PCONSOLE_FONT_INFOEX;
// //the function declaration begins
// #ifdef __cplusplus
// extern "C" {
// #endif
// BOOL WINAPI SetCurrentConsoleFontEx(HANDLE hConsoleOutput, BOOL bMaximumWindow, PCONSOLE_FONT_INFOEX
// lpConsoleCurrentFontEx);
// #ifdef __cplusplus
// }
// #endif

int main(){
    
    //*set up font size , screen and allocation of buffer
    
    CONSOLE_FONT_INFOEX cfi;
    //WindowFromPoint((POINT){0,0});
    //ShowWindow(GetConsoleWindow(), SW_MAXIMIZE);
    
    ShowCursor(SW_HIDE);
    
    cfi.nFont = FF_DECORATIVE;
    cfi.FontWeight = 1;
    cfi.FontFamily = FKF_CLICKON;
    cfi.dwFontSize.X = 1;
    cfi.dwFontSize.Y = 1;
    
    PCONSOLE_FONT_INFOEX cfiP = &cfi;
    
    // Create Screen Buffer
    wchar_t *screen = (wchar_t*)malloc(sizeof(wchar_t[(int)(nScreenWidth*nScreenHeight)]));
    
    
    POINT mousexy;
    MOUSEINPUT mI;
    COORD loc;
    //*/

    //*handle the console screen
    PCOORD throwaway;
    HWND hCosWindow = GetConsoleWindow();
    UINT hConsoleOut = GetConsoleOutputCP();
    HANDLE hSTDCon = GetStdHandle(STD_OUTPUT_HANDLE);
    HANDLE hConsole = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, 0, NULL, CONSOLE_TEXTMODE_BUFFER, 0);
    SetConsoleActiveScreenBuffer(hConsole);
    SetCurrentConsoleFontEx(hCosWindow, 0,cfiP);
    SetConsoleDisplayMode(hCosWindow,SHOW_FULLSCREEN,throwaway);
    
    
    
    DWORD dwBytesWritten = 0;
    //*/

    Vector VminutesHand, VhoursHand, VsecondsHand, VscrCenter,
           VhalfCM, VrescaledHands_S, VrescaledHands_M, VrescaledHands_H;
    //*Vector Init
    VscrCenter.x = (nScreenWidth)/2;
    VscrCenter.y = (nScreenHeight)/2;
    VsecondsHand.y = -SECONDS_HAND_LENGTH;
    VminutesHand.y = -MINUTES_HAND_LENGTH;
    VhoursHand.y = -HOURS_HAND_LENGTH;
    VsecondsHand.x = 0;
    VminutesHand.x = 0;
    VhoursHand.x = 0;
    //*/
    
    clock_t start =clock(), end = clock();
    double timeTaken = 0;
    
    time_t rawtime;
    struct tm * timeinfo;
    
    time(&rawtime);
    timeinfo = localtime(&rawtime);
    
    //angle between 12o'clock and current time
    Vrotate(&VsecondsHand,(2*(double)timeinfo->tm_sec*PI)/60);
    Vrotate(&VminutesHand,(2*((double)timeinfo->tm_min+(double)timeinfo->tm_sec/60)*PI)/60);
    Vrotate(&VhoursHand,(2*((double)timeinfo->tm_hour+((double)timeinfo->tm_min/60+(double)timeinfo->tm_sec/60/60))*PI)/12);

    Circle ClockCirc     = {VscrCenter, 150*3};
    Circle Clock12thDots = {VscrCenter, 120*3};
    Circle Clock60thDots = {VscrCenter, 140*3};

    while(GetAsyncKeyState('Q')==0 || GetAsyncKeyState(VK_LCONTROL)==0 || GetAsyncKeyState(VK_LMENU)==0){
        start = clock();
        //clear screen
        for (size_t i = 0; i < nScreenWidth*nScreenHeight; i++)
        {   
            screen[i] = ' ';           
        }
        
        DrawCircle(screen,ClockCirc,800);
        DrawCircle(screen,Clock12thDots,12);
        DrawCircle(screen,Clock60thDots,60);

        Vrotate(&VsecondsHand, -SECONDS_ANGLE * timeTaken);
        Vrotate(&VminutesHand, -MINUTES_ANGLE * timeTaken);
        Vrotate(&VhoursHand, -HOURS_ANGLE * timeTaken);       
        
        //GetCursorPos(&mousexy);
        //loc.X = (mousexy.x)/2;
        //loc.Y = (mousexy.y)/5;
        //VhalfCM = VaddR(VscrCenter,VratioScale(VsubR((Vector){loc.X, loc.Y},VscrCenter),(Vector){0.5,0.5}));
        //screen[(int)(loc.Y*(nScreenWidth) + loc.X)] = '0';
        //screen[(int)(((int)VhalfCM.y)*nScreenWidth  + (VhalfCM.x))] = '0';
        //screen[(int)((VhalfCM.y) * (nScreenWidth) + (VhalfCM.x))] = '0';
        //always 1half shifted towards vscrncenter but it is smooth 
        //screen[(int)((VscrCenter.y+loc.Y-VscrCenter.y/2)*(nScreenWidth) + VscrCenter.x+(loc.X-VscrCenter.x/2))] = '0';

        screen[(int)(VscrCenter.y*(nScreenWidth) + VscrCenter.x)] = '0';
        
        VrescaledHands_S = VratioScale(VsecondsHand,(Vector){0.5,0.2});
        VrescaledHands_M = VratioScale(VminutesHand,(Vector){0.5,0.2});
        VrescaledHands_H = VratioScale(VhoursHand,(Vector){0.5,0.2});
        
        //mlerp(screen, VscrCenter, VsubR((Vector){loc.X,loc.Y}, VscrCenter),20,'q');
        mlerp(screen,VscrCenter,VrescaledHands_S,60,'.');
        mlerp(screen,VscrCenter,VrescaledHands_M,100,'m');
        mlerp(screen,VscrCenter,VrescaledHands_H,150,'H');
        /*mouse cursor handler
        SetConsoleCursorPosition(hConsole, loc);
        //screen[(int)(loc.Y*(nScreenWidth) + loc.X)] = '0';
        //printf("\033[%d;%dH",mousexy.x, mousexy.y);
        //*/
        
        if (-0.01<VangleR(VsecondsHand,(Vector){0,-1}) && VangleR(VsecondsHand,(Vector){0,-1})<0.01){
            //MessageBeep(MB_ICONWARNING);
        }

        //diagnostics and writeout
        //swprintf_s(screen, 60, L"X= %d, Y= %d, halfCM.x= %.2f, halfCM.y= %.2f", loc.X, loc.Y, VhalfCM.x, VhalfCM.y*nScreenWidth);
        WriteConsoleOutputCharacterW(hConsole, screen, nScreenWidth * nScreenHeight, (COORD){0,0} , &dwBytesWritten);
        timeTaken = ((double) (end - start)) / CLOCKS_PER_SEC;
        end = start;
    }
    free(screen);
    
    
    return 0;
}

esse é um programa simples que fiz para fazer um Clock no console. para que funcione, você precisa definir a fonte do console como 5; entre nas propriedades do console clicando com o botão direito na janela e pressione f11 para tela inteira. os comentários são para solução de problemas e testes; você pode se livrar deles, mas se você é novo na programação do Windows, é bom ter uma ideia do esquema de nomenclatura deles e se quiser mais documentação:https://learn.microsoft.com/en-us/windows/win32/learnwin32/what-is-a-window-

para o meu "Vec.h", é apenas uma biblioteca vetorial normal:

    #ifndef VEC_H
#define VEC_H

#include <math.h>
typedef struct Vector{
    double x,y,m;

} Vector, *PVector;

void VSetEqual (PVector v1,Vector v2){
    v1->x = v2.x;
    v1->y = v2.y;
    v1->m = v2.m;
}

void Vadd (PVector v1,Vector v2){
    v1->x += v2.x;
    v1->y += v2.y;
    
}

void Vsub (PVector v1,Vector v2){
    v1->x -= v2.x;
    v1->y -= v2.y;
}

void Vscale (PVector v1, double s1){
    v1->x*=s1;
    v1->y*=s1;
    v1->m*=s1;
}

Vector VaddR (Vector v1,Vector v2){
    return (Vector){v1.x + v2.x, v1.y + v2.y};
    
}

Vector VsubR (Vector v1,Vector v2){
    return (Vector){v1.x - v2.x, v1.y - v2.y};
}

Vector VscaleR (Vector v1, double s1){
    return (Vector){v1.x * s1, v1.y * s1};
}

double Vdot(Vector A, Vector B){
    return (A.x* B.x + A.y * B.y);
}

double VmagR(Vector v1){
    return sqrt(v1.x*v1.x + v1.y*v1.y);;
}

void Vmag(PVector v1){
    v1->m =  sqrt(v1->x*v1->x + v1->y*v1->y);
}

void Vnorm(PVector v1) {
    Vmag(v1);
    if(v1->m==0) return;
    v1->x /= v1->m;
    v1->y /= v1->m;
    v1->m = 1;
}

Vector VnormR(Vector v1){
    double m = VmagR(v1);
    if (m==0)return (Vector){0,0,0};
    
    return VscaleR(v1,m);
}

Vector VratioScale(Vector v1,Vector scalars){
    v1.x *= scalars.x;
    v1.y *= scalars.y;
    return v1;
}

void Vrotate (PVector v1, double angle){
    double temp = v1->x;
    v1->x = v1->x*cosf(angle) - v1->y*sinf(angle);
    v1->y = temp*sinf(angle) + v1->y*cosf(angle);

}
Vector VrotateR (Vector v1, double angle){
    double temp = v1.x;
    v1.x = (v1.x * cos(angle)) - (v1.y * sin(angle));
    v1.y = (temp * sin(angle)) + (v1.y * cos(angle));
    return v1;
}

double VangleR(Vector v1, Vector v2){
    return (acos((v1.x*v2.x+v1.y+v2.y)/(VmagR(v1)*VmagR(v2))));
}

//cos -sin |  x
//         |
//sin cos  |  y

#endif

informação relacionada