开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
SampleDisplay.cc
资源名称：cdrdao-1.1.3.src.tar.gz　[点击查看]
上传用户：weiliju62
上传日期：2007-01-06
资源大小：619k
文件大小：31k
源码类别：

SCSI/ASPI

开发平台：

MultiPlatform

SampleDisplay.cc：源码内容
  1. /*  cdrdao - write audio CD-Rs in disc-at-once mode
  2.  *
  3.  *  Copyright (C) 1998  Andreas Mueller <mueller@daneb.ping.de>
  4.  *
  5.  *  This program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2 of the License, or
  8.  *  (at your option) any later version.
  9.  *
  10.  *  This program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  *  GNU General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with this program; if not, write to the Free Software
  17.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  */
  19. /*
  20.  * $Log: SampleDisplay.cc,v $
  21.  * Revision 1.5  1999/08/07 16:27:28  mueller
  22.  * Applied patch from Yves Bastide:
  23.  * * prefixing member function names with their class name in connect_to_method
  24.  * * explicitly `const_cast'ing a cast to const
  25.  *
  26.  * Revision 1.4  1999/05/24 18:10:25  mueller
  27.  * Adapted to new reading interface of 'trackdb'.
  28.  *
  29.  * Revision 1.3  1999/01/30 19:45:43  mueller
  30.  * Fixes for compilation with Gtk-- 0.11.1.
  31.  *
  32.  * Revision 1.1  1998/11/20 18:55:22  mueller
  33.  * Initial revision
  34.  *
  35.  */
  37. static char rcsid[] = "$Id$";
  39. #include <stdio.h>
  40. #include <limits.h>
  41. #include <math.h>
  42. #include <assert.h>
  44. #include "TocEdit.h"
  45. #include "SampleDisplay.h"
  46. #include "SampleManager.h"
  47. #include "TrackManager.h"
  49. #include "Toc.h"
  50. #include "util.h"
  53. /* XPM data for track marker */
  54. #define TRACK_MARKER_XPM_WIDTH 9
  55. #define TRACK_MARKER_XPM_HEIGHT 12
  56. static gchar *TRACK_MARKER_XPM_DATA[] = {
  57.   "9 12 3 1",
  58.   "       c None",
  59.   "X      c #000000000000",
  60.   ".      c #FFFFFFFFFFFF",
  61.   "         ",
  62.   " XXXXXXX ",
  63.   " XXXXXXX ",
  64.   " XXXXXXX ",
  65.   " XXXXXXX ",
  66.   " XXXXXXX ",
  67.   " XXXXXXX ",
  68.   "  XXXXX  ",
  69.   "   XXX   ",
  70.   "    X    ",
  71.   "    X    ",
  72.   "    X    "};
  74. /* XPM data for index marker */
  75. static gchar *INDEX_MARKER_XPM_DATA[] = {
  76.   "9 12 3 1",
  77.   "       c None",
  78.   "X      c #000000000000",
  79.   ".      c #FFFFFFFFFFFF",
  80.   "         ",
  81.   " XXXXXXX ",
  82.   " X.....X ",
  83.   " X.....X ",
  84.   " X.....X ",
  85.   " X.....X ",
  86.   " X.....X ",
  87.   "  X...X  ",
  88.   "   X.X   ",
  89.   "    X    ",
  90.   "    X    ",
  91.   "    X    "};
  93. /* XPM data for extend track marker */
  94. static gchar *TRACK_EXTEND_XPM_DATA[] = {
  95.   "9 12 3 1",
  96.   "       c None",
  97.   "X      c #000000000000",
  98.   ".      c #FFFFFFFFFFFF",
  99.   "......XX.",
  100.   ".....XXX.",
  101.   "....XXXX.",
  102.   "...XXXXX.",
  103.   "..XXXXXX.",
  104.   ".XXXXXXX.",
  105.   "..XXXXXX.",
  106.   "...XXXXX.",
  107.   "....XXXX.",
  108.   ".....XXX.",
  109.   "......XX.",
  110.   "........."};
  112. /* XPM data for extend track marker */
  113. static gchar *INDEX_EXTEND_XPM_DATA[] = {
  114.   "9 12 3 1",
  115.   "       c None",
  116.   "X      c #000000000000",
  117.   ".      c #FFFFFFFFFFFF",
  118.   "......XX.",
  119.   ".....X.X.",
  120.   "....X..X.",
  121.   "...X...X.",
  122.   "..X....X.",
  123.   ".X.....X.",
  124.   "..X....X.",
  125.   "...X...X.",
  126.   "....X..X.",
  127.   ".....X.X.",
  128.   "......XX.",
  129.   "........."};
  132. SampleDisplay::SampleDisplay()
  133. {
  134.   adjustment_ = new Gtk_Adjustment(0.0, 0.0, 1.0);
  135.   connect_to_method(adjustment_->value_changed, this,
  136.     &SampleDisplay::scrollTo);
  138.   trackManager_ = NULL;
  140.   pixmap_ = NULL;
  141.   trackMarkerPixmap_ = indexMarkerPixmap_ = NULL;
  142.   trackMarkerSelectedPixmap_ = indexMarkerSelectedPixmap_ = NULL;
  143.   trackExtendPixmap_ = indexExtendPixmap_ = NULL;
  145.   drawGc_ = NULL;
  146.   timeTickFont_ = NULL;
  147.   trackMarkerFont_ = NULL;
  148.   width_ = height_ = chanHeight_ = lcenter_ = rcenter_ = 0;
  149.   timeLineHeight_ = timeLineY_ = 0;
  150.   timeTickWidth_ = 0;
  151.   timeTickSep_ = 20;
  152.   sampleStartX_ = sampleEndX_ = sampleWidthX_ = 0;
  153.   minSample_ = maxSample_ = resolution_ = 0;
  154.   tocEdit_ = NULL;
  156.   chanSep_ = 10;
  158.   cursorControlExtern_ = 0;
  159.   cursorDrawn_ = 0;
  160.   cursorX_ = 0;
  162.   markerSet_ = 0;
  163.   selectionSet_ = 0;
  164.   regionSet_ = 0;
  165.   dragMode_ = DRAG_NONE;
  167.   pickedTrackMarker_ = NULL;
  168.   selectedTrack_ = 0;
  169.   selectedIndex_ = 0;
  171.   connect_to_method(expose_event, this,
  172.                     &SampleDisplay::handle_expose_event);
  173.   connect_to_method(configure_event, this,
  174.                     &SampleDisplay::handle_configure_event);
  175.   connect_to_method(motion_notify_event, this,
  176.                     &SampleDisplay::handle_motion_notify_event);
  177.   connect_to_method(button_press_event, this,
  178.                     &SampleDisplay::handleButtonPressEvent);
  179.   connect_to_method(button_release_event, this,
  180.                     &SampleDisplay::handleButtonReleaseEvent);
  181.   connect_to_method(enter_notify_event, this,
  182.                     &SampleDisplay::handleEnterEvent);
  183.   connect_to_method(leave_notify_event, this,
  184.                     &SampleDisplay::handleLeaveEvent);
  185.   
  186.   //connect_to_method (motion_notify_event, this, &handle_motion_notify_event);
  187.   //connect_to_method (button_press_event, this, &handle_button_press_event);
  189.   set_events (GDK_EXPOSURE_MASK
  190.       | GDK_LEAVE_NOTIFY_MASK
  191.       | GDK_ENTER_NOTIFY_MASK
  192.       | GDK_BUTTON_PRESS_MASK
  193.       | GDK_BUTTON_RELEASE_MASK
  194.       | GDK_POINTER_MOTION_MASK
  195.       | GDK_POINTER_MOTION_HINT_MASK);
  196. }
  198. void SampleDisplay::setTocEdit(TocEdit *t)
  199. {
  200.   tocEdit_ = t;
  202.   Toc *toc = tocEdit_->toc();
  204.   markerSet_ = 0;
  205.   selectionSet_ = 0;
  206.   regionSet_ = 0;
  208.   minSample_ = 0;
  210.   if (toc->length().samples() > 0) {
  211.     maxSample_ = toc->length().samples() - 1;
  212.   }
  213.   else {
  214.     maxSample_ = 0;
  215.   }
  216. }
  218. void SampleDisplay::updateToc()
  219. {
  220.   Toc *toc = tocEdit_->toc();
  222.   if (toc->length().samples() == 0) {
  223.     minSample_ = maxSample_ = 0;
  224.   }
  225.   else {
  226.     if (maxSample_ >= toc->length().samples()) {
  227.       // adjust 'maxSample_' to reduced length
  228.       unsigned long len = maxSample_ - minSample_;
  230.       maxSample_ = toc->length().samples() - 1;
  231.       if (maxSample_ > len) {
  232. minSample_ = maxSample_ - len;
  233.       }
  234.       else {
  235. minSample_ = 0;
  236.       }
  237.     }
  238.   }
  240.   setView(minSample_, maxSample_);
  241. }
  243. void SampleDisplay::setView(unsigned long start, unsigned long end)
  244. {
  245.   Toc *toc = tocEdit_->toc();
  247.   if (end < start)
  248.     end = start;
  250.   unsigned long len = end - start + 1;
  252.   if (len < 3 && toc != NULL) {
  253.     end = start + 2;
  255.     if (end >= toc->length().samples()) {
  256.       if (toc->length().samples() != 0)
  257. end = toc->length().samples() - 1;
  258.       else
  259. end = 0;
  261.       if (end <= 2)
  262. start = 0;
  263.       else 
  264. start = end - 2;
  265.     }
  266.     
  267.     len = (end == 0 ? 0 : 3);
  268.   }
  270.   minSample_ = start;
  271.   maxSample_ = end;
  273.   updateSamples();
  274.   redraw(0, 0, width_, height_, 0);
  276.   GtkAdjustment *adjust = adjustment_->gtkobj();
  277.   if (toc == NULL) {
  278.     adjust->lower = 0.0;
  279.     adjust->upper = 1.0;
  280.     adjust->value = 0.0;
  281.     adjust->page_size = 0.0;
  282.   }
  283.   else {
  284.     adjust->lower = 0.0;
  285.     adjust->upper = toc->length().samples();
  286.     adjust->value = minSample_;
  288.     adjust->step_increment = len / 4;
  289.     if (adjust->step_increment == 0.0)
  290.       adjust->step_increment = 1.0;
  292.     adjust->page_increment = len / 1.1;
  293.     adjust->page_size = len;
  294.   }
  295.   adjustment_->changed();
  296.   
  297. }
  299. void SampleDisplay::getView(unsigned long *start, unsigned long *end)
  300. {
  301.   *start = minSample_;
  302.   *end = maxSample_;
  303. }
  305. int SampleDisplay::getSelection(unsigned long *start, unsigned long *end)
  306. {
  307.   if (selectionSet_) {
  308.     *start = selectionStartSample_;
  309.     *end = selectionEndSample_;
  310.     return 1;
  311.   }
  312.   
  313.   return 0;
  314. }
  316. int SampleDisplay::getMarker(unsigned long *sample)
  317. {
  318.   if (markerSet_) {
  319.     *sample = markerSample_;
  320.     return 1;
  321.   }
  323.   return 0;
  324. }
  326. void SampleDisplay::setSelectedTrackMarker(int trackNr, int indexNr)
  327. {
  328.   selectedTrack_ = trackNr;
  329.   selectedIndex_ = indexNr;
  330. }
  332. void SampleDisplay::setRegion(unsigned long start, unsigned long end)
  333. {
  334.   Toc *toc = tocEdit_->toc();
  336.   if (end <= start || end >= toc->length().samples()) {
  337.     regionSet_ = 0;
  338.   }
  339.   else {
  340.     regionStartSample_ = start;
  341.     regionEndSample_ = end;
  342.     regionSet_ = 1;
  343.   }
  345.   setView(minSample_, maxSample_);
  347. }
  349. int SampleDisplay::getRegion(unsigned long *start, unsigned long *end)
  350. {
  351.   if (regionSet_) {
  352.     *start = regionStartSample_;
  353.     *end = regionEndSample_;
  354.     return 1;
  355.   }
  357.   return 0;
  358. }
  360. void SampleDisplay::setCursor(int ctrl, unsigned long sample)
  361. {
  362.   if (ctrl == 0) {
  363.     cursorControlExtern_ = 0;
  364.   }
  365.   else {
  366.     cursorControlExtern_ = 1;
  368.     gint x = sample2pixel(sample);
  369.     if (x >= 0)
  370.       drawCursor(x);
  371.     else
  372.       undrawCursor();
  373.   }
  374. }
  376. void SampleDisplay::getColor(const char *colorName, Gdk_Color *color)
  377. {
  378.   if (!color->parse(colorName) || !get_colormap().alloc(*color)) {
  379.     message(-1, "Cannot allocate color "%s"", colorName);
  380.     *color = get_colormap().black();
  381.   }
  382. }
  384. void SampleDisplay::scrollTo()
  385. {
  386.   Toc *toc = tocEdit_->toc();
  387.   GtkAdjustment *adjust = adjustment_->gtkobj();
  389.   if (adjust->page_size == 0.0)
  390.     return;
  392.   minSample_ = (unsigned long)adjust->value;
  393.   maxSample_ = (unsigned long)(adjust->value + adjust->page_size) - 1;
  395.   if (maxSample_ >= toc->length().samples()) {
  396.     maxSample_ = toc->length().samples() - 1;
  397.     if (maxSample_ <= (unsigned long)(adjust->page_size - 1))
  398.       minSample_ = 0;
  399.     else 
  400.       minSample_ = maxSample_ - (unsigned long)(adjust->page_size - 1);
  401.   }
  403.   updateSamples();
  404.   redraw(0, 0, width_, height_, 0);
  405. }
  407. unsigned long SampleDisplay::pixel2sample(gint x)
  408. {
  409.   Toc *toc = tocEdit_->toc();
  410.   unsigned long sample;
  412.   if (toc->length().lba() == 0)
  413.     return 0;
  415.   assert(x >= sampleStartX_ && x <= sampleEndX_);
  417.   x -= sampleStartX_;
  419.   double res = maxSample_ - minSample_;
  420.   res /= sampleWidthX_ - 1;
  422.   sample = (unsigned long)(minSample_ + res * x + 0.5);
  424.   unsigned long round = 75 * 588; // 1 second
  425.   unsigned long rest;
  427.   if (res >=  2 * round) {
  428.     if ((rest = sample % round) != 0)
  429.       sample += round - rest;
  430.   }
  431.   else {
  432.     round = 588; // 1 block
  433.     if (res >= 2 * round) {
  434.       if ((rest = sample % round) != 0)
  435. sample += round - rest;
  436.     }
  437.   }
  439.   if (sample > maxSample_)
  440.     sample = maxSample_;
  442.   return sample;
  443. }
  445. gint SampleDisplay::sample2pixel(unsigned long sample)
  446. {
  447.   if (sample < minSample_ || sample > maxSample_)
  448.     return -1;
  450.   unsigned long len = maxSample_ - minSample_;
  451.   double val = sample - minSample_;
  453.   val *= sampleWidthX_ - 1;
  454.   val /= len;
  456.   return (gint)(sampleStartX_ + val + 0.5);
  457. }
  459. int SampleDisplay::handle_configure_event (GdkEventConfigure *event)
  460. {
  461.   if (drawGc_ == NULL) {
  462.     Gdk_Bitmap mask;
  463.     Gdk_Window window(get_window());
  465.     drawGc_ = new Gdk_GC(window);
  466.     getColor("darkslateblue", &sampleColor_);
  467.     getColor("red3", &middleLineColor_);
  468.     getColor("gold2", &cursorColor_);
  469.     getColor("red", &markerColor_);
  470.     getColor("#ffc0e0", &selectionBackgroundColor_);
  472.     timeTickFont_ = new Gdk_Font("fixed");
  473.     drawGc_->set_font(*timeTickFont_);
  475.     trackMarkerFont_ = timeTickFont_;
  477.     timeLineHeight_ = timeTickFont_->char_height('0') + 6;
  478.     trackLineHeight_ = timeTickFont_->char_height('0') + 10;
  480.     trackMarkerPixmap_ = new Gdk_Pixmap;
  481.     trackMarkerPixmap_->create_from_xpm_d(window, mask,
  482.   get_colormap().white(),
  483.   TRACK_MARKER_XPM_DATA);
  484.     indexMarkerPixmap_ = new Gdk_Pixmap;
  485.     indexMarkerPixmap_->create_from_xpm_d(window, mask,
  486.   get_colormap().white(),
  487.   INDEX_MARKER_XPM_DATA);
  488.     trackMarkerSelectedPixmap_ = new Gdk_Pixmap;
  489.     trackMarkerSelectedPixmap_->create_from_xpm_d(window, mask,
  490.   markerColor_,
  491.   TRACK_MARKER_XPM_DATA);
  492.     indexMarkerSelectedPixmap_ = new Gdk_Pixmap;
  493.     indexMarkerSelectedPixmap_->create_from_xpm_d(window, mask,
  494.   markerColor_,
  495.   INDEX_MARKER_XPM_DATA);
  496.     trackExtendPixmap_ = new Gdk_Pixmap;
  497.     trackExtendPixmap_->create_from_xpm_d(window, mask,
  498.   get_colormap().white(),
  499.   TRACK_EXTEND_XPM_DATA);
  500.     indexExtendPixmap_ = new Gdk_Pixmap;
  501.     indexExtendPixmap_->create_from_xpm_d(window, mask,
  502.   get_colormap().white(),
  503.   INDEX_EXTEND_XPM_DATA);
  505.     trackMarkerWidth_ = trackMarkerWidth();
  506.     trackManager_ = new TrackManager(TRACK_MARKER_XPM_WIDTH);
  507.   }
  509.   width_ = width();
  510.   height_ = height();
  511.   chanHeight_ = (height_ - timeLineHeight_ - trackLineHeight_ - 2) / 2;
  513.   lcenter_ = chanHeight_ / 2 + trackLineHeight_;
  514.   rcenter_ = lcenter_ + timeLineHeight_ + chanHeight_;
  516.   trackLineY_ = trackLineHeight_ - 1;
  518.   timeLineY_ = chanHeight_ + timeLineHeight_ + trackLineHeight_;
  519.   timeTickWidth_ = timeTickWidth();
  521.   sampleStartX_ = 10;
  522.   sampleEndX_ = width_ - 10;
  523.   sampleWidthX_ = sampleEndX_ - sampleStartX_ + 1;
  524.   
  525.   if (pixmap_ != NULL)
  526.     delete pixmap_;
  528.   pixmap_ = new Gdk_Pixmap(get_window(), width(), height(), -1);
  530.   //message(0, "handle_configure_event: %dn", width_);
  532.   updateSamples();
  534.   return TRUE;
  535. }
  538. int SampleDisplay::handle_expose_event (GdkEventExpose *event)
  539. {
  540.   redraw(event->area.x, event->area.y, event->area.width, event->area.height,
  541.  0);
  543.   return FALSE;
  544. }
  546. int SampleDisplay::handleButtonPressEvent(GdkEventButton *event)
  547. {
  548.   gint x = (gint)event->x;
  549.   gint y = (gint)event->y;
  551.   dragMode_ = DRAG_NONE;
  553.   if (cursorControlExtern_)
  554.     return TRUE;
  556.   if (event->button == 1 && x >= sampleStartX_ && x <= sampleEndX_) {
  557.     if (y > trackLineY_) {
  558.       dragMode_ = DRAG_SAMPLE_MARKER;
  559.       dragStart_ = dragEnd_ = x;
  560.     }
  561.     else {
  562.       if ((pickedTrackMarker_ = trackManager_->pick(x - sampleStartX_ + 4,
  563.     &dragStopMin_,
  564.     &dragStopMax_)) != NULL) {
  565. dragMode_ = DRAG_TRACK_MARKER;
  566. dragStart_ = dragEnd_ = x;
  567. dragLastX_ = -1;
  568. dragStopMin_ += sampleStartX_;
  569. dragStopMax_ += sampleStartX_;
  570.       }
  571.     }
  573.   }
  575.   return TRUE;
  576. }
  578. int SampleDisplay::handleButtonReleaseEvent(GdkEventButton *event)
  579. {
  580.   gint x = (gint)event->x;
  582.   if (cursorControlExtern_)
  583.     return TRUE;
  585.   if (x < sampleStartX_) {
  586.     x = sampleStartX_;
  587.   }
  588.   else if (x > sampleEndX_) {
  589.     x = sampleEndX_;
  590.   }
  592.   if (event->button == 1 && dragMode_ != DRAG_NONE) {
  593.     if (dragMode_ == DRAG_SAMPLE_MARKER) {
  594.       if (dragStart_ - x >= -5 && dragStart_ - x <= 5) {
  595. markerSet(pixel2sample(dragStart_));
  596.       }
  597.       else {
  598. selectionSet_ = 1;
  599. if (x > dragStart_) {
  600.   selectionStartSample_ = pixel2sample(dragStart_);
  601.   selectionEndSample_ = pixel2sample(x);
  602.   selectionStart_ = dragStart_;
  603.   selectionEnd_ = x;
  604. }
  605. else {
  606.   selectionEndSample_ = pixel2sample(dragStart_);
  607.   selectionStartSample_ = pixel2sample(x);
  608.   selectionEnd_ = dragStart_;
  609.   selectionStart_ = x;
  610. }
  611. selectionSet(selectionStartSample_, selectionEndSample_);
  612.       }
  613.     }
  614.     else if (dragMode_ == DRAG_TRACK_MARKER) {
  615.       if (dragStart_ - x >= -5 && dragStart_ - x <= 5) {
  616. trackManager_->select(pickedTrackMarker_);
  617. selectedTrack_ = pickedTrackMarker_->trackNr;
  618. selectedIndex_ = pickedTrackMarker_->indexNr;
  619. drawTrackLine();
  620. trackMarkSelected(pickedTrackMarker_->track, selectedTrack_,
  621.   selectedIndex_);
  622.       }
  623.       else {
  624. selectedTrack_ = pickedTrackMarker_->trackNr;
  625. selectedIndex_ = pickedTrackMarker_->indexNr;
  626. trackMarkMoved(pickedTrackMarker_->track, selectedTrack_,
  627.        selectedIndex_, pixel2sample(x));
  628.       }
  629.       pickedTrackMarker_ = NULL;
  630.     }
  632.     dragMode_ = DRAG_NONE;
  633.     drawCursor(x);
  634.     redraw(0, 0, width_, height_, 0);
  635.   }
  637.   return TRUE;
  638. }
  640. int SampleDisplay::handle_motion_notify_event (GdkEventMotion *event)
  641. {
  642.   gint x, y;
  643.   GdkModifierType state;
  645.   if (cursorControlExtern_)
  646.     return TRUE;
  647.   
  648.   if (event->is_hint)
  649.     gdk_window_get_pointer (event->window, &x, &y, &state);
  650.   else {
  651.     x = (gint)event->x;
  652.     y = (gint)event->y;
  653.     state = (GdkModifierType) event->state;
  654.   }
  657.   if (dragMode_ == DRAG_SAMPLE_MARKER) {
  658.     gint dw = 0;
  659.     gint dx;
  661.     if (x < sampleStartX_)
  662.       x = sampleStartX_;
  663.     else if (x > sampleEndX_)
  664.       x = sampleEndX_;
  665.     
  666.     if (selectionEnd_ > dragStart_) {
  667.       if (x < selectionEnd_) {
  668. redraw(x + 1, 0, selectionEnd_ - x, height_, 0x01);
  669. if (x < dragStart_) {
  670.   dw = dragStart_ - x + 1;
  671.   dx = x;
  672. }
  673.       }
  674.       else {
  675. dw = x - selectionEnd_;
  676. dx = selectionEnd_ + 1;
  677.       }
  678.     }
  679.     else if (selectionEnd_ < dragStart_) {
  680.       if (x > selectionEnd_) {
  681. redraw(selectionEnd_, 0, x - selectionEnd_, height_, 0x01);
  682. if (x > dragStart_) {
  683.   dw = x - dragStart_ + 1;
  684.   dx = dragStart_;
  685. }
  686.       }
  687.       else {
  688. dw = selectionEnd_ - x;
  689. dx = x;
  690.       }
  691.     }
  693.     if (dw != 0) {
  694.       drawGc_->set_foreground(cursorColor_);
  695.       drawGc_->set_function(GDK_XOR);
  696.       get_window().draw_rectangle(*drawGc_, TRUE, dx, 0, dw, height_ - 1);
  697.       drawGc_->set_function(GDK_COPY);
  698.     }      
  700.     selectionEnd_ = x;
  701.   }
  702.   else if (dragMode_ == DRAG_TRACK_MARKER) {
  703.     if (x < dragStopMin_)
  704.       x = dragStopMin_;
  706.     if (x > dragStopMax_)
  707.       x = dragStopMax_;
  709.     if (dragLastX_ > 0) {
  710.       drawTrackMarker(2, dragLastX_, 0, 0, 0, 0);
  711.     }
  712.     drawTrackMarker(1, x, pickedTrackMarker_->trackNr,
  713.     pickedTrackMarker_->indexNr, 0, 0);
  714.     dragLastX_ = x;
  715.     drawCursor(x);
  716.   }
  717.   else {
  718.     drawCursor(x);
  719.   }
  720.   
  721.   return TRUE;
  722. }
  724. int SampleDisplay::handleEnterEvent(GdkEventCrossing *event)
  725. {
  726.   if (cursorControlExtern_)
  727.     return TRUE;
  729.   drawCursor((gint)event->x);
  730.   return TRUE;
  731. }
  733. int SampleDisplay::handleLeaveEvent(GdkEventCrossing *event)
  734. {
  735.   if (cursorControlExtern_)
  736.     return TRUE;
  738.   undrawCursor();
  739.   return TRUE;
  740. }
  742. // drawMask: 0x01: do not draw cursor
  743. //           0x02: do not draw marker
  744. void SampleDisplay::redraw(gint x, gint y, gint width, gint height,
  745.    int drawMask)
  746. {
  747.   get_window().draw_pixmap(*drawGc_, *pixmap_, x, y, x, y, width, height);
  749.   if ((drawMask & 0x02) == 0)
  750.     drawMarker();
  752.   if ((drawMask & 0x01) == 0 && cursorDrawn_) {
  753.     cursorDrawn_ = 0;
  754.     drawCursor(cursorX_);
  755.   }
  756. }
  758. void SampleDisplay::drawMarker()
  759. {
  760.   if (markerSet_) {
  761.     drawGc_->set_foreground(markerColor_);
  763.     markerX_ = sample2pixel(markerSample_);
  764.     if (markerX_ >= 0) 
  765.       get_window().draw_line(*drawGc_, markerX_, trackLineY_,
  766.      markerX_, height_ - 1);
  767.   }
  768. }
  770. void SampleDisplay::setMarker(unsigned long sample)
  771. {
  772.   if (markerSet_)
  773.     redraw(markerX_, 0, 1, height_, 0x02);
  775.   markerSample_ = sample;
  776.   markerSet_ = 1;
  777.   drawMarker();
  778. }
  780. void SampleDisplay::clearMarker()
  781. {
  782.   if (markerSet_)
  783.     redraw(markerX_, 0, 1, height_, 0x02);
  785.   markerSet_ = 0;
  786. }
  789. void SampleDisplay::updateSamples()
  790. {
  791.   Toc *toc = tocEdit_->toc();
  793.   if (pixmap_ == NULL)
  794.     return;
  796.   gint halfHeight = chanHeight_ / 2;
  798.   drawGc_->set_foreground(get_colormap().white());
  799.   pixmap_->draw_rectangle(*drawGc_, TRUE, 0, 0, width_, height_);
  800.   
  801.   long res = (maxSample_ - minSample_ + 1)/sampleWidthX_;
  802.   long bres = res / tocEdit_->sampleManager()->blocking();
  803.   gint i;
  804.   double pos;
  805.   long j;
  806.   unsigned long s;
  807.   short lnegsum, lpossum, rnegsum, rpossum;
  808.   gint regionStart = -1;
  809.   gint regionEnd = -1;
  810.   int regionActive = 0;
  812.   if (regionSet_) {
  813.     if (regionStartSample_ <= maxSample_ &&
  814. regionEndSample_ >= minSample_) {
  816.       if (regionStartSample_ > minSample_)
  817. regionStart = sample2pixel(regionStartSample_);
  818.       else
  819. regionStart = sampleStartX_;
  821.       if (regionEndSample_ < maxSample_)
  822. regionEnd = sample2pixel(regionEndSample_);
  823.       else
  824. regionEnd = sampleEndX_;
  825.     }
  827.     if (regionStart >= 0 && regionEnd >= regionStart) {
  828.       drawGc_->set_foreground(selectionBackgroundColor_);
  829.       pixmap_->draw_rectangle(*drawGc_, TRUE,
  830.       regionStart, lcenter_ - halfHeight,
  831.       regionEnd - regionStart + 1, chanHeight_);
  832.       pixmap_->draw_rectangle(*drawGc_, TRUE,
  833.       regionStart, rcenter_ - halfHeight,
  834.       regionEnd - regionStart + 1, chanHeight_);
  835.     }
  836.   }
  838.   drawGc_->set_foreground(sampleColor_);
  840.   if (bres > 0) {
  841.     //message(0, "Draw 1");
  842.     for (s = minSample_, i = sampleStartX_;
  843.  s < maxSample_ && i <= sampleEndX_;
  844.  s += res, i++) {
  845.       lnegsum = lpossum = rnegsum = rpossum = 0;
  847.       if (regionStart != -1 && i >= regionStart && regionActive == 0) {
  848. regionActive = 1;
  849. drawGc_->set_foreground(markerColor_);
  850.       }
  851.       else if (regionActive == 1 && i > regionEnd) {
  852. regionActive = 2;
  853. drawGc_->set_foreground(sampleColor_);
  854.       }
  856.       tocEdit_->sampleManager()->getPeak(s, s + res, &lnegsum, &lpossum,
  857.  &rnegsum, &rpossum);
  859.       pos = double(lnegsum) * halfHeight;
  860.       pos /= SHRT_MAX;
  861.       //pos /= bres;
  862.       if (pos != 0)
  863. pixmap_->draw_line(*drawGc_, i, lcenter_, i, lcenter_ - (gint)pos);
  864.       
  865.       pos = double(lpossum) * halfHeight;
  866.       pos /= SHRT_MAX;
  867.       //pos /= bres;
  868.       if (pos != 0)
  869. pixmap_->draw_line(*drawGc_, i, lcenter_, i, lcenter_ - (gint)pos);
  870.       
  871.       pos = double(rnegsum) * halfHeight;
  872.       pos /= SHRT_MAX;
  873.       //pos /= bres;
  874.       if (pos != 0)
  875. pixmap_->draw_line(*drawGc_, i, rcenter_, i, rcenter_ - (gint)pos);
  876.       
  877.       pos = double(rpossum) * halfHeight;
  878.       pos /= SHRT_MAX;
  879.       //pos /= bres;
  880.       if (pos != 0)
  881. pixmap_->draw_line(*drawGc_, i, rcenter_, i, rcenter_ - (gint)pos);
  882.     }
  883.   }
  884.   else if (maxSample_ > 0 && res >= 1) {
  885.     //message(0, "Draw 2: %ld < %ld", res,
  886.     //        tocEdit_->sampleManager()->blocking());
  887.     TocReader reader(toc);
  889.     if (reader.openData() == 0) {
  890.       Sample *sampleBuf = new Sample[tocEdit_->sampleManager()->blocking()];
  891.       double dres = double(maxSample_ - minSample_ + 1)/double(sampleWidthX_);
  892.       double ds;
  894.       for (ds = minSample_, i = sampleStartX_;
  895.    ds < maxSample_ && i <= sampleEndX_;
  896.    ds += dres, i++) {
  898. lnegsum = lpossum = rnegsum = rpossum = 0;
  900. if (reader.seekSample((long)ds) == 0 &&
  901.     reader.readSamples(sampleBuf, res) == res) {
  902.   for (j = 0; j < res; j++) {
  903.     if (sampleBuf[j].left() < lnegsum)
  904.       lnegsum = sampleBuf[j].left();
  906.     if (sampleBuf[j].left() > lpossum)
  907.       lpossum = sampleBuf[j].left();
  909.     if (sampleBuf[j].right() < rnegsum)
  910.       rnegsum = sampleBuf[j].right();
  912.     if (sampleBuf[j].right() > rpossum)
  913.       rpossum = sampleBuf[j].right();
  914.   }
  915. }
  917. if (regionStart != -1 && i >= regionStart && regionActive == 0) {
  918.   regionActive = 1;
  919.   drawGc_->set_foreground(markerColor_);
  920. }
  921. else if (regionActive == 1 && i > regionEnd) {
  922.   regionActive = 2;
  923.   drawGc_->set_foreground(sampleColor_);
  924. }
  926. pos = double(lnegsum) * halfHeight;
  927. pos /= SHRT_MAX;
  928. //pos /= bres;
  929. if (pos != 0)
  930.   pixmap_->draw_line(*drawGc_, i, lcenter_, i, lcenter_ - (gint)pos);
  931.       
  932. pos = double(lpossum) * halfHeight;
  933. pos /= SHRT_MAX;
  934. //pos /= bres;
  935. if (pos != 0)
  936.   pixmap_->draw_line(*drawGc_, i, lcenter_, i, lcenter_ - (gint)pos);
  938. pos = double(rnegsum) * halfHeight;
  939. pos /= SHRT_MAX;
  940. //pos /= bres;
  941. if (pos != 0)
  942.   pixmap_->draw_line(*drawGc_, i, rcenter_, i, rcenter_ - (gint)pos);
  944. pos = double(rpossum) * halfHeight;
  945. pos /= SHRT_MAX;
  946. //pos /= bres;
  947. if (pos != 0)
  948.   pixmap_->draw_line(*drawGc_, i, rcenter_, i, rcenter_ - (gint)pos);
  949.       }
  951.       delete[] sampleBuf;
  952.       reader.closeData();
  953.     }
  954.   }
  955.   else if (toc != NULL && maxSample_ > minSample_ + 1) {
  956.     //message(0, "Draw 3");
  958.     TocReader reader(toc);
  960.     if (reader.openData() == 0) {
  961.       long len = maxSample_ - minSample_ + 1;
  962.       Sample *sampleBuf = new Sample[len];
  963.       double pres = double(sampleWidthX_ - 1) / double(len - 1);
  964.       double di;
  965.       gint pos1;
  966.       gint lastPosLeft, lastPosRight;
  968.       //printf("Drawing exact, res=%ld pres=%g %ld-%ldn", res, pres, minSample_, maxSample_);
  970.       if (reader.seekSample(minSample_) == 0 &&
  971.   reader.readSamples(sampleBuf, len) == len) {
  972. //printf("Drawing exact1n");
  974. for (j = 1, di = sampleStartX_ + pres;
  975.      j < len && di < sampleEndX_ + 1; j++, di += pres) {
  976.   if (regionStart != -1 && regionActive == 0 &&
  977.       minSample_ + j - 1 >= regionStartSample_ &&
  978.       minSample_ + j <= regionEndSample_) {
  979.     regionActive = 1;
  980.     drawGc_->set_foreground(markerColor_);
  981.   }
  982.   else if (regionActive == 1 && minSample_ + j > regionEndSample_) {
  983.     regionActive = 2;
  984.     drawGc_->set_foreground(sampleColor_);
  985.   }
  987.   pos = sampleBuf[j - 1].left() * halfHeight;
  988.   pos /= SHRT_MAX;
  990.   pos1 = sampleBuf[j].left() * halfHeight;
  991.   pos1 /= SHRT_MAX;
  992.   lastPosLeft = pos1;
  994.   if (pos != 0 || pos1 != 0)
  995.     pixmap_->draw_line(*drawGc_, long(di - pres), lcenter_ - (gint)pos,
  996.        long(di), lcenter_ - pos1);
  998.   pos = sampleBuf[j - 1].right() * halfHeight;
  999.   pos /= SHRT_MAX;
  1001.   pos1 = sampleBuf[j].right() * halfHeight;
  1002.   pos1 /= SHRT_MAX;
  1003.   lastPosRight = pos1;
  1005.   if (pos != 0 || pos1 != 0)
  1006.     pixmap_->draw_line(*drawGc_, long(di - pres), rcenter_ - (gint)pos,
  1007.        long(di), rcenter_ - pos1);
  1008. }
  1010. if (0 && (gint)di < sampleEndX_) {
  1011.   pos = sampleBuf[len -1].left() * halfHeight;
  1012.   pos /= SHRT_MAX;
  1013.   if (pos != 0 || lastPosLeft != 0)
  1014.     pixmap_->draw_line(*drawGc_, long(di), lcenter_ - lastPosLeft, 
  1015.        sampleEndX_, lcenter_ - (gint)pos);
  1016.   
  1017.   pos = sampleBuf[len - 1].right() * halfHeight;
  1018.   pos /= SHRT_MAX;
  1019.   if (pos != 0 || lastPosRight != 0)
  1020.     pixmap_->draw_line(*drawGc_, long(di), rcenter_ - lastPosRight,
  1021.        sampleEndX_, rcenter_ - (gint)pos);
  1022. }
  1023.       }
  1025.       delete[] sampleBuf;
  1026.     }
  1027.   }
  1030.   drawGc_->set_foreground(middleLineColor_);
  1032.   pixmap_->draw_line(*drawGc_, sampleStartX_, lcenter_, sampleEndX_, lcenter_);
  1033.   pixmap_->draw_line(*drawGc_, sampleStartX_, rcenter_, sampleEndX_, rcenter_);
  1035.   drawGc_->set_foreground(get_colormap().black());
  1037.   pixmap_->draw_line(*drawGc_, sampleStartX_ - 1, lcenter_ - halfHeight,
  1038.      sampleEndX_ + 1, lcenter_ - halfHeight);
  1039.   pixmap_->draw_line(*drawGc_, sampleStartX_ - 1, lcenter_ + halfHeight,
  1040.      sampleEndX_ + 1, lcenter_ + halfHeight);
  1041.   pixmap_->draw_line(*drawGc_, sampleStartX_ - 1, lcenter_ - halfHeight,
  1042. sampleStartX_ - 1, lcenter_ + halfHeight);
  1043.   pixmap_->draw_line(*drawGc_, sampleEndX_ + 1, lcenter_ - halfHeight,
  1044.      sampleEndX_ + 1, lcenter_ + halfHeight);
  1046.   pixmap_->draw_line(*drawGc_, sampleStartX_ - 1, rcenter_ - halfHeight,
  1047.      sampleEndX_ + 1, rcenter_ - halfHeight);
  1048.   pixmap_->draw_line(*drawGc_, sampleStartX_ - 1, rcenter_ + halfHeight,
  1049.      sampleEndX_ + 1, rcenter_ + halfHeight);
  1050.   pixmap_->draw_line(*drawGc_, sampleStartX_ - 1, rcenter_ + halfHeight,
  1051.      sampleStartX_ - 1, rcenter_ - halfHeight);
  1052.   pixmap_->draw_line(*drawGc_, sampleEndX_ + 1, rcenter_ + halfHeight,
  1053.      sampleEndX_ + 1, rcenter_ - halfHeight);
  1055.   drawTimeLine();
  1057.   trackManager_->update(toc, minSample_, maxSample_, sampleWidthX_);
  1058.   if (selectedTrack_ > 0) {
  1059.     trackManager_->select(selectedTrack_, selectedIndex_);
  1060.   }
  1061.   drawTrackLine();
  1062. }
  1064. void SampleDisplay::drawCursor(gint x)
  1065. {
  1066.   if (pixmap_ == NULL)
  1067.     return;
  1069.   if (x < sampleStartX_ || x > sampleEndX_)
  1070.     return;
  1072.   if (cursorDrawn_ && cursorX_ != x) {
  1073.     redraw(cursorX_, 0, 1, height_, 0x01);
  1074.   }
  1075.   
  1076.   if (!cursorDrawn_ || cursorX_ != x) {
  1077.     drawGc_->set_foreground(cursorColor_);
  1078.     get_window().draw_line(*drawGc_, x, trackLineY_, x, height_ - 1);
  1079.   }
  1080.   
  1081.   cursorDrawn_ = 1;
  1082.   cursorX_ = x;
  1084.   if (cursorControlExtern_ == 0)
  1085.     cursorMoved(pixel2sample(x));
  1086. }
  1088. void SampleDisplay::undrawCursor()
  1089. {
  1090.   if (cursorDrawn_) {
  1091.     redraw(cursorX_, 0, 1, height_, 0x01);
  1092.     cursorDrawn_ = 0;
  1093.   }
  1094. }
  1096. void SampleDisplay::drawTimeTick(gint x, gint y, unsigned long sample)
  1097. {
  1098.   char buf[50];
  1100.   if (pixmap_ == NULL)
  1101.     return;
  1103.   unsigned long min = sample / (60 * 44100);
  1104.   sample %= 60 * 44100;
  1106.   unsigned long sec = sample / 44100;
  1107.   sample %= 44100;
  1109.   unsigned long frame = sample / 588;
  1110.   sample %= 588;
  1112.   sprintf(buf, "%lu:%02lu:%02lu.%03lu", min, sec, frame, sample);
  1114.   drawGc_->set_foreground(get_colormap().black());
  1116.   pixmap_->draw_line(*drawGc_, x, y - timeLineHeight_, x, y);
  1117.   pixmap_->draw_string(*timeTickFont_, *drawGc_, x + 3, y - 3, buf);
  1118. }
  1120. gint SampleDisplay::timeTickWidth()
  1121. {
  1122.   return timeTickFont_->string_width("000:00:00.000") + 3;
  1123. }
  1125. void SampleDisplay::drawTimeLine()
  1126. {
  1127.   Toc *toc = tocEdit_->toc();
  1129.   if (toc->length().lba() == 0)
  1130.     return;
  1132.   gint sep = timeTickWidth_ + timeTickSep_;
  1133.   int maxNofTicks = (sampleWidthX_ + timeTickSep_) / sep;
  1134.   gint x;
  1136.   unsigned long len = maxSample_ - minSample_ + 1;
  1137.   unsigned long dt;
  1138.   unsigned long dtx;
  1139.   unsigned long startSample;
  1140.   unsigned long s;
  1142.   if ((s = len / (60 * 44100)) > 1) {
  1143.     dt = 60 * 44100;
  1144.   }
  1145.   else if ((s = len / 44100) > 1) {
  1146.     dt = 44100;
  1147.   }
  1148.   else if ((s = len / 588) > 1) {
  1149.     dt = 588;
  1150.   }
  1151.   else {
  1152.     dt = 1;
  1153.     s = len;
  1154.   }
  1156.   if (s > maxNofTicks) {
  1157.     dtx = s / maxNofTicks;
  1158.     if (s % maxNofTicks != 0)
  1159.       dtx++;
  1160.     dtx *= dt;
  1161.   }
  1162.   else {
  1163.     dtx = dt;
  1164.   }
  1166.   if (dt > 1) {
  1167.     if (minSample_ % dt == 0) {
  1168.       startSample = minSample_;
  1169.     }
  1170.     else {
  1171.       startSample = minSample_ / dt;
  1172.       startSample = startSample * dt + dt;
  1173.     }
  1174.   }
  1175.   else {
  1176.     startSample = minSample_;
  1177.   }
  1179.   for (s = startSample; s < maxSample_; s += dtx) {
  1180.     x = sample2pixel(s);
  1182.     if (x + timeTickWidth_ <= sampleEndX_) 
  1183.       drawTimeTick(x, timeLineY_, s);
  1184.   }
  1185. }
  1187. gint SampleDisplay::trackMarkerWidth()
  1188. {
  1189.   return trackMarkerFont_->string_width("00.00") + TRACK_MARKER_XPM_WIDTH + 2;
  1190. }
  1193. // Draws track marker.
  1194. // mode: 0: draw on 'pixmap_'
  1195. //       1: draw on window
  1196. //       2: redraw region at given position
  1197. void SampleDisplay::drawTrackMarker(int mode, gint x, int trackNr,
  1198.     int indexNr, int selected, int extend)
  1199. {
  1200.   if (mode < 2) {
  1201.     char buf[20];
  1203.     sprintf(buf, "%d.%d", trackNr, indexNr);
  1205.     Gdk_Pixmap *marker;
  1207.     if (extend) {
  1208.       marker = indexNr == 1 ? trackExtendPixmap_ : indexExtendPixmap_;
  1209.     }
  1210.     else {
  1211.       if (selected)
  1212. marker = indexNr == 1 ? trackMarkerSelectedPixmap_ :
  1213.                         indexMarkerSelectedPixmap_;
  1214.       else
  1215. marker = indexNr == 1 ? trackMarkerPixmap_ : indexMarkerPixmap_;
  1216.     }
  1220.     Gdk_Drawable dr(get_window());
  1222.     if (mode == 0)
  1223.       dr = *pixmap_;
  1225.     if (mode == 0) {
  1226.       if (selected)
  1227. drawGc_->set_foreground(markerColor_);
  1228.       else
  1229. drawGc_->set_foreground(get_colormap().white());
  1231.       dr.draw_rectangle(*drawGc_, TRUE,  x-4, trackLineY_ - trackLineHeight_,
  1232. trackMarkerWidth_, trackLineHeight_);
  1233.     }
  1235.     drawGc_->set_foreground(get_colormap().black());
  1237.     dr.draw_pixmap(*drawGc_, *marker, 0, 0,
  1238.    x - 4, trackLineY_ - TRACK_MARKER_XPM_HEIGHT,
  1239.    TRACK_MARKER_XPM_WIDTH, TRACK_MARKER_XPM_HEIGHT);
  1241.     dr.draw_string(*trackMarkerFont_, *drawGc_, 
  1242.     x + TRACK_MARKER_XPM_WIDTH / 2 + 2, trackLineY_ - 1, buf);
  1243.   }
  1244.   else {
  1245.     redraw(x - 4, trackLineY_ - trackLineHeight_, trackMarkerWidth_,
  1246.    trackLineHeight_, 0x03);
  1247.   }
  1248. }
  1250. void SampleDisplay::drawTrackLine()
  1251. {
  1252.   const TrackManager::Entry *run;
  1253.   const TrackManager::Entry *selected = NULL;
  1255.   for (run = trackManager_->first(); run != NULL;
  1256.        run = trackManager_->next()) {
  1257.     if (run->selected != 0 && run->extend == 0) {
  1258.       selected = run;
  1259.     }
  1260.     else if (run->indexNr != 1 || run->extend != 0) {
  1261.       drawTrackMarker(0, sampleStartX_ + run->xpos, run->trackNr, run->indexNr,
  1262.       0, run->extend);
  1263.     }
  1264.   }
  1266.   for (run = trackManager_->first(); run != NULL;
  1267.        run = trackManager_->next()) {
  1268.     if (run->indexNr == 1 && run->selected == 0 && run->extend == 0) {
  1269.       drawTrackMarker(0, sampleStartX_ + run->xpos, run->trackNr, run->indexNr,
  1270.       0, run->extend);
  1271.     }
  1272.   }
  1274.   if (selected != NULL)
  1275.     drawTrackMarker(0, sampleStartX_ + selected->xpos, selected->trackNr,
  1276.     selected->indexNr, 1, 0);
  1277. }
  1279. void SampleDisplay::updateTrackMarks()
  1280. {
  1281.   Toc *toc = tocEdit_->toc();
  1283.   drawGc_->set_foreground(get_colormap().white());
  1284.   pixmap_->draw_rectangle(*drawGc_, TRUE,
  1285.   sampleStartX_ - 4, trackLineY_ - trackLineHeight_,
  1286.   width_ - sampleStartX_, trackLineHeight_);
  1288.   trackManager_->update(toc, minSample_, maxSample_, sampleWidthX_);
  1289.   if (selectedTrack_ > 0) {
  1290.     trackManager_->select(selectedTrack_, selectedIndex_);
  1291.   }
  1292.   drawTrackLine();
  1293.   
  1294.   redraw(0, 0, width_, height_, 0x03);
  1295. }