grid.c

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

  pGridData->nCols--;

  return 1;
}

/***************************************************************************/
/* Delete a row indexed by nRows
 * @nRows: index.
 * @pGridData: Grid control data.
 * return 1 if success
 */
static int DeleteRow(int nRows, PGRIDDATA pGridData)
{
  PGRIDROWHDR pRow1, pRow2;
  PGRIDCOLHDR pColHdr;
  PCELLDATA pCell1, pCell2, pCell3;

  if(nRows > pGridData->nRows-1) return 0;

  pRow1 = pRow2 = pGridData->pGridRowHdr;
  if(pRow2->nRows == nRows) {//the first row
    pGridData->pGridRowHdr = pRow2->pNext;
    if(pRow1->pNext)
      pCell1 = pRow1->pNext->pHeadCell;
    else
      pCell1 = NULL;
    pCell3 = pCell2 = pRow1->pHeadCell;
    
    //adjust pointers of row
    pColHdr = pGridData->pGridColHdr;
    while(pColHdr) {
      pCell3 = pCell2->pRight;
      freecell(pCell2);
      pCell2 = pCell3;

      pColHdr->pHeadCell = pCell1;
      pColHdr = pColHdr->pNext;
      if(pCell1) pCell1 = pCell1->pRight;
    }
    freerow(pRow2);
  }
  else {//!the first row
    while(pRow2->nRows != nRows ) {
      pRow1 = pRow2;
      pRow2 = pRow2->pNext;
    }
    
    pRow1->pNext = pRow2->pNext;//adjust row header pointer
    pColHdr = pGridData->pGridColHdr;//adjust pointers of previous row
    pCell3 = pRow2->pHeadCell;

    while(pColHdr) {
      pCell1 = pCell2 = pColHdr->pHeadCell;
      while(pCell2 != pCell3) {
	pCell1 = pCell2;
	pCell2 = pCell2->pNext;
      }
      pCell1->pNext = pCell2->pNext;
      pColHdr = pColHdr->pNext;
      pCell3 = pCell3->pRight;
      freecell(pCell2);
    }
    freerow(pRow2);
  }

  //dec row header nRows field
  pRow2 = pRow1->pNext;
  while(pRow2) {
    pRow2->y = pRow1->y + pRow1->nHeight;
    pRow2->nRows--;
    pRow1 = pRow2;
    pRow2 = pRow2->pNext;
  }
  pGridData->nRows--;

  return 1;//sucess
}

static int AddCol(HWND hwnd, PGRIDCOLHEADER pHeader, PGRIDDATA pGridData)
{
  PGRIDCOLHDR pCol1, pCol2;
  PGRIDROWHDR pRowHdr;
  PCELLDATA pCell1, pCell2, pCell3;
  GRIDCOLHEADER temp;
  memset(&temp, 0, sizeof(temp));
  //GRIDCELL cellinfo; 

  if(pGridData->nCols >= GRID_COL_MAX)
    return -1;
  
  //check pHeader
  if(!pHeader) pHeader = (PGRIDCOLHEADER)&temp;
  if(pHeader->nWidth < 10)
    pHeader->nWidth = pGridData->nHeadWidth;;
  if(pHeader->nCols > pGridData->nCols)
    pHeader->nCols = pGridData->nCols;

  pRowHdr = pGridData->pGridRowHdr;

  if(pHeader->nCols == 0) {//first column
    //header
    if((pCol1 = pCol2 = newcolhdr(pHeader)) == NULL) 
      return 0;//failed to get mem
    pCol1->x = pGridData->nHeadWidth;
    pCol1->pNext = pGridData->pGridColHdr;
    pGridData->pGridColHdr = pCol1;
    //first cell
    if(pRowHdr) {
      if((pCell1 = newcell(NULL)) == NULL)
	return 0;
      pCol1->pHeadCell = pCell1;
      pCell1->pRight = pRowHdr->pHeadCell;
      (PGRIDCOLHDR)pCell1->pRowHdr = pRowHdr;
      (PGRIDCOLHDR)pCell1->pColHdr = pCol1;
      pRowHdr->pHeadCell = pCell1;
      pRowHdr = pRowHdr->pNext;
    }
    //other cells
    while(pRowHdr) {
      if((pCell2 = newcell(NULL)) == NULL)
	return 0;
      pCell1->pNext = pCell2;
      pCell1 = pCell2;
      pCell2->pRight = pRowHdr->pHeadCell;
      (PGRIDCOLHDR)pCell2->pColHdr = pCol2;
      (PGRIDROWHDR)pCell2->pRowHdr = pRowHdr;
      pRowHdr->pHeadCell = pCell2;
      pRowHdr = pRowHdr->pNext;
    }
  }
  else {//!first col
    pCol1 = pGridData->pGridColHdr;
    while(pCol1->nCols != pHeader->nCols - 1) {
      pCol1 = pCol1->pNext;
    }
    //header
    if((pCol2 = newcolhdr(pHeader)) == NULL)
      return 0;
    pCol2->x = pCol1->x + pCol1->nWidth;
    pCol2->pNext = pCol1->pNext;
    pCol1->pNext = pCol2;
    //first cell
    if(pRowHdr) {
      pCell1 = pCol1->pHeadCell;
      if(pCol2->pNext)
	pCell2 = pCol2->pNext->pHeadCell;
      else
	pCell2 = NULL;
      if((pCell3 = newcell(NULL)) == NULL)
	return 0;
      pCol2->pHeadCell = pCell3;
      pCell1->pRight = pCell3;
      pCell3->pRight = pCell2;
      (PGRIDCOLHDR)pCell3->pColHdr = pCol2;
      (PGRIDROWHDR)pCell3->pRowHdr = pRowHdr;
      pRowHdr = pRowHdr->pNext;
      pCell1 = pCell1->pNext;
      if(pCell2) pCell2 = pCell2->pNext;
    }
    //other cells
    while(pRowHdr) {
      if((pCell3->pNext = newcell(NULL)) == NULL)
	return 0;
      pCell3 = pCell3->pNext;
      pCell1->pRight = pCell3;
      pCell3->pRight = pCell2;
      (PGRIDCOLHDR)pCell3->pColHdr = pCol2;
      (PGRIDROWHDR)pCell3->pRowHdr = pRowHdr;
      pRowHdr = pRowHdr->pNext;
      pCell1 = pCell1->pNext;
      if(pCell2) pCell2 = pCell2->pNext;
    }    
  }

  //inc headers nCols field
  pCol2 = pCol2->pNext;
  while(pCol2) {
    pCol2->nCols++;
    pCol2->x += pHeader->nWidth;
    pCol2 = pCol2->pNext;
  }
  pGridData->nCols++;
  
  return 1;//sucess
}

static int AddRow(HWND hwnd, PGRIDROWHEADER pHeader, PGRIDDATA pGridData)
{
  PGRIDROWHDR pRow1, pRow2;
  PGRIDCOLHDR pColHdr;
  PCELLDATA pCell1, pCell2, pCell3;
  GRIDROWHEADER temp;

  if(pGridData->nRows >= GRID_ROW_MAX)
    return -1;

  //check pHeader
  if(!pHeader) 
    pHeader = (PGRIDROWHEADER)&temp;
  if(pHeader->nHeight < 10)
    pHeader->nHeight = pGridData->nHeadHeight;
  if(pHeader->nRows > pGridData->nRows)
    pHeader->nRows = pGridData->nRows;

  pColHdr = pGridData->pGridColHdr;

  if(pHeader->nRows == 0) {//first row
    //header
    if((pRow1 = pRow2 = newrowhdr(pHeader)) == NULL) 
      return 0;//failed to get mem
    pRow1->y = pGridData->nHeadHeight;
    pRow1->pNext = pGridData->pGridRowHdr;
    pGridData->pGridRowHdr = pRow1;
    //first cell
    if(pColHdr) {
      if((pCell1 = newcell(NULL)) == NULL)
	return 0;
      pRow1->pHeadCell = pCell1;
      pCell1->pNext = pColHdr->pHeadCell;
      (PGRIDCOLHDR)pCell1->pColHdr = pColHdr;
      (PGRIDROWHDR)pCell1->pRowHdr = pRow2;
      pColHdr->pHeadCell = pCell1;
      pColHdr = pColHdr->pNext;
    }
    //other cells
    while(pColHdr) {
      if((pCell2 = newcell(NULL)) == NULL)
	return 0;
      pCell1->pRight = pCell2;
      pCell1 = pCell2;
      pCell2->pNext = pColHdr->pHeadCell;
      (PGRIDCOLHDR)pCell2->pColHdr = pColHdr;
      (PGRIDROWHDR)pCell2->pRowHdr = pRow2;
      pColHdr->pHeadCell = pCell2;
      pColHdr = pColHdr->pNext;
    }
  }
  else {//!first row
    pRow1 = pGridData->pGridRowHdr;
    while(pRow1->nRows != pHeader->nRows - 1) {
      pRow1 = pRow1->pNext;
    }
    //header
    if((pRow2 = newrowhdr(pHeader)) == NULL)
      return 0;
    pRow2->y = pRow1->y + pRow1->nHeight;
    pRow2->pNext = pRow1->pNext;
    pRow1->pNext = pRow2;
    //first cell
    if(pColHdr) {
      pCell1 = pRow1->pHeadCell;
      if(pRow2->pNext) 
	pCell2 = pRow2->pNext->pHeadCell;
      else
	pCell2 = NULL;
      if((pCell3 = newcell(NULL)) == NULL)
	return 0;
      pRow2->pHeadCell = pCell3;
      pCell1->pNext = pCell3;
      pCell3->pNext = pCell2;
      (PGRIDCOLHDR)pCell3->pColHdr = pColHdr;
      (PGRIDROWHDR)pCell3->pRowHdr = pRow2;

      pColHdr = pColHdr->pNext;
      if(pCell1) pCell1 = pCell1->pRight;
      if(pCell2) pCell2 = pCell2->pRight;
    }
    //other cells
    while(pColHdr) {
      if((pCell3->pRight = newcell(NULL)) == NULL)
	return 0;
      pCell3 = pCell3->pRight;
      pCell1->pNext = pCell3;
      pCell3->pNext = pCell2;
      (PGRIDCOLHDR)pCell3->pColHdr = pColHdr;
      (PGRIDROWHDR)pCell3->pRowHdr = pRow2;

      pColHdr = pColHdr->pNext;
      if(pCell1) pCell1 = pCell1->pRight;
      if(pCell2) pCell2 = pCell2->pRight;
    }    
  }
  
  //inc headers nCols field
  pRow2 = pRow2->pNext;
  while(pRow2) {
    pRow2->nRows++;
    pRow2->y += pHeader->nHeight;
    pRow2 = pRow2->pNext;
  }
  pGridData->nRows++;
  
  return 1;//sucess
}

/************************* internal functions ************************************/
static void freecell(PCELLDATA pCell)
{
  if(pCell->pszInfo) 
    free(pCell->pszInfo);
  free(pCell);
}
static void freerow(PGRIDROWHDR pRow)
{
  if(pRow->pTitle)
    free(pRow->pTitle);
  free(pRow);
}
static void freecol(PGRIDCOLHDR pCol)
{
  if(pCol->pTitle)
    free(pCol->pTitle);
  free(pCol);
}
static PCELLDATA newcell(PGRIDCELL pCell)
{
  PCELLDATA pNew = calloc(1, sizeof(CELLDATA));

  if(pCell) {
    //do some initial work here
    if(pCell->pszInfo) {
      pNew->pszInfo = malloc(strlen(pCell->pszInfo) + 1);
      strcpy(pNew->pszInfo, pCell->pszInfo);
    }
    else {
      pNew->pszInfo = malloc(1);
      strcpy(pNew->pszInfo, ""); 
    }
    if(pCell->nTextColor) 
      pNew->nTextColor = pCell->nTextColor;
    else
      pNew->nTextColor = COLOR_black;
    pNew->addData = pCell->addData;
  }

  return pNew;
}
static PGRIDCOLHDR newcolhdr(PGRIDCOLHEADER pHeader)
{
  char col[3]; //since the max col is 62
  PGRIDCOLHDR pCol = calloc(1, sizeof(GRIDCOLHDR));

  //initial work
  if(pHeader) {
    if(pHeader->nWidth) pCol->nWidth = pHeader->nWidth;
    if(pHeader->nCols) pCol->nCols = pHeader->nCols;

    if(pHeader->pTitle) {
      pCol->pTitle = malloc(strlen(pHeader->pTitle) + 1);
      strcpy(pCol->pTitle, pHeader->pTitle);
    }
    else {
      sprintf(col, "%d", pHeader->nCols);
      pCol->pTitle = malloc(strlen(col) + 1);
      strcpy(pCol->pTitle, col);
    }
    
    if(pHeader->image) pCol->Image = pHeader->image;
    if(pHeader->flags) pCol->flags = pHeader->flags;
  }

  return pCol;
}
static PGRIDROWHDR newrowhdr(PGRIDROWHEADER pHeader)
{
  char row[7]; //since the max row is 100000
  PGRIDROWHDR pRow = calloc(1, sizeof(GRIDROWHDR));

  if(pHeader) {
    //initial work
    if(pHeader->nHeight) pRow->nHeight = pHeader->nHeight;
    if(pHeader->nRows) pRow->nRows = pHeader->nRows;
    
    if(pHeader->pTitle) {
      pRow->pTitle = malloc(strlen(pHeader->pTitle) + 1);
      strcpy(pRow->pTitle, pHeader->pTitle);
    }
    else {
      sprintf(row, "%d", pHeader->nRows);
      pRow->pTitle = malloc(strlen(row) + 1);
      strcpy(pRow->pTitle, row);
    }
  
    if(pHeader->image) pRow->Image = pHeader->image;
    if(pHeader->flags) pRow->flags = pHeader->flags;
  }

  return pRow;
}
static int GetGridWidth(PGRIDDATA pGridData)
{
  int width;
  PGRIDCOLHDR pCol = pGridData->pGridColHdr;
  width = pGridData->nHeadWidth;
  while(pCol) {
    width += pCol->nWidth;
    pCol = pCol->pNext;
  }

  return width;  
}
static int GetGridHeight(PGRIDDATA pGridData)
{
  int height;
  PGRIDROWHDR pRow = pGridData->pGridRowHdr;
  height = pGridData->nHeadHeight;
  while(pRow) {
    height += pRow->nHeight;
    pRow = pRow->pNext;
  }

  return height;  
}
static void showGrid(PGRIDDATA pGridData)
{
  PGRIDROWHDR pRowHdr;
  PCELLDATA pCell;
  pRowHdr = pGridData->pGridRowHdr;
  printf("Show Grid NUMRow:%d   NUMCol:%d\n", pGridData->nRows, pGridData->nCols);
  while(pRowHdr) {
    printf("%s  ", pRowHdr->pTitle);
    pCell = pRowHdr->pHeadCell;
    while(pCell) {
      printf("%s  ", pCell->pszInfo);
      pCell = pCell->pRight;
    }
    pRowHdr = pRowHdr->pNext;
    printf("\n");
  }
}

/*************************** draw functions ************************************/
static void GridDrawText (HDC hdc, int x, int y, int width, int height, 
		const char *pszText, UINT format)
{
    RECT rect;
    //SIZE size;

    if (pszText != NULL)
    {
	SetRect (&rect, x+2, y+2, x+width, y+height);
        DrawText (hdc, pszText, -1, &rect, format);
    }
}
static void GridDrawHeader(HWND hwnd, HDC hdc)
{
  PGRIDCOLHDR pCol = NULL;
  PGRIDROWHDR pRow = NULL;
  PGRIDDATA pGridData;
  RECT rcClient;
  BOOL up = TRUE;
  UINT format;

  GetClientRect (hwnd, &rcClient);
  pGridData = (PGRIDDATA) GetWindowAdditionalData2 (hwnd);
  pCol = pGridData->pGridColHdr;
  pRow = pGridData->pGridRowHdr;

  SetBkColor (hdc, PIXEL_lightgray);
  SetBrushColor (hdc, PIXEL_lightgray);
  FillBox (hdc, rcClient.left, rcClient.top, rcClient.right - rcClient.left,
	   pGridData->nHeadHeight);
  FillBox(hdc, rcClient.left, rcClient.top, pGridData->nHeadWidth,
	  rcClient.bottom - rcClient.top);

  SetTextColor (hdc, PIXEL_black);

  //column header
  while (pCol) {
    if((pCol->x +pCol->nWidth - pGridData->nOriginalX > pGridData->nHeadWidth) 
       || (pCol->x +pCol->nWidth - pGridData->nOriginalX < GetGridWidth(pGridData))) {
      if(pCol == pGridData->pColSelected) {
	up = FALSE;
      }
#ifdef _FLAT_WINDOW_STYLE
      DrawFlatControlFrameEx (hdc, pCol->x - pGridData->nOriginalX+1,
			      GRID_HDR_TOP,// - pGridData->nOriginalY-1,
			      pCol->x - pGridData->nOriginalX + pCol->nWidth - 1,
			      GRID_HDR_TOP + pGridData->nHeadHeight, PIXEL_lightgray, 0, up);
#else
      Draw3DControlFrame (hdc, pCol->x - pGridData->nOriginalX + 1,
			  GRID_HDR_TOP,
			  pCol->x - pGridData->nOriginalX + pCol->nWidth - 1,
			  GRID_HDR_TOP + pGridData->nHeadHeight, PIXEL_lightgray, up);
#endif
      up = TRUE;
      if (pCol->flags & GRIDHF_CENTERALIGN)
	format = DT_SINGLELINE | DT_CENTER | DT_VCENTER;
      else if (pCol->flags & GRIDHF_RIGHTALIGN)
	format = DT_SINGLELINE | DT_RIGHT | DT_VCENTER;
      else
	format = DT_SINGLELINE | DT_LEFT | DT_VCENTER;
      
      GridDrawText (hdc, pCol->x - pGridData->nOriginalX + 2, GRID_HDR_TOP,
		    pCol->nWidth - 4, pGridData->nHeadHeight, pCol->pTitle, format);
      //draw the cell line
      if(pCol->x + pCol->nWidth - pGridData->nOriginalX > pGridData->nHeadWidth) {
	MoveTo(hdc, pCol->x + pCol->nWidth - pGridData->nOriginalX-1, pGridData->nHeadHeight);
	LineTo(hdc, pCol->x + pCol->nWidth - pGridData->nOriginalX-1, GetGridHeight(pGridData));
      }
    }
    pCol = pCol->pNext;
  }
  //draws the right most unused header
  if ( !GRID_H_OUTWND(pGridData, rcClient) ) {
#ifdef _FLAT_WINDOW_STYLE
    DrawFlatControlFrameEx (hdc, GetGridWidth (pGridData)-2,
			    GRID_HDR_TOP-1,
			    rcClient.right+2,
			    GRID_HDR_TOP + pGridData->nHeadHeight, PIXEL_lightgray, 0, up);
#else
    Draw3DControlFrame (hdc, GetGridWidth (pGridData),
			GRID_HDR_TOP,