CuGLES

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

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

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

//

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

//


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

//


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

// 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 來做範例.