ListDialog::ListDialog() : QDialog()
{
    ui.setupUi(this);

    connect(ui.addButton, SIGNAL(clicked()), this, SLOT(addItem()));
    connect(ui.editButton, SIGNAL(clicked()), this, SLOT(editItem()));
    connect(ui.deleteButton, SIGNAL(clicked()), this, SLOT(deleteItem()));
}

void TeethX::lvMain_KeyDown(Win::Event& e)
{
	LPNMLVKEYDOWN p = (LPNMLVKEYDOWN) e.lParam;
	if (p->wVKey == VK_DELETE)
	{
		deleteItem();
	}
}

void CTabbedInt::reset()
{
	deleteItem(activeTab);
	activeTab = createItem(activeID);
	activeTab->moveTo(pos.topLeft());

	if (active)
		redraw();
}

void MusicSongsSummarizied::contextMenuEvent(QContextMenuEvent *event)
{
    QMenu menu(this);
    menu.setStyleSheet(MusicUIObject::MMenuStyle02);
    menu.addAction(QIcon(":/contextMenu/delete"), tr("deleteItem"), this, SLOT(deleteItem()));
    menu.addAction(QIcon(":/contextMenu/add"), tr("addNewItem"), this, SLOT(addNewItem()));
    menu.addAction(tr("changItemName"), this, SLOT(changItemName()));
    menu.exec(event->globalPos());
}

void
destroyKeyboardInstanceObject (KeyboardInstanceObject *kio) {
  flushKeyEvents(kio);
  if (kio->events.buffer) free(kio->events.buffer);

  deleteItem(kio->kmo->instanceQueue, kio);
  if (kio->kix) destroyKeyboardInstanceExtension(kio->kix);
  free(kio);
}

void JsonDbSortingListModelPrivate::sendNotifications(int partitionIndex, const QVariantMap &v, QJsonDbWatcher::Action action)
{
    if (action == QJsonDbWatcher::Created) {
        addItem(v, partitionIndex);
    } else if (action == QJsonDbWatcher::Removed) {
        deleteItem(v, partitionIndex);
    } else if (action == QJsonDbWatcher::Updated) {
        updateItem(v, partitionIndex);
    }
}

/**
 * Slot for deleting an item called from the popup menu.
 */
void RefactoringAssistant::deleteItem()
{
    QTreeWidgetItem *item = currentItem();
    if (item) {
        UMLObject *o = findUMLObject(item);
        if (o) {
            deleteItem(item, o);
        }
    }
}

void WidgetListEditor::addItem(QWidget *item)
{
  WidgetListItem* widgetListItem = new WidgetListItem(this);
  widgetListItem->setItem(item);
  ui->list->addWidget(widgetListItem);

  connect(widgetListItem, SIGNAL(deleteItem()), this, SLOT(on_deleteItem()));
  connect(widgetListItem, SIGNAL(moveUp()), this, SLOT(on_moveUp()));
  connect(widgetListItem, SIGNAL(moveDown()), this, SLOT(on_moveDown()));
}

/**
 * Xoa tat ca cac item co itemID thuoc list itemIDs.
 * @param itemIDs
 * @return bool
 */
bool ItemDB::deleteAllItem(vector<string> itemIDs, ItemTagDB& itemTagDB) {
    int size = itemIDs.size();
    bool result = true;
    for (int i = 0; i < size; i++) {
        if (!deleteItem(itemIDs[i], itemTagDB)) {
            poco_error_f1(*logger, "deleteAllItem: Error to delete ItemID = %s", itemIDs[i]);
            result = false;
        }
    }
    return result;
}

void BST::deleteItem(TreeNode *& treePtr,
                                  KeyType searchKey)
                                  throw(TreeException)
// Calls: deleteNodeItem.
{
   if (treePtr == NULL)
      throw TreeException("TreeException: delete failed");  // empty tree

   else if (searchKey == treePtr->item.getKey())
      // item is in the root of some subtree
      deleteNodeItem(treePtr);  // delete the item

   // else search for the item
   else if (searchKey < treePtr->item.getKey())
      // search the left subtree
      deleteItem(treePtr->leftChildPtr, searchKey);

   else  // search the right subtree
      deleteItem(treePtr->rightChildPtr, searchKey);
}  // end deleteItem

bool Q3GList::removeRef( Q3PtrCollection::Item d )
{
    if ( findRef(d) == -1 )
	return false;
    Q3LNode *n = unlink();
    if ( !n )
	return false;
    deleteItem( n->data );
    delete n;
    return true;
}

/*!
  Replaces the item at index \a index with \a d.
*/
bool Q3GList::replaceAt( uint index, Q3PtrCollection::Item d )
{
    Q3LNode *n = locate( index );
    if ( !n )
	return false;
    if ( n->data != d ) {
	deleteItem( n->data );
	n->data = newItem( d );
    }
    return true;
}

int main(int argc, char *argv[])
{


	FILE *file = initFile();
	init(file);
	if(argc == 1){
		printItems();
	} else {


		if(!strcmp(argv[1],"add")){
			if(argc<3){
				printf("Usage: todo add [<priority>] <text>\n");
			} else {
				insertItem(argv,argc);
			}
		}

		if(!strcmp(argv[1],"del")){
			if(argc<3){
				printf("Usage: todo del <id>\n");
			} else {
				deleteItem(atoi(argv[2]));
			}
		}

		if(!strcmp(argv[1],"swap")){
			if(argc<4){
				printf("Usage: todo swap <id1> <id2>\n");
			} else {
				swapIDs(atoi(argv[2]), atoi(argv[3]));
			}
		}

		/*
		if(!strcmp(argv[1],"prio")){
			if(argc < 4){
				printf("Usage: todo prio <id> <new_prio>\n");
			} else {
				changePrio(atoi(argv[2]), atoi(argv[3]));

			}


		}
		*/
	}
	cleanUp();



	return 0;
}

void UserFunctionListWidget::keyPressEvent(QKeyEvent* event)
{
    if (event->key() == Qt::Key_Delete)
        deleteItem();
    else if (event->key() == Qt::Key_E)
        editItem();
    else {
        QWidget::keyPressEvent(event);
        return;
    }
    event->accept();
}

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    ui->progressBar->setVisible(false);
    ui->widthSpinBox->setValue(Settings::instance()->width());
    ui->heightSpinBox->setValue(Settings::instance()->height());

    new QShortcut(QKeySequence(Qt::Key_Delete), this, SLOT(deleteItem()));
}

void LoLEngine::updateObjectFlightPosition(FlyingObject *t) {
	if (t->objectType == 0) {
		setItemPosition(t->item, t->x, t->y, t->flyingHeight, (t->flyingHeight == 0) ? 1 : 0);
	} else if (t->objectType == 1) {
		if (t->flyingHeight == 0) {
			deleteItem(t->item);
			checkSceneUpdateNeed(calcBlockIndex(t->x, t->y));
		} else {
			setItemPosition(t->item, t->x, t->y, t->flyingHeight, 0);
		}
	}
}

void QGVector::clear()				// clear vector
{
    if ( vec ) {
	for ( uint i=0; i<len; i++ ) {		// delete each item
	    if ( vec[i] )
		deleteItem( vec[i] );
	}
	DELETE(vec);
	vec = 0;
	len = numItems = 0;
    }
}

void AdBlockTreeWidget::removeRule()
{
    QTreeWidgetItem* item = currentItem();
    if (!item || !m_subscription->canEditRules() || item == m_topItem) {
        return;
    }

    int offset = item->data(0, Qt::UserRole + 10).toInt();

    m_subscription->removeRule(offset);
    deleteItem(item);
}

void ToDoPapers::cleanAndRefresh()
{
    while( !p->items.isEmpty() )
        deleteItem(p->items.first());

    const QString & text = p->text;

    int lastPos = 0;
    int pos = text.indexOf("\n",lastPos);
    while( pos != text.length() )
    {
        if( pos == -1 )
            pos = text.length();

        const QString & str = text.mid(lastPos,pos-lastPos);
        const QString & slc = str.mid(0,2);
        bool checkable = (slc=="* " || slc=="- ");

        if( !checkable && !p->items.isEmpty() )
        {
            p->signal_blocker = true;
            ToDoPapersItem *item = p->items.last();
            item->setText( item->text() + "\n" + str );
            p->signal_blocker = false;
        }
        else
        {
            ToDoPapersItem *item = new ToDoPapersItem(this);
            item->setCheckable(checkable);
            item->setText( checkable? str.mid(2) : str );
            item->setChecked( slc=="* " );

            connect( item, SIGNAL(textChanged())   , SLOT(refreshText()) );
            connect( item, SIGNAL(checkedChanged()), SLOT(refreshText()) );

            connect( item, SIGNAL(accepted(ToDoPapersItem*))  , SLOT(createItemAfter(ToDoPapersItem*)) );
            connect( item, SIGNAL(removed(ToDoPapersItem*))   , SLOT(removeItem(ToDoPapersItem*))      );
            connect( item, SIGNAL(removeNext(ToDoPapersItem*)), SLOT(removeNextItem(ToDoPapersItem*))  );

            connect( item, SIGNAL(upPressed(ToDoPapersItem*))  , SLOT(focusOnUp(ToDoPapersItem*))   );
            connect( item, SIGNAL(downPressed(ToDoPapersItem*)), SLOT(focusOnDown(ToDoPapersItem*)) );

            p->items << item;
            p->base_layout->insertWidget(p->base_layout->count()-1,item);
            item->show();
        }

        lastPos = pos+1;
        if( pos != text.length() )
            pos = text.indexOf("\n",lastPos);
    }
}

void Column::updatePos(qreal t)
{
    qreal newX = pos().x() + v * t;
    qreal newY = pos().y();
    if (newX + boundingRect().width() < 0)
    {
        emit deleteItem(this);
    }
    else
    {
        setPos(newX, newY);
    }
}