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
ProgressResult	Import (WaveTrackFactory *trackFactory, TrackHolders &outTracks, Tags *tags) override
wxInt32	GetStreamCount () override
const TranslatableStrings &	GetStreamInfo () override
void	SetStreamUsage (wxInt32 WXUNUSED(StreamID), bool WXUNUSED(Use)) override
Public Member Functions inherited from ImportFileHandle
	ImportFileHandle (const FilePath &filename)
virtual	~ImportFileHandle ()
void	CreateProgress ()
virtual void	SetStreamUsage (wxInt32 StreamID, bool Use)=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
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	ProgressResult = BasicUI::ProgressResult
using	ByteCount = unsigned long long
Static Public Member Functions inherited from ImportFileHandle
static sampleFormat	ChooseFormat (sampleFormat effectiveFormat)
	Choose appropriate format, which will not be narrower than the specified one. More...
Protected Member Functions inherited from ImportFileHandle
std::shared_ptr< WaveTrack >	NewWaveTrack (WaveTrackFactory &trackFactory, sampleFormat effectiveFormat, double rate)
	Build a wave track with appropriate format, which will not be narrower than the specified one. More...
Protected Attributes inherited from ImportFileHandle
FilePath	mFilename
std::unique_ptr< ProgressDialog >	mProgress

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 121 of file ImportLOF.cpp.

Constructor & Destructor Documentation

LOFImportFileHandle()

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

Definition at line 166 of file ImportLOF.cpp.

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

References name.

~LOFImportFileHandle()

LOFImportFileHandle::~LOFImportFileHandle

(

)

Definition at line 570 of file ImportLOF.cpp.

{
}

Member Function Documentation

doDurationAndScrollOffset()

void LOFImportFileHandle::doDurationAndScrollOffset ( )

private

Definition at line 544 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(), ProjectWindow::Get(), TrackList::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 262 of file ImportLOF.cpp.

{
   return DESC;
}

References DESC.

GetFileUncompressedBytes()

auto LOFImportFileHandle::GetFileUncompressedBytes ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 267 of file ImportLOF.cpp.

{
   return 0;
}

GetStreamCount()

wxInt32 LOFImportFileHandle::GetStreamCount ( )

inlineoverridevirtual

Implements ImportFileHandle.

Definition at line 133 of file ImportLOF.cpp.

{ return 1; }

GetStreamInfo()

const TranslatableStrings& LOFImportFileHandle::GetStreamInfo ( )

inlineoverridevirtual

Implements ImportFileHandle.

Definition at line 135 of file ImportLOF.cpp.

   {
      static TranslatableStrings empty;
      return empty;
   }

Import()

ProgressResult LOFImportFileHandle::Import ( WaveTrackFactory *  trackFactory, TrackHolders &  outTracks, Tags *  tags  )

overridevirtual

Implements ImportFileHandle.

Definition at line 272 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();
      return ProgressResult::Failed;
   }
 
   wxString line = mTextFile->GetFirstLine();
 
   while (!mTextFile->Eof())
   {
      lofOpenFiles(&line);
      line = mTextFile->GetNextLine();
   }
 
   // for last line
   lofOpenFiles(&line);
 
   if(!mTextFile->Close())
      return ProgressResult::Failed;
 
   // set any duration/offset factors for last window, as all files were called
   doDurationAndScrollOffset();
 
   return ProgressResult::Success;
}

References doDurationAndScrollOffset(), lofOpenFiles(), mTextFile, and BasicUI::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 349 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
            {
               AudacityMessageBox(
                  /* i18n-hint: You do not need to translate "LOF" */
                  XO("Invalid window offset in LOF file."),
                  /* i18n-hint: You do not need to translate "LOF" */
                  XO("LOF Error"),
                  wxOK | wxCENTRE);
            }
 
            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
            {
               AudacityMessageBox(
                  /* i18n-hint: You do not need to translate "LOF" */
                  XO("Invalid duration in LOF file."),
                  /* i18n-hint: You do not need to translate "LOF" */
                  XO("LOF Error"),
                  wxOK | wxCENTRE);
            }
         }     // 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.Leaders().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))
               {
                  AudacityMessageBox(
                     XO("MIDI tracks cannot be offset individually, only audio files can be."),
                     XO("LOF Error"),
                     wxOK | wxCENTRE);
               }
               else
#endif
               {
                  for (auto channel : TrackList::Channels(t))
                     channel->SetOffset(offset);
               }
 
               // Amend the undo transaction made by import
               ProjectHistory::Get( *mProject ).ModifyState(false);
            } // end of converting "offset" argument
            else
            {
               AudacityMessageBox(
                  /* i18n-hint: You do not need to translate "LOF" */
                  XO("Invalid track offset in LOF file."),
                  /* i18n-hint: You do not need to translate "LOF" */
                  XO("LOF Error"),
                  wxOK | wxCENTRE);
            }
         }     // 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 AudacityMessageBox(), callDurationFactor, callScrollOffset, TrackList::Channels(), Internat::CompatibleToDouble(), doDurationAndScrollOffset(), DoImportMIDIProject(), durationFactor, ProjectHistory::Get(), TrackList::Get(), FileNames::IsMidi(), mLOFFileName, ProjectHistory::ModifyState(), mProject, nFilesInGroup, ProjectManager::OpenProject(), scrollOffset, 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 141 of file ImportLOF.cpp.

   {}

Member Data Documentation

callDurationFactor

bool LOFImportFileHandle::callDurationFactor { false }

private

Definition at line 158 of file ImportLOF.cpp.

Referenced by doDurationAndScrollOffset(), and lofOpenFiles().

callScrollOffset

bool LOFImportFileHandle::callScrollOffset { false }

private

Definition at line 162 of file ImportLOF.cpp.

Referenced by doDurationAndScrollOffset(), and lofOpenFiles().

durationFactor

double LOFImportFileHandle::durationFactor { 1 }

private

Definition at line 159 of file ImportLOF.cpp.

Referenced by doDurationAndScrollOffset(), and lofOpenFiles().

mLOFFileName

wxFileName LOFImportFileHandle::mLOFFileName

private

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

Definition at line 150 of file ImportLOF.cpp.

Referenced by lofOpenFiles().

mProject

AudacityProject* LOFImportFileHandle::mProject {}

private

Definition at line 152 of file ImportLOF.cpp.

Referenced by doDurationAndScrollOffset(), and lofOpenFiles().

mTextFile

std::unique_ptr<wxTextFile> LOFImportFileHandle::mTextFile

private

Definition at line 149 of file ImportLOF.cpp.

Referenced by Import().

nFilesInGroup

int LOFImportFileHandle::nFilesInGroup { 0 }

private

Definition at line 155 of file ImportLOF.cpp.

Referenced by lofOpenFiles().

scrollOffset

double LOFImportFileHandle::scrollOffset { 0 }

private

Definition at line 163 of file ImportLOF.cpp.

Referenced by doDurationAndScrollOffset(), and lofOpenFiles().

---

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

• ImportLOF.cpp