Changeset 1264

Show
Ignore:
Timestamp:
09/23/07 15:02:41 (12 months ago)
Author:
calvin
Message:

adapt buze to latest zzub cleanups, also fixes a focus takeover issue in the machine parameter view

Location:
trunk/src/buzelib
Files:
15 modified

Legend:

Unmodified
Added
Removed

  • trunk/src/buzelib/Document.cpp

    r1263 r1264  
    325325bool CDocument::createPattern(metaplugin* machine) { 
    326326        PatternCreate* redo = new PatternCreate(); 
    327         redo->init(machine->getName(), machine->getNewPatternName(), configuration->getMachinePatternLength(machine->machineInfo->uri)); 
     327        redo->init(machine->getName(), machine->getNewPatternName(), configuration->getMachinePatternLength(machine->loader->plugin_info->uri)); 
    328328 
    329329        PatternDelete* undo = new PatternDelete(); 
    … …  
    492492         
    493493        int targetTracks = machine->getTracks()-1; 
    494         if (targetTracks<(int)machine->getMachineMinTracks()) return false; 
    495         if (targetTracks>=machine->getMachineMaxTracks()) return false; 
     494        if (targetTracks<(int)machine->loader->plugin_info->min_tracks) return false; 
     495        if (targetTracks>=machine->loader->plugin_info->max_tracks) return false; 
    496496 
    497497        vector<vector<patterntrack*> > nodata; 
    … …  
    565565                        if (track != -1 && track != j) continue; 
    566566                        zzub::patterntrack* t = pattern->getPatternTrack(i, j); 
    567                         for (int k = 0; k < getTrackColumns(i, j, machine->machineInfo); k++) { 
     567                        for (int k = 0; k < getTrackColumns(i, j, machine->loader->plugin_info); k++) { 
    568568                                if (column != -1 && column != k) continue; 
    569569                                const zzub::parameter* para = machine->getMachineParameter(i, j, k); 
    … …  
    611611                        if (track != -1 && track != j) continue; 
    612612                        zzub::patterntrack* t = pattern->getPatternTrack(i, j); 
    613                         for (int k = 0; k < getTrackColumns(i, j, machine->machineInfo); k++) { 
     613                        for (int k = 0; k < getTrackColumns(i, j, machine->loader->plugin_info); k++) { 
    614614                                if (column != -1 && column != k) continue; 
    615615                                const zzub::parameter* para = machine->getMachineParameter(i, j, k); 
    … …  
    848848std::string CDocument::getMachineFileName(pluginloader* loader) { 
    849849        if (!loader) return ""; 
    850         return loader->getFile(); 
     850        if (!loader->lib) return ""; 
     851        return loader->lib->fileName; 
    851852} 
    852853 
    853854std::string CDocument::getMachineFullName(pluginloader* loader) { 
    854855        if (!loader) return ""; 
    855         const zzub::info* info=loader->getInfo(); 
    856         if (!info) return ""; 
    857         if (!info->name) return ""; 
    858         return info->name; 
     856        if (!loader->plugin_info) return ""; 
     857        if (!loader->plugin_info->name) return ""; 
     858        return loader->plugin_info->name; 
    859859} 
    860860 
    861861std::string CDocument::getMachineAuthor(pluginloader* loader) { 
    862862        if (!loader) return ""; 
    863         const zzub::info* info = loader->getInfo(); 
    864         if (!info) return ""; 
    865         if (!info->author) return ""; 
    866         return info->author; 
     863        if (!loader->plugin_info) return ""; 
     864        if (!loader->plugin_info->author) return ""; 
     865        return loader->plugin_info->author; 
    867866} 
    868867 
    869868std::string CDocument::getMachineUri(pluginloader* loader) { 
    870869        if (!loader) return ""; 
    871         const zzub::info* info = loader->getInfo(); 
    872         if (!info) return ""; 
    873         if (!info->uri) return ""; 
    874         return info->uri; 
     870        if (!loader->plugin_info) return ""; 
     871        if (!loader->plugin_info->uri) return ""; 
     872        return loader->plugin_info->uri; 
    875873} 
    876874 
    … …  
    12491247void CDocument::playMachineNote(metaplugin* m, int note, int prevNote) { 
    12501248        // create a blank 1-row pattern we're going to play 
    1251         zzub::pattern* p = new zzub::pattern(m->machineInfo, m->getConnections(), m->getTracks(), 1); 
     1249        zzub::pattern* p = new zzub::pattern(m->loader->plugin_info, m->getConnections(), m->getTracks(), 1); 
    12521250 
    12531251        bool multiChannel; 

  • trunk/src/buzelib/EditorActions.cpp

    r1261 r1264  
    151151        if (machine == 0) return false; 
    152152        //document->player->lockTick(); 
    153         sequence* t = machine->createSequence(); 
     153        sequence* t = document->player->song_sequencer.createTrack(machine); 
    154154 
    155155        zzub::mem_instream inf(sequenceBytes); 
    … …  
    239239        //player->saveFragment(buffer, machine, false, false); 
    240240 
    241         this->pluginUri=machine->loader->getUri(); 
     241        this->pluginUri=machine->loader->plugin_info->uri; 
    242242        this->name=machine->getName(); 
    243243        this->x=machine->x; 
    244244        this->y=machine->y; 
    245245        this->tracks=machine->getTracks(); 
    246         this->machineInfo = machine->machineInfo; 
     246        this->machineInfo = machine->loader->plugin_info; 
    247247         
    248248        for (size_t i=0; i<machine->getConnections(); i++) { 
    … …  
    291291        } 
    292292 
    293         for (size_t i=0; i<machine->machineInfo->global_parameters.size(); i++) { 
     293        for (size_t i=0; i<machine->loader->plugin_info->global_parameters.size(); i++) { 
    294294                this->states.push_back(machine->getParameter(1, 0, i)); 
    295295        } 
    296296 
    297297        for (size_t i=0; i<machine->getTracks(); i++) { 
    298                 for (size_t j=0; j<machine->machineInfo->track_parameters.size(); j++) { 
     298                for (size_t j=0; j<machine->loader->plugin_info->track_parameters.size(); j++) { 
    299299                        this->states.push_back(machine->getParameter(2, i, j)); 
    300300                } 
    … …  
    346346 
    347347    if (!patternBytes.size()) { 
    348             if (machine->getMachineMinTracks() > 0 && machine->getMachineMaxTracks() > 0) 
    349                 machine->setTracks(machine->getMachineMinTracks()); 
     348            if (machine->loader->plugin_info->min_tracks > 0 && machine->loader->plugin_info->max_tracks > 0) 
     349                machine->setTracks(machine->loader->plugin_info->min_tracks); 
    350350    } else 
    351351        machine->setTracks(tracks); 
    352352 
    353353        if (this->states.size()) { 
    354                 int numGlobals = machine->machineInfo->global_parameters.size(); 
     354                int numGlobals = machine->loader->plugin_info->global_parameters.size(); 
    355355                for (int i = 0; i < numGlobals; i++) { 
    356356                        machine->setParameter(1, 0, i, this->states[i], false); 
    357357                } 
    358358 
    359                 int numTrackParams = machine->machineInfo->track_parameters.size(); 
     359                int numTrackParams = machine->loader->plugin_info->track_parameters.size(); 
    360360                for (size_t i = 0; i < machine->getTracks(); i++) { 
    361361                        for (int j = 0; j < numTrackParams; j++) { 
    … …  
    422422                } 
    423423 
    424                 zzub::pattern* pattern = machine->createPattern(document->configuration->getMachinePatternLength(machine->machineInfo->uri)); 
     424                zzub::pattern* pattern = machine->createPattern(document->configuration->getMachinePatternLength(machine->loader->plugin_info->uri)); 
    425425                pattern->setName(machine->getNewPatternName()); 
    426426        } 
    … …  
    747747        int numTracks=this->tracks; 
    748748         
    749         if (numTracks<machine->getMachineMaxTracks()) { 
    750                 int prevTracks=machine->getTracks(); 
     749        if (numTracks<machine->loader->plugin_info->max_tracks) { 
     750                int prevTracks = machine->getTracks(); 
    751751                machine->setTracks(numTracks); 
    752752 

  • trunk/src/buzelib/MachineFolderView.cpp

    r1224 r1264  
    143143                pluginloader* loader = player->getMachineLoader(i); 
    144144                HTREEITEM hmachineItem; 
    145                 if (loader->getType() == plugin_type_effect) 
    146                         hmachineItem = treeCtrl.InsertItem( loader->getName(), hEffectItem, TVI_LAST); else 
    147                         hmachineItem = treeCtrl.InsertItem( loader->getName(), hGeneratorItem, TVI_LAST);  
    148                 treeCtrl.SetItemData(hmachineItem, (DWORD)loader->getUri()); 
     145                if (loader->plugin_info->type == plugin_type_effect) 
     146                        hmachineItem = treeCtrl.InsertItem(loader->plugin_info->name, hEffectItem, TVI_LAST); else 
     147                        hmachineItem = treeCtrl.InsertItem(loader->plugin_info->name, hGeneratorItem, TVI_LAST);  
     148                treeCtrl.SetItemData(hmachineItem, (DWORD)loader->plugin_info->uri); 
    149149        } 
    150150        treeCtrl.SetRedraw(TRUE); 

  • trunk/src/buzelib/MachineParameterView.cpp

    r1260 r1264  
    8181        mainFrame->addDisabledAcceleratorComboBox(presetDropDown); 
    8282 
    83         std::string uri = machine->loader->getUri(); 
     83        std::string uri = machine->loader->plugin_info->uri; 
    8484        std::string pluginName = player->getBuzzName(uri); 
    8585        std::string fileName; 
    … …  
    184184                if (i == selectedSlider) { 
    185185                        sliderView.sliders[i]->trackBar.m_slider.SetSelected(true);  
    186                         sliderView.sliders[i]->trackBar.m_slider.SetFocus(); 
     186                        if (mainFrame->frame.focusedClientView() == *this)  
     187                                sliderView.sliders[i]->trackBar.m_slider.SetFocus(); 
    187188                } else { 
    188189                        sliderView.sliders[i]->trackBar.m_slider.SetSelected(false); 
    … …  
    207208        defaultPreset.name = "<default>"; 
    208209        defaultPreset.parameters = 0; 
    209         for (size_t i = 0; i<machine->getStateParameters(); i++) { 
     210        for (size_t i = 0; i<getStateParameters(machine); i++) { 
    210211                size_t pgroup = 0, ptrack = 0, pcolumn = 0; 
    211                 machine->stateToPatternSpace(i, pgroup, ptrack, pcolumn); 
     212                stateToPatternSpace(machine, i, pgroup, ptrack, pcolumn); 
    212213                if (pgroup == 0) continue; 
    213214 
    … …  
    229230        CPresetDialog presetDlg(&presets, machine); 
    230231        if (IDOK == presetDlg.DoModal()) { 
    231                 string uri = machine->loader->getUri(); 
     232                string uri = machine->loader->plugin_info->uri; 
    232233                std::string pluginName = player->getBuzzName(uri); 
    233234                if (pluginName == "") pluginName = hexencode(uri); 
    … …  
    242243LRESULT CMachineParameterView::OnPresetRandom(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) { 
    243244 
    244         for (size_t i = 0; i<machine->getStateParameters(); i++) { 
     245        for (size_t i = 0; i<getStateParameters(machine); i++) { 
    245246                size_t pgroup = 0, ptrack = 0, pcolumn = 0; 
    246                 machine->stateToPatternSpace(i, pgroup, ptrack, pcolumn); 
     247                stateToPatternSpace(machine, i, pgroup, ptrack, pcolumn); 
    247248                if (pgroup == 0) continue; 
    248249 
    … …  
    263264LRESULT CMachineParameterView::OnPresetCopy(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) { 
    264265         
    265         bool hasGlobal = machine->machineInfo->global_parameters.size() > 0; 
    266         bool hasTrack = machine->machineInfo->track_parameters.size() > 0; 
     266        bool hasGlobal = machine->loader->plugin_info->global_parameters.size() > 0; 
     267        bool hasTrack = machine->loader->plugin_info->track_parameters.size() > 0; 
    267268 
    268269        CMenu menu;  
    … …  
    287288 
    288289        // create a temp 1-row pattern w/0 inputs 
    289         pattern temp(machine->machineInfo, 0, machine->getTracks(), 1); 
     290        pattern temp(machine->loader->plugin_info, 0, machine->getTracks(), 1); 
    290291 
    291292        // paste global state into pattern 
    … …  
    294295 
    295296        // paste track states into pattern 
    296         int col = machine->machineInfo->global_parameters.size(); 
     297        int col = machine->loader->plugin_info->global_parameters.size(); 
    297298        for (int i = 0; i < machine->getTracks(); i++) { 
    298299                track = machine->getStateTrackCopy(2, i); 
    299300                temp.pasteTrack(0, col, track); 
    300301 
    301                 col += machine->machineInfo->track_parameters.size(); 
     302                col += machine->loader->plugin_info->track_parameters.size(); 
    302303        } 
    303304 
    … …  
    328329LRESULT CMachineParameterView::OnPresetCopyTrack(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) { 
    329330        // create a temp 1-row pattern w/0 inputs 
    330         pattern temp(machine->machineInfo, 0, machine->getTracks(), 1); 
     331        pattern temp(machine->loader->plugin_info, 0, machine->getTracks(), 1); 
    331332 
    332333        // paste track states into pattern 
    333         int first_col = machine->machineInfo->global_parameters.size(); 
     334        int first_col = machine->loader->plugin_info->global_parameters.size(); 
    334335        int col = first_col; 
    335336        for (int i = 0; i < machine->getTracks(); i++) { 
    … …  
    337338                temp.pasteTrack(0, col, track); 
    338339 
    339                 col += machine->machineInfo->track_parameters.size(); 
     340                col += machine->loader->plugin_info->track_parameters.size(); 
    340341        } 
    341342 
    … …  
    360361        int valueIndex = 0; 
    361362        for (size_t i=0; i<pi.parameters; i++) { 
    362                 if (i<machine->getStateParameters()) { 
     363                if (i<getStateParameters(machine)) { 
    363364                        size_t pgroup=0, ptrack=0, pcolumn=0; 
    364                         machine->stateToPatternSpace(i, pgroup, ptrack, pcolumn); 
     365                        stateToPatternSpace(machine, i, pgroup, ptrack, pcolumn); 
    365366                        if (pgroup == 0) continue; 
    366367 
    … …  
    562563        // burde hete getstatecolumn 
    563564        size_t numSliders=0; 
    564         size_t stateColumns=machine->getStateParameters(); 
     565        size_t stateColumns=getStateParameters(machine); 
    565566        for (size_t i=0; i<stateColumns; i++) { 
    566567                size_t pgroup=0, ptrack=0, pcolumn=0; 
    567                 machine->stateToPatternSpace(i, pgroup, ptrack, pcolumn); 
     568                stateToPatternSpace(machine, i, pgroup, ptrack, pcolumn); 
    568569                if (pgroup != 0) { 
    569570 
    … …  
    589590        for (size_t i=0; i<stateColumns; i++) { 
    590591                size_t pgroup=0, ptrack=0, pcolumn=0; 
    591                 machine->stateToPatternSpace(i, pgroup, ptrack, pcolumn); 
     592                stateToPatternSpace(machine, i, pgroup, ptrack, pcolumn); 
    592593 
    593594                if (pgroup != 0) { 
    … …  
    666667        hiddenMenu.CreatePopupMenu(); 
    667668        int hiddens=0; 
    668         for (size_t i=0; i<machine->getStateParameters(); i++) { 
     669        for (size_t i=0; i<getStateParameters(machine); i++) { 
    669670                size_t pgroup=0, ptrack=0, pcolumn=0; 
    670                 machine->stateToPatternSpace(i, pgroup, ptrack, pcolumn); 
     671                stateToPatternSpace(machine, i, pgroup, ptrack, pcolumn); 
    671672 
    672673                if (pgroup == 0) continue; 
    673674 
    674675                size_t paramIndex=-1; 
    675                 zzub::pattern conv(machine->machineInfo, machine->getConnections(), machine->getTracks(), 0); 
     676                zzub::pattern conv(machine->loader->plugin_info, machine->getConnections(), machine->getTracks(), 0); 
    676677                conv.patternToLinear(pgroup, ptrack, pcolumn, paramIndex); 
    677678 

  • trunk/src/buzelib/MachineView.cpp

    r1261 r1264  
    777777        assert(loader); 
    778778 
    779         if (loader && loader->getHelpFile().length()>0) { 
     779/*      if (loader && loader->getHelpFile().length()>0) { 
    780780//              menu.InsertMenu(-1, MF_BYPOSITION|MF_SEPARATOR); 
    781781                menu.InsertMenu(-1, MF_BYPOSITION|MF_STRING, (UINT_PTR)ID_MACHINE_HELP, "Help"); 
    782782        } 
    783  
     783*/ 
    784784        CMenu patternMenu; 
    785785        patternMenu.CreatePopupMenu(); 
    … …  
    944944 
    945945void CMachineView::getStatusRect(zzub::metaplugin* plugin, RECT* rc) { 
    946         MachineSkin* skin = mainFrame->getSkin(plugin->machineInfo->uri); 
     946        MachineSkin* skin = mainFrame->getSkin(plugin->loader->plugin_info->uri); 
    947947        RECT mRect; 
    948948        getMachineRect(plugin, &mRect); 
    … …  
    12601260        dc.Rectangle(mRect.left, mRect.top, mRect.right, mRect.bottom); 
    12611261         
    1262         MachineSkin* skin = mainFrame->getSkin(plugin->machineInfo->uri); 
     1262        MachineSkin* skin = mainFrame->getSkin(plugin->loader->plugin_info->uri); 
    12631263        if (skin && skin->skin && !plugin->minimized) { 
    12641264                CDC bitmapDC; 
    … …  
    14051405                getStatusRect(machine, &rc); 
    14061406 
    1407                 MachineSkin* skin = mainFrame->getSkin(machine->machineInfo->uri); 
     1407                MachineSkin* skin = mainFrame->getSkin(machine->loader->plugin_info->uri); 
    14081408                if (skin && skin->led && !machine->minimized) { 
    14091409                        CDC bitmapDC; 

  • trunk/src/buzelib/MachineView.h

    r1260 r1264  
    33#include "DragDropImpl.h" 
    44#include "MachineDropTarget.h" 
    5  
    6 #define _USE_MATH_DEFINES 1 
    7 #include <math.h> 
    85 
    96const int MAX_MACHINE_FONTS=10; 

  • trunk/src/buzelib/MainFrm.cpp

    r1261 r1264  
    18111811                int views = (machineParameters.getViews() % 16); 
    18121812 
    1813                 int params = m->getStateParameters(); 
     1813                int params = getStateParameters(m); 
    18141814                int parameterHeight = params*CParameterSliderCtrl::sliderHeight + 20;   // 22 = toolbarheight 
    18151815 
    … …  
    22982298                        metaplugin* m = document->getSelectedMachine(0); 
    22992299                        if (!m) return 0; 
    2300                         if (_Module.configuration->getMachineMidiInDisabled(m->machineInfo->uri)) return 0; 
     2300                        if (_Module.configuration->getMachineMidiInDisabled(m->loader->plugin_info->uri)) return 0; 
    23012301                        document->playMachineNote(m, note, -1); 
    23022302                } else 
    … …  
    23072307                        if (!m) return 0; 
    23082308 
    2309                         if (_Module.configuration->getMachineMidiInDisabled(m->machineInfo->uri)) return 0; 
     2309                        if (_Module.configuration->getMachineMidiInDisabled(m->loader->plugin_info->uri)) return 0; 
    23102310                        document->playMachineNote(m, note_value_off, note); 
    23112311 
    … …  
    24362436        if (!loader) return; 
    24372437 
    2438         const zzub::info* info=loader->getInfo(); 
     2438        const zzub::info* info = loader->plugin_info; 
    24392439        if (!info) return ; 
    24402440        // TODO: if machine was already preloaded, do something here (= keep the returned isntrument library and re-populate) 
    … …  
    25062506        for (int i=0; i<player->getMachineLoaders(); i++) { 
    25072507                pluginloader* loader=player->getMachineLoader(i); 
    2508                 string pluginUri=loader->getUri(); 
    2509                 string pluginName=player->getBuzzName(pluginUri); 
     2508                string pluginUri = loader->plugin_info->uri; 
     2509                string pluginName = player->getBuzzName(pluginUri); 
    25102510                if (pluginName.empty()) 
    25112511                        pluginName = pluginUri; 
    25122512                MachineItem* mi=document->machineIndex.root.getMachineByName(pluginName); 
    25132513                if (!mi) { 
    2514                         mi=new MachineItem(); 
    2515                         mi->label=loader->getName(); 
    2516                         mi->fullMachineName=mi->fileName=pluginName; 
    2517  
    2518                         if (loader->getType() == zzub_plugin_type_effect) 
     2514                        mi = new MachineItem(); 
     2515                        mi->label = loader->plugin_info->name; 
     2516                        mi->fullMachineName = mi->fileName = pluginName; 
     2517 
     2518                        if (loader->plugin_info->type == zzub_plugin_type_effect) 
    25192519                                effectMenu->append(mi); else 
    2520                         if (loader->getType() == zzub_plugin_type_generator) 
     2520                        if (loader->plugin_info->type == zzub_plugin_type_generator) 
    25212521                                generatorMenu->append(mi); 
    25222522                } 
    … …  
    25442544        if (parameterIndex < 0) return; 
    25452545 
    2546         _Module.configuration->setMachineParameterVisibility(machine->loader->getUri(), parameterIndex, state); 
     2546        _Module.configuration->setMachineParameterVisibility(machine->loader->plugin_info->uri, parameterIndex, state); 
    25472547} 
    25482548 
    … …  
    25552555        if (parameterIndex < 0) return false; 
    25562556         
    2557         return _Module.configuration->getMachineParameterVisibility(machine->loader->getUri(), parameterIndex); 
     2557        return _Module.configuration->getMachineParameterVisibility(machine->loader->plugin_info->uri, parameterIndex); 
    25582558} 
    25592559 

  • trunk/src/buzelib/ParameterSliderCtrl.cpp

    r1258 r1264  
    143143        hiddenMenu.CreatePopupMenu(); 
    144144        size_t hiddens=0; 
    145         for (size_t i=0; i<machine->getStateParameters(); i++) { 
     145        for (size_t i=0; i<getStateParameters(machine); i++) { 
    146146                size_t pgroup=0, ptrack=0, pcolumn=0; 
    147                 machine->stateToPatternSpace(i, pgroup, ptrack, pcolumn); 
     147                stateToPatternSpace(machine, i, pgroup, ptrack, pcolumn); 
    148148 
    149149                size_t paramIndex=-1; 

  • trunk/src/buzelib/PatternView.cpp

    r1263 r1264  
    10611061        int parameter_index = 0; 
    10621062        patternEditor.AddTrack("Global"); 
    1063         for (size_t i = 0; i< machine->machineInfo->global_parameters.size(); i++, parameter_index++) { 
     1063        for (size_t i = 0; i< machine->loader->plugin_info->global_parameters.size(); i++, parameter_index++) { 
    10641064                //TODO: document->configuration->getMachineParameterVisibility(machine->machineInfo->uri, parameter_index); 
    1065                 const zzub::parameter* paraGlobal = machine->machineInfo->global_parameters[i]; 
     1065                const zzub::parameter* paraGlobal = machine->loader->plugin_info->global_parameters[i]; 
    10661066                 
    10671067                patternEditor.AddColumn(1, 0, i, paraGlobal->type, getNoValue(paraGlobal), getParamMinValue(paraGlobal), getParamMaxValue(paraGlobal)); 
    … …  
    10781078                patternEditor.AddTrack("Track " + stringFromInt(j+1)); 
    10791079                parameter_index = first_track_index; 
    1080                 for (size_t i = 0; i< machine->machineInfo->track_parameters.size(); i++, parameter_index++) { 
     1080                for (size_t i = 0; i< machine->loader->plugin_info->track_parameters.size(); i++, parameter_index++) { 
    10811081                        //TODO: document->configuration->getMachineParameterVisibility(machine->machineInfo->uri, parameter_index); 
    1082                         const zzub::parameter* paraTrack = machine->machineInfo->track_parameters[i]; 
     1082                        const zzub::parameter* paraTrack = machine->loader->plugin_info->track_parameters[i]; 
    10831083                        patternEditor.AddColumn(2, j, i, paraTrack->type, getNoValue(paraTrack), getParamMinValue(paraTrack), getParamMaxValue(paraTrack)); 
    10841084 
    … …  
    16581658        menu.CreatePopupMenu(); 
    16591659 
    1660         bool hasMoreTracks = machine->getTracks() < machine->machineInfo->max_tracks; 
    1661         bool hasLessTracks = machine->getTracks() > machine->machineInfo->min_tracks; 
     1660        bool hasMoreTracks = machine->getTracks() < machine->loader->plugin_info->max_tracks; 
     1661        bool hasLessTracks = machine->getTracks() > machine->loader->plugin_info->min_tracks; 
    16621662        bool hasPattern = pattern != 0; 
    16631663 

  • trunk/src/buzelib/PresetDialog.cpp

    r1218 r1264  
    33#include "PresetDialog.h" 
    44#include "PresetManager.h" 
     5#include "utils.h" 
    56 
    67CPresetDialog::CPresetDialog(PresetManager* prs, zzub::metaplugin* plug) { 
    … …  
    4647    commentBox.GetWindowText(pc, 4096); 
    4748    pi->comment = pc; 
    48     pi->parameters = plugin->getStateParameters(); 
     49    pi->parameters = getStateParameters(plugin); 
    4950    for (size_t i = 0; i<pi->parameters; i++) {