void CGitProgressList::AddNotify(NotificationData* data, CColors::Colors color)
{
if (color != CColors::COLOR_END)
data->color = m_Colors.GetColor(color);
else
data->SetColorCode(m_Colors);
m_arData.push_back(data);
AddItemToList();
if ((!data->bAuxItem) && (m_itemCount > 0))
{
if (m_pProgControl)
{
m_pProgControl->ShowWindow(SW_SHOW);
m_pProgControl->SetPos(m_itemCount);
m_pProgControl->SetRange32(0, m_itemCountTotal);
}
if (m_pTaskbarList && m_pPostWnd)
{
m_pTaskbarList->SetProgressState(m_pPostWnd->GetSafeHwnd(), TBPF_NORMAL);
m_pTaskbarList->SetProgressValue(m_pPostWnd->GetSafeHwnd(), m_itemCount, m_itemCountTotal);
}
}
// needed as long as RemoteProgressCommand::RemoteCompletionCallback never gets called by libgit2
if (m_pAnimate)
m_pAnimate->ShowWindow(SW_HIDE);
}
void TaskEditor::PopulateChildren()
{
LOGN_DEBUG("taskeditor.cpp", "Populate Children");
mChildrenView->clear();
mChildrenView->setColumnCount(2);
mChildrenView->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
mChildrenView->horizontalHeader()->setFixedHeight(20);
mChildrenView->verticalHeader()->setHidden(true);
QStringList names;
names.push_back(tr("Name"));
names.push_back(tr("Task Type"));
mChildrenView->setHorizontalHeaderLabels(names);
names.clear();
if (mChildrenView->currentItem() == NULL)
{
DisableEditButtons();
}
else
{
mChildrenView->setItemSelected(mChildrenView->currentItem(), true);
}
dtDAL::Map* m = EditorData::GetInstance().getCurrentMap();
if (m == NULL)
{
LOG_ERROR("Unable read the children of a task actor without a valid current map.");
return;
}
dtDAL::Map& currMap = *m;
if (mChildren.valid())
{
std::vector<dtDAL::NamedParameter*> toFill;
mChildren->GetParameters(toFill);
for (unsigned i = 0; i < toFill.size(); ++i)
{
dtDAL::NamedParameter* np = toFill[i];
if (np->GetDataType() == dtDAL::DataType::ACTOR)
{
dtCore::UniqueId id = static_cast<dtDAL::NamedActorParameter*>(np)->GetValue();
dtDAL::ActorProxy* child = currMap.GetProxyById(id);
if (child != NULL)
{
AddItemToList(*child);
}
}
}
BlankRowLabels();
}
}
void TaskEditor::AddSelected()
{
LOGN_DEBUG("taskeditor.cpp", "Add Selected Clicked");
int index = mComboBox->currentIndex();
if (index >= 0)
{
QVariant v = mComboBox->itemData(index);
dtCore::RefPtr<dtDAL::ActorProxy> proxy = v.value<dtCore::RefPtr<dtDAL::ActorProxy> >();
AddItemToList(*proxy);
BlankRowLabels();
//remove the item being added from the removed list, if necessary.
std::set<dtCore::RefPtr<dtDAL::ActorProxy> >::iterator itor = mRemovedTasks.find(proxy);
if (itor != mRemovedTasks.end())
{
mRemovedTasks.erase(itor);
}
RefreshComboBox("");
}
}
//向列表中添加元素
void AddItem(List * plist)
{
Item temp;
puts("Please input the carid:");
scanf("%d",&temp.carid);
delMore();
puts("Please enter the car's trademark:");
gets(temp.trademark);
temp.flag = false;
if(ListIsFull(plist))
{
fprintf(stderr,"List is full!\n");
}
else
{
if(AddItemToList(&temp,plist) == false)
{
fprintf(stderr,"Add item failed!\n");
exit(EXIT_FAILURE);
}
}
}
static BOOL FillStructureFromControls (HWND hwnd, LPGRANTPARAMS lpgrant)
{
int max_item_number;
HWND hwndDatabases = GetDlgItem (hwnd, IDC_GNREF_PROCEDURE_DATABASES);
HWND hwndGrantees = GetDlgItem (hwnd, IDC_GNREF_PROCEDURE_GRANTEES);
HWND hwndProcedures= GetDlgItem (hwnd, IDC_GNREF_PROCEDURE_PROCEDURES);
max_item_number = CAListBox_GetSelCount (hwndProcedures);
if (max_item_number >= 1)
{
lpgrant->lpobject = AddItemToList (hwndProcedures);
if (!lpgrant->lpobject)
{
FreeAttachedPointers (lpgrant, OTLL_GRANT);
ErrorMessage ((UINT) IDS_E_CANNOT_ALLOCATE_MEMORY, RES_ERR);
return FALSE;
}
}
max_item_number = CAListBox_GetSelCount (hwndGrantees);
if (max_item_number >= 1)
{
lpgrant->lpgrantee = AddItemToList (hwndGrantees);
if (!lpgrant->lpgrantee)
{
FreeAttachedPointers (lpgrant, OTLL_GRANT);
ErrorMessage ((UINT)IDS_E_CANNOT_ALLOCATE_MEMORY, RES_ERR);
return FALSE;
}
}
if (Button_GetCheck (GetDlgItem (hwnd, IDC_GNREF_PROCEDURE_USER)))
lpgrant->GranteeType = OT_USER;
else
if (Button_GetCheck (GetDlgItem (hwnd, IDC_GNREF_PROCEDURE_GROUP)))
lpgrant->GranteeType = OT_GROUP;
else
if (Button_GetCheck (GetDlgItem (hwnd, IDC_GNREF_PROCEDURE_ROLE)))
lpgrant->GranteeType = OT_ROLE;
else
if (Button_GetCheck (GetDlgItem (hwnd, IDC_GNREF_PROCEDURE_PUBLIC)))
{
lpgrant->GranteeType = OT_PUBLIC; // Public
FreeObjectList (lpgrant->lpgrantee);
lpgrant->lpgrantee = APublicUser ();
if (!lpgrant->lpgrantee)
{
FreeAttachedPointers (lpgrant, OTLL_GRANT);
ErrorMessage ((UINT)IDS_E_CANNOT_ALLOCATE_MEMORY, RES_ERR);
return FALSE;
}
}
if (lpgrant->ObjectType == OT_SEQUENCE) {
lpgrant->grant_option = FALSE;
lpgrant->Privileges[GRANT_NEXT_SEQUENCE] = TRUE;
return TRUE;
}
lpgrant->grant_option = Button_GetCheck (GetDlgItem (hwnd, IDC_GNREF_PROCEDURE_OPTION));
return TRUE;
}
//================================================================================================
//
// DeviceAdded
//
// This routine is the callback for our IOServiceAddMatchingNotification. When we get called
// we will look at all the devices that were added and we will:
//
// 1. Create some private data to relate to each device (in this case we use the service's name
// and the location ID of the device
// 2. Submit an IOServiceAddInterestNotification of type kIOGeneralInterest for this device,
// using the refCon field to store a pointer to our private data. When we get called with
// this interest notification, we can grab the refCon and access our private data.
//
//================================================================================================
static void DeviceAdded(void *refCon, io_iterator_t iterator) {
kern_return_t kr;
io_service_t usbDevice;
IOCFPlugInInterface **plugInInterface = NULL;
SInt32 score;
HRESULT res;
while((usbDevice = IOIteratorNext(iterator))) {
io_name_t deviceName;
CFStringRef deviceNameAsCFString;
UInt32 locationID;
UInt16 vendorId;
UInt16 productId;
UInt16 addr;
DeviceItem_t* deviceItem = new DeviceItem_t();
// Get the USB device's name.
kr = IORegistryEntryGetName(usbDevice, deviceName);
if(KERN_SUCCESS != kr) {
deviceName[0] = '\0';
}
deviceNameAsCFString = CFStringCreateWithCString(kCFAllocatorDefault, deviceName, kCFStringEncodingASCII);
if(deviceNameAsCFString) {
Boolean result;
char deviceName[MAXPATHLEN];
// Convert from a CFString to a C (NUL-terminated)
result = CFStringGetCString(deviceNameAsCFString,
deviceName,
sizeof(deviceName),
kCFStringEncodingUTF8);
if(result) {
deviceItem->deviceParams.deviceName = deviceName;
}
CFRelease(deviceNameAsCFString);
}
CFStringRef manufacturerAsCFString = (CFStringRef)IORegistryEntrySearchCFProperty(
usbDevice,
kIOServicePlane,
CFSTR(kUSBVendorString),
kCFAllocatorDefault,
kIORegistryIterateRecursively
);
if(manufacturerAsCFString) {
Boolean result;
char manufacturer[MAXPATHLEN];
// Convert from a CFString to a C (NUL-terminated)
result = CFStringGetCString(
manufacturerAsCFString,
manufacturer,
sizeof(manufacturer),
kCFStringEncodingUTF8
);
if(result) {
deviceItem->deviceParams.manufacturer = manufacturer;
}
CFRelease(manufacturerAsCFString);
}
CFStringRef serialNumberAsCFString = (CFStringRef) IORegistryEntrySearchCFProperty(
usbDevice,
kIOServicePlane,
CFSTR(kUSBSerialNumberString),
kCFAllocatorDefault,
kIORegistryIterateRecursively
);
if(serialNumberAsCFString) {
Boolean result;
char serialNumber[MAXPATHLEN];
// Convert from a CFString to a C (NUL-terminated)
result = CFStringGetCString(
serialNumberAsCFString,
serialNumber,
sizeof(serialNumber),
kCFStringEncodingUTF8
);
if(result) {
deviceItem->deviceParams.serialNumber = serialNumber;
}
CFRelease(serialNumberAsCFString);
}
// Now, get the locationID of this device. In order to do this, we need to create an IOUSBDeviceInterface
// for our device. This will create the necessary connections between our userland application and the
// kernel object for the USB Device.
kr = IOCreatePlugInInterfaceForService(usbDevice, kIOUSBDeviceUserClientTypeID, kIOCFPlugInInterfaceID, &plugInInterface, &score);
if((kIOReturnSuccess != kr) || !plugInInterface) {
fprintf(stderr, "IOCreatePlugInInterfaceForService returned 0x%08x.\n", kr);
continue;
}
stDeviceListItem *deviceListItem = new stDeviceListItem();
// Use the plugin interface to retrieve the device interface.
res = (*plugInInterface)->QueryInterface(plugInInterface, CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID), (LPVOID*) &deviceListItem->deviceInterface);
// Now done with the plugin interface.
(*plugInInterface)->Release(plugInInterface);
if(res || deviceListItem->deviceInterface == NULL) {
fprintf(stderr, "QueryInterface returned %d.\n", (int) res);
continue;
}
// Now that we have the IOUSBDeviceInterface, we can call the routines in IOUSBLib.h.
// In this case, fetch the locationID. The locationID uniquely identifies the device
// and will remain the same, even across reboots, so long as the bus topology doesn't change.
kr = (*deviceListItem->deviceInterface)->GetLocationID(deviceListItem->deviceInterface, &locationID);
if(KERN_SUCCESS != kr) {
fprintf(stderr, "GetLocationID returned 0x%08x.\n", kr);
continue;
}
std::stringstream sstream;
sstream << std::hex << locationID;
deviceItem->deviceParams.locationId = sstream.str();
kr = (*deviceListItem->deviceInterface)->GetDeviceAddress(deviceListItem->deviceInterface, &addr);
if(KERN_SUCCESS != kr) {
fprintf(stderr, "GetDeviceAddress returned 0x%08x.\n", kr);
continue;
}
deviceItem->deviceParams.deviceAddress = addr;
kr = (*deviceListItem->deviceInterface)->GetDeviceVendor(deviceListItem->deviceInterface, &vendorId);
if(KERN_SUCCESS != kr) {
fprintf(stderr, "GetDeviceVendor returned 0x%08x.\n", kr);
continue;
}
deviceItem->deviceParams.vendorId = vendorId;
kr = (*deviceListItem->deviceInterface)->GetDeviceProduct(deviceListItem->deviceInterface, &productId);
if(KERN_SUCCESS != kr) {
fprintf(stderr, "GetDeviceProduct returned 0x%08x.\n", kr);
continue;
}
deviceItem->deviceParams.productId = productId;
// Extract path name as unique key
io_string_t pathName;
IORegistryEntryGetPath(usbDevice, kIOServicePlane, pathName);
deviceNameAsCFString = CFStringCreateWithCString(kCFAllocatorDefault, pathName, kCFStringEncodingASCII);
char cPathName[MAXPATHLEN];
if(deviceNameAsCFString) {
Boolean result;
// Convert from a CFString to a C (NUL-terminated)
result = CFStringGetCString(
deviceNameAsCFString,
cPathName,
sizeof(cPathName),
kCFStringEncodingUTF8
);
CFRelease(deviceNameAsCFString);
}
AddItemToList(cPathName, deviceItem);
deviceListItem->deviceItem = deviceItem;
if(initialDeviceImport == false) {
WaitForDeviceHandled();
currentItem = &deviceItem->deviceParams;
isAdded = true;
uv_async_send(&async_handler);
}
// Register for an interest notification of this device being removed. Use a reference to our
// private data as the refCon which will be passed to the notification callback.
kr = IOServiceAddInterestNotification(
gNotifyPort, // notifyPort
usbDevice, // service
kIOGeneralInterest, // interestType
DeviceRemoved, // callback
deviceListItem, // refCon
&(deviceListItem->notification) // notification
);
if(KERN_SUCCESS != kr) {
printf("IOServiceAddInterestNotification returned 0x%08x.\n", kr);
}
// Done with this USB device; release the reference added by IOIteratorNext
kr = IOObjectRelease(usbDevice);
}
}
int MyListCtrl::AddItemToList(ITEMINFO *pItem, int iImage)
{
int nCount= GetItemCount();
return AddItemToList(nCount++,iImage,pItem);
}
/*------------------------------------------------------------------------------*\
InstantiateItem( archive)
- instantiates a filter from the given archive
\*------------------------------------------------------------------------------*/
void BmFilterList::InstantiateItem( BMessage* archive) {
BmFilter* newFilter = new BmFilter( archive, this);
AddItemToList( newFilter);
}
