size_t wxBitmapDataObject::GetDataSize() const
{
#if wxUSE_WXDIB
    return wxDIB::ConvertFromBitmap(NULL, GetHbitmapOf(GetBitmap()));
#else
    return 0;
#endif
}

wxObject * MaxBitmapComboBoxXmlHandler::DoCreateResource()
{
    if (m_class == wxT("ownerdrawnitem"))
    {
        wxCHECK_MSG(m_combobox, NULL, wxT("Incorrect syntax of XRC resource: ownerdrawnitem not within a bitmapcombobox!"));

        m_combobox->Append(GetText(wxT("text")), GetBitmap(wxT("bitmap"), wxART_MISSING_IMAGE));

        return m_combobox;
    }
    else /*if( m_class == wxT("wxBitmapComboBox"))*/
    {
        // find the selection
        long selection = GetLong( wxT("selection"), -1 );

        XRC_MAKE_INSTANCE(control, MaxBitmapComboBox)

        control->Create(m_parentAsWindow,
                        GetID(),
                        GetText(wxT("value")),
                        GetPosition(), GetSize(),
                        0,
                        NULL,
                        GetStyle(),
                        wxDefaultValidator,
                        GetName());

		control->MaxBind(_wx_wxbitmapcombobox_wxBitmapComboBox__xrcNew(control));

        m_isInside = true;
        m_combobox = control;

        wxXmlNode *children_node = GetParamNode(wxT("object"));

        wxXmlNode *n = children_node;

        while (n)
        {
            if ((n->GetType() == wxXML_ELEMENT_NODE) &&
                (n->GetName() == wxT("object")))
            {
                CreateResFromNode(n, control, NULL);
            }
            n = n->GetNext();
        }

        m_isInside = false;
        m_combobox = NULL;

        if (selection != -1)
            control->SetSelection(selection);

        SetupWindow(control);

        return control;
    }
}

wxObject* wxRibbonXmlHandler::Handle_galleryitem()
{
    wxRibbonGallery *gallery = wxStaticCast(m_parent, wxRibbonGallery);
    wxCHECK (gallery, NULL);

    gallery->Append (GetBitmap(), GetID());

    return NULL; // nothing to return
}

void Sprite::Render(Bitmap& bitmap)
	{
	if (!visible_)
		{
		return;
		}

	GetBitmap().Blit((int)GetCel(),bitmap,Round(GetX()-GetOriginX()),Round(GetY()-GetOriginY()),GetColor(),GetAlpha());
	}

void CBitmapEx::SethBitmap(int iWidth, int iHeight, HDC hdc)
{
	_hBitmap = CreateCompatibleBitmap(
		hdc, iWidth, iHeight);

	GetObject(hGethBitmap(), sizeof(BITMAP), &GetBitmap());


}

// Obtain a mask bitmap. A mask bitmap is a bitmap which has
// all pixels with the color "crColor" set to white and all
// other pixels set to black.
HBITMAP ClsBitmap::GetMaskBitmap( COLORREF crColor, int nXPos /* = 0 */, int nYPos /* = 0 */ ) const
{
	_ASSERT_VALID( m_hGdiObject ); // Must be valid.

	// Preset result.
	BOOL bResult = FALSE;
	HBITMAP hMaskBM = NULL;

	// Create the necessary device contexts.
	ClsDC dcSrc, dcDst;
	if ( dcSrc.CreateCompatibleDC( NULL ) &&
	     dcDst.CreateCompatibleDC( NULL ))
	{
		// Get source bitmap information.
		BITMAP bm;
		if ( GetBitmap( &bm ))
		{
			// Create a monochrome bitmap of the same size.
			hMaskBM = ::CreateBitmap( bm.bmWidth, bm.bmHeight, 1, 1, NULL );
			if ( hMaskBM )
			{
				// Select both the source and destination bitmaps.
				HGDIOBJ hOldSrc = dcSrc.SelectObject( m_hGdiObject );
				HGDIOBJ hOldDst = dcDst.SelectObject( hMaskBM );
				_ASSERT( hOldSrc && hOldDst );

				// Obtain the color used to create the mask bitmap.
				if ( crColor == CLR_DEFAULT )
					crColor = dcSrc.GetPixel( nXPos, nYPos );

				// Change the background color to the masked color.
				COLORREF crOldBkCol = dcSrc.SetBkColor( crColor );

				// Copy the source into the destination which creates
				// the mask.
				if ( dcDst.BitBlt( 0, 0, bm.bmWidth, bm.bmHeight, &dcSrc, 0, 0, SRCCOPY ))
					// Success...
					bResult = TRUE;
				
				// Restore background color.
				dcSrc.SetBkColor( crOldBkCol );

				// Restore old bitmaps.
				dcSrc.SelectObject( hOldSrc );
				dcDst.SelectObject( hOldDst );

				// Destroy it if no successful.
				if ( bResult == FALSE ) 
					::DeleteObject( hMaskBM );
			}
		}
	}
	// Destroy DCs
	if ( dcSrc.IsValid())    dcSrc.DeleteDC();
	if ( dcDst.IsValid())    dcDst.DeleteDC();
	return bResult == TRUE ? hMaskBM : NULL;
}

void C4DefGraphics::Draw(C4Facet &cgo, DWORD iColor, C4Object *pObj, int32_t iPhaseX, int32_t iPhaseY, C4DrawTransform* trans)
{
	// default: def picture rect
	C4Rect fctPicRect = pDef->PictureRect;
	C4Facet fctPicture;

	// if assigned: use object specific rect and graphics
	if (pObj) if (pObj->PictureRect.Wdt) fctPicRect = pObj->PictureRect;

	// specific object color?
	if (pObj) pObj->PrepareDrawing();

	switch(Type)
	{
	case C4DefGraphics::TYPE_Bitmap:
		fctPicture.Set(GetBitmap(iColor),fctPicRect.x,fctPicRect.y,fctPicRect.Wdt,fctPicRect.Hgt);
		fctPicture.DrawTUnscaled(cgo,true,iPhaseX,iPhaseY,trans);
		break;
	case C4DefGraphics::TYPE_Mesh:
		// TODO: Allow rendering of a mesh directly, without instance (to render pose; no animation)
		std::unique_ptr<StdMeshInstance> dummy;
		StdMeshInstance* instance;

		C4Value value;
		if (pObj)
		{
			instance = pObj->pMeshInstance;
			pObj->GetProperty(P_PictureTransformation, &value);
		}
		else
		{
			dummy.reset(new StdMeshInstance(*Mesh, 1.0f));
			instance = dummy.get();
			pDef->GetProperty(P_PictureTransformation, &value);
		}

		StdMeshMatrix matrix;
		if (C4ValueToMatrix(value, &matrix))
			pDraw->SetMeshTransform(&matrix);

		pDraw->SetPerspective(true);
		pDraw->RenderMesh(*instance, cgo.Surface, cgo.X,cgo.Y, cgo.Wdt, cgo.Hgt, pObj ? pObj->Color : iColor, trans);
		pDraw->SetPerspective(false);
		pDraw->SetMeshTransform(NULL);

		break;
	}

	if (pObj) pObj->FinishedDrawing();

	// draw overlays
	if (pObj && pObj->pGfxOverlay)
		for (C4GraphicsOverlay *pGfxOvrl = pObj->pGfxOverlay; pGfxOvrl; pGfxOvrl = pGfxOvrl->GetNext())
			if (pGfxOvrl->IsPicture())
				pGfxOvrl->DrawPicture(cgo, pObj, trans);
}

//////////////////
// Attach is just like the CGdiObject version,
// except it also creates the palette
//
BOOL CDib::Attach(HGDIOBJ hbm)
{
	if (CBitmap::Attach(hbm)) {
		if (!GetBitmap(&m_bm))			// load BITMAP for speed
			return FALSE;
		m_pal.DeleteObject();			// in case one is already there
		return CreatePalette(m_pal);	// create palette
	}
	return FALSE;	
}

void ReconcileProjectDlg::OnUndoSelectedFiles(wxCommandEvent& event)
{
    wxDataViewItemArray items;
    m_dataviewAssigned->GetSelections(items);

    for(size_t i=0; i<items.GetCount(); ++i) {
        wxVariant v;
        ReconcileFileItemData* data = dynamic_cast<ReconcileFileItemData*>(m_dataviewAssignedModel->GetClientObject( items.Item(i) ));
        if ( data ) {
            wxFileName fn(data->GetFilename());
            fn.MakeRelativeTo(m_toplevelDir);

            wxVector<wxVariant> cols;
            cols.push_back(::MakeIconText(fn.GetFullPath(), GetBitmap(fn.GetFullName())));
            m_dvListCtrl1Unassigned->AppendItem( cols, (wxUIntPtr)NULL );

        }
    }

    // get the list of items
    wxArrayString allfiles;
    for(int i=0 ; i<m_dvListCtrl1Unassigned->GetItemCount(); ++i) {
        wxVariant v;
        m_dvListCtrl1Unassigned->GetValue(v, i, 0);
        wxDataViewIconText it;
        it << v;
        allfiles.Add(it.GetText());
    }

    m_dataviewAssignedModel->DeleteItems(wxDataViewItem(0), items);

    // Could not find a nicer way of doing this, but
    // we want the files to be sorted again
    m_dvListCtrl1Unassigned->DeleteAllItems();

    std::sort(allfiles.begin(), allfiles.end());
    for(size_t i=0; i<allfiles.GetCount(); ++i) {
        wxVector<wxVariant> cols;
        cols.push_back( ::MakeIconText(allfiles.Item(i), GetBitmap(allfiles.Item(i)) ) );
        m_dvListCtrl1Unassigned->AppendItem( cols, (wxUIntPtr)NULL);
    }
}

void cVnsiOsd::Flush(void)
{
  if (!Active())
     return;
  cBitmap *Bitmap;
  bool full = cVnsiOsdProvider::IsRequestFull();
  for (int i = 0; (Bitmap = GetBitmap(i)) != NULL; i++)
  {
    uint8_t reset = !shown || full;
    Cmd(VNSI_OSD_OPEN, i, Bitmap->Bpp(), Left() + Bitmap->X0(), Top() + Bitmap->Y0(), Left() + Bitmap->X0() + Bitmap->Width() - 1, Top() + Bitmap->Y0() + Bitmap->Height() - 1, (void *)&reset, 1);
    int x1 = 0, y1 = 0, x2 = 0, y2 = 0;
    if (!shown || Bitmap->Dirty(x1, y1, x2, y2) || full)
    {
      if (!shown || full)
      {
        x1 = y1 = 0;
        x2 = Bitmap->Width() - 1;
        y2 = Bitmap->Height() - 1;
      }
      // commit colors:
      int NumColors;
      const tColor *Colors = Bitmap->Colors(NumColors);
      if (Colors)
      {
        Cmd(VNSI_OSD_SETPALETTE, i, 0, NumColors, 0, 0, 0, Colors, NumColors*sizeof(tColor));
      }
      // commit modified data:
      int size = (y2-y1) * Bitmap->Width() + (x2-x1+1);
      Cmd(VNSI_OSD_SETBLOCK, i, Bitmap->Width(), x1, y1, x2, y2, Bitmap->Data(x1, y1), size);
    }
    Bitmap->Clean();
  }
  if (!shown)
  {
    // Showing the windows in a separate loop to avoid seeing them come up one after another
    for (int i = 0; (Bitmap = GetBitmap(i)) != NULL; i++)
    {
      Cmd(VNSI_OSD_MOVEWINDOW, i, 0, Left() + Bitmap->X0(), Top() + Bitmap->Y0());
    }
    shown = true;
  }
}

int NewBitmapCursor(Cursor *cp, char *source, char *mask)
{
	XColor fore, back;
	int hotx, hoty;
	int sx, sy, mx, my;
	unsigned int sw, sh, mw, mh;
	Pixmap spm, mpm;
	Colormap cmap = Scr->RootColormaps.cwins[0]->colormap->c;

	if(dpy == NULL) {
		// Handle special cases like --cfgchk
		*cp = None;
		return 0;
	}

	fore.pixel = Scr->Black;
	XQueryColor(dpy, cmap, &fore);
	back.pixel = Scr->White;
	XQueryColor(dpy, cmap, &back);

	spm = GetBitmap(source);
	if((hotx = HotX) < 0) {
		hotx = 0;
	}
	if((hoty = HotY) < 0) {
		hoty = 0;
	}
	mpm = GetBitmap(mask);

	/* make sure they are the same size */

	XGetGeometry(dpy, spm, &JunkRoot, &sx, &sy, &sw, &sh, &JunkBW, &JunkDepth);
	XGetGeometry(dpy, mpm, &JunkRoot, &mx, &my, &mw, &mh, &JunkBW, &JunkDepth);
	if(sw != mw || sh != mh) {
		fprintf(stderr,
		        "%s:  cursor bitmaps \"%s\" and \"%s\" not the same size\n",
		        ProgramName, source, mask);
		return (1);
	}
	*cp = XCreatePixmapCursor(dpy, spm, mpm, &fore, &back, hotx, hoty);
	return (0);
}

void MAS::Progress::UpdateSize() {
   Bitmap bmp = GetBitmap();
   if (!bmp) return;
      
   if (orientation == 1) {
      h(bmp.h());
   }
   else {
      w(bmp.w());
   }
}

bool wxBitmapDataObject::GetDataHere(void *buf) const
{
#if wxUSE_WXDIB && !defined(__WXWINCE__)
    BITMAPINFO * const pbi = (BITMAPINFO *)buf;

    return wxDIB::ConvertFromBitmap(pbi, GetHbitmapOf(GetBitmap())) != 0;
#else
    wxUnusedVar(buf);
    return false;
#endif
}

void CMyStatic::OnLButtonDown(UINT nFlags, CPoint point)
{
	bool bHandled = false;
	HBITMAP hBitmap = GetBitmap();
	COleDataSourceEx *pDataSrc = NULL;
	if (m_bDelayRendering)
		pDataSrc = DelayRenderOleData(hBitmap);
	else
		pDataSrc = CacheOleData(hBitmap, false);
	if (pDataSrc)
	{
		if (m_bAllowDropDesc)						// Allow targets to show user defined text.
			pDataSrc->AllowDropDescriptionText();	// Must be called before setting the drag image.

		CPoint pt(-1, 30000);						// Cursor is centered below the image
		switch (m_nDragImageType & DRAG_IMAGE_FROM_MASK)
		{
		case DRAG_IMAGE_FROM_CAPT :
			// Get drag image from content with optional scaling
			pDataSrc->InitDragImage(hBitmap, m_nDragImageScale, &pt);
			break;
		case DRAG_IMAGE_FROM_RES :
			// Use bitmap from resources as drag image
			pDataSrc->InitDragImage(IDB_BITMAP_DRAGME, &pt, CLR_INVALID);
			break;
		case DRAG_IMAGE_FROM_HWND :
			// This window handles DI_GETDRAGIMAGE messages.
//			pDataSrc->SetDragImageWindow(m_hWnd, &point);
//			break;
		case DRAG_IMAGE_FROM_SYSTEM :
			// Let Windows create the drag image.
			// With file lists and provided "Shell IDList Array" data, file type images are shown.
			// Otherwise, a generic image is used.
			pDataSrc->SetDragImageWindow(NULL, &point);
			break;
		case DRAG_IMAGE_FROM_EXT :
			// Get drag image from file extension using the file type icon
			pDataSrc->InitDragImage(_T(".bmp"), m_nDragImageScale, &pt);
			break;
//		case DRAG_IMAGE_FROM_TEXT :
//		case DRAG_IMAGE_FROM_BITMAP :
		default :
			// Get drag image from content without scaling
			pDataSrc->InitDragImage(hBitmap, 100, &pt);
		}
		m_bDragging = true;							// to know when dragging over our own window
		pDataSrc->DoDragDropEx(DROPEFFECT_COPY);
		pDataSrc->InternalRelease();
		m_bDragging = false;
		bHandled = true;
	}
	if (!bHandled)
		CStatic::OnLButtonDown(nFlags, point);
}

void CBitmapEx::SethBitmap(const TCHAR* szFileName)
{
	_hBitmap = (HBITMAP)LoadImage(
		NULL,			//hInstance=NULL lay cua so hien tai
		szFileName,		//File can lay hinh
		IMAGE_BITMAP,	//loai la bitmap
		0,
		0,
		LR_LOADFROMFILE | LR_CREATEDIBSECTION | LR_DEFAULTSIZE
		);
	GetObject(hGethBitmap(), sizeof(BITMAP), &GetBitmap());
}

wxObject * MaxBannerWindowXmlHandler::DoCreateResource()
{
    XRC_MAKE_INSTANCE(banner, MaxBannerWindow)

    banner->Create(m_parentAsWindow,
                   GetID(),
                   GetDirection(wxS("direction")),
                   GetPosition(),
                   GetSize(),
                   GetStyle(wxS("style")),
                   GetName());

	banner->MaxBind(CB_PREF(wx_wxbannerwindow_wxBannerWindow__xrcNew)(banner));

    SetupWindow(banner);

    const wxColour colStart = GetColour(wxS("gradient-start"));
    const wxColour colEnd = GetColour(wxS("gradient-end"));
    if ( colStart.IsOk() || colEnd.IsOk() )
    {
        if ( !colStart.IsOk() || !colEnd.IsOk() )
        {
            ReportError
            (
                "Both start and end gradient colours must be "
                "specified if either one is."
            );
        }
        else
        {
            banner->SetGradient(colStart, colEnd);
        }
    }

    wxBitmap bitmap = GetBitmap();
    if ( bitmap.IsOk() )
    {
        if ( colStart.IsOk() || colEnd.IsOk() )
        {
            ReportError
            (
                "Gradient colours are ignored by wxBannerWindow "
                "if the background bitmap is specified."
            );
        }

        banner->SetBitmap(bitmap);
    }

    banner->SetText(GetText(wxS("title")), GetText(wxS("message")));

    return banner;
}

// Creates the control and returns a pointer to it.
wxObject *wxStaticPictureXmlHandler::DoCreateResource()
{
    XRC_MAKE_INSTANCE(control, wxStaticPicture)

    control->Create(m_parentAsWindow, GetID(),
        GetBitmap(wxT("bitmap"), wxART_OTHER, GetSize()),
        GetPosition(), GetSize(), GetStyle(), GetName());

    SetupWindow(control);

    return control;
}

	virtual void SetActive(bool On)
	{
		if (On != Active())
		{
			cOsd::SetActive(On);
			if (!On)
				Clear();
			else
				if (GetBitmap(0))
					Flush();
		}
	}

wxSize wxStaticBitmapBase::DoGetBestSize() const
{
    wxSize best;
    wxBitmap bmp = GetBitmap();
    if ( bmp.IsOk() )
        best = bmp.GetScaledSize();
    else
        // this is completely arbitrary
        best = wxSize(16, 16);
    CacheBestSize(best);
    return best;
}

	virtual void Flush(void)
	{
		if (!Active() || !m_fb)
			return;

		if (IsTrueColor())
		{
			LOCK_PIXMAPS;
			while (cPixmapMemory *pm =
					dynamic_cast<cPixmapMemory *>(RenderPixmaps()))
			{
				const uint8_t *src = pm->Data();
				char *dst = m_fb + (Left() + pm->ViewPort().Left()) *
						(m_vinfo.bits_per_pixel / 8 ) +
						(Top() + pm->ViewPort().Top()) * m_finfo.line_length;

				for (int y = 0; y < pm->DrawPort().Height(); y++)
				{
					memcpy(dst, src, pm->DrawPort().Width() * sizeof(tColor));
					src += pm->DrawPort().Width() * sizeof(tColor);
					dst += m_finfo.line_length;
				}
#if APIVERSNUM >= 20110
				DestroyPixmap(pm);
#else
				delete pm;
#endif
			}
		}
		else
		{
			for (int i = 0; cBitmap *bitmap = GetBitmap(i); ++i)
			{
				int x1, y1, x2, y2;
				if (bitmap->Dirty(x1, y1, x2, y2))
				{
					char *dst = m_fb + (Left() + bitmap->X0() + x1) *
							(m_vinfo.bits_per_pixel / 8 ) +
							(Top() + bitmap->Y0() + y1) * m_finfo.line_length;

					for (int y = y1; y <= y2; ++y)
					{
						tColor *p = (tColor *)dst;
						for (int x = x1; x <= x2; ++x)
							*p++ = bitmap->GetColor(x, y);

						dst += m_finfo.line_length;
					}
					bitmap->Clean();
				}
			}
		}
	}