4. Standard Form ändern

Standard Form ändern

  • ?

    Ich möchte endlich aus dem Bann des 4-Ecks entweichen sprich die Form meines Programms selber bestimmen wollen.

    Möchte z.B. dass mein Prog mehr so aussieht.
    ---
    | |--|
    | |--|
    ---

    Hättet ihr ne Ahnugn wie ich dass anstellen.
    Andere machen dass auch auch, (Winamp,MediaPlayer...)

    [ Dieser Beitrag wurde am 08.12.2002 um 08:55 Uhr von Jansen editiert. ]

    0
  • J

    Hab dafür einen entsprechenden Beitrag in die FAQ geschoben.

    0
  • W

    Und wenn die Form etwas spezieller sein sollte und du ein Bitmap als Maske hast, dann mail mich an. Ich hab da ein paar Routinen, die dir zusagen könnten. 🙂

    0
  • D

    sehnen wir uns nicht alle nach den Zeiten indem Windows nicht mehr von Vierecken regiert wird sondern wir zur holden Weihnachtszeit ein Herzchen ein Sternchen und ein Zipfelmützenförmiges Fenster auf unserem Desktop haben 😃

    Jetz mal im Ernst, ich würd das was unter dem fenster ist auslesen und als bitmap anzeigen, dann kannst du da zwar immernochnicht draufklicken aber du siehst es nicht 😃

    0
  • ?

    WebFritzi´ich wäre dann soweit, habe meine Grafik eigenzlich fast fertig.
    Noch ist es eine *.png Datei, aber kann ich auch nach bmp umwandeln.
    Bin schonmal auf die Tricks und Tipps gespannt

    0
  • W

    Na gut, wenn du mich nicht anmailen willst, dann muss ich das Ganze wohl hier posten. Ist alles WinAPI unter C++.

    //
//  RegionFunctions.h
//
//---------------------------------------------------------------------------
#ifndef RegionFunctionsH
#define RegionFunctionsH
//---------------------------------------------------------------------------
#include <windows.h>
#include <stdio.h>
//---------------------------------------------------------------------------
#define  LR_FROMRESOURCE   1
#define  LR_FROMFILE       2
//---------------------------------------------------------------------------

struct RESFILEINFO
{
    HINSTANCE  hInstance;
    UINT       uiID;
    LPCTSTR    lpszFileName;
};
//---------------------------------------------------------------------------

HRGN ScanRegion(HBITMAP, BYTE, BYTE, BYTE);
BYTE* Get24BitPixels(HBITMAP, DWORD*, WORD*);
BOOL SaveRegion(HRGN, char*);
BOOL LoadRegion(HRGN&, WORD, RESFILEINFO*);
BOOL DuplicateRegion(HRGN, HRGN&);
//---------------------------------------------------------------------------
#endif

//
//  RegionFunctions.cpp
//
#include "RegionFunctions.h"

// --------------------------------------------------------------------------
// Return bitmap pixels in 24bits format.
// The caller must release the memory...
// This function is used in ScanRegion()
// --------------------------------------------------------------------------
BYTE* Get24BitPixels(HBITMAP pBitmap, DWORD *pwWidth, WORD *pwHeight)
{
  // a bitmap object just to get bitmap width and height
  BITMAP bmpBmp;

  // pointer to original bitmap info
  LPBITMAPINFO pbmiInfo;

  // bitmap info will hold the new 24bit bitmap info
  BITMAPINFO bmiInfo;

  // width and height of the bitmap
  WORD wBmpWidth, wRealBmpWidth, wBmpHeight;

  // ---------------------------------------------------------
  // get some info from the bitmap
  // ---------------------------------------------------------
  GetObject(pBitmap, sizeof(bmpBmp), &bmpBmp);
  pbmiInfo   = (LPBITMAPINFO)&bmpBmp;

  // get width and height
  wRealBmpWidth  = (WORD)pbmiInfo->bmiHeader.biWidth;
  wBmpWidth      = (WORD)(wRealBmpWidth - (wRealBmpWidth%4) + 4); // width is 4 byte boundary aligned.
  wBmpHeight     = (WORD)pbmiInfo->bmiHeader.biHeight;

  // copy to caller width and height params
  *pwWidth  = MAKELONG(wRealBmpWidth, wBmpWidth);
  *pwHeight = wBmpHeight;
  // ---------------------------------------------------------

  // allocate width * height * 24bits pixels
  BYTE *pPixels = new BYTE[wBmpWidth * wBmpHeight * 3];
  if(!pPixels) return NULL;

  // get user desktop device context to get pixels from
  HDC hDC = GetWindowDC(NULL);

  // fill desired structure
  bmiInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  bmiInfo.bmiHeader.biWidth = wBmpWidth - 1;
  bmiInfo.bmiHeader.biHeight = -wBmpHeight;
  bmiInfo.bmiHeader.biPlanes = 1;
  bmiInfo.bmiHeader.biBitCount = 24;
  bmiInfo.bmiHeader.biCompression = BI_RGB;
  bmiInfo.bmiHeader.biSizeImage = wBmpWidth * wBmpHeight * 3;
  bmiInfo.bmiHeader.biXPelsPerMeter = 0;
  bmiInfo.bmiHeader.biYPelsPerMeter = 0;
  bmiInfo.bmiHeader.biClrUsed = 0;
  bmiInfo.bmiHeader.biClrImportant = 0;

  // get pixels from the original bitmap converted to 24bits
  int iRes = GetDIBits(hDC, pBitmap, 0, wBmpHeight, (LPVOID)pPixels, &bmiInfo, DIB_RGB_COLORS);

  // release the device context
  ReleaseDC(NULL, hDC);

  // if failed, cancel the operation.
  if(!iRes)
  {
     delete[] pPixels;
     return NULL;
  };

  // return the pixel array
  return pPixels;
}

// --------------------------------------------------------------------------
// Scan a bitmap and return a perfect fit region.
// The caller must release the region object...
// (this method starts with a full region and excludes inside the loop)
// --------------------------------------------------------------------------
HRGN ScanRegion(HBITMAP hBitmap, BYTE jTranspR, BYTE jTranspG, BYTE jTranspB)
{
  // bitmap width and height
  WORD wBmpWidth, wBmpHeight;
  WORD wRealBmpWidth;
  DWORD dwBmpWidthes;

  // the final region and a temporary region
  HRGN hRgn, hTmpRgn;

  // 24bit pixels from the bitmap
  BYTE *pPixels = Get24BitPixels(hBitmap, &dwBmpWidthes, &wBmpHeight);
  wBmpWidth = HIWORD(dwBmpWidthes);
  wRealBmpWidth = LOWORD(dwBmpWidthes);
  if(!pPixels) return NULL;

  // create our working region
  hRgn = CreateRectRgn(0, 0, wRealBmpWidth, wBmpHeight);
  if(!hRgn) return NULL;

  // ---------------------------------------------------------
  // scan the bitmap
  // ---------------------------------------------------------
  DWORD p=0;
  for (WORD y=0; y<wBmpHeight; y++)
  {
     for (WORD x=0; x<wBmpWidth; x++)
     {
        BYTE jRed   = pPixels[p + 2];
        BYTE jGreen = pPixels[p + 1];
        BYTE jBlue  = pPixels[p + 0];

        if (jRed == jTranspR && jGreen == jTranspG && jBlue == jTranspB)
        {
           // remove transparent color from region
           hTmpRgn = CreateRectRgn(x, y, x+1, y+1);
           CombineRgn(hRgn, hRgn, hTmpRgn, RGN_XOR);
           DeleteObject(hTmpRgn);
        }

        // next pixel
        p = p + 3;
     }
  }

  // We don't need the pixels array anymore
  delete[] pPixels;

  // return the region
  return hRgn;
}
//---------------------------------------------------------------------------

// --------------------------------------------------------------------------
// Save a region to disk (szFile is the filename)
// --------------------------------------------------------------------------
BOOL SaveRegion(HRGN hRgn, char* szFile)
{
  // get the size of the region object
  int iSize = GetRegionData(hRgn, 0,0);

  // allocate space for it
  LPRGNDATA pData = new RGNDATA[iSize];
  if(!pData) return false;

  // get the region as binary data
  GetRegionData(hRgn, iSize, pData);

  // save
  FILE *file = fopen(szFile, "wb");
  if(!file)
  {
     delete pData;
     return false;
  }
  fwrite(pData, 1, iSize, file);
  fclose(file);

  delete pData;
  return true;
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//   Load a region from a resource or a file
//---------------------------------------------------------------------------
BOOL LoadRegion(HRGN& hRgn, WORD wFlags, RESFILEINFO* rfInfo)
{
   switch(wFlags)
   {
      case LR_FROMRESOURCE:
      {
         // -------------------------------------------------
         // We retrieve the skin region from resource.
         // -------------------------------------------------

         // ask resource for our skin.
         HRSRC hrsrc = FindResource(rfInfo->hInstance,
                                    MAKEINTRESOURCE(rfInfo->uiID),
                                    "BINARY");
         if(!hrsrc) return false;

         // this is standard "BINARY" retrieval
         LPRGNDATA pRgnData = (LPRGNDATA)LoadResource(rfInfo->hInstance, hrsrc);
         if(!pRgnData) return false;

         // create the region using the binary data.
         hRgn = ExtCreateRegion(NULL, SizeofResource(NULL, hrsrc), pRgnData);

         // check if we have the skin at hand.
         if(!hRgn) return FALSE;
      }
      break;

      case LR_FROMFILE:
      {
         RGNDATA* pRgnData;

         // Open the file
         HANDLE hFile = CreateFile(rfInfo->lpszFileName, GENERIC_READ, 0,
                                   NULL, OPEN_EXISTING, 0, NULL);
         if(hFile == INVALID_HANDLE_VALUE) return FALSE;

         // Get FileSize
         DWORD fileSize = GetFileSize(hFile, NULL);
         if(fileSize == 0xFFFFFFFF) return FALSE;

         // Read Region Data From File
         BYTE* buffer = new BYTE[fileSize];
         DWORD BytesRead;
         if(!ReadFile(hFile, (LPVOID)buffer, fileSize, &BytesRead, NULL))
            return FALSE;
         if(BytesRead < fileSize)
            return FALSE;
         pRgnData = (RGNDATA*)buffer;

         // create the region using the binary data.
         hRgn = ExtCreateRegion(NULL, fileSize, pRgnData);

         // check if we have the skin at hand.
         if(!hRgn) return FALSE;

         // Done
         CloseHandle(hFile);
      }
   }

   return TRUE;
}
//---------------------------------------------------------------------------

BOOL DuplicateRegion(HRGN hSrcRgn, HRGN& hDestRgn)
{
   // get the size of the region object
   int iSize = GetRegionData(hSrcRgn, 0,0);

   // allocate space for it
   LPRGNDATA pData = new RGNDATA[iSize];
   if(!pData) return FALSE;

   // get the region as binary data
   GetRegionData(hSrcRgn, iSize, pData);

   hDestRgn = ExtCreateRegion(NULL, iSize, pData);

   delete pData;
   return TRUE;
}
//---------------------------------------------------------------------------

    Zuerst schreibst du dir einen kleinen Code, der per ScanRegion() dein Bitmap einscannt. Dabei musst du die transparente Farbe angeben. Zurück bekommst du ein Handle auf eine Region. Dieses übergibst du dann an die Funktion SaveRegion(), die deine Region binär in ein neues File schreibt. Dann kannst du den Code, den du gerade geschrieben hast, vergessen. Du hast deine Region ja abgespeichert. In dein richtiges Proggi bindest du dann das Bitmap (als Bitmap) und die Region (binär) als Resource ein. Dann brauchst du nur noch die Funktion LoadRegion(), um deine Region aus den Resourcen zu laden. Feddisch!

    [ Dieser Beitrag wurde am 15.12.2002 um 20:57 Uhr von WebFritzi editiert. ]

    0
  • ?

    OK, Danke WebFritzi, scheint mir alles noch etwas kompliziert aber ich hoffe ich kriege das hin.

    Entschuldige, dass ich das mit der eMail in der Zwischenzeit wieder vergessen habe, aber so nützt das vielleicht mehreren. evt. sogar ne Aufnahme in die FAQ?

    Möchte mich auf jeden Fall mal bedanken!! Werde das aber erst nächstes Wochende ausprobieren können.

    0
  • W

    Hehe. Ich hab's dir leichter gemacht: ich habe gestern und heute ein Tool gebaut, mit dem du leicht Regions erstellen und speichern kannst. Ein kleines HTML-Hilfe-File anbei hilft dir beim Laden der gespeicherten Region in das Projekt. Du findest das Tool (RegionBuilder) auf meiner HP unter Downloads oder gleich unter http://de.geocities.com/webfritzi/Downloads.htm.

    [ Dieser Beitrag wurde am 16.12.2002 um 19:07 Uhr von WebFritzi editiert. ]

    0
  • ?

    Huhu 🙂

    Deine Komponente ist super!! Bloß läd's das bei mir nicht.
    Ich habe die erstelle Region.dat zum Projekt hinzugefügt. Dann noch eine Region.rc mit dem Inhalt aus der ersten rauen Tabelle.

    Dann die in die *.cpp die ganze zweite graue Tabelle eingefügt und habe dann um zu sehen, ob es funktioniert die boolfunktion über einen ButtonClick folgend aufgerufen

    bool LoadRegion();

    Was habe ich falsch gemacht?

    0
Anmelden zum Antworten