perl-win32-gui-cvscommit Mailing List for Win32::GUI

Update of /cvsroot/perl-win32-gui/Win32-GUI-Grid/MFCGrid
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15861/MFCGrid

Added Files:
	CellRange.h GridCell.cpp GridCell.h GridCellBase.cpp 
	GridCellBase.h GridCellCheck.cpp GridCellCheck.h 
	GridCellCombo.cpp GridCellCombo.h GridCellDateTime.cpp 
	GridCellDateTime.h GridCellNumeric.cpp GridCellNumeric.h 
	GridCellURL.cpp GridCellURL.h GridCtrl.cpp GridCtrl.h 
	GridDropTarget.cpp GridDropTarget.h InPlaceEdit.cpp 
	InPlaceEdit.h Makefile MemDC.h StdAfx.cpp StdAfx.h 
	TitleTip.cpp TitleTip.h 
Log Message:
Added to repository

--- NEW FILE: InPlaceEdit.h ---
//////////////////////////////////////////////////////////////////////
// InPlaceEdit.h : header file
//
// MFC Grid Control - inplace editing class
//
// Written by Chris Maunder <cma...@ma...>
// Copyright (c) 1998-2002. All Rights Reserved.
//
// This code may be used in compiled form in any way you desire. This
// file may be redistributed unmodified by any means PROVIDING it is 
// not sold for profit without the authors written consent, and 
// providing that this notice and the authors name and all copyright 
// notices remains intact. 
//
// An email letting me know how you are using it would be nice as well. 
//
// This file is provided "as is" with no expressed or implied warranty.
// The author accepts no liability for any damage/loss of business that
// this product may cause.
//
// For use with CGridCtrl v2.10+
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_INPLACEEDIT_H__ECD42821_16DF_11D1_992F_895E185F9C72__INCLUDED_)
#define AFX_INPLACEEDIT_H__ECD42821_16DF_11D1_992F_895E185F9C72__INCLUDED_

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

class CInPlaceEdit : public CEdit
{
// Construction
public:
    CInPlaceEdit(CWnd* pParent, CRect& rect, DWORD dwStyle, UINT nID,
                 int nRow, int nColumn, CString sInitText, UINT nFirstChar);

// Attributes
public:
 
// Operations
public:
     void EndEdit();
 
// Overrides
     // ClassWizard generated virtual function overrides
     //{{AFX_VIRTUAL(CInPlaceEdit)
	public:
	virtual BOOL PreTranslateMessage(MSG* pMsg);
	protected:
	virtual void PostNcDestroy();
	//}}AFX_VIRTUAL
 
// Implementation
public:
     virtual ~CInPlaceEdit();
 
// Generated message map functions
protected:
    //{{AFX_MSG(CInPlaceEdit)
    afx_msg void OnKillFocus(CWnd* pNewWnd);
    afx_msg void OnChar(UINT nChar, UINT nRepCnt, UINT nFlags);
    afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
	afx_msg UINT OnGetDlgCode();
	//}}AFX_MSG
    DECLARE_MESSAGE_MAP()

private:
    int     m_nRow;
    int     m_nColumn;
    CString m_sInitText;
    UINT    m_nLastChar;
    BOOL    m_bExitOnArrows;
    CRect   m_Rect;
};
 
/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_INPLACEEDIT_H__ECD42821_16DF_11D1_992F_895E185F9C72__INCLUDED_)

--- NEW FILE: GridCellCheck.cpp ---
// GridCellCheck.cpp : implementation file
//
// MFC Grid Control - Main grid cell class
//
// Provides the implementation for a combobox cell type of the
// grid control.
//
// Written by Chris Maunder <cma...@ma...>
// Copyright (c) 1998-2002. All Rights Reserved.
//
// Parts of the code contained in this file are based on the original
// CInPlaceList from http://www.codeguru.com/listview
//
// This code may be used in compiled form in any way you desire. This
// file may be redistributed unmodified by any means PROVIDING it is
// not sold for profit without the authors written consent, and
// providing that this notice and the authors name and all copyright
// notices remains intact.
//
// An email letting me know how you are using it would be nice as well.
//
// This file is provided "as is" with no expressed or implied warranty.
// The author accepts no liability for any damage/loss of business that
// this product may cause.
//
// For use with CGridCtrl v2.22+
//
// History:
// 23 Jul 2001 - Complete rewrite
//
/////////////////////////////////////////////////////////////////////////////

#include "StdAfx.h"
#include "GridCell.h"
#include "GridCtrl.h"

#include "GridCellCheck.h"


#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

IMPLEMENT_DYNCREATE(CGridCellCheck, CGridCell)

CGridCellCheck::CGridCellCheck() : CGridCell()
{
    m_bChecked = FALSE;
    //m_Rect.IsRectNull();
}

CSize CGridCellCheck::GetCellExtent(CDC* pDC)
{
    // Using SM_CXHSCROLL as a guide to the size of the checkbox
    int nWidth = GetSystemMetrics(SM_CXHSCROLL) + 2*GetMargin();  // Yogurt $$LR$$
    CSize	cellSize = CGridCell::GetCellExtent(pDC);
    cellSize.cx += nWidth;
    cellSize.cy = max (cellSize.cy, nWidth);
    return  cellSize;
}

// i/o:  i=dims of cell rect; o=dims of text rect
BOOL CGridCellCheck::GetTextRect( LPRECT pRect)
{
    BOOL bResult = CGridCell::GetTextRect(pRect);
    if (bResult)
    {
        int nWidth = GetSystemMetrics(SM_CXHSCROLL) + 2*GetMargin();
        pRect->left += nWidth;
        if (pRect->left > pRect->right)
            pRect->left = pRect->right;
    }
    return bResult;
}

// Override draw so that when the cell is selected, a drop arrow is shown in the RHS.
BOOL CGridCellCheck::Draw(CDC* pDC, int nRow, int nCol, CRect rect,  BOOL bEraseBkgnd /*=TRUE*/)
{
    BOOL bResult = CGridCell::Draw(pDC, nRow, nCol, rect,  bEraseBkgnd);

#ifndef _WIN32_WCE
    // Store the cell's dimensions for later
    m_Rect = rect;

    CRect CheckRect = GetCheckPlacement();
    rect.left = CheckRect.right;

    // enough room to draw?
    // if (CheckRect.Width() < rect.Width() && CheckRect.Height() < rect.Height()) {

    // Do the draw
    pDC->DrawFrameControl(GetCheckPlacement(), DFC_BUTTON,
            (m_bChecked)? DFCS_BUTTONCHECK | DFCS_CHECKED : DFCS_BUTTONCHECK);

    // }
#endif
    return bResult;
}

void CGridCellCheck::OnClick(CPoint PointCellRelative)
{
    // PointCellRelative is relative to the topleft of the cell. Convert to client coords
    PointCellRelative += m_Rect.TopLeft();
    
    CCellID cell = GetGrid()->GetCellFromPt (PointCellRelative);
    if (!GetGrid()->IsCellEditable (cell))
        return;

    // GetCheckPlacement returns the checkbox dimensions in client coords. Only check/
    // uncheck if the user clicked in the box
    if (GetCheckPlacement().PtInRect(PointCellRelative))
    {
        m_bChecked = !m_bChecked;
        GetGrid()->InvalidateRect(m_Rect);
    }
}

//////////////////////////////////////////////////////////////////////
// Operations
//////////////////////////////////////////////////////////////////////

BOOL CGridCellCheck::SetCheck(BOOL bChecked /*=TRUE*/)
{
        BOOL bTemp = m_bChecked;
        m_bChecked = bChecked;
        if (!m_Rect.IsRectEmpty())
                GetGrid()->InvalidateRect(m_Rect);

        return bTemp;
}

BOOL CGridCellCheck::GetCheck()
{
        return m_bChecked;
}

//////////////////////////////////////////////////////////////////////
// Protected implementation
//////////////////////////////////////////////////////////////////////

// Returns the dimensions and placement of the checkbox in client coords.
CRect CGridCellCheck::GetCheckPlacement()
{
    int nWidth = GetSystemMetrics(SM_CXHSCROLL);
    CRect place = m_Rect + CSize(GetMargin(), GetMargin());
    place.right = place.left + nWidth;
    place.bottom = place.top + nWidth;
    
    /* for centering
    int nDiff = (place.Width() - nWidth)/2;
    if (nDiff > 0)
    {
    place.left += nDiff;
    place.right = place.left + nWidth;
    }
    nDiff = (place.Height() - nWidth)/2;
    if (nDiff > 0)
    {
    place.top += nDiff;
    place.bottom = place.top + nWidth;
    }
    */
    // Yogurt $$LR$$
    if (m_Rect.Height() < nWidth + 2 * (int)GetMargin() ) 
    {
        place.top    = m_Rect.top + (m_Rect.Height() - nWidth) / 2;
        place.bottom = place.top + nWidth;	
    }    

    return place;
}

--- NEW FILE: GridCell.cpp ---
// GridCell.cpp : implementation file
//
// MFC Grid Control - Main grid cell class
//
// Provides the implementation for the "default" cell type of the
// grid control. Adds in cell editing.
//
// Written by Chris Maunder <cma...@ma...>
// Copyright (c) 1998-2002. All Rights Reserved.
//
// This code may be used in compiled form in any way you desire. This
// file may be redistributed unmodified by any means PROVIDING it is 
// not sold for profit without the authors written consent, and 
// providing that this notice and the authors name and all copyright 
// notices remains intact. 
//
// An email letting me know how you are using it would be nice as well. 
//
// This file is provided "as is" with no expressed or implied warranty.
// The author accepts no liability for any damage/loss of business that
// this product may cause.
//
// For use with CGridCtrl v2.20+
//
// History:
// Eric Woodruff - 20 Feb 2000 - Added PrintCell() plus other minor changes
// Ken Bertelson - 12 Apr 2000 - Split CGridCell into CGridCell and CGridCellBase
// <ken...@ho...>
// C Maunder     - 17 Jun 2000 - Font handling optimsed, Added CGridDefaultCell
//
/////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "GridCell.h"
#include "InPlaceEdit.h"
#include "GridCtrl.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

IMPLEMENT_DYNCREATE(CGridCell, CGridCellBase)
IMPLEMENT_DYNCREATE(CGridDefaultCell, CGridCell)

/////////////////////////////////////////////////////////////////////////////
// GridCell

CGridCell::CGridCell()
{
    m_plfFont = NULL;
	CGridCell::Reset();
}

CGridCell::~CGridCell()
{
    delete m_plfFont;
}

/////////////////////////////////////////////////////////////////////////////
// GridCell Attributes

void CGridCell::operator=(const CGridCell& cell)
{
    if (this != &cell) CGridCellBase::operator=(cell);
}

void CGridCell::Reset()
{
    CGridCellBase::Reset();

    m_strText.Empty();
    m_nImage   = -1;
    m_lParam   = NULL;           // BUG FIX J. Bloggs 20/10/03
    m_pGrid    = NULL;
    m_bEditing = FALSE;
    m_pEditWnd = NULL;

    m_nFormat = (DWORD)-1;       // Use default from CGridDefaultCell
    m_crBkClr = CLR_DEFAULT;     // Background colour (or CLR_DEFAULT)
    m_crFgClr = CLR_DEFAULT;     // Forground colour (or CLR_DEFAULT)
    m_nMargin = (UINT)-1;        // Use default from CGridDefaultCell

    delete m_plfFont;
    m_plfFont = NULL;            // Cell font
}

void CGridCell::SetFont(const LOGFONT* plf)
{
    if (plf == NULL)
    {
        delete m_plfFont;
        m_plfFont = NULL;
    }
    else
    {
        if (!m_plfFont)
            m_plfFont = new LOGFONT;
        if (m_plfFont)
            memcpy(m_plfFont, plf, sizeof(LOGFONT)); 
    }
}

LOGFONT* CGridCell::GetFont() const
{
    if (m_plfFont == NULL)
    {
        CGridDefaultCell *pDefaultCell = (CGridDefaultCell*) GetDefaultCell();
        if (!pDefaultCell)
            return NULL;

        return pDefaultCell->GetFont();
    }

    return m_plfFont; 
}

CFont* CGridCell::GetFontObject() const
{
    // If the default font is specified, use the default cell implementation
    if (m_plfFont == NULL)
    {
        CGridDefaultCell *pDefaultCell = (CGridDefaultCell*) GetDefaultCell();
        if (!pDefaultCell)
            return NULL;

        return pDefaultCell->GetFontObject();
    }
    else
    {
        static CFont Font;
        Font.DeleteObject();
        Font.CreateFontIndirect(m_plfFont);
        return &Font;
    }
}

DWORD CGridCell::GetFormat() const
{
    if (m_nFormat == (DWORD)-1)
    {
        CGridDefaultCell *pDefaultCell = (CGridDefaultCell*) GetDefaultCell();
        if (!pDefaultCell)
            return 0;

        return pDefaultCell->GetFormat();
    }

    return m_nFormat; 
}

UINT CGridCell::GetMargin() const           
{
    if (m_nMargin == (UINT)-1)
    {
        CGridDefaultCell *pDefaultCell = (CGridDefaultCell*) GetDefaultCell();
        if (!pDefaultCell)
            return 0;

        return pDefaultCell->GetMargin();
    }

    return m_nMargin; 
}

/////////////////////////////////////////////////////////////////////////////
// GridCell Operations

BOOL CGridCell::Edit(int nRow, int nCol, CRect rect, CPoint /* point */, UINT nID, UINT nChar)
{
    if ( m_bEditing )
	{      
        if (m_pEditWnd)
		    m_pEditWnd->SendMessage ( WM_CHAR, nChar );    
    }  
	else  
	{   
		DWORD dwStyle = ES_LEFT;
		if (GetFormat() & DT_RIGHT) 
			dwStyle = ES_RIGHT;
		else if (GetFormat() & DT_CENTER) 
			dwStyle = ES_CENTER;
		
		m_bEditing = TRUE;
		
		// InPlaceEdit auto-deletes itself
		CGridCtrl* pGrid = GetGrid();
		m_pEditWnd = new CInPlaceEdit(pGrid, rect, dwStyle, nID, nRow, nCol, GetText(), nChar);
    }
    return TRUE;
}

void CGridCell::EndEdit()
{
    if (m_pEditWnd)
        ((CInPlaceEdit*)m_pEditWnd)->EndEdit();
}

void CGridCell::OnEndEdit()
{
    m_bEditing = FALSE;
    m_pEditWnd = NULL;
}

/////////////////////////////////////////////////////////////////////////////
// CGridDefaultCell

CGridDefaultCell::CGridDefaultCell() 
{
#ifdef _WIN32_WCE
    m_nFormat = DT_LEFT|DT_VCENTER|DT_SINGLELINE|DT_NOPREFIX;
#else
    m_nFormat = DT_LEFT|DT_VCENTER|DT_SINGLELINE|DT_NOPREFIX | DT_END_ELLIPSIS;
#endif
    m_crFgClr = CLR_DEFAULT;
    m_crBkClr = CLR_DEFAULT;
    m_Size    = CSize(30,10);
    m_dwStyle = 0;

#ifdef _WIN32_WCE
    LOGFONT lf;
    GetObject(GetStockObject(SYSTEM_FONT), sizeof(LOGFONT), &lf);
    SetFont(&lf);
#else // not CE
    NONCLIENTMETRICS ncm;
    ncm.cbSize = sizeof(NONCLIENTMETRICS);
    VERIFY(SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &ncm, 0));
    SetFont(&(ncm.lfMessageFont));
#endif
}

CGridDefaultCell::~CGridDefaultCell()
{
    m_Font.DeleteObject(); 
}

void CGridDefaultCell::SetFont(const LOGFONT* plf)
{
    ASSERT(plf);

    if (!plf) return;

    m_Font.DeleteObject();
    m_Font.CreateFontIndirect(plf);

    CGridCell::SetFont(plf);

    // Get the font size and hence the default cell size
    CDC* pDC = CDC::FromHandle(::GetDC(NULL));
    if (pDC)
    {
        CFont* pOldFont = pDC->SelectObject(&m_Font);

        SetMargin(pDC->GetTextExtent(_T(" "), 1).cx);
        m_Size = pDC->GetTextExtent(_T(" XXXXXXXXXXXX "), 14);
        m_Size.cy = (m_Size.cy * 3) / 2;

        pDC->SelectObject(pOldFont);
        ReleaseDC(NULL, pDC->GetSafeHdc());
    }
    else
    {
        SetMargin(3);
        m_Size = CSize(40,16);
    }
}

LOGFONT* CGridDefaultCell::GetFont() const
{
    ASSERT(m_plfFont);  // This is the default - it CAN'T be NULL!
    return m_plfFont;
}

CFont* CGridDefaultCell::GetFontObject() const
{
    ASSERT(m_Font.GetSafeHandle());
    return (CFont*) &m_Font; 
}

--- NEW FILE: Makefile ---
# Microsoft Developer Studio Generated NMAKE File, Based on MFCGrid.dsp

!IF "$(OS)" == "Windows_NT"
NULL=
!ELSE
NULL=nul
!ENDIF

CPP=cl.exe
RSC=rc.exe

OUTDIR=.\Lib
INTDIR=.\Build
# Begin Custom Macros
OutDir=.\Lib
# End Custom Macros

ALL : "$(OUTDIR)\MFCGrid.lib"

CLEAN :
		-@erase "$(INTDIR)\GridCellUrl.obj"
        -@erase "$(INTDIR)\GridCellNumeric.obj"
        -@erase "$(INTDIR)\GridCellDateTime.obj"
        -@erase "$(INTDIR)\GridCellCheck.obj"
        -@erase "$(INTDIR)\GridCellCombo.obj"
        -@erase "$(INTDIR)\GridCell.obj"
        -@erase "$(INTDIR)\GridCellBase.obj"
        -@erase "$(INTDIR)\GridCtrl.obj"
        -@erase "$(INTDIR)\GridDropTarget.obj"
        -@erase "$(INTDIR)\InPlaceEdit.obj"
        -@erase "$(INTDIR)\StdAfx.obj"
        -@erase "$(INTDIR)\TitleTip.obj"
        -@erase "$(INTDIR)\vc60.idb"
        -@erase "$(INTDIR)\MFCGrid.pch"
        -@erase "$(OUTDIR)\MFCGrid.lib"

"$(OUTDIR)" :
    mkdir "$(OUTDIR)"

"$(INTDIR)" :
    mkdir "$(INTDIR)"

CPP=cl.exe
CPP_PROJ=/nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D"_WINDLL" /D"_USRDLL" /D "_AFXDLL" /D "_AFX_NOFORCE_LIBS" /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /c

BSC32=bscmake.exe
BSC32_FLAGS=/nologo /o"$(OUTDIR)\MFCGrid.bsc"
BSC32_SBRS= \

LIB32=link.exe -lib
LIB32_FLAGS=/nologo /out:"$(OUTDIR)\MFCGrid.lib"
LIB32_OBJS= \
        "$(INTDIR)\TitleTip.obj" \
        "$(INTDIR)\InPlaceEdit.obj" \
        "$(INTDIR)\GridDropTarget.obj" \
        "$(INTDIR)\GridCtrl.obj" \
        "$(INTDIR)\GridCellBase.obj" \
        "$(INTDIR)\GridCell.obj" \
        "$(INTDIR)\GridCellNumeric.obj" \
		"$(INTDIR)\GridCellUrl.obj" \
        "$(INTDIR)\GridCellDateTime.obj" \
        "$(INTDIR)\GridCellCheck.obj" \
        "$(INTDIR)\GridCellCombo.obj" \
        "$(INTDIR)\StdAfx.obj"

"$(OUTDIR)\MFCGrid.lib" : "$(OUTDIR)" "$(INTDIR)" $(DEF_FILE) $(LIB32_OBJS)
    $(LIB32) @<<
  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
<<

.c{$(INTDIR)}.obj::
   $(CPP) @<<
   $(CPP_PROJ) $<
<<

.cpp{$(INTDIR)}.obj::
   $(CPP) @<<
   $(CPP_PROJ) $<
<<

.cxx{$(INTDIR)}.obj::
   $(CPP) @<<
   $(CPP_PROJ) $<
<<

.c{$(INTDIR)}.sbr::
   $(CPP) @<<
   $(CPP_PROJ) $<
<<

.cpp{$(INTDIR)}.sbr::
   $(CPP) @<<
   $(CPP_PROJ) $<
<<

.cxx{$(INTDIR)}.sbr::
   $(CPP) @<<
   $(CPP_PROJ) $<
<<

GridCell.cpp : \
        "CellRange.h"\
        "GridCell.h"\
        "GridCellBase.h"\
        "GridCtrl.h"\
        "GridDropTarget.h"\
        "InPlaceEdit.h"\
        "StdAfx.h"\
        "TitleTip.h"


GridCellBase.cpp : \
        "CellRange.h"\
        "GridCell.h"\
        "GridCellBase.h"\
        "GridCtrl.h"\
        "GridDropTarget.h"\
        "StdAfx.h"\
        "TitleTip.h"


GridCtrl.cpp : \
        "CellRange.h"\
        "GridCell.h"\
        "GridCellBase.h"\
        "GridCtrl.h"\
        "GridDropTarget.h"\
        "MemDC.h"\
        "StdAfx.h"\
        "TitleTip.h"


GridDropTarget.cpp : \
        "CellRange.h"\
        "GridCell.h"\
        "GridCellBase.h"\
        "GridCtrl.h"\
        "GridDropTarget.h"\
        "StdAfx.h"\
        "TitleTip.h"


InPlaceEdit.cpp : \
        "CellRange.h"\
        "GridCell.h"\
        "GridCellBase.h"\
        "GridCtrl.h"\
        "GridDropTarget.h"\
        "InPlaceEdit.h"\
        "StdAfx.h"\
        "TitleTip.h"


StdAfx.cpp : \
        "StdAfx.h"


TitleTip.cpp : \
        "CellRange.h"\
        "GridCell.h"\
        "GridCellBase.h"\
        "GridCtrl.h"\
        "GridDropTarget.h"\
        "StdAfx.h"\
        "TitleTip.h"

GridCellNumeric.cpp : \
        "GridCell.h"\
        "GridCellBase.h"\
        "GridCtrl.h"\
        "InPlaceEdit.h"\
        "StdAfx.h"

GridCellDateTime.cpp : \
        "GridCell.h"\
        "GridCellBase.h"\
        "GridCtrl.h"\
        "StdAfx.h"

GridCellCheck.cpp : \
        "GridCellCheck.h"\
        "GridCell.h"\
        "GridCellBase.h"\
        "GridCtrl.h"\
        "StdAfx.h"

GridCellCombo.cpp : \
        "GridCellCombo.h"\
        "GridCell.h"\
        "GridCellBase.h"\
        "GridCtrl.h"\
        "StdAfx.h"

GridCellUrl.cpp : \
        "GridCellUrl.h"\
        "GridCell.h"\
        "GridCellBase.h"\
        "GridCtrl.h"\
        "StdAfx.h"

SOURCE=GridCell.cpp

"$(INTDIR)\GridCell.obj" : $(SOURCE) "$(INTDIR)"
        $(CPP) $(CPP_PROJ) $(SOURCE)

SOURCE=GridCellBase.cpp

"$(INTDIR)\GridCellBase.obj" : $(SOURCE) "$(INTDIR)"
        $(CPP) $(CPP_PROJ) $(SOURCE)

SOURCE=GridCtrl.cpp

"$(INTDIR)\GridCtrl.obj" : $(SOURCE) "$(INTDIR)"
        $(CPP) $(CPP_PROJ) $(SOURCE)

SOURCE=GridDropTarget.cpp

"$(INTDIR)\GridDropTarget.obj" : $(SOURCE) "$(INTDIR)"
        $(CPP) $(CPP_PROJ) $(SOURCE)

SOURCE=InPlaceEdit.cpp

"$(INTDIR)\InPlaceEdit.obj" : $(SOURCE) "$(INTDIR)"
        $(CPP) $(CPP_PROJ) $(SOURCE)

SOURCE=StdAfx.cpp

"$(INTDIR)\StdAfx.obj" : $(SOURCE) "$(INTDIR)"
        $(CPP) $(CPP_PROJ) $(SOURCE)

SOURCE=TitleTip.cpp

"$(INTDIR)\TitleTip.obj" : $(SOURCE) "$(INTDIR)"
        $(CPP) $(CPP_PROJ) $(SOURCE)

SOURCE=GridCellNumeric.cpp

"$(INTDIR)\GridCellNumeric.obj" : $(SOURCE) "$(INTDIR)"
        $(CPP) $(CPP_PROJ) $(SOURCE)

SOURCE=GridCellDateTime.cpp

"$(INTDIR)\GridCellDateTime.obj" : $(SOURCE) "$(INTDIR)"
        $(CPP) $(CPP_PROJ) $(SOURCE)

SOURCE=GridCellCheck.cpp

"$(INTDIR)\GridCellCheck.obj" : $(SOURCE) "$(INTDIR)"
        $(CPP) $(CPP_PROJ) $(SOURCE)

SOURCE=GridCellCombo.cpp

"$(INTDIR)\GridCellCombo.obj" : $(SOURCE) "$(INTDIR)"
        $(CPP) $(CPP_PROJ) $(SOURCE)

SOURCE=GridCellUrl.cpp

"$(INTDIR)\GridCellUrl.obj" : $(SOURCE) "$(INTDIR)"
        $(CPP) $(CPP_PROJ) $(SOURCE)

--- NEW FILE: GridCellCombo.h ---
#if !defined(AFX_GRIDCELLCOMBO_H__ECD42822_16DF_11D1_992F_895E185F9C72__INCLUDED_)
#define AFX_GRIDCELLCOMBO_H__ECD42822_16DF_11D1_992F_895E185F9C72__INCLUDED_

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

/////////////////////////////////////////////////////////////////////////////
// GridCellCombo.h : header file
//
// MFC Grid Control - Grid combo cell class header file
//
// Written by Chris Maunder <cma...@ma...>
// Copyright (c) 1998-2002. All Rights Reserved.
//
// This code may be used in compiled form in any way you desire. This
// file may be redistributed unmodified by any means PROVIDING it is 
// not sold for profit without the authors written consent, and 
// providing that this notice and the authors name and all copyright 
// notices remains intact. 
//
// An email letting me know how you are using it would be nice as well. 
//
// This file is provided "as is" with no expressed or implied warranty.
// The author accepts no liability for any damage/loss of business that
// this product may cause.
//
// For use with CGridCtrl v2.10
//
//////////////////////////////////////////////////////////////////////


#include "GridCell.h"


class CGridCellCombo : public CGridCell
{
    friend class CGridCtrl;
    DECLARE_DYNCREATE(CGridCellCombo)

public:
    CGridCellCombo();

// editing cells
public:
    virtual BOOL  Edit(int nRow, int nCol, CRect rect, CPoint point, UINT nID, UINT nChar);
    virtual CWnd* GetEditWnd() const;
    virtual void  EndEdit();

// Operations
public:
	virtual CSize GetCellExtent(CDC* pDC);

// CGridCellCombo specific calls
public:
    void  SetOptions(const CStringArray& ar);
    void  SetStyle(DWORD dwStyle)           { m_dwStyle = dwStyle; }
    DWORD GetStyle()                        { return m_dwStyle;    }

protected:
    virtual BOOL Draw(CDC* pDC, int nRow, int nCol, CRect rect, BOOL bEraseBkgnd = TRUE);

    CStringArray m_Strings;
    DWORD        m_dwStyle;
};

class CGridCellList : public CGridCellCombo
{
    DECLARE_DYNCREATE(CGridCellList)
public:
    CGridCellList();
};

/////////////////////////////////////////////////////////////////////////////
// CComboEdit window

#define IDC_COMBOEDIT 1001

class CComboEdit : public CEdit
{
// Construction
public:
	CComboEdit();

// Attributes
public:

// Operations
public:

// Overrides
	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CComboEdit)
	virtual BOOL PreTranslateMessage(MSG* pMsg);
	//}}AFX_VIRTUAL

// Implementation
public:
	virtual ~CComboEdit();

	// Generated message map functions
protected:
	//{{AFX_MSG(CComboEdit)
	afx_msg void OnKillFocus(CWnd* pNewWnd);
	afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
	afx_msg void OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags);
	//}}AFX_MSG

	DECLARE_MESSAGE_MAP()
};

/////////////////////////////////////////////////////////////////////////////
// CInPlaceList window

class CInPlaceList : public CComboBox
{
    friend class CComboEdit;

// Construction
public:
	CInPlaceList(CWnd* pParent,         // parent
                 CRect& rect,           // dimensions & location
                 DWORD dwStyle,         // window/combobox style
                 UINT nID,              // control ID
                 int nRow, int nColumn, // row and column
                 COLORREF crFore, COLORREF crBack,  // Foreground, background colour
				 CStringArray& Items,   // Items in list
                 CString sInitText,     // initial selection
				 UINT nFirstChar);      // first character to pass to control

// Attributes
public:
   CComboEdit m_edit;  // subclassed edit control

// Operations
public:

// Overrides
	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CInPlaceList)
	protected:
	virtual void PostNcDestroy();
	//}}AFX_VIRTUAL

// Implementation
public:
	virtual ~CInPlaceList();
    void EndEdit();

protected:
    int GetCorrectDropWidth();

// Generated message map functions
protected:
	//{{AFX_MSG(CInPlaceList)
	afx_msg void OnKillFocus(CWnd* pNewWnd);
	afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
	afx_msg void OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags);
	afx_msg void OnDropdown();
	afx_msg void OnSelChange();
	afx_msg UINT OnGetDlgCode();
	afx_msg HBRUSH CtlColor(CDC* pDC, UINT nCtlColor);
	//}}AFX_MSG
	//afx_msg void OnSelendOK();

	DECLARE_MESSAGE_MAP()

private:
	int		 m_nNumLines;
	CString  m_sInitText;
	int		 m_nRow;
	int		 m_nCol;
 	UINT     m_nLastChar; 
	BOOL	 m_bExitOnArrows; 
    COLORREF m_crForeClr, m_crBackClr;
};

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

//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_GRIDCELLCOMBO_H__ECD42822_16DF_11D1_992F_895E185F9C72__INCLUDED_)

--- NEW FILE: GridCellURL.h ---
// GridCellURL.h: interface for the CGridCellURL class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_GridCellURL_H__9F4A50B4_D773_11D3_A439_F7E60631F563__INCLUDED_)
#define AFX_GridCellURL_H__9F4A50B4_D773_11D3_A439_F7E60631F563__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "GridCell.h"

typedef struct {
    LPCTSTR szURLPrefix;
    int     nLength;
} URLStruct;



class CGridCellURL : public CGridCell  
{
    DECLARE_DYNCREATE(CGridCellURL)

public:
	CGridCellURL();
	virtual ~CGridCellURL();

    virtual BOOL     Draw(CDC* pDC, int nRow, int nCol, CRect rect, BOOL bEraseBkgnd = TRUE);
    // virtual BOOL     Edit(int nRow, int nCol, CRect rect, CPoint point, UINT nID, UINT nChar);
    virtual LPCTSTR  GetTipText() { return NULL; }
	void SetAutoLaunchUrl(BOOL bLaunch = TRUE) { m_bLaunchUrl = bLaunch;	}
	BOOL GetAutoLaunchUrl() { return m_bLaunchUrl && !m_bEditing; }

protected:
    virtual BOOL OnSetCursor();
    virtual void OnClick(CPoint PointCellRelative);

	BOOL HasUrl(CString str);
    BOOL OverURL(CPoint& pt, CString& strURL);

protected:
#ifndef _WIN32_WCE
    static HCURSOR g_hLinkCursor;		// Hyperlink mouse cursor
	HCURSOR GetHandCursor();
#endif
    static URLStruct g_szURIprefixes[];

protected:
	COLORREF m_clrUrl;
    COLORREF m_clrOld;
	BOOL     m_bLaunchUrl;
    CRect    m_Rect;
};

#endif // !defined(AFX_GridCellURL_H__9F4A50B4_D773_11D3_A439_F7E60631F563__INCLUDED_)

--- NEW FILE: GridCellDateTime.h ---
// GridCellDateTime.h: interface for the CGridCellDateTime class.
//
// Provides the implementation for a datetime picker cell type of the
// grid control.
//
// For use with CGridCtrl v2.22+
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_DATETIMECELL_H__A0B7DA0A_0AFE_4D28_A00E_846C96D7507A__INCLUDED_)
#define AFX_DATETIMECELL_H__A0B7DA0A_0AFE_4D28_A00E_846C96D7507A__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "GridCell.h"
#include "afxdtctl.h"   // for CDateTimeCtrl

class CGridCellDateTime : public CGridCell
{
  friend class CGridCtrl;
  DECLARE_DYNCREATE(CGridCellDateTime)

  CTime m_cTime;
  DWORD m_dwStyle;

public:
        CGridCellDateTime();
        CGridCellDateTime(DWORD dwStyle);
        virtual ~CGridCellDateTime();
    
  // editing cells
public:
        void Init(DWORD dwStyle);
        virtual BOOL  Edit(int nRow, int nCol, CRect rect, CPoint point, UINT nID, UINT nChar);
        virtual CWnd* GetEditWnd() const;
        virtual void  EndEdit();
        virtual CSize GetCellExtent(CDC* pDC);

        CTime* GetTime() {return &m_cTime;};
        void   SetTime(CTime time);
};

class CInPlaceDateTime : public CDateTimeCtrl
{
    // Construction
public:
    CInPlaceDateTime(CWnd* pParent,         // parent
        CRect& rect,           // dimensions & location
        DWORD dwStyle,         // window/combobox style
        UINT nID,              // control ID
        int nRow, int nColumn, // row and column
        COLORREF crFore, COLORREF crBack,  // Foreground, background colour
        CTime* pcTime,
        UINT nFirstChar);      // first character to pass to control
    
    // Overrides
    // ClassWizard generated virtual function overrides
    //{{AFX_VIRTUAL(CInPlaceList)
protected:
    virtual void PostNcDestroy();
    //}}AFX_VIRTUAL
    
    // Implementation
public:
    virtual ~CInPlaceDateTime();
    void EndEdit();
    
    // Generated message map functions
protected:
    //{{AFX_MSG(CInPlaceList)
    afx_msg void OnKillFocus(CWnd* pNewWnd);
    afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
    afx_msg void OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags);
    afx_msg UINT OnGetDlgCode();
    afx_msg void OnCloseUp ( NMHDR * pNotifyStruct, LRESULT* result );
    //}}AFX_MSG
    //afx_msg void OnSelendOK();
    
    DECLARE_MESSAGE_MAP()
        
private:
    CTime*   m_pcTime;
    int              m_nRow;
    int              m_nCol;
    UINT     m_nLastChar;
    BOOL     m_bExitOnArrows;
    COLORREF m_crForeClr, m_crBackClr;
};

class CGridCellTime : public CGridCellDateTime
{
    CGridCellTime():CGridCellDateTime(DTS_TIMEFORMAT) {}
    
    DECLARE_DYNCREATE(CGridCellTime)
};

class CGridCellDateCal : public CGridCellDateTime
{
    CGridCellDateCal():CGridCellDateTime() {}

    virtual BOOL Edit(int nRow, int nCol, CRect rect, CPoint /* point */, UINT nID, UINT nChar);

    DECLARE_DYNCREATE(CGridCellDateCal)
};
#endif // !defined(AFX_DATETIMECELL_H__A0B7DA0A_0AFE_4D28_A00E_846C96D7507A__INCLUDED_)

--- NEW FILE: GridCell.h ---
/////////////////////////////////////////////////////////////////////////////
// GridCell.h : header file
//
// MFC Grid Control - Grid cell class header file
//
// Written by Chris Maunder <cma...@ma...>
// Copyright (c) 1998-2002. All Rights Reserved.
//
// This code may be used in compiled form in any way you desire. This
// file may be redistributed unmodified by any means PROVIDING it is 
// not sold for profit without the authors written consent, and 
// providing that this notice and the authors name and all copyright 
// notices remains intact. 
//
// An email letting me know how you are using it would be nice as well. 
//
// This file is provided "as is" with no expressed or implied warranty.
// The author accepts no liability for any damage/loss of business that
// this product may cause.
//
// For use with CGridCtrl v2.20+
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_GRIDCELL_H__519FA702_722C_11D1_ABBA_00A0243D1382__INCLUDED_)
#define AFX_GRIDCELL_H__519FA702_722C_11D1_ABBA_00A0243D1382__INCLUDED_

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

class CGridCtrl;
#include "GridCellBase.h"

// Each cell contains one of these. Fields "row" and "column" are not stored since we
// will usually have acces to them in other ways, and they are an extra 8 bytes per
// cell that is probably unnecessary.

class CGridCell : public CGridCellBase
{
    friend class CGridCtrl;
    DECLARE_DYNCREATE(CGridCell)

// Construction/Destruction
public:
    CGridCell();
    virtual ~CGridCell();

// Attributes
public:
    void operator=(const CGridCell& cell);

    virtual void  SetText(LPCTSTR szText)        { m_strText = szText;  }                       
    virtual void  SetImage(int nImage)           { m_nImage = nImage;   }                        
    virtual void  SetData(LPARAM lParam)         { m_lParam = lParam;   }      
    virtual void  SetGrid(CGridCtrl* pGrid)      { m_pGrid = pGrid;     }                          
    // virtual void SetState(const DWORD nState);  -  use base class version   
    virtual void  SetFormat(DWORD nFormat)       { m_nFormat = nFormat; }                      
    virtual void  SetTextClr(COLORREF clr)       { m_crFgClr = clr;     }                          
    virtual void  SetBackClr(COLORREF clr)       { m_crBkClr = clr;     }                          
    virtual void  SetFont(const LOGFONT* plf);
    virtual void  SetMargin(UINT nMargin)        { m_nMargin = nMargin; }
    virtual CWnd* GetEditWnd() const             { return m_pEditWnd;   }
    virtual void  SetCoords(int /*nRow*/, int /*nCol*/) {}  // don't need to know the row and
                                                            // column for base implementation

    virtual LPCTSTR     GetText() const             { return (m_strText.IsEmpty())? _T("") : LPCTSTR(m_strText); }
    virtual int         GetImage() const            { return m_nImage;  }
    virtual LPARAM      GetData() const             { return m_lParam;  }
    virtual CGridCtrl*  GetGrid() const             { return m_pGrid;   }
    // virtual DWORD    GetState() const - use base class
    virtual DWORD       GetFormat() const;
    virtual COLORREF    GetTextClr() const          { return m_crFgClr; } // TODO: change to use default cell
    virtual COLORREF    GetBackClr() const          { return m_crBkClr; }
    virtual LOGFONT*    GetFont() const;
    virtual CFont*      GetFontObject() const;
    virtual UINT        GetMargin() const;

    virtual BOOL        IsEditing() const           { return m_bEditing; }
    virtual BOOL        IsDefaultFont() const       { return (m_plfFont == NULL); }
    virtual void        Reset();

// editing cells
public:
    virtual BOOL Edit(int nRow, int nCol, CRect rect, CPoint point, UINT nID, UINT nChar);
    virtual void EndEdit();
protected:
    virtual void OnEndEdit();

protected:
    CString    m_strText;      // Cell text (or binary data if you wish...)
    LPARAM     m_lParam;       // 32-bit value to associate with item
    int        m_nImage;       // Index of the list view item’s icon
    DWORD      m_nFormat;
    COLORREF   m_crFgClr;
    COLORREF   m_crBkClr;
    LOGFONT*   m_plfFont;
    UINT       m_nMargin;

    BOOL       m_bEditing;     // Cell being edited?

    CGridCtrl* m_pGrid;        // Parent grid control
    CWnd*      m_pEditWnd;
};

// This class is for storing grid default values. It's a little heavy weight, so
// don't use it in bulk 
class CGridDefaultCell : public CGridCell
{
    DECLARE_DYNCREATE(CGridDefaultCell)

// Construction/Destruction
public:
    CGridDefaultCell();
    virtual ~CGridDefaultCell();

public:
    virtual DWORD GetStyle() const                      { return m_dwStyle;      }
    virtual void  SetStyle(DWORD dwStyle)               { m_dwStyle = dwStyle;   }
    virtual int   GetWidth() const                      { return m_Size.cx;      }
    virtual int   GetHeight() const                     { return m_Size.cy;      }
    virtual void  SetWidth(int nWidth)                  { m_Size.cx = nWidth;    }
    virtual void  SetHeight(int nHeight)                { m_Size.cy = nHeight;   }

    // Disable these properties
    virtual void     SetData(LPARAM /*lParam*/)             { ASSERT(FALSE);         }      
    virtual void     SetState(DWORD /*nState*/)             { ASSERT(FALSE);         }
    virtual DWORD    GetState() const                       { return CGridCell::GetState()|GVIS_READONLY; }
    virtual void     SetCoords( int /*row*/, int /*col*/)   { ASSERT(FALSE);         }
    virtual void     SetFont(const LOGFONT* /*plf*/);
    virtual LOGFONT* GetFont() const;   
    virtual CFont*   GetFontObject() const;

protected:
    CSize m_Size;       // Default Size
    CFont m_Font;       // Cached font
    DWORD m_dwStyle;    // Cell Style - unused
};

//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_GRIDCELL_H__519FA702_722C_11D1_ABBA_00A0243D1382__INCLUDED_)

--- NEW FILE: GridCellNumeric.h ---
// GridCellNumeric.h: interface for the CGridCellNumeric class.
//
// Written by Andrew Truckle [ajt...@ws...]
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_GRIDINTEGERCELL_H__3479ED0D_B57D_4940_B83D_9E2296ED75B5__INCLUDED_)
#define AFX_GRIDINTEGERCELL_H__3479ED0D_B57D_4940_B83D_9E2296ED75B5__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "GridCell.h"

class CGridCellNumeric : public CGridCell  
{
    DECLARE_DYNCREATE(CGridCellNumeric)

public:
    virtual BOOL Edit(int nRow, int nCol, CRect rect, CPoint point, UINT nID, UINT nChar);
    virtual void EndEdit();

};

#endif // !defined(AFX_GRIDINTEGERCELL_H__3479ED0D_B57D_4940_B83D_9E2296ED75B5__INCLUDED_)

--- NEW FILE: CellRange.h ---
///////////////////////////////////////////////////////////////////////
// CellRange.h: header file
//
// MFC Grid Control - interface for the CCellRange class.
//
// Written by Chris Maunder <cma...@ma...>
// Copyright (c) 1998-2002. All Rights Reserved.
//
// This code may be used in compiled form in any way you desire. This
// file may be redistributed unmodified by any means PROVIDING it is 
// not sold for profit without the authors written consent, and 
// providing that this notice and the authors name and all copyright 
// notices remains intact. 
//
// An email letting me know how you are using it would be nice as well. 
//
// This file is provided "as is" with no expressed or implied warranty.
// The author accepts no liability for any damage/loss of business that
// this product may cause.
//
// For use with CGridCtrl v2.20+
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_CELLRANGE_H__F86EF761_725A_11D1_ABBA_00A0243D1382__INCLUDED_)
#define AFX_CELLRANGE_H__F86EF761_725A_11D1_ABBA_00A0243D1382__INCLUDED_

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

// The code contained in this file is based on the original
// WorldCom Grid control written by Joe Willcoxson,
//      mailto:chi...@ao...
//      http://users.aol.com/chinajoe

class CCellID
{    
// Attributes
public:
    int row, col;

// Operations
public:
    explicit CCellID(int nRow = -1, int nCol = -1) : row(nRow), col(nCol) {}

    int IsValid() const { return (row >= 0 && col >= 0); }
    int operator==(const CCellID& rhs) const { return (row == rhs.row && col == rhs.col); }
    int operator!=(const CCellID& rhs) const { return !operator==(rhs); }
};

class CCellRange
{ 
public:
    
    CCellRange(int nMinRow = -1, int nMinCol = -1, int nMaxRow = -1, int nMaxCol = -1)
    {
        Set(nMinRow, nMinCol, nMaxRow, nMaxCol);
    }

    void Set(int nMinRow = -1, int nMinCol = -1, int nMaxRow = -1, int nMaxCol = -1);
    
    int  IsValid() const;
    int  InRange(int row, int col) const;
    int  InRange(const CCellID& cellID) const;
    int  Count() { return (m_nMaxRow - m_nMinRow + 1) * (m_nMaxCol - m_nMinCol + 1); }
    
    CCellID  GetTopLeft() const;
    CCellRange  Intersect(const CCellRange& rhs) const;
    
    int GetMinRow() const {return m_nMinRow;}
    void SetMinRow(int minRow) {m_nMinRow = minRow;}
    
    int GetMinCol() const {return m_nMinCol;}
    void SetMinCol(int minCol) {m_nMinCol = minCol;}
    
    int GetMaxRow() const {return m_nMaxRow;}
    void SetMaxRow(int maxRow) {m_nMaxRow = maxRow;}
    
    int GetMaxCol() const {return m_nMaxCol;}
    void SetMaxCol(int maxCol) {m_nMaxCol = maxCol;}

    int GetRowSpan() const {return m_nMaxRow - m_nMinRow + 1;}
    int GetColSpan() const {return m_nMaxCol - m_nMinCol + 1;}
    
    void operator=(const CCellRange& rhs);
    int  operator==(const CCellRange& rhs);
    int  operator!=(const CCellRange& rhs);
    
protected:
    int m_nMinRow;
    int m_nMinCol;
    int m_nMaxRow;
    int m_nMaxCol;
};

inline void CCellRange::Set(int minRow, int minCol, int maxRow, int maxCol)
{
     m_nMinRow = minRow;
     m_nMinCol = minCol;
     m_nMaxRow = maxRow;
     m_nMaxCol = maxCol;
}

inline void CCellRange::operator=(const CCellRange& rhs)
{
    if (this != &rhs) Set(rhs.m_nMinRow, rhs.m_nMinCol, rhs.m_nMaxRow, rhs.m_nMaxCol);
}

inline int CCellRange::operator==(const CCellRange& rhs)
{
     return ((m_nMinRow == rhs.m_nMinRow) && (m_nMinCol == rhs.m_nMinCol) &&
             (m_nMaxRow == rhs.m_nMaxRow) && (m_nMaxCol == rhs.m_nMaxCol));
}

inline int CCellRange::operator!=(const CCellRange& rhs)
{
     return !operator==(rhs);
}

inline int CCellRange::IsValid() const
{
     return (m_nMinRow >= 0 && m_nMinCol >= 0 && m_nMaxRow >= 0 && m_nMaxCol >= 0 &&
             m_nMinRow <= m_nMaxRow && m_nMinCol <= m_nMaxCol);
}

inline int CCellRange::InRange(int row, int col) const
{
     return (row >= m_nMinRow && row <= m_nMaxRow && col >= m_nMinCol && col <= m_nMaxCol);
}

inline int CCellRange::InRange(const CCellID& cellID) const
{
     return InRange(cellID.row, cellID.col);
}

inline CCellID CCellRange::GetTopLeft() const
{
     return CCellID(m_nMinRow, m_nMinCol);
}

inline CCellRange CCellRange::Intersect(const CCellRange& rhs) const
{
     return CCellRange(max(m_nMinRow,rhs.m_nMinRow), max(m_nMinCol,rhs.m_nMinCol),
                       min(m_nMaxRow,rhs.m_nMaxRow), min(m_nMaxCol,rhs.m_nMaxCol));
}

#endif // !defined(AFX_CELLRANGE_H__F86EF761_725A_11D1_ABBA_00A0243D1382__INCLUDED_)

--- NEW FILE: GridCellBase.cpp ---
// GridCellBase.cpp : implementation file
//
// MFC Grid Control - Main grid cell base class
//
// Provides the implementation for the base cell type of the
// grid control. No data is stored (except for state) but default
// implementations of drawing, printingetc provided. MUST be derived
// from to be used.
//
// Written by Chris Maunder <cma...@ma...>
// Copyright (c) 1998-2002. All Rights Reserved.
//
// This code may be used in compiled form in any way you desire. This
// file may be redistributed unmodified by any means PROVIDING it is 
// not sold for profit without the authors written consent, and 
// providing that this notice and the authors name and all copyright 
// notices remains intact. 
//
// An email letting me know how you are using it would be nice as well. 
//
// This file is provided "as is" with no expressed or implied warranty.
// The author accepts no liability for any damage/loss of business that
// this product may cause.
//
// For use with CGridCtrl v2.22+
//
// History:
// Ken Bertelson - 12 Apr 2000 - Split CGridCell into CGridCell and CGridCellBase
// C Maunder     - 19 May 2000 - Fixed sort arrow drawing (Ivan Ilinov)
// C Maunder     - 29 Aug 2000 - operator= checks for NULL font before setting (Martin Richter)
// C Maunder     - 15 Oct 2000 - GetTextExtent fixed (Martin Richter)
// C Maunder     -  1 Jan 2001 - Added ValidateEdit
// Yogurt        - 13 Mar 2004 - GetCellExtent fixed
//
// NOTES: Each grid cell should take care of it's own drawing, though the Draw()
//        method takes an "erase background" paramter that is called if the grid
//        decides to draw the entire grid background in on hit. Certain ambient
//        properties such as the default font to use, and hints on how to draw
//        fixed cells should be fetched from the parent grid. The grid trusts the
//        cells will behave in a certain way, and the cells trust the grid will
//        supply accurate information.
//        
/////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "GridCtrl.h"
#include "GridCellBase.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

IMPLEMENT_DYNAMIC(CGridCellBase, CObject)

/////////////////////////////////////////////////////////////////////////////
// GridCellBase

CGridCellBase::CGridCellBase()
{
    Reset();
}

CGridCellBase::~CGridCellBase()
{
}

/////////////////////////////////////////////////////////////////////////////
// GridCellBase Operations

void CGridCellBase::Reset()
{
    m_nState  = 0;
}

void CGridCellBase::operator=(const CGridCellBase& cell)
{
	if (this == &cell) return;

    SetGrid(cell.GetGrid());    // do first in case of dependencies

    SetText(cell.GetText());
    SetImage(cell.GetImage());
    SetData(cell.GetData());
    SetState(cell.GetState());
    SetFormat(cell.GetFormat());
    SetTextClr(cell.GetTextClr());
    SetBackClr(cell.GetBackClr());
    SetFont(cell.IsDefaultFont()? NULL : cell.GetFont());
    SetMargin(cell.GetMargin());
}

/////////////////////////////////////////////////////////////////////////////
// CGridCellBase Attributes

// Returns a pointer to a cell that holds default values for this particular type of cell
CGridCellBase* CGridCellBase::GetDefaultCell() const
{
    if (GetGrid())
        return GetGrid()->GetDefaultCell(IsFixedRow(), IsFixedCol());
    return NULL;
}


/////////////////////////////////////////////////////////////////////////////
// CGridCellBase Operations

// EFW - Various changes to make it draw cells better when using alternate
// color schemes.  Also removed printing references as that's now done
// by PrintCell() and fixed the sort marker so that it doesn't draw out
// of bounds.
BOOL CGridCellBase::Draw(CDC* pDC, int nRow, int nCol, CRect rect,  BOOL bEraseBkgnd /*=TRUE*/)
{
    // Note - all through this function we totally brutalise 'rect'. Do not
    // depend on it's value being that which was passed in.

    CGridCtrl* pGrid = GetGrid();
    ASSERT(pGrid);

    if (!pGrid || !pDC)
        return FALSE;

    if( rect.Width() <= 0 || rect.Height() <= 0)  // prevents imagelist item from drawing even
        return FALSE;                             //  though cell is hidden

    //TRACE3("Drawing %scell %d, %d\n", IsFixed()? _T("Fixed ") : _T(""), nRow, nCol);

    int nSavedDC = pDC->SaveDC();
    pDC->SetBkMode(TRANSPARENT);

    // Get the default cell implementation for this kind of cell. We use it if this cell
    // has anything marked as "default"
    CGridDefaultCell *pDefaultCell = (CGridDefaultCell*) GetDefaultCell();
    if (!pDefaultCell)
        return FALSE;

    // Set up text and background colours
    COLORREF TextClr, TextBkClr;

    TextClr = (GetTextClr() == CLR_DEFAULT)? pDefaultCell->GetTextClr() : GetTextClr();
    if (GetBackClr() == CLR_DEFAULT)
        TextBkClr = pDefaultCell->GetBackClr();
    else
    {
        bEraseBkgnd = TRUE;
        TextBkClr = GetBackClr();
    }

    // Draw cell background and highlighting (if necessary)
    if ( IsFocused() || IsDropHighlighted() )
    {
        // Always draw even in list mode so that we can tell where the
        // cursor is at.  Use the highlight colors though.
        if(GetState() & GVIS_SELECTED)
        {
            TextBkClr = ::GetSysColor(COLOR_HIGHLIGHT);
            TextClr = ::GetSysColor(COLOR_HIGHLIGHTTEXT);
            bEraseBkgnd = TRUE;
        }

        rect.right++; rect.bottom++;    // FillRect doesn't draw RHS or bottom
        if (bEraseBkgnd)
        {
            TRY 
            {
                CBrush brush(TextBkClr);
                pDC->FillRect(rect, &brush);
            } 
            CATCH(CResourceException, e)
            {
                //e->ReportError();
            }
            END_CATCH
        }

        // Don't adjust frame rect if no grid lines so that the
        // whole cell is enclosed.
        if(pGrid->GetGridLines() != GVL_NONE)
        {
            rect.right--;
            rect.bottom--;
        }

        if (pGrid->GetFrameFocusCell())
        {
            // Use same color as text to outline the cell so that it shows
            // up if the background is black.
            TRY 
            {
                CBrush brush(TextClr);
                pDC->FrameRect(rect, &brush);
            }
            CATCH(CResourceException, e)
            {
                //e->ReportError();
            }
            END_CATCH
        }
        pDC->SetTextColor(TextClr);

        // Adjust rect after frame draw if no grid lines
        if(pGrid->GetGridLines() == GVL_NONE)
        {
            rect.right--;
            rect.bottom--;
        }

        //rect.DeflateRect(0,1,1,1);  - Removed by Yogurt
    }
    else if ((GetState() & GVIS_SELECTED))
    {
        rect.right++; rect.bottom++;    // FillRect doesn't draw RHS or bottom
        pDC->FillSolidRect(rect, ::GetSysColor(COLOR_HIGHLIGHT));
        rect.right--; rect.bottom--;
        pDC->SetTextColor(::GetSysColor(COLOR_HIGHLIGHTTEXT));
    }
    else
    {
        if (bEraseBkgnd)
        {
            rect.right++; rect.bottom++;    // FillRect doesn't draw RHS or bottom
            CBrush brush(TextBkClr);
            pDC->FillRect(rect, &brush);
            rect.right--; rect.bottom--;
        }
        pDC->SetTextColor(TextClr);
    }

    // Draw lines only when wanted
    if (IsFixed() && pGrid->GetGridLines() != GVL_NONE)
    {
        CCellID FocusCell = pGrid->GetFocusCell();

        // As above, always show current location even in list mode so
        // that we know where the cursor is at.
        BOOL bHiliteFixed = pGrid->GetTrackFocusCell() && pGrid->IsValid(FocusCell) &&
            (FocusCell.row == nRow || FocusCell.col == nCol);

        // If this fixed cell is on the same row/col as the focus cell,
        // highlight it.
        if (bHiliteFixed)
        {
            rect.right++; rect.bottom++;
            pDC->DrawEdge(rect, BDR_SUNKENINNER /*EDGE_RAISED*/, BF_RECT);
            rect.DeflateRect(1,1);
        }
        else
        {
            CPen lightpen(PS_SOLID, 1,  ::GetSysColor(COLOR_3DHIGHLIGHT)),
                darkpen(PS_SOLID,  1, ::GetSysColor(COLOR_3DDKSHADOW)),
                *pOldPen = pDC->GetCurrentPen();

            pDC->SelectObject(&lightpen);
            pDC->MoveTo(rect.right, rect.top);
            pDC->LineTo(rect.left, rect.top);
            pDC->LineTo(rect.left, rect.bottom);

            pDC->SelectObject(&darkpen);
            pDC->MoveTo(rect.right, rect.top);
            pDC->LineTo(rect.right, rect.bottom);
            pDC->LineTo(rect.left, rect.bottom);

            pDC->SelectObject(pOldPen);
            rect.DeflateRect(1,1);
        }
    }

    // Draw Text and image
#if !defined(_WIN32_WCE_NO_PRINTING) && !defined(GRIDCONTROL_NO_PRINTING)
    if (!pDC->m_bPrinting)
#endif
    {
        CFont *pFont = GetFontObject();
        ASSERT(pFont);
        if (pFont)
            pDC->SelectObject(pFont);
    }

    //rect.DeflateRect(GetMargin(), 0); - changed by Yogurt
    rect.DeflateRect(GetMargin(), GetMargin());    
    rect.right++;
    rect.bottom++;

    if (pGrid->GetImageList() && GetImage() >= 0)
    {
        IMAGEINFO Info;
        if (pGrid->GetImageList()->GetImageInfo(GetImage(), &Info))
        {
            //  would like to use a clipping region but seems to have issue
            //  working with CMemDC directly.  Instead, don't display image
            //  if any part of it cut-off
            //
            // CRgn rgn;
            // rgn.CreateRectRgnIndirect(rect);
            // pDC->SelectClipRgn(&rgn);
            // rgn.DeleteObject();

            /*
            // removed by Yogurt
            int nImageWidth = Info.rcImage.right-Info.rcImage.left+1;
            int nImageHeight = Info.rcImage.bottom-Info.rcImage.top+1;
            if( nImageWidth + rect.left <= rect.right + (int)(2*GetMargin())
                && nImageHeight + rect.top <= rect.bottom + (int)(2*GetMargin())  )
            {
                pGrid->GetImageList()->Draw(pDC, GetImage(), rect.TopLeft(), ILD_NORMAL);
            }
            */
            // Added by Yogurt
            int nImageWidth = Info.rcImage.right-Info.rcImage.left;            
            int nImageHeight = Info.rcImage.bottom-Info.rcImage.top;            
            if ((nImageWidth + rect.left <= rect.right) && (nImageHeight + rect.top <= rect.bottom))                
                pGrid->GetImageList()->Draw(pDC, GetImage(), rect.TopLeft(), ILD_NORMAL);

            //rect.left += nImageWidth+GetMargin();
        }
    }

    // Draw sort arrow
    if (pGrid->GetSortColumn() == nCol && nRow == 0)
    {
        CSize size = pDC->GetTextExtent(_T("M"));
        int nOffset = 2;

        // Base the size of the triangle on the smaller of the column
        // height or text height with a slight offset top and bottom.
        // Otherwise, it can get drawn outside the bounds of the cell.
        size.cy -= (nOffset * 2);

        if (size.cy >= rect.Height())
            size.cy = rect.Height() - (nOffset * 2);

        size.cx = size.cy;      // Make the dimensions square

        // Kludge for vertical text
        BOOL bVertical = (GetFont()->lfEscapement == 900);

        // Only draw if it'll fit!
        //if (size.cx + rect.left < rect.right + (int)(2*GetMargin())) - changed / Yogurt
        if (size.cx + rect.left < rect.right)
        {
            int nTriangleBase = rect.bottom - nOffset - size.cy;    // Triangle bottom right
            //int nTriangleBase = (rect.top + rect.bottom - size.cy)/2; // Triangle middle right
            //int nTriangleBase = rect.top + nOffset;                 // Triangle top right

            //int nTriangleLeft = rect.right - size.cx;                 // Triangle RHS
            //int nTriangleLeft = (rect.right + rect.left - size.cx)/2; // Triangle middle
            //int nTriangleLeft = rect.left;                            // Triangle LHS

            int nTriangleLeft;
            if (bVertical)
                nTriangleLeft = (rect.right + rect.left - size.cx)/2; // Triangle middle
            else
                nTriangleLeft = rect.right - size.cx;               // Triangle RHS

            CPen penShadow(PS_SOLID, 0, ::GetSysColor(COLOR_3DSHADOW));
            CPen penLight(PS_SOLID, 0, ::GetSysColor(COLOR_3DHILIGHT));
            if (pGrid->GetSortAscending())
            {
                // Draw triangle pointing upwards
                CPen *pOldPen = (CPen*) pDC->SelectObject(&penLight);
                pDC->MoveTo( nTriangleLeft + 1, nTriangleBase + size.cy + 1);
                pDC->LineTo( nTriangleLeft + (size.cx / 2) + 1, nTriangleBase + 1 );
                pDC->LineTo( nTriangleLeft + size.cx + 1, nTriangleBase + size.cy + 1);
                pDC->LineTo( nTriangleLeft + 1, nTriangleBase + size.cy + 1);

                pDC->SelectObject(&penShadow);
                pDC->MoveTo( nTriangleLeft, nTriangleBase + size.cy );
                pDC->LineTo( nTriangleLeft + (size.cx / 2), nTriangleBase );
                pDC->LineTo( nTriangleLeft + size.cx, nTriangleBase + size.cy );
                pDC->LineTo( nTriangleLeft, nTriangleBase + size.cy );
                pDC->SelectObject(pOldPen);
            }
            else
            {
                // Draw triangle pointing downwards
                CPen *pOldPen = (CPen*) pDC->SelectObject(&penLight);
                pDC->MoveTo( nTriangleLeft + 1, nTriangleBase + 1 );
                pDC->LineTo( nTriangleLeft + (size.cx / 2) + 1, nTriangleBase + size.cy + 1 );
                pDC->LineTo( nTriangleLeft + size.cx + 1, nTriangleBase + 1 );
                pDC->LineTo( nTriangleLeft + 1, nTriangleBase + 1 );
    
                pDC->SelectObject(&penShadow);
                pDC->MoveTo( nTriangleLeft, nTriangleBase );
                pDC->LineTo( nTriangleLeft + (size.cx / 2), nTriangleBase + size.cy );
                pDC->LineTo( nTriangleLeft + size.cx, nTriangleBase );
                pDC->LineTo( nTriangleLeft, nTriangleBase );
                pDC->SelectObject(pOldPen);
            }
            
            if (!bVertical)
                rect.right -= size.cy;
        }
    }

    // We want to see '&' characters so use DT_NOPREFIX
    GetTextRect(rect);
    rect.right++;    
    rect.bottom++;

    DrawText(pDC->m_hDC, GetText(), -1, rect, GetFormat() | DT_NOPREFIX);

    pDC->RestoreDC(nSavedDC);

    return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// CGridCellBase Mouse and Cursor events

// Not yet implemented
void CGridCellBase::OnMouseEnter()
{
    TRACE0("Mouse entered cell\n");
}

void CGridCellBase::OnMouseOver()
{
    //TRACE0("Mouse over cell\n");
}

// Not Yet Implemented
void CGridCellBase::OnMouseLeave()
{
    TRACE0("Mouse left cell\n");
}

void CGridCellBase::OnClick( CPoint PointCellRelative)
{
    UNUSED_ALWAYS(PointCellRelative);
    TRACE2("Mouse Left btn up in cell at x=%i y=%i\n", PointCellRelative.x, PointCellRelative.y);
}

void CGridCellBase::OnClickDown( CPoint PointCellRelative)
{
    UNUSED_ALWAYS(PointCellRelative);
    TRACE2("Mouse Left btn down in cell at x=%i y=%i\n", PointCellRelative.x, PointCellRelative.y);
}

void CGridCellBase::OnRClick( CPoint PointCellRelative)
{
    UNUSED_ALWAYS(PointCellRelative);
    TRACE2("Mouse right-clicked in cell at x=%i y=%i\n", PointCellRelative.x, PointCellRelative.y);
}

void CGridCellBase::OnDblClick( CPoint PointCellRelative)
{
    UNUSED_ALWAYS(PointCellRelative);
    TRACE2("Mouse double-clicked in cell at x=%i y=%i\n", PointCellRelative.x, PointCellRelative.y);
}

// Return TRUE if you set the cursor
BOOL CGridCellBase::OnSetCursor()
{
#ifndef _WIN32_WCE_NO_CURSOR
    SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
#endif
    return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// CGridCellBase editing

void CGridCellBase::OnEndEdit() 
{
	ASSERT( FALSE); 
}

BOOL CGridCellBase::ValidateEdit(LPCTSTR str)
{
    UNUSED_ALWAYS(str);
	return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// CGridCellBase Sizing

BOOL CGridCellBase::GetTextRect( LPRECT pRect)  // i/o:  i=dims of cell rect; o=dims of text rect
{
    if (GetImage() >= 0)
    {
        IMAGEINFO Info;

        CGridCtrl* pGrid = GetGrid();
        CImageList* pImageList = pGrid->GetImageList();
        
        if (pImageList && pImageList->GetImageInfo( GetImage(), &Info))
        {
            int nImageWidth = Info.rcImage.right-Info.rcImage.left; //+1;
            pRect->left += nImageWidth + GetMargin();
        }
    }

    return TRUE;
}

// By default this uses the selected font (which is a bigger font)
CSize CGridCellBase::GetTextExtent(LPCTSTR szText, CDC* pDC /*= NULL*/)
{
    CGridCtrl* pGrid = GetGrid();
    ASSERT(pGrid);

    BOOL bReleaseDC = FALSE;
    if (pDC == NULL || szText == NULL)
    {
        if (szText)
            pDC = pGrid->GetDC();
        if (pDC == NULL || szText == NULL) 
        {
            CGridDefaultCell* pDefCell = (CGridDefaultCell*) GetDefaultCell();
            ASSERT(pDefCell);
            return CSize(pDefCell->GetWidth(), pDefCell->GetHeight());
        }
        bReleaseDC = TRUE;
    }

    CFont *pOldFont = NULL,
        *pFont = GetFontObject();
    if (pFont)
        pOldFont = pDC->SelectObject(pFont);

    CSize size;
    int nFormat = GetFormat();

    // If the cell is a multiline cell, then use the width of the cell
    // to get the height
    if ((nFormat & DT_WORDBREAK) && !(nFormat & DT_SINGLELINE))
    {
        CString str = szText;
        int nMaxWidth = 0;
        while (TRUE)
        {
            int nPos = str.Find(_T('\n'));
            CString TempStr = (nPos < 0)? str : str.Left(nPos);
            int nTempWidth = pDC->GetTextExtent(TempStr).cx;
            if (nTempWidth > nMaxWidth)
                nMaxWidth = nTempWidth;

            if (nPos < 0)
                break;
            str = str.Mid(nPos + 1);    // Bug fix by Thomas Steinborn
        }
        
        CRect rect;
        rect.SetRect(0,0, nMaxWidth+1, 0);
        pDC->DrawText(szText, -1, rect, nFormat | DT_CALCRECT);
        size = rect.Size();
    }
    else
        size = pDC->GetTextExtent(szText, _tcslen(szText));

    // Removed by Yogurt
    //TEXTMETRIC tm;
    //pDC->GetTextMetrics(&tm);
    //size.cx += (tm.tmOverhang);

    if (pOldFont)
        pDC->SelectObject(pOldFont);
    
    size += CSize(2*GetMargin(), 2*GetMargin());

    // Kludge for vertical text
    LOGFONT *pLF = GetFont();
    if (pLF->lfEscapement == 900 || pLF->lfEscapement == -900)
    {
        int nTemp = size.cx;
        size.cx = size.cy;
        size.cy = nTemp;
        size += CSize(0, 4*GetMargin());
    }
    
    if (bReleaseDC)
        pGrid->ReleaseDC(pDC);

    return size;
}


CSize CGridCellBase::GetCellExtent(CDC* pDC)
{    
    CSize size = GetTextExtent(GetText(), pDC);    
    CSize ImageSize(0...
 
[truncated message content]

Update of /cvsroot/perl-win32-gui/Win32-GUI-Grid
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15861

Added Files:
	Changes Grid.pm Grid.xs MANIFEST Makefile.PL README TYPEMAP 
Log Message:
Added to repository

--- NEW FILE: Makefile.PL ---
use ExtUtils::MakeMaker;
# See lib/ExtUtils/MakeMaker.pm for details of how to influence
# the contents of the Makefile that is written.

WriteMakefile(
    'NAME'         => 'Win32::GUI::Grid',
    'VERSION_FROM' => 'Grid.pm',
    'XS'           => { 'Grid.xs' => 'Grid.cpp' },
    'LIBS'         => ['Comctl32.lib Mfc42.lib Eafxis.lib'],   # e.g., '-lm'
    'DEFINE'       => '',     # e.g., '-DHAVE_SOMETHING'
    'INC'          => '',     # e.g., '-I/usr/include/other'
    'MYEXTLIB'     => './MFCGrid/Lib/MFCGrid.lib',
     ($] ge '5.005')
     ? (
      'AUTHOR'   => 'ROCHER Laurent (lr...@cp...)',
      'ABSTRACT' => 'Add a Grid control to Win32::GUI (MFC Grid from CodeProject.com)',
     )
     : (),
);


sub MY::xs_c {
'

.xs.c:
    $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.c

.xs.cpp:
    $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.cpp

./MFCGrid/Lib/MFCGrid.lib: MFCGrid/makefile
    cd MFCGrid
    nmake
    cd ..

';
}


--- NEW FILE: MANIFEST ---
Makefile.PL
Changes
Grid.pm
Grid.xs
MANIFEST
TYPEMAP
MFCGrid/Makefile
--- NEW FILE: Grid.xs ---
/**********************************************************************/
/*                          G R I D . x s                             */
/**********************************************************************/

//////////////////////////////////////////////////////////////////////
// Include
//////////////////////////////////////////////////////////////////////

//
// MFC
//

#define _AFX_NOFORCE_LIBS // not force library
#define _WINDLL         // Windows DLL
#define _USRDLL         //
#define _AFXDLL         // Use shared MFC
#define VC_EXTRALEAN    // Exclude rarely-used stuff from Windows headers

#include <afxwin.h>     // MFC core and standard components
[...3241 lines suppressed...]
      object->m_SvSub = NULL;
      object->SetCompareFunction(NULL);
    }
    else if (nCol < object->GetColumnCount()) {
      pFun = (SV*) object->m_RowSortFunc.GetAt (nCol);
      if (pFun != NULL) {
        SvREFCNT_dec (pFun);
        object->m_RowSortFunc.SetAtGrow(nCol, NULL);
      }
    }
  }

  # // in-built sort functions
  # static int CALLBACK pfnCellTextCompare(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort);
  # static int CALLBACK pfnCellNumericCompare(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort);

  #
  #
  ##################################################################


--- NEW FILE: Grid.pm ---
package Win32::GUI::Grid;

use strict;
use vars qw($VERSION @ISA @EXPORT @EXPORT_OK $AUTOLOAD);
use Carp 'croak','carp';
use Win32::GUI;

require Exporter;
require DynaLoader;
require AutoLoader;

@ISA = qw(Exporter DynaLoader Win32::GUI::Window);
# Items to export into callers namespace by default. Note: do not export
# names by default without a very good reason. Use EXPORT_OK instead.
# Do not simply export all your public functions/methods/constants.

@EXPORT = qw (
  GVL_NONE
  GVL_HORZ
[...1199 lines suppressed...]
=item C<_GetData> (nRow, nCol)

  [virtual Mode Only]
  Must return data cell.

=item C<_CacheHint> (nMinRow, nMinCol, nMaxRow, nMaxCol)

  [virtual Mode Only]
  Range before request data.

=head1 AUTHOR

  Laurent Rocher (lr...@cp...)
  HomePage : http://perso.club-internet.fr/rocherl/Win32GUI.html

=head1 SEE ALSO

Win32::GUI

=cut

--- NEW FILE: README ---
Win32::GUI::Grid version 0.07
=============================

Win32::GUI::Grid add a grid control to Win32::GUI.

This module use MFC Grid control By Chris Maunder.
Url : http://www.codeproject.com/miscctrl/gridctrl.asp
(Modified sources code include)

INSTALLATION

To install this module type the following:

   perl Makefile.PL
   make
   make install

DEPENDENCIES

This module requires these other modules and libraries:

   Win32::GUI
   Microsoft Foudation Classes (MFC)

WEB PAGE AND PPM REPOSITORY

See: http://perso.club-internet.fr/rocherl/Win32GUI.html

COPYRIGHT AND LICENCE

Copyright 2003 by Laurent Rocher (lr...@cp...).

This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.

See <http://www.perl.com/perl/misc/Artistic.html>.

--- NEW FILE: Changes ---

Revision history for Perl extension Win32::GUI::Grid.

0.07  14/02/2004
        - Use MFC Grid control 2.25
        - Correct EnsureCellVisible methods ( bad name in XS, but keep EnsureVisible for compatibility)
        - Fix locale setting problem.

0.06  14/02/2004
        - Fix Clipboard error (Ctrl+C) [Thank to Andrew St. Denis]
        - Fix some Grid draw problem
        - Add WM_PRINTCLIENT support for new Win32::GUI -noflicker option.
        - New Cell Type (Calendar, URL)
        - SetCellOptions : New options

0.05  07/09/2003
        - Add SetCellEditable method.
        - Add List cell editing.
        - New event _ChangedEdit for COMBO and LIST edit control when select change in list.

0.04  07/08/2003
        - Correct -heigth option.
        - In InsertColumn, set last parameter optional.
        - Add Column Perl Sort method.

0.03  03/06/2003
        - Correct Abnormal terminaison when multiple grid instance

0.02  03/06/2003
        - Correct crash when destroy grid during cell edit.
        - Virtual Mode support.
        - New cell editing support.
            + Numeric
            + Date
            + Time
            + Check
            + Combo
        - Add Perl Sort method.

0.01  28/05/2003
        - First build Win32::GUI::Grid
        - Use MFC Grid control 2.24

TODO
   - Printing support (???)

--- NEW FILE: TYPEMAP ---
TYPEMAP
LPCTSTR                   T_PV
LPCSTR                    T_PV
LPTSTR                    T_PV
DWORD                     T_IV
UINT                      T_IV
BOOL                      T_IV
HBITMAP                   T_HANDLE
HDC                       T_HANDLE
HFONT                     T_HANDLE
HIMAGELIST                T_HANDLE
HWND                      T_HANDLE
CMFCWnd*                  T_MFCWND
COLORREF                  T_COLOR

################################################################################
INPUT
T_HANDLE
    if(SvROK($arg)) {
        if(hv_fetch((HV*)SvRV($arg), \"-handle\", 7, 0) != NULL)
            $var = ($type) SvIV(*(hv_fetch((HV*)SvRV($arg), \"-handle\", 7, 0)));
        else
            $var = NULL;
    } else
        $var = ($type) SvIV($arg);

T_MFCWND
    $var = ($type) SvIV(*(hv_fetch((HV*)SvRV($arg), \"-CMFCWnd\", 8, 0)));

T_COLOR
    $var = SvCOLORREF(aTHX_ $arg);

################################################################################
OUTPUT
T_HANDLE
    sv_setiv($arg, (IV) $var);
T_COLOR
    sv_setiv($arg, (IV) $var);

Update of /cvsroot/perl-win32-gui/Win32-GUI-Grid/samples
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15861/samples

Added Files:
	one.bmp test1.pl test2.pl test3.pl test4.pl test5.pl test6.pl 
	three.bmp two.bmp 
Log Message:
Added to repository

--- NEW FILE: test5.pl ---
#! perl -w
#
# - Custom Cell Type
# - Sort function
#
use strict;
use Win32::GUI;
use Win32::GUI::Grid;

# main Window
my $Window = new Win32::GUI::Window (
    -title    => "Win32::GUI::Grid test 5",
    -pos     => [100, 100],
    -size    => [400, 400],
    -name     => "Window",
) or die "new Window";

# Grid Window
my $Grid = new Win32::GUI::Grid (
    -parent  => $Window,
    -name    => "Grid",
    -pos     => [0, 0],
) or die "new Grid";

# Grid cell base
$Grid->SetDefCellType(GVIT_NUMERIC);  # Preset Cell type before cell creation

# Init Grid
$Grid->SetEditable(1);
$Grid->SetRows(10);
$Grid->SetColumns(10);
$Grid->SetFixedRows(1);
$Grid->SetFixedColumns(1);

# Fill Grid
for my $row (0..$Grid->GetRows()) {
  for my $col (0..$Grid->GetColumns()) {
    if ($row == 0) {
      $Grid->SetCellText($row, $col,"Column : $col");
    }
    elsif ($col == 0) {
      $Grid->SetCellText($row, $col, "Row : $row");
    }
    else {
      # $Grid->SetCellType($row, $col, GVIT_NUMERIC);  # Set cell type after creation.
      $Grid->SetCellText($row, $col, $row*$col);
    }
  }
}

# Set Date edit control in cell (1,1)
$Grid->SetCellText(1, 1, "");
$Grid->SetCellType(1, 1, GVIT_DATE);

# Set Date edit control in cell (1,1)
$Grid->SetCellText(2, 1, "");
$Grid->SetCellType(2, 1, GVIT_DATECAL);

# Set Time edit control in cell (1,2)
$Grid->SetCellText(1, 2, "");
$Grid->SetCellType(1, 2, GVIT_TIME);

# Set Check edit control in cell (1,3)
$Grid->SetCellText(1, 3, "");
$Grid->SetCellType(1, 3, GVIT_CHECK);
$Grid->SetCellCheck(1, 3, 1);
print "Cell Check : ", $Grid->GetCellCheck(1, 3), "\n";

# Set Combobox edit control in cell (1,4)
$Grid->SetCellText(1, 4, "");
$Grid->SetCellType(1, 4, GVIT_COMBO);
$Grid->SetCellOptions(1, 4, ["Option 1", "Option 2", "Option 3"]);

# Set Listbox control in cell (1,5)
$Grid->SetCellText(1, 5, "");
$Grid->SetCellType(1, 5, GVIT_LIST);
$Grid->SetCellOptions(1, 5, ["Option 1", "Option 2", "Option 3"]);

# Set Url control in cell (1,6)
$Grid->SetCellText(1, 6, "www.perl.com");
$Grid->SetCellType(1, 6, GVIT_URL);
$Grid->SetCellOptions(1, 6, -autolaunch => 0);

# Set Url control in cell (2,6)
$Grid->SetCellText(2, 6, "www.perl.com");
$Grid->SetCellType(2, 6, GVIT_URL);
# Set uneditable cell (2,6)
$Grid->SetCellEditable(2, 6, 0);

# Sort Numeric reverse order  (Method 1)
# $Grid->SortNumericCells(5, 0);
# Sort Numeric reverse order (Method 2)
# $Grid->SortCells(5, 0, sub { my ($e1, $e2) = @_; return (int($e1) - int ($e2)); } );
# Sort Numeric reverse order (Method 3)
# $Grid->SetSortFunction (sub { my ($e1, $e2) = @_; return (int($e1) - int ($e2)); } );
# $Grid->SortCells(7, 0);
# $Grid->SetSortFunction (); # remove sort method

# Resize Grid Cell
$Grid->AutoSize();

# Event loop
$Window->Show();
Win32::GUI::Dialog();

# Main window event handler
sub Window_Terminate {

  return -1;
}

sub Window_Resize {

  my ($width, $height) = ($Window->GetClientRect)[2..3];
  $Grid->Resize ($width, $height);
}

sub Grid_BeginEdit {
  my ($col, $row) = @_;
  print "Begin Edit ($col, $row)\n";
}

sub Grid_ChangedEdit {
  my ($col, $row, $str) = @_;
  print "Changed Edit ($col, $row, $str)\n";
}

sub Grid_EndEdit {
  my ($col, $row) = @_;
  print "End Edit ($col, $row)\n";
}

--- NEW FILE: two.bmp ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: test3.pl ---
#! perl -w
# 
# Test Grid method
#   - Default cell setting
#   - font method
#
use strict;
use Win32::GUI;
use Win32::GUI::Grid;

# main Window
my $Window = new Win32::GUI::Window (
    -title    => "Win32::GUI::Grid test 3",
    -pos     => [100, 100],
    -size    => [400, 400],
    -name     => "Window",
) or die "new Window";

# Grid Window
my $Grid = $Window->AddGrid (
    -name    => "Grid",
    -pos     => [0, 0],
) or die "new Grid";

# Image list
my $IL = new Win32::GUI::ImageList(16, 16, 24, 3, 10);
$IL->Add("one.bmp");
$IL->Add("two.bmp");
$IL->Add("three.bmp");

# Attach ImageList to grid
$Grid->SetImageList($IL);

# Set default cell style
$Grid->SetDefCellTextColor(0,0, '#FF0000');
$Grid->SetDefCellTextColor(1,0, '#00FF00');
$Grid->SetDefCellTextColor(0,1, '#0000FF');

$Grid->SetDefCellBackColor(0,0, '#0000FF');
$Grid->SetDefCellBackColor(1,0, '#FF0000');
$Grid->SetDefCellBackColor(0,1, '#00FF00');

$Grid->SetDefCellFormat(0, 0, DT_RIGHT|DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS|DT_NOPREFIX);
$Grid->SetDefCellFormat(0, 1, DT_RIGHT|DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS|DT_NOPREFIX);
$Grid->SetDefCellFormat(1, 0, DT_LEFT|DT_WORDBREAK);

# Change default font
my %font = $Grid->GetDefCellFont(0,0);
$font {-bold} = 1;
$font {-height} = 10;
$Grid->SetDefCellFont(0,0, %font);

# Create Cells after set default style. (required for format ONLY)
$Grid->SetRows(50);
$Grid->SetColumns(10);
$Grid->SetFixedRows(1);
$Grid->SetFixedColumns(1);

# Fill Grid
for my $row (0..$Grid->GetRows()) {
  for my $col (0..$Grid->GetColumns()) {
    if ($row == 0) {
      $Grid->SetCellText($row, $col,"Column : $col");
      $Grid->SetCellImage($row, $col, 0); # Add bitmap
    }
    elsif ($col == 0) {
      $Grid->SetCellText($row, $col, "Row : $row");
      $Grid->SetCellImage($row, $col, 1); # Add bitmap
    }
    else {
      $Grid->SetCellText($row, $col, "Cell : ($row,$col)");
      $Grid->SetCellImage($row, $col, 2); # Add bitmap
    }
  }
}

# Set Cell font
$Grid->SetCellFont(0, 0, -name   => 'Arial' ,
                         -size => 12,
                         -italic => 1,
                         -bold => 1);

# Set font from a Win32::GUI::Font
my $F = new Win32::GUI::Font(
        -name => "MS Sans Serif",
        -size => 10,
        -bold => 1,
);
$Grid->SetCellFont(0, 1, $F->Info());

# Resize Grid Cell
$Grid->AutoSize();

# Event loop
$Window->Show();
Win32::GUI::Dialog();

# Main window event handler
sub Window_Terminate {

  return -1;
}

sub Window_Resize {
  my ($width, $height) = ($Window->GetClientRect)[2..3];
  $Grid->Resize ($width, $height);
}

sub Grid_Click {

 my ($row, $col) = @_;

 # Get font information
 print "\nFont for cell ($row, $col) :\n";
 my %font = $Grid->GetCellFont($row, $col);
 for my $key (keys %font) {
   print $key, " => ", $font{$key}, "\n";
 }

}

--- NEW FILE: test2.pl ---
#! perl -w
# 
# Test Grid method
#   - create option
#   - Color method
#   - ImageList support
#   - Event
#   - POINT, RECT method.

use strict;
use Win32::GUI;
use Win32::GUI::Grid;

# main Window
my $Window = new Win32::GUI::Window (
    -title    => "Win32::GUI::Grid test 2",
    -pos     => [100, 100],
    -size    => [400, 400],
    -name     => "Window",
) or die "new Window";

# Grid Window
my $Grid = $Window->AddGrid (
    -name    => "Grid",
    -pos     => [0, 0],
    -rows    => 50,
    -columns => 10,
    -fixedrows    => 1,
    -fixedcolumns => 1,
    -editable => 1,
) or die "new Grid";

# Image list
my $IL = new Win32::GUI::ImageList(16, 16, 24, 3, 10);
$IL->Add("one.bmp");
$IL->Add("two.bmp");
$IL->Add("three.bmp");

# Attach ImageList to grid
$Grid->SetImageList($IL);

# Change some color (different color format)
$Grid->SetGridBkColor([66,66,66]);
$Grid->SetGridLineColor('#0000ff');
$Grid->SetTitleTipBackClr('#00ff00');
$Grid->SetDefCellTextColor(0,0, 0x9F9F9F);
$Grid->SetDefCellBackColor(0,0, 0x003300);

# Some test
my ($x, $y) = $Grid->GetCellOrigin(1, 1);
print "CellOrigine(1,1) = ($x, $y)\n";
my ($left, $top, $right, $bottom) = $Grid->GetCellRect(1,1);
print "GetCellRect(1,1) ($left, $top, $right, $bottom)\n";
($left, $top, $right, $bottom) = $Grid->GetTextRect(1,1);
print "GetTextRect(1,1) ($left, $top, $right, $bottom)\n";
($x, $y) = $Grid->GetCellFromPt(85, 50);
print "GetCellFromPt(85,50) = ($x, $y)\n";

# Fill Grid
for my $row (0..$Grid->GetRows()) {
  for my $col (0..$Grid->GetColumns()) {
    if ($row == 0) {
      $Grid->SetCellFormat($row, $col, DT_LEFT|DT_WORDBREAK);
      $Grid->SetCellText($row, $col,"Column : $col");
      $Grid->SetCellImage($row, $col, 0); # Add bitmap
    }
    elsif ($col == 0) {
      $Grid->SetCellFormat($row, $col, DT_RIGHT|DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS|DT_NOPREFIX);
      $Grid->SetCellText($row, $col, "Row : $row");
      $Grid->SetCellImage($row, $col, 1); # Add bitmap
    }
    else {
      $Grid->SetCellFormat($row, $col, DT_RIGHT|DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS|DT_NOPREFIX);
      $Grid->SetCellText($row, $col, "Cell : ($row,$col)");
      $Grid->SetCellImage($row, $col, 2); # Add bitmap
    }
  }
}
# Resize Grid Cell
$Grid->AutoSize();

# Some test
($x, $y) = $Grid->GetCellOrigin(1, 1);
print "CellOrigine(1,1) = ($x, $y)\n";
($left, $top, $right, $bottom) =  $Grid->GetCellRect(1,1);
print "GetCellRect(1,1) ($left, $top, $right, $bottom)\n";
($left, $top, $right, $bottom) = $Grid->GetTextRect(1,1);
print "GetTextRect(1,1) ($left, $top, $right, $bottom)\n";
($x, $y) = $Grid->GetCellFromPt(85, 50);
print "GetCellFromPt(85,50) = ($x, $y)\n";

# Event loop
$Window->Show();
Win32::GUI::Dialog();

# Main window event handler
sub Window_Terminate {

  return -1;
}

sub Window_Resize {
  my ($width, $height) = ($Window->GetClientRect)[2..3];
  $Grid->Resize ($width, $height);
}

sub Grid_Click {
  my ($col, $row) = @_;
  print "Click ($col, $row)\n";
}
sub Grid_RClick {
  my ($col, $row) = @_;
  print "Right Click ($col, $row)\n";
}
sub Grid_DblClick {
  my ($col, $row) = @_;
  print "Double Click ($col, $row)\n";
}
sub Grid_Changing {
  my ($col, $row) = @_;
  print "Selection Changing ($col, $row)\n";
}
sub Grid_Changed {
  my ($col, $row) = @_;
  print "Selection Changed ($col, $row)\n";
}
sub Grid_BeginEdit {
  my ($col, $row) = @_;
  print "Begin Edit ($col, $row)\n";
}
sub Grid_EndEdit {
  my ($col, $row) = @_;
  print "End Edit ($col, $row)\n";
}
sub Grid_BeginDrag {
  my ($col, $row) = @_;
  print "Begin Drag ($col, $row)\n";
}

--- NEW FILE: one.bmp ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: test4.pl ---
#! perl -w
#
# Test Grid method
#   - Virtual mode
#   - EndEdit event in virtual mode
#
use strict;
use Win32::GUI;
use Win32::GUI::Grid;

# main Window
my $Window = new Win32::GUI::Window (
    -title    => "Win32::GUI::Grid test 4",
    -pos     => [100, 100],
    -size    => [400, 400],
    -name     => "Window",
) or die "new Window";

# Grid Window
my $Grid = $Window->AddGrid (
    -name    => "Grid",
    -pos     => [0, 0],
    -rows    => 50,             # Use create option
    -columns => 10,
    -fixedrows    => 1,
    -fixedcolumns => 1,
    -editable     => 1,
    -virtual      => 1,
) or die "new Grid";

# $Grid->SetVirtualMode(1);   # Set virtual before set rows and columns
# $Grid->SetRows(50);
# $Grid->SetColumns(10);
# $Grid->SetFixedRows(1);
# $Grid->SetFixedColumns(1);
# $Grid->SetEditable(1);

$Grid->SetCellBkColor(2, 2, 0xFF0000);

# Event loop
$Window->Show();
Win32::GUI::Dialog();

# Main window event handler
sub Window_Terminate {

  return -1;
}

sub Window_Resize {
  my ($width, $height) = ($Window->GetClientRect)[2..3];
  $Grid->Resize ($width, $height);
}

# Virtual Grid request data
sub Grid_GetData {
 my ($row, $col) = @_;

 return "Cell ($row, $col)";
}

sub Grid_EndEdit {
  my ($col, $row, $str) = @_;
  print "End Edit ($col, $row) = $str\n";
  return 1;
}

--- NEW FILE: test6.pl ---
#! perl -w
#
# Test multiple Grid instance
# noflicker Win32::GUI support
#
use strict;
use Win32::GUI;
use Win32::GUI::Grid;

# main Window
my $Window = new Win32::GUI::Window (
    -title    => "Win32::GUI::Grid test 6",
    -pos     => [100, 100],
    -size    => [400, 400],
    -name     => "Window",
    -noflicker => 1,
) or die "new Window";

# Grid Window
my $Grid = new Win32::GUI::Grid (
    -parent  => $Window,
    -name    => "Grid",
    -pos     => [0, 0],
    -rows    => 10,
    -columns => 10,
    -fixedrows    => 1,
    -fixedcolumns => 1,
) or die "new Grid";

my $Grid2 = new Win32::GUI::Grid (
    -parent  => $Window,
    -name    => "Grid2",
    -pos     => [0, 0],
    -rows    => 10,
    -columns => 10,
    -fixedrows    => 1,
    -fixedcolumns => 1,
) or die "new Grid2";

# Fill Grid
for my $row (0..$Grid->GetRows()) {
  for my $col (0..$Grid->GetColumns()) {
    if ($row == 0) {
      $Grid->SetCellText($row, $col,"Column : $col");
      $Grid2->SetCellText($row, $col,"Column : $col");
    }
    elsif ($col == 0) {
      $Grid->SetCellText($row, $col, "Row : $row");
      $Grid2->SetCellText($row, $col, "Row : $row");
    }
    else {
      $Grid->SetCellText($row, $col, $row*$col);
      $Grid2->SetCellText($row, $col, $row*$col);
    }
  }
}


# Resize Grid Cell
$Grid->AutoSize();
$Grid2->AutoSize();

# Event loop
$Window->Show();
Win32::GUI::Dialog();

# Main window event handler
sub Window_Terminate {

  return -1;
}

sub Window_Resize {

  my ($width, $height) = ($Window->GetClientRect)[2..3];
  $Grid->Resize ($width, $height/2);
  $Grid2->Move (0, $height/2);
  $Grid2->Resize ($width, $height/2);
}

sub Grid_Click {

 my ($row, $col) = @_;
 print "Grid cell ($row, $col)\n";
}

sub Grid2_Click {

 my ($row, $col) = @_;
 print "Grid2 cell ($row, $col)\n";
}

--- NEW FILE: test1.pl ---
#! perl -w
#
# Test Basic Grid method
#
use strict;
use Win32::GUI;
use Win32::GUI::Grid;

# main Window
my $Window = new Win32::GUI::Window (
    -title    => "Win32::GUI::Grid test 1",
    -pos     => [100, 100],
    -size    => [400, 400],
    -name     => "Window",
) or die "new Window";

# Grid Window
my $Grid = new Win32::GUI::Grid (
    -parent  => $Window,
    -name    => "Grid",
    -pos     => [0, 0],
) or die "new Grid";

# Init Grid
$Grid->SetEditable(1);
$Grid->SetRows(50);
$Grid->SetColumns(10);
$Grid->SetFixedRows(1);
$Grid->SetFixedColumns(1);

# Fill Grid
for my $row (0..$Grid->GetRows()) {
  for my $col (0..$Grid->GetColumns()) {
    if ($row == 0) {
      $Grid->SetCellFormat($row, $col, DT_LEFT|DT_WORDBREAK);
      $Grid->SetCellText($row, $col,"Column : $col");
    }
    elsif ($col == 0) {
      $Grid->SetCellFormat($row, $col, DT_RIGHT|DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS|DT_NOPREFIX);
      $Grid->SetCellText($row, $col, "Row : $row");
    }
    else {
      $Grid->SetCellFormat($row, $col, DT_RIGHT|DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS|DT_NOPREFIX);
      $Grid->SetCellText($row, $col, "Cell : ($row,$col)");
    }
  }
}
# Resize Grid Cell
$Grid->AutoSize();

# Event loop
$Window->Show();
Win32::GUI::Dialog();

# Main window event handler
sub Window_Terminate {

  return -1;
}

sub Window_Resize {

  my ($width, $height) = ($Window->GetClientRect)[2..3];
  $Grid->Resize ($width, $height);
}

--- NEW FILE: three.bmp ---
(This appears to be a binary file; contents omitted.)

Update of /cvsroot/perl-win32-gui/Win32-GUI-Grid/samples
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15758/samples

Log Message:
Directory /cvsroot/perl-win32-gui/Win32-GUI-Grid/samples added to the repository

Update of /cvsroot/perl-win32-gui/Win32-GUI-Grid/MFCGrid
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15758/MFCGrid

Log Message:
Directory /cvsroot/perl-win32-gui/Win32-GUI-Grid/MFCGrid added to the repository

Update of /cvsroot/perl-win32-gui/Win32-GUI-AxWindow/Samples
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15455/Samples

Added Files:
	DHtmlEdit.pl DHtmlEdit.pm DHtmlEditor.pl Google.pl Info.bat 
	InfoControl.pl MShtml.pl Movie.avi MovieControl.pl 
	MsFlexGrid.pl SCGrid.pl TestOLE.pl WebBrowser.pl 
Log Message:
Added to repository

--- NEW FILE: MsFlexGrid.pl ---
# perl -w
#
#  Hosting MsFlexGrid : Test Indexed properties
#
use Cwd;
use Win32::GUI;
use Win32::GUI::AxWindow;

# main Window
$Window = new Win32::GUI::Window (
    -title    => "Win32::GUI::AxWindow test",
    -pos     => [100, 100],
    -size    => [400, 400],
    -name     => "Window",
) or die "new Window";

# Create AxWindow
$Control = new Win32::GUI::AxWindow  (
               -parent  => $Window,
               -name    => "Control",
               -pos     => [0, 0],
               -size    => [400, 400],
               -control => "MSFlexGridLib.MSFlexGrid",
 ) or die "new Control";

# Test Enum property set by string value
# $Control->SetProperty("ScrollBars", "flexScrollBarNone");
# $Control->SetProperty("GridLines", "flexGridInset");

$Control->SetProperty("Rows", 5);
$Control->SetProperty("Cols", 5);

$Control->SetProperty("TextMatrix", 1, 2, "Hello!!!");

$r = $Control->GetProperty("Rows");
$c = $Control->GetProperty("Cols");
$t = $Control->GetProperty("TextMatrix", 1, 2);
print "Rows = $r, Cols = $c, TextMatrix(1,2) = $t\n";

# Event loop
$Window->Show();
Win32::GUI::Dialog();

# Main window event handler

sub Window_Terminate {

  return -1;
}

sub Window_Resize {

  if (defined $Window) {
    ($width, $height) = ($Window->GetClientRect)[2..3];
    $Control->Move   (0, 0);
    $Control->Resize ($width, $height);
  }
}

--- NEW FILE: Movie.avi ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: WebBrowser.pl ---
# perl -w
#
#  Hosting a WebBrowser
#    Create a WebBrowser and register an event.
#    Enumerate Property, Methods and Events and create a Html file.
#    Load Html file in WebBrowser.
#
use Cwd;
use Win32::GUI;
use Win32::GUI::AxWindow;

# main Window
$Window = new Win32::GUI::Window (
    -title    => "Win32::GUI::AxWindow test",
    -pos     => [100, 100],
    -size    => [400, 400],
    -name     => "Window",
) or die "new Window";

# Create AxWindow
$Control = new Win32::GUI::AxWindow  (
               -parent  => $Window,
               -name    => "Control",
               -pos     => [0, 0],
               -size    => [400, 400],
               -control => "Shell.Explorer.2",
#               -control => "{8856F961-340A-11D0-A96B-00C04FD705A2}",
 ) or die "new Control";

# Register Event

$Control->RegisterEvent("StatusTextChange", sub { $self = shift; $id = shift; print "Event : ", @_, "\n"; } );

# Enum Property info

open (F, ">Webbrowser.html") or die "open";
print F '<HTML><BODY><HR><H1>Properties</H1><HR>';

foreach $id ($Control->EnumPropertyID()) {

  %property = $Control->GetPropertyInfo ($id);

  foreach $key (keys %property) {
    print F "<B>$key</B> = ", $property {$key}, "<BR>";
  }

  print F "<P>";
}

# Enum Method info

print F "<P><HR><H1>Methods</H1><HR>";

foreach $id ($Control->EnumMethodID()) {

  %method = $Control->GetMethodInfo ($id);

  foreach $key (keys %method) {
    print F "<B>$key</B> = ", $method {$key}, "<BR>";
  }

  print F "<P>";
}

# Enum Event info

print F "<P><HR><H1>Events</H1><HR>";

foreach $id ($Control->EnumEventID()) {

  %event = $Control->GetEventInfo ($id);

  foreach $key (keys %event) {
    print F "<B>$key</B> = ", $event {$key}, "<BR>";
  }

  print F "<P>";
}

print F "</BODY></HTML>";
close (F);

# Method call
$dir  = cwd;
$path = "file://$dir/Webbrowser.html";

# print $path, "\n";
$Control->CallMethod("Navigate", $path);

# Event loop
$Window->Show();
Win32::GUI::Dialog();


# Main window event handler

sub Window_Terminate {

  return -1;
}

sub Window_Resize {

  if (defined $Window) {
    ($width, $height) = ($Window->GetClientRect)[2..3];
    $Control->Move   (0, 0);
    $Control->Resize ($width, $height);
  }
}

--- NEW FILE: DHtmlEdit.pm ---
#
#  Win32::GUI::DHtmlEdit : wrapper package for DHtmlEdit ActiveX
#    by Laurent Rocher.
#
#  TODO : Check ExecuteCommand (Some commande have parametre)
#  TODO : Check QueryStatus (Usefull for all)
#
package Win32::GUI::DHtmlEdit;

use strict;
use vars qw(@ISA $VERSION);
use Carp 'croak','carp';

use Win32::GUI::AxWindow;

@ISA = qw(Win32::GUI::AxWindow Exporter);

$VERSION = "1.0";

[...1362 lines suppressed...]

  my ($self, $callback) = @_;

  $self->RegisterEvent ("onblur", $callback);
}

#
# onreadystatechange
#

sub OnReadyStateChange {

  croak("Usage: OnReadyStateChange (CallBack)") if (@_ != 2);

  my ($self, $callback) = @_;

  $self->RegisterEvent ("onreadystatechange", $callback);
}

1;

--- NEW FILE: DHtmlEdit.pl ---
# perl -w
#
#  Hosting DHtmlEdit basic 
#

use Cwd;
use Win32::GUI;
use Win32::GUI::AxWindow;

# main Window
$Window = new Win32::GUI::Window (
    -name     => "Window",
    -title    => "Win32::GUI::AxWindow test",
    -pos      => [100, 100],
    -size     => [400, 400],
) or die "new Window";

# Create AxWindow
$Control = new Win32::GUI::AxWindow  (
               -parent  => $Window,
               -name    => "Control",
               -pos     => [0, 0],
               -size    => [400, 400],
               -control => "{2D360200-FFF5-11D1-8D03-00A0C959BC0A}",
 ) or die "new Control";

# Method call
$Control->CallMethod("NewDocument");

# Event loop
$Window->Show();
Win32::GUI::Dialog();

# Main window event handler

sub Window_Terminate {

  # Print Html Text
  print $Control->GetProperty("DocumentHTML");

  return -1;
}

sub Window_Resize {

  if (defined $Window) {
    ($width, $height) = ($Window->GetClientRect)[2..3];
    $Control->Move   (0, 0);
    $Control->Resize ($width, $height);
  }
}

--- NEW FILE: MovieControl.pl ---
# perl -v
#
#  Hosting Movie Control (A movie player control see http://www.viscomsoft.com/movieplayer.htm)
#
use Cwd;
use Win32::GUI;
use Win32::GUI::AxWindow;

# main Window
$Window = new Win32::GUI::Window (
    -title    => "Movie Control Test",
    -pos     => [100, 100],
    -size    => [400, 400],
    -name     => "Window",
) or die "new Window";

# Create AxWindow
$Control = new Win32::GUI::AxWindow  (
               -parent  => $Window,
               -name    => "Control",
               -pos     => [0, 0],
               -size    => [400, 400],
#               -control => "{F4A32EAF-F30D-466D-BEC8-F4ED86CAF84E}",
               -control => "MOVIEPLAYER.MoviePlayerCtrl.1",
 ) or die "new Control";

# Load Avi file
$Control->SetProperty("FileName", "movie.avi");

# Event loop
$Window->Show();
# Start Avi player
$Control->CallMethod("Play");
Win32::GUI::Dialog();


# Main window event handler

sub Window_Terminate {

  # Release all before destroy window
  # $Control->Release();

  return -1;
}

sub Window_Resize {

  if (defined $Window) {
    ($width, $height) = ($Window->GetClientRect)[2..3];
    $Control->Move   (0, 0);
    $Control->Resize ($width, $height);
  }
}

--- NEW FILE: SCGrid.pl ---
# perl -w
#
#  Hosting SCGrid (A freeware Grid ActiveX see : http://www.scgrid.com/)
#
use Cwd;
use Win32::GUI;
use Win32::GUI::AxWindow;

# main Window
$Window = new Win32::GUI::Window (
    -title    => "Win32::GUI::AxWindow test",
    -pos     => [100, 100],
    -size    => [400, 400],
    -name     => "Window",
) or die "new Window";

# Create AxWindow
$Control = new Win32::GUI::AxWindow  (
               -parent  => $Window,
               -name    => "Control",
               -pos     => [0, 0],
               -size    => [400, 400],
               -control => "prjSCGrid.SCGrid",
 ) or die "new Control";

# Redraw Off
$Control->SetProperty("Redraw", 0);

# Create 1 Fixed col and Row
$Control->SetProperty("FixedRows", 1);
$Control->SetProperty("FixedCols", 1);
# Create 5 col and Row
$Control->SetProperty("Rows", 5);
$Control->SetProperty("Cols", 5);
# Adjust grid on column
$Control->SetProperty("AdjustLast", "scColumn");
# Add Resize column mode
$Control->SetProperty("ResizeMode", "scColumn");

# Fill Cell
for $C (0..4)
{
  for $R (0..4)
  {
    $Control->SetProperty("Text", $R, $C, "Cell ($R, $C)");
  }
}

# Fill Fixed Rows
$Control->SetProperty("Text", -1, -1, "    ");
for $R (0..4)
{
  $Control->SetProperty("Text", $R, -1, "$R");
}
$Control->CallMethod("AdjustWidth", -1, -32767);  # Force optional value

# Fill Fixed Cols and adjust size
for $C (0..4)
{
  $Control->SetProperty("Text", -1, $C, "FixedCol($C)");
  $Control->CallMethod("AdjustWidth", $C, -32767); # Force optional value
}

# Enable draw mode
$Control->SetProperty("Redraw", 1);

# Some property get
$r = $Control->GetProperty("Rows");
$c = $Control->GetProperty("Cols");
$t = $Control->GetProperty("Text", 1, 2);
print "Rows = $r, Cols = $c, Text(1,2) = $t\n";

# Event loop
$Window->Show();
Win32::GUI::Dialog();

# Main window event handler

sub Window_Terminate {

  return -1;
}

sub Window_Resize {

  if (defined $Window) {
    ($width, $height) = ($Window->GetClientRect)[2..3];
    $Control->Move   (0, 0);
    $Control->Resize ($width, $height);
  }
}

--- NEW FILE: TestOLE.pl ---
# perl -W
#
#  Host with AxWindow and manipulate with Win32::OLE
#  - Use GetOLE
#  - Call method
#  - Write in a HTML document
#
use Cwd;
use Win32::GUI;
use Win32::OLE;
use Win32::GUI::AxWindow;

# main Window
$Window = new Win32::GUI::Window (
    -title    => "Win32::GUI::AxWindow and Win32::OLE",
    -pos     => [100, 100],
    -size    => [400, 400],
    -name     => "Window",
) or die "new Window";

# A button
$Button = new Win32::GUI::Button (
    -parent  => $Window,
    -name    => "Button",
    -pos     => [0, 25],
    -size    => [400, 50],
    -text    => "Click me !!!",
    );

# Create AxWindow
$Control = new Win32::GUI::AxWindow  (
               -parent  => $Window,
               -name    => "Control",
               -pos     => [0, 100],
               -size    => [400, 300],
               -control => "Shell.Explorer.2",
 ) or die "new Control";

# Get Ole object
$OLEControl = $Control->GetOLE();
# $OLEControl->Navigate("about:blank");  # Clear control
$OLEControl->Navigate("http://www.google.com/");

# Event loop
$Window->Show();
Win32::GUI::Dialog();

# Button Event
sub Button_Click {
  $OLEControl->{Document}->{body}->insertAdjacentHTML("BeforeEnd","Click !!!");
  print "HTML = ", $OLEControl->{Document}->{body}->innerHTML, "\n";
}

# Main window event handler

sub Window_Terminate {

  # Release all before destroy window
  undef $OLEControl;
  $Control->Release();

  return -1;
}

sub Window_Resize {

  if (defined $Window) {
    ($width, $height) = ($Window->GetClientRect)[2..3];
    $Button->Move(0,25);
    $Button->Resize ($width, 50);
    $Control->Move   (0, 100);
    $Control->Resize ($width, $height-100);
  }
}

--- NEW FILE: DHtmlEditor.pl ---
# perl -w
#
#  Hosting DHtmlEdit and use wrapper package
#
#
use Cwd;
use Win32::GUI;
use DHtmlEdit;

my $HtmlFile  = "";
my $Directory = cwd;

# main menu
my $Menu =  Win32::GUI::MakeMenu(
    "&File"                   => "File",
    "   > &New..."            => "FileNew",
    "   > &Open..."           => "FileOpen",
    "   > -"                  => 0,
    "   > &Save"              => "FileSave",
    "   > Save &As..."        => "FileSaveAs",
    "   > -"                  => 0,
    "   > &Print"             => "FilePrint",
    "   > -"                  => 0,
    "   > &Directory..."      => "FileDirectory",
    "   > -"                  => 0,
    "   > E&xit"              => "FileExit",
    "&Edit"                   => "Edit",
    "   > &Undo"              => "EditUndo",
    "   > &Redo"              => "EditRedo",
    "   > -"                  => 0,
    "   > Cu&t"               => "EditCut",
    "   > &Copy"              => "EditCopy",
    "   > &Paste"             => "EditPaste",
    "   > -"                  => 0,
    "   > &Select All"        => "EditSelectAll",
    "   > &Delete"            => "EditDelete",
    "   > -"                  => 0,
    "   > &Find "             => "EditFind",
    "&Format"                 => "Format",
    "   > &Bold"              => "FormatBold",
    "   > &Italic"            => "FormatItalic",
    "   > &Underline"         => "FormatUnderline",
    "   > &Font..."           => "FormatFont",
    "   > -"                  => 0,
    "   > Justify &Left"      => "FormatJustifyLeft",
    "   > Justify &Center"    => "FormatJustifyCenter",
    "   > Justify &Right"     => "FormatJustifyRight",
    "   > -"                  => 0,
    "   > &Indent"            => "FormatIndent",
    "   > &Outdent"           => "FormatOutdent",
    "&Insert"                 => "Insert",
    "   > &HyperLink..."      => "InsertHyperLink",
    "   > &Image..."          => "InsertImage",
    "   > -"                  => 0,
    "   > &OrderList"         => "InsertOrderList",
    "   > &UnOrderList"       => "InsertUnOrderList",
    "   > -"                  => 0,
    "   > &Unlink"            => "InsertUnlink",
    "&Help"                   => "Help",
    "   > &About"             => "HelpAbout",
    );

# main Window
$Window = new Win32::GUI::Window (
    -name     => "Window",
    -title    => "Win32::GUI::AxWindow test",
    -pos      => [100, 100],
    -size     => [400, 400],
    -menu     => $Menu,
) or die "new Window";

# Create AxWindow
$Control = new Win32::GUI::DHtmlEdit  (
               -parent  => $Window,
               -name    => "Control",
               -pos     => [0, 0],
               -size    => [400, 400],
 ) or die "new Control";

# Method call
$Control->DocumentHTML('<HTML><BODY><B>Hello World !!!</B></BODY></HTML>');

# Event handler

$Control->OnDisplayChanged ( "Event_DisplayChanged" );

# Event loop
$Window->Show();
Win32::GUI::Dialog();

sub Event_DisplayChanged {

  my $self = shift;

  # Check Edit menu

  if ($Control->QueryUndo() == 3) { $Menu->{EditUndo}->Enabled(1); }
                             else { $Menu->{EditUndo}->Enabled(0); }

  if ($Control->QueryRedo() == 3) { $Menu->{EditRedo}->Enabled(1); }
                             else { $Menu->{EditRedo}->Enabled(0); }

  if ($Control->QueryCut() == 3)  { $Menu->{EditCut}->Enabled(1);  }
                             else { $Menu->{EditCut}->Enabled(0);  }

  if ($Control->QueryCopy() == 3) { $Menu->{EditCopy}->Enabled(1); }
                             else { $Menu->{EditCopy}->Enabled(0); }

  if ($Control->QueryPaste() == 3) { $Menu->{EditPaste}->Enabled(1); }
                              else { $Menu->{EditPaste}->Enabled(0); }

  if ($Control->QuerySelectAll() == 3) { $Menu->{EditSelectAll}->Enabled(1); }
                                  else { $Menu->{EditSelectAll}->Enabled(0); }

  if ($Control->QueryDelete() == 3) { $Menu->{EditDelete}->Enabled(1); }
                               else { $Menu->{EditDelete}->Enabled(0); }

}

# Finish method
sub Finish {

  # Change after last save.
  if ($Control->IsDirty()) {
    FileSave_Click();
  }

  return -1;
}

# Main window event handler

sub Window_Terminate {

  return Finish ();
}

sub Window_Resize {

  if (defined $Window) {
    ($width, $height) = ($Window->GetClientRect)[2..3];
    $Control->Move   (0, 0);
    $Control->Resize ($width, $height);
  }
}

#######################################################################
#
#  File Menu
#
#######################################################################

# New
sub FileNew_Click {

  $Control->NewDocument ();
  $HtmlFile = "";
}

# Open
sub FileOpen_Click {

  my $ret = Win32::GUI::GetOpenFileName(
                 -title     => "Open html File",
                 -filter    => [
                     "Html Document (*.htm, *.html)" => "*.htm;*.html",
                     "All files", "*.*",
                               ],
                 -directory => $Directory,
                 );
  if ($ret) {

    $HtmlFile = $ret;
    $Control->LoadDocument ($HtmlFile);

  }
  elsif (Win32::GUI::CommDlgExtendedError()) {
     Win32::GUI::MessageBox (0, "ERROR : ".Win32::GUI::CommDlgExtendedError(),
                            "GetOpenFileName Error");
  }
}

# Save
sub FileSave_Click {

  unless ($HtmlFile eq "") {
    my $ret = Win32::GUI::MessageBox (0, "Overwrite existing file ?",
                           "Save",MB_ICONQUESTION | MB_YESNOCANCEL);
    if ($ret == 6) {
      $ret = $Control->SaveDocument ($HtmlFile);
      unless ($ret) {
        Win32::GUI::MessageBox (0, "ERROR : SaveDocument ", "Save Error");
      }
    }
    elsif ($ret == 7) {
      FileSaveAs_Click();
    }
  }
  else {
    FileSaveAs_Click();
  }
}

# SaveAs
sub FileSaveAs_Click {

  my $ret = Win32::GUI::GetSaveFileName(
                 -title     => "Save html File As",
                 -filter    => ["Html Document (*.htm, *.html)" => "*.htm;*.html"],
                 -directory => $Directory,
                 );

  if ($ret) {
    $HtmlFile = $ret;
    $ret = $Control->SaveDocument ($HtmlFile);
    unless ($ret) {
      Win32::GUI::MessageBox (0, "ERROR : SaveDocument ", "Save Error");
    }
  }
  elsif (Win32::GUI::CommDlgExtendedError()) {
     Win32::GUI::MessageBox (0, "ERROR : ".Win32::GUI::CommDlgExtendedError(),
                            "GetSaveFileName Error");
  }

}

# Print
sub FilePrint_Click {

  $ret = $Control->PrintDocument (1);
}

# Directory
sub FileDirectory_Click {

  my $ret = Win32::GUI::BrowseForFolder (
                        -title      => "Select default directory",
                        -directory  => $Directory,
                        -folderonly => 1,
                        );
  $Directory = $ret if ($ret);
}

# Exit
sub FileExit_Click {

  return Finish();
}

#######################################################################
#
#  Edit Menu
#
#######################################################################

sub EditUndo_Click {
  $Control->Undo();
}

sub EditRedo_Click {
  $Control->Redo();
}

sub EditCut_Click {
  $Control->Cut();
}

sub EditCopy_Click {
  $Control->Copy();
}

sub EditPaste_Click {
  $Control->Paste();
}

sub EditSelectAll_Click {
  $Control->SelectAll();
}

sub EditDelete_Click {
  $Control->Delete();
}

sub EditFind_Click {
  $Control->FindText();
}

#######################################################################
#
#  Format Menu
#
#######################################################################

sub FormatBold_Click {
  $Control->Bold();
}

sub FormatItalic_Click {
  $Control->Italic();
}

sub FormatUnderline_Click {
  $Control->Underline();
}

sub FormatFont_Click {
  $Control->Font();
}

sub FormatJustifyLeft_Click {
  $Control->JustifyLeft();
}

sub FormatJustifyCenter_Click {
  $Control->JustifyCenter();
}

sub FormatJustifyRight_Click {
  $Control->JustifyRight();
}

sub FormatIndent_Click {
  $Control->Indent();
}

sub FormatOutdent_Click {
  $Control->Outdent();
}

#######################################################################
#
#  Insert Menu
#
#######################################################################

sub InsertHyperLink_Click {
  $Control->HyperLink();
}

sub InsertImage_Click {
  $Control->Image();
}

sub InsertOrderList {
  $Control->OrderList();
}

sub InsertUnOrderList {
  $Control->UnOrderList();
}

sub InsertUnlink_Click {
  $Control->Unlink();
}

#######################################################################
#
#  Help Menu
#
#######################################################################

sub HelpAbout_Click {

  Win32::GUI::MessageBox (0, "Perl Html Editor 0.1 by Laurent Rocher",
                         "About",MB_ICONINFORMATION);

}


--- NEW FILE: InfoControl.pl ---
# perl -w
#
#  Information about a control.
#  Create a html file with control information.
#  Parametre : CLSID Or ProgID
#
use Cwd;
use Win32::GUI;
use Win32::GUI::AxWindow;

if ($#ARGV != 0)
{
  print $0, " : ControlId\n";
  exit(0);
}

$ControlID = $ARGV[0];

# main Window
$Window = new Win32::GUI::Window (
    -title    => "Win32::GUI::AxWindow test",
    -left     => 100,
    -top      => 100,
    -width    => 400,
    -height   => 400,
    -name     => "Window",
) or die "new Window";

# Create AxWindow
$Control = new Win32::GUI::AxWindow  (
               -parent  => $Window,
               -name    => "Control",
               -pos     => [0, 0],
               -size    => [400, 400],
               -control => $ControlID,
 ) or die "new Control";

open (F, ">$ControlID.html") or die "open";

# Enum Property info

print F '<HTML><BODY><HR><H1>Properties</H1><HR>';
print "Properties\n";
foreach $id ($Control->EnumPropertyID()) {

  %property = $Control->GetPropertyInfo ($id);

  foreach $key (keys %property) {
    print F "<B>$key</B> = ", $property {$key}, "<BR>";
  }

  print F "<P>";
}

# Enum Method info

print F "<P><HR><H1>Methods</H1><HR>";
print "Methods\n";
foreach $id ($Control->EnumMethodID()) {

  %method = $Control->GetMethodInfo ($id);

  foreach $key (keys %method) {
    print F "<B>$key</B> = ", $method {$key}, "<BR>";
  }

  print F "<P>";
}

# Enum Event info

print F "<P><HR><H1>Events</H1><HR>";
print "Events\n";
foreach $id ($Control->EnumEventID()) {

  %event = $Control->GetEventInfo ($id);

  foreach $key (keys %event) {
    print F "<B>$key</B> = ", $event {$key}, "<BR>";
  }

  print F "<P>";
}

print F "</BODY></HTML>";
close (F);

--- NEW FILE: MShtml.pl ---
# perl -w
#
#  MSHTML : Load static HTML data
#
#
use Cwd;
use Win32::GUI;
use Win32::GUI::AxWindow;

# main Window
$Window = new Win32::GUI::Window (
    -title    => "Win32::GUI::AxWindow test",
    -pos     => [100, 100],
    -size    => [400, 400],
    -name     => "Window",
) or die "new Window";

# Create AxWindow
$Control = new Win32::GUI::AxWindow  (
               -parent  => $Window,
               -name    => "Control",
               -pos     => [0, 0],
               -size    => [400, 400],
               -control => "MSHTML:<HTML><BODY>This is a line of text</BODY></HTML>",
 ) or die "new Control";

# Event loop
$Window->Show();
Win32::GUI::Dialog();

# Main window event handler

sub Window_Terminate {

  return -1;
}

sub Window_Resize {

  if (defined $Window) {
    ($width, $height) = ($Window->GetClientRect)[2..3];
    $Control->Move   (0, 0);
    $Control->Resize ($width, $height);
  }
}

--- NEW FILE: Info.bat ---
rem Small Batch file for call InfoControl script

rem DHTML edit
rem perl infocontrol.pl {2D360200-FFF5-11D1-8D03-00A0C959BC0A}

rem Webbrowser {8856F961-340A-11D0-A96B-00C04FD705A2}
perl infocontrol.pl Explorer.Shell.2

rem FlexGrid
rem perl infocontrol.pl {AFC78D00-B917-11CE-AAE4-CE6AC0F06E88}

rem MsFlexGrid  {6262D3A0-531B-11CF-91F6-C2863C385E30}
rem perl infocontrol.pl MSFlexGridLib.MSFlexGrid

rem SCGrid
rem perl infocontrol.pl prjSCGrid.SCGrid

rem Movie control information
rem perl infocontrol.pl MOVIEPLAYER.MoviePlayerCtrl.1
--- NEW FILE: Google.pl ---
# perl -w
#
#  Hosting WebBrowser
#    - Create a WebBrowser control and get a Win32::OLe handler.
#    - Navigate on Google.fr
#    - When document loaded (DoucmentComplete event), set Win32::GUI::AxWindow in serach edit then submit
#       If Google Html page change, must change Item index.
#
use Cwd;
use Win32::GUI;
use Win32::OLE;
use Win32::GUI::AxWindow;

# main Window
$Window = new Win32::GUI::Window (
    -title    => "Win32::GUI::AxWindow and Win32::OLE",
    -pos     => [100, 100],
    -size    => [400, 400],
    -name     => "Window",
) or die "new Window";

# Create AxWindow with a webbrowser
$Control = new Win32::GUI::AxWindow  (
               -parent  => $Window,
               -name    => "Control",
               -pos     => [0, 100],
               -size    => [400, 300],
               -control => "Shell.Explorer.2",
 ) or die "new Control";

# Register Event
$Control->RegisterEvent ("DocumentComplete", "DocumentComplete_Event" );

# Get Ole object
$OLEControl = $Control->GetOLE();

# Navigate to google
$Control->CallMethod("Navigate", 'http://www.google.fr/');

# Event loop
$Window->Show();
Win32::GUI::Dialog();

# Event handler
sub DocumentComplete_Event { 
  
  # print $OLEControl->{LocationUrl}, "\n";
  return unless $OLEControl->{LocationUrl} eq 'http://www.google.fr/';
  
  print "Search Win32::GUI::AXWindow\n";

  my $all = $OLEControl->{Document}->{all};

  # List all HTML TAG
  # for $i (0..$all->length) {
  #  my $item = $all->item($i);
  #   print "$i = ", $item->outerHTML , "\n\n";    	
  # }

  # Input texte
  my $inputTexte = $all->item(49);    
  $inputTexte->{value} = "Win32::GUI::AxWindow";

  # Submit
  my $Submit     = $all->item(55);
  $Submit->click;
}	

# Main window event handler

sub Window_Terminate {

  # Release all before destroy window
  undef $OLEControl;
  # $Control->Release();

  return -1;
}

sub Window_Resize {

  if (defined $Window) {
    ($width, $height) = ($Window->GetClientRect)[2..3];
    $Control->Move   (0, 0);
    $Control->Resize ($width, $height);
  }
}

Update of /cvsroot/perl-win32-gui/Win32-GUI-AxWindow
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15455

Added Files:
	AxWindow.html AxWindow.pm AxWindow.xs Changes MANIFEST 
	Makefile.PL README TYPEMAP 
Log Message:
Added to repository

--- NEW FILE: AxWindow.pm ---
package Win32::GUI::AxWindow;

use vars qw($VERSION @ISA @EXPORT @EXPORT_OK);
use Win32::GUI;

require Exporter;
require DynaLoader;
require AutoLoader;

@ISA = qw(Exporter DynaLoader Win32::GUI::Window);

# Items to export into callers namespace by default. Note: do not export
# names by default without a very good reason. Use EXPORT_OK instead.
# Do not simply export all your public functions/methods/constants.
@EXPORT = qw();
$VERSION = '0.07';

bootstrap Win32::GUI::AxWindow $VERSION;

# Preloaded methods go here.

# Initialise

Win32::GUI::AxWindow::_Initialise();

# DeInitialise

END {
  Win32::GUI::AxWindow::_DeInitialise();
}

# Autoload methods go after =cut, and are processed by the autosplit program.

#
#  new : Create a new ActiveX Window
#

sub new {

  my $class  = shift;
  my %in     = @_;

  ### Control option
  croak("-parent undefined")  unless exists $in{-parent};
  croak("-name undefined")    unless exists $in{-name};
  croak("-control undefined") unless exists $in{-control};

  my $parent = $in{-parent};
  my $name   = $in{-name};
  my $clsid  = $in{-control};

  # print "Parent = $parent->{-name}\n";
  # print "Name = $name\n";
  # print "Control = $clsid\n";

  ### Size
  my ($x, $y, $w, $h) = (0,0,1,1);

  $x = $in{-left}       if exists $in{-left};
  $y = $in{-top}        if exists $in{-top};
  $w = $in{-width}      if exists $in{-width};
  $h = $in{-height}     if exists $in{-height};
  ($x, $y) = ($in{-pos}[0] , $in{-pos}[1]) if exists $in{-pos};
  ($w, $h) = ($in{-size}[0],$in{-size}[1]) if exists $in{-size};
  # print "(x,y) = ($x,$y)\n(w,h) = ($w,$h)\n";

  ### Window Style
  my $style = WS_CHILD | WS_CLIPCHILDREN;

  $style  = $in{-style}     if exists $in{-style};
  $style |= $in{-pushstyle} if exists $in{-pushstyle};
  $style ^= $in{-popstyle}  if exists $in{-popstyle};
  $style |= $in{-addstyle}  if exists $in{-addstyle};
  $style ^= $in{-remstyle}  if exists $in{-remstyle};

  $style |= WS_VISIBLE      unless exists $in{-visible} && $in{-visible} == 0;
  $style |= WS_TABSTOP      unless exists $in{-tabstop} && $in{-tabstop} == 0;
  $style |= WS_DISABLED     if exists $in{-enable} && $in{-enable} == 0;
  $style |= WS_HSCROLL      if exists $in{-hscroll} && $in{-hscroll} == 1;
  $style |= WS_VSCROLL      if exists $in{-vscroll} && $in{-vscroll} == 1;

  # print "Style = $style\n";

  ### Window ExStyle
  my $exstyle = 0;

  $exstyle = $in{-exstyle}      if exists $in{-exstyle};
  $exstyle |= $in{-pushexstyle} if exists $in{-pushexstyle};
  $exstyle ^= $in{-popexstyle}  if exists $in{-popexstyle};
  $exstyle |= $in{-addexstyle}  if exists $in{-addexstyle};
  $exstyle ^= $in{-remexstyle}  if exists $in{-remexstyle};

  # print "ExStyle = $exstyle\n";

  ### Create Window and ActiveX Object
  my $self = {};
  bless $self, $class;

  if ( $self->_Create($parent, $clsid, $style, $exstyle, $x, $y, $w, $h) )
  {
    ### Store Data (Win32::GUI glue)
    $self->{-name}   = $in{-name};
    $parent->{$name} = $self;

    return $self;
  }

  return undef;
}

#
# CallMethod : Use Invoke with DISPATCH_METHOD
#

sub CallMethod {
  my $self = shift;

  return $self->Invoke (0x01, @_);
}

#
# GetProperty : Use Invoke with DISPATCH_PROPERTYGET
#

sub GetProperty {

  my $self = shift;

  return $self->Invoke (0x02, @_);
}

#
# PutProperty : Use Invoke with DISPATCH_PROPERTYPUT
#

sub SetProperty {

  my $self = shift;

  return $self->Invoke (0x04, @_);
}


1;
__END__
# Below is the stub of documentation for your module. You better edit it!

=head1 NAME

Win32::GUI::AxWindow - Perl extension for Hosting ActiveX Control in Win32::GUI

=head1 SYNOPSIS

  use Win32::GUI;
  use Win32::GUI::AxWindow;

  # Main Window
  $Window = new Win32::GUI::Window (
               -name     => "Window",
               -title    => "Win32::GUI::AxWindow test",
               -post     => [100, 100],
               -size     => [400, 400],
  );

  # Add a WebBrowser AxtiveX
  $Control = new Win32::GUI::AxWindow  (
                -parent  => $Window,
                -name    => "Control",
                -control => "Shell.Explorer.2",
                # -control => "{8856F961-340A-11D0-A96B-00C04FD705A2}",
                -pos     => [0, 0],
                -size    => [400, 400],
  );

  # Register some event
  $Control->RegisterEvent("StatusTextChange",
                           sub {
                               $self    = shift;
                               $eventid = shift;
                               print "Event : ", @_, "\n";
                            } );

  # Call Method
  $Control->CallMethod("Navigate", 'http://www.perl.com/');

  # Event loop
  $Window->Show();
  Win32::GUI::Dialog();

  # Main window event handler

  sub Window_Terminate {

    return -1;
  }

  sub Window_Resize {

    if (defined $Window) {
      ($width, $height) = ($Window->GetClientRect)[2..3];
      $Control->Move   (0, 0);
      $Control->Resize ($width, $height);
    }
  }


=head1 DESCRIPTION

=head2 AxWindow

=item C<new> (...)

  Create a new ActiveX window.

  options  :

  -parent  => parent window  (Required)
  -name    => window name    (Required)
  -size    => window size [ width, heigth ]
  -pos     => window pos  [ left, top ]
  -width   => window width
  -height  => window height
  -left    => window left
  -top     => window top
  -control => clisd (see below) (Required).

  clsid is a string identifier to create the control.
  Must be formatted in one of the following ways:

    - A ProgID such as "MSCAL.Calendar.7"
    - A CLSID such as "{8E27C92B-1264-101C-8A2F-040224009C02}"
    - A URL such as "http://www.microsoft.com"
    - A reference to an Active document such as 'file://Documents/MyDoc.doc'
    - A fragment of HTML such as "MSHTML:<HTML><BODY>This is a line of text</BODY></HTML>"
      Note   "MSHTML:" must precede the HTML fragment so that it is designated as being an MSHTML stream.

  styles:

  -visible => 0/1
  -tabstop => 0/1
  -hscroll => 0/1
  -vscroll => 0/1

  -style, -addstyle, -pushstyle, -remstyle, -popstyle
  -exstyle, -exaddstyle, -expushstyle, -exremstyle, -expopstyle

  Default style is : WS_CHILD |  WS_VISIBLE | WS_TABSTOP | WS_CLIPCHILDREN

=item C<Release> ()

  If have crash when exiting, call this function before all the window are destroy (before Win32::GUI::Dialog(); exit).
  Generaly, call this function in the Window_Terminate handle.

=head2 Property

=item C<EnumPropertyID> ()

  Return a list of all the Property ID of the control.

=item C<EnumPropertyName> ()

  Return a list of all the Property name of the control.

=item C<GetPropertyInfo> (ID_or_Name)

  Return a hash with information about the Property from ID or Name.

  Hash entry :
    -Name        => Property Name.
    -ID          => Property ID.
    -VarType     => Property Type (Variant type).
    -EnumValue   => A formated string of enum value ( enum1=value1,enum2=value2,... ).
    -ReadOnly    => Indicate if a property can only be read.
    -Description => Property Description.
    -Prototype   => Prototype

=item C<GetProperty> (ID_or_Name, [index, ...])

  Get property value.
  For indexed property, add index list.

=item C<SetProperty> (ID_or_Name, [index, ...], value)

  Set property value
  For indexed property, add index list before value.

=head2 Method

=item C<EnumMethodID> ()

  Return a list of all the Method ID of the control.

=item C<EnumMethodName> ()

  Return a list of all the Method name of the control.

=item C<GetMethodInfo> (ID_Name)

  Return a hash with information about the Method from ID or Name.

  Hash entry :
    -Name        => Method Name.
    -ID          => Method ID.
    -Description => Method Description.
    -Prototype   => Method Prototype.

=item C<CallMethod> (ID_or_Name, ...)

  Invoke a method of an ActiveX control.

=head2 Event

=item C<EnumEventID> ()

  Return a list of all the Event ID of the control.

=item C<EnumEventName> ()

  Return a list of all the Event Name of the control.

=item C<GetEventInfo> (ID_or_Name)

  Return a hash with information about the Event from ID or Name.

  Hash entry :
    -Name        => Method Name.
    -ID          => Method ID.
    -Description => Method Description.
    -Prototype   => Method Prototype.

=item C<RegisterEvent> (ID_or_Name, Callback)

  Associate a Callback for an ActiveX Event.

=head2 Win32::OLE

=item C<GetOLE> ()

   Return a Win32::OLE object of Hosted ActiveX Control.

   You MUST add use Win32::OLE in your script.

=head1 AUTHOR

  Laurent Rocher (lr...@cp...)
  HomePage :http://perso.club-internet.fr/rocherl/Win32GUI.html

=head1 SEE ALSO

  Win32::GUI

=cut

--- NEW FILE: Makefile.PL ---
use ExtUtils::MakeMaker;
# See lib/ExtUtils/MakeMaker.pm for details of how to influence
# the contents of the Makefile that is written.
WriteMakefile(
    'NAME'	   => 'Win32::GUI::AxWindow',
    'VERSION_FROM' => 'AxWindow.pm', # finds $VERSION
    'XS'           => { 'AxWindow.xs' => 'AxWindow.cpp' },
    'LIBS'         => ['atl.lib'],   # e.g., '-lm'    
    'INC'	   => '',     # e.g., '-I/usr/include/other' 
     ($] eq '5.00503')
     ? (
	'DEFINE'	   => '-DPERL_5005',     # e.g., '-DHAVE_SOMETHING' 
     ) : (
	'DEFINE'	   => '',     # e.g., '-DHAVE_SOMETHING' 
     ),     
     ($] ge '5.005')
     ? (
      'AUTHOR'   => 'ROCHER Laurent (ro...@cl...)',
      'ABSTRACT' => 'Add ActiveX Control Hosting in Win32::GUI',
     )
     : (),
);

sub MY::xs_c {
'

.xs.c:
    $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.c

.xs.cpp:
    $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.cpp

';
}

--- NEW FILE: MANIFEST ---
Makefile.PL
Changes
AxWindow.pm
AxWindow.xs
MANIFEST
TYPEMAP
Samples/WebBrowser.pl
Samples/InfoControl.pl
Samples/DHtmlEdit.pl
Samples/DHtmlEdit.pm
Samples/DHtmlEditor.pl
Samples/MsFlexGrid.pl
Samples/TestOLE.pl

--- NEW FILE: AxWindow.xs ---
/**********************************************************************/
/*                     C o n t a i n e r . x s                        */
/**********************************************************************/

#include <atlbase.h>

CComModule _Module;

#include <atlcom.h>
#include <atlhost.h>
#include <atlctl.h>

#include <winbase.h>

/*====================================================================*/
/*                          Perl Compatibility                        */
/*====================================================================*/

#ifdef PERL_5005
[...2660 lines suppressed...]
void
Release (container)
   CContainer*  container
CODE:
  //  printf("Release\n");
   container->Clean();
  //  printf("Release\n");

  ##################################################################
  #
  # DESTROY
  #

void
DESTROY(container)
   CContainer*  container
CODE:
  // printf("DESTROY\n");
   delete container;
  // printf("DESTROY\n");

--- NEW FILE: README ---
Win32::GUI::AxWindow 0.07
=========================

Win32::GUI::AxWindow - Perl extension for Hosting ActiveX Control in Win32::GUI

INSTALLATION

To install this module type the following:

   perl Makefile.PL
   make
   make install

DEPENDENCIES

This module requires these other modules and libraries:

  Win32::GUI
  Active Template Library (ATL)

WEB PAGE AND PPM REPOSITORY

See: http://perso.club-internet.fr/rocherl/Win32GUI.html

COPYRIGHT AND LICENCE

Copyright 2003 by Laurent Rocher (lr...@cp...).

This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.

See <http://www.perl.com/perl/misc/Artistic.html>.


--- NEW FILE: Changes ---

Revision history for Perl extension AxWindow.

0.07  03/02/2004
	- Correct GetOLE() method when using PAR and PerlApp.

0.06  28/09/2003
        - Rewrite creation method (Remove AttachControl method).
        - No more need to call Release Method before exit.
        - Correct bug in GetPropertyInfo with VARTYPE property.
        - Correct -heigth option.
        - Update and add samples.

0.05  15/10/2002
        - Add GetOLE method (return a Win32::OLE object of Hosted ActiveX Control).
        - Add TestOle.pl Sample.

0.04  14/09/2002
        - Add indexed property support.
        - Change code organisation (Invoke method, CProperty child of CMethod).
        - Add MSFlexGrid Sample.

0.03  30/05/2002
        - Add VARTYPE property support.
        - Add output parameter for event support.
        - Accept control without event.
        - Correct DHTMLEdit.pm wrapper class.

0.02  25/03/2002
        - Correct ReadOnly value for Properties.
        - Add =value for Enum string list for Properties.
        - Test ReadOnly attribut in SetProperty.
        - SetProperty handle Enum property by value or string constant.
        - Add a Release method for clean ActiveX reference before window destroy.
        - Manage VT_USERDEFINED as enum in CallMethod.
        - Add some documentation (sorry for my english ;-).
        - Add DHTML Edit sample (basic and a wrapper class).

0.01  22/03/2002
        - original version; created by h2xs 1.19
        - ActiveX control information (Properties, Metods, Events).
        - Set/Get property.
        - Call a Method.
        - Event Support.
        - Support of basic variant type.

--- NEW FILE: TYPEMAP ---
TYPEMAP
CContainer*  T_CONTAINER
HWND         T_HANDLE
HMENU        T_HANDLE
HICON        T_HANDLE
HCURSOR      T_HANDLE
HBITMAP      T_HANDLE
HFONT        T_HANDLE
HGDIOBJ      T_HANDLE
HIMAGELIST   T_HANDLE
HDC          T_HANDLE
HBRUSH       T_HANDLE
HPEN         T_HANDLE
HTREEITEM    T_IV
LONG         T_IV
LPCTSTR      T_PV
LPTSTR       T_PV
DWORD        T_IV
UINT         T_IV
BOOL         T_IV
WPARAM       T_IV
LPARAM       T_IV
LRESULT      T_IV
HINSTANCE    T_IV
COLORREF     T_COLOR
LPCSTR       T_PV
HENHMETAFILE T_IV
FLOAT        T_FLOAT
LPVOID       T_PV
HACCEL       T_IV

################################################################################
INPUT
T_HANDLE
    if(SvROK($arg)) {
        if(hv_fetch((HV*)SvRV($arg), \"-handle\", 7, 0) != NULL)
            $var = ($type) SvIV(*(hv_fetch((HV*)SvRV($arg), \"-handle\", 7, 0)));
        else
            $var = NULL;
    } else
        $var = ($type) SvIV($arg);
T_COLOR
    $var = SvCOLORREF($arg);
T_CONTAINER
    $var = ($type) SvIV(*(hv_fetch((HV*)SvRV($arg), \"-CContainer\", 11, 0)));

################################################################################
OUTPUT
T_HANDLE
    sv_setiv($arg, (IV) $var);
T_COLOR
    sv_setiv($arg, (IV) $var);


--- NEW FILE: AxWindow.html ---
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Win32::GUI::AxWindow - Perl extension for Hosting ActiveX Control in Win32::GUI</title>
<link rev="made" href="mailto:" />
</head>

<body style="background-color: white">

<p><a name="__index__"></a></p>
<!-- INDEX BEGIN -->

<ul>

	<li><a href="#name">NAME</a></li>
	<li><a href="#synopsis">SYNOPSIS</a></li>
	<li><a href="#description">DESCRIPTION</a></li>
	<ul>

		<li><a href="#axwindow">AxWindow</a></li>
		<li><a href="#property">Property</a></li>
		<li><a href="#method">Method</a></li>
		<li><a href="#event">Event</a></li>
		<li><a href="#win32::ole">Win32::OLE</a></li>
	</ul>

	<li><a href="#author">AUTHOR</a></li>
	<li><a href="#see_also">SEE ALSO</a></li>
</ul>
<!-- INDEX END -->

<hr />
<p>
</p>
<h1><a name="name">NAME</a></h1>
<p>Win32::GUI::AxWindow - Perl extension for Hosting ActiveX Control in Win32::GUI</p>
<p>
</p>
<hr />
<h1><a name="synopsis">SYNOPSIS</a></h1>
<pre>
  use Win32::GUI;
  use Win32::GUI::AxWindow;</pre>
<pre>
  # Main Window
  $Window = new Win32::GUI::Window (
               -name     =&gt; &quot;Window&quot;,
               -title    =&gt; &quot;Win32::GUI::AxWindow test&quot;,
               -post     =&gt; [100, 100],
               -size     =&gt; [400, 400],
  );</pre>
<pre>
  # Add a WebBrowser AxtiveX
  $Control = new Win32::GUI::AxWindow  (
                -parent  =&gt; $Window,
                -name    =&gt; &quot;Control&quot;,
                -control =&gt; &quot;Shell.Explorer.2&quot;,
                # -control =&gt; &quot;{8856F961-340A-11D0-A96B-00C04FD705A2}&quot;,
                -pos     =&gt; [0, 0],
                -size    =&gt; [400, 400],
  );</pre>
<pre>
  # Register some event
  $Control-&gt;RegisterEvent(&quot;StatusTextChange&quot;,
                           sub {
                               $self    = shift;
                               $eventid = shift;
                               print &quot;Event : &quot;, @_, &quot;\n&quot;;
                            } );</pre>
<pre>
  # Call Method
  $Control-&gt;CallMethod(&quot;Navigate&quot;, '<a href="http://www.perl.com/">http://www.perl.com/</a>');</pre>
<pre>
  # Event loop
  $Window-&gt;Show();
  Win32::GUI::Dialog();</pre>
<pre>
  # Main window event handler</pre>
<pre>
  sub Window_Terminate {</pre>
<pre>
    return -1;
  }</pre>
<pre>
  sub Window_Resize {</pre>
<pre>
    if (defined $Window) {
      ($width, $height) = ($Window-&gt;GetClientRect)[2..3];
      $Control-&gt;Move   (0, 0);
      $Control-&gt;Resize ($width, $height);
    }
  }</pre>
<p>
</p>
<hr />
<h1><a name="description">DESCRIPTION</a></h1>
<p>
</p>
<h2><a name="axwindow">AxWindow</a></h2>
<dl>
<dt><strong><a name="item_new"><code>new</code> (...)</a></strong><br />
</dt>
<dd>
<pre>
  Create a new ActiveX window.</pre>
</dd>
<dd>
<pre>
  options  :</pre>
</dd>
<dd>
<pre>
  -parent  =&gt; parent window  (Required)
  -name    =&gt; window name    (Required)
  -size    =&gt; window size [ width, heigth ]
  -pos     =&gt; window pos  [ left, top ]
  -width   =&gt; window width
  -height  =&gt; window height
  -left    =&gt; window left
  -top     =&gt; window top
  -control =&gt; clisd (see below) (Required).</pre>
</dd>
<dd>
<pre>
  clsid is a string identifier to create the control.
  Must be formatted in one of the following ways:</pre>
</dd>
<dd>
<pre>
    - A ProgID such as &quot;MSCAL.Calendar.7&quot;
    - A CLSID such as &quot;{8E27C92B-1264-101C-8A2F-040224009C02}&quot;
    - A URL such as &quot;<a href="http://www.microsoft.com&quot">http://www.microsoft.com&quot</a>;
    - A reference to an Active document such as '<a href="file://Documents/MyDoc.doc">file://Documents/MyDoc.doc</a>'
    - A fragment of HTML such as &quot;MSHTML:&lt;HTML&gt;&lt;BODY&gt;This is a line of text&lt;/BODY&gt;&lt;/HTML&gt;&quot;
      Note   &quot;MSHTML:&quot; must precede the HTML fragment so that it is designated as being an MSHTML stream.</pre>
</dd>
<dd>
<pre>
  styles:</pre>
</dd>
<dd>
<pre>
  -visible =&gt; 0/1
  -tabstop =&gt; 0/1
  -hscroll =&gt; 0/1
  -vscroll =&gt; 0/1</pre>
</dd>
<dd>
<pre>
  -style, -addstyle, -pushstyle, -remstyle, -popstyle
  -exstyle, -exaddstyle, -expushstyle, -exremstyle, -expopstyle</pre>
</dd>
<dd>
<pre>
  Default style is : WS_CHILD |  WS_VISIBLE | WS_TABSTOP | WS_CLIPCHILDREN</pre>
</dd>
<dt><strong><a name="item_release"><code>Release</code> ()</a></strong><br />
</dt>
<dd>
<pre>
  If have crash when exiting, call this function before all the window are destroy (before Win32::GUI::Dialog(); exit).
  Generaly, call this function in the Window_Terminate handle.</pre>
</dd>
</dl>
<p>
</p>
<h2><a name="property">Property</a></h2>
<dl>
<dt><strong><a name="item_enumpropertyid"><code>EnumPropertyID</code> ()</a></strong><br />
</dt>
<dd>
<pre>
  Return a list of all the Property ID of the control.</pre>
</dd>
<dt><strong><a name="item_enumpropertyname"><code>EnumPropertyName</code> ()</a></strong><br />
</dt>
<dd>
<pre>
  Return a list of all the Property name of the control.</pre>
</dd>
<dt><strong><a name="item_getpropertyinfo"><code>GetPropertyInfo</code> (ID_or_Name)</a></strong><br />
</dt>
<dd>
<pre>
  Return a hash with information about the Property from ID or Name.</pre>
</dd>
<dd>
<pre>
  Hash entry :
    -Name        =&gt; Property Name.
    -ID          =&gt; Property ID.
    -VarType     =&gt; Property Type (Variant type).
    -EnumValue   =&gt; A formated string of enum value ( enum1=value1,enum2=value2,... ).
    -ReadOnly    =&gt; Indicate if a property can only be read.
    -Description =&gt; Property Description.
    -Prototype   =&gt; Prototype</pre>
</dd>
<dt><strong><a name="item_getproperty"><code>GetProperty</code> (ID_or_Name, [index, ...])</a></strong><br />
</dt>
<dd>
<pre>
  Get property value.
  For indexed property, add index list.</pre>
</dd>
<dt><strong><a name="item_setproperty"><code>SetProperty</code> (ID_or_Name, [index, ...], value)</a></strong><br />
</dt>
<dd>
<pre>
  Set property value
  For indexed property, add index list before value.</pre>
</dd>
</dl>
<p>
</p>
<h2><a name="method">Method</a></h2>
<dl>
<dt><strong><a name="item_enummethodid"><code>EnumMethodID</code> ()</a></strong><br />
</dt>
<dd>
<pre>
  Return a list of all the Method ID of the control.</pre>
</dd>
<dt><strong><a name="item_enummethodname"><code>EnumMethodName</code> ()</a></strong><br />
</dt>
<dd>
<pre>
  Return a list of all the Method name of the control.</pre>
</dd>
<dt><strong><a name="item_getmethodinfo"><code>GetMethodInfo</code> (ID_Name)</a></strong><br />
</dt>
<dd>
<pre>
  Return a hash with information about the Method from ID or Name.</pre>
</dd>
<dd>
<pre>
  Hash entry :
    -Name        =&gt; Method Name.
    -ID          =&gt; Method ID.
    -Description =&gt; Method Description.
    -Prototype   =&gt; Method Prototype.</pre>
</dd>
<dt><strong><a name="item_callmethod"><code>CallMethod</code> (ID_or_Name, ...)</a></strong><br />
</dt>
<dd>
<pre>
  Invoke a method of an ActiveX control.</pre>
</dd>
</dl>
<p>
</p>
<h2><a name="event">Event</a></h2>
<dl>
<dt><strong><a name="item_enumeventid"><code>EnumEventID</code> ()</a></strong><br />
</dt>
<dd>
<pre>
  Return a list of all the Event ID of the control.</pre>
</dd>
<dt><strong><a name="item_enumeventname"><code>EnumEventName</code> ()</a></strong><br />
</dt>
<dd>
<pre>
  Return a list of all the Event Name of the control.</pre>
</dd>
<dt><strong><a name="item_geteventinfo"><code>GetEventInfo</code> (ID_or_Name)</a></strong><br />
</dt>
<dd>
<pre>
  Return a hash with information about the Event from ID or Name.</pre>
</dd>
<dd>
<pre>
  Hash entry :
    -Name        =&gt; Method Name.
    -ID          =&gt; Method ID.
    -Description =&gt; Method Description.
    -Prototype   =&gt; Method Prototype.</pre>
</dd>
<dt><strong><a name="item_registerevent"><code>RegisterEvent</code> (ID_or_Name, Callback)</a></strong><br />
</dt>
<dd>
<pre>
  Associate a Callback for an ActiveX Event.</pre>
</dd>
</dl>
<p>
</p>
<h2><a name="win32::ole">Win32::OLE</a></h2>
<dl>
<dt><strong><a name="item_getole"><code>GetOLE</code> ()</a></strong><br />
</dt>
<dd>
<pre>
   Return a Win32::OLE object of Hosted ActiveX Control.</pre>
</dd>
<dd>
<pre>
   You MUST add use Win32::OLE in your script.</pre>
</dd>
</dl>
<p>
</p>
<hr />
<h1><a name="author">AUTHOR</a></h1>
<pre>
  Laurent Rocher (lr...@cp...)
  HomePage :<a href="http://perso.club-internet.fr/rocherl/Win32GUI.html">http://perso.club-internet.fr/rocherl/Win32GUI.html</a></pre>
<p>
</p>
<hr />
<h1><a name="see_also">SEE ALSO</a></h1>
<pre>
  Win32::GUI</pre>

</body>

</html>

Update of /cvsroot/perl-win32-gui/Win32-GUI-AxWindow/Samples/UnComplete
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15455/Samples/UnComplete

Added Files:
	MsFlexGrid.pm 
Log Message:
Added to repository

--- NEW FILE: MsFlexGrid.pm ---
#
#  Win32::GUI::MsFlexGrid: wrapper package for MsFlexGrid ActiveX
#    by Laurent Rocher.
#
#

use strict;
use vars qw(@ISA $VERSION);
use Carp 'croak','carp';

use Win32::GUI::AxWindow;

@ISA = qw(Win32::GUI::AxWindow Exporter);

$VERSION = "1.0";

BEGIN {
        use Exporter();
        use vars qw(@EXPORT);
[...1680 lines suppressed...]

# VARIANT_BOOL RightToLeft() / void RightToLeft([in] VARIANT_BOOL rhs)
# Determines text display direction and control visual appearance on a bidirectional system.
sub RightToLeft {

  croak("Usage: VARIANT_BOOL RightToLeft() / void RightToLeft([in] VARIANT_BOOL rhs)") if (@_ != 1 && @_ != 2);

  my ($self, $value) = @_;

  if (defined $value) {
    return $self->SUPER::SetProperty (0xfffffd9d, $value);
  }
  else {
    return $self->SUPER::GetProperty (0xfffffd9d);
  }
}

1;

__END__

Update of /cvsroot/perl-win32-gui/Win32-GUI-AxWindow/Samples/UnComplete
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15339/UnComplete

Log Message:
Directory /cvsroot/perl-win32-gui/Win32-GUI-AxWindow/Samples/UnComplete added to the repository

Update of /cvsroot/perl-win32-gui/Win32-GUI-AxWindow/Samples
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15316/Samples

Log Message:
Directory /cvsroot/perl-win32-gui/Win32-GUI-AxWindow/Samples added to the repository

Update of /cvsroot/perl-win32-gui/Win32-GUI-Scintilla
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv23874

Added Files:
	Changes MANIFEST Makefile.PL Perl.pm README Scintilla.html 
	Scintilla.pm Scintilla.pm.begin Scintilla.pm.end Scintilla.xs 
	Typemap 
Log Message:
Added to repository

--- NEW FILE: Makefile.PL ---
use ExtUtils::MakeMaker;

# See lib/ExtUtils/MakeMaker.pm for details of how to influence
# the contents of the Makefile that is written.
WriteMakefile(
    'NAME'              => 'Win32::GUI::Scintilla',
    'VERSION_FROM'      => 'Scintilla.pm.begin', # finds $VERSION
    'PREREQ_PM'         => {}, # e.g., Module::Name => 1.1
    'PM' => {
        'Scintilla.pm'  => '$(INST_LIBDIR)/Scintilla.pm',
        'Perl.pm'       => '$(INST_LIBDIR)/Scintilla/Perl.pm',
    },
    ($] >= 5.005 ?    ## Add these new keywords supported since 5.005
      (ABSTRACT => 'Add Scintilla control to Win32::GUI',
       AUTHOR   => 'ROCHER Laurent (lr...@cp...)') : ()),
    'LIBS'              => [''], # e.g., '-lm'
    'DEFINE'            => '', # e.g., '-DHAVE_SOMETHING'
        # Insert -I. if you add *.h files later:
    'INC'               => '', # e.g., '-I/usr/include/other'
        # Un-comment this if you add C files to link with later:
    # 'OBJECT'          => '$(O_FILES)', # link all the C files too
);

sub MY::postamble {

return <<'MAKE_FRAG';

Scintilla.pm : Scintilla.pm.begin Scintilla.pm.end include/Scintilla.iface include/autogen.pl
	$(PERL) ./include/autogen.pl

config :: $(INST_ARCHAUTODIR)/SciLexer.dll
	@$(NOOP)

$(INST_ARCHAUTODIR)/SciLexer.dll : include/SciLexer.dll
	$(CP) ./include/SciLexer.dll $(INST_ARCHAUTODIR)/SciLexer.dll

MAKE_FRAG
}

--- NEW FILE: Scintilla.pm.begin ---
#------------------------------------------------------------------------
# Scintilla control for Win32::GUI
# by Laurent ROCHER (lr...@cp...)
#------------------------------------------------------------------------
#perl2exe_bundle 'SciLexer.dll'

package Win32::GUI::Scintilla;

use vars qw($ABSTRACT $VERSION @ISA @EXPORT @EXPORT_OK $AUTOLOAD);
use Win32::GUI;
use Config;

require Exporter;
require DynaLoader;
require AutoLoader;

@ISA = qw(Exporter DynaLoader Win32::GUI::Window);

$VERSION = '1.7';

bootstrap Win32::GUI::Scintilla $VERSION;

#------------------------------------------------------------------------

# Load Scintilla DLL from perl directory or standard LoadLibrary search
my $SCILEXER_PATH = $Config{'installsitelib'} . '\auto\Win32\GUI\Scintilla\SciLexer.DLL';
my $SCINTILLA_DLL = Win32::GUI::LoadLibrary($SCILEXER_PATH) || Win32::GUI::LoadLibrary('SciLexer.DLL');

Win32::GUI::Scintilla::_Initialise();

END {
  # Free Scintilla DLL
  Win32::GUI::FreeLibrary($SCINTILLA_DLL);
  Win32::GUI::Scintilla::_UnInitialise();
}

#------------------------------------------------------------------------

#
# Notify event code
#

use constant SCN_STYLENEEDED        => 2000;
use constant SCN_CHARADDED          => 2001;
use constant SCN_SAVEPOINTREACHED   => 2002;
use constant SCN_SAVEPOINTLEFT      => 2003;
use constant SCN_MODIFYATTEMPTRO    => 2004;
use constant SCN_KEY                => 2005;
use constant SCN_DOUBLECLICK        => 2006;
use constant SCN_UPDATEUI           => 2007;
use constant SCN_MODIFIED           => 2008;
use constant SCN_MACRORECORD        => 2009;
use constant SCN_MARGINCLICK        => 2010;
use constant SCN_NEEDSHOWN          => 2011;
use constant SCN_PAINTED            => 2013;
use constant SCN_USERLISTSELECTION  => 2014;
use constant SCN_URIDROPPED         => 2015;
use constant SCN_DWELLSTART         => 2016;
use constant SCN_DWELLEND           => 2017;
use constant SCN_ZOOM               => 2018;
use constant SCN_HOTSPOTCLICK       => 2019;
use constant SCN_HOTSPOTDOUBLECLICK => 2020;
use constant SCN_CALLTIPCLICK       => 2021;

#------------------------------------------------------------------------

#
# New scintilla control
#

sub new {

  my $class  = shift;

  my (%in)   = @_;
  my %out;

  ### Filtering option
  for my $option qw(
        -name -parent
        -left -top -width -height -pos -size
        -pushstyle -addstyle -popstyle -remstyle -notstyle -negstyle
        -exstyle -pushexstyle -addexstyle -popexstyle -remexstyle -notexstyle
        ) {
    $out{$option} = $in{$option} if exists $in{$option};
  }

  ### Default window
  my $constant     = Win32::GUI::constant("WIN32__GUI__STATIC", 0);
  $out{-style}     = WS_CLIPCHILDREN;
  $out{-class}     = "Scintilla";

  ### Window style
  $out{-style} |= WS_TABSTOP unless exists $in{-tabstop} && $in{-tabstop} == 0;         #Default to -tabstop => 1
  $out{-style} |= WS_VISIBLE unless exists $in{-visible} && $in{-visible} == 0;         #Default to -visible => 1
  $out{-style} |= WS_HSCROLL if     exists $in{-hscroll} && $in{-hscroll} == 1;
  $out{-style} |= WS_VSCROLL if     exists $in{-vscroll} && $in{-vscroll} == 1;

  my $self = Win32::GUI->_new($constant, $class, %out);
  if (defined ($self)) {

    # Option Text :
    $self->SetText($in{-text}) if exists $in{-text};
    $self->SetReadOnly($in{-readonly}) if exists $in{-readonly};
  }

  return $self;
}

#
# Win32 shortcut
#

sub Win32::GUI::Window::AddScintilla {
  my $parent  = shift;
  return Win32::GUI::Scintilla->new (-parent => $parent, @_);
}

#------------------------------------------------------------------------
# Miscolous function
#------------------------------------------------------------------------

#
# Clear Scintilla Text
#

sub NewFile {
  my $self = shift;

  $self->ClearAll();
  $self->EmptyUndoBuffer();
  $self->SetSavePoint();
}

#
# Load text file to Scintilla
#

sub LoadFile {
  my ($self, $file) = @_;

  $self->ClearAll();
  $self->Cancel();
  $self->SetUndoCollection(0);

  open F, "<$file" or return 0;
  while ( <F> ) {
    $self->AppendText($_);
  }
  close F;

  $self->SetUndoCollection(1);
  $self->EmptyUndoBuffer();
  $self->SetSavePoint();
  $self->GotoPos(0);

  return 1;
}

#
# Save Scintilla text to file
#

sub SaveFile {
  my ($self, $file) = @_;

  open F, ">$file" or return 0;

  for my $i (0..$self->GetLineCount()) {
    print F $self->GetLine ($i);
  }

  close F;

  $self->SetSavePoint();

  return 1;
}

#
# Help routine for StyleSet
#

sub StyleSetSpec {
  my ($self, $style, $textstyle) = @_;

  foreach my $prop (split (/,/, $textstyle)) {

    my ($key, $value) = split (/:/, $prop);

    $self->StyleSetFore($style, $value) if $key eq 'fore';
    $self->StyleSetBack($style, $value) if $key eq 'back';

    $self->StyleSetFont($style, $value) if $key eq 'face';

    $self->StyleSetSize($style, int ($value) )  if $key eq 'size';

    $self->StyleSetBold($style, 1)      if $key eq 'bold';
    $self->StyleSetBold($style, 0)      if $key eq 'notbold';
    $self->StyleSetItalic($style, 1)    if $key eq 'italic';
    $self->StyleSetItalic($style, 0)    if $key eq 'notitalic';
    $self->StyleSetUnderline($style, 1) if $key eq 'underline';
    $self->StyleSetUnderline($style, 0) if $key eq 'notunderline';
    $self->StyleSetEOLFilled ($style, 1) if $key eq 'eolfilled';
    $self->StyleSetEOLFilled ($style, 0) if $key eq 'noteolfilled';
  }
}

#------------------------------------------------------------------------
# Begin Autogenerate
#------------------------------------------------------------------------


--- NEW FILE: Scintilla.html ---
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Win32::GUI::Scintilla - Add Scintilla edit control to Win32::GUI</title>
<link rev="made" href="mailto:" />
</head>

<body style="background-color: white">

<p><a name="__index__"></a></p>
<!-- INDEX BEGIN -->

<ul>

	<li><a href="#name">NAME</a></li>
	<li><a href="#synopsis">SYNOPSIS</a></li>
	<li><a href="#description">DESCRIPTION</a></li>
	<ul>

[...3150 lines suppressed...]
  See comment for relation between Lexer language and lexer constante.</pre>
</dd>
</dl>
<p>
</p>
<hr />
<h1><a name="author">AUTHOR</a></h1>
<pre>
  Laurent Rocher (lr...@cp...)
  HomePage :<a href="http://perso.club-internet.fr/rocherl/Win32GUI.html">http://perso.club-internet.fr/rocherl/Win32GUI.html</a></pre>
<p>
</p>
<hr />
<h1><a name="see_also">SEE ALSO</a></h1>
<pre>
  Win32::GUI</pre>

</body>

</html>

--- NEW FILE: Perl.pm ---
=head1 NAME

Win32::GUI::Scintilla::Perl -- Scintilla control with Perl
awareness.

=head1 SYNOPSIS

        use Win32::GUI::Scintilla::Perl;

        my $win = #Create window here

        my $sciViewer = $winMain->AddScintillaPerl  (
                -name    => "sciViewer",
                -left   => 0,
                -top    => 30,
                -width  => 400,
                -height => 240,
                -addexstyle => WS_EX_CLIENTEDGE,
                );

        #Change look and feel to your liking here.

=cut

package Win32::GUI::Scintilla::Perl;

use strict;
use Win32::GUI::Scintilla;

=head1 METHODS

=head2 new(%hOption)

Create a Win32::GUI::Scintilla control which is in "Perl
mode". Other than this, it's a regular Scintilla object.

You can override any setting afterward.

=cut

my %hFontFace = (
                'times'  => 'Times New Roman',
                'mono'   => 'Courier New',
                'helv'   => 'Lucida Console',
                'lucida' => 'Lucida Console',
                'other'  => 'Comic Sans MS',
                'size'   => '10',
                'size2'  => '9',
                'backcol'=> '#FFFFFF',
                );

my $keywordPerl = q{
NULL __FILE__ __LINE__ __PACKAGE__ __DATA__ __END__ AUTOLOAD
BEGIN CORE DESTROY END EQ GE GT INIT LE LT NE CHECK abs accept
alarm and atan2 bind binmode bless caller chdir chmod chomp chop
chown chr chroot close closedir cmp connect continue cos crypt
dbmclose dbmopen defined delete die do dump each else elsif endgrent
endhostent endnetent endprotoent endpwent endservent eof eq eval
exec exists exit exp fcntl fileno flock for foreach fork format
formline ge getc getgrent getgrgid getgrnam gethostbyaddr gethostbyname
gethostent getlogin getnetbyaddr getnetbyname getnetent getpeername
getpgrp getppid getpriority getprotobyname getprotobynumber getprotoent
getpwent getpwnam getpwuid getservbyname getservbyport getservent
getsockname getsockopt glob gmtime goto grep gt hex if index
int ioctl join keys kill last lc lcfirst le length link listen
local localtime lock log lstat lt m map mkdir msgctl msgget msgrcv
msgsnd my ne next no not oct open opendir or ord our pack package
pipe pop pos print printf prototype push q qq qr quotemeta qu
qw qx rand read readdir readline readlink readpipe recv redo
ref rename require reset return reverse rewinddir rindex rmdir
s scalar seek seekdir select semctl semget semop send setgrent
sethostent setnetent setpgrp setpriority setprotoent setpwent
setservent setsockopt shift shmctl shmget shmread shmwrite shutdown
sin sleep socket socketpair sort splice split sprintf sqrt srand
stat study sub substr symlink syscall sysopen sysread sysseek
system syswrite tell telldir tie tied time times tr truncate
uc ucfirst umask undef unless unlink unpack unshift untie until
use utime values vec wait waitpid wantarray warn while write
x xor y
};

sub new {
  my $pkg = shift;
  $pkg = ref($pkg) || $pkg;
  my $sci = Win32::GUI::Scintilla->new(@_) or return(undef);

  SetupPerl($sci) or return(undef);

  return($sci);
}

=head1 ROUTINES

=head2 SetupPerl($sciControl)

Setup $sciControl in Perl mode.

Return 1 on success, else 0.

=cut
sub SetupPerl {
  my ($sci) = @_;

  # Set Perl Lexer
  $sci->SetLexer(Win32::GUI::Scintilla::SCLEX_PERL);

  # Set Perl Keyword
  $sci->SetKeyWords(0, $keywordPerl);

  # Folder ????
  $sci->SetProperty("fold", "1");
  $sci->SetProperty("tab.timmy.whinge.level", "1");

  # Indenetation
  $sci->SetIndentationGuides(1);
  $sci->SetUseTabs(1);
  $sci->SetTabWidth(4);
  $sci->SetIndent(4);

  # Edge Mode
  $sci->SetEdgeMode(Win32::GUI::Scintilla::EDGE_LINE); #Win32::GUI::Scintilla::EDGE_BACKGROUND
  $sci->SetEdgeColumn(80);

  # Define margin
  # $sci->SetMargins(0,0);
  $sci->SetMarginTypeN(1, Win32::GUI::Scintilla::SC_MARGIN_NUMBER);
  $sci->SetMarginWidthN(1, 25);

  $sci->SetMarginTypeN(2, Win32::GUI::Scintilla::SC_MARGIN_SYMBOL);
  $sci->SetMarginMaskN(2, Win32::GUI::Scintilla::SC_MASK_FOLDERS);
  $sci->SetMarginSensitiveN(2, 1);
  $sci->SetMarginWidthN(2, 12);

  # Define marker
  $sci->MarkerDefine(Win32::GUI::Scintilla::SC_MARKNUM_FOLDEREND,     Win32::GUI::Scintilla::SC_MARK_BOXPLUSCONNECTED);
  $sci->MarkerSetFore(Win32::GUI::Scintilla::SC_MARKNUM_FOLDEREND, '#FFFFFF');
  $sci->MarkerSetBack(Win32::GUI::Scintilla::SC_MARKNUM_FOLDEREND, '#000000');
  $sci->MarkerDefine(Win32::GUI::Scintilla::SC_MARKNUM_FOLDEROPENMID, Win32::GUI::Scintilla::SC_MARK_BOXMINUSCONNECTED);
  $sci->MarkerSetFore(Win32::GUI::Scintilla::SC_MARKNUM_FOLDEROPENMID, '#FFFFFF');
  $sci->MarkerSetBack(Win32::GUI::Scintilla::SC_MARKNUM_FOLDEROPENMID, '#000000');
  $sci->MarkerDefine(Win32::GUI::Scintilla::SC_MARKNUM_FOLDERMIDTAIL, Win32::GUI::Scintilla::SC_MARK_TCORNER);
  $sci->MarkerSetFore(Win32::GUI::Scintilla::SC_MARKNUM_FOLDERMIDTAIL, '#FFFFFF');
  $sci->MarkerSetBack(Win32::GUI::Scintilla::SC_MARKNUM_FOLDERMIDTAIL, '#000000');
  $sci->MarkerDefine(Win32::GUI::Scintilla::SC_MARKNUM_FOLDERTAIL,    Win32::GUI::Scintilla::SC_MARK_LCORNER);
  $sci->MarkerSetFore(Win32::GUI::Scintilla::SC_MARKNUM_FOLDERTAIL, '#FFFFFF');
  $sci->MarkerSetBack(Win32::GUI::Scintilla::SC_MARKNUM_FOLDERTAIL, '#000000');
  $sci->MarkerDefine(Win32::GUI::Scintilla::SC_MARKNUM_FOLDERSUB,     Win32::GUI::Scintilla::SC_MARK_VLINE);
  $sci->MarkerSetFore(Win32::GUI::Scintilla::SC_MARKNUM_FOLDERSUB, '#FFFFFF');
  $sci->MarkerSetBack(Win32::GUI::Scintilla::SC_MARKNUM_FOLDERSUB, '#000000');
  $sci->MarkerDefine(Win32::GUI::Scintilla::SC_MARKNUM_FOLDER,        Win32::GUI::Scintilla::SC_MARK_BOXPLUS);
  $sci->MarkerSetFore(Win32::GUI::Scintilla::SC_MARKNUM_FOLDER, '#FFFFFF');
  $sci->MarkerSetBack(Win32::GUI::Scintilla::SC_MARKNUM_FOLDER, '#000000');
  $sci->MarkerDefine(Win32::GUI::Scintilla::SC_MARKNUM_FOLDEROPEN,    Win32::GUI::Scintilla::SC_MARK_BOXMINUS);
  $sci->MarkerSetFore(Win32::GUI::Scintilla::SC_MARKNUM_FOLDEROPEN, '#FFFFFF');
  $sci->MarkerSetBack(Win32::GUI::Scintilla::SC_MARKNUM_FOLDEROPEN, '#000000');

  # Define Style
  $sci->StyleClearAll();

  # Global default styles for all languages
  $sci->StyleSetSpec(Win32::GUI::Scintilla::STYLE_DEFAULT,     "face:$hFontFace{'mono'},size:$hFontFace{'size'}");
  $sci->StyleSetSpec(Win32::GUI::Scintilla::STYLE_LINENUMBER,  "back:#C0C0C0,face:$hFontFace{mono}");
  $sci->StyleSetSpec(Win32::GUI::Scintilla::STYLE_CONTROLCHAR, "face:$hFontFace{mono}");
  $sci->StyleSetSpec(Win32::GUI::Scintilla::STYLE_BRACELIGHT,  "fore:#FFFFFF,back:#0000FF,bold");
  $sci->StyleSetSpec(Win32::GUI::Scintilla::STYLE_BRACEBAD,    "fore:#000000,back:#FF0000,bold");

  # White space
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_DEFAULT, "fore:#808080,face:$hFontFace{'mono'}");
  # Error
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_ERROR , "fore:#0000FF");
  # Comment
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_COMMENTLINE, "fore:#007F00");
  # POD: = at beginning of line
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_POD, "fore:#004000,back:#E0FFE0,eolfilled");
  # Number
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_NUMBER, "fore:#007F7F");
  # Keyword
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_WORD , "fore:#00007F,bold");
  # Double quoted string
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_STRING, "fore:#7F007F,face:$hFontFace{'mono'},italic");
  # Single quoted string
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_CHARACTER, "fore:#7F0000,face:$hFontFace{'mono'},italic");
  # Symbols / Punctuation. Currently not used by LexPerl.
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_PUNCTUATION, "fore:#00007F,bold");
  # Preprocessor. Currently not used by LexPerl.
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_PREPROCESSOR, "fore:#00007F,bold");
  # Operators
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_OPERATOR , "bold");
  # Identifiers (functions, etc.)
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_IDENTIFIER , "fore:#000000");
  # Scalars: $var
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_SCALAR, "fore:#000000,back:#FFE0E0");
  # Array: @var
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_ARRAY, "fore:#000000,back:#FFFFE0");
  # Hash: %var
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_HASH, "fore:#000000,back:#FFE0FF");
  # Symbol table: *var
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_SYMBOLTABLE, "fore:#000000,back:#E0E0E0");
  # Regex: /re/ or m{re}
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_REGEX, "fore:#000000,back:#A0FFA0");
  # Substitution: s/re/ore/
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_REGSUBST, "fore:#000000,back:#F0E080");
  # Long Quote (qq, qr, qw, qx) -- obsolete: replaced by qq, qx, qr, qw
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_LONGQUOTE, "fore:#FFFF00,back:#8080A0");
  # Back Ticks
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_BACKTICKS, "fore:#FFFF00,back:#A08080");
  # Data Section: __DATA__ or __END__ at beginning of line
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_DATASECTION, "#600000,back:#FFF0D8,eolfilled");
  # Here-doc (delimiter)
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_HERE_DELIM, "fore:#000000,back:#DDD0DD");
  # Here-doc (single quoted, q)
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_HERE_Q, "fore:#7F007F,back:#DDD0DD,eolfilled,notbold");
  # Here-doc (double quoted, qq)
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_HERE_QQ, "fore:#7F007F,back:#DDD0DD,eolfilled,bold");
  # Here-doc (back ticks, qx)
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_HERE_QX, "fore:#7F007F,back:#DDD0DD,eolfilled,italics");
  # Single quoted string, generic
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_STRING_Q, "fore:#7F007F,notbold");
  # qq = Double quoted string
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_STRING_QQ, "fore:#7F007F,italic");
  # qx = Back ticks
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_STRING_QX, "fore:#FFFF00,back:#A08080");
  # qr = Regex
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_STRING_QR, "fore:#000000,back:#A0FFA0");
  # qw = Array
  $sci->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_STRING_QW, "fore:#000000,back:#FFFFE0");

  return(1);
}

=head1 Win32::GUI::Window methods

=head2 AddScintillaPerl

Create and add a Win32::GUI::Scintilla::Perl control to this
window.

=cut
sub Win32::GUI::Window::AddScintillaPerl {
  my $parent  = shift;
  return Win32::GUI::Scintilla::Perl->new (-parent => $parent, @_);
}

1;

=head1 AUTHOR

Laurent Rocher (the hard work) and Johan Lindström (subclassing).

Same license as Perl.

=cut

__END__

--- NEW FILE: README ---
Win32::GUI::Scintilla version 1.7
=================================

Win32::GUI::Scintilla - Add Scintilla edit control to Win32::GUI

INSTALLATION

To install this module type the following:

   perl Makefile.PL
   make
   make install

Makefile.pl notes:
  - Scintilla.pm is create by /include/autogen.pl by Makefile.PL.
    it use Scintilla.iface, Scintilla.pm.begin and Scintilla.pm.end.
  - Makefile.pl copy ./include/SciLexer.dll to .\blib\arch\auto\Win32\GUI\Scintilla\SciLexer.dll

DEPENDENCIES

This module requires these other modules and libraries:

   Win32::GUI   
   Scintilla (http:/www.scintilla.org/)

WEB PAGE AND PPM REPOSITORY

See: http://perso.club-internet.fr/rocherl/Win32GUI.html

COPYRIGHT AND LICENCE

Copyright 2003 by Laurent Rocher (lr...@cp...).

This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.

See <http://www.perl.com/perl/misc/Artistic.html>.


--- NEW FILE: Scintilla.pm ---
#------------------------------------------------------------------------
# Scintilla control for Win32::GUI
# by Laurent ROCHER (lr...@cp...)
#------------------------------------------------------------------------
#perl2exe_bundle 'SciLexer.dll'

package Win32::GUI::Scintilla;

use vars qw($ABSTRACT $VERSION @ISA @EXPORT @EXPORT_OK $AUTOLOAD);
use Win32::GUI;
use Config;

require Exporter;
require DynaLoader;
require AutoLoader;

@ISA = qw(Exporter DynaLoader Win32::GUI::Window);

$VERSION = '1.7';
[...5864 lines suppressed...]

=item C<Lexer constant>

  See Scintilla.pm

  SCLEX_* contante for lexer language.
  SCE_* for lexer constante.

  See comment for relation between Lexer language and lexer constante.

=head1 AUTHOR

  Laurent Rocher (lr...@cp...)
  HomePage :http://perso.club-internet.fr/rocherl/Win32GUI.html

=head1 SEE ALSO

  Win32::GUI

=cut

--- NEW FILE: Scintilla.xs ---
/**********************************************************************/
/*                    S c i n t i l l a . x s                         */
/**********************************************************************/

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include <windows.h>
#include "./include/Scintilla.h"

/*====================================================================*/
/*                       W I N 3 2 : : G U I                          */
/*====================================================================*/

#define MAX_WINDOW_NAME 128

/*
 * Various definitions to accomodate the different Perl versions around
 */

#ifdef PERL_OBJECT
#   ifdef _INC_WIN32_PERL5
#       pragma message( "\n*** Using the 5.005 Perl Object CPerlObj class.\n" )
#       define NOTXSPROC   CPerlObj *pPerl,
#       define NOTXSCALL   pPerl,
#       define CPerl CPerlObj
#   else // not _INC_WIN32_PERL5
#       pragma message( "\n*** Using the 5.004 Perl Object CPerl class.\n" )
#       define NOTXSPROC   CPerl *pPerl,
#       define NOTXSCALL   pPerl,
#   endif  //  _INC_WIN32_PERL5
#else
#   pragma message( "\n*** Using a non-Object Core Perl.\n" )
#   define NOTXSPROC
#   define NOTXSCALL
#endif

/*
 * what we'll store in GWL_USERDATA
 */
typedef struct tagPERLWIN32GUI_USERDATA {
        DWORD           dwSize;                                                 // struct size (our signature)
#ifdef PERL_OBJECT
        CPerl           *pPerl;                                                 // a pointer to the Perl Object
#endif
        SV*             svSelf;                                                 // a pointer to ourself
        char            szWindowName[MAX_WINDOW_NAME];  // our -name
        BOOL            fDialogUI;                                              // are we to intercept dialog messages?
        int             iClass;                                                 // our (Perl) class
        HACCEL          hAcc;                                                   // our accelerator table
        HWND            hTooltip;
        HCURSOR         hCursor;
        DWORD           dwPlStyle;
        int             iMinWidth;
        int             iMaxWidth;
        int             iMinHeight;
        int             iMaxHeight;
        COLORREF        clrForeground;
        COLORREF        clrBackground;
        HBRUSH          hBackgroundBrush;
        WNDPROC         wndprocPreContainer;
        WNDPROC         wndprocPreNEM;
        int             iEventModel;
        HV*             hvEvents;
        DWORD           dwEventMask;
        HWND            Modal;
} PERLWIN32GUI_USERDATA, *LPPERLWIN32GUI_USERDATA;


BOOL ProcessEventError(NOTXSPROC char *Name, int* PerlResult) {
    if(strncmp(Name, "main::", 6) == 0) Name += 6;
    if(SvTRUE(ERRSV)) {
        MessageBeep(MB_ICONASTERISK);
        *PerlResult = MessageBox(
            NULL,
            SvPV_nolen(ERRSV),
            Name,
            MB_ICONERROR | MB_OKCANCEL
        );
        if(*PerlResult == IDCANCEL) {
            *PerlResult = -1;
        }
        return TRUE;
    } else {
        return FALSE;
    }
}


/*====================================================================*/
/*                   H O O K   F U N C T I O N                        */
/*====================================================================*/

typedef struct SCNotification * pSCNotification;

/*
struct SCNotification {
        struct NotifyHeader nmhdr;
        int position;   // SCN_STYLENEEDED, SCN_MODIFIED, SCN_DWELLSTART, SCN_DWELLEND
        int ch;         // SCN_CHARADDED, SCN_KEY
        int modifiers;  // SCN_KEY
        int modificationType;   // SCN_MODIFIED
        const char *text;       // SCN_MODIFIED
        int length;             // SCN_MODIFIED
        int linesAdded; // SCN_MODIFIED
        int message;    // SCN_MACRORECORD
        uptr_t wParam;  // SCN_MACRORECORD
        sptr_t lParam;  // SCN_MACRORECORD
        int line;               // SCN_MODIFIED
        int foldLevelNow;       // SCN_MODIFIED
        int foldLevelPrev;      // SCN_MODIFIED
        int margin;             // SCN_MARGINCLICK
        int listType;   // SCN_USERLISTSELECTION
        int x;                  // SCN_DWELLSTART, SCN_DWELLEND
        int y;          // SCN_DWELLSTART, SCN_DWELLEND
};
*/


int DoEvent (NOTXSPROC char *Name, UINT code, pSCNotification evt) {
    int PerlResult;
    int count;
    PerlResult = 1;
    if(perl_get_cv(Name, FALSE) != NULL) {
        dSP;
        dTARG;
        ENTER;
        SAVETMPS;
        PUSHMARK(SP);
        XPUSHs(sv_2mortal(newSVpv("-code", 0)));
        XPUSHs(sv_2mortal(newSViv(code)));
        if (code == SCN_STYLENEEDED || code == SCN_MODIFIED || code == SCN_DWELLSTART ||
            code == SCN_DWELLEND || code == SCN_MARGINCLICK ||
            code == SCN_HOTSPOTCLICK || code == SCN_HOTSPOTDOUBLECLICK ||
            code == SCN_CALLTIPCLICK)
        {
          XPUSHs(sv_2mortal(newSVpv("-position", 0)));
          XPUSHs(sv_2mortal(newSViv(evt->position)));
        }
        if (code == SCN_CHARADDED || code == SCN_KEY)
        {
          XPUSHs(sv_2mortal(newSVpv("-ch", 0)));
          XPUSHs(sv_2mortal(newSViv(evt->ch)));
        }
        if (code == SCN_KEY || code == SCN_MARGINCLICK ||
            code == SCN_HOTSPOTCLICK || code == SCN_HOTSPOTDOUBLECLICK)
        {
          XPUSHs(sv_2mortal(newSVpv("-modifiers", 0)));
          XPUSHs(sv_2mortal(newSViv(evt->modifiers)));

          XPUSHs(sv_2mortal(newSVpv("-shift", 0)));
          XPUSHs(sv_2mortal(newSViv(evt->modifiers & SCMOD_SHIFT)));

          XPUSHs(sv_2mortal(newSVpv("-control", 0)));
          XPUSHs(sv_2mortal(newSViv(evt->modifiers & SCMOD_CTRL)));

          XPUSHs(sv_2mortal(newSVpv("-alt", 0)));
          XPUSHs(sv_2mortal(newSViv(evt->modifiers & SCMOD_ALT)));
        }
        if (code == SCN_MODIFIED )
        {
          XPUSHs(sv_2mortal(newSVpv("-modificationType", 0)));
          XPUSHs(sv_2mortal(newSViv(evt->modificationType)));
//          XPUSHs(sv_2mortal(newSVpv("-text", 0)));
//          XPUSHs(sv_2mortal(newSVpv(evt->text, 0)));
          XPUSHs(sv_2mortal(newSVpv("-length", 0)));
          XPUSHs(sv_2mortal(newSViv(evt->length)));
          XPUSHs(sv_2mortal(newSVpv("-linesAdded", 0)));
          XPUSHs(sv_2mortal(newSViv(evt->linesAdded)));
          XPUSHs(sv_2mortal(newSVpv("-line", 0)));
          XPUSHs(sv_2mortal(newSViv(evt->line)));
          XPUSHs(sv_2mortal(newSVpv("-foldLevelNow", 0)));
          XPUSHs(sv_2mortal(newSViv(evt->foldLevelNow)));
          XPUSHs(sv_2mortal(newSVpv("-foldLevelPrev", 0)));
          XPUSHs(sv_2mortal(newSViv(evt->foldLevelPrev)));
        }
        if (code == SCN_MACRORECORD)
        {
          XPUSHs(sv_2mortal(newSVpv("-message", 0)));
          XPUSHs(sv_2mortal(newSViv(evt->message)));
        }
        if (code == SCN_MARGINCLICK)
        {
          XPUSHs(sv_2mortal(newSVpv("-margin", 0)));
          XPUSHs(sv_2mortal(newSViv(evt->margin)));
        }
        if (code == SCN_USERLISTSELECTION)
        {
          XPUSHs(sv_2mortal(newSVpv("-listType", 0)));
          XPUSHs(sv_2mortal(newSViv((int) evt->wParam))); // ???
//          XPUSHs(sv_2mortal(newSViv(evt->listType)));
//          XPUSHs(sv_2mortal(newSVpv("-text", 0)));
//          XPUSHs(sv_2mortal(newSVpv(evt->text, 0)));
        }
        if (code == SCN_DWELLSTART || code == SCN_DWELLEND)
        {
          XPUSHs(sv_2mortal(newSVpv("-x", 0)));
          XPUSHs(sv_2mortal(newSViv(evt->x)));
          XPUSHs(sv_2mortal(newSVpv("-y", 0)));
          XPUSHs(sv_2mortal(newSViv(evt->y)));
        }
        PUTBACK;
        count = perl_call_pv(Name, G_EVAL|G_ARRAY);
        SPAGAIN;
        if(!ProcessEventError(NOTXSCALL Name, &PerlResult)) {
            if(count > 0) PerlResult = POPi;
        }
        PUTBACK;
        FREETMPS;
        LEAVE;
    }
    return PerlResult;
}

int DoEvent_Generic(NOTXSPROC char *Name)
{
    int PerlResult;
    int count;
    PerlResult = 1;

    if(perl_get_cv(Name, FALSE) != NULL) {
        dSP;
        dTARG;
        ENTER;
        SAVETMPS;
        PUSHMARK(SP);
        PUTBACK;
        count = perl_call_pv(Name, G_EVAL|G_NOARGS);
        SPAGAIN;
        if(!ProcessEventError(NOTXSCALL Name, &PerlResult))
        {
            if(count > 0) PerlResult = POPi;
        }
        PUTBACK;
        FREETMPS;
        LEAVE;
    }
    return PerlResult;
}


HHOOK hhook;

LRESULT WINAPI CallWndProc(int nCode, WPARAM wParam, LPARAM lParam)
{
    CWPSTRUCT * msg = (CWPSTRUCT *) lParam;

    if (nCode >= 0 && msg->message == WM_NOTIFY)
    {
      NMHDR *lpnmhdr = (LPNMHDR) msg->lParam;
      char Name [255];

      // Read Sender Class
      GetClassName (lpnmhdr->hwndFrom, Name, 255);

      if (memcmp (Name, "Scintilla", 9) == 0)
      {

         // Perl contexte
#ifdef PERL_OBJECT
         CPerl *pPerl;
#endif
        LPPERLWIN32GUI_USERDATA perlud = (LPPERLWIN32GUI_USERDATA) GetWindowLong(lpnmhdr->hwndFrom, GWL_USERDATA);

        if (perlud != NULL)
        {

#ifdef PERL_OBJECT
         pPerl = perlud->pPerl;
#endif

          // Build name
          strcpy(Name, "main::");
          strcat(Name, (char *) perlud->szWindowName);
          strcat(Name, "_Notify");

          DoEvent(NOTXSCALL Name, lpnmhdr->code, (pSCNotification) msg->lParam);
        }
      }
    }
    else if (nCode >= 0 && msg->message == WM_COMMAND && msg->lParam != 0)
    {
      char Name [255];

      // Read Sender Class
      GetClassName ((HWND) msg->lParam, Name, 255);

      if (memcmp (Name, "Scintilla", 9) == 0)
      {
         // Perl contexte
#ifdef PERL_OBJECT
         CPerl *pPerl;
#endif
        LPPERLWIN32GUI_USERDATA perlud = (LPPERLWIN32GUI_USERDATA) GetWindowLong((HWND) msg->lParam, GWL_USERDATA);
        if (perlud != NULL)
        {

#ifdef PERL_OBJECT
          pPerl = perlud->pPerl;
#endif
          // Build name
          strcpy(Name, "main::");
          strcat(Name, (char *) perlud->szWindowName);

          switch (HIWORD(msg->wParam))
          {
          case SCEN_CHANGE :
            strcat(Name, "_Change");
            DoEvent_Generic (NOTXSCALL Name);
            break;
          case SCEN_SETFOCUS :
            strcat(Name, "_GotFocus");
            DoEvent_Generic (NOTXSCALL Name);
            break;
          case SCEN_KILLFOCUS :
            strcat(Name, "_LostFocus");
            DoEvent_Generic (NOTXSCALL Name);
            break;
          }
        }
      }
    }

    return CallNextHookEx(hhook, nCode, wParam, lParam);
}

/*====================================================================*/
/*                Win32::GUI::Scintilla    package                    */
/*====================================================================*/

MODULE = Win32::GUI::Scintilla          PACKAGE = Win32::GUI::Scintilla

    ###########################################################################
    # _Initialise() (internal)
    # Install Hook function

void
_Initialise()
PREINIT:
CODE:
  hhook = SetWindowsHookEx(WH_CALLWNDPROC, CallWndProc, (HINSTANCE) NULL, GetCurrentThreadId());

    ###########################################################################
    # _UnInitialise() (internal)
    # Release Hook function

void
_UnInitialise()
PREINIT:
CODE:
  UnhookWindowsHookEx (hhook);

    ###########################################################################
    # SendMessageNP : Posts a message to a window
    # Take WPARAM as int and LPARAM as a LPVOID

LRESULT
SendMessageNP(handle,msg,wparam,lparam)
    HWND handle
    UINT msg
    WPARAM wparam
    LPVOID lparam
CODE:
    RETVAL = SendMessage(handle, msg, (WPARAM) wparam, (LPARAM) lparam);
OUTPUT:
    RETVAL

    ###########################################################################
    # SendMessagePP : Posts a message to a window
    # Take WPARAM and LPARAM as a LPVOID

LRESULT
SendMessagePP(handle,msg,wparam,lparam)
    HWND handle
    UINT msg
    LPVOID wparam
    LPVOID lparam
CODE:
    RETVAL = SendMessage(handle, msg, (WPARAM) wparam, (LPARAM) lparam);
OUTPUT:
    RETVAL

--- NEW FILE: MANIFEST ---
Changes
Makefile.PL
MANIFEST
README
Scintilla.pm
Scintilla.xs
Scintilla.pm.begin
Scintilla.pm.end
Perl.pm
Typemap
Include/autogen.pl
Include/Readme.txt
Include/Scintilla.iface
Include/Scintilla.h
Include/SciLexer.dll
Samples/test.pl
Samples/test2.pl
Samples/Editor.pl
--- NEW FILE: Changes ---
Revision history for Perl extension Scintilla.

1.7  28/02/2004
        - Use Scintilla 1.59

1.6  30/11/2003
        - Use Scintilla 1.57
	- Rewrite Makefile.pl

1.5  28/10/2003
        - Use Scintilla 1.56

1.4  28/09/2003
        - Correct -visible and -tabstop option (thank to Johan Lindström)
        - Use Scintilla 1.55

1.3  27/05/2003
        - [UPDATE] Add Perl2Exe support (Automaticly add Scilexer.dll from current directory)
          Copy SciLexer.dll in script directory before run perl2exe.

1.2  26/05/2003
        - [BUG] Correct some bugs (thank to Jeremy White again)
        - Add Win32::GUI::Scintilla::Perl (thank to Johan Lindström)
        - Add FindAndSelect method for simplify text search.
        - Add Perl2Exe support (Automaticly add Scilexer.dll from current directory)
        - Use Scintilla 1.53

1.1  14/03/2003
        - [BUG] Correct LineLength call (thank to Jeremy White)
        - Add Change, LostFocus and GotFocus Events.
        - Use Scintilla 1.51

1.0  24/01/2003
        - First release

--- NEW FILE: Typemap ---
TYPEMAP
HWND         T_HANDLE
HTREEITEM    T_IV
LONG         T_IV
LPCTSTR      T_PV
LPTSTR       T_PV
DWORD        T_IV
UINT         T_IV
BOOL         T_IV
WPARAM       T_IV
LPARAM       T_IV
LRESULT      T_IV
HINSTANCE    T_IV
COLORREF     T_COLOR
LPCSTR       T_PV
FLOAT        T_FLOAT
LPVOID       T_PV

################################################################################
INPUT
T_HANDLE
    if(SvROK($arg)) {
        if(hv_fetch((HV*)SvRV($arg), \"-handle\", 7, 0) != NULL)
            $var = ($type) SvIV(*(hv_fetch((HV*)SvRV($arg), \"-handle\", 7, 0)));
        else
            $var = NULL;
    } else
        $var = ($type) SvIV($arg);

--- NEW FILE: Scintilla.pm.end ---

#------------------------------------------------------------------------
# End Autogenerate
#------------------------------------------------------------------------

# Code Here because need constant

#------------------------------------------------------------------------
# BraceHighEvent Management
#------------------------------------------------------------------------

sub BraceHighEvent {

  my $self   = shift;
  my $braces = shift || "[]{}()";

  my $braceAtCaret = -1;
  my $braceOpposite = -1;
  my $caretPos = $self->GetCurrentPos();
[...2435 lines suppressed...]

=item C<Lexer constant>

  See Scintilla.pm

  SCLEX_* contante for lexer language.
  SCE_* for lexer constante.

  See comment for relation between Lexer language and lexer constante.

=head1 AUTHOR

  Laurent Rocher (lr...@cp...)
  HomePage :http://perso.club-internet.fr/rocherl/Win32GUI.html

=head1 SEE ALSO

  Win32::GUI

=cut

Update of /cvsroot/perl-win32-gui/Win32-GUI-Scintilla/Include
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv23874/Include

Added Files:
	Readme.txt SciLexer.dll Scintilla.h Scintilla.iface autogen.pl 
Log Message:
Added to repository

--- NEW FILE: Scintilla.iface ---
## First line may be used for shbang

## This file defines the interface to Scintilla

## Copyright 2000-2003 by Neil Hodgson <ne...@sc...>
## The License.txt file describes the conditions under which this software may be distributed.

## A line starting with ## is a pure comment and should be stripped by readers.
## A line starting with #! is for future shbang use
## A line starting with # followed by a space is a documentation comment and refers
## to the next feature definition.

## Each feature is defined by a line starting with fun, get, set, val or evt.
##     cat -> start a category
##     fun -> a function
##     get -> a property get function
##     set -> a property set function
##     val -> definition of a constant
##     evt -> an event
[...2399 lines suppressed...]
evt void URIDropped=2015(string text)
evt void DwellStart=2016(int position)
evt void DwellEnd=2017(int position)
evt void Zoom=2018(void)
evt void HotSpotClick=2019(int modifiers, int position)
evt void HotSpotDoubleClick=2020(int modifiers, int position)
evt void CallTipClick=2021(int position)

cat Deprecated

# CARET_POLICY changed in 1.47
fun void SetCaretPolicy=2369(int caretPolicy, int caretSlop)
val CARET_CENTER=0x02
val CARET_XEVEN=0x08
val CARET_XJUMPS=0x10

# The old name for SCN_UPDATEUI
val SCN_CHECKBRACE=2007
evt void PosChanged=2012(int position)


--- NEW FILE: Readme.txt ---
Scilexer.dll    : Scintilla control with lexer.
Scintilla.h     : C include file of Scintilla control.
Scintilla.iface : Interface desciption of Scintilla control.
Autogen.pl      : Build Scintilla.pm from Scintilla.pm.begin, Scintilla.pm.end and Scintilla.iface.
--- NEW FILE: autogen.pl ---
#! perl

open G, ">Scintilla.pm" or return 1;

# Add Startup
open F, "<scintilla.pm.begin" or return 1;
while ( <F> )
{
  print G $_;
}
close F;

# Build Scintilla interface
open F, "<include/scintilla.iface" or return 2;
while ( <F> )
{
  #--- Constant ---
  if (/^val (.*)=(.*)$/)
  {
    print G "use constant $1 => $2 ;\n";
  }
  #--- Get ---
  elsif (/^get colour (.*)=(.*)\(,\)$/ )
  {
    print G "sub $1 {\n  my \$self = shift;\n  my \$colour = \$self->SendMessage ($2, 0, 0);\n  \$colour = sprintf ('#%x', \$colour);\n  \$colour =~ s/(.)(..)(..)(..)/\$1\$4\$3\$2/;\n  return \$colour;\n}\n";
  }
  elsif (/^get colour (.*)=(.*)\(int (.*),\)$/ )
  {
    print G "sub $1 {\n  my (\$self, \$$3) = \@_;\n  my \$colour = \$self->SendMessage ($2, \$$3, 0);\n  \$colour = sprintf ('#%x', \$colour);\n  \$colour =~ s/(.)(..)(..)(..)/\$1\$4\$3\$2/;\n  return \$colour;\n}";
  }
  elsif (/^get (.*) (.*)=(.*)\(,\)$/ )
  {
    print G "sub $2 {\n  my \$self = shift;\n  return \$self->SendMessage ($3, 0, 0);\n}\n";
  }
  elsif (/^get int GetCharAt=2007\(position pos,\)$/ )
  {
    print G "sub GetCharAt {\n  my (\$self, \$pos) = \@_;\n  return chr \$self->SendMessage (2007, \$pos, 0);\n}\n";
  }
  elsif (/^get (.*) (.*)=(.*)\(position (.*),\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4) = \@_;\n  return \$self->SendMessage ($3, \$$4, 0);\n}\n";
  }
  elsif (/^get (.*) (.*)=(.*)\(int (.*),\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4) = \@_;\n  return \$self->SendMessage ($3, \$$4, 0);\n}\n";
  }
  elsif (/^get (.*) (.*)=(.*)\(int (.*), int (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4, \$$5) = \@_;\n  return \$self->SendMessage ($3, \$$4, \$$5);\n}\n";
  }
  #--- Set ---
  elsif (/^set (.*) (.*)=(.*)\(,\)$/ )
  {
    print G "sub $2 {\n  my \$self = shift;\n  return \$self->SendMessage ($3, 0, 0);\n}\n";
  }
  elsif (/^set (.*) (.*)=(.*)\(bool (.*),\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4) = \@_;\n  return \$self->SendMessage ($3, \$$4, 0);\n}\n";
  }
  elsif (/^set (.*) (.*)=(.*)\(int (.*),\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4) = \@_;\n  return \$self->SendMessage ($3, \$$4, 0);\n}\n";
  }
  elsif (/^set (.*) (.*)=(.*)\(position (.*),\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4) = \@_;\n  return \$self->SendMessage ($3, \$$4, 0);\n}\n";
  }
  elsif (/^set (.*) (.*)=(.*)\(colour (.*),\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4) = \@_;\n  \$$4 =~ s/.(..)(..)(..)/\$3\$2\$1/;\n  return \$self->SendMessage ($3, int hex \$$4, 0);\n}\n";
  }
  elsif (/^set (.*) (.*)=(.*)\(int (.*), int (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4, \$$5) = \@_;\n  return \$self->SendMessage ($3, \$$4, \$$5);\n}\n";
  }
  elsif (/^set (.*) (.*)=(.*)\(int (.*), bool (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4, \$$5) = \@_;\n  return \$self->SendMessage ($3, \$$4, \$$5);\n}\n";
  }
  elsif (/^set (.*) (.*)=(.*)\(bool (.*), colour (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4, \$$5) = \@_;\n  \$$5 =~ s/.(..)(..)(..)/\$3\$2\$1/;\n  return \$self->SendMessage ($3, \$$4, int hex \$$5);\n}\n";
  }
  elsif (/^set (.*) (.*)=(.*)\(int (.*), colour (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4, \$$5) = \@_;\n  \$$5 =~ s/.(..)(..)(..)/\$3\$2\$1/;\n  return \$self->SendMessage ($3, \$$4, int hex \$$5);\n}\n";
  }
  elsif (/^set (.*) (.*)=(.*)\(int (.*), string (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4, \$$5) = \@_;\n  return \$self->SendMessageNP ($3, \$$4, \$$5);\n}\n";
  }
  elsif (/^set (.*) (.*)=(.*)\(string (.*), string (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4, \$$5) = \@_;\n  return \$self->SendMessagePP ($3, \$$4, \$$5);\n}\n";
  }
  elsif (/^set (.*) (.*)=(.*)\(, string (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4) = \@_;\n  return \$self->SendMessageNP ($3, 0, \$$4);\n}\n";
  }
  elsif (/^set (.*) (.*)=(.*)\(,\s?int (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4) = \@_;\n  return \$self->SendMessage ($3, 0, \$$4);\n}\n";
  }
  #--- Special Function ---
  # AddText, ReplaceTarget, ReplaceTargetRE, SearchInTarget, AppendText, CopyText
  elsif (/^fun (.*) (.*)=(.*)\(int length, string text\)$/ )
  {
    print G "# $2(text)\n";
    print G "sub $2 {\n";
    print G '  my ($self, $text) = @_;', "\n";
    print G '  my $length = length $text;', "\n";
    print G "  return \$self->SendMessageNP ($3, \$length, \$text);\n";
    print G '}', "\n";
  }
  # AddStyledText
  elsif (/^fun void AddStyledText=2002\(int length, cells c\)$/ )
  {
    print G '# AddStyledText(styledtext)', "\n";
    print G 'sub AddStyledText {', "\n";
    print G '  my ($self, $text) = @_;', "\n";
    print G '  my $length = length $text;', "\n";
    print G '  return $self->SendMessageNP (2002, $length, $text);', "\n";
    print G '}', "\n";
  }
  # GetStyledText and GetTextRange
  elsif (/^fun (.*) (.*)=(.*)\(, textrange (.*)\)$/ )
  {
    print G "sub $2 {\n  my \$self = shift;\n  my \$start = shift || 0;\n  my \$end = shift || \$self->GetLength();\n\n";
    print G "  return undef if \$start >= \$end;\n\n";
    if ( $2 eq 'GetStyledText')
    {
      print G "  my \$text = \" \" x ((\$end - \$start + 1)*2);\n";
    }
    else
    {
      print G "  my \$text = \" \" x (\$end - \$start + 1);\n";
    }
    print G "  my \$textrange = pack(\"LLp\", \$start, \$end, \$text);\n";
    print G "  \$self->SendMessageNP ($3, 0, \$textrange);\n";
    print G "  return \$text;\n}\n";
  }
  # GetCurLine
  elsif (/^fun int GetCurLine=2027\(int length, stringresult text\)$/)
  {
    print G '# GetCurline () : Return curent line Text', "\n";
    print G 'sub GetCurLine {', "\n";
    print G '  my ($self) = @_;',"\n";
    print G '  my $line   = $self->GetLineFromPosition ($self->GetCurrentPos());',"\n";
    print G '  my $lenght = $self->LineLength($line);',"\n";
    print G '  my $text   = " " x ($lenght+1);',"\n\n";
    print G '  if ($self->SendMessageNP (2027, $lenght, $text)) {',"\n";
    print G '    return $text;',"\n";
    print G '  } else {',"\n";
    print G '    return undef;',"\n";
    print G '  }',"\n";
    print G '}',"\n";
  }
  # GetLine
  elsif (/^fun int GetLine=2153\(int line, stringresult text\)/)
  {
    print G '# Getline (line)', "\n";
    print G 'sub GetLine {', "\n";
    print G '  my ($self, $line)  = @_;', "\n";
    print G '  my $lenght = $self->LineLength($line);', "\n";
    print G '  my $text   = " " x ($lenght + 1);', "\n\n";
    print G '  if ($self->SendMessageNP (2153, $line, $text)) {', "\n";
    print G '    return $text;', "\n";
    print G '  } else {', "\n";
    print G '    return undef;', "\n";
    print G '  }', "\n";
    print G '}', "\n";
  }

  # GetSelText
  elsif (/^fun int GetSelText=2161\(, stringresult text\)/)
  {
    print G '# GetSelText() : Return selected text', "\n";
    print G 'sub GetSelText {', "\n";
    print G '  my $self  = shift;', "\n";
    print G '  my $start = $self->GetSelectionStart();', "\n";
    print G '  my $end   = $self->GetSelectionEnd();', "\n\n";

    print G '  return undef if $start >= $end;', "\n";
    print G '  my $text   = " " x ($end - $start + 1);', "\n\n";

    print G '  $self->SendMessageNP (2161, 0, $text);', "\n";
    print G '  return $text;', "\n";
    print G '}', "\n";
  }
  # GetText :
  elsif (/^fun int GetText=2182\(int length, stringresult text\)/)
  {
    print G '# GetText() : Return all text', "\n";
    print G 'sub GetText {', "\n";
    print G '  my $self   = shift;', "\n";
    print G '  my $lenght = $self->GetTextLength() + 1;', "\n";
    print G '  my $text   = " " x ($lenght+1);', "\n\n";
    print G '  if ($self->SendMessageNP (2182, $lenght, $text)) {', "\n";
    print G '    return $text;', "\n";
    print G '  } else {', "\n";
    print G '    return undef;', "\n";
    print G '  }', "\n";
    print G '}', "\n";
  }
  # FindText :
  elsif (/^fun position FindText=2150\(int flags, findtext ft\)/)
  {
    print G '# FindText (textToFind, start=0, end=GetLength(), flag = SCFIND_WHOLEWORD)', "\n";
    print G 'sub FindText {', "\n";
    print G '  my $self       = shift;', "\n";
    print G '  my $text       = shift;', "\n";
    print G '  my $start      = shift || 0;', "\n";
    print G '  my $end        = shift || $self->GetLength();', "\n";
    print G '  my $flag       = shift || SCFIND_WHOLEWORD;', "\n\n";
    print G '  return undef if $start >= $end;', "\n\n";
    print G '  my $texttofind =  pack("LLpLL", $start, $end, $text, 0, 0);', "\n";
    print G '  my $pos = $self->SendMessageNP (2150, $flag, $texttofind);', "\n";
    print G '  return $pos unless defined wantarray;', "\n";
    print G '  my @res = unpack("LLpLL", $texttofind);', "\n";
    print G '  return ($res[3], $res[4]); # pos , lenght', "\n";
    print G '}', "\n";
  }
  # FindRange :
  elsif (/^fun position FormatRange=2151\(bool draw, formatrange fr\)/)
  {
    print G '# FormatRange (start=0, end=GetLength(), draw=1)', "\n";
    print G 'sub FormatRange {', "\n";
    print G '  my $self       = shift;', "\n";
    print G '  my $start      = shift || 0;', "\n";
    print G '  my $end        = shift || $self->GetLength();', "\n";
    print G '  my $draw       = shift || 1;', "\n";
    print G '  return undef if $start >= $end;', "\n\n";
    print G '  my $formatrange = pack("LL", $start, $end);', "\n";
    print G '  return $self->SendMessageNP (2151, $draw, $formatrange);', "\n";
    print G '}', "\n";
  }
  #--- Function ---
  elsif (/^fun (.*) (.*)=(.*)\(,\)$/ )
  {
    print G "sub $2 {\n  my \$self = shift;\n  return \$self->SendMessage ($3, 0, 0);\n}\n";
  }
  elsif (/^fun (.*) (.*)=(.*)\(bool (.*),\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4) = \@_;\n  return \$self->SendMessage ($3, \$$4, 0);\n}\n";
  }
  elsif (/^fun (.*) (.*)=(.*)\(int (.*),\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4) = \@_;\n  return \$self->SendMessage ($3, \$$4, 0);\n}\n";
  }
  elsif (/^fun (.*) (.*)=(.*)\(position (.*),\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4) = \@_;\n  return \$self->SendMessage ($3, \$$4, 0);\n}\n";
  }
  elsif (/^fun (.*) (.*)=(.*)\(, position (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4) = \@_;\n  return \$self->SendMessage ($3, 0, \$$4);\n}\n";
  }
  elsif (/^fun (.*) (.*)=(.*)\(int (.*), int (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4, \$$5) = \@_;\n  return \$self->SendMessage ($3, \$$4, \$$5);\n}\n";
  }
  elsif (/^fun (.*) (.*)=(.*)\(int (.*), colour (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4, \$$5) = \@_;\n  \$$5 =~ s/.(..)(..)(..)/\$3\$2\$1/;\n  return \$self->SendMessage ($3, \$$4, int hex \$$5);\n}\n";
  }
  elsif (/^fun (.*) (.*)=(.*)\(int (.*), string (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4, \$$5) = \@_;\n  return \$self->SendMessageNP ($3, \$$4, \$$5);\n}\n";
  }
  elsif (/^fun (.*) (.*)=(.*)\(, string (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4) = \@_;\n  return \$self->SendMessageNP ($3, 0, \$$4);\n}\n";
  }
  elsif (/^fun (.*) (.*)=(.*)\(, int (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4) = \@_;\n  return \$self->SendMessage ($3, 0, \$$4);\n}\n";
  }
  elsif (/^fun (.*) (.*)=(.*)\(position (.*), string (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4, \$$5) = \@_;\n  return \$self->SendMessageNP ($3, \$$4, \$$5);\n}\n";
  }
  elsif (/^fun (.*) (.*)=(.*)\(position (.*), bool (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4, \$$5) = \@_;\n  return \$self->SendMessage ($3, \$$4, \$$5);\n}\n";
  }
  elsif (/^fun (.*) (.*)=(.*)\(position (.*), int (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4, \$$5) = \@_;\n  return \$self->SendMessage ($3, \$$4, \$$5);\n}\n";
  }
  elsif (/^fun (.*) (.*)=(.*)\(position (.*), position (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4, \$$5) = \@_;\n  return \$self->SendMessage ($3, \$$4, \$$5);\n}\n";
  }
  elsif (/^fun (.*) (.*)=(.*)\(bool (.*), colour (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4, \$$5) = \@_;\n  \$$5 =~ s/.(..)(..)(..)/\$3\$2\$1/;\n  return \$self->SendMessage ($3, \$$4, int hex \$$5);\n}\n";
  }
  elsif (/^fun (.*) (.*)=(.*)\(int (.*), cells (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$$4, \$$5) = \@_;\n  return \$self->SendMessageNP ($3, \$$4, \$$5);\n}\n";
  }
  elsif (/^fun (.*) (.*)=(.*)\(keymod (.*),\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$key, \$modifiers) = \@_;\n";
    print G "  my \$param = pack ('ss', \$key, \$modifiers);\n";
    print G "  return \$self->SendMessage ($3, \$param, 0);\n}\n";
  }
  elsif (/^fun (.*) (.*)=(.*)\(keymod (.*), int (.*)\)$/ )
  {
    print G "sub $2 {\n  my (\$self, \$key, \$modifiers, \$$5) = \@_;\n";
    print G "  my \$param = pack ('ss', \$key, \$modifiers);\n";
    print G "  return \$self->SendMessage ($3, \$param, \$$5);\n}\n";
  }
  #--- Comment ---
  elsif (/^\#\s(.*)$/)
  {
    print G "# $1\n";
  }
  elsif (/^lex (.*)$/)
  {
    print G "# $1\n";
  }
  #--- Error ----
  elsif (/^fun (.*)$/)
  {
    print "===> Function = $1\n";
  }
  elsif (/^set (.*)$/)
  {
    print "===> Set      = $1\n";
  }
  elsif (/^get (.*)$/)
  {
    print "===> Get      = $1\n";
  }
}
close F;

# Add End
open F, "<scintilla.pm.end" or return 3;
while ( <F> )
{
  print G $_;
}
close F;

close G;

--- NEW FILE: SciLexer.dll ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: Scintilla.h ---
// Scintilla source code edit control
/** @file Scintilla.h
 ** Interface to the edit control.
 **/
// Copyright 1998-2003 by Neil Hodgson <ne...@sc...>
// The License.txt file describes the conditions under which this software may be distributed.

// Most of this file is automatically generated from the Scintilla.iface interface definition
// file which contains any comments about the definitions. HFacer.py does the generation.

#ifndef SCINTILLA_H
#define SCINTILLA_H

#if PLAT_WIN
// Return false on failure:
bool Scintilla_RegisterClasses(void *hInstance);
bool Scintilla_ReleaseResources();
#endif
int Scintilla_LinkLexers();

// Here should be placed typedefs for uptr_t, an unsigned integer type large enough to
// hold a pointer and sptr_t, a signed integer large enough to hold a pointer.
// May need to be changed for 64 bit platforms.
#if _MSC_VER >= 1300
#include <BaseTsd.h>
#endif
#ifdef MAXULONG_PTR
typedef ULONG_PTR uptr_t;
typedef LONG_PTR sptr_t;
#else
typedef unsigned long uptr_t;
typedef long sptr_t;
#endif

typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam, sptr_t lParam);

//++Autogenerated -- start of section automatically generated from Scintilla.iface
#define INVALID_POSITION -1
#define SCI_START 2000
#define SCI_OPTIONAL_START 3000
#define SCI_LEXER_START 4000
#define SCI_ADDTEXT 2001
#define SCI_ADDSTYLEDTEXT 2002
#define SCI_INSERTTEXT 2003
#define SCI_CLEARALL 2004
#define SCI_CLEARDOCUMENTSTYLE 2005
#define SCI_GETLENGTH 2006
#define SCI_GETCHARAT 2007
#define SCI_GETCURRENTPOS 2008
#define SCI_GETANCHOR 2009
#define SCI_GETSTYLEAT 2010
#define SCI_REDO 2011
#define SCI_SETUNDOCOLLECTION 2012
#define SCI_SELECTALL 2013
#define SCI_SETSAVEPOINT 2014
#define SCI_GETSTYLEDTEXT 2015
#define SCI_CANREDO 2016
#define SCI_MARKERLINEFROMHANDLE 2017
#define SCI_MARKERDELETEHANDLE 2018
#define SCI_GETUNDOCOLLECTION 2019
#define SCWS_INVISIBLE 0
#define SCWS_VISIBLEALWAYS 1
#define SCWS_VISIBLEAFTERINDENT 2
#define SCI_GETVIEWWS 2020
#define SCI_SETVIEWWS 2021
#define SCI_POSITIONFROMPOINT 2022
#define SCI_POSITIONFROMPOINTCLOSE 2023
#define SCI_GOTOLINE 2024
#define SCI_GOTOPOS 2025
#define SCI_SETANCHOR 2026
#define SCI_GETCURLINE 2027
#define SCI_GETENDSTYLED 2028
#define SC_EOL_CRLF 0
#define SC_EOL_CR 1
#define SC_EOL_LF 2
#define SCI_CONVERTEOLS 2029
#define SCI_GETEOLMODE 2030
#define SCI_SETEOLMODE 2031
#define SCI_STARTSTYLING 2032
#define SCI_SETSTYLING 2033
#define SCI_GETBUFFEREDDRAW 2034
#define SCI_SETBUFFEREDDRAW 2035
#define SCI_SETTABWIDTH 2036
#define SCI_GETTABWIDTH 2121
#define SC_CP_UTF8 65001
#define SC_CP_DBCS 1
#define SCI_SETCODEPAGE 2037
#define SCI_SETUSEPALETTE 2039
#define MARKER_MAX 31
#define SC_MARK_CIRCLE 0
#define SC_MARK_ROUNDRECT 1
#define SC_MARK_ARROW 2
#define SC_MARK_SMALLRECT 3
#define SC_MARK_SHORTARROW 4
#define SC_MARK_EMPTY 5
#define SC_MARK_ARROWDOWN 6
#define SC_MARK_MINUS 7
#define SC_MARK_PLUS 8
#define SC_MARK_VLINE 9
#define SC_MARK_LCORNER 10
#define SC_MARK_TCORNER 11
#define SC_MARK_BOXPLUS 12
#define SC_MARK_BOXPLUSCONNECTED 13
#define SC_MARK_BOXMINUS 14
#define SC_MARK_BOXMINUSCONNECTED 15
#define SC_MARK_LCORNERCURVE 16
#define SC_MARK_TCORNERCURVE 17
#define SC_MARK_CIRCLEPLUS 18
#define SC_MARK_CIRCLEPLUSCONNECTED 19
#define SC_MARK_CIRCLEMINUS 20
#define SC_MARK_CIRCLEMINUSCONNECTED 21
#define SC_MARK_BACKGROUND 22
#define SC_MARK_DOTDOTDOT 23
#define SC_MARK_ARROWS 24
#define SC_MARK_PIXMAP 25
#define SC_MARK_CHARACTER 10000
#define SC_MARKNUM_FOLDEREND 25
#define SC_MARKNUM_FOLDEROPENMID 26
#define SC_MARKNUM_FOLDERMIDTAIL 27
#define SC_MARKNUM_FOLDERTAIL 28
#define SC_MARKNUM_FOLDERSUB 29
#define SC_MARKNUM_FOLDER 30
#define SC_MARKNUM_FOLDEROPEN 31
#define SC_MASK_FOLDERS 0xFE000000
#define SCI_MARKERDEFINE 2040
#define SCI_MARKERSETFORE 2041
#define SCI_MARKERSETBACK 2042
#define SCI_MARKERADD 2043
#define SCI_MARKERDELETE 2044
#define SCI_MARKERDELETEALL 2045
#define SCI_MARKERGET 2046
#define SCI_MARKERNEXT 2047
#define SCI_MARKERPREVIOUS 2048
#define SCI_MARKERDEFINEPIXMAP 2049
#define SC_MARGIN_SYMBOL 0
#define SC_MARGIN_NUMBER 1
#define SCI_SETMARGINTYPEN 2240
#define SCI_GETMARGINTYPEN 2241
#define SCI_SETMARGINWIDTHN 2242
#define SCI_GETMARGINWIDTHN 2243
#define SCI_SETMARGINMASKN 2244
#define SCI_GETMARGINMASKN 2245
#define SCI_SETMARGINSENSITIVEN 2246
#define SCI_GETMARGINSENSITIVEN 2247
#define STYLE_DEFAULT 32
#define STYLE_LINENUMBER 33
#define STYLE_BRACELIGHT 34
#define STYLE_BRACEBAD 35
#define STYLE_CONTROLCHAR 36
#define STYLE_INDENTGUIDE 37
#define STYLE_LASTPREDEFINED 39
#define STYLE_MAX 127
#define SC_CHARSET_ANSI 0
#define SC_CHARSET_DEFAULT 1
#define SC_CHARSET_BALTIC 186
#define SC_CHARSET_CHINESEBIG5 136
#define SC_CHARSET_EASTEUROPE 238
#define SC_CHARSET_GB2312 134
#define SC_CHARSET_GREEK 161
#define SC_CHARSET_HANGUL 129
#define SC_CHARSET_MAC 77
#define SC_CHARSET_OEM 255
#define SC_CHARSET_RUSSIAN 204
#define SC_CHARSET_SHIFTJIS 128
#define SC_CHARSET_SYMBOL 2
#define SC_CHARSET_TURKISH 162
#define SC_CHARSET_JOHAB 130
#define SC_CHARSET_HEBREW 177
#define SC_CHARSET_ARABIC 178
#define SC_CHARSET_VIETNAMESE 163
#define SC_CHARSET_THAI 222
#define SCI_STYLECLEARALL 2050
#define SCI_STYLESETFORE 2051
#define SCI_STYLESETBACK 2052
#define SCI_STYLESETBOLD 2053
#define SCI_STYLESETITALIC 2054
#define SCI_STYLESETSIZE 2055
#define SCI_STYLESETFONT 2056
#define SCI_STYLESETEOLFILLED 2057
#define SCI_STYLERESETDEFAULT 2058
#define SCI_STYLESETUNDERLINE 2059
#define SC_CASE_MIXED 0
#define SC_CASE_UPPER 1
#define SC_CASE_LOWER 2
#define SCI_STYLESETCASE 2060
#define SCI_STYLESETCHARACTERSET 2066
#define SCI_STYLESETHOTSPOT 2409
#define SCI_SETSELFORE 2067
#define SCI_SETSELBACK 2068
#define SCI_SETCARETFORE 2069
#define SCI_ASSIGNCMDKEY 2070
#define SCI_CLEARCMDKEY 2071
#define SCI_CLEARALLCMDKEYS 2072
#define SCI_SETSTYLINGEX 2073
#define SCI_STYLESETVISIBLE 2074
#define SCI_GETCARETPERIOD 2075
#define SCI_SETCARETPERIOD 2076
#define SCI_SETWORDCHARS 2077
#define SCI_BEGINUNDOACTION 2078
#define SCI_ENDUNDOACTION 2079
#define INDIC_MAX 7
#define INDIC_PLAIN 0
#define INDIC_SQUIGGLE 1
#define INDIC_TT 2
#define INDIC_DIAGONAL 3
#define INDIC_STRIKE 4
#define INDIC_HIDDEN 5
#define INDIC_BOX 6
#define INDIC0_MASK 0x20
#define INDIC1_MASK 0x40
#define INDIC2_MASK 0x80
#define INDICS_MASK 0xE0
#define SCI_INDICSETSTYLE 2080
#define SCI_INDICGETSTYLE 2081
#define SCI_INDICSETFORE 2082
#define SCI_INDICGETFORE 2083
#define SCI_SETWHITESPACEFORE 2084
#define SCI_SETWHITESPACEBACK 2085
#define SCI_SETSTYLEBITS 2090
#define SCI_GETSTYLEBITS 2091
#define SCI_SETLINESTATE 2092
#define SCI_GETLINESTATE 2093
#define SCI_GETMAXLINESTATE 2094
#define SCI_GETCARETLINEVISIBLE 2095
#define SCI_SETCARETLINEVISIBLE 2096
#define SCI_GETCARETLINEBACK 2097
#define SCI_SETCARETLINEBACK 2098
#define SCI_STYLESETCHANGEABLE 2099
#define SCI_AUTOCSHOW 2100
#define SCI_AUTOCCANCEL 2101
#define SCI_AUTOCACTIVE 2102
#define SCI_AUTOCPOSSTART 2103
#define SCI_AUTOCCOMPLETE 2104
#define SCI_AUTOCSTOPS 2105
#define SCI_AUTOCSETSEPARATOR 2106
#define SCI_AUTOCGETSEPARATOR 2107
#define SCI_AUTOCSELECT 2108
#define SCI_AUTOCSETCANCELATSTART 2110
#define SCI_AUTOCGETCANCELATSTART 2111
#define SCI_AUTOCSETFILLUPS 2112
#define SCI_AUTOCSETCHOOSESINGLE 2113
#define SCI_AUTOCGETCHOOSESINGLE 2114
#define SCI_AUTOCSETIGNORECASE 2115
#define SCI_AUTOCGETIGNORECASE 2116
#define SCI_USERLISTSHOW 2117
#define SCI_AUTOCSETAUTOHIDE 2118
#define SCI_AUTOCGETAUTOHIDE 2119
#define SCI_AUTOCSETDROPRESTOFWORD 2270
#define SCI_AUTOCGETDROPRESTOFWORD 2271
#define SCI_REGISTERIMAGE 2405
#define SCI_CLEARREGISTEREDIMAGES 2408
#define SCI_AUTOCGETTYPESEPARATOR 2285
#define SCI_AUTOCSETTYPESEPARATOR 2286
#define SCI_SETINDENT 2122
#define SCI_GETINDENT 2123
#define SCI_SETUSETABS 2124
#define SCI_GETUSETABS 2125
#define SCI_SETLINEINDENTATION 2126
#define SCI_GETLINEINDENTATION 2127
#define SCI_GETLINEINDENTPOSITION 2128
#define SCI_GETCOLUMN 2129
#define SCI_SETHSCROLLBAR 2130
#define SCI_GETHSCROLLBAR 2131
#define SCI_SETINDENTATIONGUIDES 2132
#define SCI_GETINDENTATIONGUIDES 2133
#define SCI_SETHIGHLIGHTGUIDE 2134
#define SCI_GETHIGHLIGHTGUIDE 2135
#define SCI_GETLINEENDPOSITION 2136
#define SCI_GETCODEPAGE 2137
#define SCI_GETCARETFORE 2138
#define SCI_GETUSEPALETTE 2139
#define SCI_GETREADONLY 2140
#define SCI_SETCURRENTPOS 2141
#define SCI_SETSELECTIONSTART 2142
#define SCI_GETSELECTIONSTART 2143
#define SCI_SETSELECTIONEND 2144
#define SCI_GETSELECTIONEND 2145
#define SCI_SETPRINTMAGNIFICATION 2146
#define SCI_GETPRINTMAGNIFICATION 2147
#define SC_PRINT_NORMAL 0
#define SC_PRINT_INVERTLIGHT 1
#define SC_PRINT_BLACKONWHITE 2
#define SC_PRINT_COLOURONWHITE 3
#define SC_PRINT_COLOURONWHITEDEFAULTBG 4
#define SCI_SETPRINTCOLOURMODE 2148
#define SCI_GETPRINTCOLOURMODE 2149
#define SCFIND_WHOLEWORD 2
#define SCFIND_MATCHCASE 4
#define SCFIND_WORDSTART 0x00100000
#define SCFIND_REGEXP 0x00200000
#define SCFIND_POSIX 0x00400000
#define SCI_FINDTEXT 2150
#define SCI_FORMATRANGE 2151
#define SCI_GETFIRSTVISIBLELINE 2152
#define SCI_GETLINE 2153
#define SCI_GETLINECOUNT 2154
#define SCI_SETMARGINLEFT 2155
#define SCI_GETMARGINLEFT 2156
#define SCI_SETMARGINRIGHT 2157
#define SCI_GETMARGINRIGHT 2158
#define SCI_GETMODIFY 2159
#define SCI_SETSEL 2160
#define SCI_GETSELTEXT 2161
#define SCI_GETTEXTRANGE 2162
#define SCI_HIDESELECTION 2163
#define SCI_POINTXFROMPOSITION 2164
#define SCI_POINTYFROMPOSITION 2165
#define SCI_LINEFROMPOSITION 2166
#define SCI_POSITIONFROMLINE 2167
#define SCI_LINESCROLL 2168
#define SCI_SCROLLCARET 2169
#define SCI_REPLACESEL 2170
#define SCI_SETREADONLY 2171
#define SCI_NULL 2172
#define SCI_CANPASTE 2173
#define SCI_CANUNDO 2174
#define SCI_EMPTYUNDOBUFFER 2175
#define SCI_UNDO 2176
#define SCI_CUT 2177
#define SCI_COPY 2178
#define SCI_PASTE 2179
#define SCI_CLEAR 2180
#define SCI_SETTEXT 2181
#define SCI_GETTEXT 2182
#define SCI_GETTEXTLENGTH 2183
#define SCI_GETDIRECTFUNCTION 2184
#define SCI_GETDIRECTPOINTER 2185
#define SCI_SETOVERTYPE 2186
#define SCI_GETOVERTYPE 2187
#define SCI_SETCARETWIDTH 2188
#define SCI_GETCARETWIDTH 2189
#define SCI_SETTARGETSTART 2190
#define SCI_GETTARGETSTART 2191
#define SCI_SETTARGETEND 2192
#define SCI_GETTARGETEND 2193
#define SCI_REPLACETARGET 2194
#define SCI_REPLACETARGETRE 2195
#define SCI_SEARCHINTARGET 2197
#define SCI_SETSEARCHFLAGS 2198
#define SCI_GETSEARCHFLAGS 2199
#define SCI_CALLTIPSHOW 2200
#define SCI_CALLTIPCANCEL 2201
#define SCI_CALLTIPACTIVE 2202
#define SCI_CALLTIPPOSSTART 2203
#define SCI_CALLTIPSETHLT 2204
#define SCI_CALLTIPSETBACK 2205
#define SCI_CALLTIPSETFORE 2206
#define SCI_CALLTIPSETFOREHLT 2207
#define SCI_VISIBLEFROMDOCLINE 2220
#define SCI_DOCLINEFROMVISIBLE 2221
#define SC_FOLDLEVELBASE 0x400
#define SC_FOLDLEVELWHITEFLAG 0x1000
#define SC_FOLDLEVELHEADERFLAG 0x2000
#define SC_FOLDLEVELBOXHEADERFLAG 0x4000
#define SC_FOLDLEVELBOXFOOTERFLAG 0x8000
#define SC_FOLDLEVELCONTRACTED 0x10000
#define SC_FOLDLEVELUNINDENT 0x20000
#define SC_FOLDLEVELNUMBERMASK 0x0FFF
#define SCI_SETFOLDLEVEL 2222
#define SCI_GETFOLDLEVEL 2223
#define SCI_GETLASTCHILD 2224
#define SCI_GETFOLDPARENT 2225
#define SCI_SHOWLINES 2226
#define SCI_HIDELINES 2227
#define SCI_GETLINEVISIBLE 2228
#define SCI_SETFOLDEXPANDED 2229
#define SCI_GETFOLDEXPANDED 2230
#define SCI_TOGGLEFOLD 2231
#define SCI_ENSUREVISIBLE 2232
#define SC_FOLDFLAG_LINEBEFORE_EXPANDED 0x0002
#define SC_FOLDFLAG_LINEBEFORE_CONTRACTED 0x0004
#define SC_FOLDFLAG_LINEAFTER_EXPANDED 0x0008
#define SC_FOLDFLAG_LINEAFTER_CONTRACTED 0x0010
#define SC_FOLDFLAG_LEVELNUMBERS 0x0040
#define SC_FOLDFLAG_BOX 0x0001
#define SCI_SETFOLDFLAGS 2233
#define SCI_ENSUREVISIBLEENFORCEPOLICY 2234
#define SCI_SETTABINDENTS 2260
#define SCI_GETTABINDENTS 2261
#define SCI_SETBACKSPACEUNINDENTS 2262
#define SCI_GETBACKSPACEUNINDENTS 2263
#define SC_TIME_FOREVER 10000000
#define SCI_SETMOUSEDWELLTIME 2264
#define SCI_GETMOUSEDWELLTIME 2265
#define SCI_WORDSTARTPOSITION 2266
#define SCI_WORDENDPOSITION 2267
#define SC_WRAP_NONE 0
#define SC_WRAP_WORD 1
#define SCI_SETWRAPMODE 2268
#define SCI_GETWRAPMODE 2269
#define SC_CACHE_NONE 0
#define SC_CACHE_CARET 1
#define SC_CACHE_PAGE 2
#define SC_CACHE_DOCUMENT 3
#define SCI_SETLAYOUTCACHE 2272
#define SCI_GETLAYOUTCACHE 2273
#define SCI_SETSCROLLWIDTH 2274
#define SCI_GETSCROLLWIDTH 2275
#define SCI_TEXTWIDTH 2276
#define SCI_SETENDATLASTLINE 2277
#define SCI_GETENDATLASTLINE 2278
#define SCI_TEXTHEIGHT 2279
#define SCI_SETVSCROLLBAR 2280
#define SCI_GETVSCROLLBAR 2281
#define SCI_APPENDTEXT 2282
#define SCI_GETTWOPHASEDRAW 2283
#define SCI_SETTWOPHASEDRAW 2284
#define SCI_TARGETFROMSELECTION 2287
#define SCI_LINESJOIN 2288
#define SCI_LINESSPLIT 2289
#define SCI_SETFOLDMARGINCOLOUR 2290
#define SCI_SETFOLDMARGINHICOLOUR 2291
#define SCI_LINEDOWN 2300
#define SCI_LINEDOWNEXTEND 2301
#define SCI_LINEUP 2302
#define SCI_LINEUPEXTEND 2303
#define SCI_CHARLEFT 2304
#define SCI_CHARLEFTEXTEND 2305
#define SCI_CHARRIGHT 2306
#define SCI_CHARRIGHTEXTEND 2307
#define SCI_WORDLEFT 2308
#define SCI_WORDLEFTEXTEND 2309
#define SCI_WORDRIGHT 2310
#define SCI_WORDRIGHTEXTEND 2311
#define SCI_HOME 2312
#define SCI_HOMEEXTEND 2313
#define SCI_LINEEND 2314
#define SCI_LINEENDEXTEND 2315
#define SCI_DOCUMENTSTART 2316
#define SCI_DOCUMENTSTARTEXTEND 2317
#define SCI_DOCUMENTEND 2318
#define SCI_DOCUMENTENDEXTEND 2319
#define SCI_PAGEUP 2320
#define SCI_PAGEUPEXTEND 2321
#define SCI_PAGEDOWN 2322
#define SCI_PAGEDOWNEXTEND 2323
#define SCI_EDITTOGGLEOVERTYPE 2324
#define SCI_CANCEL 2325
#define SCI_DELETEBACK 2326
#define SCI_TAB 2327
#define SCI_BACKTAB 2328
#define SCI_NEWLINE 2329
#define SCI_FORMFEED 2330
#define SCI_VCHOME 2331
#define SCI_VCHOMEEXTEND 2332
#define SCI_ZOOMIN 2333
#define SCI_ZOOMOUT 2334
#define SCI_DELWORDLEFT 2335
#define SCI_DELWORDRIGHT 2336
#define SCI_LINECUT 2337
#define SCI_LINEDELETE 2338
#define SCI_LINETRANSPOSE 2339
#define SCI_LINEDUPLICATE 2404
#define SCI_LOWERCASE 2340
#define SCI_UPPERCASE 2341
#define SCI_LINESCROLLDOWN 2342
#define SCI_LINESCROLLUP 2343
#define SCI_DELETEBACKNOTLINE 2344
#define SCI_HOMEDISPLAY 2345
#define SCI_HOMEDISPLAYEXTEND 2346
#define SCI_LINEENDDISPLAY 2347
#define SCI_LINEENDDISPLAYEXTEND 2348
#define SCI_HOMEWRAP 2349
#define SCI_HOMEWRAPEXTEND 2450
#define SCI_LINEENDWRAP 2451
#define SCI_LINEENDWRAPEXTEND 2452
#define SCI_VCHOMEWRAP 2453
#define SCI_VCHOMEWRAPEXTEND 2454
#define SCI_LINECOPY 2455
#define SCI_MOVECARETINSIDEVIEW 2401
#define SCI_LINELENGTH 2350
#define SCI_BRACEHIGHLIGHT 2351
#define SCI_BRACEBADLIGHT 2352
#define SCI_BRACEMATCH 2353
#define SCI_GETVIEWEOL 2355
#define SCI_SETVIEWEOL 2356
#define SCI_GETDOCPOINTER 2357
#define SCI_SETDOCPOINTER 2358
#define SCI_SETMODEVENTMASK 2359
#define EDGE_NONE 0
#define EDGE_LINE 1
#define EDGE_BACKGROUND 2
#define SCI_GETEDGECOLUMN 2360
#define SCI_SETEDGECOLUMN 2361
#define SCI_GETEDGEMODE 2362
#define SCI_SETEDGEMODE 2363
#define SCI_GETEDGECOLOUR 2364
#define SCI_SETEDGECOLOUR 2365
#define SCI_SEARCHANCHOR 2366
#define SCI_SEARCHNEXT 2367
#define SCI_SEARCHPREV 2368
#define SCI_LINESONSCREEN 2370
#define SCI_USEPOPUP 2371
#define SCI_SELECTIONISRECTANGLE 2372
#define SCI_SETZOOM 2373
#define SCI_GETZOOM 2374
#define SCI_CREATEDOCUMENT 2375
#define SCI_ADDREFDOCUMENT 2376
#define SCI_RELEASEDOCUMENT 2377
#define SCI_GETMODEVENTMASK 2378
#define SCI_SETFOCUS 2380
#define SCI_GETFOCUS 2381
#define SCI_SETSTATUS 2382
#define SCI_GETSTATUS 2383
#define SCI_SETMOUSEDOWNCAPTURES 2384
#define SCI_GETMOUSEDOWNCAPTURES 2385
#define SC_CURSORNORMAL -1
#define SC_CURSORWAIT 4
#define SCI_SETCURSOR 2386
#define SCI_GETCURSOR 2387
#define SCI_SETCONTROLCHARSYMBOL 2388
#define SCI_GETCONTROLCHARSYMBOL 2389
#define SCI_WORDPARTLEFT 2390
#define SCI_WORDPARTLEFTEXTEND 2391
#define SCI_WORDPARTRIGHT 2392
#define SCI_WORDPARTRIGHTEXTEND 2393
#define VISIBLE_SLOP 0x01
#define VISIBLE_STRICT 0x04
#define SCI_SETVISIBLEPOLICY 2394
#define SCI_DELLINELEFT 2395
#define SCI_DELLINERIGHT 2396
#define SCI_SETXOFFSET 2397
#define SCI_GETXOFFSET 2398
#define SCI_CHOOSECARETX 2399
#define SCI_GRABFOCUS 2400
#define CARET_SLOP 0x01
#define CARET_STRICT 0x04
#define CARET_JUMPS 0x10
#define CARET_EVEN 0x08
#define SCI_SETXCARETPOLICY 2402
#define SCI_SETYCARETPOLICY 2403
#define SCI_SETPRINTWRAPMODE 2406
#define SCI_GETPRINTWRAPMODE 2407
#define SCI_SETHOTSPOTACTIVEFORE 2410
#define SCI_SETHOTSPOTACTIVEBACK 2411
#define SCI_SETHOTSPOTACTIVEUNDERLINE 2412
#define SCI_SETHOTSPOTSINGLELINE 2421
#define SCI_PARADOWN 2413
#define SCI_PARADOWNEXTEND 2414
#define SCI_PARAUP 2415
#define SCI_PARAUPEXTEND 2416
#define SCI_POSITIONBEFORE 2417
#define SCI_POSITIONAFTER 2418
#define SCI_COPYRANGE 2419
#define SCI_COPYTEXT 2420
#define SC_SEL_STREAM 0
#define SC_SEL_RECTANGLE 1
#define SC_SEL_LINES 2
#define SCI_SETSELECTIONMODE 2422
#define SCI_GETSELECTIONMODE 2423
#define SCI_GETLINESELSTARTPOSITION 2424
#define SCI_GETLINESELENDPOSITION 2425
#define SCI_LINEDOWNRECTEXTEND 2426
#define SCI_LINEUPRECTEXTEND 2427
#define SCI_CHARLEFTRECTEXTEND 2428
#define SCI_CHARRIGHTRECTEXTEND 2429
#define SCI_HOMERECTEXTEND 2430
#define SCI_VCHOMERECTEXTEND 2431
#define SCI_LINEENDRECTEXTEND 2432
#define SCI_PAGEUPRECTEXTEND 2433
#define SCI_PAGEDOWNRECTEXTEND 2434
#define SCI_STUTTEREDPAGEUP 2435
#define SCI_STUTTEREDPAGEUPEXTEND 2436
#define SCI_STUTTEREDPAGEDOWN 2437
#define SCI_STUTTEREDPAGEDOWNEXTEND 2438
#define SCI_WORDLEFTEND 2439
#define SCI_WORDLEFTENDEXTEND 2440
#define SCI_WORDRIGHTEND 2441
#define SCI_WORDRIGHTENDEXTEND 2442
#define SCI_SETWHITESPACECHARS 2443
#define SCI_SETCHARSDEFAULT 2444
#define SCI_AUTOCGETCURRENT 2445
#define SCI_ALLOCATE 2446
#define SCI_STARTRECORD 3001
#define SCI_STOPRECORD 3002
#define SCI_SETLEXER 4001
#define SCI_GETLEXER 4002
#define SCI_COLOURISE 4003
#define SCI_SETPROPERTY 4004
#define KEYWORDSET_MAX 8
#define SCI_SETKEYWORDS 4005
#define SCI_SETLEXERLANGUAGE 4006
#define SCI_LOADLEXERLIBRARY 4007
#define SC_MOD_INSERTTEXT 0x1
#define SC_MOD_DELETETEXT 0x2
#define SC_MOD_CHANGESTYLE 0x4
#define SC_MOD_CHANGEFOLD 0x8
#define SC_PERFORMED_USER 0x10
#define SC_PERFORMED_UNDO 0x20
#define SC_PERFORMED_REDO 0x40
#define SC_LASTSTEPINUNDOREDO 0x100
#define SC_MOD_CHANGEMARKER 0x200
#define SC_MOD_BEFOREINSERT 0x400
#define SC_MOD_BEFOREDELETE 0x800
#define SC_MODEVENTMASKALL 0xF77
#define SCEN_CHANGE 768
#define SCEN_SETFOCUS 512
#define SCEN_KILLFOCUS 256
#define SCK_DOWN 300
#define SCK_UP 301
#define SCK_LEFT 302
#define SCK_RIGHT 303
#define SCK_HOME 304
#define SCK_END 305
#define SCK_PRIOR 306
#define SCK_NEXT 307
#define SCK_DELETE 308
#define SCK_INSERT 309
#define SCK_ESCAPE 7
#define SCK_BACK 8
#define SCK_TAB 9
#define SCK_RETURN 13
#define SCK_ADD 310
#define SCK_SUBTRACT 311
#define SCK_DIVIDE 312
#define SCMOD_SHIFT 1
#define SCMOD_CTRL 2
#define SCMOD_ALT 4
#define SCN_STYLENEEDED 2000
#define SCN_CHARADDED 2001
#define SCN_SAVEPOINTREACHED 2002
#define SCN_SAVEPOINTLEFT 2003
#define SCN_MODIFYATTEMPTRO 2004
#define SCN_KEY 2005
#define SCN_DOUBLECLICK 2006
#define SCN_UPDATEUI 2007
#define SCN_MODIFIED 2008
#define SCN_MACRORECORD 2009
#define SCN_MARGINCLICK 2010
#define SCN_NEEDSHOWN 2011
#define SCN_PAINTED 2013
#define SCN_USERLISTSELECTION 2014
#define SCN_URIDROPPED 2015
#define SCN_DWELLSTART 2016
#define SCN_DWELLEND 2017
#define SCN_ZOOM 2018
#define SCN_HOTSPOTCLICK 2019
#define SCN_HOTSPOTDOUBLECLICK 2020
#define SCN_CALLTIPCLICK 2021
//--Autogenerated -- end of section automatically generated from Scintilla.iface

// These structures are defined to be exactly the same shape as the Win32
// CHARRANGE, TEXTRANGE, FINDTEXTEX, FORMATRANGE, and NMHDR structs.
// So older code that treats Scintilla as a RichEdit will work.

struct CharacterRange {
	long cpMin;
	long cpMax;
};

struct TextRange {
	struct CharacterRange chrg;
	char *lpstrText;
};

struct TextToFind {
	struct CharacterRange chrg;
	char *lpstrText;
	struct CharacterRange chrgText;
};

#ifdef PLATFORM_H

// This structure is used in printing and requires some of the graphics types
// from Platform.h.  Not needed by most client code.

struct RangeToFormat {
	SurfaceID hdc;
	SurfaceID hdcTarget;
	PRectangle rc;
	PRectangle rcPage;
	CharacterRange chrg;
};

#endif

struct NotifyHeader {
	// hwndFrom is really an environment specifc window handle or pointer
	// but most clients of Scintilla.h do not have this type visible.
	//WindowID hwndFrom;
	void *hwndFrom;
	unsigned int idFrom;
	unsigned int code;
};

struct SCNotification {
	struct NotifyHeader nmhdr;
	int position;	// SCN_STYLENEEDED, SCN_MODIFIED, SCN_DWELLSTART, SCN_DWELLEND
	int ch;		// SCN_CHARADDED, SCN_KEY
	int modifiers;	// SCN_KEY
	int modificationType;	// SCN_MODIFIED
	const char *text;	// SCN_MODIFIED
	int length;		// SCN_MODIFIED
	int linesAdded;	// SCN_MODIFIED
	int message;	// SCN_MACRORECORD
	uptr_t wParam;	// SCN_MACRORECORD
	sptr_t lParam;	// SCN_MACRORECORD
	int line;		// SCN_MODIFIED
	int foldLevelNow;	// SCN_MODIFIED
	int foldLevelPrev;	// SCN_MODIFIED
	int margin;		// SCN_MARGINCLICK
	int listType;	// SCN_USERLISTSELECTION
	int x;			// SCN_DWELLSTART, SCN_DWELLEND
	int y;		// SCN_DWELLSTART, SCN_DWELLEND
};

// Deprecation section listing all API features that are deprecated and will
// will be removed completely in a future version.
// To enable these features define INCLUDE_DEPRECATED_FEATURES

#ifdef INCLUDE_DEPRECATED_FEATURES

#define SCI_SETCARETPOLICY 2369
#define CARET_CENTER 0x02
#define CARET_XEVEN 0x08
#define CARET_XJUMPS 0x10

#define SCN_POSCHANGED 2012
#define SCN_CHECKBRACE 2007

#endif

#endif

Update of /cvsroot/perl-win32-gui/Win32-GUI-Scintilla/Samples
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv23874/Samples

Added Files:
	Editor.pl test.pl test2.pl 
Log Message:
Added to repository

--- NEW FILE: test2.pl ---
# perl -w
use Win32::GUI;
use Win32::GUI::Scintilla;
use Win32::GUI::Scintilla::Perl;

# main Window
$Window = new Win32::GUI::Window (
    -name     => "Window",
    -title    => "Scintilla test",
    -pos      => [100, 100],
    -size     => [400, 400],
) or die "new Window";

# Create Scintilla Edit Window
# $Edit = new Win32::GUI::Scintilla  (
#               -parent  => $Window,
# Or
$Edit = $Window->AddScintillaPerl  (
               -name    => "Edit",
               -pos     => [0, 0],
               -size    => [400, 400],
               -text    => "my \$Test\n",
) or die "new Edit";

# Call Some method
$Edit->AddText ("if (\$i == 1) {\n \$i++;\n}\n");

# Event loop
$Window->Show();
Win32::GUI::Dialog();

# Main window event handler
sub Window_Terminate {
 return -1;
}

# Main window resize
sub Window_Resize {

  if (defined $Window) {
    ($width, $height) = ($Window->GetClientRect)[2..3];
    $Edit->Resize ($width, $height);
  }
}

# Scintilla Event Notification
sub Edit_Notify {

  my (%evt) = @_;
  print "Edit Notify = ", %evt, "\n";
}


--- NEW FILE: test.pl ---
# perl -w
use Win32::GUI;
use Win32::GUI::Scintilla;

# main Window
$Window = new Win32::GUI::Window (
    -name     => "Window",
    -title    => "Scintilla test",
    -pos      => [100, 100],
    -size     => [400, 400],
) or die "new Window";

$Edit = $Window->AddButton  (
    -name     => "Test",
    -text     => "Test",
    -pos      => [0, 0],
    -size     => [100, 10],
);

# Create Scintilla Edit Window
# $Edit = new Win32::GUI::Scintilla  (
#               -parent  => $Window,
# Or
$Edit = $Window->AddScintilla  (
               -name    => "Edit",
               -pos     => [0, 10],
               -size    => [400, 400],
               -text    => "Test\n",
) or die "new Edit";

# Call Some method
$Edit->AddText ("add\n");
$Edit->AppendText ("append\n");

# Event loop
$Window->Show();
Win32::GUI::Dialog();

# Main window event handler
sub Window_Terminate {
 # Call Some method
 print "GetText = ", $Edit->GetText(), "\n";
 print "GetLine(1) = ", $Edit->GetLine(1), "\n";
 print "GetSelText = ", $Edit->GetSelText(), "\n";
 print "GetTextRange(2) = ", $Edit->GetTextRange(2), "\n";
 print "GetTextRange(2, 6) = ", $Edit->GetTextRange(2, 6), "\n";
 return -1;
}
# Main window resize
sub Window_Resize {

  if (defined $Window) {
    ($width, $height) = ($Window->GetClientRect)[2..3];
    $Edit->Move   (0, 10);
    $Edit->Resize ($width, $height-10);
  }
}

# Scintilla Event Notification
sub Edit_Notify {

  my (%evt) = @_;
 # print "Edit Notify = ", %evt, "\n";
}


sub Edit_Change {
  print "Change!!!\n";
}

sub Edit_GotFocus {
  print "GotFocus!!!\n";
}

sub Edit_LostFocus {
  print "LostFocus!!!\n";
}

--- NEW FILE: Editor.pl ---
# Perl Editor
#-----------------------------------------------------------------------
# perl -v
use strict;
use Cwd;
use Win32::GUI;
use Win32::GUI::Scintilla;

my $VERSION = "1.0alpha1";
my $CurrentFile = "";
my $Directory = cwd;

my %faces = ( 'times'  => 'Times New Roman',
              'mono'   => 'Courier New',
              'helv'   => 'Lucida Console',
              'lucida' => 'Lucida Console',
              'other'  => 'Comic Sans MS',
              'size'   => '10',
              'size2'  => '9',
              'backcol'=> '#FFFFFF',
            );

my $PERL_KEYWORD = q{
NULL __FILE__ __LINE__ __PACKAGE__ __DATA__ __END__ AUTOLOAD
BEGIN CORE DESTROY END EQ GE GT INIT LE LT NE CHECK abs accept
alarm and atan2 bind binmode bless caller chdir chmod chomp chop
chown chr chroot close closedir cmp connect continue cos crypt
dbmclose dbmopen defined delete die do dump each else elsif endgrent
endhostent endnetent endprotoent endpwent endservent eof eq eval
exec exists exit exp fcntl fileno flock for foreach fork format
formline ge getc getgrent getgrgid getgrnam gethostbyaddr gethostbyname
gethostent getlogin getnetbyaddr getnetbyname getnetent getpeername
getpgrp getppid getpriority getprotobyname getprotobynumber getprotoent
getpwent getpwnam getpwuid getservbyname getservbyport getservent
getsockname getsockopt glob gmtime goto grep gt hex if index
int ioctl join keys kill last lc lcfirst le length link listen
local localtime lock log lstat lt m map mkdir msgctl msgget msgrcv
msgsnd my ne next no not oct open opendir or ord our pack package
pipe pop pos print printf prototype push q qq qr quotemeta qu
qw qx rand read readdir readline readlink readpipe recv redo
ref rename require reset return reverse rewinddir rindex rmdir
s scalar seek seekdir select semctl semget semop send setgrent
sethostent setnetent setpgrp setpriority setprotoent setpwent
setservent setsockopt shift shmctl shmget shmread shmwrite shutdown
sin sleep socket socketpair sort splice split sprintf sqrt srand
stat study sub substr symlink syscall sysopen sysread sysseek
system syswrite tell telldir tie tied time times tr truncate
uc ucfirst umask undef unless unlink unpack unshift untie until
use utime values vec wait waitpid wantarray warn while write
x xor y
};


my $Menu =  Win32::GUI::MakeMenu(
    "&File"                   => "File",
    "   > &New"               => "FileNew",
    "   > &Open..."           => "FileOpen",
    "   > -"                  => 0,
    "   > &Save"              => "FileSave",
    "   > &Save As..."        => "FileSaveAs",
    "   > -"                  => 0,
    "   > &Directory..."      => "FileDirectory",
    "   > -"                  => 0,
    "   > E&xit"              => "FileExit",
    "&Edit"                   => "Edit",
    "   > &Undo"              => "EditUndo",
    "   > &Redo"              => "EditRedo",
    "   > -"                  => 0,
    "   > Cu&t"               => "EditCut",
    "   > &Copy"              => "EditCopy",
    "   > &Paste"             => "EditPaste",
    "   > &Delete"            => "EditClear",
    "   > -"                  => 0,
    "   > Select A&ll"        => "EditSelectAll",
    "   > -"                  => 0,
    "   > &Find..."           => "EditFind",
    "&Help"                   => "Help",
    "   > &About..."          => "HelpAbout",
    );

# main Window
my $Window = new Win32::GUI::Window (
                   -name     => "Window",
                   -title    => "Perl Editor",
                   -pos      => [100, 100],
                   -size     => [400, 400],
                   -menu     => $Menu,
                   ) or die "new Window";

# Create Scintilla Edit Window
# $Edit = new Win32::GUI::Scintilla  (
#               -parent  => $Window,
my $Editor = $Window->AddScintilla  (
                        -name    => "Editor",
                        -pos     => [0, 0],
                        -size    => [400, 400],
                        -addexstyle => WS_EX_CLIENTEDGE,
                        ) or die "new Edit";
# Init editor
InitEditor();

# Create FindDlg window
my $FindDlg = CreateFindDlg ();

# Event loop
$Window->Show();
Win32::GUI::Dialog();

# Free FindDlg
$FindDlg->CloseWindow();


sub InitEditor {

  # Set Perl Lexer
  $Editor->SetLexer(Win32::GUI::Scintilla::SCLEX_PERL);

  # Set Perl Keyword
  $Editor->SetKeyWords(0, $PERL_KEYWORD);

  # Folder ????
  $Editor->SetProperty("fold", "1");
  $Editor->SetProperty("tab.timmy.whinge.level", "1");

  # Indenetation
  $Editor->SetIndentationGuides(1);
  $Editor->SetUseTabs(1);
  $Editor->SetTabWidth(3);
  $Editor->SetIndent(3);

  # Edge Mode
  $Editor->SetEdgeMode(Win32::GUI::Scintilla::EDGE_LINE); #Win32::GUI::Scintilla::EDGE_BACKGROUND
  $Editor->SetEdgeColumn(80);

  # Define margin
  # $Editor->SetMargins(0,0);
  $Editor->SetMarginTypeN(1, Win32::GUI::Scintilla::SC_MARGIN_NUMBER);
  $Editor->SetMarginWidthN(1, 25);

  $Editor->SetMarginTypeN(2, Win32::GUI::Scintilla::SC_MARGIN_SYMBOL);
  $Editor->SetMarginMaskN(2, Win32::GUI::Scintilla::SC_MASK_FOLDERS);
  $Editor->SetMarginSensitiveN(2, 1);
  $Editor->SetMarginWidthN(2, 12);

  # Define marker
  $Editor->MarkerDefine(Win32::GUI::Scintilla::SC_MARKNUM_FOLDEREND,     Win32::GUI::Scintilla::SC_MARK_BOXPLUSCONNECTED);
  $Editor->MarkerSetFore(Win32::GUI::Scintilla::SC_MARKNUM_FOLDEREND, '#FFFFFF');
  $Editor->MarkerSetBack(Win32::GUI::Scintilla::SC_MARKNUM_FOLDEREND, '#000000');
  $Editor->MarkerDefine(Win32::GUI::Scintilla::SC_MARKNUM_FOLDEROPENMID, Win32::GUI::Scintilla::SC_MARK_BOXMINUSCONNECTED);
  $Editor->MarkerSetFore(Win32::GUI::Scintilla::SC_MARKNUM_FOLDEROPENMID, '#FFFFFF');
  $Editor->MarkerSetBack(Win32::GUI::Scintilla::SC_MARKNUM_FOLDEROPENMID, '#000000');
  $Editor->MarkerDefine(Win32::GUI::Scintilla::SC_MARKNUM_FOLDERMIDTAIL, Win32::GUI::Scintilla::SC_MARK_TCORNER);
  $Editor->MarkerSetFore(Win32::GUI::Scintilla::SC_MARKNUM_FOLDERMIDTAIL, '#FFFFFF');
  $Editor->MarkerSetBack(Win32::GUI::Scintilla::SC_MARKNUM_FOLDERMIDTAIL, '#000000');
  $Editor->MarkerDefine(Win32::GUI::Scintilla::SC_MARKNUM_FOLDERTAIL,    Win32::GUI::Scintilla::SC_MARK_LCORNER);
  $Editor->MarkerSetFore(Win32::GUI::Scintilla::SC_MARKNUM_FOLDERTAIL, '#FFFFFF');
  $Editor->MarkerSetBack(Win32::GUI::Scintilla::SC_MARKNUM_FOLDERTAIL, '#000000');
  $Editor->MarkerDefine(Win32::GUI::Scintilla::SC_MARKNUM_FOLDERSUB,     Win32::GUI::Scintilla::SC_MARK_VLINE);
  $Editor->MarkerSetFore(Win32::GUI::Scintilla::SC_MARKNUM_FOLDERSUB, '#FFFFFF');
  $Editor->MarkerSetBack(Win32::GUI::Scintilla::SC_MARKNUM_FOLDERSUB, '#000000');
  $Editor->MarkerDefine(Win32::GUI::Scintilla::SC_MARKNUM_FOLDER,        Win32::GUI::Scintilla::SC_MARK_BOXPLUS);
  $Editor->MarkerSetFore(Win32::GUI::Scintilla::SC_MARKNUM_FOLDER, '#FFFFFF');
  $Editor->MarkerSetBack(Win32::GUI::Scintilla::SC_MARKNUM_FOLDER, '#000000');
  $Editor->MarkerDefine(Win32::GUI::Scintilla::SC_MARKNUM_FOLDEROPEN,    Win32::GUI::Scintilla::SC_MARK_BOXMINUS);
  $Editor->MarkerSetFore(Win32::GUI::Scintilla::SC_MARKNUM_FOLDEROPEN, '#FFFFFF');
  $Editor->MarkerSetBack(Win32::GUI::Scintilla::SC_MARKNUM_FOLDEROPEN, '#000000');

  # Define Style
  $Editor->StyleClearAll();

  # Global default styles for all languages
  $Editor->StyleSetSpec(Win32::GUI::Scintilla::STYLE_DEFAULT,     "face:$faces{'mono'},size:$faces{'size'}");
  $Editor->StyleSetSpec(Win32::GUI::Scintilla::STYLE_LINENUMBER,  "back:#C0C0C0,face:$faces{mono}");
  $Editor->StyleSetSpec(Win32::GUI::Scintilla::STYLE_CONTROLCHAR, "face:$faces{mono}");
  $Editor->StyleSetSpec(Win32::GUI::Scintilla::STYLE_BRACELIGHT,  "fore:#FFFFFF,back:#0000FF,bold");
  $Editor->StyleSetSpec(Win32::GUI::Scintilla::STYLE_BRACEBAD,    "fore:#000000,back:#FF0000,bold");

  # White space
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_DEFAULT, "fore:#808080,face:$faces{'mono'}");
  # Error
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_ERROR , "fore:#0000FF");
  # Comment
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_COMMENTLINE, "fore:#007F00");
  # POD: = at beginning of line
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_POD, "fore:#004000,back:#E0FFE0,eolfilled");
  # Number
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_NUMBER, "fore:#007F7F");
  # Keyword
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_WORD , "fore:#00007F,bold");
  # Double quoted string
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_STRING, "fore:#7F007F,face:$faces{'mono'},italic");
  # Single quoted string
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_CHARACTER, "fore:#7F0000,face:$faces{'mono'},italic");
  # Symbols / Punctuation. Currently not used by LexPerl.
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_PUNCTUATION, "fore:#00007F,bold");
  # Preprocessor. Currently not used by LexPerl.
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_PREPROCESSOR, "fore:#00007F,bold");
  # Operators
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_OPERATOR , "bold");
  # Identifiers (functions, etc.)
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_IDENTIFIER , "fore:#000000");
  # Scalars: $var
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_SCALAR, "fore:#000000,back:#FFE0E0");
  # Array: @var
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_ARRAY, "fore:#000000,back:#FFFFE0");
  # Hash: %var
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_HASH, "fore:#000000,back:#FFE0FF");
  # Symbol table: *var
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_SYMBOLTABLE, "fore:#000000,back:#E0E0E0");
  # Regex: /re/ or m{re}
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_REGEX, "fore:#000000,back:#A0FFA0");
  # Substitution: s/re/ore/
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_REGSUBST, "fore:#000000,back:#F0E080");
  # Long Quote (qq, qr, qw, qx) -- obsolete: replaced by qq, qx, qr, qw
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_LONGQUOTE, "fore:#FFFF00,back:#8080A0");
  # Back Ticks
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_BACKTICKS, "fore:#FFFF00,back:#A08080");
  # Data Section: __DATA__ or __END__ at beginning of line
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_DATASECTION, "#600000,back:#FFF0D8,eolfilled");
  # Here-doc (delimiter)
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_HERE_DELIM, "fore:#000000,back:#DDD0DD");
  # Here-doc (single quoted, q)
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_HERE_Q, "fore:#7F007F,back:#DDD0DD,eolfilled,notbold");
  # Here-doc (double quoted, qq)
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_HERE_QQ, "fore:#7F007F,back:#DDD0DD,eolfilled,bold");
  # Here-doc (back ticks, qx)
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_HERE_QX, "fore:#7F007F,back:#DDD0DD,eolfilled,italics");
  # Single quoted string, generic
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_STRING_Q, "fore:#7F007F,notbold");
  # qq = Double quoted string
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_STRING_QQ, "fore:#7F007F,italic");
  # qx = Back ticks
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_STRING_QX, "fore:#FFFF00,back:#A08080");
  # qr = Regex
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_STRING_QR, "fore:#000000,back:#A0FFA0");
  # qw = Array
  $Editor->StyleSetSpec (Win32::GUI::Scintilla::SCE_PL_STRING_QW, "fore:#000000,back:#FFFFE0");
}

sub Editor_Notify {

  my (%evt) = @_;

  if ($evt{-code} == Win32::GUI::Scintilla::SCN_UPDATEUI)
  {
    # Update menu
    my $Sel = ($Editor->GetSelectionStart() !=  $Editor->GetSelectionEnd());
    $Menu->{EditUndo}->Enabled($Editor->CanUndo());
    $Menu->{EditRedo}->Enabled($Editor->CanRedo());
    $Menu->{EditCut}->Enabled($Sel);
    $Menu->{EditCopy}->Enabled($Sel);
    $Menu->{EditPaste}->Enabled($Editor->CanPaste());
    $Menu->{EditClear}->Enabled($Sel);

    # check for matching braces
    $Editor->BraceHighEvent();
  }
  elsif ($evt{-code} == Win32::GUI::Scintilla::SCN_MARGINCLICK)
  {
    # Click on folder margin
    if ($evt{-margin} == 2) {

      # Manage Folder
      $Editor->FolderEvent(%evt);
      # caret visible
      $Editor->ScrollCaret();
    }

  }
}

# Main window event handler
sub Window_Terminate {

  return FileExit_Click();
}

sub Window_Resize {

  if (defined $Window) {
    my ($width, $height) = ($Window->GetClientRect)[2..3];
    $Editor->Move   (0, 0);
    $Editor->Resize ($width, $height);
  }
}

#######################################################################
#
#  File Menu
#
#######################################################################

sub FileNew_Click {

  $Editor->NewFile();
  $CurrentFile = "";
}

sub FileOpen_Click {

  my $file = Win32::GUI::GetOpenFileName(
                   -owner  => $Window,
                   -title  => "Open a text file",
                   -filter => [
                       'Perl script (*.pl)' => '*.pl',
                       'All files' => '*.*',
                    ],
                   -directory => $Directory,
                   );

  if ($file) {
     $Editor->LoadFile ($file);
     $CurrentFile = $file;
  }
  elsif (Win32::GUI::CommDlgExtendedError()) {
     Win32::GUI::MessageBox (0, "ERROR : ".Win32::GUI::CommDlgExtendedError(),
                            "GetOpenFileName Error");
  }
}

sub FileSave_Click {

  unless ($CurrentFile eq "") {
    my $ret = Win32::GUI::MessageBox (0, "Overwrite existing file ?",
                           "Save", MB_ICONQUESTION | MB_YESNOCANCEL);
    if ($ret == 6) {
      $ret = $Editor->SaveFile ($CurrentFile);
      unless ($ret) {
        Win32::GUI::MessageBox (0, "ERROR : SaveDocument ", "Save Error");
      }
    }
    elsif ($ret == 7) {
      FileSaveAs_Click();
    }
  }
  else {
    FileSaveAs_Click();
  }
}

sub FileSaveAs_Click {

  my $ret = Win32::GUI::GetSaveFileName (
                 -title     => "Save text file As",
                 -filter => [
                       'Perl script (*.pl)' => '*.pl',
                       'All files' => '*.*',
                  ],
                 -directory => $Directory,
                 );

  if ($ret) {
    $CurrentFile = $ret;
    $ret = $Editor->SaveFile ($CurrentFile);
    unless ($ret) {
      Win32::GUI::MessageBox (0, "ERROR : SaveDocument ", "Save Error");
    }
  }
  elsif (Win32::GUI::CommDlgExtendedError()) {
     Win32::GUI::MessageBox (0, "ERROR : ".Win32::GUI::CommDlgExtendedError(),
                            "GetSaveFileName Error");
  }

}

sub FileDirectory_Click {

  my $ret = Win32::GUI::BrowseForFolder (
                        -title      => "Select default directory",
                        -directory  => $Directory,
                        -folderonly => 1,
                        );
  $Directory = $ret if ($ret);
}

sub FileExit_Click {

  return -1
}

#######################################################################
#
#  Edit Menu
#
#######################################################################

sub EditUndo_Click {
  $Editor->Undo();
}

sub EditRedo_Click {
  $Editor->Redo();
}

sub EditCut_Click {
  $Editor->Cut();
}

sub EditCopy_Click {
  $Editor->Copy();
}

sub EditPaste_Click {
  $Editor->Paste();
}

sub EditSelectAll_Click {
  $Editor->SelectAll();
}

sub EditClear_Click {
  $Editor->Clear();
}

sub EditFind_Click {

  $FindDlg->Show();
}

#######################################################################
#
#  Help Menu
#
#######################################################################

sub HelpAbout_Click  {

  Win32::GUI::MessageBox(
     0,
     "Perl Editor, version $VERSION\r\n".
     "Laurent ROCHER",
     "About...",
     MB_ICONINFORMATION | MB_OK,
  );

  return 1;
}

#######################################################################
#
#  FindWindow
#
#######################################################################

sub CreateFindDlg {

  my $FindDlg = new Win32::GUI::Window(
                  -name  => "FindDlg",
                  -title => "Find",
                  -pos   => [ 150, 150 ],
                  -size  => [ 270, 140 ],
          );

  $FindDlg->AddLabel (
                  -name  => "FindDlg_Label",
                  -text  => "Find what...",
                  -pos   => [10, 12],
                  -size  => [100, 13],
          );

  $FindDlg->AddTextfield (
                  -name  => "FindDlg_Text",
                  -pos   => [10, 30],
                  -size  => [150, 21],
          );

  $FindDlg->AddCheckbox (
                  -name  => "FindDlg_Case",
                  -text  => "Match case",
                  -pos   => [10, 50],
                  -size  => [100, 21],
          );

  $FindDlg->AddCheckbox (
                  -name  => "FindDlg_Word",
                  -text  => "Find Whole word only",
                  -pos   => [10, 70],
                  -size  => [100, 21],
          );

  $FindDlg->AddCheckbox (
                  -name  => "FindDlg_REGEX",
                  -text  => "Regular expression",
                  -pos   => [10, 90],
                  -size  => [75, 21],
          );

  $FindDlg->AddButton (
                  -name  => "FindDlg_Forward",
                  -text  => "&Forward",
                  -pos   => [180, 10],
                  -size  => [75 , 21],
          );

  $FindDlg->AddButton (
                  -name  => "FindDlg_Backware",
                  -text  => "&Backware",
                  -pos   => [180, 40],
                  -size  => [75 , 21],
          );

  $FindDlg->AddButton (
                  -name  => "FindDlg_Close",
                  -text  => "C&lose",
                  -pos   => [180, 70],
                  -size  => [75 , 21],
          );

  return $FindDlg;
}


sub FindDlg_Forward_Click {

  my $text = $FindDlg->FindDlg_Text->Text();
  my $flag = 0;


  $flag |= Win32::GUI::Scintilla::SCFIND_MATCHCASE if ($FindDlg->FindDlg_Case->Checked());
  $flag |= Win32::GUI::Scintilla::SCFIND_WHOLEWORD if ($FindDlg->FindDlg_Word->Checked());
  $flag |= Win32::GUI::Scintilla::SCFIND_REGEXP    if ($FindDlg->FindDlg_REGEX->Checked());

  if ($Editor->FindAndSelect ($text, $flag, 1, 1) == -1)
  {
    Win32::GUI::MessageBox($FindDlg, "Text not found", "Find...");
  }

  0;
}

sub FindDlg_Backware_Click {

  my $text = $FindDlg->FindDlg_Text->Text();
  my $flag = 0;

  $flag |= Win32::GUI::Scintilla::SCFIND_MATCHCASE if ($FindDlg->FindDlg_Case->Checked());
  $flag |= Win32::GUI::Scintilla::SCFIND_WHOLEWORD if ($FindDlg->FindDlg_Word->Checked());
  $flag |= Win32::GUI::Scintilla::SCFIND_REGEXP    if ($FindDlg->FindDlg_REGEX->Checked());

  if ($Editor->FindAndSelect ($text, $flag, -1, 1) == -1)
  {
    Win32::GUI::MessageBox($FindDlg, "Text not found", "Find...");
  }
  0;
}

sub FindDlg_Close_Click {

  $FindDlg->Hide();
  0;
}

sub FindDlg_Terminate {

  return FindDlg_Close_Click();
}

Update of /cvsroot/perl-win32-gui/Win32-GUI-Scintilla/Samples
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv23550/Samples

Log Message:
Directory /cvsroot/perl-win32-gui/Win32-GUI-Scintilla/Samples added to the repository

Update of /cvsroot/perl-win32-gui/Win32-GUI-Scintilla/Include
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv23550/Include

Log Message:
Directory /cvsroot/perl-win32-gui/Win32-GUI-Scintilla/Include added to the repository