#include <math.h>
#include <stdlib.h>
#include <graphics.h>

int main (void)
{
   int gd=9, mode=2;
   double x, y, z;
   initgraph(&gd, &mode, ".");
   while (!kbhit()) {
      z = random(3);
      x = x / 2 + sin(z / 3 * (2 * M_PI));
      y = y / 2 + cos(z / 3 * (2 * M_PI));
      putpixel(320 + (x * 120), 241 - (y * 120), 15-z);
   }
   closegraph();
   return 1;
}

#include <windows.h>
#include <ddraw.h>
#include <mmsystem.h>

// полезные макросы, пригодятся

#define SAFE_DELETE(p)  { if(p) { delete (p);     (p)=NULL; } }   
#define SAFE_RELEASE(p) { if(p) { (p)->Release(); (p)=NULL; } }


// режим экрана

#define SCREEN_WIDTH    1024
#define SCREEN_HEIGHT   768
#define SCREEN_BPP      32



LRESULT CALLBACK MainWndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam ); // колбек-процедура обработки сообщений
HRESULT WinInit( HINSTANCE hInst, int nCmdShow, HWND* phWnd, HACCEL* phAccel );  // инициализация Win32
HRESULT InitDirectDraw( HWND hWnd );  // инициализация DirectDraw (мы же хотим полноценный полноэкранный режим?)


HRESULT ProcessNextFrame(); // процедура отображения очередного кадра

HRESULT RestoreSurfaces(); // восстановление потерянных поверхностей (в случае alt-tab и др.)

VOID    FreeDirectDraw(); // корректное завершение DirectDraw




LPDIRECTDRAW            DDRAW=NULL;    // объект DirectDraw
LPDIRECTDRAWSURFACE     DSprim=NULL;   // первичная поверхность
LPDIRECTDRAWSURFACE     DSback=NULL;   // вторичная поверхность

HWND     hWnd;    // хендл окна


BOOL                 g_bActive = FALSE; // для отключения рендеринга при неактивном окне

int APIENTRY WinMain( HINSTANCE hInst, HINSTANCE, LPSTR, int nCmdShow )
{
    MSG       msg;
    HACCEL   hAccel;


    srand( GetTickCount() );

    // инициализация Win32

    if( FAILED( WinInit( hInst, nCmdShow, &hWnd, &hAccel ) ) )  return FALSE;

    // инициализация DirectDraw

    if( FAILED( InitDirectDraw( hWnd ) ) )
    {
        MessageBox( hWnd, TEXT("DirectDraw init failed. ")
                    TEXT("The program will now exit. "), TEXT("Треугольник Серпиньского"),
                    MB_ICONERROR | MB_OK );
        return FALSE;
    }

   

    while( TRUE )
    {
        // Смотрим очередь сообщений, если сообщений нет, рисуем кадр

        if( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) )
        {
            if( 0 == GetMessage(&msg, NULL, 0, 0 ) )
            {
                // пришло WM_QUIT, выходим
                return (int)msg.wParam;
            }

            // Translate&dispatch

            if( 0 == TranslateAccelerator( hWnd, hAccel, &msg ) )
            {
                TranslateMessage( &msg );
                DispatchMessage( &msg );
            }
        }
        else
        {
            if( g_bActive )
            {

                if( FAILED( ProcessNextFrame() ) )
                {
                   

                    MessageBox( hWnd, TEXT("Displaying the next frame failed. ")
                                TEXT("The program will now exit. "), TEXT("Треугольник Серпиньского"),
                                MB_ICONERROR | MB_OK );
                    return FALSE;
                }
            }
            else
            {
                // не рисуем кадр, если не нужно

                WaitMessage();
            }
        }
    }
}

HRESULT WinInit( HINSTANCE hInst, int nCmdShow, HWND* phWnd, HACCEL* phAccel )
{
    WNDCLASS wc;
    HWND     hWnd;


    // Регистрация класса окна

    wc.lpszClassName = TEXT("Triangle");
    wc.lpfnWndProc   = MainWndProc;
    wc.style         = CS_VREDRAW | CS_HREDRAW;
    wc.hInstance     = hInst;
    wc.hIcon         = LoadIcon( hInst, MAKEINTRESOURCE(IDI_MAIN) );
    wc.hCursor       = LoadCursor( NULL, IDC_ARROW );
    wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
    wc.lpszMenuName  = NULL;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;

    if( RegisterClass( &wc ) == 0 )
        return E_FAIL;


    // Создаем и показываем главное окно

    hWnd = CreateWindowEx( 0, TEXT("Triangle"), TEXT("Треугольник Серпиньского"),
                           WS_POPUP, CW_USEDEFAULT, CW_USEDEFAULT,
                            CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInst, NULL );
    if( hWnd == NULL )
       return E_FAIL;

    ShowWindow( hWnd, nCmdShow );
    UpdateWindow( hWnd );

    *phWnd   = hWnd;
    *phAccel = NULL; // ну их пока, эти акселлераторы





    return S_OK;
}

HRESULT InitDirectDraw( HWND hWnd )
{
   HRESULT hr;
   DDSURFACEDESC SD;
   DDSCAPS SC;
   HDC DC;


   hr=DirectDrawCreate(NULL,&DDRAW,NULL);

   if(hr == DD_OK)
   {
      // Получаем эксклюзивный режим
      
       hr = DDRAW->SetCooperativeLevel(hWnd,DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
      
       if(hr == DD_OK)
       {
      
         hr=DDRAW->SetDisplayMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP);

         if(hr == DD_OK)
         {
          
         // Создаем первичную поверхность с одним бекбуффером (double buffering)
         
           SD.dwSize = sizeof(SD);
           SD.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
           SD.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
           SD.dwBackBufferCount = 1;
           hr = DDRAW->CreateSurface(&SD, &DSprim, NULL);
           if(hr == DD_OK)
           {
            
            // получаем указатель на вторичную поверхность (бекбуффер)
          
              SC.dwCaps = DDSCAPS_BACKBUFFER;
              DSprim->GetAttachedSurface(&SC,&DSback);


              return DD_OK;
           }
          }
       }
   }


    return DD_FALSE;
}

LRESULT CALLBACK MainWndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
    switch (msg)
    {
      case WM_KEYDOWN:
          
          // выход по нажатию любой клавиши
         
           PostMessage( hWnd, WM_CLOSE, 0, 0 );
         break;


        case WM_SETCURSOR:
           
         // Прячем курсор в полноэкранном режиме
           
         SetCursor( NULL );
            return TRUE;

        case WM_SIZE:
           
         // Окно становится неактивным...
           
         if( SIZE_MAXHIDE==wParam || SIZE_MINIMIZED==wParam )
                g_bActive = FALSE;
            else
                g_bActive = TRUE;

            break;
           
        case WM_EXITMENULOOP:

            break;

        case WM_EXITSIZEMOVE:
 
            break;
           
        case WM_MOVE:
       
            break;

        case WM_SYSCOMMAND:
           
         // В полноэкранном режиме нехорошо выключать монитор и менять размеры/положение окна
           
         switch( wParam )
            {
                case SC_MOVE:
                case SC_SIZE:
                case SC_MAXIMIZE:
                case SC_MONITORPOWER:
                    return TRUE;
            }
            break;
           
        case WM_DESTROY:
           
         // Собираем мусор и выходим
           
         FreeDirectDraw();
           
            PostQuitMessage( 0 );
            return 0L;
    }

   // не забываем отдать остальное дефолтному обработчику
   
    return DefWindowProc(hWnd, msg, wParam, lParam); 
}

HRESULT ProcessNextFrame()
{
    HRESULT hr;


      // Блокировка поверхности
   
   DDSURFACEDESC2 desc;
   ZeroMemory(&desc, sizeof(desc));
   desc.dwSize = sizeof(desc);
   
   if (DSprim->Lock(0, &desc, DDLOCK_WAIT, 0)==DD_OK)
   {
      BYTE* dst = (BYTE *)desc.lpSurface;  // поверхность в видеопамяти
      
      
      z = random(3);
       x = x / 2 + sin(z / 3 * (2 * M_PI));
       y = y / 2 + cos(z / 3 * (2 * M_PI));
      
      int iOffset = y*desc.lPitch + x*2; // смещение в видеопамяти
      
      *(DWORD *)(dst + iOffset) = 0xFFFFF; // ставим беленький пиксель))
      
      DSprim->Unlock(0);
    }
   

    // Меняем местами передний и задний буферы
   
    if( FAILED( hr = DSprim->Flip(NULL, 0) ) )
    {
        if( hr != DDERR_SURFACELOST )
            return hr;

        // Мы потеряли поверхности, надо их восстановить
      
        RestoreSurfaces();
    }

    return S_OK;
}

HRESULT RestoreSurfaces()
{
   HRESULT hr;

   hr=DSprim->Restore();
   

   return hr;
}

VOID FreeDirectDraw()
{
   SAFE_RELEASE(DSprim);
   SAFE_RELEASE(DDRAW);
}

#include <windows.h>
#include <math.h>


LRESULT CALLBACK WndProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam);
HWND hWnd=NULL;



//---------------------------------------------------------------------------
WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int)
{
  WNDCLASS wndWc; MSG msg;
  wndWc.style = CS_OWNDC;
  wndWc.lpfnWndProc = (WNDPROC) WndProc;
  wndWc.cbClsExtra = 0;
  wndWc.cbWndExtra = 0;
  wndWc.hInstance = hInstance;
 
  wndWc.hCursor = LoadCursor(0, IDC_ARROW);
  wndWc.hbrBackground = CreateSolidBrush(0x00000000);
  wndWc.lpszMenuName = NULL;
  wndWc.lpszClassName = "Virus";
  if (!RegisterClass(&wndWc)) return false;

  int w = (WORD)GetSystemMetrics(SM_CXSCREEN);
  int h = (WORD)GetSystemMetrics(SM_CYSCREEN);
  RECT rc = {(w-300)/2,(h-300)/2,300,300};

  hWnd = CreateWindow("Virus",szs,WS_OVERLAPPEDWINDOW,rc.left,rc.top,300,300,NULL,NULL,GetModuleHandle(NULL),NULL);

  ShowWindow(hWnd, SW_SHOW);






    while( TRUE )
    {
        // Смотрим очередь сообщений, если сообщений нет, рисуем кадр

        if( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) )
        {
            if( 0 == GetMessage(&msg, NULL, 0, 0 ) )
            {
                // пришло WM_QUIT, выходим
                return (int)msg.wParam;
            }

            // Translate&dispatch

            if( 0 == TranslateAccelerator( hWnd, hAccel, &msg ) )
            {
                TranslateMessage( &msg );
                DispatchMessage( &msg );
            }
        }
        else
        {
            // рисуем
         
         HDC DC = GetDC(hWnd); // получаем контекст нашего окна
         
         z = random(3);
         x = x / 2 + sin(z / 3 * (2 * M_PI));
         y = y / 2 + cos(z / 3 * (2 * M_PI));
         SetPixel(DC, x, y, RGB(FF, FF, FF));
         
         ReleaseDC(DC);
        }
    }

  DestroyWindow(hWnd);
  return 0;
}




LRESULT CALLBACK WndProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
{

switch(uMessage)
  {
  case WM_KEYDOWN:
    {
    switch (wParam)
      {
        case VK_ESCAPE:
          PostQuitMessage(0);
        break;
      }
    break;
    }
  case WM_DESTROY:
   {
     PostQuitMessage(0);
   }
  default:
    return DefWindowProc(hWnd,uMessage,wParam,lParam);
  }
return(0);
}

#include <QtGui/QApplication>
#include "test.h"

int main(int argc, char *argv[])
{
   QApplication app(argc, argv);
   test win;
   win.show();
   app.connect(&app, SIGNAL(lastWindowClosed()), &app, SLOT(quit()));
   return app.exec();
}

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop
//---------------------------------------------------------------------------
USEFORM("main.cpp", Form1);
//---------------------------------------------------------------------------
WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
        try
        {
                 Application->Initialize();
                 Application->CreateForm(__classid(TForm1), &Form1);
                 Application->Run();
        }
        catch (Exception &exception)
        {
                 Application->ShowException(&exception);
        }
        catch (...)
        {
                 try
                 {
                         throw Exception("");
                 }
                 catch (Exception &exception)
                 {
                         Application->ShowException(&exception);
                 }
        }
        return 0;
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "main.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{

}

class CTest{
public:
       LPWSTR wcName;
       CTest(void);
       ~CTest(void);
};
CTest::CTest(void){
    wcName = new WCHAR[10];
    wcscpy(wcName,_T("Проверка"));
}
CTest::~CTest(void){
    if (wcName != NULL){
         delete [] wcName;
    }   
}
main(){
CTest* lpTest = new CTest[5];
delete []lpTest;
}