LOFImportFileHandle Class Reference

An ImportFileHandle for LOF data. More...

Inheritance diagram for LOFImportFileHandle:

Collaboration diagram for LOFImportFileHandle:

Public Member Functions
	LOFImportFileHandle (AudacityProject *pProject, const FilePath &name, std::unique_ptr< wxTextFile > &&file)
	~LOFImportFileHandle ()
TranslatableString	GetFileDescription () override
ByteCount	GetFileUncompressedBytes () override
void	Import (ImportProgressListener &progressListener, WaveTrackFactory *trackFactory, TrackHolders &outTracks, Tags *tags) override
FilePath	GetFilename () const override
void	Cancel () override
void	Stop () override
wxInt32	GetStreamCount () override
const TranslatableStrings &	GetStreamInfo () override
void	SetStreamUsage (wxInt32 WXUNUSED(StreamID), bool WXUNUSED(Use)) override
Public Member Functions inherited from ImportFileHandle
virtual	~ImportFileHandle ()
virtual FilePath	GetFilename () const =0
virtual TranslatableString	GetErrorMessage () const
virtual TranslatableString	GetFileDescription ()=0
virtual ByteCount	GetFileUncompressedBytes ()=0
virtual wxInt32	GetStreamCount ()=0
virtual const TranslatableStrings &	GetStreamInfo ()=0
virtual void	SetStreamUsage (wxInt32 StreamID, bool Use)=0
virtual void	Import (ImportProgressListener &progressListener, WaveTrackFactory *trackFactory, TrackHolders &outTracks, Tags *tags)=0
virtual void	Cancel ()=0
virtual void	Stop ()=0

Private Member Functions
void	lofOpenFiles (wxString *ln)
	Processes a single line from a LOF text file, doing whatever is indicated on the line. More...
void	doDurationAndScrollOffset ()

Private Attributes
std::unique_ptr< wxTextFile >	mTextFile
const wxFileName	mLOFFileName
AudacityProject *	mProject {}
int	nFilesInGroup { 0 }
bool	callDurationFactor { false }
double	durationFactor { 1 }
bool	callScrollOffset { false }
double	scrollOffset { 0 }

Additional Inherited Members
Public Types inherited from ImportFileHandle
using	ByteCount = unsigned long long

Detailed Description

An ImportFileHandle for LOF data.

Supports the opening of ".lof" files which are text files that contain a list of individual files to open in audacity in specific formats. Files may be file names (in the same directory as the LOF file), absolute paths or relative paths relative to the directory of the LOF file.

(In BNF) The syntax for an LOF file, denoted by <lof>:

  <lof> ::= [<window> | <file> | <#>]*
  <window> ::= window [<window-parameter>]* <newline>
  <window-parameter> ::= offset <time> | duration <time>
  <time> ::= [<digit>]+ [ . [<digit>]* ]
  <file> ::= file [<file-parameter>]* <newline>
  <file-parameter> ::= offset <time>
  <#> ::= <comment> <newline>

EXAMPLE LOF file:

  # everything following the hash character is ignored
  window # an initial window command is implicit and optional
  file "C:\folder1\sample1.wav"    # sample1.wav is displayed
  file "C:\sample2.wav" offset 5   # sample2 is displayed with a 5s offset
  File "C:\sample3.wav"            # sample3 is displayed with no offset
  File "foo.aiff" # foo is loaded from the same directory as the LOF file
  window offset 5 duration 10      # open a NEW window, zoom to display
  # 10 seconds total starting at 5 (ending at 15) seconds
  file "C:\sample3.wav" offset 2.5

SEMANTICS:

There are two commands: "window" creates a NEW window, and "file" appends a track to the current window and displays the file there. The first file is always placed in a NEW window, whether or not an initial "window" command is given.

Commands have optional keyword parameters that may be listed in any order. A parameter should only occur once per command. The "offset" parameter specifies a time offset. For windows, this is the leftmost time displayed in the window. For files, the offset is an amount by which the file is shifted in time before display (only enabled for audio; not midi). The offset is specified as an integer or decimal number of seconds, and the default value is zero.

Windows may also have a "duration" parameter, which specifies how much time should be displayed in the window. The default duration is equal to the duration of the longest track currently displayed.

Definition at line 117 of file ImportLOF.cpp.

Constructor & Destructor Documentation

LOFImportFileHandle()

LOFImportFileHandle::LOFImportFileHandle	(	AudacityProject *	pProject,
		const FilePath &	name,
		std::unique_ptr< wxTextFile > &&	file
	)

Definition at line 170 of file ImportLOF.cpp.

:  mTextFile(std::move(file))
   , mLOFFileName{name}
   , mProject{ pProject }
{
}

~LOFImportFileHandle()

LOFImportFileHandle::~LOFImportFileHandle

(

)

Definition at line 576 of file ImportLOF.cpp.

{
}

Member Function Documentation

Cancel()

void LOFImportFileHandle::Cancel ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 329 of file ImportLOF.cpp.

{
   //LOFImport delegates import to other plugins
}

doDurationAndScrollOffset()

void LOFImportFileHandle::doDurationAndScrollOffset ( )

private

Definition at line 550 of file ImportLOF.cpp.

{
   if (!mProject)
      return;
 
   callScrollOffset = callScrollOffset && (scrollOffset != 0);
   bool doSomething = callDurationFactor || callScrollOffset;
 
   if (callDurationFactor)
   {
      double longestDuration = TrackList::Get(*mProject).GetEndTime();
      ProjectWindow::Get( *mProject ).ZoomBy(longestDuration / durationFactor);
      callDurationFactor = false;
   }
 
   if (callScrollOffset)
   {
      ProjectWindow::Get( *mProject ).TP_ScrollWindow(scrollOffset);
      callScrollOffset = false;
   }
 
   if (doSomething)
      // Amend last undo state
      ProjectHistory::Get( *mProject ).ModifyState(false);
}

References callDurationFactor, callScrollOffset, durationFactor, ProjectHistory::Get(), TrackList::Get(), ProjectWindow::Get(), TrackList::GetEndTime(), ProjectHistory::ModifyState(), mProject, scrollOffset, ProjectWindow::TP_ScrollWindow(), and ProjectWindow::ZoomBy().

Referenced by Import(), and lofOpenFiles().

Here is the call graph for this function:

Here is the caller graph for this function:

GetFileDescription()

TranslatableString LOFImportFileHandle::GetFileDescription ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 265 of file ImportLOF.cpp.

{
   return DESC;
}

References DESC.

GetFilename()

FilePath LOFImportFileHandle::GetFilename ( ) const

overridevirtual

Implements ImportFileHandle.

Definition at line 324 of file ImportLOF.cpp.

{
   return mLOFFileName.GetFullPath();
}

References mLOFFileName.

GetFileUncompressedBytes()

auto LOFImportFileHandle::GetFileUncompressedBytes ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 270 of file ImportLOF.cpp.

{
   return 0;
}

GetStreamCount()

wxInt32 LOFImportFileHandle::GetStreamCount ( )

inlineoverridevirtual

Implements ImportFileHandle.

Definition at line 137 of file ImportLOF.cpp.

{ return 1; }

GetStreamInfo()

const TranslatableStrings & LOFImportFileHandle::GetStreamInfo ( )

inlineoverridevirtual

Implements ImportFileHandle.

Definition at line 139 of file ImportLOF.cpp.

   {
      static TranslatableStrings empty;
      return empty;
   }

Import()

void LOFImportFileHandle::Import ( ImportProgressListener &  progressListener, WaveTrackFactory *  trackFactory, TrackHolders &  outTracks, Tags *  tags  )

overridevirtual

Implements ImportFileHandle.

Definition at line 275 of file ImportLOF.cpp.

{
   // Unlike other ImportFileHandle subclasses, this one never gives any tracks
   // back to the caller.
   // Instead, it recursively calls AudacityProject::Import for each file listed
   // in the .lof file.
   // Each importation creates a NEW undo state.
   // If there is an error or exception during one of them, only that one's
   // side effects are rolled back, and the rest of the import list is skipped.
   // The file may have "window" directives that cause NEW AudacityProjects
   // to be created, and the undo states are pushed onto the latest project.
   // If a project is created but the first file import into it fails, destroy
   // the project.
 
   outTracks.clear();
 
   wxASSERT(mTextFile->IsOpened());
 
   if(mTextFile->Eof())
   {
      mTextFile->Close();
      progressListener.OnImportResult(ImportProgressListener::ImportResult::Error);
      return;
   }
 
   wxString line = mTextFile->GetFirstLine();
 
   while (!mTextFile->Eof())
   {
      lofOpenFiles(&line);
      line = mTextFile->GetNextLine();
   }
 
   // for last line
   lofOpenFiles(&line);
 
   if(!mTextFile->Close())
   {
      progressListener.OnImportResult(ImportProgressListener::ImportResult::Error);
      return;
   }
   // set any duration/offset factors for last window, as all files were called
   doDurationAndScrollOffset();
   progressListener.OnImportResult(ImportProgressListener::ImportResult::Success);
}

References doDurationAndScrollOffset(), ImportProgressListener::Error, lofOpenFiles(), mTextFile, ImportProgressListener::OnImportResult(), and ImportProgressListener::Success.

Here is the call graph for this function:

lofOpenFiles()

void LOFImportFileHandle::lofOpenFiles ( wxString *  ln )

private

Processes a single line from a LOF text file, doing whatever is indicated on the line.

This function should just return for lines it cannot deal with, and the caller will continue to the next line of the input file

Definition at line 370 of file ImportLOF.cpp.

{
   wxStringTokenizer tok(*ln, wxT(" "));
   wxStringTokenizer temptok1(*ln, wxT("\""));
   wxStringTokenizer temptok2(*ln, wxT(" "));
   int tokenplace = 0;
 
   wxString targetfile;
   wxString tokenholder = tok.GetNextToken();
 
 
   if (tokenholder.IsSameAs(wxT("window"), false))
   {
      // set any duration/offset factors for last window, as all files were called
      doDurationAndScrollOffset();
 
      if (nFilesInGroup > 0 )
         // Cause a project to be created with the next import
         mProject = nullptr;
 
      nFilesInGroup = 0;
 
      while (tok.HasMoreTokens())
      {
         tokenholder = tok.GetNextToken();
 
         if (tokenholder.IsSameAs(wxT("offset"), false))
         {
            if (tok.HasMoreTokens())
               tokenholder = tok.GetNextToken();
 
            if (Internat::CompatibleToDouble(tokenholder, &scrollOffset))
            {
               callScrollOffset = true;
            }
            else
            {
               ImportUtils::ShowMessageBox(
                  /* i18n-hint: You do not need to translate "LOF" */
                  XO("Invalid window offset in LOF file."));
            }
 
            if (tok.HasMoreTokens())
               tokenholder = tok.GetNextToken();
         }
 
         if (tokenholder.IsSameAs(wxT("duration"), false))
         {
            if (tok.HasMoreTokens())
               tokenholder = tok.GetNextToken();
 
            if (Internat::CompatibleToDouble(tokenholder, &durationFactor))
            {
               callDurationFactor = true;
            }
            else
            {
               ImportUtils::ShowMessageBox(
                  /* i18n-hint: You do not need to translate "LOF" */
                  XO("Invalid duration in LOF file."));
            }
         }     // End if statement
 
         if (tokenholder == wxT("#"))
         {
            // # indicates comments; ignore line
            tok = wxStringTokenizer(wxT(""), wxT(" "));
         }
      }     // End while loop
   }        // End if statement handling "window" lines
 
   else if (tokenholder.IsSameAs(wxT("file"), false))
   {
      nFilesInGroup++;
      // To identify filename and open it
      tokenholder = temptok1.GetNextToken();
      wxString targettoken = temptok1.GetNextToken();
      targetfile = targettoken;
 
      // If path is relative, make absolute path from LOF path
      if(!wxIsAbsolutePath(targetfile)) {
         wxFileName fName(targetfile);
         fName.Normalize(wxPATH_NORM_ALL, mLOFFileName.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR));
         if(fName.FileExists()) {
            targetfile = fName.GetFullPath();
         }
      }
 
      // Do recursive call to import
 
#ifdef USE_MIDI
      // If file is a midi
      if (FileNames::IsMidi(targetfile))
      {
         mProject = DoImportMIDIProject(mProject, targetfile);
      }
 
      // If not a midi, open audio file
      else
 
#else // !USE_MIDI
         /* if we don't have midi support, go straight on to opening as an
          * audio file. TODO: Some sort of message here? */
 
#endif // USE_MIDI
         mProject = ProjectManager::OpenProject( mProject, targetfile,
            true /* addtohistory */, true /* reuseNonemptyProject */ );
 
      // Set tok to right after filename
      temptok2.SetString(targettoken);
      tokenplace = temptok2.CountTokens();
 
      for (int i = 0; i < tokenplace; i++)
         tokenholder = tok.GetNextToken();
 
      if (tok.HasMoreTokens())
      {
         tokenholder = tok.GetNextToken();
 
         if (tokenholder == wxT("#"))
         {
            // # indicates comments; ignore line
            tok = wxStringTokenizer(wxT(""), wxT(" "));
         }
 
         if (tokenholder.IsSameAs(wxT("offset"), false))
         {
            if (tok.HasMoreTokens())
               tokenholder = tok.GetNextToken();
            double offset;
 
            // handle an "offset" specifier
            if (!mProject)
               // there was an import error,
               // presumably with its own error message
               ;
            else if (Internat::CompatibleToDouble(tokenholder, &offset))
            {
               auto &tracks = TrackList::Get( *mProject );
               auto t = *tracks.rbegin();
 
               // t is now the last track in the project, unless the import of
               // all tracks failed, in which case it will be null. In that
               // case we return because we cannot offset a non-existent track.
               if (t == NULL)
                  return;
#ifdef USE_MIDI
               if (targetfile.AfterLast(wxT('.')).IsSameAs(wxT("mid"), false) ||
                   targetfile.AfterLast(wxT('.')).IsSameAs(wxT("midi"), false))
               {
                  ImportUtils::ShowMessageBox(XO("MIDI tracks cannot be offset individually, only audio files can be."));
               }
               else
#endif
               t->MoveTo(offset);
 
               // Amend the undo transaction made by import
               ProjectHistory::Get( *mProject ).ModifyState(false);
            } // end of converting "offset" argument
            else
            {
               ImportUtils::ShowMessageBox(
                  /* i18n-hint: You do not need to translate "LOF" */
                  XO("Invalid track offset in LOF file."));
            }
         }     // End if statement for "offset" parameters
      }     // End if statement (more tokens after file name)
   }     // End if statement "file" lines
 
   else if (tokenholder == wxT("#"))
   {
      // # indicates comments; ignore line
      tok = wxStringTokenizer(wxT(""), wxT(" "));
   }
   else
   {
      // Couldn't parse a line
   }
}

References callDurationFactor, callScrollOffset, Internat::CompatibleToDouble(), doDurationAndScrollOffset(), DoImportMIDIProject(), durationFactor, ProjectHistory::Get(), TrackList::Get(), FileNames::IsMidi(), mLOFFileName, ProjectHistory::ModifyState(), mProject, nFilesInGroup, ProjectManager::OpenProject(), scrollOffset, ImportUtils::ShowMessageBox(), tracks, wxT(), and XO().

Referenced by Import().

Here is the call graph for this function:

Here is the caller graph for this function:

SetStreamUsage()

void LOFImportFileHandle::SetStreamUsage ( wxInt32   WXUNUSEDStreamID, bool   WXUNUSEDUse  )

inlineoverride

Definition at line 145 of file ImportLOF.cpp.

   {}

Stop()

void LOFImportFileHandle::Stop ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 334 of file ImportLOF.cpp.

{
   //LOFImport delegates import to other plugins
}

Member Data Documentation

callDurationFactor

bool LOFImportFileHandle::callDurationFactor { false }

private

Definition at line 162 of file ImportLOF.cpp.

Referenced by doDurationAndScrollOffset(), and lofOpenFiles().

callScrollOffset

bool LOFImportFileHandle::callScrollOffset { false }

private

Definition at line 166 of file ImportLOF.cpp.

Referenced by doDurationAndScrollOffset(), and lofOpenFiles().

durationFactor

double LOFImportFileHandle::durationFactor { 1 }

private

Definition at line 163 of file ImportLOF.cpp.

Referenced by doDurationAndScrollOffset(), and lofOpenFiles().

mLOFFileName

const wxFileName LOFImportFileHandle::mLOFFileName

private

The name of the LOF file, which is used to interpret relative paths in it

Definition at line 154 of file ImportLOF.cpp.

Referenced by GetFilename(), and lofOpenFiles().

mProject

AudacityProject* LOFImportFileHandle::mProject {}

private

Definition at line 156 of file ImportLOF.cpp.

Referenced by doDurationAndScrollOffset(), and lofOpenFiles().

mTextFile

std::unique_ptr<wxTextFile> LOFImportFileHandle::mTextFile

private

Definition at line 153 of file ImportLOF.cpp.

Referenced by Import().

nFilesInGroup

int LOFImportFileHandle::nFilesInGroup { 0 }

private

Definition at line 159 of file ImportLOF.cpp.

Referenced by lofOpenFiles().

scrollOffset

double LOFImportFileHandle::scrollOffset { 0 }

private

Definition at line 167 of file ImportLOF.cpp.

Referenced by doDurationAndScrollOffset(), and lofOpenFiles().

---

The documentation for this class was generated from the following file:

• ImportLOF.cpp