Software > Coding

Bildschirmbereich sichern und wiederherstellen (C/C++)

(1/2) > >>

Count:
Hallo zusammen,

in einem C++-Programm, das aus Geschwindigkeitsgründen vorwiegend über die BIOS-Funktion Bconout Textausgabe macht, möchte ich eine Fileselectbox aufrufen. Dafür möchte ich vorher den Bildschirmbereich, der von der Fileselectbox beansprucht wird, sichern und anschließend wiederherstellen.

Das ganze möchte ich natürlich so kompatibel wie möglich lösen, also unabhängig von der TOS-Version, der Bildschirmauflösung und vor allem unabhängig von irgendwelchen Erweiterungen wie NVDI o.ä.

Ich habe mir überlegt, den betreffenden Bereich mit vro_cpyfm() vom Bildschirmspeicher in einen mit malloc() reservierten Speicherbereich zu kopieren und anschließend wieder zurück. Die Frage, die ich mir nun stelle, ist die, wie ich den benötigten Speicher berechne? Hat das schon mal jemand von euch gelöst?

Ich habe den Code im Anhang mal so zusammengestrichen, dass es für das Verständnis sicher ausreicht.


--- Code: ---VdiHdl vdi_handle, wk_handle;
short work_out[57];
short work_out_extnd[57];


int main() {
    short work_in[11] = { Getrez()+2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2 };
    short dummy;
    void* screen_buffer;
   
    vdi_handle = graf_handle(&dummy, &dummy, &dummy, &dummy);

    // Workstation öffnen
    v_opnvwk(work_in, &wk_handle, work_out);
   
    // Erweiterte Informationen holen (Planes)
    vq_extnd(vdi_handle, 1, work_out_extnd);
   
    ... tu was ...
   
    // (100,100) bis (200,200) sichern
    screen_buffer = getScreenContent(100, 100, 200, 200);
   
    ... Fileselector aufrufen ...
   
    // und wiederherstellen
    putScreenContent(100, 100, 200, 200, screen_buffer);

    // Speicher wieder freigeben
    free(screen_buffer);
   
    ... tu was ...
   
    return 0;
}


void* getScreenContent(short x1, short y1, short x2, short y2) {
    void*        buffer;
    MFDB         copysrc, copydst;
    short        width       = x2 - x1 + 1;
    short        height      = y2 - y1 + 1;
    short        pxyarray[8] = { x1, y1, x2,        y2
                               , 0,  0,  width - 1, height - 1
                               };
    const size_t wordlen     = sizeof(short);
    size_t       buflen;

    // Speicherbedarf berechnen
    buflen = height * wordlen * (width / wordlen + (width % wordlen != 0 ? wordlen : 0));
    buffer = malloc(buflen);

    // Kopieren von      Bildschirm    -->    Puffer
    copysrc.fd_addr    = Physbase();          copydst.fd_addr = buffer;
    copysrc.fd_w       = copydst.fd_w       = m_work_out[0] + 1;
    copysrc.fd_h       = copydst.fd_h       = m_work_out[1] + 1;
    copysrc.fd_stand   = copydst.fd_stand   = 0;
    copysrc.fd_wdwidth = copydst.fd_wdwidth = m_work_out[0] + 1 / wordlen;
    copysrc.fd_nplanes = copydst.fd_nplanes = m_work_out_extnd[4];

    v_hide_m(vdi_handle);
    vro_cpyfm(vdi_handle, S_ONLY, pxyarray, &copysrc, &copydst);
    v_show_m(vdi_handle, 1);

    return buffer;
}


void putScreenContent(short x1, short y1, short x2, short y2, void* buffer) {
    MFDB         copysrc, copydst;
    short        width       = x2 - x1 + 1;
    short        height      = y2 - y1 + 1;
    short        pxyarray[8] = { 0,  0,  width - 1, height - 1
                               , x1, y1, x2,        y2
                               };

    // Kopieren von      Puffer      -->      Puffer
    copysrc.fd_addr    = buffer;              copydst.fd_addr = Physbase();
    copysrc.fd_w       = copydst.fd_w       = m_work_out[0] + 1;
    copysrc.fd_h       = copydst.fd_h       = m_work_out[1] + 1;
    copysrc.fd_stand   = copydst.fd_stand   = 0;
    copysrc.fd_wdwidth = copydst.fd_wdwidth = m_work_out[0] + 1 / sizeof(short);
    copysrc.fd_nplanes = copydst.fd_nplanes = m_work_out_extnd[4];

    v_hide_m(vdi_handle);
    vro_cpyfm(vdi_handle, S_ONLY, pxyarray, &copysrc, &copydst);
    v_show_m(vdi_handle, 1);
}
--- Ende Code ---

guest3744:
Gibt es keine Refresh-Befehl für solche Dinge auf dem Desktop?

Gruss

mfro:

--- Zitat von: Count am So 22.11.2015, 19:30:46 ---...Ich habe mir überlegt, den betreffenden Bereich mit vro_cpyfm() vom Bildschirmspeicher in einen mit malloc() reservierten Speicherbereich zu kopieren und anschließend wieder zurück. Die Frage, die ich mir nun stelle, ist die, wie ich den benötigten Speicher berechne? Hat das schon mal jemand von euch gelöst?

--- Ende Zitat ---

Der Speicherbedarf für die Kopie des Bildschirmausschnitts ist unabhängig von der Auflösung

Breite in Worten x 2 Bytes/Wort x Anzahl Planes x Höhe in Pixel Bytes

mit

Breite in Worten = (Breite in Pixel + 15) / 16;

ST-Oldie:
Hi,


--- Zitat von: mfro am Mo 23.11.2015, 11:44:57 ---Der Speicherbedarf für die Kopie des Bildschirmausschnitts ist unabhängig von der Auflösung
--- Ende Zitat ---

Du meinst wohl abhängig? Zumindest die Farbtiefe geht da schon ein.


--- Zitat von: mfro am Mo 23.11.2015, 11:44:57 ---Breite in Worten x 2 Bytes/Wort x Anzahl Planes x Höhe in Pixel Bytes

mit

Breite in Worten = (Breite in Pixel + 15) / 16;
--- Ende Zitat ---

Wobei "Anzahl Planes" die Abhängigkeit zur Farbtiefe darstellt.

Tschüß
Michael

guest3744:
Mit welchem "C++" programmierst du auf den ST ?

Danke.
Gruss

Navigation

[0] Themen-Index

[#] Nächste Seite