// call by
// void Pstable::moveCol(int col, int place)
// void Pstable::setTreeMode(bool treemode)
// void Procview::set_fields()
// TODO: checkField();
void Procview::fieldArrange()
{
if (treeview == true)
{
// Tree Mode
// If ProcessName isn't the leftmost column, move it to
// leftmost
// *** important : F_PROCESSNAME field should be the first in
// TreeMode!
if (cats[0]->index != F_PROCESSNAME)
{
// find F_PROCESSNAME
for (int i = 1; i < cats.size(); i++)
{
if (cats[i]->index == F_PROCESSNAME)
moveColumn(i, 0);
}
}
// PID sort for convenience (default)
/*
if(false and cats[i]->index == F_PID )
{
reversed = false;
sortcat = cats[i];
//// pstable->setSortedCol(i);
} */
// Linear_Mode:
}
if (true)
{
for (int i = 0; i < cats.size(); i++)
{
if (cats[i]->index == F_CMDLINE)
{
// COMMAND_LINE field should always be the last
// field
if (i == (cats.size() - 1))
moveColumn(i, 0);
else
{
}
}
}
}
}
/*************************************************************************
Handler method for when a segment is dragged & dropped.
*************************************************************************/
bool ListHeader::segmentMovedHandler(const EventArgs& e)
{
const Vector2f mousePos(getUnprojectedPosition(
getGUIContext().getMouseCursor().getPosition()));
// segment must be dropped within the window
if (isHit(mousePos))
{
// get mouse position as something local
Vector2f localMousePos(CoordConverter::screenToWindow(*this, mousePos));
// set up to allow for current offsets
float currwidth = -d_segmentOffset;
// calculate column where dragged segment was dropped
uint col;
for (col = 0; col < getColumnCount(); ++col)
{
currwidth += d_segments[col]->getPixelSize().d_width;
if (localMousePos.d_x < currwidth)
{
// this is the column, exit loop early
break;
}
}
// find original column for dragged segment.
ListHeaderSegment* seg = ((ListHeaderSegment*)((WindowEventArgs&)e).window);
uint curcol = getColumnFromSegment(*seg);
// move column
moveColumn(curcol, col);
}
return true;
}
// Computer AI
// 1. Search for possible wins for me
// 2. Search for possible wins for opponent
// 3. Perform most strategic move
static void autoMove()
{
// Can I win
if (moveRow(PLAYER2))
return;
if (moveColumn(PLAYER2))
return;
if (moveDiagonal(PLAYER2))
return;
// Can he/she win
if (moveRow(PLAYER1))
return;
if (moveColumn(PLAYER1))
return;
if (moveDiagonal(PLAYER1))
return;
// Most strategic move
if (board[5] == NO_ONE)
{
board[5] = PLAYER2;
return;
}
// Very Special cases
if ((board[5] == PLAYER2) && (board[9] == NO_ONE) &&
(board[8] == PLAYER1) && (board[3] == PLAYER1))
{
board[9] = PLAYER2;
return;
}
if ((board[5] == PLAYER2) && (board[9] == NO_ONE) &&
(board[7] == PLAYER1) && (board[6] == PLAYER1))
{
board[9] = PLAYER2;
return;
}
if ((board[5] == PLAYER2) && (board[7] == NO_ONE) &&
(board[8] == PLAYER1) && (board[1] == PLAYER1))
{
board[7] = PLAYER2;
return;
}
// Special cases
int *r = 0;
if ((board[5] == PLAYER2) &&
(((board[1] == PLAYER1) && (board[9] == PLAYER1)) ||
((board[3] == PLAYER1) && (board[7] == PLAYER1))))
{
static int rtmp[9] = {5, 2, 4, 6, 8, 1, 3, 7, 9};
r = rtmp;
}
else if ((board[5] == PLAYER2) &&
(board[2] == PLAYER1) && (board[4] == PLAYER1))
{
static int rtmp[9] = {5, 1, 4, 6, 8, 2, 3, 7, 9};
r = rtmp;
}
else if ((board[5] == PLAYER2) &&
(board[2] == PLAYER1) && (board[6] == PLAYER1))
{
static int rtmp[9] = {5, 3, 4, 6, 8, 1, 2, 7, 9};
r = rtmp;
}
else if ((board[5] == PLAYER2) &&
(board[8] == PLAYER1) && (board[4] == PLAYER1))
{
static int rtmp[9] = {5, 7, 4, 6, 8, 1, 3, 2, 9};
r = rtmp;
}
else if ((board[5] == PLAYER2) &&
(board[8] == PLAYER1) && (board[6] == PLAYER1))
{
static int rtmp[9] = {5, 9, 4, 6, 8, 1, 3, 7, 2};
r = rtmp;
}
else
{
static int tics = 0;
if (++tics % 10 == 0)
{
// In one out of 10 cases, give the user a chance.
static int rtmp[9] = {5, 2, 4, 6, 8, 1, 3, 7, 9};
r = rtmp;
}
else
{
static int rtmp[9] = {5, 1, 3, 7, 9, 2, 4, 6, 8};
r = rtmp;
}
}
for (int i = 0; i < 9; i++)
if (board[r[i]] == NO_ONE) {
board[r[i]] = PLAYER2;
return;
}
}
/*************************************************************************
Move a segment to a new position
*************************************************************************/
void ListHeader::moveSegment(const ListHeaderSegment& segment, const ListHeaderSegment& position)
{
moveColumn(getColumnFromSegment(segment), getColumnFromSegment(position));
}
/*************************************************************************
Move a segment to a new position
*************************************************************************/
void ListHeader::moveSegment(const ListHeaderSegment& segment, uint position)
{
moveColumn(getColumnFromSegment(segment), position);
}
/*************************************************************************
Move a column segment to a new position.
*************************************************************************/
void ListHeader::moveColumn(uint column, const ListHeaderSegment& position)
{
moveColumn(column, getColumnFromSegment(position));
}
void Splitter::endTracking(const CPoint &aPoint)
{
if (XPR_IS_NOT_NULL(mTrack) && XPR_IS_TRUE(mTrack->mSetCapture))
{
xpr_sint_t sCapturedCoord = XPR_IS_FALSE(mTrack->mHorzSplitter) ? aPoint.x : aPoint.y;
xpr_sint_t sCurPos = mTrack->mCurPos + (sCapturedCoord - mTrack->mCapturedCoord);
if (mMinPaneSize > 0 && sCurPos < mMinPaneSize) sCurPos = mMinPaneSize;
if (mMaxPaneSize > 0 && sCurPos > mMaxPaneSize) sCurPos = mMaxPaneSize;
xpr_sint_t sOffset = sCurPos - mTrack->mCurPos;
if (XPR_IS_FALSE(mTrack->mHorzSplitter))
{
CSize sRightPaneSize(0, 0);
getPaneSize(mTrack->mRow, mTrack->mColumn + 1, sRightPaneSize);
if (mMinPaneSize > 0 && (sRightPaneSize.cx - sOffset) < mMinPaneSize)
sCurPos -= mMinPaneSize - (sRightPaneSize.cx - sOffset);
}
else
{
CSize sRightPaneSize(0, 0);
getPaneSize(mTrack->mRow + 1, mTrack->mColumn, sRightPaneSize);
if (mMinPaneSize > 0 && (sRightPaneSize.cy - sOffset) < mMinPaneSize)
sCurPos -= mMinPaneSize - (sRightPaneSize.cy - sOffset);
}
if (sCurPos != mTrack->mCurPos)
{
sOffset = sCurPos - mTrack->mCurPos;
mTrack->mCurPos = sCurPos;
mTrack->mCapturedCoord += sOffset;
if (XPR_IS_FALSE(mTrack->mHorzSplitter))
{
CSize sRightPaneSize(0, 0);
getPaneSize(mTrack->mRow, mTrack->mColumn + 1, sRightPaneSize);
moveColumn(mTrack->mColumn, mTrack->mCurPos);
moveColumn(mTrack->mColumn + 1, sRightPaneSize.cx - sOffset);
}
else
{
moveRow(mTrack->mRow, mTrack->mCurPos);
}
//resize();
//::UpdateWindow(mTrack->mHwnd);
}
mTrack->mHover = XPR_FALSE;
mTrack->mPressed = XPR_FALSE;
mTrack->mPressedLeave = XPR_FALSE;
mTrack->mSetCapture = XPR_FALSE;
::ReleaseCapture();
::InvalidateRect(mTrack->mHwnd, XPR_NULL, XPR_TRUE);
//::UpdateWindow(mTrack->mHwnd);
XPR_SAFE_DELETE(mTrack);
}
}
xpr_bool_t Splitter::moveTracking(const CPoint &aPoint)
{
if (XPR_IS_NOT_NULL(mTrack) && XPR_IS_TRUE(mTrack->mSetCapture))
{
SetCursor(::LoadCursor(0, XPR_IS_FALSE(mTrack->mHorzSplitter) ? IDC_SIZEWE : IDC_SIZENS));
xpr_sint_t sCapturedCoord = XPR_IS_FALSE(mTrack->mHorzSplitter) ? aPoint.x : aPoint.y;
xpr_sint_t sCurPos = mTrack->mCurPos + (sCapturedCoord - mTrack->mCapturedCoord);
//XPR_TRACE(XPR_STRING_LITERAL("OnMouseMove - %d\n", sCurPos));
if (mMinPaneSize > 0 && sCurPos < mMinPaneSize) sCurPos = mMinPaneSize;
if (mMaxPaneSize > 0 && sCurPos > mMaxPaneSize) sCurPos = mMaxPaneSize;
xpr_sint_t sOffset = sCurPos - mTrack->mCurPos;
if (XPR_IS_FALSE(mTrack->mHorzSplitter))
{
CSize sRightPaneSize(0, 0);
getPaneSize(mTrack->mRow, mTrack->mColumn + 1, sRightPaneSize);
if (mMinPaneSize > 0 && (sRightPaneSize.cx - sOffset) < mMinPaneSize)
sCurPos -= mMinPaneSize - (sRightPaneSize.cx - sOffset);
}
else
{
CSize sRightPaneSize(0, 0);
getPaneSize(mTrack->mRow + 1, mTrack->mColumn, sRightPaneSize);
if (mMinPaneSize > 0 && (sRightPaneSize.cy - sOffset) < mMinPaneSize)
sCurPos -= mMinPaneSize - (sRightPaneSize.cy - sOffset);
}
if (sCurPos != mTrack->mCurPos)
{
sOffset = sCurPos - mTrack->mCurPos; // recalculate offset
mTrack->mCurPos = sCurPos;
mTrack->mCapturedCoord += sOffset;
XPR_TRACE(XPR_STRING_LITERAL("OnMouseMove - %d\n"), mTrack->mCurPos);
if (XPR_IS_FALSE(mTrack->mHorzSplitter))
{
CSize sRightPaneSize(0, 0);
getPaneSize(mTrack->mRow, mTrack->mColumn + 1, sRightPaneSize);
moveColumn(mTrack->mColumn, mTrack->mCurPos);
moveColumn(mTrack->mColumn + 1, sRightPaneSize.cx - sOffset);
}
else
{
moveRow(mTrack->mRow, mTrack->mCurPos);
}
//resize();
//::UpdateWindow(mTrack->mHwnd);
}
return XPR_TRUE;
}
xpr_sint_t i;
xpr_sint_t sSplitterCount = getSplitterCount();
xpr_bool_t sSplitterHover = XPR_FALSE;
xpr_bool_t sHorzSplitter = XPR_FALSE;
CRect sSplitterRect;
for (i = 0; i < sSplitterCount; ++i)
{
if (getSplitterRect(i, sSplitterRect, &sHorzSplitter) == XPR_FALSE)
continue;
if (sSplitterRect.PtInRect(aPoint) == XPR_TRUE)
{
sSplitterHover = XPR_TRUE;
break;
}
}
if (XPR_IS_TRUE(sSplitterHover))
{
SetCursor(::LoadCursor(0, XPR_IS_FALSE(sHorzSplitter) ? IDC_SIZEWE : IDC_SIZENS));
}
return XPR_FALSE;
}
