Beispiel #1
0
PluginWindow* PluginWindow::getWindowFor (AudioProcessorGraph::Node* node,
                                          bool useGenericView)
{
    for (int i = activePluginWindows.size(); --i >= 0;)
        if (activePluginWindows.getUnchecked(i)->owner == node
             && activePluginWindows.getUnchecked(i)->isGeneric == useGenericView)
            return activePluginWindows.getUnchecked(i);

    AudioProcessorEditor* ui = nullptr;

    if (! useGenericView)
    {
        ui = node->getProcessor()->createEditorIfNeeded();

        if (ui == nullptr)
            useGenericView = true;
    }

    if (useGenericView)
    {
        ui = new GenericAudioProcessorEditor (node->getProcessor());
    }

    if (ui != nullptr)
    {
        AudioPluginInstance* const plugin = dynamic_cast <AudioPluginInstance*> (node->getProcessor());

        if (plugin != nullptr)
            ui->setName (plugin->getName());

        return new PluginWindow (ui, node, useGenericView);
    }

    return nullptr;
}
Beispiel #2
0
static void show_gui(struct SoundPlugin *plugin){
#if JUCE_LINUX
  const MessageManagerLock mmLock;
#endif

  Data *data = (Data*)plugin->data;

  if (data->window==NULL) {

    const char *title = strdup(plugin->patch==NULL ? talloc_format("%s %s",plugin->type->type_name, plugin->type->name) : plugin->patch->name);
    data->window = new PluginWindow(title, data);

    if (data->x < 0 || data->y < 0)
      data->window->centreWithSize (data->window->getWidth(), data->window->getHeight());
    else {
      data->window->setTopLeftPosition(data->x, data->y);
    }
    
    AudioProcessorEditor *editor = data->audio_instance->createEditor(); //IfNeeded();
    editor->setName (data->audio_instance->getName());

    data->window->setContentOwned(editor, true);
    data->window->setUsingNativeTitleBar(true);
  }

  data->window->setVisible(true);
}
void HoaToolsAudioProcessor::setStateInformation (const void* data, int sizeInBytes)
{
    char name[256];
    ScopedPointer<XmlElement> xmlState (getXmlFromBinary (data, sizeInBytes));

    if (xmlState != nullptr)
    {
        if (xmlState->hasTagName("HoaToolsSettings"))
        {
            setNumberOfSources(xmlState->getIntAttribute("NumberOfSources"));

            for (int i = 0; i < getNumberOfSources(); i++)
            {
                sprintf(name, "Abscissa%i", i);
                m_sources->sourceSetAbscissa(i, xmlState->getDoubleAttribute(name));
                sprintf(name, "Ordinate%i", i);
                m_sources->sourceSetOrdinate(i, xmlState->getDoubleAttribute(name));
            }
        }
    }

    AudioProcessorEditor* Editor = NULL;
    Editor = getActiveEditor();
    if(Editor)
    {
        Editor->repaint();
    }
}
void HoaToolsAudioProcessor::setParameter(int index, float newValue)
{
    int param_index = index % 2;
    int source_index = index / 2;

    if(source_index >= getNumberOfSources())
        return;

    switch (param_index)
    {
    case 0:
        m_sources->sourceSetAbscissa(source_index, Hoa::scale(newValue, 0, 1, -DISTANCE_MAX, DISTANCE_MAX) );
        break;
    case 1:
        m_sources->sourceSetOrdinate(source_index, Hoa::scale(newValue, 0, 1, -DISTANCE_MAX, DISTANCE_MAX) );
        break;
    default:
        break;
    }

    AudioProcessorEditor* Editor = NULL;
    Editor = getActiveEditor();
    if(Editor)
        Editor->repaint();
}
void HoaToolsAudioProcessor::prepareToPlay(double sampleRate, int samplesPerBlock)
{
    m_vector_size = samplesPerBlock;

    AudioProcessorEditor* Editor = NULL;
    Editor = getActiveEditor();
    if(Editor)
        Editor->repaint();
}
void HoaToolsAudioProcessor::numChannelsChanged()
{
    AudioProcessorEditor* Editor = NULL;
    Editor = getActiveEditor();
    if(Editor)
        Editor->repaint();

    updateHostDisplay();
}
void StandaloneFilterWindow::loadFile(String filename)
{
    File file(filename);
    pluginHolder->stopPlaying();
    pluginHolder->reloadAudioDeviceState();
    deleteEditorComp();
    pluginHolder->deletePlugin();

    if(file.existsAsFile())
    {
        //cUtils::showMessage(file.loadFileAsString());
        float originalPluginWidth=100;
        float originalPluginHeight=100;
        StringArray csdArray;
        csdArray.addLines(file.loadFileAsString());
        for(int i=0; i<csdArray.size(); i++)
        {
            if(csdArray[i].contains("form "))
            {
                CabbageGUIType cAttr(csdArray[i], -99);
                originalPluginWidth = cAttr.getNumProp(CabbageIDs::width);
                originalPluginHeight = cAttr.getNumProp(CabbageIDs::height);
                this->getProperties().set("colour", cAttr.getStringProp(CabbageIDs::colour));
                this->lookAndFeelChanged();
            }
        }

        Point<float> scale;

        if(originalPluginWidth>=originalPluginHeight)
        {
            scale = Point<float>(desktopRect.getWidth()/originalPluginWidth,
                                 (desktopRect.getHeight()/originalPluginHeight)*.95);
        }
        else
        {
            scale = Point<float>(desktopRect.getHeight()/originalPluginHeight,
                                 (desktopRect.getHeight()/originalPluginHeight)*.95);
        }

        pluginHolder->createPlugin(file.getFullPathName(), scale);
        AudioProcessorEditor* ed = createEditorComp();
        setContentOwned(ed, true);
        //createEditorComp();

        ed->setSize(desktopRect.getWidth(), desktopRect.getHeight());
        //this->resized();

        setName(pluginHolder->processor->getName());
        pluginHolder->startPlaying();

    }

}
Beispiel #8
0
PluginWindow* PluginWindow::getWindowFor (AudioProcessorGraph::Node* const node,
                                          WindowFormatType type)
{
  jassert (node != nullptr);
  
  for (int i = activePluginWindows.size(); --i >= 0;)
    if (activePluginWindows.getUnchecked(i)->owner == node
        && activePluginWindows.getUnchecked(i)->type == type)
      return activePluginWindows.getUnchecked(i);
  
  AudioProcessor* processor = node->getProcessor();
  AudioProcessorEditor* ui = nullptr;
  
  if (type == Normal)
  {
    ui = processor->createEditorIfNeeded();
    
    if (ui == nullptr)
      type = Generic;
  }
  
  if (ui == nullptr)
  {
    //if (type == Generic || type == Parameters)
      //ui = new PMixGenericAudioProcessorEditor (processor);
//    else if (type == Programs)
//      ui = new ProgramAudioProcessorEditor (processor);
  }
  
  if (ui != nullptr)
  {
    if (AudioPluginInstance* const plugin = dynamic_cast<AudioPluginInstance*> (processor))
      ui->setName (plugin->getName());
    
    return new PluginWindow (ui, node, type);
  }
  
  return nullptr;
}