Logo Search packages:      
Sourcecode: alsa-tools version File versions  Download package

routingwidget.cpp

/*
 *  qlo10k1 - GUI frontend for ld10k1
 *
 *  Copyright (c) 2004 by Peter Zubaj
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 */
 
#include <qdockarea.h>
#include <qtoolbutton.h>
#include <qspinbox.h>
#include <qregion.h>
#include <qpushbutton.h>
#include <qpainter.h>
#include <qtooltip.h>

#include "routingwidget.h"
#include "structure.h"
#include "strglobal.h"
#include "structure_io.h"
#include "structure_patch.h"

//icons
#include "icons/routing_fx.xpm"
#include "icons/routing_in.xpm"
#include "icons/routing_out.xpm"
#include "icons/routing_route.xpm"
#include "icons/routing_effect.xpm"
#include "icons/routing_effect_stack.xpm"
#include "icons/routing_zoom_plus.xpm"
#include "icons/routing_zoom_minus.xpm"
#include "icons/routing_normal.xpm"

class RoutingToolTip : public QToolTip
{
protected:
      virtual void maybeTip(const QPoint &p);
public:
      RoutingToolTip(QWidget *widget, QToolTipGroup *group = 0);
};

RoutingDrawWidget::RoutingDrawWidget(RoutingWidget *parent, const char *name, WFlags f)
      : QScrollView(parent, name, f)
{
      setFocusPolicy(QWidget::StrongFocus);
      resizeContents(4000,3000);
      this->viewport()->setEraseColor(QColor(255,255,255));
      resizeItem = NULL;
      
      mode = None;
      
      //enable tooltips
      new RoutingToolTip(this);
}

RoutingDrawWidget::~RoutingDrawWidget()
{
}

void RoutingDrawWidget::drawContents(QPainter* p, int cx, int cy, int cw, int ch)
{
      RoutingWidget *parent = (RoutingWidget *)parentWidget();
      StrGlobal *structure = parent->getStructure();
      
      if (!structure)
            return;
      
      RSItemBaseWithType *item;
      DrawingParams dp(parent->getZoomLevel(), this->viewport(), NULL, p);
      
      p->setFont(createFont(parent->getZoomLevel()));
            
      for(item = structure->UsedItems.first(); item; item = structure->UsedItems.next() )
      {
            if (item->flagNew() || item->flagChanged())
            {
                  item->calcSize();
                  item->setFlagNew(false);
                  item->setFlagChanged(false);
            }
            
            item->draw(&dp);
      }
      
      // if in link mode
      if (mode == DragLink)
      {
            QPainter p(this->viewport());
            int piox, pioy;
            int ex = selectEndPoint.x();
            int ey = selectEndPoint.y();
            
            ((StrPatch *)linkStart->getOwner())->getIOPoint(linkStart, &piox, &pioy);
            contentsToViewport(parent->zoomVal(piox), parent->zoomVal(pioy), piox, pioy);
            contentsToViewport(parent->zoomVal(ex), parent->zoomVal(ey), ex, ey);
            
            p.setPen(LINE_PEN);
            p.drawLine(QPoint(piox, pioy), QPoint(ex, ey));
            p.setPen(DEF_PAINTING_PEN);
      }
}

void RoutingDrawWidget::mousePressEvent(QMouseEvent *e)
{
      QScrollView::mousePressEvent(e);
      setFocus();
      
      RoutingWidget *parent = (RoutingWidget *)parentWidget();
      StrGlobal *structure = parent->getStructure();
      
      if (!structure)
            return;
            
      //treba prepocet na zoom a ofset qscrollview - a niekde to pada
      int xp = e->x();
      int yp = e->y();
      
      viewportToContents(xp, yp, xp, yp);
      
      xp = parent->deZoomVal(xp);
      yp = parent->deZoomVal(yp);
      
      RSItemBaseWithType *item;
      
      QPtrList <RSItemBaseWithType> toClear;
      
      if (e->button() == MidButton)
            return;

      if (mode == DragLink)
      {
            QPoint tmpp = mapToGlobal(QPoint(e->x(), e->y()));
            connectLinkDrag(xp, yp, tmpp.x(), tmpp.y());
            return;
      }
            
      // get mode
      if (parent->getWidgetMode() != RoutingWidget::Normal &&
            e->button() == LeftButton)
      {
            parent->putNewObjectAt(xp, yp);
            return;
      }
            
            
      // find item under this point
      bool oneSelected = false;
      bool clearOthers = false;
      
      RSItemBase::RSItemHandle resHandle = RSItemBase::None;
      RSItemBaseWithType *itemToResize = NULL;
      RSItemBaseWithType *itemOn = NULL;
      linkHandle = -1;
      
      for(item = structure->UsedItems.first(); item; item = structure->UsedItems.next())
      {
            bool redraw = false;
            
            if (!oneSelected && item->containsPoint(xp, yp))
            {
                  if (!item->flagSelected())
                  {
                        item->setFlagSelected(true);
                        redraw = true;
                        clearOthers = true;
                  }
                  else if (e->state() & Qt::ControlButton)
                  {
                        item->setFlagSelected(false);
                        redraw = true;
                  }
                  oneSelected = true;
                  
                  itemOn = item;
                  
                  // check resize point
                  resHandle = item->getHandlePoint(xp, yp);
                  if (resHandle == RSItemBase::Other)
                  {
                        itemToResize = item;
                        linkHandle = item->getHandlePointNum(xp, yp);
                  }
                  else
                  {
                        linkHandle = -1;              
                        if (resHandle != RSItemBase::None)
                              itemToResize = item;
                  }
            }
            else
            {
                  if (item->flagSelected())
                        toClear.append(item);
            }
                        
            if (redraw)
            {
                  this->updateContents(parent->zoomVal(item->x()),
                        parent->zoomVal(item->y()),
                        parent->zoomVal(item->width()),
                        parent->zoomVal(item->height()));
            }
      }
      
      EditMode newMode = None;
      RoutingWidget::MenuMode newMenuMode = RoutingWidget::MenuNone;
      
      parent->itemOn = NULL;
      
      bool doClearOthers = false;
      
      if (e->button() == LeftButton)
      {
            if (!oneSelected)
            {
                  // set select mode
                  newMode = Select;
            }
            else 
            {
                  if (e->state() & Qt::ControlButton)
                  {
                        newMode = None;
                  }
                  else
                  {
                        if (clearOthers)
                              doClearOthers = true;
                        if (itemToResize)
                        {
                              resizeItem = itemToResize;
                                    
                              if (linkHandle < 0)
                              {
                                    switch (resHandle)
                                    {
                                          case RSItemBase::TopLeft:
                                                newMode = ResizeTopLeft;
                                                break;
                                          case RSItemBase::TopRight:
                                                newMode = ResizeTopRight;
                                                break;
                                          case RSItemBase::BottomLeft:
                                                newMode = ResizeBottomLeft;
                                                break;
                                          case RSItemBase::BottomRight:
                                                newMode = ResizeBottomRight;
                                                break;
                                          default:
                                                break;
                                    }
                              }
                              else
                                    newMode = HandleMove;
                        }
                        else if(itemOn->type() != RSItemBaseWithType::Link)
                              newMode = Move;
                        else
                              newMode = None;
                  }
            }
      }
      else
      {
            if (!oneSelected)
            {
                  newMenuMode = RoutingWidget::MenuNone;
                  doClearOthers = true;
            }
            else
            {
                  if (clearOthers)
                  {
                        doClearOthers = true;
                  }
                        
                  if (!doClearOthers && toClear.count() > 0)
                        newMenuMode = RoutingWidget::MenuObjects;
                  else
                  {
                        switch (itemOn->type())
                        {
                              case RSItemBaseWithType::In:
                              case RSItemBaseWithType::Out:
                              case RSItemBaseWithType::FX:
                                    newMenuMode = RoutingWidget::MenuIO;
                                    break;
                              case RSItemBaseWithType::Link:
                                    newMenuMode = RoutingWidget::MenuLink;
                                    break;
                              case RSItemBaseWithType::Patch:
                                    newMenuMode = RoutingWidget::MenuPatch;
                                    break;
                              default:
                                    break;
                        }
                  }
            }
            
            parent->itemOn = itemOn;
            parent->posXOn = xp;
            parent->posYOn = yp;
      }
      
      if (doClearOthers)
      {
            for(item = toClear.first(); item; item = toClear.next())
            {
                  item->setFlagSelected(false);
                  
                  this->updateContents(parent->zoomVal(item->x()),
                        parent->zoomVal(item->y()),
                        parent->zoomVal(item->width()),
                        parent->zoomVal(item->height()));
            }           
      }
      
      if (e->button() == LeftButton)
            mode = newMode;
      else
      {
            QPoint p = mapToGlobal(QPoint(e->x(), e->y()));
            parent->openObjectMenuAt(itemOn, newMenuMode, xp, yp, p.x(), p.y());
      }
      
      selectStartPoint.setX(e->x());
      selectStartPoint.setY(e->y());
      selectEndPoint = selectStartPoint;

}

void RoutingDrawWidget::mouseMoveEvent(QMouseEvent *e)
{
      RoutingWidget *parent = (RoutingWidget *)parentWidget();
      StrGlobal *structure = parent->getStructure();
      
      if (!structure)
            return;
            
      if (mode == Select && 
            (e->x() != selectStartPoint.x() || e->y() != selectStartPoint.y()))
      {
            QPainter p(this->viewport());
            
            p.drawWinFocusRect(selectStartPoint.x(),
                  selectStartPoint.y(),
                  selectEndPoint.x() - selectStartPoint.x(),
                  selectEndPoint.y() - selectStartPoint.y());
                  
            selectEndPoint.setX(e->x());
            selectEndPoint.setY(e->y());
                  
            p.drawWinFocusRect(selectStartPoint.x(),
                  selectStartPoint.y(),
                  selectEndPoint.x() - selectStartPoint.x(),
                  selectEndPoint.y() - selectStartPoint.y());
      }
      else
      {
            int dx = parent->deZoomVal((selectEndPoint.x() - selectStartPoint.x()));
            int dy = parent->deZoomVal((selectEndPoint.y() - selectStartPoint.y()));
            
            if (mode == Move)
            {
                  RSItemBaseWithType *item;
                  for(item = structure->UsedItems.first(); item; item = structure->UsedItems.next() )
                  {
                        if (item->flagSelected())
                        {
                              // update old
                              item->updateContents(this, parent->getZoomLevel());
                                    
                              item->moveRel(dx, dy);
                              // update new
                              item->updateContents(this, parent->getZoomLevel());
                        }
                  }
            }
            else if (mode == HandleMove)
            {
                  // update old
                  resizeItem->updateContents(this, parent->getZoomLevel());
                        
                  resizeItem->moveHandleRel(linkHandle, dx, dy);
                  // update new
                  resizeItem->updateContents(this, parent->getZoomLevel());
            }
            else if (mode == ResizeTopLeft || 
                  mode == ResizeTopRight ||
                  mode == ResizeBottomLeft ||
                  mode == ResizeBottomRight)
            {
                  int nx = resizeItem->x();
                  int ny = resizeItem->y();
                  int nw = resizeItem->width();
                  int nh = resizeItem->height();
                                                
                  switch (mode)
                  {
                        case ResizeTopLeft:
                              nx = nx + dx;
                              ny = ny + dy;
                              nw = nw - dx;
                              nh = nh - dy;
                              break;
                        case ResizeTopRight:
                              ny = ny + dy;
                              nw = nw + dx;
                              nh = nh - dy;
                              break;
                        case ResizeBottomLeft:
                              nx = nx + dx;
                              nw = nw - dx;
                              nh = nh + dy;
                              break;
                        case ResizeBottomRight:
                              nw = nw + dx;
                              nh = nh + dy;
                              break;
                        default:
                              break;
                  }
                  
                  if (nx < 0)
                        nx = 0;
                  if (ny < 0)
                        ny = 0;

                  if (nw < resizeItem->minWidth())
                        nw = resizeItem->minWidth();
                  if (nh < resizeItem->minHeight())
                        nh = resizeItem->minHeight();
                        
                  resizeItem->updateContents(this, parent->getZoomLevel());

                  resizeItem->setPosition(nx, ny);
                  resizeItem->setSize(nw, nh);
                  // update new
                  resizeItem->updateContents(this, parent->getZoomLevel());
            }
            else if (mode == DragLink)
            {
                  updateDragLink();
            }
            
            selectStartPoint = selectEndPoint;
      
            selectEndPoint.setX(e->x());
            selectEndPoint.setY(e->y());
            
            if (mode == DragLink)
            {
                  int ex = selectEndPoint.x();
                  int ey = selectEndPoint.y();
                  
                  viewportToContents(parent->deZoomVal(ex), parent->deZoomVal(ey), ex, ey);
                  
                  selectEndPoint.setX(ex);
                  selectEndPoint.setY(ey);
            }
      }
}

void RoutingDrawWidget::updateDragLink()
{
      RoutingWidget *parent = (RoutingWidget *)parentWidget();
      
      int piox, pioy;
                  
      int ex = selectEndPoint.x();
      int ey = selectEndPoint.y();

      ((StrPatch *)linkStart->getOwner())->getIOPoint(linkStart, &piox, &pioy);
      
      QRect rect(QPoint(piox, pioy), QPoint(ex, ey));
      rect = rect.normalize();
      rect.setX(rect.x() - 1);
      rect.setY(rect.y() - 1);
      rect.setWidth(rect.width() + 2 * 1);
      rect.setHeight(rect.height() + 2 * 1);
      this->updateContents(parent->zoomVal(rect.x()),
            parent->zoomVal(rect.y()),
            parent->zoomVal(rect.width()),
            parent->zoomVal(rect.height()));
}

void RoutingDrawWidget::mouseReleaseEvent(QMouseEvent *e)
{
      RoutingWidget *parent = (RoutingWidget *)parentWidget();
      StrGlobal *structure = parent->getStructure();
      
      if (!structure)
            return;
            
      if (mode == Select)
      {
            selectEndPoint.setX(e->x());
            selectEndPoint.setY(e->y());
            
            QRect selArea(selectStartPoint, selectEndPoint);
            selArea = selArea.normalize();
            
            // transform
            int xt1;
            int yt1;
            
            int xt2;
            int yt2;
            
            viewportToContents(selArea.x(), selArea.y(), xt1, yt1);
            xt1 = parent->deZoomVal(xt1);
            yt1 = parent->deZoomVal(yt1);
            
            viewportToContents(selArea.right(), selArea.bottom(), xt2, yt2);
            xt2 = parent->deZoomVal(xt2);
            yt2 = parent->deZoomVal(yt2);
            
            // set flag for selected
            QRect selAreaTrans(QPoint(xt1, yt1), QPoint(xt2, yt2));
            
            RSItemBaseWithType *item;           
            for(item = structure->UsedItems.first(); item; item = structure->UsedItems.next() )
            {
                  if (selAreaTrans.contains(item->x(), item->y()) &&
                        selAreaTrans.contains(item->x() + item->width(), item->y() + item->height()))
                  {
                        if (!item->flagSelected())
                              item->setFlagSelected(true);
                  }
                  else
                  {
                        if (!(e->state() & Qt::ControlButton) && item->flagSelected()) 
                        {
                              item->setFlagSelected(false);
                              
                              this->updateContents(parent->zoomVal(item->x()),
                                    parent->zoomVal(item->y()),
                                    parent->zoomVal(item->width()),
                                    parent->zoomVal(item->height()));
                        }
                  }
                  
                  
            }
            
            //this->updateContents(selArea);
            this->viewport()->update(selArea);
      }
      
      if (mode != DragLink)
            mode = None;
}

void RoutingDrawWidget::keyPressEvent(QKeyEvent *e)
{
      if (e->key() == Key_Escape && isDragLink())
            stopLinkDrag();
      
      if (e->key() == Key_Delete && !isDragLink())
      {
            deleteAllSelected();
      }
}

void RoutingDrawWidget::startLinkDrag(RSItemIO *si, int xp, int yp)
{
      mode = DragLink;
      linkStart = si;
      
      selectStartPoint.setX(xp);
      selectStartPoint.setY(yp);
      selectEndPoint = selectStartPoint;
      
      setMouseTracking(true);
      viewport()->setMouseTracking(true);
}

void RoutingDrawWidget::stopLinkDrag()
{
      mode = None;
      updateDragLink();
}

QFont &RoutingDrawWidget::createFont(float zoom)
{
      //QFont f("Helvetica", 10 * zoom);
      titleFont.setStyleHint(QFont::Helvetica);
      titleFont.setPointSize((int)(10 * zoom));
      return titleFont;
}


RoutingWidget::RoutingWidget(QWidget *parent, const char *name, WFlags f)
      : QWidget(parent, name, f)
{
      structure = NULL;
      setFocusPolicy(QWidget::StrongFocus);

      RoutingWidgetLayout = new QVBoxLayout(this);

      createButtons();

      drawing = new RoutingDrawWidget(this);

      RoutingWidgetLayout->addWidget(drawing/*, 1, 1*/);
      drawing->setUpdatesEnabled(TRUE);

      widgetMode = Normal;
      toggleMode(widgetMode);

      setZoomLevel(1.00);
      updateZoomLevelCtrl(100);
}

void RoutingWidget::createButtons()
{
      QHBoxLayout *hbox = new QHBoxLayout(RoutingWidgetLayout);


      pbRoutingNormal = new QPushButton(this);
      pbRoutingNormal->setIconSet(QIconSet(QPixmap((const char**)routing_normal)));
      hbox->addWidget(pbRoutingNormal);
      pbRoutingNormal->setToggleButton(true);

      pbRoutingFX = new QPushButton(this);
      pbRoutingFX->setIconSet(QIconSet(QPixmap((const char**)routing_fx)));
      hbox->addWidget(pbRoutingFX);
      pbRoutingFX->setToggleButton(true);

      pbRoutingIn = new QPushButton(this);
      pbRoutingIn->setIconSet(QIconSet(QPixmap((const char**)routing_in)));
      hbox->addWidget(pbRoutingIn);
      pbRoutingIn->setToggleButton(true);

      pbRoutingOut = new QPushButton(this);
      pbRoutingOut->setIconSet(QIconSet(QPixmap((const char**)routing_out)));
      hbox->addWidget(pbRoutingOut);
      pbRoutingOut->setToggleButton(true);

      pbRoutingRoute = new QPushButton(this);
      pbRoutingRoute->setIconSet(QIconSet(QPixmap((const char**)routing_route)));
      hbox->addWidget(pbRoutingRoute);
      pbRoutingRoute->setToggleButton(true);

      pbRoutingEffect = new QPushButton(this);
      pbRoutingEffect->setIconSet(QIconSet(QPixmap((const char**)routing_effect)));
      hbox->addWidget(pbRoutingEffect);
      pbRoutingEffect->setToggleButton(true);

      pbRoutingEffectStack = new QPushButton(this);
      pbRoutingEffectStack->setIconSet(QIconSet(QPixmap((const char**)routing_effect_stack)));
      hbox->addWidget(pbRoutingEffectStack);
      pbRoutingEffectStack->setToggleButton(true);
      
      pbRoutingEffectStack->hide();

      QSpacerItem *spacer1 = new QSpacerItem(10, 0, QSizePolicy::Minimum, QSizePolicy::Minimum);
      hbox->addItem(spacer1);

      QPushButton *pbRoutingZoomPlus = new QPushButton(this);
      pbRoutingZoomPlus->setIconSet(QIconSet(QPixmap((const char**)routing_zoom_plus)));
      hbox->addWidget(pbRoutingZoomPlus);

      sbRoutingZoom = new QSpinBox(this);
      hbox->addWidget(sbRoutingZoom);
      sbRoutingZoom->setMinValue(10);
      sbRoutingZoom->setMaxValue(500);

      QPushButton *pbRoutingZoomMinus = new QPushButton(this);
      pbRoutingZoomMinus->setIconSet(QIconSet(QPixmap((const char**)routing_zoom_minus)));
      hbox->addWidget(pbRoutingZoomMinus);


      QSpacerItem *spacer = new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Minimum);
      hbox->addItem(spacer);

      connect(pbRoutingNormal, SIGNAL(clicked()), this, SLOT(modeNormalClicked()));
      connect(pbRoutingFX, SIGNAL(clicked()), this, SLOT(modeFxClicked()));
      connect(pbRoutingIn, SIGNAL(clicked()), this, SLOT(modeInClicked()));
      connect(pbRoutingOut, SIGNAL(clicked()), this, SLOT(modeOutClicked()));
      connect(pbRoutingRoute, SIGNAL(clicked()), this, SLOT(modeRouteClicked()));
      connect(pbRoutingEffect, SIGNAL(clicked()), this, SLOT(modeEffectClicked()));
      connect(pbRoutingEffectStack, SIGNAL(clicked()), this, SLOT(modeEffectStackClicked()));

      connect(sbRoutingZoom, SIGNAL(valueChanged(int)), this, SLOT(zoomValueChanged(int)));

      connect(pbRoutingZoomMinus, SIGNAL(clicked()), this, SLOT(zoomOutClicked()));
      connect(pbRoutingZoomPlus, SIGNAL(clicked()), this, SLOT(zoomInClicked()));
}

RoutingWidget::~RoutingWidget()
{
}

void RoutingWidget::untoggleMode(EditMode m)
{
      if (m != Normal)
            pbRoutingNormal->setOn(false);
      if (m != FX)
            pbRoutingFX->setOn(false);
      if (m != In)
            pbRoutingIn->setOn(false);
      if (m != Out)
            pbRoutingOut->setOn(false);
      if (m != Route)
            pbRoutingRoute->setOn(false);
      if (m != Effect)
            pbRoutingEffect->setOn(false);
      if (m != EffectStack)
            pbRoutingEffectStack->setOn(false);
}

void RoutingWidget::toggleMode(EditMode m)
{
      switch (m)
      {
            case Normal:
                  pbRoutingNormal->setOn(true);
                  break;
            case FX:
                  pbRoutingFX->setOn(true);
                  break;
            case In:
                  pbRoutingIn->setOn(true);
                  break;
            case Out:
                  pbRoutingOut->setOn(true);
                  break;
            case Route:
                  pbRoutingRoute->setOn(true);
                  break;
            case Effect:
                  pbRoutingEffect->setOn(true);
                  break;
            case EffectStack:
                  pbRoutingEffectStack->setOn(true);
                  break;
      }
}

void RoutingWidget::modeNormalClicked()
{
      widgetMode = Normal;
      toggleMode(widgetMode);
      untoggleMode(widgetMode);
}

void RoutingWidget::modeFxClicked()
{
      widgetMode = FX;
      toggleMode(widgetMode);
      untoggleMode(widgetMode);
}

void RoutingWidget::modeInClicked()
{
      widgetMode = In;
      toggleMode(widgetMode);
      untoggleMode(widgetMode);
}

void RoutingWidget::modeOutClicked()
{
      widgetMode = Out;
      toggleMode(widgetMode);
      untoggleMode(widgetMode);
}

void RoutingWidget::modeRouteClicked()
{
      widgetMode = Route;
      toggleMode(widgetMode);
      untoggleMode(widgetMode);
}

void RoutingWidget::modeEffectClicked()
{
      widgetMode = Effect;
      toggleMode(widgetMode);
      untoggleMode(widgetMode);
}

void RoutingWidget::modeEffectStackClicked()
{
      widgetMode = EffectStack;
      toggleMode(widgetMode);
      untoggleMode(widgetMode);
}

void RoutingWidget::setZoomLevel(float level)
{
      if (level < 0.10)
            level = 0.10;
      if (level > 5.00)
            level = 5.00;

      zoomLevel = level;
      drawing->viewport()->update();
      drawing->resizeContents((int)(4000 * zoomLevel), (int)(3000 * zoomLevel));
}

void RoutingWidget::updateZoomLevelCtrl(int level)
{
      sbRoutingZoom->setValue(level);
}

float RoutingWidget::getZoomLevel()
{
      return zoomLevel;
}

void RoutingWidget::zoomValueChanged(int value)
{
      setZoomLevel(value / 100.0);
}

void RoutingWidget::zoomInClicked()
{
      setZoomLevel(zoomLevel + 0.10);
      updateZoomLevelCtrl((int)(zoomLevel * 100));
}

void RoutingWidget::zoomOutClicked()
{
      setZoomLevel(zoomLevel - 0.10);
      updateZoomLevelCtrl((int)(zoomLevel * 100));
}

void RoutingWidget::refreshDrawing(StrGlobal *str)
{
      structure = str;
      
      drawing->updateContents();
}

RoutingWidget::EditMode RoutingWidget::getWidgetMode()
{
      return widgetMode;
}

void RoutingWidget::putNewObjectAt(int xp, int yp)
{
      RSItemBaseWithType *newItem = NULL;
      
      switch (widgetMode)
      {
            case FX:
            case In:
            case Out:
                  newItem = createNewIO(widgetMode);
                  if (widgetMode == FX)
                        structure->FXs.append((StrFX *)newItem);
                  else if (widgetMode == In)
                        structure->Inputs.append((StrInput *)newItem);
                  else
                        structure->Outputs.append((StrOutput *)newItem);
                  break;
            case Effect:
                  newItem = createNewPatch();
                  structure->updatePatchesOrder();
                  break;
            case Route:
                  if (!drawing->isDragLink())
                        startLinkDrag(xp, yp);
                  return;
            default:
                  break;
      }
      
      if (newItem)
      {
            if (newItem->type() != RSItemBaseWithType::Patch)
                  structure->UsedItems.append(newItem);
            newItem->setPosition(xp, yp);
            
            drawing->updateContents();
      
            //modeNormalClicked();
      }
}




RoutingToolTip::RoutingToolTip(QWidget *widget, QToolTipGroup *group) : QToolTip(widget, group)
{
}

void RoutingToolTip::maybeTip(const QPoint &p)
{
      RoutingDrawWidget *drawWidget = (RoutingDrawWidget *)parentWidget();
      RoutingWidget *parent = (RoutingWidget *)drawWidget->parentWidget();
      StrGlobal *structure = parent->getStructure();
      
      if (!structure)
            return;
            
      int i, j;
      // find object under cursor
      int xp = p.x();
      int yp = p.y();
      
      drawWidget->viewportToContents(xp, yp, xp, yp);
      
      xp = parent->deZoomVal(xp);
      yp = parent->deZoomVal(yp);
      
      RSItemBaseWithType *item;

      for(item = structure->UsedItems.first(); item; item = structure->UsedItems.next())
      {
            if (item->containsPoint(xp, yp))
            {
                  int ix;
                  int iy;
                  int iw;
                  int ih;
                  
                  QString tipText = "";
                  
                  StrInput *in = NULL;
                  StrOutput *out = NULL;
                  StrFX *fx = NULL;
                  StrPatch *patch = NULL;
                  
                  ix = item->x();
                  iy = item->y();
                  iw = item->width();
                  ih = item->height();
                  
                  RSItemIO *pio = NULL;
                  
                  switch(item->type())
                  {
                        case RSItemBaseWithType::In:
                              in = (StrInput *)item;
                              tipText = QString("Input: %1\nName: %2").arg(in->num()).arg(in->name());
                              break;
                        case RSItemBaseWithType::Out:
                              out = (StrOutput *)item;
                              tipText = QString("Output: %1\nName: %2").arg(out->num()).arg(out->name());
                              break;
                        case RSItemBaseWithType::FX:
                              fx = (StrFX *)item;
                              tipText = QString("FX: %1\nName: %2").arg(fx->num()).arg(fx->name());
                              break;
                        case RSItemBaseWithType::Patch:
                              patch = (StrPatch *)item;
                              
                              pio = patch->getIOAtPoint(xp, yp);
                              if (pio)
                              {
                                    if (pio->isOutput())
                                          tipText = QString("Patch output: %1\nOutput name: %2\n\n").arg(pio->getIdx()).arg(pio->getDesc());
                                    else
                                          tipText = QString("Patch input: %1\nInput name: %2\n\n").arg(pio->getIdx()).arg(pio->getDesc());
                                    
                                    QRect r;
                                    patch->getIORect(pio->isOutput(), pio->getIdx(), r);
                                    
                                    ix = r.x();
                                    iy = r.y();
                                    iw = r.width();
                                    ih = r.height();
                              }
                              else
                              {
                                    // create region without ios
                                    QRegion reg(ix, iy, iw, ih);
                                    QRect ior;
                                    
                                    for (j = 0; j < 2; j++)
                                    {
                                          for (i = 0; i < patch->getMaxIOIdx(j); i++)
                                          {
                                                patch->getIORect(j, i, ior);
                                                reg = reg.subtract(QRegion(ior));
                                          }
                                    }
                                    
                                    // find rect with point
                                    QMemArray<QRect> rects = reg.rects();
                                    
                                    for (i = 0; i < (int)rects.count(); i++)
                                    {
                                          if (rects[i].contains(xp, yp))
                                          {
                                                ix = rects[i].x();
                                                iy = rects[i].y();
                                                iw = rects[i].width();
                                                ih = rects[i].height();
                                                break;
                                          }
                                    }
                              }
                              
                              tipText = tipText + QString("Patch: %1\nOrder: %2\nName: %3").arg(patch->num()).arg(patch->order()).arg(patch->name());
                              break;
                        default:
                              break;
                  }
                  
                  if (tipText != "")
                  {
                        ix = parent->zoomVal(ix);
                        iy = parent->zoomVal(iy);
                        iw = parent->zoomVal(iw);
                        ih = parent->zoomVal(ih);
                  
                        drawWidget->contentsToViewport(ix, iy, ix, iy);
                        
                        tip(QRect(ix, iy, iw, ih), tipText);
                  }
            }
      }     
}

Generated by  Doxygen 1.6.0   Back to index