C++ clr函数代码示例

static void	draw_vertical(t_lst *a, t_lst *b, t_env *e)
{
	int		y;
	char	rev;

	rev = a->y_pix > b->y_pix ? 1 : 0;
	y = a->y_pix;
	while (y != b->y_pix)
	{
		mlx_pixel_put(e->mlx, e->win, a->x_pix, y, clr(a, b, e));
		rev ? y-- : y++;
	}
}

/* ------------- reset the MENUBAR -------------- */
static void reset_menubar(WINDOW wnd)
{
    ATTRCHR * cp = GetText(wnd) = DFrealloc(GetText(wnd), (SCREENWIDTH+5) * sizeof(ATTRCHR));
	int attr = clr(WndForeground(wnd), WndBackground(wnd));
	int i;
	for (i=0; i < SCREENWIDTH +5; i++)
	{
		cp->ch = ' ';
		cp->attrib = attr;
		cp++;
	}
    (GetText(wnd)+WindowWidth(wnd))->ch = '\0';
}

void init() {
	int i;
	if ((lcd_fd = open("/dev/dbox/lcd0",O_RDWR)) < 0) {
		perror("open(/dev/dbox/lcd0)");
		exit(1);
	}
	clr();

	i = LCD_MODE_BIN;
	if (ioctl(lcd_fd,LCD_IOCTL_ASC_MODE,&i) < 0) {
		perror("init(LCD_MODE_BIN)");
		exit(1);
	}
}

void GColorStatic::OnPaint() {

    CPaintDC paintdc(this);

    CDC * cdc = GetDC();
    if (cdc == NULL) {
//        logger.log("cdc null in GColorStatic::OnPaint()");
        return;
    }
    CRect rect;
    GetClientRect(rect);

	COLORREF clr(RGB(212,208,200));
	clr=RGB(170,170,170);



	COLORREF crblack = RGB(0,0,0);
	CBrush brush(crblack);
//	CGdiObject * oldbrush = cdc->SelectObject(brush);
	cdc->FrameRect(rect, &brush);
	rect.DeflateRect(1,1,1,1);
	cdc->FrameRect(rect, &brush);
	rect.DeflateRect(1,1,1,1);
	cdc->FrameRect(rect, &brush);
//	cdc->SelectObject(oldbrush);


	cdc->FillSolidRect( mRect.TopLeft().x, mRect.TopLeft().y,
		mRect.Width(), mRect.Height(), clr);


	ReleaseDC(cdc);



class CUseBrush {
	CGdiObject* m_OldBrush;
	CDC* m_pDC;
public:
	CUseBrush(CDC* pDC, CGdiObject * br) {
		m_pDC=pDC; 
		m_OldBrush=pDC->SelectObject(br);
	}
	~CUseBrush() {
		m_pDC->SelectObject(m_OldBrush);
	}
};

}

void init(int n)
{
        globalCnt=0;
        flagCycle=false;
        head=1;
        for(int i=0;i<=n;i++)
        {
            adj[i].clear();adj_shrink[i].clear();
            tarjan.clear();
        }
        clr(vis);clr(color);  clr(indeg);clr(outdeg);
        clr(low);clr(disc);clr(cycle);
}

void menuNewRaid(){
    clr();
    int n;
    printf("\n\tNueva Unidad RAID\n\n");
    printf("Ingrese la ruta de la nueva unidad\n");
    printf("raid-manager> ");
    char *path = readln(256);
    printf("\n %s Ruta Seleccionada!\nIngrese el tamaño de la nueva unidad (mb) \n",path);
    printf("Min: 2(mb) Max: 10(mb)\n");
    scanf("%i",&n);
    newraid(path,n);
    printf("\nPresione cualquier tecla para continuar...");
    readchar();
    
}

void ins() {
    int tmp, i, n;
    int h = 0;
    scanf("%d", &n);
    while(n--) {
        scanf("%d", &tmp);
        tmp--;
        if(node[h].next[tmp] == 0) {
            clr();
            node[h].next[tmp] = tot;
        }
        h = node[h].next[tmp];
    }
    node[h].id++;
}

void Eular()
{
	clr(check,false);
    totp = 0;
	for (int i = 2; i < N; i++)
	{
		if (!check[i]) prime[totp++] = i;
		for (int j = 0; j < totp; j++)
		{
			if (i * prime[j] >= N) break;
			check[i * prime[j]] = true;
			if (i % prime[j] == 0) break;
		}
	}
}

int main(int argc, char *argv[])
{
    screen_t screen;
    int x, y;
//	int D=atoi(argv[1]);
#define D	3
    // try other values
    pthread_t ut;
    init();

    memset(intensity, 0, LCD_ROWS*LCD_COLS*8);
    pthread_create(&ut, 0, update_thread, 0);

    for (y=0; y<65; y++)
    {
        for (x=0; x<120; x++)
            image[LCD_COLS*y+x]=0;
    }

    while (1)
    {
        int x, y, yy, pix;
        for (y=0; y<LCD_ROWS; y++) {
            for (x=0; x<LCD_COLS; x++) {
                pix = 0;
                for (yy=0; yy<8; yy++) {
                    int off=(8*y+(7-yy))*LCD_COLS+x;
                    int val, t=image[off];

                    if (intensity[off] < t)
                        val=1;
                    else
                        val=0;

                    pix = (pix<<1) + val;

                    intensity[off]=(intensity[off])*(256-D)/256;
                    intensity[off]+=val*D;
                }
                screen[y*LCD_COLS+x] = pix;
            }
        }

        draw_screen(screen);
    }
    clr();
    return 0;
}

void Graph::set_colorlines(const std::vector<std::string> &_colorlines) {
    this->colorlines = _colorlines;
    std::string delimiter = "#";
    for(std::vector<std::string>::const_iterator it = this->colorlines.begin();
        it != this->colorlines.end(); ++it) {

        std::string value = it->substr(0, it->find(delimiter));
        std::string rgb = it->substr(it->find(delimiter) + 1);

        this->colorline_values.push_back( str2float(value) );
        Color clr(hex2int(rgb.substr(0,2)),
                  hex2int(rgb.substr(2,2)),
                  hex2int(rgb.substr(4,2)) );
        this->colorline_colors.push_back(clr);
    }
}

int phi_table(int n){
    clr (check, 0); phi[1] = 1;
    int tot = 0;
    for (int i = 2; i <= n; ++ i){
        if (!check[i]) prm[ tot++ ] = i, phi[i] = i - 1;
        for (int j = 0; j < tot; j ++){
            if (i * prm[j] > n) break;
            check[ i*prm[j] ] = 1;
            if (i % prm[j] == 0){
                phi[ i*prm[j] ] = phi[i] * prm[j]; break;
            }
            else phi[ i*prm[j] ] = phi[i] * (prm[j] - 1);
        }
    }
    return tot;
}

int main(struct multiboot *mboot_ptr)
{
    int i, j;
    char ch = 'a';
//	initializegdt();
    clr ();
    // int a = 204800000;
    //asm volatile("mov %0, %%esp" : : "r" (a));
    // asm volatile("cli");
    initializegdt();
    initializeidt();
    DetectBios32Service();
    DetectPciBiosService();
    // InitializePaging();

    StrobePciDevices();
    //asm volatile("sti");
    // pci_scan();
    // StrobePciDevices();
    DetectNetworkDevices();
    asm volatile("sti");

    putch('\n');
//	asm volatile ("int $0x10");
//	asm volatile ("int $0x0");
//	asm volatile ("int $0x2");
//	asm volatile("sti");
//        while(1)
    {
        //    int  *pointer = (uint32 *)kmalloc(12000000);
        //      }
//        int *pointer = (uint32 *) 0x10000000;
        //      if( pointer )
        //				*pointer = 201;
        //		  else
        //			   puts("Failed to allocate");
        //         putint(*pointer);
//			 puts("unknown\n");
//          kfree(pointer);
    }
//        while(1);
//	clr();
//	test();
//	puts("rajnesh\n");
//	putint(12323);
    return 0xDEADBABA;
}

/////////////////////////////////////
// Purpose:	render texture as
//			billboard. Texture will be
//			displayed on GFXSceneRender
// Output:	scene added
// Return:	TRUE if success
/////////////////////////////////////
u32 IgfxTexture::BltBillboard(const Vec3D & center, f32 size, f32 rot, const Vec4D *pClr)
{
	//check for frustrum
	if(!FrustrumCheckCube(center.x, center.y, center.z, size))
		return TRUE;

	Matrix trans; MtxIdentity(&trans);

	if(rot != 0)
	{
		Matrix axisM; MtxAxisRotation(&g_txtDir, rot, &axisM);

		trans._11 = size*axisM._11;
		trans._21 = size*axisM._21;
		trans._31 = size*axisM._31;

		trans._12 = size*axisM._12;
		trans._22 = size*axisM._22;
		trans._32 = size*axisM._32;

		trans._13 = size*axisM._13;
		trans._23 = size*axisM._23;
		trans._33 = size*axisM._33;

		trans._14 = size*axisM._14;
		trans._24 = size*axisM._24;
		trans._34 = size*axisM._34;

		trans._41 = center.x; trans._42 = center.y; trans._43 = center.z;
	}
	else
	{
		trans._11 = size; trans._22 = size; trans._33 = size;
		trans._41 = center.x; trans._42 = center.y; trans._43 = center.z;
	}

	if(pClr)
		Blt3DEX(s_pTxtBBVtxBuff, GFXPT_TRIANGLEFAN, 4, 2, &trans, *pClr);
	else
	{
		Vec4D clr(1,1,1,1);
		Blt3DEX(s_pTxtBBVtxBuff, GFXPT_TRIANGLEFAN, 4, 2, &trans, clr);
	}

	return TRUE;
}

//-----------------------------------------------------------------------------
mglCanvas::mglCanvas(int w, int h) : mglBase()
{
	clr(MGL_DISABLE_SCALE);
	set(MGL_VECT_FRAME);	// NOTE: require a lot of memory!
	Z=0;	C=G=G4=GB=0;	OI=0;	gif=0;
	CurFrameId=0;	Delay=0.5;
	Width=Height=Depth=0;	ObjId=-1;
	fscl=ftet=0;		PlotId = "frame";
	pnt_col = 0;

	ac.ch='c';
	ax.dir = mglPoint(1,0,0);	ax.a = mglPoint(0,1,0);	ax.b = mglPoint(0,0,1);	ax.ch='x';
	ay.dir = mglPoint(0,1,0);	ay.a = mglPoint(1,0,0);	ay.b = mglPoint(0,0,1);	ay.ch='y';
	az.dir = mglPoint(0,0,1);	az.a = mglPoint(0,1,0);	az.b = mglPoint(1,0,0);	az.ch='z';

	SetSize(w,h);	SetQuality(MGL_DRAW_NORM);	DefaultPlotParam();
}

void dijkstra(int s) {
	priority_queue<PII, vector<PII>, greater<PII> > que;
	clr(dis, INF);
	dis[s] = 0;
	que.push(PII(0, s));
	while (!que.empty()) {
		PII p = que.top(); que.pop();
		int v = p.se;
		if (dis[v] < p.fi) continue;
		for (int i = head[v]; i != -1; i = e[i].next) {
			int u = e[i].to, cost = e[i].cost;
			if (dis[u] > dis[v] + cost) {
				dis[u] = dis[v] + cost;
				que.push(PII(dis[u], u));
			}
		}
	}
}