☰

Kann ich ein Programm als mein Win10-Hintergrundbild ausführen? (Ähnlich wie Android Live Wallpapers)

tag-icon • tag-icon windows-10 desktop-customization
Kann ich ein Programm als mein Win10-Hintergrundbild ausführen? (Ähnlich wie Android Live Wallpapers)

Gibt es eine Möglichkeit, ein Programm als Hintergrundbild laufen zu lassen? Einfach eine EXE-Datei dauerhaft im Hintergrund laufen lassen. Im Prinzip wäre das dann meine eigene „Hintergrund-Anwendung“.

Antwort1

Nein, das ist nicht möglich. In Vista hat MicrosoftTraumszeneDabei handelte es sich lediglich um ein Video, das unter dem Desktop abgespielt wurde. Dies wurde in Windows 7 entfernt und Microsoft hat so etwas nie wieder hinzugefügt.

Es gibt jetzt ein Drittanbieter-Tool namensLebhafte Tapete das behauptet, dass es Apps/Spiele im Hintergrund ausführen kann

Antwort2

Ja, abhängig von der EXE und Ihren Fähigkeiten ist es möglich, eine Anwendung als Desktop-Hintergrund auszuführen.

  1. Die beste Option ist, ein Programm oder Skript zu schreiben, das die richtige Art von Fenster erstellt. Das ist nicht einfach, aber möglich. Es gibt Python-Skripte, die dies in nur wenigen hundert Zeilen Code demonstrieren. Dies bietet die größte Flexibilität und Effizienz bei geringsten Kosten.

  2. Es gibt ein kostenloses Open-Source-Programm namens Lively, mit dem Sie die meisten Dinge (Bilder, Videos, Webseiten, Unity Engine-Spiele/-Anwendungen usw.) als Desktop-Hintergrund hinzufügen können. Seine Funktionen sind nicht so umfangreich wie bei einigen kostenpflichtigen Programmen und es ist nicht ganz so effizient.

  3. Es gibt ein günstiges (4–5 USD) Programm namens Wallpaper Engine, das mehr Funktionen und eine bessere Leistung als Lively bietet.

Es gibt auch andere kostenpflichtige Tapetenprogramme. Sie müssen mit jeder Option experimentieren, um herauszufinden, welche Ihren speziellen Zwecken entspricht.

Antwort3

Wenn Sie auf direktem Weg die volle Kontrolle und maximale Flexibilität mit einer EXE-Datei als Hintergrundbild erreichen möchten, müssen Sie das Programm selbst erstellen, es so einstellen, dass es beim Start ausgeführt wird, und sicherstellen, dass es keine Ressourcen verschlingt.

Kurz gesagt, Sie könnten Wallpaper Engine verwenden. Aber ich würde das nicht empfehlen, wenn Sie keine 5 Dollar ausgeben möchten und programmieren können.

Wenn Sie sich dafür entscheiden, von Grund auf neu zu programmieren, würde ich Ihnen die Verwendung von C und der <windows.h>-Bibliothek und allem, was Sie sonst noch brauchen, empfehlen. windows.h bietet eine Fülle von Funktionen und Typen, die Sie zum Erstellen und Steuern eines FENSTERS und zum Verwalten von E/A auf einer viel niedrigeren Ebene verwenden können. Beispiel:

    #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;
}

das ist ein einfaches Programm, das ich gemacht habe, um eine Uhr in der Konsole zu erstellen. Damit es funktioniert, müssen Sie die Schriftart der Konsole auf 5 einstellen; gehen Sie mit einem Rechtsklick auf das Fenster in die Konsoleneigenschaften und drücken Sie dann F11 für den Vollbildmodus. Die Kommentare dienen der Fehlersuche und zum Testen; Sie können sie entfernen, aber wenn Sie neu in der Windows-Programmierung sind, ist es gut, mit ihnen ein Gefühl für das Benennungsschema zu bekommen, und wenn Sie weitere Dokumentation wünschen:https://learn.microsoft.com/en-us/windows/win32/learnwin32/what-is-a-window-

für mein „Vec.h“ ist es nur eine normale Vektorbibliothek:

    #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

verwandte Informationen