int wxDDGrid::StretchIt()
{
	int new_width = GetClientSize().GetWidth() - GetRowLabelSize() - 10;
	int fixedWidth = 0, numStretches = 0, numStretched = 0;

	for( int i = 0; i < GetNumberCols(); ++i )
	{
		if( sf[i] == 0 ) fixedWidth += GetColSize(i);
		else if( sf[i] < 0 )
		{
			AutoSizeColumn(i, false);
			fixedWidth += GetColSize(i);
		}
		else
		{
			numStretches += sf[i];
			numStretched += 1;
		}
	}

	// Now either we have space for normal layout or resort to wxGrid default behaviour
	if( numStretched && ((fixedWidth + numStretched * 10) < new_width) )
	{
		int stretchSpace = (new_width - fixedWidth) / numStretches;
		//BeginBatch();
		int i, max = GetNumberCols();
		for(i = 0; i < max; ++i )
			if( sf[i] > 0 )
				SetColSize(i, stretchSpace * sf[i]);
		//EndBatch();
		return 1;
	}
	return 0;
}

//---------------------------------------------------------
bool CVIEW_Table_Control::Update_Table(void)
{
	if( GetBatchCount() > 0 )
	{
		return( false );
	}

	BeginBatch();

	//-----------------------------------------------------
	int	Difference	= (m_pTable->Get_Field_Count() - m_Field_Offset) - GetNumberCols();

	if( Difference > 0 )
	{
		AppendCols(Difference);
	}
	else if( (Difference = -Difference < GetNumberCols() ? -Difference : GetNumberCols()) > 0 )
	{	// here is (or was!?) a memory leak - solution: use own wxGridTableBase derived grid table class
		DeleteCols(0, Difference);
	}

	//-----------------------------------------------------
	for(int iCol=0, iField=m_Field_Offset; iField<m_pTable->Get_Field_Count(); iCol++, iField++)
	{
		SetColLabelValue(iCol, m_pTable->Get_Field_Name(iField));

		switch( m_pTable->Get_Field_Type(iField) )
		{
		default:
		case SG_DATATYPE_Byte:
		case SG_DATATYPE_Char:
		case SG_DATATYPE_String:
		case SG_DATATYPE_Date:
		case SG_DATATYPE_Binary:
			SetColFormatCustom(iCol, wxGRID_VALUE_STRING);
			break;

		case SG_DATATYPE_Bit:
		case SG_DATATYPE_Word:
		case SG_DATATYPE_Short:
		case SG_DATATYPE_DWord:
		case SG_DATATYPE_Int:
		case SG_DATATYPE_ULong:
		case SG_DATATYPE_Long:
		case SG_DATATYPE_Color:
			SetColFormatNumber(iCol);
			break;

		case SG_DATATYPE_Float:
		case SG_DATATYPE_Double:
			SetColFormatFloat(iCol);
			break;
		}
	}

	//-----------------------------------------------------
	EndBatch();

	return( _Set_Records() );
}

void CDDBaseGrid::SelectRow(long row)
{
   if (row >= 0 && row < GetNumberRows() && GetNumberCols() > 0)
   {
      SetMultiSelectMode(TRUE);
      GotoRow(row);
      SelectRange(0, row, (GetNumberCols() - 1), row);
   }
}

void ctlResultGrid::fillGrid( PGresult * result )
{
    int    rowCount = PQntuples( result );
    int    colCount = PQnfields( result );

    // If this PGresult represents a non-query command 
    // (like an INSERT), there won't be any columns in 
    // the result set - just return

    if( colCount == 0 )
        return;

    // Disable repaints to we don't flicker too much

    BeginBatch();

    // Clear out the old results (if any) and resize 
    // grid to match the result set

    if( GetNumberRows())
        DeleteRows( 0, GetNumberRows());
    if( GetNumberCols())
        DeleteCols( 0, GetNumberCols());

    AppendRows( rowCount );
    AppendCols( colCount );

    EnableEditing( false );

    // Copy the column names from the result set into the column headers

    for( int col = 0; col < colCount; ++col )
        SetColLabelValue( col, wxString( PQfname( result, col ), wxConvUTF8 ));

    // Now copy each value from the result set into the grid

    for( int row = 0; row < rowCount; ++row )
    {
        for( int col = 0; col < colCount; ++col )
        {
            if( PQgetisnull( result, row, col ))
                SetCellValue( row, col, wxT( "" ));
            else
                SetCellValue( row, col, wxString( PQgetvalue( result, row, col ), wxConvUTF8 ));
        }
    }

    // Resize each column to fit its content

    AutoSizeColumns( false );

    // Enable repaints

    EndBatch();
}

bool CGridLabThresholds::_SetData(
  CLabThresholds *pData, 
  const wxString &sKitName,
  const wxChar * const *psLabels)
{
  m_pData = pData;
  bool bOK = CGridLocusColumns::SetupKit(
    this,sKitName,true,m_bILS,true,true);

      // set row labels
  if(bOK)
  {
    const wxChar * const *pRowLabel;
    int nColCount = GetNumberCols();
    int j = 1;
    for(pRowLabel = psLabels; (*pRowLabel) != NULL; pRowLabel++)
    {
      SetRowLabelValue(j++,*pRowLabel);
    }
    // put junk in row 1 to set cell width
    _CreateGrid(m_nRows,nColCount);
    for(j = 0; j < nColCount ; j++)
    {
      SetCellValue(1,j,"0000000000");  // set cell width
    }
    nwxGrid::UpdateLabelSizes(this);
    AutoSize();
  }
  return bOK;
}

void CLayerTypeGrid::OnDClicked(int col,long row, RECT *rect,POINT *point,BOOL processed)
{
   int lastColIndx = GetNumberCols() - 1;
   CString cellText(QuickGetText(lastColIndx, row));
   int layerType = atoi(cellText);

   // Edit color if a layerType row (not a group name row)
   // and double click was not in the layer type column.
   if (layerType > -1 && col > 0)
   {
      CUGCell cell;
      GetCell(col, row, &cell); 

      COLORREF color = cell.GetBackColor(); // current color

	   CPersistantColorDialog dialog(color);
	   if (dialog.DoModal() == IDOK)
      {
	      color = dialog.GetColor();
         cell.SetBackColor(color);
         SetCell(col, row, &cell);
         RedrawAll();
      }
   }
}

void CGridAlleleBase::CheckRowCount()
{
  wxString s;
  int nRows = GetNumberRows();
  int nCols = GetNumberCols();
  int nStart = nRows - 2;
  int nCol;
  int nRow;

  if(nStart < 0)
  {
    nStart = 0;
  }
  for(nRow = nStart; nRow < nRows; nRow++)
  {
    for(nCol = 0; nCol < nCols; nCol++)
    {
      s = GetCellValue(nRow,nCol);
      nwxString::Trim(&s);
      if(s.Len())
      {
        nwxGrid::SetRowCount(nRows + 4);
        nCol = nCols;  // loop exit
        nRow = nRows;
      }
    }
  }
}

bool CGridLabThresholdsSample::SetData(CLabThresholds *pData,
    const wxString &sKitName)
{
  const wxChar * const psLabels[] = 
  {
    FRACTION_MAX_PEAK,
    PULLUP_FRACTIONAL_FILTER,
    STUTTER_THRESHOLD,
    PLUS_STUTTER_THRESHOLD,
    ADENYLATION_THRESHOLD,
    wxS("Min. heterozygote balance (0 - 1.0) "),
    wxS("Min. homozygote threshold (RFU) "),
    NULL
  };
  bool bOK = _SetData(pData,sKitName,psLabels);
  if(bOK)
  {
    int nCols = GetNumberCols();
    int i;
    for(i = 0; i < nCols; i++)
    {
      SetCellEditor(
        ROW_MIN_BOUND_HOMOZYGOTE,i,new wxGridCellFloatEditor(-1,0));
    }
  }
  return bOK;
}

void ctPropertyEditorGrid::OnSize(wxSizeEvent& event)
{
    if (m_stretchableColumn != -1)
    {
        // This window's client size = the internal window's
        // client size if it has no borders
        wxSize sz = GetClientSize();

        int totalSize = 0;
        int i;
        for (i = 0; i < GetNumberCols(); i ++)
        {
            if (i != m_stretchableColumn)
            {
                totalSize += GetColSize(i);
            }
        }

        // Allow for grid lines
        totalSize += 1;

        int stretchSize = wxMax(5, sz.x - totalSize);
        SetColSize(m_stretchableColumn, stretchSize);
    }

    event.Skip();
}

const std::string wex::grid::get_selected_cells_value() const
{
  // This does not work, only filled in for singly selected cells.
  // wxGridCellCoordsArray cells = GetSelectedCells();
  wxString text;

  for (int i = 0; i < GetNumberRows(); i++)
  {
    bool value_added = false;

    for (int j = 0; j < GetNumberCols(); j++)
    {
      if (IsInSelection(i, j))
      {
        if (value_added)
        {
          text << "\t";
        }

        text << GetCellValue(i, j);

        value_added = true;
      }
    }

    if (value_added)
    {
      text << "\n";
    }
  }

  return text;
}

void ctlSQLGrid::AutoSizeColumn(int col, bool setAsMin, bool doLimit)
{
	ColKeySizeHashMap::iterator it = colSizes.find(GetColKeyValue(col));
	if (it != colSizes.end()) // Restore user-specified size
		SetColSize(col, it->second);
	else
		wxGrid::AutoSizeColumn(col, setAsMin);

	if (doLimit)
	{
		int newSize, oldSize;
		int maxSize, totalSize = 0, availSize;

		oldSize = GetColSize(col);
		availSize = GetClientSize().GetWidth() - GetRowLabelSize();
		maxSize = availSize / 2;
		for (int i = 0 ; i < GetNumberCols() ; i++)
			totalSize += GetColSize(i);

		if (oldSize > maxSize && totalSize > availSize)
		{
			totalSize -= oldSize;
			/* Shrink wide column to maxSize.
			 * If the rest of the columns are short, make sure to use all the remaining space,
			 *   but no more than oldSize (which is enough according to AutoSizeColumns())
			 */
			newSize = wxMin(oldSize, wxMax(maxSize, availSize - totalSize));
			SetColSize(col, newSize);
		}
	}
}

void ctlSQLGrid::OnMouseWheel(wxMouseEvent &event)
{
	if (event.ControlDown() || event.CmdDown())
	{
		wxFont fontlabel = GetLabelFont();
		wxFont fontcells = GetDefaultCellFont();
		if (event.GetWheelRotation() > 0)
		{
			fontlabel.SetPointSize(fontlabel.GetPointSize() - 1);
			fontcells.SetPointSize(fontcells.GetPointSize() - 1);
		}
		else
		{
			fontlabel.SetPointSize(fontlabel.GetPointSize() + 1);
			fontcells.SetPointSize(fontcells.GetPointSize() + 1);
		}
		SetLabelFont(fontlabel);
		SetDefaultCellFont(fontcells);
		SetColLabelSize(fontlabel.GetPointSize() * 4);
		SetDefaultRowSize(fontcells.GetPointSize() * 2);
		for (int index = 0; index < GetNumberCols(); index++)
			SetColSize(index, -1);
		ForceRefresh();
	}
	else
		event.Skip();
}

void wex::grid::set_cells_value(
  const wxGridCellCoords& start_coords, 
  const std::string& data)
{
  tokenizer tkz(data, "\n");

  auto start_at_row = start_coords.GetRow();

  while (tkz.has_more_tokens())
  {
    const auto line(tkz.get_next_token());

    tokenizer tkz(line, "\t");

    auto next_col = start_coords.GetCol();

    while (tkz.has_more_tokens() && next_col < GetNumberCols())
    {
      const std::string value = tkz.get_next_token();

      if (!IsReadOnly(start_at_row, next_col))
      {
        set_grid_cell_value(wxGridCellCoords(start_at_row, next_col), value);
      }

      next_col++;
    }

    start_at_row++;
  }
}

wxString ctlSQLGrid::GetExportLine(int row, wxArrayInt cols)
{
	wxString str;
	unsigned int col;

	if (GetNumberCols() == 0)
		return str;

	for (col = 0 ; col < cols.Count() ; col++)
	{
		if (col > 0)
			str.Append(settings->GetCopyColSeparator());

		wxString text = GetCellValue(row, cols[col]);

		bool needQuote  = false;
		if (settings->GetCopyQuoting() == 1)
		{
			needQuote = IsColText(cols[col]);
		}
		else if (settings->GetCopyQuoting() == 2)
			/* Quote everything */
			needQuote = true;

		if (needQuote)
			str.Append(settings->GetCopyQuoteChar());
		str.Append(text);
		if (needQuote)
			str.Append(settings->GetCopyQuoteChar());
	}
	return str;
}

void CGridAlleleBase::_FitString(const wxString &s, int nStartColumn)
{
  int nCols = GetNumberCols();
  int nRows = GetNumberRows();
  int nCol;
  int nRow;
  if(nStartColumn < 0)
  {
    nStartColumn = (int)m_vsLeftColumns.size();
  }
  if(nRows > 1 && nCols > 0)
  {
    for(nCol = nStartColumn; nCol < nCols; nCol++)
    {
      SetCellValue(1,nCol,s);
    }
    for(nRow = 0; nRow < nRows; nRow++)
    {
      SetRowLabelValue(nRow,wxEmptyString);
    }
    UpdateLabelSizes();
    SetRowLabelSize(2);
    AutoSize();
  }
}

void CTWenUGCtrlEx::AppendRow_ButtonAdd(void)
{
	int nRow = CUGCtrl::GetNumberRows();

	if(nRow > 0)
	{
		CUGCell cell;
		GetCell(0, nRow-1, &cell);

		if(cell.GetBitmap()==GetBitmap(m_nIndexBMP_Add))//如果有增加行
		{
			return;
		}
	}

	if(AppendRow() != UG_SUCCESS) return;

	int nCol = GetNumberCols();

	JoinCells(1, nRow, nCol-1, nRow);

	if(nCol>1)
	{
		QuickSetBackColor(1, nRow, RGB(240,240,240));
		QuickSetBorder(1, nRow, UG_BDR_RAISED|UG_BDR_LTHIN|UG_BDR_RTHIN|UG_BDR_TTHIN|UG_BDR_BTHIN); 
	}

	QuickSetBitmap(0, nRow, m_nIndexBMP_Add);
}

void wxSheetValueProviderBase::Clear()
{
    const int numRows = GetNumberRows();
    const int numCols = GetNumberCols();
    if (numRows > 0) UpdateRows(0, -numRows);
    if (numCols > 0) UpdateCols(0, -numCols);
}

void CGridLabThresholds::_CreateGrid(int nRows, int nCols)
{
  int nPrevCols = 0;
  int nPrevRows = 0;
  int nCol;
  if(!m_bCreated)
  {
    m_bCreated = true;
    CreateGrid(nRows,nCols);
    SetRowLabelAlignment(wxALIGN_LEFT, wxALIGN_CENTRE);
    EnableDragColSize(false);
    EnableDragRowSize(false);
    SetDefaultCellAlignment(wxALIGN_RIGHT,wxALIGN_CENTRE);
  }
  else
  {
    nPrevRows = GetNumberRows();
    nPrevCols = GetNumberCols();
    nwxGrid::SetRowColCount(this,nRows,nCols);
  }
  for(nCol = nPrevCols; nCol < nCols; nCol++)
  {
    // set alignment for Channel row
    SetCellAlignment(0,nCol,wxALIGN_CENTRE, wxALIGN_CENTRE);
  }
}

void CGridAlerts::OnCellChange(wxGridEvent &e)
{
  if( !(m_nInCellChangeEvent || IsTableReadOnly()) )
  {
    CIncrementer x(m_nInCellChangeEvent);
    nwxGridBatch xxxx(this);
    int nRow = e.GetRow();
    int nCol = e.GetCol();
    COARmessage *pMsg = m_pMsgEdit->GetMessage((size_t) nRow);
    int nCols = GetNumberCols();
    const wxString &sName(pMsg->GetMessageName());
    if(nCol == (nCols - 1))
    {
      UpdateTextFromRow(nRow,pMsg);
    }
    else if(nCol == (nCols - 2))
    {
      UpdateDisabledFromRow(nRow,pMsg);
      if((!sName.IsEmpty()) && GetBoolValue(nRow,nCol))
      {
        // a row has been enabled
        // check for mutually exclusive rows
        // that are enabled and disable them

        set<wxString> ss;
        const COARmsgExportMap *pMsgExp = m_pMsgEdit->GetMsgExport();
        if(pMsgExp->GetGroupsByMsgName(sName,&ss))
        {
          // we found group names
          size_t nCount = m_pMsgEdit->GetMessageCount();
          size_t iRow;
          for(iRow = 0; iRow < nCount; iRow++)
          {
            if(iRow == (size_t)nRow)
            {}
            else if(!GetBoolValue(iRow,nCol))
            {} // already unchecked, fuhgeddaboudit.
            else
            {
              COARmessage *pMsgA = m_pMsgEdit->GetMessage(iRow);
              const wxString &sNameA(pMsgA->GetMessageName());
              if(sNameA.IsEmpty())
              {}
              else if( (sNameA == sName) ||
                  (pMsgExp->HasGroupByMsgName(sNameA,ss)) )
              {
                // need to uncheck message
                SetBoolValue(iRow,nCol,false);
                UpdateDisabledFromRow(iRow,pMsgA);
              }
            }
          }
        }
      }
    }
  }
  e.Skip(true);
}

void CGridAlerts::UpdateDisabledFromRow(
  int nRow, COARmessage *pMsg)
{
  int nCols = GetNumberCols() - 2;
  bool bHidden = !GetBoolValue(nRow,nCols++);
  pMsg->SetHidden(bHidden);
  DisableEdit(nRow,nCols,bHidden);
  Refresh();
}