지나간 삶

#include "afxwin.h"

class CColorEdit :public CEdit
{
public:

    COLORREF m_clrText;    // 글자색
    COLORREF m_clrBkg;  // 글자 배경색
    CBrush   m_hbrBkg;    // 배경을 칠할 브러시

    void SetColor( COLORREF clrText, COLORREF clrBkg)
    {
        m_clrText = clrText;
        m_clrBkg  = clrBkg;

        if ( m_hbrBkg.m_hObject != 0 )
            m_hbrBkg.DeleteObject();

        m_hbrBkg.CreateSolidBrush( m_clrBkg);
    }

    // WM_CTLCOLOR
    HBRUSH CtlColor(CDC* pDC, UINT /*nCtlColor*/)
    {
        // 이제 부모가 반사해준 메세지를 처리한다.
        pDC->SetTextColor( m_clrText );
        pDC->SetBkColor(  m_clrBkg);

        // 배경을 칠할 브러시를 리턴한다.
        return (HBRUSH)m_hbrBkg.m_hObject;
    }
};

#include "afxwin.h"

struct LISTDATA
{
    HICON hIcon;
    CString text;
};

#include <vector>
using std::vector;

class CIconListBox : public CListBox
{
public:
    vector<LISTDATA> m_vector;
   
    void AddItem( HICON hIcon, CString text )
    {
        LISTDATA data = { hIcon, text };
        m_vector.push_back( data );

        // 일단 빈문자열로 채워 둔다.
        int index = AddString("");

        static int id = 0;
        SetItemData( index, id );
    }

    void DrawItem(LPDRAWITEMSTRUCT p)
    {
        // 항목을 그린다.
        HDC hdc = p->hDC;

        CRect rc( p->rcItem );

        // 이제 그린다. m_vector의 내용으로
        int id = (int)p->itemID;

        HICON hIcon = m_vector[id].hIcon;
        CString text = m_vector[id].text;

        DrawIcon( hdc, rc.left, rc.top, hIcon );
        TextOut( hdc, rc.left + 35, rc.top, text, text.GetLength() );
    }

    void MeasureItem(LPMEASUREITEMSTRUCT p)
    {
        p->itemHeight = 32;
    }
};

#include "afxext.h"

class CMyStatusBar : public CStatusBar
{
public:
    // 프로그레스가 들어갈 pane의 ID
    UINT m_index; 

    CProgressCtrl m_wndProgress;

    void OnSize(UINT nType, int cx, int cy)
    {
        CStatusBar::OnSize(nType, cx, cy);

        // 프로그레스바가 만들어 지면 실행하도록 조건을 건다.
        if( m_wndProgress.GetSafeHwnd() )
        {
            CRect rc;
            GetItemRect( m_index, &rc );
            m_wndProgress.MoveWindow( rc );
        }
    }

    void CreateProgress( UINT index, int width )
    {
        int w;
        UINT id, style;

        m_index = index;

        // id pane 의 정보를 구한다.
        GetPaneInfo( index, id, style, w );
        // 이제 너비만 변경한다.
        SetPaneInfo( index, id, style, width );

        // 이제 해당 id pane의 정확한 크기를 구한다.
        CRect rc(0, 0, 0, 0);
        GetItemRect( index, &rc );

        // 이제 프로그래스를 만든다.
        m_wndProgress.Create( WS_CHILD | WS_VISIBLE | PBS_SMOOTH, rc,
            this, 2001 );
        m_wndProgress.SetRange( 0, 100 );
        m_wndProgress.SetPos(55);
    }

#include <stdio.h>
#include <time.h>
#include <windows.h>
struct task_struct
{
    int pid;
    struct task_struct *pidhash_next;
    struct task_struct **pidhash_pprev;
};

#define PIDHASH_SZ  16
#define pid_hashfn(x)   ((((x) >> 8) ^ (x)) & (PIDHASH_SZ - 1))

struct task_struct *pidhash[PIDHASH_SZ];


void hash_pid(struct task_struct *p)
{
    struct task_struct **htable = &pidhash[pid_hashfn(p->pid)]; if((p->pidhash_next = *htable) != NULL)
        (*htable)->pidhash_pprev = &p->pidhash_next;
    *htable = p;
    p->pidhash_pprev = htable;
}

void unhash_pid(struct task_struct *p)
{
    if(p->pidhash_next)
        p->pidhash_next->pidhash_pprev = p->pidhash_pprev;
    *p->pidhash_pprev = p->pidhash_next;
}


struct task_struct *find_task_by_pid(int pid)
{
    struct task_struct *p, **htable = &pidhash[pid_hashfn(pid)];

    for(p = *htable; p && p->pid != pid; p = p->pidhash_next)
        ;

    return p;
}

void display()
{
    int i;
    struct task_struct *p;

    system("cls");                                          
    for(i =0 ; i < PIDHASH_SZ; i++ )
    {
        printf("[%2d]", i);
        for(p = pidhash[i]; p; p = p->pidhash_next)
            printf("<->[%4d]", p->pid);
        printf("\n");
    }
}

int main()
{

    int temp,i;
    struct task_struct *task;
    srand((unsigned int)time(0));
    display();
    for(i=0; i<30; i++ )
    {
        getchar();
        while( temp = rand())
        {
            if( !find_task_by_pid( temp ))
                break;
        }
        task = (struct task_struct*)malloc(sizeof(struct task_struct));
        task->pid = temp;
        hash_pid( task);
        display();
    }
}

#include <stdio.h>

struct list_head
{
    struct list_head *next;
    struct list_head *prev;
};

typedef struct
{
    int count;
    int pid;
    struct list_head list;
} TASK;

void __list_add(struct list_head *new,
struct list_head *prev,
struct list_head *next)
{
    next->prev = new;
    new->next = next;
    new->prev = prev;
    prev->next = new;
}

void list_add(struct list_head *new, struct list_head *head)
{
    __list_add(new, head, head->next);
}

#define  list_entry( temp, type, list ) \
    ((type *)( (char*)temp - (unsigned long)(&((type *)0)->list)))

#define list_for_each(pos, head) \
    for (pos = (head)->next; pos != (head); pos = pos->next )

#define LIST_HEAD_INIT(name) { &(name), &(name) }

#define LIST_HEAD(name) \
struct list_head name = LIST_HEAD_INIT(name)

int main()
{
    struct list_head *temp;
    LIST_HEAD(head);

    TASK  t1 = { 1, 1000, 0, 0 };
    TASK  t2 = { 2, 2000, 0, 0 };
    TASK *p;

    list_add ( &t1.list, &head );
    list_add ( &t2.list, &head );

    printf("[head]");
    list_for_each( temp, &head )
    {
        p = list_entry( temp, TASK, list );
        printf("->[%4d, %4d]",p->count, p->pid);
    }
    printf("\n");
    return 0;
}