So, this situation was the motivation to create an alternative, simplified and up-to-date GStreamer installation package for windows. In fact, there is already a project with this very same goal, called OABuild, developed by Ole André Ravnas. OABuild contains a suite of MS Visual C++ projects that allows to compile GStreamer, among other useful open source libraries and tools, using the Microsoft compiler.

One problem with the current version of OABuild is that it includes a stripped-down version of FFmpeg, in order to compile it with MSVC. FFmpeg is the underlying library in GStreamer that provides support for decoding tons of commonplace video formats. However, the FFmpeg included in OABuild only provides a few codecs and hence wasn't very useful to incorporate in a general GStreamer installer.

The aim of the following sections is to show the main tasks I had to accomplish in order to create this installer, starting with the compilation of a fully functional FFmpeg distribution under windows. This is not a step-by-step tutorial, only the steps or "tricks" I considered central for success are mentioned, while other details are assumed to be known.

Anyways, for those who are not interesting in these little nasty details, here you have a link where you can download the binary installer, as well as an installer of the development files, in case you need to compile applications that use GStreamer:

20080911 release of GStreamerOABuild installer

Please note that this is an initial release intended mostly for testing and debugging. Please let me know of any issues you might find with it.

Compiling FFmpeg under windows

So, for the task of compiling the latest source of FFmpeg, the Microsoft compiler is not an option, since FFmpeg uses features of the C99 specification of the C language which are not recognized by MSVC. What I did was to use MinGW and MSYS in order to compile FFmpeg with gcc, the GNU C compiler.

There were lots of useful information on how to compile and use FFmpeg on windows machines on this FFmpeg Windows help page, specially in the wiki and forum sections. However, the wiki has been down for a couple of months. I was able to recover some data from the copies stored in the Google cache. The forum seems to be online again, though.

I set up a MinGW + MSYS development environment, but the latest stable release of MSYS (1.0.10) won't work to compile FFmepg because of an incompatibility between FFmpeg and the version of make included with 1.0.10. Version 1.0.11 solves this issue, and can be downloaded from here as individual packages. I prepared an installer that contains all those files in a single package, you can grab it from here.

Once MinGW and MSYS are installed, you have to fix the msys.bat file that is inside the root MSYS folder. The steps to perform this fix according to the FFmpeg Windows help site (gotten from Google cache) are the following:

"Open C:\msys\msys.bat in a plain-text editor, such as notepad.exe.

If you plan on compiling your apps with MSVC++ (note: your apps, not FFmpeg), you will need .lib files to link against FFmpeg's libraries.
Those .lib files can be generated by the lib command from the Microsoft's Toolchain.
For that, you must have Microsoft Visual Studio, or Microsoft Visual C++.
Add the following line to the beggining of msys.bat, replacing the path leading to vcvars32.bat to wherever that file is located in your computer:

call "C:\Program Files\Microsoft Visual Studio 8\VC\bin\vcvars32.bat"

If you have Windows x64, you must add the following lines right after the :_WindowsNT label (line 36), or else the shell window will quickly open and close:

rem Hopefully a temporary workaround for getting MSYS shell to run on x64
rem (WoW64 cmd prompt sets PROCESSOR_ARCHITECTURE to x86)
if not "x%PROCESSOR_ARCHITECTURE%" == "xAMD64" goto _NotX64
set COMSPEC=%WINDIR%\SysWOW64\cmd.exe
%COMSPEC% /c %0 %1 %2 %3 %4 %5 %6 %7 %8 %9
goto EOF
:_NotX64
"

The next important "trick" is to update the gcc included in the latest stable MinGW (which should be 3.4.5) to 4.2 or higher, otherwise FFmpeg will give nasty errors about wrong compilation and not properly aligned stack variables... I have tried gcc 4.30-preview available on the sourceforge page of MinGW, but the resulting FFmpeg is also broken. Fortunately, a version of gcc 4.2.4 available at this website worked fine. I was able to successfully compile FFmpeg (from the svn source snapshot taken on 2008-09-04) with the following configure parameters:

--enable-shared --disable-static --enable-memalign-hack --enable-w32threads

You can download a zip file containing the resulting dlls, lib files and headers from here.

Integration of MinGW-generated FFmpeg and OABuild

Once I obtained the FFmpeg's dlls, lib and headers files, I had to remove the FFmpeg that comes included with OABuild by default and to create new MSVC projects for the MinGW-generated FFmpeg. The idea is to integrate these changes into the OABuild mainline pretty soon.

Fixes to OABuild

I replaced the source code of gst-ffmpeg in OAbuild with the one from the latest stable release (0.10.5). This code needed some changes in order to compile from MSVC:

• Include <libavcodec/avcodec.h> and <libavformat/avformat.h> instead of <ffmpeg/avcodec.h> and <ffmpeg/avformat.h>
• In gstffmpegenc.c do: replace in_plugin = first_avcodec; by in_plugin = av_codec_next(NULL); and in_plugin = in_plugin->next; by in_plugin = av_codec_next(in_plugin);
• In gstffmpegdec.c, do: replace in_plugin = first_avcodec; by in_plugin = av_codec_next(NULL); and in_plugin = in_plugin->next; by in_plugin = av_codec_next(in_plugin);
• In gstffmpegdemux.c, do: replace in_plugin = first_iformat; by in_plugin = av_iformat_next(NULL); and in_plugin = in_plugin->next; by in_plugin = av_iformat_next(in_plugin);
• In gstffmpegmux.c, do: replace in_plugin = first_oformat; by in_plugin = av_oformat_next(NULL); and in_plugin = in_plugin->next;by in_plugin = av_oformat_next(in_plugin);

Also, the qtdemux element wasn't included in OABuild. Without it is not possible to open quicktime mov files. Again, using the qtdemux code from the latest gst-plugins-good package, I created a project file inside OABuild. The following changes in code were needed in order to compile the pluign:

• In qtdemux_dump.h, change #include <qtdemux.h> with #include "qtdemux.h"
• Then remove gstrtpxqtdepay.c y gstrtpxqtdepay.h from project.
• Comment out the occurrence of gst_tag_freeform_string_to_utf8 in qtdemux.c and the following code: if (!gst_element_register (plugin, "rtpxqtdepay", GST_RANK_MARGINAL, GST_TYPE_RTP_XQT_DEPAY)) return FALSE; in quicktime.c

Creating binaries with the ReleaseWdkCrt option

The binaries resulting from compiling with the Release option in OABuild won't work unless the machine where they are installed also has the MSVC 2008 redistributable package installed on it. It is a small nag, but ideally the GStreamer installer shouldn't need any aditional libraries in order to be it entirely self-contained. This is solved by using the ReleaseWdkCrt compiling option, which requires to use some CRT object files that come with the Windows Driver Kit (WDK). This is kind of a messy topic, and here it is explained in detail the logic of this workaround. The WDK can be downloaded after creating a free account on Microsoft Connect. Then, only the following files from the WDK are needed to be copied inside <OABuild root>\build\builddeps\wdkcrt.

GNU Wget page

MinGW SourceForge page

UNIX / Linux Tutorial for Beginners

Down the Port

Download the Current Release of the Wget port, version 1.9.1 as of this post, from the link below:

http://sourceforge.net/project/showfiles.php?group_id=2435&package_id=233332

Create the directory C:\MSYS\1.0\src and save the downloaded file to that path.

Note: If your MSYS is not installed on the standard path of C:\MSYS then you'll have to adjust the paths to match your installation.

Preparation

Start MSYS and then change to the /usr/src directory:

cd /usr/src

Extract the port, then change to the wget-1.9.1/mingwport directory:

tar xvjf wget-1.9.1-mingwPORT.tar.bz2
cd wget-1.9.1/mingwport


Copy the wget.exe file to the /tmp directory:

cp -p wget.exe /tmp/

Note: The port is a shell script that will download, configure, and make the Wget source automatically, after we answer a few prompts.

Compiling Wget

Execute the port script:

./mingwPORT.sh

We will accept the default response to every prompt. Press the enter key in response to the prompt to accept the default.

After pressing enter at the CFLAGS prompt the interactive stage ends and the script goes into fully automated operation.

Note: You may need to unblock wget if the Windows Firewall asks, although I didn't.

Note: During the build process a great deal of text is output to the MSYS console, which you may need to refer back to if any errors occur.

Last Steps

Now install the Info pages for Wget:

install-info wget.info dir

You're done.

HOWTO_Install_the_MinGW(GCC)_Compiler_Suite (Read keith's comment on concatenation of info/dir files.)

Invoking install-info (GNU Texinfo 4.12 manual page)

Installing Info Files

Start MSYS using the shortcut on the Windows desktop or All Programs menu. You'll have to exit MSYS at the end of this procedure.

cd /mingw/info
for file in *.info; do install-info $file dir; done
echo export INFOPATH=/mingw/info >> ~/.profile
exit


Note: The info pages will be made available after you exit and restart MSYS.

I want to install MinGW and MSYS on my computer so I can compile some open source programs. I have only a small amount of experience with Unix from school, and my time with Kubuntu to rely on. It should be a fun learning experience, but setting up a build environment with MinGW / MSYS is quite complicated.

I'm not taking anything away from the MinGW guys, because the work they do is very hard, and greatly beneficial to those who use open source software on Windows. Even so, I feel it necessary to blog about this, if only as a record of my attempts for my own future reference. Please don't assume anything I post about MinGW / MSYS is authoritative, or necessarily even correct. If you want to know the truth, try downloading MinGW / MSYS and working with it on your own.

Relevant Links

http://www.mingw.org (Home page of MinGW and MSYS)

http://sourceforge.net/projects/mingw (Project page of MinGW and MSYS on Sourceforge)

http://www.vim.org (Vim home online)

http://www.eng.hawaii.edu/Tutor/vi.html ("Mastering the VI editor": University of Hawai`i, College of Engineering, Computer Facility)

http://gcc.gnu.org (Home page of the GNU Compiler Collection)

http://www.ee.surrey.ac.uk/Teaching/Unix/index.html (UNIX / Linux Tutorial for Beginners)

My Computer

HP Pavilion dv8135nr, Windows XP Media Center Edition (Service Pack 3)

About Package Versions

I'm downloading the versions of each package that are available as I write this. In the future there will be newer versions of these packages, so don't expect your experience to be the same if the version numbers aren't the same. By all means please download the latest versions, and find your own way as you go.

MinGW Installation

Note: It is advised to install MinGW first. The MSYS installer will normalize to your existing MinGW installation.

Download the Automated MinGW Installer, version 5.1.4 as of this post, from the link below:

https://sourceforge.net/project/showfiles.php?group_id=2435&package_id=240780

click to expand image

Create the folder C:\MinGW and save the downloaded file there. Now you sould have the file C:\MinGW\MinGW-5.1.4.exe.

Important Note: Never install MinGW or MSYS on a path containing spaces!

Double click the MinGW-5.1.4.exe file to run the Automated MinGW Installer.

Note: When the installer runs for the first time, it will perform a quick update check, and then create the mingw.ini file to record information about your installation.

Follow along to answer the prompts as shown. Prompts are shown in italics, and actions you should take are in parentheses.

Welcome to MinGW . . . (Click Next)

Install or just download files? (Choose Downlaoad and install, then click Next)

License Agreement (Click I Agree)

Choose Package (Choose Current, then click Next)

Choose Components (Checkmark MinGW base tools and g++ compiler, then click Next.)

Note: Do not checkmark MinGW Make!

Choose Install Location (Note the default location of C:\MinGW and click Next)

Choose Start Menu Folder (Click Install)

Note: If the Automated MinGW Installer fails for any reason, check your Internet connection, and run the Automated MinGW Installer again.

Downloading . . . (Wait and observe the process)

Extracting . . . (Wait and observe the process)

Installation Complete (Note the intallation log, then click Next.)

MinGW has finished . . . (Click Finish.)

Note: The Automated MinGW Installer has downloaded and extracted all required packages to the C:\MinGW folder.

click to expand image

Note: The Automated MinGW Installer has also placed shortcuts in the Windows All Programs menu and Add or Remove Programs applet of the Control Panel.

MSYS Installation

Download the MSYS Base System installer from the link below. Be sure to get the Current Release, version 1.0.10 as of this post.

http://sourceforge.net/project/showfiles.php?group_id=2435&package_id=24963&release_id=89960

Note: It may be necessary to scroll your browser window, or drill down the menu, until you find Current Release: msys-1.0.10.

click to expand image

Create the folder C:\MSYS and save the downloaded file there. Now you should have the file C:\MSYS\MSYS-1.0.10.exe.

Important Note: Never install MinGW or MSYS on a path containing spaces!

Double click the MSYS-1.0.10.exe file to run the installer, and answer the prompts as follows. Prompts are shown in italics, and actions you should take are in parentheses.

This will install "Minimal SYStem". Do you wish to continue? (Click Yes)

Welcome to the "Minimal SYStem" . . . (Click Next)

License Agreement (Click Yes)

Information (Read the information, then click Next)

Select Destination Directory (Note the default location of C:\msys\1.0, then click Next)

Select Components (Accept the default of i386 based CPUs, and click Next)

Select Start Menu Folder (Click Next)

Ready to Install (Be sure the installation settings are correct, then click Install)

The installer now runs a small batch program to complete the installation.

MSYS Post Install Process

The batch program will open in a command line window, and prompt you to answer a few simple questions. You must be especially careful in answering the prompts because the batch program may misunderstand a mistyped response.

click to expand image

Note: Be sure to follow along carefully as the batch program will not give you a chance to correct any mistakes!

Read the texts in the command window fully, and answer the prompts as follows. Prompts are shown in code style, and actions you should take are in (parentheses).

C:\msys\1.0\postinstall>..\bin\sh.exe pi.sh

This is a post install process that will try to normalize between
your MinGW install if any as well as your previous MSYS installs
if any. I don't have any traps as aborts will not hurt anything.
Do you wish to continue with the post install? [yn ]

(Type the lower case letter y, then type the enter key)

click to expand image

Note: By type I mean you should press and quickly release the key.

Do you have MinGW installed? [yn ]

(Type the lower case letter y, then the enter key)

Note: Pay special attention to the path delimiters used in the next prompt because we are expected to use the forward slash, usually found on the same key as question mark.

Please answer the following in the form of c:/foo/bar.
Where is your MinGW installation?

(Type the full path of the MinGW folder in the format shown by the prompt.)

Note: Recall that we chose the location C:\MinGW during the MinGW installation process.

Note: If you typed the path incorrectly, perhaps by using anything other than the forward slash as a path delimiter, then you'll be required to manually edit the /etc/fstab file after completing MSYS installation.

There will be no further interaction with the batch program after you press the enter key. If you typed all responses correctly up to this point, then the command prompt window will look like the image below.

click to expand image

(Type the enter key.)

Creating /etc/fstab with mingw mount bindings.
Normalizing your MSYS environment.

C:\msys\1.0\postinstall>pause
Press any key to continue . . .

(Type the enter key one time to proceed)

click to expand image

Note: Observe that we are advised not to install MinGW Make.

Now we go back to the Setup - "Minimal SYStem" installer window. The process is complete.

Setup has finished installing "Minimal SYStem" . . . (Click Finish)

Note: If you left the two boxes check marked, as you should have, you will see two document windows with important texts which you should now read.

click to expand image

Note: You can read the MSYS documentation again later. They are located at C:\MSYS\1.0\doc, if you've followed along.

click to expand image

Note: MSYS is installed to the path C:\MSYS\1.0, which will become the root of the MSYS virtual file system.

click to expand image

Note: Shortcuts for MSYS have been added to the Windows desktop, All Programs menu, and Add or Remove Programs applet of the Control Panel.

Write a Test Program

We'll create a simple C program and compile it with GCC to test our installation.

Start by double clicking the MSYS icon on your desktop, or clicking the MSYS icon in your Start menu's All Programs sub menu. Alternatively, you may also start MSYS by executing the C:\MSYS\1.0\msys.bat batch program.

MSYS opens an rxvt terminal with a Unix command prompt. If you are not familiar with Unix, then you'll need a good tutorial on the subject. I'm not teaching Unix here, but I encourage you to learn Unix if you have the patience.

click to expand image

I'll be using the Vim text editor which is included with MSYS. Be advised that the MSYS package has omitted the Vim documentation. If you don't know Vim, then I strongly advise you to read a good tutorial first. Teaching you to use Vim is far, far beyond the scope of this post.

IMPORTANT NOTE: Many people have floundered hopelessly on their first encounter with Vim, myself included. Some people love Vim for it's power and efficiency, and justifiably so, but I am not one of them. I'm hoping to successfully compile Emacs later, but feel free to use Vim all you like if it suits you better.

In the MSYS terminal, create a directory named hello in your home directory and change to the new directory.
mkdir ~/hello
cd ~/hello
Now enter the command vim hello.c to begin editing the C source code file.
vim hello.c

Type in the code, shown below in preformatted style. Write the file to disk, and quit from Vim.
#include <stdio.h>

int main(void) {
printf("Hello, World!");
return 0;
}

Note: If you have any difficulty editing the source code in Vim, then please go to the tutorial and read it. Don't say you weren't warned!

Now compile the code with GCC:
gcc -ohello.exe hello.c
Test the compiled code by running the generated executable:
./hello.exe

If the hello message is printed and no errors are reported, then you're good to go with MinGW and MSYS!

(A simple windows program in c)

Этот флаг добавляется в Project -> Properties, C/C++ Build ->Settings->Tool Settings->MinGW C++ Linker в поле Command: после g++ (получается "g++ -mwindows") .

Après un peu d'inactivité sur ce blog, voici un nouveau tutoriel.
Il décrit les étapes pour installer les célèbres (ou pas) librairies Boost sur Windows avec MinGW.

Si vous ne connaissez pas Boost, c'est un ensemble de librairies pour le C++ qui permettent de faire tout un tas de choses et qui sont très bien réputées. Pour plus d'info, je vous invite à aller voir leur site officiel : http://www.boost.org/

Ce tuto est accessible via le lien suivant : http://devtricks.wordpress.com/installer-boost-sous-windows-avec-mingw/

Amusez-vous bien !

Bob

Czas najwyższy na podanie kodu aplikacji:

#include <d3d9.h>

LPDIRECT3D9       pD3D9       = NULL;
LPDIRECT3DDEVICE9 pD3D9Device = NULL;

HRESULT InitialiseD3D(HWND hWnd)
{
  // First of all, create the main D3D object. If it is created successfully
  // we should get a pointer to an IDirect3D8 interface.
 pD3D9 = Direct3DCreate9( D3D_SDK_VERSION );
if ( !pD3D9 )
{
MessageBox( 0, "Direct3DCreate9() - Failed", 0, 0 );
return 0;

}

  //Get the current display mode
  D3DDISPLAYMODE d3ddm;
  if(FAILED(pD3D9->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm)))
  {
    return E_FAIL;
  }

D3DPRESENT_PARAMETERS D3Dpp;
ZeroMemory( &D3Dpp, sizeof(D3Dpp) );
D3Dpp.Windowed = TRUE;
D3Dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;

if ( FAILED( pD3D9->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
hWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &D3Dpp, &pD3D9Device ) ) )
{
MessageBox( 0, "CreateDevice() - Failed", 0, 0 );
  if(pD3D9 != NULL)
  {
    pD3D9->Release();
    pD3D9 = NULL;
  }
return 0;

}

  return S_OK;
}

void Render()
{
  if(pD3D9Device == NULL)
  {
    return;
  }

  // Clear the backbuffer to blue
  pD3D9Device->Clear(0, NULL, D3DCLEAR_TARGET,
                      D3DCOLOR_XRGB(0, 0, 255), 1.0f, 0);

  // Begin the scene
  pD3D9Device->BeginScene();

  // Fill in here the rendering of other objects

  // End the scene
  pD3D9Device->EndScene();

  // Fill back and front buffers so that back buffer will be visible on screen
  pD3D9Device->Present(NULL, NULL, NULL, NULL);
}

void CleanUp()
{
  if(pD3D9Device != NULL)
  {
    pD3D9Device->Release();
    pD3D9Device = NULL;
  }

  if(pD3D9 != NULL)
  {
    pD3D9->Release();
    pD3D9 = NULL;
  }
}

void MainLoop()
{
  // Enter the main loop
  MSG  msg;
  BOOL bMessage;

  PeekMessage(&msg, NULL, 0U, 0U, PM_NOREMOVE);

  while(msg.message != WM_QUIT)
  {
    bMessage = PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE);

    if(bMessage)
    {
      // Process message
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }
    else
    {
      Render(); // No message to process -> render the scene
    }
  }// while
}

// The windows message handler
LRESULT WINAPI WinProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
  switch(msg)
  {
    case WM_DESTROY:
      PostQuitMessage(0);
      return 0;
      break;

    case WM_KEYUP:
      switch (wParam)
      {
        case VK_ESCAPE:
          // Escape key pressed -> exit
          DestroyWindow(hWnd);
          return 0;
          break;
      }
      break;
  }// switch

  return DefWindowProc(hWnd, msg, wParam, lParam);
}

// Application main entry point
INT WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR, INT)
{
  //Register the window class
  WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, WinProc, 0L, 0L,
                    GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
                    "DirectX Project", NULL };
  RegisterClassEx(&wc);

  // Create the application's main window
  HWND hWnd = CreateWindow("DirectX Project", "DirectX9 APP : Eclipse + CDT + MinGW",
                           WS_OVERLAPPEDWINDOW, 50, 50, 500, 500,
                           GetDesktopWindow(), NULL, wc.hInstance, NULL);

  // Initialize Direct3D
  if(SUCCEEDED(InitialiseD3D(hWnd)))
  {
    // Show window
    ShowWindow(hWnd, SW_SHOWDEFAULT);
    UpdateWindow(hWnd);

    //Start game running: Enter the game loop
    MainLoop();
  }

  CleanUp();

  UnregisterClass("DirectX Project", wc.hInstance);

  return 0;
}

Efektem będzie okienko wypełnione kolorem niebieskim. Aż się prosi aby uzupełnić metodę Render() o dowolne efekty..

Ok, na start należy mieć:

1. Wspomnianą dystrybucję MinGW,
2. Eclipse wraz z CDT skonfigurowane z toolchain'em  MinGW.

Najprościej będzie więc wykonać kroki z tego wpisu..

Stwórzmy teraz nowy projekt cpp i udajmy się do jego właściwości. Istotne dla nas będzie ustawienie katalogu include (Tool settings/GCC C++ Compiler/Directories) na podkatalog include w miejscu, gdzie rozpakujemy wspomniane wyżej distro MinGW (np. D:\PRO\MinGW\include) oraz katalogu i plików bibliotek statycznych lib (analogicznie pokatalog lib dystrybucji, czyli np. D:\PRO\MinGW\lib). W tym miejscu (Tool settings/MinGW C++ Linker/Libraries) oprócz ścieżki do podkatalogu lib, musimy wprowadzić także nazwy bibliotek statycznych, które będą użyte przez aplikację SDL - dwie najważniejsze to SDL_main oraz sdl, przy zachowaniu ich kolejności!

Teraz dodajmy trochę kodu:

#include <SDL/SDL.h>
#undef main

int main(){
	SDL_Surface * cSurface;
	if(SDL_Init(SDL_INIT_VIDEO) < 0) {
		printf("SDL_Init error..\n");
		return 1;
	}

	atexit(SDL_Quit);

	cSurface = SDL_SetVideoMode(1024, 768, 32, SDL_ANYFORMAT);

	if(!cSurface) {
		printf("SDL_SetVideoMode error..\n");
		return 1;
	}
	SDL_Delay(5000);//czekaj 5 sekund i wyjdz..
	return 0;
}

Uwagę należy zwrócić jedynie na jedną rzecz:
#undef main
która dodana jest pomiędzy import nagłówka SDL.h a metodą main(). Krok ten jest niezbędny jeśli nie chcemy uzyskać komunikatu o niezdefiniowanej metodzie WinMain16 w naszym kodzie.

Możemy lecz nie musimy, ponieważ w naszym prostym przykładzie możemy zrobić również tak:

#include <windows.h>
#include <SDL/SDL.h>
#include <memory.h>
//#undef main

//int main(){
int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpszArgument,
                    int cmd){

	SDL_Surface * cSurface;
	if(SDL_Init(SDL_INIT_VIDEO) < 0) {
		printf("SDL_Init error..\n");
		return 1;
	}

	atexit(SDL_Quit);

	cSurface = SDL_SetVideoMode(1024, 768, 32, SDL_ANYFORMAT);

	if(!cSurface) {
		printf("SDL_SetVideoMode error..\n");
		return 1;
	}

	MSG messages;
	memset(&messages ,0,sizeof(MSG));

    while (GetMessage (&messages, NULL, 0, 0))
    {
        TranslateMessage(&messages);
        DispatchMessage(&messages);
    }

    return messages.wParam;
}

lub nawet tak:

#include <windows.h>
#include <SDL/SDL.h>
//#include <memory.h>
//#undef main

//int main(){
int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpszArgument,
                    int cmd){

	SDL_Surface * cSurface;
	if(SDL_Init(SDL_INIT_VIDEO) < 0) {
		printf("SDL_Init error..\n");
		return 1;
	}

	atexit(SDL_Quit);

	cSurface = SDL_SetVideoMode(1024, 768, 32, SDL_ANYFORMAT);

	if(!cSurface) {
		printf("SDL_SetVideoMode error..\n");
		return 1;
	}

   SDL_Event event;

   while(true) {
      if(SDL_PollEvent(&event)) {
         if(event.type==SDL_QUIT || event.type==SDL_KEYDOWN)
            return 0;
      }

      SDL_Delay(100);	//oszczedz troche CPU
   }
}

W tym drugim przypadku do obsługi zdarzeń wykorzystujemy SDL, a konkretnie obiekt klasy SDL_Event.
W efekcie powinniśmy uzyskać nowe okienko o zadanych rozmiarach wypełnione czarnym kolorem..

Tak jak w temacie, pokażę jak napisać prosty pomost między Javą a cpp przy wykorzystaniu IDE Eclipse z biblioteką CDT5.0 oraz wykorzystując toolchain'a MinGW. O sposobie konfiguracji takiego środowiska wspomniałem już wcześniej, a więc zaczynamy.

Naszym zadaniem będzie napisanie kodu w Javie, który będzie wykorzystywał dll'ke, którą przygotujemy wykorzystując język cpp i toolchain'a MinGW - będziemy przesyłać i odbierać dane z dll'a.

Lista wymagań jest następująca:

1. Eclipse + CDT + MinGW,
2. Java JDK (nie musi być koniecznie nowe), JRE nie wystarczy.

Ze wspomnianego JDK wykorzystamy następujące rzeczy:

• bin\javah.exe - pozwoli automatycznie wygenerować nagłówek języka cpp(.h) dla danej klasy Javy,
• include\jni.h - dostarcza "funkcje" do konwersji typów Java <-> cpp oraz wiele innych,
• include\$platform$ - $platform$ w moim przypadku to win32.

Kolejne kroki które będziemy wykonywać przedstawiają się następująco:

1. napisanie kodu klas(y) w Javie z użyciem słowa kluczowego native,
2. kompilacja klas(y) - otrzymujemy pliki .class,
3. wygenerowanie nagłówka dla języka cpp (.h) za pomocą narzędzia javah.exe,
4. implementacja wygenerowanego pliku nagłówkowego w projekcie w języku cpp,
5. skompilowanie kodu do postaci pliku biblioteki dynamicznej (dll/so),
6. uruchomienie aplikacji Javy.

Zaczynamy - punkt 1 i napisanie kodu klasy w Javie.
Jak już wspomniałem, użyjemy słowa kluczowego native do oznaczenia metod, które chcielibyśmy zaimplementować w języku cpp.

Niech za przykład takiego kodu w Javie posłuży nam następująca klasa:

public class SomeData {

native String GetVersion();
native void SetVersion(String sNewVersion);
native void DoSomething();

static{

System.loadLibrary("libjni_test");

}

public String GetSomeDataFromJava(){

return "dane z javy";

}

public static void main(String[] args) {

SomeData cData = new SomeData();
System.out.println("Version: "+cData.GetVersion());

}

}

Parę słów komentarza: na początku mamy metody natywne, które będziemy implementować w cpp - podajemy więc ich definicję i na tym kończymy. Następnie widoczny jest blok static{} w którym podajemy informację do JVM, z jakiej dokładnie biblioteki dll/so będziemy korzystać.
Ważne są dwie rzeczy:

1. nie podajemy tam rozszerzenia pliku (bez dll/so) ponieważ w zależności od systemu JVM zrobi to za nas,
2. nie musimy ładowania biblioteki zewnętrznej umieszczać w bloku static{} - równie dobrze można to zrobić zaraz na początku metody main(String[] args).

Ostatecznie w metodzie main(String[] args) wywołujemy naszą natywną metodę w celu sprawdzenia efektu.

Czas na punkt 2 z listy czyli kompilację - tak naprawdę dzieje się ona z automatu jeśli mamy w Eclipse ustawioną opcję automatycznego kompilowania przy zapisywaniu pliku. Jeśli więc utworzyliśmy prosty projekt Javy, to plik źródłowy (.java) znajduje się w katalogu /src/ a skompilowana klasa w katalogu /bin/.

W punkcie następnym użyjemy generatora nagłowka (.h) - narzędzia javah.exe. Jeśli jest on w naszej zmiennej środowiskowej PATH to wydanie polecania:

javah -jni $nasza_klasa$

w katalogu \src\ powinno zakończyć się sukcesem i wygenerowanym nagłówkiem, lecz może być jeszcze konieczne przekopiowanie pliku skompilowanego (.class) z katalogu \bin\ do \src\.
Natomiast jeśli wydanie powyższego polecania zgłasza błąd nieznanego polecenia, należy edytować zmienną PATH (np. z poziomu właściwości mój komputer, na zakładce Zaawansowane, przycisk zmienne środowiskowe, dodając dodatkowy wpis do zmiennej PATH, który będzie zawierał ścieżkę do pliku wykonywalnego java, javac, javah, itp. - np. D:\Program Files\Java\jdk1.6.0_06\bin\ - należy uważać żeby nie nadpisać jej całkowicie a tylko dopisać dodając średnik jeśli to konieczne do oddzielenia ścieżek).

W tym momencie mamy już wygenerowany plik nagłówkowy więc możemy w Eclipse opcjonalnie przełączyć perspektywę na C/C++ i utworzyć projekt C++ (New C++ Project) - również pisałem już o tym wcześniej, najważniejsze żeby dostępny był toolchain MinGW oraz rodzaj projektu wybrać Empty Project (.exe) ewentualnie docelowy Shared Library.

Po utworzeniu pustego projektu, należy dokonać na starcie paru ustawień - przechodzimy do jego właściwości:

• na zakładce C/C++ Bulid przechodzimy do Settings/Tool Settings,
• przechodzimy do GCC C++ Compiler i dalej do Directories,
• klikając przycisk dodajemy katalogi \include i \include\win32 - (w moim przypadku są to D:\Program Files\Java\jdk1.6.0_06\include oraz D:\Program Files\Java\jdk1.6.0_06\include\win32)
• zatwierdzamy wprowadzone zmiany,
• następnie odnajdujemy zakładkę MinGW C++ Linker, która jest na poziomie C/C++ Bulid,
• przechodzimy do zakładki Miscellaneous i w Linker Flags wpisujemy:
  -Wl,--add-stdcall-alias
  Bardzo istotna opcja, ponieważ dzięki niej nie dojdzie do "udziwnienie" metod w wynikowym pliku biblioteki dynamicznej. Gdybyśmy o tej opcji zapomnieli, to pomimo że nasza biblioteka byłaby widoczna, to JVM nie odnalazłaby w niej określonych nazw, właśnie przez te "udziwnienia", tworzone przez linker z toolchain'a MinGW.
• sprawdzamy jeszcze, czy na zakładce poniżej Miscellaneous-Shared Library Settings zaznaczona jest pierwsza opcja od góry Shared (jeśli tworzony był Empty Project trzeba ją zaznaczyć),
• opcjonalnie, jeśli korzystaliśmy z Empty Project musimy zmienić ustawienia generowania pliku wykonywalnego na generowania dll/so - uczynimy to zmieniając zakładkę Tool Settings na Build Artifact i ustawiając pole Artifact Type na Shared Library. Resztę opcji możemy tak pozostawić chyba że pragniemy dla przykładu nadać jakąś specyficzną nazwę dla biblioteki dynamicznej.
• zatwierdzamy wprowadzone zmiany i powracamy do ekranu głównego.

Teraz możemy zaimportować wygenerowany przez javah plik nagłówkowy (import/File System/podajemy scieżkę do wygenerowanego pliku nagłówkowego). Gdy spróbujemy ten plik podejrzeć,  include jni.h nie powinien zgłaszać błędów (w p.p sprawdź include directory), lecz syntax error'y pojawią się przy wszystkich liniach rozpoczynających się np. tak JNIEXPORT jstring JNICALL, czyli wszystkich eksportowanych metodach z/do Javy - nie musimy się tym w ogóle przejmować.

Teraz należy utworzyć plik implementacji zaimportowanego pliku nagłówkowego czyli wkraczamy w punkt 4 - dodajemy w nim include'y dla pliku nagłówkowego i jni.h oraz kopiujemy definicje metod z pliku nagłówkowego i uzupełniamy je o nazwy zmiennych w metodach(są tylko typy) oraz ciało metod.

Dla przykładu podam ciało metody zwracającej z dll'ki napis typu String:



JNIEXPORT jstring JNICALL Java_SomeData_GetVersion(JNIEnv * env, jobject o){
const char *str = "1.1 MinGW compiled";
return env->NewStringUTF(str);
}

Jak widać w powyższym, nie ma bezpośredniej konwersji typów między Javą i cpp, dlatego musimy się posługiwać metodami konwersji, które dostępne są przez odwołanie do JNIEnv, która jest tablicą metod pomocniczych.

Kompilujemy kod (Bulid Project) i jeśli wszystko dobrze wcześniej ustawiliśmy, otrzymamy w wyniku plik biblioteki dynamicznej o nazwie projektu z przedrostkiem lib lub podaną przy ustawieniach Arifact name, co kończy punkt 5.

Przed wykonaniem ostatniego punktu, czyli odpalenia aplikacji Javy, musimy w odpowiednim miejscu umieścić nasz plik wynikowy biblioteki dynamicznej. Możemy go umieścić w scieżkę wskazywanej przez java.library.path lub umieścić w wybranym miejscu i w ustawieniach projektu Javy - Java Build Path, rozwinąć zakładkę Source i edytować ostatnią pozycję o nazwie Native Library Location, wskazując folder gdzie znajduje się skompilowany dll/so.

Czas na wykonanie ostatniego kroku i uruchomienie (najszybciej w Eclipse z opcji Run As/Java application) kodu. W wyniku nie powinniśmy otrzymać błędu java.lang.UnsatisfiedLinkError, a jeśli się to zdarzy, to należy uważnie przejrzeć opisane wcześniej czynności.

W ten sposób kończę ten najdłuższy do tej pory wpis na blogu.
Z takimi podstawami można już szybko ruszyć w dalszą drogę i poznawać możliwości JNI.

Note: The steps listed here will only work on Python 2.5 and above as that is when they added support for allowing MinGW to compile code

I mentioned in a previous post that I was looking for a way to get public/private key encryption in Python and I was having a bugger of a time until I found ezPyCrypto. I don't know if I have mentioned this before, but I have been an Linux user for about 4 years now. Specifically Gentoo Linux ,and I would never run another OS now that I have been a Linux user. At any rate that's not the point of this post. Since the script I was developing had to run on Windows I needed to install PyCrypto (it's a dependency for ezPyCrypto). Well this would be trivial except that PyCrypto has C code that needs to be compiled. There are binary builds on the PyCrypto site for both Python 2.3 and 2.4, but not 2.5 which I am running. I wasn't going to let this stop me however. The rest of this post will explain what you need to do in order to get PyCrypto working under Windows with Python 2.5. After completing this you will also be able to build your own installer that you could package with your scripts to let people who don't want to install a C compiler run your code :)

The first thing you are going to want to do is install MinGW . MinGW will give you a nice C and C++ compiler for Windows. Just follow the instructions on their site and you will be good to go. After you have MinGW installed you will probably want to add entries to the Windows PATH variable so that when you are in a terminal you will be able to directly access MinGW. [As a note I still run Windows XP so these instructions will be done with that in mind] Doing this is quite simple:

1. Right Click My Computer --> Properties --> Advanced --> Environment Variables.
2. You will see User and System variables. If you want all users to use MinGW edit the Path entry in there. Otherwise add a Path variable under User variables.
3. Go to the Path variable from step 2. Add an entry to the Path that points to MinGW's bin directory. For me this was "C:\MinGW\bin" but it all depends on where you installed MinGW. Note: Entires in Windows Environment variables are separated by ';'
4. Click ok a bunch of times

While you are changing environment variables you will want to add the main directory for Python to your path. For me this was: "C:\Python25". This made my final User Path entry: "C:\MinGW\bin;C:\Python25"

Now that you are done changing environment variables you will want to reboot your computer so that Windows gets your changes. Really... you will regret it if you don't reboot!

Now download PyCrypto and unpackage it. This turned out to be problem enough because not many people keep programs around that open .tar.gz files. Since am a Linux user I just unpacked them in Linux and transferred them to Windows (I run Windows XP under VirtualBox ). However, if that is not an option you can download and install IZarc Archiver. IZarc has been my favorite [Windows] extraction tool for a long time and it supports just about every archive format imaginable.I would recommend extracting the contents of PyCrypto to your desktop. Now is when the first starts!

First, open up a terminal. We will only be using a few commands and you don't have to be a terminal wiz kid to do this. I normally open a terminal by going: Start --> Run --> "cmd" --> Press Enter

Now that you have a terminal up you want get to the PyCrypto directory. To move between directories in the terminal we use the "cd" command.

cd PATH-GOES-HERE

So, for example here is the command I used to get to where I had PyCrypto:

cd C:\Documents and Settings\Jinto\Desktop\pycrypto-2.0.1

Of course that command will only work for you if your user name is Jinto and you extracted it to the desktop exactly like I did ;) So modify it to fit your needs. Once you are in the pycrypto directory do a quick:

dir /w

To make sure you see files. Specially make sure setup.py is there. We need to run that setup script and tell it to build the libraries. To do this issue the following command:

python setup.py build -c mingw32

If all goes well it should build without any troubles and all that is left is to install it by issuing the following command:

python setup.py install

You should be all set to use PyCrypto now, or to install ezPyCrypto which uses PyCrypto. As a bonus feature if you are looking to make an executable installer for PyCrypto you can run the following command:

python setup.py bdist_wininst

This will leave you with a .exe file located in the "dist" folder.

I hope this helps everyone get PyCrypto running under Windows. For those of you Linux users who think I am leaving you out check your distro specific respository system they probably already have a package for PyCrypto!

By the way, this methods works with other editors as well. If you use PSPad you can easily adapt this explanations to it.

Create a batch file (cedt_mk.bat) with this one line:

C:/msys/1.0/bin/sh --login -c "cd '%1' ; cd `pwd`; make %2"

and store it in the msys /usr/bin directory (C:/msys/1.0/bin in my installation).

This batch file starts the msys shell and sets up all the environment variables as if you had login, so if your makefile depends on variables you set on your .profile, it will work.
It then goes to the directory specified by the first argument, where it expects to find a makefile, and makes the target specified by the second parameter.
Note that the first cd will receive a path in MSDOS format (e.g. 'D:\projects') that the shell will convert to '/d/projects'. However there is a bug in msys when the UNIX path ends with '/'. To fix it a cd to the current directory (cd `pwd`) is needed

Now add a couple of "tools" to CEDT through the "Tools/Conf. User Tools...":

I defined two. The first one as "Make ..." that will prompt for the name of the target (second argument set to $(UserInput).

and the second one as "Make Selected" that will use the selected word as the name of the target (second argument set to $(CurWord).

I mapped them to F9 and Ctrl+F9 respectively.

Having set the first "Argument" and the "Initial Dir" to $(FileDir), the makefile used will be the one stored in the same directory of the current file. This may work or not for you depending on the structure of the directories in your project.
I usually have a makefile for each directory in the project (src, test, docs, ...) but sometimes I use a single makefile in the root directory of the project. In that case setting the first argument of cedt_mk.bat to "$(FileDir)\.."  would have worked.  Of course one could play with the cedt_mk.bat script to add more intelligence to it. I will be happy to hear any improvement.

Having set to option "Capture Output", I will get all the error messages directly in the output pane of CEDT. If I only could jump directly the file/line when an error occurs ...

Die kommerzielle Version bringt zwar die automatische Integration in Visual Studio mit sich, dafür kostet diese Version einiges und ist nicht jedermanns Sache. Mit diesem Artikel will ich die Integration Schritt für Schritt so einfach wie möglich erklären.

Vorbereitung

Bevor wir mit der Integration überhaupt beginnen, wollen wir uns erstmal Vorbereiten. Falls sie schon das SP1 für Visual Studio installiert haben oder es demnächst installieren wollen benötigen wir das Hotfix KB930198. Der direkte Bezug von Microsoft ist nur bei der englischen Version von VS möglich. Nutzer der deutschen Version sind auf andere Quellen angewiesen. Unten in meinen Referenzen werdet ihr einen Link finden, wo ihr das Hotfix runterladen könnt. Als nächstes besorgt ihr euch QT. Achtet darauf, dass es die Open Source Version ohne Mingw ist e.g. qt-win-opensource-src-4.4.0.zip. Entpackt nun das runtergeladene Qt-Paket in ein Verzeichnis eurer Wahl e.g. D:\QT4.

Umgebungsvariablen

Jetzt wollen wir unserem Betriebssystem QT bekannt machen. Dafür müssen wir bestimmte Umgebungsvariablen setzen.

Dafür gehen wir zunächst in System rein. Erreichbar mit Superkey (Windowstaste) + Pause oder über die Systemsteuerung. Danach wechseln wir über den Erweitert-Reiter zu den Umgebungsvariablen. Unter Systemvariablen erstellen wir nun unsere Variablen mit den dazugehörigen Werten.

Hier verwende ich als Beispiel den Pfad D:\QT4, den müsst ihr bei euch natürlich anpassen.

QTDIR       D:\QT4
INCLUDE   %QTDIR%\include
LIB            %QTDIR%\lib
PATH        %QTDIR%\bin

QT Installation

Nachdem ihr QT entpackt und die Umgebungsvariablen gesetzt habt müsst ihr die "Visual Studio Command Prompt" öffnen. Das ist nichts anderes als die normale Windows Konsole nur angepasst an die Anforderungen von VS.

Die Konsole erreicht ihr über:

Startmenü -> Programme -> Microsoft Visual Studio 2005 ->
Visual Studio Tools

Nun wechselt ihr in euer QT Verzeichnis (cd %QTDIR%). Als nächstes müssen wir die Quelldateien konfigurieren bevor wir sie kompilieren können.

Dafür geben wir folgenden Befehl ein:

configure -platform win32-msvc2005 -no-qt3support
-qt-sql-odbc -qt-sql-sqlite -qt-zlib -qt-libpng

Hier sagen wir configure, dass er die Dateien für eine win32 Platform mit VS2005 erzeugen soll. Ich verzichte absichtlich auf QT3. Falls ihr es brauchen solltet lasst einfach "-no-qt3support" weg. Die folgenden Parameter sind optional, daher könnt ihr sie auch weglassen.

Diese Konfiguration dauert nun ein Weilchen, holt euch währenddessen einen Kaffee......

So..ihr seid nun mit der Konfiguration fertig. Freut euch nicht zu früh, denn jetzt kommt nmake. Damit wird der Kompilierungsvorgang angestoßen. Dieser Vorgang wird viel länger dauern, daher empfehle ich euch währenddessen was anderes zu machen...
So..damit seid ihr also auch fertig. Schön!

Macht euch nun am besten zwei Verknüpfungen auf euer Desktop. Diese zwei werdet ihr öfters brauchen. Zum einen gibt es da den QT Designer und die QT Hilfe. Beide werden euch ein QT-Leben lang begleiten.

%QTDIR%\bin\designer.exe

%QTDIR%\doc\html\index.html

Beispielprojekt

Erzeugt euch zunächst ein neues leeres Win32-Projekt. Im Assistenten wählt ihr "leeres Projekt" und "Windows Anwendung".  Als erstes erzeugen wir uns die main.cpp, da sie unser Einstiegspunkt sein wird. Den Inhalt können wir zunächst leer lassen.

In diesem Beispiel soll unsere Anwendung  ein einfaches Fenster erzeugen, mehr nicht! Dies dürfte als Demonstration ausreichend sein.

Dafür legen wir nun eine C++ Klasse an. Wir nennen sie mywindow. Die Basisklasse ist die QMainWindow. Da VS QMainWindow noch nicht kennt, wird er meckern. Ignoriert einfach diese Meldung und klickt auf Ja. Nun habt ihr drei Dateien in eurem Projekt die main.cpp, mywindow.cpp und die mywindow.h.

Als nächstes wechselt ihr in die Projekteigenschaften. Hier wählt ihr als Konfiguration "Alle Konfigurationen" (linke obere Kombobox). Im linken Bereich des Fensters wechselt ihr zu C/C++ und fügt auf der rechten Seite bei "Zusätzliche Includeverzeichnisse"
die Werte $(QTDIR)\include;$(QTDIR)\include\Qt;

Als nächstes ist der Linker dran. Wie eben wechseln wir nun links zu Linker und fügen auf der rechten Seite bei "Zusätzliche Bibliotheksverzeichnisse" den Wert $(QTDIR)\lib ein. Wir bleiben kurz noch bei Linker. Bevor wir fortfahren wechseln sie wieder die Auswahl in der Kombobox. Diesmal auf Debug.

Unter Linker werden sie "Eingabe" sehen. Wechseln sie dorthin und geben sie auf der rechten Seite bei "Zusätzliche Abhängigkeiten"
die Werte qtmaind.lib QtGuid4.lib QtCored4.lib ein.

Genau die Selbe Option setzen wir auch für Release. Wechseln sie dafür die Auswahl in der Kombobox und wie eben unter Linker in Eingabe reingehen. Auf der rechten Seite bei "Zusätzliche Abhängigkeiten" die Werte qtmain.lib QtGui4.lib QtCore4.lib einfügen.

Bevor wir fortfahren, wollen wir zuerst mit dem QT Designer eine *.ui Datei erstellen. Diese enthält das zu erzeugende Fenster in XML Form. Erzeugen sie mit dem Designer ein einfaches Mainwindow aus der Vorlage und speichern es in das Projektverzeichnis.

Danach gehen wir in die Projektmappe und fügen die eben erzeugte *.ui Datei in unsere Ressourcen. Das bewältigen wir mit einem einfachen Rechtsklick auf Ressourcen und Hinzufügen -> vorhandenes Element.

Da VS *.ui Dateien noch nicht kennt, müssen wir ihm sagen was er damit machen soll. Deshalb erzeugen wir eine Buildregel.

Beispiel:

Anzeigename: ui_regel
Dateiname:     ui_regel
Verzeichnis:   ..\..\Eigene Dateien\Visual Studio 2005\Regeln

Im gleichen Fenster klicken sie nun auf Buildregel hinzufügen. Im erscheinenden Fenster geben sie folgendes ein:

Befehlszeile:
$(QTDIR)/bin/uic.exe "$(InputPath)" -o ui_$(InputName).h
Dateierw.:  
*.ui
Name:
UI
Anzeigename:      
Kompiliere UI Datei (*.ui)
Ausführungsbe.:  
Erzeuge UI Datei ui\_\$(InputName).h
Ausgaben:
ui_$(InputName).h

Solche Regeln sollten sie in ein Regelverzeichnis abspeichern und es VS verfügbar machen, damit es dauerhaft an der definierten Stelle nach Regeln suchen kann.

Extras -> Optionen -> Projekte und Projektmappen -> [VC++-Projekteinstellungen]

Auf der rechten Seite geben sie bei "Regeldatei-Suchpfade" das Verzeichnis an, wo VS nach Regeln suchen soll.

Beispiel Source

//main.cpp

#include <QApplication.h>
#include "mywindow.h"

int main(int argc,char **argv)
{
QApplication app(argc,argv);
mywindow win;
win.show();

return app.exec();
}

//mywindow.h
#pragma once
#include "ui_mywindow.h"

class mywindow :
public QMainWindow,Ui::MainWindow
{
Q_OBJECT
public:
mywindow(void);
~mywindow(void);
};

//myindow.cpp
#include "mywindow.h"

mywindow::mywindow(void)
{
setupUi(this);
}

mywindow::~mywindow(void)
{
}

MOC

Bevor das Projekt gelinkt werden kann, sollten sie voher den Meta Object Compiler über unsere Header-Dateien laufen lassen. Zur Zeit müssen wir dies über einen unangenehmen Weg machen. Wir müssen in die Eigenschaften der jeweiligen Datei rein um einen Buildschritt zu definieren.

Befehlszeile:
$(QTDIR)\bin\moc.exe "$(InputPath)" -o
"$(InputDir)moc_$(InputName).cpp"

Beschreibung:
moc läuft auf $(InputName).h

Ausgaben:
$(InputDir)moc_$(InputName).cpp

Nach Fertigstellung kompilieren sie die jeweilige Datei mit einem Rechtsklick über die Projektmappe. Nach der Kompilierung sollte in unserem Projektverzeichnis nun eine neue Datei erscheinen. Die neue e.g. moc_mywindow.cpp fügen wir unserem Projekt hinzu.

Erst jetzt kann das Projekt erfolgreich gelinkt werden.

Schlusswort

Anhand dieses Artikels müssten sie nun in der Lage sein, die Integration erfolgreich durchzuführen. Demnächst werde ich paar nützliche Addins vorstellen und den Schritt mit dem moc etwas erleichtern (mit PREmoc automatisieren). Ausserdem kommt noch ein Artikel über die Bibliothek qwt, welche man zum plotten von Graphen nutzen kann.

Referenzen

QT 4.x Integration in Visual Studio 2005

QTFORUM

http://www.mingw.org

MinGW: A collection of freely available and freely distributable Windows specific header files and import libraries combined with GNU toolsets that allow one to produce native Windows programs that do not rely on any 3rd-party C runtime DLLs.

MSYS: A contraction of "Minimal SYStem", MSYS is a POSIX-like command line interpreter system, (CLI), offered as an alternative to the Windows Command Prompt, (a.k.a. cmd.exe). Conceived to facilitate the execution of the POSIX style build scripts commonly provided by Open Source projects, and to interpret the Makefiles which they generate, its CLI interprets the Bourne Shell command language, in order to execute the commands commonly invoked by such scripts.

http://www.boost.org/development/tests/trunk/developer/summary.html

This appears to be a list of the statuses of various libraries within the Boost library.  I don't recall why I was checking this out.

http://www.research.att.com/~bs/compilers.html

This page written by Bjarne Stroustrup contains a short list of compilers for C++ as well as references to other sites that contain information on various C++ compilers.

http://videolectures.net

This site contains a large number of interesting videos of university lectures; many of these videos are about topics in computer science.

http://pastebin.com

This site was referenced in an IRC channel that I visited.  It allows you to post a block of code at a public url so it's easy to reference certain lines when you're talking to someone about it online.

http://news.ycombinator.com/item?id=149317

This seems to be a thread discussing some hardware hacking resources.  Here are some of the links they mention, if you don't feel like combing through the article:

• [1]: http://www.sparkfun.com
• [3]: http://www.opencircuits.com
• [4]: http://www.hackaday.com/
• [5]: http://www.makezine.com
• [6]: http://digikey.com - Huge selection. Great if you know what you want.
• [7]: http://octopart.com/ - Electronic Component search engine

http://www.ailab.si/orange/doc/ofb/c_basics.htm

A beginner tutorial on how to use the Orange library; a cool library if you're interesting in data mining.

http://aigamedev.com/archives

Many awesome articles of topics in artificial intelligence for games, defnitely worth a look.

||=== cimg, Debug ===|
C:\Documents and Settings\King\Desktop\cimg\CImg.h||In member function `cimg_library::CImg<T>& cimg_library::CImg<T>::RGBtoHSV()':|
C:\Documents and Settings\King\Desktop\cimg\CImg.h|15581|internal compiler error: in int_const_binop, at fold-const.c:1328|
||=== Build finished: 1 errors, 0 warnings ===|

Check your version of mingw by typing "C:\MingW\bin\g++.exe -v"... I had version "gcc version 3.4.2 (mingw-special)".

After installing MinGW-5.1.4.exe (gcc version 3.4.5 (mingw-vista special r3)), the problem was fixed. I hope that helps. Searching for CImg.h internal compiler error: in int_const_binop, at fold-const.c, didn't turn up any results so I decided to blog about it.

Warum MinGW und UltraEdit?

UltraEdit ist ein Texteditor für Programmierer aus dem Hause IDM (offizielle Website). Der Vorteil bei UltraEdit ist, das er zwar ein mächtiger Texteditor für nahezu alle Bedürfnisse ist, aber dem Entwickler nicht am Code pfuscht. Das heißt Sie geben die Kontrolle über Ihre Projekte nicht aus der Hand und trotzdem wird in an vielen Stellen Arbeit abgenommen. So lässt sich zum Beispiel die Codevervollständigung aktivieren oder externe Programme (wie Compiler) einbinden. Natürlich gehören auch Lesezeichen, (auch eigene) Code-Vorlagen, Umgang mit Projekten und Einzeldateien, WebSearchToolbar, Verschlüsselung, FTP-Browser, eine anpass- und abspeicherbare Arbeitsoberfläche, Codebereinigung, ... zum Lieferumfang.

MinGW ist ein Compilerpaket, dass veile Sprachen wie C/C++, JAVA, ... abdeckt. Im Grunde sind dort alle Werkzeuge der GNU-Compiler-Collection enthalten. Diese sind für jedes Linux-System verfügbar, weshalb das MinGW-Paket ausschließlich für Windows erhältlich ist. Neben dem Compiler Von Microsoft ist der g++ einer der am häufigsten genutzten Compiler für C/C++.

MinGW installieren

Da die Installation von UltraEdit durch den Installationsassisten in Deutsch eigentlich sehr einfach ist und ohne Probleme ablaufen sollte, gehen wir im Folgenden davon aus, das dies bereits erledigt ist. Bleibt also noch MinGW. Die offizielle Website lautet http://www.mingw.org/. Dort befindet sich auch ein Link zum Sourceforge-Archiv des MinGW-Projekts, wo die Dateien heruntergeladen werden können. Wir nehmen hier den "Automated MinGW Installer".

Nach dem Dowload kann die .exe gestartet werden. Eine Meldung erscheint, das nach der aktuellsten version gesucht wird. Anscheinend erscheint die Meldung "Welcome to MinGW Version ...".

1. Die Installation kann mit "Next >" vorbereitet werden. Hier wählen wir "Download and install" um die benötigten Datien aus dem Internet zu laden und MinGW anschließend zu installieren.
2. MinGW kann nur isntalliert werden, wenn sie die nun sichtbare lizenz mit "I Agree" akzeptieren.
3. Bei der Frage,w elche Version wählen wir "Current". Es gibt in der regel keinen Grund ältere Sofwtare vorzuziehen. Aber eine ß-Version kann zu Problem führen. Weiter mit "Next >".
4. Nun können Sie wählen welche Pakete installiert werden sollen. Zunächst reicht uns für die reine C++-Programmierung "MinGW Base Tools" und "g++ Compiler". (Natürlich können Sie bei Bedarf weitere installieren.)
5. Nach "Next >" können Sie nun ein Installatiosnverzeichnis wählen. Sie könne hier im Grunde ein beliebiges auswählen. allerdings verursachen Compiler manchmal Probleme, wenn in irgendeinem Pfad Leerzeichen sind. Es wäre also praktisch hierauf zu verzichten. Der Vorschlag ("C:\MinGW") ist also eine gute Idee.
6. Anschließend kann der Name für den Ordner im Startverzeichnis gewählt werden.
7. Nach dem Klick auf "Install" werden die benötigten Datien aus dem Internet geladen und die Installation startet.
8. Anschließend ein Klick auf "Next >" und hier auf "Finish" und Sie haben es geschafft.

g++ ohne UltraEdit benutzen

g++ ist nun einsatzbereit. Sie sollten allerdings den Pfad zu MinGW noch als Umgebungsvariable setzen. Sonst müssen Sie beim Kompilieren immer den kompletten Pfad angaben.

1. Gehen Sie in den Eintrag "System" in der Systemsteuerung. Hierfür muss die klassische Ansicht ausgewählt sein.
2. Nun gehen Sie auf den Reiter "Erweitert" und klciken auf den Button ganz unten "Umgebungsavriablen".
3. Unter "Systemvariablen" suchen Sie den Eintrag "Path".
4. Nach einem Doppelklick können Sie in das Feld "Wert der Variablen" den folgenden Text anhängen: ";C:\MinGW\bin" (ohne Anführungszeichen, gegebenenfalls müssen Sie den Pfad anpassen, wenn Sie ihr Installationsverzeichnis anders gewählt haben).
5. Damit die Umgebungsvariablen komplett übernommen werden, sollte der PC nun neugestartet werden.

Wenn Sie nun eine .cpp-Datei kompilieren wollen, rufen Sie die Konsole auf (zum Beispiel mit [WIndows]+[E] und dort "cmd" (ohne Anführungszeichen) eingeben. Mit [Enter] bestätigen).

1. wechseln Sie mit "cd" in das Verzeichnis, indem sich die .cpp-Datei befindet. Zum Beispiel: cd C:\dev\cpp
2. Hier geben Sie g++ -o MeinErstesProgramm MeinErsterCode.cpp ein (g++ -o [Name die die .exe haben soll] [Kompletter Name der Datei]).
3. Wenn Sie mehrere Dateien kompilieren wollen, können Sie anstatt "MeinErsterCode.cpp" auch "*.cpp" schreiben.

g++ in UltraEdit einbinden

Wenn Sie UltraEdit benutzen, können Sie sich die ganze Arbeit unter "g++ ohne UltraEdit benutzen" sparen. Hier gehen Sie einfach unter [Extras]->[Werkzeug-Konfiguration]. Anschließend auf "Einfügen". Nun können Sie die folgenden Werte eingeben:

• Bezeichnung für den Menüeintrag: aktuelle Datei kompilieren
• Befehlszeile: C:\MinGW\bin\g++.exe -o "%n" %F
• Arbeistverzeichnis: %P
• (Nun im Reiter "Optionen") Programmtyp: Dos-Programm
• Ein Harken bei "Aktive Datei erst speichern"
• (Nun im Reiter "Ausgabe")Befehlsausgabe: Ausgabe in Listenfeld und Ausgabe aufzeichnen
• Markierten Text ersetzen durch: Nicht ersetzen

Wenn Sie ganze Projekte kompilieren möchten, müssen Sie im Gegensatz zu oben einige Einträge ändern:

• Bezeichnung für den Menüeintrag: Projekt kompilieren
• Befehlszeile: C:\MinGW\bin\g++.exe -o "%rn" %RP*.cpp
• Arbeistverzeichnis: %RP
• Ein Harken bei "Erst alles speichern"

Nun können Sie noch Einträge zum Ausführen der erstellen Programme einfügen. Wenn Sie die erstellte .exe einer Datei ausführen wollen, lautet die Befsehlszeile "%P%N.exe" (beim Projekt "%RP%RN.exe"). Unter Optionen wird nichts gespeichert und das DOS-Programm ausgewählt. Bei beiden Typen wird unter dem Reiter "Ausgabe" das Häkchen bei "Ausgabe aufzeichnen" entfernt und afür eins bei "DOS-Fenster anzeigen" gesetzt.

Mehr zu diesen Möglichkeiten bei UltraEdit finden Sie auch sehr gut dokumentiert in der Hilfe. Der Eintrag in der Hilfe ist gleichnamig mit dem genutzten im Extras-Menü.

jajaja, al menos todavía somos útiles o no??. Estuve buscando por un largo tiempo la forma para crear un interfaz gráfica para un mi proyectito que tengo en C++, considere utilizar la WinApi (la libreria para crear codigo Nativo de Windows), pero la verdad creo que aprender esa libreria llevaría mucho tiempo y tanto esfuerzo solo serviría para Windows y no para Linux, que tambien me interesa.

Segui buscando y encontré varias opciones,

WxWidgets: http://www.wxwidgets.org/

Qt: http://trolltech.com/downloads/opensource

GTK+: http://www.gtk.org/

¿Cual elegir?, Quizás algunas personas me contradigan en lo siguiente, pero yo pienso que esto es parecido a cuando uno elige su lado en alguno de los siguientes temas, la politica, el futbol y la religión, jajajaja, todos son correctos y a la vez todos equivocados, es cuestión de gustos, recuerden que lo que es fácil para alguno puede ser dificil para otro, asi que no podria venir y decir cual es más fácil, ni cual es más dificil.

Yo me decidi por GTK, senti facilidad para aprenderlas, hay gran cantidad de aplicaciones que la utilizan y su aspecto es muy bueno,  estas librerias estan muy apoyadas por una gran comunidad, ademas de ser compatibles para windows y linux, pero vuelvo a repetir, "Es cuestión de gustos".

pero si les interesa utilizar GTK aqui les dejo un tutorial de como hacerlo utlizando el compilador MinGW con el IDE Code::Blocks sobre Windows.

Para Descargar Tutorial PRESIONAR AQUI.

Modifique a variável $mingw_path para o caminho do MinGW (Geralmente é C:\MinGW\bin).

O arquivo C deve estar em C:\Documents and Settings\Usuário\Meus Documentos, ou simplesmente 'Meus Documentos', a não ser que você modifique a variável $home.

Link para o script: http://dumpmind.pastebin.com/f2c038168

Potrzebne będą dwie rzeczy:

1. Dystrybucja MinGW,
2. Eclipse + CDT lub samo CDT do pobrania przez update software w Eclipse po dodaniu strony
   http://download.eclipse.org/tools/cdt/releases/ganymede.

Wykorzystałem dystrybucję MinGW Distro - nuwen.net, ponieważ jest szybka w instalacji (rozpakowanie plików) i zawiera wszelkie podstawowe aplikacje oraz te bardziej specjalne, ale o tym można się dowiedzieć na podanej stronie.

Jeśli chodzi o Eclipse, to jest to wersja specjalnie przygotowana do projektów w cpp i zawiera oprócz CDT (w wersji 5.0) także klienta repozytorium CVS (klienta SVN można ściągnąć ze strony subclipse.tigris.org) oraz Mylyn.

Istotne jest to, jak należy "zainstalować" tą dystrybucję MinGW, żeby była widoczna dla Eclipse. Otóż możemy rozpakować podaną dystrybucję gdziekolwiek (najlepiej bez białych znaków w strukturze katalogów), lecz jeśli nie będzie to standardowe miejsce C:\MinGW\ to musimy utworzyć na dysku C takie katalogi: C:\MinGW\bin\, ponieważ CDT wyszukuje zainstalowanego toolchain'a od MinGW właśnie po istnieniu podanej ścieżki na dysku C.
To oczywiście nie wszystko - w zmiennej PATH należy dodać lokalizację rozpakowanej dystrybucji ze ścieżką do podkatalogu bin, czyli dla przykładu D:\PRO\MinGW\bin\. Żeby sprawdzić czy wszystko jest ok, należy uruchomić ponownie komputer lub wylogować się z profilu - dopiero wtedy zmiany w PATH zostaną uwzględnione dla systemu (oczywiście można wszystko zmienić z wiersza polecenia ale nie będę komplikował).

W tym momencie należy sprawdzić, czy zmienna systemowa PATH zawiera dystrybucję MinGW - w tym celu wydajemy w konsoli systemu (cmd) polecenie:
g++ -v.
Jeśli wszystko jest ok, to powinniśmy otrzymać parę linii komunikatu kończącego się np. tak:
gcc version 4.2.1-dw2 (mingw32-2).

Czas na odpalenie Eclipse i stworzenie projektu.
W tym celu wybieramy opcję New Project/C++ Project z menu kontekstowego nad oknem Project Explorer, przez przyciśnięcie przycisku na liście toolbox'a New C/C++ Project lub przez menu File.

W otworzonym okienku istotne są dwie rzeczy:

1. W prawym panelu powinien być widoczny toolchain MinGW GCC,
2. Tworząc "zwykły" projekt .exe wybieramy "Empty Project", zamiast pozostałych "Hello World ...".

Dalsze okienka akceptujemy bez wprowadzania zmian.

Tworzymy nowy plik implementacji (.cpp) z menu new, i dodajemy tam przykładowy kod:

#include <iostream>
using namespace std;

int main () {
// Say Hello five times
for (int index = 0; index < 5; ++index)
cout << "HelloWorld!" << endl;
exit(0);
}



Domyślnie kompilacja następuje przy każdym save'owaniu - o ile przy programowaniu w Javi'e nie jest to uciążliwe (a wręcz bardzo pomocne), to w przypadku pracy z cpp może to przeszkadzać osobą takim jak ja, które wciskają ctrl+s co 20 sekund. Warto więc odznaczyć pole "Build Automatically" w menu Project.
Kompilacji (build całego projektu) dokonywać teraz można np. poprzez skrót ctrl+b lub przez odpowiednią ikonkę "młotka" na toolbox'ie Eclipse'a.
W odpowiedzi w oknie Console dostaniemy podobne podsumowanie:

Build complete for project (twój projekt)
Time consumed: 1578 ms.


Teraz wystarczy otrzymany .exe odpalić bezpośrednio z Eclipse przez menu Run as - Local C/C++ Application i w oknie Console otrzymamy wynik działania aplikacji podanej wyżej.