chxavfileui.cpp

来自「著名的 helix realplayer 基于手机 symbian 系统的 播放」· C++ 代码 · 共 1,125 行 · 第 1/3 页

            // file exists; confirm that delete is ok
            TPtrC name = NameFromIndex(idxItem);
	    if(CHXAvMessageDialog::DoQueryL(CHXAvCleanString(R_CONF_OVERWRITE_ITEM_FORMAT, name)()) )
	    {
                // user opts to overwrite target...
                const CHXAvFileStore::Entries& entries = m_spStore->GetEntries();
                const TEntry& entry = entries[idxItem].m_entry;
	        err = m_spStore->MoveItemL(idxItem, pathDest, entry.iName, true /*overwrite*/);
	    }
            else
            {
                // user opted not to overwrite target; prompt for new target name
                err = DoPromptMoveItemHelperL(pathDest, idxItem);
            }
        }
    }

    return err;
}

////////////////////////////////////////////////////////////
// move a file from disk; if successful, delete the name from the
// current list
//
// if successful, 'text items' are updated and 'remove indexes' contains
// indexes of deleted items
//
// pathDest               - absolute or relative to current root
//
// idxItem                - index of item in current folder path
//
TInt CHXAvFileUI::MoveItemHelperL(const TDesC& pathDest, TInt idxItem)
{
    DPRINTF(SYMP_FILE_UI, ("AvFileUI::MoveItemHelperL(): moving item %d to '%s'\n", idxItem, dbg::CharPtr(pathDest)()));
    SUSPEND_REFRESH(m_spStore);

    const CHXAvFileStore::Entries& entries = m_spStore->GetEntries();

    HX_ASSERT(idxItem < entries.Nelements());
    TInt err = KErrGeneral;
    if( idxItem < entries.Nelements())
    {
	HX_ASSERT(m_spStore->PathExistsL(pathDest, KNullDesC));
 
        if(!m_spStore->IsSafeFileNameLengthL(pathDest, idxItem))
        {
            // name can't fit in target path; prompt for safer (smaller) name
            err = DoPromptMoveItemHelperL(pathDest, idxItem);
        }
        else if(m_spStore->NameExistsInTargetPathL(pathDest, idxItem))
	{
            err = DoOverwriteMoveItemHelperL(pathDest, idxItem); 
	}
	else
	{
            const TEntry& entry = entries[idxItem].m_entry;

	    // target doesn't exist; go ahead and move
	    err = m_spStore->MoveItemL(idxItem, pathDest, entry.iName, false /*rename*/);
	}
    }

    HandleDiskFullCase(err);

    return err;
}

////////////////////////////////////////////////////
// prompt user to select a folder via a pop-up 
// folder navigation list
//
// set folder name in working buffer if folder is selected
//
bool CHXAvFileUI::DoGetTargetFolderPathL(TInt resIdPrompt, TInt resIdSelectButton)
{
    m_targetFolderPath.Zero();

    CHXAvPathSelector selector;
    selector.InitL(m_playerUI->GetMediaStoreInfoL(), resIdPrompt, resIdSelectButton);

    bool bSelected = selector.PromptUserSelectPathL();
    if( bSelected )
    {
        m_targetFolderPath.Copy(selector.GetSelectedPath());
    }

    return bSelected;
    
}


////////////////////////////////////////////////////////////
// delete selected item
//
// return KErrCancel if user cancels
//
TInt CHXAvFileUI::DoDeleteItemL(TInt idxItem)
{
    TInt err = KErrCancel;
    SUSPEND_REFRESH(m_spStore);

    const CHXAvFileStore::Entries& entries = m_spStore->GetEntries();
    const TEntry& entry = entries[idxItem].m_entry;

    bool bUserConfirmed = false;
    if( entry.IsDir() )
    {
        bUserConfirmed = CHXAvMessageDialog::DoQueryL(R_CONF_DELETE_FOLDER);
    }
    else
    {
        TPtrC name = NameFromIndex(idxItem);
        bUserConfirmed = CHXAvMessageDialog::DoQueryL(CHXAvCleanString(R_CONF_DELETE_ITEM_FORMAT, name)());
    }
    
    if( bUserConfirmed )
    {
        CHXAvCleanString msg(R_NOW_DELETING_ITEM_FORMAT, NameFromIndex(idxItem));
        //CHXAvCleanString msg(R_NOW_DELETING);
        m_spWaitNote->SetTextL(msg());
        //EnableWaitNoteCancelButtonL(true);
        m_spWaitNote->StartAndKickL();
        
    	err = m_spStore->DeleteItemL(idxItem);
        m_spWaitNote->EndL();
	if(IsNonCancelError(err))
	{
            CHXAvMessageDialog::DoAlertErrorL(CHXAvCleanString(R_ERR_DELETE_FAILED)());
	}
    }

    return err;
}

////////////////////////////////////////////////////////////
// delete multiple items (query just once)
//
// only files (not folder) may be deleted this way
//
// return KErrCancel if user cancels
//
TInt CHXAvFileUI::DoDeleteItemsL(const CArrayFix<TInt>& items)
{
    SUSPEND_REFRESH(m_spStore);
    
    TInt count = items.Count();

    //
    // confirm with user
    //
    bool bUserConfirmed = false;
    if( 1 == count )
    {
        TPtrC name = NameFromIndex(items[0]);
        bUserConfirmed = CHXAvMessageDialog::DoQueryL(CHXAvCleanString(R_CONF_DELETE_ITEM_FORMAT, name)());
    }
    else
    {
        bUserConfirmed = CHXAvMessageDialog::DoQueryL(CHXAvCleanString(R_CONF_DELETE_MULT_ITEMS_FORMAT, count)());
    }

    //
    // do the deed if user said 'ok'
    //
    TInt err = KErrCancel;
    if(bUserConfirmed)
    {
        
        m_spWaitNote->SetTextL(CHXAvCleanString(R_NOW_DELETING_MULT_ITEMS_FORMAT, count)());
        //EnableWaitNoteCancelButtonL(true);
        m_spWaitNote->StartAndKickL();

	for( TInt idx = 0; idx < count; ++idx )
	{
	    TInt idxDeleteItem = items[idx];
	    HX_ASSERT(!m_spStore->GetEntries()[idxDeleteItem].m_entry.IsDir()); // folders can't be in multiple item list!
	    
	    err = m_spStore->DeleteItemL(idxDeleteItem);
	    if(IsNonCancelError(err))
	    {
		// XXXLCM ask to continue/cancel?
		break;
	    }
	}

        m_spWaitNote->EndL();
        if( IsNonCancelError(err) )
        {
            CHXAvMessageDialog::DoAlertErrorL(CHXAvCleanString(R_ERR_DELETE_FAILED)());	   
        }

    }

    return err;
}

////////////////////////////////////////////////////
// show error message if err indicates disk full
void CHXAvFileUI::HandleDiskFullCase(TInt err)
{
    // display error message if copy failed due to low disk space
    if( KErrDiskFull == err || KErrNoMemory == err)
    {
        CHXAvMessageDialog::DoSystemErrorNoteL(err);
    }
}

////////////////////////////////////////////////////
// prompt user for a new name for the currently
// hilighted file or folder
//
TInt CHXAvFileUI::DoRenameL(TInt idxItem, TInt resIdPrompt)
{
    DPRINTF(SYMP_FILE_UI, ("CHXAvFileUI::DoRenameL(): idx = \n", idxItem));

    SUSPEND_REFRESH(m_spStore);

    const CHXAvFileStore::Entries& entries = m_spStore->GetEntries();

    HX_ASSERT(idxItem < entries.Nelements());
    const TEntry& entry = entries[idxItem].m_entry;

    TInt err = KErrGeneral;
    TUint flags = 0;
    if(entry.IsDir())
    {
        flags |= fWantFolder;
    }

    // get new file name...
    QueryTargetNameResult res = QueryTargetNameL(CHXAvCleanString(resIdPrompt)(), 
				m_spStore->GetCurrentPath(), 
				entry.iName, flags); 
    switch (res)
    {
        case qtrUnique:
        case qtrOverwrite:
            // got name...
	    err = m_spStore->MoveItemL(idxItem, m_nameBuf, res == qtrOverwrite, true /*use rename*/);
            break;
        case qtrAbort:
	    // user canceled
	    err = KErrCancel;
            break;
        default:
            err = KErrGeneral;
            break;
    }

    if(IsNonCancelError(err))
    {
        HandleDiskFullCase(err);
        CHXAvMessageDialog::DoAlertErrorL(CHXAvCleanString(R_ERR_RENAME_FAILED)());
    }

    DPRINTF(SYMP_FILE_UI, ("CHXAvFileUI::DoRenameL(): exit\n"));
    return err;
}

////////////////////////////////////////
// query folder name, then do save link
// to that folder
TInt
CHXAvFileUI::DoCreateLinkL(const CHXString& url, const TDesC& defaultName)
{
    TInt err = KErrCancel;
    bool bGotIt = DoGetTargetFolderPathL(R_PROMPT_SAVE_TO, R_AVP_SAVE_BUTTON_TEXT);
    if(bGotIt)
    {
	err = DoCreateLinkL(m_targetFolderPath, url, defaultName);
    }
    return err;
}
////////////////////////////////////////
// create a link file pointing to the given
// URL in the given folder
//
// return KErrCancel if user cancels
//
TInt
CHXAvFileUI::DoCreateLinkL(const TDesC& folder, 
			   const CHXString& url, 
                           const TDesC& defaultName)
{  
    TInt err = KErrGeneral;

    TFileName* pDefaultName = CHXAvFile::AllocFileNameL(defaultName);
    AUTO_PUSH_POP_DEL(pDefaultName);
    if( pDefaultName->Length() == 0 )
    {
        // no default name given...
        CHXAvCleanString lastResortName(R_DEFAULT_NEW_LINK_NAME);
        pDefaultName->Copy(lastResortName());
    }
    pDefaultName->Append(CHXAvUtil::KLinkFileExt);

    // get a unique name within destination folder
    QueryTargetNameResult res = QueryTargetNameL(CHXAvCleanString(R_PROMPT_ENTER_SAVE_NAME)(), 
					folder, *pDefaultName, fSuggestUniqueDefaultName);
    // XXXLCM check for low disk?
    switch (res)
    {
        case qtrUnique:
        case qtrOverwrite:
            // got name...
            {
	        FILE* pFile = m_spStore->OpenFileL(folder, m_nameBuf, "wt");
	        if(pFile)
	        {
	            ::fprintf(pFile, "%s\n", static_cast<const char*>(url));
	            ::fclose(pFile);
                    err = KErrNone;
                    CHXAvMessageDialog::DoAlertConfirmL(CHXAvCleanString(R_INFO_LINK_SAVED)());
	        }
                else
                {
                    err = KErrGeneral;
                }
            }
            break;
        case qtrAbort:
	    // user canceled
	    err = KErrCancel;
            break;
        default:
            err = KErrGeneral;
            break;
    }

    if( IsNonCancelError(err) )
    {
        HandleDiskFullCase(err);
        CHXAvMessageDialog::DoAlertErrorL(CHXAvCleanString(R_ERR_CREATE_LINK_FAILED)());
    }

    return err;
}

void CHXAvFileUI::UserCancelPendingFileOp()
{
    DPRINTF(SYMP_FILE_UI, ("CHXAvFileUI::UserCancelPendingFileOp()\n"));
    m_bIsCancelOpPending = true;
#if defined(ASYNC_COPYMOVE)
    m_spStore->CancelAsyncFileOp();
#endif
}

void CHXAvFileUI::OnFileOpStart(FileStoreOperationObserver::OperationType type, const TDesC& source, const TDesC& target)
{
    //DPRINTF(SYMP_FILE_UI, ("CHXAvFileUI::OnFileOpStart(): op = %d; src = '%s'; dst = '%s'\n", type,  dbg::CharPtr(source)(), dbg::CharPtr(target)()));
    m_bIsCancelOpPending = false;
}

bool CHXAvFileUI::OnFileOpTick(FileStoreOperationObserver::OperationType type, const TDesC& source, const TDesC& target, TInt64 cbCopied)
{
    //DPRINTF(SYMP_FILE_UI, ("CHXAvFileUI::OnFileOpTick(): op = %d; src = '%s'; dst = '%s'; cb = %lu\n", type,  dbg::CharPtr(source)(), dbg::CharPtr(target)(), cbCopied.Low()));
    return !m_bIsCancelOpPending;
}

void CHXAvFileUI::OnFileOpEnd(FileStoreOperationObserver::OperationType type, TInt err, const TDesC& source, const TDesC& target)
{
    //DPRINTF(SYMP_FILE_UI, ("CHXAvFileUI::OnFileOpEnd(): op = %d; err = %d, src = '%s'; dst = '%s'\n", type, err, dbg::CharPtr(source)(), dbg::CharPtr(target)()));
    
    m_bIsCancelOpPending = false;
}