示例#1
0
UINT16 gdi_get_color_16bpp(HGDI_DC hdc, GDI_COLOR color)
{
	BYTE r, g, b;
	UINT16 color16;

	GetRGB32(r, g, b, color);

	if (hdc->rgb555)
	{
		if (hdc->invert)
		{
			color16 = BGR15(r, g, b);
		}
		else
		{
			color16 = RGB15(r, g, b);
		}
	}
	else
	{
		if (hdc->invert)
		{
			color16 = BGR16(r, g, b);
		}
		else
		{
			color16 = RGB16(r, g, b);
		}
	}

	return color16;
}
示例#2
0
uint16 gdi_get_color_16bpp(HDC hdc, COLORREF color)
{
	uint8 r, g, b;
	uint16 color16;

	GetRGB32(r, g, b, color);

	if(hdc->rgb555)
	{
		if (hdc->invert)
		{
			color16 = BGR15(r, g, b);
		}
		else
		{
			color16 = RGB15(r, g, b);
		}
	}
	else
	{
		if (hdc->invert)
		{
			color16 = BGR16(r, g, b);
		}
		else
		{
			color16 = RGB16(r, g, b);
		}
	}

	return color16;
}
// Get a 32 bit palette, even under <39
void LIBFUNC L_GetPalette32(
	REG(a0, struct ViewPort *vp),
	REG(a1, unsigned long *palette),
	REG(d0, unsigned short count),
	REG(d1, short first))
{
	// If under 39+ we get it directly
	if( ((struct Library *)GfxBase)->lib_Version>=39)
		GetRGB32(vp->ColorMap,first,count,palette);

	// Otherwise, we have to convert from 4 bit colour
	else
	{
		unsigned short pen;
		unsigned long colour;

		// Go through each pen
		for (pen=0;pen<count;pen++)
		{
			// Get colour value of this pen
			colour=GetRGB4(vp->ColorMap,pen+first);

			// Convert from 4 to 32 bit colour
			*palette++=(((colour>>8)&0xf)<<28)|0x0fffffff;
			*palette++=(((colour>>4)&0xf)<<28)|0x0fffffff;
			*palette++=((colour&0xf)<<28)|0x0fffffff;
		}
	}
}
示例#4
0
uint16 GetPenColor_16bpp(HPEN pen)
{
	uint16 p;
	int r, g, b;
	GetRGB32(r, g, b, pen->color);
 	RGB_888_565(r, g, b);
	p = RGB16(r, g, b);
	return p;
}
示例#5
0
void test_color_GetRGB32(void)
{
	int r, g, b;
	UINT32 rgb32 = 0x00AABBCC;
	GetRGB32(r, g, b, rgb32);

	CU_ASSERT(r == 0xAA);
	CU_ASSERT(g == 0xBB);
	CU_ASSERT(b == 0xCC);
}
示例#6
0
uint32 gdi_get_color_32bpp(HGDI_DC hdc, GDI_COLOR color)
{
	uint32 color32;
	uint8 a, r, g, b;

	a = 0xFF;
	GetRGB32(r, g, b, color);

	if (hdc->invert)
	{
		color32 = ABGR32(a, r, g, b);
	}
	else
	{
		color32 = ARGB32(a, r, g, b);
	}

	return color32;
}
示例#7
0
unsigned long xf_gdi_get_color(xfContext* xfc, GDI_COLOR color)
{
	XColor x11_color;

	x11_color.flags = DoRed | DoGreen | DoBlue;
	GetRGB32(x11_color.red, x11_color.green, x11_color.blue, color);
	x11_color.red = x11_color.red << 8;
	x11_color.green = x11_color.green << 8;
	x11_color.blue = x11_color.blue << 8;

	if (XAllocColor(xfc->display, xfc->colormap, &x11_color) != 0)
	{
		XFreeColors(xfc->display, xfc->colormap, &x11_color.pixel, 1, 0);
	}
	else
	{
		x11_color.pixel = BlackPixel(xfc->display, xfc->screen_number);
	}

	return x11_color.pixel;
}
示例#8
0
void Amiga_ConfigColors(void){
	FILE *file;
	UWORD depth;
	long num_colors=1;
	long lokke;
	int lokke2;
	ULONG *table;

	rtPaletteRequest(
		"Color Config. Saved as radium:radiumcolors.conf",NULL,
		RT_Screen,mainscreen,
		TAG_END
	);

	file=fopen("radium:radiumcolors.conf","w");
	if(file==NULL){
		RError("Could not save radium:radiumcolors.conf\n");
		return;
	}
	depth=GetBitMapAttr(mainscreen->RastPort.BitMap,BMA_DEPTH);
	for(lokke=0;lokke<depth;lokke++){
		num_colors*=2;
	}

	fprintf(file,"%d\n",num_colors);

	table=talloc_atomic((size_t)(sizeof(ULONG)*num_colors*3));

	GetRGB32(mainscreen->ViewPort.ColorMap,0,num_colors,table);

	for(lokke=0;lokke<num_colors;lokke++){
		if(lokke==256) break;
		for(lokke2=0;lokke2<3;lokke2++){
			fprintf(file,"%lu\n",table[lokke*3+lokke2]);
		}
	}

	fclose(file);
	
}
struct DragObj * PRIVATE CreateDragObj(struct DragGadget *dg,int x,int y)
{
  struct Screen *scr;
  struct RastPort *rp;
  struct DragObj *gdo;
  ULONG line;
  int wordwidth;
  int width,height,depth;
  int i = 0,xpos,ypos;

  scr = dg->dg_Window->WScreen;
  rp = &scr->RastPort;

  if (dg->dg_Flags & DGF_IMAGES && ((struct ImageNode *)dg->dg_Object.od_Object)->in_Image)
    dg->dg_Image = ((struct ImageNode *)dg->dg_Object.od_Object)->in_Image;

  if (!dg->dg_Width || !dg->dg_Height)
  {
    if ((dg->dg_Type == LISTVIEW_KIND) && !dg->dg_Image)
    {
      dg->dg_Width = dg->dg_Gadget->Width-20;
      dg->dg_Height = dg->dg_ItemHeight;
    }
    else if (!dg->dg_RenderHook && dg->dg_Image)
    {
      dg->dg_Width = dg->dg_Image->Width;
      dg->dg_Height = dg->dg_Image->Height;
    }
    else  /* be sure width & height are not zero */
    {
      dg->dg_Width = dg->dg_Gadget->Width;
      dg->dg_Height = dg->dg_Gadget->Height;
    }
  }
  width = dg->dg_Width;
  height = dg->dg_Height;
  memset(&dm,0,sizeof(struct DropMessage));

  if (dg->dg_Type == LISTVIEW_KIND)
  {
    xpos = dg->dg_Gadget->LeftEdge+2;
    ypos = dg->dg_Gadget->TopEdge+2;
    dg->dg_Object.od_Object = NULL;

    if (y < ypos || y > ypos+dg->dg_Gadget->Height-5)
      return(NULL);
    line = (y-ypos)/dg->dg_ItemHeight;
    ypos += line*dg->dg_ItemHeight;

    GT_GetGadgetAttrs(dg->dg_Gadget,dg->dg_Window,NULL,GTLV_Labels,&dg->dg_List,TAG_END);
    if (dg->dg_List && !IsListEmpty(dg->dg_List))
    {
      GT_GetGadgetAttrs(dg->dg_Gadget,dg->dg_Window,NULL,GTLV_Top,&i,TAG_END);
      i += line;
      if (i < CountNodes(dg->dg_List))
      {
        struct Node *ln;

        dm.dm_SourceEntry = i;
        for(ln = dg->dg_List->lh_Head;i;i--,ln = ln->ln_Succ);

        if (dg->dg_Flags & DGF_TREEVIEW && TREENODE(ln)->tn_Flags & TNF_STATIC)
        {
          mx = ~0L;      // avoid a following drag
          return(NULL);
        }
        dg->dg_Object.od_Object = ln;

        if (dg->dg_ObjectFunc)
          dg->dg_ObjectFunc(dg->dg_Window,dg->dg_Gadget,&dg->dg_Object,dm.dm_SourceEntry);
      }
    }
  }
  else
  {
    if (dg->dg_ObjectFunc)
      dg->dg_ObjectFunc(dg->dg_Window,dg->dg_Gadget,&dg->dg_Object,0L);

    dm.dm_SourceEntry = dg->dg_SourceEntry;
    xpos = x-width/2;
    ypos = y-height/2;
  }
  if (!dg->dg_Object.od_Object)
  {
    mx = ~0L;        // avoid a following drag
    return(NULL);
  }
  wordwidth = (width + 15) >> 4;
  depth = GetBitMapAttr(rp->BitMap,BMA_DEPTH);

  if (dg->dg_Object.od_Object && (gdo = AllocMem(sizeof(struct DragObj), MEMF_CLEAR | MEMF_PUBLIC)))
  {
#ifdef LOCKLAYERS
    LockLayers(&scr->LayerInfo);
    UnlockLayer(dg->dg_Window->RPort->Layer);
#endif

    gdo->do_Screen = scr;
    gdo->do_ScrRPort = rp;

    gdo->do_BitMap = AllocBitMap(width,height,depth,BMF_CLEAR | BMF_MINPLANES,!(GetBitMapAttr( rp->BitMap, BMA_FLAGS ) & BMF_INTERLEAVED) ? rp->BitMap : NULL);
    gdo->do_SaveBack = AllocBitMap(width,height,depth,BMF_CLEAR | BMF_MINPLANES,rp->BitMap);
    gdo->do_RefreshMap = AllocBitMap(width*2,height*2,depth,BMF_CLEAR | BMF_MINPLANES,rp->BitMap);

    if (GetBitMapAttr(gdo->do_BitMap,BMA_FLAGS) & BMF_STANDARD)
      i = MEMF_CHIP | MEMF_PUBLIC;
    else
      i = 0;

    gdo->do_FullShadow = AllocMem(2*wordwidth*height,i | MEMF_CLEAR);
    gdo->do_HalfShadow = AllocMem(2*wordwidth*height,i);

    if (gdo->do_BitMap && gdo->do_SaveBack && gdo->do_RefreshMap && gdo->do_FullShadow && gdo->do_HalfShadow)
    {
      InitRastPort(&gdo->do_RPort);
      gdo->do_RPort.BitMap = gdo->do_BitMap;
      InitRastPort(&gdo->do_RefreshRPort);
      gdo->do_RefreshRPort.BitMap = gdo->do_RefreshMap;

      gdo->do_DragGadget = dg;
      CopyMem(&dg->dg_Object,&dm.dm_Object,sizeof(struct ObjectDescription));
      dm.dm_Window = dg->dg_Window;
      dm.dm_Gadget = dg->dg_Gadget;

      /*** create the drag&drop image ***/

      if (dg->dg_RenderHook)
      {
        struct LVDrawMsg lvdm;

        SetFont(&gdo->do_RPort,scr->RastPort.Font);
        lvdm.lvdm_MethodID = LV_DRAW;
        lvdm.lvdm_RastPort = &gdo->do_RPort;
        lvdm.lvdm_DrawInfo = GetScreenDrawInfo(scr);
        lvdm.lvdm_Bounds.MinX = 0;
        lvdm.lvdm_Bounds.MinY = 0;
        lvdm.lvdm_Bounds.MaxX = width-1;
        lvdm.lvdm_Bounds.MaxY = height-1;
        lvdm.lvdm_State = LVR_SELECTED;
        CallHookPkt(dg->dg_RenderHook,dm.dm_Object.od_Object,&lvdm);
        FreeScreenDrawInfo(scr,lvdm.lvdm_DrawInfo);
      }
      else if (dg->dg_Image)
        DrawImage(&gdo->do_RPort,dg->dg_Image,0,0);
      else
        ClipBlit(dg->dg_Window->RPort,xpos,ypos,&gdo->do_RPort,0,0,width,height,0xc0);

      /*** initialize drag object structure ***/

      gdo->do_X = -9999;
      gdo->do_Y = ypos+dg->dg_Window->TopEdge;
      gdo->do_PX = -9999;
      gdo->do_Width = width;
      gdo->do_Height = height;
      gdo->do_DeltaX = xpos-x+dg->dg_Window->LeftEdge;
      gdo->do_DeltaY = ypos-y+dg->dg_Window->TopEdge;
      gdo->do_Mask = gdo->do_FullShadow;

      /*** create masks (transparent and full imagery) ***/

      if (CyberGfxBase && (GetBitMapAttr(gdo->do_BitMap,BMA_FLAGS) & BMF_STANDARD) == 0L)
      {
        struct BitMap tbm;
        ULONG  col;

        InitBitMap(&tbm,1,width,height);
        tbm.Planes[0] = (UBYTE *)gdo->do_FullShadow;

        /* if (!GetCyberMapAttr(gdo->do_BitMap, CYBRMATTR_PIXELFMT)) */

        if (GetBitMapAttr(gdo->do_BitMap, BMA_DEPTH) > 8L)
        {
          ULONG triplet[3];

          GetRGB32(scr->ViewPort.ColorMap,0L,1L,triplet);
          col = (triplet[0] & 0xff0000) | (triplet[1] & 0xff00) | (triplet[2] & 0xff);
        }
        else
          col = 0;

        // ExtractColor(rp,&tbm,col,xpos,ypos,width,height);
        ExtractColor(&gdo->do_RPort,&tbm,col,0,0,width,height);

        BltBitMap(&tbm,0,0,&tbm,0,0,width,height,0x50,0xff,NULL);  // invertieren der Maske
      }
      else
      {
        UWORD *p = gdo->do_FullShadow;

        for(ypos = 0;ypos < height;ypos++)
        {
          for(xpos = 0;xpos < wordwidth;xpos++,p++)
          {
            for(i = 0;i < depth;i++)
              *p |= *((UWORD *)gdo->do_BitMap->Planes[i]+ypos*(gdo->do_BitMap->BytesPerRow >> 1)+xpos);
          }
        }
      }

      {
        UWORD *p = gdo->do_HalfShadow;

        CopyMem(gdo->do_FullShadow,p,2*wordwidth*height);
        for(line = 0x5555,ypos = 0;ypos < height;ypos++)
        {
          line = ~line;
          for(xpos = 0;xpos < wordwidth;xpos++,p++)
            *p &= (UWORD)line;
        }
      }

      if (!boopsigad)
        FakeInputEvent();
      UpdateDragObj(gdo,gdo->do_X,gdo->do_Y);    /* show drag object */

      return(gdo);
    }
示例#10
0
/// IdentifyPointerColors()
static void IdentifyPointerColors(Object *obj)
{
  int i;
  ULONG colors[3*3];
  LONG blackDiff[3];
  LONG whiteDiff[3];
  LONG blackIndex;
  LONG whiteIndex;

  ENTER();

  // get the current screen's pointer colors (17 to 19)
  GetRGB32(_window(obj)->WScreen->ViewPort.ColorMap, 17, 3, colors);

  for(i=0; i < 3; i++)
  {
    LONG dr;
    LONG dg;
    LONG db;

    // normalize the colors to 8 bit per gun as GetRGB32() returns
    // 32bit left aligned values
    colors[i*3+0] >>= 24;
    colors[i*3+1] >>= 24;
    colors[i*3+2] >>= 24;

    // calculate the geometric difference to the color black (=0x00000000)
    dr = 0x00000000 - colors[i*3+0];
    dg = 0x00000000 - colors[i*3+1];
    db = 0x00000000 - colors[i*3+2];
    blackDiff[i] = dr * dr + dg * dg + db * db;

    // calculate the geometric difference to the color white (=0x000000ff)
    dr = 0x000000ff - colors[i*3+0];
    dg = 0x000000ff - colors[i*3+1];
    db = 0x000000ff - colors[i*3+2];
    whiteDiff[i] = dr * dr + dg * dg + db * db;
  }

  // the smallest difference defines the color which is closest to black or
  // equal to black
  if(blackDiff[0] > blackDiff[1])
  {
    if(blackDiff[1] > blackDiff[2])
      blackIndex = 19;
    else
      blackIndex = 18;
  }
  else if(blackDiff[0] > blackDiff[2])
    blackIndex = 19;
  else
    blackIndex = 17;

  // the smallest difference defines the color which is closest to white or
  // equal to white
  if(whiteDiff[0] > whiteDiff[1])
  {
    if(whiteDiff[1] > whiteDiff[2])
      whiteIndex = 19;
    else
      whiteIndex = 18;
  }
  else if(whiteDiff[0] > whiteDiff[2])
    whiteIndex = 19;
  else
    whiteIndex = 17;

  // Here we expect the user to have set up quite "different" colors. That
  // means the color closest to white will never be close to black and vice
  // versa. According to these differences we spread the required bitplanes.
  if(whiteIndex == 17)
  {
    if(blackIndex == 18)
    {
      selectPointerBitmap.Planes[0] = (PLANEPTR)selectPointer_bp0;
      selectPointerBitmap.Planes[1] = (PLANEPTR)selectPointer_bp1;
    }
    else // blackIndex == 19
    {
      selectPointerBitmap.Planes[0] = (PLANEPTR)selectPointer_bp2;
      selectPointerBitmap.Planes[1] = (PLANEPTR)selectPointer_bp1;
    }
  }
  else if(whiteIndex == 18)
  {
    if(blackIndex == 17)
    {
      selectPointerBitmap.Planes[0] = (PLANEPTR)selectPointer_bp1;
      selectPointerBitmap.Planes[1] = (PLANEPTR)selectPointer_bp0;
    }
    else // blackIndex == 19
    {
      selectPointerBitmap.Planes[0] = (PLANEPTR)selectPointer_bp1;
      selectPointerBitmap.Planes[1] = (PLANEPTR)selectPointer_bp2;
    }
  }
  else // whiteIndex == 19
  {
    if(blackIndex == 17)
    {
      selectPointerBitmap.Planes[0] = (PLANEPTR)selectPointer_bp2;
      selectPointerBitmap.Planes[1] = (PLANEPTR)selectPointer_bp0;
    }
    else // blackIndex == 18
    {
      selectPointerBitmap.Planes[0] = (PLANEPTR)selectPointer_bp0;
      selectPointerBitmap.Planes[1] = (PLANEPTR)selectPointer_bp2;
    }
  }

  LEAVE();
}
示例#11
0
void main()
{
	ULONG class,code;
	struct Gadget *gadget;
	struct IntuiMessage *message;
	struct DrawInfo *dri;
	BOOL running=TRUE;

	unless(Scr=LockPubScreen("Workbench")) LEAVE;
	unless(dri=GetScreenDrawInfo(Scr)) LEAVE;
	unless(SmartBitMapBase=OpenLibrary("images/smartbitmap.image",36L)) LEAVE;
	unless(ImClass=GetSmartBitMapClass()) LEAVE;

	GetRGB32(Scr->ViewPort.ColorMap,0,1,&pal[0].R);

	unless(Im=NewObject(ImClass,NULL,
		IA_Left,25,
		IA_Top,25,
		IA_Width,20,
		SMBM_Border,FALSE,
		SMBM_SelBorder,TRUE,
		SMBM_Screen,Scr,
		SMBM_BitMap,&TBCOLORWHEELBitMap,
//		SMBM_BitMap,&Size45UDBitMap,
		SMBM_Palette,pal,
		TAG_DONE)) LEAVE;
	unless(MainWnd=OpenWindowTags(NULL,
		WA_Left,0,
		WA_Top,0,
		WA_Width,600,
		WA_Height,200,
		WA_IDCMP,IDCMP_CLOSEWINDOW|IDCMP_GADGETUP,
		WA_Flags,WFLG_CLOSEGADGET|WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_ACTIVATE|WFLG_SIZEGADGET,
		WA_CustomScreen,Scr,
		TAG_DONE)) LEAVE;

	DrawImageState(MainWnd->RPort,(struct Image *)Im,0,0,IDS_NORMAL,dri);

	while(running)
	{
		Wait(1L<<MainWnd->UserPort->mp_SigBit);
		while(message=GT_GetIMsg(MainWnd->UserPort))
		{
			class=message->Class;
			code=message->Code;
			gadget=(struct Gadget *)message->IAddress;
			GT_ReplyIMsg(message);
			switch(class)
			{
				case IDCMP_CLOSEWINDOW:
					running=FALSE;
					break;
			}
		}
	}
end:
	if(MainWnd)
	{
		CloseWindow(MainWnd);
	}
	if(Im) DisposeObject(Im);
	if(SmartBitMapBase) CloseLibrary(SmartBitMapBase);
	if(dri) FreeScreenDrawInfo(Scr,dri);
	if(Scr) UnlockPubScreen(NULL,Scr);
}