敏捷軟體學院 : 教學資源網

crecord

2011-06-20T00:32:00.001-07:00

class crecord extends crecord_NullObject {

    var $model;
    var $table;
    var $row;

    var $id;

    function crecord()
    {
        $this->model = NULL;
        $this->table = "";

        $this->_common_init();
    }

    function _common_init( $id = NULL )
    {
        $this->row = NULL;
        $this->id = $id;

        if( $id != NULL )
            $this->load($id);
    }

    function init( &$model , $table, $id = NULL)
    {
        $this->model = &$model;
        $this->table = $table;

        $this->_common_table();
        $this->load($id);
    }

    function equal($record)
    {
        foreach($record->row as $key => $value)
        {

            if( $this->getField($key) != $value )
                    return false;
        }
        return true;
    }


    function reuse($id = NULL)
    {
        $this->_common_init($id);
    }

    function loadlast( $key = null , $value = null)
    {
        $id = $this->model->select_max('id', $key, $value);
        $this->load($id);
    }


    function _common_table()
    {
        $this->model->init($this->table);
    }

    function load($id = NULL)
    {
         return $this->loadwithfield("id", $id);
    }

    function loadwithfield($field, $value)
    {
        $this->_common_table();
        $this->reuse();

        if( $field == NULL || $value == NULL )
            return;

        $row = $this->model->select_field_row($field,$value);

        return $this->_init_load_field($row);

    }

    function _init_load_field($row)
    {
        if( $row == NULL )
        {
            $this->id = NULL;
            return;
        }

        $this->id = $row->id;
        $this->setrow($row);

        return $this->row;
    }

    function load2($field ='id',$value=NULL)
    {
        return $this->loadwithfield($field, $value);

    }

    function is_update()
    {
        return $this->id != NULL;
    }

    function save()
    {
        if( $this->row == NULL )
            return;

        $this->_common_table();
        if( $this->id == NULL )
        {
           $this->id = $this->model->insert($this->row);
           return $this->id;
        }
        else
        {
           $this->model->update($this->id, $this->row);
           return $this->id;
        }

    }

    function delete($id = null)
    {
        $this->_common_table();


        if( $id != null )
            $this->load($id);

        if( $this->id == NULL )
            return;

        $this->model->delete($this->id);
        return $this->id;
    }

    function getField($field)
    {
        if( $field == "id" )
        {
            return $this->id;
        }

        switch( gettype($this->row) )
        {
            case "array":
                return $this->row[$field];

            case "object":
            {
                if( isset($this->row->$field) )
                    return $this->row->$field;
            }

            default:
                return;
        }

        if( is_object($this->row))
                return $this->row->$field;

        if( is_array($this->row))
                return $this->row[$field];
    }


    function setField($field, $value)
    {
        $type = gettype($this->row);
        switch( $type)
        {
            case "array":
                return $this->row[$field] = $value;
            case "object":
            default:
                return $this->row->$field = $value;
        }
    }

    function getrow()
    {
        $row = $this->row;
        if( $row != NULL )
            $row->id = $this->id;
        return $row;
    }

    function setrow($row)
    {
        $this->_tranArr2Obj ($row);
    }

    function _tranArr2Obj($array_row)
    {
        foreach($array_row as $key => $value )
        {
            if( $key == "id" )
                continue;
            $this->setField($key, $value);
        }
    }

    function create_owner()
    {
        return new crecord;
    }

    function isNull()
    {
        return "FALSE";
    }
    
}

mymodel_db

2011-06-20T00:19:00.000-07:00

class mymodel_db extends model{

    var $table;

    function mymodel_db(){
        parent::model();

        $this->table = "";
    }

    function init($table)
    {
        $this->table = $table;
    }

    function select($id)
    {
        $row = $this->select_field_row("id", $id);
        return $row;
    }

    function select_query($field, $value)
    {
        $this->db->flush_cache();
        $this->db->where($field , $value);
        
        $query = $this->db->get($this->table);
        return $query;

    }


    function select_field_row($field, $value)
    {
        $query = $this->select_query($field, $value);
        return $query->row();

    }


    function select2($field,$value)
    {

        return $this->select_field_row($field, $value);
    }

    function delete($id){
        $this->db->flush_cache();
        $this->db->where("id",$id);
        $this->db->delete($this->table);

    }

    function insert($row)
    {
        $this->db->flush_cache();
        $this->db->insert($this->table,$row);
        $id = $this->db->insert_id();

        return $id;

    }

    function update($id, $row)
    {
        $this->db->flush_cache();
        $this->db->where("id",$id);
        $this->db->update($this->table,$row);
    }

    function selectall()
    {
        $this->db->flush_cache();
        $query = $this->db->get($this->table);
        return $query;
    }

    function select_all_idTOarr()
    {
        $id_arr = array();
        $this->db->flush_cache();
        $query = $this->db->get($this->table);
        foreach($query->result() as $row)
        {
            $id_arr[] = $row->id;
        }
        return $id_arr;
    }

    function like_query($field, $value)
    {
        $this->db->flush_cache();
        $this->db->like($field , $value);
        $query = $this->db->get($this->table);
        return $query;
    }

    function list_fields()
    {
        $result = $this->db->list_fields($this->table);
        return $result;
    }
}

cweb_grid

2011-05-19T18:35:00.001-07:00

class cweb_grid {

    var $column_obj; // 欄位
    var $item_arr; // 項目列
    var $param; // 參數列

    function cweb_grid()
    {

        $this->column_obj = new empty_object;
        $this->item_arr = array();
        $this->param = array();
        
    }


    function _pre_html()
    {
        $param_str = "";
        foreach($this->param as $key => $value )
        {
            $param_str .= " {$key}=\"{$value}\" ";
        }

        $result = "<table " . $param_str . " >";

        return $result;

    }

    function _after_html()
    {
        return "</table>";
    }

    function _arr2obj($row)
    {
        return $row;
    }

    function _proc_row($row)
    {
        $result = "";
        foreach($this->column_obj as $key => $value)
        {
            if( !isset($row->$key) )
                $result .= "<td ></td>";
            else
                $result .= "<td >{$row->$key}</td>";
        }

        $result = "<tr> {$result} </tr>";

        return $result;

    }

    function _proc_column()
    {
        return $this->_proc_row($this->column_obj);

    }

    function _proc_item()
    {

        $result = "";
        foreach($this->item_arr as $item)
        {
            $result .= $this->_proc_row($item);
        }

        return $result;
    }

    function insert_column($key, $text)
    {
        $this->column_obj->$key = $text;
    }

    function insert_item($row)
    {

        $obj = $this->_arr2obj($row);
        $this->item_arr[] = $obj;

    }

    function add_param($key, $value)
    {
        $this->param[$key] = $value;
    }

    function outHtml()
    {
        $result = "";
        
        $result .= $this->_pre_html();

        $result .= $this->_proc_column();

        $result .= $this->_proc_item();

        $result .= $this->_after_html();

        return $result;
    }

}

cweb_link

2011-05-18T21:39:00.001-07:00

class cweb_link
{
    var $id;
    var $url;
    var $text;
    var $display;
    function cweb_link($id = "")
    {
        $this->id = $id;
        $this->url = null;
        $this->text = null;
        $this->display = null;
    }

    function insert($url=null,$text=null,$display=true)
    {
        if($url == null || $text == null)
            return;
        $this->url = $url;
        $this->text = $text;
        $this->display = $display;
    }

    function outHtml()
    {
        if($this->display==false)
            return "";

        $html = "<a id='{$this->id}' href='{$this->url}'>{$this->text}</a>";
        if($this->id == "")
            $html = "<a href='{$this->url}'>{$this->text}</a>";
        
        return $html;
    }
}

cweb_select

2011-05-17T04:11:00.000-07:00


class cweb_select {
    //put your code here

    var $name;
    var $option;
    var $selected;

    function cweb_select($name = "")
    {
        $this->option = array();
        $this->selected = null;
        $this->name = $name;
    }

    function insert($row /*array or object*/ )
    {
        foreach ($row as $key => $value )
        {
            $this->insertItem($key, $value);
        }
    }

    function insert_only_value($row /*array or object*/ )
    {
        foreach ($row as $value )
        {
            $this->insertItem($value, $value);
        }
    }

    function insertItem($value , $text)
    {
        $this->option[$value] = $text;
    }

    function selected($value)
    {
        $this->selected = $value;
    }

    function getText($value)
    {
        return $this->option[$value];
    }

    function outHtml()
    {
        $result = "";


        foreach( $this->option as $value => $text )
        {
            $selected = "";
            if( $this->selected == $value)
                $selected = " selected";

            $result .= "<option value='{$value}'{$selected}>{$text}</option>";
        }

        $result = "<select name='{$this->name}' >{$result}</select>";

        return $result;
    }
}

Non-Virtual Interface (NVI)

2010-05-31T00:41:00.000-07:00

class IuGUI : public IuUnknown
{

public:
    void OnDraw(HDC hDC)
    {
        this->OnOwnerDraw(hDC);
    }

private:
    virtual void OnOwnerDraw(HDC hDC) = 0;

};

class CuGUI :
    public IuGUI
{
public:
    CuGUI(void);
    ~CuGUI(void);

    virtual ULONG Release() 
    { 
        delete this;
        return 0;
    }

private:
    virtual void OnOwnerDraw(HDC hDC);
};

how to using CriticalSection

2010-05-24T19:55:00.000-07:00

struct CParam
{
    BOOL bActive;
    int nCount;
    CCriticalSection CriticalSection;

    CParam();
};

CParam::CParam()
:bActive(TRUE)
,nCount(0)
{

}

DWORD WINAPI MyThread(LPVOID lpParameter)
{
    CParam *pParam;
    pParam = (CParam*)lpParameter;
    pParam->bActive = TRUE;

    while(1)
    {
        pParam->CriticalSection.Enter();
        ++pParam->nCount;
        pParam->CriticalSection.Leave();
        Sleep(1);
    }

    pParam->bActive = FALSE;

    ExitThread(0);
}



void InitThread()
{
    HANDLE hThread;
    DWORD ThreadId;

    CParam param;
    hThread = CreateThread(NULL, 0, 
        (LPTHREAD_START_ROUTINE)MyThread, (void*)¶m, 0, &ThreadId);

    while(param.bActive == TRUE)
    {
        param.CriticalSection.Enter();
        Sleep(100);
        cout << param.nCount << "\n";
        param.CriticalSection.Leave();
        
    }

    CloseHandle(hThread);
}


int _tmain(int argc, _TCHAR* argv[])
{
    InitThread();
    return 0;
}

define SaveToSQL interface

2010-05-24T01:07:00.000-07:00


class ISaveToSQL {
    function GetField()
    {
        echo "hi... go back to study PHP 3 year!";
    }
}

class cucustom extends ISaveToSQL{
    ....

    function GetField()
    {
        $this->field["name"] = $this->name;
        $this->field["tel"] = $this->tel;
        $this->field["address"] = $this->address;

        return $this->field;
    }
}

class CuModelSave extends model
{
    function insertSaveToSQL(/*ISaveToSQL*/ $ISaveToSQL)
    {
        $this->db->insert($this->table_name, $ISaveToSQL->GetField());
    }
}


class custom_sql extends CuModelSave{
    ...
}

Prototype Pattern -- Load User Define Library

2010-05-16T18:43:00.000-07:00

function testUnit_CreateCustom()
    {
        $Custom = $this->cucustom->MyClone();
        echo $this->unit->run($Custom != NULL, "is_TRUE", "Create Custom");
        
        if( $Custom == NULL )
            return;
        
        $Custom->Init("Eric", "1234567", "高興路");
        echo $this->unit->run($Custom->name, "Eric", "name");
        echo $this->unit->run($Custom->tel, "1234567", "tel");
        echo $this->unit->run($Custom->address, "高興路", "address");
        
    }

class cucustom {

    var $name;
    var $tel;
    var $address;

    function cucustom($name = "", $tel = "", $address = "")
    {
        $this->Init($name, $tel, $address);
    }

    function MyClone()
    {
        return new cucustom;
    }

    function Init($name = "", $tel = "", $address = "")
    {
        $this->name = $name;
        $this->tel = $tel;
        $this->address = $address;
    }
}

Create General Object From DLL.

2010-05-12T22:09:00.000-07:00

// the GUI is a GUI.DLL

// GUI.h


typedef IuGUI* (*LPFN_CREATEGUI)(void);

GUI_API IuGUI* CreateObject(void);

GUI_API IuGUI* CreateObject(void)
{
    return new CuGUI;
}

// CuGUI

class CuGUI :
    public IuGUI
{
public:
    CuGUI(void);
    ~CuGUI(void);

     virtual ULONG Release() 
     { 
        delete this;
        return 0;
     }

    virtual void OnDraw(HDC hDC);
};

// CGUILoadTest

void CGUILoadTest::testDllCreateObject(void)
{

    LPFN_CREATEGUI lpfnCreateGUI = NULL;

    CuDllManager dllGUI;
    BOOL bResult = dllGUI.LoadLibrary(TEXT("GUI.dll"));
    CPPUNIT_ASSERT( bResult != NULL );

    lpfnCreateGUI = (LPFN_CREATEGUI)dllGUI.GetProcAddress(("CreateObject"));
    CPPUNIT_ASSERT( lpfnCreateGUI != NULL );

    IuGUI *pIuGUI = NULL;

    if( lpfnCreateGUI != NULL )
        pIuGUI = lpfnCreateGUI();

    CPPUNIT_ASSERT( pIuGUI != NULL );

    if( pIuGUI != NULL )
        pIuGUI->Release();

}

filedrive - file upload download

2010-05-02T16:20:00.000-07:00


class filedrive extends controller{

    function filedrive()
    {
        parent::controller();
        $this->load->model('filedrive_model','FileDrive',true);
        $this->load->library("cudownload");
        $this->load->library("cuupload");
        $this->culogin->onlogin();
    }

    function index($id="")
    {
        $data["downloadlist"] = "";
        if (empty($id))
                $query = $this->FileDrive->file_query();
        else
                $query = $this->FileDrive->tags_like($id);

        foreach($query->result() as $row){
                $filelist["row"] = $row;
                $data["downloadlist"] .= $this->load->view("downloadlist",$filelist,true);
        }
        $dnTable = $this->load->view("downloadtable",$data,true);
        $viewData["body"] = $dnTable;
        $this->_MainFrame($viewData);
    }

    function upload_form(){
        $tags = $this->FileDrive->get_tags();
        $upForm = array("error"=>"");
        $upForm["active_url"] = "filedrive/upload";
        $upLoadform = $this->cuciload->view("upload_form",$upForm,true);
        $tags = $this->cuciload->view("tags",array("tags"=>$tags,),true);
        $backpage = $this->cuciload->view("backpage",array("goback" => "filedrive"),true);
        $viewData["body"] = $backpage.$upLoadform.$tags;
        $this->_MainFrame($viewData);
    }

    function update_form($id){
        $data["row"] = $this->FileDrive->select_file($id);
        $viewData["body"] = $this->load->view("update_form",$data,true).$this->file_tags();
        $this->_MainFrame($viewData);
    }

    function delete_form($id){
        $data["row"] = $this->FileDrive->select_file($id);
        $viewData["body"] = $this->load->view("delete_form",$data,true);
        $this->_MainFrame($viewData);
    }
    
    function file_tags(){
        $tags = $this->FileDrive->get_tags();
        return $this->cuciload->view("tags",array("tags"=>$tags,),true);
    }

    function update($id){
        $this->FileDrive->update($id);
        redirect("filedrive","location");
    }

    function delete($id){
        $row = $this->FileDrive->select_file($id);
        $this->FileDrive->delete_file($id);
        unlink("./uploads/".$row->file_name.$row->file_ext);
        redirect("filedrive","location");
    }


    function IsUpload($result){
        $data = $this->upload->data();
        $data["true_name"] = $result["true_name"];
        $data["file_date"] = date("Y-m-d");
        $data["file_time"] = date("H:i:s");
        $data["file_tag"] = $this->FileDrive->write_sql($data);
        $data["is_img"]= lang("NO")."</li>";
        if($data["is_image"])
        {
            $data["is_img"] = $this->load->view("is_image",$data,true);
        }

        return $data;
    }

    function Upload()
    {
        if ( empty($_FILES["userfile"]["name"]) )
                redirect("filedrive/upload_form", "location");
        $result = $this->FileDrive->filename();

        $this->cuupload->InitUploadLib_($result["file_name"]);

        if ( ! $this->upload->do_upload())
        {
            $data["body"] = $this->upload->display_errors()."<br>".anchor("filedrive","return file upload!");
        }
        else
        {
            $susess_data = $this->IsUpload($result);
            redirect("filedrive","location");
        }
        $this->_MainFrame($data);
    }

    function _MainFrame($frame)
    {
        $data = $this->_Tag_List();
        $frame["leftmenu"] = $this->load->view("leftmenu",$data,true);
        $frame["submenu"] = $this->load->view("submenu","",true);
        $this->csmainframe->view($frame);
    }

    function _Tag_List(){
        $tags = array();
        $query =$this->FileDrive->get_tags();

        foreach($query->result() as $row){
                $number = $this->FileDrive->count_tags_like($row->id);
                $tags[] = anchor("filedrive/index/".$row->id, $row->tags . " ( ".$number ." ) ");
        }

        $query_all = $this->FileDrive->tags_like("");
        $data["all_num"] = $query_all->num_rows();

        $notags_num = $this->FileDrive->tags_like("null");
        $data["notags_num"] = $notags_num->num_rows();
        $data["tag"] = $tags;
        return $data;
    }

    function download($id){
        $result = $this->FileDrive->download($id);
        $this->cudownload->DownLoadEx($result, "./uploads/");
    }

}

login extends controller

2010-04-22T16:16:00.001-07:00

class login extends controller{

    function login()
    {
        parent::controller();
    }

    function index()
    {
        $this->load->view("login");
    }

    function chklogin()
    {
        $this->culogin->login($_POST["account"],$_POST["password"]);
        $this->culogin->islogin();
    }

    function logout(){
        $this->session->unset_userdata("login");
        redirect("main","location");
    }
}

CuLogin -- Login base on CodeIgniter Library

2010-04-21T17:50:00.001-07:00


class CuLogin {

    function CuLogin()
    {
        $this->Login_Information();
    }

    function Login_Information(){
        $this->login_account = "useric";
        $this->login_password = "password";
    }

    function chk_login($account,$password){
        if (($account == $this->login_account) && ($password == $this->login_password))
            return true;
        return false;
    }

    function login($account = "",$password = ""){
        $CI = &get_instance();
        $CI->session->set_userdata("login",$this->chk_login($account,$password));
    }

    function islogin(){
        $CI = &get_instance();
        if ($CI->session->userdata("login"))
            redirect("bulletin","location");
        redirect("login","location");
    }

    function onlogin(){
        $CI = &get_instance();
        if (!$CI->session->userdata("login"))
            redirect("main","location");
    }


}

weblink -- view

2010-04-16T00:06:00.000-07:00

# delete_form.php

<a href="javascript:history.go(-1)"><?=lang("BACK")?></a> <?=anchor("weblink/delete_link/".$row->id,lang("DELETE"))?>
<table>
    <tr>
        <td><?=lang("LINK").lang("DESCRIPTION")?></td>
        <td><?=$row->link_des?></td>
    </tr>
    <tr>
        <td><?=lang("LINK").lang("WEB")?></td>
        <td>http://<?=$row->weblink?></td>
    </tr>
</table>

# edit_form.php

<?=form_open("weblink/{$action}")?>
<table>
    <tr>
        <td><?=lang("LINK").lang("DESCRIPTION")?></td>
        <td><input type="text" name="link_des" size="40" maxlength="64" value="<?=$row->link_des?>" /></td>
    </tr>
    <tr>
        <td><?=lang("LINK").lang("WEB")?></td>
        <td>http://<input type="text" name="weblink" size="40" maxlength="256" value="<?=$row->weblink?>" /></td>
    </tr>
    <tr>
        <td colspan="2" align="center"><input type="submit" value="<?=lang("SUBMIT")?>"></td>
    </tr>
</table>
</form>

# showlink.php

<table border="1">
    <tr>
        <td width="150"><?=lang("LINK").lang("DESCRIPTION")?></td>
        <td width="250"><?=lang("LINK").lang("WEB")?></td>
        <td width="50"><?=lang("EDIT")?></td>
    </tr>
    <?php foreach($query->result() as $row):?>
    <tr>
        <td><?=anchor_popup("http://".$row->weblink,$row->link_des,$atts)?></td>
        <td>http://<?=$row->weblink?></td>
        <td><?=anchor("weblink/edit_form/".$row->id,lang("EDIT"))?> <?=anchor("weblink/delete_form/".$row->id,lang("DELETE"))?></td>
    </tr>
    <?php endforeach;?>
</table>

# submenu.php

<table border="0">
    <tr>
        <td><?=anchor("weblink",lang("VIEW").lang("LINK"))?></td>
        <td><?=anchor("weblink/insert_link_form",lang("INSERT").lang("LINK"))?></td>
    </tr>
</table>

weblink_sql -- model

2010-04-15T00:57:00.000-07:00


class weblink_sql extends model{

    function weblink_sql()
    {
        parent::model();
        $database_table = $this->config->item("database_table_name");
        $this->table_name = $database_table."weblink";
    }

    function load_post()
    {
        return array(
            "link_des" => $_POST["link_des"],
            "weblink" => $_POST["weblink"]
        );
    }

    function select($id = ""){
        if($id != "")
            return $this->db->get_where($this->table_name,array("id"=>$id));
        $this->db->order_by("id","desc");
        return $this->db->get($this->table_name);

    }

    function insert()
    {
        $this->db->insert($this->table_name,$this->load_post());
    }

    function update($id)
    {
        $this->db->where("id",$id);
        $this->db->update($this->table_name,$this->load_post());
    }

    function delete($id){
        $this->db->where("id",$id);
        $this->db->delete($this->table_name);
    }

}

weblink - modify web link

2010-04-12T01:00:00.001-07:00

class weblink extends controller{

    function weblink()
    {
        parent::controller();
        $this->culogin->onlogin();
        $this->load->model("weblink_sql","WLINK",TRUE);
    }

    function index()
    {
        $data["atts"] = array("width" => "1024");
        $data["query"] = $this->WLINK->select();
        $frame["body"] = $this->load->view("showlink",$data,TRUE);
        $this->_MainFrame($frame);
    }

    function insert_link_form(){
        $data["row"] = array();
        $data["action"] = "insert_link";
        $frame["body"] = $this->load->view("edit_form",$data,TRUE);
        $this->_MainFrame($frame);
    }

    function edit_form($id){
        $query = $this->WLINK->select($id);
        $data["action"] = "update_link/".$id;
        $data["row"] = $query->row();
        $frame["body"] = $this->load->view("edit_form",$data,TRUE);
        $this->_MainFrame($frame);
    }

    function delete_form($id){
        $query = $this->WLINK->select($id);
        $data["row"] = $query->row();
        $frame["body"] = $this->load->view("delete_form",$data,TRUE);
        $this->_MainFrame($frame);
    }

    function insert_link(){
        $this->WLINK->insert();
        $this->_Redirect();
    }

    function update_link($id){
        $this->WLINK->update($id);
        $this->_Redirect();
    }

    function delete_link($id){
        $this->WLINK->delete($id);
        $this->_Redirect();
    }

    function _Redirect(){
        redirect("weblink","location");
    }

    function _MainFrame($frame = ""){
        $frame["submenu"] = $this->load->view("submenu","",TRUE);
        $frame["leftmenu"] ="";
        $this->cuciload->view("mainframework",$frame);
    }
}

CuGLES

2010-02-24T15:00:00.000-08:00


class CuGLES : public CuEGL  
{

public:
    void Ortho(double left, double right, double bottom, double top, double Near, double Far);
    void Frustum( double fovy, double aspect, double zNear, double zFar );
    void Viewport(int x, int y, int width, int height);
#if 0
    void DrawArrays(const void *pvlist, const void *pnvlist, const void *ptclist,int stride, int numvertices);
    void DrawElements(const void *pvlist, const void *pnvlist, const void *ptclist,int stride, int numvertices,
        const void *pfaceindex, int numfaceindex);
#endif
    
    CuGLES();
    virtual ~CuGLES();

};



CuGLES::CuGLES()
{

}

CuGLES::~CuGLES()
{

}

#if 0
void CuGLES::DrawArrays(const void *pvlist, const void *pnvlist, const void *ptclist, int stride, int numvertices)
{

    glTexCoordPointer(2, GL_FIXED, stride, ptclist);
    // setup client states
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);    // setup arrays
    // first the vertices
    glVertexPointer(3, GL_FIXED , stride, pvlist);
    glEnableClientState(GL_VERTEX_ARRAY);


    // next the normals
//  glNormalPointer(GL_SHORT, stride, pnvlist);
    glNormalPointer(GL_FIXED , stride, pnvlist);
    glEnableClientState(GL_NORMAL_ARRAY);

    glDrawArrays(GL_TRIANGLES , 0, numvertices);


    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_NORMAL_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);

}


void CuGLES::DrawElements(const void *pvlist, const void *pnvlist, const void *ptclist,int stride, int numvertices,
    const void *pfaceindex, int numfaceindex)
{

    glTexCoordPointer(2, GL_FIXED, stride, ptclist);
    // setup client states
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);


    // setup arrays
    // first the vertices
    glVertexPointer(3, GL_FIXED , stride, pvlist);
    glEnableClientState(GL_VERTEX_ARRAY);


    // next the normals
    glNormalPointer(GL_FIXED , stride, pnvlist);
    glEnableClientState(GL_NORMAL_ARRAY);

    glDrawElements(GL_TRIANGLES , numfaceindex, GL_UNSIGNED_BYTE , pfaceindex);


    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_NORMAL_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);

}
#endif

void CuGLES::Viewport(int x, int y, int width, int height)
{
    glViewport(x,y,width,height);
}

#define PI_     3.14159265358979323846
void CuGLES::Frustum(double fovy, double aspect, double zNear, double zFar)
{
    // 設定投影
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    float right, left, top, bottom;
    top = zNear * tan(fovy * PI_ / 180.0 / 2 );
    bottom = -top;
    right = top * aspect;
    left = -right;

    glFrustumx(EGL_FixedFromFloat(left), EGL_FixedFromFloat(right),
        EGL_FixedFromFloat(bottom), EGL_FixedFromFloat(top),
        EGL_FixedFromFloat(zNear), EGL_FixedFromFloat(zFar) );

}

void CuGLES::Ortho(double left, double right, double bottom, double top, double Near, double Far)
{

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrthox(
        EGL_FixedFromFloat(left),
        EGL_FixedFromFloat(right),
        EGL_FixedFromFloat(bottom), 
        EGL_FixedFromFloat(top), 
        EGL_FixedFromFloat(Near), 
        EGL_FixedFromFloat(Far));

}

完全不了解為什麼要繼承, 想不起來.

CuEGL

2010-02-23T15:00:00.000-08:00

class CuEGL  
{

    int _red_size;
    int _green_size;
    int _bule_size;
    int _alpha_size;

public:

    // 
    void SwapBuffers();


    // 只要有呼叫 Init() 做初始化 就要呼叫 Exit() 
    // 在這裡 解構會自動呼叫
    void Exit();

    // 初始化 EGL
    // Return:  1 有問題初始化失敗   0: 一切正常
    bool Init(NativeWindowType hWnd);

    CuEGL();
    virtual ~CuEGL();

    EGLDisplay  _eglDisplay;
    EGLConfig   _eglConfig;
    EGLSurface  _eglSurface;
    EGLContext  _eglContext;



};

CuEGL::CuEGL()
{

    _eglDisplay = EGL_NO_DISPLAY;
    _eglConfig;
    _eglSurface = EGL_NO_SURFACE;
    _eglContext = EGL_NO_CONTEXT;

    _red_size = 5;
    _green_size = 6;
    _bule_size = 5;
    _alpha_size = 0;


}

CuEGL::~CuEGL()
{

    if( _eglDisplay != EGL_NO_DISPLAY )
        this->Exit();

}


bool CuEGL::Init(NativeWindowType hWnd)
{

    int buffer_size = _red_size + _green_size + _bule_size + _alpha_size;
    EGLint  attrs[] = {
        EGL_ALPHA_SIZE, _alpha_size,
        EGL_RED_SIZE, _red_size,
        EGL_GREEN_SIZE, _green_size,
        EGL_BLUE_SIZE, _bule_size,
        EGL_BUFFER_SIZE, buffer_size,
        EGL_DEPTH_SIZE, 16,
        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
        EGL_NONE};

    EGLint  numConfig;
    LONG        lRet = 1; 

    // NOTE: Theres a bunch of stuff we should be doing to release resources
    //       in the case of failure that we're not bothering with atm

    HDC hdc = GetWindowDC((HWND)hWnd);

    // Get the display device


    _eglDisplay = eglGetDisplay(hdc);

    Assert( _eglDisplay != EGL_NO_DISPLAY, L"CuEGL::Init:\n _eglDisplay == EGL_NO_DISPLAY");

    // Initialize the display
    if (!eglInitialize(_eglDisplay, NULL, NULL))
        {  
            Assert(0, L"CuEGL::Init:\n can't Initialize egl");
            return lRet;

        }

    // Obtain the first configuration with a depth buffer
    if (!eglChooseConfig(_eglDisplay, attrs, &_eglConfig, 1, &numConfig))
        { 
            Assert(0, L"CuEGL::Init:\n can't ChooseConfig");
            return lRet; 
        }

    // Create a surface for the main window
    _eglSurface = eglCreateWindowSurface(_eglDisplay, _eglConfig, (NativeWindowType)hWnd, NULL);
    Assert( _eglSurface != EGL_NO_SURFACE, L"CuEGL::Init:\n _eglSurface == EGL_NO_SURFACE");

    // Create an OpenGL ES context
    _eglContext = eglCreateContext(_eglDisplay, _eglConfig, EGL_NO_CONTEXT, NULL);
    Assert( _eglContext != EGL_NO_CONTEXT, L"CuEGL::Init:\n _eglContext == EGL_NO_CONTEXT");


    // Make the context and surface current
    if (!eglMakeCurrent(_eglDisplay, _eglSurface, _eglSurface, _eglContext))
        {  
            Assert(0, L"CuEGL::Init:\n can't MakeCurrent");
            return lRet; 
        }

    return 0;

}

void CuEGL::Exit()
{

    // Set the current context to nothing
    eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);

    // Free any EGL contexts; should be called per context created
    eglDestroyContext(_eglDisplay, _eglContext);

    // Free any EGL surfaces; should be called per surface created
    eglDestroySurface(_eglDisplay, _eglSurface);

    // Terminate any EGL displays; should be called per display initialized
    eglTerminate(_eglDisplay); 

}

void CuEGL::SwapBuffers()
{

    eglSwapBuffers(_eglDisplay, _eglSurface);

}

好舊的碼了~ 如果有更新會在加上去

CuGPSDevice

2010-02-19T15:00:00.000-08:00

class CuGPSDevice : public CuPort  
{
    CuFile m_LogFile;
    CuFile m_CheckLogFile;
    CuFile m_CheckErrorLogFile;
    CuFile m_Error_Message_File;


    DWORD m_dReadDataBufferSize;
    DWORD m_dReadDataBuffseIndex;
    BYTE *m_pReadDataBuffer;

    bool _writeFileCheck(CuFile &File, void *pData, int nSize);

public:
    BOOL CheckReadData(BYTE* pReadData);
    virtual void OnWrite(BYTE *pByte, int nSize);
    virtual void OnRead(BYTE *pByte, int nSize);
    CuGPSDevice();
    virtual ~CuGPSDevice();

};

//

CuGPSDevice::CuGPSDevice()
:m_dReadDataBufferSize(1024)
,m_dReadDataBuffseIndex(0)
,m_pReadDataBuffer(NULL)
{

    m_pReadDataBuffer = new BYTE[m_dReadDataBufferSize];

    CuModuleFile mf;
    wstring strLogFile = mf.GetModuleFileName(L"GPS_Log.txt");
    m_LogFile.Open(strLogFile, L"w");


    strLogFile = mf.GetModuleFileName(L"GPS_Check_Log.txt");
    m_CheckLogFile.Open(strLogFile, L"w");

    strLogFile = mf.GetModuleFileName(L"GPS_Check_Error_Log.txt");
    m_CheckErrorLogFile.Open(strLogFile, L"w");


    strLogFile = mf.GetModuleFileName(L"GPS_Error_Message_Log.txt");
    m_Error_Message_File.Open(strLogFile, L"w");
    


}

CuGPSDevice::~CuGPSDevice()
{

}
void CuGPSDevice::OnWrite(BYTE *pByte, int nSize)
{

    unsigned char checksum = 0 ;
    for(int i=0 ; i < nSize; i++)
    {
        checksum ^= pByte[i];
    }
    
    char strCheckSum[2];

    sprintf( strCheckSum, "%x", checksum);
    char pSendStr[2048];
    memset(pSendStr, 0, 2048);

    ::strcat(pSendStr, "$");
    ::strcat(pSendStr, (char*)pByte);

    ::strcat(pSendStr, "*");
    ::strcat(pSendStr, strCheckSum);
    ::strcat(pSendStr, "\x0d");
    ::strcat(pSendStr, "\x0a");
        
    CuPort::OnWrite((BYTE*)pSendStr, strlen(pSendStr));

}

void CuGPSDevice::OnRead(BYTE *pByte, int nSize)
{

    for( int i = 0 ; i < nSize ; i++ )
    {

    
        if( pByte[i] == 0x0a )
        {
            m_pReadDataBuffer[m_dReadDataBuffseIndex++] = pByte[i];
            if( CheckReadData( m_pReadDataBuffer) )
                _writeFileCheck(m_CheckLogFile, (void*)m_pReadDataBuffer , m_dReadDataBuffseIndex);
                m_CheckLogFile.Write(()m_pReadDataBuffer, m_dReadDataBuffseIndex);
            else
                _writeFileCheck(m_CheckErrorLogFile, (void*)m_pReadDataBuffer , m_dReadDataBuffseIndex);
                m_CheckErrorLogFile.Write((void*)m_pReadDataBuffer, m_dReadDataBuffseIndex);


            memset(m_pReadDataBuffer, 0, m_dReadDataBuffseIndex);
            m_dReadDataBuffseIndex = 0;
            continue;
        }

        m_pReadDataBuffer[m_dReadDataBuffseIndex++] = pByte[i];


    }

    {
        m_LogFile.Write((void*)pByte, nSize);
        _writeFileCheck(m_LogFile, (void*)pByte , nSize);
    }


}

BOOL CuGPSDevice::CheckReadData(BYTE* pReadData)
{
    int nSize;
    nSize = strlen((char*)pReadData);

    unsigned char checksumtemp;

    TCHAR checkstr[3];
    checkstr[0] = pReadData[ nSize - 4 ];
    checkstr[1] = pReadData[ nSize - 3 ];
    checkstr[2] = 0;

    swscanf(checkstr, L"%x", &checksumtemp);

    unsigned char checksum = 0 ;
    checksum = 0;
    for(int i=1 ; i < nSize - 5 ; i++)
    {
        checksum ^= pReadData[i];
    }

    return checksum == checksumtemp ? TRUE : FALSE;

}

bool CuGPSDevice::_writeFileCheck(CuFile &File, void *pData, int nSize)
{
    static int nWriteFileResult = 0;
    nWriteFileResult = File.Write(pData, nSize);
    
    bool bResult = (nWriteFileResult == nSize);

    if( !bResult )
    {
        MessageBox(NULL, L"WriteFileError", L"WriteFileError", MB_OK);
        m_Error_Message_File.Write(pData, nSize);
    }
    return bResult;
}

CuImageLoaderBMP

2010-02-18T15:00:00.000-08:00




//

class CuImageLoaderBMP : public IuImageLoaderBMP  
{


public:
    CuImageLoaderBMP();
    virtual ~CuImageLoaderBMP();

    //////////////////////////////////////////////////////////////////
    // IuUnknown 公開虛擬界面 
    virtual ULONG Release();

    //////////////////////////////////////////////////////////////////
    // IuImageLoader 公開虛擬界面 
    virtual BOOL LoadFile(IuImageEx *pImageEx, LPCTSTR lpszResourceName);

    enum BMPFORMAT { BMP1555, BMP565};

    void SetBmpFormat(BMPFORMAT bmpFormat);

private:

    BOOL _Load565Bmp(BYTE * pbits);
    BOOL _Load1555Bmp(BYTE * pbits);


//  BOOL _Load565Bmp16(BYTE * pbits);
    BOOL _Load565Bmp24(BYTE * pbits);


    BOOL _Load1555Bmp24(BYTE * ptr);
    BOOL _Load1555Bmp16(BYTE * ptr);
    BOOL _Load1555Bmp8(BYTE * ptr);

private:

    IuImageEx *m_tempImageEx;

    BMPFORMAT m_bmpFormat;
    BITMAPFILEHEADER m_bmfh;
    BITMAPINFOHEADER *m_pInfo;


};


//


CuImageLoaderBMP::CuImageLoaderBMP()
:m_bmpFormat(BMP1555)
,m_pInfo(NULL)
{

}

CuImageLoaderBMP::~CuImageLoaderBMP()
{
    delete [] m_pInfo;
}

ULONG CuImageLoaderBMP::Release()
{
    delete this;
    return 0;
}

void CuImageLoaderBMP::SetBmpFormat(BMPFORMAT bmpFormat)
{
    m_bmpFormat = bmpFormat;
}


BOOL CuImageLoaderBMP::LoadFile(IuImageEx *pImageEx, LPCTSTR lpszResourceName)
{

    delete [] m_pInfo;
    m_pInfo = NULL;

    m_tempImageEx = pImageEx;

    // 需要 Bits 只支援 24 & 16 BIT bmp 圖
    /////////////////////////////////////////////////////////////////////////////////////////////
//  BITMAPINFOHEADER *pInfo = NULL;
    BYTE *pbits;

    CuFile File; 

    if( !File.Open(lpszResourceName, L"rb") )
    {
        Assert(0, L"CuBitmap::LoadFile /n can't open the file");
        return FALSE;
    }


    DWORD readed;
//  BITMAPFILEHEADER bmfh;


    int size = File.GetFileSize();
    if( size > sizeof(BITMAPFILEHEADER) )
    {

        //ReadFile( hfile, &m_bmfh, sizeof(BITMAPFILEHEADER), &readed, 0 );
        readed = File.Read( &m_bmfh,  sizeof(BITMAPFILEHEADER) );

        if(( readed == sizeof(BITMAPFILEHEADER) ) && ( m_bmfh.bfType == 0x4d42 ))
        {

            m_pInfo = (BITMAPINFOHEADER*)(new BYTE[ size - sizeof(BITMAPFILEHEADER) ]);

            Assert(m_pInfo, L"CuBitmap::LoadFile /n not enough memory.");

            File.Read(  m_pInfo, size - sizeof(BITMAPFILEHEADER) );

            // the pInfo type is BITMAPINFOHEADER, 
            // if pInfo add 1 that mean pInfo jump sizeof(BITMAPINFOHEADER)
            pbits = (BYTE*)(m_pInfo+1);

        }
        else
        {
            return FALSE;
        }


    }

    // use Create allocate memory   
    pImageEx->Create(m_pInfo->biWidth, m_pInfo->biHeight, 16);

//  WORD &biBitCount = m_pInfo->biBitCount;

    BOOL bResult = false;

    switch( m_bmpFormat )
    {
    case BMP1555:
        return _Load1555Bmp(pbits);
        break;
    case BMP565:
        return _Load565Bmp(pbits);
        break;
    
    }

    delete [] m_pInfo;
    m_pInfo = NULL;

    return bResult;

}
BOOL CuImageLoaderBMP::_Load565Bmp(BYTE * pbits)
{
    BOOL bResult = false;

    switch( m_pInfo->biBitCount )
    {
    case 24:
        bResult = this->_Load565Bmp24(pbits);
        break;
    case 16:
//      bResult = this->_Load565Bmp16(pbits);
        break;
    case 8:
//      bResult = this->_Load565Bmp8(pbits);
        break;
    default:
        {
            Assert(0, L"CuBitmap::LoadFile /n biBitCount not support.");
        }
        break;
    }

    return bResult;
}
// 
// BOOL CuImageLoaderBMP::_Load565Bmp16(BYTE * pbits)
// {
//  return FALSE;
// }

BOOL CuImageLoaderBMP::_Load565Bmp24(BYTE * pbits)
{

    int nSrcTotalByte = m_tempImageEx->Width() * m_tempImageEx->Height() * 3;
    int nDescTotalByte = m_tempImageEx->Width() * m_tempImageEx->Height() * 2;


    // our copy pointer
    WORD *ptr = (WORD *)m_tempImageEx->Data();

    BYTE r, g, b;

    // Convert From BGR To RGB Format And Copy over
    for( long i = 0; i < nSrcTotalByte; i += 3 ) // Loop Through All Of The Pixels
    {

        BYTE* pPixel=&pbits[i];                 // Grab The Current Pixel

        r = pPixel[2];//br;                                 // copy red
        g = pPixel[1];//bg;                                 // copy green
        b = pPixel[0];//bb;                                 // copy blue

        *(ptr++) = (WORD)( ( r >> 3 << 11) | 
            ( g >> 2 << 5) | 
            ( b >> 3 ) );

    }

    return TRUE;

}


BOOL CuImageLoaderBMP::_Load1555Bmp(BYTE * pbits)
{
    BOOL bResult = false;

    switch( m_pInfo->biBitCount )
    {
    case 24:
        bResult = this->_Load1555Bmp24(pbits);
        break;
    case 16:
        bResult = this->_Load1555Bmp16(pbits);
        break;
    case 8:
        bResult = this->_Load1555Bmp8(pbits);
        break;
    default:
        {
            Assert(0, L"CuBitmap::LoadFile /n biBitCount not support.");
        }
        break;
    }

    return bResult;
}

BOOL CuImageLoaderBMP::_Load1555Bmp8(BYTE * pbits)
{
    int nSrcTotalByte = m_tempImageEx->Width() * m_tempImageEx->Height();
    int nDescTotalByte = m_tempImageEx->Width() * m_tempImageEx->Height() * 2;


    RGBQUAD *pPalette = (RGBQUAD*)(pbits);

    pbits += m_bmfh.bfOffBits - sizeof(BITMAPFILEHEADER) - sizeof(BITMAPINFOHEADER);

    // 來源圖 做 4byte 對齊
    int nSrcJumpByte = 4 - (m_tempImageEx->Width() % 4);
    if( nSrcJumpByte == 4 )
        nSrcJumpByte = 0;

    int nDescJumpByte = 2 - ( (m_tempImageEx->Width() ) % 2 );
    if( nDescJumpByte == 2 )
        nDescJumpByte = 0;

//  nDescJumpByte = 1;


    // our copy pointer
    WORD *ptr = (WORD *)m_tempImageEx->Data();//_bits;

//  BYTE r, g, b;

    // Convert From BGR To RGB Format And Copy over
    //for( long i = 0; i < nSrcTotalByte; i += 1 )   // Loop Through All Of The Pixels

    int i = 0;
    for( int nHeight = 0 ; nHeight < m_tempImageEx->Height() ; nHeight += 1 )
    {
        for( int nWidth = 0 ; nWidth < m_tempImageEx->Width() ; nWidth += 1)
        {

            int nColorIndex = pbits[i++];                   // Grab The Current Pixel
            RGBQUAD Color = pPalette[nColorIndex];

            *(ptr++) = (WORD)( ( Color.rgbRed >> 3 << 10) | 
                                ( Color.rgbGreen >> 3 << 5) | 
                                ( Color.rgbBlue >> 3 ) );

        }
        i += nSrcJumpByte; 
        ptr += nDescJumpByte;

    }



    return TRUE;
}


BOOL CuImageLoaderBMP::_Load1555Bmp16(BYTE * pbits)
{

    int nTotalByte = m_tempImageEx->Width() * m_tempImageEx->Height() * 2;
    BYTE *pData = m_tempImageEx->Data();
    memcpy( pData, pbits, nTotalByte);
    return TRUE;

}

BOOL CuImageLoaderBMP::_Load1555Bmp24(BYTE * pbits)
{

        int nSrcTotalByte = m_tempImageEx->Width() * m_tempImageEx->Height() * 3;
        int nDescTotalByte = m_tempImageEx->Width() * m_tempImageEx->Height() * 2;


        // our copy pointer
        WORD *ptr = (WORD *)m_tempImageEx->Data();

        BYTE r, g, b;

        // Convert From BGR To RGB Format And Copy over
        for( long i = 0; i < nSrcTotalByte; i += 3 ) // Loop Through All Of The Pixels
        {

            BYTE* pPixel=&pbits[i];                 // Grab The Current Pixel
            
            r = pPixel[2];//br;                                 // copy red
            g = pPixel[1];//bg;                                 // copy green
            b = pPixel[0];//bb;                                 // copy blue

            *(ptr++) = (WORD)( ( r >> 3 << 10) | 
                                      ( g >> 3 << 5) | 
                                      ( b >> 3 ) );

        }

    return TRUE;

}

功能複合的太多就會像上面這樣, 整個看起來好像很好用, 但真的要改的時後, 會有點頭大的感覺

CuResetSystemIdleTimer

2010-02-17T15:00:00.000-08:00



//


class CuResetSystemIdleTimer
{
    TuWinTimer<CuResetSystemIdleTimer> m_WinTimer;

public:
    CuResetSystemIdleTimer();
    virtual ~CuResetSystemIdleTimer();
    BOOL Init(HANDLE hParent);
    void OnTimeOut();

};


//


CuResetSystemIdleTimer::CuResetSystemIdleTimer()
{

}

CuResetSystemIdleTimer::~CuResetSystemIdleTimer()
{

}

BOOL CuResetSystemIdleTimer::Init(HANDLE hParent)
{
    OnTimeOut();

    m_WinTimer.Init(30000);
    m_WinTimer.CombineElement(this, &CuResetSystemIdleTimer::OnTimeOut, (HWND)hParent);
    m_WinTimer.OnStardTime();
    return TRUE;
}

void CuResetSystemIdleTimer::OnTimeOut()
{
    keybd_event(VK_F24 , 0, KEYEVENTF_SILENT, 0);    
    keybd_event(VK_F24 , 0, KEYEVENTF_SILENT | KEYEVENTF_KEYUP, 0);
}

猜看看這個是幹嘛的!

CuHtmlGeneric

2010-02-16T15:00:00.000-08:00


//


class CuHtmlGeneric
{
    function OnHTML()
    {
        
    }   
}



class CuHTMLString extends CuHtmlGeneric
{
    var $m_string;
    
    function CuHTMLString()
    {
        $this->m_string = "";
    }
    
    function OnAdd($str)
    {
        $this->m_string .= $str;
    }
    
    function OnHTML()
    {
        return $this->m_string;
    }
}

class CuWebControl extends CuHtmlGeneric
{
    var $Attribute;
    
    function CuWebControl()
    {
        $this->Attribute = array();
    }
    
    
    function __set($member, $val){
        $this->Attribute[$member] = $val;
    }
    
    function Set($member, $val)
    {
        $this->__set($member, $val);
    }
    
    function __get($member)
    {
        return $this->Attribute[$member];
    }
    
    function Get($member)
    {
        return $this->__get($member);
    }
    
    function Remove($member)
    {
        $Attribute = $this->Attribute[$member];
        unset($this->Attribute[$member]);
        return $Attribute;
    }
    
    function MakeAttribute()
    {
        foreach($this->Attribute as $key => $value)
        {
            if( $value != "" )
                $str = "$key=\"$value\" ";
            else
                $str = "$key ";
            
            $html .= $str;
        }
        
        return $html;
    }
    
    
    function OnHTML()
    {
        $html = "<" . $this->MakeAttribute() . ">";
        return $html;
    }
    
}

/************************************************
* 類別名稱: CuHTMLAnchor
* 類別說明: 將HTML 的 連結控制項 Tag <a>
************************************************/
class CuHTMLAnchor extends CuWebControl
{
    
    function CuHTMLAnchor()
    {
        //CuHTMLAnchor
    }
    
    function OnHTML()
    {
        
        $value = $this->Remove("value");
        
        $html = "<" . $this->MakeAttribute() . ">" . $value . "</a>";
        
        return $html;
    }
}

支援 CuPage 的相關類別, 控制項類別, 組合字串類別, 方便用來操做HTML組裝

CuPage

2010-02-15T15:00:00.000-08:00

// Task.form.html

<table><tr><td>
    <form method="POST" action="">
<input type="hidden" name="msg" value="#?msg?#">

    主旨:<input type="text" name="title" size="80"></p>
    <p>內容:<br>
    <textarea rows="5" name="description" cols="80"></textarea></p>
    <p><input type="submit" value="送出" name="B1"><input type="reset" value="重新設定" name="B2"></p>
    </form>
</td></tr></table>

//

class CuTestTaskForm extends CuPage 
{
    function OnProcess()
    {
        $this->title->Set("value", "哦哦更爽的");
        $this->msg->Set("value", "這樣行嗎?");
    }
    
}

$page = new CuTestTaskForm;

$filename = "resource/Task.form.html";
$page->LoadFile($filename);


$nIndex = $page->GetObjectIndex("msg");
$this->debug->debug($nIndex, "msg nIndex");
$this->assertTrue($nIndex == 5, "msg nIndex from CuPageGetObjectIndex");

$msg = $page->GetObject("msg");
$msg->Set("value", "抓出來的是考備版");
$this->debug->debug($msg, "CuPage::GetObject 抓出來的是考備版");
$page->SetObject($msg); // 再蓋回去囉
$this->debug->innerText($page->OnHTML(), "CuPage->SetObject 再蓋回去囉");

$page->OnProcess();
$this->debug->innerText($page->OnHTML(), "from CuPage::OnHTML");

// CuPage.php


/************************************************
* 類別名稱: CuPage
* 類別說明: 將HTML 的 form 載入後轉為PHP控制物件 CuWebControl
* 現在只支援 <INPUT >
************************************************/
class CuPage
{
    var $m_Control;
    var $m_Index;
    
    function CuPage()
    {
        $this->m_Control = array();
        $this->m_Index = 0;
    }
    

    /************************************************
    * 函式名稱: LoadFile
    * 函式說明: 載入html檔
    ************************************************/   
    function LoadFile($filename)
    {
        $html = LoadFile("resource/Task.form.html");
        $this->ExplodeForm($html);
        $this->CombineControl();
    }


    /************************************************
    * 函式名稱: ExplodeForm
    * 函式說明: 將Html Form 轉為 控制項陣列
    ************************************************/       
    function ExplodeForm($html)
    {
        $html_array = explode("<", $html);
        
        foreach( $html_array as $key => $value )
        {
            if( ereg( "^input", $value ) )
            {
                list($webcode, $str) = explode(">", $value);
                
                $object_Attribute = explode(" ", $webcode);
                $this->CreateWebControl($object_Attribute);
                
                $this->CreateHTMLString( $str );
            }
            else if( $value != "" )
            {
                $this->CreateHTMLString( "<" . $value );
            }
        }       
    }
    

    /************************************************
    * 函式名稱: CombineControl
    * 函式說明: 叫用這個函式, 來派發form 物件到類別內
    ************************************************/
    function CombineControl()
    {
        foreach( $this->m_Control as $key => $value )
        {
            if( $value->Attribute["name"] == "" )
                continue;
            
            $name = $value->Attribute["name"];
            $this->$name = &$this->m_Control[$key];
        }
        
    }
    
    
    /************************************************
    * 函式名稱: OnProcess
    * 函式說明: 子類別繼承這個函式後對表單的操作函式
    ************************************************/
    function OnProcess()
    {
            
    }
    
    
    /************************************************
    * 函式名稱: AddObject
    * 函式說明: 將CuWebControl加入CuPage陣列
    ************************************************/   
    function AddObject($object)
    {
        $this->m_Index = $this->m_Index + 1;
        $this->m_Control[$this->m_Index] = $object;       
    }
    
    
    /************************************************
    * 函式名稱: SetObject
    * 函式說明: 將CuWebControl加入CuPage陣列, 這裡會掃name參數, 找到一樣的就蓋掉, 找不到就轉叫 AddObject
    ************************************************/
    function SetObject($object)
    {
        
        $index = $this->GetObjectIndex($object->Get("name"));
        if( $index == 0 )
            $this->AddObject($object);
        else
            $this->m_Control[$index] = $object;

    }
    
    
    /************************************************
    * 函式名稱: GetObjectIndex
    * 函式說明: 依名稱尋找索引值
    ************************************************/
    function GetObjectIndex($name)
    {
        foreach( $this->m_Control as $key => $value )
        {
            if( $name == $value->Attribute["name"] )
                return $key;
        }
    }
    
    
    /************************************************
    * 函式名稱: GetObject
    * 函式說明: 依名稱尋找元件 -- 這裡傳回的是copy版, 
    ************************************************/   
    function GetObject($name)
    {
        
        foreach( $this->m_Control as $key => $value )
        {
            if( $name == $value->Attribute["name"] )
                return $this->m_Control[$key];
        }

    }   


    /************************************************
    * 函式名稱: CreateWebControl
    * 函式說明: 將處理好一半的HTML碼轉為CuWebControl, 並且叫用SetObject
    ************************************************/       
    function CreateWebControl($html_tag_array)
    {
        
        $Control = new CuWebControl;
        foreach($html_tag_array as $Attribute_key => $Attribute_value)
        {
            list($key, $value) = explode("=", $Attribute_value);
            $value = split("\"", $value);
            $Control->Set($key, $value[1]);
        }
        
        $this->AddObject($Control);
        
    }


    /************************************************
    * 函式名稱: CreateHTMLString
    * 函式說明: 建構HTML字串元件除了可以轉換的 FORM INPUT 外, 其他的文字直接建文字元件
    ************************************************/           
    function CreateHTMLString($string)
    {
        if( $string == "" )
            return;
        
        $Control = new CuHTMLString();
        $Control->OnAdd( $string );
        $this->AddObject($Control);
        
    }
    
    
    function OnHTML()
    {
        $html = "";
        foreach( $this->m_Control as $key => $value )
        {
            if( $value != null )
                $html .= $value->OnHTML();
        }
        return $html;
    }
    
}

Form 的載入一般都直接使用HTML並且替換字串, 在這裡將form.html當做外部介面設定檔,
將 input 生成為可控制類別, 使用類別操控的方式來處理表單, 可以很方便的操作內容元件,
上面拿 tag input 來做範例.

CuTaskDlg

2010-02-14T15:00:00.000-08:00

//

//***************************************
// 類別名稱：CuTask
// 功　　能：工作記錄 對資料表 task 資料維護
//***************************************/
class CuTaskDlg  {

    // 成員變數
    // private
    var $created;
    
    // public
    var $title;
    var $description;
    var $account_id;


    // 資料庫關聯
    var $ado;
    var $record;
    
    // 靜態變數
    var $table_name = "hrc_task";
    
    /************************************************
    * 函式名稱: CuTaskDlg
    * 函式說明: 使用CuRecord作業
    ************************************************/       
    function CuTaskDlg($ado) {

        $this->ado = $ado;
        $this->record = new CuRecord($ado, $this->table_name, "sn");

    }
    
    
    /************************************************
    * 函式名稱: Save
    * 函式說明: 儲存 這個 啞資料類別不處理
    ************************************************/   
    function Save()
    {
        if(!($this->title))
            return;
            
        
        $this->created = date("Y-m-d H:i:s", time());
        $record = &$this->record;
        
        // 檢查是否有留言過
        $sn = $record->Load("title", "$this->title");
        if( $sn != "" )
            return;
        
        $record->SetField("created", $this->created );
        $record->SetField("title", $this->title);
        $record->SetField("description", $this->description);
        
        
        $record->SetField("account_id", $this->account_id);
        $record->Save(); 
    }
    
    
    /************************************************
    * 函式名稱: Load
    * 函式說明: 指定SN值 載入指定的資料項
    ************************************************/       
    function Load($sn)
    {
        $record = &$this->record;
        $record->Load("sn", $sn);
        
        $this->created  = $record->GetField("created");
        $this->title = $record->GetField("title");
        $this->description = $record->GetField("description");
        $this->account_id = $record->GetField("account_id");
        
    }
    
}



/*

-- 
-- 資料表格式： `hrc_task`
-- 

CREATE TABLE `hrc_task` (
  `sn` int(11) NOT NULL auto_increment,
  `created` timestamp NOT NULL default '0000-00-00 00:00:00',
  `title` varchar(256) NOT NULL,
  `description` text,
  `account_id` int(11) NOT NULL DEFAULT '0',
  PRIMARY KEY  (`sn`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

 created 記錄建立日期
 title 項目主旨
 description 詳細內容
 account_id 帳號索引 用來關聯是那位使用者寫入的 預設為0 
*/

CuCount

2010-02-13T16:39:00.000-08:00




// CuCount.php

class CuCount
{
    var $ado;
    var $count_name;
    var $record;
    
    function CuCount(/*CuAdo*/ $ado, $count_name)
    {

        $this->ado = &$ado;
        $this->count_name = $count_name;
        $this->record = new CuRecord(&$ado, "hrc_count", "id");
        $this->record->Load("name", $this->count_name);

    }
    
    function Inc()
    {
        
        $record = &$this->record;
        
        $count = $record->GetField("count");
        $count = $count + 1;
        $record->SetField("count", $count);
        $record->SetField("name", $this->count_name);
        $record->Save();
        
        $this->AddLog();
        $CountLog = $this->CountLog();
        

        $TotalCount = $record->GetField("totalcount");
        $TotalCount = $TotalCount + $CountLog;

        return $TotalCount;
        
    }
    
    function CountLog( $date = "" )
    {
        $id = $this->record->GetField('id');
        if( $date != "" )
            $created_stmt = " AND created = '$date' ";
            
            
        $stmt = "SELECT * FROM hrc_countlog WHERE `count_id` = '". $id ."'" . $created_stmt;
        $this->ado->sql($stmt);   
        $result_table = $this->ado->fetch_array();
        return count($result_table);
        
    }
    
    function AddLog()
    {
                
        $CountLog = new CuRecord(&$this->ado, "hrc_countlog", "id");
        $created = date("Y-m-d", time());       
        $CountLog->SetField("created", $created);
        $CountLog->SetField("count_id", $this->record->GetField("id"));
        $CountLog->SetField("user_agent",  $GLOBALS["HTTP_USER_AGENT"]);
        $CountLog->Save();
        
    }
    
}

/*
CREATE TABLE `hrc_count` (
`id` INT( 11 ) NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`name` VARCHAR( 64 ) NOT NULL ,
`count` INT( 11 ) NOT NULL ,
`totalcount` INT( 11 ) NOT NULL default '0',
INDEX ( `name` ) 
) ENGINE = MYISAM ;

CREATE TABLE `hrc_countlog` (
`id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`count_id` INT NOT NULL ,
`created` DATE NOT NULL default '0000-00-00',
`user_agent` varchar(256) NOT NULL,
INDEX ( `count_id` ) 
) ENGINE = MYISAM ;

*/

有了CuRecord & CuADO 後. 在處理資料表時就簡明多了

TuPokerRule - 分析牌型

2010-02-12T15:00:00.000-08:00

// u_TPokerRule.pas

unit u_TPokerRule;

interface
uses
        Windows, Classes, SysUtils,
        StdCtrls,
        ch_LogMessages,

        u_TList,
        u_TDeck,
        u_TexasHoldConst;

type

//******************************************************************************
// 類別名稱：TuPokerRule
// 功　　能：分析牌型
//******************************************************************************
        TuPokerRule = class
          private
            m_PokerRuleMessToFiles : TLogMessToFiles;
            m_nPokerRule : integer; // 牌型

            // 計算每個花色的牌有幾張
            m_aCategory : array[0..3] of integer;
            // 記錄 每種 數字 有幾張
            m_aSumIndex: array[0..CARD_INDEX_LIMIT] of integer;
            // 記錄有幾種牌型
            m_aSumRules: array[0..POKER_RULES_LIMIT - 1]of integer;

            // 暫存要分析的撲克
            m_TempPokerList : TuList; // type TCardData.nListIndex;
            m_CardDataList: TuList; // type TCardData;
            m_MaxRulePoker : TuList; // type TCardData; 最大的五張牌


            m_pDeck : TuDeck;

            function _GetFlushIndex(): Integer; // 抓同花是那一個花色

            function _GetMaxRules : Integer; // 取最大的牌型
            procedure _OnRanderMaxPoker( nRuleType:Integer ); // 依牌型抓最大的五張

            procedure _OnMaxPokerZilch;         // 抓 最大的五張
            procedure _OnMaxPokerOnePair;       // 抓 一對 最大的五張
            procedure _OnMaxPokerTwoPair;       // 抓 兩對 最大的五張
            procedure _OnMaxPokerThreeKind;     // 抓 三條 最大的五張
            procedure _OnMaxPokerStraight;      // 抓 順子 最大的五張
            procedure _OnMaxPokerFlush;         // 抓 同花 最大的五張
            procedure _OnMaxPokerFullHouse;     // 抓 葫蘆 最大的五張
            procedure _OnMaxPokerFourKind;      // 抓 鐵支 最大的五張
            procedure _OnMaxPokerStraightFlush; // 抓 同花順 最大的五張

            function _PokerRulesTwoPair:Integer;         // 檢查有沒有 兩對
            function _PokerRulesStraight : Integer;      // 檢查有沒有 順子
            function _PokerRulesFlush :Integer;          // 檢查有沒有 同花
            function _PokerRulesFullHouse: Integer;      // 檢查有沒有 葫蘆
            function _PokerRulesStraightFlush():Integer; // 檢查有沒有 同花順
            function _PokerRulesRoyalFlush():Integer;    // 檢查有沒有 同花順

            procedure _debug_LogPoker;// 將 牌 匯出
          public
            constructor Create(var pDeck: TuDeck);
            destructor Destroy(); override;

            procedure Init();
            procedure OnAddCard(nIndex:Integer);        // 將牌加入
            function GetPokerRule(): Integer;           // 取出最大的牌型
            procedure GetMaxRulePoker(var MaxPoker:TuList); // 將最大的五張牌寫入 MaxPoker

        end;



//******************************************************************************
// 類別名稱：TuUITextPokerRule
// 功　　能：牌型顯示 文字版本
//******************************************************************************
        TuTextPokerRule = class
          private
            //m_uiText : TuUIText;
            m_strPokerRule : string; // 轉換完成的字串
            m_AToKTextList : TStringList; // A 到 K 的文字 字串
            m_PokerRulesFormat : TStringList; //
          public
            constructor Create();
            destructor Destroy(); override;
            procedure OnProcess(PokerRules: Word; var CardDataList : TuList ); // 牌型 五張牌
            property Text: string read m_strPokerRule;
        end;



implementation

// { TuUITextPokerRule }

constructor TuTextPokerRule.Create;
begin
        m_AToKTextList := TStringList.Create();
        if( Assigned( m_AToKTextList ) = True ) then begin
            m_AToKTextList.LoadFromFile( INI_DATA_PATH + 'AToKText_en.ini' );
        end;

        m_PokerRulesFormat := TStringList.Create();
        if( Assigned( m_PokerRulesFormat ) = True ) then begin
            m_PokerRulesFormat.LoadFromFile( INI_DATA_PATH + 'PokerRulesTextFormat_en.ini' );
        end;

end;


destructor TuTextPokerRule.Destroy;
begin
        m_PokerRulesFormat.Free;
        m_AToKTextList.Free;
  inherited;
end;


procedure TuTextPokerRule.OnProcess(PokerRules: Word;
  var CardDataList: TuList);
var
        strP1:string;
        strP2:string;

        TmpCardData : TCardData;
        TmpCardDataList : TuList;
        nIndex : Integer;
begin

        if CardDataList.Count = 0 then
            exit;

        strP1 := '';
        strP2 := '';
        // 牌型
        case PokerRules of
          POKER_RULES_ZILCH: begin

              TmpCardData := CardDataList.GetItems(0);
              nIndex := TmpCardData.Index - 1;
              strP1 := m_AToKTextList.Strings[ nIndex ];
          end;
          POKER_RULES_ONE_PAIR: begin
              TmpCardData := CardDataList.GetItems(0);
              nIndex := TmpCardData.Index - 1;
              strP1 := Format('%ss',[m_AToKTextList.Strings[ nIndex ]]);

          end;

          POKER_RULES_TWO_PAIRS: begin
              TmpCardData := CardDataList.GetItems(0);
              nIndex := TmpCardData.Index - 1;
              strP1 := Format('%ss',[m_AToKTextList.Strings[ nIndex ]]);

              TmpCardData := CardDataList.GetItems(3);
              nIndex := TmpCardData.Index - 1;
              strP2 := Format('%ss',[m_AToKTextList.Strings[ nIndex ]]);
          end;

          POKER_RULES_THREE_KIND: begin
              TmpCardData := CardDataList.GetItems(0);
              nIndex := TmpCardData.Index - 1;
              strP1 := Format('%ss',[m_AToKTextList.Strings[ nIndex ]]);
          end;

          POKER_RULES_STRAIGHT: begin
              TmpCardData := CardDataList.GetItems(4);
              nIndex := TmpCardData.Index - 1;
              strP1 := m_AToKTextList.Strings[ nIndex ];

              TmpCardData := CardDataList.GetItems(0);
              nIndex := TmpCardData.Index - 1;
              strP2 := m_AToKTextList.Strings[ nIndex ];
          end;

          POKER_RULES_FLUSH: begin
              TmpCardData := CardDataList.GetItems(0);
              nIndex := TmpCardData.Index - 1;
              strP1 := m_AToKTextList.Strings[ nIndex ];

          end;

          POKER_RULES_FULLHOUSE: begin
              TmpCardData := CardDataList.GetItems(0);
              nIndex := TmpCardData.Index - 1;
              strP1 := Format('%ss',[m_AToKTextList.Strings[ nIndex ]]);

              TmpCardData := CardDataList.GetItems(3);
              nIndex := TmpCardData.Index - 1;
              strP2 := Format('%ss',[m_AToKTextList.Strings[ nIndex ]]);
          end;

          POKER_RULES_FOUR_KIND: begin
              TmpCardData := CardDataList.GetItems(0);
              nIndex := TmpCardData.Index - 1;
              strP1 := Format('%ss',[m_AToKTextList.Strings[ nIndex ]]);
          end;

          POKER_RULES_STRAIGHT_FLUSH: begin
              TmpCardData := CardDataList.GetItems(4);
              nIndex := TmpCardData.Index - 1;
              strP1 := m_AToKTextList.Strings[ nIndex ];

              TmpCardData := CardDataList.GetItems(0);
              nIndex := TmpCardData.Index - 1;
              strP2 := m_AToKTextList.Strings[ nIndex ];
          end;

//          POKER_RULES_STRAIGHT_FLUSH: begin
//              TmpCardData := CardDataList.GetItems(0);
//              nIndex := TmpCardData.Index - 1;
//              strP1 := m_AToKTextList.Strings[ nIndex ];
//
//              TmpCardData := CardDataList.GetItems(4);
//              nIndex := TmpCardData.Index - 1;
//              strP2 := m_AToKTextList.Strings[ nIndex ];
//          end;


        end;

        m_strPokerRule := Format(m_PokerRulesFormat.Strings[PokerRules], [strP1, strP2]);

end;

constructor TuPokerRule.Create(var pDeck: TuDeck);
begin
        m_pDeck := pDeck;
        m_TempPokerList := TuList.Create();
        m_MaxRulePoker := TuList.Create();
        m_CardDataList := TuList.Create();

        m_PokerRuleMessToFiles := TLogMessToFiles.Create('PokerRuleMessage.txt');
end;

destructor TuPokerRule.Destroy;
begin
        m_PokerRuleMessToFiles.Free;
        m_TempPokerList.Free;
        m_MaxRulePoker.Free;
        m_CardDataList.Free;
end;


//******************************************************************************
// 函式名稱：Init
// 功　　能：使用TuPokerRule 之前要先呼叫Init 用來清除所有資料
//******************************************************************************
procedure TuPokerRule.Init;
var
        i:integer;
begin

        // 初始化 PokerRules 記錄
        m_nPokerRule := POKER_RULES_ZILCH;

        // 清除花色記錄器
        for i := 0 to High(m_aCategory) do begin
            m_aCategory[i] := 0;
        end;

        // 清除牌數字記錄器
        for i := 0 to High(m_aSumIndex) do begin
            m_aSumIndex[i] := 0;
        end;

        // 清除牌數字記錄器
        for i := 0 to High(m_aSumRules) do begin
            m_aSumRules[i] := 0;
        end;

        // 清除暫存陣列
        m_TempPokerList.Clear();
        m_MaxRulePoker.Clear();
        m_CardDataList.Clear();
end;


//******************************************************************************
// 函式名稱：OnAddCard
// 功　　能：將要運牌的牌加入TuPokerRule
//******************************************************************************
procedure TuPokerRule.OnAddCard(nIndex:Integer);
begin

        if( nIndex = - 1 ) then begin
            exit;
        end;
        m_TempPokerList.Add(Pointer(nIndex));
        m_CardDataList.Add(m_pDeck.Items(nIndex));
end;


//******************************************************************************
// 函式名稱：GetPokerRule
// 功　　能：TuPokerRule 最主要的函式 計算牌型 計算最大的五張牌
//******************************************************************************
function TuPokerRule.GetPokerRule():Integer ;
var

        i: integer;
        nNum: integer;
        nListIndex: integer;
        nCategory : integer;
        // 有幾對
        nPairCount : integer;
        nThreeCount : integer;


begin
    try
        if m_TempPokerList.Count = 0 then  // 沒有牌不用處理
          exit;

        m_CardDataList.Sort(compareByPoker);

        for i := 0 to m_TempPokerList.Count - 1 do begin

            nListIndex := Integer(m_TempPokerList.GetItems(i));
            nCategory := m_pDeck.Category(nListIndex);
            nNum :=  m_pDeck.Index(nListIndex);

            // 計數每種花色有幾張
            m_aCategory[nCategory] := m_aCategory[nCategory] + 1;

            // 計數 同樣數字的撲克牌有幾張
            m_aSumIndex[nNum] :=  m_aSumIndex[nNum] + 1;

            if nNum = 13 then
                m_aSumIndex[0] :=  m_aSumIndex[0] + 1;

        end;

        for i := 1 to High(m_aSumIndex) do begin
            case m_aSumIndex[i] of
                2: m_aSumRules[POKER_RULES_ONE_PAIR] :=  m_aSumRules[POKER_RULES_ONE_PAIR] + 1;     // 計數對子
                3: m_aSumRules[POKER_RULES_THREE_KIND] := m_aSumRules[POKER_RULES_THREE_KIND] + 1;  // 計數三條
                4: m_aSumRules[POKER_RULES_FOUR_KIND] := m_aSumRules[POKER_RULES_FOUR_KIND] + 1;   // 計數四隻
            end;
        end;

        // 這裡有牌型是互斥的 可以使用 if else 作區分加快計算
        m_aSumRules[POKER_RULES_TWO_PAIRS] := _PokerRulesTwoPair();  // 檢查 兩對
        m_aSumRules[POKER_RULES_STRAIGHT] := _PokerRulesStraight();  // 檢查 順子
        m_aSumRules[POKER_RULES_FLUSH] := _PokerRulesFlush();        // 檢查 同花
        m_aSumRules[POKER_RULES_FULLHOUSE] := _PokerRulesFullHouse(); // 檢查 葫蘆
        m_aSumRules[POKER_RULES_STRAIGHT_FLUSH] := _PokerRulesStraightFlush();// 檢查 同花順
        m_aSumRules[POKER_RULES_ROYAL_FLUSH] := _PokerRulesRoyalFlush();  // 檢查 大同花順

        Result := _GetMaxRules();
        _OnRanderMaxPoker(Result);

      except
          m_PokerRuleMessToFiles.m_WriteTXTOne('GetPokerRule', 1);
      end;


end;


//******************************************************************************
// 函式名稱：_OnRanderMaxPoker
// 功　　能：依牌型種類 抓出最大的五張牌
//******************************************************************************
procedure TuPokerRule._OnRanderMaxPoker(nRuleType: Integer);
begin

        case nRuleType of
            POKER_RULES_ZILCH:        _OnMaxPokerZilch;       // 沒有
            POKER_RULES_ONE_PAIR:     _OnMaxPokerOnePair;     // 一對
            POKER_RULES_TWO_PAIRS:    _OnMaxPokerTwoPair;     // 兩對
            POKER_RULES_THREE_KIND:   _OnMaxPokerThreeKind;   // 三條
//          POKER_RULES_SMALL_STRAIGHT:                     // 小順子
            POKER_RULES_STRAIGHT:     _OnMaxPokerStraight;    // 順子
            POKER_RULES_FLUSH:        _OnMaxPokerFlush;           // 同花
            POKER_RULES_FULLHOUSE:    _OnMaxPokerFullHouse;   // 葫蘆
            POKER_RULES_FOUR_KIND:    _OnMaxPokerFourKind;    // 鐵支
            POKER_RULES_STRAIGHT_FLUSH:_OnMaxPokerStraightFlush;  // 同花順
            POKER_RULES_ROYAL_FLUSH:  _OnMaxPokerStraightFlush;   // 大同花順
        end;

end;


//******************************************************************************
// 函式名稱：_GetMaxRules
// 功　　能：選出 最大的牌型
//******************************************************************************
function TuPokerRule._GetMaxRules() : Integer;
var
        i : Integer;
begin

        for i := POKER_RULES_LIMIT - 1  downto POKER_RULES_ZILCH do begin
            if( m_aSumRules[i] > 0 ) then begin
                m_nPokerRule := i;
                break;
            end;
        end;
        Result := m_nPokerRule;

end;


//******************************************************************************
// 函式名稱：PokerRulesTwoPair
// 功　　能：檢查有沒有兩對
//******************************************************************************
function TuPokerRule._PokerRulesTwoPair():integer;
begin

        if  m_aSumRules[POKER_RULES_ONE_PAIR] < 2 then
        begin
            Result := 0;
            exit;
        end;
        Result := 1;

end;


//******************************************************************************
// 函式名稱：PokerRulesStraight
// 功　　能：檢查牌型 順子 & 順便檢查是不是最小順
//******************************************************************************
function TuPokerRule._PokerRulesStraight : integer;
var
        i : integer;
        nCountStraight : integer;
        nMaxCountStraight : integer;
begin
        nCountStraight := 0;
        nMaxCountStraight := 0;

        Result := 0;

        for i := High(m_aSumIndex) downto 0  do begin
            if m_aSumIndex[i] = 0 then
                nCountStraight := 0;

            if m_aSumIndex[i] > 0 then
                nCountStraight := nCountStraight + 1;

            if nMaxCountStraight < nCountStraight then
                nMaxCountStraight := nCountStraight;
        end;

        // 有超過5張連續的牌 代表有順子
        if nMaxCountStraight >= 5 then begin
            Result := 1;
        end;

        // 這裡要另外檢查 是否為最小順  A 2 3 4 5

        if( m_aSumIndex[1] > 0) And
          ( m_aSumIndex[2] > 0) And
          ( m_aSumIndex[3] > 0) And
          ( m_aSumIndex[4] > 0) And
          ( m_aSumIndex[0] > 0) then begin

            if nMaxCountStraight = 5 then begin
                m_aSumRules[POKER_RULES_SMALL_STRAIGHT] := 1;
            end;
            
            Result := 1;
        end;


end;


//******************************************************************************
// 函式名稱：PokerRulesFlush
// 功　　能：檢查牌型 同花
//******************************************************************************
function TuPokerRule._PokerRulesFlush :integer;
var
        i : integer;
        nListIndex : integer;
        nNum : integer;
        nCategory : integer;
begin
        Result := 0;
        // 檢查是否有五張的花色
        for i := 0 to High(m_aCategory) do begin
            if( m_aCategory[i] >= 5 ) then begin
                m_nPokerRule := POKER_RULES_FLUSH;
                Result := 1;
            end;
        end;

end;


//******************************************************************************
// 函式名稱：PokerRulesFullHouse
// 功　　能：檢查牌型 葫蘆
//******************************************************************************
function TuPokerRule._PokerRulesFullHouse: integer;
begin

        Result := 0;
        case m_aSumRules[POKER_RULES_THREE_KIND] of
            // 有兩組三條
            2: Result := 1;
            // 有一組三條 + 一組對子
            1:
                begin
                if(m_aSumRules[POKER_RULES_ONE_PAIR] > 0 ) then
                    Result := 1;
                end;
        end;
    
end;


// 加入了 m_CardDataList 找時間改寫..
//******************************************************************************
// 函式名稱：PokerRulesStraightFlush
// 功　　能：檢查牌型 同花順
//******************************************************************************
function TuPokerRule._PokerRulesStraightFlush():Integer ;
var
        i : Integer;
        nA : Integer;
        nTemp : Integer;
        nCategoryIndex: Integer;
        nCategory2Index: Integer;
        nCategory3Index: Integer;

        nSum: Integer;
        nMaxSum : Integer;

        aArray : TuList;

        str : String;
        strFileName :string;

begin

        Result := 0;
        // 沒有同花 跟 順子 就不用檢查 同花順        
        if ( m_aSumRules[POKER_RULES_STRAIGHT] = 0 ) Or
           (m_aSumRules[POKER_RULES_FLUSH] = 0) then
           exit;


        aArray := TuList.Create();

        for i := 0 to m_TempPokerList.Count - 1  do begin
            aArray.Add(m_TempPokerList.GetItems(i));
        end;

        aArray.Sort(compareByInteger);

        nCategoryIndex := _GetFlushIndex();


        // 檢查有沒有連續的順子
        nSum := 0;
        nMaxSum := 0;
        for i := 0 to m_TempPokerList.Count - 2 do
        begin
            nCategory2Index :=  m_pDeck.Category(Integer(aArray.GetItems(i + 1)));
            nCategory3Index :=  m_pDeck.Category(Integer(aArray.GetItems(i)));

            if( Integer(aArray.GetItems(i + 1)) - Integer(aArray.GetItems( i )) = 1 ) And
            ( nCategory2Index = nCategory3Index ) then
            begin
                nSum := nSum + 1;
                if( nMaxSum < nSum ) then
                    nMaxSum := nMaxSum + 1;
            end
            else
            begin
                nSum := 0;
            end;
        end;

        if( nMaxSum >= 4 ) then
        begin
            Result := 1;
            aArray.Free();
            exit;
        end;

        // 如果有小順 要另外檢查  只要檢查 有沒有同花色A 就行了
        if( nMaxSum <> 3 ) Or
          (m_aSumRules[POKER_RULES_SMALL_STRAIGHT] = 0 )then begin
            aArray.Free();
            exit;
        end;

        // 計算同花色的A 的索引值
        nA := nCategoryIndex * 13 + 12 ;
        for i := 0 to m_TempPokerList.Count -1 do
        begin
            //nTemp := aArray[i];
            if Integer(aArray.GetItems(i)) = nA then
            begin
                Result := 1;
                break;
            end;
        end;

        aArray.Free();


end;


//******************************************************************************
// 函式名稱：_PokerRulesRoyalFlush
// 功　　能：檢查牌型 大同花順
//******************************************************************************
function TuPokerRule._PokerRulesRoyalFlush: Integer;
var
        i:Integer;
        j:integer;
        TmpCardData : TCardData;
        nCategory:integer;
        nCardIndex:integer;
begin
        Result := 0;
        // 沒有同花順 就不用檢查 大同花順
        if ( m_aSumRules[POKER_RULES_STRAIGHT_FLUSH] = 0 ) then
           exit;

        nCategory := _GetFlushIndex();
        nCardIndex := 13;

        // 抓滿五張
        j := m_CardDataList.Count - 1;
        for i := 0 to 4 do begin
            TmpCardData := m_CardDataList.GetItems(j);
            if (TmpCardData.Index <> nCardIndex) Or
               (TmpCardData.Category <> nCategory) then begin 
               Result := 0;
               exit;

            end;
            j := j - 1;
            nCardIndex := nCardIndex - 1;
        end;

        Result := 1;

end;


//******************************************************************************
// 函式名稱：GetMaxRulePoker
// 功　　能：計算最大的牌型
//******************************************************************************
procedure TuPokerRule.GetMaxRulePoker(var MaxPoker: TuList);
var
        i : integer;
begin

        MaxPoker.Clear();
        for i := 0 to m_MaxRulePoker.Count -1 do begin
            MaxPoker.Add(m_MaxRulePoker.GetItems(i));
        end;
        
end;


//******************************************************************************
// 函式名稱：_OnMaxPokerOnePair
// 功　　能：將沒有任何牌形 的最大五張牌抓出來
//******************************************************************************
procedure TuPokerRule._OnMaxPokerZilch;
var
        i: integer;
        j: integer;
        TmpCardData : TCardData;
begin
        // 抓五張
        for j := m_CardDataList.Count - 1 downto 0 do begin
            TmpCardData := m_CardDataList.GetItems(j);
            m_MaxRulePoker.Add(TmpCardData);
            if m_MaxRulePoker.Count = 5 then begin
                Break;
            end;
        end;
end;


//******************************************************************************
// 函式名稱：_OnMaxPokerOnePair
// 功　　能：將牌形一對 的最大五張牌抓出來
//******************************************************************************
procedure TuPokerRule._OnMaxPokerOnePair;
var
        i: integer;
        j: integer;
        nNum: integer;

        TmpCardData : TCardData;
begin
        // 抓最大的一對牌
        for i := High(m_aSumIndex) downto 1 do begin
            if m_aSumIndex[i] = 2 then begin
                for j := 0 to m_CardDataList.Count - 1 do begin
                    TmpCardData := m_CardDataList.GetItems(j);
                    //nListIndex := TmpCardData.ListIndex;
                    nNum :=  TmpCardData.Index;
                    if nNum = i then begin
                        m_MaxRulePoker.Add(TmpCardData);
                    end;
                end;
                Break;
            end;
        end;

        // 抓剩下的三張
        for j := m_CardDataList.Count - 1 downto 0 do begin
            TmpCardData := m_CardDataList.GetItems(j);
            if m_aSumIndex[TmpCardData.Index] = 2 then begin
                Continue;
            end;

            m_MaxRulePoker.Add(TmpCardData);
            if m_MaxRulePoker.Count = 5 then begin
                Break;
            end;
        end;

end;


//******************************************************************************
// 函式名稱：_OnMaxPokerTwoPair
// 功　　能：將牌形兩對 的最大五張牌抓出來
//******************************************************************************
procedure TuPokerRule._OnMaxPokerTwoPair;
var

        i: integer;
        j: integer;
        nNum: integer;
        nListIndex: integer;
        nPairCount: integer;
        TmpCardData : TCardData;
begin

        // 抓最大的兩對牌
        nPairCount := 0;
        for i := High(m_aSumIndex) downto 1 do begin
            if m_aSumIndex[i] = 2 then begin
                nPairCount := nPairCount + 1;
                for j := 0 to m_CardDataList.Count - 1 do begin
                    TmpCardData := m_CardDataList.GetItems(j);
                    //nListIndex := TmpCardData.ListIndex;
                    nNum :=  TmpCardData.Index;
                    if nNum = i then begin
                        m_MaxRulePoker.Add(TmpCardData);
                    end;
                end;
                if nPairCount = 2 then begin
                    break;
                end;
            end;
        end;

        // 抓第五張
        nPairCount := 0;
        for j := m_CardDataList.Count - 1 downto 0 do begin
            TmpCardData := m_CardDataList.GetItems(j);

            if m_aSumIndex[TmpCardData.Index] = 2 then begin
                nPairCount := nPairCount + 1;
                if nPairCount <= 4 then begin
                    Continue;
                end;
            end;

            m_MaxRulePoker.Add(TmpCardData);
            break;

        end;
end;


//******************************************************************************
// 函式名稱：_OnMaxPokerThreeKind
// 功　　能：將牌形三條 的最大五張牌抓出來
//******************************************************************************
procedure TuPokerRule._OnMaxPokerThreeKind;
var
        i: integer;
        j: integer;
        nNum: integer;

        TmpCardData : TCardData;
begin
        // 抓三條
        for i := High(m_aSumIndex) downto 1 do begin
            if m_aSumIndex[i] = 3 then begin
                for j := 0 to m_CardDataList.Count - 1 do begin
                    TmpCardData := m_CardDataList.GetItems(j);
                    //nListIndex := TmpCardData.ListIndex;
                    nNum :=  TmpCardData.Index;
                    if nNum = i then begin
                        m_MaxRulePoker.Add(TmpCardData);
                    end;
                end;
                Break;
            end;
        end;

        // 抓滿五張
        for j := m_CardDataList.Count - 1 downto 0 do begin
            TmpCardData := m_CardDataList.GetItems(j);
            if m_aSumIndex[TmpCardData.Index] = 3 then begin
                Continue;
            end;

            m_MaxRulePoker.Add(TmpCardData);
            if m_MaxRulePoker.Count = 5 then begin
                Break;
            end;
        end;


end;


//******************************************************************************
// 函式名稱：_OnMaxPokerStraight
// 功　　能：將牌形 順子 的最大五張牌抓出來
//******************************************************************************
procedure TuPokerRule._OnMaxPokerStraight;
var
        i : integer;

        nCardDataIndex : integer;
        nCardDataNextIndex : Integer;
        nCountStraight : integer;
        nMaxCountStraight : integer;

        TmpCardData : TCardData;
        TmpCardDataNext : TCardData;
begin

        _debug_LogPoker();
        
        nCountStraight := 0;
        nMaxCountStraight := 0;

        nCardDataIndex := m_CardDataList.Count - 1;
        nCardDataNextIndex := nCardDataIndex - 1;
        for i := m_CardDataList.Count - 1 downto 1 do begin
            TmpCardData := m_CardDataList.GetItems(nCardDataIndex);
            TmpCardDataNext := m_CardDataList.GetItems(nCardDataNextIndex);

            // 先加入第一張牌
            if m_MaxRulePoker.Count = 0 then
                m_MaxRulePoker.Add(TmpCardData);

            // 如果 兩張牌面數字一樣 換下一張
            while (nCardDataNextIndex > 0) And
                (TmpCardData.Index = (TmpCardDataNext.Index )) do begin
                nCardDataNextIndex := nCardDataNextIndex - 1;
                TmpCardDataNext := m_CardDataList.GetItems(nCardDataNextIndex);
            end;

            // 下一張是不是比前一張少一
            if TmpCardData.Index = (TmpCardDataNext.Index + 1) then begin
                m_MaxRulePoker.Add(TmpCardDataNext);
            end else begin
                m_MaxRulePoker.Clear;
            end;

            // 超過五張
            if m_MaxRulePoker.Count = 5 then
                Break;

            nCardDataIndex := nCardDataNextIndex;
            nCardDataNextIndex := nCardDataNextIndex - 1;

            if nCardDataIndex = 0 then begin
                Break;
            end;

        end;

        // 如果是小順 要另外處理A
        if m_aSumRules[POKER_RULES_SMALL_STRAIGHT] <> 0 then begin
            for i := m_CardDataList.Count - 1 downto 0 do begin
                TmpCardData := m_CardDataList.GetItems(i);
                if TmpCardData.Index = 13 then begin
                    m_MaxRulePoker.Add(TmpCardData);
                    break;
                end;
            end;
        end;


end;


//******************************************************************************
// 函式名稱：_OnMaxPokerFlush
// 功　　能：將牌形 同花 的最大五張牌抓出來
//******************************************************************************
procedure TuPokerRule._OnMaxPokerFlush;
var
        i : integer;
        nListIndex : integer;
        nNum : integer;
        nCategory : integer;

        TmpCardData : TCardData;
begin

        nCategory := _GetFlushIndex();

        for i := m_CardDataList.Count - 1 downto 0 do begin
            TmpCardData := m_CardDataList.GetItems(i);
            if TmpCardData.Category = nCategory then begin
                m_MaxRulePoker.Add(TmpCardData);
            end;

            if m_MaxRulePoker.Count = 5 then
                Break;
        end;
end;


//******************************************************************************
// 函式名稱：_OnMaxPokerFullHouse
// 功　　能：將牌形 葫蘆 的最大五張牌抓出來
//******************************************************************************
procedure TuPokerRule._OnMaxPokerFullHouse;
var
        i: integer;
        j: integer;
        nMaxThreeKind : integer;
        TmpCardData : TCardData;
begin
        // 抓最大的三條
        for i := High(m_aSumIndex) downto 1 do begin
            if m_aSumIndex[i] = 3 then begin

                for j := m_CardDataList.Count - 1 downto 0 do begin
                    TmpCardData := m_CardDataList.GetItems(j);
                    if TmpCardData.Index = i then begin
                        m_MaxRulePoker.Add(TmpCardData);
                    end;

                    if m_MaxRulePoker.Count = 3 then
                        Break;
                end;
                nMaxThreeKind := i;
                Break;
            end;
        end;

        // 抓最大的對子
        for i := High(m_aSumIndex) downto 1 do begin
            if m_aSumIndex[i] >= 2 then begin
                if i = nMaxThreeKind then begin
                    continue;
                end;

                for j := m_CardDataList.Count - 1 downto 0 do begin
                    TmpCardData := m_CardDataList.GetItems(j);
                    if TmpCardData.Index = i then begin
                        m_MaxRulePoker.Add(TmpCardData);
                    end;

                    if m_MaxRulePoker.Count = 5 then begin
                        Exit;
                    end;
                end;
            end;
        end;

end;


//******************************************************************************
// 函式名稱：_OnMaxPokerFourKind
// 功　　能：將牌形 鐵支 的最大五張牌抓出來
//******************************************************************************
procedure TuPokerRule._OnMaxPokerFourKind;
var
        i: integer;
        j: integer;
        nMaxFourKind : integer;
        TmpCardData : TCardData;
begin
        // 抓最大的鐵支四張
        for i := High(m_aSumIndex) downto 1 do begin
            if m_aSumIndex[i] = 4 then begin

                for j := m_CardDataList.Count - 1 downto 0 do begin
                    TmpCardData := m_CardDataList.GetItems(j);
                    if TmpCardData.Index = i then begin
                        m_MaxRulePoker.Add(TmpCardData);
                    end;

                    if m_MaxRulePoker.Count = 4 then
                        Break;
                end;
                nMaxFourKind := i;
                Break;
            end;
        end;

        // 抓滿五張
        for j := m_CardDataList.Count - 1 downto 0 do begin
            TmpCardData := m_CardDataList.GetItems(j);
            if TmpCardData.Index = nMaxFourKind then begin
                Continue;
            end;

            m_MaxRulePoker.Add(TmpCardData);
            if m_MaxRulePoker.Count = 5 then begin
                Break;
            end;
        end;

end;


//******************************************************************************
// 函式名稱：_OnMaxPokerStraightFlush
// 功　　能：將牌形 同花順 的最大五張牌抓出來
//******************************************************************************
procedure TuPokerRule._OnMaxPokerStraightFlush;
var
        i : integer;

        nCardDataIndex : integer;
        nCardDataNextIndex : Integer;
        nCountStraight : integer;
        nMaxCountStraight : integer;

        TmpCardData : TCardData;
        TmpCardDataNext : TCardData;

        nCategory : integer;
begin
        _debug_LogPoker();

        nCategory := _GetFlushIndex();

        
        nCountStraight := 0;
        nMaxCountStraight := 0;

        nCardDataIndex := m_CardDataList.Count - 1;
        for i := m_CardDataList.Count - 1 downto 1 do begin

            TmpCardData := m_CardDataList.GetItems(nCardDataIndex);
            while TmpCardData.Category <> nCategory do begin
                nCardDataIndex := nCardDataIndex - 1;
                TmpCardData := m_CardDataList.GetItems(nCardDataIndex);
            end;

            nCardDataNextIndex := nCardDataIndex - 1;
            TmpCardDataNext := m_CardDataList.GetItems(nCardDataNextIndex);
            while (nCardDataNextIndex > 0 ) And
                (TmpCardDataNext.Category <> nCategory) do begin
                nCardDataNextIndex := nCardDataNextIndex - 1;
                TmpCardDataNext := m_CardDataList.GetItems(nCardDataNextIndex);
            end;

            // 先加入第一張牌
            if m_MaxRulePoker.Count = 0 then
                m_MaxRulePoker.Add(TmpCardData);

//            同樣花色不可能數字一樣 // 如果 兩張牌面數字一樣 換下一張
//            while TmpCardData.Index = (TmpCardDataNext.Index ) do begin
//                nCardDataNextIndex := nCardDataNextIndex - 1;
//                TmpCardDataNext := m_CardDataList[nCardDataNextIndex];
//            end;

            // 下一張是不是比前一張少一
            if TmpCardData.Index = (TmpCardDataNext.Index + 1) then begin
                m_MaxRulePoker.Add(TmpCardDataNext);
            end else begin
                m_MaxRulePoker.Clear;
            end;

            // 超過五張
            if m_MaxRulePoker.Count = 5 then
                Break;

            nCardDataIndex := nCardDataNextIndex;
//            nCardDataNextIndex := nCardDataNextIndex - 1;

            if nCardDataIndex = 0 then begin
                Break;
            end;

        end;

        // 如果是小順 要另外處理A
        if m_aSumRules[POKER_RULES_SMALL_STRAIGHT] <> 0 then begin
            for i := m_CardDataList.Count - 1 downto 0 do begin
                TmpCardData := m_CardDataList.GetItems(i);
                if TmpCardData.Index = 13 then begin
                    m_MaxRulePoker.Add(TmpCardData);
                    break;
                end;
            end;
        end;

end;


//******************************************************************************
// 函式名稱：_GetFlushIndex
// 功　　能：傳回同花的花色索引
//******************************************************************************
function TuPokerRule._GetFlushIndex: Integer;
var
        i:integer;
begin

        Result := -1 ;
        // 查一下什麼同花
        for i := 0 to High(m_aCategory) do
        begin
            if( m_aCategory[i] >= 5 ) then
            begin
                Result := i;
                break;
            end;
        end;

        if Result = -1 then begin
            Result := 0;
        end;

        
end;


procedure TuPokerRule._debug_LogPoker;
var
        i:Integer;
        str:String;
        strPoker:string;
        TmpCardData : TCardData;
begin
        exit;
        str := '';
        strPoker := '';
        for i := m_CardDataList.Count -1 downto 0 do begin
            TmpCardData := m_CardDataList.GetItems(i);
            str := Format('%d ', [TmpCardData.Index] );
            strPoker := strPoker + str;
        end;
        m_PokerRuleMessToFiles.m_WriteTXTOne(strPoker, 1);

end;


end.

應該感受的出來這一份代碼表現的緊張, 在時間壓力下寫出來的代碼實在是慘無人道丫!

在接下來的C++版時會大力的改善 Switch 實在是個使用多型的好地方!

CuCompositeImage

2010-02-11T15:41:00.000-08:00



//

class CuCompositeImage
{

    vector<IuImageEx*> _itsImage;

public:
    int GetSize();
    virtual IuImageEx* Get(int i){ return i < _itsImage.size() ? _itsImage[i] : NULL; }

    void clear();


    void add(IuImageEx* pImage){ _itsImage.push_back(pImage); }
    void push_back(IuImageEx* pImage){ _itsImage.push_back(pImage); }

    CuCompositeImage();
    virtual ~CuCompositeImage();

};


//


CuCompositeImage::CuCompositeImage()
{

}

CuCompositeImage::~CuCompositeImage()
{
}



void CuCompositeImage::clear()
{

    IuImageEx *pImage;
    vector<IuImageEx*>::iterator _itor; 

    _itor = _itsImage.begin();

    while(  _itor != _itsImage.end() )
    {

        pImage = *(_itor++);
        if( pImage )
            pImage->Release();
    }

    _itsImage.clear();

}

int CuCompositeImage::GetSize()
{
    return _itsImage.size();
}

在TuComposite還沒獨立出來之前, 每個需要Composite的部份都需要像上面這樣另外寫一份,也就是為何後來直接將Composite轉為Template的主要原因.

CuFont

2010-02-10T15:30:00.001-08:00




//


class CuFont  
{
    HDC m_hDC;
    HFONT m_hFont;

public:
    void Release();
    void SetFontSize(int iFontSize);
    CuFont(HDC hDC);
    virtual ~CuFont();


private:
    CuFont(){}

};


//


CuFont::CuFont(HDC hDC):
m_hFont(NULL)
{
    m_hDC = hDC;
}

CuFont::~CuFont()
{

    if( m_hDC )
        Release();
}

void CuFont::SetFontSize(int iFontSize)
{
    if( !m_hDC )
        return;

    HFONT hFontCreated = NULL;
    HFONT hFont = (HFONT) GetStockObject(SYSTEM_FONT);

    hFontCreated = CuFontManager::Instance()->GetFontHandle(hFont, iFontSize);

    m_hFont = (HFONT)::SelectObject(m_hDC, hFontCreated);

    DeleteObject(hFont);

}

void CuFont::Release()
{
    if( m_hDC && m_hFont )
    {
        HFONT hFontCreated = (HFONT)::SelectObject(m_hDC, m_hFont);
    }

    m_hDC = NULL;
}

CuTimeZone -

2010-02-09T15:17:00.000-08:00

//


#define RV_TIMEZONES    TEXT("Time Zones")
#define RK_CLOCK        TEXT("Software\\Microsoft\\Clock")
#define RV_INDST        TEXT("HomeDST")                     // are we currently in DST
#define RV_AUTODST      TEXT("AutoDST")
#define RV_DSTUI        TEXT("ShowDSTUI") 
#define RV_TIMEZONES    TEXT("Time Zones")
#define RV_DISPLAY      TEXT("Display")
#define RV_TZI          TEXT("TZI")
#define RV_DLT          TEXT("Dlt")
#define RV_STD          TEXT("Std")

#define ZoneHasDaylightTime(tzi)    (tzi.DaylightDate.wMonth && tzi.DaylightBias)

struct TZREG {
    LONG    Bias;
    LONG    StandardBias;
    LONG    DaylightBias;
    SYSTEMTIME StandardDate;
    SYSTEMTIME DaylightDate;
};

class CuTimeZone
{
    TIME_ZONE_INFORMATION m_TimeZoneInformation;

    vector<wstring> m_vecTimeZoneList;
    wstring m_strCurrZone;
    int m_nCurrZone;

public:
    CuTimeZone();
    virtual ~CuTimeZone();

    void Init();
    vector<wstring> &GetTimeZoneList(void);

    wstring GetCurrZone(){ return m_strCurrZone; }
    int GetCurrZoneIndex(){ return m_nCurrZone; }

    void SetCurrZone(int nCurrZone);
    void SetCurrZone(wstring strCurrZone);


};


//

CuTimeZone::~CuTimeZone()
{

}


CuTimeZone::CuTimeZone()
{
    CReg   Reg1(HKEY_LOCAL_MACHINE, RV_TIMEZONES), Reg2;

    TCHAR  szTimeZone[64];
    TCHAR  szTimeZoneStd[64];
    
//  TIME_ZONE_INFORMATION tziCurrent;
    DWORD tzid = GetTimeZoneInformation(&m_TimeZoneInformation);


    // Get DAYLIGHT States
    BOOL fInDST = (TIME_ZONE_ID_DAYLIGHT == tzid );

    CReg reg(HKEY_LOCAL_MACHINE, RK_CLOCK);
    reg.SetDW(RV_DSTUI, 1);

    
    while(Reg1.EnumKey(szTimeZone,64))
    {
        LPTSTR szTemp;
        Reg2.Reset();
        
        if(Reg2.Open(Reg1,szTimeZone))
        {
        
            // use the display name rather than the standard name 
            szTemp = (LPTSTR)Reg2.ValueSZ(RV_DISPLAY);

            Reg2.ValueSZ(RV_STD, szTimeZoneStd, sizeof(szTimeZoneStd));


            if(szTemp && 
                    ( !lstrcmp(szTimeZone, m_TimeZoneInformation.StandardName) ||
                      !lstrcmp(szTimeZoneStd, m_TimeZoneInformation.StandardName) )
                )
            {
                //lstrcpy(szZoneCurr,szTemp);
                m_nCurrZone = m_vecTimeZoneList.size();
                m_strCurrZone = szTemp;
            }

            m_vecTimeZoneList.push_back(szTemp);
        }

    }

}



vector<wstring> &CuTimeZone::GetTimeZoneList(void)
{
    return m_vecTimeZoneList;
}

void CuTimeZone::SetCurrZone(int nCurrZone)
{

    wstring strCurrZone = m_vecTimeZoneList[nCurrZone];
    SetCurrZone(strCurrZone);
}


void CuTimeZone::SetCurrZone(wstring strCurrZone)
{
    // Iterate over all timezones. Init new timezone to current just in case 
    TCHAR   szTimeZone[32];
    CReg    Reg1(HKEY_LOCAL_MACHINE, RV_TIMEZONES), Reg2;
    CReg reg(HKEY_LOCAL_MACHINE, RK_CLOCK);
    BOOL fUseDST =  ZoneHasDaylightTime(m_TimeZoneInformation);

    reg.SetDW(RV_AUTODST, fUseDST);
    while(Reg1.EnumKey(szTimeZone,32))
    {
        Reg2.Reset();
        if(Reg2.Open(Reg1,szTimeZone))
        {
            // if the display name matches the one in the combobox get the TZI data.
            if(!lstrcmp(strCurrZone.c_str(), Reg2.ValueSZ(RV_DISPLAY)))
            {
                TZREG  *pTZR = (TZREG*)Reg2.ValueBinary(RV_TZI);
                if(pTZR)
                {
                    m_TimeZoneInformation.Bias = pTZR->Bias;
                    m_TimeZoneInformation.StandardBias = pTZR->StandardBias;
                    m_TimeZoneInformation.DaylightBias = pTZR->DaylightBias;
                    m_TimeZoneInformation.StandardDate = pTZR->StandardDate;
                    m_TimeZoneInformation.DaylightDate = pTZR->DaylightDate;
                            
                    Reg2.ValueSZ(RV_DLT, m_TimeZoneInformation.DaylightName, 32);
                    lstrcpy(m_TimeZoneInformation.StandardName, szTimeZone);

                    m_strCurrZone = strCurrZone;
                    break;
                }
            }
        }
    }
    SetTimeZoneInformation(&m_TimeZoneInformation);


}

很特別的程式片段, 從APP裡移出來後就沒在理他, 等他被review 或需要改動功能時, 在來調整了

CuFontManager

2010-02-08T15:00:00.000-08:00



// CuFontManager.h



class CuFontManager  
{
private:
    static  CuFontManager   m_pInstance; 
    map<int, HFONT>       m_mapFontHandle;

    CuFontManager();
public:
    virtual ~CuFontManager();

    static CuFontManager *Instance()
    {
        return &m_pInstance;
    }

    HFONT GetFontHandle(HFONT hFont,int iFontSize);
};


// CuFontManager.cpp



CuFontManager CuFontManager::m_pInstance;

CuFontManager::CuFontManager()
{

}

CuFontManager::~CuFontManager()
{
    map<int, HFONT>::iterator it;

    for(it = m_mapFontHandle.begin(); it != m_mapFontHandle.end(); it++) {
        HFONT hFontCreated = it->second;
        DeleteObject(hFontCreated);
    }

    m_mapFontHandle.clear();
}

HFONT CuFontManager::GetFontHandle(HFONT hFont,int iFontSize)
{
    HFONT hFontCreated;
    LOGFONT lf;
    map<int, HFONT>::const_iterator it;

    it = m_mapFontHandle.find(iFontSize);

    if(it == m_mapFontHandle.end()) {
        if (GetObject(hFont, sizeof LOGFONT, &lf)) {
            HDC hDC;

            hDC = ::GetDC(NULL);
            lf.lfHeight=-((iFontSize * GetDeviceCaps(hDC, LOGPIXELSY)) / 72);
            lf.lfWeight = FW_SEMIBOLD;

            hFontCreated = CreateFontIndirect(&lf);
            m_mapFontHandle.insert(map<int, HFONT>::value_type(iFontSize, hFontCreated));
            ReleaseDC(NULL, hDC);
        }
    }
    else
        hFontCreated = it->second;

    return hFontCreated;
}

CuLight

2010-02-07T16:35:00.001-08:00

//


class CuLight  
{
    // CuLight 一實體後預存的值
    // 在解構時會將這個值寫回registey
    int m_nDefaultValue;

    LIGHT_INCVALUE  m_pfIncValue;
    LIGHT_DECVALUE  m_pfDecValue;
    LIGHT_GETVALUE  m_pfGetValue;
    LIGHT_SETVALUE  m_pfSetValue;

    LIGHT_GETMAXSTEP m_pfGetMaxStep;

    CuDllManager m_LightDll;


public:
    wstring strDllfile;
    

    CuLight();
    virtual ~CuLight(); 


    void Init();
    int OnGetValue(void);
    void OnSetValue(int n);

    void OnDecValue();
    void OnIncValue();
    void OnSave(){ m_nDefaultValue = OnGetValue(); }

    int OnGetMaxStep(){ return m_pfGetMaxStep(); }


};



//


CuLight::CuLight()
{

}

CuLight::~CuLight()
{
    OnSetValue(m_nDefaultValue);
}

void CuLight::Init()
{

    CuFile f;
    wstring strFile = f.GetModuleFileName(strDllfile.c_str());

    Verify(m_LightDll.LoadLibrary(strFile.c_str()) != NULL, L"can't Load Light_dll.dll Error");


    m_pfIncValue = (LIGHT_INCVALUE)m_LightDll.GetProcAddress(L"IncValue");
    Assert(m_pfIncValue != NULL, L"can't Load LIGHT_INCVALUE");

    m_pfDecValue = (LIGHT_DECVALUE)m_LightDll.GetProcAddress(L"DecValue");
    Assert(m_pfDecValue != NULL, L"can't Load LIGHT_DECVALUE");

    m_pfGetValue = (LIGHT_GETVALUE)m_LightDll.GetProcAddress(L"GetValue");
    Assert(m_pfGetValue != NULL, L"can't Load LIGHT_GETVALUE");

    m_pfSetValue = (LIGHT_SETVALUE)m_LightDll.GetProcAddress(L"SetValue");
    Assert(m_pfSetValue != NULL, L"can't Load LIGHT_SETVALUE");

    m_pfGetMaxStep = (LIGHT_GETMAXSTEP)m_LightDll.GetProcAddress(L"GetMaxStep");
    Assert(m_pfGetMaxStep != NULL, L"can't Load LIGHT_GETMAXSTEP");

    m_nDefaultValue = OnGetValue();

}

int CuLight::OnGetValue(void)
{ 
    int value;
    value = m_pfGetValue(); 
    return value;
}
void CuLight::OnSetValue(int n)
{ 
    m_pfSetValue(n); 
}

void CuLight::OnDecValue()
{
    m_pfDecValue(); 

    int value;
    value = m_pfGetValue(); 

}

void CuLight::OnIncValue()
{
    m_pfIncValue(); 
    int value;
    value = m_pfGetValue(); 

}

CE沒有標準, 所以定個介面元件對不同的機器實作獨一的DLL檔! 在設定檔裡指定要載入那一份DLL!

CuWinAppEx

2010-02-06T15:00:00.000-08:00




// CuWinAppEx.h

class CuWinAppEx
{
private:
    static CuWinAppEx *m_pWinApp;

protected:

    class CuMainWnd : public CuWnd
    {
        virtual LRESULT OnMsg(MSG &msg)
        {
            return CuWinAppEx::GetTheApp()->OnMsg(msg);
        };
    };

    CuMainWnd m_MainWnd;

public:
    CuWinAppEx(void);
    virtual ~CuWinAppEx(void);


public:
    static CuWinAppEx* GetTheApp(); 
    virtual LRESULT OnMsg(MSG & msg);
    virtual BOOL Run();

public:
    int OnDestroy(void);
};


// CuWinAppEx.cpp



CuWinAppEx *CuWinAppEx::m_pWinApp;

CuWinAppEx::CuWinAppEx(void)
{
    m_pWinApp = this;
}

CuWinAppEx::~CuWinAppEx(void)
{
}

CuWinAppEx* CuWinAppEx::GetTheApp()
{
    return m_pWinApp;
}

LRESULT CuWinAppEx::OnMsg(MSG & msg)
{

    switch(msg.message)
    {
    case WM_DESTROY:
        OnDestroy();
        break;

    default:
        return FALSE;
    }

    return TRUE;
}

int CuWinAppEx::OnDestroy(void)
{
     ::PostQuitMessage(0);

     return 0;
}


BOOL CuWinAppEx::Run()
{
    MSG msg;

    // Main message loop:
    while (GetMessage(&msg, NULL, 0, 0)) 
    {
        //      if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    return msg.wParam;
}

雖然函式裡有virtual 但有時後並不代表這個類別是打算被繼承的, 有一半是這個類別繼承了別人, 但在解構式定為virtual就表示, 這個類別100%是可以被繼承的, 或是一定要被繼承!

IuImageEx

2010-02-05T15:00:00.000-08:00

class IuImageEx : public IuUnknown
{
public:
    virtual BOOL    Create( int nWidth, int nHeight, int nBPP = 16) = 0;

    virtual BYTE*   Data(void) = 0; 

    virtual UINT    Height() = 0;
    virtual void    Height(UINT nHeight) = 0;

    virtual UINT    Width() = 0;
    virtual void    Width(UINT nWidth) = 0;

    virtual UINT    BitCount() = 0;
    virtual void    BitCount(UINT nBitCount) = 0;

    virtual COLORREF GetPixel( int x, int y) = 0;
};

圖型編碼太多種, 但實際使用時, 也只有用到部份函式, 整個拉出介面時, 才發現用到的不多!

IuImageWnd

2010-02-04T15:00:00.000-08:00

class IuImageWnd : public IuImageEx
{
public:
    virtual HDC GetDC() = 0;
    virtual void ReleaseDC() = 0;

    virtual BOOL BitBlt( HDC hDestDC, int xDest, int yDest, int nDestWidth, 
        int nDestHeight, int xSrc, int ySrc, DWORD dwROP = SRCCOPY ) = 0;

    virtual BOOL StretchBlt( HDC hDestDC, int xDest, int yDest, 
        int nDestWidth, int nDestHeight, int xSrc, int ySrc, int nSrcWidth, 
        int nSrcHeight, DWORD dwROP = SRCCOPY ) = 0;


    virtual operator HBITMAP() const = 0;

};

不管學院派對介面的定義為何! 在這裡介面獨立最好的地方是, 看起來就是輕巧, 使用起來壓力會小很多, 不必為了看到源碼或是太多功能搞的自己頭大!

CuImageEx

2010-02-03T15:00:00.000-08:00

// CuImageEx.h



class CuImageEx : public IuImageEx 
{
    //圖高
    UINT    _nHeight;

    //圖寬
    UINT    _nWidth;

    // 圖的色素  :  16  
    UINT    _nBitCount;

    // 存放 圖形點陣列
    BYTE    *_bits;


public:
    CuImageEx();
    virtual ~CuImageEx();

    //////////////////////////////////////////////////////////////////
    // IuUnknown 公開虛擬界面 
    virtual ULONG Release();

    //////////////////////////////////////////////////////////////////
    // IuImage 公開虛擬界面 
    virtual BOOL Create(int nWidth, int nHeight, int nBPP = 16);

    virtual UINT    Height(){ return _nHeight; }
    virtual void    Height(UINT nHeight){ _nHeight = nHeight; }

    virtual UINT    Width(){ return _nWidth; }
    virtual void    Width(UINT nWidth){ _nWidth = nWidth; }

    virtual UINT    BitCount(){ return _nBitCount; }
    virtual void    BitCount(UINT nBitCount){ _nBitCount = nBitCount; }

    virtual COLORREF GetPixel( int x, int y);
    virtual BYTE*   Data(void){ return _bits; }


    //////////////////////////////////////////////////////////////////
    // 未公開虛擬界面 的 public 函式

    void Data(BYTE *pDate){ _bits = pDate; }

    void Destroy();

private:
    CuImageEx& operator =(CuImageEx& img);

};

 
// CuImageEx.cpp


CuImageEx::CuImageEx()
:_nHeight(0)
,_nWidth(0)
,_nBitCount(0)
,_bits(NULL)
{
}

CuImageEx::~CuImageEx()
{
    Destroy();
}

ULONG CuImageEx::Release()
{
    delete this;
    return 0;
}

BOOL CuImageEx::Create(int nWidth, int nHeight, int nBPP)
{

    Destroy();

    Height(nHeight);
    Width(nWidth);
    BitCount(nBPP);

    _bits = new BYTE[nWidth * nHeight * (nBPP >> 3)];

    return (_bits != NULL);

}

void CuImageEx::Destroy()
{

    Height(0);
    Width(0);
    BitCount(0);

    delete [] _bits;
    _bits = NULL;

}

COLORREF CuImageEx::GetPixel( int x, int y)
{

    WORD *pBits = (WORD*)this->Data();

    if( !pBits )
        return RGB(0, 0, 0);

    int nW = Width() ;

    // 
    if( nW % 2 )
        nW++;

    WORD wPixel = pBits[y * nW + x];

    return RGB( (wPixel >> 10 ) & 0x1f,
        (wPixel >> 5) & 0x1f,
        wPixel & 0x1f);
}

CuImageEx& CuImageEx::operator =(CuImageEx& img)
{
    
    if( this == &img )
        return *this;
    
    this->Create(img.Width() , img.Height(), img.BitCount() );

    memcpy(_bits, img._bits, _nWidth  * _nHeight * ( _nBitCount >> 3 ) );
        
    return *this;

}

與CuImageWnd 相異的地方在於, 若已經有一份點陣DC時, 其實其他的圖型運算是可以使用自製效能優化過的元件! 在這裡縮小圖結構方便替換運算元件!

CuImageWnd

2010-02-02T15:00:00.000-08:00

// CuImageWnd.h



class CuImageWnd : public IuImageWnd
{

    // Image 的控制代碼
    HBITMAP m_hBitmap;

    // GetDC 時　暫存用的控制代碼
    HBITMAP m_hOldBitmap;

    // GetDC 時　暫存的DC控制代碼
    HDC m_hDC;

    // DC使用參考計數
    UINT m_nDCRefCount;

    CuImageEx m_ImageEx;
public:

    CuImageWnd();
    virtual ~CuImageWnd();

    //////////////////////////////////////////////////////////////////
    // IuUnknown 公開虛擬界面 
    virtual ULONG Release();

    //////////////////////////////////////////////////////////////////
    // IuImage 公開虛擬界面 
    virtual BOOL Create( int nWidth, int nHeight, int nBPP);

    virtual UINT    Height(){ return m_ImageEx.Height(); }
    virtual void    Height(UINT nHeight){ m_ImageEx.Height(nHeight); }

    virtual UINT    Width(){ return m_ImageEx.Width(); }
    virtual void    Width(UINT nWidth){ m_ImageEx.Width(nWidth); }

    virtual UINT    BitCount(){ return m_ImageEx.BitCount(); }
    virtual void    BitCount(UINT nBitCount){ m_ImageEx.BitCount(nBitCount); }

    virtual COLORREF GetPixel( int x, int y){ return m_ImageEx.GetPixel(x,y); }
    virtual BYTE*   Data(void){ return m_ImageEx.Data(); }

    //////////////////////////////////////////////////////////////////
    // IuImageWnd 公開虛擬界面 

        // window 支援函式


    virtual HDC GetDC();
    virtual void ReleaseDC();

    virtual BOOL BitBlt( HDC hDestDC, int xDest, int yDest, int nDestWidth, 
        int nDestHeight, int xSrc, int ySrc, DWORD dwROP = SRCCOPY );

    virtual BOOL StretchBlt( HDC hDestDC, int xDest, int yDest, 
        int nDestWidth, int nDestHeight, int xSrc, int ySrc, int nSrcWidth, 
        int nSrcHeight, DWORD dwROP = SRCCOPY );

    virtual operator HBITMAP() const;

    ///////////////////////////////////////////////////////////////////


    //////////////////////////////////////////////////////////////////
    // 未公開虛擬界面 的 public 函式
    void Destroy();

};



// CuImageWnd.cpp


CuImageWnd::CuImageWnd()
:m_hBitmap(NULL)
,m_hOldBitmap(NULL)
,m_hDC(NULL)
,m_nDCRefCount(0)
{
}


CuImageWnd::~CuImageWnd()
{

    Destroy();
}

ULONG CuImageWnd::Release()
{
    delete this;
    return 0;
}

BOOL CuImageWnd::Create( int nWidth, int nHeight, int nBPP)
{

    Destroy();

    BITMAPINFO  dibInfo;
    dibInfo.bmiHeader.biBitCount = nBPP;
    dibInfo.bmiHeader.biClrImportant = 0;
    dibInfo.bmiHeader.biClrUsed = 0;
    dibInfo.bmiHeader.biCompression = BI_RGB;
    dibInfo.bmiHeader.biHeight = nHeight;
    dibInfo.bmiHeader.biPlanes = 1;
    dibInfo.bmiHeader.biSize = sizeof( BITMAPINFOHEADER );
    dibInfo.bmiHeader.biSizeImage = nWidth * nHeight * (nBPP >> 3 );
    dibInfo.bmiHeader.biWidth = nWidth;
    dibInfo.bmiHeader.biXPelsPerMeter = 0;
    dibInfo.bmiHeader.biYPelsPerMeter = 0;
    dibInfo.bmiColors[0].rgbBlue = 0;
    dibInfo.bmiColors[0].rgbGreen = 0;
    dibInfo.bmiColors[0].rgbRed = 0;
    dibInfo.bmiColors[0].rgbReserved = 0;

    Height(nHeight);
    Width(nWidth);
    BitCount(nBPP);

    void* ppvBits ;//= Data();

    m_hBitmap = ::CreateDIBSection(NULL, &dibInfo, DIB_RGB_COLORS,
        (void**)&ppvBits, NULL, 0);

    m_ImageEx.Data((BYTE*)ppvBits);
    
    return (BOOL)m_hBitmap;

}

void CuImageWnd::Destroy()
{
    if( m_hBitmap )
    {
        ::DeleteObject(m_hBitmap);
        m_hBitmap = NULL;
    }

    m_ImageEx.Data(0);

    Height(0);
    Width(0);
    BitCount(0);

}

HDC CuImageWnd::GetDC() 
{

    Assert(m_hBitmap != NULL, L" CuImage::GetDC() m_hBitmap != NULL");
    
    m_nDCRefCount++;
    if( m_hDC == NULL )
    {
        m_hDC = ::CreateCompatibleDC(NULL);
        m_hOldBitmap = HBITMAP(::SelectObject( m_hDC, m_hBitmap ));
    }

    return m_hDC;
}

void CuImageWnd::ReleaseDC() 
{
    HBITMAP hBitmap;

    Assert( m_hDC != NULL, L"");

    m_nDCRefCount--;
    if( m_nDCRefCount == 0 )
    {
        hBitmap = HBITMAP( ::SelectObject( m_hDC, m_hOldBitmap ) );
        Assert( hBitmap == m_hBitmap ,L"");
        ::DeleteDC( m_hDC );
        m_hDC = NULL;
    }
}


BOOL CuImageWnd::StretchBlt( HDC hDestDC, int xDest, int yDest, 
    int nDestWidth, int nDestHeight, int xSrc, int ySrc, int nSrcWidth, 
    int nSrcHeight, DWORD dwROP ) 
{

    BOOL bResult;

    Assert( m_hBitmap != NULL, L"" );
    Assert( hDestDC != NULL, L"" );

    HDC hDC = this->GetDC();

    bResult = ::StretchBlt( hDestDC, xDest, yDest, nDestWidth, nDestHeight, hDC,
        xSrc, ySrc, nSrcWidth, nSrcHeight, dwROP );

    this->ReleaseDC();

    return( bResult );

}


BOOL CuImageWnd::BitBlt( HDC hDestDC, int xDest, int yDest, int nDestWidth, 
    int nDestHeight, int xSrc, int ySrc, DWORD dwROP )
{
    BOOL bResult;
 
    Assert( m_hBitmap != NULL, L"");
    Assert( hDestDC != NULL, L"");

    GetDC();

    bResult = ::BitBlt( hDestDC, xDest, yDest, nDestWidth, nDestHeight, m_hDC, 
        xSrc, ySrc, dwROP );

    ReleaseDC();

    return( bResult );
}

CuImageWnd::operator HBITMAP() const
    { return m_hBitmap; }

支援Windows 專用的部份函式型別轉換: HDC HBITMAP 當然還有最重要的點陣資料集

CuWaitKeyEven - 等待外部文字檔標示的EVENT

2010-02-01T15:00:00.000-08:00

// CuWaitKeyEven.h



class CuWaitKeyEven  
{

    CuWinThread *m_pProcessThread;
public:
    wstring m_strSys;

    HANDLE  *_pHandleArray;

    wstring *_pStrEven;

    int _nNumEvent;

    // 程式設定檔

    CuWaitKeyEven();
    virtual ~CuWaitKeyEven();

    void Init();
    static DWORD Process(LPVOID lpVoid);
};


// CuWaitKeyEven.cpp


CuWaitKeyEven::CuWaitKeyEven()
:m_strSys(L"HardKey_sys.cfg")
,_pHandleArray(NULL)
,_nNumEvent(0)
,_pStrEven(NULL)
,m_pProcessThread(NULL)

{

}

CuWaitKeyEven::~CuWaitKeyEven()
{

    if( m_pProcessThread )
    {
        m_pProcessThread->Delete();
    }

    if( _pHandleArray )
    {
        for( int i = 0 ; i < _nNumEvent ; i++ )
        {
            CloseHandle(_pHandleArray[i]);
        }
        delete [] _pHandleArray;
    }

    if( _pStrEven )
        delete [] _pStrEven;


}

DWORD CuWaitKeyEven::Process(LPVOID lpVoid)
{

    CuWaitKeyEven *pWaitKeyEven = (CuWaitKeyEven *)lpVoid;
 
    DWORD dwResult;
    int nIndex;
    while (1)
    {
        dwResult = WaitForMultipleObjects(pWaitKeyEven->_nNumEvent, pWaitKeyEven->_pHandleArray, FALSE, INFINITE);

        keybd_event(VK_F12, 0, 0 ,0);
        keybd_event(VK_F12, 0, KEYEVENTF_KEYUP,0);


        nIndex = dwResult - WAIT_OBJECT_0;

        ResetEvent(pWaitKeyEven->_pHandleArray[nIndex]);

        PostMessage(GetTheApp()->m_hWnd, WM_HR_PROCESS, (WPARAM)(void*)pWaitKeyEven->_pStrEven[nIndex].c_str(), (LPARAM)pWaitKeyEven);

    }

    return 0;
}



void CuWaitKeyEven::Init()
{
    
    CuModuleFile mf;
    wstring strTempSysName = mf.GetModuleFileName(m_strSys.c_str());

    IuFileLex *pFileLex;
    pFileLex = new CuFileLex;
    
    pFileLex->Open(strTempSysName.c_str(), L"r");
    
    pFileLex->_readInt(_nNumEvent);
    
    if( _nNumEvent )
    {
        _pHandleArray = new HANDLE[_nNumEvent];
        _pStrEven = new wstring[_nNumEvent];
        
        wstring strEven;
        for( int i = 0 ; i < _nNumEvent ; i++ )
        {
            pFileLex->_readString(strEven);
            _pStrEven[i] = strEven;
            _pHandleArray[i] =  CreateEvent( NULL, TRUE, FALSE, strEven.c_str()) ;
        }
        
        
        m_pProcessThread = ::_BeginThread((_THREADPROC)CuWaitKeyEven::Process, (LPVOID)this);
    }
    pFileLex->Release();

}

CuToolhelp - Takes a snapshot of the specified processes

2010-01-31T15:00:00.000-08:00

//  Takes a snapshot of the specified processes




// CuToolhelp.h


class CuToolhelp  
{
    HANDLE  m_hSnapshot;

public:
    CuToolhelp();
    virtual ~CuToolhelp();

    BOOL CreateSnapshot(DWORD dwFlags, DWORD dwProcessID = 0);
    void CloseSnapshot();

    BOOL ProcessFirst(PPROCESSENTRY32 ppe) const;
    BOOL ProcessNext(PPROCESSENTRY32 ppe) const;
    BOOL ProcessFind(DWORD dwProcessID, PPROCESSENTRY32 ppe) ;
    BOOL ProcessFind(wstring strExeFile, PPROCESSENTRY32 ppe) ;
};


// CuToolhelp.cpp



CuToolhelp::CuToolhelp()
:m_hSnapshot(INVALID_HANDLE_VALUE)
{

}

CuToolhelp::~CuToolhelp()
{
    CloseSnapshot();
}

BOOL CuToolhelp::CreateSnapshot(DWORD dwFlags, DWORD dwProcessID)
{
    CloseSnapshot();

    if( dwFlags == 0 )
    {
        m_hSnapshot = INVALID_HANDLE_VALUE;
    }
    else
    {
        m_hSnapshot = CreateToolhelp32Snapshot(dwFlags, dwProcessID);
    }

    return (m_hSnapshot != INVALID_HANDLE_VALUE);

}

void CuToolhelp::CloseSnapshot()
{
    if( m_hSnapshot != INVALID_HANDLE_VALUE )
        CloseToolhelp32Snapshot(m_hSnapshot);
}

BOOL CuToolhelp::ProcessFirst(PPROCESSENTRY32 ppe) const
{
    BOOL fOk = ::Process32First(m_hSnapshot, ppe);

    // Remove the "[ System Process]" (PID = 0)
    if( fOk && (ppe->th32ProcessID == 0 ))
        fOk = ProcessNext(ppe);

    return (fOk);
}

BOOL CuToolhelp::ProcessNext(PPROCESSENTRY32 ppe) const
{
    BOOL fOk = ::Process32Next(m_hSnapshot, ppe);

    // Remove the "[ System Process]" (PID = 0)
    if( fOk && (ppe->th32ProcessID == 0 ))
        fOk = ProcessNext(ppe);

    return (fOk);
}

BOOL CuToolhelp::ProcessFind(DWORD dwProcessID, PPROCESSENTRY32 ppe) 
{

    BOOL bFound = FALSE;
    for( BOOL fOk = ProcessFirst(ppe); fOk; fOk = ProcessNext(ppe) )
    {
        bFound = ( ppe->th32ProcessID == dwProcessID );
        if( bFound )
            break;
    }

    return (bFound);

}
BOOL CuToolhelp::ProcessFind(wstring strExeFile, PPROCESSENTRY32 ppe) 
{

    BOOL bFound = FALSE;
    for( BOOL fOk = ProcessFirst(ppe); fOk; fOk = ProcessNext(ppe) )
    {
        bFound = (strExeFile == ppe->szExeFile);
        if( bFound )
            break;
    }
    return (bFound);

}

TuPowerNotification -

2010-01-30T15:00:00.000-08:00

//
class PowerNotificationTest
{
private:
    TuPowerNotification<PowerNotificationTest> uPowerNotification;

public:
    PowerNotificationTest() {}
    ~PowerNotificationTest() {}

    void Init()
    {
        //初始化 TuPowerNotification
        uPowerNotification.CombineElement(this, PowerNotificationTest::PowerNotify);
        uPowerNotification.RequestPowerNotifications();
    }

    void PowerNotify(PPOWER_BROADCAST ppower_broadcast)
    {
        switch(ppower_broadcast->Message)
        {
           //取得 power status
            case PBT_TRANSITION:

                break;
            case PBT_RESUME:


                break;
            case PBT_POWERSTATUSCHANGE:

                break;

            case PBT_POWERINFOCHANGE:
                break;
        }
 }



// TuPowerNotification.h

template <typename T>
class TuPowerNotification : public CuPowerNotification
{
    typedef void ( T::*POWER_NOTIFICATION_PROC)(PPOWER_BROADCAST ppower_broadcast);
    POWER_NOTIFICATION_PROC m_fpPowerNotificationProc;
    T *m_pElement;
public:

    TuPowerNotification();
    ~TuPowerNotification();
    void CombineElement(T *pElement, POWER_NOTIFICATION_PROC fpTimeOutProc);    
    virtual void OnPowerNotification(PPOWER_BROADCAST ppower_broadcast);

};

template <typename T>
TuPowerNotification<T>::TuPowerNotification()
:m_fpPowerNotificationProc(NULL)
,m_pElement(NULL)
{
}

template <typename T>
TuPowerNotification<T>::~TuPowerNotification()
{
}


template <typename T>
void TuPowerNotification<T>::OnPowerNotification(PPOWER_BROADCAST ppower_broadcast)
{
    if(m_fpPowerNotificationProc)
        (m_pElement->*m_fpPowerNotificationProc)(ppower_broadcast);
}

template <typename T>
void TuPowerNotification<T>::CombineElement(T *pElement, POWER_NOTIFICATION_PROC fpTimeOutProc)
{ 
    m_pElement = pElement; 
    m_fpPowerNotificationProc = fpTimeOutProc;
}

CuFileLex - 文字檔剖析

2010-01-29T15:00:00.000-08:00

// config.sys
--------------------------------------------

TOTAL_ELEMENT_NUM   8

    ELEMENT_NUM 1
        ELEMENT_TYPE        "element"
        ELEMENT_NAME            "background"
        ELEMENT_POINT       0   0
        ELEMENT_NEEDALPHA   0
        TOTAL_PHOTO_NUM     1
            PHOTO_NAME  "media_bg.bmp" 4
        ELEMENT_END

    ELEMENT_NUM 2
        ELEMENT_TYPE        "button"
        ELEMENT_NAME            "close" 
        ELEMENT_POINT       3   3
        ELEMENT_NEEDALPHA   1
        TOTAL_PHOTO_NUM     4
            PHOTO_NAME  "close.bmp" 0
            PHOTO_NAME  "close_alpha.bmp" 1
            PHOTO_NAME  "close_down.bmp" 2
            PHOTO_NAME  "close_down_alpha.bmp" 3
        ELEMENT_END
        BUTTON_END


    ELEMENT_NUM 3
        ELEMENT_TYPE        "commandbt"
        ELEMENT_NAME            "goto-photo"        
        ELEMENT_POINT       208 85
        ELEMENT_NEEDALPHA   1
        TOTAL_PHOTO_NUM     4
            PHOTO_NAME  "photoviewer_Icon.bmp" 13
            PHOTO_NAME  "photoviewer_Icon_alpha.bmp" 14
            PHOTO_NAME  "photoviewer_animation01.bmp" 15
            PHOTO_NAME  "photoviewer_animation01_alpha.bmp" 16
        ELEMENT_END
        BUTTON_END
        COMMANDBT_ACTIVE_NAME   "photoviewv350.exe"
        COMMANDBT_END

    ELEMENT_NUM 4
        ELEMENT_TYPE        "commandbt"
        ELEMENT_NAME            "goto-music"        
        ELEMENT_POINT       14  85
        ELEMENT_NEEDALPHA   1
        TOTAL_PHOTO_NUM     4
            PHOTO_NAME  "music_Icon.bmp" 9
            PHOTO_NAME  "music_Icon_alpha.bmp" 10
            PHOTO_NAME  "music_animation01.bmp" 11
            PHOTO_NAME  "music_animation01_alpha.bmp" 12
        ELEMENT_END
        BUTTON_END
        COMMANDBT_ACTIVE_NAME   "musicv350.exe"
        COMMANDBT_END


    ELEMENT_NUM 5
        ELEMENT_TYPE        "commandbt"
        ELEMENT_NAME            "goto-video"        
        ELEMENT_POINT       113 85
        ELEMENT_NEEDALPHA   1
        TOTAL_PHOTO_NUM     4
            PHOTO_NAME  "movie_Icon.bmp" 5
            PHOTO_NAME  "movie_Icon_alpha.bmp" 6
            PHOTO_NAME  "movie_animation01.bmp" 7
            PHOTO_NAME  "movie_animation01_alpha.bmp" 8
        ELEMENT_END
        BUTTON_END
        COMMANDBT_ACTIVE_NAME   "video\videov350.exe"
        COMMANDBT_END

    ELEMENT_NUM 6
        ELEMENT_TYPE        "statictext" 
        "PhotoView"
        "text-photoview"
        208 180 98  30
        12
        255 255 255

    ELEMENT_NUM 7
        ELEMENT_TYPE        "statictext" 
        "Music"
        "text-music"
        14  180 98  30
        12
        255 255 255



    ELEMENT_NUM 8
        ELEMENT_TYPE        "statictext" 
        "Video"
        "text-Video"
        113 180 98  30
        12
        255 255 255

//




// CuFileLex.h


class CuFileLex
{
    BOOL    m_bUnicode;
    BOOL    _IsUnicodeFile();
    int     _lexw(void);
    int     _lexa(void);

    CuFile  m_File;
public:
    CuFileLex(void);
    ~CuFileLex(void);


    BOOL Open( LPCSTR lpszFileName, LPCSTR lpszOpenMode);
    virtual BOOL Open( LPCTSTR lpszFileName, LPCTSTR lpszOpenMode);

    int _type; // 最後呼叫 _lex() 的字串類型
    wstring _text; // 將讀到的字串 放到這裡

    enum {UNKNOW = 0, INTEGER = 1, FLOAT, SYMBOL, INDEX, STRING, NODE, BLOCKSTART, BLOCKEND};
    // 讀一段字 並分析字串 傳回字串類型
    int _lex(void);

    void _readInt(int &i);
    void _readInt3(int i[3]);
    void _readInt4(int i[4]);
    void _readFloat(float &f);
    void _readFloat3(float f[3]);
    void _readSymbol(wstring &str);
    void _readIndex();
    void _readString(wstring &str);
    void _readNode();
    void _readBlockStart();
    
    int _skip();

};


// CuFileLex.cpp


CuFileLex::CuFileLex(void) : _type(UNKNOW)
{

}

CuFileLex::~CuFileLex(void)
{

}

int CuFileLex::_lex(void)
{

//  static 
//  char check[] = "-0123456789._ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\"{}:*";
                 //"12345678901234567890123456789012345678901234567890123456789012345 678901234
                 //"0        1         2         3         4         5         6          7 
                // 1~11  = INTEGER
                // 12 = FLOAT
                // 13~65 = SYMBOL
                // 69 = INDEX
                // 66 = STRING
                // 70 = NODE  
                // 67 = BLOCKSTART
                // 68 = BLOCKEND

    // 字串分析的權位 左邊比較低 右邊比較高 
//  enum {UNKNOW = 0, INTEGER = 1, FLOAT, SYMBOL, INDEX, STRING, NODE, BLOCKSTART, BLOCKEND};

    _text = L"";

    int result;

    int current_type = 0;  
    int type = UNKNOW; // 分析字串的類型

    bool baString = false; // 當正在讀字串時 會一直讀到 下一個 '\"' 


    // 排除前置空白 換行 定位 字元
    do
    {
        result = m_File.get();
    }while( result != EOF && (result == 9 || result == 32 || result == 13 || result == 10 ));
    

    while(result != EOF)
    {

        // ---------------+---------------
        // 字串種類判段

        if( baString )
        {
            if( result == 0x22 )
                baString = !baString;

        }else if( (result >= 0x41 && result <= 0x5a) ||
                (result >= 0x61 && result <= 0x7a) ||
                (result == 0x5f) )
            current_type = SYMBOL;
        else if( (result >= 0x30 && result <= 0x39) || result == 0x2d  )
            current_type = INTEGER;
        else
        {
            switch( result )
            {
            case 0x2e:
                current_type = FLOAT;
                break;
            case 0x3a:
                current_type = INDEX;
                break;
            case 0x22:
                current_type = STRING;
                baString = !baString;
                break;
            case 0x2a:
                current_type = NODE;
                break;
            case 0x7b:
                current_type = BLOCKSTART;
                break;
            case 0x7d:
                current_type = BLOCKEND;
                break;
            default:
                {
                    _type = type;
                    return type;
                }
            }
        }
        if( type < current_type )
            type = current_type;
        // ---------------+---------------

        _text += result;
        result = m_File.get();

    }

    _type = type;

    return type;
}


int CuFileLex::_lexw(void)
{
//  static 
//  TCHAR check[] = L"-0123456789._ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\"{}:*";
                   //"12345678901234567890123456789012345678901234567890123456789012345 678901234
                   //"0        1         2         3         4         5         6          7 
                // 1~11  = INTEGER
                // 12 = FLOAT
                // 13~65 = SYMBOL
                // 69 = INDEX
                // 66 = STRING
                // 70 = NODE  
                // 67 = BLOCKSTART
                // 68 = BLOCKEND

    // 字串分析的權位 左邊比較低 右邊比較高 
//  enum {UNKNOW = 0, INTEGER = 1, FLOAT, SYMBOL, INDEX, STRING, NODE, BLOCKSTART, BLOCKEND};

    _text = L"";

    WORD result;

    int current_type = 0;  
    int type = UNKNOW; // 分析字串的類型

    bool baString = false; // 當正在讀字串時 會一直讀到 下一個 '\"' 

    int nSizeT = 0;

    // 排除前置空白 換行 定位 字元
    do
    {
        nSizeT = m_File.Read(&result, sizeof(result) );
    }while( nSizeT != 0 && (result != EOF && result == 9 || result == 32 || result == 13 || result == 10 ));
    

    while(result != EOF && nSizeT != 0 )
    {

        // ---------------+---------------
        // 字串種類判段

        if( baString )
        {
            if( result == 0x22 )
                baString = !baString;

        }else if( (result >= 0x41 && result <= 0x5a) ||
                (result >= 0x61 && result <= 0x7a) ||
                (result == 0x5f) )
                current_type = SYMBOL;
        else if( (result >= 0x30 && result <= 0x39) || result == 0x2d  )
            current_type = INTEGER;
        else
        {
            switch( result )
            {
            case 0x2e:
                current_type = FLOAT;
                break;
            case 0x3a:
                current_type = INDEX;
                break;
            case 0x22:
                current_type = STRING;
                baString = !baString;
                break;
            case 0x2a:
                current_type = NODE;
                break;
            case 0x7b:
                current_type = BLOCKSTART;
                break;
            case 0x7d:
                current_type = BLOCKEND;
                break;
            default:
                {
                    _type = type;
                    return type;
                }
            }
        }
        if( type < current_type )
            type = current_type;
        // ---------------+---------------

        _text += result;
        nSizeT = m_File.Read(&result, sizeof(result) );
    }

    _type = type;

    return type;
}

// 讀一段字 並分析字串 傳回字串類型
int CuFileLex::_lex(void)
{
    if( m_bUnicode )
        return _lexw();
    else
        return _lexa();

    return m_bUnicode ? _lexw() : _lexa();
}


// 讀一段字 並分析字串 傳回字串類型

void CuFileLex::_readInt(int &i)
{

    _lex();
    Assert( _type == INTEGER , L"CuFileLex::_readInt: Expected an integer\n");
    swscanf(_text.c_str(), L"%i", &i);

}

void CuFileLex::_readInt3(int i[3])
{

    _readInt(i[0]);
    _readInt(i[1]);
    _readInt(i[2]);

}

void CuFileLex::_readInt4(int i[4])
{

    _readInt(i[0]);
    _readInt(i[1]);
    _readInt(i[2]);
    _readInt(i[3]);

}

void CuFileLex::_readFloat(float &f)
{

    _lex();
    Assert( _type == FLOAT , L"CuFileLex::_readFloat: Expected an float\n");
    swscanf(_text.c_str(), L"%f", &f);

}

void CuFileLex::_readFloat3(float f[3])
{

    _readFloat(f[0]);
    _readFloat(f[1]);
    _readFloat(f[2]);

}

void CuFileLex::_readSymbol(wstring &str)
{

    _lex();
    Assert( _type == SYMBOL , L"CuFileLex::_readSymbol: Expected a symbol\n");
    str = _text;

}

void CuFileLex::_readIndex()
{

    _lex();
    Assert( _type == INDEX , L"CuFileLex::_readIndex: Expected a index\n");

}

void CuFileLex::_readString(wstring &str)
{

    _lex();
    Assert( _type == STRING , L"CuFileLex::_readString: Expected a string\n");

    // 脫溢字串兩頭的 雙引號
    if( _text.size() != 0 )
        str.assign( _text, 1, _text.size() - 2);

}
void CuFileLex::_readNode()
{

    _lex();
    Assert( _type == NODE , L"CuFileLex::_readNode: Expected a node\n");

}

void CuFileLex::_readBlockStart()
{

    _lex();
    Assert( _type == BLOCKSTART , L"CuFileLex::_readBlockStart: Expected an open brace\n");

}

int CuFileLex::_skip()
{

    int nextToken;
    int depth = 0;
    char neednext = 1;

    do {
        if(neednext) 
            nextToken = _lex();
        else 
            neednext = 1;

        if(nextToken == BLOCKSTART) 
            depth++;
        if(nextToken == BLOCKEND) 
            if(depth > 0) {
            /*printf("skipping %s\n", ASE_text);*/
            depth--;
            nextToken = _lex();
            neednext = 0;
        }
        /*printf("skipping %s (%i) (depth %i)\n", ASE_text, ASE_linenum, depth);*/
    } while(nextToken && (depth || (nextToken != NODE && nextToken != BLOCKEND)));
    /*printf("done (got %s)\n", ASE_text);*/
    return nextToken;

}

BOOL CuFileLex::_IsUnicodeFile()
{

    FILE* pFileStream = m_File.GetFILE();

    WORD result = 0;
    fseek( pFileStream, 0, SEEK_SET);
    int nSizeT = m_File.Read(&result, sizeof(result) );


    if( result != 0xfeff )
    {
        fseek( pFileStream, 0, SEEK_SET);
    }

    return (result == 0xfeff);

}
BOOL CuFileLex::Open( LPCSTR lpszFileName, LPCSTR lpszOpenMode)
{
    string strFileName = lpszFileName;
    string strOpenMode = lpszOpenMode;

    wstring wstrFileName(strFileName.begin(), strFileName.end());
    wstring wstrOpenMode(strOpenMode.begin(), strOpenMode.end());

    return Open(wstrFileName.c_str(),wstrOpenMode.c_str() );

}

BOOL CuFileLex::Open( LPCTSTR lpszFileName, LPCTSTR lpszOpenMode)
{
    

    BOOL bResult = m_File.Open(lpszFileName, lpszOpenMode);

    Assert(bResult != FALSE, L"can't open file" );
    Assert(bResult != FALSE, const_cast<TCHAR *>(lpszFileName) );

    if( bResult == FALSE )
        return FALSE;

    m_bUnicode = this->_IsUnicodeFile();

    if( m_bUnicode )
    {
        if( wcscmp (lpszOpenMode , L"r") == 0 )
        {
            lpszOpenMode = L"rb";
            m_File.Close();
            bResult = m_File.Open(lpszFileName, lpszOpenMode);
            m_bUnicode = this->_IsUnicodeFile();
        }

    }
    else
    {
        m_File.Close();
        bResult = m_File.Open(lpszFileName, lpszOpenMode);
        
    }

    return bResult;
}

從某一隻ASE檔載入器中抓出來的,
CuFileLex 跟CuStringList 相比, 能載入較多格式的文字串, 組合後可以使用更豐富的設定檔
上面有兩大段分別支援一般文字檔跟UNICODE文字檔, 很顯示需要重構! 現在沒打算重構!
重構時間點在何時呢? 在他出錯的時後, 或是下次程式碼"review"的時後!

CuMicroTime - the current timestamp with microseconds.

2010-01-28T15:00:00.000-08:00

// the current timestamp with microseconds.



// CuMicroTime.php 


class CuMicroTime  {

    var $usec;
    var $sec;
    
    function CuMicroTime(/* CuMicroTime */ $MicroTime = null) {

        if( $this->CheckClassType($MicroTime) )
        {
            $this->usec = $MicroTime->usec;
            $this->sec = $MicroTime->sec;
        }
        else
        {
            list($this->usec, $this->sec) = explode(" ", microtime());
        }
    }
    
    function Dec( /* CuMicroTime */ $MicroTime)
    {
        
        if( CheckClassType($MicroTime) )
            return NULL;

        $usec = (float)$this->usec - (float)$MicroTime->usec;
        $sec = $this->sec - $MicroTime->sec;

        $usec = substr($usec, 1);
        return $sec.$usec;
        
    }
    
    function CheckClassType($MicroTime)
    {
        if( gettype($MicroTime) != 'object' || get_class($MicroTime) != "cumicrotime" )
            return false;
        else
            return true;
    }
    
    
}

CuShellExecuteEx - Performs an operation on a specified file.

2010-01-27T15:00:00.000-08:00

// Performs an operation on a specified file.



// CuShellExecuteEx.h

class CuShellExecuteEx  
{

public:
    void SetExecuteFile(wstring strFile, BOOL bAutoModuleFile = FALSE);
    BOOL OnShellExecuteEx();

    SHELLEXECUTEINFO m_sei;
    wstring m_strExecuteFile;

    CuShellExecuteEx();
    ~CuShellExecuteEx();

};


// CuShellExecuteEx.cpp

CuShellExecuteEx::CuShellExecuteEx()
{
    m_sei.cbSize = sizeof(SHELLEXECUTEINFO);
    m_sei.fMask = 0;
    m_sei.hwnd = NULL;
    m_sei.lpVerb = TEXT("open");
    m_sei.lpFile = NULL;
    m_sei.lpParameters = NULL;
    m_sei.lpDirectory = NULL;
    m_sei.nShow = SW_SHOW;
    m_sei.hInstApp = NULL;
}

CuShellExecuteEx::~CuShellExecuteEx()
{

}

BOOL CuShellExecuteEx::OnShellExecuteEx()
{
    return ::ShellExecuteEx(&m_sei);
}

void CuShellExecuteEx::SetExecuteFile(wstring strFile, BOOL bAutoModuleFile /*= FALSE*/)
{

    if( bAutoModuleFile )
    {
        CuModuleFile mf;
        strFile = mf.GetModuleFileName(strFile);
    }

    m_strExecuteFile = strFile;
    m_sei.lpFile = m_strExecuteFile.c_str();

}

CuModuleFile - Retrieves the fully-qualified path for the file that contains the onwer module.

2010-01-26T15:00:00.000-08:00

// Retrieves the fully-qualified path for the file that contains the onwer module.



// CuModuleFile.h

class CuModuleFile //: public IuModuleFile
{
public:
    CuModuleFile();
    ~CuModuleFile();


    wstring GetModuleFileName(wstring strFileName);

   // 傳入空的字串 會傳回執行檔檔名
    wstring GetUnModuleFileName(wstring strFileName = L""); 
    wstring CutRFind(wstring str, TCHAR ch);

};



// CuModuleFile.cpp


CuModuleFile::CuModuleFile()
{

}

CuModuleFile::~CuModuleFile()
{

}


//////////////////////////////////////////////////////////////////////
// 函式名稱:GetModuleFileName
// 函式說明:將strFileName 前面加上 主執行緒執行檔同目錄的路徑
// 使用範例:
// 啟動 C:\Documents and Settings\Eric Wang\My Documents\Work\test.exe
// strFileName = L"sample.ini"
// str = mf.GetModuleFileName(strFileName);
// Access(str = L"C:\Documents and Settings\Eric Wang\My Documents\Work\sample.ini");
//////////////////////////////////////////////////////////////////////
wstring CuModuleFile::GetModuleFileName(wstring strFileName)
{

    wstring filename;
    wstring strFile = strFileName;

    wstring::size_type npos = -1;
    wstring::size_type indexCh1a;

    int nCount = 0;
    while   ( (indexCh1a = strFile.find(L"..\\")) != npos )
    {
        nCount++;
        strFile = strFile.substr(indexCh1a + 3);
    }

    TCHAR szModule[255] = L"";
    LPTSTR psz;

    ::GetModuleFileName(GetModuleHandle(NULL), szModule, MAX_PATH);

    do
    {
        psz = wcsrchr(szModule, L'\\');
        if (psz)
        {
            *psz = L'\0';
        }
    }while( nCount-- );

    wcscat(szModule, L"\\");
    wcscat(szModule, strFile.c_str());

    return szModule;    
}


//////////////////////////////////////////////////////////////////////
// 函式名稱:GetUnModuleFileName
// 函式說明:函路徑的檔名前面的路徑清掉, strFileName = NULL 時 會傳回主執行緒的執行檔檔名
// 使用範例:
// strFileName = L"C:\\Documents and Settings\\Eric Wang\My Documents\\Work\\temp.txt"
// str = mf.GetUnModuleFileName(strFileName);
// Access(str = L"temp.txt");
//////////////////////////////////////////////////////////////////////
wstring CuModuleFile::GetUnModuleFileName(wstring strFileName /* = L"" */)
{


    wstring filename;
    wstring strFull;
    
    if( strFileName.size() == 0 )
    {
        TCHAR szModule[255] = L"";
        ::GetModuleFileName(GetModuleHandle(NULL), szModule, MAX_PATH);
        strFull = szModule;
    }
    else
        strFull = strFileName;

    static const wstring::size_type npos = -1;


    wstring::size_type indexCh1a;
    indexCh1a = strFull.rfind('\\');

    if( indexCh1a != npos )
        filename = strFull.substr(indexCh1a + 1);
    else
        filename = strFull;

    return filename;


}


//////////////////////////////////////////////////////////////////////
// 函式名稱: CutRFind
// 函式說明: 去掉 ch 右邊的字串
// 使用範例: 
// str = text.txt
// str2 = mf.GetRFind(str, '.');
// Assert( str2 = L"text");
//////////////////////////////////////////////////////////////////////
wstring CuModuleFile::CutRFind(wstring str, TCHAR ch)
{

    wstring strResult;
    static const wstring::size_type npos = -1;
    wstring::size_type indexCh1a;
    indexCh1a = str.rfind(ch);

    if( indexCh1a != npos )
        strResult = str.substr(0, indexCh1a);
    else
        strResult = str;

    return strResult;

}

CuVolume - sets the volume of a waveform output device.

2010-01-25T15:00:00.000-08:00

// sets the volume of a waveform output device.


DWORD dw, dw2;
// dw : 0x0000~0xffff
// dw2: 0~MAX

CuVolume Volume;
dw = Volume.GetVolume();
dw2 = Volume.GetVolume(MAX);

Volume.SetVolume(dw);
Volume.SetVolume(dw2, MAX);

Volume.IncVolume(MAX);
Volume.DecVolume(MAX);



// CuVolume.h

class CuVolume  
{
    BOOL    m_bMute;
    unsigned long   m_nVolume;

    //////////////////////////////////////////////////////////////////////
    // 
    CuDllManager dll;
    typedef DWORD (*pAudio)  ();
    pAudio pProc;

    void UpdateVolumeFromRegistry();
    //////////////////////////////////////////////////////////////////////

public:
    CuVolume();
    virtual ~CuVolume();

    void IncVolume(int nMax);
    void DecVolume(int nMax);

    BOOL GetMute(void){ return m_bMute; }
    BOOL SetMute(BOOL b);

    // 直接指定值 v = 0 ~ 0xffff
    BOOL SetVolume(unsigned long v);
    unsigned long GetVolume(void);

    // 正規化過的值  指定max  Ex: v = 50 , nMAx = 100 , 會設定 50%
    // v = 1, nMax = 5, 會設定 20%
    BOOL SetVolume(int v, int nMax);

    // 取回正規化過的值
    int GetVolume(int nMax);
};


// CuVolume.cpp

#define MAX_VALUES 0xffff

void CuVolume::UpdateVolumeFromRegistry()
{
    if( pProc )
        pProc();
}


CuVolume::CuVolume()
:m_bMute(FALSE)
{
    GetVolume();

    dll.LoadLibrary(_T("coredll.dll"));
    pProc = (pAudio)dll.GetProcAddress(_T("AudioUpdateFromRegistry"));

}

CuVolume::~CuVolume()
{
}

BOOL CuVolume::SetMute(BOOL b)
{

    static unsigned long nVolume = GetVolume();

    m_bMute = b;
    if (m_bMute)
    {
        nVolume = GetVolume();
        SetVolume(0);
    }
    else
    {
        SetVolume(nVolume);
    }

    return TRUE;

}

BOOL CuVolume::SetVolume(unsigned long v)
{

    m_nVolume = v;
    waveOutSetVolume(NULL, 0x10001 * v) ;

    CReg reg(HKEY_CURRENT_USER, _T("ControlPanel\\Volume"));
    reg.SetDW(_T("Volume"), 0x10001 * v);

    UpdateVolumeFromRegistry();

    return TRUE;
}

unsigned long CuVolume::GetVolume(void)
{

    unsigned long Value;
    if (waveOutGetVolume(NULL,&Value) == MMSYSERR_NOERROR)
    {
        m_nVolume = ( (LOWORD(Value)+HIWORD(Value)) ) / 2 ;
    }
    return m_nVolume;

}

BOOL CuVolume::SetVolume(int v, int nMax)
{

    DWORD Value = v * MAX_VALUES / nMax;
    SetVolume(Value);

    return TRUE;

}

int CuVolume::GetVolume(int nMax)
{
    unsigned long Value;
    Value = (float)nMax * ((float)GetVolume() + 600) / (float)MAX_VALUES;
    return Value;
}

void CuVolume::IncVolume(int nMax)
{
    
    if( GetMute() )
        SetMute(FALSE);

    unsigned long offset_Value = (float)MAX_VALUES / nMax;
    unsigned long Value = (float)GetVolume();

    Value += offset_Value;
    if( Value > MAX_VALUES)
        Value = MAX_VALUES;

    SetVolume(Value);

}
void CuVolume::DecVolume(int nMax)
{

    if( GetMute() )
        SetMute(FALSE);

    float offset_Value = (float)MAX_VALUES / nMax;
    float Value = (float)GetVolume();

    if( Value <= offset_Value)
        Value = 0;
    else
        Value -= offset_Value;

    SetVolume(Value);

}

CuPowerNotification - to register for power notification events.

2010-01-24T15:00:00.000-08:00

// to register for power notification events.



// CuPowerNotification.h


class CuPowerNotification  
{
    HANDLE m_hRequestPowerNotifications;

    CuWinThread *m_pWinThread;

    CuMsgQueue m_MsgQueue;

public:
    virtual void OnPowerNotification(PPOWER_BROADCAST ppower_broadcast){};
    BOOL StopPowerNotifications();
    HANDLE RequestPowerNotifications(DWORD Flags = POWER_NOTIFY_ALL, wstring strMsgQueueName = L"");
    CuPowerNotification();
    virtual ~CuPowerNotification();


private:
    static DWORD Process(LPVOID lpVoid);

};


// CuPowerNotification.cpp


#define QUEUE_ENTRIES 3
#define QUEUE_SIZE ( QUEUE_ENTRIES * (sizeof(POWER_BROADCAST) + sizeof(POWER_BROADCAST_POWER_INFO)) )
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CuPowerNotification::CuPowerNotification()
:m_hRequestPowerNotifications(NULL)
,m_pWinThread(NULL)

{

}

CuPowerNotification::~CuPowerNotification()
{
    StopPowerNotifications();
}

HANDLE CuPowerNotification::RequestPowerNotifications(
DWORD Flags /* = POWER_NOTIFY_ALL */
, wstring strMsgQueueName /*= L""*/)
{

    StopPowerNotifications();

    MSGQUEUEOPTIONS MsgQueueOptions;

    memset(&MsgQueueOptions , 0, sizeof( MsgQueueOptions));
    
    MsgQueueOptions.dwSize = sizeof( MSGQUEUEOPTIONS );
    MsgQueueOptions.dwFlags = 0  ;
    MsgQueueOptions.dwMaxMessages = QUEUE_ENTRIES;
    MsgQueueOptions.cbMaxMessage =  QUEUE_SIZE;
    MsgQueueOptions.bReadAccess = TRUE ;
    //TCHAR *pszMsgQueue = strMsgQueueName.c_str();
    TCHAR szMsgQueueName[64] = L"";

    if( strMsgQueueName.empty() )
        wsprintf( szMsgQueueName, L"%x", (int)this );
    else
        wsprintf( szMsgQueueName, L"%s", strMsgQueueName.c_str());
    m_MsgQueue.CreateMsgQueue(szMsgQueueName, &MsgQueueOptions);

    m_hRequestPowerNotifications = ::RequestPowerNotifications(  m_MsgQueue, Flags );

    if( m_hRequestPowerNotifications )
        m_pWinThread = _BeginThread((_THREADPROC)CuPowerNotification::Process,
          (LPVOID)this);

    return m_hRequestPowerNotifications;

}

BOOL CuPowerNotification::StopPowerNotifications()
{

    if( m_pWinThread )
        m_pWinThread->Delete();

    m_pWinThread = NULL;

    return ::StopPowerNotifications(m_hRequestPowerNotifications);
}


DWORD CuPowerNotification::Process(LPVOID lpVoid)
{
    CuPowerNotification *pPowerNotification = (CuPowerNotification *)lpVoid;

    static BYTE buf[QUEUE_SIZE];
    static unsigned long nRead = 0;
    static unsigned long flags = 0;
    
    DWORD dwResult;
    while(1)
    {
        dwResult = WaitForSingleObject(pPowerNotification->m_MsgQueue, INFINITE);
        if( dwResult == WAIT_OBJECT_0 )
        {
            memset(&buf , 0, QUEUE_SIZE);
            dwResult = pPowerNotification->m_MsgQueue.ReadMsgQueue( 
            &buf, QUEUE_SIZE, &nRead, INFINITE, &flags);
            if( dwResult != FALSE )
                pPowerNotification->OnPowerNotification((PPOWER_BROADCAST)buf);
        }
    }

    return 0;
}

TuWinTimer - creates a timer with the specified time-out value.

2010-01-23T15:00:00.000-08:00

// creates a timer with the specified time-out value.



class CuMyClass
{
    TuWinTimer<CuMyClass> m_winTimer;

public:

    void OnMyFunction(void);
    void Init(void);

};

void CuMyClass::Init()
{
    m_winTimer.Init(1000); 
    m_winTimer.CombineElement(this, &CuMyClass::OnMyFunction, g_hWnd);

    ...
    m_winTimer.OnStardTime();
}

void CuMyClass::OnMyFunction(void)
{
    ...
    m_winTimer.OnStopTime();
}


// TuWinTimer.h

template <typename T>
class TuWinTimer 
    
    UINT m_uElapse;

    T *m_pElement;

    HWND m_hWnd;

    typedef void ( T::*ELEMENTTIME_TIMEOUTPROC)(void);
    ELEMENTTIME_TIMEOUTPROC m_fpTimeOutProc;


    static VOID CALLBACK TuWinTimerTimerProc( HWND hwnd,
        UINT uMsg,
        UINT_PTR idEvent,
        DWORD dwTime
    )
    {

        TuWinTimer<T> *pElement = (TuWinTimer<T>*)idEvent;
        T *pActiveElement = pElement->m_pElement;
        (pActiveElement->*(pElement->m_fpTimeOutProc))();

    }
public:
    
    TuWinTimer();
    ~TuWinTimer();

    void Init(UINT uElapse);
    void CombineElement(T *pElement, ELEMENTTIME_TIMEOUTPROC fpTimeOutProc, HWND hWnd);

    void OnStardTime();
    void OnStopTime();

};




template <typename T>
TuWinTimer<T>::TuWinTimer()
:m_uElapse(0)
,m_pElement(NULL)
,m_fpTimeOutProc(NULL)
,m_hWnd(NULL)
{
}

template <typename T>
TuWinTimer<T>::~TuWinTimer()
{
    OnStopTime();
}

template <typename T>
void TuWinTimer<T>::Init(UINT uElapse)
{
    m_uElapse = uElapse;
}

template <typename T>
void TuWinTimer<T>::OnStardTime()
{

    OnStopTime();
    ::SetTimer(m_hWnd, (UINT)this, m_uElapse, TuWinTimer<T>::TuWinTimerTimerProc );

}
template <typename T>
void TuWinTimer<T>::OnStopTime()
{
    ::KillTimer(m_hWnd, (UINT)this);
}


template <typename T>
void TuWinTimer<T>::CombineElement(T *pElement, ELEMENTTIME_TIMEOUTPROC fpTimeOutProc, HWND hWnd)
{ 
    m_pElement = pElement; 
    m_fpTimeOutProc = fpTimeOutProc;

    Assert( hWnd != NULL , L"Error : hWnd == NULL");
    m_hWnd = hWnd;
}

CuMsgQueue - pass information between different programs.

2010-01-22T15:00:00.000-08:00

// pass information between different programs.

//

MSGQUEUEOPTIONS msg_queue_options;

msg_queue_options.dwSize    = sizeof(MSGQUEUEOPTIONS);
msg_queue_options.dwMaxMessages    = 0;
msg_queue_options.cbMaxMessage    = TEST_BUFFER_SIZE;
msg_queue_options.bReadAccess    = TRUE;
msg_queue_options.dwFlags    = MSGQUEUE_NOPRECOMMIT;

MsgReadQueue.CreateMsgQueue(lpszName, &msg_queue_options);

//

wchar_t test_text[TEST_BUFFER_SIZE];
ret = WaitForSingleObject(MsgReadQueue, INFINITE);
 

if (ret == WAIT_OBJECT_0) {
        DWORD    read_bytes;
        DWORD    flag;

        MsgReadQueue.ReadMsgQueue(test_text, sizeof(wchar_t) * TEST_BUFFER_SIZE, &read_bytes, INFINITE, &flag);
}


// CuMsgQueue.h


class CuMsgQueue  
{
    HANDLE m_hCreateMsgQueue;

public:
    BOOL ReadMsgQueue(LPVOID lpBuffer,
                        DWORD cbBufferSize,
                        LPDWORD lpNumberOfBytesRead,
                        DWORD dwTimeout,
                        DWORD* pdwFlags);
    HANDLE CreateMsgQueue(LPWSTR lpszName,LPMSGQUEUEOPTIONS lpOptions);
    BOOL CloseMsgQueue(  );
    operator HANDLE() const;


    CuMsgQueue();
    virtual ~CuMsgQueue();

};


// CuMsgQueue.cpp


CuMsgQueue::CuMsgQueue()
:m_hCreateMsgQueue(NULL)
{

}

CuMsgQueue::~CuMsgQueue()
{
    CloseMsgQueue();
}

BOOL CuMsgQueue::CloseMsgQueue()
{
    return ::CloseMsgQueue(m_hCreateMsgQueue);
}

HANDLE CuMsgQueue::CreateMsgQueue(LPWSTR lpszName, LPMSGQUEUEOPTIONS lpOptions)
{

    CloseMsgQueue();
    m_hCreateMsgQueue = ::CreateMsgQueue(lpszName, lpOptions);
    return m_hCreateMsgQueue;
}

CuMsgQueue::operator HANDLE() const
    { return (HANDLE)(this == NULL ? NULL : m_hCreateMsgQueue); }

BOOL CuMsgQueue::ReadMsgQueue(LPVOID lpBuffer,
                        DWORD cbBufferSize,
                        LPDWORD lpNumberOfBytesRead,
                        DWORD dwTimeout,
                        DWORD* pdwFlags)
{
    return ::ReadMsgQueue(m_hCreateMsgQueue, lpBuffer, cbBufferSize, lpNumberOfBytesRead, dwTimeout, pdwFlags);
}

像這種 MSGQUEUEOPTIONS msg_queue_options; 有結構設定的部份, 實在很想把他包到類別裡, 在使用函式參數傳遞,並且設定部份參數為預設值!

不僅使用起來美觀! 而且還不用特別去查結構!

CuTimer - specialized type of clock.

2010-01-21T15:23:00.000-08:00

// specialized type of clock. 


CuTimer _Timer;

while(1)
{
    _Timer.Make_Tick_Data();

    if( _Timer.GetTimeOut(9) )
        ....

    _Timer.Tick_Data_Clear();
}

// CuTimer.h

class CuTimer
{

public:
    BOOL GetTimeOut(int i); // table_1

    void Make_Tick_Data();
    void Tick_Data_Full();
    void Tick_Data_Clear();
    CuTimer();
    ~CuTimer();

private:
    DWORD More_Time[20];
    DWORD lastTickCount[20];
    BYTE Time_move[20];
    DWORD thisTickCount;

};



// CuTimer.cpp


CuTimer::CuTimer(void)
{

    this->Tick_Data_Clear();

}

CuTimer::~CuTimer(void)
{
}


void CuTimer::Tick_Data_Clear()
{
    memset( Time_move, 0, sizeof Time_move );
}

void CuTimer::Tick_Data_Full()
{
    memset( Time_move, 1, sizeof Time_move );
}

void CuTimer::Make_Tick_Data()
{
    static DWORD delay[20] = {
          10,     //0 , 1/100 sec 0.01
          16,     //1 , 1/60  sec 0.016
          17,     //2 , 1/56  sec 0.017
          20,     //3 , 1/48  sec 0.020
          25,     //4 , 1/40  sec 0.025
          33,     //5 , 1/30  sec 0.033
          41,     //6 , 1/24  sec 0.041
          62,     //7 , 1/16  sec 0.062
          83,     //8 , 1/12  sec 0.083
          125,    //9 , 1/8   sec 0.125
          166,    //10, 1/6   sec 0.166
          250,    //11, 1/4   sec 0.250
          333,    //12, 1/3   sec 0.333
          500,    //13, 1/2   sec 0.5
          1000,   //14, 1     sec
          2000,   //15, 2     sec
          3000,   //16, 3     sec
          4000,   //17, 4     sec
          5000,   //18, 5     sec
          8000    //19, 8     sec
        };

    thisTickCount = GetTickCount();
    for (int i = 0; i < 20;  i++)
    {
        if( (thisTickCount - lastTickCount[i]) >= delay[i])
        {
        More_Time[i] = (thisTickCount - lastTickCount[i]) - delay[i];

        lastTickCount[i] = thisTickCount;

        if( More_Time[i] < 30 )
          lastTickCount[i] -= More_Time[i];

        Time_move[i]++;
        }
    }
}

BOOL CuTimer::GetTimeOut(int i)
{
    return (BOOL)Time_move[i];
}

PHP : CDate

2010-01-20T15:00:00.000-08:00

// CDate.php

class CDate {
    
    function str2time($strStr, $strPattern)
    {
        

       // an array of the valide date characters, see: http://php.net/date#AEN21898
       $arrCharacters = array(
           'd', // day
           'm', // month
           'y', // year, 2 digits
           'Y', // year, 4 digits
           'H', // hours
           'i', // minutes
           's'  // seconds
       );
       // transform the characters array to a string
       $strCharacters = implode('', $arrCharacters);


    
       // splits up the pattern by the date characters to get an array of the delimiters between the date characters
       $arrDelimiters = preg_split('~['.$strCharacters.']~', $strPattern);

       // transform the delimiters array to a string
       $strDelimiters = quotemeta(implode('', array_unique($arrDelimiters)));


    
       // splits up the date by the delimiters to get an array of the declaration
       $arrStr    = preg_split('~[' . $strDelimiters . ']~' , $strStr);
    

       // splits up the pattern by the delimiters to get an array of the used characters
       $arrPattern = preg_split('~['.$strDelimiters.']~', $strPattern);
    
        
       // if the numbers of the two array are not the same, return false, because the cannot belong together
       if (count($arrStr) !== count($arrPattern)) {
           return false;
       }
    
       // creates a new array which has the keys from the $arrPattern array and the values from the $arrStr array
       $arrTime = array();
       for ($i = 0;$i < count($arrStr);$i++) {
           $arrTime[$arrPattern[$i]] = $arrStr[$i];
       }
    
            
       // gernerates a 4 digit year declaration of a 2 digit one by using the current year
       if (isset($arrTime['y']) && !isset($arrTime['Y'])) {
           $arrTime['Y'] = substr(date('Y'), 0, 2) . $arrTime['y'];
       }
    
    
       // if a declaration is empty, it will be filled with the current date declaration
       foreach ($arrCharacters as $strCharacter) {
           if (empty($arrTime[$strCharacter])) {
               $arrTime[$strCharacter] = date($strCharacter);
           }
       }
    
    
       // checks if the date is a valide date
       if (!checkdate($arrTime['m'], $arrTime['d'], $arrTime['Y'])) {
           return false;
       }
    
       // generates the timestamp
       $intTime = mktime($arrTime['H'], $arrTime['i'], $arrTime['s'], $arrTime['m'], $arrTime['d'], $arrTime['Y']);
       // returns the timestamp
    
       return $intTime;
    } // end function str2time
    
}// end class CDate

雖然現在很少人在寫PHP用手動比對時間, 通常都交給SQL去驗證.

Assert - assertion

2010-01-19T15:00:00.000-08:00

// An assertion statement specifies a condition that you expect to hold true at some particular point in your program.

Assert(m_hThread != NULL, _T("CuWinThread::ResumeThread m_hThread != NULL");

// uAssert.h


#if defined(_DEBUG)


    #define WIDEN2(x) L ## x
    #define WIDEN(x) WIDEN2(x)
    #define __WFILE__ WIDEN(__FILE__)

    extern bool CustomAssertFunction( bool, TCHAR*, int, TCHAR*, bool*);

    #if defined(_WINDOWS)
    #define ASSERTPRESS { _asm { int 3 } }
    #else
    #define ASSERTPRESS {}
    #endif // defined(_WINDOWS)


    #define Assert( exp, description) \
    { static bool ignoreAlways = false; \
        if( !ignoreAlways) { \
            if( CustomAssertFunction( (int)(exp), description, __LINE__, __FILE__, &ignoreAlways) ) \
                ASSERTPRESS \
        } \
    }

    #define Verify(exp, description)          Assert(exp, description)


#else

    #define Assert(exp, description)    ((void)0)
    #define Verify(exp, description)    ((void)(exp))

#endif  // defined(_DEBUG)




// uAssert.cpp



// Return:
// true - Stop On Assert Line
// false - continue
bool CustomAssertFunction( bool bExp, TCHAR* strDesc, int iLine, TCHAR* strFilename,  bool *ignoreAlways)
{

    if( !bExp )
    {
        TCHAR strTitle[255] = TEXT("");
        TCHAR strText[255] = TEXT("");
        wsprintf(strTitle, TEXT("%s - %d"), strFilename, iLine);
        wsprintf(strText, TEXT("%s \n Yes to Continue \n No to Break\n Cancle to Ignore Always"), strDesc);
        int nRelease = MessageBox(NULL, strText, strTitle, MB_YESNOCANCEL);
        switch( nRelease )
        {
        case 6:
            return false;
            break;
        case 7:
            return true;
            break;
        case 2:
            *ignoreAlways = true;
            break;
        }
    }
        
    return false;

}

這個有擴充過, 使用 _asm { int 3 } 能停在Assert 那一行.

CuSocketFile - A CuFile object used for sending and receiving data across a network via Windows Sockets

2010-01-18T15:00:00.000-08:00

// CuSocketFile - A CuFile object used for sending and receiving data across a network via Windows Sockets.

CuSocket sk;
CuSocketFile skFile(&sk);

CuFile *pFile = &skFile;

pFile->Write(...);
pFile->Read(...);



// CuSocketFile.h

class CuSocketFile : public CuFile  
{
    CuSocket* m_pSocket;

public:

    CuSocketFile( CuSocket* pSocket);
    ~CuSocketFile();

public:
    virtual int Write(const void* lpBuf, UINT nCount);
    virtual int Read(void* lpBuf, UINT nCount);

};



// CuSocketFile.cpp

CuSocketFile::~CuSocketFile()
{

}

CuSocketFile::CuSocketFile(CuSocket *pSocket)
{

    m_pSocket = pSocket;

}

// rc == SOCKET_ERROR 在外部在處理
int CuSocketFile::Read(void *lpBuf, UINT nCount)
{

    if( lpBuf == NULL ) 
        return 0;

    return m_pSocket->Receive(lpBuf, nCount, 0);

}

int CuSocketFile::Write(const void *lpBuf, UINT nCount)
{

    if( lpBuf == NULL ) 
        return 0;
        
    retrun m_pSocket->Send((const TCHAR*)lpBuf , nCount, 0);

}

使用繼承 public CuFile , 在對TheApp做多型, TheApp並不需要知道是LocalFile 還是 Remote Socket.
這裡有個很特別的問題, CuFile 跟 CuSocketFile 除了介面相同外, 並沒有任何的程式碼相容.
因此需要繼承的並不是CuFile實體, 而是
class CuFile : public IuFile
class CuSocketFile : public IuFile
繼承 CuFile 的介面 IuFile

CuTestUnit - Easy way to Unit Test.

2010-01-17T15:00:00.000-08:00

// Easy way to Unit Test.



// CuTestUnit.php

class CuTestUnit
{
    var $debug;
    
    function __construct()
    {
        $this->debug = new CuDebugger; 
    }   
    
    function CuTestUnit()
    {
        $this->__construct();
    }
    
    function assertTrue($bool, $key = null )
    {
        if( !$bool || $bool != true)
            $result = "<font color = '#ff0000'>FALSE</font>";
        else
            $result = "<font color = '#0000ff'>OK</font>";
        
        $this->debug->debug($result,  $key);  
    }
    
    function assertEquals($value1, $value2, $key = null)
    {
        $this->assertTrue($value1 == $value2, $key);
    }
    
    function GetHTML()
    {
        return $this->debug->GetHTML();
    }
    
}

TuDeck - Card stack

2010-01-16T15:00:00.000-08:00

//   Card stack


// u_TDeck.pas

unit u_TDeck;
interface
uses
        Windows, Classes, SysUtils,
        StdCtrls,
        ch_LogMessages,

        u_TList,
        u_TexasHoldConst;

const

        CARD_LIMIT = (13 * 4);    // 撲克牌總數 十三張 * 4種類

        // 牌的位置
        POSITION_POOL = 0; // 在牌堆裡
        POSITION_HOLE = 1; // 玩家手牌
        POSITION_FIELD = 2;// 桌上公牌

        // 牌的類型
        CARD_CATEGORY_SPADE = 0;  // 黑桃
        CARD_CATEGORY_HEARD = 1;  // 紅心
        CARD_CATEGORY_CLUB = 2;  // 梅花
        CARD_CATEGORY_DIAMOND = 3;  // 方塊
        CARD_CATEGORY_LIMIT = 4;  //

type

//******************************************************************************
// 類別名稱：TCardData
// 功　　能：每張牌的結構定義
//******************************************************************************
        TCardData = class        //TCardData 結構的定義
            Category: word;       // 種類                 
            Index: word;          // 數
            ListIndex: word;      // 表格位置
            Position: word;       // 位置
            Player: integer;      // 玩家
        end;

//******************************************************************************
// 類別名稱：TuDeck
// 功　　能：維護牌堆資料 提供 亂數取牌
//******************************************************************************
        TuDeck = Class
          private
            m_aCardDataList: TuList;  // 撲克牌陣列
            m_DeckMessToFiles : TLogMessToFiles;
            function GetRandomCardIndex: integer; // 找一張沒有被派發出來的牌
          public
            constructor Create;
            destructor Destroy; override;

            procedure Init; // 初始化

            
            function GetRandomCard(Player, nPosition: integer): integer;
            function GetIndexCard(nIndex,Player, nPosition:integer):integer;

            function Items( nListIndex:integer ):TCardData;
            function Index( nListIndex:integer ): word;
            function Category( nListIndex:integer ): word;
            function Position( nListIndex:integer ): word;
            function Player( nListIndex:integer ): integer;
        end;
        function compareByPoker(Item1 : Pointer; Item2 : Pointer) : Integer;


implementation


constructor TuDeck.Create;
var
        i: integer;
        TmpCardData: TCardData;
begin
        m_DeckMessToFiles := TLogMessToFiles.Create('DeckMessage.txt');
 
        m_aCardDataList := TuList.Create();
        for i := 0 to CARD_LIMIT - 1 do begin
            TmpCardData := TCardData.Create();
            m_aCardDataList.Add(TmpCardData);
        end;
        
        Init();
end;


destructor TuDeck.Destroy;
begin
        m_aCardDataList.Free;
        m_DeckMessToFiles.Free;
end;


//******************************************************************************
// 函式名稱：Init
// 功　　能：初始化撲克牌陣列 並洗牌(重設亂數種子)
//******************************************************************************
procedure TuDeck.Init();
var

        TmpCategory: integer;
        TmpIndex: integer;
        CardIndex: integer;
        TmpCardData : TCardData;
begin

        // 每一把要重新洗牌 重設亂數種子
        Randomize;

        CardIndex := 0;
        for TmpCategory := 0 to CARD_CATEGORY_LIMIT - 1 do begin
            for TmpIndex := 1 to CARD_INDEX_LIMIT do begin
                TmpCardData := m_aCardDataList.GetItems(CardIndex);
                TmpCardData.Category := TmpCategory;
                TmpCardData.Index := TmpIndex;
                TmpCardData.ListIndex := CardIndex;
                TmpCardData.Position := POSITION_POOL;
                TmpCardData.Player := PLAYER_NIL;
                Inc(CardIndex);
            end;
        end;
end;


//******************************************************************************
// 函式名稱：GetIndexCard
// 功　　能：直接取出 nIndex 指定的牌
//******************************************************************************
function TuDeck.GetIndexCard(nIndex,Player, nPosition:integer):integer;
var
        TmpCardData : TCardData;
begin
        TmpCardData := m_aCardDataList.GetItems(nIndex);
        TmpCardData.Position := nPosition;
        TmpCardData.Player := Player;

        Result := nIndex;
end;


//******************************************************************************
// 函式名稱：GetRandomCard
// 功　　能：亂數取牌
//******************************************************************************
function TuDeck.GetRandomCard(Player, nPosition: integer): integer;
var
        nIndex: integer;
        TmpCardData : TCardData;
begin

        nIndex := GetRandomCardIndex();
        TmpCardData := m_aCardDataList.GetItems(nIndex);
        TmpCardData.Position := nPosition;
        TmpCardData.Player := Player;

        Result := nIndex;
end;


//******************************************************************************
// 函式名稱：GetRandomCardIndex
// 功　　能：隨機取得 CardList 的參數
//******************************************************************************
function TuDeck.GetRandomCardIndex: integer;
var
        TmpIndex, nIndex: integer;


        nTmpNext : Integer;
        nTmpPrev : Integer;
        nRandom2 : Integer;

        TmpCardData : TCardData;
begin


        nIndex := Random(CARD_LIMIT);

        // 如果 還沒發出去就直接發
        TmpCardData := m_aCardDataList.GetItems(nIndex);
        if TmpCardData.Position = POSITION_POOL then
        begin
            Result := nIndex;
            exit;
        end;

        if nIndex = CARD_LIMIT - 1 then begin
            nIndex := 0;
        end;

        (* 順序搜尋 *)
        nTmpNext := -1;
        for TmpIndex := nIndex to CARD_LIMIT - 1 do begin
            TmpCardData := m_aCardDataList.GetItems(TmpIndex);
            if TmpCardData.Position = POSITION_POOL then
            begin
                nTmpNext := TmpIndex;
                break;
            end;
        end;
        
        if nIndex = 0 then begin
            nIndex := CARD_LIMIT - 1;
        end;

        nTmpPrev := -1;
        for TmpIndex := nIndex downto 0 do begin
            TmpCardData := m_aCardDataList.GetItems(TmpIndex);
            if TmpCardData.Position = POSITION_POOL then begin
                nTmpPrev := TmpIndex;
                break;
            end;
        end;

        // 當所有牌都發完時 才會兩個都是負的
        // 如果發到都沒有牌 代表程式有問題
        if (nTmpNext = -1) And (nTmpPrev = -1) then begin
            m_DeckMessToFiles.m_WriteTXTOne(
            Format ('nIndex %d nTmpNext %d nTmpPrev %d ',[nIndex, nTmpNext, nTmpPrev]), 1);
        end;

        if nTmpNext = -1 then begin
            Result := nTmpPrev;
            exit;
        end;

        if nTmpPrev = -1 then begin
            Result := nTmpNext;
            exit;
        end;


        nRandom2 := Random(CARD_LIMIT) mod 2;
        if nRandom2 = 1 then begin
            Result := nTmpNext;
        end else begin
            Result := nTmpPrev;
        end;

end;

function TuDeck.Index( nListIndex:integer ): word;
begin
        Result := TCardData(m_aCardDataList.GetItems(nListIndex)).Index;
end;

function TuDeck.Category( nListIndex:integer ): word;
begin
       Result := TCardData(m_aCardDataList.GetItems(nListIndex)).Category;
end;

function TuDeck.Player( nListIndex:integer ): integer;
begin
       Result := TCardData(m_aCardDataList.GetItems(nListIndex)).Player;
end;

function TuDeck.Position( nListIndex:integer ): word;
begin
       Result := TCardData(m_aCardDataList.GetItems(nListIndex)).Position;
end;

function TuDeck.Items( nListIndex:integer ): TCardData;
begin
        Result := m_aCardDataList.GetItems(nListIndex);
end;

end.

function compareByPoker(Item1 : Pointer; Item2 : Pointer) : Integer;
var
        CardData1, CardData2: TCardData;
begin
        CardData1 := Item1;
        CardData2 := Item2;

        if CardData1.Index > CardData2.Index then
            Result := 1
        else if CardData1.Index = CardData2.Index then
            Result := 0
        else
            Result := -1;

end;

compare是給TList使用的

牌堆取牌器(52張牌)

用在發牌, 發麻將, 都還不錯.

當然啦,除非要用, 不然在小弟的強大墮性的驅使下, 不會花時間做任何的多型!

CuListCtrl - Encapsulates the functionality of a "list view control"

2010-01-15T15:00:00.000-08:00

// Encapsulates the functionality of a "list view control"

m_ListCtrl.Create( WS_VISIBLE | WS_CHILD | LVS_REPORT | LVS_SHOWSELALWAYS , rt, hWnd, (UINT)&1);



// CuListCtrl.h

class CuListCtrl
{
private:
    CuWnd m_ListCtrlWnd;
public:
    CuListCtrl(void);
    ~CuListCtrl(void);

    virtual BOOL Create( DWORD dwStyle, const RECT& rect,
        HWND hParentWnd, UINT nID );

    int InsertColumn( int nCol, const LVCOLUMN* pColumn );
    int InsertColumn( int nCol, TCHAR * lpszColumnHeading, 
        int nFormat = LVCFMT_LEFT, int nWidth = -1,int nSubItem = -1 );

    int InsertItem( const LVITEM* pItem );
    int InsertItem( int nItem,  TCHAR * lpszItem );
    int InsertItem( int nItem,  TCHAR * lpszItem, int nImage );
    int InsertItem( UINT nMask, int nItem, TCHAR * lpszItem, 
        UINT nState, UINT nStateMask, int nImage, LPARAM lParam );

    BOOL SetItemText( int nItem, int nSubItem, TCHAR * lpszText );

};



// CuListCtrl.cpp

CuListCtrl::CuListCtrl(void)
{
}

CuListCtrl::~CuListCtrl(void)
{
}

BOOL CuListCtrl::Create(
                    DWORD dwStyle,
                    const RECT& rect,
                    HWND hParentWnd,
                    UINT nID 
                    )
{
    return m_ListCtrlWnd.Create(WC_LISTVIEW , L"", dwStyle, rect, hParentWnd, nID);
}

int CuListCtrl::InsertColumn( int nCol, const LVCOLUMN* pColumn )
{
    return ListView_InsertColumn(m_ListCtrlWnd.GetSafeHwnd() , nCol, pColumn) ;
}

int CuListCtrl::InsertColumn( int nCol, TCHAR *lpszColumnHeading, 
                 int nFormat /* = LVCFMT_LEFT */, int nWidth /* = -1 */ ,int nSubItem /* = -1 */)
{
    LV_COLUMN lvC = {0};
    lvC.mask = LVCF_FMT | LVCF_TEXT ;

    if( nWidth != -1 )
    {
        lvC.mask = lvC.mask | LVCF_WIDTH;
        lvC.cx = nWidth;
    }

    if( nSubItem != -1 )
    {
        lvC.mask = lvC.mask | LVCF_SUBITEM;
        lvC.iSubItem = nSubItem;
    }

    lvC.fmt = nFormat;
    lvC.pszText = lpszColumnHeading;

    return this->InsertColumn( nCol, &lvC);

}

int CuListCtrl::InsertItem( const LVITEM* pItem )
{
    return  ListView_InsertItem(m_ListCtrlWnd.GetSafeHwnd(), pItem);
}

int CuListCtrl::InsertItem( int nItem,  TCHAR * lpszItem )
{

    LVITEM lvI = {0};
    lvI.mask = LVIF_TEXT ;
    lvI.iItem = nItem;
    lvI.pszText = lpszItem;

    return this->InsertItem( &lvI);

}

int CuListCtrl::InsertItem( int nItem,  TCHAR * lpszItem, int nImage )
{
    LVITEM lvI = {0};
    lvI.mask = LVIF_TEXT | LVIF_IMAGE ;
    lvI.iItem = nItem;
    lvI.pszText = lpszItem;
    lvI.iImage = nImage;

    return this->InsertItem( &lvI);
}

int CuListCtrl::InsertItem( UINT nMask, int nItem, TCHAR * lpszItem, 
                           UINT nState, UINT nStateMask, int nImage, LPARAM lParam )
{

    LVITEM lvI = {0};
    lvI.mask = nMask;
    lvI.iItem = nItem;
    lvI.pszText = lpszItem;
    lvI.state = nState;
    lvI.stateMask = nStateMask;
    lvI.iImage = nImage;
    lvI.lParam = lParam;

    return this->InsertItem( &lvI);

}

BOOL CuListCtrl::SetItemText( int nItem, int nSubItem, TCHAR * lpszText )
{
    ListView_SetItemText( m_ListCtrlWnd.GetSafeHwnd(), nItem, nSubItem, lpszText)
    return true;
}

這個是很無聊的封裝, 但在CE上作業時, 不開MFC下, 也只能包一包

CuDebugger - Display PHP value about Array , Class detail information.

2010-01-14T15:00:00.000-08:00

// Display PHP value about Array , Class detail information.

$debug = new CuDebugger
$debug->debug($result,  $key);


// CuDebugger.php

class CuDebugger  {

    var $m_Data;
    var $m_DataIndex;

    function CuDebugger() {
        $this->m_Data = array();
        $this->m_DataIndex = 0;
    }
    
    function debug($data, $key = null, $innerText = false)
    {
    
        $index = $this->m_DataIndex + 1;
        $this->m_Data[$index . " " .$key] = $data;
        $this->m_DataIndex = $index;
    }
    
    function innerText($data, $key = null)
    {
        $data = str_replace("<", "& lt;", $data);
        $data = str_replace(">", "& gt;", $data); 
        
        $this->debug($data, $key);
    }
    
    function GetHTML(){
        return $this->printArray($this->m_Data);
    }
    
    function printArray($var) {
        
        $title_string = "";
        $string_row = "";
        $string_value = "";
        $string = "";
        
        foreach($var as $key => $value){
            
            
            if( is_array($value) ) {
                $string_value .= $this->printArray($value, false);
            }
            elseif(gettype($value) == 'object') {
                $string_value .= "Object of class " . get_class($value) . " { ".serialize($value) . " } ";
            }
            elseif( $value ) {
                $string_value .= "$value";
            }
            else {
                $string_value .= "< BR >";
            }
            
            $string_row .= "<tr>\n<td><b>$key</b></td><td>$string_value</td></tr>\n";       
            $string_value = "";
            
        }
        
        if( $string_row ) {
            $string = '<table border = "1">'.$string_row;
            $string .= "</table>\n";
        }
        
        return $string;
        
        
    }   
}

CuEdit - provides the functionality of a Windows edit control.

2010-01-13T15:00:00.000-08:00

// provides the functionality of a Windows edit control.


CuEdit gEdit;
gEdit.Create( WS_VISIBLE|WS_CHILD| WS_BORDER,
       CuRect(0, 0, 40 * 2 , 14 * 2), hWnd, (UINT)1);

gEdit.SetWindowText(TEXT("HI Edit"));

String strText;
gEdit.GetWindowText(strText);



// CuEdit.h


class CuEdit
{
    CuWnd m_EditWnd;
public:
    CuEdit(void);
    ~CuEdit(void);

    virtual BOOL Create( DWORD dwStyle, const RECT& rect, 
        HWND hParentWnd, UINT nID );

    void SetWindowText( LPCTSTR lpszString );
    void GetWindowText( String& rString ) const;
};




// CuEdit.cpp


CuEdit::CuEdit(void)
{
}

CuEdit::~CuEdit(void)
{
}

BOOL CuEdit::Create( DWORD dwStyle, const RECT& rect, 
                    HWND hParentWnd, UINT nID )
{
    return m_EditWnd.CreateEx(WS_EX_CLIENTEDGE, TEXT("EDIT"), 
        TEXT(""), dwStyle, rect, hParentWnd, nID);
}


void CuEdit::SetWindowText( LPCTSTR lpszString )
{
    ::SetWindowText( m_EditWnd.GetSafeHwnd(), lpszString );
}

void CuEdit::GetWindowText( String& rString ) const
{
    int nLenght = ::GetWindowTextLength( m_EditWnd );
    TCHAR *pszBuffer = new TCHAR[nLenght + 1];

    ::GetWindowText(m_EditWnd , pszBuffer, nLenght);

    rString = pszBuffer;
    delete [] pszBuffer;
}

沒打算繼承CuWnd! 看不到多型繼承後也沒任何好處!

CuWnd - is distinct from a Windows window

2010-01-12T15:00:00.001-08:00

// is distinct from a Windows window

//
class CuMainWnd : public CuWnd {};

//
CuWnd ListCtrlWnd;
ListCtrlWnd.Create(WC_LISTVIEW , TEXT(""), dwStyle, rect, hParentWnd, nID);

CuWnd EditWnd;
EditWnd.CreateEx(WS_EX_CLIENTEDGE, TEXT("EDIT"), TEXT(""), dwStyle, rect, hParentWnd, nID);

// CuWnd.h

class CuWnd
{
private:
    HWND m_hWnd;

private:

    //////////////////////////////////////////////////////////////////////
    // 函式名稱: WndProc
    // 函式說明: Create時預設的訊息回圈 會將訊息派送到 OnMsg裡
    //////////////////////////////////////////////////////////////////////
    static LRESULT CALLBACK WndProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam);

public:
    // 建構 解構
    CuWnd(void);
    virtual ~CuWnd(void);

protected:

    //////////////////////////////////////////////////////////////////////
    // 函式名稱: OnMsg
    // 函式說明: 繼承這個函式處理windows訊息
    //////////////////////////////////////////////////////////////////////
    virtual LRESULT OnMsg(MSG &msg);

public:

    virtual BOOL Create( LPCTSTR lpszClassName, LPCTSTR lpszWindowName,
        DWORD dwStyle,  const CuRect &rect, 
        HWND hParentWnd = NULL, UINT nID = NULL );

    virtual BOOL CreateEx( DWORD dwExStyle, LPCTSTR lpszClassName,
        LPCTSTR lpszWindowName, DWORD dwStyle, const CuRect& rect,
        HWND hParentWnd = NULL, UINT nID = NULL);

    ATOM WndRegisterClassEx(LPCTSTR szWindowClass);


    // inline 函式 實作碼在下方
    HWND GetSafeHwnd( ) const;
    BOOL ShowWindow(int nCmdShow);
    BOOL UpdateWindow();
    BOOL DestroyWindow();

    operator HWND() const
    {
        return GetSafeHwnd();
    }

public:
    // 訊息處理函式
    void OnDestroy();

};

inline HWND CuWnd::GetSafeHwnd() const
{ return (HWND)(this == NULL ? NULL : m_hWnd) ;}

inline BOOL CuWnd::ShowWindow(int nCmdShow)
{ return ::ShowWindow( m_hWnd, nCmdShow); }

inline BOOL CuWnd::UpdateWindow()
{ return ::UpdateWindow(m_hWnd); }

inline BOOL CuWnd::DestroyWindow()
{ 
 BOOL bResult = ::DestroyWindow(m_hWnd); 
 m_hWnd = NULL;
 return bResult;
}

// CuWnd.cpp


CuWnd::CuWnd(void)
:m_hWnd(NULL)
{

}

CuWnd::~CuWnd(void)
{
    this->DestroyWindow();
}


//////////////////////////////////////////////////////////////////////
// 函式名稱: OnMsg
// 函式說明: 預設訊息處理
//////////////////////////////////////////////////////////////////////
LRESULT CuWnd::OnMsg(MSG &msg)
{
    return 0;
}

void CuWnd::OnDestroy()
{
    PostQuitMessage(0);
}

LRESULT CALLBACK CuWnd::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    static MSG msg;

    msg.hwnd = hWnd;
    msg.message = message;
    msg.wParam = wParam;
    msg.lParam = lParam;

    static CuWnd *pWnd = NULL;
    if( message == WM_CREATE )
    {
    
        CREATESTRUCT *pct = (LPCREATESTRUCT)lParam;
        ::SetWindowLong( hWnd , GWL_USERDATA, (LONG)pct->lpCreateParams );
        
    }


    pWnd = (CuWnd *)::GetWindowLong(hWnd, GWL_USERDATA);
    if( pWnd && pWnd->OnMsg(msg) )
        return 0;
    else
        return ::DefWindowProc(hWnd, message, wParam, lParam);
    


}

BOOL CuWnd::Create( LPCTSTR lpszClassName, LPCTSTR lpszWindowName,
                    DWORD dwStyle, const CuRect &rect,
                    HWND hParentWnd /* = NULL */, UINT nID /* = NULL*/ )
{


    m_hWnd = ::CreateWindow(lpszClassName, lpszWindowName, dwStyle,
        rect.left, rect.top, rect.Width(), rect.Height(), 
        hParentWnd, (HMENU)nID, GetModuleHandle(NULL), (LPVOID) this);

    Assert( m_hWnd != NULL, L"CreateWindow Error");
    DWORD dwError = GetLastError();

    return (BOOL) (m_hWnd == NULL ? NULL : m_hWnd);

}

BOOL CuWnd::CreateEx( DWORD dwExStyle, LPCTSTR lpszClassName,
                      LPCTSTR lpszWindowName, DWORD dwStyle, const CuRect& rect,
                      HWND hParentWnd  /* = NULL */, UINT nID /* = NULL*/)
{

    m_hWnd = ::CreateWindowEx( dwExStyle, lpszClassName, 
        lpszWindowName, dwStyle, 
        rect.left, rect.top, rect.Width(), rect.Height(),
        hParentWnd, (HMENU)nID, GetModuleHandle(NULL), (LPVOID) this);

    Assert( m_hWnd != NULL, L"CreateWindow Error");
    DWORD dwError = GetLastError();

    return (BOOL) (m_hWnd == NULL ? NULL : m_hWnd);
}


ATOM CuWnd::WndRegisterClassEx(LPCTSTR szWindowClass)
{

    WNDCLASS    wc;
    
    wc.style            = CS_HREDRAW | CS_VREDRAW;

    wc.lpfnWndProc      = (WNDPROC) WndProc;
    wc.cbClsExtra       = 0;
    wc.cbWndExtra       = 0;
    wc.hInstance        = GetModuleHandle(NULL);
    wc.hIcon            = 0;
    wc.hCursor          = 0;
    wc.hbrBackground    = 0;
    wc.lpszMenuName     = 0;
    wc.lpszClassName    = szWindowClass;
    
    return RegisterClass(&wc);


}

CCriticalSection - a critical section object.

2010-01-11T16:00:00.001-08:00

// a critical section object.

CCriticalSection m_cs;
...


m_cs.Enter();
...
m_cs.Leave();

// CCriticalSection.h


class CCriticalSection  
{
    CRITICAL_SECTION m_CriticalSection;
public:
    void Leave();
    void Enter();

    CCriticalSection();
    virtual ~CCriticalSection();

};




// CCriticalSection.cpp

CCriticalSection::CCriticalSection()
{
    ::InitializeCriticalSection(&m_CriticalSection);
}

CCriticalSection::~CCriticalSection()
{
    ::DeleteCriticalSection(&m_CriticalSection);
}

void CCriticalSection::Enter()
{
    ::EnterCriticalSection(&m_CriticalSection);
}

void CCriticalSection::Leave()
{
    ::LeaveCriticalSection(&m_CriticalSection);
}

CuKeyStatusComposite - group of KeyStatus

2010-01-10T16:00:00.000-08:00

// group of KeyStatus


CuKeyStatusComposite ksComposite;

for( int j = 0 ; j < arr.size() ; j++ )
{
    CuKeyStatus *pks = new CuKeyStatus;
    // ...
    ksComposite.push_back(pks);
}

ksComposite.clear();

// CuKeyStatusComposite.h

class CuKeyStatusComposite :
 public TuComposite<CuKeyStatus>
{
public:
    CuKeyStatusComposite(void);
    ~CuKeyStatusComposite(void);

    int GetEqualItemIndex( CuKeyStatus &KeyStatus);
};



// CuKeyStatusComposite.cpp

CuKeyStatusComposite::CuKeyStatusComposite(void)
{
}

CuKeyStatusComposite::~CuKeyStatusComposite(void)
{
    this->clear();
}

int CuKeyStatusComposite::GetEqualItemIndex( CuKeyStatus &KeyStatus)
{
    int nResult = -1;
    
    _itor = _itsElement.begin();
    
    while(  _itor != _itsElement.end() )
    {
    
        if( KeyStatus == *(*_itor) )
        {
            nResult = _itor - _itsElement.begin();
            break;
        }
    
        _itor++;
    
    }
    
    return nResult;

}

GetEqualItemIndex 只有這個專案需要, 沒有打算移到 TuComposite 內, 下次在遇到時, 在處理.

CReg - An encapsulation of the Windows registry key.

2010-01-09T16:00:00.000-08:00

// An encapsulation of the Windows registry key.  


CReg reg(HKEY_LOCAL_MACHINE, TEXT("Software\\AppName\\"));
string strPath = reg.ValueSZ( "KeyName" );


// CReg.h

class CReg  
{
private:
    HKEY    m_hKey;
    int     m_Index;
    LPBYTE  m_lpbValue; // last value read, if any

public:
    CReg();
    ~CReg();

    BOOL Create(HKEY hkRoot, LPCTSTR pszKey) {
        DWORD dwDisp;
        return ERROR_SUCCESS==RegCreateKeyEx(hkRoot, pszKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &m_hKey, &dwDisp);
    }

    BOOL Open(HKEY hkRoot, LPCTSTR pszKey, REGSAM sam=KEY_READ) {
        return ERROR_SUCCESS==RegOpenKeyEx(hkRoot, pszKey, 0, sam, &m_hKey);
    }

    CReg(HKEY hkRoot, LPCTSTR pszKey) {
        m_hKey = NULL;
        m_Index = 0;
        m_lpbValue = NULL;
        Open(hkRoot, pszKey);
    }



    void MyFree(LPBYTE m_lpbValue) {
        delete [] m_lpbValue;
    }

    LPBYTE MyRgAlloc(int dwLen)
    {
        return new BYTE[dwLen];
    }

    void Reset() { 
        if(m_hKey) RegCloseKey(m_hKey); 
        MyFree(m_lpbValue);
        m_hKey = NULL;
        m_Index = 0;
        m_lpbValue = NULL;
    }

    operator HKEY() { return m_hKey; }

    BOOL IsOK(void) { return m_hKey!=NULL; }


    BOOL EnumKey(LPTSTR psz, DWORD dwLen) {
        if(!m_hKey) return FALSE;
        return ERROR_SUCCESS==RegEnumKeyEx(m_hKey, m_Index++, psz, &dwLen, NULL, NULL, NULL, NULL);
    }

    BOOL EnumValue(LPTSTR pszName, DWORD dwLenName, LPTSTR pszValue, DWORD dwLenValue) {
        DWORD dwType;
        if(!m_hKey) return FALSE;
        dwLenValue *= sizeof(TCHAR); // convert length in chars to bytes
        return ERROR_SUCCESS==RegEnumValue(m_hKey, m_Index++, pszName, &dwLenName, NULL, &dwType, (LPBYTE)pszValue, &dwLenValue);
    }

    BOOL ValueSZ(LPCTSTR szName, LPTSTR szValue, DWORD dwLen) 
    {
        if(!m_hKey) return FALSE;
        dwLen *= sizeof(TCHAR); // convert length in chars to bytes
        return ERROR_SUCCESS==RegQueryValueEx(m_hKey, szName, NULL, NULL, (LPBYTE)szValue, &dwLen);
    }

    DWORD ValueBinary(LPCTSTR szName, LPBYTE lpbValue, DWORD dwLen) {
        if(!m_hKey) return FALSE;
        DWORD dwLenWant = dwLen;
        if(ERROR_SUCCESS==RegQueryValueEx(m_hKey, szName, NULL, NULL, lpbValue, &dwLen))
            return dwLen;
        else
            return 0;
    }

    LPCTSTR ValueSZ(LPCTSTR szName)
    {
        if(!m_hKey) return TEXT("");
        DWORD dwLen = 0;
        if( (ERROR_SUCCESS != RegQueryValueEx(m_hKey, szName, NULL, NULL, NULL, &dwLen)) || 
            (dwLen == 0) )
                return TEXT("");
        MyFree(m_lpbValue);
        if( !(m_lpbValue = MyRgAlloc(dwLen)) ||
            (ERROR_SUCCESS != RegQueryValueEx(m_hKey, szName, NULL, NULL, m_lpbValue, &dwLen)) )
                return TEXT("");
        return (LPTSTR)m_lpbValue;
    }

    LPBYTE ValueBinary(LPCTSTR szName) {
        return (LPBYTE)ValueSZ(szName);
    }

    DWORD ValueDW(LPCTSTR szName, DWORD dwDefault=0) {
        if(!m_hKey) return FALSE;
        DWORD dwValue = dwDefault;
        DWORD dwLen = sizeof(DWORD);
        RegQueryValueEx(m_hKey, szName, NULL, NULL, (LPBYTE)&dwValue, &dwLen);
        return dwValue;
    }

    LONG  ValueDW2(LPCTSTR szName, DWORD &dwDefault) {
        if(!m_hKey) return FALSE;
        DWORD dwValue = dwDefault;
        DWORD dwLen = sizeof(DWORD);
        return RegQueryValueEx(m_hKey, szName, NULL, NULL, (LPBYTE)&dwValue, &dwLen);
    }

    BOOL SetSZ(LPCTSTR szName, LPCTSTR szValue, DWORD dwLen) {
        if(!m_hKey) return FALSE;
        return ERROR_SUCCESS==RegSetValueEx(m_hKey, szName, 0, REG_SZ, (LPBYTE)szValue, sizeof(TCHAR)*dwLen);
    }
    
    BOOL SetSZ(LPCTSTR szName, LPCTSTR szValue) {
        return SetSZ(szName, szValue, 1+lstrlen(szValue));
    }

    BOOL SetDW(LPCTSTR szName, DWORD dwValue) {
        if(!m_hKey) return FALSE;
        return ERROR_SUCCESS==RegSetValueEx(m_hKey, szName, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(DWORD));
    }
    
    BOOL SetBinary(LPCTSTR szName, LPBYTE lpbValue, DWORD dwLen) {
        if(!m_hKey) return FALSE;
        return ERROR_SUCCESS==RegSetValueEx(m_hKey, szName, 0, REG_BINARY, lpbValue, dwLen);
    }

    BOOL SetMultiSZ(LPCTSTR szName, LPCTSTR lpszValue, DWORD dwLen) {
        return ERROR_SUCCESS==RegSetValueEx(m_hKey, szName, 0, REG_MULTI_SZ, (LPBYTE)lpszValue, sizeof(TCHAR)*dwLen);
    }

    BOOL DeleteValue(LPCTSTR szName) {
        if(!m_hKey) return FALSE;
        return ERROR_SUCCESS==RegDeleteValue(m_hKey, szName);
    }

    BOOL DeleteKey(LPCTSTR szName) {
        if(!m_hKey) return FALSE;
        return ERROR_SUCCESS==RegDeleteKey(m_hKey, szName);
    }
};


// CReg.cpp

CReg::CReg()
{
        m_hKey = NULL;
        m_Index = 0;
        m_lpbValue = NULL;
}

CReg::~CReg()
{
    if(m_hKey) 
        RegCloseKey(m_hKey); 
    MyFree(m_lpbValue);
}

CuRecord - Access Record

2010-01-08T16:00:00.000-08:00

// Access Record

$record = new CuRecord($ado, $table_name, $key);

//
$record->SetField("field_name", $field_value );
$record->Save();

//
$record->Load("field_name", $field_value);
$value = $record->GetField("field_name");

//
$record->Load("field_name", $field_value);
$record->Destroy();


// CuRecord.php

class CuRecord  {

    var $ado;
    var $table_name; 
    
    var $key_name; 
    var $key_value; 
    
    var $database_fields;
    var $modified_fields;
    
    
    function CuRecord($ado, $table_name, $key_name = "sn" , $key_value = "") {
        
        $this->ado = &$ado;
        $this->table_name = $table_name;
        $this->key_name = $key_name;
        $this->key_value = $this->_check_input($key_value);
        
        $this->database_fields = array();
        $this->modified_fields = array();        
    }
    
    
    function SetField( $field, $value) {

        if( is_numeric($field) ) 
            return;
        
        $this->database_fields[$field] = $value;
        $this->modified_fields[$field] = true;

    }


    function GetField($field) {
        return $this->database_fields[$field]; 
    }   


    function Destroy() {
        
        if( !$this->key_value )
            return;
        return $this->ado->sql("DELETE FROM $this->table_name WHERE $this->key_name = '$this->key_value'");
        
    }   
    

    function Save()
    {
        
        if( $this->key_value )
        {
            $result = $this->_update();
        }
        else
        {
            $result = $this->_insert();
            $this->_load_key_value();
        }
        
        return $this->key_value;
    }
    

    function Load($bargain_field, $bargain_value)
    {
        
        if(!($bargain_field && $bargain_value ))
        {
            $bargain_field = $this->key_name;
            $bargain_value = $this->key_value;
        }
        
        if( !($bargain_field && $bargain_value ) )
            return;
        
        $value = $this->_check_input($bargain_value);
        $stmt = "`$bargain_field` = '$value'";
        $stmt = "SELECT * FROM $this->table_name WHERE $stmt";
         
        $result = $this->ado->sql($stmt);
        if( $result == "" )
            return ;
        
        $result_table = $this->ado->fetch_array();
        $this->database_fields = $result_table[0];
        
        if( sizeof($this->modified_fields) > 0 ) {
            foreach( $this->modified_fields as $key => $value ) {
                $this->modified_fields[$key] = false;
            }
        }       
        
        $this->key_value = $result_table[0][$this->key_name];
        
        return $this->key_value;
        
    }
    

    function _load_key_value()
    {
        $stmt = "SELECT MAX($this->key_name) AS $this->key_name FROM `$this->table_name` WHERE ";
        foreach( $this->database_fields as $key => $value ){
            if( !is_numeric($key) && $value ){
                if( $this->modified_fields[$key] == true ){
                    $value = $this->_check_input($value); 
                    $stmt .= "`$key` = '$value' AND ";
                }
            }
        } 
        
        $stmt = substr($stmt,0,strlen($stmt)-5);    
        $handle = $this->ado->sql($stmt);
        
        $result_table = $this->ado->fetch_array();
        $this->key_value = $result_table[0][$this->key_name];
        
        return $result_rows;
    }
    

    function _insert() {

        $stmt = "INSERT INTO `$this->table_name` ";
        
        foreach ($this->database_fields as $key => $value) {
            if( !is_numeric( $key )&& $value){
                $key = $this->_check_input($key);
                $key_stmt .= " `$key`,";
                
                $value = $this->_check_input($value);
                $value_stmt .= " '$value',";
                
            }
        }
        
        $key_stmt = substr($key_stmt,0,strlen($key_stmt)-1); 
        $value_stmt = substr($value_stmt,0,strlen($value_stmt)-1); 
        
        $stmt .= " (" . $key_stmt . ") VALUES (" . $value_stmt . ")" ;
        $handle = $this->ado->sql($stmt, "_insert");
        
        
        return $handle . " " . $stmt;
        
    }    
    
    
    function _update() {
        
        $field_value = $this->key_value;
        $field_name = $this->key_name;
        $table_name = $this->table_name;
        
        $stmt = "UPDATE `$table_name` SET ";
        foreach ($this->database_fields as $key => $value) {
            if( !is_numeric( $key ) ){
                if( $this->modified_fields[$key] == true ) {
                    $value = $this->_check_input($value);
                    if( $value == "" ){
                        $stmt .= "`$key` = 'NULL', ";
                    }
                    else {
                        $stmt .= "`$key` = '$value', ";
                    }
                }
            }
        }
        
        $stmt = substr($stmt, 0, strlen($stmt) - 2);
        $stmt .= " WHERE `$field_name` = '$field_value'"; 
        
        $handle = $this->ado->sql($stmt);
        return $handle . " " . $stmt;
        
    } 
    
    
    function _check_input($value)
    {
        if($value == "")
            return "";

        if (get_magic_quotes_gpc())
        {
            $value = stripslashes($value);
        }
        
        if (!is_numeric($value))
        {
            $value =  mysql_real_escape_string($value);
        }
        
        return $value;
    }
}

CuSize - Similar to the Windows SIZE structure

2010-01-07T16:00:00.000-08:00

// Similar to the Windows SIZE structure

// CuSize.h

class CuSize : public tagSIZE
{
public:

// Constructors
    // construct an uninitialized size
    CuSize() throw();
    // create from two integers
    CuSize(int initCX, int initCY) throw();
    // create from another size
    CuSize(SIZE initSize) throw();
    // create from a point
    CuSize(POINT initPt) throw();
    // create from a DWORD: cx = LOWORD(dw) cy = HIWORD(dw)
    CuSize(DWORD dwSize) throw();

// Operations
    BOOL operator==(SIZE size) const throw();
    BOOL operator!=(SIZE size) const throw();
    void operator+=(SIZE size) throw();
    void operator-=(SIZE size) throw();
    void SetSize(int CX, int CY) throw();

// Operators returning CuSize values
    CuSize operator+(SIZE size) const throw();
    CuSize operator-(SIZE size) const throw();
    CuSize operator-() const throw();

// Operators returning CuPoint values
    CuPoint operator+(POINT point) const throw();
    CuPoint operator-(POINT point) const throw();

// Operators returning CuRect values
    CuRect operator+(const RECT* lpRect) const throw();
    CuRect operator-(const RECT* lpRect) const throw();
};

inline CuSize::CuSize()
    { /* random filled */ }
inline CuSize::CuSize(int initCX, int initCY)
    { cx = initCX; cy = initCY; }
inline CuSize::CuSize(SIZE initSize)
    { *(SIZE*)this = initSize; }
inline CuSize::CuSize(POINT initPt)
    { *(POINT*)this = initPt; }
inline CuSize::CuSize(DWORD dwSize)
    {
        cx = (short)LOWORD(dwSize);
        cy = (short)HIWORD(dwSize);
    }
inline BOOL CuSize::operator==(SIZE size) const
    { return (cx == size.cx && cy == size.cy); }
inline BOOL CuSize::operator!=(SIZE size) const
    { return (cx != size.cx || cy != size.cy); }
inline void CuSize::operator+=(SIZE size)
    { cx += size.cx; cy += size.cy; }
inline void CuSize::operator-=(SIZE size)
    { cx -= size.cx; cy -= size.cy; }
inline void CuSize::SetSize(int CX, int CY)
    { cx = CX; cy = CY; }   
inline CuSize CuSize::operator+(SIZE size) const
    { return CuSize(cx + size.cx, cy + size.cy); }
inline CuSize CuSize::operator-(SIZE size) const
    { return CuSize(cx - size.cx, cy - size.cy); }
inline CuSize CuSize::operator-() const
    { return CuSize(-cx, -cy); }
inline CuPoint CuSize::operator+(POINT point) const
    { return CuPoint(cx + point.x, cy + point.y); }
inline CuPoint CuSize::operator-(POINT point) const
    { return CuPoint(cx - point.x, cy - point.y); }
inline CuRect CuSize::operator+(const RECT* lpRect) const
    { return CuRect(lpRect) + *this; }
inline CuRect CuSize::operator-(const RECT* lpRect) const
    { return CuRect(lpRect) - *this; }

CuADO - connection to a MySQL Server

2010-01-06T15:52:00.000-08:00

// connection to a MySQL Server

$this->ado = new CuADO;
$ado->Connect($host, $username, $password);
$ado->SelectDB($db); 


// CuADO.php


class CuADO  {
    
    var $link;
    var $query_handle;
    
    function CuADO() {
        
    }
    
    function Connect($host, $username, $password)
    {
        $this->link = mysql_connect($host, $username, $password);
        return $this->link;
    }
    
    function SelectDB($db)
    {
        return mysql_select_db($db, $this->link);
    }

    function sql($stmt, $debug_key = "")
    {
        $this->query_handle = mysql_query($stmt, $this->link) ;
        return $this->query_handle;
    }

    function fetch_array() {
        
        $query_handle = &$this->query_handle;
        $i = 0;
        while($result_rows[$i] = mysql_fetch_array( $query_handle ) ){
            $i++;
        }
        
        return $result_rows;
        
    }   
    
}

TuComposite - Template of Composite pattern

2010-01-05T15:26:00.000-08:00

// allows a group of objects to be treated in the same way as a single instance of an object.

//
TuComposite<CuMyObject> myComposite;
CuMyObject *pMyObject = &myComposite;

//
class CuMyCompositeObject : public TuComposite<CuMyObject> 
{
    ...
};

// TuComposite.h


template <typename T>
class TuComposite : public T
{
protected:
    vector<T*> _itsElement;
    typename vector<T*>::iterator _itor; 
    
public:

    TuComposite(){};
    virtual ~TuComposite(){};

    void push_back(T *pElement){ _itsElement.push_back(pElement); }
    void insert(int n, T *pElement){ _itsElement.insert(_itsElement.begin() + n, pElement); }

    T* at(const int nIndex){ return _itsElement[nIndex]; }
    void reserve( int _Count ){_itsElement.reserve(_Count); }

    int size(){ return _itsElement.size(); }
    
    void remove(T *pElement);
    void clear();
    
    
};

template <typename T>
void TuComposite<T>::clear()
{
    
    _itor = _itsElement.begin();
    
    while(  _itor != _itsElement.end() )
    {
        
        T* pElement = *_itor;
        delete pElement;
        _itor++;
        
    }
    
    _itsElement.clear();
    
}

template <typename T>
void TuComposite<T>::remove(T *pElement)
{
    
    _itor = _itsElement.begin();
    
    while(  _itor != _itsElement.end() )
    {
        
        if( pElement == *_itor )
        {
            _itsElement.erase(_itor);
            break;
        }
        _itor++;
        
    }
    
}

TuList - General purpose container of a list of objects

2010-01-05T02:09:00.000-08:00

// General purpose container of a list of objects

ObjList : TuList;
ObjList := TuList.Create();
ObjList.Add(MyObject);

MyObject := ObjList.GetItems(i);
ObjList.Free;

// u_TList.pas

unit u_TList;

interface
uses
      Windows, Classes, SysUtils,
      StdCtrls,
      ch_LogMessages;

type

      TuList = class
        private
          m_List : TList;
        public
          constructor Create();
          destructor Destroy();  override;
          procedure Clear();
          function Count: Integer;
          function Add( Item:Pointer ):Integer;
          function GetItems(Index: Integer): Pointer;
          procedure Sort(Compare: TListSortCompare);
          procedure Delete(Index: Integer);
      end;

implementation

{ TuList }


function TuList.Add(Item: Pointer): Integer;
begin
        Result := m_List.Add(Item);
end;

procedure TuList.Clear;
begin
        m_List.Clear;
end;

function TuList.Count: Integer;
begin
        Result := m_List.Count;
end;

constructor TuList.Create;
begin
        m_List := TList.Create;
end;

procedure TuList.Delete(Index: Integer);
begin
        m_List.Delete(Index);
end;

destructor TuList.Destroy;
begin
        m_List.Free;
        inherited;
end;

function TuList.GetItems(Index: Integer): Pointer;
begin

        if (Index < 0) or (Index >= m_List.Count ) then begin
            Index := 0;
        end;

        Result := m_List.Items[Index];

end;


procedure TuList.Sort(Compare: TListSortCompare);
begin
        m_List.Sort(Compare);
end;

end.

CuKeyStatus - a struct of the keyboard status.

2010-01-04T15:52:00.000-08:00

// a struct of the keyboard status. 
// override operator == 
CuKeyStatus ksFromLLKeyHook;
CuKeyStatus ksClientDefault;

Assert( ksFromLLKeyHook == ksClientDefault );

// CuKeyStatus.h
class CuKeyStatus
{
public:
    BOOL m_bAlt;
    BOOL m_bCtrl;
    BOOL m_bShift;
    DWORD m_dwScanCode;
    DWORD m_dwVirtualKey;

    CuKeyStatus()
        :m_bAlt(FALSE)
        ,m_bCtrl(FALSE)
        ,m_bShift(FALSE)
        ,m_dwScanCode(0)
        ,m_dwVirtualKey(0)
    {};
    ~CuKeyStatus(void){};

    BOOL operator == (CuKeyStatus &KeyStatus);
    
};

inline BOOL CuKeyStatus::operator == (CuKeyStatus &KeyStatus)
{
    return m_bAlt == KeyStatus.m_bAlt &&
        m_bCtrl == KeyStatus.m_bCtrl &&
        m_bShift == KeyStatus.m_bShift &&
        m_dwScanCode == KeyStatus.m_dwScanCode &&
        m_dwVirtualKey == KeyStatus.m_dwVirtualKey ;
}

CuMenu - An encapsulation of the Windows HMENU.

2010-01-03T16:14:00.000-08:00

// An encapsulation of the Windows HMENU. 

CuMenu MenuTray.LoadMenu(IDR_MENU_MYMENU);
CuMenu *pTrackMenu = MenuTray.GetSubMenu(0);
pTrackMenu->TrackPopupMenu(TPM_BOTTOMALIGN, pt.x, pt.y, this->GetSafeHwnd() );  
MenuTray.DestroyMenu();



// CuMenu.h

class CuMenu
{
    HMENU m_hMenu;
public:
    CuMenu(void);
    ~CuMenu(void);

    BOOL DestroyMenu();
    BOOL LoadMenu( UINT nIDResource );
    CuMenu* GetSubMenu( int nPos ) const;

    BOOL Attach( HMENU hMenu );
    BOOL TrackPopupMenu(
        UINT nFlags,
        int x,
        int y,
        HWND hWnd,
        LPCRECT lpRect = 0
        );

};



// CuMenu.cpp


CuMenu::CuMenu(void)
:m_hMenu(NULL)
{
}

CuMenu::~CuMenu(void)
{
    DestroyMenu();
}

BOOL CuMenu::LoadMenu( UINT nIDResource )
{
    m_hMenu = ::LoadMenu(::GetModuleHandle(NULL), MAKEINTRESOURCE(nIDResource));
    return ( m_hMenu != NULL );
}

CuMenu* CuMenu::GetSubMenu( int nPos ) const
{
    HMENU hMenu = ::GetSubMenu( m_hMenu, nPos );

    static CuMenu SubMenu;
    SubMenu.Attach(hMenu);
    return &SubMenu;
}

BOOL CuMenu::Attach( HMENU hMenu )
{
    m_hMenu = hMenu;
    return ( m_hMenu != NULL );
}

BOOL CuMenu::TrackPopupMenu(
                    UINT nFlags,
                    int x,
                    int y,
                    HWND hWnd,
                    LPCRECT lpRect /*= 0*/
                    )
{
    return ::TrackPopupMenu(m_hMenu, nFlags, x, y, 0, hWnd, lpRect);
}

BOOL CuMenu::DestroyMenu()
{
    return ::DestroyMenu(m_hMenu);
}

CuKeyboard - Conversion LowLevelKeyHook to CuKeyStatus

2010-01-02T18:14:00.000-08:00

// Conversion LowLevelKeyHook to CuKeyStatus


LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam)
{

    static CuKeyboard Keyboard;
    Keyboard.FromLowLevelKeyHook(wParam, lParam);
    
    CuKeyNameTextEx KeyNameTextEx(Keyboard.GetKeyStatus());
    
    wstring strKeyboard = KeyNameTextEx;
 
    return 0;
}

CuHook hook;
hook.Init(HookProc, WH_KEYBOARD_LL);


// CuKeyboard.h


class CuKeyboard
{
    CuKeyStatus m_KeyStatus;
    BOOL m_bScanCode[256];

public:
    CuKeyboard(void);
    ~CuKeyboard(void);

    void FromLowLevelKeyHook(WPARAM wParam, LPARAM lParam);
    CuKeyStatus GetKeyStatus(){ return m_KeyStatus; }
private:
    bool IsFunctionKey(DWORD dwScanCode);

};


// CuKeyboard.cpp


CuKeyboard::CuKeyboard(void)
{
    memset((void*)m_bScanCode, 0, sizeof(m_bScanCode)  );
}

CuKeyboard::~CuKeyboard(void)
{
}


void CuKeyboard::FromLowLevelKeyHook(WPARAM wParam, LPARAM lParam)
{
    KBDLLHOOKSTRUCT *pKB = (KBDLLHOOKSTRUCT *)lParam;

    //
    BOOL bKeyDown = ( (wParam == WM_KEYDOWN) || (wParam == WM_SYSKEYDOWN) );
    m_bScanCode[pKB->scanCode] = bKeyDown;


    // 
    if( IsFunctionKey(pKB->scanCode) )
    {
        m_KeyStatus.m_bAlt = m_bScanCode[56];
        m_KeyStatus.m_bCtrl = m_bScanCode[29];
        m_KeyStatus.m_bShift = (m_bScanCode[42] || m_bScanCode[54]);
    }
    else
    {
        if( !bKeyDown )
            m_KeyStatus.m_dwScanCode = 0;
        else
            m_KeyStatus.m_dwScanCode = pKB->scanCode; 
    }

}

bool CuKeyboard::IsFunctionKey(DWORD dwScanCode)
{
    return ((dwScanCode == 56) || (dwScanCode == 29) || (dwScanCode == 42) || (dwScanCode == 54));
}

CuPoint - A 2-D point, similar to Windows POINT structure.

2010-01-01T17:12:00.000-08:00

// CuPoint - A 2-D point, similar to Windows POINT structure.

class CuPoint : public tagPOINT
{
public:
// Constructors

    // create an uninitialized point
    CuPoint() throw();
    // create from two integers
    CuPoint(int initX, int initY) throw();
    // create from another point
    CuPoint(POINT initPt) throw();
    // create from a size
    CuPoint(SIZE initSize) throw();
    // create from an LPARAM: x = LOWORD(dw) y = HIWORD(dw)
    CuPoint(LPARAM dwPoint) throw();


// Operations

// translate the point
    void Offset(int xOffset, int yOffset) throw();
    void Offset(POINT point) throw();
    void Offset(SIZE size) throw();
    void SetPoint(int X, int Y) throw();

    BOOL operator==(POINT point) const throw();
    BOOL operator!=(POINT point) const throw();
    void operator+=(SIZE size) throw();
    void operator-=(SIZE size) throw();
    void operator+=(POINT point) throw();
    void operator-=(POINT point) throw();

// Operators returning CuPoint values
    CuPoint operator+(SIZE size) const throw();
    CuPoint operator-(SIZE size) const throw();
    CuPoint operator-() const throw();
    CuPoint operator+(POINT point) const throw();

// Operators returning CuSize values
    CuSize operator-(POINT point) const throw();

// Operators returning CuRect values
    CuRect operator+(const RECT* lpRect) const throw();
    CuRect operator-(const RECT* lpRect) const throw();
};


inline CuPoint::CuPoint()
    { /* random filled */ }
inline CuPoint::CuPoint(int initX, int initY)
    { x = initX; y = initY; }
inline CuPoint::CuPoint(POINT initPt)
    { *(POINT*)this = initPt; }
inline CuPoint::CuPoint(SIZE initSize)
    { *(SIZE*)this = initSize; }
inline CuPoint::CuPoint(LPARAM dwPoint)
    {
        x = (short)LOWORD(dwPoint);
        y = (short)HIWORD(dwPoint);
    }
inline void CuPoint::Offset(int xOffset, int yOffset)
    { x += xOffset; y += yOffset; }
inline void CuPoint::Offset(POINT point)
    { x += point.x; y += point.y; }
inline void CuPoint::Offset(SIZE size)
    { x += size.cx; y += size.cy; }
inline void CuPoint::SetPoint(int X, int Y)
    { x = X; y = Y; }
inline BOOL CuPoint::operator==(POINT point) const
    { return (x == point.x && y == point.y); }
inline BOOL CuPoint::operator!=(POINT point) const
    { return (x != point.x || y != point.y); }
inline void CuPoint::operator+=(SIZE size)
    { x += size.cx; y += size.cy; }
inline void CuPoint::operator-=(SIZE size)
    { x -= size.cx; y -= size.cy; }
inline void CuPoint::operator+=(POINT point)
    { x += point.x; y += point.y; }
inline void CuPoint::operator-=(POINT point)
    { x -= point.x; y -= point.y; }
inline CuPoint CuPoint::operator+(SIZE size) const
    { return CuPoint(x + size.cx, y + size.cy); }
inline CuPoint CuPoint::operator-(SIZE size) const
    { return CuPoint(x - size.cx, y - size.cy); }
inline CuPoint CuPoint::operator-() const
    { return CuPoint(-x, -y); }
inline CuPoint CuPoint::operator+(POINT point) const
    { return CuPoint(x + point.x, y + point.y); }
inline CuSize CuPoint::operator-(POINT point) const
    { return CuSize(x - point.x, y - point.y); }
inline CuRect CuPoint::operator+(const RECT* lpRect) const
    { return CuRect(lpRect) + *this; }
inline CuRect CuPoint::operator-(const RECT* lpRect) const
    { return CuRect(lpRect) - *this; }

CuKeyNameTextEx - retrieves a string that represents the name of a composite key

2010-01-01T00:11:00.000-08:00

// retrieves a string that represents the name of a composite key

CuKeyStatus KeyStatus;
....

CuKeyNameTextEx KeyNameTextEx(KeyStatus);
wstring strKeyText = KeyNameTextEx;
// Assert( strKeyText == TEXT("Alt+Ctrl+Shift+D"));
// Assert( strKeyText == TEXT("Alt+Ctrl+D"));
// Assert( strKeyText == TEXT("Ctrl+Shift+D"));


// CuKeyNameTextEx.h

class CuKeyNameTextEx
{
    wstring m_strKeyText;

public:
    CuKeyNameTextEx(void);
    CuKeyNameTextEx(CuKeyStatus &KeyStatus);
    ~CuKeyNameTextEx(void);

    void SetKeyStatus(CuKeyStatus &KeyStatus);
    
    operator wstring() const
    {
        return m_strKeyText;
    };
    BOOL IsMustAdd(bool l, bool r);
private:
    wstring ProcessFunctionKey(CuKeyStatus &KeyStatus);
};




// CuKeyNameTextEx.cpp

CuKeyNameTextEx::CuKeyNameTextEx(void)
{
}

CuKeyNameTextEx::~CuKeyNameTextEx(void)
{
}

CuKeyNameTextEx::CuKeyNameTextEx(CuKeyStatus &KeyStatus)
{
    SetKeyStatus(KeyStatus);
}


void CuKeyNameTextEx::SetKeyStatus(CuKeyStatus &KeyStatus)
{

    if( !KeyStatus.m_dwScanCode )
        return;

    wstring strResult;

    strResult = ProcessFunctionKey(KeyStatus);
    
    CuKeyNameText KeyName(KeyStatus.m_dwScanCode);
    wstring strKeyText = KeyName;

    wstring strAdd = TEXT("+");
    if( !strKeyText.empty() && !strResult.empty() )
        strResult += strAdd;
    
    strResult += strKeyText;

    m_strKeyText = strResult;

}


wstring CuKeyNameTextEx::ProcessFunctionKey(CuKeyStatus &KeyStatus)
{

    wstring strResult;

    wstring strAlt = TEXT("Alt");
    wstring strCtrl = TEXT("Ctrl");
    wstring strShift = TEXT("Shift");
    wstring strAdd = TEXT("+");


    if( KeyStatus.m_bAlt )
        strResult += strAlt;

    if( KeyStatus.m_bAlt && KeyStatus.m_bCtrl )
        strResult += strAdd;

    if( KeyStatus.m_bCtrl )
        strResult += strCtrl;

    if( KeyStatus.m_bShift && (KeyStatus.m_bAlt || KeyStatus.m_bCtrl) )
        strResult += strAdd;

    if( KeyStatus.m_bShift )
        strResult += strShift;

    return strResult;
}

CuSocket - create an endpoint for communication

2009-12-30T16:41:00.000-08:00

// create an endpoint for communication

CuSocket ClientSocket;
ClientSocket.Socket();
ClientSocket.Connect(lpszHostAddress, nHostPort);


// CuSocket.h


class CuSocket
{
private:
    SOCKET m_hSocket;
public:
    CuSocket(void);
public:
    ~CuSocket(void);

    SOCKET Socket(int nSocketType = SOCK_STREAM);
    int Close(void);

    //enum { SD_SEND = 0, SD_RECEIVE = 1,  SD_BOTH = 2};
    int ShutDown(int nHow = SD_BOTH);

    int Bind(UINT nSocketPort);
    int Listen( int nConnectionBacklog = 5 );
    SOCKET Accept( SOCKADDR *lpSockAddr, int *lpAddrLen );

    int Connect( LPCSTR lpszHostAddress, UINT nHostPort);

    int Receive(void *lpBuf, int nBufLen, int nFlags);
    int Send(const void *lpBuf, int nBufLen, int nFlags);

    BOOL Attach(SOCKET hSocket);
    operator SOCKET() const;
    CuSocket &operator =(CuSocket &socket);

};




// CuSocket.cpp


CuSocket::CuSocket(void)
:m_hSocket(NULL)
{
}

CuSocket::~CuSocket(void)
{
    if( m_hSocket != NULL )
    {
        Close();
    }
}

SOCKET CuSocket::Socket(int nSocketType /* = SOCK_STREAM */ )
{
    this->Close();
    m_hSocket = socket(AF_INET, nSocketType, IPPROTO_TCP);
    return m_hSocket;
}

BOOL CuSocket::Attach(SOCKET hSocket)
{
    this->Close();
    m_hSocket = hSocket;
    return (m_hSocket != NULL);
}

int CuSocket::Close(void)
{
    int error = 0;
    if( m_hSocket != NULL )
    {
        this->ShutDown();
        error = closesocket(m_hSocket);
        m_hSocket = NULL;
    }
    return error;
}

int CuSocket::Bind(UINT nSocketPort)
{
    SOCKADDR_IN SockAddr;
    SockAddr.sin_family = AF_INET;
    SockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    SockAddr.sin_port = htons(nSocketPort);

    int error = bind( m_hSocket, (PSOCKADDR)&SockAddr, sizeof(SockAddr) );
    return error;
}

int CuSocket::ShutDown(int nHow /* = SD_BOTH */ )
{
    int error = shutdown( m_hSocket, nHow );
    return error;
}

int CuSocket::Listen( int nConnectionBacklog /* = 5 */ )
{
    int error = listen(m_hSocket, nConnectionBacklog);
    return error;
}

SOCKET CuSocket::Accept( SOCKADDR *lpSockAddr, int *lpAddrLen )
{
    SOCKET hSocket = NULL;
    hSocket = accept( m_hSocket, lpSockAddr, lpAddrLen );
    return hSocket;
}

int CuSocket::Connect( LPCSTR lpszHostAddress, UINT nHostPort)
{
    SOCKADDR_IN ServerAddr;
    ServerAddr.sin_family = AF_INET;
    ServerAddr.sin_port = htons(nHostPort);
    ServerAddr.sin_addr.s_addr = inet_addr( lpszHostAddress );

    int error = connect(m_hSocket, (PSOCKADDR)&ServerAddr, sizeof(ServerAddr));
    return error;
}

CuSocket::operator SOCKET() const
{
    return m_hSocket;
}

CuSocket& CuSocket::operator =(CuSocket &socket)
{
    m_hSocket = socket.m_hSocket;
    return *this;
}

int CuSocket::Receive(void *lpBuf, int nBufLen, int nFlags)
{
    return recv( m_hSocket, static_cast<char *>(lpBuf), nBufLen, nFlags );
}

int CuSocket::Send(const void *lpBuf, int nBufLen, int nFlags)
{
    return send( m_hSocket, static_cast<const char*>(lpBuf), nBufLen, nFlags );
}

CuKeyNameText - retrieves a string that represents the name of a key

2009-12-30T00:12:00.000-08:00

// retrieves a string that represents the name of a key

CuKeyNameText KeyNameBySet;
KeyNameBySet.SetScanCode(dwScanCode);
wstring strKeyTextBySet = KeyNameBySet;

CuKeyNameText KeyName(dwScanCode);
wstring strKeyText = KeyName;


// CuKeyNameText.h

class CuKeyNameText
{
    wstring m_strKeyText;
public:
    CuKeyNameText(){};
    CuKeyNameText(DWORD dwScanCode);
    ~CuKeyNameText(){};

    void SetScanCode(DWORD dwScanCode);
    operator wstring() const;
};



// CuKeyNameText.cpp

CuKeyNameText::CuKeyNameText(DWORD dwScanCode)
{
    SetScanCode(dwScanCode);
}

void CuKeyNameText::SetScanCode(DWORD dwScanCode)
{
    LONG lKeyParam = ( dwScanCode << 16 );
    TCHAR szKeyName[16] = L"";
    ::GetKeyNameText(lKeyParam, szKeyName, sizeof(szKeyName));
    m_strKeyText = szKeyName;
}

CuKeyNameText::operator wstring() const
{
    return m_strKeyText;
}

CuDrawText - draws formatted text in the specified rectangle.

2009-12-29T00:09:00.000-08:00

//  draws formatted text in the specified rectangle.

CuDrawText textTest;

...

CuRect rt;
GetClientRect(hWnd, &rt);
textTest.SetRect(&rt);

...

textTest.SetText(TEXT("Hi") );

...

CuPaintDC dc(hWnd);
textTest.OnDraw(dc);


// CuDrawText.h

class CuDrawText
{
    CuRect m_rt;
    wstring m_strText;
    UINT m_uFormat;

public:
    CuDrawText(void);
    ~CuDrawText(void);

    void SetRect(  int xLeft,  int yTop,  int xRight,  int yBottom);
    void SetRect( RECT *rt );
    void SetText(LPCTSTR lpszString);
    void SetFormat(UINT uFormat);

    int OnDraw(HDC hdc);
};




// CuDrawText.cpp


CuDrawText::CuDrawText(void)
:m_uFormat(DT_LEFT)
{
}

CuDrawText::~CuDrawText(void)
{
}

void CuDrawText::SetRect(  int xLeft,  int yTop,  int xRight,  int yBottom)
{
    m_rt.SetRect(xLeft, yTop, xRight, yBottom);
}

void CuDrawText::SetRect( RECT *rt )
{
    m_rt = *rt;
}

void CuDrawText::SetText(LPCTSTR lpszString)
{
    m_strText = lpszString;
}

void CuDrawText::SetFormat(UINT uFormat)
{
    m_uFormat = uFormat;
}

int CuDrawText::OnDraw(HDC hdc)
{
    return ::DrawText(hdc, m_strText.c_str(), m_strText.size(), &m_rt, m_uFormat);
}

CuPort - Opens I/O device.

2009-12-28T00:47:00.000-08:00

// Opens I/O device.
class CuDevice : public CuPort
{
public:
    CuDevice();
    virtual ~CuDevice();
    virtual void OnRead(BYTE *pByte, int nSize);

};


CuDevice g_device;
DCB g_dcb;

g_device.Open(L"COM2:");
g_device.SetupComm(1024 * 1024 * 2, 2 * 1024);
g_device.GetCommState(&g_dcb);
....
g_device.SetCommState (&g_dcb);

COMMTIMEOUTS CommTimeouts;
g_device.GetCommTimeouts ( &CommTimeouts);
....
g_device.SetCommTimeouts ( &CommTimeouts);
g_device.StardReadThread();


// CuPort.h

class CuPort  
{
    CuWinThread *m_pReadThread;
    
    HANDLE m_hFile;

    int m_nReadBufferSize;
    BYTE *m_pReadBuffer;

public:

    BOOL ClearCommError(LPDWORD lpErrors, LPCOMSTAT lpStat);
    BOOL SetCommTimeouts(LPCOMMTIMEOUTS lpCommTimeouts);
    BOOL GetCommTimeouts(LPCOMMTIMEOUTS lpCommTimeouts);
    BOOL GetCommState(LPDCB lpDCB);
    BOOL SetupComm(DWORD dwInQueue, DWORD dwOutQueue);
    BOOL SetCommState(LPDCB lpDCB);
    BOOL Open(LPCTSTR szComPort);
    BOOL Close(void);

    CuPort();
    virtual ~CuPort();
    virtual void OnRead(BYTE *pByte, int nSize){};
    virtual void OnWrite(BYTE *pByte, int nSize);

    BOOL StardReadThread();
    static DWORD ProcessReadThread(LPVOID lpVoid);

private:
    void ResizeReadBuffer();

};



// CuPort.cpp

CuPort::CuPort():
m_hFile(INVALID_HANDLE_VALUE)
,m_pReadThread(NULL)
,m_nReadBufferSize(1024)
,m_pReadBuffer(NULL)
{
    ResizeReadBuffer();
}

CuPort::~CuPort()
{
    delete [] m_pReadBuffer;
    Close();
}

BOOL CuPort::Close()
{

    BOOL bResult = FALSE;
    if( m_hFile != INVALID_HANDLE_VALUE )
        bResult = ::CloseHandle (m_hFile);
    m_hFile = INVALID_HANDLE_VALUE;

    if( m_pReadThread )
    {
        m_pReadThread->SuspendThread();
        m_pReadThread->Delete();
    }
    m_pReadThread = NULL;

    return bResult;

}

BOOL CuPort::Open(LPCTSTR szComPort)
{

    Close();

    m_hFile = ::CreateFile(szComPort, GENERIC_READ | GENERIC_WRITE,0, NULL, OPEN_EXISTING, 0, NULL);
    
    return m_hFile == INVALID_HANDLE_VALUE ? FALSE : TRUE;
}

BOOL CuPort::SetCommState(LPDCB lpDCB)
{
    return ::SetCommState( m_hFile, lpDCB); 
}

BOOL CuPort::SetupComm(DWORD dwInQueue, DWORD dwOutQueue)
{
    return ::SetupComm( m_hFile, dwInQueue, dwOutQueue); 
}

BOOL CuPort::GetCommState(LPDCB lpDCB)
{
    return ::GetCommState (m_hFile, lpDCB);
}

BOOL CuPort::GetCommTimeouts(LPCOMMTIMEOUTS lpCommTimeouts)
{
    return ::GetCommTimeouts(m_hFile, lpCommTimeouts);
}

BOOL CuPort::SetCommTimeouts(LPCOMMTIMEOUTS lpCommTimeouts)
{
    return ::SetCommTimeouts(m_hFile, lpCommTimeouts);
}

BOOL CuPort::ClearCommError(LPDWORD lpErrors, LPCOMSTAT lpStat)
{
    return ::ClearCommError(m_hFile, lpErrors, lpStat );
}

BOOL CuPort::StardReadThread()
{
    m_pReadThread = _BeginThread((_THREADPROC)CuPort::ProcessReadThread, (LPVOID)this);
    return m_pReadThread == NULL ? FALSE : TRUE;
}

void CuPort::OnWrite(BYTE *pByte, int nSize)
{

    if( m_hFile == INVALID_HANDLE_VALUE )
        return;

    DWORD dBytes = 0;

    BYTE *pByteIndex = pByte;

    while( nSize )
    {
        ::WriteFile(m_hFile, pByteIndex, nSize, &dBytes, 0);
        Sleep(1);
        pByteIndex += dBytes;
        nSize -= dBytes;
    }

}

DWORD CuPort::ProcessReadThread(LPVOID lpVoid)
{
    CuPort *pPort = static_cast<CuPort*>(lpVoid);

    static DWORD Errors;
    static COMSTAT ComStat;//COMSTAT;
    static DWORD dBytes = 0;

    while(1)
    {
        do
        {
            Sleep(1);
            ::ReadFile(pPort->m_hFile, pPort->m_pReadBuffer, pPort->m_nReadBufferSize, &dBytes , 0);
        }while( !dBytes );

        // 如果讀的跟預備的BUFFER 一樣大
        // 就把BUFFER 再加大一倍

        pPort->OnRead(pPort->m_pReadBuffer, dBytes );

        if( dBytes ==  pPort->m_nReadBufferSize )
            pPort->ResizeReadBuffer();
    }

    return 0;
}


void CuPort::ResizeReadBuffer()
{
    delete [] m_pReadBuffer;
    m_nReadBufferSize *= 2;
    m_pReadBuffer = new BYTE[m_nReadBufferSize];
}

CuRect - Similar to a Windows RECT structure.

2009-12-27T01:32:00.000-08:00

// Similar to a Windows RECT structure. 

CuRect rt;
GetClientRect(hWnd, &rt);

// CuRect.h

class CuRect : public tagRECT
{
    // Constructors
public:
    // uninitialized rectangle
    CuRect() throw();
    // from left, top, right, and bottom
    CuRect(int l, int t, int r, int b) throw();
    // copy constructor
    CuRect(const RECT& srcRect) throw();
    // from a pointer to another rect
    CuRect(LPCRECT lpSrcRect) throw();
    // from a point and size
    CuRect(POINT point, SIZE size) throw();
    // from two points
    CuRect(POINT topLeft, POINT bottomRight) throw();

    // Attributes (in addition to RECT members)

    // retrieves the width
    int Width() const throw();
    // returns the height
    int Height() const throw();
    // returns the size
    CuSize Size() const throw();
    // reference to the top-left point
    CuPoint& TopLeft() throw();
    // reference to the bottom-right point
    CuPoint& BottomRight() throw();
    // const reference to the top-left point
    const CuPoint& TopLeft() const throw();
    // const reference to the bottom-right point
    const CuPoint& BottomRight() const throw();
    // the geometric center point of the rectangle
    CuPoint CenterPoint() const throw();
    // swap the left and right
    void SwapLeftRight() throw();
    static void WINAPI SwapLeftRight(LPRECT lpRect) throw();

    // convert between CuRect and LPRECT/LPCRECT (no need for &)
    operator LPRECT() throw();
    operator LPCRECT() const throw();

    // returns TRUE if rectangle has no area
    BOOL IsRectEmpty() const throw();
    // returns TRUE if rectangle is at (0,0) and has no area
    BOOL IsRectNull() const throw();
    // returns TRUE if point is within rectangle
    BOOL PtInRect(POINT point) const throw();

    // Operations

    // set rectangle from left, top, right, and bottom
    void SetRect(int x1, int y1, int x2, int y2) throw();
    void SetRect(POINT topLeft, POINT bottomRight) throw();
    // empty the rectangle
    void SetRectEmpty() throw();
    // copy from another rectangle
    void CopyRect(LPCRECT lpSrcRect) throw();
    // TRUE if exactly the same as another rectangle
    BOOL EqualRect(LPCRECT lpRect) const throw();

    // Inflate rectangle's width and height by
    // x units to the left and right ends of the rectangle
    // and y units to the top and bottom.
    void InflateRect(int x, int y) throw();
    // Inflate rectangle's width and height by
    // size.cx units to the left and right ends of the rectangle
    // and size.cy units to the top and bottom.
    void InflateRect(SIZE size) throw();
    // Inflate rectangle's width and height by moving individual sides.
    // Left side is moved to the left, right side is moved to the right,
    // top is moved up and bottom is moved down.
    void InflateRect(LPCRECT lpRect) throw();
    void InflateRect(int l, int t, int r, int b) throw();

    // deflate the rectangle's width and height without
    // moving its top or left
    void DeflateRect(int x, int y) throw();
    void DeflateRect(SIZE size) throw();
    void DeflateRect(LPCRECT lpRect) throw();
    void DeflateRect(int l, int t, int r, int b) throw();

    // translate the rectangle by moving its top and left
    void OffsetRect(int x, int y) throw();
    void OffsetRect(SIZE size) throw();
    void OffsetRect(POINT point) throw();
    void NormalizeRect() throw();

    // absolute position of rectangle
    void MoveToY(int y) throw();
    void MoveToX(int x) throw();
    void MoveToXY(int x, int y) throw();
    void MoveToXY(POINT point) throw();

    // set this rectangle to intersection of two others
    BOOL IntersectRect(LPCRECT lpRect1, LPCRECT lpRect2) throw();

    // set this rectangle to bounding union of two others
    BOOL UnionRect(LPCRECT lpRect1, LPCRECT lpRect2) throw();

    // set this rectangle to minimum of two others
    BOOL SubtractRect(LPCRECT lpRectSrc1, LPCRECT lpRectSrc2) throw();

    // Additional Operations
    void operator=(const RECT& srcRect) throw();
    BOOL operator==(const RECT& rect) const throw();
    BOOL operator!=(const RECT& rect) const throw();
    void operator+=(POINT point) throw();
    void operator+=(SIZE size) throw();
    void operator+=(LPCRECT lpRect) throw();
    void operator-=(POINT point) throw();
    void operator-=(SIZE size) throw();
    void operator-=(LPCRECT lpRect) throw();
    void operator&=(const RECT& rect) throw();
    void operator|=(const RECT& rect) throw();

    // Operators returning CuRect values
    CuRect operator+(POINT point) const throw();
    CuRect operator-(POINT point) const throw();
    CuRect operator+(LPCRECT lpRect) const throw();
    CuRect operator+(SIZE size) const throw();
    CuRect operator-(SIZE size) const throw();
    CuRect operator-(LPCRECT lpRect) const throw();
    CuRect operator&(const RECT& rect2) const throw();
    CuRect operator|(const RECT& rect2) const throw();
    //  CuRect MulDiv(int nMultiplier, int nDivisor) const throw();
};


inline CuRect::CuRect()
{ /* random filled */ }
inline CuRect::CuRect(int l, int t, int r, int b)
{ left = l; top = t; right = r; bottom = b; }
inline CuRect::CuRect(const RECT& srcRect)
{ ::CopyRect(this, &srcRect); }
inline CuRect::CuRect(LPCRECT lpSrcRect)
{ ::CopyRect(this, lpSrcRect); }
inline CuRect::CuRect(POINT point, SIZE size)
{ right = (left = point.x) + size.cx; bottom = (top = point.y) + size.cy; }
inline CuRect::CuRect(POINT topLeft, POINT bottomRight)
{ left = topLeft.x; top = topLeft.y;
right = bottomRight.x; bottom = bottomRight.y; }
inline int CuRect::Width() const
{ return right - left; }
inline int CuRect::Height() const
{ return bottom - top; }
inline CuSize CuRect::Size() const
{ return CuSize(right - left, bottom - top); }
inline CuPoint& CuRect::TopLeft()
{ return *((CuPoint*)this); }
inline CuPoint& CuRect::BottomRight()
{ return *((CuPoint*)this+1); }
inline const CuPoint& CuRect::TopLeft() const
{ return *((CuPoint*)this); }
inline const CuPoint& CuRect::BottomRight() const
{ return *((CuPoint*)this+1); }
inline CuPoint CuRect::CenterPoint() const
{ return CuPoint((left+right)/2, (top+bottom)/2); }
inline void CuRect::SwapLeftRight()
{ SwapLeftRight(LPRECT(this)); }
inline void WINAPI CuRect::SwapLeftRight(LPRECT lpRect)
{ LONG temp = lpRect->left; lpRect->left = lpRect->right; lpRect->right = temp; }
inline CuRect::operator LPRECT()
{ return this; }
inline CuRect::operator LPCRECT() const
{ return this; }
inline BOOL CuRect::IsRectEmpty() const
{ return ::IsRectEmpty(this); }
inline BOOL CuRect::IsRectNull() const
{ return (left == 0 && right == 0 && top == 0 && bottom == 0); }
inline BOOL CuRect::PtInRect(POINT point) const
{ return ::PtInRect(this, point); }
inline void CuRect::SetRect(int x1, int y1, int x2, int y2)
{ ::SetRect(this, x1, y1, x2, y2); }
inline void CuRect::SetRect(POINT topLeft, POINT bottomRight)
{ ::SetRect(this, topLeft.x, topLeft.y, bottomRight.x, bottomRight.y); }
inline void CuRect::SetRectEmpty()
{ ::SetRectEmpty(this); }
inline void CuRect::CopyRect(LPCRECT lpSrcRect)
{ ::CopyRect(this, lpSrcRect); }
inline BOOL CuRect::EqualRect(LPCRECT lpRect) const
{ return ::EqualRect(this, lpRect); }
inline void CuRect::InflateRect(int x, int y)
{ ::InflateRect(this, x, y); }
inline void CuRect::InflateRect(SIZE size)
{ ::InflateRect(this, size.cx, size.cy); }
inline void CuRect::DeflateRect(int x, int y)
{ ::InflateRect(this, -x, -y); }
inline void CuRect::DeflateRect(SIZE size)
{ ::InflateRect(this, -size.cx, -size.cy); }
inline void CuRect::OffsetRect(int x, int y)
{ ::OffsetRect(this, x, y); }
inline void CuRect::OffsetRect(POINT point)
{ ::OffsetRect(this, point.x, point.y); }
inline void CuRect::OffsetRect(SIZE size)
{ ::OffsetRect(this, size.cx, size.cy); }
inline void CuRect::MoveToY(int y)
{ bottom = Height() + y; top = y; }
inline void CuRect::MoveToX(int x)
{ right = Width() + x; left = x; }
inline void CuRect::MoveToXY(int x, int y)
{ MoveToX(x); MoveToY(y); }
inline void CuRect::MoveToXY(POINT pt)
{ MoveToX(pt.x); MoveToY(pt.y); }
inline BOOL CuRect::IntersectRect(LPCRECT lpRect1, LPCRECT lpRect2)
{ return ::IntersectRect(this, lpRect1, lpRect2);}
inline BOOL CuRect::UnionRect(LPCRECT lpRect1, LPCRECT lpRect2)
{ return ::UnionRect(this, lpRect1, lpRect2); }
inline void CuRect::operator=(const RECT& srcRect)
{ ::CopyRect(this, &srcRect); }
inline BOOL CuRect::operator==(const RECT& rect) const
{ return ::EqualRect(this, &rect); }
inline BOOL CuRect::operator!=(const RECT& rect) const
{ return !::EqualRect(this, &rect); }
inline void CuRect::operator+=(POINT point)
{ ::OffsetRect(this, point.x, point.y); }
inline void CuRect::operator+=(SIZE size)
{ ::OffsetRect(this, size.cx, size.cy); }
inline void CuRect::operator+=(LPCRECT lpRect)
{ InflateRect(lpRect); }
inline void CuRect::operator-=(POINT point)
{ ::OffsetRect(this, -point.x, -point.y); }
inline void CuRect::operator-=(SIZE size)
{ ::OffsetRect(this, -size.cx, -size.cy); }
inline void CuRect::operator-=(LPCRECT lpRect)
{ DeflateRect(lpRect); }
inline void CuRect::operator&=(const RECT& rect)
{ ::IntersectRect(this, this, &rect); }
inline void CuRect::operator|=(const RECT& rect)
{ ::UnionRect(this, this, &rect); }
inline CuRect CuRect::operator+(POINT pt) const
{ CuRect rect(*this); ::OffsetRect(&rect, pt.x, pt.y); return rect; }
inline CuRect CuRect::operator-(POINT pt) const
{ CuRect rect(*this); ::OffsetRect(&rect, -pt.x, -pt.y); return rect; }
inline CuRect CuRect::operator+(SIZE size) const
{ CuRect rect(*this); ::OffsetRect(&rect, size.cx, size.cy); return rect; }
inline CuRect CuRect::operator-(SIZE size) const
{ CuRect rect(*this); ::OffsetRect(&rect, -size.cx, -size.cy); return rect; }
inline CuRect CuRect::operator+(LPCRECT lpRect) const
{ CuRect rect(this); rect.InflateRect(lpRect); return rect; }
inline CuRect CuRect::operator-(LPCRECT lpRect) const
{ CuRect rect(this); rect.DeflateRect(lpRect); return rect; }
inline CuRect CuRect::operator&(const RECT& rect2) const
{ CuRect rect; ::IntersectRect(&rect, this, &rect2);
return rect; }
inline CuRect CuRect::operator|(const RECT& rect2) const
{ CuRect rect; ::UnionRect(&rect, this, &rect2);
return rect; }
inline BOOL CuRect::SubtractRect(LPCRECT lpRectSrc1, LPCRECT lpRectSrc2)
{ return ::SubtractRect(this, lpRectSrc1, lpRectSrc2); }

inline void CuRect::NormalizeRect()
{
    int nTemp;
    if (left > right)
    {
        nTemp = left;
        left = right;
        right = nTemp;
    }
    if (top > bottom)
    {
        nTemp = top;
        top = bottom;
        bottom = nTemp;
    }
}

inline void CuRect::InflateRect(LPCRECT lpRect)
{
    left -= lpRect->left;       top -= lpRect->top;
    right += lpRect->right;     bottom += lpRect->bottom;
}

inline void CuRect::InflateRect(int l, int t, int r, int b)
{
    left -= l;          top -= t;
    right += r;         bottom += b;
}

inline void CuRect::DeflateRect(LPCRECT lpRect)
{
    left += lpRect->left;   top += lpRect->top;
    right -= lpRect->right; bottom -= lpRect->bottom;
}

inline void CuRect::DeflateRect(int l, int t, int r, int b)
{
    left += l;      top += t;
    right -= r;     bottom -= b;
}

CuHook - HookDLL.dll Adapter

2009-12-26T00:35:00.000-08:00

// HookDLL.dll Adapter

LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam);

CuHook Hook;
Hook.Init(HookProc, WH_KEYBOARD_LL);



// CuHook.h

class CuHook
{
    typedef void (* LPFN_INITHOOK)(HOOKPROC lpfnCallBackHookProc, int idHook);
    LPFN_INITHOOK m_lpfnInitHook;

    typedef void (* LPFN_UNHOOK)(void);
    LPFN_UNHOOK m_lpfnUnHook;

    CuDllManager m_DllManager;

public:
    CuHook(void);
    ~CuHook(void);

    void Init(HOOKPROC lpfnCallBackHookProc, int idHook);
};



// CuHook.cpp

CuHook::CuHook(void)
:m_lpfnInitHook(NULL),
m_lpfnUnHook(NULL)
{
}

CuHook::~CuHook(void)
{
    if( m_lpfnUnHook != NULL )
        m_lpfnUnHook();
}


void CuHook::Init(HOOKPROC lpfnCallBackHookProc, int idHook)
{
    BOOL bLoadDll = m_DllManager.LoadLibrary(L"HookDll.dll");
    Assert( bLoadDll != NULL, TEXT("Don't Find HookDll.dll") );

    m_lpfnInitHook = (LPFN_INITHOOK)m_DllManager.GetProcAddress("InitHook");
    Assert( m_lpfnInitHook != NULL, TEXT("Don't Find function InitHook") );

    m_lpfnUnHook = (LPFN_UNHOOK)m_DllManager.GetProcAddress("UnHook");
    Assert( m_lpfnInitHook != NULL, TEXT("Don't Find function UnHook") );

    if( m_lpfnInitHook != NULL )
        m_lpfnInitHook(lpfnCallBackHookProc, idHook);
}

CuPaintDC - A device-context class.

2009-12-25T00:06:00.000-08:00

// A device-context class. 
// A CuPaintDC object can only be used when responding to a WM_PAINT message

CuPaintDC dc(hWnd);


// CuPaintDC.h

class CuPaintDC
{
    HWND m_hWnd;
    HDC m_hDC;
    PAINTSTRUCT m_PS;
public:
    CuPaintDC(HWND hWnd);
public:
    ~CuPaintDC(void);
    operator HDC() const;
};


// CuPaintDC.cpp

CuPaintDC::CuPaintDC(HWND hWnd)
{
    m_hWnd = hWnd;
    m_hDC = BeginPaint(m_hWnd, &m_PS);
}

CuPaintDC::~CuPaintDC(void)
{
    EndPaint(m_hWnd, &m_PS);
}

CuPaintDC::operator HDC() const
{
    return m_hDC;
}

HookDll - installs an application-defined hook procedure into a hook chain.

2009-12-23T22:22:00.000-08:00

// installs an application-defined hook procedure into a hook chain.

LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam);

typedef void (* LPFN_INITHOOK)(HOOKPROC lpfnCallBackHookProc, int idHook);
LPFN_INITHOOK lpfnInitHook;

typedef void (* LPFN_UNHOOK)(void);
LPFN_UNHOOK lpfnUnHook;

CuDllManager DllManager;
BOOL bLoadDll = DllManager.LoadLibrary(L"HookDll.dll");
lpfnInitHook = (LPFN_INITHOOK)DllManager.GetProcAddress("InitHook");
lpfnUnHook = (LPFN_UNHOOK)DllManager.GetProcAddress("UnHook");
lpfnInitHook(HookProc, WH_MOUSE_LL);

lpfnUnHook();

// HookDll.h

#ifdef HOOKDLL_EXPORTS
#define HOOKDLL_API __declspec(dllexport)
#else
#define HOOKDLL_API __declspec(dllimport)
#endif

#ifdef __cplusplus
extern "C" {
#endif //__cplusplus

    HOOKDLL_API void InitHook(HOOKPROC lpfnCallBackHookProc, int idHook );
    HOOKDLL_API void UnHook(void);

#ifdef __cplusplus
} // extern "C"
#endif //__cplusplus

// HookDll.cpp

#pragma comment(linker,"/SECTION:.MYSEC,RWS")   

#pragma data_seg(".MYSEC") 
HOOKPROC g_lpfnCallBackHookProc = NULL;
HHOOK ghHook = NULL;
#pragma data_seg()  

HMODULE ghModule;

#ifdef _MANAGED
#pragma managed(push, off)
#endif

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
    case DLL_THREAD_ATTACH:
        ghModule = hModule;
        break;
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        UnHook();
        ghHook = NULL;
        break;
    }
    return TRUE;
}

#ifdef _MANAGED
#pragma managed(pop)
#endif

LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam)
{

    if ( nCode < 0 )
        return ::CallNextHookEx(ghHook, nCode, wParam, lParam);

    if( nCode == HC_ACTION )
    {
        if( g_lpfnCallBackHookProc )
            g_lpfnCallBackHookProc(nCode, wParam, lParam);
    }

    return ::CallNextHookEx(ghHook, nCode, wParam, lParam);

}


HOOKDLL_API void InitHook(HOOKPROC lpfnCallBackHookProc, int idHook )
{
    g_lpfnCallBackHookProc = lpfnCallBackHookProc;
    ghHook = (HHOOK)::SetWindowsHookEx(idHook, HookProc, ghModule ,0);
}


HOOKDLL_API void UnHook(void)
{
    ::UnhookWindowsHookEx(ghHook);
}

CuDllManager - Retrieves the address of an exported function or variable from the specified dynamic-link library (DLL).

2009-12-23T00:12:00.001-08:00

// Retrieves the address of an exported function or variable from the specified dynamic-link library (DLL).


typedef void (* LPFN_MYFUNCTION)(void);
LPFN_MYFUNCTION lpfnMyFunction;

CuDllManager DllManager;

BOOL bLoadDll = DllManager.LoadLibrary(L"dllfile.dll");
lpfnMyFunction = (LPFN_MYFUNCTION)DllManager.GetProcAddress("MyFunction");

// CuDllManager.h

class CuDllManager
{
private:
    HINSTANCE m_hinstDll;

public:

    virtual FARPROC GetProcAddress(LPCSTR lpProcName);

    virtual void FreeLibrary();
    virtual BOOL LoadLibrary(LPCTSTR szLibrary);

    CuDllManager();
    virtual ~CuDllManager();

};




// CuDllManager.cpp

CuDllManager::CuDllManager()
{
    m_hinstDll = NULL;
}

CuDllManager::~CuDllManager()
{
    FreeLibrary();
}

BOOL CuDllManager::LoadLibrary(LPCTSTR szLibrary)
{
    FreeLibrary();
    m_hinstDll = ::LoadLibrary(szLibrary);
    return (BOOL)m_hinstDll != NULL;
}

void CuDllManager::FreeLibrary()
{
    if( m_hinstDll != NULL )
    {
        ::FreeLibrary(m_hinstDll);
        m_hinstDll = NULL;
    }
}

FARPROC CuDllManager::GetProcAddress(LPCSTR lpProcName)
{
    return ::GetProcAddress(m_hinstDll, lpProcName);
}

CuEventObject - Creates or opens a named or unnamed event object.

2009-12-21T20:40:00.000-08:00

// Creates or opens a named or unnamed event object.




// CuEventObject.h


class CuEventObject
{
    HANDLE m_hHandle;

public:
    DWORD WaitForSingleObject(DWORD dwMilliseconds = INFINITE);

    BOOL SetEvent();
    BOOL ResetEvent();
    BOOL CreateEvent(TCHAR *szName, BOOL bManualReset = FALSE, BOOL bInitialState = FALSE);
    BOOL CloseHandle();
    operator HANDLE() const;

    CuEventObject();
    CuEventObject(TCHAR *szName);

    // 自動呼叫　CloseHandle();
    virtual ~CuEventObject();
};



// CuEventObject.cpp

CuEventObject::CuEventObject(TCHAR *szName)
:m_hHandle(NULL)
{
    CreateEvent(szName);
}

CuEventObject::CuEventObject()
:m_hHandle(NULL)
{

}

CuEventObject::~CuEventObject()
{
    CloseHandle();
}

CuEventObject::operator HANDLE() const
{
    return m_hHandle;
}

BOOL CuEventObject::CloseHandle()
{
    BOOL bResult = TRUE;
    if(m_hHandle)
        bResult = ::CloseHandle(m_hHandle);
    m_hHandle = NULL;

    return bResult;
}

BOOL CuEventObject::CreateEvent(TCHAR *szName, BOOL bManualReset /*= FALSE*/, BOOL bInitialState /*= FALSE*/)
{

    CloseHandle();
    m_hHandle = ::CreateEvent(NULL, bManualReset, bInitialState, szName);
    return (m_hHandle == NULL);

}
BOOL CuEventObject::ResetEvent()
{
    return ::ResetEvent(m_hHandle);
}

BOOL CuEventObject::SetEvent()
{
    return  ::SetEvent(m_hHandle);
}

DWORD CuEventObject::WaitForSingleObject(DWORD dwMilliseconds /*  = INFINITE */)
{
    return  ::WaitForSingleObject(m_hHandle, dwMilliseconds);
}

CuWinThread - Represents a thread of execution within an application.

2009-12-21T00:26:00.000-08:00

// Represents a thread of execution within an application. 

// CuWinThread.h

typedef UINT (__cdecl  *_THREADPROC)(LPVOID);

// global helpers for threads
class CuWinThread;

CuWinThread* _BeginThread(_THREADPROC pfnThreadProc, LPVOID pParam,
    int nPriority = THREAD_PRIORITY_NORMAL, UINT nStackSize = 0,
    DWORD dwCreateFlags = 0, LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL);

class CuWinThread  
{
public:
    BOOL CreateThread(DWORD dwCreateFlags = 0, UINT nStackSize = 0, LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL);

    // only valid while running
    HANDLE m_hThread;       // this thread's HANDLE
    DWORD m_nThreadID;      // this thread's ID
    BOOL m_bAutoDelete;     // enables 'delete this' after thread termination

    LPVOID m_pThreadParams; // generic parameters passed to starting function
    _THREADPROC m_pfnThreadProc;

    CuWinThread();
    CuWinThread(_THREADPROC pfnThreadProc, LPVOID pParam);

// Operations
    DWORD SuspendThread();
    DWORD ResumeThread();
    BOOL SetThreadPriority(int nPriority);

// Implementation
    void CommonConstruct();
    virtual ~CuWinThread();

    // 'delete this' only if m_bAutoDelete == TRUE
    virtual void Delete();

};


inline DWORD CuWinThread::ResumeThread()
    { Assert(m_hThread != NULL, _T("CuWinThread::ResumeThread m_hThread != NULL") ); return ::ResumeThread(m_hThread); }
inline DWORD CuWinThread::SuspendThread()
    { Assert(m_hThread != NULL, _T("CuWinThread::SuspendThread m_hThread != NULL")) ; return ::SuspendThread(m_hThread); }
inline BOOL CuWinThread::SetThreadPriority(int nPriority)
    { Assert(m_hThread != NULL, _T("CuWinThread::SetThreadPriority m_hThread != NULL")); return ::SetThreadPriority(m_hThread, nPriority); }



// CuWinThread.cpp

struct _THREAD_STARTUP
{
    // following are "in" parameters to thread startup
    //_THREAD_STATE* pThreadState;    // thread state of parent thread
    CuWinThread* pThread;    // CWinThread for new thread
    DWORD dwCreateFlags;    // thread creation flags

    HANDLE hEvent;          // event triggered after success/non-success
    HANDLE hEvent2;         // event triggered after thread is resumed

    // strictly "out" -- set after hEvent is triggered
    BOOL bError;    // TRUE if error during startup
};

DWORD __cdecl _ThreadEntry(void* pParam)
{

    _THREAD_STARTUP* pStartup = (_THREAD_STARTUP*)pParam;
    Assert(pStartup != NULL, _T("_ThreadEntry::\npStartup != NULL"));
    Assert(pStartup->pThread != NULL, _T("_ThreadEntry::\npStartup->pThread != NULL"));
    Assert(pStartup->hEvent != NULL, _T("_ThreadEntry::\npStartup->hEvent != NULL"));
    Assert(!pStartup->bError, _T("_ThreadEntry::\n!pStartup->bError"));

    CuWinThread* pThread = pStartup->pThread;
    
    // pStartup is invlaid after the following
    // SetEvent (but hEvent2 is valid)
    HANDLE hEvent2 = pStartup->hEvent2;

    // allow the creating thread to return from CWinThread::CreateThread
    Verify(::SetEvent(pStartup->hEvent), _T(""));

    // wait for thread to be resumed
    Verify(::WaitForSingleObject(hEvent2, INFINITE) == WAIT_OBJECT_0, _T(""));
    ::CloseHandle(hEvent2);

    // first -- check for simple worker thread
    DWORD nResult = 0;
    if (pThread->m_pfnThreadProc != NULL)
    {
        nResult = (*pThread->m_pfnThreadProc)(pThread->m_pThreadParams);
    }

    pThread->Delete();

    // allow C-runtime to cleanup, and exit the thread
    ::ExitThread(nResult);
    return 0;

}


CuWinThread* _BeginThread(_THREADPROC pfnThreadProc, LPVOID pParam,
    int nPriority /* = THREAD_PRIORITY_NORMAL */, UINT nStackSize /* = 0 */,
    DWORD dwCreateFlags /* = 0 */, LPSECURITY_ATTRIBUTES lpSecurityAttrs /* = NULL*/ )
{

    Assert(pfnThreadProc != NULL, _T(""));

    CuWinThread* pThread = new CuWinThread(pfnThreadProc, pParam);
    Assert(pThread != NULL , _T("_BeginThread:: pThread == NULL"));

    if (!pThread->CreateThread(dwCreateFlags|CREATE_SUSPENDED, nStackSize,
        lpSecurityAttrs))
    {
        pThread->Delete();
        return NULL;
    }

    Verify(pThread->SetThreadPriority(nPriority) , _T(""));
    if (!(dwCreateFlags & CREATE_SUSPENDED))
        Verify(pThread->ResumeThread() != (DWORD)-1, _T(""));

    return pThread;

}

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CuWinThread::CuWinThread()
{

    m_pThreadParams = NULL; 
    m_pfnThreadProc = NULL;

    CommonConstruct();

}

CuWinThread::CuWinThread(_THREADPROC pfnThreadProc, LPVOID pParam)
{

    m_pThreadParams = pParam;
    m_pfnThreadProc = pfnThreadProc;

    CommonConstruct();

}

CuWinThread::~CuWinThread()
{

    // free thread object
    if (m_hThread != NULL)
        CloseHandle(m_hThread);

}



void CuWinThread::CommonConstruct()
{

    m_hThread = NULL;
    m_nThreadID = 0;
    m_bAutoDelete = TRUE;

}


void CuWinThread::Delete()
{
    // delete thread if it is auto-deleting
    if (m_bAutoDelete)
        delete this;
}

BOOL CuWinThread::CreateThread(DWORD dwCreateFlags, UINT nStackSize, LPSECURITY_ATTRIBUTES lpSecurityAttrs)
{

    Assert(m_hThread == NULL, _T("CreateThread::m_hThread == NULL"));  // already created?

    // setup startup structure for thread initialization
    _THREAD_STARTUP startup; 
    
    memset(&startup, 0, sizeof(startup));
    startup.pThread = this;
    startup.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
    startup.hEvent2 = ::CreateEvent(NULL, TRUE, FALSE, NULL);
    startup.dwCreateFlags = dwCreateFlags;
    if (startup.hEvent == NULL || startup.hEvent2 == NULL)
    {

        Assert(0, _T("Warning: CreateEvent failed in CWinThread::CreateThread.\n"));
        //TRACE(traceAppMsg, 0, "Warning: CreateEvent failed in CWinThread::CreateThread.\n");
        if (startup.hEvent != NULL)
            ::CloseHandle(startup.hEvent);
        if (startup.hEvent2 != NULL)
            ::CloseHandle(startup.hEvent2);
        return FALSE;
    }


    // create the thread (it may or may not start to run)
    m_hThread = ::CreateThread(lpSecurityAttrs, nStackSize,  //REVIEW
        (LPTHREAD_START_ROUTINE)&_ThreadEntry,  &startup, dwCreateFlags | CREATE_SUSPENDED, (PDWORD)&m_nThreadID);

    if (m_hThread == NULL)
        return FALSE;

    // start the thread just for MFC initialization
    Verify(ResumeThread() != (DWORD)-1, _T(""));
    Verify(::WaitForSingleObject(startup.hEvent, INFINITE) == WAIT_OBJECT_0, _T(""));
    ::CloseHandle(startup.hEvent);

    // if created suspended, suspend it until resume thread wakes it up
    if (dwCreateFlags & CREATE_SUSPENDED)
        Verify(::SuspendThread(m_hThread) != (DWORD)-1, _T(""));

    // if error during startup, shut things down
    if (startup.bError)
    {
        Verify(::WaitForSingleObject(m_hThread, INFINITE) == WAIT_OBJECT_0, _T(""));
        ::CloseHandle(m_hThread);
        m_hThread = NULL;
        ::CloseHandle(startup.hEvent2);
        return FALSE;
    }

    // allow thread to continue, once resumed (it may already be resumed)
    ::SetEvent(startup.hEvent2);

    return TRUE;
}

Filter of the Internet cache - CuUrlCacheFilter

2009-12-18T07:37:00.000-08:00

// Filter of the Internet cache

string GetCacheIconFile( string &strUrl )
{
    CuUrlCacheFilter UrlCacheFilter;
    return UrlCacheFilter.OnGetCacheFile(".ico", strUrl.c_str());
}

// CuUrlCacheFilter.h

class CuUrlCacheFilter
{
    CuUrlCacheEntry m_UrlCacheEntry;

public:
    CuUrlCacheFilter(void);
    ~CuUrlCacheFilter(void);

public:
    string OnGetCacheFile(LPCTSTR szFilter = TEXT(".jpg") , LPCTSTR szURL = TEXT("") ); 

private:
    BOOL IsFilter( LPCTSTR lpszSource, LPCTSTR lpszFilter );
    BOOL IsFilterLocalFile( INTERNET_CACHE_ENTRY_INFO * lpEntry, LPCTSTR szFilter );
    BOOL IsFilterURL(INTERNET_CACHE_ENTRY_INFO * lpEntry, LPCTSTR szURL);

};


// CuUrlCacheFilter.cpp

CuUrlCacheFilter::CuUrlCacheFilter(void)
{
    m_UrlCacheEntry.ProcessEnumCacheEntry();
}

CuUrlCacheFilter::~CuUrlCacheFilter(void)
{
}

string CuUrlCacheFilter::OnGetCacheFile(LPCTSTR szFilter , LPCTSTR szURL  )
{

    string strResult;
    INTERNET_CACHE_ENTRY_INFO* lpEntry = NULL;
    for( int i = 0 ; i < m_UrlCacheEntry.size() ; i++ )
    {
        lpEntry = m_UrlCacheEntry.at(i);
        if(  IsFilterLocalFile( lpEntry, szFilter) && IsFilterURL(lpEntry, szURL) )
        {
            strResult = lpEntry->lpszLocalFileName;
            break;
        }
    }

    return strResult;
}


BOOL CuUrlCacheFilter::IsFilter( LPCTSTR lpszSource, LPCTSTR lpszFilter )
{
    if( lpszSource == NULL )
        return FALSE;

    string strTempFile(lpszSource);
    size_t found = strTempFile.find(lpszFilter);

    return ( found != string::npos );
}

BOOL CuUrlCacheFilter::IsFilterURL(INTERNET_CACHE_ENTRY_INFO * lpEntry, LPCTSTR szURL)
{
    return IsFilter(lpEntry->lpszSourceUrlName , szURL);
}

BOOL CuUrlCacheFilter::IsFilterLocalFile( INTERNET_CACHE_ENTRY_INFO * lpEntry, LPCTSTR szFilter )
{ 
    return IsFilter(lpEntry->lpszLocalFileName , szFilter);
}

Enumeration of the Internet cache - CuUrlCacheEntry

2009-12-18T07:20:00.001-08:00

// Enumeration of the Internet cache.

CuUrlCacheEntry UrlCacheEntry;
UrlCacheEntry.ProcessEnumCacheEntry();

INTERNET_CACHE_ENTRY_INFO* lpEntry = NULL;
for( int i = 0 ; i < UrlCacheEntry.size() ; i++ )
{
    lpEntry = UrlCacheEntry.at(i);
}

// CuUrlCacheEntry.h

class CuUrlCacheEntry
{
    HANDLE m_hEnumHandle;
    vector<INTERNET_CACHE_ENTRY_INFO*> m_vecCacheEntryInfo;

public:
    CuUrlCacheEntry(void);
    ~CuUrlCacheEntry(void);

    UINT size(){ return m_vecCacheEntryInfo.size(); };
    INTERNET_CACHE_ENTRY_INFO* at(UINT i){ return m_vecCacheEntryInfo.at(i); };

public:
    void ProcessEnumCacheEntry();

private:
    HANDLE FindFirstEntry( LPCTSTR lpszUrlSearchPattern,  LPINTERNET_CACHE_ENTRY_INFO lpFirstCacheEntryInfo, LPDWORD lpcbCacheEntryInfo );
    BOOL FindNextEntry( LPINTERNET_CACHE_ENTRY_INFO lpNextCacheEntryInfo, LPDWORD lpcbCacheEntryInfo );
    BOOL FindCloseUrlCache();

    void Clear();
    BOOL CacheFirstEntry();
    BOOL CacheNextEntry();

};


// CuUrlCacheEntry.cpp

CuUrlCacheEntry::CuUrlCacheEntry(void)
:m_hEnumHandle(NULL)
{
}

CuUrlCacheEntry::~CuUrlCacheEntry(void)
{
    FindCloseUrlCache();
    this->Clear();
}

void CuUrlCacheEntry::ProcessEnumCacheEntry()
{

    BOOL bResult = CacheFirstEntry();
    if( bResult == FALSE )
        return;
    do 
    {
        bResult = CacheNextEntry();
    } while (bResult);

    FindCloseUrlCache();
}



HANDLE CuUrlCacheEntry::FindFirstEntry( LPCTSTR lpszUrlSearchPattern,  LPINTERNET_CACHE_ENTRY_INFO lpFirstCacheEntryInfo, LPDWORD lpcbCacheEntryInfo )
{
    FindCloseUrlCache();
    this->Clear();

    m_hEnumHandle = ::FindFirstUrlCacheEntry(lpszUrlSearchPattern, lpFirstCacheEntryInfo, lpcbCacheEntryInfo );
    return m_hEnumHandle;
}


BOOL CuUrlCacheEntry::FindNextEntry( LPINTERNET_CACHE_ENTRY_INFO lpNextCacheEntryInfo, LPDWORD lpcbCacheEntryInfo )
{
    return ::FindNextUrlCacheEntry(m_hEnumHandle, lpNextCacheEntryInfo, lpcbCacheEntryInfo  );
}


BOOL CuUrlCacheEntry::FindCloseUrlCache( )
{
    BOOL bResult = ::FindCloseUrlCache( m_hEnumHandle );
    m_hEnumHandle = NULL;
    return bResult;
}

void CuUrlCacheEntry::Clear()
{

    TCHAR* szBuffer = NULL;
    vector<INTERNET_CACHE_ENTRY_INFO*>::iterator iter;
    for( iter = m_vecCacheEntryInfo.begin() ; iter < m_vecCacheEntryInfo.end() ; iter++)
    {
        szBuffer = (TCHAR*)(*iter);
        delete [] szBuffer;
    }

    m_vecCacheEntryInfo.clear();

}

BOOL CuUrlCacheEntry::CacheFirstEntry()
{

    DWORD dwEntrySize = 0;

    BOOL bResult = (BOOL)FindFirstEntry(NULL, NULL, &dwEntrySize);
    if( (GetLastError() == ERROR_INSUFFICIENT_BUFFER) )
    {   
        INTERNET_CACHE_ENTRY_INFO * lpEntry = (INTERNET_CACHE_ENTRY_INFO * )new TCHAR[dwEntrySize];
        bResult = (BOOL)FindFirstEntry(NULL, lpEntry, &dwEntrySize);
        m_vecCacheEntryInfo.push_back(lpEntry);
    }

    return bResult;
}

BOOL CuUrlCacheEntry::CacheNextEntry()
{

    DWORD dwEntrySize = 0;

    BOOL bResult = (BOOL)FindNextEntry(NULL, &dwEntrySize);
    if( (GetLastError() == ERROR_INSUFFICIENT_BUFFER) )
    {   
        INTERNET_CACHE_ENTRY_INFO * lpEntry = (INTERNET_CACHE_ENTRY_INFO * )new TCHAR[dwEntrySize];
        bResult = FindNextEntry(lpEntry, &dwEntrySize);
        m_vecCacheEntryInfo.push_back(lpEntry);
    }

    return bResult;
}

CuEnvironmentString - Changing Environment Variables

2009-12-18T00:46:00.000-08:00

// Changing Environment Variables

CuEnvironmentString envString( szPath );
string strPath(envString);

// CuEnvironmentString.h

class CuEnvironmentString
{
    string m_strString;
public:
    CuEnvironmentString(void);
    CuEnvironmentString(string str);
    ~CuEnvironmentString(void);

public:
    void OnDo( string &str );
    operator string() const;

private:
    BOOL HaveEnvironmentVariable( string &str );
    string GetEnvironmentVariable( string &str );
    string ExplodeEnironmentVariable( string &str, size_t ops = 0 );
    string SubStrToIndexChar( string &str, char ch, size_t pos = 0 );
};


// CuEnvironmentString.cpp

CuEnvironmentString::CuEnvironmentString(void)
{
}

CuEnvironmentString::~CuEnvironmentString(void)
{
}

CuEnvironmentString::CuEnvironmentString(string str)
{
    OnDo(str);
}

void CuEnvironmentString::OnDo( string &str )
{

    m_strString.clear();
    if( !HaveEnvironmentVariable(str) )
    {
        m_strString = str;
        return;
    }

    size_t pos = 0;
    string strNotEnv;
    string strEnv;
    do 
    {
        strNotEnv = SubStrToIndexChar( str, '%', pos);
        m_strString += strNotEnv;
        pos += strNotEnv.size() + 1;

        strEnv = SubStrToIndexChar( str, '%', pos);
        m_strString += this->GetEnvironmentVariable(strEnv);
        pos += strEnv.size() + 1;

    } while ( pos < str.size() );

}

string CuEnvironmentString::SubStrToIndexChar( string &str, char ch, size_t pos/* = 0 */)
{
    string strResult;       
    if( pos > str.size() )
        return strResult;

    size_t found = str.find( '%' , pos);
    strResult = str.substr( pos, found - pos );

    return strResult;
}

string CuEnvironmentString::GetEnvironmentVariable( string &str )
{
    TCHAR newEnv[MAX_PATH +1];
    DWORD res = ::GetEnvironmentVariable( str.c_str(), newEnv, MAX_PATH );
    string strResult;
    if( res != 0 )
        strResult = newEnv;
    return strResult;
}

string CuEnvironmentString::ExplodeEnironmentVariable( string &str, size_t ops /* = 0*/ )
{

    size_t found_first = str.find( '%' , ops );
    size_t found_second = str.find( '%' , found_first + 1);

    string strResult;
    if( found_first != string::npos && found_second != string::npos )
        strResult = str.substr (found_first + 1, found_second - 1);

    return strResult;

}

BOOL CuEnvironmentString::HaveEnvironmentVariable( string &str )
{
    string strResult = ExplodeEnironmentVariable(str);
    return (!strResult.empty());
}

CuEnvironmentString::operator string() const
{ return string(m_strString.begin(), m_strString.end()); }

ExpandEnvironmentStrings - Changing Environment Variables

2009-12-17T19:23:00.000-08:00

// Changing Environment Variables
int _ExpandEnvironmentStrings( LPTSTR pText )
{
    TCHAR* p1 = _tcschr( pText, _T('%') );
    if( p1 == NULL )
        return -1;

    TCHAR* p2 = _tcschr( p1 +1, _T('%') );
    if( p2 == NULL )
        return -1;

    TCHAR provi[MAX_PATH +1];
    provi[0] = TCHAR(0);
    TCHAR env[MAX_PATH +1];
    p1 = pText;
    TCHAR* d = provi;
    while( *p1 != TCHAR(0) )
    {
        if( *p1 != _T('%') )
        {
            *d++ = *p1++;
            continue;
        }

        // find %
        p2 = _tcschr( p1 +1, _T('%') );
        if( p2 == NULL )
            return -1;

        lstrcpyn( env, p1 +1, int(p2 - p1) );
        TCHAR newEnv[MAX_PATH +1];
        DWORD res = ::GetEnvironmentVariable( env, newEnv, MAX_PATH );
        if( res > 0 )
        {
            lstrcpy( d, newEnv );
            d += lstrlen( newEnv );
        }
        p1 = p2 +1;
    }
    *d = TCHAR(0);

    if( lstrlen( provi ) != 0 )
    {
        lstrcpy( pText, provi );
    }

    return 0;
}

Explode ini File -- CuIniFile

2009-12-17T18:03:00.001-08:00

//Explode ini File

CuIniFile IniFile;
IniFile.OpenFile(szFilename);
string strURL = IniFile.GetValue("InternetShortcut", "URL");


// CuIniFile.h

class CuINIItem
{
public:
    string m_Key;
    string m_Value;
};

class CuINIStatment
{
public:
    string m_Name;
    vector<CuINIItem> m_vecItem;
};

//  有使用分號 ';' 的那一行, 會直接將整行試為註解, 不管分號是不是在第一個字元
class CuIniFile
{
    vector<CuINIStatment> m_vecStatment;

public:
    CuIniFile(void);
    ~CuIniFile(void);

public:
    int OpenFile(LPCTSTR szFileName);
    string GetValue( string strStatment, string strKey);

    CuINIStatment *FindStatment( string strStatmentName );
    CuINIItem *FindItem( CuINIStatment *pStatment, string strItemName );

private:
    string GetStatment(string &str);
    BOOL IsStatmentLine(string &str);
    BOOL IsMemoLine(string &str);
    void CreateNewStatment( string &str );
    void CreateNewItem( string &str );
};


// CuIniFile.cpp

CuIniFile::CuIniFile(void)
{
}

CuIniFile::~CuIniFile(void)
{
}


int CuIniFile::OpenFile(LPCTSTR szFileName)
{
    CuStringList StrList;
    StrList.OpenFile(szFileName);

    string strTemp;
    for( int i = 0 ; i < StrList.size() ; i++ )
    {
        strTemp = StrList.at(i);
        if( IsMemoLine(strTemp) )
            continue;

        if( IsStatmentLine(strTemp) )
            CreateNewStatment(strTemp);
        else
            CreateNewItem(strTemp);
    }

    return 0;
}

CuINIStatment *CuIniFile::FindStatment( string strStatmentName )
{
    vector<CuINIStatment>::iterator iter =  m_vecStatment.begin();
    for( ; iter < m_vecStatment.end(); iter++ )
    {
        if( (*iter).m_Name == strStatmentName ) 
            return &(*iter);
    }

    return NULL;
}

CuINIItem *CuIniFile::FindItem( CuINIStatment *pStatment, string strItemName )
{
    vector<CuIniFile> &IniItem =  pStatment->m_vecItem;
    vector<CuIniFile>::iterator iter = IniItem.begin();

    for( ; iter < IniItem.end(); iter++ )
    {
        if( (*iter).m_Key == strItemName )
            return &(*iter);
    }

    return NULL;
}

string CuIniFile::GetValue( string strStatment, string strKey)
{

    CuINIStatment *pStatment = FindStatment(strStatment);
    if( pStatment == NULL )
        return "";

    CuINIItem *pItem = FindItem(pStatment , strKey);
    if( pItem == NULL )
        return "";

    return pItem->m_Value;

}

BOOL CuIniFile::IsMemoLine(string &str)
{
    size_t found = str.find( ';' );
    return ( found == 0 );
}

string CuIniFile::GetStatment(string &str)
{

    size_t found_first = str.find( '[' );
    size_t found_second = str.find( ']' , found_first);

    string strStatment;
    if( found_first != string::npos && found_second != string::npos )
        strStatment =  str.substr(found_first + 1, found_second - found_first - 1);

    return strStatment;
}

BOOL CuIniFile::IsStatmentLine(string &str)
{
    string strStatmentKey = GetStatment(str);
    return (!strStatmentKey.empty());
}

void CuIniFile::CreateNewStatment( string &str )
{
    CuINIStatment Statment;
    Statment.m_Name = GetStatment(str);
    m_vecStatment.push_back(Statment);
}   


void CuIniFile::CreateNewItem( string &str )
{

    size_t found = str.find('=');
    if( found == string::npos )
        return;

    string strKey = str.substr(0, found);
    string strValue = str.substr( found + 1 , str.size());

    CuINIItem Item;
    Item.m_Key = strKey;
    Item.m_Value = strValue;
    m_vecStatment[ m_vecStatment.size() - 1 ].m_vecItem.push_back(Item);
}