//
// Copyright 1997 Nicholas J. Irias. All rights reserved.
//
//
// JobListCtrl.cpp : implementation file
//
#include "stdafx.h"
#include "p4win.h"
#include "JobListCtrl.h"
#include "JobsConfigure.h"
#include "MainFrm.h"
#include "TokenString.h"
#include "JobDescribe.h"
#include "SpecDescDlg.h"
#include "cmd_editspec.h"
#include "cmd_jobs.h"
#include "cmd_delete.h"
#include "catchalldlg.h"
#include "RegKeyEx.h"
#include "ImageList.h"
static LPCTSTR sRegKey = _T("Software\\Perforce\\P4Win\\Layout\\Job List");
static LPCTSTR sRegValue_ColumnWidths = _T("Column Widths");
static LPCTSTR sRegValue_SortColumns = _T("Sort Columns");
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#define IMG_INDEX(x) (x-IDB_PERFORCE)
/////////////////////////////////////////////////////////////////////////////
// CJobListCtrl
IMPLEMENT_DYNCREATE(CJobListCtrl, CP4ListCtrl)
BEGIN_MESSAGE_MAP(CJobListCtrl, CP4ListCtrl)
ON_WM_CREATE()
ON_UPDATE_COMMAND_UI(ID_VIEW_UPDATE_RIGHT, OnUpdateViewUpdate)
ON_WM_CONTEXTMENU()
ON_UPDATE_COMMAND_UI(ID_JOB_DELETE, OnUpdateJobDelete)
ON_COMMAND(ID_JOB_DELETE, OnJobDelete)
ON_UPDATE_COMMAND_UI(ID_JOB_EDITSPEC, OnUpdateJobEditspec)
ON_COMMAND(ID_JOB_EDITSPEC, OnJobEditspec)
ON_NOTIFY_REFLECT(LVN_DELETEITEM, OnDeleteitem)
ON_UPDATE_COMMAND_UI(ID_JOB_DESCRIBE, OnUpdateJobDescribe)
ON_WM_LBUTTONDBLCLK()
ON_COMMAND(ID_SETFILTER_JOBS, OnJobSetFilter)
ON_COMMAND(ID_CLEARFILTER_JOBS, OnJobRemovefilter)
ON_UPDATE_COMMAND_UI(ID_JOB_SETFILTER, OnUpdateJobSetFilter)
ON_COMMAND(ID_JOB_SETFILTER, OnJobSetFilter)
ON_UPDATE_COMMAND_UI(ID_JOB_REMOVEFILTER, OnUpdateJobRemovefilter)
ON_COMMAND(ID_JOB_REMOVEFILTER, OnJobRemovefilter)
ON_UPDATE_COMMAND_UI(ID_JOB_SETFILEFILTER, OnUpdateJobSetFileFilter)
ON_COMMAND(ID_JOB_SETFILEFILTER, OnJobSetFileFilter)
ON_UPDATE_COMMAND_UI(ID_JOB_SETFILEFILTERINTEG, OnUpdateJobSetFileFilter)
ON_COMMAND(ID_JOB_SETFILEFILTERINTEG, OnJobSetFileFilterInteg)
ON_UPDATE_COMMAND_UI(ID_JOB_REMOVEFILEFILTER, OnUpdateJobRemoveFileFilter)
ON_COMMAND(ID_JOB_REMOVEFILEFILTER, OnJobRemoveFileFilter)
ON_UPDATE_COMMAND_UI(ID_JOB_NEW, OnUpdateJobNew)
ON_COMMAND(ID_JOB_NEW, OnJobNew)
ON_COMMAND(ID_JOB_DESCRIBE, OnDescribe)
ON_COMMAND(ID_VIEW_UPDATE_RIGHT, OnViewUpdate)
ON_UPDATE_COMMAND_UI(ID_JOB_CONFIGURE, OnUpdateJobConfigure)
ON_COMMAND(ID_JOB_CONFIGURE, OnJobConfigure)
ON_COMMAND(ID_PERFORCE_OPTIONS, OnPerforceOptions)
ON_MESSAGE(WM_P4JOBS, OnP4JobList )
ON_MESSAGE(WM_P4EDITSPEC, OnP4JobSpec )
ON_MESSAGE(WM_P4ENDSPECEDIT, OnP4EndSpecEdit )
ON_MESSAGE(WM_P4DELETE, OnP4Delete )
ON_MESSAGE(WM_P4JOBSPEC, OnP4JobSpecColumnNames )
ON_MESSAGE(WM_P4DESCRIBE, OnP4Describe )
ON_MESSAGE(WM_P4ENDDESCRIBE, OnP4EndDescribe )
ON_MESSAGE(WM_FETCHJOBS, OnFetchJobs )
ON_MESSAGE(WM_QUERYJOBS, OnQueryJobs )
ON_MESSAGE(WM_QUERYJOBSPEC, OnQueryJobSpec )
ON_MESSAGE(WM_QUERYJOBFIELDS, OnQueryJobFields )
ON_MESSAGE(WM_QUERYJOBCOLS, OnQueryJobColumns )
ON_MESSAGE( WM_QUERYJOBSELECTION, OnQueryJobSelection )
ON_MESSAGE(WM_JOB_FILTER, OnJobFilter2)
ON_MESSAGE(WM_CLEARLIST, OnClear)
END_MESSAGE_MAP()
CJobListCtrl::CJobListCtrl()
{
m_SortAscending = m_FilterIncIntegs = FALSE;
m_LastSortCol=0;
m_viewType = P4JOB_SPEC;
m_bAlreadyGotColumns = m_Need2CallOnJobConfigure = FALSE;
m_PostListToChangeNum= 0;
m_PostListToChangeWnd= 0;
m_Need2DoNew = FALSE;
m_NewJob = FALSE;
m_ColCodes.RemoveAll();
m_captionplain = LoadStringResource(IDS_PERFORCE_JOBS);
m_FastJobs = GetSavedColumnNames(m_DesiredCols, _T("Job List"));
m_CF_JOB = static_cast<CLIPFORMAT>(RegisterClipboardFormat(LoadStringResource(IDS_DRAGFROMJOB)));
m_CF_DEPOT = static_cast<CLIPFORMAT>(RegisterClipboardFormat(LoadStringResource(IDS_DRAGFROMDEPOT)));
}
CJobListCtrl::~CJobListCtrl()
{
}
/////////////////////////////////////////////////////////////////////////////
// CJobListCtrl diagnostics
#ifdef _DEBUG
void CJobListCtrl::AssertValid() const
{
CP4ListCtrl::AssertValid();
}
void CJobListCtrl::Dump(CDumpContext& dc) const
{
CP4ListCtrl::Dump(dc);
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CJobListCtrl message handlers
void CJobListCtrl::OnLButtonDblClk(UINT nFlags, CPoint point)
{
int index = GetHitItem ( point );
if(index != -1)
{
SetItemState( index, LVIS_SELECTED|LVIS_FOCUSED, LVIS_SELECTED|LVIS_FOCUSED );
OnDescribe();
}
else
CP4ListCtrl::OnLButtonDblClk(nFlags, point);
}
LRESULT CJobListCtrl::OnClear( WPARAM wParam, LPARAM lParam )
{
m_sFilter.Empty( );
PersistentJobFilter( KEY_READ );
Clear();
return 0;
}
void CJobListCtrl::Clear()
{
SetRedraw(FALSE);
DeleteAllItems();
SetRedraw(TRUE);
CP4ListCtrl::Clear();
}
/////////////////////////////////
// Three functions to allow the changelist pane to fetch the job list
// and the current job codes list
/////////////////////////////////
LRESULT CJobListCtrl::OnFetchJobs( WPARAM wParam, LPARAM lParam )
{
m_PostListToChangeNum= wParam;
m_PostListToChangeWnd= (HWND)lParam;
if( GetItemCount() > 0 )
{
::SendMessage(m_PostListToChangeWnd, WM_P4JOBS, m_PostListToChangeNum, 0);
m_PostListToChangeNum=0;
m_PostListToChangeWnd=0;
}
else
OnViewUpdate();
return 0;
}
LRESULT CJobListCtrl::OnQueryJobs( WPARAM wParam, LPARAM lParam )
{
CObList *m_pJobList= new CObList;
// Make a copy of the joblist, so the consumer doesnt need
// to worry about any refresh that happens here at a later
// time. (They just need to delete the list when done)
for( int i = 0; i < GetItemCount(); i++ )
{
CP4Job *job= (CP4Job *) GetItemData(i);
CP4Job *newJob= new CP4Job;
newJob->Create(job);
m_pJobList->AddHead(newJob);
}
return (LRESULT) m_pJobList;
}
LRESULT CJobListCtrl::OnQueryJobSpec( WPARAM wParam, LPARAM lParam )
{
return (LRESULT)&m_Spec;
}
LRESULT CJobListCtrl::OnQueryJobFields( WPARAM wParam, LPARAM lParam )
{
// The caller has provided an array. Just transpose our array
// into that array, to give the caller a snapshot.
CArray<int,int> *array= ( CArray<int,int> *) wParam;
array->RemoveAll();
for(int i=0; i < m_ColCodes.GetSize(); i++)
array->Add( m_ColCodes[i] );
return (LRESULT) array;
}
LRESULT CJobListCtrl::OnQueryJobColumns( WPARAM wParam, LPARAM lParam )
{
return (LRESULT)&m_ColNames;
}
LRESULT CJobListCtrl::OnQueryJobSelection( WPARAM wParam, LPARAM lParam )
{
m_Active = GetSelectedItemText();
return (LRESULT)&m_Active;
}
void CJobListCtrl::OnUpdateJobNew(CCmdUI* pCmdUI)
{
pCmdUI->SetText ( LoadStringResource( IDS_NEW ) );
pCmdUI->Enable(!SERVER_BUSY() && !m_EditInProgress);
m_Need2DoNew = FALSE;
}
/*
_________________________________________________________________
since users can now define their own types in the job tracker, we
have to get the names from the server.
_________________________________________________________________
*/
LRESULT CJobListCtrl::OnP4JobSpecColumnNames( WPARAM wParam, LPARAM lParam )
{
CCmd_JobSpec *pCmd = ( CCmd_JobSpec *) wParam;
ASSERT_KINDOF(CCmd_JobSpec, pCmd);
if(!pCmd->GetError())
{
// Delete the old column names
int i;
for( i= m_ColCodes.GetUpperBound(); i>=0; i-- )
DeleteColumn(i);
pCmd->GetSpec( m_Spec );
m_FieldNames.SetSize(0);
GetFldNames( m_FieldNames, m_Spec );
// Default column widths based on all 5 default columns being present
//
int width[MAX_JOBS_COLUMNS] = { 90,80,60,90,200 };
RestoreSavedWidths( width, max(MAX_JOBS_COLUMNS, m_ColCodes.GetSize()), _T("Job List") );
for (i = -1; ++i < MAX_JOBS_COLUMNS; )
{
if (width[i] > 5000)
width[i] = 30;
}
InsertColumnHeaders( m_ColNames, width );
m_bAlreadyGotColumns = TRUE;
// okay, we got all the job column names.
// now get the job list or start the configure dialog
//
if (m_Need2CallOnJobConfigure)
OnJobConfigure();
else
GetJobs( );
}
else if(m_PostListToChangeNum != 0)
{
::SendMessage(m_PostListToChangeWnd, WM_P4JOBS, m_PostListToChangeNum, 0);
m_PostListToChangeNum=0;
m_PostListToChangeWnd=0;
}
delete pCmd;
MainFrame()->ClearStatus();
return 0;
}
/*
_________________________________________________________________
Simple parse code to check jobspec for spec codes 101-105,
which are reserved codes for default fields that may be present in the
output of p4 jobs. Record the column headings for these codes.
_________________________________________________________________
*/
BOOL CJobListCtrl::GetFldNames( CStringArray &fldNames, const CString &spec )
{
int i;
CString errorText;
CString fields;
m_SpecNames.RemoveAll();
m_ColNames.RemoveAll();
m_ColNames.SetSize(0);
m_ColNames.Copy(m_DesiredCols);
// Get the field names from the spec. they are between the word
// "Fields:" and the word "Required" strip the separator. Don't
// crash if the jobspec is not recognized.
int start= spec.Find(_T("Fields:")) + lstrlen(_T("Fields:"));
int end= spec.Find(_T("Required:"));
if( start == -1 || end == -1 || end < start || end >= spec.GetLength())
errorText=LoadStringResource(IDS_UNABLE_TO_FIND_FIELD_DELIMITERS);
if( errorText.IsEmpty() )
{
fields = spec.Mid(start, end - start);
start= fields.Find( 0x09 );
if( start == -1 )
errorText=LoadStringResource(IDS_UNABLE_TO_FIND_INITIAL_FIELD_DELIMITER);
}
if( errorText.IsEmpty() )
{
m_ColCodes.RemoveAll();
fields = fields.Mid( start + 1 );
// Pick out the requested field names if present
int code;
CString field;
int max = m_ColNames.GetSize();
do
{
// get the field spec (e.g., "101 Job word 32")
// and truncate the fields.
//
int delim = fields.Find( 0x0a);
if(delim < 9) // need at least "n Job x n" or something's wrong
break;
field = fields.Left ( delim + 1 );
fields = fields.Right ( fields.GetLength( ) - (delim + 1) );
// get the "101" part of the spec in code
//
delim = field.Find(_T(' '));
if(delim < 1)
break;
code = _ttoi ( field.Left ( delim ) ) ;
field = field.Right ( field.GetLength ( ) - (delim + 1) );
// get the "Job" part in field.
//
delim = field.Find(_T(' '));
if(delim < 1)
break;
field = field.Left ( delim );
m_SpecNames.Add(field); // save all field names from the spec here.
if (code == 101) // if this is the jobname field, capture its name for 1st column
m_ColNames.SetAt(0, field);
else if (code == 103)
m_ReportedByTitle = field;
for (i = -1; ++i < max; )
{
CString colname = m_ColNames.GetAt(i);
if (colname == field)
{
fldNames.Add( field );
m_ColCodes.Add( code );
break;
}
else if ((colname.GetAt(0) == _T(':')) && (colname.GetAt(1) == _T('1')) && (colname.GetAt(2) == _T('0')))
{
TCHAR digit = colname.GetAt(3);
int colcode = 100 + (digit & 0x0F);
if (colcode == code)
{
m_ColNames.SetAt(i, field);
fldNames.Add( field );
m_ColCodes.Add( code );
break;
}
}
}
}
while ( !field.IsEmpty( ) );
}
if( !errorText.IsEmpty() )
{
// Very unlikely that we will ever report this error, but an error
// message is always preferable to an inexplicable crash
AddToStatus(CString(_T("JobView::GetFldNames()") + errorText), SV_ERROR);
return FALSE;
}
else
return TRUE;
}
/*
_________________________________________________________________
*/
void CJobListCtrl::InsertJob(CP4Job *job, int index)
{
LV_ITEM lvItem;
int iActualItem = -1;
CString txt;
CString colName;
ASSERT(job != NULL);
m_iImage = CP4ViewImageList::VI_JOB;
int maxcols = m_ColNames.GetSize();
for(int subItem=0; subItem < maxcols; subItem++)
{
lvItem.mask=LVIF_TEXT |
((subItem==0) ? LVIF_IMAGE : 0) |
((subItem==0) ? LVIF_PARAM : 0);
lvItem.iItem= (subItem==0) ? index : iActualItem;
ASSERT(lvItem.iItem != -1);
lvItem.iSubItem= subItem;
lvItem.iImage = CP4ViewImageList::VI_JOB;
lvItem.lParam=(LPARAM) job;
txt=PadCRs(job->GetJobField(subItem));
lvItem.pszText = const_cast<LPTSTR>( (LPCTSTR ) txt);
if(subItem==0)
iActualItem=InsertItem(&lvItem);
else
SetItem(&lvItem);
}
}
/* _________________________________________________________________
After a spec edit, update the appropriate tree item
_________________________________________________________________
*/
void CJobListCtrl::UpdateJob(CP4Job *job, int index)
{
// First, switch the user data
CP4Job *oldJob= (CP4Job *) GetItemData(index);
delete oldJob;
SetItemData(index, (LPARAM) job);
CString txt;
CString colName;
// Then update the text for any fields that are present
int maxCols = m_ColNames.GetSize();
for( int subItem=0; subItem < maxCols; subItem++ )
{
txt=PadCRs(job->GetJobField(subItem));
SetItemText(index, subItem, const_cast<LPTSTR>((LPCTSTR)txt));
}
}
/*
_________________________________________________________________
*/
void CJobListCtrl::OnUpdateJobDescribe(CCmdUI* pCmdUI)
{
pCmdUI->Enable( OnUpdateShowMenuItem( pCmdUI, IDS_DESCRIBEIT_s ) );
}
/*
_________________________________________________________________
*/
LRESULT CJobListCtrl::OnP4JobList(WPARAM wParam, LPARAM lParam)
{
POSITION pos;
CP4Job *job;
int index;
CObList *jobs;
CCmd_Jobs *pCmd= (CCmd_Jobs *) wParam;
if(!pCmd->GetError())
{
SET_BUSYCURSOR();
jobs= pCmd->GetList();
SetRedraw(FALSE);
CString bigjob = _T("");
for(pos= jobs->GetHeadPosition(), index=0; pos != NULL; index++)
{
job=(CP4Job *) jobs->GetNext(pos);
if (m_FilterView.GetCount() > 1) // check for duplicates
{ // if filtering on more than 1 file
CString jobname = job->GetJobName();
if (jobname <= bigjob)
{
if (jobname == bigjob || FindInList(jobname) != -1)
{
delete job;
continue;
}
}
else
bigjob = jobname;
}
InsertJob(job, index);
}
SetRedraw(TRUE);
CString msg;
msg.FormatMessage(IDS_NUMBER_OF_JOBS_n, index );
AddToStatus( msg, SV_COMPLETION );
////jobs->RemoveAll();
ReSort();
if(jobs->GetCount() > 0)
{
int i = FindInList(m_Active);
if (i < 0) i=0;
SetItemState(i, LVIS_SELECTED|LVIS_FOCUSED, LVIS_SELECTED|LVIS_FOCUSED);
EnsureVisible(i, FALSE);
}
CP4ListCtrl::SetUpdateDone();
if (m_Need2DoNew)
OnJobNew();
::SetCursor(::LoadCursor(NULL, IDC_ARROW));
}
else
{
CP4ListCtrl::SetUpdateFailed();
m_Need2DoNew = FALSE;
}
if(m_PostListToChangeNum != 0)
{
::SendMessage(m_PostListToChangeWnd, WM_P4JOBS, m_PostListToChangeNum, 0);
m_PostListToChangeNum= 0;
m_PostListToChangeWnd= 0;
}
delete pCmd;
MainFrame()->ClearStatus();
// Notify the mainframe that we have finished getting the jobs,
// hence the entire set of async command have finished.
MainFrame()->ExpandDepotIfNeedBe();
return 0;
}
/*
_________________________________________________________________
*/
void CJobListCtrl::OnUpdateViewUpdate(CCmdUI* pCmdUI)
{
pCmdUI->Enable(!SERVER_BUSY() && !MainFrame()->IsModlessUp());
}
void CJobListCtrl::OnViewUpdate( )
{
MainFrame()->SetJobUpdateTime(GetTickCount());
m_Active = GetSelectedItemText();
SetCaption( );
if( m_ReadSavedWidths )
SaveColumnWidths();
if( GET_SERVERLEVEL() > 3 )
GetJobSpec( ) ; //which also calls GetJobs( )
else
{
// Against 97.3 server, the column names are always the same
m_ColNames.RemoveAll();
m_ColNames.Add(LoadStringResource(IDS_P4JOB));
m_ColNames.Add(LoadStringResource(IDS_P4STATUS));
m_ColNames.Add(LoadStringResource(IDS_REPORTEDBY));
m_ColNames.Add(LoadStringResource(IDS_REPORTEDDATE));
m_ColNames.Add(LoadStringResource(IDS_DESCRIPTION));
m_ColCodes.RemoveAll();
int i;
for(i=101; i <= 105; i++)
m_ColCodes.Add(i);
// there is no default for the jobs now that the fields
// are user-defined.
//
int width[ MAX_JOBS_COLUMNS ] = { 90,80,60,90,200 };
RestoreSavedWidths( width, m_ColCodes.GetSize(), _T("Job List") );
for (i = -1; ++i < MAX_JOBS_COLUMNS; )
{
if (width[i] > 5000)
width[i] = 30;
}
InsertColumnHeaders( m_ColNames, width );
m_bAlreadyGotColumns = TRUE;
GetJobs();
}
}
void CJobListCtrl::GetJobSpec( )
{
CCmd_JobSpec *pCmd = new CCmd_JobSpec;
pCmd->Init( m_hWnd, RUN_ASYNC );
if( !pCmd->Run( ) )
delete pCmd;
}
void CJobListCtrl::GetJobs( )
{
CCmd_Jobs *pCmd = new CCmd_Jobs;
pCmd->Init( m_hWnd, RUN_ASYNC);
if( GET_SERVERLEVEL() == 3)
{
m_sFilter.Empty();
pCmd->SetFilter( FALSE );
}
else
pCmd->SetFilter( !m_sFilter.IsEmpty( ) );
ASSERT(m_bAlreadyGotColumns);
int maxFlds = m_FieldNames.GetSize();
int maxCols = m_ColNames.GetSize();
int i;
for (i = -1; ++i < maxCols; ) // add the fields desired in column order
{
CString colName = m_ColNames.GetAt(i);
int j;
for (j = -1; ++j < maxFlds; )
{
if (m_FieldNames.GetAt(j) == colName)
{
pCmd->GetFieldNames().Add(colName);
pCmd->GetFieldCodes().Add(m_ColCodes.GetAt(j));
break;
}
}
if (j >= maxFlds)
{
pCmd->GetFieldNames().Add(_T(""));
pCmd->GetFieldCodes().Add(0);
}
}
// Make a copy of the filter view, because CCmd_Jobs will
// destroy that copy
POSITION pos=m_FilterView.GetHeadPosition();
m_StrList.RemoveAll();
while(pos != NULL)
m_StrList.AddTail(m_FilterView.GetNext(pos));
if( pCmd->Run( m_sFilter, m_FastJobs, &m_StrList, m_FilterIncIntegs ) )
{
Clear();
CP4ListCtrl::OnViewUpdate();
MainFrame()->UpdateStatus( LoadStringResource(IDS_REQUESTING_JOBS_LISTING) );
}
else
delete pCmd;
}
/*
_________________________________________________________________
*/
CString CJobListCtrl::SetCaption()
{
if( (m_sFilter.IsEmpty() && m_FilterView.IsEmpty()) || GET_SERVERLEVEL() < 4)
m_caption = LoadStringResource(IDS_PERFORCE_JOBS);
else
{
CString filter;
if (!m_sFilter.IsEmpty() && !m_FilterView.IsEmpty())
filter.FormatMessage(IDS_FILTERED_BOTH, m_sFilter);
else if (!m_FilterView.IsEmpty())
{
CString filelist=m_FilterView.GetHead();
if (m_FilterView.GetCount() > 1)
{
POSITION pos= m_FilterView.GetHeadPosition();
m_FilterView.GetNext(pos);
while( pos != NULL )
filelist += _T(", ") + m_FilterView.GetNext(pos);
}
filter.FormatMessage(IDS_FILTERED_BY_FILES, filelist);
}
else
filter.FormatMessage(IDS_FILTERED, m_sFilter);
m_caption = LoadStringResource(IDS_PERFORCE_JOBS) + filter;
}
CP4PaneContent::GetView()->SetCaption();
return m_caption;
}
/*
_________________________________________________________________
*/
void CJobListCtrl::OnContextMenu(CWnd* pWnd, CPoint point)
{
// make sure window is active
GetParentFrame()->ActivateFrame();
///////////////////////////////
// See ContextMenuRules.txt for order of menu commands!
// create an empty context menu
CP4Menu popMenu;
popMenu.CreatePopupMenu();
int index;
SetIndexAndPoint( index, point );
// Can always create new job
popMenu.AppendMenu(MF_ENABLED | MF_STRING, ID_JOB_NEW );
if(index != -1)
{
popMenu.AppendMenu(MF_ENABLED | MF_STRING, ID_JOB_EDITSPEC );
popMenu.AppendMenu(MF_ENABLED | MF_STRING, ID_JOB_DESCRIBE );
popMenu.AppendMenu(MF_ENABLED | MF_STRING, ID_JOB_DELETE );
}
popMenu.AppendMenu(MF_SEPARATOR);
popMenu.AppendMenu(MF_ENABLED | MF_STRING, ID_JOB_SETFILTER );
popMenu.AppendMenu(MF_ENABLED | MF_STRING, ID_JOB_REMOVEFILTER );
popMenu.AppendMenu(MF_SEPARATOR);
popMenu.AppendMenu(MF_ENABLED | MF_STRING, ID_JOB_SETFILEFILTER, LoadStringResource(IDS_FILTER_JOBVIEW) );
if (GET_P4REGPTR()->GetEnableSubChgIntegFilter())
popMenu.AppendMenu(MF_ENABLED | MF_STRING, ID_JOB_SETFILEFILTERINTEG, LoadStringResource(IDS_FILTERINTEG_JOBVIEW) );
popMenu.AppendMenu(MF_ENABLED | MF_STRING, ID_JOB_REMOVEFILEFILTER, LoadStringResource(IDS_JOB_REMOVEFILEFILTER) );
popMenu.AppendMenu(MF_SEPARATOR);
popMenu.AppendMenu(MF_ENABLED | MF_STRING, ID_JOB_CONFIGURE, LoadStringResource(IDS_JOB_CONFIGURE) );
popMenu.AppendMenu(MF_ENABLED | MF_STRING, ID_VIEW_UPDATE, LoadStringResource(IDS_REFRESH));
MainFrame()->AddToolsToContextMenu(&popMenu);
popMenu.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y, AfxGetMainWnd());
}
/*
_________________________________________________________________
*/
void CJobListCtrl::OnUpdateJobDelete(CCmdUI* pCmdUI)
{
pCmdUI->Enable( OnUpdateShowMenuItem( pCmdUI, IDS_DELETE_s ) );
}
void CJobListCtrl::OnJobDelete()
{
OnDelete( P4JOB_DEL );
}
/*
_________________________________________________________________
*/
void CJobListCtrl::OnUpdateJobEditspec( CCmdUI* pCmdUI )
{
pCmdUI->Enable( OnUpdateShowMenuItem(pCmdUI, IDS_EDITSPEC_s) && !m_EditInProgress );
}
void CJobListCtrl::EditTheSpec(CString *name)
{
OnJobEditspec(name);
}
void CJobListCtrl::OnJobEditspec()
{
CString str = GetSelectedItemText();
OnJobEditspec(&str);
}
void CJobListCtrl::OnJobEditspec(CString *jobname)
{
m_Active = *jobname;
m_NewJob = FALSE;
EditSpec( ) ;
}
void CJobListCtrl::OnJobNew()
{
MainFrame()->ViewJobs();
if (SERVER_BUSY())
m_Need2DoNew = TRUE;
else
{
m_Need2DoNew = FALSE;
m_Active.Empty();
m_NewJob = TRUE;
EditSpec( ) ;
}
}
void CJobListCtrl::EditSpec()
{
if (m_EditInProgress)
{
CantEditRightNow(IDS_JOB);
return;
}
m_pNewSpec = new CP4Job;
CCmd_EditSpec *pCmd = new CCmd_EditSpec;
pCmd->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK );
if( pCmd->Run( P4JOB_SPEC, m_Active, m_pNewSpec ) )//fanny:is this okay for edit and new?
MainFrame()->UpdateStatus( LoadStringResource(IDS_EDITING_JOB_SPEC) );
else
{
delete pCmd;
delete m_pNewSpec;
}
}
LRESULT CJobListCtrl::OnP4JobSpec(WPARAM wParam, LPARAM lParam)
{
CCmd_EditSpec *pCmd= (CCmd_EditSpec *) wParam;
// let the dialogbox know whether this is a new job or an edit of an existing one
pCmd->SetIsRequestingNew(m_NewJob);
pCmd->SetCaller(DYNAMIC_DOWNCAST(CView, GetParent()));
if(!pCmd->GetError() && !m_EditInProgress && pCmd->DoSpecDlg(this))
{
m_EditInProgress = TRUE;
m_EditInProgressWnd = pCmd->GetSpecSheet();
}
else
{
delete m_pNewSpec;
if (pCmd->HaveServerLock())
pCmd->ReleaseServerLock();
delete pCmd;
}
MainFrame()->ClearStatus();
return 0;
}
LRESULT CJobListCtrl::OnP4EndSpecEdit( WPARAM wParam, LPARAM lParam )
{
CCmd_EditSpec *pCmd= (CCmd_EditSpec *) wParam;
int index;
if (lParam != IDCANCEL && lParam != IDABORT && lParam != IDRETRY)
{
m_pNewSpec->SetJobName(pCmd->GetNewJobName());
if(m_NewJob)
{
LPCTSTR statustext = m_pNewSpec->GetStatusText();
if (!*statustext)
m_pNewSpec->SetJobStatus(JOB_OPEN);
}
m_pNewSpec->ConvertToColumns(m_ColCodes, m_ColNames, m_FieldNames);
if(m_NewJob & (FindInList(pCmd->GetNewJobName()) == -1) )
{
InsertJob(m_pNewSpec, GetItemCount());
ReSort();
index= FindInList(pCmd->GetNewJobName());
}
else
{
index= FindInList(pCmd->GetNewJobName());
if (index != -1)
UpdateJob(m_pNewSpec, index);
else if (m_ColNames.GetSize()) // Has job pane been initialized?
{
InsertJob(m_pNewSpec, GetItemCount());
ReSort();
index= FindInList(pCmd->GetNewJobName());
}
else
delete m_pNewSpec;
}
EnsureVisible( index, TRUE );
SetItemState( index, LVIS_SELECTED|LVIS_FOCUSED, LVIS_SELECTED|LVIS_FOCUSED );
}
else
delete m_pNewSpec;
if (lParam != IDABORT)
{
MainFrame()->ClearStatus();
if (pCmd->HaveServerLock())
pCmd->ReleaseServerLock();
CDialog *dlg = (CDialog *)pCmd->GetSpecSheet();
dlg->DestroyWindow();
}
delete pCmd;
m_EditInProgress = FALSE;
return 0;
}
//////////////////////////////////////////////////////////////////////////
// Sort callback, not in class
int CJobListCtrl::OnCompareItems(LPARAM lParam1, LPARAM lParam2, int subItem)
{
ASSERT(lParam1 && lParam2);
CString txt1= ((CP4Job const *)lParam1)->GetJobField(subItem);
CString txt2= ((CP4Job const *)lParam2)->GetJobField(subItem);
int rc;
if(m_SortAscending)
rc = txt1.Compare(txt2);
else
rc = txt2.Compare(txt1);
return rc;
}
/*
_________________________________________________________________
*/
void CJobListCtrl::OnDeleteitem(NMHDR* pNMHDR, LRESULT* pResult)
{
NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
delete (CP4Job *) GetItemData(pNMListView->iItem);
*pResult = 0;
}
/*
_________________________________________________________________
*/
void CJobListCtrl::OnUpdateJobSetFilter(CCmdUI* pCmdUI)
{
pCmdUI->SetText ( LoadStringResource( IDS_FILTER ) );
pCmdUI->Enable(MainFrame()->SetMenuIcon(pCmdUI, GET_SERVERLEVEL() > 3 && !SERVER_BUSY()));
}
LRESULT CJobListCtrl::OnJobFilter2(WPARAM, LPARAM)
{
OnJobSetFilter();
return 0;
}
void CJobListCtrl::OnJobSetFilter()
{
RECT rect;
CJobFilter dlg;
dlg.SetFilterString ( m_sFilter );
GetWindowRect(&rect); // we want to position filter dialog box
dlg.m_top = rect.top + GetSystemMetrics(SM_CYCAPTION); // at the top left of this pane, so pass
dlg.m_left = rect.left + 2; // it our current screen location
dlg.m_right= rect.right;
MainFrame()->DoNotAutoPoll();
dlg.DoModal( );
MainFrame()->ResumeAutoPoll();
if ( m_sFilter != dlg.GetFilterString ( ) )
{
m_sFilter = dlg.GetFilterString ( );
PersistentJobFilter( KEY_WRITE );
OnViewUpdate( );
}
}
void CJobListCtrl::OnUpdateJobRemovefilter(CCmdUI* pCmdUI)
{
pCmdUI->SetText ( LoadStringResource( IDS_CLEARFILTER ) );
pCmdUI->Enable(MainFrame()->SetMenuIcon(pCmdUI, GET_SERVERLEVEL() > 3
&& !SERVER_BUSY() && !m_sFilter.IsEmpty()));
}
void CJobListCtrl::OnJobRemovefilter()
{
m_sFilter.Empty ( );
PersistentJobFilter( KEY_WRITE );
OnViewUpdate( );
}
void CJobListCtrl::PersistentJobFilter( REGSAM accessmask )
{
HKEY hKey = NULL;
CString sKey = _T("Software\\Perforce\\P4Win\\");
CString sEntry = _T("JobFilter");
DWORD disposition;
if ( RegCreateKeyEx( HKEY_CURRENT_USER, sKey,
0, NULL,
REG_OPTION_NON_VOLATILE,
accessmask, NULL,
&hKey, &disposition ) == ERROR_SUCCESS )
{
const DWORD lenFilter = 512;
if ( accessmask == KEY_WRITE )
{
RegSetValueEx( hKey, sEntry, NULL, REG_SZ
, (LPBYTE)(LPCTSTR) m_sFilter, m_sFilter.GetLength( ) * sizeof(TCHAR) + 1);
}
else
{
TCHAR buf[ lenFilter ];
DWORD cbData = sizeof(buf);
if ( (RegQueryValueEx( hKey, sEntry, NULL, NULL,
(LPBYTE)buf, &cbData ) == ERROR_SUCCESS) && cbData )
{
if(!cbData)
cbData = 1;
buf[cbData-1] = _T('\0');
m_sFilter = buf;
}
}
RegCloseKey( hKey );
}
}
void CJobListCtrl::OnUpdateJobConfigure(CCmdUI* pCmdUI)
{
pCmdUI->Enable(MainFrame()->SetMenuIcon(pCmdUI, !SERVER_BUSY()));
}
int CJobListCtrl::GetFieldNbr( CString str, const CString &spec )
{
// Get the field names from the spec. they are between the word
// "Fields:" and the word "Required" strip the separator. Don't
// crash if the jobspec is not recognized.
CString errorText;
CString fields;
int start= spec.Find(_T("Fields:")) + lstrlen(_T("Fields:"));
int end= spec.Find(_T("Required:"));
if( start == -1 || end == -1 || end < start || end >= spec.GetLength())
errorText=LoadStringResource(IDS_UNABLE_TO_FIND_FIELD_DELIMITERS);
if( errorText.IsEmpty() )
{
fields = spec.Mid(start, end - start);
start= fields.Find( _T('\t') );
if( start == -1 )
errorText=LoadStringResource(IDS_UNABLE_TO_FIND_INITIAL_FIELD_DELIMITER);
}
if( errorText.IsEmpty() )
{
fields = fields.Mid( start + 1 );
// Pick out the requested field names if present
int code;
CString field;
do
{
// get the field spec (e.g., "101 Job word 32")
// and truncate the fields.
//
field = fields.Left ( fields.Find( _T('\n') ) + 1 );
fields = fields.Right ( fields.GetLength( ) - field.Find ( _T('\n') ) - 1 );
// get the "101" part of the spec in code
// and the "Job" part in field.
//
int i = field.Find( _T(' ') );
if (i == -1)
return 0x7FFF;
code = _ttoi ( field.Left ( i ) ) ;
field = field.Right ( field.GetLength ( ) - field.Find( _T(' ') ) - 1 );
field = field.Left ( field.Find ( _T(' ') ) );
if (str == field)
return code;
}
while ( !field.IsEmpty( ) );
}
if( !errorText.IsEmpty() )
{
// Very unlikely that we will ever report this error, but an error
// message is always preferable to an inexplicable crash
AddToStatus(CString(_T("JobView::GetFldNbr()") + errorText), SV_ERROR);
}
return 0x7FFF;
}
void CJobListCtrl::OnJobConfigure()
{
int rc;
CJobsConfigure dlg;
int maxcols = m_ColNames.GetSize();
if (!maxcols && !m_Need2CallOnJobConfigure)
{
m_Need2CallOnJobConfigure = TRUE;
GetJobSpec( );
return;
}
m_Need2CallOnJobConfigure = FALSE;
CStringArray colNames;
colNames.SetSize(maxcols);
CArray<int, int> colWidths;
colWidths.SetSize(maxcols);
int subItem;
for(subItem=0; subItem < maxcols; subItem++)
{
dlg.m_ColNames += m_ColNames.GetAt(subItem) + _T(' ');
colWidths.SetAt(subItem, GetColumnWidth(subItem));
colNames.SetAt(subItem, m_ColNames.GetAt(subItem));
}
int maxflds = m_SpecNames.GetSize();
for(subItem=0; subItem < maxflds; subItem++)
dlg.m_SpecNames += m_SpecNames.GetAt(subItem) + _T(' ');
if ((rc = dlg.DoModal( )) != IDCANCEL)
{
BOOL need2save = FALSE;
CString newWidths;
CString newSorts;
if (rc == IDOK)
{
int i, j;
CString num;
CString newNames;
int newSortCols[MAX_SORT_COLUMNS] = {0,0,0,0};
int tokenctr = 1;
CTokenString tokstr;
CString token;
tokstr.Create(dlg.m_ColNames);
tokstr.PrepareParse( );
token=tokstr.GetToken();
while(!token.IsEmpty())
{
num = _T("50");
for (i = -1; ++i < maxcols; )
{
if (m_ColNames.GetAt(i) == token)
{
int k;
for (k=-1; ++k < maxcols; )
{
if (colNames.GetAt(k) == token)
break;
}
if (k < maxcols)
num.Format(_T("%d"), colWidths.GetAt(k));
for (j=-1, ++i; ++j < MAX_SORT_COLUMNS; )
{
if (abs(m_SortColumns[j]) == i)
{
newSortCols[j] = m_SortColumns[j] < 0 ? -tokenctr : tokenctr;
break;
}
}
break;
}
}
if(!newWidths.IsEmpty())
newWidths += _T(",");
newWidths += num;
int n = GetFieldNbr(token, m_Spec);
if (n < 106)
token.Format(_T(":%d"), n);
newNames += token + _T(' ');
token=tokstr.GetToken();
tokenctr++;
}
SaveColumnNames(newNames, _T("Job List"));
for (i = -1; ++i < MAX_SORT_COLUMNS; )
{
num.Format(_T("%d"), newSortCols[i]);
if(i)
newSorts+=_T(",");
newSorts+=num;
}
need2save = TRUE;
}
else if (rc == IDIGNORE)
{
DeleteColumnNames(_T("Job List"));
newWidths = _T("90,80,60,90,200");
newSorts = _T("-1,0,0,0");
need2save = TRUE;
}
if (need2save)
{
// Save the column widths
CString theKey = sRegKey;
CRegKeyEx key;
if(ERROR_SUCCESS == key.Create(HKEY_CURRENT_USER, theKey))
{
key.SetValueString(newWidths, sRegValue_ColumnWidths);
key.SetValueString(newSorts, sRegValue_SortColumns);
m_ReadSavedWidths = FALSE;
}
}
m_DesiredCols.RemoveAll();
m_DesiredCols.SetSize(0);
m_FastJobs = GetSavedColumnNames(m_DesiredCols, _T("Job List"));
m_FieldNames.SetSize(0);
GetFldNames( m_FieldNames, m_Spec );
OnViewUpdate( );
}
}
void CJobListCtrl::OnDescribeJob()
{
// let user type in the job name. if it's blank the user bailed.
//
CJobDescribe dlg;
dlg.m_JobStr = m_Describing;
if( dlg.DoModal( ) == IDCANCEL )
return;
m_Describing = dlg.GetJobStr( ) ;
if ( m_Describing.IsEmpty( ) )
return;
m_Active = GetSelectedItemText(); // so we can see whether to show the Edit button or not
CCmd_Describe *pCmd= new CCmd_Describe;
pCmd->Init( m_hWnd, RUN_ASYNC);
if( pCmd->Run( P4JOB_SPEC, m_Describing) )
MainFrame()->UpdateStatus(LoadStringResource(IDS_FETCHING_JOB_SPEC));
else
delete pCmd;
}
BOOL CJobListCtrl::TryDragDrop( )
{
// Store the job this is from
m_DragFromItemName = GetSelectedItemText();
m_OLESource.DelayRenderData( (unsigned short) m_CF_JOB);
return m_OLESource.DoDragDrop(DROPEFFECT_COPY, &m_DragSourceRect, NULL)
== DROPEFFECT_NONE ? FALSE : TRUE;
}
/////////////////////////////////////////////////////////////////////
// OLE drag-drop support, to accept depot files or folders
// or accept user or client names which will
// define a view to be used to filter the submitted
// changes that this window displays.
// Also can drop Jobs to be Fixed.
/////////////////////////////////////////////////////////////////////
DROPEFFECT CJobListCtrl::OnDragEnter(COleDataObject* pDataObject, DWORD dwKeyState, CPoint point)
{
m_DropEffect=DROPEFFECT_NONE;
m_DragDataFormat=0;
// Dont allow a drop if the server is busy, since a drop immediately attempts to
// invoke a server command
if(SERVER_BUSY())
return DROPEFFECT_NONE;
if(pDataObject->IsDataAvailable( (unsigned short) m_CF_DEPOT))
{
m_DropEffect=DROPEFFECT_COPY;
m_DragDataFormat=m_CF_DEPOT;
}
#ifdef UNICODE
else if(pDataObject->IsDataAvailable( (unsigned short) CF_UNICODETEXT))
{
m_DropEffect=DROPEFFECT_COPY;
m_DragDataFormat=CF_UNICODETEXT;
}
#else
else if(pDataObject->IsDataAvailable( (unsigned short) CF_TEXT))
{
m_DropEffect=DROPEFFECT_COPY;
m_DragDataFormat=CF_TEXT;
}
#endif
return m_DropEffect;
}
DROPEFFECT CJobListCtrl::OnDragOver(COleDataObject* pDataObject, DWORD dwKeyState, CPoint point)
{
// Dont allow a drop if the server is busy, since a drop immediately attempts to
// invoke a server command
if(SERVER_BUSY())
m_DropEffect= DROPEFFECT_NONE;
return m_DropEffect;
}
BOOL CJobListCtrl::OnDrop(COleDataObject* pDataObject, DROPEFFECT dropEffect, CPoint point)
{
CString fname;
if(SERVER_BUSY())
{
// OnDragEnter() and OnDragOver() should avoid a drop at
// the wrong time!
ASSERT(0);
return FALSE;
}
if(m_DragDataFormat == m_CF_DEPOT)
{
ClientToScreen(&point);
::SendMessage(m_depotWnd, WM_DROPTARGET, JOBVIEW, MAKELPARAM(point.x,point.y));
return TRUE;
}
#ifdef UNICODE
if(m_DragDataFormat == CF_UNICODETEXT)
{
HGLOBAL hGlob = pDataObject->GetGlobalData(CF_UNICODETEXT);
#else
if(m_DragDataFormat == CF_TEXT)
{
HGLOBAL hGlob = pDataObject->GetGlobalData(CF_TEXT);
#endif
LPCTSTR p;
if ((hGlob != NULL) && ((p = (LPCTSTR)::GlobalLock(hGlob)) != NULL))
{
CString itemStr = p;
::GlobalUnlock(hGlob);
OnEditPaste( itemStr );
}
return TRUE;
}
// Return false, so depot window doesnt start a file-open operation
return FALSE;
}
int CJobListCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CP4ListCtrl::OnCreate(lpCreateStruct) == -1)
return -1;
m_sFilter.Empty( );
PersistentJobFilter( KEY_READ );
return 0;
}
void CJobListCtrl::OnJobSetFileFilter()
{
if( !SERVER_BUSY() )
{
::SendMessage(m_depotWnd, WM_GETSELLIST, (WPARAM) &m_FilterView, 0);
m_FilterIncIntegs = FALSE;
OnViewUpdate();
}
}
void CJobListCtrl::OnJobSetFileFilterInteg()
{
if( !SERVER_BUSY() )
{
::SendMessage(m_depotWnd, WM_GETSELLIST, (WPARAM) &m_FilterView, 0);
m_FilterIncIntegs = GET_P4REGPTR()->GetEnableSubChgIntegFilter();
OnViewUpdate();
}
}
void CJobListCtrl::OnUpdateJobSetFileFilter(CCmdUI* pCmdUI)
{
pCmdUI->Enable( !SERVER_BUSY()
&& (pCmdUI->m_nID != ID_JOB_SETFILEFILTERINTEG
|| GET_P4REGPTR()->GetEnableSubChgIntegFilter())
&& ::SendMessage(m_depotWnd, WM_GETSELCOUNT, 0, 0) > 0 );
}
void CJobListCtrl::OnUpdateJobRemoveFileFilter(CCmdUI* pCmdUI)
{
pCmdUI->Enable(!SERVER_BUSY() && !m_FilterView.IsEmpty());
}
void CJobListCtrl::OnJobRemoveFileFilter()
{
m_FilterView.RemoveAll();
m_FilterIncIntegs = FALSE;
OnViewUpdate( );
}
void CJobListCtrl::OnUpdateSetFilterJobs(CCmdUI* pCmdUI)
{
pCmdUI->Enable( !SERVER_BUSY() &&
// can do expression filtering
(GET_SERVERLEVEL() > 3 ||
// or files selected for filter by files
::SendMessage(m_depotWnd, WM_GETSELCOUNT, 0, 0) > 0 ));
}
void CJobListCtrl::OnUpdateClearFilterJobs(CCmdUI* pCmdUI)
{
pCmdUI->Enable(!SERVER_BUSY() &&
(!m_FilterView.IsEmpty() || !m_sFilter.IsEmpty()));
}
void CJobListCtrl::OnPerforceOptions()
{
MainFrame()->OnPerforceOptions(TRUE, FALSE, IDS_PAGE_JOB);
}