grid.c

libminigui-1.3.0.tar.gz。 miniGUI的库函数源代码！

    GridSetVScrollInfo(pgriddata);

    break;

  case MSG_SETCURSOR:
    mouseX = LOSWORD(lParam);
    mouseY = HISWORD(lParam);
            
    if ((GRIDSTATUS(hwnd) & GRID_BDDRAG) || 
	(GridInWhichColHdrBorder (mouseX, mouseY, NULL, pgriddata) > 0)) {
      SetCursor (GetSystemCursor (IDC_SPLIT_VERT));

      return 0;
    }
    break;

  case MSG_PAINT:
    {
      HDC hdc;
      
      hdc = BeginPaint(hwnd);
      GridOnDraw(hwnd, hdc);
      EndPaint(hwnd, hdc);
      
      return 0;
    }

  case MSG_SETFOCUS:
  case MSG_KILLFOCUS:
    /*if(message == MSG_SETFOCUS)
      pgriddata->bkc_selected = LIGHTBLUE;
    else
      pgriddata->bkc_selected = GRAYBLUE;
    if(pgriddata->nColSelected > 0) {
      RECT rc;
      GRID_GET_CELL_RECT(pgriddata->nColSelected, rc);
      InvalidateRect(hwnd, &rc, FALSE);
      }*/
    break;
    
    //case MSG_GET_DLGCODE:
    //return DLGC_WANTARROWS | DLGC_WANTCHARS;
    
  case MSG_MOUSEMOVE:
    mouseX = LOSWORD(lParam);
    mouseY = HISWORD(lParam);

    if(GRIDSTATUS(hwnd) & GRIDST_BDDRAG) {
      if(pgriddata->pColDraged)
	GridColBorderDrag(hwnd, mouseX, mouseY);
      if(pgriddata->pRowDraged)
	GridRowBorderDrag(hwnd, mouseX, mouseY);
    }
    break;

  case MSG_LBUTTONDOWN:
    {
      RECT rcClient;
      PGRIDCOLHDR pColHdr;
      PGRIDROWHDR pRowHdr;
      mouseX = LOSWORD (lParam);
      mouseY = HISWORD (lParam);

      GetClientRect(hwnd, &rcClient);
      /*      nCols = IsInGridColHdr(mouseX, mouseY, &pColHdr, pgriddata);
      nRows = IsInGridRowHdr(mouseX, mouseY, &pRowHdr, pgriddata);
      
      if(nCols > 0) {
	if(GetCapture() == hwnd)
	  break;
	
	SetCapture(hwnd);
	GRIDSTATUS(hwnd) |= (GRIDST_HEADSELECT | GRIDST_INHEAD);
	pgriddata->pColSelected = pColHdr;
	
	SetRect(&rect, pColHdr->x - pgriddata->nOriginalX, GRID_HDR_TOP,
		pColHdr->x - pgriddata->nOriginalX + pColHdr->nWidth,
		GRID_HDR_TOP+ GRID_HDRH_DEF(hwnd));
	InvalidateRect(hwnd, &rect, FALSE);
	}*/
      //else 
      {
	if((nCols = GridInWhichColHdrBorder(mouseX, mouseY, &pColHdr, pgriddata)) >= 0) {
	  GRIDSTATUS(hwnd) |= GRIDST_BDDRAG;
	  pgriddata->pColDraged = pColHdr;
	  pgriddata->pRowDraged = NULL;
	  SetCapture(hwnd);
	}
      }
      /*if(nRows > 0) {
	if(GetCapture() == hwnd)
	  break;
	
	SetCapture(hwnd);
	GRIDSTATUS(hwnd) |= (GRIDST_HEADSELECT | GRIDST_INHEAD);
	pgriddata->pRowSelected = pRowHdr;
	
	SetRect(&rect, GRID_HDR_LEFT, pRowHdr->y - pgriddata->nOriginalY,
		GRID_HDR_LEFT+ GRID_HDRW_DEF(hwnd),
		pRowHdr->y - pgriddata->nOriginalY + pRowHdr->nHeight);
	InvalidateRect(hwnd, &rect, FALSE);
      }
      else */
      {
	if((nRows = GridInWhichRowHdrBorder(mouseX, mouseY, &pRowHdr, pgriddata)) >= 0) {
	  GRIDSTATUS(hwnd) |= GRIDST_BDDRAG;
	  pgriddata->pRowDraged = pRowHdr;
	  pgriddata->pColDraged = NULL;
	  SetCapture(hwnd);
	}
      }
      break;
    }
  case MSG_LBUTTONUP: {
    PGRIDCOLHDR pColHdr;
    PGRIDROWHDR pRowHdr;
    PCELLDATA pCell;
    int nCells = -1;
    nCols = -1;
    nRows = -1;
    mouseX = LOSWORD (lParam);
    mouseY = HISWORD (lParam);
    
    if(!(GRIDSTATUS(hwnd) & GRIDST_BDDRAG)) {
      nCols = IsInGridColHdr(mouseX, mouseY, &pColHdr, pgriddata);
      nRows = IsInGridRowHdr(mouseX, mouseY, &pRowHdr, pgriddata);
      nCells = IsInGridCell(mouseX, mouseY, &pCell, pgriddata); 
    }

    //in col head
    if(nCols >= 0) {
      if(GRIDSTATUS(hwnd) & GRIDST_HEADSELECT) {
	if(pgriddata->pColSelected != pColHdr) {
	  GRIDSTATUS(hwnd) |= (GRIDST_HEADSELECT);
	  pgriddata->pColSelected = pColHdr;
	  pgriddata->pRowSelected = NULL;
	  //printf("%s\n", pgriddata->pColSelected->pTitle);
	}
	else {
	  GRIDSTATUS(hwnd) &= ~GRIDST_HEADSELECT;
	  pgriddata->pColSelected = NULL;
	}
      }
      else {
	GRIDSTATUS(hwnd) |= (GRIDST_HEADSELECT);
	pgriddata->pColSelected = pColHdr;
	pgriddata->pRowSelected = NULL;
	//printf("%s\n", pgriddata->pColSelected->pTitle);
      }
    }
    //in row head
    else if(nRows >= 0) {
      if(GRIDSTATUS(hwnd) & GRIDST_HEADSELECT) {
	if(pgriddata->pRowSelected != pRowHdr) {
	  GRIDSTATUS(hwnd) |= (GRIDST_HEADSELECT);
	  pgriddata->pRowSelected = pRowHdr;
	  pgriddata->pColSelected = NULL;
	  //printf("%s\n", pgriddata->pRowSelected->pTitle);
	}
	else {
	  GRIDSTATUS(hwnd) &= ~GRIDST_HEADSELECT;
	  pgriddata->pRowSelected = NULL;
	}
      }
      else {
	GRIDSTATUS(hwnd) |= (GRIDST_HEADSELECT);
	pgriddata->pRowSelected = pRowHdr;
	pgriddata->pColSelected = NULL;
	//printf("%s\n", pgriddata->pRowSelected->pTitle);
      }
    }
    //in cell
    else if(nCells > 0) {
      pgriddata->pCellFocus = pCell;

      if(pgriddata->hwnd_edit && pgriddata->pCellEdit != pCell)
	PostMessage(hwnd, GRID_EDITENTER, 1, (DWORD)pCell);
      GRIDSTATUS(hwnd) &= ~GRIDST_HEADSELECT;
      pgriddata->pColSelected = NULL;
      pgriddata->pRowSelected = NULL;
      GridMakeCellVisible(hwnd, pgriddata, pCell); 
    }      
    if (GRIDSTATUS(hwnd) & GRIDST_BDDRAG) {
      ReleaseCapture ();
      if(pgriddata->pColDraged) {
	GridSetHScrollInfo (pgriddata);
	pgriddata->pColDraged = NULL;
      }
      if(pgriddata->pRowDraged) {
	GridSetVScrollInfo(pgriddata);
	pgriddata->pRowDraged = NULL;
      }
      GRIDSTATUS(hwnd) &= ~GRIDST_BDDRAG;
    } 
    InvalidateRect (hwnd, NULL, FALSE);
  }
    break;

  case MSG_LBUTTONDBLCLK: {
    PCELLDATA pCell;
    mouseX = LOSWORD (lParam);
    mouseY = HISWORD (lParam);

    if(IsInGridCell(mouseX, mouseY, &pCell, pgriddata) > 0) {
      if(pgriddata->pCellEdit) {
	free(pgriddata->pCellEdit->pszInfo);
	pgriddata->pCellEdit->pszInfo = malloc(GetWindowTextLength(pgriddata->hwnd_edit)+1);
	GetWindowText(pgriddata->hwnd_edit, pgriddata->pCellEdit->pszInfo, 256);
	pgriddata->pCellEdit = NULL;
	DestroyWindow(pgriddata->hwnd_edit);
      }
      pgriddata->pCellEdit = pCell;
      pgriddata->hwnd_edit = CreateWindow (CTRL_EDIT,
					   pCell->pszInfo,
					   WS_CHILD | WS_VISIBLE | WS_BORDER,
					   IDC_EDIT,
					   pCell->pColHdr->x - pgriddata->nOriginalX + 3,
					   pCell->pRowHdr->y - pgriddata->nOriginalY + 3,
					   pCell->pColHdr->nWidth - 5,
					   pCell->pRowHdr->nHeight - 5, hwnd, 0);
      SetFocusChild(pgriddata->hwnd_edit);
      SetWindowAdditionalData(pgriddata->hwnd_edit, (DWORD)pgriddata);
      old_edit_proc = SetWindowCallbackProc(pgriddata->hwnd_edit, EnterEditBox);
    }
  }
    break;
  case GRID_EDITENTER: {
    if(pgriddata->pCellEdit) {
      free(pgriddata->pCellEdit->pszInfo);
      pgriddata->pCellEdit->pszInfo = malloc(GetWindowTextLength(pgriddata->hwnd_edit)+1);
      GetWindowText(pgriddata->hwnd_edit, pgriddata->pCellEdit->pszInfo, 256);
      //sprintf(pgriddata->pCellEdit->pszInfo, "%s", );
      if(wParam > 0)
	pgriddata->pCellFocus = (PCELLDATA)lParam;
      else {
	if(pgriddata->pCellEdit->pNext)
	  pgriddata->pCellFocus = pgriddata->pCellEdit->pNext;
      }
      pgriddata->pCellEdit = NULL;
      DestroyWindow(pgriddata->hwnd_edit);
      InvalidateRect(hwnd, NULL, FALSE);
    }
  }
    break;
  case MSG_KEYDOWN: {
    int id = LOWORD (wParam);
    
    switch(id) {
    case SCANCODE_CURSORBLOCKDOWN:
      if(pgriddata->pCellFocus) {
	if(pgriddata->pCellFocus->pNext) {
	  pgriddata->pCellFocus = pgriddata->pCellFocus->pNext;
	  if(pgriddata->pCellEdit)
	    PostMessage(hwnd, GRID_EDITENTER, 1, (DWORD)pgriddata->pCellEdit->pNext);
	}
	if(GridMakeCellVisible(hwnd, pgriddata, pgriddata->pCellFocus) < 0)
	  InvalidateRect(hwnd, NULL, FALSE);
      }
      break;
    case SCANCODE_CURSORBLOCKUP: {
      PCELLDATA pCell;
      if(pgriddata->pCellFocus) {
	pCell = pgriddata->pCellFocus->pColHdr->pHeadCell;
	while(pCell) {
	  if(pCell->pNext == pgriddata->pCellFocus) {
	    pgriddata->pCellFocus = pCell;
	    if(pgriddata->pCellEdit)
	      PostMessage(hwnd, GRID_EDITENTER, 1, (DWORD)pCell);
	    if(GridMakeCellVisible(hwnd, pgriddata, pCell) < 0)
	      InvalidateRect(hwnd, NULL, FALSE);
	    break;
	  }
	  else
	    pCell = pCell->pNext;
	}
      }
    }
      break;
    case SCANCODE_HOME:
      break;
    case SCANCODE_END:
      if(pgriddata->pCellFocus) {
	while(pgriddata->pCellFocus->pNext)
	  pgriddata->pCellFocus = pgriddata->pCellFocus->pNext;
      }
      //make cell visible
      if(GridMakeCellVisible(hwnd, pgriddata, pgriddata->pCellFocus) < 0)
	      InvalidateRect(hwnd, NULL, FALSE);
      break;
    case SCANCODE_CURSORBLOCKLEFT: {
      PCELLDATA pCell;
      if(pgriddata->pCellEdit)
	break;
      if(pgriddata->pCellFocus) {
	pCell = pgriddata->pCellFocus->pRowHdr->pHeadCell;
	while(pCell) {
	  if(pCell->pRight == pgriddata->pCellFocus) {
	    pgriddata->pCellFocus = pCell;
	    if(pgriddata->hwnd_edit)
	      DestroyWindow(pgriddata->hwnd_edit);
	    if(GridMakeCellVisible(hwnd, pgriddata, pCell) < 0)
	      InvalidateRect(hwnd, NULL, FALSE);
	    break;
	  }
	  else
	    pCell = pCell->pRight;
	}
      }
    }
      break;
    case SCANCODE_CURSORBLOCKRIGHT:
      if(pgriddata->pCellEdit)
	break;
      if(pgriddata->pCellFocus) {
	if(pgriddata->pCellFocus->pRight) {
	  pgriddata->pCellFocus = pgriddata->pCellFocus->pRight;
	  if(pgriddata->hwnd_edit)
	    DestroyWindow(pgriddata->hwnd_edit);
	}
	if(GridMakeCellVisible(hwnd, pgriddata, pgriddata->pCellFocus) < 0)
	  InvalidateRect(hwnd, NULL, FALSE);
      }
      break;
    case SCANCODE_PAGEUP:
      SendMessage (hwnd, MSG_VSCROLL, SB_PAGEUP, 0);
      break;
    case SCANCODE_PAGEDOWN:
      SendMessage (hwnd, MSG_VSCROLL, SB_PAGEDOWN, 0);
      break;
    }
      break;
    }
    
  case MSG_VSCROLL:
    GridVScroll (hwnd, wParam, lParam);
    return 0;
    
  case MSG_HSCROLL:
    GridHScroll (hwnd, wParam, lParam);
    return 0;

  case GRIDM_GETGRIDCOLS:
    return pgriddata->nCols;
  case GRIDM_SETGRIDCOLS:
    if((wParam >= pgriddata->nCols) && (wParam <= GRID_COL_MAX)) {
      while(pgriddata->nCols < wParam) {
	AddColTail(hwnd, pgriddata);
      }
      InvalidateRect(hwnd, NULL, FALSE);
      return GRID_OKAY;
    }
    return GRID_ERR;
  case GRIDM_GETGRIDROWS:
    return pgriddata->nRows;
  case GRIDM_SETGRIDROWS:
    if((wParam >= pgriddata->nRows) && (wParam <= GRID_ROW_MAX)) {
      while(pgriddata->nRows < wParam) {
	AddRowTail(hwnd, pgriddata);
      }
      InvalidateRect(hwnd, NULL, FALSE);
      return GRID_OKAY;
    }
    return GRID_ERR;

  case GRIDM_ADDCOL:
    if(AddCol(hwnd, (PGRIDCOLHEADER)lParam, pgriddata)) {
      GridSetHScrollInfo(pgriddata);
      InvalidateRect(hwnd, NULL, FALSE);
      return GRID_OKAY;
    }
    return GRID_ERR;
    
  case GRIDM_DELCOL:
    if(DeleteCol(wParam, pgriddata) >0) {
      GridSetHScrollInfo(pgriddata);
      InvalidateRect(hwnd, NULL, FALSE);
      return GRID_OKAY;
    }
    return GRID_ERR;

  case GRIDM_ADDROW:
    if(AddRow(hwnd, (PGRIDROWHEADER)lParam, pgriddata)) {
      GridSetVScrollInfo(pgriddata);
      InvalidateRect(hwnd, NULL, FALSE);
      return GRID_OKAY;
    }
    return GRID_ERR;
    
  case GRIDM_DELROW:
    if(DeleteRow(wParam, pgriddata) >0) {
      GridSetVScrollInfo(pgriddata);
      InvalidateRect(hwnd, NULL, FALSE);
      return GRID_OKAY;
    }
    return GRID_ERR;
    
  case GRIDM_SETHEADWIDTH:
    if(wParam > COLWIDTHMIN) {
      pgriddata->nHeadWidth = wParam;
      InvalidateRect(hwnd, NULL, FALSE);
      return GRID_OKAY;
    }
    return GRID_ERR;
  case GRIDM_SETHEADHEIGHT:
    if(wParam > ROWHEIGHTMIN) {
      pgriddata->nHeadHeight = wParam;
      InvalidateRect(hwnd, NULL, FALSE);
      return GRID_OKAY;
    }
    return GRID_ERR;
  case GRIDM_GETHEADWIDTH:
    return pgriddata->nHeadWidth;
  case GRIDM_GETHEADHEIGHT:
    return pgriddata->nHeadHeight;
    
  case GRIDM_SETCOLDATA: {
    PGRIDCOLHDR pColHdr;
    
    if(lParam) {
      pColHdr = GetColHdrByNum(((PGRIDCOLHEADER)lParam)->nCols, pgriddata);
      if(pColHdr) {
	GridSetColWidth(pColHdr, ((PGRIDCOLHEADER)lParam)->nWidth, pgriddata);
	if(((PGRIDCOLHEADER)lParam)->pTitle) {
	  if(pColHdr->pTitle) free(pColHdr->pTitle);
	  pColHdr->pTitle = malloc(strlen(((PGRIDCOLHEADER)lParam)->pTitle));
	  sprintf(pColHdr->pTitle, "%s", ((PGRIDCOLHEADER)lParam)->pTitle);
	}
	pColHdr->flags = ((PGRIDCOLHEADER)lParam)->flags;
	pColHdr->Image = ((PGRIDCOLHEADER)lParam)->image;
	//pColHdr->cellflags = ((PGRIDCOLHEADER)lParam)->cellflags;
	return GRID_OKAY;
      }
    }
    return GRID_ERR;
  }
  case GRIDM_SETROWDATA: {
    PGRIDROWHDR pRowHdr;
    
    if(lParam) {
      pRowHdr = GetRowHdrByNum(((PGRIDROWHEADER)lParam)->nRows, pgriddata);
      if(pRowHdr) {
	GridSetRowHeight(pRowHdr, ((PGRIDROWHEADER)lParam)->nHeight, pgriddata);
	if(((PGRIDROWHEADER)lParam)->pTitle) {
	  if(pRowHdr->pTitle) free(pRowHdr->pTitle);
	  pRowHdr->pTitle = malloc(strlen(((PGRIDROWHEADER)lParam)->pTitle));
	  sprintf(pRowHdr->pTitle, "%s", ((PGRIDROWHEADER)lParam)->pTitle);
	}
	pRowHdr->flags = ((PGRIDROWHEADER)lParam)->flags;
	pRowHdr->Image = ((PGRIDROWHEADER)lParam)->image;
	//pRowHdr->cellflags = ((PGRIDROWHEADER)lParam)->cellflags;
	return GRID_OKAY;
      }
    }
    return GRID_ERR;
  }
    break;
 
  case GRIDM_SETCOLWIDTH:
    if(GridSetColWidth(GetColHdrByNum(wParam, pgriddata), wParam, pgriddata) > 0) {
      InvalidateRect(hwnd, NULL, FALSE);
      GridSetHScrollInfo(pgriddata);
      return GRID_OKAY;
    }
    return GRID_ERR;
  case GRIDM_SETROWHEIGHT:
    if(GridSetRowHeight(GetRowHdrByNum(wParam, pgriddata), wParam, pgriddata) > 0) {
      InvalidateRect(hwnd, NULL, FALSE);
      GridSetVScrollInfo(pgriddata);
      return GRID_OKAY;
    }
    return GRID_ERR;
    
  case GRIDM_SETCELLFOCUS: {
    PCELLDATA pCell = GetCellByNum(wParam, lParam, pgriddata);
    if(pCell) {
      pgriddata->pCellFocus = pCell;
      InvalidateRect(hwnd, NULL, FALSE);
      return GRID_OKAY;
    }
    return GRID_ERR;
  }
    break;

  case MSG_DESTROY:
    DeleteGrid (pgriddata);
    break;
  }
  return DefaultControlProc (hwnd, message, wParam, lParam);
}

//***********************************************************************************
BOOL RegisterGridControl (void)
{
    WNDCLASS WndClass;

    WndClass.spClassName = CTRL_GRID;
    WndClass.dwStyle = WS_NONE;
    WndClass.dwExStyle = WS_EX_NONE;
    WndClass.hCursor = GetSystemCursor (0);
    WndClass.iBkColor = PIXEL_lightwhite;
    WndClass.WinProc = sGridProc;

    return RegisterWindowClass (&WndClass);
}

void GridControlCleanup (void)
{
    UnregisterWindowClass (CTRL_GRID);
}

#endif /* _EXT_CTRL_GRID */