www.pudn.com > 1.rar > I2BaseWBSet.cpp

// I2BaseWBSet.cpp: implementation of the CI2WBBaseWBSet class. 
// 
////////////////////////////////////////////////////////////////////// 
 
#include "stdafx.h" 
#include "resource.h" 
#include "iaspwb.h" 
  
HINSTANCE g_hinstance; 
UINT g_wb32clipformat; 
 
void initLib() 
{ 
  g_hinstance=GetModuleHandle("iaspwb.dll"); 
	InitCommonControls(); 
  CI2WBBaseWB wb(NULL); 
  wb.registerClassEx(); 
} 
 
CI2WBBaseWBSet::CI2WBBaseWBSet() 
{ 
	m_whiteboardindex=-1; 
	m_controlsetpos=0; 
	m_wbcallback=NULL; 
 
	m_prop_linewidth=1; 
	m_prop_linestyle=PS_SOLID; 
	m_prop_color=RGB(0,0,0); 
	m_prop_bkcolor=RGB(255,255,255); 
	m_prop_font.size=9; 
	m_prop_font.color=RGB(0,0,0); 
	m_prop_font.style=0; 
	HFONT font=(HFONT)GetStockObject(DEFAULT_GUI_FONT); 
	LOGFONT logfont; 
	GetObject(font,sizeof(LOGFONT),(void*)&logfont); 
	lstrcpy(m_prop_font.name,logfont.lfFaceName); 
 
	m_stream=NULL; 
	m_findi=TRUE; 
	m_indipos.x=WB_INDICATE_XOFFSET; 
	m_indipos.y=WB_INDICATE_YOFFSET; 
  m_permit=1; 
  m_erase=0; 
 
} 
 
CI2WBBaseWBSet::~CI2WBBaseWBSet() 
{ 
int i,j; 
j=m_whiteboardlist.get_Count()-1; 
for(i=j;i>=0;i--) 
{ 
    delete (CI2WBBaseWB*)(m_whiteboardlist.get_Items()[i]); 
    m_whiteboardlist.Delete(i); 
}  
j=m_controlsetlist.get_Count()-1; 
for(i=j;i>=0;i--) 
{ 
    delete m_controlsetlist.get_Items()[i]; 
    m_controlsetlist.Delete(i); 
} 
} 
  
void CI2WBBaseWBSet::addWb(LPSTR pwbname,INT index,BOOL fsend,BOOL fsync) 
{ 
if(m_whiteboardindex!=-1) 
{ 
  CI2WBBaseWB* pwb1=(CI2WBBaseWB*)m_whiteboardlist.get_Items()[m_whiteboardindex]; 
  if(pwb1->m_wbs==wbsInplaceEditorActive) 
    pwb1->closeInplaceEditor();//close inplace editor 
} 
 
CI2WBBaseWB* pwb=new CI2WBBaseWB(this); 
if(!pwb) 
    throw new I2BaseException(I2E_OUTOFMEMORY); 
pwb->createEx(0,WB32CLASSNAME,NULL, 
                      WS_CHILD|WS_VISIBLE, 
                      0,0,WB_DEFAULT_WIDTH,WB_DEFAULT_HEIGHT, 
                      m_hwnd,NULL); 
HWND h; 
if(m_whiteboardindex > -1) 
{ 
    h=(HWND)(*m_whiteboardlist[m_whiteboardindex]); 
    ShowWindow(h,SW_HIDE); 
} 
 
if(index>0 && indexset_Name(buf); 
} 
else 
    pwb->set_Name(pwbname); 
 
if(m_wbcallback) 
	  m_wbcallback(WB32_SETCURWB,(void*)&(m_whiteboardindex)); 
h=(HWND)(*m_whiteboardlist[m_whiteboardindex]); 
ShowWindow(h,SW_SHOW); 
if(fsend) 
{ 
    CHAR tmpbuf[MAX_CTRLIDNAME]; 
    pwb->get_Name(tmpbuf); 
	  sendSlideShow(WB_NEW,tmpbuf); 
} 
if(!fsync) 
    pwb->set_Sync(FALSE); 
} 
  
BOOL CI2WBBaseWBSet::setWb(INT index,BOOL fsend) 
{ 
if(m_whiteboardindex==-1 ) 
   return TRUE; 
 
ShowWindow((HWND)(*m_whiteboardlist[m_whiteboardindex]),SW_HIDE); 
if(index<0 || index>m_whiteboardlist.get_Count()-1) 
	m_whiteboardindex=0; 
else	 
	m_whiteboardindex=index; 
ShowWindow((HWND)(*m_whiteboardlist[m_whiteboardindex]),SW_SHOW); 
if(fsend) 
	sendSlideShow(WB_SET,NULL); 
if(m_wbcallback) 
	m_wbcallback(WB32_SETCURWB,(void*)&(m_whiteboardindex)); 
 
//sync 
CI2WBBaseWB* pwb=(CI2WBBaseWB*)m_whiteboardlist.get_Items()[m_whiteboardindex]; 
if(!(pwb->get_Sync())) 
  return FALSE;//need sync 
 
return TRUE; 
} 
 
void CI2WBBaseWBSet::delWb(LPSTR wbname,BOOL fsend) 
{ 
INT index; 
index=getWbIndex(wbname); 
delWb(index,fsend); 
} 
 
void CI2WBBaseWBSet::delWb(INT index,BOOL fsend) 
{ 
if(m_whiteboardindex!=-1) 
{ 
CI2WBBaseWB* pwb1=(CI2WBBaseWB*)m_whiteboardlist.get_Items()[m_whiteboardindex]; 
if(pwb1->m_wbs==wbsInplaceEditorActive) 
  pwb1->closeInplaceEditor();//close inplace editor 
} 
 
HWND h; 
if(m_whiteboardindex==-1) 
  return; 
 
if(index-1<0 && index!=-1) 
  return; 
if( index-1>=m_whiteboardlist.get_Count()) 
  return; 
 
CHAR buf[256]; 
memset(buf,0,256); 
 
if(index-1 == m_whiteboardindex || index == -1) 
{ 
    get_Name(buf,m_whiteboardindex); 
    delete m_whiteboardlist[m_whiteboardindex]; 
    m_whiteboardlist.Delete(m_whiteboardindex); 
 
    if(m_whiteboardindex-1>=0) 
    { 
        m_whiteboardindex--; 
        h=(HWND)(*m_whiteboardlist[m_whiteboardindex]); 
        ShowWindow(h,SW_SHOW); 
    } 
    else 
    { 
        m_whiteboardindex = m_whiteboardlist.get_Count()-1; 
        if(m_whiteboardindex!=-1) 
        { 
        	  h=(HWND)(*m_whiteboardlist[m_whiteboardindex]); 
        	  ShowWindow(h,SW_SHOW); 
        } 
    } 
} 
else 
{ 
    get_Name(buf,index-1); 
    delete m_whiteboardlist[index-1]; 
    m_whiteboardlist.Delete(index-1); 
    if(index-1 < m_whiteboardindex) 
        m_whiteboardindex=m_whiteboardindex-1; 
} 
 
if(fsend) 
{ 
	  sendSlideShow(WB_DEL,buf); 
} 
if(m_wbcallback) 
	  m_wbcallback(WB32_SETCURWB,(void*)&(m_whiteboardindex)); 
} 
 
BOOL CI2WBBaseWBSet::prevWb(BOOL fsend) 
{ 
HWND h; 
if(m_whiteboardindex==-1 ) 
   return TRUE; 
 
h=(HWND)(*m_whiteboardlist[m_whiteboardindex]); 
ShowWindow(h,SW_HIDE); 
m_whiteboardindex=m_whiteboardindex-1; 
if(m_whiteboardindex<0) 
  m_whiteboardindex=m_whiteboardlist.get_Count()-1; 
h=(HWND)(*m_whiteboardlist[m_whiteboardindex]); 
ShowWindow(h,SW_SHOW); 
if(fsend) 
	sendSlideShow(WB_SET,NULL); 
if(m_wbcallback) 
	m_wbcallback(WB32_SETCURWB,(void*)&(m_whiteboardindex)); 
 
//sync 
CI2WBBaseWB* pwb=(CI2WBBaseWB*)m_whiteboardlist.get_Items()[m_whiteboardindex]; 
 
if(pwb->m_wbs==wbsInplaceEditorActive) 
  pwb->closeInplaceEditor();//close inplace editor 
 
if(!(pwb->get_Sync())) 
  return FALSE;//need sync 
 
return TRUE; 
} 
 
BOOL CI2WBBaseWBSet::nextWb(BOOL fsend) 
{ 
if(m_whiteboardindex==-1) 
   return TRUE; 
 
HWND h=(HWND)(*m_whiteboardlist[m_whiteboardindex]); 
ShowWindow(h,SW_HIDE); 
m_whiteboardindex=m_whiteboardindex+1; 
if(m_whiteboardindex > m_whiteboardlist.get_Count()-1) 
	m_whiteboardindex=0; 
h=(HWND)(*m_whiteboardlist[m_whiteboardindex]); 
ShowWindow(h,SW_SHOW); 
if(fsend) 
	sendSlideShow(WB_SET,NULL); 
if(m_wbcallback) 
	m_wbcallback(WB32_SETCURWB,(void*)&(m_whiteboardindex)); 
 
//sync 
CI2WBBaseWB* pwb=(CI2WBBaseWB*)m_whiteboardlist.get_Items()[m_whiteboardindex]; 
 
if(pwb->m_wbs==wbsInplaceEditorActive) 
  pwb->closeInplaceEditor();//close inplace editor 
 
if(!(pwb->get_Sync())) 
  return FALSE;//need sync 
 
return TRUE; 
} 
 
void CI2WBBaseWBSet::setCallBack(IASPWB32PROC wbcallback) 
{ 
m_wbcallback=wbcallback; 
} 
 
void CI2WBBaseWBSet::writeToStream() 
{ 
 
} 
 
void CI2WBBaseWBSet::readFromStream() 
{ 
 
} 
 
BOOL CI2WBBaseWBSet::recv(VOID *p,INT len) 
{ 
I2MemoryFileStream stm(1024); 
WB32HEADER wh; 
WB32SLIDE wd; 
WB32INDICATE	wi; 
try 
{ 
CHAR *pdata=(CHAR*)GlobalAlloc(GPTR,*((long*)p)); 
INT count=I2Zlib::decompress((CHAR*)p+sizeof(long),len-sizeof(long),pdata); 
stm.writeFile(pdata,*((long*)p));//*(long*)p) length of data before compress 
                                 //len = length of compressed data + long 
GlobalFree(pdata); 
} 
catch(I2Exception *e) 
{ 
  d::s("recv decompress"); 
  e->report(); 
  e->Delete(); 
} 
if(stm.get_Length()==0) 
   return TRUE; 
stm.seekFile(0,I2SEEK_SET); 
stm.readFile((CHAR *)&wh,sizeof(WB32HEADER)); 
switch(wh.datatype) 
{ 
case  WB_TYPE_SLIDE://slide show operation 
stm.readFile((CHAR*)&wd,sizeof(WB32SLIDE)); 
switch(LOWORD(wd.code)) 
{ 
    case WB_NEW: 
    	addWb(wd.wbname,-1,FALSE,TRUE); 
    	break; 
 
    case WB_FIRST: 
    	break; 
 
    case WB_LAST: 
    	break; 
 
    case WB_NEXT: 
//    	return nextWb(FALSE); 
      break; 
 
    case WB_PREV: 
//    	return prevWb(FALSE); 
      break; 
 
    case WB_DEL: 
    	delWb(wd.wbname,FALSE); 
    	break; 
 
    case WB_SET: 
    	return setWb(HIWORD(wd.code),FALSE); 
} 
break; 
 
case WB_TYPE_INDICATE: 
	{ 
    stm.readFile((CHAR*)&wi,sizeof(WB32INDICATE)); 
    CI2WBBaseWB* pwb=(CI2WBBaseWB*)m_whiteboardlist.get_Items()[m_whiteboardindex]; 
    if(m_findi==wi.findi) 
    	pwb->drawIndicate(wi.point.x,wi.point.y,FALSE,FALSE); 
    else 
    { 
    	pwb->drawIndicate(wi.point.x,wi.point.y,TRUE,FALSE); 
    	m_findi=wi.findi; 
    } 
	} 
break; 
 
default: 
{ 
    if(m_whiteboardindex==-1) 
        return TRUE; 
    if(getWbIndex(wh.wbname)>0) 
    { 
        CI2WBBaseWB* pwb=(CI2WBBaseWB*)m_whiteboardlist.get_Items()[getWbIndex(wh.wbname)-1]; 
        if(pwb->get_Sync())//m_sync=FALSE,not receive remote data 
          pwb->recv(stm.get_Pointer(),stm.get_Length()); 
    } 
} 
break; 
} 
return TRUE; 
} 
 
BOOL CI2WBBaseWBSet::processMessage(UINT uMsg,WPARAM wParam,LPARAM lParam) 
{ 
switch(uMsg) 
   { 
   case WM_CREATE: 
	   { 
     if(!g_hinstance) 
	     g_hinstance=GetModuleHandle("iaspwb.dll"); 
     CI2WBBaseWBSet *pwb=(CI2WBBaseWBSet *)(((LPCREATESTRUCT)lParam)->lpCreateParams); 
     pwb->m_himl = ImageList_LoadBitmap(g_hinstance,MAKEINTRESOURCE(IDB_INDICATE_REMOTE),WB_INDICATE_WIDTH,2,RGB(255,0,255)); 
     break; 
	   } 
 
   case WM_SIZE: 
     break; 
 
   case WM_HSCROLL: 
     { 
     INT pos; 
     if(LOWORD(wParam)==SB_THUMBPOSITION||LOWORD(wParam)==SB_THUMBTRACK) 
       pos=HIWORD(wParam); 
     else 
       pos=GetScrollPos(m_hwnd,SB_HORZ); 
     INT min,max; 
     GetScrollRange(m_hwnd,SB_HORZ,&min,&max); 
 
     switch(LOWORD(wParam)) 
     { 
     case SB_LINELEFT: 
     pos--; 
     break; 
 
     case SB_LINERIGHT: 
     pos++; 
     break; 
 
     case SB_PAGELEFT: 
     pos-=10; 
     break; 
 
     case SB_PAGERIGHT: 
     pos+=10; 
     break; 
 
     case SB_THUMBPOSITION: 
     break; 
 
     case SB_THUMBTRACK: 
     break; 
      
     default: 
     return 0; 
     } 
   if(posmax) 
      pos=max; 
    
   SetScrollPos(m_hwnd,SB_HORZ,pos,TRUE); 
   OnHScroll(pos); 
   } 
   break; 
 
   case WM_VSCROLL: 
   { 
   INT pos; 
   if(LOWORD(wParam)==SB_THUMBPOSITION||LOWORD(wParam)==SB_THUMBTRACK) 
      pos=HIWORD(wParam); 
   else 
      pos=GetScrollPos(m_hwnd,SB_VERT); 
   INT min,max; 
   GetScrollRange(m_hwnd,SB_VERT,&min,&max); 
 
   switch(LOWORD(wParam)) 
     { 
     case SB_LINEUP: 
     pos--; 
     break; 
 
     case SB_LINEDOWN: 
     pos++; 
     break; 
 
     case SB_PAGEUP: 
     pos-=10; 
     break; 
 
     case SB_PAGEDOWN: 
     pos+=10; 
     break; 
 
     case SB_THUMBPOSITION: 
     break; 
 
     case SB_THUMBTRACK: 
     break; 
      
     default: 
     return 0; 
     } 
   if(posmax) 
      pos=max; 
    
   SetScrollPos(m_hwnd,SB_VERT,pos,TRUE); 
   OnVScroll(pos); 
   } 
   break; 
 
   default: 
   return I2Wnd::processMessage(uMsg,wParam,lParam); 
   }  
return TRUE; 
} 
 
void CI2WBBaseWBSet::fillClassInfo(LPWNDCLASSEX pwcx) 
{ 
pwcx->hbrBackground=(HBRUSH)(COLOR_BTNFACE+1); 
pwcx->lpszClassName=WB32HOLDERCLASSNAME; 
pwcx->style=CS_DBLCLKS; 
} 
 
void CI2WBBaseWBSet::Initialize(HWND hParentWnd,const I2Rect& rect,I2Stream* stream) 
{ 
if(!hParentWnd) 
   throw new I2BaseException(I2E_INVALIDPARAMETER); 
 
/*CI2WBBaseWB wb(this); 
wb.registerClassEx();*/ 
 
InitControlSetList(); 
 
RegisterEditorControl(CSID_Draw,Draw_Text); 
RegisterDragDropControl("txt",CSID_Draw,Draw_Text); 
RegisterDragDropControl("bat",CSID_Draw,Draw_Text); 
RegisterDragDropControl("h",CSID_Draw,Draw_Text); 
RegisterDragDropControl("c",CSID_Draw,Draw_Text); 
RegisterDragDropControl("cpp",CSID_Draw,Draw_Text); 
 
//RegisterDragDropControl("bmp",CSID_Draw,Draw_Image); 
//RegisterDragDropControl("gif",CSID_Draw,Draw_ImageGif); 
//RegisterDragDropControl("jpg",CSID_Draw,Draw_ImageJpeg); 
//RegisterDragDropControl("wmf",CSID_Draw,Draw_ImageMeta); 
//RegisterDragDropControl("wmf",CSID_Draw,Draw_ImageMeta); 
g_wb32clipformat = RegisterClipboardFormat(IASPWB32CLIPBOARDFORMAT); 
 
set_Stream(stream); 
} 
 
VOID screentoclient(HWND hwnd,I2Rect& lprect) 
{ 
POINT p; 
 
p.x=lprect.left; 
p.y=lprect.top; 
ScreenToClient(hwnd,&p); 
lprect.left=p.x; 
lprect.top=p.y; 
 
p.x=lprect.right; 
p.y=lprect.bottom; 
ScreenToClient(hwnd,&p); 
lprect.right=p.x; 
lprect.bottom=p.y; 
} 
 
VOID CI2WBBaseWBSet::InitControlSetList() 
{ 
CI2WBControlSet* pwb=new CI2WBControlSet; 
m_controlsetlist.append((CI2WBBaseCSet*)pwb); 
CI2WBElecSet* pwb2=new CI2WBElecSet; 
m_controlsetlist.append((CI2WBBaseCSet*)pwb2); 
CI2WBCurveSet* pwb1=new CI2WBCurveSet; 
m_controlsetlist.append((CI2WBBaseCSet*)pwb1); 
} 
 
VOID CI2WBBaseWBSet::OnPageScrollChange() 
{ 
if(m_whiteboardindex==-1) 
   ShowScrollBar(m_hwnd,SB_BOTH,FALSE); 
else 
  { 
  I2Rect rect,wbrect; 
  CI2WBBaseWB* pwb=new CI2WBBaseWB(this); 
  INT  newleft,newtop; 
  BOOL hbar=FALSE,vbar=FALSE; 
   
  GetWindowRect(m_hwnd,&rect); 
  pwb=(CI2WBBaseWB*)(m_whiteboardlist.get_Items()[m_whiteboardindex]); 
  GetWindowRect((HWND)(*pwb),&wbrect); 
  screentoclient(m_hwnd,wbrect); 
   
  //show/hide scroll bar 
  if(pwb->m_width>rect.width()&&pwb->m_height>rect.height()) 
    { 
    hbar=TRUE; 
    rect.bottom-=GetSystemMetrics(SM_CYHSCROLL); 
    vbar=TRUE; 
    rect.right-=GetSystemMetrics(SM_CYVSCROLL); 
    } 
  else if(pwb->m_width>rect.width()) 
    { 
    hbar=TRUE; 
    rect.bottom-=GetSystemMetrics(SM_CYHSCROLL); 
    if(pwb->m_height>rect.height()) 
      { 
      vbar=TRUE; 
      rect.right-=GetSystemMetrics(SM_CYVSCROLL); 
      } 
    } 
  else if(pwb->m_height>rect.height()) 
    { 
    vbar=TRUE; 
    rect.right-=GetSystemMetrics(SM_CYVSCROLL); 
    if(pwb->m_width>rect.width()) 
      { 
      hbar=TRUE; 
      rect.bottom-=GetSystemMetrics(SM_CYHSCROLL); 
      } 
    } 
     
  ShowScrollBar(m_hwnd,SB_HORZ,hbar); 
  ShowScrollBar(m_hwnd,SB_VERT,vbar); 
   
  //calculate horizontal space 
  if(pwb->m_width>rect.width()) 
    {  
    if(wbrect.left>=0) 
       newleft=0; 
    else 
       newleft=0-min(abs(wbrect.left),pwb->m_width-rect.width()); 
    } 
  else 
    newleft=(rect.width()-pwb->m_width)/2; 
  //calculate vertical space 
  if(pwb->m_height>rect.height()) 
    { 
    if(wbrect.top>=0) 
       newtop=0; 
    else 
       newtop=0-min(abs(wbrect.top),pwb->m_height-rect.height()); 
    } 
  else 
    newtop=(rect.height()-pwb->m_height)/2; 
 
  if(hbar) 
    { 
    SetScrollRange(m_hwnd,SB_HORZ,0,pwb->m_width-rect.width(),FALSE); 
    SetScrollPos(m_hwnd,SB_HORZ,abs(newleft),TRUE); 
    } 
  if(vbar) 
    { 
    SetScrollRange(m_hwnd,SB_VERT,0,pwb->m_height-rect.height(),FALSE); 
    SetScrollPos(m_hwnd,SB_VERT,abs(newtop),TRUE); 
    } 
   
  MoveWindow((HWND)(*pwb),newleft,newtop,pwb->m_width,pwb->m_height,TRUE); 
  delete pwb;//322 
  } 
} 
 
VOID CI2WBBaseWBSet::resize(const I2Rect& rect) 
{ 
if(!m_hwnd) 
   throw new I2BaseException(I2E_INVALIDPARAMETER); 
 
MoveWindow(m_hwnd,rect.left,rect.top, 
           rect.right-rect.left,rect.bottom-rect.top,TRUE); 
} 
 
 
VOID CI2WBBaseWBSet::getCurWbIndex(INT* Value) 
{ 
*Value=m_whiteboardindex+1; 
}  
 
   INT CI2WBBaseWBSet::getWbIndex(LPSTR wbname) 
{ 
INT i; 
CI2WBBaseWB* pwb; 
CHAR buf[MAX_CTRLIDNAME]; 
for(i=0;iget_Name(buf); 
if(!lstrcmp(buf,wbname)) 
    return i+1; 
} 
return -2; 
} 
   
INT CI2WBBaseWBSet::get_Count() 
{ 
return m_whiteboardlist.get_Count(); 
} 
 
 
VOID CI2WBBaseWBSet::sendSlideShow(DWORD slide,LPSTR wbname) 
{ 
I2MemoryFileStream stm(1024); 
WB32HEADER wh; 
WB32SLIDE wd;  
wh.datatype=WB_TYPE_SLIDE; 
stm.writeFile((CHAR*)&wh,sizeof(WB32HEADER)); 
if(slide==WB_SET) 
  wd.code=MAKELONG(slide,m_whiteboardindex); 
else 
  wd.code=slide; 
lstrcpy(wd.wbname,wbname); 
stm.writeFile((CHAR*)&wd,sizeof(WB32SLIDE)); 
 
//if(m_stream) 
//  m_stream->write((CHAR*)stm.get_Pointer(),stm.get_Length()); 
sendData(stm); 
} 
 
VOID CI2WBBaseWBSet::set_Stream(I2Stream* Value) 
{ 
m_stream=Value; 
} 
 
VOID CI2WBBaseWBSet::get_Stream(I2Stream* Value) 
{ 
Value=m_stream; 
} 
 
INT CI2WBBaseWBSet::get_Permit() 
{ 
return m_permit; 
} 
 
VOID CI2WBBaseWBSet::set_Permit(BOOL fpermit) 
{ 
m_permit=fpermit; 
} 
 
void CI2WBBaseWBSet::enumControlSet(I2List& infolist) 
{ 
int i; 
for(i=0;iOnCSIDChange(m_CurControlSetId,Value); 
m_CurControlSetId=Value; 
} 
 
VOID CI2WBBaseWBSet::getControlID(INT* Value) 
{ 
*Value=m_CurControlId; 
} 
 
VOID CI2WBBaseWBSet::setControlID(INT Value) 
{ 
m_CurControlId=Value; 
} 
 
CI2WBBaseCSet * CI2WBBaseWBSet::getCurControlSet() 
{ 
INT i; 
 
for(i=0;igetControlSetID(&csid); 
   if(IsEqualGUID(csid,m_CurControlSetId)) 
	  return pwcs; 
   } 
 
return NULL; 
} 
 
VOID CI2WBBaseWBSet::lock(VOID) 
{ 
if(m_whiteboardindex==-1) 
  return; 
if(!m_permit) 
  return; 
CI2WBBaseWB* pwb=(CI2WBBaseWB*)m_whiteboardlist.get_Items()[m_whiteboardindex]; 
pwb->lock(); 
} 
 
VOID CI2WBBaseWBSet::unlock(VOID) 
{ 
if(m_whiteboardindex==-1) 
  return; 
if(!m_permit) 
  return; 
CI2WBBaseWB* pwb=(CI2WBBaseWB*)m_whiteboardlist.get_Items()[m_whiteboardindex]; 
pwb->unlock(); 
} 
 
VOID CI2WBBaseWBSet::get_LineWidth(INT* Value) 
{ 
*Value=m_prop_linewidth; 
} 
 
VOID CI2WBBaseWBSet::set_LineWidth(INT Value) 
{ 
if(Value>=MIN_LINEWIDTH&&Value<=MAX_LINEWIDTH) 
  {  
  m_prop_linewidth=Value; 
  if(m_whiteboardindex!=-1) 
    ((CI2WBBaseWB*)(m_whiteboardlist.get_Items()[m_whiteboardindex]))->OnAttribChange(WBAT_LINEWIDTH); 
  } 
} 
 
VOID CI2WBBaseWBSet::get_LineStyle(INT* Value) 
{ 
*Value=m_prop_linestyle; 
} 
 
VOID CI2WBBaseWBSet::set_LineStyle(INT Value) 
{ 
m_prop_linestyle=Value; 
if(m_whiteboardindex!=-1) 
 ((CI2WBBaseWB*)(m_whiteboardlist.get_Items()[m_whiteboardindex]))->OnAttribChange(WBAT_LINESTYLE); 
} 
 
VOID CI2WBBaseWBSet::get_Color(COLORREF* Value) 
{ 
*Value=m_prop_color; 
} 
 
VOID CI2WBBaseWBSet::set_Color(COLORREF Value) 
{ 
m_prop_color=Value; 
if(m_whiteboardindex!=-1) 
  ((CI2WBBaseWB*)(m_whiteboardlist.get_Items()[m_whiteboardindex]))->OnAttribChange(WBAT_COLOR); 
} 
 
VOID CI2WBBaseWBSet::get_BKColor(COLORREF* Value) 
{ 
*Value=m_prop_bkcolor; 
} 
 
VOID CI2WBBaseWBSet::set_BKColor(COLORREF Value) 
{ 
m_prop_bkcolor=Value; 
if(m_whiteboardindex!=-1) 
  ((CI2WBBaseWB*)(m_whiteboardlist.get_Items()[m_whiteboardindex]))->OnAttribChange(WBAT_BKCOLOR); 
} 
 
VOID CI2WBBaseWBSet::get_Font(LPWB32FONT Value) 
{ 
CopyMemory(Value,&m_prop_font,sizeof(WB32FONT)); 
} 
 
VOID CI2WBBaseWBSet::set_Font(LPWB32FONT Value,INT mask) 
{ 
CopyMemory(&m_prop_font,Value,sizeof(WB32FONT)); 
if(m_whiteboardindex!=-1) 
{ 
  DWORD type=MAKELONG(WBAT_FONT,mask); 
  ((CI2WBBaseWB*)(m_whiteboardlist.get_Items()[m_whiteboardindex]))->OnAttribChange(type); 
} 
} 
 
VOID CI2WBBaseWBSet::bringToFront(BOOL fsend) 
{ 
if(!m_permit) 
  return; 
 
if(m_whiteboardindex!=-1) 
  ((CI2WBBaseWB*)(m_whiteboardlist.get_Items()[m_whiteboardindex]))->bringToFront(); 
if(fsend) 
  sendLayer(TRUE); 
} 
 
VOID CI2WBBaseWBSet::sendToBack(BOOL fsend) 
{ 
if(!m_permit) 
  return; 
 
if(m_whiteboardindex!=-1) 
  ((CI2WBBaseWB*)(m_whiteboardlist.get_Items()[m_whiteboardindex]))->sendToBack(); 
if(fsend) 
  sendLayer(FALSE); 
} 
 
VOID CI2WBBaseWBSet::sendLayer(BOOL flayer) 
{ 
  CI2WBBaseCtrl* pawc; 
  I2MemoryFileStream stm(1024); 
  WB32HEADER wh; 
  WB32LAYER wi; 
  I2List l; 
 
  wh.datatype=WB_TYPE_LAYER; 
  stm.writeFile((CHAR*)&wh,sizeof(WB32HEADER)); 
 
  wi.flayer=flayer; 
 
  ((CI2WBBaseWB*)m_whiteboardlist.get_Items()[m_whiteboardindex])->getStateControlList(l,CTRLSTATE_SELECT); 
  if(l.get_Count()!=1) 
     return; 
  pawc=(CI2WBBaseCtrl*)l.get_Items()[0]; 
  pawc->get_Name(wi.idname); 
 
  stm.writeFile((CHAR*)&wi,sizeof(WB32LAYER)); 
//  if(m_stream) 
//    m_stream->write((CHAR*)stm.get_Pointer(),stm.get_Length()); 
  sendData(stm); 
} 
 
VOID CI2WBBaseWBSet::changeIndicate()  
{ 
if(!m_permit) 
  return; 
 
if(m_whiteboardindex==-1) 
  return; 
((CI2WBBaseWB*)(m_whiteboardlist.get_Items()[m_whiteboardindex]))->drawIndicate(m_indipos.x,m_indipos.y,TRUE,TRUE); 
m_findi=!m_findi; 
sendIndicate(m_findi,m_indipos.x,m_indipos.y); 
}  
 
VOID CI2WBBaseWBSet::sendIndicate(BOOL findi,INT x,INT y) 
{ 
I2MemoryFileStream stm(1024); 
WB32HEADER wh; 
WB32INDICATE wi; 
wh.datatype=WB_TYPE_INDICATE; 
stm.writeFile((CHAR*)&wh,sizeof(WB32HEADER)); 
 
wi.findi=findi; 
wi.point.x=x; 
wi.point.y=y; 
stm.writeFile((CHAR*)&wi,sizeof(WB32INDICATE)); 
sendData(stm); 
} 
 
VOID CI2WBBaseWBSet::sendData(I2MemoryFileStream& stm) 
{ 
if(m_stream) 
{ 
  CHAR *p=(CHAR*)GlobalAlloc(GPTR,stm.get_Length()*1.001+12+sizeof(long)); 
  long lendata=I2Zlib::compress((CHAR*)stm.get_Pointer(),stm.get_Length(),p+sizeof(long),9); 
  *((long*)p)=stm.get_Length(); 
  m_stream->write(p,lendata+sizeof(long)); 
  GlobalFree(p); 
} 
} 
 
VOID CI2WBBaseWBSet::OnHScroll(INT offset) 
{ 
if(m_whiteboardindex==-1) 
   return; 
 
CI2WBBaseWB* pwb=(CI2WBBaseWB*)m_whiteboardlist.get_Items()[m_whiteboardindex]; 
 
I2Rect rect; 
GetWindowRect((HWND)(*pwb),&rect); 
screentoclient(m_hwnd,rect); 
MoveWindow((HWND)(*pwb),0-offset,rect.top,pwb->m_width,pwb->m_height,TRUE); 
} 
 
VOID CI2WBBaseWBSet::OnVScroll(INT offset) 
{ 
if(m_whiteboardindex==-1) 
   return; 
 
CI2WBBaseWB* pwb=(CI2WBBaseWB*)m_whiteboardlist.get_Items()[m_whiteboardindex]; 
 
I2Rect rect; 
GetWindowRect((HWND)(*pwb)/*->m_hwnd*/,&rect); 
screentoclient(m_hwnd,rect); 
MoveWindow((HWND)(*pwb)/*->m_hwnd*/,rect.left,0-offset,pwb->m_width,pwb->m_height,TRUE); 
} 
 
CI2WBBaseCSet* CI2WBBaseWBSet::getControlSet(GUID m_csid) 
{ 
INT i; 
 
for(i=0;igetControlSetID(&csid); 
	if(IsEqualGUID(csid,m_csid)) 
    return pwcs; 
  } 
 
return NULL; 
} 
 
VOID CI2WBBaseWBSet::del() 
{ 
if(!m_permit) 
  return; 
 
if(m_whiteboardindex==-1) 
   return; 
CI2WBBaseWB* pwb=(CI2WBBaseWB*)m_whiteboardlist.get_Items()[m_whiteboardindex]; 
pwb->deleteControl(); 
} 
 
VOID CI2WBBaseWBSet::cut() 
{ 
if(!m_permit) 
  return; 
 
if(m_whiteboardindex==-1) 
   return; 
CI2WBBaseWB* pwb=(CI2WBBaseWB*)m_whiteboardlist.get_Items()[m_whiteboardindex]; 
pwb->cut(); 
} 
 
VOID CI2WBBaseWBSet::copy() 
{ 
if(!m_permit) 
  return; 
 
if(m_whiteboardindex==-1) 
  return; 
CI2WBBaseWB* pwb=(CI2WBBaseWB*)m_whiteboardlist.get_Items()[m_whiteboardindex]; 
pwb->copy(); 
} 
 
VOID CI2WBBaseWBSet::paste() 
{ 
if(!m_permit) 
  return; 
 
if(m_whiteboardindex==-1) 
  return; 
CI2WBBaseWB* pwb=(CI2WBBaseWB*)m_whiteboardlist.get_Items()[m_whiteboardindex]; 
pwb->paste(); 
} 
 
VOID CI2WBBaseWBSet::cutWb() 
{ 
if(!m_permit) 
  return; 
 
if(m_whiteboardindex==-1) 
   return; 
CI2WBBaseWB* pwb=(CI2WBBaseWB*)m_whiteboardlist.get_Items()[m_whiteboardindex]; 
pwb->copyWb(); 
delWb(-1,TRUE); 
} 
 
VOID CI2WBBaseWBSet::copyWb() 
{ 
if(!m_permit) 
  return; 
 
if(m_whiteboardindex==-1) 
   return; 
CI2WBBaseWB* pwb=(CI2WBBaseWB*)m_whiteboardlist.get_Items()[m_whiteboardindex]; 
pwb->copyWb(); 
} 
 
VOID CI2WBBaseWBSet::pasteWb() 
{ 
    if(!m_permit) 
      return; 
 
    addWb(NULL,-1,TRUE,TRUE); 
    CI2WBBaseWB* pwb=(CI2WBBaseWB*)m_whiteboardlist.get_Items()[m_whiteboardindex]; 
    pwb->pasteWb(); 
} 
 
VOID CI2WBBaseWBSet::select() 
{ 
    setControlSetID(GUID_NULL); 
    m_erase=0; 
} 
 
VOID CI2WBBaseWBSet::erase() 
{ 
    setControlSetID(GUID_NULL); 
    m_erase=1; 
} 
 
VOID CI2WBBaseWBSet::RegisterEditorControl(GUID csid,INT cid) 
{ 
    REGEDITORENTRY ree; 
    ree.csid=csid; 
    ree.cid=cid; 
 
    m_regeditorcontrol.append(ree); 
} 
 
VOID CI2WBBaseWBSet::RegisterDragDropControl(LPSTR fileext,GUID csid,INT cid) 
{ 
    if(lstrlen(fileext)>16) 
        throw new I2BaseException(I2E_INVALIDPARAMETER); 
 
    REGDRAGDROPENTRY rdde; 
    lstrcpy((char*)rdde.ext,fileext); 
    rdde.csid=csid; 
    rdde.cid=cid; 
 
    m_regdragdropcontrol.append((const REGDRAGDROPENTRY)rdde); 
} 
 
VOID CI2WBBaseWBSet::saveStreamWb(I2MemoryFileStream& stm,int index) 
{ 
  if(m_whiteboardindex==-1) 
    return; 
  //I2MemoryFileStream mstm(1024); 
  if(index>-1 && indexsave(stm); 
  } 
} 
 
VOID CI2WBBaseWBSet::loadTeachPlan(VOID* p,INT len,INT index,CHAR *wbname) 
{ 
addWb(wbname,index,TRUE,TRUE); 
CI2WBBaseWB* pwb=m_whiteboardlist[m_whiteboardindex]; 
pwb->load(-1,-1,p,len,0); 
} 
 
VOID CI2WBBaseWBSet::syncWb(INT index,VOID* p,INT len) 
{ 
if(m_whiteboardindex==-1) 
  return; 
if(index-1>-1 && index-1load(-1,-1,p,len,0); 
  pwb->set_Sync(TRUE); 
} 
} 
 
VOID CI2WBBaseWBSet::loadCourseWare(SHORT x,SHORT y,VOID* p,INT len) 
{ 
if(m_whiteboardindex==-1) 
  return; 
CI2WBBaseWB* pwb=m_whiteboardlist[m_whiteboardindex]; 
pwb->load(x,y,p,len,1); 
} 
 
VOID CI2WBBaseWBSet::get_Name(CHAR* value,INT index) 
{ 
  if(m_whiteboardindex==-1) 
    return; 
  CI2WBBaseWB* pwb; 
  if(index==-1) 
  { 
    pwb=m_whiteboardlist[m_whiteboardindex]; 
    pwb->get_Name(value); 
  } 
  else if(index>=0 && index < m_whiteboardlist.get_Count()) 
  { 
    pwb=m_whiteboardlist[index]; 
    pwb->get_Name(value); 
  } 
  else 
    throw new I2BaseException(I2E_INVALIDPARAMETER); 
} 
 
VOID CI2WBBaseWBSet::set_Name(CHAR* value,INT index) 
{ 
  if(m_whiteboardindex==-1) 
    return; 
  CI2WBBaseWB* pwb; 
  if(index==-1) 
    pwb=m_whiteboardlist[m_whiteboardindex]; 
  else 
    pwb=m_whiteboardlist[index]; 
  pwb->set_Name(value); 
}