Ignore:
Timestamp:
Dec 16, 2000, 10:09:53 PM (25 years ago)
Author:
umoeller
Message:

Miscellanous updates.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/helpers/animate.c

    r15 r17  
    4444#define INCL_DOSERRORS
    4545
     46#define INCL_WINWINDOWMGR
    4647#define INCL_WINPOINTERS
    4748#define INCL_WINSYS
    … …  
    5556#include <string.h>
    5657
    57 #include "setup.h"                      // code generation and debugging options
    58 
    59 #include "helpers\animate.h"
    60 
    61 #include "helpers\winh.h"
    62 #include "helpers\gpih.h"
     58// #include "setup.h"                      // code generation and debugging options
     59
     60// #include "helpers\animate.h"
     61
     62// #include "helpers\winh.h"
     63// #include "helpers\gpih.h"
    6364
    6465/*
    … …  
    165166}
    166167
    167 #define LAST_WIDTH 2
    168 #define LAST_STEPS 50
    169 #define WAIT_TIME  10
     168#define LAST_LINE_WIDTH 2
    170169
    171170/* ******************************************************************
    … …  
    179178 *      displays an animation that looks like a
    180179 *      monitor being turned off; hps must have
    181  *      been acquired using WinGetScreenPS,
    182  *      ulSteps should be around 40-50.
     180 *      been acquired using WinGetScreenPS.
    183181 *
    184182 *@@changed V0.9.7 (2000-12-08) [umoeller]: got rid of dtGetULongTime
    185183 */
    186184
    187 VOID anmPowerOff(HPS hps, ULONG ulSteps)
     185VOID anmPowerOff(HPS hps,
     186                 ULONG ulMaxTime1, //  = 500,
     187                 ULONG ulMaxTime2, //  = 800,
     188                 ULONG ulMaxTime3, //  = 200,
     189                 ULONG ulWaitEnd)  //  = 300
    188190{
    189     RECTL       rclScreen, rclNow, rclLast, rclDraw;
    190     ULONG       ul = ulSteps;
    191     ULONG       ulPhase = 1;
     191    RECTL       rclScreen,
     192                rclNow,
     193                rclLast,
     194                rclDraw;
     195    ULONG       ulPhase = 1,
     196                ulCXLastLine;
     197
     198    ULONG       ulStartTime = 0,
     199                ulTimeNow = 0;
    192200
    193201    WinQueryWindowRect(HWND_DESKTOP, &rclScreen);
     202    ulCXLastLine = rclScreen.xRight / 3;
    194203
    195204    WinShowPointer(HWND_DESKTOP, FALSE);
    … …  
    200209    // "phases", signified by the ulPhase variable. While
    201210    // ulPhase != 99, we stay in a do-while loop.
    202     ul = 0;
    203211    ulPhase = 1;
    204212
    205213    do
    206214    {
    207         ULONG ulFromTime, ulTime2;
     215        // get current time
    208216        DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT,
    209                         &ulFromTime,
    210                         sizeof(ulFromTime));
     217                        &ulTimeNow,
     218                        sizeof(ulTimeNow));
     219
     220        // get start time
     221        if (ulStartTime == 0)
     222            // this is reset when we enter a new phase
     223            ulStartTime = ulTimeNow;
    211224
    212225        if (ulPhase == 1)
    … …  
    218231            // the center is black too. Sort of like this:
    219232
    220             //          ***************************
    221             //          *       black             *
    222             //          *                         *
    223             //          *      .............      *
    224             //          *      . rclNow:   .      *
    225             //          *  ->  . untouched .  <-  *
    226             //          *      .............      *
    227             //          *            ^            *
    228             //          *            !            *
    229             //          ***************************
     233            //          ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
     234            //          º       black             º
     235            //          º                         º
     236            //          º      ÚÄÄÄÄÄÄÄÄÄÄÄ¿      º
     237            //          º      ³ rclNow:   ³      º
     238            //          º  ->  ³ untouched ³  <-  º
     239            //          º      ÀÄÄÄÄÄÄÄÄÄÄÄÙ      º
     240            //          º            ^            º
     241            //          º            |            º
     242            //          ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍŒ
     243
     244            // This part lasts exactly (ulMaxTime1) milliseconds.
    230245
    231246            // rclNow contains the rectangle _around_ which
    232247            // the black rectangles are to be drawn. With
    233248            // every iteration, rclNow is reduced in size.
    234             rclNow.xLeft = ((rclScreen.yTop / 2) * ul / ulSteps );
     249            ULONG ulMaxX = (rclScreen.xRight - ulCXLastLine) / 2,
     250                  ulMaxY = rclScreen.yTop / 2 - LAST_LINE_WIDTH;
     251            ULONG ulTimePassed = (ulTimeNow - ulStartTime);
     252            if (ulTimePassed >= ulMaxTime1)
     253            {
     254                // time has elapsed:
     255                ulTimePassed = ulMaxTime1;
     256                // enter next phase on next loop
     257                ulPhase++;
     258                // reget start time
     259                ulStartTime = 0;
     260            }
     261            rclNow.xLeft = ulMaxX * ulTimePassed / ulMaxTime1;
     262            rclNow.yBottom = ulMaxY * ulTimePassed / ulMaxTime1;
     263            rclNow.xRight = (rclScreen.xRight) - rclNow.xLeft;
     264            rclNow.yTop = (rclScreen.yTop) - rclNow.yBottom;
     265
     266            /* rclNow.xLeft = ((rclScreen.yTop / 2) * ul / ulSteps );
    235267            rclNow.xRight = (rclScreen.xRight) - rclNow.xLeft;
    236268            rclNow.yBottom = ((rclScreen.yTop / 2) * ul / ulSteps );
    237             rclNow.yTop = (rclScreen.yTop) - rclNow.yBottom;
    238 
    239             if (rclNow.yBottom > (rclNow.yTop - LAST_WIDTH) )
     269            rclNow.yTop = (rclScreen.yTop) - rclNow.yBottom; */
     270
     271            /* if (rclNow.yBottom > (rclNow.yTop - LAST_WIDTH) )
    240272            {
    241273                rclNow.yBottom = (rclScreen.yTop / 2) - LAST_WIDTH;
    242274                rclNow.yTop = (rclScreen.yTop / 2) + LAST_WIDTH;
    243             }
     275            } */
    244276
    245277            // draw black rectangle on top of rclNow
    … …  
    275307
    276308            // done with "shrinking"?
    277             if ( rclNow.xRight < ((rclScreen.xRight / 2) + LAST_WIDTH) )
     309            /* if ( rclNow.xRight < ((rclScreen.xRight / 2) + LAST_WIDTH) )
     310            {
    278311                ulPhase = 2; // exit
     312                // reget start time
     313                ulStartTime = 0;
     314            } */
     315
     316            if (ulPhase == 2)
     317            {
     318                // this was the last step in this phase:
     319                memcpy(&rclLast, &rclScreen, sizeof(RECTL));
     320            }
    279321        }
    280322        else if (ulPhase == 2)
    281323        {
    282324            // Phase 2: draw a horizontal white line about
    283             // where the last rclNow was. This is only
    284             // executed once.
    285 
    286             //          ***************************
    287             //          *       black             *
    288             //          *                         *
    289             //          *                         *
    290             //          *        -----------      *
    291             //          *                         *
    292             //          *                         *
    293             //          *                         *
    294             //          ***************************
    295 
    296             rclDraw.xLeft = (rclScreen.xRight / 2) - LAST_WIDTH;
    297             rclDraw.xRight = (rclScreen.xRight / 2) + LAST_WIDTH;
    298             rclDraw.yBottom = (rclScreen.yTop * 1 / 4);
    299             rclDraw.yTop = (rclScreen.yTop * 3 / 4);
    300             WinFillRect(hps, &rclDraw, CLR_WHITE);
    301 
    302             ulPhase = 3;
    303             ul = 0;
    304 
     325            // where the last rclNow was. and shrink it
     326            // towards the middle. This ends with a white
     327            // dot in the middle of the screen.
     328
     329            //          ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
     330            //          º       black             º
     331            //          º                         º
     332            //          º                         º
     333            //          º  -->   ÄwhiteÄÄÄÄ   <-- º
     334            //          º                         º
     335            //          º                         º
     336            //          º                         º
     337            //          ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍŒ
     338
     339            // This part lasts exactly (ulMaxTime2) milliseconds.
     340
     341            // start is same as max in step 1
     342            ULONG ulStartX = (rclScreen.xRight - ulCXLastLine) / 2,
     343                  ulY      = rclScreen.yTop / 2 - LAST_LINE_WIDTH;
     344            ULONG ulMaxX = (rclScreen.xRight) / 2 - LAST_LINE_WIDTH;      // center
     345            ULONG ulTimePassed = (ulTimeNow - ulStartTime);
     346            if (ulTimePassed >= ulMaxTime2)
     347            {
     348                // time has elapsed:
     349                ulTimePassed = ulMaxTime2;
     350                // enter next phase on next loop
     351                ulPhase++;
     352                // reget start time
     353                ulStartTime = 0;
     354            }
     355
     356            rclNow.xLeft =  ulStartX
     357                          + ( (ulMaxX - ulStartX) * ulTimePassed / ulMaxTime2 );
     358            rclNow.yBottom = ulY;
     359            rclNow.xRight = (rclScreen.xRight) - rclNow.xLeft;
     360            rclNow.yTop = (rclScreen.yTop) - rclNow.yBottom;
     361
     362            // draw black rectangle left of rclNow
     363            rclDraw.xLeft = rclLast.xLeft;
     364            rclDraw.xRight = rclNow.xLeft;
     365            rclDraw.yBottom = rclLast.yBottom;
     366            rclDraw.yTop = rclLast.yTop;
     367            WinFillRect(hps, &rclDraw, CLR_BLACK);
     368
     369            // draw black rectangle right of rclNow
     370            rclDraw.xLeft = rclNow.xRight;
     371            rclDraw.xRight = rclLast.xRight;
     372            rclDraw.yBottom = rclLast.yBottom;
     373            rclDraw.yTop = rclLast.yTop;
     374            WinFillRect(hps, &rclDraw, CLR_BLACK);
     375
     376            // WinFillRect(hps, &rclNow, CLR_WHITE);
     377
     378            // remember rclNow for next iteration
     379            memcpy(&rclLast, &rclNow, sizeof(RECTL));
     380
     381            if (ulPhase == 3)
     382            {
     383                // this was the last step in this phase:
     384                // keep the dot visible for a while
     385                DosSleep(ulMaxTime3);
     386
     387                // draw a white line for phase 3
     388                rclLast.xLeft = ulMaxX;
     389                rclLast.yBottom = rclScreen.yTop / 4;
     390                rclLast.xRight = rclScreen.xRight - rclLast.xLeft;
     391                rclLast.yTop = rclScreen.yTop - rclLast.yBottom;
     392
     393                WinFillRect(hps, &rclLast, CLR_WHITE);
     394            }
    305395        }
    306396        else if (ulPhase == 3)
    … …  
    308398            // Phase 3: make the white line shorter with
    309399            // every iteration by drawing black rectangles
    310             // above it. These are drawn closer to the
    311             // center with each iteration.
    312 
    313             //          ***************************
    314             //          *       black             *
    315             //          *                         *
    316             //          *                         *
    317             //          *       ->  ----  <-      *
    318             //          *                         *
    319             //          *                         *
    320             //          *                         *
    321             //          ***************************
    322 
    323             rclDraw.xLeft = (rclScreen.xRight / 2) - LAST_WIDTH;
    324             rclDraw.xRight = (rclScreen.xRight / 2) + LAST_WIDTH;
     400            // above and below it. These are drawn closer
     401            // to the center with each iteration.
     402
     403            //          ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
     404            //          º                         º
     405            //          º                         º
     406            //          º            |            º
     407            //          º            |            º
     408            //          º            |            º
     409            //          º                         º
     410            //          º                         º
     411            //          ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍŒ
     412
     413            // This part lasts exactly ulMaxTime3 milliseconds.
     414            ULONG ulX = (rclScreen.xRight) / 2 - LAST_LINE_WIDTH,      // center
     415                  ulStartY = rclScreen.yTop / 4;
     416            ULONG ulMaxY = (rclScreen.yTop) / 2 - LAST_LINE_WIDTH;      // center
     417            ULONG ulTimePassed = (ulTimeNow - ulStartTime);
     418            if (ulTimePassed >= ulMaxTime3)
     419            {
     420                // time has elapsed:
     421                ulTimePassed = ulMaxTime3;
     422                // stop
     423                ulPhase = 99;
     424            }
     425
     426            rclNow.xLeft =  ulX;
     427            rclNow.yBottom = ulStartY
     428                          + ( (ulMaxY - ulStartY) * ulTimePassed / ulMaxTime3 );
     429            rclNow.xRight = (rclScreen.xRight) - rclNow.xLeft;
     430            rclNow.yTop = (rclScreen.yTop) - rclNow.yBottom;
     431
     432            // draw black rectangle on top of rclNow
     433            rclDraw.xLeft = rclLast.xLeft;
     434            rclDraw.xRight = rclLast.xRight;
     435            rclDraw.yBottom = rclNow.yTop;
     436            rclDraw.yTop = rclLast.yTop;
     437            WinFillRect(hps, &rclDraw, CLR_BLACK);
     438
     439            // draw black rectangle at the bottom of rclNow
     440            rclDraw.xLeft = rclLast.xLeft;
     441            rclDraw.xRight = rclLast.xRight;
     442            rclDraw.yBottom = rclLast.yBottom;
     443            rclDraw.yTop = rclNow.yBottom;
     444            WinFillRect(hps, &rclDraw, CLR_BLACK);
     445
     446            // remember rclNow for next iteration
     447            memcpy(&rclLast, &rclNow, sizeof(RECTL));
     448
     449            /* rclDraw.xLeft = (rclScreen.xRight / 2) - LAST_LINE_WIDTH;
     450            rclDraw.xRight = (rclScreen.xRight / 2) + LAST_LINE_WIDTH;
    325451            rclDraw.yTop = (rclScreen.yTop * 3 / 4);
    326452            rclDraw.yBottom = (rclScreen.yTop * 3 / 4) - ((rclScreen.yTop * 1 / 4) * ul / LAST_STEPS);
    327             if (rclDraw.yBottom < ((rclScreen.yTop / 2) + LAST_WIDTH))
    328                 rclDraw.yBottom = ((rclScreen.yTop / 2) + LAST_WIDTH);
    329             WinFillRect(hps, &rclDraw, CLR_BLACK);
    330 
    331             rclDraw.xLeft = (rclScreen.xRight / 2) - LAST_WIDTH;
    332             rclDraw.xRight = (rclScreen.xRight / 2) + LAST_WIDTH;
     453            if (rclDraw.yBottom < ((rclScreen.yTop / 2) + LAST_LINE_WIDTH))
     454                rclDraw.yBottom = ((rclScreen.yTop / 2) + LAST_LINE_WIDTH);
     455            WinFillRect(hps, &rclDraw, CLR_BLACK);
     456
     457            rclDraw.xLeft = (rclScreen.xRight / 2) - LAST_LINE_WIDTH;
     458            rclDraw.xRight = (rclScreen.xRight / 2) + LAST_LINE_WIDTH;
    333459            rclDraw.yBottom = (rclScreen.yTop * 1 / 4);
    334460            rclDraw.yTop = (rclScreen.yTop * 1 / 4) + ((rclScreen.yTop * 1 / 4) * ul / LAST_STEPS);
    335             if (rclDraw.yTop > ((rclScreen.yTop / 2) - LAST_WIDTH))
    336                 rclDraw.yBottom = ((rclScreen.yTop / 2) - LAST_WIDTH);
     461            if (rclDraw.yTop > ((rclScreen.yTop / 2) - LAST_LINE_WIDTH))
     462                rclDraw.yBottom = ((rclScreen.yTop / 2) - LAST_LINE_WIDTH);
    337463
    338464            WinFillRect(hps, &rclDraw, CLR_BLACK);
    339465
    340466            ul++;
    341             if (ul > LAST_STEPS)
    342                 ulPhase = 99;
     467            if (ul > LAST_STEPS) */
     468            //     ulPhase = 99;
    343469        }
    344470
    345         ul++;
    346 
    347         DosSleep(WAIT_TIME);
    348 
    349         /* do
    350         {
    351             DosSleep(0);
    352             DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT,
    353                             &ulTime2,
    354                             sizeof(ulTime2));
    355         }  while (ulTime2 < ulFromTime + WAIT_TIME); */
    356471    } while (ulPhase != 99);
    357472
    358473    // sleep a while
    359     DosSleep(500);
     474    DosSleep(ulWaitEnd / 2);
    360475    WinFillRect(hps, &rclScreen, CLR_BLACK);
    361     DosSleep(500);
     476    DosSleep(ulWaitEnd / 2);
    362477
    363478    WinShowPointer(HWND_DESKTOP, TRUE);
    … …  
    365480
    366481
    367 
     482// testcase
     483
     484/* int main(int argc, char* argp)
     485{
     486    HENUM henum;
     487    HWND hwndTop;
     488    HAB hab = WinInitialize(0);
     489    HMQ hmq = WinCreateMsgQueue(hab, 0);
     490    HPS hps = WinGetScreenPS(HWND_DESKTOP);
     491
     492    anmPowerOff(hps);
     493
     494    henum = WinBeginEnumWindows(HWND_DESKTOP);
     495    while ((hwndTop = WinGetNextWindow(henum)))
     496        if (WinIsWindowShowing(hwndTop))
     497            WinInvalidateRect(hwndTop, NULL, TRUE);
     498    WinEndEnumWindows(henum);
     499
     500    WinShowPointer(HWND_DESKTOP, TRUE);
     501
     502    WinDestroyMsgQueue(hmq);
     503    WinTerminate(hab);
     504
     505    return (0);
     506} */
Note: See TracChangeset for help on using the changeset viewer.